Por que JSON.parse di "Unexpected token"?

Isto é o diagnóstico de Unexpected token con JSON.parse: que quere dicir o erro, como ler a posición e que facer cando o corpo é HTML. As comas finais, as comiñas e Unexpected end explícanse con máis amplitude en Erros habituais de JSON: coma final, comiñas e Unexpected token.

Que quere dicir “Unexpected token” en JSON.parse()?

JSON.parse() esixe a gramática JSON. Un carácter ilegal na posición actual laza SyntaxError. {“name”:“Alex”,} é inválido: despois desa coma o obxecto non pode rematar. O texto da mensaxe e a posición seguen variando segundo o tempo de execución.

Que erro laza JSON.parse()?

O JSON inválido, en xeral, laza SyntaxError. Rexistre error.name para confirmar o tipo. Non deixe fixo todo error.message: motores e versións redáctano de xeitos distintos.

try {
  JSON.parse('{"name":"Alex",}');
} catch (error) {
  console.log(error.name);
  // SyntaxError
}

1. Usar comiñas simples no lugar de dobres

{‘name’:‘Alex’} é JSON inválido. {“name”:“Alex”} é válido. As cadeas JSON e os nomes de membro de obxecto usan comiñas dobres. Un literal de obxecto JavaScript como const user = { name: ‘Alex’ } pode ser JavaScript legal e, aínda así, non ser texto JSON.

Inválido

{'name':'Alex'}

Válido

{"name":"Alex"}

2. Comas finais

Unha coma despois da última propiedade ou do último elemento de array non é JSON estándar válido. {“name”:“Alex”,“age”:30,} e [1, 2, 3,] fallan ambos. Tráteo como unha causa de Unexpected token; Erros habituais de JSON: coma final, comiñas e Unexpected token aprofunda nas comas finais.

Inválido

{
  "name": "Alex",
  "age": 30,
}

Válido

{
  "name": "Alex",
  "age": 30
}

[1, 2, 3,]

3. Nomes de propiedade sen comiñas

{ name: “Alex” } pode ser un literal de obxecto JavaScript. En JSON, os nomes de membro son cadeas e precisan comiñas dobres: {“name”:“Alex”}.

Inválido

{
  name: "Alex"
}

Válido

{
  "name": "Alex"
}

4. Escape de cadea inválido

No texto JSON unha barra invertida inicia un escape. Un camiño cru como C:\Users\Alex é inválido porque \U non é un escape legal. Dobre as barras invertidas. Non mesture o escape da linguaxe anfitrioa co escape JSON. Erros habituais de JSON: coma final, comiñas e Unexpected token cóbreo con máis detalle.

Inválido

{"file":"C:\Users\Alex"}

Válido

{"file":"C:\\Users\\Alex"}

5. Texto de máis antes ou despois do JSON

JSON.parse espera un só valor JSON. Un prefixo como Success: diante de {“ok”:true}, ou un sufixo como done detrás, deixa inválida toda a cadea. O espazo en branco insignificante arredor dun único valor JSON si está permitido. JSON non prohibe espazos antes ou despois do valor.

Success:
{"ok":true}

{"ok":true}
done

6. Analizar HTML no lugar de JSON

Chamar a response.json() sobre unha páxina HTML é un caso habitual de Unexpected token. Extremos incorrectos, páxinas HTML 404 ou 500, redireccións de login, corpos de proxy e páxinas de recambio adoitan comezar con marcado. «Unexpected token < sempre significa HTML» é demasiado forte: < é unha pista, non unha proba.

fetch('/api/data')
  .then(response => response.json())

Que adoita querer dicir “Unexpected token <”?

Os valores JSON non adoitan comezar por <. Se o corpo comeza con ou , < pode ser o primeiro carácter ilegal. Na depuración local, mire o estado HTTP, Content-Type e o corpo en bruto. A redacción do motor segue variando.

Revise a resposta antes de analízala

O corpo de fetch só se pode consumir unha vez. Na depuración local, lea text() primeiro, inspecte un prefixo curto e despois aplique JSON.parse a esa mesma cadea. Non chame a response.json() e despois a response.text() sobre a mesma resposta. Non rexistre por defecto cargas sensibles de produción.

const response = await fetch(url);
const text = await response.text();

console.log(response.status);
console.log(response.headers.get("content-type"));
console.log(text.slice(0, 200));

try {
  const data = JSON.parse(text);
  console.log(data);
} catch (error) {
  console.error("Invalid JSON:", error);
}

Que quere dicir “at position 123”?

Algúns motores informan unha posición, liña ou columna. Mire preto unha comiña, coma, chave ou escape incorrectos. Ese índice é onde a análise notou un problema; a causa real pode estar antes. Non está garantido que sexa o carácter defectuoso exacto.

Unexpected token fronte a Unexpected end

