Преобразуйте строку внутри поля ввода в массив в javascript [duplicate]

Все строки 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 / нг / http.js

Я использую только 2 строки для выполнения этого:

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

Вот и все!

Но имейте в виду, что есть 2 ловушки: 1. JSON.parse(null) возвращает null 2. Любое число или строка может быть проанализирована с помощью метода JSON.parse(). & NBSP; & NBSP; JSON.parse("5") возвращает 5 & nbsp; & nbsp; 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

Я предлагаю в режиме машинописного текста:

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

Вы можете попробовать его декодировать и поймать исключение (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(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 результат теста

Мне нравится лучший ответ, но если это пустая строка, он возвращает 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;
}

Ну ... Это зависит от того, как вы получаете свои данные. Я думаю, что сервер отвечает строкой 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 на стороне клиента - все, что вам нужно сделать, это проверить член «статус» и действие соответственно.

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

function isJson(str) {
    if (typeof str !== "string" || `${str}`.length === 0) return [false, str];
    let json = "";
    let isValid = false;
    try {
        json = JSON.parse(str);
        isValid = true;
    } catch (e) {
        isValid = false
    }
    if (!json || typeof json !== "object") isValid = false;
    return [isValid, json]
};

//Usage
const [isValid, json] = isJson("[\"abc\", \"123\"]");
if(isValid) console.log(json);

Если сервер отвечает JSON, тогда у него будет тип содержимого application/json, если он отвечает простым текстовым сообщением, тогда он должен иметь тип содержимого text/plain. Убедитесь, что сервер отвечает правильным типом контента и проверит это.

при использовании jQuery $.ajax() ответ будет иметь свойство responseJSON, если ответ был JSON, это можно было бы проверить следующим образом:

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

В дополнение к предыдущим ответам, в случае необходимости проверки формата 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

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.