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.

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 tous les guillemets doubles).

Voici comment ça fonctionne:

• ['"]est une classe de caractères, correspond à des guillemets simples et doubles. vous pouvez le remplacer par "pour ne faire correspondre que les guillemets doubles.
• +: une ou plusieurs guillemets, caractères, tels que définis par la classe char précédente (facultatif)
• g: le drapeau mondial . Cela indique à JS d'appliquer l'expression régulière à 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 contournement:

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 à n'importe quel littéral "
• (: commencez à capturer le groupe. Tout ce qui est entre les parenthèses ( ()) sera capturé et pourra être utilisé dans la valeur de remplacement.
• [^"]+: Classe de personnage, correspond à tous les caractères, sauf "1 ou plusieurs fois
• (?="): assertion d'anticipation positive de largeur nulle (comme dans non capturée). Le match précédent ne sera valide que s'il est suivi d'un "littéral
• ): fin du groupe de capture, nous avons tout capturé entre la fermeture d'ouverture "
• ": un autre littéral, cf élément de liste un

Le remplacement est '$1', c'est une référence arrière au premier groupe capturé, étant [^" ]+, ou tout entre les guillemets doubles. Le modèle correspond à la fois aux guillemets et à ce qui se trouve entre eux, mais le remplace uniquement par ce qui se trouve entre les guillemets, les supprimant ainsi efficacement.
Ce qu'il fait est some "string with" quotes-> remplace "string with"par -> string with. Les citations ont disparu, le travail est fait.

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

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

Avec l'entrée remove "foo" delimiting ", la sortie restera inchangée, mais changez la chaîne d'entrée en "remove "foo" delimiting quotes", et vous vous retrouverez avec remove "foo" delimiting quotescomme sortie.

Explication:

• ^": correspond au début de la chaîne ^et a ". 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 l'anticipation positive soit vraie
• (?="$): le lookahead positif est à peu près le même que ci-dessus, seulement il spécifie que le " doit être la fin de la chaîne ( $=== end)
• "$: correspond à cette citation de fin, mais ne la capture pas

Le remplacement se fait de la même manière qu'avant: nous remplaçons la correspondance (qui comprend 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' gindicateur (pour le BTW global), car puisque nous traitons la chaîne entière, cette expression ne s'applique qu'une seule fois.
Une expression rationnelle plus facile qui fait à peu près la même chose (il existe une différence interne de la façon dont la expression rationnelle est compilée / appliquée) serait:

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

Comme précédemment ^"et "$faites correspondre les guillemets de délimitation au début et à la fin d'une chaîne, et le fait (.+)correspondre tout le reste et le capture. J'ai essayé cette expression régulière, à côté de celle ci-dessus (avec assertion de lookahead) et, certes, à ma surprise, j'ai trouvé que celle-ci était légèrement plus lente. Je suppose que l'assertion de la recherche entraîne l'échec de l'expression précédente dès que le moteur détermine qu'il n'y en a pas "à la fin de la chaîne. Ah bien, mais si c'est ce que vous voulez / avez besoin, veuillez lire :

Cependant, dans ce dernier cas, c'est beaucoup plus sûr, plus rapide, plus facile à entretenir et tout simplement mieux de le 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 substrpour couper ces premier et dernier caractères. Les chaînes sont indexées à zéro, donc le dernier caractère est le charAt(str.length -1). substrattend 2 arguments, où le premier est le décalage à partir duquel la sous-chaîne démarre, le second est sa longueur. Puisque nous ne voulons pas du dernier caractère, pas plus que nous ne voulons du premier, cette longueur est str.length - 2. Facile-peazy.

Astuces :

Plus d'informations sur les assertions peuvent être trouvées ici Les
Regex 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 les expressions régulières, vous voudrez peut-être 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 l'expression régulière

str = str.replace(/^"(.*)"$/, '$1');

Cette expression régulière supprimera uniquement les guillemets si ce sont les 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)

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

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

slice a beaucoup moins de frais généraux qu'une expression régulière.

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

"20151212211647278"

ou similaire, cela supprime bien les citations environnantes

JSON.parse("20151212211647278");

Pas une réponse universelle, mais astucieuse pour les besoins de niche

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

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

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

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

Obtenez la sous-chaîne de caractères contenue entre zéro ou un guillemets doubles et zéro ou un guillemets fin.

Voici l'expression rationnelle qui fait cela:

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

Décomposer le regexp:

• ^"? une correspondance gourmande pour zéro ou un guillemets doubles
• "?$ une correspondance gourmande pour zéro ou un guillemets doubles finaux
• ces deux serre-livres une capture non gourmande de tous les autres personnages (.+?), qui contiendra la cible en tant que $1.

Cela reviendra delimited "string" herepour:

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

Un paquebot pour les paresseux

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

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

var expressionWithoutQuotes = '';
for(var i =0; i<length;i++){
    if(expressionDiv.charAt(i) != '"'){
        expressionWithoutQuotes += expressionDiv.charAt(i);
    }
}

Cela peut fonctionner pour vous.

Si vous souhaitez supprimer tous les guillemets doubles dans la 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

Ce code simple fonctionnera également, pour supprimer par exemple les guillemets doubles d'une chaîne entourée de guillemets doubles:

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

Si vous essayez de supprimer les guillemets doubles, essayez de suivre

  var Stringstr = "\"I am here\"";
  var mystring = String(Stringstr);
  mystring = mystring.substring(1, mystring.length - 1);
  alert(mystring);

ce code est très meilleur pour afficher le numéro dans la zone de texte

$ (this) = [votre zone de texte]

            var number = $(this).val();
            number = number.replace(/[',]+/g, '');
            number = number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
            $(this).val(number); // "1,234,567,890"

Veuillez essayer de suivre l'expression régulière pour supprimer les guillemets doubles de la chaîne.

    $string = "I am here";
    $string =~ tr/"//d;
    print $string;
    exit();