Explication détaillée des propriétés et méthodes de l'objet String des compétences natives JavaScript objects

longueur

La propriété

length renvoie le nombre de caractères dans une chaîne.

length obtient la longueur basée sur le codage UTF-16 de la chaîne. La longueur d'une chaîne vide est 0. la longueur ne peut pas être modifiée.

charAt()

La méthode charAt() renvoie le caractère à la position spécifiée. Notez que JavaScript n'a pas de type de données caractère distinct du type chaîne, les caractères renvoyés sont donc des chaînes de longueur 1.

stringObject.charAt(index)

L'index du paramètre est obligatoire. Nombre qui représente une certaine position dans une chaîne, c'est-à-dire l'indice d'un caractère dans la chaîne. L'index du premier caractère de la chaîne est 0. Si l'index du paramètre n'est pas compris entre 0 et string.length, cette méthode renvoie une chaîne vide.

Remarque : La méthode charAt() peut rencontrer des problèmes pour prendre en charge certains caractères non BMP (Basic-Multilingual-Plane). Référence : MDN

charCodeAt()

La méthode charCodeAt() renvoie l'encodage Unicode du caractère à la position spécifiée. Cette valeur de retour est un entier compris entre 0 et 65 535.
La méthode charCodeAt() effectue une opération similaire à la méthode charAt(), sauf que la première renvoie l'encodage du caractère à la position spécifiée, tandis que la seconde renvoie une sous-chaîne de caractères.

stringObject.charCodeAt(index)

L'index du paramètre est facultatif. Nombre qui représente une certaine position dans une chaîne, c'est-à-dire l'indice d'un caractère dans la chaîne. L'index du premier caractère de la chaîne est 0. Si l'index est négatif, ou supérieur ou égal à la longueur de la chaîne, charCodeAt() renvoie NaN. La valeur par défaut est 0 lorsque l'index est vide.

La plage de codage Unicode est comprise entre 0 et 1 114 111. Les 128 premiers codages Unicode correspondent aux codages de caractères ASCII. La valeur renvoyée par la méthode charCodeAt() est toujours inférieure à 65536, car les caractères avec des valeurs plus élevées apparaissent par paires et doivent être récupérés simultanément avec charCodeAt(i) et charCodeAt(i 1).

concat() – Obsolète

La méthode concat() est utilisée pour concaténer deux ou plusieurs chaînes.

stringObject.concat(stringX, stringX, …, stringX)

Le paramètre stringX est obligatoire. Est un ou plusieurs objets chaîne qui seront concaténés en une chaîne.

La méthode

concat() convertira tous ses paramètres en chaînes, puis les concatènera à la fin de la chaîne stringObject dans l'ordre et renverra la chaîne concaténée. Notez que le stringObject lui-même n'est pas modifié.

Notez qu'il est fortement recommandé d'utiliser l'opérateur " " pour concaténer des chaînes comme alternative à cette méthode, qui est plus efficace : concat vs vs join.
indexOf()

La méthode indexOf() renvoie la position de la première occurrence d'une valeur de chaîne spécifiée dans la chaîne.

stringObject.indexOf(searchvalue, fromindex)

Le paramètre searchvalue est obligatoire et précise la valeur de chaîne à récupérer. Le paramètre fromindex est un paramètre entier facultatif. Spécifie la position dans la chaîne pour commencer la recherche. Ses valeurs légales vont de 0 à stringObject.length – 1. Si ce paramètre est omis, la recherche démarrera à partir du premier caractère de la chaîne.

