Question Quelle est la différence entre String.slice et String.substring?


Est-ce que quelqu'un sait quelle est la différence entre ces deux méthodes:

String.slice
String.substring

582
2018-02-11 10:34


origine


Réponses:


slice() fonctionne comme substring() avec quelques comportements différents.

Syntax: string.slice(start, stop);
Syntax: string.substring(start, stop);

Ce qu'ils ont en commun:

  1. Si start équivaut à stop: renvoie une chaîne vide
  2. Si stop est omis: extrait les caractères à la fin de la chaîne
  3. Si l'un des arguments est supérieur à la longueur de la chaîne, la longueur de la chaîne sera utilisée à la place.

Distinctions de  substring():

  1. Si start > stop, puis substring échangera ces 2 arguments.
  2. Si l'un des arguments est négatif ou est NaN, il est traité comme s'il était 0.

Distinctions de  slice():

  1. Si start > stop, slice() NE permutera PAS les 2 arguments.
  2. Si start est négatif: définit char à la fin de la chaîne, exactement comme substr() dans Firefox. Ce comportement est observé dans Firefox et IE.
  3. Si stop est négatif: met l'arrêt à: string.length – Math.abs(stop) (valeur d'origine), sauf borné à 0 (donc, Math.max(0, string.length + stop)) couverts par Spécification ECMA.

La source: Art rudimentaire de la programmation et du développement: Javascript: substr () v.s. substring ()


652
2018-02-11 10:36



Note: si vous êtes pressé, et / ou recherchez une réponse courte, faites défiler vers le bas de la réponse et lisez les deux dernières lignes. Si vous n'êtes pas pressé, lisez le tout.


permettez-moi de commencer par énoncer les faits:

Syntaxe:
string.slice(start,end)
string.substr(start,length)
string.substring(start,end)
Note 1: slice()==substring()

Ce qu'il fait?
le slice() La méthode extrait des parties d'une chaîne et renvoie les parties extraites dans une nouvelle chaîne.
le substr() méthode extrait des parties d'une chaîne, en commençant par le caractère à la position spécifiée, et renvoie le nombre de caractères spécifié.
le substring() La méthode extrait des parties d'une chaîne et renvoie les parties extraites dans une nouvelle chaîne.
Note 2:slice()==substring()

Modifie la chaîne d'origine?
slice() Ne pas
substr() Ne pas
substring() Ne pas
Note 3:slice()==substring()

Utilisation de nombres négatifs en tant qu'argument:
slice() sélectionne les caractères à partir de la fin de la chaîne
substr()sélectionne les caractères à partir de la fin de la chaîne
substring() Ne fonctionne pas
Note 3:slice()==substr()==substr()

si le premier argument est plus grand que le second:
slice() Ne fonctionne pas
substr() puisque le second argument n'est PAS une position, mais une valeur de longueur, il fonctionnera comme d'habitude, sans problèmes
substring() va échanger les deux arguments, et effectuer comme d'habitude

le premier argument:
slice() Obligatoire, indique: Index de départ
substr() Obligatoire, indique: Index de départ
substring() Obligatoire, indique: Index de départ
Note # 4:slice()==substr()==substring()

le deuxième argument:
slice() Facultatif, La position (jusqu'à, mais sans inclure) où terminer l'extraction
substr() Facultatif, Le nombre de caractères à extraire
substring() Facultatif, La position (jusqu'à, mais sans inclure) où terminer l'extraction
Note # 5:slice()==substring()

Que faire si le deuxième argument est omis?
slice() sélectionne tous les caractères de la position de départ à la fin de la chaîne
substr() sélectionne tous les caractères de la position de départ à la fin de la chaîne
substring() sélectionne tous les caractères de la position de départ à la fin de la chaîne
Note # 6:slice()==substr()==substring()

donc, vous pouvez dire qu'il y a une différence entre slice() et substr(), tandis que substring() est essentiellement une copie de slice().

En résumé:
si vous connaissez l'index (la position) sur lequel vous allez vous arrêter (mais pas inclure), utilisez slice()
Si vous connaissez la longueur des caractères à extraire, utilisez substr().


66
2017-08-10 01:58



Ben Nadel a écrit un bon article à ce sujet, il souligne la différence dans les paramètres de ces fonctions:

String.slice( begin [, end ] )
String.substring( from [, to ] )
String.substr( start [, length ] )

Il souligne également que si les paramètres à découper sont négatifs, ils référencent la chaîne depuis la fin. La sous-chaîne et la sous-chaîne ne le sont pas.

Voici son article à ce sujet http://www.bennadel.com/blog/2159-using-slice-substring-and-substr-in-javascript.htm


18
2017-12-05 16:11



La seule réponse est bien, mais nécessite un peu de lecture. Surtout avec la nouvelle terminologie "stop".

My Go - organisé par des différences pour le rendre utile en plus de la première réponse de Daniel ci-dessus:

1) indices négatifs. La sous-chaîne requiert des index positifs et mettra un index négatif à 0. L'index natif de Slice indique la position à partir de la fin de la chaîne.

"1234".substring(-2, -1) == "1234".substring(0,0) == ""
"1234".slice(-2, -1) == "1234".slice(2, 3) == "3"

2) Échange d'index. La sous-chaîne réorganisera les index pour que le premier index soit inférieur ou égal au second index.

"1234".substring(3,2) == "1234".substring(2,3) == "3"
"1234".slice(3,2) == ""

--------------------------

