Bagaimana cara menguji apakah suatu string adalah JSON atau tidak?

Saya punya panggilan AJAX sederhana, dan server akan mengembalikan string JSON dengan data yang berguna atau string pesan kesalahan yang dihasilkan oleh fungsi PHP mysql_error(). Bagaimana saya bisa menguji apakah data ini adalah string JSON atau pesan kesalahan.

Akan menyenangkan untuk menggunakan fungsi yang disebut isJSONsama seperti Anda dapat menggunakan fungsi instanceofuntuk menguji apakah ada sesuatu yang merupakan Array.

Ini yang aku inginkan:

if (isJSON(data)){
    //do some data stuff
}else{
    //report the error
    alert(data);
}

Gunakan JSON.parse

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
}

Kode ini JSON.parse(1234)atau JSON.parse(0)atau JSON.parse(false)atau JSON.parse(null)semuanya akan kembali benar.

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
}

Jadi saya menulis ulang kode dengan cara ini:

function isJson(item) {
    item = typeof item !== "string"
        ? JSON.stringify(item)
        : item;

    try {
        item = JSON.parse(item);
    } catch (e) {
        return false;
    }

    if (typeof item === "object" && item !== null) {
        return true;
    }

    return false;
}

Hasil pengujian:

isJson hasil tes

Mari kita rekap ini (untuk 2019+).

Argumen : Nilai-nilai seperti true, false, nullberlaku JSON (?)

FAKTA : Nilai-nilai primitif ini adalah JSON-parsable tetapi mereka bukan struktur JSON yang terbentuk dengan baik. Spesifikasi JSON menunjukkan JSON dibangun di atas dua struktur: Kumpulan pasangan nama / nilai (objek) atau daftar nilai yang terurut (array).

Argumen : Penanganan pengecualian tidak boleh digunakan untuk melakukan sesuatu yang diharapkan.
(Ini adalah komentar yang memiliki 25+ upvotes!)

FAKTA : Tidak! Sudah pasti legal untuk menggunakan try / catch, terutama dalam kasus seperti ini. Jika tidak, Anda harus melakukan banyak hal analisis string seperti operasi tokenizing / regex; yang akan memiliki kinerja yang buruk.

hasJsonStructure()

Ini berguna jika tujuan Anda adalah untuk memeriksa apakah beberapa data / teks memiliki format pertukaran JSON yang tepat.

function hasJsonStructure(str) {
    if (typeof str !== 'string') return false;
    try {
        const result = JSON.parse(str);
        const type = Object.prototype.toString.call(result);
        return type === '[object Object]' 
            || type === '[object Array]';
    } catch (err) {
        return false;
    }
}

Pemakaian:

hasJsonStructure('true')             // —» false
hasJsonStructure('{"x":true}')       // —» true
hasJsonStructure('[1, false, null]') // —» true

safeJsonParse()

Dan ini berguna jika Anda ingin berhati-hati saat mengurai beberapa data ke nilai JavaScript.

function safeJsonParse(str) {
    try {
        return [null, JSON.parse(str)];
    } catch (err) {
        return [err];
    }
}

Pemakaian:

const [err, result] = safeJsonParse('[Invalid JSON}');
if (err) {
    console.log('Failed to parse JSON: ' + err.message);
} else {
    console.log(result);
}

Jika server merespons dengan JSON maka ia akan memiliki tipe application/jsonkonten, jika merespons dengan pesan teks biasa maka ia harus memiliki tipe text/plainkonten. Pastikan server merespons dengan tipe konten yang benar dan mengujinya.

saat menggunakan jQuery $.ajax()respons akan memiliki responseJSONproperti jika responsnya adalah JSON, ini dapat diperiksa seperti ini:

if (xhr.hasOwnProperty('responseJSON')) {}

Saya suka jawaban terbaik tetapi jika itu adalah string kosong mengembalikan benar. Jadi inilah perbaikannya:

function isJSON(MyTestStr){
    try {
        var MyJSON = JSON.stringify(MyTestStr);
        var json = JSON.parse(MyJSON);
        if(typeof(MyTestStr) == 'string')
            if(MyTestStr.length == 0)
                return false;
    }
    catch(e){
        return false;
    }
    return true;
}

var parsedData;

try {
    parsedData = JSON.parse(data)
} catch (e) {
    // is not a valid JSON string
}

Namun, saya akan menyarankan kepada Anda bahwa panggilan / layanan http Anda harus selalu mengembalikan data dalam format yang sama. Jadi jika Anda memiliki kesalahan, maka Anda harus memiliki objek JSON yang membungkus kesalahan ini:

{"error" : { "code" : 123, "message" : "Foo not supported" } } 

Dan mungkin menggunakan status HTTP serta kode 5xx.

Yah ... Itu tergantung cara Anda menerima data Anda. Saya pikir server merespons dengan string yang diformat JSON (menggunakan json_encode () dalam PHP, misalnya). Jika Anda menggunakan posting JQuery dan mengatur data respons menjadi format JSON dan itu adalah JSON yang salah bentuk, ini akan menghasilkan kesalahan:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        //Supposing x is a JSON property...
        alert(response.x);

  },
  dataType: 'json',
  //Invalid JSON
  error: function (){ alert("error!"); }
});

