web-dev-qa-db-fra.com

Je veux supprimer les guillemets doubles d'une chaîne

Je veux supprimer le "" autour d'une chaîne.

par exemple. si la chaîne est: "I am here" alors je veux sortir uniquement I am here.

javascriptregex
198
ankur

En supposant:

_var someStr = 'He said "Hello, my name is Foo"';
console.log(someStr.replace(/['"]+/g, ''));
_

Cela devrait faire l'affaire ... (si votre objectif est de remplacer toutes les guillemets doubles).

Voilà comment cela fonctionne:

  • _['"]_ est une classe de caractères, qui correspond aux guillemets simples et doubles. vous pouvez le remplacer par _"_ pour ne faire correspondre que les guillemets doubles.
  • _+_: un ou plusieurs guillemets, tels que définis par la classe de caractères précédente (facultatif)
  • g: l'indicateur global . Cela indique à JS d'appliquer le regex à la chaîne entière. Si vous omettez cela, vous ne remplacerez qu'un seul caractère.

Si vous essayez de supprimer les guillemets autour d'une chaîne donnée (c'est-à-dire par paires), les choses deviennent un peu plus compliquées. Vous devrez utiliser des assertions de lookaround:

_var str = 'remove "foo" delimiting double quotes';
console.log(str.replace(/"([^"]+(?="))"/g, '$1'));
//logs remove foo delimiting quotes
str = 'remove only "foo" delimiting "';//note trailing " at the end
console.log(str.replace(/"([^"]+(?="))"/g, '$1'));
//logs remove only foo delimiting "<-- trailing double quote is not removed
_

Regex a expliqué:

  • _"_: littéral, correspond à tout littéral _"_
  • _(_: commence la capture du groupe. Tout ce qui est entre les parenthèses (_()_) sera capturé et peut être utilisé dans la valeur de remplacement.
  • _[^"]+_: Classe de caractères, correspond à tous les caractères , sauf _"_ 1 fois ou plus
  • _(?=")_: assertion d'anticipation positive de largeur nulle (comme dans le cas non capturée). La correspondance précédente ne sera valide que si elle est suivie d'un _"_ littéral
  • _)_: fin du groupe de capture, nous avons tout capturé entre la fermeture _"_
  • _"_: autre littéral, cf élément de liste un

Le remplacement est _'$1'_, il s'agit d'une référence arrière au premier groupe capturé, soit _[^" ]+_, ou tout en-dessous des guillemets. Le modèle correspond à la fois aux guillemets et à ce qui les sépare, mais ne le remplace que par ce qui est entre les guillemets, ce qui les supprime efficacement.
Le résultat est _some "string with" quotes_ -> remplace _"string with"_ par -> _string with_. Les citations sont parties, le travail est fait.

Si les guillemets sont toujours au début et à la fin de la chaîne, vous pouvez utiliser ceci:

_str.replace(/^"(.+(?="$))"$/, '$1');
_

Avec input remove "foo" delimiting ", la sortie restera inchangée, mais changera la chaîne d'entrée en "remove "foo" delimiting quotes", et vous vous retrouverez avec _remove "foo" delimiting quotes_ en sortie.

Explication:

  • _^"_: correspond au début de la chaîne _^_ et à un _"_. Si la chaîne ne commence pas par un _"_, l'expression échoue déjà ici et rien n'est remplacé.
  • _(.+(?="$))_: correspond (et capture) tout, y compris les guillemets doubles une ou plusieurs fois, à condition que le résultat positif soit vrai
  • _(?="$)_: le résultat positif est le même que ci-dessus, mais il spécifie que le _"_ doit être la fin du chaîne de caractères (_$_ === end)
  • _"$_: correspond à cette citation finale, mais ne la capture pas

Le remplacement se fait de la même manière qu'auparavant: nous remplaçons le match (qui inclut les guillemets d'ouverture et de fermeture), avec tout ce qui était à l'intérieur.
Vous avez peut-être remarqué que j'ai omis l'indicateur g (pour le BTW global), car, comme nous traitons la chaîne entière, cette expression ne s'applique qu'une fois.
Une expression rationnelle plus simple qui fait, en gros, la même chose (il existe une différence interne quant à la manière dont elle est compilée/appliquée) serait:

_someStr.replace(/^"(.+)"$/,'$1');
_

Comme auparavant, _^"_ et _"$_ correspondent aux guillemets de délimitation au début et à la fin d'une chaîne, et le _(.+)_ correspond à tout ce qui se trouve entre eux et le capture. J'ai essayé cette expression rationnelle, à côté de celle ci-dessus (avec une affirmation anticipée) et, à ma grande surprise, celle-ci a été légèrement plus lente. Je suppose que l'assertion de lookaround entraîne l'échec de l'expression précédente dès que le moteur détermine qu'il n'y a pas de _"_ à la fin de la chaîne. Ah bon, mais si c'est ce que vous voulez/avez besoin, veuillez continuer à lire :

Cependant, dans ce dernier cas, il est beaucoup plus sûr, plus rapide, plus facile à maintenir et à faire:

_if (str.charAt(0) === '"' && str.charAt(str.length -1) === '"')
{
    console.log(str.substr(1,str.length -2));
}
_

Ici, je vérifie si le premier et le dernier caractère de la chaîne sont des guillemets doubles. S'ils le sont, j'utilise substr pour couper les premiers et derniers caractères. Les chaînes étant indexées à zéro, le dernier caractère est le charAt(str.length -1). substr attend 2 arguments, où le premier est le décalage à partir duquel la sous-chaîne commence, le second est sa longueur. Puisque nous ne voulons pas le dernier caractère, pas plus que le premier, cette longueur est _str.length - 2_. Facile comme bonjour.

Astuces :

Plus sur les assertions de lookaround peut être trouvé ici
Les expressions rationnelles sont très utiles (et amusantes à l’OMI), peuvent être un peu déroutantes au début. Voici quelques détails supplémentaires et des liens vers des ressources sur le sujet.
Si vous n'êtes pas encore très à l'aise avec l'utilisation de regex, vous pouvez envisager d'utiliser:

_var noQuotes = someStr.split('"').join('');
_

S'il y a beaucoup de guillemets dans la chaîne, cela pourrait même être plus rapide que d'utiliser regex

334
Elias Van Ootegem
str = str.replace(/^"(.*)"$/, '$1');

Cette expression rationnelle ne supprimera les guillemets que s'il s'agit des premier et dernier caractères de la chaîne. F.ex:

"I am here"  => I am here (replaced)
I "am" here  => I "am" here (untouched)
I am here"   => I am here" (untouched)
67
David Hellsing

Si la chaîne est garantie d'avoir un guillemet (ou tout autre caractère unique) au début et à la fin que vous souhaitez supprimer:

str = str.slice(1, -1);

slice est beaucoup moins onéreux qu'une expression régulière.

40
darrinm

Si vous avez le contrôle de vos données et que vous savez que vos guillemets doubles entourent la chaîne (n'apparaissez donc pas dans la chaîne) et que la chaîne est un entier ... dites avec:

"20151212211647278"

ou similaire cela enlève joliment les citations environnantes

JSON.parse("20151212211647278");

Ce n'est pas une réponse universelle, même pour des besoins particuliers

31
Scott Stensland

Si vous souhaitez uniquement supprimer les guillemets:

function stripquotes(a) {
    if (a.charAt(0) === '"' && a.charAt(a.length-1) === '"') {
        return a.substr(1, a.length-2);
    }
    return a;
}

Cette approche ne touchera pas la chaîne si elle ne ressemble pas à "text in quotes".

12
Kos

Si vous souhaitez uniquement supprimer les guillemets du début ou de la fin, utilisez l'expression régulière suivante:

'"Hello"'.replace(/(^"|"$)/g, '');
7
Denis

Pour reformuler votre problème de manière plus facile à exprimer en tant qu’expression régulière:

Obtenez la sous-chaîne de caractères comprise entre zéro ou un guillemet double et zéro ou un guillemet double.

Voici l'expression rationnelle qui fait ça:

  var regexp = /^"?(.+?)"?$/;
  var newStr = str.replace(/^"?(.+?)"?$/,'$1');

Décomposer l'expression rationnelle:

  • ^"? une correspondance gourmande pour zéro ou un des guillemets doubles
  • "?$ une correspondance gourmande pour zéro ou un guillemet double
  • ces deux livres constituent une capture non gourmande de tous les autres personnages, (.+?), qui contiendra la cible sous la forme $1.

Ceci retournera delimited "string" here pour:

str = "delimited "string" here"  // ...
str = '"delimited "string" here"' // ...
str = 'delimited "string" here"' // ... and
str = '"delimited "string" here'
5
Mogsdad

Un seul paquebot pour les paresseux

var str = '"a string"';
str = str.replace(/^"|"$/g, '');
4
Kolob Canyon

Si vous souhaitez supprimer toutes les guillemets doubles d'une chaîne, utilisez

var str = '"some "quoted" string"';
console.log( str.replace(/"/g, '') );
// some quoted string

Sinon, vous souhaitez supprimer uniquement les guillemets autour de la chaîne, utilisez:

var str = '"some "quoted" string"';
console.log( clean = str.replace(/^"|"$/g, '') );
// some "quoted" string
1
balkon_smoke

Ce code simple fonctionnera également, pour supprimer par exemple une citation double d'une chaîne entourée d'une citation double:

var str = 'remove "foo" delimiting double quotes';
console.log(str.replace(/"(.+)"/g, '$1'));
0
Amaynut

Cela marche...

var string1 = "'foo'";
var string2 = '"bar"';

function removeFirstAndLastQuotes(str){
  var firstChar = str.charAt(0);
  var lastChar = str[str.length -1];
  //double quotes
  if(firstChar && lastChar === String.fromCharCode(34)){
    str = str.slice(1, -1);
  }
  //single quotes
  if(firstChar && lastChar === String.fromCharCode(39)){
    str = str.slice(1, -1);
  }
  return str;
}
console.log(removeFirstAndLastQuotes(string1));
console.log(removeFirstAndLastQuotes(string2));
0
Ron Royston
var expressionWithoutQuotes = '';
for(var i =0; i<length;i++){
    if(expressionDiv.charAt(i) != '"'){
        expressionWithoutQuotes += expressionDiv.charAt(i);
    }
}

Cela peut fonctionner pour vous.

0
Splinker P