Varför säger JSON.parse "Unexpected token"?

Det här är felsökning av Unexpected token i JSON.parse: vad felet betyder, hur du läser positionen och vad du gör när kroppen är HTML. Bredare täckning av avslutande kommatecken, citattecken och Unexpected end finns i Vanliga JSON-fel: avslutande kommatecken, citattecken och Unexpected token.

Vad betyder “Unexpected token” i JSON.parse()?

JSON.parse() kräver JSON-grammatik. Ett otillåtet tecken på aktuell position kastar SyntaxError. {“name”:“Alex”,} är ogiltig: efter det kommatecknet får objektet inte sluta. Meddelandetext och position varierar fortfarande per runtime.

Vilket fel kastar JSON.parse()?

Ogiltig JSON kastar i regel SyntaxError. Logga error.name för att bekräfta typen. Hardkoda inte hela error.message: motorer och versioner formulerar det olika.

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

1. Enkla citattecken i stället för dubbla

{‘name’:‘Alex’} är ogiltig JSON. {“name”:“Alex”} är giltig. JSON-strängar och objektmedlemsnamn använder dubbla citattecken. En JavaScript-objektliteral som const user = { name: ‘Alex’ } kan vara laglig JavaScript och ändå inte vara JSON-text.

Ogiltig

{'name':'Alex'}

Giltig

{"name":"Alex"}

2. Avslutande kommatecken

Ett kommatecken efter sista egenskapen eller sista arrayelementet är inte giltig standard-JSON. {“name”:“Alex”,“age”:30,} och [1, 2, 3,] fallerar båda. Behandla det som en orsak till Unexpected token; Vanliga JSON-fel: avslutande kommatecken, citattecken och Unexpected token går djupare in på avslutande kommatecken.

Ogiltig

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

Giltig

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

[1, 2, 3,]

3. Oquotade egenskapsnamn

{ name: “Alex” } kan vara en JavaScript-objektliteral. I JSON är objektmedlemsnamn strängar och behöver dubbla citattecken: {“name”:“Alex”}.

Ogiltig

{
  name: "Alex"
}

Giltig

{
  "name": "Alex"
}

4. Ogiltig sträng-escape

I JSON-text inleder ett bakstreck en escape. En rå sökväg som C:\Users\Alex är ogiltig eftersom \U inte är en laglig escape. Dubbla bakstrecken. Blanda inte värdspråkets sträng-escape med JSON-escape. Vanliga JSON-fel: avslutande kommatecken, citattecken och Unexpected token täcker detta djupare.

Ogiltig

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

Giltig

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

5. Extra text före eller efter JSON

JSON.parse väntar ett enda JSON-värde. Ett prefix som Success: före {“ok”:true}, eller ett suffix som done efter, gör hela strängen ogiltig. Betydelselös whitespace runt ett ensamt JSON-värde är tillåten. JSON förbjuder inte mellanslag före eller efter värdet.

Success:
{"ok":true}

{"ok":true}
done

6. Parsa HTML i stället för JSON

Att anropa response.json() på en HTML-sida är ett vanligt Unexpected token-fall. Fel endpoint, HTML-sidor vid 404 eller 500, inloggningsomdirigeringar, proxykroppar och fallbacksidor börjar ofta med märkning. ”Unexpected token < betyder alltid HTML” är för starkt: < är en ledtråd, inte ett bevis.

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

Vad brukar “Unexpected token <” betyda?

JSON-värden börjar normalt inte med <. Om kroppen inleds med eller kan < vara det första otillåtna tecknet. Vid lokal felsökning, kontrollera HTTP-status, Content-Type och råkroppen. Motorns formulering varierar fortfarande.

Kontrollera svaret innan du parsar det

Kroppen från fetch kan bara konsumeras en gång. Vid lokal felsökning, läs text() först, inspektera ett kort prefix och kör sedan JSON.parse på samma sträng. Anropa inte response.json() och därefter response.text() på samma svar. Logga inte känsliga produktionslaster som standard.

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

Vad betyder “at position 123”?

Vissa motorer rapporterar en position, rad eller kolumn. Leta i närheten efter fel citattecken, kommatecken, klammer eller escape. Indexet är där parsningen märkte ett problem; den verkliga orsaken kan ligga tidigare. Det är inte garanterat att vara exakt det felaktiga tecknet.

Unexpected token kontra Unexpected end

