Cum pot elimina un personaj dintr-un șir de caractere folosind Javascript?

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

va înlocui pe /r cu"/", folosind String.prototype.replace.

Alternativ, ai putea folosi regex cu un steag globale (cum a sugerat de către Erik Reppen & Sagar Gala, de mai jos) pentru a înlocui toate aparițiile cu

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

EDIT: Din moment ce toată lumea's având atât de distractiv aici și user1293504 nu't par să revină în orice moment în curând pentru a răspunde la întrebări, aici's o metodă de a elimina N-lea caracter dintr-un șir:

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

Deoarece user1293504 folosit normal conta în loc de zero indexate conta, ne-am'trebuie să scoateți-1 din index, dacă doriți să utilizați acest pentru a reproduce cât charAt lucrări nu scade 1 din indexul pe linia a 3-a și de a folosi tmp.splice(i, 1) în loc.

Un simplu funcțional javascript cum ar fi

mystring = mystring.split('/r').alăturați-vă('/')

simplu, rapid, înlocuiți la nivel global și nu este nevoie pentru funcții sau prototipuri

Nu's mereu șir de funcții, dacă știi că ai're întotdeauna va elimina cel de-al patrulea personaj:

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

Prima func este aproape dreapta. Doar elimina 'g' pavilion care vine de la 'global' (editare) și în context la fața locului, cea de-a doua 'r'.

Edit: am't vedea că a fost cea de-a doua 'r' înainte, astfel încât adăugat '/'. Are nevoie de \/ să scape de '/' atunci când se utilizează un regEx arg. Multumesc pentru upvotes dar am fost greșit, așa că am'll fix și se adaugă mai multe detalii pentru cei interesați în a înțelege elementele de bază ale regEx mai bine, dar acest lucru ar funcționa:

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

Acum, pentru excesivă explicație:

Când citirea/scrierea unui regEx model gândesc în termeni de: <un caracter sau un set de charcters> urmat de <un caracter sau un set de charcters> urmat de <...

În regEx <un caracter sau un set de charcters> ar putea fi unul la un moment dat:

/each char in this pattern/

Deci, citiți cum e, urmat de un, urmat de c, etc...

Sau o singur <un caracter sau un set de charcters> ar putea fi personajele descrise de o clasa de caracter:

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

Sau extins pentru a se potrivi o cantitate de caractere (dar încă cel mai bun de a gândi ca un singur element în termeni de model secvențial):

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

Deci smoosh o grămadă împreună:

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

Și, desigur, am'am terminat-elaborat, dar ideea mea era pur și simplu ca acest lucru:

/cat/

este o serie de 3 elemente de model (un lucru urmat de un lucru urmat de un lucru).

Și așa este:

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

La fel de traznita ca regEx începe să se uite, totul se reduce la o serie de lucruri (potențial multi-caracter lucruri) după fiecare alte secvențial. Un fel de un punct de bază, dar una care mi-a luat ceva timp sa trec așa că am'am plecat peste bord explice aici cum cred că-l's unul care ar ajuta OP și altele noi pentru regEx înțelege ceea ce's întâmplă. Cheia pentru citirea/scrierea regEx este de rupere-l în jos, în aceste piese.

Pentru global înlocuirea '/r', acest cod a lucrat pentru mine.

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

Doar repara replaceAt:

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

mystring.replaceAt(4, 1);

Am'd numesc removeAt în loc. :)

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

`char.lungimea este zero. Ai nevoie să adăugați " 1 " în acest caz, în scopul de a sări de caracter.

Aceasta funcționează numai dacă l-am înlocui cu un alt personaj. Acesta nu va pur și simplu scoateți-l.

Acest lucru este pentru că atunci când char este egal cu "", `char.lungimea este 0, deci cuvinte se combina pentru a forma șirul original. Merge cu cod de încercare, următoarelor va funcționa:

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][1]

Crearea funcție de genul de mai jos

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

Pentru a înlocui da un caracter de mai jos

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

și pentru a elimina personajul certă la index, dă de-al doilea parametru ca șir gol

a.replaceAt(4,'');

Dacă este mereu al 4-lea char în yourString puteți încerca:

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

Dacă doriți doar pentru a elimina singur caracter și Dacă știi indicele de un personaj pe care doriți să-l eliminați, puteți utiliza următoarele funcții:

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

Îmi displace folosind înlocui funcția de a elimina caracterele din șir. Acest lucru nu este logic pentru a face asta. De obicei am un program in C# (Ascuțit), și ori de câte ori vreau să-l elimina caracterele din șir, eu folosesc Elimina metoda din clasa String, dar nu Înlocui metoda, chiar dacă ea există, pentru că atunci când sunt pe cale de a elimina, elimina, nu-l înlocuiți. Acest lucru este logic!

În Javascript, nu există nici o scoate funcție de șir, dar nu există funcția substr. Puteți utiliza funcția substr o dată sau de două ori pentru a șterge caracterele din șir. Puteți face următoarele funcția de a elimina caracterele de la început index la sfârșitul șir, la fel ca c# metoda primul suprasarcină Șir.Elimina(int startIndex):

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

și/sau, de asemenea, puteți face următoarele funcția de a elimina caracterele de la început index și număra, la fel ca în c# metoda a doua de suprasarcină Șir.Elimina(int startIndex, int count):

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

și apoi, puteți utiliza aceste două funcții sau de unul dintre ei pentru nevoile tale!

Exemplu:

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

Ieșire: monitoare crt/2002_2

Atingerea obiectivelor de a face tehnici cu nici o logică ar putea duce la confuzii în înțelegerea de cod, și greșelile în viitor, dacă veți face acest lucru o mulțime într-un proiect de mare!

Următoarea funcție a lucrat cel mai bine pentru cazul meu:

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

Cel mai scurt drum ar fi utilizarea de îmbinare

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

Puteți folosi acest lucru: dacă ( str[4] === 'r' ) str = str.felie(0, 4) + str.felie(5)

Explicație:

1. dacă ( str[4] === 'r' )<br> Verificați dacă 5-lea caracter este un'r'`
   

2. str.felie(0, 4)
   Felie șir pentru a obține tot ceea ce înainte de 'r'

3. + str.felie(5)
   Se adaugă restul de șir.

Minified: s=s[4]=='r'?s.felie(0,4)+s.felie(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)

Aceasta este o îmbunătățire a simpleigh raspuns (omite lungime)

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

În C# (Ascuțit), puteți face un gol de caracter ca '\0'. Poate că puteți face acest lucru:

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

Cauta pe google sau pentru a naviga pe interent și verificați dacă javascript vă permite să facă gol de caractere, cum ar fi C# are. Dacă da, atunci să învețe cum să facă asta, și poate că replaceAt funcția va lucra la ultimul, și te'll obține ceea ce vrei!

În cele din urmă ca 'r' caracterul va fi eliminat!