Come posso rimuovere un carattere da una stringa usando Javascript?

Sono così vicino a ottenerlo, ma non è giusto. Tutto quello che vorrei fare è rimuovere il personaggio rda una stringa. Il problema è che rnella stringa è presente più di un'istanza . Tuttavia, è sempre il carattere all'indice 4 (quindi il 5 ° carattere).

stringa di esempio: crt/r2002_2

Quello che voglio: crt/2002_2

Questa funzione di sostituzione rimuove entrambi r

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

produce: ct/2002_2

Ho provato questa funzione:

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

Funziona solo se lo sostituisco con un altro personaggio. Non lo rimuoverà semplicemente.

qualche idea?

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

sostituirà /rcon l' /utilizzo String.prototype.replace.

In alternativa puoi usare regex con una bandiera globale (come suggerito da Erik Reppen e Sagar Gala , di seguito) per sostituire tutte le occorrenze con

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

EDIT: Dal momento che tutti si stanno divertendo così tanto e user1293504 non sembra tornare presto in qualsiasi momento per rispondere a domande chiarenti, ecco un metodo per rimuovere l'ennesimo carattere da una stringa:

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

Poiché user1293504 ha utilizzato il conteggio normale anziché un conteggio indicizzato zero, dobbiamo rimuovere 1 dall'indice, se si desidera utilizzarlo per replicare come charAtfunziona non sottrarre 1 dall'indice sulla 3a riga e utilizzare tmp.splice(i, 1)invece.

Un modo javascript funzionale sarebbe

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

semplice, veloce, si sostituisce a livello globale e non necessita di funzioni o prototipi

Esistono sempre le funzioni stringa, se sai che rimuoverai sempre il quarto carattere:

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

La tua prima funzione è quasi giusta. Basta rimuovere il flag 'g' che sta per 'global' (modifica) e dargli un po 'di contesto per individuare la seconda' r '.

Modifica: non ho visto che era la seconda 'r' prima, quindi ho aggiunto '/'. Deve \ / sfuggire a '/' quando si utilizza un arg regEx. Grazie per i voti positivi, ma ho sbagliato, quindi aggiusterò e aggiungerò maggiori dettagli per le persone interessate a comprendere meglio le basi di regEx, ma funzionerebbe:

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

Ora per la spiegazione eccessiva:

Quando leggi / scrivi un modello regEx, pensa in termini di: <un carattere o set di caratteri> seguito da <un carattere o set di caratteri> seguito da <...

In regEx <un carattere o un set di caratteri> potrebbe essere uno alla volta:

/each char in this pattern/

Quindi leggi come e, seguito da a, seguito da c, ecc ...

Oppure un singolo <a carattere o set di caratteri> potrebbe essere rappresentato da una classe di caratteri:

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

O espanso per abbinare una quantità di caratteri (ma è comunque meglio pensare a un singolo elemento in termini di modello sequenziale):

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

Quindi smoosh un mucchio insieme:

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

E ovviamente ho elaborato troppo ma il mio punto era semplicemente che:

/cat/

è una serie di 3 elementi del modello (una cosa seguita da una cosa seguita da una cosa).

E così è questo:

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

Per quanto bizzarro come regEx inizi a guardare, tutto si scompone in serie di cose (potenzialmente cose multi-carattere) che si susseguono in sequenza. Una specie di punto base, ma che mi ha richiesto un po 'di tempo per andare oltre, quindi ho esagerato spiegandolo qui perché penso che sia uno che aiuterebbe l'OP e gli altri nuovi regEx a capire cosa sta succedendo. La chiave per leggere / scrivere regEx è scomporla in quei pezzi.

Per la sostituzione globale di '/ r', questo codice ha funzionato per me.

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

Basta risolvere il tuo replaceAt:

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

mystring.replaceAt(4, 1);

Lo chiamerei removeAtinvece. :)

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

char.lengthè zero. È necessario aggiungere 1in questo caso per saltare il personaggio.

Se è sempre il 4 ° carattere nel tuoString puoi provare:

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

Funziona solo se lo sostituisco con un altro personaggio. Non lo rimuoverà semplicemente.

Questo perché quando charè uguale a "", char.lengthè 0, quindi le sottostringhe si combinano per formare la stringa originale. Seguendo il tuo tentativo di codice, funzionerà quanto segue:

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

Crea una funzione come di seguito

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

Per sostituire dare carattere come di seguito

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

e per rimuovere il carattere con un indice definito, assegnare il secondo parametro come stringa vuota

a.replaceAt(4,'');

Se vuoi solo rimuovere un singolo carattere e se conosci l'indice di un personaggio che vuoi rimuovere, puoi usare la seguente funzione:

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

Non mi piace usare la funzione di sostituzione per rimuovere i caratteri dalla stringa. Non è logico farlo in quel modo. Di solito programma in C # (Sharp) e ogni volta che voglio rimuovere i caratteri dalla stringa, utilizzo il metodo Remove della classe String, ma nessun metodo Replace, anche se esiste, perché quando sto per rimuovere, rimuovo, non sostituire. Questo è logico!

In Javascript, non esiste una funzione di rimozione per la stringa, ma esiste la funzione substr. È possibile utilizzare la funzione substr una o due volte per rimuovere i caratteri dalla stringa. È possibile effettuare la seguente funzione per rimuovere i caratteri dall'indice iniziale alla fine della stringa, proprio come il primo metodo c # sovraccarica String.Remove (int startIndex):

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

e / o è anche possibile effettuare la seguente funzione per rimuovere i caratteri nell'indice iniziale e nel conteggio, proprio come il secondo sovraccarico del metodo c # String.Remove (int startIndex, int count):

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

e quindi puoi usare queste due funzioni o una di esse per le tue esigenze!

Esempio:

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

Uscita: crt / 2002_2

Raggiungere obiettivi facendo tecniche senza logica potrebbe causare confusione nella comprensione del codice e errori futuri, se lo fai molto in un grande progetto!

La seguente funzione ha funzionato meglio per il mio caso:

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

Il modo più breve sarebbe usare la giunzione

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

Puoi usare questo: if ( str[4] === 'r' ) str = str.slice(0, 4) + str.slice(5)

Spiegazione:

1. if ( str[4] === 'r' )
   Controlla se il 5 ° carattere è a 'r'
   

2. str.slice(0, 4)
   Taglia la stringa per ottenere tutto prima del 'r'

3. + str.slice(5)
   Aggiungi il resto della stringa.

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

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

Questo è il miglioramento della risposta semplice (ometti lunghezza)

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

In C # (Sharp), puoi creare un carattere vuoto come '\ 0'. Forse puoi farlo:

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

Cerca su Google o naviga nel frattempo e controlla se javascript ti consente di creare caratteri vuoti, come fa C #. Se sì, allora impara come farlo, e forse la funzione sostituisci alla fine funzionerà e otterrai ciò che vuoi!

Alla fine quel carattere "r" verrà rimosso!