Quelle est la différence entre la Chaîne.tranche et de la Corde.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 égale 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 ou l'autre des arguments est supérieur à la longueur de la chaîne, La longueur de la chaîne sera utilisé à la place.

les Distinctions de substring() :

1. Si start > stop , puis substring échange de ces 2 arguments.
2. si l'un ou l'autre 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 sera PAS intervertir les 2 arguments.
2. Si start est négatif: jeux de caractères à partir de la fin de la chaîne, exactement comme substr() dans Firefox. Ce comportement est observé chez Firefox et IE.
3. si stop est négatif: définit stop à: string.length – Math.abs(stop) (valeur originale), sauf limité à 0 (donc, Math.max(0, string.length + stop) ) tel que couvert par la spécification ECMA .

Source: rudimentaire Art of Programming & Development: Javascript: substr () v. S. substrat ()

Note: Si vous êtes pressé, et/ou à la recherche de réponse courte, faites défiler la réponse au bas de la page, et lisez les deux dernières lignes.si ce n'est pas pressé, lisez 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()

Qu'est-ce que ça fait?

La méthode slice() extrait des parties d'une chaîne et renvoie les parties extraites dans une nouvelle chaîne.

La méthode substr() extrait des parties d'une chaîne, en commençant par le caractère à la position spécifiée, et renvoie le nombre spécifié de caractères.

La méthode substring() extrait des parties d'une chaîne et renvoie les parties extraites dans une nouvelle chaîne.

Note #2: slice()==substring()

change la chaîne D'origine?

slice() N'est pas

substr() N'est pas

substring() N'est pas

Note #3: slice()==substring()

utilisant des nombres négatifs comme Argument:

slice() sélectionne les caractères à partir de la fin de la chaîne de caractères

substr() sélectionne des caractères à partir de la fin de la chaîne

substring() Ne fonctionne pas

Note #3: slice()==substr()

si le Premier Argument est Plus grand que le Second:

slice() Ne pas Effectuer de

substr() depuis le Second Argument n'est PAS une position, mais la longueur de la valeur, il fonctionnera comme d'habitude, pas de problèmes

substring() échange les deux arguments, et procéder comme d'habitude

le premier Argument:

slice() obligatoire, indique: commençant L'Index

substr() requis, indique: commençant L'Index

substring() requis, indique: commençant L'Index

Note #4: slice()==substr()==substring()

le deuxième Argument:

slice() Optionnel, La position (jusqu'à, mais sans inclure) où terminer l'extraction

substr() optionnel, le nombre de caractères pour extraire

substring() optionnel, La position (jusqu'à, mais sans inclure) où terminer l'extraction

Note #5: slice()==substring()

que se passe-t-il si le second Argument est omis?

slice() sélectionne tous les caractères de la position de départ à la position de départ. la fin de la chaîne

substr() sélectionne tous les caractères de la start-position à la fin de la chaîne

substring() sélectionne tous les caractères de la start-position à 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() , alors que substring() est essentiellement une copie de slice() .

En résumé:

si vous connaissez l'index(la position) sur lequel vous vous arrêterez (mais non inclus), 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 fait aussi remarquer que si les paramètres à trancher sont négatifs, ils renvoient la chaîne du bout. Sous-couche et sous-couche.

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

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

Mon Aller-organisée par les différences de le rendre utile, en plus de la première réponse de Daniel:

1) indices négatifs. La soustraction requiert des indices positifs, et définira un indice négatif à 0. L'indice nagatif 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) oscillation index. La soustraction permet de réorganiser les indices de manière à ce que le premier indice soit inférieur ou égal au second.

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

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

commentaire général -- je trouve bizarre que le second indice soit la position après le dernier caractère de la tranche ou de la chaîne. Je m'attendais à "1234".trancher (2,2) pour retourner "3". Cela rend la confusion D'Andy plus que justifiée -- Je m'attendrais à "1234".tranche (2, -1) pour retourner "34". Oui, cela signifie que Je suis nouveau au Javascript. Cela signifie aussi 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 les sous-chaîne et de la tranche - est de savoir comment ils travaillent avec des négatifs et donnant sur des lignes à l'étranger arguments:

substring (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".substrat (-2)); / / "testme", -2 devient 0

en outre, si start > end, les arguments sont interchangés, i.e. intrigue retours 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 substrat logique.

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

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

La seule différence entre la tranche et de la sous-chaîne de la méthode est d'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 substring mais pour la méthode tranche pour la traverser de la fin.

Tranche argument d'une méthode de détails:

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

Arguments

start_index Index du point de départ de slice. Si la valeur est indiquée en négatif, cela signifie commencer à partir de la dernière. par exemple, -1 pour le dernier caractère. end_index Index après l'extrémité de la tranche. S'il n'est pas fourni, slice sera pris de start_index à end of string. En cas de valeur négative de l'indice sera mesurée à partir de la fin de la chaîne.

détails de l'argument de la méthode de soustraction:

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 optionnel non négatif à fournir index avant lequel la sous-chaîne doit être terminée.

Pour la tranche(start, stop), si l'arrêt est négatif, arrêt sera fixé à: chaîne de caractères.longueur de Math.abs(arrêt), plutôt (chaîne de caractères.longueur – 1) – Math.abs(arrêt).