Tetapi, jika Anda menggunakan respons tipe sebagai teks, Anda perlu menggunakan $ .parseJSON. Menurut situs jquery: "Melewati string JSON yang salah dapat menghasilkan pengecualian yang dilemparkan". Dengan demikian kode Anda akan:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        try {
            parsedData = JSON.parse(response);
        } catch (e) {
            // is not a valid JSON string
        }

  },
  dataType: 'text',
});

Mungkin ada tes yang dapat Anda lakukan, misalnya jika Anda tahu bahwa JSON yang dikembalikan selalu akan dikelilingi oleh {dan }kemudian Anda dapat menguji untuk karakter-karakter itu, atau metode peretasan lainnya. Atau Anda bisa menggunakan pustaka JS json.org untuk mencoba dan menguraikannya dan mengujinya jika berhasil.

Namun saya akan menyarankan pendekatan yang berbeda. Skrip PHP Anda saat ini mengembalikan JSON jika panggilan berhasil, tetapi ada yang lain jika tidak. Mengapa tidak selalu mengembalikan JSON?

Misalnya

Panggilan sukses:

{ "status": "success", "data": [ <your data here> ] }

Panggilan salah:

{ "status": "error", "error": "Database not found" }

Ini akan membuat menulis sisi klien Anda JS jauh lebih mudah - yang harus Anda lakukan adalah memeriksa "status" anggota dan bertindak sesuai.

Saya hanya menggunakan 2 baris untuk melakukan itu:

var isValidJSON = true;
try { JSON.parse(jsonString) } catch { isValidJSON = false }

Itu saja!

Namun perlu diingat ada 2 jebakan:
1. JSON.parse(null)return null
2. Semua angka atau string dapat diuraikan dengan JSON.parse()metode.
   JSON.parse("5")mengembalikan 5
   JSON.parse(5)pengembalian5

Mari kita bermain kode:

// TEST 1
var data = '{ "a": 1 }'

// Avoiding 'null' trap! Null is confirmed as JSON.
var isValidJSON = data ? true : false
try { JSON.parse(data) } catch(e) { isValidJSON = false }

console.log("data isValidJSON: ", isValidJSON);
console.log("data isJSONArray: ", isValidJSON && JSON.parse(data).length ? true : false);

Console outputs:
data isValidJSON:  true
data isJSONArray:  false


// TEST 2
var data2 = '[{ "b": 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data2) } catch(e) { isValidJSON = false }

console.log("data2 isValidJSON: ", isValidJSON);
console.log("data2 isJSONArray: ", isValidJSON && JSON.parse(data2).length ? true : false);

Console outputs:
data2 isValidJSON:  true
data2 isJSONArray:  true


// TEST 3
var data3 = '[{ 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data3) } catch(e) { isValidJSON = false }

console.log("data3 isValidJSON: ", isValidJSON);
console.log("data3 isJSONArray: ", isValidJSON && JSON.parse(data3).length ? true : false);

Console outputs:
data3 isValidJSON:  false
data3 isJSONArray:  false


// TEST 4
var data4 = '2'

var isValidJSON = data ? true : false
try { JSON.parse(data4) } catch(e) { isValidJSON = false }

console.log("data4 isValidJSON: ", isValidJSON);
console.log("data4 isJSONArray: ", isValidJSON && JSON.parse(data4).length ? true : false);


Console outputs:
data4 isValidJSON:  true
data4 isJSONArray:  false


// TEST 5
var data5 = ''

var isValidJSON = data ? true : false
try { JSON.parse(data5) } catch(e) { isValidJSON = false }

console.log("data5 isValidJSON: ", isValidJSON);
console.log("data5 isJSONArray: ", isValidJSON && JSON.parse(data5).length ? true : false);


Console outputs:
data5 isValidJSON:  false
data5 isJSONArray:  false

// TEST 6
var data6; // undefined

var isValidJSON = data ? true : false
try { JSON.parse(data6) } catch(e) { isValidJSON = false }

console.log("data6 isValidJSON: ", isValidJSON);
console.log("data6 isJSONArray: ", isValidJSON && JSON.parse(data6).length ? true : false);

Console outputs:
data6 isValidJSON:  false
data6 isJSONArray:  false

Anda dapat mencoba mendekodekannya dan menangkap pengecualian (asli atau json2.js ):

try {
  newObj = JSON.parse(myJsonString);
} catch (e) {
  console.log('Not JSON');
}

Namun, saya menyarankan agar respons JSON selalu valid. Jika Anda mendapatkan kesalahan kembali dari permintaan MySQL Anda, cukup kirim kembali JSON dengan kesalahan:

{"error":"The MySQL error string."}

Lalu:

if (myParsedJSON.error) {
  console.log('An error occurred: ' + myParsedJSON.error);
}

Peringatan: Untuk metode yang mengandalkan JSON.parse- Array dan kutipan string yang dikelilingi akan berlalu juga (mis. console.log(JSON.parse('[3]'), JSON.parse('"\uD800"')))

