Как проверить, является ли строка 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)все вернет true.

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

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

Результаты теста isJson

Давайте повторим это (для 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')) {}

Мне нравится лучший ответ, но если это пустая строка, она возвращает true. Итак, вот исправление:

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 всегда будет окружен, {а }затем вы можете проверить эти символы или какой-нибудь другой хакерский метод. Или вы можете использовать JS-библиотеку json.org, чтобы попытаться проанализировать ее и проверить, успешно ли она работает.

Однако я бы предложил другой подход. Ваш PHP-скрипт в настоящее время возвращает JSON, если вызов успешен, но что-то еще, если это не так. Почему не всегда возвращать JSON?

Например

Успешный звонок:

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

Ошибочный вызов:

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

Это значительно упростит написание JS на стороне клиента - все, что вам нужно сделать, это проверить элемент «status» и действовать соответственно.

Я использую только 2 строки, чтобы выполнить это:

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

Вы можете попробовать расшифровать его и поймать исключение (native или 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-примитивов (логических, нулевых, массивов, чисел, строк), я предлагаю использовать следующее:

/* 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 - не ложно (исключая ноль, который регистрируется как typeof 'объект')
• (typeof o === 'object') - исключает логическое значение, число и строку
• ! Array.isArray (o) - исключить массивы (которые регистрируются как typeof 'object')
• try ... JSON.stringify / JSON.parse - запрашивает движок JavaScript, чтобы определить, действительно ли JSON

Почему бы не использовать ответ hasJsonStructure ()?

Полагаться на toString()это не очень хорошая идея. Это потому, что разные движки JavaScript могут возвращать разные строковые представления. В общем, методы, которые полагаются на это, могут потерпеть неудачу в разных средах или могут стать причиной сбоя позже, если механизм когда-либо изменит строковый результат

Почему поймать исключение не взломать?

Было высказано мнение, что поймать исключение для определения достоверности чего-либо никогда нельзя. Это вообще хороший совет, но не всегда. В этом случае перехват исключений, вероятно, является наилучшим маршрутом, поскольку он основан на реализации механизма проверки данных JSON в движке JavaScript.

Опора на движок 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('-----------------')

Вы можете попробовать следующий, потому что он также проверяет число, ноль, строку, но отмеченный выше ответ не работает правильно, это просто исправление вышеуказанной функции:

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