Quiero eliminar comillas dobles de una cadena

Quiero eliminar el ""alrededor de una cadena.

por ejemplo, si la cadena es: "I am here"entonces quiero única salida I am here.

Asumiendo:

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

Eso debería hacer el truco ... (si su objetivo es reemplazar todas las comillas dobles).

Así es como funciona:

• ['"]es una clase de caracteres, coincide con comillas simples y dobles. puedes reemplazar esto con" solo coincidir comillas dobles.
• +: una o más comillas, caracteres, como se define en la clase char anterior (opcional)
• g: la bandera global . Esto le dice a JS que aplique la expresión regular a toda la cadena. Si omite esto, solo reemplazará un único carácter.

Si está tratando de eliminar las comillas alrededor de una cadena dada (es decir, en pares), las cosas se ponen un poco más complicadas. Tendrás que usar aserciones 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 explicó:

• ": literal, coincide con cualquier literal "
• (: comienza a capturar el grupo. Lo que sea que esté entre paréntesis (() ) se capturará y se puede usar en el valor de reemplazo.
• [^"]+: Clase de personaje, coincide con todos los caracteres, excepto" 1 o más veces
• (?="): aserción positiva anticipada positiva de ancho cero (como en no capturado). El partido anterior solo será válido si es seguido por un" literal
• ): grupo de captura final, hemos capturado todo entre el cierre de apertura "
• ": otro literal, cf elemento de la lista uno

El reemplazo es '$1', esta es una referencia al primer grupo capturado, que está [^" ]+o todo entre las comillas dobles. El patrón coincide tanto con las comillas como con lo que hay entre ellas, pero lo reemplaza solo con lo que está entre las comillas, eliminando así efectivamente
Lo que hace es some "string with" quotes-> reemplaza "string with"con -> string with. Cotizaciones desaparecidas, trabajo hecho.

Si las comillas siempre van a estar al principio y al final de la cadena, puede usar esto:

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

Con la entrada remove "foo" delimiting ", la salida permanecerá sin cambios, pero cambie la cadena de entrada a "remove "foo" delimiting quotes", y terminará conremove "foo" delimiting quotes como salida.

Explicación:

• ^": coincide con el comienzo de la cadena ^y a ". Si la cadena no comienza con a ", la expresión ya falla aquí y no se reemplaza nada.
• (.+(?="$)): coincide (y captura) todo, incluidas las comillas dobles una o más veces, siempre que la anticipación positiva sea cierta
• (?="$): la anticipación positiva es muy similar a la anterior, solo que especifica que " debe ser el final de la cadena ($ === final)
• "$: coincide con la cita final, pero no la captura

El reemplazo se realiza de la misma manera que antes: reemplazamos la coincidencia (que incluye las comillas de apertura y cierre), con todo lo que estaba dentro de ellas.
Es posible que haya notado que he omitido el gindicador (para BTW global), ya que estamos procesando toda la cadena, esta expresión solo se aplica una vez.
Una expresión regular más fácil que hace, más o menos, lo mismo (hay una diferencia interna de cómo se compila / aplica la expresión regular) sería:

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

Al igual que antes ^"y "$que coincida con las cotizaciones que delimita al comienzo y al final de una cadena, y el (.+)coincidencias todo en el medio, y lo captura. He probado esta expresión regular, junto con la anterior (con afirmación anticipada) y, para mi sorpresa, descubrí que esta es un poco más lenta. Supongo que la aserción lookaround hace que la expresión anterior falle tan pronto como el motor determina que no hay una "al final de la cadena. Ah bueno, pero si esto es lo que quieres / necesitas, sigue leyendo :

Sin embargo, en este último caso, es mucho más seguro, más rápido, más fácil de mantener y mejor hacerlo:

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

Aquí, estoy verificando si el primer y el último carácter en la cadena son comillas dobles. Si es así, estoy usando substrpara cortar esos primeros y últimos caracteres. Las cadenas están indexadas a cero, por lo que el último carácter es el charAt(str.length -1). substrespera 2 argumentos, donde el primero es el desplazamiento desde el cual comienza la subcadena, el segundo es su longitud. Como no queremos el último personaje, más de lo que queremos el primero, esa longitud es str.length - 2. Easy-peazy.

Consejos :

Puede encontrar más información sobre las afirmaciones de búsqueda aquí
. Las expresiones regulares son muy útiles (y divertidas para la OMI), pueden ser un poco desconcertantes al principio. Aquí hay más detalles y enlaces a recursos sobre el tema.
Si aún no se siente muy cómodo usando expresiones regulares, puede considerar usar:

var noQuotes = someStr.split('"').join('');

Si hay muchas citas en la cadena, esto podría ser incluso más rápido que usar regex

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

Esta expresión regular solo eliminará las comillas si son el primer y el último carácter de la cadena. F.ex:

"I am here"  => I am here (replaced)
I "am" here  => I "am" here (untouched)
I am here"   => I am here" (untouched)

Si se garantiza que la cadena tendrá una comilla (o cualquier otro carácter individual) al principio y al final que le gustaría eliminar:

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

slice tiene mucho menos gastos generales que una expresión regular.

Si tiene control sobre sus datos y sabe que sus comillas dobles rodean la cadena (por lo que no aparecen dentro de la cadena) y la cadena es un número entero ... digamos con:

"20151212211647278"

o similar, esto elimina las comillas circundantes

JSON.parse("20151212211647278");

No es una respuesta universal, aunque es hábil para las necesidades de nicho

Si solo desea eliminar las comillas límite:

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

Este enfoque no tocará la cadena si no se ve así "text in quotes".

Si solo desea eliminar las comillas desde el principio o el final, use la siguiente expresión regular:

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

Para reformular su problema de una manera que sea más fácil de expresar como una expresión regular:

Obtenga la subcadena de caracteres que está contenida entre cero o una comillas dobles iniciales y cero o una comillas dobles finales.

Aquí está la expresión regular que hace eso:

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

Desglosando la expresión regular:

• ^"? una coincidencia codiciosa para cero o una comillas dobles principales
• "?$ una coincidencia codiciosa para cero o una comillas dobles
• esos dos sujetar una captura no codiciosa de todos los otros personajes (.+?), que contendrá el objetivo como $1.

Esto regresará delimited "string" herepara:

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

Un trazador de líneas para la gente perezosa

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

Esto funciona...

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

Esto puede funcionar para usted.

Si desea eliminar todas las comillas dobles en cadena, use

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

De lo contrario, solo desea eliminar las comillas alrededor de la cadena, use:

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

Este código simple también funcionará, para eliminar, por ejemplo, comillas dobles de una cadena rodeada de comillas dobles:

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

Si está intentando eliminar las comillas dobles, intente lo siguiente

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

este código es muy mejor para mostrar el número en el cuadro de texto

$ (this) = [su cuadro de texto]

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

Intenta seguir la expresión regular para eliminar las comillas dobles de la cadena.

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