Commentaire général - Je trouve bizarre que le deuxième index soit la position après le dernier caractère de la tranche ou de la sous-chaîne. Je m'attendrais "1234" .slice (2,2) à retourner "3". Cela rend la confusion d'Andy ci-dessus justifiée - je m'attendrais à ce que "1234" .slice (2, -1) renvoie "34". Oui, cela signifie que je suis nouveau sur Javascript. Cela signifie également ce comportement:

"1234".slice(-2, -2) == "", "1234".slice(-2, -1) == "3", "1234".slice(-2, -0) == "" <-- you have to use length or omit the argument to get the 4.
"1234".slice(3, -2) == "", "1234".slice(3, -1) == "", "1234".slice(3, -0) == "" <-- same issue, but seems weirder.

Mon 2c.


9
2018-06-04 14:32



La différence entre la sous-chaîne et la tranche - est de savoir comment ils fonctionnent avec des arguments négatifs et en ignorant les lignes à l'étranger:

sous-chaîne (début, fin)

Les arguments négatifs sont interprétés comme zéro. Les valeurs trop grandes sont tronquées à la longueur de la chaîne:     alert ("testme" .substring (-2)); // "testme", -2 devient 0

En outre, si start> end, les arguments sont interchangés, c'est-à-dire que la ligne de tracé retourne entre le début et la fin:

alert ( "testme" .substring (4, -1)); // "test"
// -1 Becomes 0 -> got substring (4, 0)
// 4> 0, so that the arguments are swapped -> substring (0, 4) = "test"

tranche

Les valeurs négatives sont mesurées à partir de la fin de la ligne:

alert ( "testme" .slice (-2)); // "me", from the end position 2
alert ( "testme" .slice (1, -1)); // "estm", from the first position to the one at the end.

C'est beaucoup plus pratique que l'étrange sous-chaîne logique.

Une valeur négative du premier paramètre à substr supporté dans tous les navigateurs sauf IE8-.

Si le choix de l'une de ces trois méthodes, pour une utilisation dans la plupart des situations - il sera tranche: arguments négatifs et il maintient et fonctionne le plus évident.


9
2018-02-05 14:32



-------------------------------------- Différences --------------------------------------

String.prototype.slice

Traitement des indices négatifs

  • " Si [soit l'argument est] négatif, il est traité comme strLength + [index] où strLength est la longueur de la chaîne (par exemple, si [index] est -3 il est traité comme strLength - 3). "

Indice de départ supérieur à l'indice de fin

  • " Si [l'indice de départ] est supérieur à ou égal au [traitement de l'index de fin] du [tranche de ficelle], slice() retourne une chaîne vide. "

    - MDN


String.prototype.substring

Traitement des indices négatifs

  • " Si l'un des arguments est [négatif] [...], il est traité comme s'il était 0. "

Indice de départ supérieur à l'indice de fin

  • " Si [l'indice de départ] est supérieur à [l'index de fin], puis le
     effet de substring() est comme si les deux arguments étaient échangés; par exemple, str.substring(1, 0) == str.substring(0, 1). "

    - MDN

-------------------------------------- Similitudes --------------------------------------

Tout le reste est le même, je pense, y compris:

  • Si un index de fin l'argument est undefined, il devient la longueur de la chaîne.
  • Arguments qui ne sont pas des nombres et ne peuvent pas être contraints à des chiffres deviennent 0.

* Ce qui précède est également vrai pour le substr() méthode, sauf substr() n'a pas d'argument d'index de fin.

------------------------------------------ Remarques ------------------------------------------

String.prototype.substr

[légèrement au-delà de la portée de la question]

  • String.prototype.substr est très semblable slice(), en particulier en ce qui concerne le traitement des nombres négatifs pour les valeurs d'indice; Cependant, la différence clé est que substr()Le deuxième argument ne spécifie pas d'index de fin, mais la longueur des caractères que l'appelant veut renvoyer. Il suffit de dire que substr() se comporte aussi prévisible que slice() fait au-delà de cette différence clé; passer un négatif length argument renvoie une chaîne vide avec cette méthode.


8
2017-08-01 07:55



La seule différence entre la méthode slice et la sous-chaîne est celle des arguments

Les deux prennent deux arguments, par ex. start / from et fin / à.

Vous ne pouvez pas passer une valeur négative comme premier argument pour sous-chaîne méthode mais pour tranche méthode pour le traverser depuis la fin.

Détails de l'argument de la méthode Slice:

REF: http://www.thesstech.com/javascript/string_slice_method

Arguments

start_index Index à partir duquel la tranche devrait commencer. Si la valeur est fournie en négatif, cela signifie partir du dernier. par exemple. -1 pour le dernier caractère. end_index Index après la fin de la tranche. Si non fourni, la tranche sera prise de start_index à la fin de la chaîne. En cas d'indice de valeur négatif sera mesurée à partir de la fin de la chaîne.

Détails de l'argument de la méthode de sous-chaîne:

REF: http://www.thesstech.com/javascript/string_substring_method

Arguments

de Ce devrait être un entier non négatif pour spécifier l'index à partir duquel la sous-chaîne devrait commencer. à Un entier facultatif non négatif pour fournir l'index avant quelle sous-chaîne devrait être terminée.


2
2018-05-24 13:37



Pour slice (start, stop), si stop est négatif, stop sera défini sur: string.length - Math.abs (stop), plutôt (string.length - 1) - Math.abs (stop).


0
2018-03-29 05:32