Wie kann ich mit Javascript ein Zeichen aus einer Zeichenfolge entfernen?

Ich bin so nah dran, aber es ist einfach nicht richtig. Ich möchte nur das Zeichen raus einer Zeichenfolge entfernen . Das Problem ist, dass es mehr als eine Instanz von gibtr die Zeichenfolge . Es ist jedoch immer das Zeichen bei Index 4 (also das 5. Zeichen).

Beispielzeichenfolge: crt/r2002_2

Was ich möchte: crt/2002_2

Diese Ersetzungsfunktion entfernt beide r

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

Produziert: ct/2002_2

Ich habe diese Funktion ausprobiert:

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

Es funktioniert nur, wenn ich es durch ein anderes Zeichen ersetze. Es wird es nicht einfach entfernen.

Irgendwelche Gedanken?

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

ersetzen wird /rmit /Verwendung String.prototype.replace.

Alternativ können Sie Regex mit einem globalen Flag verwenden (wie von Erik Reppen & Sagar Gala unten vorgeschlagen), um alle Vorkommen durch zu ersetzen

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

BEARBEITEN: Da alle hier so viel Spaß haben und user1293504 nicht bald zurück zu kommen scheint, um klärende Fragen zu beantworten, ist hier eine Methode, um das N-te Zeichen aus einer Zeichenfolge zu entfernen:

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

Da user1293504 die normale Anzahl anstelle einer nullindizierten Anzahl verwendet hat, müssen wir 1 aus dem Index entfernen. Wenn Sie dies verwenden möchten, um zu replizieren, wie charAtfunktioniert, subtrahieren Sie nicht 1 vom Index in der 3. Zeile und verwenden Sie tmp.splice(i, 1)stattdessen.

Ein einfacher funktionaler Javascript-Weg wäre

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

Einfach, schnell, global zu ersetzen und ohne Funktionen oder Prototypen

Es gibt immer die Zeichenfolgenfunktionen, wenn Sie wissen, dass Sie immer das vierte Zeichen entfernen werden:

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

Deine erste Funk ist fast richtig. Entfernen Sie einfach das 'g'-Flag, das für' global 'steht (bearbeiten), und geben Sie ihm einen Kontext, um das zweite' r 'zu erkennen.

Bearbeiten: Ich habe nicht gesehen, dass es das zweite 'r' war, also habe ich das '/' hinzugefügt. Benötigt \ /, um das '/' zu umgehen, wenn ein regEx-Argument verwendet wird. Vielen Dank für die Upvotes, aber ich habe mich geirrt, also werde ich mehr Details für Leute korrigieren und hinzufügen, die daran interessiert sind, die Grundlagen von regEx besser zu verstehen, aber das würde funktionieren:

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

Nun zur übermäßigen Erklärung:

Denken Sie beim Lesen / Schreiben eines regEx-Musters an: <a Zeichen oder Zeichensatz> gefolgt von <a Zeichen oder Zeichensatz> gefolgt von <...

In regEx kann <a Zeichen oder Zeichensatz> einzeln sein:

/each char in this pattern/

Lesen Sie also als e, gefolgt von a, gefolgt von c usw.

Oder ein einzelnes <a Zeichen oder ein Satz von Zeichen> können Zeichen sein, die von einer Zeichenklasse beschrieben werden:

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

Oder erweitert, um einer Anzahl von Zeichen zu entsprechen (aber am besten als ein einzelnes Element in Bezug auf das sequentielle Muster zu betrachten):

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

Also mach ein paar zusammen:

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

Und natürlich habe ich zu viel ausgearbeitet, aber mein Punkt war einfach, dass dies:

/cat/

ist eine Reihe von 3 Musterelementen (eine Sache, gefolgt von einer Sache, gefolgt von einer Sache).

Und so ist das:

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

So verrückt regEx auch aussieht, es zerfällt alles in eine Reihe von Dingen (möglicherweise Dinge mit mehreren Zeichen), die nacheinander aufeinander folgen. Ein grundlegender Punkt, aber einer, für den ich eine Weile gebraucht habe, um vorbei zu kommen. Ich bin über Bord gegangen und habe ihn hier erklärt, da ich denke, dass er dem OP und anderen RegEx-Neulingen helfen würde, zu verstehen, was los ist. Der Schlüssel zum Lesen / Schreiben von regEx besteht darin, es in diese Teile zu zerlegen.

