Rouille - String

Le type de données String dans Rust peut être classé comme suit:

  • Chaîne littérale(&str)

  • Objet String(String)

Chaîne littérale

Les littéraux de chaîne (& str) sont utilisés lorsque la valeur d'une chaîne est connue au moment de la compilation. Les littéraux de chaîne sont un ensemble de caractères codés en dur dans une variable. Par exemple, laissez company = "Tutorials Point" . Les littéraux de chaîne se trouvent dans le module std :: str. Les littéraux de chaîne sont également appelés tranches de chaîne.

L'exemple suivant déclare deux chaînes littérales: société et emplacement .

fn main() {
   let company:&str="TutorialsPoint";
   let location:&str = "Hyderabad";
   println!("company is : {} location :{}",company,location);
}

Les littéraux de chaîne sont statiques par défaut. Cela signifie que les littéraux de chaîne sont garantis valides pendant toute la durée du programme. Nous pouvons également spécifier explicitement la variable comme statique comme indiqué ci-dessous -

fn main() {
   let company:&'static str = "TutorialsPoint";
   let location:&'static str = "Hyderabad";
   println!("company is : {} location :{}",company,location);
}

Le programme ci-dessus générera la sortie suivante -

company is : TutorialsPoint location :Hyderabad

Objet String

Le type d'objet String est fourni dans la bibliothèque standard. Contrairement à la chaîne littérale, le type d'objet chaîne ne fait pas partie du langage de base. Il est défini comme une structure publique dans la bibliothèque standard pub struct String . String est une collection évolutive. Il est de type mutable et encodé en UTF-8. leStringLe type d'objet peut être utilisé pour représenter des valeurs de chaîne fournies lors de l'exécution. L'objet String est alloué dans le tas.

Syntaxe

Pour créer un objet String, nous pouvons utiliser l'une des syntaxes suivantes -

String::new()

La syntaxe ci-dessus crée une chaîne vide

String::from()

Cela crée une chaîne avec une valeur par défaut transmise en paramètre au from() méthode.

L'exemple suivant illustre l'utilisation d'un objet String.

fn main(){
   let empty_string = String::new();
   println!("length is {}",empty_string.len());

   let content_string = String::from("TutorialsPoint");
   println!("length is {}",content_string.len());
}

L'exemple ci-dessus crée deux chaînes: un objet chaîne vide à l'aide de la nouvelle méthode et un objet chaîne à partir d'une chaîne littérale à l'aide de la méthode from .

La sortie est comme indiqué ci-dessous -

length is 0
length is 14

Méthodes courantes - Objet chaîne

Sr.No. Méthode Signature La description
1 Nouveau() pub const fn new () → Chaîne Crée une nouvelle chaîne vide.
2 to_string () fn to_string (& self) → Chaîne Convertit la valeur donnée en String.
3 remplacer() pub fn replace <'a, P> (&' a self, from: P, to: & str) → String Remplace toutes les correspondances d'un modèle par une autre chaîne.
4 as_str () pub fn as_str (& soi) → & str Extrait une tranche de chaîne contenant la chaîne entière.
5 pousser() pub fn push (& mut self, ch: char) Ajoute le caractère donné à la fin de cette chaîne.
6 push_str () pub fn push_str (& mut self, string: & str) Ajoute une tranche de chaîne donnée à la fin de cette chaîne.
sept len () pub fn len (& self) → utiliser Renvoie la longueur de cette chaîne, en octets.
8 réduire() pub fn trim (& self) → & str Renvoie une tranche de chaîne avec les espaces de début et de fin supprimés.
9 split_whitespace () pub fn split_whitespace (& self) → SplitWhitespace Divise une tranche de chaîne par un espace et renvoie un itérateur.
dix Divisé() pub fn split <'a, P> (&' a self, pat: P) → Split <'a, P>, où P est motif peut être & str, char, ou une fermeture qui détermine la séparation. Renvoie un itérateur sur les sous-chaînes de cette tranche de chaîne, séparés par des caractères correspondant à un modèle.
11 caractères () pub fn chars (& self) → Chars Renvoie un itérateur sur les caractères d'une tranche de chaîne.

Illustration: nouveau ()

Un objet chaîne vide est créé à l'aide de new()et sa valeur est définie sur hello .

fn main(){
   let mut z = String::new();
   z.push_str("hello");
   println!("{}",z);
}

Production

Le programme ci-dessus génère la sortie suivante -

hello

Illustration: to_string ()

Pour accéder à toutes les méthodes de l'objet String, convertissez une chaîne littérale en type d'objet à l'aide de la to_string() fonction.

fn main(){
   let name1 = "Hello TutorialsPoint , 
   Hello!".to_string();
   println!("{}",name1);
}

Production

Le programme ci-dessus génère la sortie suivante -

Hello TutorialsPoint , Hello!

Illustration: replace ()

le replace()La fonction prend deux paramètres - le premier paramètre est un modèle de chaîne à rechercher et le second paramètre est la nouvelle valeur à remplacer. Dans l'exemple ci-dessus, Hello apparaît deux fois dans la chaîne name1 .

La fonction replace remplace toutes les occurrences de la chaîne Hello avec Howdy.

fn main(){
   let name1 = "Hello TutorialsPoint , 
   Hello!".to_string();         //String object
   let name2 = name1.replace("Hello","Howdy");    //find and replace
   println!("{}",name2);
}

Production

