How can I remove a character from a string using JavaScript?

var mystring = "crt/r2002_2";
mystring = mystring.replace('/r','/');

will replace /r with / using String.prototype.replace.

Alternatively you could use regex with a global flag (as suggested by Erik Reppen & Sagar Gala, below) to replace all occurrences with

mystring = mystring.replace(/\/r/g, '/');

EDIT: Since everyone's having so much fun here and user1293504 doesn't seem to be coming back any time soon to answer clarifying questions, here's a method to remove the Nth character from a string:

String.prototype.removeCharAt = function (i) {
    var tmp = this.split(''); // convert to an array
    tmp.splice(i - 1 , 1); // remove 1 element from the array (adjusting for non-zero-indexed counts)
    return tmp.join(''); // reconstruct the string
}

console.log("crt/r2002_2".removeCharAt(4));

Since user1293504 used the normal count instead of a zero-indexed count, we've got to remove 1 from the index, if you wish to use this to replicate how charAt works do not subtract 1 from the index on the 3rd line and use tmp.splice(i, 1) instead.

A simple functional javascript way would be

mystring = mystring.split('/r').join('/')

simple, fast, it replace globally and no need for functions or prototypes

There's always the string functions, if you know you're always going to remove the fourth character:

str.slice(0, 4) + str.slice(5, str.length)

Your first func is almost right. Just remove the 'g' flag which stands for 'global' (edit) and give it some context to spot the second 'r'.

Edit: didn't see it was the second 'r' before so added the '/'. Needs \/ to escape the '/' when using a regEx arg. Thanks for the upvotes but I was wrong so I'll fix and add more detail for people interested in understanding the basics of regEx better but this would work:

mystring.replace(/\/r/, '/')

Now for the excessive explanation:

When reading/writing a regEx pattern think in terms of: followed by followed by <...

In regEx could be one at a time:

/each char in this pattern/

Or a single could be characters described by a character class:

/[123!y]/
//any one of these
/[^123!y]/
//anything but one of the chars following '^' (very useful/performance enhancing btw)

/a{2}/
//precisely two 'a' chars - matches identically as /aa/ would

/[aA]{1,3}/
//1-3 matches of 'a' or 'A'

/[a-zA-Z]+/
//one or more matches of any letter in the alphabet upper and lower
//'-' denotes a sequence in a character class

/[0-9]*/
//0 to any number of matches of any decimal character (/\d*/ would also work)

   var rePattern = /[aA]{4,8}(Eat at Joes|Joes all you can eat)[0-5]+/g
   var joesStr = 'aaaAAAaaEat at Joes123454321 or maybe aAaAJoes all you can   eat098765';

   joesStr.match(rePattern);

   //returns ["aaaAAAaaEat at Joes123454321", "aAaAJoes all you can eat0"]
   //without the 'g' after the closing '/' it would just stop at the first   match and return:
   //["aaaAAAaaEat at Joes123454321"]

/cat/

/[aA]{4,8}(Eat at Joes|Joes all you can eat)[0-5]+/

This is improvement of simpleigh answer (omit length)

s.slice(0, 4) + s.slice(5)

let s = "crt/r2002_2"; let o = s.slice(0, 4) + s.slice(5); let delAtIdx = (s, i) => s.slice(0, i) + s.slice(i + 1); // this function remove letter at index i console.log(o); console.log(delAtIdx(s, 4));

return this.substr(0, index) + char + this.substr(index + char.length);

char.length is zero. You need to add 1 in this case in order to skip character.

let str = '1234567'; let index = 3; str = str.substring(0, index) + str.substring(index + 1); console.log(str) // 123567 - number "4" under index "3" is removed

Maybe I'm a noob, but I came across these today and they all seem unnecessarily complicated.

Here's a simpler (to me) approach to removing whatever you want from a string.

function removeForbiddenCharacters(input) {
let forbiddenChars = ['/', '?', '&','=','.','"']

for (let char of forbiddenChars){
    input = input.split(char).join('');
}
return input

}

Create function like below

  String.prototype.replaceAt = function (index, char) {
      if(char=='') {
          return this.slice(0,index)+this.substr(index+1 + char.length);
      } else {
          return this.substr(0, index) + char + this.substr(index + char.length);
      }
  }

To replace give character like below

  var a="12346";
  a.replaceAt(4,'5');

https://i.stack.imgur.com/IjITb.png

and to remove character at definite index, give second parameter as empty string