Untuk menghindari semua primitif JSON non-objek (boolean, null, array, number, string), saya sarankan menggunakan yang berikut ini:

/* Validate a possible object ie. o = { "a": 2 } */
const isJSONObject = (o) => 
  !!o && (typeof o === 'object') && !Array.isArray(o) && 
  (() => { try { return Boolean(JSON.stringify(o)); } catch { return false } })()

/* Validate a possible JSON object represented as string ie. s = '{ "a": 3 }' */
function isJSONObjectString(s) {
    try {
        const o = JSON.parse(s);
        return !!o && (typeof o === 'object') && !Array.isArray(o)
    } catch {
        return false
    }
}

Penjelasan Kode

• !! o - Tidak palsu (tidak termasuk null, yang mendaftar sebagai jenis 'objek')
• (typeof o === 'objek') - Tidak termasuk boolean, angka, dan string
• ! Array.isArray (o) - Kecualikan array (yang mendaftar sebagai jenis 'objek')
• coba ... JSON.stringify / JSON.parse - Minta mesin JavaScript untuk menentukan apakah JSON valid

Mengapa tidak menggunakan jawaban hasJsonStructure ()?

Mengandalkan toString()bukan ide yang bagus. Ini karena Mesin JavaScript yang berbeda dapat mengembalikan representasi string yang berbeda. Secara umum, metode yang mengandalkan ini dapat gagal di lingkungan yang berbeda atau dapat mengalami kegagalan nanti jika mesin mengubah hasil string

Mengapa menangkap pengecualian bukan peretasan?

Dikatakan bahwa menangkap pengecualian untuk menentukan validitas sesuatu tidak pernah merupakan cara yang tepat untuk dilakukan. Ini umumnya nasihat yang baik, tetapi tidak selalu. Dalam hal ini, penangkapan pengecualian kemungkinan adalah rute terbaik karena bergantung pada implementasi mesin JavaScript dalam memvalidasi data JSON.

Mengandalkan mesin JS menawarkan keuntungan berikut:

1. Lebih teliti dan terus diperbarui seiring dengan perubahan spesifikasi JSON
2. Kemungkinan untuk berjalan lebih cepat (karena ini kode level lebih rendah)

Ketika diberi kesempatan untuk bersandar pada mesin JavaScript, saya sarankan melakukannya. Khususnya dalam hal ini. Meskipun mungkin terasa gila untuk menangkap pengecualian, Anda benar-benar hanya menangani dua status pengembalian yang mungkin dari metode eksternal.

Ini adalah kode dengan sedikit modifikasi dalam jawaban Bourne. Karena JSON.parse (angka) berfungsi dengan baik tanpa kecuali sehingga ditambahkan isNaN.

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return isNaN(str);
}

Semua string json dimulai dengan '{' atau '[' dan diakhiri dengan '}' atau '] yang sesuai, jadi cukup periksa untuk itu.

Begini cara Angular.js melakukannya:

var JSON_START = /^\[|^\{(?!\{)/;
var JSON_ENDS = {
  '[': /]$/,
  '{': /}$/
};

function isJsonLike(str) {
    var jsonStart = str.match(JSON_START);
    return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
}

https://github.com/angular/angular.js/blob/v1.6.x/src/ng/http.js

Saya sarankan dalam mode skrip:

export function stringify(data: any): string {
    try {
         return JSON.stringify(data)
    } catch (e) {
         return 'NOT_STRINGIFIABLE!'
    }
}

Saya menggunakan yang ini (semacam campuran jawaban yang berbeda, tapi tetap saja):

const isJSON = str => {
  if (typeof str === 'string'){
    try {
      JSON.parse(str)
      return true
    } catch(e){
    }
  }
  return false
}



[null, undefined, false, true, [], {}, 
 '', 'asdf', '{}', '[]', "{\"abc\": 2}","{\"abc\": \"2\"}"]
  .map(el => {
      console.log(`[>${el}<] - ${isJSON(el)}`)
})

console.log('-----------------')

Anda dapat mencoba yang berikut karena ini juga memvalidasi angka, null, string tetapi jawaban yang ditandai di atas tidak berfungsi dengan benar itu hanya perbaikan dari fungsi di atas:

function isJson(str) {
  try {
      const obj = JSON.parse(str);
      if (obj && typeof obj === `object`) {
        return true;
      }
    } catch (err) {
      return false;
    }
   return false;
}

Selain jawaban sebelumnya, jika Anda perlu memvalidasi format JSON seperti "{}", Anda dapat menggunakan kode berikut:

const validateJSON = (str) => {
  try {
    const json = JSON.parse(str);
    if (Object.prototype.toString.call(json).slice(8,-1) !== 'Object') {
      return false;
    }
  } catch (e) {
    return false;
  }
  return true;
}

Contoh penggunaan:

validateJSON('{}')
true
validateJSON('[]')
false
validateJSON('')
false
validateJSON('2134')
false
validateJSON('{ "Id": 1, "Name": "Coke" }')
true