Cette méthode récupérera la chaîne stringObject du début à la fin pour voir si elle contient la valeur de recherche de la sous-chaîne. La position de départ de la recherche est au fromindex de la chaîne ou au début de la chaîne (lorsque fromindex n'est pas spécifié). Si une valeur de recherche est trouvée, la position de la première occurrence de la valeur de recherche est renvoyée. Les positions des caractères dans stringObject commencent à 0.

Remarque : La méthode indexOf() est sensible à la casse ! Si la valeur de chaîne à récupérer n'apparaît pas, la méthode renvoie -1.

lastIndexOf()

La méthode

lastIndexOf() peut renvoyer la dernière position d'occurrence d'une valeur de chaîne spécifiée, en recherchant de l'arrière vers l'avant à la position spécifiée dans une chaîne.

Les paramètres et méthodes d'utilisation de lastIndexOf() et indexOf() sont les mêmes, sauf qu'ils effectuent une recherche de l'arrière vers l'avant.

Copier le code Le code est le suivant :

var str="Bonjour le monde !"

console.log(str.indexOf("wo")); //6
console.log(str.indexOf("wo",2)); //6
console.log(str.indexOf("wo",10)); //12
console.log(str.lastIndexOf("wo")); //12
console.log(str.lastIndexOf("wo",2)); //-1
console.log(str.lastIndexOf("wo",10)); //6

localeCompare()

Compare deux chaînes dans un ordre spécifique local.

stringObject.localeCompare(target)

Le paramètre target est obligatoire, la chaîne à comparer avec stringObject dans un ordre spécifique local.

Renvoie le numéro du résultat de la comparaison. Si stringObject est inférieur à la cible, localeCompare() renvoie un nombre inférieur à 0. Si stringObject est supérieur à target, cette méthode renvoie un nombre supérieur à 0. Si les deux chaînes sont égales ou s’il n’y a aucune différence selon le classement local, cette méthode renvoie 0.

Lorsque les opérateurs < et > sont appliqués aux chaînes, ils comparent uniquement les chaînes en utilisant le codage Unicode du caractère, quel que soit le classement local. L'ordre généré de cette manière n'est pas nécessairement correct. Par exemple, en espagnol, le caractère « ch » est généralement classé comme un caractère qui apparaît entre les lettres « c » et « d ». La méthode localeCompare() fournit un moyen de comparer des chaînes, en tenant compte du classement local par défaut.

Les paramètres de localeCompare() dans certains navigateurs avancés prennent également en charge les paramètres régionaux et les options, reportez-vous au code et MDN suivants : https://developer.mozilla.org/en-US/docs/Web/JavaScript / Référence/Global_Objects/String/localeCompare

Copier le code Le code est le suivant :

//Différentes cultures ont des règles de tri différentes 

console.log('ä'.localeCompare('z', 'de')); //-1 

console.log('ä'.localeCompare('z', 'sv')); //1

match()

La méthode

match() récupère une valeur spécifiée dans une chaîne ou trouve une correspondance pour une ou plusieurs expressions régulières.

Cette méthode est similaire à indexOf() et lastIndexOf(), mais elle renvoie la valeur spécifiée au lieu de la position de la chaîne.

stringObject.match(regexp)

Le paramètre regexp peut être une chaîne ou un objet RegExp d'expression régulière.

Renvoie un tableau stockant les résultats correspondants. Le contenu de ce tableau dépend du fait que l'expression rationnelle possède ou non l'indicateur global g.

Si l'expression rationnelle n'a pas l'indicateur g, alors la méthode match() ne peut effectuer qu'une seule correspondance dans le stringObject. Si aucun texte correspondant n'est trouvé, match() renvoie null. Sinon, il renvoie un tableau contenant des informations sur le texte correspondant trouvé. Le 0ème élément du tableau contient le texte correspondant, tandis que les éléments restants contiennent le texte qui correspond à la sous-expression de l'expression régulière. En plus de ces éléments de tableau réguliers, le tableau renvoyé contient deux propriétés d'objet. L'attribut index déclare la position du caractère de début du texte correspondant dans stringObject et l'attribut input déclare une référence à stringObject.

Si l'expression rationnelle a l'indicateur g, la méthode match() effectue une recherche globale pour trouver toutes les sous-chaînes correspondantes dans stringObject. Si aucune sous-chaîne correspondante n'est trouvée, null est renvoyé. Si une ou plusieurs sous-chaînes correspondantes sont trouvées, un tableau est renvoyé. Cependant, le contenu du tableau renvoyé par la correspondance globale est très différent du premier. Ses éléments du tableau stockent toutes les sous-chaînes correspondantes dans stringObject, et il n'y a pas d'attribut d'index ni d'attribut d'entrée.

Sans l'indicateur g, appeler stringObject.match(regexp) a le même résultat que appeler regexp.exec(stringObject). En mode de recherche globale, match() ne fournit pas d'informations sur le texte correspondant à la sous-expression, ni ne déclare la position de chaque sous-chaîne correspondante. Si vous avez besoin de ces informations récupérées globalement, vous pouvez utiliser RegExp.exec().

Remarque : si vous avez besoin de savoir si une chaîne correspond à une expression régulière, utilisez regexp.test(string); si vous ne souhaitez la faire correspondre qu'une seule fois, utilisez regexp.exec(string) au lieu de string.match(regexp) .

Copier le code Le code est le suivant :

var str="Bonjour tout le monde !"
var str2="1 plus 2 égale 3"

console.log(str.match("world")); //["world", index : 6, input : "Bonjour tout le monde !"]
console.log(str2.match(/d /g)); //["1", "2", "3"]

remplacer()

La méthode

replace() est utilisée pour remplacer certains caractères par d'autres caractères dans une chaîne, ou pour remplacer une sous-chaîne qui correspond à une expression régulière.

stringObject.replace(regexp/substr, remplacement)

Les paramètres regexp/substr sont obligatoires. Un objet RegExp qui spécifie la sous-chaîne ou le modèle à remplacer. Si la valeur est une chaîne, elle est récupérée sous forme de modèle littéral plutôt que d'être d'abord convertie en objet RegExp. Le remplacement des paramètres est requis. est une valeur de chaîne. Spécifie les fonctions permettant de remplacer du texte ou de générer du texte de remplacement.

La méthode

renvoie une nouvelle chaîne obtenue en remplaçant la première ou toutes les correspondances de l'expression rationnelle par remplacement.

La méthode replace() de string stringObject effectue une opération de recherche et de remplacement. Il recherchera les sous-chaînes dans stringObject qui correspondent à l'expression rationnelle et remplacera ces sous-chaînes par un remplacement. Si l'expression rationnelle a l'indicateur global g, alors la méthode replace() remplace toutes les sous-chaînes correspondantes. Sinon, il remplace uniquement la première sous-chaîne correspondante.

le remplacement peut être une chaîne ou une fonction. S'il s'agit d'une chaîne, alors chaque correspondance sera remplacée par la chaîne. Mais le caractère $ en remplacement a une signification précise. Comme indiqué ci-dessous, cela montre que la chaîne obtenue à partir de la correspondance de modèle sera utilisée pour le remplacement :

1.$$ – $
2.$` - le texte à gauche de la sous-chaîne correspondante.
3.$' - le texte à droite de la sous-chaîne correspondante.
4.$& - expression rationnelle correspondant à la sous-chaîne.
5.$number - Texte qui correspond à la sous-expression numéro-ième dans l'expression rationnelle.

le remplacement peut être une fonction, auquel cas la fonction est appelée pour chaque correspondance et la chaîne qu'elle renvoie sera utilisée comme texte de remplacement. Le premier paramètre de cette fonction est une chaîne correspondant au modèle. L'argument suivant est une chaîne qui correspond à la sous-expression dans le modèle, et il peut y avoir 0 ou plusieurs arguments de ce type. Le paramètre suivant est un entier qui déclare la position dans le stringObject où la correspondance se produit. Le dernier paramètre est le stringObject lui-même.

Copier le code Le code est le suivant :

//Remplacer une fois
var str = "Bonjour Microsoft !";
console.log(str.replace(/Microsoft/, "Google")); //Bonjour Google !
console.log(str); //Bonjour Microsoft !

//Remplacer plusieurs fois
var str2 = "Bonjour Microsoft ! et Microsoft ! et Microsoft ! ou Microsoft !";
console.log(str2.replace(/Microsoft/g, "Google")); //Bonjour Google ! et Google !

//Conversion de caractères
var str3 = "Biche, John";
console.log(str3.replace(/(w )s*, s*(w )/, "$2 $1")); //John Doe

var str4 = '"a", "b"';
console.log(str4.replace(/"([^"]*)"/g, "'$1'")); //'a', 'b'

//Utiliser la fonction
var str5 = 'aaa bbb ccc';
console.log(str5.replace(/bw b/g, function(word){
return word.substring(0,1).toUpperCase() word.substring(1);}
)); //Aaa Bbb Ccc

recherche()

La méthode

search() est utilisée pour récupérer une sous-chaîne spécifiée dans une chaîne, ou pour récupérer une sous-chaîne qui correspond à une expression régulière.

stringObject.search(regexp)

Le paramètre regexp peut être la sous-chaîne qui doit être récupérée dans stringObject, ou il peut s'agir de l'objet RegExp qui doit être récupéré.

Renvoie la position de départ de la première sous-chaîne de stringObject qui correspond à l'expression rationnelle. Si aucune sous-chaîne correspondante n'est trouvée, -1 est renvoyé.

Remarque : La méthode search() n'effectue pas de correspondance globale, elle ignore l'indicateur g. Il ignore également la propriété lastIndex de l'expression rationnelle et récupère toujours à partir du début de la chaîne, ce qui signifie qu'il renvoie toujours la première position correspondante du stringObject.

Copier le code Le code est le suivant :

var str = "Bonjour Microsoft !";

console.log(str.search(/Microsoft/)); //6

如果只是想知道是否有符合的字串，使用search()和使用test()方法差不多。如果想得到更多的信息，可以使用match()和exec()方法，但是效率會低。

slice()

slice() 方法可提取字串的某個部分，並以新的字串傳回被提取的部分。

stringObject.slice(start, end)

參數start是要抽取的片斷的起始下標。如果是負數，則此參數規定的是從字串的尾部開始算起的位置。也就是說，-1 指字串的最後一個字符，-2 指倒數第二個字符，以此類推。

參數end是緊接著要抽取的片段的結尾的下標。若未指定此參數，則要擷取的子字串包括 start 到原始字串結尾的字串。如果該參數是負數，那麼它規定的是從字串的尾部開始算起的位置。

方法會傳回一個新的字串。包括字串 stringObject 從 start 開始（包括 start）到 end 結束（不包括 end）為止的所有字元。

注意：String 物件的方法 slice()、substring() 和 substr() 都可傳回字串的指定部分。強烈建議在所有場合都使用 slice() 方法。

複製程式碼程式碼如下:

var str = "Hello Microsoft!";

console.log(str.slice(6));      //Microsoft!

console.log(str.slice(6, 12));  //Micros

substring()

不建議使用，建議使用slice()替代。

substr()

不建議使用，建議使用slice()替代。

toLocaleLowerCase()

不建議使用，只在土耳其語等少數語種中有用，建議使用toLowerCase()替代。

toLocaleUpperCase()

不建議使用，只在土耳其語等少數語種中有用，建議使用toUpperCase()替代。

toLowerCase()

toLowerCase() 方法用來把字串轉換為小寫。

toUpperCase()

toUpperCase() 方法用來把字串轉換為大寫。

String物件還有很多用於HTML 標籤的方法：anchor()、big()、blink()、bold()、fixed()、fontcolor()、fontsize()、italics()、link() 、small()、strike()、sub()、sup()。他們主要是對String物件進行HTML格式化處理，現在已經很少人會應用到了，不建議使用。

方法示範實例:

複製程式碼程式碼如下:

var txt="Hello World!"

document.write("

Big: " txt.big() "

")
document.write("

Small: " txt.small() "

document.write("

Bold: " txt.bold() "

")
document.write("

Italic: " txt.italics() "

document.write("