Le programme ci-dessus génère la sortie suivante -

Howdy TutorialsPoint , Howdy!

Illustration: as_str ()

le as_str() La fonction extrait une tranche de chaîne contenant la chaîne entière.

fn main() {
   let example_string = String::from("example_string");
   print_literal(example_string.as_str());
}
fn print_literal(data:&str ){
   println!("displaying string literal {}",data);
}

Production

Le programme ci-dessus génère la sortie suivante -

displaying string literal example_string

Illustration: pousser ()

le push() function ajoute le caractère donné à la fin de cette chaîne.

fn main(){
   let mut company = "Tutorial".to_string();
   company.push('s');
   println!("{}",company);
}

Production

Le programme ci-dessus génère la sortie suivante -

Tutorials

Illustration: push_str ()

le push_str() function ajoute une tranche de chaîne donnée à la fin d'une chaîne.

fn main(){
   let mut company = "Tutorials".to_string();
   company.push_str(" Point");
   println!("{}",company);
}

Production

Le programme ci-dessus génère la sortie suivante -

Tutorials Point

Illustration: len ()

le len() La fonction renvoie le nombre total de caractères dans une chaîne (espaces compris).

fn main() {
   let fullname = " Tutorials Point";
   println!("length is {}",fullname.len());
}

Production

Le programme ci-dessus génère la sortie suivante -

length is 20

Illustration: trim ()

La fonction trim () supprime les espaces de début et de fin dans une chaîne. Notez que cette fonction ne supprimera pas les espaces en ligne.

fn main() {
   let fullname = " Tutorials Point \r\n";
   println!("Before trim ");
   println!("length is {}",fullname.len());
   println!();
   println!("After trim ");
   println!("length is {}",fullname.trim().len());
}

Production

Le programme ci-dessus génère la sortie suivante -

Before trim
length is 24

After trim
length is 15

Illustration: split_whitespace ()

le split_whitespace()divise la chaîne d'entrée en différentes chaînes. Il renvoie un itérateur donc nous itérons à travers les jetons comme indiqué ci-dessous -

fn main(){
   let msg = "Tutorials Point has good t
   utorials".to_string();
   let mut i = 1;
   
   for token in msg.split_whitespace(){
      println!("token {} {}",i,token);
      i+=1;
   }
}

Production

token 1 Tutorials
token 2 Point
token 3 has
token 4 good
token 5 tutorials

Illustration: chaîne split ()

le split() stringLa méthode retourne un itérateur sur des sous-chaînes d'une tranche de chaîne, séparées par des caractères correspondant à un modèle. La limitation de la méthode split () est que le résultat ne peut pas être stocké pour une utilisation ultérieure. lecollect peut être utilisée pour stocker le résultat renvoyé par split () sous forme de vecteur.

fn main() {
   let fullname = "Kannan,Sudhakaran,Tutorialspoint";

   for token in fullname.split(","){
      println!("token is {}",token);
   }

   //store in a Vector
   println!("\n");
   let tokens:Vec<&str>= fullname.split(",").collect();
   println!("firstName is {}",tokens[0]);
   println!("lastname is {}",tokens[1]);
   println!("company is {}",tokens[2]);
}

L'exemple ci-dessus divise la chaîne fullname, chaque fois qu'il rencontre une virgule (,).

Production

token is Kannan
token is Sudhakaran
token is Tutorialspoint

firstName is Kannan
lastname is Sudhakaran
company is Tutorialspoint

Illustration: chars ()

Les caractères individuels d'une chaîne sont accessibles à l'aide de la méthode chars. Prenons un exemple pour comprendre cela.

fn main(){
   let n1 = "Tutorials".to_string();

   for n in n1.chars(){
      println!("{}",n);
   }
}

Production

T
u
t
o
r
i
a
l
s

Concaténation de chaînes avec l'opérateur +

Une valeur de chaîne peut être ajoutée à une autre chaîne. C'est ce qu'on appelle la concaténation ou l'interpolation. Le résultat de la concaténation de chaînes est un nouvel objet chaîne. L'opérateur + utilise en interne une méthode add . La syntaxe de la fonction add prend deux paramètres. Le premier paramètre est self - l'objet chaîne lui-même et le second paramètre est une référence du second objet chaîne. Ceci est montré ci-dessous -

//add function
add(self,&str)->String { 
   // returns a String object
}

Illustration: Concaténation de chaînes

fn main(){
   let n1 = "Tutorials".to_string();
   let n2 = "Point".to_string();

   let n3 = n1 + &n2; // n2 reference is passed
   println!("{}",n3);
}

La sortie sera comme indiqué ci-dessous

TutorialsPoint

Illustration: moulage de type

L'exemple suivant illustre la conversion d'un nombre en objet chaîne -

fn main(){
   let number = 2020;
   let number_as_string = number.to_string(); 
   
   // convert number to string
   println!("{}",number_as_string);
   println!("{}",number_as_string=="2020");
}

La sortie sera comme indiqué ci-dessous

2020
true

Illustration: Format! Macro

Une autre façon d'ajouter des objets String ensemble consiste à utiliser une fonction macro appelée format. L'utilisation de Format! est comme indiqué ci-dessous.

fn main(){
   let n1 = "Tutorials".to_string();
   let n2 = "Point".to_string();
   let n3 = format!("{} {}",n1,n2);
   println!("{}",n3);
}

La sortie sera comme indiqué ci-dessous

Tutorials Point