a.replaceAt(4,'');

https://i.stack.imgur.com/oTO1d.png

If it is always the 4th char in yourString you can try:

yourString.replace(/^(.{4})(r)/, function($1, $2) { return $2; });

It only works if I replace it with another character. It will not simply remove it.

This is because when char is equal to "", char.length is 0, so your substrings combine to form the original string. Going with your code attempt, the following will work:

String.prototype.replaceAt = function (index, char) {
    return this.substr(0, index) + char + this.substr(index + 1);
    //   this will 'replace' the character at index with char ^
}

DEMO

You can use this: if ( str[4] === 'r' ) str = str.slice(0, 4) + str.slice(5)

Explanation:

if ( str[4] === 'r' ) Check if the 5th character is a 'r' str.slice(0, 4) Slice the string to get everything before the 'r' + str.slice(5) Add the rest of the string.

Minified: s=s[4]=='r'?s.slice(0,4)+s.slice(5):s [37 bytes!]

DEMO:

function remove5thR (s) { s=s[4]=='r'?s.slice(0,4)+s.slice(5):s; console.log(s); // log output } remove5thR('crt/r2002_2') // > 'crt/2002_2' remove5thR('crt|r2002_2') // > 'crt|2002_2' remove5thR('rrrrr') // > 'rrrr' remove5thR('RRRRR') // > 'RRRRR' (no change)

If you just want to remove single character and If you know index of a character you want to remove, you can use following function:

/**
 * Remove single character at particular index from string
 * @param {*} index index of character you want to remove
 * @param {*} str string from which character should be removed
 */
function removeCharAtIndex(index, str) {
    var maxIndex=index==0?0:index;
    return str.substring(0, maxIndex) + str.substring(index, str.length)
}

I dislike using replace function to remove characters from string. This is not logical to do it like that. Usually I program in C# (Sharp), and whenever I want to remove characters from string, I use the Remove method of the String class, but no Replace method, even though it exists, because when I am about to remove, I remove, no replace. This is logical!

In Javascript, there is no remove function for string, but there is substr function. You can use the substr function once or twice to remove characters from string. You can make the following function to remove characters at start index to the end of string, just like the c# method first overload String.Remove(int startIndex):

function Remove(str, startIndex) {
    return str.substr(0, startIndex);
}

and/or you also can make the following function to remove characters at start index and count, just like the c# method second overload String.Remove(int startIndex, int count):

function Remove(str, startIndex, count) {
    return str.substr(0, startIndex) + str.substr(startIndex + count);
}

and then you can use these two functions or one of them for your needs!

Example:

alert(Remove("crt/r2002_2", 4, 1));

Output: crt/2002_2

Achieving goals by doing techniques with no logic might cause confusions in understanding of the code, and future mistakes, if you do this a lot in a large project!

The following function worked best for my case:

public static cut(value: string, cutStart: number, cutEnd: number): string {
    return value.substring(0, cutStart) + value.substring(cutEnd + 1, value.length);
}

The shortest way would be to use splice

var inputString = "abc";
// convert to array and remove 1 element at position 4 and save directly to the array itself
let result = inputString.split("").splice(3, 1).join();
console.log(result);

This problem has many applications. Tweaking @simpleigh solution to make it more copy/paste friendly:

function removeAt( str1, idx) {
  return str1.substr(0, idx) + str1.substr(idx+1)
}
console.log(removeAt('abbcdef', 1))  // prints: abcdef

So basically, another way would be to:

Convert the string to an array using Array.from() method. Loop through the array and delete all r letters except for the one with index 1. Convert array back to a string.

let arr = Array.from("crt/r2002_2"); arr.forEach((letter, i) => { if(letter === 'r' && i !== 1) arr[i] = "" }); document.write(arr.join(""));

Using [index] position for removing a specific char (s)

String.prototype.remplaceAt = function (index, distance) {
  return this.slice(0, index) + this.slice(index + distance, this.length);
};

credit to https://stackoverflow.com/users/62576/ken-white

In C# (Sharp), you can make an empty character as '\0'. Maybe you can do this:

String.prototype.replaceAt = function (index, char) {
return this.substr(0, index) + char + this.substr(index + char.length);
}
mystring.replaceAt(4, '\0')

Search on google or surf on the interent and check if javascript allows you to make empty characters, like C# does. If yes, then learn how to do it, and maybe the replaceAt function will work at last, and you'll achieve what you want!

Finally that 'r' character will be removed!