Für den globalen Ersatz von '/ r' hat dieser Code für mich funktioniert.

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

Repariere einfach deine replaceAt:

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

mystring.replaceAt(4, 1);

Ich würde es removeAtstattdessen nennen. :) :)

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

char.lengthist Null. Sie müssen 1in diesem Fall hinzufügen , um Zeichen zu überspringen.

Wenn es immer das 4. Zeichen in Ihrem String ist, können Sie versuchen:

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

Es funktioniert nur, wenn ich es durch ein anderes Zeichen ersetze. Es wird es nicht einfach entfernen.

Dies liegt daran , wenn chargleich "", char.length0, so dass Ihr Teil kombinieren , um die ursprüngliche Zeichenfolge zu bilden. Bei Ihrem Codeversuch funktioniert Folgendes:

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

Erstellen Sie eine Funktion wie unten

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

Zum Ersetzen geben Sie Zeichen wie unten

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

Um das Zeichen am bestimmten Index zu entfernen, geben Sie den zweiten Parameter als leere Zeichenfolge an

a.replaceAt(4,'');

Wenn Sie nur ein einzelnes Zeichen entfernen möchten und den Index eines Zeichens kennen, das Sie entfernen möchten, können Sie die folgende Funktion verwenden:

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

Ich mag es nicht, die Ersetzungsfunktion zu verwenden, um Zeichen aus der Zeichenfolge zu entfernen. Das ist nicht logisch , um es so zu machen. Normalerweise programmiere ich in C # (scharf), und wann immer ich Zeichen aus der Zeichenfolge entfernen möchte, verwende ich die Remove-Methode der String-Klasse, aber keine Replace-Methode, obwohl sie vorhanden ist, denn wenn ich sie entfernen möchte, entferne ich kein ersetzen. Das ist logisch!

In Javascript gibt es keine Entfernungsfunktion für Zeichenfolgen, aber eine Substr-Funktion. Sie können die substr-Funktion ein- oder zweimal verwenden, um Zeichen aus der Zeichenfolge zu entfernen. Sie können die folgende Funktion ausführen, um Zeichen am Startindex bis zum Ende der Zeichenfolge zu entfernen, genau wie die c # -Methode zuerst String.Remove (int startIndex) überlädt:

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

und / oder Sie können auch die folgende Funktion ausführen, um Zeichen beim Startindex zu entfernen und zu zählen, genau wie bei der zweiten Überladung der c # -Methode String.Remove (int startIndex, int count):

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

und dann können Sie diese beiden Funktionen oder eine davon für Ihre Bedürfnisse verwenden!

Beispiel:

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

Ausgabe: crt / 2002_2

Das Erreichen von Zielen durch Techniken ohne Logik kann zu Verwirrung beim Verständnis des Codes und zu zukünftigen Fehlern führen, wenn Sie dies in einem großen Projekt häufig tun!

Die folgende Funktion hat in meinem Fall am besten funktioniert:

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

Der kürzeste Weg wäre die Verwendung von Spleiß

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

Sie können dies verwenden: if ( str[4] === 'r' ) str = str.slice(0, 4) + str.slice(5)

Erläuterung:

1. if ( str[4] === 'r' )
   Überprüfen Sie, ob das 5. Zeichen a ist 'r'
   

2. str.slice(0, 4)
   Schneiden Sie die Schnur, um alles vor dem zu bekommen 'r'

3. + str.slice(5)
   Fügen Sie den Rest der Zeichenfolge hinzu.

Minimiert: 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

Dies ist eine Verbesserung der einfachen Antwort (Länge weglassen)

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 # (scharf) können Sie ein leeres Zeichen als '\ 0' erstellen. Vielleicht kannst du das machen:

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

Suchen Sie auf Google oder surfen Sie im Interent und prüfen Sie, ob Sie mit Javascript leere Zeichen erstellen können, wie dies bei C # der Fall ist. Wenn ja, dann lernen Sie, wie es geht, und vielleicht funktioniert die Funktion replaceAt endlich, und Sie werden erreichen, was Sie wollen!

Schließlich wird dieses 'r'-Zeichen entfernt!