锈 - 切片

切片是一种没有所有权的数据类型。 Slice 引用一个连续的内存分配而不是整个集合。切片也存在于Python，类似于 Rust 中的切片。当您不想要完整的集合或想要其中的一部分时，可以使用切片。

切片要点：

• 在切片中，第一个元素位于 0 索引，最后一个元素是索引 1。

//gfg is String or Array
&gfg[0..2]  //from 0 to 1 index
&gfg[0..3]  //from 0 to 2 index

• 如果要从 0 开始，则不需要传递 0。

//gfg is String or Array
&gfg[..2] //from 0 to 1 index
&gfg[..3] //from 0 to 3 index

• 如果要到 String 或 Array 的末尾，请先计算长度然后传递它。

//gfg is String or Array
//calculate length using len() method
length_of_string=gfg.len();
//from 0 to last index
&gfg[..lenght_of_string] 
//from 4th element or index=3 to last index
&gfg[3..length_of_string]

示例 1 的方法：

• 对于第一个字符，我们将从&gfg[0..1] (0,1) 开始。
• 对于前三个字符，我们将使用&gfg[..3]或&gfg[0..3]。
• 从 0 开始到 x &gfg[..x]或&gfg[0..x] 。
• 对于从 0 到字符串 的长度，为此我们需要首先使用 len() 方法计算长度，而不是使用&gfg[..x]或&gfg[0..length_of_string] 。
• 对于从 x 开始到长度大于&gfg[x..length_of_string]。

示例 1：在 Rust 中对字符串进行切片

Rust

// Rust program for slicing of String
fn main() {
    
      // String
    let gfg = "GFG is a great start to start coding and improve".to_string();
    
    // for first character
    println!("first character ={}",&gfg[0..1] );
    
      // for first three characters
    println!("first three character ={}",&gfg[..3] );
  
      // calculating length of String
    let length_of_string=gfg.len();
    
      let x=5;
    
    // start from first to last character
    println!("start from 0 to x ={}",&gfg[..x] );
    
      // start from x to last character
    println!("start from x to end ={}",&gfg[x..length_of_string]);
    
      // start from first to last character
    println!("from start to last ={}",&gfg[..length_of_string])
}

输出 ：

first character =G
first three character =GFG
start from 0 to x =GFG i
start from x to end =s a great start to start coding and improve
from start to last =GFG is a great start to start coding and improve

示例 2 的方法：

• 对于数组中的第一个值，我们将从&gfg[0..1] (0,1) 开始。
• 对于数组中的前三个值，我们将使用&gfg[..3]或&gfg[0..3] 。
• 从 0 开始到 x &gfg[..x]或&gfg[0..x] 。
• 为了从 0 开始到数组的长度，为此我们需要首先使用 len() 方法计算长度，而不是使用&gfg[..length_of_array]或&gfg[0..length_of_array] 。
• 从 x 开始到数组的长度&gfg[x..length_of_array] 。

示例 2：对数组进行切片

锈

// Rust program for slicing Array
fn main() {
    
    let gfg = [10, 22, 31, 43, 57];
    let length_of_array=gfg.len();
    let x=2;
    
      // for first value
    println!("for first= {:?}",&gfg[0..1]);
    
      // for first three value
    println!("for first three= {:?}",&gfg[0..3]);
    
      // for first to last(or length)
    println!("for 0 to length of the array= {:?}",&gfg[0..length_of_array] );
   
    println!("{:?}",&gfg[x..length_of_array]);
}

输出 ：

for first= [10]
for first three= [10, 22, 31]
for 0 to length of the array= [10, 22, 31, 43, 57]
[31, 43, 57]