TypeScript String

En TypeScript, String est un type de données de base utilisé pour représenter des données textuelles. Il hérite et étend les fonctionnalités de chaîne de caractères de JavaScript tout en ajoutant la vérification statique des types.

Syntaxe

var txt = new String("string");

Ou plus simplement :

var txt = "string";

Deux méthodes de création et leurs différences essentielles

Il existe deux façons de créer des chaînes de caractères en TypeScript, mais elles présentent des différences essentielles en matière de type, de performances et de scénarios d'utilisation :

Méthode 1 : littéraux de chaîne de caractères (recommandé)

C'est la manière la plus courante et la plus performante en TypeScript/JavaScript. Elle crée le type primitif string (string), qui est également le type de chaîne par défaut dans le système de types de TypeScript.

// 原始字符串(推荐使用)
const txt1: string = "Hello TypeScript"; // 显式指定类型
const txt2 = "Hello JavaScript"; // 类型推导为 string

Méthode 2 : objet String (non recommandé)

L'utilisation denew String()crée le type objet enveloppeur (String), qui est essentiellement un objet plutôt qu'une valeur primitive, ce qui entraîne une confusion de type et une perte de performances.

// String 对象(不推荐)
const txtObj: String = new String("Hello Object"); // 类型为 String(对象)

Les objets String et les littéraux de chaîne de caractères sont de types différents :

  • Les littéraux de chaîne de caractères sont un type de données primitifstring, utilisé pour stocker directement des valeurs de chaîne.
  • StringL'objet est deStringtype ; il s'agit en fait d'un objet, et non de la valeur primitive de chaîne.

Exemple

let strLiteral: string = "Hello";
let strObject: String = new String("Hello");

console.log(typeof strLiteral); // Sortie : "string"
console.log(typeof strObject);  // Sortie : "object"
Fonctionnalité Littéral de chaîne (string) Objet String (String)
Nature du type Valeur primitive Type référence (object)
Performance Efficace, aucune surcharge mémoire supplémentaire Inefficace, crée des instances d’objet
Vérification de type (TypeScript) Conforme aux spécifications de type de base de TS Incompatibilité de type (par ex., on ne peut pas affecter un objet String à une variable de type string)
Méthode de comparaison Compare directement les valeurs Compare les adresses de référence (nécessite valueOf() pour obtenir la valeur primitive)

Compatibilité de type entre les littéraux de chaîne et les objets String

En TypeScript, le type littéral string et le type objet String ne sont pas entièrement compatibles.

Par exemple, une variable de type string ne peut pas utiliser directement les méthodes d’un objet String, et inversement. Par conséquent, il n’est généralement pas nécessaire d’utiliser l’objet String.

Exemple

let strLiteral: string = "Test";
let strObject: String = new String("Test");

console.log(strLiteral === strObject);  // Sortie : false, même contenu, types différents
console.log(strLiteral == strObject);   // Sortie : true, même contenu
console.log(strLiteral === strObject.valueOf()); // Sortie : true, comparaison après conversion de l'objet en chaîne primitive

strLiteral est le type chaîne primitive (string), tandis que strObject est le type objet String (String). Cela signifie que leurs types sont différents.

Le code ci-dessus converti en JavaScript est :

Exemple

var strLiteral = "Test";
var strObject = new String("Test");
console.log(strLiteral === strObject); // Sortie : false, même contenu, types différents
console.log(strLiteral == strObject); // Sortie : true, même contenu
console.log(strLiteral === strObject.valueOf()); // Sortie : true, comparaison après conversion de l'objet en chaîne primitive

Propriétés de l'objet String

Le tableau suivant répertorie les propriétés prises en charge par l'objet String :

Non. Propriété & Description Exemple
1. constructor

Une référence à la fonction qui a créé l'objet.

var str = new String( "This is string" ); 
console.log("str.constructor is:" + str.constructor)

Sortie :

str.constructor is:function String() { [native code] }
2. longueur

Renvoie la longueur de la chaîne.

var uname = new String("Hello World") 
console.log("Length "+uname.length)  // 输出 11
3. prototype

Permet d'ajouter des propriétés et des méthodes à un objet.

function employee(id:number,name:string) { 
    this.id = id 
    this.name = name 
 } 
 var emp = new employee(123,"admin") 
 employee.prototype.email="admin@example.com" // 添加属性 email
 console.log("员工号: "+emp.id) 
 console.log("员工姓名: "+emp.name) 
 console.log("员工邮箱: "+emp.email)

Méthodes de String

Le tableau suivant répertorie les méthodes prises en charge par l'objet String :

Non. Metode & Deskripsi Exemple
1. charAt()

Renvoie le caractère à la position spécifiée.

var str = new String("EXAMPLE"); 
console.log("str.charAt(0) 为:" + str.charAt(0)); // R
console.log("str.charAt(1) 为:" + str.charAt(1)); // U 
console.log("str.charAt(2) 为:" + str.charAt(2)); // N 
console.log("str.charAt(3) 为:" + str.charAt(3)); // O 
console.log("str.charAt(4) 为:" + str.charAt(4)); // O 
console.log("str.charAt(5) 为:" + str.charAt(5)); // B
2. charCodeAt()

Renvoie la valeur Unicode du caractère à la position spécifiée.

var str = new String("EXAMPLE"); 
console.log("str.charCodeAt(0) 为:" + str.charCodeAt(0)); // 82
console.log("str.charCodeAt(1) 为:" + str.charCodeAt(1)); // 85 
console.log("str.charCodeAt(2) 为:" + str.charCodeAt(2)); // 78 
console.log("str.charCodeAt(3) 为:" + str.charCodeAt(3)); // 79 
console.log("str.charCodeAt(4) 为:" + str.charCodeAt(4)); // 79
console.log("str.charCodeAt(5) 为:" + str.charCodeAt(5)); // 66
3. concat()

