Структура Utf8Chunks
#![allow(unused)] fn main() { pub struct Utf8Chunks<'a> { /* приватные поля */ } }
Итератор для декодирования среза байтов, преимущественно в кодировке UTF-8, в срезы строк (&str) и срезы байтов (&[u8]).
Этот структ создается методом utf8_chunks для срезов байтов. Если вам нужна простая конвертация из срезов UTF-8 байтов в срезы строк, проще использовать from_utf8.
См. документацию типа Utf8Chunk для информации о элементах, возвращаемых этим итератором.
Примеры
Можно использовать для создания функциональности, аналогичной String::from_utf8_lossy, без выделения памяти в куче:
#![allow(unused)] fn main() { fn from_utf8_lossy<F>(input: &[u8], mut push: F) where F: FnMut(&str) { for chunk in input.utf8_chunks() { push(chunk.valid()); if !chunk.invalid().is_empty() { push("\u{FFFD}"); } } } }
Реализации трейтов
impl<'a> Clone for Utf8Chunks<'a>
| Функция | Синтаксис | Пример | Назначение |
|---|---|---|---|
| clone | fn clone(&self) -> Utf8Chunks<'a> ⓘ | let cloned = utf8_chunks.clone(); | Возвращает копию значения |
| clone_from | fn clone_from(&mut self, source: &Self) | utf8_chunks.clone_from(&other); | Выполняет копирующее присваивание из source |
impl Debug for Utf8Chunks<'_>
| Функция | Синтаксис | Пример | Назначение |
|---|---|---|---|
| fmt | fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> | println!("{:?}", utf8_chunks); | Форматирует значение с помощью заданного форматтера |
impl<'a> Iterator for Utf8Chunks<'a>
| Функция | Синтаксис | Пример | Назначение |
|---|---|---|---|
| Item (тип) | type Item = Utf8Chunk<'a> | Тип элементов, по которым производится итерация | |
| next | fn next(&mut self) -> Option<Utf8Chunk<'a>> | let chunk = utf8_chunks.next(); | Продвигает итератор и возвращает следующее значение |
| next_chunk | fn next_chunk<const N: usize>(&mut self) -> Result<([Self::Item; N], IntoIter<Self::Item, N>)> | let chunks = utf8_chunks.next_chunk::<3>()?; | 🔬 Ночная экспериментальная функция (iter_next_chunk #98326). Продвигает итератор и возвращает массив из следующих N значений |
| size_hint | fn size_hint(&self) -> (usize, Option<usize>) | let (min, max) = utf8_chunks.size_hint(); | Возвращает границы оставшейся длины итератора |
| count | fn count(self) -> usize | let total = utf8_chunks.count(); | Потребляет итератор, подсчитывая количество итераций и возвращая его |
| last | fn last(self) -> Option<Self::Item> | let last_chunk = utf8_chunks.last(); | Потребляет итератор, возвращая последний элемент |
| advance_by | fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> | utf8_chunks.advance_by(3)?; | 🔬 Ночная экспериментальная функция (iter_advance_by #77404). Продвигает итератор на n элементов |
| nth | fn nth(&mut self, n: usize) -> Option<Self::Item> | let third_chunk = utf8_chunks.nth(2); | Возвращает n-й элемент итератора |
| step_by (с версии 1.28.0) | fn step_by(self, step: usize) -> StepBy<Self> ⓘ | let stepped = utf8_chunks.step_by(2); | Создает итератор, начинающийся с той же точки, но пропускающий заданное количество элементов на каждой итерации |
| chain | fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> ⓘ | let chained = utf8_chunks.chain(other_iter); | Берет два итератора и создает новый итератор, проходящий по обоим последовательно |
| zip | fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> ⓘ | let zipped = utf8_chunks.zip(other_iter); | "Сшивает" два итератора в один итератор пар |
| intersperse | fn intersperse(self, separator: Self::Item) -> Intersperse<Self> ⓘ | let interspersed = utf8_chunks.intersperse(separator); | 🔬 Ночная экспериментальная функция (iter_intersperse #79524). Создает новый итератор, который помещает копию разделителя между соседними элементами исходного итератора |
| intersperse_with | fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ | `let with_sep = utf8_chunks.intersperse_with( | |
| map | fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ | `let valid_parts = utf8_chunks.map( | c |
| for_each (с версии 1.21.0) | fn for_each<F>(self, f: F) | `utf8_chunks.for_each( | chunk |
| filter | fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ | `let valid_chunks = utf8_chunks.filter( | c |
| filter_map | fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘ | `let valid_strings = utf8_chunks.filter_map( | c |
| enumerate | fn enumerate(self) -> Enumerate<Self> ⓘ | for (i, chunk) in utf8_chunks.enumerate() | Создает итератор, который дает текущий счетчик итераций, а также следующее значение |
| peekable | fn peekable(self) -> Peekable<Self> ⓘ | let peekable = utf8_chunks.peekable(); | Создает итератор, который может использовать методы peek и peek_mut для просмотра следующего элемента итератора без его потребления |
| skip_while | fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘ | `let after_invalid = utf8_chunks.skip_while( | c |
| take_while | fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘ | `let valid_only = utf8_chunks.take_while( | c |
| map_while (с версии 1.57.0) | fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘ | `let valid_strings = utf8_chunks.map_while( | c |
| skip | fn skip(self, n: usize) -> Skip<Self> ⓘ | let skipped = utf8_chunks.skip(2); | Создает итератор, который пропускает первые n элементов |
| take | fn take(self, n: usize) -> Take<Self> ⓘ | let taken = utf8_chunks.take(3); | Создает итератор, который выдает первые n элементов или меньше, если базовый итератор закончится раньше |
| scan | fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> ⓘ | `let scanned = utf8_chunks.scan(0, | acc, chunk |
| flat_map | fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘ | `let all_bytes = utf8_chunks.flat_map( | c |
| flatten (с версии 1.29.0) | fn flatten(self) -> Flatten<Self> ⓘ | let flattened = utf8_chunks.flatten(); | Создает итератор, который разглаживает вложенную структуру |
| map_windows | fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘ | `let windows = utf8_chunks.map_windows( | arr: &[Utf8Chunk; 3] |
| fuse | fn fuse(self) -> Fuse<Self> ⓘ | let fused = utf8_chunks.fuse(); | Создает итератор, который завершается после первого None |
| inspect | fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ | `let inspected = utf8_chunks.inspect( | chunk |
| by_ref | fn by_ref(&mut self) -> &mut Self | utf8_chunks.by_ref().take(5).for_each(...); | Создает "по ссылке" адаптер для этого экземпляра Iterator |
| collect | fn collect<B>(self) -> B | let vec: Vec<Utf8Chunk> = utf8_chunks.collect(); | Преобразует итератор в коллекцию |
| try_collect | fn try_collect<B>(&mut self) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType | let result: Result<Vec<_>, _> = utf8_chunks.try_collect(); | 🔬 Ночная экспериментальная функция (iterator_try_collect #94047). Пытается преобразовать итератор в коллекцию, замыкаясь при первой ошибке |
| collect_into | fn collect_into<E>(self, collection: &mut E) -> &mut E | utf8_chunks.collect_into(&mut vec); | 🔬 Ночная экспериментальная функция (iter_collect_into #94780). Собирает все элементы из итератора в коллекцию |
| partition | fn partition<B, F>(self, f: F) -> (B, B) | `let (valid, invalid) = utf8_chunks.partition( | c |
| partition_in_place | fn partition_in_place<'a, T, P>(self, predicate: P) -> usize | `let true_count = utf8_chunks.partition_in_place( | c |
| is_partitioned | fn is_partitioned<P>(self, predicate: P) -> bool | `let partitioned = utf8_chunks.is_partitioned( | c |
| try_fold (с версии 1.27.0) | fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R | `let total_len = utf8_chunks.try_fold(0, | acc, chunk |
| try_for_each (с версии 1.27.0) | fn try_for_each<F, R>(&mut self, f: F) -> R | `utf8_chunks.try_for_each( | chunk |
| fold | fn fold<B, F>(self, init: B, f: F) -> B | `let total_valid_len = utf8_chunks.fold(0, | acc, chunk |
| reduce (с версии 1.51.0) | fn reduce<F>(self, f: F) -> Option<Self::Item> | `let largest_chunk = utf8_chunks.reduce( | a, b |
| try_reduce | fn try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType | `let largest = utf8_chunks.try_reduce( | a, b |
| all | fn all<F>(&mut self, f: F) -> bool | `let all_valid = utf8_chunks.all( | c |
| any | fn any<F>(&mut self, f: F) -> bool | `let has_invalid = utf8_chunks.any( | c |
| find | fn find<P>(&mut self, predicate: P) -> Option<Self::Item> | `let first_invalid = utf8_chunks.find( | c |
| find_map (с версии 1.30.0) | fn find_map<B, F>(&mut self, f: F) -> Option<B> | `let first_invalid_bytes = utf8_chunks.find_map( | c |
| try_find | fn try_find<R>(&mut self, f: impl FnMut(&Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType | `let result = utf8_chunks.try_find( | c |
| position | fn position<P>(&mut self, predicate: P) -> Option<usize> | `let pos = utf8_chunks.position( | c |
| rposition | fn rposition<P>(&mut self, predicate: P) -> Option<usize> | `let rpos = utf8_chunks.rposition( | c |
| max | fn max(self) -> Option<Self::Item> | let max_chunk = utf8_chunks.max(); | Возвращает максимальный элемент итератора |
| min | fn min(self) -> Option<Self::Item> | let min_chunk = utf8_chunks.min(); | Возвращает минимальный элемент итератора |
| max_by_key (с версии 1.6.0) | fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> | `let longest_valid = utf8_chunks.max_by_key( | c |
| max_by (с версии 1.15.0) | fn max_by<F>(self, compare: F) -> Option<Self::Item> | `let longest = utf8_chunks.max_by( | a, b |
| min_by_key (с версии 1.6.0) | fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> | `let shortest_valid = utf8_chunks.min_by_key( | c |
| min_by (с версии 1.15.0) | fn min_by<F>(self, compare: F) -> Option<Self::Item> | `let shortest = utf8_chunks.min_by( | a, b |
| rev | fn rev(self) -> Rev<Self> ⓘ | let reversed = utf8_chunks.rev(); | Меняет направление итератора на противоположное |
| unzip | fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) | `let (valids, invalids): (Vec<&str>, Vec<&[u8]>) = utf8_chunks.map( | c |
| copied (с версии 1.36.0) | fn copied<'a, T>(self) -> Copied<Self> ⓘ | let copied: Copied<_> = utf8_chunks.copied(); | Создает итератор, который копирует все свои элементы |
| cloned | fn cloned<'a, T>(self) -> Cloned<Self> ⓘ | let cloned: Cloned<_> = utf8_chunks.cloned(); | Создает итератор, который клонирует все свои элементы |
| cycle | fn cycle(self) -> Cycle<Self> ⓘ | let cycled = utf8_chunks.cycle(); | Повторяет итератор бесконечно |
| array_chunks | fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> ⓘ | let chunks = utf8_chunks.array_chunks::<3>(); | 🔬 Ночная экспериментальная функция (iter_array_chunks #100450). Возвращает итератор по N элементам итератора за раз |
| sum (с версии 1.11.0) | fn sum<S>(self) -> S | `let total_len: usize = utf8_chunks.map( | c |
| product (с версии 1.11.0) | fn product<P>(self) -> P | `let product: usize = utf8_chunks.map( | c |
| cmp (с версии 1.5.0) | fn cmp<I>(self, other: I) -> Ordering | utf8_chunks.cmp(other_iter) | Лексикографически сравнивает элементы этого Iterator с элементами другого |
| cmp_by | fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering | `utf8_chunks.cmp_by(other_iter, | a, b |
| partial_cmp (с версии 1.5.0) | fn partial_cmp<I>(self, other: I) -> Option<Ordering> | utf8_chunks.partial_cmp(other_iter) | Лексикографически сравнивает элементы PartialOrd этого Iterator с элементами другого. Сравнение работает как короткое замыкание, возвращая результат без сравнения оставшихся элементов |
| partial_cmp_by | fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> | `utf8_chunks.partial_cmp_by(other_iter, | a, b |
| eq (с версии 1.5.0) | fn eq<I>(self, other: I) -> bool | utf8_chunks.eq(other_iter) | Определяет, равны ли элементы этого Iterator элементам другого |
| eq_by | fn eq_by<I, F>(self, other: I, eq: F) -> bool | `utf8_chunks.eq_by(other_iter, | a, b |
| ne (с версии 1.5.0) | fn ne<I>(self, other: I) -> bool | utf8_chunks.ne(other_iter) | Определяет, не равны ли элементы этого Iterator элементам другого |
| lt (с версии 1.5.0) | fn lt<I>(self, other: I) -> bool | utf8_chunks.lt(other_iter) | Определяет, являются ли элементы этого Iterator лексикографически меньше элементов другого |
| le (с версии 1.5.0) | fn le<I>(self, other: I) -> bool | utf8_chunks.le(other_iter) | Определяет, являются ли элементы этого Iterator лексикографически меньше или равны элементам другого |
| gt (с версии 1.5.0) | fn gt<I>(self, other: I) -> bool | utf8_chunks.gt(other_iter) | Определяет, являются ли элементы этого Iterator лексикографически больше элементов другого |
| ge (с версии 1.5.0) | fn ge<I>(self, other: I) -> bool | utf8_chunks.ge(other_iter) | Определяет, являются ли элементы этого Iterator лексикографически больше или равны элементам другого |
| is_sorted (с версии 1.82.0) | fn is_sorted(self) -> bool | let sorted = utf8_chunks.is_sorted(); | Проверяет, отсортированы ли элементы этого итератора |
| is_sorted_by (с версии 1.82.0) | fn is_sorted_by<F>(self, compare: F) -> bool | `let sorted = utf8_chunks.is_sorted_by( | a, b |
| is_sorted_by_key (с версии 1.82.0) | fn is_sorted_by_key<F, K>(self, f: F) -> bool | `let sorted = utf8_chunks.is_sorted_by_key( | c |
impl FusedIterator for Utf8Chunks<'_>
Этот трейт не имеет методов, но гарантирует, что после исчерпания итератор всегда будет возвращать None