Membaca Pesan Errornya

Error ini muncul ketika kamu mencoba mem-parsing sebuah string yang seharusnya berformat JSON, tetapi parser menemukan karakter yang tidak valid tepat setelah kurung kurawal pembuka {. Pesan error lengkapnya biasanya terlihat seperti ini:

SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2)

Pesan ini ditampilkan oleh engine JavaScript (V8 di Node.js maupun browser) ketika metode JSON.parse() dipanggil pada string yang secara struktur tidak memenuhi spesifikasi JSON. Kata "Expected property name" berarti parser mengharapkan sebuah nama properti — yaitu string yang diapit tanda kutip ganda "..." — atau alternatifnya karakter } yang menandakan objek kosong. Namun yang ditemukan justru karakter lain, sehingga parsing gagal di posisi karakter kedua (index 1, karena index dimulai dari 0).

Dalam bahasa Indonesia, error ini kurang lebih berarti: "Diharapkan nama properti atau '}' dalam JSON pada posisi 1 (baris 1 kolom 2)". Artinya, karakter kedua dari string JSON kamu sudah salah menurut aturan JSON.

Kenapa error ini muncul? Intinya, ada perbedaan mendasar antara sintaks JavaScript object literal dan JSON string. Banyak developer menulis objek dengan tanda kutip tunggal atau bahkan tanpa tanda kutip pada key — sah di JavaScript, tapi ilegal di JSON. Ketika objek semacam ini di-string-kan secara manual atau di-parse sebagai JSON, mesin JSON parser akan menolaknya karena melanggar spesifikasi RFC 8259.

// Ini JavaScript object literal — VALID di JS, BUKAN JSON valid
const obj = { name: "Andi", age: 25 };
const badJson = "{'name':'Andi','age':25}";

// Kedua hal di atas akan gagal jika diparsing sebagai JSON
JSON.parse(badJson);
// SyntaxError: Expected property name or '}' in JSON at position 1

