This should do it: "C:\\backup\\".replace(/\\\\/g, '\\')

In the regular expression, a single \ must be escaped to \\, and in the replacement \ also.

[edit 2021] Maybe it's better to use template literals.

console.log(`original solution ${"C:\\backup\\".replace(/\\\\/g, '\\')}`)

// a template literal will automagically replace \\ with \
console.log(`template string without further ado ${`C:\\backup\\`}`);

// but if they are escaped themselves
console.log(`Double escaped ${`C:\\\\backup\\\\`.replace(/\\{2,}/g, '\\')}`);

// multiple escaped
console.log(`multiple escaped ${`C:\\\\\\\\backup\\\\`
  .replace(/\\{2,}/g, '\\')}`);

// don't want to replace the last \\
console.log(`not the last ${`C:\\\\\\backup\\\\`
  .replace(/\\{2,}([^\\{2,}$])/g, (a ,b) => a.slice(0,1) + b)}` );

// don't want to replace the first \\
console.log(`not the first ${`C:\\\\backup\\`.replace(/\\[^\\]$/g, '\\')}`);

// a generic tagged template to replace all multiple \\ OR //
const toSingleSlashes = (strs, ...args) => 
  strs.reduce( (a, v, i ) => 
    a.concat(args[i-1] || ``).concat(v, ``), `` )
      .replace( /(\\|\/){2,}/g, (a, b) => b );

console.log(`generic tagged template 1 ${
  toSingleSlashes`C:\\backup\\`}`);

console.log(`generic tagged template 2 ${
  toSingleSlashes`C:\\\\\\\\backup\\\\\\\\\\`}`);
  
console.log(`generic tagged template 3 ${
  toSingleSlashes`C:\\\\\\\\backup\\`}`);
  
console.log(`generic tagged template 4 ${
  toSingleSlashes`C:////////backup////`}`);

console.log(`reply to comment @chitgoks => 
"test\\\\hehehe" is by default "test\\hehehe"
so, no replacement necessary here ...`);

.as-console-wrapper {
    max-height: 100% !important;
}

When using regex,

• a literal reverse solidus (a.k.a. backslash,( a.k.a. \)) must be escaped with a \ .

• So when you input \\, that's literally \.

• If you want to input 2 \ each one must be escaped. That means \\\\ is literally a string of 2 \.

The following demo uses ES6 Template Literals:

• It's a new syntax for String that uses the backtick ` (top left corner key) instead of quotes " or '.

• It can interpolate variables by prefixing with ${ and suffixing with }.

  var x = 2; `this template literal will display x as ${x}.`
  // this template literal will display x as 2.
  

• The \ is U+5c in unicode. Using escaped unicode in Template Literal, it would be prefixed with \u{ and suffixed with }

  `A template literal with an escaped unicode backslash is \u{5c}`
  // A template literal with an escaped unicode backslash is \.
  

Demo

function XtoY(str, x, y) {
  var rgx = `/${x}/g`;
  var result = str.replace(rgx, `${y}`);
  return result;
}

const uni = `\u{5c}`;
const string = `\\a\\a\\b`;
const from = `${uni}${uni}`
const to = `${uni}`;

let z = XtoY(string, from, to);

console.log(z);

You should escape the slash twice:

"tel:\\99999999999".replace('\\\\', '\\');

Try:

   var parts = replaceableString.split('\\');
   var output = parts.join('\\\\');

Personally, as I am not so expert in reg exps, I tend to avoid them when dealing with non-alphanumeric characters, both due to readability and to avoid weird mistake.

Actually, the first method is correct and works. Two backslash is indeed used to make a single backslash.

console.log("hello & 100%".replace(/([&%$#_{}])/g, "\\$1")); // "hello \& 100\%"

If console.log is giving you some trouble, which it shouldn't, try alert. Also you need to use the return value which you aren't doing.

Andrew Cooper's answer is correct in terms of why that third statement is going wrong. But you're also overwriting newbigbend each time, so you won't see the result of the first two replacements at all.

If you're trying to replace all slashes, backslashes, and asterisks with nothing, do this:

newbigbend = bb_val.replace(/[/\\*]/g, "");

Note you don't need the i flag, none of those characters is case sensitive anyway. (And note that within the [], you don't need to escape / or *, because they don't have special meaning there.) Live example.

But if you want it as three individual statements for whatever reason, then use newbigbend in the second two (and add the backslash Andrew flagged up):

newbigbend = bb_val.replace(/\//gi,"");
newbigbend = newbigbend.replace(/\\/gi,"");
newbigbend = newbigbend.replace(/\*/gi,"");

Now I noticed that stand-alone backslashes are causing errors.

Backslashes in the string you're operating on won't have any effect on replacing ' characters whatsoever. If your goal is to replace backslash characters, use this:

value = value.replace(/\\/g, "whatever");

...which will replace all backslashes in the string with "whatever". Note that I've had to write two backslashes rather than just one. That's because in a regular expression literal, the backslash is used to introduce various special characters and character classes, and is also used as an escape — two backslashes together in a regular expression literal (as in a string) represent a single actual backslash in the string.

To change a single backslash into two backslashes, use:

value = value.replace(/\\/g, "\\\\");

Note that, again, to get a literal backslash in the replacement string, we have to escape each of the two — resulting in four in total in the replacement string.

I need to modify the value using javascript, to make it ready to be put as part of a SQL insert query.

You don't want to do this by hand. Any technology that allows you to make database queries and such (JDBC, ODBC, etc.) will provide some form of prepared or parameterized statement (link), which deals with these sorts of escaping issues for you. Doing it yourself is virtually guaranteed to leave security holes in your software which could be exploited. You want to use the work of a team that's had to think this through, and which updates the resulting code periodically as issues come to light, rather than flying alone. Further, if your JavaScript is running on the client (as most is, but by no means all — I use JavaScript server-side all the time), then nothing you do to escape the string can make it safe, because client requests to the server can be spoofed, completely bypassing your client-side code.