On this page
Struct std::env::Args
pub struct Args { /* private fields */ }
An iterator over the arguments of a process, yielding a String
value for each argument.
This struct is created by env::args()
. See its documentation for more.
The first element is traditionally the path of the executable, but it can be set to arbitrary text, and might not even exist. This means this property should not be relied upon for security purposes.
Trait Implementations
impl Debug for Args
fn fmt(&self, f: &mut Formatter<'_>) -> Result
impl DoubleEndedIterator for Args
fn next_back(&mut self) -> Option<String>
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
#77404)
n
elements. Read more
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
n
th element from the end of the iterator. Read more
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
Iterator::try_fold()
: it takes elements starting from the back of the iterator. Read more
fn rfold<B, F>(self, init: B, f: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
impl ExactSizeIterator for Args
fn len(&self) -> usize
fn is_empty(&self) -> bool
exact_size_is_empty
#35428)
true
if the iterator is empty. Read more
impl Iterator for Args
type Item = String
fn next(&mut self) -> Option<String>
fn size_hint(&self) -> (usize, Option<usize>)
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where
Self: Sized,
iter_next_chunk
#98326)
N
values. Read more
fn count(self) -> usize
where
Self: Sized,
fn last(self) -> Option<Self::Item>
where
Self: Sized,
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
#77404)
n
elements. Read more
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more
fn step_by(self, step: usize) -> StepBy<Self> ⓘ
where
Self: Sized,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> ⓘ
where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> ⓘ
where
Self: Sized,
U: IntoIterator,
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> ⓘ
where
Self: Sized,
Self::Item: Clone,
iter_intersperse
#79524)
separator
between adjacent items of the original iterator. Read more
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ
where
Self: Sized,
G: FnMut() -> Self::Item,
iter_intersperse
#79524)
separator
between adjacent items of the original iterator. Read more
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F)
where
Self: Sized,
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘ
where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self> ⓘ
where
Self: Sized,
fn peekable(self) -> Peekable<Self> ⓘ
where
Self: Sized,
peek
and peek_mut
methods to look at the next element of the iterator without consuming it. See their documentation for more information. Read more
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘ
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘ
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘ
where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self> ⓘ
where
Self: Sized,
n
elements. Read more
fn take(self, n: usize) -> Take<Self> ⓘ
where
Self: Sized,
n
elements, or fewer if the underlying iterator ends sooner. Read more
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> ⓘ
where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fold
, holds internal state, but unlike fold
, produces a new iterator. Read more
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘ
where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘ
where
Self: Sized,
F: FnMut(&[Self::Item; N]) -> R,
iter_map_windows
#87155)
f
for each contiguous window of size N
over self
and returns an iterator over the outputs of f
. Like slice::windows()
, the windows during mapping overlap as well. Read more
fn fuse(self) -> Fuse<Self> ⓘ
where
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
where
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self
where
Self: Sized,
fn collect<B>(self) -> B
where
B: FromIterator<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut E
where
E: Extend<Self::Item>,
Self: Sized,
iter_collect_into
#94780)
fn partition<B, F>(self, f: F) -> (B, B)
where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
where
T: 'a,
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
iter_partition_in_place
#62543)
true
precede all those that return false
. Returns the number of true
elements found. Read more
fn is_partitioned<P>(self, predicate: P) -> bool
where
Self: Sized,
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
#62544)
true
precede all those that return false
. Read more
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R
where
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn fold<B, F>(self, init: B, f: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn reduce<F>(self, f: F) -> Option<Self::Item>
where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
#87053)
fn all<F>(&mut self, f: F) -> bool
where
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool
where
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B>
where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
#63178)
fn position<P>(&mut self, predicate: P) -> Option<usize>
where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize>
where
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item>
where
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item>
where
Self: Sized,
Self::Item: Ord,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item>
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item>
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self> ⓘ
where
Self: Sized + DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn copied<'a, T>(self) -> Copied<Self> ⓘ
where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self> ⓘ
where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> ⓘ
where
Self: Sized,
iter_array_chunks
#100450)
N
elements of the iterator at a time. Read more
fn sum<S>(self) -> S
where
Self: Sized,
S: Sum<Self::Item>,
fn product<P>(self) -> P
where
Self: Sized,
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering
where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
#64295)
Iterator
with those of another with respect to the specified comparison function. Read more
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
PartialOrd
elements of this Iterator
with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned. Read more
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
#64295)
Iterator
with those of another with respect to the specified comparison function. Read more
fn eq<I>(self, other: I) -> bool
where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn eq_by<I, F>(self, other: I, eq: F) -> bool
where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
#64295)
Iterator
are equal to those of another with respect to the specified equality function. Read more
fn ne<I>(self, other: I) -> bool
where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> bool
where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically less than those of another. Read more
fn le<I>(self, other: I) -> bool
where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically less or equal to those of another. Read more
fn gt<I>(self, other: I) -> bool
where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically greater than those of another. Read more
fn ge<I>(self, other: I) -> bool
where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically greater than or equal to those of another. Read more
fn is_sorted(self) -> bool
where
Self: Sized,
Self::Item: PartialOrd,
is_sorted
#53485)
fn is_sorted_by<F>(self, compare: F) -> bool
where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
#53485)
fn is_sorted_by_key<F, K>(self, f: F) -> bool
where
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
is_sorted
#53485)
impl !Send for Args
impl !Sync for Args
Auto Trait Implementations
impl RefUnwindSafe for Args
impl Unpin for Args
impl UnwindSafe for Args
Blanket Implementations
impl<T> Any for T
where
T: 'static + ?Sized,
impl<T> Borrow<T> for T
where
T: ?Sized,
impl<T> BorrowMut<T> for T
where
T: ?Sized,
impl<T> From<T> for T
fn from(t: T) -> T
Returns the argument unchanged.
impl<T, U> Into<U> for T
where
U: From<T>,
fn into(self) -> U
Calls U::from(self)
.
That is, this conversion is whatever the implementation of From<T> for U
chooses to do.
impl<I> IntoIterator for I
where
I: Iterator,
type Item = <I as Iterator>::Item
type IntoIter = I
fn into_iter(self) -> I
impl<T, U> TryFrom<U> for T
where
U: Into<T>,
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
impl<T, U> TryInto<U> for T
where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/env/struct.Args.html