Comment remplacer toutes les occurrences d'une chaîne en JavaScript
J'ai cette ficelle:
"Test abc test test abc test test test abc test test abc"
Faire
str = str.replace('abc', '');
semble ne supprimer que la première occurrence de abc dans la chaîne ci-dessus. Comment puis-je remplacer toutes occurrences?
Par souci d'exhaustivité, j'ai réfléchi à la méthode que je devrais utiliser pour le faire. Il existe essentiellement deux façons de procéder, comme le suggèrent les autres réponses de cette page.
Remarque: En général, il n'est pas recommandé d'étendre les prototypes intégrés en JavaScript. Je fournis des extensions sur le prototype String simplement à des fins d'illustration, illustrant différentes implémentations d'une méthode standard hypothétique sur le prototype intégré String.
Implémentation basée sur une expression régulière
String.prototype.replaceAll = function(search, replacement) {
var target = this;
return target.replace(new RegExp(search, 'g'), replacement);
};
Mise en œuvre fractionnée et jointe (fonctionnelle)
String.prototype.replaceAll = function(search, replacement) {
var target = this;
return target.split(search).join(replacement);
};
Ne sachant pas trop comment les expressions régulières fonctionnent en coulisse en termes d’efficacité, j’avais tendance à pencher vers la scission et à rejoindre la mise en œuvre dans le passé sans penser à la performance. Quand je me suis demandé ce qui était le plus efficace et de quelle marge, je l'ai utilisé comme excuse pour le savoir.
Sur mon ordinateur Windows 8 sous Chrome, l'implémentation basée sur les expressions régulières est la plus rapide, l'implémentation split et join étant 53% plus lente. Cela signifie que les expressions régulières sont deux fois plus rapides pour l’entrée lorem ipsum que j’ai utilisée.
Découvrez ceci benchmark en exécutant ces deux implémentations l'une contre l'autre.
Comme noté dans le commentaire ci-dessous par @ThomasLeduc et autres, il pourrait y avoir un problème avec l'implémentation basée sur les expressions régulières si search contient certains caractères réservés en tant que caractères spéciaux dans les expressions régulières . L'implémentation suppose que l'appelant échappera la chaîne au préalable ou ne transmettra que les chaînes sans les caractères de la table dans Expressions régulières (MDN).
MDN fournit également une implémentation pour échapper à nos chaînes. Ce serait bien si cela était aussi normalisé en tant que RegExp.escape(str), mais hélas, cela n'existe pas:
function escapeRegExp(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}
Nous pourrions appeler escapeRegExp dans notre implémentation String.prototype.replaceAll, mais je ne sais pas dans quelle mesure cela affectera les performances (potentiellement, même pour les chaînes pour lesquelles l'échappement n'est pas nécessaire, comme toutes les chaînes alphanumériques).
str = str.replace(/abc/g, '');
En réponse au commentaire:
var find = 'abc';
var re = new RegExp(find, 'g');
str = str.replace(re, '');
En réponse au commentaire de Cliquez sur le vote positif , vous pourriez le simplifier encore plus:
function replaceAll(str, find, replace) {
return str.replace(new RegExp(find, 'g'), replace);
}
Remarque: Les expressions régulières contiennent des caractères spéciaux (méta). Par conséquent, il est dangereux de passer aveuglément un argument dans la fonction find ci-dessus sans le pré-traiter pour échapper à ces caractères. Ceci est couvert dans le Mozilla Developer Network 's Guide JavaScript sur les expressions régulières , où ils présentent la fonction utilitaire suivante:
function escapeRegExp(str) {
return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}
Ainsi, afin de rendre la fonction replaceAll() ci-dessus plus sûre, vous pouvez la modifier comme suit si vous incluez également escapeRegExp:
function replaceAll(str, find, replace) {
return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
Remarque: Ne l'utilisez pas dans le code réel.
Comme alternative aux expressions régulières pour une chaîne littérale simple, vous pouvez utiliser
str = "Test abc test test abc test...".split("abc").join("");
Le schéma général est
str.split(search).join(replacement)
Auparavant, c'était plus rapide que d'utiliser replaceAll et une expression régulière, mais cela ne semble plus être le cas dans les navigateurs modernes. Donc, cela ne devrait vraiment être utilisé que comme un hack rapide pour éviter de devoir échapper à l'expression régulière, pas dans du code réel.
L'utilisation d'une expression régulière avec l'indicateur g remplacera tous les éléments suivants:
someString = 'the cat looks like a cat';
anotherString = someString.replace(/cat/g, 'dog');
// anotherString now contains "the dog looks like a dog"
Voir ici aussi
Voici une fonction de prototype de chaîne basée sur la réponse acceptée:
String.prototype.replaceAll = function (find, replace) {
var str = this;
return str.replace(new RegExp(find, 'g'), replace);
};
MODIFIER
Si votre find contient des caractères spéciaux, vous devez les échapper:
String.prototype.replaceAll = function (find, replace) {
var str = this;
return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};
Fiddle: http://jsfiddle.net/cdbzL/
Mettre à jour:
Il est un peu tard pour une mise à jour, mais comme je viens de trébucher sur cette question et de constater que ma réponse précédente ne me convient pas. Puisque la question impliquait de remplacer un seul mot, il est incroyable que personne n'ait pensé à utiliser les limites de Word (\b)
'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//"a dog is not a caterpillar"
C'est un regex simple qui évite de remplacer des parties de mots dans la plupart des cas. Cependant, un tiret - est toujours considéré comme une limite de Word. Donc les conditionnels peuvent être utilisés dans ce cas pour éviter de remplacer des chaînes comme cool-cat:
'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"
fondamentalement, cette question est la même que celle ici: Javascript remplace "" "par" ""
@ Mike, vérifie la réponse que j'ai donnée là-bas ... l'expression rationnelle n'est pas le seul moyen de remplacer plusieurs occurrences d'une souscription, loin de là. Pensez flexible, pensez à diviser!
var newText = "the cat looks like a cat".split('cat').join('dog');
Alternativement, pour éviter de remplacer des parties Word - ce que la réponse approuvée fera aussi! Vous pouvez contourner ce problème en utilisant des expressions régulières qui sont, je l’admets, un peu plus complexes et, par conséquent, un peu plus lentes:
var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
La sortie est identique à la réponse acceptée, toutefois, en utilisant l'expression/cat/g sur cette chaîne:
var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns "the dog looks like a dog, not a dogerpillar or cooldog" ??
Oups en effet, ce n'est probablement pas ce que vous voulez. Qu'est-ce que c'est alors? IMHO, une regex qui ne remplace que "cat" conditionnellement. (c.-à-d. ne faisant pas partie d'un mot), comme suit:
var caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
//return "the dog looks like a dog, not a caterpillar or coolcat"
À mon avis, cela répond à vos besoins. Ce n'est pas complet, bien sûr, mais cela devrait suffire à vous aider à démarrer. Je recommande de lire un peu plus sur ces pages. Cela s'avérera utile pour perfectionner cette expression afin de répondre à vos besoins spécifiques.
http://www.javascriptkit.com/jsref/regexp.shtml
http://www.regular-expressions.info
Ajout final:
Étant donné que cette question suscite encore beaucoup de points de vue, j'ai pensé ajouter un exemple de .replace utilisé avec une fonction de rappel. Dans ce cas, l’expression and est considérablement simplifiée, ce qui permet une plus grande flexibilité, comme le remplacement par une capitalisation correcte ou le remplacement simultané de cat et cats:
'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
.replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
{
//check 1st, capitalize if required
var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
if (char1 === ' ' && char2 === 's')
{//replace plurals, too
cat = replacement + 's';
}
else
{//do not replace if dashes are matched
cat = char1 === '-' || char2 === '-' ? cat : replacement;
}
return char1 + cat + char2;//return replacement string
});
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar
Correspondre à une expression régulière globale:
anotherString = someString.replace(/cat/g, 'dog');
str = str.replace(/abc/g, '');
Ou essayez la fonction replaceAll à partir d'ici:
Quelles sont les méthodes JavaScript utiles qui étend les objets intégrés?
str = str.replaceAll('abc', ''); OR
var search = 'abc';
str = str.replaceAll(search, '');
EDIT: Clarification sur replaceAll disponibilité
La méthode 'replaceAll' est ajoutée au prototype de String. Cela signifie qu'il sera disponible pour tous les objets/littéraux de chaîne.
Par exemple.
var output = "test this".replaceAll('this', 'that'); //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'
Supposons que vous souhaitiez remplacer tous les "abc" par "x":
let some_str = 'abc def def lom abc abc def'.split('abc').join('x')
console.log(some_str) //x def def lom x x def
J'essayais de penser à quelque chose de plus simple que de modifier le prototype de chaîne.
Utilisez une expression régulière:
str.replace(/abc/g, '');
Remplacer les guillemets simples:
function JavaScriptEncode(text){
text = text.replace(/'/g,''')
// More encode here if required
return text;
}
Ce sont les méthodes les plus courantes et lisibles.
var str = "Test abc test test abc test test test abc test test abc"
Méthode 01:
str = str.replace(/abc/g, "replaced text");
Méthode 02:
str = str.split("abc").join("replaced text");
Méthode 03:
str = str.replace(new RegExp("abc", "g"), "replaced text");
Méthode 04:
while(str.includes("abc")){
str = str.replace("abc", "replaced text");
}
Sortie:
console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text
// boucle jusqu'à ce que le nombre d'occurrences atteigne 0. OR simplement copier/coller
function replaceAll(find, replace, str)
{
while( str.indexOf(find) > -1)
{
str = str.replace(find, replace);
}
return str;
}
str = str.replace(new RegExp("abc", 'g'), "");
a fonctionné mieux pour moi que les réponses ci-dessus. so new RegExp("abc", 'g') crée une RegExp qui correspond à toutes les occurrences (drapeau 'g') du texte ("abc"). La deuxième partie correspond à ce qui doit être remplacé. Dans votre cas, chaîne vide ("") .str est la chaîne, et nous devons la remplacer, car replace(...) renvoie simplement le résultat, mais pas les substitutions. Dans certains cas, vous voudrez peut-être utiliser cela.
Utiliser RegExp dans JavaScript pourrait faire le travail pour vous, faites simplement quelque chose comme ci-dessous, n'oubliez pas le /g après lequel se démarquer pour global :
var str ="Test abc test test abc test test test abc test test abc";
str = str.replace(/abc/g, '');
Si vous pensez à la réutilisation, créez une fonction pour le faire pour vous, mais ce n'est pas recommandé car c'est une fonction à une seule ligne, mais encore une fois, si vous utilisez beaucoup cela, vous pouvez écrire quelque chose comme ceci:
String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
return this.replace(new RegExp(string, 'g'), replaced);
};
et utilisez-le simplement dans votre code, encore et encore, comme ci-dessous:
var str ="Test abc test test abc test test test abc test test abc";
str = str.replaceAll('abc', '');
Mais comme je l’ai dit plus tôt, cela ne fera pas une grande différence en termes de lignes à écrire ou de performances, seule la mise en cache de la fonction peut accélérer certaines performances sur les chaînes longues et constituer une bonne pratique de code DRY vouloir réutiliser.
Si ce que vous voulez trouver est déjà dans une chaîne et que vous n'avez pas d'escaper une expression rationnelle, vous pouvez utiliser join/split:
function replaceMulti(haystack, needle, replacement)
{
return haystack.split(needle).join(replacement);
}
someString = 'the cat looks like a cat';
console.log(replaceMulti(someString, 'cat', 'dog'));function replaceAll(str, find, replace) {
var i = str.indexOf(find);
if (i > -1){
str = str.replace(find, replace);
i = i + replace.length;
var st2 = str.substring(i);
if(st2.indexOf(find) > -1){
str = str.substring(0,i) + replaceAll(st2, find, replace);
}
}
return str;
}
J'aime cette méthode (elle a l'air un peu plus propre):
text = text.replace(new RegExp("cat","g"), "dog");
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);
while (str.indexOf('abc') !== -1)
{
str = str.replace('abc', '');
}
Si la chaîne contient un motif similaire à abccc, vous pouvez utiliser ceci:
str.replace(/abc(\s|$)/g, "")
Les réponses précédentes sont beaucoup trop compliquées. Utilisez simplement la fonction de remplacement comme ceci:
str.replace(/your_regex_pattern/g, replacement_string);
Exemple:
var str = "Test abc test test abc test test test abc test test abc";
var res = str.replace(/[abc]+/g, "");
console.log(res);Si vous essayez de vous assurer que la chaîne que vous recherchez n'existera pas, même après le remplacement, vous devez utiliser une boucle.
Par exemple:
var str = 'test aabcbc';
str = str.replace(/abc/g, '');
Une fois terminé, vous aurez toujours 'test abc'!
La boucle la plus simple pour résoudre ce problème serait:
var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
str.replace(/abc/g, '');
}
Mais cela exécute le remplacement deux fois pour chaque cycle. Peut-être (au risque d’être rejeté) qui peut être combiné pour une forme légèrement plus efficace mais moins lisible:
var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!
Cela peut être particulièrement utile lorsque vous recherchez des chaînes en double.
Par exemple, si nous avons 'a , b' et que nous souhaitons supprimer toutes les virgules en double.
[Dans ce cas, on pourrait faire .replace (/, +/g, ','), mais à un moment donné, la regex devient assez complexe et lente pour la boucle.]
Bien que certaines personnes aient mentionné l’utilisation de regex, il existe une meilleure approche si vous souhaitez remplacer le texte, quel que soit le cas. Comme en majuscule ou en minuscule. Utilisez la syntaxe ci-dessous
//Consider below example
originalString.replace(/stringToBeReplaced/gi, '');
//Output will be all the occurrences removed irrespective of casing.
Vous pouvez vous référer à l'exemple détaillé ici .
La fonction suivante fonctionne pour moi:
String.prototype.replaceAllOccurence = function(str1, str2, ignore)
{
return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;
Appelez maintenant les fonctions comme ceci:
"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");
Il vous suffit de copier et coller ce code dans la console de votre navigateur pour le tester.
Vous pouvez simplement utiliser la méthode ci-dessous
/**
* Replace all the occerencess of $find by $replace in $originalString
* @param {originalString} input - Raw string.
* @param {find} input - Target key Word or regex that need to be replaced.
* @param {replace} input - Replacement key Word
* @return {String} Output string
*/
function replaceAll(originalString, find, replace) {
return originalString.replace(new RegExp(find, 'g'), replace);
};
Il suffit d'ajouter /g
document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');
à
// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');
/g signifie global
J'ai résolu ce problème par une simple ligne de code.
str.replace(/Current string/g, "Replaced string");
Consultez l'exemple sur jsfiddle https://jsfiddle.net/pot6whnx/1/
J'utilise p pour stocker le résultat du remplacement précédent de la récursivité:
function replaceAll(s, m, r, p) {
return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}
Il remplacera toutes les occurrences dans la chaîne s jusqu'à ce qu'il soit possible:
replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'
Pour éviter la boucle infinie, je vérifie si le remplacement r contient une correspondance m :
replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'
La plupart des gens font probablement cela pour encoder une URL. Pour encoder une URL, vous ne devez pas seulement considérer les espaces, mais convertir la chaîne entière correctement avec encodeURI.
encodeURI("http://www.google.com/a file with spaces.html")
obtenir:
http://www.google.com/a%20file%20with%20spaces.html
En termes de performances liées aux réponses principales ce sont quelques tests en ligne .
Certains tests de performances utilisant console.time() (qui fonctionnent le mieux dans votre propre console sont décrits ci-dessous, mais le temps est très court pour que l’extrait le soit dans l’extrait).
console.time('split and join');
"javascript-test-find-and-replace-all".split('-').join(' ');
console.timeEnd('split and join')
console.time('regular expression');
"javascript-test-find-and-replace-all".replace(new RegExp('-', 'g'), ' ');
console.timeEnd('regular expression');
console.time('while');
let str1 = "javascript-test-find-and-replace-all";
while (str1.indexOf('-') !== -1) {
str1 = str1.replace('-', ' ');
}
console.timeEnd('while');La chose intéressante à noter est que si vous les exécutez plusieurs fois, les résultats sont toujours différents même si la solution RegExp semble la plus rapide en moyenne et la solution de boucle while la plus lente.
Ma mise en œuvre, très explicite
function replaceAll(string, token, newtoken) {
if(token!=newtoken)
while(string.indexOf(token) > -1) {
string = string.replace(token, newtoken);
}
return string;
}
Pour remplacer tout type de caractères, essayez ce code:
Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\
Donc, cette méthode va résoudre ce problème.
String.prototype.replaceAll = function (find, replace) {
var str = this;
return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};
var message = $('#message').val();
message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
message = message.replaceAll('"', '\\"'); /*it will replace " to \\"*/
J'utilisais Ajax et j'avais besoin d'envoyer des paramètres au format JSON. Alors ma méthode ressemble à ceci:
function sendMessage(source, messageID, toProfileID, userProfileID) {
if (validateTextBox()) {
var message = $('#message').val();
message = message.replaceAll('\\', '\\\\');
message = message.replaceAll('"', '\\"');
$.ajax({
type: "POST",
async: "false",
contentType: "application/json; charset=utf-8",
url: "services/WebService1.asmx/SendMessage",
data: '{"source":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
dataType: "json",
success: function (data) {
loadMessageAfterSend(toProfileID, userProfileID);
$("#<%=PanelMessageDelete.ClientID%>").hide();
$("#message").val("");
$("#delMessageContainer").show();
$("#msgPanel").show();
},
error: function (result) {
alert("message sending failed");
}
});
}
else {
alert("Please type message in message box.");
$("#message").focus();
}
}
String.prototype.replaceAll = function (find, replace) {
var str = this;
return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};
Dans mes applications, j'utilise une fonction personnalisée qui est la plus puissante à cet effet, et même en enveloppant la solution split/join dans un cas plus simple, elle est un peu plus rapide dans Chrome 60etFirefox 54 ( JSBEN.CH ) que d'autres solutions. Mon ordinateur exécute Windows 7 64 bits.
L'avantage est que cette fonction personnalisée peut gérer plusieurs substitutions en même temps à l'aide de chaînes ou de caractères, ce qui peut constituer un raccourci pour certaines applications.
Comme une solution split/join ci-dessus, la solution ci-dessous ne pose aucun problème avec les caractères d'échappement, contrairement à l'approche d'expression régulière.
function replaceAll(s,find,repl,caseOff,byChar){
if (arguments.length<2) return false;
var destDel = ! repl; // if destDel delete all keys from target
var isString = !! byChar; // if byChar, replace set of characters
if (typeof find !==typeof repl && ! destDel) return false;
if (isString && (typeof find!=="string")) return false;
if (! isString && (typeof find==="string")) {
return s.split(find).join(destDel?"":repl);
}
if ((! isString) && ( ! Array.isArray(find) ||
( ! Array.isArray(repl) && ! destDel) )) return false;
// if destOne replace all strings/characters by just one element
var destOne = destDel ? false : (repl.length===1);
// Generally source and destination should have the same size
if (! destOne && ! destDel && find.length!==repl.length) return false
var prox,sUp,findUp,i,done;
if (caseOff) { // case insensitive
// Working with uppercase keys and target
sUp = s.toUpperCase();
if (isString)
findUp = find.toUpperCase()
else
findUp = find.map(function(el){ return el.toUpperCase();});
} else { // case sensitive
sUp = s;
findUp =find.slice(); // clone array/string
}
done = new Array(find.length); // size: number of keys
done.fill(null);
var pos = 0; // initial position in target s
var r = ""; // initial result
var aux, winner;
while (pos < s.length) { // Scanning the target
prox = Number.MAX_SAFE_INTEGER;
winner = -1; // no winner at start
for (i=0;i<findUp.length;i++) // find next occurence for each string
if (done[i]!==-1) { // key still alive
// Never search for the Word/char or is over?
if (done[i]===null || done[i]<pos) {
aux = sUp.indexOf(findUp[i],pos);
done[i]=aux; // Save the next occurrence
} else
aux = done[i] // restore the position of last search
if (aux<prox && aux!==-1) { // if next occurrence is minimum
winner = i; // save it
prox = aux;
}
} // not done
if (winner===-1) { // No matches forward
r += s.slice(pos);
break;
} // no winner
// found the character or string key in the target
i = winner; // restore the winner
r += s.slice(pos,prox); // update piece before the match
// Append the replacement in target
if (! destDel) r += repl[ destOne?0:i ];
pos = prox + ( isString?1:findUp[i].length ); // go after match
} // loop
return r; // return the resulting string
}
La documentation est ci-dessous
replaceAll Syntax ====== replaceAll(s,find,[ repl ,caseOff, byChar) Parameters ========== "s" is a string target of replacement. "find" can be a string or array of strings. "repl" should be the same type than "find" or empty if "find" is a string, it is a simple replacement for all "find" occurrences in "s" by string "repl" if "find" is an array, it will replaced each string in "find" that occurs in "s" for corresponding string in "repl" array. The replace specs are independent: A replacement part cannot be replaced again. if "repl" is empty all "find" occurrences in "s" will be deleted. if "repl" has only one character or element, all occurrences in "s" will be replaced for that one. "caseOff" is true if replacement is case insensitive (default is FALSE) "byChar" is true when replacement is based on set of characters. Default is false if "byChar", it will be replaced in "s" all characters in "find" set of characters for corresponding character in "repl" set of characters Return ====== the function returns the new string after the replacement.
Pour être honnête, j’ai exécuté le test benchmark sans test de paramètre.
Voici mon ensemble de test, en utilisant Node.js
function l() { return console.log.apply(null, arguments); }
var k=0;
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
["ri","nea"],["do","fa"])); //1
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
["ri","nea"],["do"])); //2
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
["ri","nea"])); //3
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
"aeiou","","",true)); //4
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
"aeiou","a","",true)); //5
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
"aeiou","uoiea","",true)); //6
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
"aeiou","uoi","",true)); //7
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
["ri","nea"],["do","fa","leg"])); //8
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
["ri","nea"],["do","fa"])); //9
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
["ri","nea"],["do","fa"],true)); //10
return;
Et les résultats:
1 'La banane est un fruit de la dope récolté loin du passé'
2 'la banane est un fruit de la dope récolté depuis le début'
3 'la banane est un fruit de pie récolté dans le ver'
4 'bnn s rp frt hrvstd nr th rvr'
5 'la banane comme rapa fraat harvastad naar tha ravar'
6 'Bununu est u ripo frait hurvostod nour tho rivor'
7 faux
8 faux
9 'BANANA IS UN FRUITS COLLECTIFS RÉCOLTÉS AU BORD DE LA RIVIÈRE'
10 'BANANA IS UN DOPÉ FRUIT RÉCOLTÉ FAVORISÉ'
Ceci peut être réalisé en utilisant Regex. Peu de combinaisons qui pourraient aider quelqu'un,
var Word = "this,\\ .is*a*test, '.and? / only / 'a \ test?";
var stri = "This is a test and only a test";
Pour remplacer tous les caractères non alpha,
console.log(Word.replace(/([^a-z])/g,' ').replace(/ +/g, ' '));
Result: [this is a test and only a test]
Pour remplacer plusieurs espaces continus par un espace,
console.log(stri.replace(/ +/g,' '));
Result: [This is a test and only a test]
Pour remplacer tous les caractères *,
console.log(Word.replace(/\*/g,''));
Result: [this,\ .isatest, '.and? / only / 'a test?]
Pour remplacer les points d'interrogation (?)
console.log(Word.replace(/\?/g,'#'));
Result: [this,\ .is*a*test, '.and# / only / 'a test#]
Pour remplacer les guillemets,
console.log(Word.replace(/'/g,'#'));
Result: [this,\ .is*a*test, #.and? / only / #a test?]
Pour remplacer tous les caractères,
console.log(Word.replace(/,/g,''));
Result: [this\ .is*a*test '.and? / only / 'a test?]
Pour remplacer un mot spécifique,
console.log(Word.replace(/test/g,''));
Result: [this,\ .is*a*, '.and? / only / 'a ?]
Pour remplacer la barre oblique inverse,
console.log(Word.replace(/\\/g,''));
Result: [this, .is*a*test, '.and? / only / 'a test?]
Pour remplacer la barre oblique,
console.log(Word.replace(/\//g,''));
Result: [this,\ .is*a*test, '.and? only 'a test?]
Pour remplacer tous les espaces,
console.log(Word.replace(/ /g,'#'));
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]
Pour remplacer les points,
console.log(Word.replace(/\./g,'#'));
Result: [this,\ #is*a*test, '#and? / only / 'a test?]
function replaceAll(str, find, replace) {
var $r="";
while($r!=str){
$r = str;
str = str.replace(find, replace);
}
return str;
}
Voici le code de travail avec prototype:
String.prototype.replaceAll = function(find, replace) {
var str = this;
return str.replace(new RegExp(find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"), 'g'), replace);
};
Pour unique valeurs remplaçables
String.prototype.replaceAll = function(search_array, replacement_array) {
//
var target = this;
//
search_array.forEach(function(substr, index) {
if (typeof replacement_array[index] != "undefined") {
target = target.replace(new RegExp(substr, 'g'), replacement_array[index])
}
});
//
return target;
};
// Use:
var replacedString = "This topic commented on :year. Talking :question.".replaceAll([':year', ':question'], ['2018', 'How to replace all occurrences of a string in JavaScript']);
//
console.log(replacedString);Méthode 1
Essayez d'implémenter l'expression régulière
"Test abc test test abc test test test test abc test test abc". Remplacer (/\abc/g, '');
Méthode 2
Split et rejoindre. Diviser avec abc et rejoindre avec un espace vide
"Test abc test test abc test test test test abc test test abc" .split ("abc"). Join ("")
Si l'utilisation d'une bibliothèque est une option pour vous, vous bénéficierez des tests et du support de la communauté associés à une fonction de bibliothèque. Par exemple, la bibliothèque string.js a une fonction replaceAll () qui fait ce que vous cherchez:
// Include a reference to the string.js library and call it (for example) S.
str = S(str).replaceAll('abc', '').s;
Dans la chaîne, premier élément, rechercher et remplacer
var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')Dans la chaîne recherche globale et remplacer
var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')Je souhaite simplement partager ma solution, basée sur certaines des fonctionnalités des dernières versions de JavaScript:
var str = "Test abc test test abc test test test abc test test abc";
var result = str.split(' ').reduce((a, b) => {
return b == 'abc' ? a : a + ' ' + b; })
console.warn(result)
J'utilise split et rejoindre ou ce funcion
function replaceAll( text, busca, reemplaza ){
while (text.toString().indexOf(busca) != -1)
text = text.toString().replace(busca,reemplaza);
return text;
}
Cela peut être résolu à l'aide d'expressions régulières et du drapeau g, ce qui signifie qu'il ne faut pas s'arrêter après avoir trouvé la première correspondance. Vraiment, les expressions régulières sauvent des vies!
function replaceAll(string, pattern, replacement) {
return string.replace(new RegExp(pattern, "g"), replacement);
}
// or if you want myString.replaceAll("abc", "");
String.prototype.replaceAll = function(pattern, replacement) {
return this.replace(new RegExp(pattern, "g"), replacement);
};
Pour remplacer une seule utilisation du temps:
var res = str.replace('abc', "");
Pour remplacer plusieurs fois, utilisez:
var res = str.replace(/abc/g, "");
Cela devrait marcher.
String.prototype.replaceAll = function (search, replacement){
var str1 = this.replace(search, replacement);
var str2 = this;
while(str1 != str2){
str2 = str1;
str1 = str1.replace(search, replacement);
}
return str1;
}
Exemple:
Console.log("Steve is the best character in minecraft".replaceAll("Steve" ,"Alex"));
Le moyen le plus simple de le faire sans utiliser d’expression rationnelle est de scinder et de rejoindre le même code ici:
var str="Test abc test test abc test test test abc test test abc";
str.split('abc').join('')
Cochez cette réponse peut aider et j'ai utilisé dans mon projet.
function replaceAll(searchString, replaceString, str) {
return str.split(searchString).join(replaceString);
}
replaceAll('abc', '',"Test abc test test abc test test test abc test test abc" ); // "Test test test test test test test test "
Essaye ça:
String.prototype.replaceAll = function (sfind, sreplace) {
var str = this;
while (str.indexOf(sfind) > -1) {
str = str.replace(sfind, sreplace);
}
return str;
};
Vous pouvez le faire sans Regex, mais vous devez faire attention si le texte de remplacement contient le texte recherché.
par exemple.
replaceAll("nihIaohi", "hI", "hIcIaO", true)
Voici donc une variante appropriée de replaceAll, y compris string-prototype:
function replaceAll(str, find, newToken, ignoreCase)
{
let i = -1;
if (!str)
{
// Instead of throwing, act as COALESCE if find == null/empty and str == null
if ((str == null) && (find == null))
return newToken;
return str;
}
if (!find) // sanity check
return str;
ignoreCase = ignoreCase || false;
find = ignoreCase ? find.toLowerCase() : find;
while ((
i = (ignoreCase ? str.toLowerCase() : str).indexOf(
find, i >= 0 ? i + newToken.length : 0
)) !== -1
)
{
str = str.substring(0, i) +
newToken +
str.substring(i + find.length);
} // Whend
return str;
}
Ou, si vous voulez avoir une fonction de prototype de chaîne:
String.prototype.replaceAll = function (find, replace) {
let str = this;
let i = -1;
if (!str)
{
// Instead of throwing, act as COALESCE if find == null/empty and str == null
if ((str == null) && (find == null))
return newToken;
return str;
}
if (!find) // sanity check
return str;
ignoreCase = ignoreCase || false;
find = ignoreCase ? find.toLowerCase() : find;
while ((
i = (ignoreCase ? str.toLowerCase() : str).indexOf(
find, i >= 0 ? i + newToken.length : 0
)) !== -1
)
{
str = str.substring(0, i) +
newToken +
str.substring(i + find.length);
} // Whend
return str;
};
var myName = 'r//i//n//o//l////d';
var myValidName = myName.replace(new RegExp('\//', 'g'), ''); > // rinold
console.log(myValidName);
var myPetName = 'manidog';
var renameManiToJack = myPetName.replace(new RegExp('mani', 'g'), 'jack'); > // jackdog
Toutes les réponses sont acceptées, vous pouvez le faire de plusieurs façons. Voici un truc pour faire ça.
const str = "Test abc test test abc test test test abc test test abc";
const compare = "abc";
arrayStr = str.split(" ");
arrayStr.forEach((element, index) => {
if (element == compare) {
arrayStr.splice(index, 1);
}
});
const newString = arrayStr.join(" ");
console.log(newString);
La meilleure solution, afin de remplacer tout caractère, nous utilisons ces fonctions indexOf(), includes(), substring() pour remplacer matched String par le provided String dans la chaîne actuelle.
String.indexOf()fonction est de trouver lanth correspondre à la position de l'index.String.includes()méthode détermine si une chaîne peut être trouvée dans une autre chaîne, en renvoyant la valeur true ou false, selon le cas.String.substring()function consiste à obtenir les parties de String (preceding,exceding). Ajout de la chaîne de remplacement entre ces pièces pour générer la chaîne de retour finale.
La fonction suivante permet d'utiliser n'importe quel caractère .
où as RegExp n'autorisera pas un caractère spécial comme ** et certains caractères doivent être échappés comme $.
String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
var retStr = this;
for (var x in obj) {
//var matchArray = retStr.match(new RegExp(x, 'ig'));
//for (var i = 0; i < matchArray.length; i++) {
var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
while (retStr.includes(x)) {
retStr = retStr.replaceMatch(x, obj[x], 0);
var replaceIndex = retStr.indexOf(x);
if( replaceIndex < prevIndex + (obj[x]).length) {
break;
} else {
prevIndex = replaceIndex;
}
}
}
return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
var retStr = this, repeatedIndex = 0;
//var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
//for (var x = 0; x < matchArray.length; x++) {
for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
if (repeatedIndex == 0 && x == 0) {
repeatedIndex = retStr.indexOf(matchkey);
} else { // matchIndex > 0
repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
}
if (x == matchIndex) {
retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
matchkey = null; // To break the loop.
}
}
return retStr;
};
Nous pouvons également utiliser un objet d'expression régulière pour faire correspondre un texte à un motif. Les fonctions suivantes sont des objets d’expression régulière.
Vous obtiendrez SyntaxError lorsque vous utilisez une expression régulière non valide telle que '**'.
String.replace()function est utilisé pour remplacer la chaîne spécifiée par la chaîne donnée.String.match()function permet de trouver combien de fois la chaîne est répétée.RegExp.prototype.testméthode exécute une recherche d'une correspondance entre une expression régulière et une chaîne spécifiée. Renvoie vrai ou faux.
String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
var retStr = this;
for (var x in obj) {
retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]);
}
return retStr;
};
Notez que les expressions régulières sont écrites sans guillemets.
Exemples à utiliser ci-dessus:
var str = "yash yas $dfdas.**";
console.log('String : ', str);
// No need to escape any special Character
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );
console.log('All Matched replace : ', str.replaceAllMatches({'as' : '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**' : '~~', '$':'&$&', '&':'%', '~':'>'}));
// You need to escape some special Characters
console.log('REGEX All Matched replace : ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));
Résultat:
String : yash yas $dfdas.**
Index Matched replace : yash yas $dfd*.**
Index Matched replace : yash ~as $dfdas.**
All Matched replace : Y**h Y** -dfd**.**
All Matched replace : yash yas %$%dfdas.>>
REGEX All Matched replace : Y**h Y** -dfd**.**