Perhatikan bahwa posisi 1 merujuk pada karakter kedua dari string, yaitu tanda kutip tunggal ' pada '{, padahal JSON hanya mengizinkan tanda kutip ganda " sebagai pembatas string dan property name.

Akar Masalahnya

Berikut adalah root cause yang paling sering menyebabkan error ini, diurutkan dari yang paling banyak ditemui di lapangan:

  • Key properti menggunakan tanda kutip tunggal (') bukan kutip ganda ("). Ini adalah penyebab paling dominan. Developer menulis {'key': 'value'} dan mengira itu JSON valid. JSON parser membaca ' di posisi 1 dan langsung gagal karena mengharapkan " atau }.

  • Key properti tidak diapit tanda kutip sama sekali. Menulis {name: "Andi"} adalah JavaScript object literal yang benar, tapi bukan JSON. Tanpa kutip, parser melihat huruf n di posisi 1 dan gagal karena mengharapkan " atau }.

  • Koma trailing (trailing comma) di akhir objek atau array. Menulis {"name": "Andi",} membuat parser menemukan } setelah koma, yang tidak diizinkan oleh spesifikasi JSON. Meskipun pesan error-nya bisa sedikit berbeda ("Unexpected token }"), ini sering muncul bersamaan dengan masalah kutip dan memperumit debugging.

  • Karakter invisible atau BOM (Byte Order Mark) di awal string. Jika file JSON disimpan dengan encoding UTF-8 BOM, ada karakter \uFEFF tersembunyi di awal. Parser melihat BOM di posisi 0 dan { di posisi 1, atau sebaliknya, sehingga menghasilkan error yang serupa.

  • Output dari console.log atau serialisasi non-standar yang diparse ulang. Misalnya, output dari util.inspect di Node.js atau REPL yang menggunakan kutip tunggal secara otomatis, kemudian string itu di-JSON.parse() kembali.

Untuk memastikan penyebab mana yang kamu alami, cara paling langsung adalah mencetak representasi karakter per karakter dari string yang gagal di-parse, khususnya beberapa karakter pertama:

const badJson = "{'name':'Andi'}";

// Cek karakter pertama
console.log(badJson[0]);  // {
console.log(badJson[1]);  // '  ← ini kutip tunggal, bukan kutip ganda!
console.log(badJson.charCodeAt(1));  // 39 (kode ASCII kutip tunggal)

// Bandingkan dengan JSON valid
const goodJson = '{"name":"Andi"}';
console.log(goodJson[1]);           // "
console.log(goodJson.charCodeAt(1)); // 34 (kode ASCII kutip ganda)

Jika charCodeAt(1) mengembalikan 39, penyebabnya adalah kutip tunggal. Jika mengembalikan kode huruf alfabet, penyebabnya adalah key tanpa kutip. Jika mengembalikan 65279, penyebabnya adalah BOM.

Cara Memperbaiki

Berikut adalah langkah-langkah perbaikan yang bisa kamu ikuti secara berurutan, dari identifikasi masalah hingga verifikasi bahwa solusi berhasil.

Langkah 1: Identifikasi karakter bermasalah di posisi 1.

Cetak kode karakter kedua dari string JSON kamu untuk mengetahui secara pasti karakter apa yang menyebabkan parsing gagal.

const input = "{'name':'Andi','age':25}";
console.log('Karakter di posisi 1:', input[1], '| Code:', input.charCodeAt(1));
// Output: Karakter di posisi 1: ' | Code: 39

Output yang diharapkan: kamu mengetahui apakah masalahnya kutip tunggal (39), huruf tanpa kutip, atau BOM (65279).

Langkah 2: Ganti kutip tunggal dengan kutip ganda pada seluruh string.

Jika penyebabnya adalah kutip tunggal, lakukan replace menyeluruh. Perhatikan urutan replace: ganti kutip ganda dulu ke placeholder agar tidak tertimpa.

const input = "{'name':'Andi','age':25}";

// Replace kutip tunggal jadi kutip ganda
// Langkah aman: karena nilai string internal mungkin mengandung kutip ganda
const fixed = input.replace(/'/g, '"');

console.log(fixed);
// Output: {"name":"Andi","age":25}

const result = JSON.parse(fixed);
console.log(result);
// Output: { name: 'Andi', age: 25 }

Namun cara naïve replace(/'/g, '"') berisiko jika nilai properti mengandung kutip tunggal yang memang sengaja ada (misalnya "It's mine"). Untuk kasus kompleks, gunakan pendekatan Langkah 3.

Langkah 3: Jika input adalah JavaScript object literal, gunakan JSON.stringify sebagai perantara.

Ketika data kamu sudah berupa objek JavaScript di memori (bukan string), jangan manually construct string JSON. Gunakan JSON.stringify() yang selalu menghasilkan JSON valid.

// Kamu punya object literal di kode JS
const obj = { name: "Andi", age: 25 };

// JANGAN manual: const badJson = "{'name':'Andi'}";
// LAKUKAN ini:
const validJsonString = JSON.stringify(obj);
console.log(validJsonString);
// Output: {"name":"Andi","age":25}

// Sekarang safe untuk parse kembali
const parsed = JSON.parse(validJsonString);
console.log(parsed.name); // Andi

Output yang diharapkan: string JSON yang valid dengan semua key dan value diapit kutip ganda, tanpa trailing comma.

Langkah 4: Hapus trailing comma jika ada.

const withTrailingComma = '{"name":"Andi",}';
// Hapus koma sebelum } atau ]
const noTrailing = withTrailingComma.replace(/,\s*([}\]])/g, '$1');
console.log(noTrailing);
// Output: {"name":"Andi"}

const parsed = JSON.parse(noTrailing);
console.log(parsed);
// Output: { name: 'Andi' }

Langkah 5: Hapus BOM jika terdeteksi.

const fs = require('fs');
let content = fs.readFileSync('data.json', 'utf8');

// Hapus BOM jika ada
if (content.charCodeAt(0) === 0xFEFF) {
  content = content.slice(1);
}

const data = JSON.parse(content);
console.log(data);

Cara verifikasi solusi berhasil: Setelah menerapkan fix, panggil JSON.parse() pada string yang sudah diperbaiki. Jika tidak melempar exception dan mengembalikan objek JavaScript yang benar, maka solusi berhasil. Kamu juga bisa menambahkan validasi schema sederhana:

try {
  const data = JSON.parse(fixedString);
  console.log('✅ JSON valid. Keys:', Object.keys(data));
} catch (e) {
  console.log('❌ Masih gagal:', e.message);
}

Perbaikan Permanen

Solusi step-by-step di atas bersifat reaktif — memperbaiki string yang sudah rusak. Fix permanen berarti mencegah string JSON invalid terbentuk sejak awal, baik di kode maupun di tooling.

Konfigurasi ESLint untuk mencegah kesalahan JSON di kode JavaScript.

ESLint dengan rule quotes dan aturan ketat bisa membantu memastikan kamu konsisten menggunakan kutip ganda di seluruh codebase, mengurangi kebiasaan menulis kutip tunggal yang lalu terbawa ke konteks JSON.

// .eslintrc.json
{
  "rules": {
    "quotes": ["error", "double", { "avoidEscape": true }],
    "json/*": "error"
  },
  "plugins": ["json"]
}

Plugin eslint-plugin-json secara khusus memvalidasi seluruh file .json dalam projekmu. File JSON yang mengandung trailing comma, kutip tunggal, atau key tanpa kutip akan langsung ditandai sebagai error oleh linter bahkan sebelum runtime.

Konfigurasi Editor untuk file JSON.

Di VS Code, pastikan file .json menggunakan formatter yang benar. Extension bernama fix-json secara otomatis memperbaiki JSON invalid saat save. Kamu juga bisa mengkonfigurasi setting berikut:

// .vscode/settings.json
{
  "files.encoding": "utf8",
  "json.validate.enable": true,
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

Prettier dengan konfigurasi berikut memastikan seluruh file JSON diformat sesuai spesifikasi:

// .prettierrc
{
  "parser": "json",
  "singleQuote": false,
  "trailingComma": "none"
}

Konfigurasi Node.js: selalu gunakan JSON.stringify untuk serialisasi.

Jangan pernah manually concatenate string JSON. Buat utility function yang menjadi satu-satunya pintu serialisasi di aplikasimu:

// utils/json-safe.js
function safeStringify(data, replacer = null, space = 2) {
  try {
    return JSON.stringify(data, replacer, space);
  } catch (err) {
    throw new Error(`JSON stringify gagal: ${err.message}`);
  }
}

function safeParse(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Input harus string untuk JSON.parse');
  }
  // Hapus BOM
  const cleaned = str.charCodeAt(0) === 0xFEFF ? str.slice(1) : str;
  return JSON.parse(cleaned);
}

module.exports = { safeStringify, safeParse };

Perbedaan antar OS.

Di Windows, file yang disimpan melalui Notepad kadang mendapatkan BOM secara default. Untuk menghindarinya, saat menyimpan file JSON di Notepad, pilih encoding "UTF-8" (bukan "UTF-8 with BOM"). Di Linux dan macOS, editor standar umumnya menyimpan tanpa BOM, sehingga masalah ini lebih jarang ditemui. Namun, jika file ditransfer antar OS melalui copy-paste