Concatène deux chaînes ou plus et renvoie une nouvelle chaîne.

var str1 = new String( "EXAMPLE" ); 
var str2 = new String( "GOOGLE" ); 
var str3 = str1.concat( str2 ); 
console.log("str1 + str2 : "+str3) // EXAMPLEGOOGLE
4. indexOf()

Renvoie la position de la première occurrence d'une valeur de chaîne spécifiée dans une chaîne.

var str1 = new String( "EXAMPLE" ); 

var index = str1.indexOf( "OO" ); 
console.log("查找的字符串位置 :" + index );  // 3
5. lastIndexOf()

Recherche une chaîne de l'arrière vers l'avant et renvoie la position de la dernière occurrence, comptée depuis la position de départ (0).

var str1 = new String( "This is string one and again string" ); 
var index = str1.lastIndexOf( "string" );
console.log("lastIndexOf 查找到的最后字符串位置 :" + index ); // 29
    
index = str1.lastIndexOf( "one" ); 
console.log("lastIndexOf 查找到的最后字符串位置 :" + index ); // 15
6. localeCompare()

Compare deux chaînes selon un ordre propre à la locale.

var str1 = new String( "This is beautiful string" );
  
var index = str1.localeCompare( "This is beautiful string");  

console.log("localeCompare first :" + index );  // 0
7.

match()

Trouve une ou plusieurs correspondances d'expression régulière.

var str="The rain in SPAIN stays mainly in the plain"; 
var n=str.match(/ain/g);  // ain,ain,ain
8. replace()

Remplace les sous-chaînes qui correspondent à une expression régulière.

var re = /(\w+)\s(\w+)/; 
var str = "zara ali"; 
var newstr = str.replace(re, "$2, $1"); 
console.log(newstr); // ali, zara
9. search()

Recherche une valeur correspondant à une expression régulière.

var re = /apples/gi; 
var str = "Apples are round, and apples are juicy.";
if (str.search(re) == -1 ) { 
   console.log("Does not contain Apples" ); 
} else { 
   console.log("Contains Apples" ); 
} 
10. slice()

Extrait un fragment d'une chaîne et renvoie la partie extraite dans une nouvelle chaîne.

11. split()

Divise une chaîne en un tableau de sous-chaînes.

var str = "Apples are round, and apples are juicy."; 
var splitted = str.split(" ", 3); 
console.log(splitted)  // [ 'Apples', 'are', 'round,' ]
12. substr()

Extrait un nombre spécifié de caractères d'une chaîne à partir de l'index de départ.

13. substring()

Extrait les caractères entre deux indices spécifiés dans une chaîne.

var str = "EXAMPLE GOOGLE TAOBAO FACEBOOK"; 
console.log("(1,2): "    + str.substring(1,2));   // U
console.log("(0,10): "   + str.substring(0, 10)); // EXAMPLE GOO
console.log("(5): "      + str.substring(5));     // B GOOGLE TAOBAO FACEBOOK
14. toLocaleLowerCase()

Convertit une chaîne en minuscules selon la locale de l'hôte. Seules quelques langues (comme le turc) ont des mappages de casse spécifiques à la locale.

var str = "Example Google"; 
console.log(str.toLocaleLowerCase( ));  // example google
15. toLocaleUpperCase()

Convertit une chaîne en majuscules selon la locale de l'hôte. Seules quelques langues (comme le turc) ont des mappages de casse spécifiques à la locale.

var str = "Example Google"; 
console.log(str.toLocaleUpperCase( ));  // EXAMPLE GOOGLE
16. toLowerCase()

Convertit une chaîne en minuscules.

var str = "Example Google"; 
console.log(str.toLowerCase( ));  // example google
17. toString()

Renvoie une chaîne.

var str = "Example"; 
console.log(str.toString( )); // Example
18. toUpperCase()

Convertit une chaîne en majuscules.

var str = "Example Google"; 
console.log(str.toUpperCase( ));  // EXAMPLE GOOGLE
19. valueOf()

Renvoie la valeur primitive de l'objet String spécifié.

var str = new String("Example"); 
console.log(str.valueOf( ));  // Example

Recommandations pour l'utilisation des objets String

En TypeScript, utiliser l'objet String est généralement inutile. Utiliser directement des littéraux de chaîne est plus efficace et conforme aux bonnes pratiques TypeScript :

  • Performance:StringL'objet est un type de référence, occupe plus de mémoire, et créer un nouvel objet à chaque fois entraîne une surcharge de performance plus importante.
  • Sécurité des types: TypeScript encourage l'utilisation destringtypes littéraux pour garder le code concis et cohérent.

Si vous avez vraiment besoin d'utiliser les méthodes de l'objet String, vous pouvez convertir l'objet en chaîne primitive à l'aide de la méthode valueOf() puis continuer le traitement.

En général, TypeScript recommande d'utiliser directement le type littéral de chaîne pour simplifier le code, améliorer les performances et éviter les conversions de type et la complexité inutiles.

Exemple

let strLiteral: string = "Utilisez des littéraux de chaîne chaque fois que possible !";
let strObject: String = new String("Évitez d'utiliser des objets String.");

console.log(strLiteral);                // Sortie : "Utilisez des littéraux de chaîne chaque fois que possible !"
console.log(strObject.valueOf());       // Sortie : "Évitez d'utiliser des objets String."
Autres extensions