Quelle est la différence entre la Chaîne.tranche et de la Corde.sous-chaîne?

Personne ne sait quelle est la différence entre ces deux méthodes:

String.prototype.slice
String.prototype.substring

C'est un exemple de la mauvaise conception de JavaScript que nous nous sommes retrouvés avec trois méthodes que tous font la même chose, mais avec d'autres bizarreries. OMI slice est celui avec le moins de comportements inattendus.
L'OMI sous-chaîne lorsqu'elle est utilisée pour prendre une sous-chaîne à partir idx jusqu'à la fin est plus compréhensible en un coup d'œil. Surtout pour les noobs
Selon ce site, slice peut réellement remplacer substring et il n'y a pas de raison de l'utiliser.
Le slice & substring méthodes sont toutes plus le même, sauf que les slice() accepte un indice négatif, par rapport à la fin de la chaîne, mais pas le substring, il jette out-of-bound erreur
Pas vrai du tout. Si vous essayez var a = "asdf".substring(-1);, il est considéré comme var a = "asdf".substring(0);. Il n'y a aucune exception n'est levée. Et si vous utilisez var a = "asdf".substring(2, -1);, il utilise 0 en place de -1 (comme avant), et les swaps, les arguments de sorte qu'il agit comme var a = "asdf".substring(0, 2);. J'ai même essayé sur IE 8 et a obtenu les résultats sans exceptions
"J'ai même essayé sur IE 8" - j'aime la programmation.

InformationsquelleAutor tmim | 2010-02-11