Unexpected token quere dicir que o analizador atopou un carácter que non agardaba. Unexpected end pode aparecer cando a entrada para antes de que o valor estea completo, como en {“name”:“Alex” sen chave de peche. A redacción exacta depende do motor. Erros habituais de JSON: coma final, comiñas e Unexpected token cobre o JSON incompleto con máis amplitude.

{"name":"Alex"

JSON non é o mesmo ca un literal de obxecto JavaScript

JSON é un formato de datos. Un literal de obxecto JavaScript é sintaxe JavaScript. O obxecto JS con chaves sen comiñas, comiñas simples e unha coma final non é texto JSON válido. JSON.parse non pode analizar con seguridade literais de obxecto JavaScript.

const data = {
  name: 'Alex',
  active: true,
};

{
  "name": "Alex",
  "active": true
}

Pode JSON conter comentarios?

O JSON estándar non admite comentarios. Unha liña // dentro dun obxecto é inválida. JSON5 e extensións semellantes son formatos distintos. Formatador e comparación de JSON valida JSON estándar con JSON.parse e non trata JSON5 como JSON.

{
  // user name
  "name": "Alex"
}

Son válidos en JSON undefined, NaN e Infinity?

Non. Os valores JSON son obxecto, array, cadea, número, true, false e null. undefined, NaN e Infinity non o son. Un valor de nivel superior non ten que ser un obxecto ou un array: true, 123, “hello” e null son JSON válido.

{"a":undefined}
{"a":NaN}
{"a":Infinity}

true
123
"hello"
null

Como corrixir un erro Unexpected token paso a paso

Traballe a fonte, non a cadea do erro:

1. Confirme que a entrada é realmente JSON, non HTML, rexistros ou JavaScript.
2. Inspecte os primeiros caracteres da entrada en bruto.
3. Se veu dunha API, revise o estado HTTP e Content-Type. Nin 200 nin application/json garanten JSON válido.
4. Valide a sintaxe nun analizador JSON.
5. Use calquera posición, liña ou columna indicada como pista, non como a causa raíz garantida.
6. Revise comiñas, comas, chaves, corchetes e escapes preto desa zona.
7. Compare cunha copia formatada e validada.
8. Corrixa o serializador ou o endpoint. Non borre o testemuño indicado ao chou.

Use JSON.stringify() ao producir JSON en JavaScript

Prefira JSON.stringify a concatenar cadeas a man. Emite texto JSON válido para os valores que serializa. Non conserva todos os valores JavaScript: undefined, as funcións e os símbolos teñen un comportamento especial. Ese detalle queda fóra de alcance aquí.

const data = {
  name: "Alex",
  active: true
};
const json = JSON.stringify(data);
// {"name":"Alex","active":true}

JSON inválido fronte a unha corrección real

Estes pares comprobáronse con JSON.parse. Para HTML, a corrección é a resposta, non un retoque de sintaxe.

Problema	Inválido	Corrección
Comiñas simples	{'a':1}	{"a":1}
Coma final	{"a":1,}	{"a":1}
Chave sen comiñas	{a:1}	{"a":1}
undefined	{"a":undefined}	{"a":null}
Corpo HTML	<html>...	Revise o endpoint e a resposta en bruto. Non edite HTML para convertelo en JSON.

Unha guía simple de decisión para Unexpected token

Se JSON.parse fallou, decida se sequera ten JSON antes de reescribir comiñas.

• JSON.parse fallou
• ↓
• Dunha API? Revise estado, Content-Type e o corpo en bruto
• Comeza como JSON? Se non, corrixa a fonte ou o endpoint
• Se si, valide comiñas, comas, chaves, corchetes, escapes, valores non admitidos
• Use a posición indicada como pista
• ↓
• Corrixa a fonte e volva analizar

Valide JSON antes de analízalo ou usalo

NEXNARA Formatador e comparación de JSON valida JSON no navegador con JSON.parse—non eval.

Valida, formata con 2 espazos, 4 espazos ou tabuladores, minifica, copia, descarga e sobe .json. JSON Diff cobre obxectos e arrays aniñados, rutas, resumo, filtros e intercambio. Tras a análise, as copias formatada e minificada dos mesmos datos compáranse como iguais; as chaves de obxecto compáranse por nome.

O texto de máis de 5 MB pode ir lento. O texto de máis de 15 MB non se procesa no navegador.

A validación e o formatado de JSON ocorren no seu navegador. Esta ferramenta non envía o JSON a un servidor de NEXNARA. Os anuncios e outras funcións do sitio si usan a rede.

Pegue a cadea que falla en Formatador e comparación de JSON e lea os primeiros caracteres antes de reescribir comiñas.

FAQ

Por que JSON.parse di Unexpected token?

O texto non é JSON válido no punto no que o analizador parou. Causas típicas: comiñas, comas, texto de máis ou un corpo que non é JSON, como HTML.

Que quere dicir Unexpected token < in JSON?

O primeiro carácter ilegal pode ser <. Iso a miúdo apunta a unha páxina HTML, mais non é proba dun 404 nin de HTML en todos os casos. Revise o estado, Content-Type e o corpo en bruto.

Como atopo a posición do erro en JSON?

Se o motor informa unha posición, liña ou columna, mire preto. O fallo real pode estar antes. Úsaa como pista e despois valide.

Pode JSON usar comiñas simples?

Non. No JSON estándar, as cadeas e os nomes de membro usan comiñas dobres.

Pode JSON ter comas finais?

Non. O JSON estándar non permite unha coma despois da última propiedade ou do último elemento de array.

Como comprobo se unha cadea é JSON válido?

Chame a JSON.parse nun try/catch, ou pegue o texto en Formatador e comparación de JSON. Se a análise laza SyntaxError, a cadea non é JSON válido.