I'm trying to write a javascript function that replaces certain characters in a string. For example, if I want to replace 'a' with 'ab' and 'b' with 'c' in the string "a b", the function should give me the string "ab c". In this case I can't just run a replace with 'a' on the string first and then another replace with 'b' on the result because that would give me "ac b" instead of "ab c".
Any ideas on how to efficiently do this?
You can use a regular expression to match the different characters, and a callback function to determine what to replace it with. As it does all replacements in one run, there is no problem with one replacement containing another thing to replace:
s = s.replace(/[ab]/g, function(m){
switch (m) {
case 'a': return 'ab';
case 'b': return 'c';
}
return m;
});
Demo: http://jsfiddle.net/Guffa/pXSM5/
To use regular expressions for matching each string, loop through them and find every match, then loop through the found matches and replace them. It's easiest to do the replacements starting with the last one in the string, that way you don't have to adjust the index of other matches when a replacement has a different length from the matched string:
var s = "a b";
var re = [{ regex: /a/g, replace: 'ab'}, { regex: /b/g, replace: 'c' }];
var pos = [];
for (var i = 0; i < re.length; i++) {
while ((r = re[i].regex.exec(s)) != null) {
pos.push({ index: r.index, match: r[0], replace: re[i].replace });
}
}
while (pos.length > 0) {
var last = 0;
for (var i = 0; i < pos.length; i++) {
if (pos[i].index > pos[last].index) last = i;
}
var p = pos[last];
s = s.substr(0, p.index) + p.replace + s.substr(p.index + p.match.length);
pos.splice(last, 1);
}
Demo: http://jsfiddle.net/Guffa/pXSM5/1/
Note: Make sure that the regular expressions doesn't match anything that can overlap.
The correct solution: regular expressions. The "downside" is that it's difficult to learn, (but once you learn, it's totally worth).
A "quick" solution is this:
like this
a -> <my_unique_replacement_which_does_not_contain_the_letter_____you_know!>
b -> c
<my_unique_replacement_which_does_not_contain_the_letter_____you_know!> -> ab
it's not guaranteed, it's not a 100% solution to use everywhere, but it is a quick fix for limited use.
I made small code using array split and replace
var s = "a b ba c",
re = [['a','ab'], ['b','c'], ['c','d']] ;
var replaced = s.split('').map( function( v ){
var found = false,
once = function( c ){
return function( v ){
return found? v: ( found = true && c ) ;
}
};
return re.reduce( function ( a, p ){
return a.replace( p[0], once( p[1]) );
}, v );
}).join('');
console.log( replaced );
and replaced has output ab c cab d
"a b".split('').map( function( v ){ return v.replace('b', 'c').replace('a','ab'); }).join('')