Estoy usando un servicio que usa un formato JSON incorrecto (sin comillas dobles alrededor de las propiedades). Entonces necesito enviar

{ name: "John Smith" } en vez de { "name": "John Smith" }

Este formato no se puede cambiar porque este no es mi servicio.

¿Alguien sabe de un enrutamiento de cadena para formatear un objeto JavaScript como el anterior?

Esta sencilla solución de expresión regular funciona para eliminar las comillas de los nombres de propiedad JSON en la mayoría de los casos:

const object = { name: 'John Smith' };
const json = JSON.stringify(object);  // {"name":"John Smith"}
console.log(json);
const unquoted = json.replace(/"([^"]+)":/g, '$1:');
console.log(unquoted);  // {name:"John Smith"}

Caso extremo:

var json = '{ "name": "J\\":ohn Smith" }'
json.replace(/\\"/g,"\uFFFF");  // U+ FFFF
json = json.replace(/"([^"]+)":/g, '$1:').replace(/\uFFFF/g, '\\\"');
// '{ name: "J\":ohn Smith" }'

Un agradecimiento especial a Rob W por arreglarlo.

Limitaciones

En casos normales, la expresión regular antes mencionada funcionará, pero matemáticamente es imposible describir el formato JSON con una expresión regular de modo que funcione en todos los casos (contar el mismo número de llaves es imposible con expresiones regulares). Por lo tanto, tengo cree una nueva función para eliminar comillas analizando formalmente la cadena JSON a través de la función nativa y reserialícela:

function stringify(obj_from_json) {
    if (typeof obj_from_json !== "object" || Array.isArray(obj_from_json)){
        // not an object, stringify using native function
        return JSON.stringify(obj_from_json);
    }
    // Implements recursive object serialization according to JSON spec
    // but without quotes around the keys.
    let props = Object
        .keys(obj_from_json)
        .map(key => `${key}:${stringify(obj_from_json[key])}`)
        .join(",");
    return `{${props}}`;
}

Ejemplo: https://jsfiddle.net/DerekL/mssybp3k/

Parece que este es un método simple de Object toString que está buscando.

En Node.js, esto se resuelve usando el objeto util y llamando a util.inspect (yourObject). Esto te dará todo lo que quieras. siga este enlace para obtener más opciones, incluida la profundidad de la aplicación del método. http://nodejs.org/api/util.html#util_util_inspect_object_options

Entonces, lo que está buscando es básicamente un inspector de objetos, no un convertidor JSON. El formato JSON especifica que todas las propiedades deben ir entre comillas dobles. Por lo tanto, no habrá convertidores JSON para hacer lo que desea, ya que simplemente no es un formato JSON. Especificaciones aquí: https://developer.mozilla.org/en-US/docs/Using_native_JSON

Objeto a la cadena o inspección es lo que necesita dependiendo del idioma de su servidor.

Puede ver el código fuente de ^{un analizador creado por el que definió el formato JSON} . Busque llamadas a funciones: estas rodean un valor entre comillas. Las claves se cotizan en las líneas 326 y 338 .json2.js quote

No incluya la biblioteca después de la modificación. En su lugar, solo tome la parte relevante ( stringify), o al menos reemplácela JSONcon otra cosa, por ejemplo. FAKEJSON.

Por ejemplo, un objeto FAKEJSONque solo define stringify: http://jsfiddle.net/PYudw/

Intenta usar el servive con JSONP, supongo que lo ofrecen cuando usan este formato.

De lo contrario, envíeles un informe de error detallado que incluya una buena argumentación de por qué deben cumplir con el estándar. Cualquier otra solución que no sea eliminar el problema de origen no es una solución real.

Una solución rápida y sucia podría ser canalizar la cadena a través de una expresión regular antes de analizarla:

var obj = JSON.parse(str.replace(/(\{|,)\s*(.+?)\s*:/g, '$1 "$2":'));

O intenta ajustar un analizador JSON de JavaScript existente (como este ) si desea un análisis más sintáctico.

Encontré un buen paquete de NPM para hacer precisamente esto:

https://www.npmjs.com/package/stringify-object

const stringify = require('stringify-object')

let prettyOutput = stringify(json);

Funciona bastante bien.

YAML, que es un superconjunto de JSON, debería asimilar fácilmente la sintaxis heredada.

Pruebe el analizador y volcador YAML de JavaScript: http://nodeca.github.com/js-yaml/

@Derek 朕 會 功夫 Gracias por compartir este método, me gustaría compartir mi código que también admite la secuenciación de una matriz de objetos.

export const stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
    // In case of an array we'll stringify all objects.
    if (Array.isArray(obj_from_json)) {
        return `[${
                    obj_from_json
                        .map(obj => `${stringifyObjectWithNoQuotesOnKeys(obj)}`)
                        .join(",")
                }]` ;
    }
    // not an object, stringify using native function
    if(typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null){
        return JSON.stringify(obj_from_json);
    }
    // Implements recursive object serialization according to JSON spec
    // but without quotes around the keys.
    return `{${
            Object
                .keys(obj_from_json)
                .map(key => `${key}:${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`)
                .join(",")
            }}`;
};

Utilizar JSON5.stringify

JSON5 es un superconjunto de JSON que permite la sintaxis de ES5, incluidas las claves de propiedad sin comillas . La implementación de referencia JSON5 ( json5paquete npm ) proporciona un JSON5objeto que tiene los mismos métodos con los mismos argumentos y semántica que el JSONobjeto integrado .

Es muy probable que el servicio que está utilizando utilice esta biblioteca.

JSON Beautifier de CSVJSON tiene una opción para colocar comillas en las claves. Si solo desea el código, puede copiarlo desde el repositorio de GitHub. Yo modifiqué JSON2 de Douglas Crockford para añadir soporte para eso.