Unexpected token betyder att parsern mötte ett tecken den inte väntade. Unexpected end kan synas när indata tar slut innan värdet är komplett, som i {“name”:“Alex” utan avslutande klammer. Exakt formulering beror på motorn. Vanliga JSON-fel: avslutande kommatecken, citattecken och Unexpected token täcker ofullständig JSON bredare.

{"name":"Alex"

JSON är inte samma sak som en JavaScript-objektliteral

JSON är ett dataformat. En JavaScript-objektliteral är JavaScript-syntax. JS-objektet med oquotade nycklar, enkla citattecken och avslutande kommatecken är inte giltig JSON-text. JSON.parse kan inte säkert parsa JavaScript-objektliteraler.

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

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

Kan JSON innehålla kommentarer?

Standard-JSON stöder inte kommentarer. En // rad inuti ett objekt är ogiltig. JSON5 och liknande tillägg är andra format. Formatera och jämför JSON validerar standard-JSON med JSON.parse och behandlar inte JSON5 som JSON.

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

Är undefined, NaN och Infinity giltig JSON?

Nej. JSON-värden är objekt, array, sträng, tal, true, false och null. undefined, NaN och Infinity är det inte. Ett toppnivåvärde behöver inte vara objekt eller array: true, 123, “hello” och null är giltig JSON.

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

true
123
"hello"
null

Så rättar du ett Unexpected token-fel steg för steg

Arbeta med källan, inte felsträngen:

1. Bekräfta att indata faktiskt är JSON, inte HTML, loggar eller JavaScript.
2. Inspektera de första tecknen i råindata.
3. Om det kom från ett API, kontrollera HTTP-status och Content-Type. Varken 200 eller application/json garanterar giltig JSON.
4. Validera syntaxen i en JSON-parser.
5. Använd rapporterad position, rad eller kolumn som ledtråd, inte som garanterad rotorsak.
6. Kontrollera citattecken, kommatecken, klamrar, hakparenteser och escape nära det området.
7. Jämför med en formaterad, validerad kopia.
8. Rätta serialiseraren eller endpointen. Radera inte det rapporterade tecknet på måfå.

Använd JSON.stringify() när du skapar JSON i JavaScript

Föredra JSON.stringify framför att sätta ihop strängar för hand. Den emitterar giltig JSON-text för de värden den serialiserar. Den bevarar inte varje JavaScript-värde: undefined, funktioner och symboler har särbeteende. Den detaljen ligger utanför den här texten.

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

Ogiltig JSON kontra en riktig rättning

De här paren kontrollerades med JSON.parse. För HTML är rättningen svaret, inte en syntaxredigering.

Problem	Ogiltig	Rättning
Enkla citattecken	{'a':1}	{"a":1}
Avslutande kommatecken	{"a":1,}	{"a":1}
Oquotad nyckel	{a:1}	{"a":1}
undefined	{"a":undefined}	{"a":null}
HTML-kropp	<html>...	Kontrollera endpointen och råsvaret. Redigera inte HTML till JSON.

En enkel beslutsguide för Unexpected token

Om JSON.parse misslyckades, avgör om du ens har JSON innan du skriver om citattecken.

• JSON.parse misslyckades
• ↓
• Från ett API? Kontrollera status, Content-Type och råkroppen
• Börjar det som JSON? Om inte, rätta källan eller endpointen
• Om ja, validera citattecken, kommatecken, klamrar, hakparenteser, escape, ostödda värden
• Använd den rapporterade positionen som ledtråd
• ↓
• Rätta källan och parsa igen

Validera JSON innan du parsar eller använder den

NEXNARA Formatera och jämför JSON validerar JSON i webbläsaren med JSON.parse—inte eval.

Validera, snygga till med 2 mellanslag, 4 mellanslag eller tabb, minify, kopiera, ladda ner och ladda upp .json. JSON Diff täcker nästlade objekt och arrayer, sökvägar, sammanfattning, filter och byte. Efter parse jämförs snygg och minifierad kopia av samma data som lika; objektnycklar jämförs på namn.

Text större än 5 MB kan kännas långsam. Text större än 15 MB bearbetas inte i webbläsaren.

JSON-validering och formatering sker i din webbläsare. Det här verktyget skickar inte JSON till en NEXNARA-server. Annonser och andra sajtfunktioner använder fortfarande nätverket.

Klistra in den felande strängen i Formatera och jämför JSON och läs de första tecknen innan du skriver om citattecken.

FAQ

Varför säger JSON.parse Unexpected token?

Texten är inte giltig JSON vid den punkt där parsern stannade. Typiska orsaker är citattecken, kommatecken, extra text eller en icke-JSON-kropp som HTML.

Vad betyder Unexpected token < in JSON?

Det första otillåtna tecknet kan vara <. Det pekar ofta mot en HTML-sida, men det är inte bevis för 404 eller för HTML i varje fall. Kontrollera status, Content-Type och råkroppen.

Hur hittar jag felpositionen i JSON?

Om motorn rapporterar en position, rad eller kolumn, titta i närheten. Det verkliga misstaget kan sitta tidigare. Använd det som ledtråd och validera sedan.

Kan JSON använda enkla citattecken?

Nej. I standard-JSON använder strängar och medlemsnamn dubbla citattecken.

Kan JSON ha avslutande kommatecken?

Nej. Standard-JSON tillåter inte ett kommatecken efter sista egenskapen eller sista arrayelementet.

Hur kontrollerar jag om en sträng är giltig JSON?

Anropa JSON.parse i en try/catch, eller klistra in texten i Formatera och jämför JSON. Om parsningen kastar SyntaxError är strängen inte giltig JSON.