Primitive Type array1.0.0[]

Expand description

一个固定大小的数组,表示为 [T; N],用于元素类型 T 和非负编译时常量大小 N

创建数组有两种语法形式:

  • 包含每个元素的列表,即 [x, y, z]
  • 重复表达式 [x; N],该数组生成包含 xN 副本的数组。 x 的类型必须为 Copy

请注意,[expr; 0] 是允许的,并产生一个空数组。 然而,这仍然会计算 expr,并立即丢弃结果值,因此请注意副作用。

如果元素类型允许,则任何大小的数组都将实现以下 traits:

如果元素类型允许,则大小为 0 到 32 (inclusive) 的数组将实现 Default trait。 作为权宜之计,trait 实现是静态生成的,最大大小为 32。

数组强制转换为 slices ([T]) ,因此可以在数组上调用 slice 方法。实际上,这提供了用于处理数组的大多数 API。 切片具有动态大小,并且不强制转换为数组。

您可以使用 切片模式 将元素移出数组。如果需要一个元素,请参见 mem::replace

Examples

let mut array: [i32; 3] = [0; 3];

array[1] = 1;
array[2] = 2;

assert_eq!([1, 2], &array[1..]);

// 该循环打印: 0 1 2
for x in array {
    print!("{} ", x);
}
Run

您还可以迭代数组元素的引用:

let array: [i32; 3] = [0; 3];

for x in &array { }
Run

您可以使用 切片模式 将元素移出数组:

fn move_away(_: String) { /* Do interesting things. */ }

let [john, roa] = ["John".to_string(), "Roa".to_string()];
move_away(john);
move_away(roa);
Run

Editions

在 Rust 1.53 之前,数组没有按值实现 IntoIterator,因此调用 array.into_iter() 方法自动引用到 slice 迭代器。 目前,为了兼容性,Rust 的 2015 和 2018 版本中保留了旧行为,忽略了 IntoIterator 的值。 将来,2015 年和 2018 年版本的行为可能会与以后版本的行为一致。

// Rust 2015 和 2018:

let array: [i32; 3] = [0; 3];

// 这将创建一个切片迭代器,产生对每个值的引用。
for item in array.into_iter().enumerate() {
    let (i, x): (usize, &i32) = item;
    println!("array[{}] = {}", i, x);
}

// `array_into_iter` lint 建议进行此更改以实现未来兼容性:
for item in array.iter().enumerate() {
    let (i, x): (usize, &i32) = item;
    println!("array[{}] = {}", i, x);
}

// 您可以使用 `IntoIterator::into_iter` 或 `std::array::IntoIter::new` 按值显式迭代数组:
for item in IntoIterator::into_iter(array).enumerate() {
    let (i, x): (usize, i32) = item;
    println!("array[{}] = {}", i, x);
}
Run

从 2021 版开始,array.into_iter() 通常使用 IntoIterator 进行值迭代,而应该像以前的版本一样使用 iter() 进行引用迭代。

// Rust 2021:

let array: [i32; 3] = [0; 3];

// 这通过引用进行迭代:
for item in array.iter().enumerate() {
    let (i, x): (usize, &i32) = item;
    println!("array[{}] = {}", i, x);
}

// 这是按值迭代的:
for item in array.into_iter().enumerate() {
    let (i, x): (usize, i32) = item;
    println!("array[{}] = {}", i, x);
}
Run

