¿Cómo puedo eliminar un carácter de una cadena usando Javascript?

Estoy tan cerca de conseguir esto, pero simplemente no está bien. Todo lo que me gustaría hacer es eliminar el carácter rde una cadena. El problema es que hay más de una instancia de ren la cadena. Sin embargo, siempre es el carácter en el índice 4 (por lo tanto, el quinto carácter).

cadena de ejemplo: crt/r2002_2

Lo que quiero: crt/2002_2

Esta función de reemplazo elimina ambos r

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

Produce: ct/2002_2

Probé esta función:

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

Solo funciona si lo reemplazo con otro personaje. No lo eliminará simplemente.

¿Alguna idea?

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

reemplazará /rcon el /usoString.prototype.replace .

Alternativamente, podría usar expresiones regulares con una bandera global (como lo sugieren Erik Reppen y Sagar Gala , a continuación) para reemplazar todas las ocurrencias con

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

EDITAR: Dado que todos se divierten mucho aquí y el usuario 1293504 no parece volver pronto para responder preguntas aclaratorias, este es un método para eliminar el enésimo carácter de una cadena:

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));

Dado que user1293504 usó el recuento normal en lugar de un recuento indexado a cero, debemos eliminar 1 del índice, si desea usar esto para replicar cómo charAtfunciona, no reste 1 del índice en la tercera línea y use tmp.splice(i, 1)en su lugar.

Una forma JavaScript funcional simple sería

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

simple, rápido, se reemplaza globalmente y no necesita funciones ni prototipos

Siempre están las funciones de cadena, si sabes que siempre vas a eliminar el cuarto carácter:

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

Tu primer func es casi correcto. Simplemente elimine la bandera 'g' que significa 'global' (editar) y dele un poco de contexto para detectar la segunda 'r'.

Editar: no vi que era la segunda 'r' antes, así que agregué '/'. Necesita \ / para escapar del '/' cuando se utiliza un argumento regEx. Gracias por los votos a favor, pero me equivoqué, así que arreglaré y agregaré más detalles para las personas interesadas en comprender mejor los conceptos básicos de regEx, pero esto funcionaría:

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

Ahora para la explicación excesiva:

Al leer / escribir un patrón regEx, piense en términos de: <un carácter o conjunto de caracteres> seguido de <un carácter o conjunto de caracteres> seguido de <...

En regEx <un carácter o conjunto de caracteres> podría ser uno a la vez:

/each char in this pattern/

Entonces lea como e, seguido de a, seguido de c, etc.

O un <carácter o conjunto de caracteres> podría ser un carácter descrito por una clase de caracteres:

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

O ampliado para que coincida con una cantidad de caracteres (pero aún así es mejor pensarlo como un elemento único en términos del patrón secuencial):

/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)

Así que haz un montón juntos:

   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"]

Y, por supuesto, he elaborado demasiado, pero mi punto era simplemente que esto:

/cat/

es una serie de 3 elementos de patrón (una cosa seguida de una cosa seguida de una cosa).

Y así es esto:

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

Tan extraño como comienza a parecer regEx, todo se descompone en una serie de cosas (cosas potencialmente de varios caracteres) que se suceden secuencialmente. Un punto básico, pero que me llevó un tiempo superar, así que me he pasado de la raya explicándolo aquí, ya que creo que es uno que ayudaría al OP y a otros nuevos en RegEx a comprender lo que está sucediendo. La clave para leer / escribir regEx es dividirlo en esas piezas.

Para el reemplazo global de '/ r', este código funcionó para mí.

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

Solo arregla tu replaceAt:

String.prototype.replaceAt = function(index, charcount) {
  return this.substr(0, index) + this.substr(index + charcount);
}

mystring.replaceAt(4, 1);

Lo llamaría en su removeAtlugar. :)

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

char.lengthes cero Debe agregar 1en este caso para omitir el carácter.

Si siempre es el cuarto personaje en tu cadena, puedes probar:

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

Solo funciona si lo reemplazo con otro personaje. No lo eliminará simplemente.

Esto se debe a que cuando chares igual a "", char.lengthes 0, por lo que sus subcadenas se combinan para formar la cadena original. Con su intento de código, lo siguiente funcionará:

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 ^
}

• MANIFESTACIÓN

Crear función como a continuación

  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);
      }
  }

Para reemplazar dar carácter como a continuación

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

y para eliminar el carácter en el índice definido, dé el segundo parámetro como una cadena vacía

a.replaceAt(4,'');

Si solo desea eliminar un solo carácter y si conoce el índice de un carácter que desea eliminar, puede usar la siguiente función:

/**
 * 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)
}

No me gusta usar la función de reemplazo para eliminar caracteres de la cadena. Esto no es lógico hacerlo así. Por lo general, programo en C # (Sharp), y cada vez que quiero eliminar caracteres de la cadena, uso el método Remove de la clase String, pero no el método Reemplazar, aunque exista, porque cuando estoy a punto de eliminarlo, elimino, No reemplazar. Esto es lógico!

En Javascript, no hay una función de eliminación para la cadena, pero hay una función substr. Puede usar la función substr una o dos veces para eliminar caracteres de la cadena. Puede realizar la siguiente función para eliminar caracteres en el índice de inicio al final de la cadena, al igual que el método c # sobrecarga primero String.Remove (int startIndex):

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

y / o también puede realizar la siguiente función para eliminar caracteres en el índice de inicio y contar, al igual que la segunda sobrecarga del método c # String.Remove (int startIndex, int count):

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

¡y luego puede usar estas dos funciones o una de ellas para sus necesidades!

Ejemplo:

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

Salida: crt / 2002_2

¡Lograr objetivos haciendo técnicas sin lógica puede causar confusión en la comprensión del código y futuros errores, si haces esto mucho en un proyecto grande!

La siguiente función funcionó mejor para mi caso:

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

La forma más corta sería usar empalme

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);

Puedes usar esto: if ( str[4] === 'r' ) str = str.slice(0, 4) + str.slice(5)

Explicación:

1. if ( str[4] === 'r' )
   Compruebe si el quinto personaje es un 'r'
   

2. str.slice(0, 4)
   Corta la cuerda para obtener todo antes de 'r'

3. + str.slice(5)
   Agrega el resto de la cadena.

Minificado: 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)

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

Esta es una mejora de la respuesta simple (omitir la longitud)

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));

En C # (Sharp), puede hacer un carácter vacío como '\ 0'. Quizás puedas hacer esto:

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

Busque en Google o navegue por Internet y compruebe si JavaScript le permite crear caracteres vacíos, como lo hace C #. En caso afirmativo, aprenda cómo hacerlo, y tal vez la función replaceAt funcione por fin, ¡y logrará lo que desea!

¡Finalmente ese personaje 'r' será eliminado!