Comment puis-je supprimer un caractère d'une chaîne en utilisant Javascript?

Je suis si près d'obtenir cela, mais ce n'est tout simplement pas bien. Tout ce que je voudrais faire, c'est supprimer le caractère rd'une chaîne. Le problème est qu'il y a plus d'une instance de rdans la chaîne. Cependant, c'est toujours le caractère à l'index 4 (donc le 5ème caractère).

exemple de chaîne: crt/r2002_2

Ce que je veux: crt/2002_2

Cette fonction de remplacement supprime les deux r

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

Produit: ct/2002_2

J'ai essayé cette fonction:

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

Cela ne fonctionne que si je le remplace par un autre personnage. Il ne le supprimera pas simplement.

Des pensées?

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

remplacera /rpar l' /utilisation String.prototype.replace.

Vous pouvez également utiliser l'expression régulière avec un indicateur global (comme suggéré par Erik Reppen & Sagar Gala , ci-dessous) pour remplacer toutes les occurrences par

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

EDIT: Étant donné que tout le monde s'amuse tellement ici et que user1293504 ne semble pas revenir de sitôt pour répondre à des questions de clarification, voici une méthode pour supprimer le Nème caractère d'une chaîne:

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

Étant donné que user1293504 a utilisé le nombre normal au lieu d'un nombre indexé à zéro, nous devons supprimer 1 de l'index, si vous souhaitez l'utiliser pour répliquer comment les charAttravaux ne soustraient pas 1 de l'index sur la 3e ligne et utilisez à la tmp.splice(i, 1)place.

Une manière javascript fonctionnelle simple serait

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

simple, rapide, il se remplace globalement et pas besoin de fonctions ou de prototypes

Il y a toujours les fonctions de chaîne, si vous savez que vous allez toujours supprimer le quatrième caractère:

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

Votre premier func a presque raison. Supprimez simplement le drapeau «g» qui signifie «global» (modifier) ​​et donnez-lui du contexte pour repérer le deuxième «r».

Edit: je n'ai pas vu que c'était le deuxième 'r' avant, alors j'ai ajouté le '/'. Nécessite \ / pour échapper au '/' lors de l'utilisation d'un argument regEx. Merci pour les votes positifs, mais j'avais tort, donc je vais corriger et ajouter plus de détails pour les personnes intéressées à mieux comprendre les bases de regEx, mais cela fonctionnerait:

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

Maintenant pour l'explication excessive:

Lors de la lecture / écriture d'un modèle regEx, pensez en termes de: <un caractère ou un ensemble de caractères> suivi de <un caractère ou un ensemble de caractères> suivi de <...

Dans regEx, <un caractère ou un ensemble de caractères> peut être un à la fois:

/each char in this pattern/

Donc, lisez e, suivi de a, suivi de c, etc ...

Ou un seul <un caractère ou un ensemble de caractères> pourrait être des caractères décrits par une classe de caractères:

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

Ou développé pour correspondre à une quantité de caractères (mais il est préférable de le considérer comme un élément unique en termes de modèle séquentiel):

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

Alors smoosh un tas ensemble:

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

Et bien sûr, j'ai trop élaboré, mais mon point était simplement que ceci:

/cat/

est une série de 3 éléments de motif (une chose suivie d'une chose suivie d'une chose).

Et c'est ainsi:

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

Aussi farfelu que regEx commence à paraître, tout se décompose en séries de choses (des choses potentiellement multi-caractères) se succédant séquentiellement. Une sorte de point de base, mais qui m'a pris un certain temps pour passer, donc je suis allé trop loin pour l'expliquer ici car je pense que c'est un point qui aiderait l'OP et d'autres nouveaux à regEx à comprendre ce qui se passe. La clé pour lire / écrire regEx est de le décomposer en ces morceaux.

Pour le remplacement global de '/ r', ce code a fonctionné pour moi.

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

Corrigez simplement votre replaceAt:

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

mystring.replaceAt(4, 1);

Je l'appellerais à la removeAtplace. :)

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

char.lengthest zéro. Vous devez ajouter 1dans ce cas afin de sauter le caractère.

Si c'est toujours le 4e caractère de votre chaîne, vous pouvez essayer:

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

Cela ne fonctionne que si je le remplace par un autre personnage. Il ne le supprimera pas simplement.

En effet, lorsque charest égal à "", char.lengthvaut 0, vos sous-chaînes se combinent pour former la chaîne d'origine. En suivant votre tentative de code, les éléments suivants fonctionneront:

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

Créer une fonction comme ci-dessous

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

Pour remplacer donnez le caractère comme ci-dessous

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

et pour supprimer le caractère à un index défini, donnez le deuxième paramètre comme chaîne vide

a.replaceAt(4,'');

Si vous souhaitez simplement supprimer un seul caractère et si vous connaissez l'index d'un caractère que vous souhaitez supprimer, vous pouvez utiliser la fonction suivante:

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

Je n'aime pas utiliser la fonction de remplacement pour supprimer des caractères de la chaîne. Ce n'est pas logique de le faire comme ça. Habituellement, je programme en C # (Sharp), et chaque fois que je veux supprimer des caractères de la chaîne, j'utilise la méthode Remove de la classe String, mais aucune méthode Replace, même si elle existe, car lorsque je suis sur le point de supprimer, je supprime, pas de remplacement. C'est logique!

En Javascript, il n'y a pas de fonction de suppression pour la chaîne, mais il y a une fonction substr. Vous pouvez utiliser la fonction substr une ou deux fois pour supprimer des caractères de la chaîne. Vous pouvez créer la fonction suivante pour supprimer les caractères au début de l'index jusqu'à la fin de la chaîne, tout comme la première méthode c # surcharge String.Remove (int startIndex):

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

et / ou vous pouvez également créer la fonction suivante pour supprimer les caractères au début de l'index et du décompte, tout comme la seconde méthode c # surcharge String.Remove (int startIndex, int count):

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

et puis vous pouvez utiliser ces deux fonctions ou l'une d'entre elles pour vos besoins!

Exemple:

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

Sortie: crt / 2002_2

Atteindre des objectifs en faisant des techniques sans logique peut provoquer des confusions dans la compréhension du code et des erreurs futures, si vous faites cela beaucoup dans un grand projet!

La fonction suivante a fonctionné le mieux pour mon cas:

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

Le moyen le plus court serait d'utiliser une épissure

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

Vous pouvez utiliser ceci: if ( str[4] === 'r' ) str = str.slice(0, 4) + str.slice(5)

Explication:

1. if ( str[4] === 'r' )
   Vérifiez si le 5ème caractère est un 'r'
   

2. str.slice(0, 4)
   Tranchez la chaîne pour tout récupérer avant la 'r'

3. + str.slice(5)
   Ajoutez le reste de la chaîne.

Minifié: s=s[4]=='r'?s.slice(0,4)+s.slice(5):s [37 octets!]

DÉMO:

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

Il s'agit d'une amélioration de la réponse simple (omettez la longueur)

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), vous pouvez créer un caractère vide sous la forme '\ 0'. Vous pouvez peut-être faire ceci:

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

Recherchez sur google ou surfez sur le contenu et vérifiez si javascript vous permet de créer des caractères vides, comme le fait C #. Si oui, alors apprenez à le faire, et peut-être que la fonction replaceAt fonctionnera enfin, et vous obtiendrez ce que vous voulez!

Enfin, ce caractère «r» sera supprimé!