JavaScript ne représente pas un seul caractère, seulement un type de chaîne de chaîne, et le type de caractères est équivalent à une chaîne contenant un seul caractère.
String String est un type de données de base de JavaScript. Dans le même temps, JavaScript prend également en charge les objets String, qui est un objet wrapper avec des valeurs d'origine. JavaScript convertit automatiquement entre la forme d'origine et le formulaire d'objet en cas de besoin. Cet article présentera le type de chaîne et l'objet d'emballage de chaîne d'origine
définition
Le type de chaîne est une séquence de caractères composée de caractères Unicode 16 bits enfermés en citations.
Les types de chaînes sont souvent utilisés pour représenter les données de texte, et à l'heure actuelle, chaque élément de la chaîne est considéré comme un point de code. Chaque élément est considéré comme occupant une position dans cette séquence, indexant ces positions avec des valeurs non négatives. Le premier caractère commence en position 0, le deuxième caractère est en position 1, et ainsi de suite
La longueur de la chaîne est le nombre d'éléments (par exemple, une valeur 16 bits). La chaîne vide a une longueur zéro, donc elle ne contient aucun éléments
Encodage Unicode
Tous les caractères peuvent être écrits sous la forme de «/ uxxxx», où XXXX représente le codage Unicode du caractère. Par exemple, / u00a9 représente le symbole du droit d'auteur
var s = '/ u00a9'; s // "©"
Si une chaîne contient des données de texte réelles, chaque élément est considéré comme une unité UTF-16 distincte. Chaque caractère est stocké dans le format 16 bits (c'est-à-dire 2 octets) à l'intérieur de JavaScript
Mais UTF-16 a deux longueurs: pour les caractères entre U + 0000 et U + FFFF, la longueur est de 16 bits (c'est-à-dire 2 octets); Pour les caractères entre U + 10000 et U + 10FFFF, la longueur est de 32 bits (c'est-à-dire 4 octets), et les deux premiers octets se situent entre 0xd800 et 0xdbff, et les deux derniers octets se trouvent entre 0xdc00 et 0xdffff, et les deux derniers octets se trouvent entre 0xdc00 et 0xdffff.
Par exemple, le caractère "?" correspondant à U + 1D306 est écrit comme UTF-16, qui est 0xd834 0xdf06. Le navigateur reconnaîtra correctement ces quatre octets comme un seul caractère, mais la longueur du caractère à l'intérieur de JavaScript est toujours fixée à 16 bits, et ces quatre octets seront traités comme deux caractères.
var s = '/ ud834 / udf06'; s // "?" s.length // 2
Pour les caractères Unicode de 4 octets de U + 10000 à U + 10FFFF, JavaScript est toujours traité comme deux caractères (l'attribut de longueur de caractères est 2)
guillemets
La chaîne de chaîne est déclarée par Double Quotes (") ou des citations simples ('). Java déclare les chaînes avec des citations doubles et des caractères avec des citations simples. Étant donné que ECMAScript n'a pas de type de caractère, l'une ou l'autre de ces deux notations peut être utilisée, mais les citations gauche et droite doivent correspondre.
// correct var scolor1 = "red"; var scolor2 = 'red'; // error var scolor1 = "red '; var scolor2 =' red";
Une chaîne délimitée par des citations simples peut contenir des citations doubles, et une chaîne délimitée par des citations doubles peut également contenir des citations simples.
'key = "valeur"' "C'est un long voyage"
Le code JavaScript peut être mélangé avec des chaînes de code HTML, et le code HTML sera également mélangé avec du code JavaScript. Par conséquent, il est préférable d'utiliser des styles de devis séparés dans JavaScript et le code HTML chacun
Des citations simples sont utilisées pour représenter les chaînes en JavaScript, des citations doubles sont utilisées pour représenter les chaînes dans les gestionnaires d'événements HTML
<bouton onclick = "alert ('merci')"> Cliquez sur moi </fruton>Barre de barre
Si vous souhaitez utiliser des devis simples dans une seule chaîne délimitée par devis, ou des devis doubles dans une chaîne délimitée à double devis, vous devez utiliser une barre arrière (/)
Les situations communes sont que l'apostrophe et les citations uniques de l'abréviation anglaise et de l'écriture possessive sont le même caractère, vous devez donc utiliser une barre de bar (/) pour échapper à l'apostrophe.
«Ne préférerais-tu pas ce livre? // "Ne préféreriez-vous pas ce livre?" "A-t-elle dit /" bonjour / "?" // "A-t-elle dit" bonjour "?" "A-t-elle dit /" bonjour / "?" // "A-t-elle dit" bonjour "?"
Caractères multi-lignes
Par défaut, les chaînes ne peuvent être écrites qu'en une seule ligne, et si elles sont divisées en plusieurs lignes, elles rapporteront une erreur.
// une erreur non apparente Syntaxerror: jeton non valide ou inattendu
'un
b
C ';
Dans Ecmascript3, les chaînes doivent être écrites en une seule ligne
Dans Ecmascript5, les chaînes peuvent être divisées en lignes, chaque ligne doit se terminer avec une barre arrière (/)
Si vous souhaitez démarrer une nouvelle ligne en quantité directe de chaîne, vous pouvez utiliser les caractères d'échappement / N
// "Onelongline" 'One / Long / Line' / * "Twolines" * / 'Two / Nlines'
Personnages d'échappement
Dans les chaînes JavaScript, les barres oblidviennes (/) ont des utilisations spéciales. L'ajout d'un caractère après le symbole de barre arrière ne représente pas leur signification littérale. Ils sont utilisés pour représenter des caractères spéciaux, appelés personnages d'évasion
/ 0 octets vides
/ n
/ ttable
/ B
/ r ENTER
Papier d'alimentation / F
// Slash
/ 'Citations uniques
/ "Double Citations
/ xnn représente un personnage en hexadécimal nn (n est 0-F), tel que / x41 représente «A»
/ Unnnn en hexadécimal nnnn représente un caractère unicode (n est 0-f), tel que / u03a3 représente le caractère grec ε
Si une barre oblique inverse est utilisée avant un caractère non spécial, l'arrière-plan est omis
'/ a' // "a"
Si la chaîne doit contenir une barre oblique inverse, une autre barre obliquetreuse doit être ajoutée avant la barre de barre pour s'échapper
"Prev // suivant" // "Précédent / suivant"
Caractéristiques
Les cordes en JavaScript sont immuables. Une fois une chaîne créée, elle ne peut jamais être modifiée. Pour modifier la chaîne enregistrée par une variable, détruisez d'abord la chaîne d'origine, puis remplissez la variable d'une autre chaîne contenant la nouvelle valeur
Une nouvelle chaîne peut être créée en concaténant d'autres chaînes via l'opérateur +.
var lang = "java"; lang = lang + "script"; // 'javascript'
Le processus réel du code ci-dessus est: Créez d'abord une nouvelle chaîne qui peut contenir 10 caractères, puis remplir cette chaîne avec «Java» et «script». La dernière étape consiste à détruire les cordes originales «java» et «script», car ces deux chaînes sont inutiles
Ce processus se produit en arrière-plan et est également la raison pour laquelle les cordes d'extraits sont lentes dans certains vieux navigateurs (IE6), mais les versions ultérieures du navigateur ont résolu ce problème d'inefficacité
Tourner la corde
Il existe deux façons de convertir une valeur en une chaîne, toString () et string ()
[Remarque] Vous pouvez utiliser une chaîne vide "" + une valeur pour convertir la valeur en une chaîne
toString ()
La première consiste à utiliser la méthode toString () que presque toutes les valeurs ont. Cette méthode renvoie la représentation de chaîne de la valeur correspondante
[Remarque] Undefined et null n'ont pas cette méthode
Undefined.toString (); // error null.toString (); // error true.toString (); // 'true'false.tostring (); //' false''abc'.tostring (); // 'abc'1.23.tostring (); //' 1.23 '({}). Objet] [1,2,3,4] .toString (); // '1,2,3,4' (new Date ()). ToString (); // "Sun 05 juin 2016 10:04:53 GMT + 0800 (Chine Standard Time)" / Ab / I.ToString (); // '/ Ab / i'Chaîne()
Vous pouvez utiliser la fonction de transformation String () lorsque vous ne savez pas si la valeur que vous souhaitez convertir n'est pas définie ou nul.
La fonction de transformation String () suit les règles suivantes:
【1】 Si la valeur est nul, renvoyez «null»; Si la valeur n'est pas définie, renvoyez «non défini»
【2】 Si la valeur n'est pas nulle ou non définie, appelez la méthode toString () et renvoyez la valeur de type d'origine
【3】 Si l'objet renvoyé par la méthode TOSTRING (), appelez la méthode de valeur Of () pour renvoyer la valeur de type d'origine. Si l'objet renvoyé par la méthode de valeur de () est renvoyé, une erreur sera signalée
// "3" String ({toString: function () {return 3;}}) // "[objet objet]" String ({valueof: function () {return 2;}}) // "3" string ({valueof: function () {return 2;}, toString: function () {return 3;}})Attribut de longueur
Chaque instance du type de chaîne a un attribut de longueur, indiquant le nombre de caractères dans la chaîne. Étant donné que les cordes sont immuables, la longueur des cordes est également immuable.
L'attribut de longueur d'une chaîne n'est pas énuméré dans la boucle FOR / In, et il ne peut pas être supprimé via l'opérateur de suppression.
[Remarque] Pour la chaîne S, l'index du dernier caractère est S.Length - 1
var str = "test"; console.log (str.length); // 4str.length = 6; console.log (str, str.length); // "test", 4
Exemple de méthode
Méthode commune de l'objet
Le type de chaîne est un type de wrapper correspondant à une chaîne, héritant des trois méthodes des méthodes générales de l'objet objet ToString (), TolocaleString () et ValueOf ().
【ToString ()】
La méthode toString () renvoie la valeur de chaîne d'origine de la chaîne
【Tolocalestring ()】
La méthode tolocalestring () renvoie la valeur de chaîne d'origine de la chaîne
【Valeur de ()】
La méthode de valeur de () renvoie la valeur de chaîne d'origine de la chaîne
console.log ("test" .valueof ()); // "test" console.log ("test" .toString ()); // "test" console.log ("test" .tolocalestring ()); // "test"Accédez aux méthodes de caractère
Il existe quatre méthodes pour accéder aux caractères dans les chaînes: chartat (), supports [], charcodeat () et fromCharcode ().
【Chartat ()】
La méthode Charat () reçoit un paramètre basé sur la position de caractère de 0 et renvoie le caractère à la position spécifiée. Lorsque le paramètre est vide ou NAN, le paramètre par défaut est 0; Lorsque le paramètre est hors de portée, une chaîne vide est renvoyée
var str = "hello"; console.log (str.charat (1)); // eonsole.log (str.charat (-1)); // '' console.log (str.charat (10)); // '' console.log (str.charat ()); // h console.log (str.charat (nan)); // h
La méthode Charat () implique la conversion de type implicite de la fonction Number (). S'il est converti en valeur numérique, la chaîne sera sortie en fonction des règles ci-dessus; S'il est converti en nan, le 0ème caractère sera sorti.
var str = "Hello"; console.log (str.charat (true)); // 'e'console.log (str.charat (false)); //' h'console.log (str.charat ('abc')); // 'h'console.log (str.charat ({})); //' h'console.log (str.charat (2]);[Remarque] Les résultats de X.Charat (pos) et X.Substring (pos, pos + 1), x.substr (pos, 1), x.slice (pos, pos + 1) sont égaux les uns aux autres.
var str = "hello"; console.log (str.charat (1)); // 'e'console.log (str.substring (1,2)); //' e'console.log (str.substr (1,2)); // 'e'
【Branches】
ECMascript5 définit une autre façon d'accéder aux caractères, en utilisant des crochets plus des index numériques pour accéder à des caractères spécifiques dans une chaîne. Si le paramètre est hors de portée ou NAN, la sortie n'est pas définie; S'il n'y a pas de paramètre, une erreur sera signalée; Cette méthode n'a pas la conversion de type implicite de la fonction de transformation Number (), mais le paramètre peut être converti en une valeur numérique lorsqu'il s'agit d'un tableau de valeurs singulières.
[Remarque] Ie7-Browser ne prend pas en charge
var str = "hello"; console.log (str [0]); // hconsole.log (str [[1]]); // eConsole.log (str [false]); // undefinedconsole.log (str [-1]); // undefinedconsole.log (str [nan]); // undefinedConsole.Log (Str []);
【Charcodeat ()】
La méthode Charcodeat () est similaire à la méthode Charat (), qui reçoit un paramètre basé sur la position de caractère de 0, mais renvoie un codage Unicode 16 bits du caractère spécifié. La valeur de retour est un entier 16 bits, entre 0-65535, c'est-à-dire entre 0x0000-0xffff
Lorsque le paramètre est vide ou NAN, le paramètre par défaut est 0; Lorsque le paramètre est hors de portée, NAN est retourné.
var str = "Hello"; console.log (str.charcodeat ()); // 104Console.log (str.charcodeat (0)); // 104Console.log (str.charcodeat (1)); // 1 01Console.log (str.charcodeat (-1)); // nanconsole.log (str.charcodeat (10)); // nanconsole.log (str.charcodeat (nan)); // 104
De même, la méthode charcodeat () implique une conversion de type implicite de la fonction nombre (). S'il est converti en valeur numérique, la valeur correspondante sera sortie en fonction des règles ci-dessus; S'il est converti en nan, le codage du caractère du 0ème caractère sera sorti.
var str = "Hello"; console.log (str.charcodeat (true)); // 101Console.log (str.charcodeat (false)); // 104Console.log (st R.Charcodeat ('ABC')); // 104Console.log (str.charcodeat ({})); // 104Console.log (str.charcodeat ([2])); // l08【From Charcode ()】
Le constructeur de chaîne lui-même a une méthode statique: fromCharcode (). La tâche de cette méthode consiste à recevoir un ou plusieurs encodages de caractères, puis de les convertir en une chaîne. Essentiellement, cette méthode effectue l'opération opposée à partir de la méthode d'instance Charcodeat (). Si le paramètre est vide et NAN, une chaîne vide est renvoyée; Si le paramètre dépasse la plage de 0-65535, les caractères de sortie sont incontrôlables.
console.log (String.FromCharcode (104,101,108,108,111)); // 'hello'console.log (String.FromCharcode (0x6211,0x662f, 0x5c0f, 0x706b, 0x67f4)); //' je suis un peu un peu un peu un peu un peu un peu un peu un peu un peu un peu un peu un peu un peu un peu match'console.log (string.fromCharcode ()); // '' console.log (string.fromCharcode (nan)); // '' console.log (string.fromCharcode (-1)); console.log (String.FromCharcode (65560));
Si un personnage prend quatre octets, il doit être divisé en deux caractères.
console.log (String.FromCharcode (0xd842, 0xdfb7)); // "�line"
Coux de cordes
Il existe deux méthodes pour les coutures de chaîne: concat () et plus signe +
【Concat ()】
La méthode CONCAT () est utilisée pour épisser une ou plusieurs chaînes et retourner la nouvelle chaîne obtenue par épissage, tandis que la chaîne d'origine ne change pas. Si le paramètre (sauf le premier paramètre) n'est pas une chaîne, il est implicitement converti en une chaîne via la méthode String (), puis l'épissage de la chaîne est effectué.
var stringValue = 'Hello'; var result = stringValue.concat ('world', '!'); console.log (résultat); // 'Hello World!' Console.log (stringValue); // 'Hello'[Remarque] Le premier paramètre ne peut être qu'une chaîne. S'il est d'autres types (sauf des tableaux), une erreur sera signalée.
(1) .concat ('2'); // Signaler une erreur
(true) .concat ('false'); // signaler une erreur
({}). Concat ('ABC'); // Signaler une erreur
[Remarque] Étant donné que le tableau a également une méthode CONCAT (), les paramètres détermineront comment se convertir en fonction de la question de savoir si le paramètre qui apparaît en premier est un tableau ou une chaîne.
'1,2,3,'. Concat ([4,5]); // '1,2,3,4,5'
[1,2,3] .concat (', 4,5'); // [1, 2, 3, ", 4,5"]
【Plus opérateur (+)】
Bien que Concat () soit une méthode spécifiquement utilisée pour épisser les chaînes, plus d'utilisation de l'opérateur plus (+) dans la pratique. L'utilisation de l'opérateur plus est souvent plus simple que Concat ()
var stringValue = 'Hello'; console.log (StringValue.concat ('World', '!')); // 'Hello World!' Console.log (StringValue + 'World' + '!'); // 'Hello World!'[Remarque] La couture de chaîne est effectuée lorsque l'un des opérandes est une chaîne, ou si l'objet est converti en chaîne
1 + 2; // 3'1 '+ 2; //' 12'var o = {valeurof: function () {return '1';}}; o + 2; // '12'var o = {valueof: function () {return 1;}}; o + 2; // 3Créer des sous-chaînes
Il existe trois méthodes de création de sous-chaînes: Slice (), substr () et substring ().
【tranche()】
La méthode Slice (démarrage, fin) nécessite deux paramètres de démarrage et de fin, qui renvoie une sous-chaîne dans cette chaîne du caractère en position de début à (mais ne contient pas) le caractère à la position finale; Si la fin n'est pas définie ou n'existe pas, il renvoie tous les caractères de la position de début à la fin de la chaîne
Si Start est un nombre négatif, démarrez = max (longueur + démarrage, 0)
Si la fin est un nombre négatif, end = max (longueur + fin, 0)
Le démarrage et la fin ne peuvent pas échanger des positions
var stringValue = 'Hello World'; console.log (StringValue.slice ()); // 'Hello World'console.log (StringValue.slice (2)); //' llo world'console.log (StringValue.Slice (2, Undefined)); // 'llo llo world'console.log (stringValue.slice (2, -5)); // 'llo 'console.log (stringValue.slice (2, -20)); //' 'console.log (stringValue.slice (20)); //' 'console.log (stringValue.slice (-2,2)); //' 'console.log (stringValue.slice (-2, -20)); //' ' console.log (stringValue.slice (-2,20)); // 'lnd'console.log (stringValue.slice (-20,2)); //' he'console.log (stringValue.slice (-20, -2)); // 'bonjour wor'
La méthode Slice () implique la conversion de type implicite de la fonction de transformation nombre (). Lorsque le démarrage est converti en NAN, il est équivalent à démarrer = 0; Lorsque la fin est convertie en nan (sauf que la fin n'est pas définie), une chaîne vide est sortie
var stringValue = 'Hello World'; console.log (stringValue.slice (nan)); // 'bonjour world'console.log (stringValue.slice (0, nan)); // '' console.log (stringValue.slice (true, [3])); // 'el'console.log (stringValue.slice (null, undefined)); //' hello'console.log (strongvalue.slice (}); world'console.log (stringValue.slice ('2', [5])); // 'llo'【Substring ()】
La méthode substring (start, fin) nécessite deux paramètres de démarrage et de fin, qui renvoie une sous-chaîne dans cette chaîne du caractère en position de début à (mais ne contient pas) le caractère à la position finale; Si la fin n'est pas définie ou n'existe pas, il renvoie tous les caractères de la position de début à la fin de la chaîne
Si l'un ou l'autre paramètre est nan ou négatif, il est remplacé par 0
Si un paramètre est supérieur à la longueur de la chaîne, il est remplacé par la longueur de chaîne
Si le démarrage est supérieur à la fin, alors leurs valeurs sont échangées
var stringValue = 'Hello World'; console.log (stringValue.SubString ()); // 'Hello World'console.log (StringValue.SubString (2)); //' llo world'console.log (StringValue.substring (2, Undefined)); // 'llo llo world'console.log (StringValue.SubString (20)); // '' console.log (StringValue.SubString (-2,2)); // 'he'console.log (StringValue.s ubstring (nan, 2)); // 'he'console.log (StringValue.SubString (-2,20)); //' he'console.log (stringValue.Substring (-2,20)); // 'bonjour world'console.log (StringValue.SubString (3,2)); // 'L'Insole.log (StringValue.SubString (3, Nan)); //' Hel 'console.log (StringValue.SubString (-20,2)); //' He'console.log (StringValue.Substring (-20, -2)); // '' '' ''
De même, la méthode substring () implique également la conversion de type implicite de la fonction de transformation nombre ()
var stringValue = 'Hello World'; console.log (stringValue.SubString (true, [3])); // 'el'console.log (stringValue.substring (null, undefined)); //' Hello World'console.log (StringValue.SubString (Null, Undefined)); // 'Hello Hello world'console.log (StringValue.Substring ({})); // 'Hello World'console.log (StringValue.Substring (' 2 ', [5])); //' llo '【Substr ()】
La méthode substr (start, fin) nécessite deux paramètres de démarrage et de fin. La fin représente le nombre de caractères dans la sous-chaîne retournée; Cette méthode renvoie une sous-chaîne de caractères finaux à partir du caractère à la position de début dans cette chaîne; Si la fin n'est pas définie ou n'existe pas, il renvoie tous les caractères de la position de début à la fin de la chaîne
Si Start est un nombre négatif, démarrez = max (longueur + démarrage, 0)
Si le démarrage est nan, il est équivalent à démarrer = 0
Si la fin est un nombre négatif ou un nan, end = 0, donc une chaîne vide est renvoyée
Le démarrage et la fin ne peuvent pas échanger des positions
[Remarque] Cette méthode n'est pas la norme ECMAScript et a été obsolète
[Remarque] IE8-Le navigateur a un problème avec la gestion de la situation où les valeurs négatives sont transmises à substr (), il renvoie la chaîne d'origine
var stringValue = 'Hello World'; console.log (StringValue.substr ()); // 'Hello World'console.log (StringValue.substr (2)); //' llo world'console.log (StringValue.substr (2, Undefined)); // 'llo llo world'console.log (stringValue.substr (2, nan)); // '' console.log (stringValue.substr (nan, 2)); // 'he'console.log (stringValue.substr (20)); //' 'console.log (stringv alue.substr(-2,3));//'ld'console.log(stringValue.substr(-2,20));//'ld'console.log(stringValue.substr(-20,2));//''''''''''''''''''''''''''''''''''''''''''' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' ''. ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' console.log (StringValue.substr (2,5)); // llo w
De même, la méthode substr () implique également la conversion de type implicite de la fonction de transformation nombre ()
var stringValue = 'Hello World'; console.log (stringValue.substr (true, [3])); // 'el'console.log (stringValue.suStr (null, undefined)); //' hello world'console.log (stringvalue.substr ({})); // 'bonjour bonjour world'console.log (stringValue.substr ('2', [5])); // 'llo w'Position des cordes
Il existe deux façons de trouver l'emplacement des sous-chaînes à partir de chaînes: indexof () et lastIndexof ()
【Indexof ()】
La méthode indexof (SearchString, Start) reçoit deux paramètres: SearchString et Démarrer, renvoyant l'emplacement où la recherche apparaît d'abord, et si elle n'est pas trouvée, elle renvoie -1
Cette méthode appelle implicitement la fonction de transformation String () pour convertir la valeur de non-chaîne SearchString en chaîne; Appelle implicitement la fonction de transformation numéro () pour convertir le démarrage de la valeur non numérique (sauf non définie) en valeur numérique en valeur numérique
SearchString représente la sous-chaîne à rechercher; Démarrer représente la position de départ de la recherche. Si le paramètre est ignoré ou si le paramètre n'est pas défini, nan ou négatif, démarrez = 0
var string = 'Hello World World '; console.log (string.indexof (' ld ')); // 9Console.log (string.indexof (' ld ', indéfini)); // 9Console.log (string.indexof (' ld ', nan)); // 9console.log (string.indexof (' ld ', - 1)); // n 9Console.log (Sty ring.indexof ('ld', - 1)); // 9Console.log (string.indexof ('ld', - 1)); // 9Console.log (string.indexof ( 'ld', - 1)); // 9Console.log (String.Indexof ('ld', - 1)); // 9Console.log (String.Indexof ('ld', - 1)); // 9 console.log (string.indexof ('ld', 10)); // 15Console.log (string.indexof ('ld', [10])); // 15Console.log (string.index De ('true', [10])); // - 1Console.log (String.Indexof (false, [10])); // - 1Console.log (String.Indexof (false, [10])); // - 1【LastIndexof ()】
La méthode LastIndexof (SearchString, Start) reçoit deux paramètres: SearchString and Start, et renvoie la dernière fois que la recherche apparaît. S'il n'est pas trouvé, il revient -1
De même, cette méthode appelle implicitement la fonction de transformation String () pour convertir des valeurs de non-chaîne SearchString en chaînes; Appelle implicitement la fonction de transformation Number () pour convertir des valeurs non numériques de démarrage (sauf non définies) en valeurs numériques.
SearchString représente la sous-chaîne à rechercher; Démarrer représente la position de départ de la recherche. Si le paramètre est ignoré ou si le paramètre n'est pas défini ou nan, start = longueur - 1
[Remarque] Contrairement à la méthode indexof (), si le démarrage est négatif, la méthode renvoie -1
var string = 'Hello World World'; console.log (string.indexof ('ld')); // 9Console.log (string.indexof ('ld', indéfini)); // 9Console.log (String.Indexof ('ld', nan)); // 9Console.log (String.Indexof ('ld', - 1)); console.log (string.indexof ('ld', 10)); // 15Console.log (string.indexof ('ld', [10])); // 15Console.log (string.index De ('true', [10])); // - 1Console.log (String.Indexof (false, [10])); // - 1Console.log (String.Indexof (false, [10])); // - 1【Conseils】 Découvrez toutes les sous-chaînes qui répondent aux critères de la chaîne
Toutes les sous-chaînes correspondantes peuvent être trouvées par boucle pour appeler indexof () ou lastIndexof ()
fonction allindexof (str, valeur) {var result = []; var pos = str.indexof (valeur); while (pos> -1) {result.push (pos); pos = str.indexof (value, pos + value.length);} return result;} console.log (alindexof ('hellhellhell', 'll')); // [2,7,12]【garniture()】
Ecmascript5 définit la méthode TRIM () pour toutes les chaînes. Cette méthode crée une copie de la chaîne, supprime tous les caractères vides dans le préfixe et le suffixe, et renvoie le résultat
Puisque la méthode Trim () renvoie une copie de la chaîne, les espaces préfixes et suffixes dans la chaîne d'origine resteront inchangés
[Remarque] Ie8-Browser ne prend pas en charge
var string = 'Hello World'; console.log (string.trim ()); // 'Hello World'console.log (String); //' Hello World '
Les caractères d'espace blanc comprennent non seulement des espaces, mais aussi des caractères d'onglet (/ t), des pauses ligne (/ n) et des caractères de retour en voiture (/ r)
'/ r / nabc /t'.trim () //' ABC '
De plus, Firefox, Safari et WebKit prennent également en charge non standard TrimRight () pour la suppression des caractères blancs à la fin des cordes
var string = 'Hello World'; console.log (string.trimRight ()); // 'Hello World';
【TIPS】 Utilisez TRIM () pour déterminer si le caractère entré est vide
if (useName.trim (). length) {alert ('correct');} else {alert ('error');}【TIPS】 Simuler Trim () avec une expression régulière
fonction fntrim (str) {return str.replace (/ ^ / s + | / s + $ /, '')} console.log (fntrim ('hello world')); // 'bonjour world'Conversion de cas
Il y a quatre méthodes impliquées dans la conversion de cas de chaîne dans ECMascript: TolowerCase (), TolocaleLowerCase (), ToupperCase () et TolocAlAupcerase ()
TolowerCase () et ToupperCase () sont deux méthodes classiques, empruntées à la même méthode de nom dans java.lang.string. Les méthodes TolocalelolowerCase () et TolocaleupperCase () sont mises en œuvre pour des régions spécifiques. Pour certaines régions, la méthode des régions est la même que les résultats obtenus par leurs méthodes générales. Cependant, quelques langues (comme le turc) appliqueront des règles spéciales pour la conversion de cas Unicode. À l'heure actuelle, la méthode des régions doit être utilisée pour garantir que la conversion correcte est obtenue.
【Touppercase ()】
La méthode touppercase () convertit la chaîne en majuscules
【Tolowercase ()】
La méthode TolowerCase () convertit la chaîne en minuscules
【Tolocaleuppercase ()】
La méthode tolocaleupperase () convertit la chaîne en majuscules (pour la région)
【TolocaleLowerCase ()】
La méthode TolocaleLowerCase () convertit la chaîne en minuscules (pour la région)
[Remarque] Il est plus sûr d'utiliser une méthode spécifique à la région sans savoir dans quelle région de votre code s'exécutera.
var string = 'Hello World'; console.log (string.tolowercase ()); // bonjour worldconsole.log (string.tolocalelowercase ()); // hello worldconsole.log (string.touppercase ()); // bonjour worldconsole.log (string.tolocaleuppercase ()); // bonjour worldconsole
Ces 4 méthodes ne prennent pas en charge la conversion de type String () implicite, ne prennent en charge que les types de chaînes
(true) .tolowercase (); // signaler une erreur
(2) .TolocaleLowerCase (); // Signaler une erreur
({}). toupperase (); // signaler une erreur
([]). tolocaleupperase (); // signaler une erreur
[Remarque] La méthode de conversion de cas peut être utilisée en continu
var string = 'Hello World'; console.log ((String.ToupperCase ()). TolowerCase ()); // Hello World
【Localcompare ()】
La méthode localcompare () est utilisée pour comparer deux chaînes, en suivant les règles suivantes
[1] Si la chaîne doit être classée avant le paramètre de chaîne dans l'alphabet, un nombre négatif est retourné (principalement -1)
【2】 Si la chaîne est égale au paramètre de chaîne, retournez 0
【3】 Si la chaîne doit être placée après le paramètre de chaîne dans l'alphabet, un nombre positif sera retourné (dans la plupart des cas 1)
var stringValue = 'Yellow'; console.log (StringValue.LocaleCompare ('Brick')); // 1 'y'> 'b'console.log (StringValue.LocaleCompare (' Yellow ')); // 0' Yellow '==' Yellow'console.log (StringValue.LocaleCompare ('ZOO'); 'Zoo'[Remarque] Bien que des lettres majuscules de l'alphabet soient devant des lettres minuscules, donc des lettres majuscules <lettres minuscules. Mais la méthode localecompare () prendra en compte la situation de tri du langage naturel et classera «B» devant «A»
console.log ('b'.localecompare (' a ')); // 1console.log (' b '>' a '); // falseconsole.log (' b'.localecompare ('a')); // 1console.log ('b'> 'a'); // true 'Ce qui précède est la connaissance pertinente sur l'explication détaillée du type de chaîne de chaîne du système de type JavaScript qui vous est présenté par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!