未来的语言版本可能会开始将 2015 和 2018 版的 array.into_iter() 语法与 2021 版相同。 因此,在编写使用这些旧版本的代码时仍应牢记这一更改,以防止将来出现破坏。 实现这一点最安全的方法是避免这些版本中的 into_iter 语法。 如果版本更新不是不可行/不受欢迎的,则有多种选择:

  • 使用 iter,相当于旧行为,创建引用
  • 使用 IntoIterator::into_iter,相当于 2021 年后的行为 (Rust 1.53+)
  • 替换 for .... in array.into_iter() {for ... in array {,相当于 2021 年后的行为 (Rust 1.53+)
// Rust 2015 和 2018:

let array: [i32; 3] = [0; 3];

// 这通过引用进行迭代:
for item in array.iter() {
    let x: &i32 = item;
    println!("{}", x);
}

// 这是按值迭代的:
for item in IntoIterator::into_iter(array) {
    let x: i32 = item;
    println!("{}", x);
}

// 这是按值迭代的:
for item in array {
    let x: i32 = item;
    println!("{}", x);
}

// IntoIter 也可以启动一个链。
// 这是按值迭代的:
for item in IntoIterator::into_iter(array).enumerate() {
    let (i, x): (usize, i32) = item;
    println!("array[{}] = {}", i, x);
}
Run

Implementations

返回大小与 self 相同的数组,并将函数 f 按顺序应用于每个元素。

如果您不一定需要新的固定大小的数组,请考虑改用 Iterator::map

关于性能和栈使用的注意事项

不幸的是,这种方法的使用目前并不总是像它们可能的那样优化。 这主要涉及大数组,因为小数组上的映射似乎优化得很好。 另请注意,在调试模式下 (即 没有任何优化),这种方法可以使用大量的栈空间 (数组大小的几倍或更多)。

因此,在性能关键的代码中,尽量避免在大型数组上使用此方法或检查发出的代码。 还要尽量避免链接 maps (例如 arr.map(...).map(...)).

在许多情况下,您可以通过在阵列上调用 .iter().into_iter() 来代替使用 Iterator::map。 只有当您真的需要一个与结果大小相同的新数组时,才需要 [T; N]::map Rust 的惰性迭代器往往会得到很好的优化。

Examples
let x = [1, 2, 3];
let y = x.map(|v| v + 1);
assert_eq!(y, [2, 3, 4]);

let x = [1, 2, 3];
let mut temp = 0;
let y = x.map(|v| { temp += 1; v * temp });
assert_eq!(y, [1, 4, 9]);

let x = ["Ferris", "Bueller's", "Day", "Off"];
let y = x.map(|v| v.len());
assert_eq!(y, [6, 9, 3, 3]);
Run
🔬 This is a nightly-only experimental API. (array_zip #80094)

将两个阵列压缩为成对的单个阵列。

zip() 返回一个新数组,其中每个元素都是一个元组,其中第一个元素来自第一个数组,第二个元素来自第二个数组。

换句话说,它将两个数组压缩在一起,成为一个数组。

Examples
#![feature(array_zip)]
let x = [1, 2, 3];
let y = [4, 5, 6];
let z = x.zip(y);
assert_eq!(z, [(1, 4), (2, 5), (3, 6)]);
Run

返回包含整个数组的切片。等效于 &s[..]

返回包含整个数组的可变切片。 等效于 &mut s[..]

🔬 This is a nightly-only experimental API. (array_methods #76118)

借用每个元素,并返回一个引用数组,其大小与 self 相同。

Example
#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
Run

如果与其他方法 (例如 map) 结合使用,则此方法特别有用。 这样,如果原始数组的元素不是 Copy,则可以避免移动原始数组。

#![feature(array_methods)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// 我们仍然可以访问原始数组:它尚未移动。
assert_eq!(strings.len(), 3);
Run
🔬 This is a nightly-only experimental API. (array_methods #76118)

借用每个元素,并返回与 self 相同大小的可变引用数组。

Example
#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);
Run
🔬 This is a nightly-only experimental API. (split_array #90091)

return type should have array as 2nd element

在一个索引处将一个数组的引用一分为二。

第一个将包含来自 [0, M) 的所有索引 (不包括索引 M 本身),第二个将包含来自 [M, N) 的所有索引 (不包括索引 N 本身)。

Panics

如果 M > N,就会出现 panics。

Examples
#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}
Run
🔬 This is a nightly-only experimental API. (split_array #90091)

return type should have array as 2nd element

在一个索引处将一个可变数组的引用一分为二。

第一个将包含来自 [0, M) 的所有索引 (不包括索引 M 本身),第二个将包含来自 [M, N) 的所有索引 (不包括索引 N 本身)。

Panics

如果 M > N,就会出现 panics。

Examples
#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);
Run

Trait Implementations

执行转换。

执行转换。

从拥有的值中一成不变地借用。 Read more

从拥有的值中借用。 Read more

使用给定的格式化程序格式化该值。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

返回类型的 “默认值”。 Read more

数组的哈希值与对应的 X 像素的哈希值相同,符合实现的要求。

#![feature(build_hasher_simple_hash_one)]
use std::hash::BuildHasher;

let b = std::collections::hash_map::RandomState::new();
let a: [u8; 3] = [0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(a), b.hash_one(s));
Run

将该值输入给定的 HasherRead more

将这种类型的切片送入给定的 Hasher 中。 Read more

索引后返回的类型。

执行索引 (container[index]) 操作。 Read more

执行可变索引 (container[index]) 操作。 Read more

创建一个消费迭代器,即将每个值移出数组 (从开始到结束)。 除非 T 实现了 Copy,否则调用此数组后不能使用数组,因此整个数组都会被复制。

在调用 .into_iter() 之前,数组具有特殊行为 2021 版 – 有关更多信息,请参见 array 版本部分。

被迭代的元素的类型。

我们将其变成哪种迭代器?

被迭代的元素的类型。

我们将其变成哪种迭代器?

从一个值创建一个迭代器。 Read more

被迭代的元素的类型。

我们将其变成哪种迭代器?

从一个值创建一个迭代器。 Read more

实现数组 按字典顺序 的比较。

此方法返回 selfother 之间的 OrderingRead more

比较并返回两个值中的最大值。 Read more

比较并返回两个值中的最小值。 Read more

将值限制在某个时间间隔内。 Read more

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

如果存在,则此方法返回 selfother 值之间的顺序。 Read more

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more

搜索等于数组中任何 char 的字符。

Examples

assert_eq!("Hello world".find(['l', 'l']), Some(2));
assert_eq!("Hello world".find(['l', 'l']), Some(2));
Run
🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

此模式的关联搜索者

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

selfhaystack 构造关联的搜索器以进行搜索。 Read more

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

检查模式是否与 haystack 中的任何位置匹配

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

检查模式是否在 haystack 的前面匹配

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

如果匹配,则从 haystack 的正面删除模式。

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

检查模式是否与 haystack 的后面匹配

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

如果匹配,则从 haystack 的后面删除模式。

搜索等于数组中任何 char 的字符。

Examples

assert_eq!("Hello world".find(&['l', 'l']), Some(2));
assert_eq!("Hello world".find(&['l', 'l']), Some(2));
Run
🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

此模式的关联搜索者

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

selfhaystack 构造关联的搜索器以进行搜索。 Read more

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

检查模式是否与 haystack 中的任何位置匹配

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

检查模式是否在 haystack 的前面匹配

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

如果匹配,则从 haystack 的正面删除模式。

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

检查模式是否与 haystack 的后面匹配

🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

如果匹配,则从 haystack 的后面删除模式。

🔬 This is a nightly-only experimental API. (slice_pattern #56345)

stopgap trait for slice patterns

匹配的切片的元素类型。

🔬 This is a nightly-only experimental API. (slice_pattern #56345)

stopgap trait for slice patterns

当前,SlicePattern 的消费者需要切片。

发生转换错误时返回的类型。

执行转换。

发生转换错误时返回的类型。

执行转换。

发生转换错误时返回的类型。

执行转换。