Le Javascript splice
ne fonctionne qu'avec des tableaux. Existe-t-il une méthode similaire pour les chaînes? Ou devrais-je créer ma propre fonction personnalisée?
Les méthodes substr()
, et substring()
renverront uniquement la chaîne extraite et ne modifieront pas la chaîne d'origine. Ce que je veux faire, c'est supprimer une partie de ma chaîne et appliquer la modification à la chaîne d'origine. De plus, la méthode replace()
ne fonctionnera pas dans mon cas car je souhaite supprimer des parties en commençant par un index et se terminant à un autre index, exactement comme ce que je peux faire avec la splice()
méthode. J'ai essayé de convertir ma chaîne en tableau, mais ce n'est pas une bonne méthode.
javascript
ProllyGeek
la source
la source
str.split
peut-être la fonction que vous recherchez: google.com/#q=javascript+string+splitstr = str.slice()
?return string.slice(0, startToSplice) + string.slice(endToSplice);
, non?Réponses:
Il est plus rapide de couper la chaîne deux fois, comme ceci:
function spliceSlice(str, index, count, add) { // We cannot pass negative indexes directly to the 2nd slicing operation. if (index < 0) { index = str.length + index; if (index < 0) { index = 0; } } return str.slice(0, index) + (add || "") + str.slice(index + count); }
que d'utiliser un fractionnement suivi d'une jointure (méthode de Kumar Harsh), comme ceci:
function spliceSplit(str, index, count, add) { var ar = str.split(''); ar.splice(index, count, add); return ar.join(''); }
Voici un jsperf qui compare les deux méthodes et quelques autres. (jsperf est en panne depuis quelques mois maintenant. Veuillez suggérer des alternatives dans les commentaires.)
Bien que le code ci-dessus implémente des fonctions qui reproduisent la fonctionnalité générale de
splice
, l'optimisation du code pour le cas présenté par le demandeur (c'est-à-dire, n'ajouter rien à la chaîne modifiée) ne change pas les performances relatives des différentes méthodes.la source
String.prototype.splice = function (index, count, add) { return this.slice(0, index) + (add || "") + this.slice(index + count); }
Gardez simplement à l'esprit que cela ne fonctionne pas exactement de la même manière que la méthode d'épissure de tableau car les chaînes sont immuables (vous ne pouvez pas les modifier une fois créées). Donc, l'utilisation serait comme:var s="ss"; s = s.splice(0,1,"t");
var StringUtils={'StringSplice':/*func def*/};
serait standard pour la manipulation de chaînes car vous avez dit qu'elle est immuable.Éditer
Ce n'est bien sûr pas la meilleure façon d '"épisser" une chaîne, j'avais donné ceci comme exemple de la façon dont l'implémentation serait, ce qui est imparfait et très évident à partir d'un split (), splice () et join (). Pour une mise en œuvre bien meilleure, voir la méthode de Louis .
Non, il n'existe pas de a
String.splice
, mais vous pouvez essayer ceci:newStr = str.split(''); // or newStr = [...str]; newStr.splice(2,5); newStr = newStr.join('');
Je me rends compte qu'il n'y a pas de
splice
fonction comme dans les tableaux, vous devez donc convertir la chaîne en un tableau. Pas de veine...la source
"asdsd".indexOf('s');
[...str]
Voici un joli petit curry qui donne une meilleure lisibilité (IMHO):
La signature de la deuxième fonction est identique à la
Array.prototype.splice
méthode.function mutate(s) { return function splice() { var a = s.split(''); Array.prototype.splice.apply(a, arguments); return a.join(''); }; } mutate('101')(1, 1, '1');
Je sais qu'il existe déjà une réponse acceptée, mais j'espère que cela sera utile.
la source
'method'
paramètre facultatif afin que vous puissiez passer unArray.prototype[method]
et traiter les chaînes comme des tableaux. De plus, avec celui - ci seul, vous pourriez abstraire le processus réel à une autre fonction - et s'il n'y a pas de chaîne, le retour d' une fonction qui prendra la chaîne et d' inverser le curry:mutate()(1, 1, '1')('101')
; Vous pouvez même duckType les arguments pour débarrasser le curry de l'invocation vide - même encapsuler une méthode, elle-même. Si vous avez besoin de ce matériel, vous voudrez peut-être examiner le modèle de commande . Juste des crachats ici.Je voudrais proposer une alternative plus simple aux méthodes Kumar / Cody et Louis. Sur tous les tests que j'ai effectués, il fonctionne aussi vite que la méthode Louis (voir les tests de violon pour les benchmarks).
String.prototype.splice = function(startIndex,length,insertString){ return this.substring(0,startIndex) + insertString + this.substring(startIndex + length); };
Vous pouvez l'utiliser comme ceci:
var creditCardNumber = "5500000000000004"; var cardSuffix = creditCardNumber.splice(0,12,'****'); console.log(cardSuffix); // output: ****0004
Voir les résultats du test: https://jsfiddle.net/0quz9q9m/5/
la source
, otherwise the third argument is not optional. This implementation also doesn't take care of
startIndex <0` contrairement aux autres suggestions. Excellent exemple d'utilisation, cependantIl semble y avoir beaucoup de confusion qui n'a été abordée que dans les commentaires d'elclanrs et de raina77ow, alors permettez-moi de poster une réponse clarifiant.
Clarification
De "
string.splice
" on peut s'attendre à ce que, comme celui des tableaux:Le problème est que l'exigence 3d ne peut pas être remplie car les chaînes sont immuables (liées: 1 , 2 ), j'ai trouvé le commentaire le plus dédié ici :
Donc, avec cela en compte, on peut s'attendre à ce que la
string.splice
chose " " soit seulement:qui est ce que
substr
fait; Ou bien,qui fait l'objet de la section suivante.
Solutions
Si vous vous souciez de l'optimisation, vous devriez probablement utiliser l'implémentation de Mike:
String.prototype.splice = function(index, count, add) { if (index < 0) { index += this.length; if (index < 0) index = 0; } return this.slice(0, index) + (add || "") + this.slice(index + count); }
Cependant, le traitement de l'indice hors limites peut varier. Selon vos besoins, vous voudrez peut-être:
if (index < 0) { index += this.length; if (index < 0) index = 0; } if (index >= this.length) { index -= this.length; if (index >= this.length) index = this.length - 1; }
ou même
index = index % this.length; if (index < 0) index = this.length + index;
Si vous ne vous souciez pas des performances, vous voudrez peut-être adapter la suggestion de Kumar qui est plus simple:
String.prototype.splice = function(index, count, add) { var chars = this.split(''); chars.splice(index, count, add); return chars.join(''); }
Performance
La différence de performances augmente considérablement avec la longueur de la corde. jsperf montre que pour les chaînes d'une longueur de 10, la dernière solution (division et jointure) est deux fois plus lente que la première solution (en utilisant slice), pour les chaînes de 100 lettres, c'est x5 et pour les chaînes de 1000 lettres, c'est x50, dans Ops / sec c'est:
10 letters 100 letters 1000 letters slice implementation 1.25 M 2.00 M 1.91 M split implementation 0.63 M 0.22 M 0.04 M
notez que j'ai changé les 1er et 2ème arguments en passant de 10 lettres à 100 lettres (je suis toujours surpris que le test pour 100 lettres soit plus rapide que pour 10 lettres).
la source
Utilisez simplement substr pour la chaîne
ex.
var str = "Hello world!"; var res = str.substr(1, str.length);
Résultat = bonjour le monde!
la source
Ainsi, quelle que soit l'ajout de la méthode d'épissure à un prototype String ne peut pas fonctionner de manière transparente aux spécifications ...
Faisons une extension:
String.prototype.splice = function(...a){ for(var r = '', p = 0, i = 1; i < a.length; i+=3) r+= this.slice(p, p=a[i-1]) + (a[i+1]||'') + this.slice(p+a[i], p=a[i+2]||this.length); return r; }
la source
La méthode Réponse de Louis , en tant que
String
fonction prototype:String.prototype.splice = function(index, count, add) { if (index < 0) { index = this.length + index; if (index < 0) { index = 0; } } return this.slice(0, index) + (add || "") + this.slice(index + count); }
Exemple:
> "Held!".splice(3,0,"lo Worl") < "Hello World!"
la source
La méthode spliceSlice de Louis échoue lorsque la valeur ajoutée est 0 ou d'autres valeurs fausses, voici un correctif:
function spliceSlice(str, index, count, add) { if (index < 0) { index = str.length + index; if (index < 0) { index = 0; } } const hasAdd = typeof add !== 'undefined'; return str.slice(0, index) + (hasAdd ? add : '') + str.slice(index + count); }
la source
J'ai résolu mon problème en utilisant ce code, c'est un peu un remplacement pour l'épissure manquante.
let str = "I need to remove a character from this"; let pos = str.indexOf("character") if(pos>-1){ let result = str.slice(0, pos-2) + str.slice(pos, str.length); console.log(result) //I need to remove character from this }
J'avais besoin de supprimer un caractère avant / après un certain mot, après avoir obtenu la position, la chaîne est divisée en deux, puis recomposée en supprimant de manière flexible les caractères en utilisant un décalage le long
pos
la source