Як перевірити, чи є рядок JSON чи ні?

У мене простий AJAX-дзвінок, і сервер поверне або рядок JSON з корисними даними, або рядок повідомлення про помилку, вироблений функцією PHP mysql_error(). Як я можу перевірити, чи є ці дані рядком JSON або повідомлення про помилку.

Було б непогано використовувати функцію, яка називається так isJSONсамо, як ви можете скористатися функцією instanceofдля перевірки, чи щось є масив.

Це те, що я хочу:

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

Використовуйте JSON.parse

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

Цей код JSON.parse(1234)або JSON.parse(0)або JSON.parse(false)або JSON.parse(null)все повертає істину.

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

Тому я переписав код таким чином:

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

Результат тестування:

є результат тестування Джона

Давайте резюмуємо це (для 2019+).

Аргумент : Значення , такі як true, false, nullдійсні в форматі JSON (?)

ФАКТ : Ці примітивні значення можна порівняти з JSON, але вони не є добре сформованими структурами JSON . Специфікація JSON вказує, що JSON побудований на двох структурах: набір пар імен / значень (об'єкт) або упорядкований список значень (масив).

Аргумент : Поводження з винятками не повинно використовуватися для виконання чогось очікуваного.
(Це коментар, який містить 25+ оновлень!)

ФАКТ : Ні! Однозначно законно використовувати try / catch, особливо у такому випадку. В іншому випадку вам знадобиться зробити багато матеріалів аналізу рядків, таких як операції з токенізацією / регексом; які мали б жахливі результати.

hasJsonStructure()

Це корисно, якщо ваша мета - перевірити, чи деякі дані / текст мають належний формат обміну JSON.

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

Використання:

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

safeJsonParse()

І це корисно, якщо ви хочете бути обережними при аналізі деяких даних на значення JavaScript.

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

Використання:

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

Якщо сервер відповідає JSON, він матиме тип application/jsonвмісту, якщо він відповідає звичайним текстовим повідомленням, то він повинен мати text/plainтип вмісту. Переконайтесь, що сервер відповідає відповідним типом вмісту і перевірити це.

при використанні jQuery $.ajax()відповіді буде responseJSONвластивість, якщо відповідь була JSON, це можна перевірити так:

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

Мені подобається найкраща відповідь, але якщо це порожній рядок, він повертає істину. Тож ось виправлення:

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
}

Однак я пропоную вам, щоб ваш http-дзвінок / послуга завжди повертав дані в тому самому форматі. Отже, якщо ви маєте помилку, тоді у вас повинен бути об’єкт JSON, який завершує цю помилку:

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

І, можливо, використовувати, а також HTTP статус 5xx код.

Ну ... Це залежить від способу отримання ваших даних. Я думаю, що сервер відповідає за допомогою форматованого рядка JSON (використовуючи json_encode () у PHP, наприклад). Якщо ви використовуєте повідомлення JQuery і встановлюєте дані відповіді форматом JSON, і це JSON, який неправильно формується, це призведе до помилки:

$.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!"); }
});

Але якщо ви використовуєте відповідь типу як текст, вам потрібно використовувати $ .parseJSON. Як повідомляє сайт jquery: "Передача в неправильно сформовану рядок JSON може призвести до викидання виключення". Таким чином ваш код буде:

$.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',
});

Напевно, ви можете зробити тести, наприклад, якщо ви знаєте, що повернений JSON завжди буде оточений, {і }тоді ви можете протестувати на цих персонажів чи якийсь інший хакі-метод. Або ви могли б використовувати json.org JS бібліотеку , щоб спробувати розібрати його і випробування , якщо це вдасться.

Однак я б запропонував інший підхід. Ваш сценарій PHP наразі повертає JSON, якщо виклик вдалий, але щось інше, якщо його немає. Чому б не завжди повернути JSON?

Напр

Успішний дзвінок:

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

Помилковий дзвінок:

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

Це полегшило б написання вашої клієнтської сторони JS - все, що вам потрібно зробити, це перевірити "статусу" члена та діяти відповідно.

Для цього я використовую лише два рядки:

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

Це все!

Але майте на увазі, що є 2 пастки:
1. JSON.parse(null)повертає null
2. Будь-яке число або рядок можна проаналізувати JSON.parse()методом.
   JSON.parse("5")повертає 5
   JSON.parse(5)прибутки5

Давайте пограємо в код:

// 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

Ви можете спробувати розшифрувати його і зафіксувати виняток (рідний або json2.js ):

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

Однак я б запропонував зробити відповідь завжди дійсною JSON. Якщо ви отримаєте помилку з вашого запиту MySQL, просто надішліть назад JSON з помилкою:

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

І потім:

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

Попередження: Для методів, на які покладається JSON.parse- Масиви та цитати, оточені рядки, також будуть передані (тобто console.log(JSON.parse('[3]'), JSON.parse('"\uD800"')))

Щоб уникнути всіх необ'єктних примітивів JSON (булева, null, масив, число, рядок), я пропоную використовувати наступне:

/* 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
    }
}

Пояснення коду

• !! o - Не хибний (виключає null, який реєструється як typeof 'object')
• (typeof o === 'object') - Виключає булева, число та рядок
• ! Array.isArray (o) - Виключити масиви (які реєструються як typeof 'object')
• спробуйте ... JSON.stringify / JSON.parse - Попросить движок JavaScript визначити, чи дійсний JSON

Чому б не використати відповідь hasJsonStructure ()?

Покладатися на toString()це не дуже гарна ідея. Це пояснюється тим, що різні двигуни JavaScript можуть повертати інше рядкове представлення. Взагалі методи, які покладаються на це, можуть вийти з ладу в різних умовах або можуть згодом зазнати збою, якщо двигун колись змінить результат рядка

Чому ловити виняток - не хак?

Було висунуто, що пошук винятку для визначення дійсності чогось ніколи не є правильним шляхом. Це взагалі гарна порада, але не завжди. У цьому випадку найкращим маршрутом є вилучення винятків, оскільки воно спирається на реалізацію JavaScript механізмом перевірки даних JSON.

Покладаючись на двигун JS, пропонуються наступні переваги:

1. Більш ретельне та постійне оновлення в міру зміни специфікацій JSON
2. Ймовірно, працює швидше (оскільки це код нижчого рівня)

Коли мені нададуть можливість спиратися на механізм JavaScript, я б запропонував це зробити. Особливо так у цьому випадку. Хоча, можливо, здається, що випробувати виняток хакі, ви дійсно просто обробляєте два можливих стани повернення із зовнішнього методу.

Ось код з незначною модифікацією у відповіді Борна. Оскільки JSON.parse (число) працює без будь-яких винятків, так додано isNaN.

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

Всі рядки json починаються з '{' або '[' і закінчуються відповідним '}' або ']', тому просто перевірте це.

Ось як це робить Angular.js:

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

Я пропоную в режимі Typescript:

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

Я використовував цей (вид суміші різних відповідей, але все одно):

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('-----------------')

Ви можете спробувати наступне, тому що воно також підтверджує число, null, string, але зазначена вище відповідь не працює належним чином, це лише виправлення наведеної вище функції:

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

На додаток до попередніх відповідей, якщо вам потрібно перевірити формат JSON типу "{}", ви можете використовувати наступний код:

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

Приклади використання:

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