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

Quelqu'un sait-il quelle est la différence entre ces deux méthodes?

String.prototype.slice
String.prototype.substring

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égal stop: renvoie une chaîne vide
2. Si stopest 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, alors substringpermutera ces 2 arguments.
2. Si l'un ou l'autre argument est négatif ou l'est NaN, il est traité comme s'il l'était 0.

Distinctions de :slice()

1. Si start > stop, slice()renverra la chaîne vide. ( "")
2. Si startest négatif: définit char à partir de la fin de la chaîne, exactement comme substr()dans Firefox. Ce comportement est observé à la fois dans Firefox et IE.
3. Si stopest négatif: définit l'arrêt sur: string.length – Math.abs(stop)(valeur d'origine), sauf limité à 0 (donc Math.max(0, string.length + stop)), comme indiqué dans la spécification ECMA .

Source: Art rudimentaire de la programmation et du développement: Javascript: substr () vs substring ()

Remarque: si vous êtes pressé et / ou recherchez une réponse courte, faites défiler jusqu'au 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)
Remarque n ° 1:slice()==substring()

Ce qu'il fait?
La slice()méthode extrait des parties d'une chaîne et renvoie les parties extraites dans une nouvelle chaîne.
La 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é.
La substring()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
substr()fait pas
substring()ne
note pas # 3:slice()==substring()

Utilisation de nombres négatifs comme 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
Remarque # 3:slice()==substr()

si le premier argument est supérieur au second:
slice()ne fonctionne pas
substr()car le deuxième argument n'est PAS une position, mais une valeur de longueur, il fonctionnera comme d'habitude, sans aucun problème
substring(), échangera les deux arguments et fonctionnera comme d'habitude

le Premier Argument:
slice()Obligatoire, indique: Index de Démarrage
substr()Obligatoire, indique: Index de Démarrage
substring()Obligatoire, indique: Index de Démarrage
Note # 4:slice()==substr()==substring()

le deuxième argument:
slice()facultatif, la position (jusqu'à, mais non compris) où terminer l'extraction
substr()facultative, le nombre de caractères à extraire
substring()facultatif, la position (jusqu'à, mais non inclus) où terminer l'extraction
Remarque # 5:slice()==substring()

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

Donc, vous pouvez dire qu'il y a une différence entre slice()et substr(), alors qu'il substring()s'agit essentiellement d'une copie de slice().

en résumé:
si vous connaissez l'index (la position) sur laquelle vous vous arrêterez (mais ne l'incluez pas), utilisez slice()
si vous connaissez la longueur des caractères à extraire, utilisez substr().

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 le substrat ne le font pas.

Voici son article à ce sujet.

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

My Go - organisé par 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 nécessite des index positifs et définira un index négatif à 0. L'index négatif de Slice signifie 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 rendre le premier index inférieur ou égal au deuxième 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 à ce que "1234" .slice (2,2) renvoie "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.

La différence entre la sous-chaîne et la tranche - est la façon dont ils fonctionnent avec les arguments négatifs et les lignes de vue à l'étranger:

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

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

De plus, si début> fin, les arguments sont échangé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 pris en charge 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 - ce sera tranche : arguments négatifs et il maintient et fonctionne le plus évident.

substr: Il nous permet de récupérer une partie de la chaîne en fonction de l'index spécifié. syntaxe de substr- string.substr (start, end) start - l'index de départ indique où commence la récupération. end - end index indique jusqu'à où la chaîne est récupérée. C'est facultatif.

tranche: Il s'agit de récupérer une partie de la chaîne en fonction de l'index spécifié. Cela nous permet de spécifier positif et index. La syntaxe de slice - string.slice (start, end) start - start index indique où commence la récupération. L'indice end - end indique jusqu'à où la chaîne est récupérée. C'est facultatif. Dans «splice», les indices de début et de fin permettent de prendre des indices positifs et négatifs.

exemple de code pour «tranche» dans la chaîne

var str="Javascript";
console.log(str.slice(-5,-1));

output: crip

exemple de code pour «sous-chaîne» dans une chaîne

var str="Javascript";
console.log(str.substring(1,5));

output: avas

[* Remarque: l'indexation négative commence à la fin de la chaîne.]

La seule différence entre la méthode slice et substring réside dans les arguments

Les deux prennent deux arguments, par exemple start / from et end / to.

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

Détails des arguments de la méthode Slice:

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

Arguments

start_index Index à partir duquel la tranche doit commencer. Si la valeur est fournie en négatif, cela signifie commencer à 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 de valeur négative, l'indice sera mesuré à 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

from Il doit s'agir d'un entier non négatif pour spécifier l'index à partir duquel la sous-chaîne doit commencer. to Un entier non négatif facultatif pour fournir un index avant lequel la sous-chaîne doit être terminée.

Car slice(start, stop), s'il stopest négatif, stopsera réglé sur:

string.length – Math.abs(stop)

plutôt que:

string.length – 1 – Math.abs(stop)