786

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 est égal à stop: retourne une chaîne vide
2. Si stop est omis: extraits de caractères à la fin de la chaîne
3. Si l'argument est plus grand que 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 échange de ces 2 arguments.
2. Si l'argument est négatif ou est NaN, elle est traitée comme si elle était 0.
Distinctions de slice():
1. Si start > stop, slice() retournera la chaîne vide. ("")
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é dans IE et Firefox.
3. Si stop est négatif: jeux de stop pour: string.length – Math.abs(stop) (valeur d'origine), à l'exception délimitée à 0 (donc, Math.max(0, string.length + stop)) dans les cas visés à l' Spécification ECMA.
Source: Rudimentaire, l'Art de la Programmation & Développement: Javascript: substr() c. s. substring()
- Dans votre dernière remarque sur slice(), il devrait être string.length - stop
- Dans votre dernière remarque sur slice(), je pense qu'il devrait être (string.length – 1) + stop ou, pour le rendre clair que c'est négatif, (string.length – 1) – Math.abs(stop)
- a été ajouté, de sorte qu'une méthode de chaîne cohérente de Array.slice. substring a toujours été là, donc, ils n'ont pas le casser et a ajouté une autre méthode. À peine une merde décision 1. la cohérence est gentil et 2. il permet de CoffeeScript du découpage de la syntaxe de travailler sur des tableaux et chaînes de caractères. @Oriol: édité dans.
- Il semble qu'il ya une différence de performance entre les sous-chaîne et de la tranche dans Firefox 22. jsperf.com/string-slice-vs-substring
- Ils sont également rapidement dans Chrome à partir de Mai 2014.
- J'aime la façon dont substring permet interchangeables arguments.
- Andy était à droite. stop sera mis à string.length + stop si stop est négatif. Rappelez-vous stop est l'indice après le dernier caractère extrait!
- Vous devriez vraiment le modifier. C'est faux.
- Il ressemble point 5 sur substr est incorrecte, selon SOCIÉTÉ: "Si le départ est négatif, substr() utilise comme un caractère d'index à partir de la fin de la chaîne. Si start est négatif et abs(start) est plus grande que la longueur de la chaîne, substr() utilise 0 comme l'index de début."
- La dernière remarque est vraiment incorrect. Il devrait être string.length - Math.abs(stop). Rappelez-vous, faire slice(0, -1) supprime uniquement le dernier char, alors que, selon votre note, il serait de supprimer les deux!
- Pouvons-nous avoir un modérateur, veuillez modifier le dernier #3 point dans la réponse ci-dessus? Il est, de façon vérifiable, incorrect, mais l'auteur n'est pas de le fixer. La preuve: "abc".slice(0, -1) est égal à "ab", PAS "a" que sa réponse indique.
- Wow, comment se fait personne n'a remarqué que jusqu'à présent? L'énoncé "Si start > stop, slice() retournera la chaîne vide" est erroné. Par exemple: 4 > -1, mais "babayaga".slice(4, -1) retourne "yag".
InformationsquelleAutor Daniel Vassallo
86

Remarque: si vous êtes pressé, et/ou à la recherche de réponse courte défiler vers le bas de la réponse, et de lire les deux dernières lignes.si Pas pressé de lire la totalité de la chose.

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() méthode des extraits des parties d'une chaîne de caractères et renvoie les parties extraites dans une nouvelle chaîne de caractères.

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

Le substring() méthode des extraits des parties d'une chaîne de caractères et renvoie les parties extraites dans une nouvelle chaîne de caractères.

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

Modifications de la Chaîne d'Origine?

slice() N'est pas

substr() N'est pas

substring() N'est pas

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

En utilisant les Nombres Négatifs comme Argument:

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

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

substring() Ne pas Effectuer

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

si le Premier Argument est Plus grand que le Second:

slice() Ne pas Effectuer

substr() depuis le Deuxième 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: l'Indice de Départ

substr() Obligatoire, indique: l'Indice de Départ

substring() Obligatoire, indique: l'Indice de Départ

Note n ° 4:slice()==substr()==substring()

le Deuxième Argument:

slice() En option, La position (jusqu'à, mais non compris) où à la fin de l'extraction

substr() En option, Le nombre de caractères à extraire

substring() En option, La position (jusqu'à, mais non compris) où à la fin de l'extraction

Note n ° 5:slice()==substring()

Que si le Deuxième Argument est Omis?

slice() sélectionne tous les caractères de la start-position à 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 n ° 6:slice()==substr()==substring()

ainsi, vous pouvez dire qu'il ya 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), l'Utilisation slice()

si vous connaissez la longueur de l'extraction de caractères utiliser substr().
- substr() ne doit pas être utilisé developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
InformationsquelleAutor Waddah
22

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 de tranche sont négatives, elles font référence à la chaîne à partir de la fin. Sous-chaîne et de substr ne marche pas.

Voici son article à propos de ce http://www.bennadel.com/blog/2159-using-slice-substring-and-substr-in-javascript.htm
- Ceci est incorrect, substr ne poignée de paramètres négatifs. '0123456789'.substr(-3, 2) -> '78'
InformationsquelleAutor Jón Viðar Þorsteinsson
11

La réponse est bien, mais nécessite un peu de lecture en. 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 ci-dessus:

1) des index négatifs. Sous-chaîne nécessite positif index et permettra de définir un indice négatif à 0. La tranche d'indice négatif signifie que 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) la Permutation des indices. Sous-chaîne va réorganiser les indices de faire le premier indice est inférieure ou égale à la deuxième indice.
```
"1234".substring(3,2) == "1234".substring(2,3) == "3"
"1234".slice(3,2) == ""
```
--------------------------

Observation générale -- je trouve ça bizarre que le second indice est la position après le dernier caractère de la tranche ou la sous-chaîne. Je m'attends à "1234".tranche(2,2) pour revenir à "3". Cela rend Andy confusion au-dessus justifiée-je en droit d'attendre "1234".tranche(2, -1) pour revenir "34". Oui, cela signifie que je suis nouveau sur le Javascript. Cela signifie également ce problème:
```
"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.

InformationsquelleAutor Gerard ONeill
10

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)

Arguments négatifs sont interprétés comme zéro. Des valeurs trop importantes sont tronqués à la longueur de la chaîne:

alert ( "testme" .substring (-2)); //"testme", -2 devient 0

En outre, si démarrer > fin de compte, les arguments sont échangés, c'est à dire 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.
```
Il est beaucoup plus pratique que la logique étrange de sous-chaîne.

Négative de la valeur 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, il sera tranche: arguments négatifs et il maintient et exploite la plus évidente.

InformationsquelleAutor Alexandr
3

La seule différence entre la tranche et de la sous-chaîne de la méthode est d'arguments

À la fois prendre deux arguments, par exemple, commencer à/de et de fin/d'.

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

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

RÉF.:
http://www.thesstech.com/javascript/string_slice_method

Arguments

start_index
Index d'où la tranche devrait commencer. Si la valeur est fournie dans la négative, cela signifie commencer à partir de la dernière. par exemple, -1 pour le dernier caractère.
end_index
Indice après la fin de la tranche. Si elle ne vient pas de tranche seront prises à partir de start_index à la fin de la chaîne. En cas de valeur négative de l'indice sera mesurée à partir de la fin de la chaîne.

Sous-chaîne argument d'une méthode de détails:

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

Arguments

de
Il doit être un entier non négatif pour spécifier l'index à partir d'où les sous-chaîne doit commencer.
à
Une option non entier négatif pour fournir de l'index avant de la sous-chaîne doit être terminé.

InformationsquelleAutor Sohail Arif
2

substr: C'est à nous d'aller chercher une partie de la chaîne basé sur l'index spécifié.
la syntaxe de substr-
chaîne de caractères.substr(début,fin)
start - démarrage de l'indice indique où la récupération de départ.
de bout en bout de l'index indique jusqu'où la chaîne extrait. C'est facultatif.

tranche: C'est pour récupérer une partie de la chaîne basé sur l'index spécifié. Il nous permet de spécifier positive et l'index.
la syntaxe de la tranche - chaîne.tranche(début,fin)
start - démarrage de l'indice indique où la récupération de départ.C'est
de bout en bout de l'index indique jusqu'où la chaîne extrait. C'est facultatif.
Dans "splice" à la fois début et de fin de l'index permet de prendre le positif et le négatif de l'indice.

exemple de code pour "tranche" dans la chaîne de
```
var str="Javascript";
console.log(str.slice(-5,-1));

output: crip
```
exemple de code pour "substring" dans la chaîne de
```
var str="Javascript";
console.log(str.substring(1,5));

output: avas
```
[*Note: négative de l'indexation commence à la fin de la chaîne.]

InformationsquelleAutor subham ruj
0

Pour slice(start, stop), si stop est négatif, stop sera fixé à:
```
string.length – Math.abs(stop)
```
plutôt que:
```
string.length – 1 – Math.abs(stop)
```
InformationsquelleAutor tingxuanz

Vous devez vous connecter pour publier un commentaire.

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