| Create |
[T; N] |
let arr: [i32; 5] = [1, 2, 3, 4, 5]; |
Array |
Create array with explicit type |
[value; N] |
let arr = [0; 5]; |
Array |
Create array with repeated value |
[v1, v2, ...] |
let arr = [1, 2, 3]; |
Array |
Array literal |
| Access |
arr[i] |
arr[0] |
[T; N] |
Index (panics if out of bounds) |
.get(i) |
arr.get(2) |
&[T] |
Safe index → Option<&T> |
.first() |
arr.first() |
&[T] |
First element → Option<&T> |
.last() |
arr.last() |
&[T] |
Last element → Option<&T> |
&arr[range] |
&arr[1..3] |
&[T] |
Slice of array |
| Info |
.len() |
arr.len() |
&[T] |
Array length (known at compile time) |
.is_empty() |
arr.is_empty() |
&[T] |
Check if length is 0 |
| Iterate |
.iter() |
for x in arr.iter() |
&[T] |
Iterate immutably (&T) |
.iter_mut() |
for x in arr.iter_mut() |
&mut [T] |
Iterate mutably (&mut T) |
.into_iter() |
for x in arr.into_iter() |
[T; N] |
Consume array (T) |
for x in &arr |
for x in &arr |
&[T] |
Shorthand for .iter() |
for x in &mut arr |
for x in &mut arr |
&mut [T] |
Shorthand for .iter_mut() |
| Search |
.contains(&x) |
arr.contains(&3) |
&[T] |
Check if element exists |
.binary_search(&x) |
arr.binary_search(&5) |
&[T] |
Binary search (sorted) → Result<usize, usize> |
.binary_search_by(fn) |
`arr.binary_search_by( |
x |
x.cmp(&5))` |
&[T] |
Custom binary search |
.binary_search_by_key(&k, fn) |
`arr.binary_search_by_key(&5, |
x |
x.id)` |
&[T] |
Binary search by key |
| Transform |
.map(fn) |
`arr.map( |
x |
x * 2)` |
[T; N] |
Transform each element → [U; N] |
.as_slice() |
arr.as_slice() |
&[T; N] |
Convert to slice &[T] |
.as_mut_slice() |
arr.as_mut_slice() |
&mut [T; N] |
Convert to mutable slice &mut [T] |
.to_vec() |
arr.to_vec() |
&[T] |
Convert to Vec<T> (clone) |
| Sort |
.sort() |
arr.sort() |
&mut [T] |
Sort in place (ascending) |
.sort_by(fn) |
`arr.sort_by( |
a, b |
b.cmp(a))` |
&mut [T] |
Custom comparison sort |
.sort_by_key(fn) |
`arr.sort_by_key( |
x |
x.age)` |
&mut [T] |
Sort by key |
.sort_unstable() |
arr.sort_unstable() |
&mut [T] |
Faster unstable sort |
.sort_unstable_by(fn) |
`arr.sort_unstable_by( |
a, b |
b.cmp(a))` |
&mut [T] |
Custom unstable sort |
.sort_unstable_by_key(fn) |
`arr.sort_unstable_by_key( |
x |
x.age)` |
&mut [T] |
Unstable sort by key |
.reverse() |
arr.reverse() |
&mut [T] |
Reverse in place |
| Split |
.split_at(i) |
let (left, right) = arr.split_at(2) |
&[T] |
Split into two slices |
.split_at_mut(i) |
let (left, right) = arr.split_at_mut(2) |
&mut [T] |
Split into mutable slices |
.split(fn) |
`arr.split( |
x |
*x == 0)` |
&[T] |
Split by predicate → Iterator |
.split_mut(fn) |
`arr.split_mut( |
x |
*x == 0)` |
&mut [T] |
Mutable split → Iterator |
.chunks(n) |
arr.chunks(2) |
&[T] |
Split into n-sized chunks |
.chunks_mut(n) |
arr.chunks_mut(2) |
&mut [T] |
Mutable chunks |
.chunks_exact(n) |
arr.chunks_exact(2) |
&[T] |
Exact-sized chunks |
.windows(n) |
arr.windows(2) |
&[T] |
Sliding windows |
| Compare |
.starts_with(slice) |
arr.starts_with(&[1, 2]) |
&[T] |
Check if starts with slice |
.ends_with(slice) |
arr.ends_with(&[4, 5]) |
&[T] |
Check if ends with slice |
| Copy |
.clone() |
let arr2 = arr.clone() |
&[T; N] |
Clone array (requires T: Clone) |
.copy_from_slice(src) |
dest.copy_from_slice(&src) |
&mut [T] |
Copy from another slice |
.clone_from_slice(src) |
dest.clone_from_slice(&src) |
&mut [T] |
Clone from slice |
| Fill |
.fill(value) |
arr.fill(0) |
&mut [T] |
Fill with value |
.fill_with(fn) |
`arr.fill_with( |
0)` |
&mut [T] |
Fill using closure |
.swap(i, j) |
arr.swap(0, 2) |
&mut [T] |
Swap two elements |
| Conversion |
Into<Vec<T>> |
let v: Vec<_> = arr.into() |
[T; N] |
Convert to Vec (move) |
.try_into() |
let arr: [i32; 3] = slice.try_into().unwrap() |
&[T] |
Try convert slice to array |
| Each |
.each_ref() |
arr.each_ref() |
&[T; N] |
Convert &[T; N] to [&T; N] |
.each_mut() |
arr.each_mut() |
&mut [T; N] |
Convert &mut [T; N] to [&mut T; N] |
| Zip |
.zip(other) |
arr.zip(other) |
[T; N] |
Zip two arrays → [(T, U); N] |