Làm thế nào để kiểm tra xem một chuỗi có phải là JSON hay không?

Tôi có một cuộc gọi AJAX đơn giản và máy chủ sẽ trả về một chuỗi JSON có dữ liệu hữu ích hoặc chuỗi thông báo lỗi do hàm PHP tạo ra mysql_error() . Làm cách nào để kiểm tra xem dữ liệu này là chuỗi JSON hay thông báo lỗi.

Sẽ thật tuyệt khi sử dụng một chức năng được gọi isJSONlà giống như bạn có thể sử dụng chức nănginstanceof để kiểm tra xem có thứ gì đó là Mảng không.

Đây là những gì tôi muốn:

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

Sử dụng JSON.parse

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

Mã này là JSON.parse(1234)hay JSON.parse(0)hay JSON.parse(false)hay JSON.parse(null)tất cả sẽ trở thành sự thật.

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

Vì vậy, tôi viết lại mã theo cách này:

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

Kết quả kiểm tra:

kết quả kiểm tra isJson

Hãy tóm tắt lại điều này (cho năm 2019+).

Lập luận : giá trị như true, false, nullcó giá trị JSON (?)

SỰ THẬT : Các giá trị nguyên thủy này có thể phân tích cú pháp JSON nhưng chúng không phải là cấu trúc JSON được hình thành tốt . Đặc tả JSON chỉ ra JSON được xây dựng trên hai cấu trúc: Một tập hợp các cặp tên / giá trị (đối tượng) hoặc một danh sách các giá trị (mảng) được sắp xếp theo thứ tự.

Luận điểm : Xử lý ngoại lệ không nên được sử dụng để làm điều gì đó được mong đợi.
(Đây là một nhận xét có hơn 25 lượt upvote!)

SỰ THẬT : Không! Sử dụng thử / bắt chắc chắn là hợp pháp, đặc biệt trong trường hợp như thế này. Mặt khác, bạn cần thực hiện nhiều công cụ phân tích chuỗi như các hoạt động tokenizing / regex; trong đó sẽ có hiệu suất khủng khiếp.

hasJsonStructure()

Điều này hữu ích nếu mục tiêu của bạn là kiểm tra xem một số dữ liệu / văn bản có định dạng trao đổi JSON phù hợp hay không.

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

Sử dụng:

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

safeJsonParse()

Và điều này rất hữu ích nếu bạn muốn cẩn thận khi phân tích một số dữ liệu thành giá trị JavaScript.

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

Sử dụng:

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

Nếu máy chủ đang phản hồi với JSON thì nó sẽ có kiểu application/jsonnội dung, nếu nó phản hồi bằng một tin nhắn văn bản đơn giản thì nó phải có kiểu text/plainnội dung. Đảm bảo rằng máy chủ đang phản hồi với loại nội dung chính xác và kiểm tra điều đó.

Khi sử dụng jQuery $.ajax()phản hồi sẽ có thuộc responseJSONtính nếu phản hồi là JSON, điều này có thể được kiểm tra như sau:

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

Tôi thích câu trả lời hay nhất nhưng nếu đó là một chuỗi rỗng thì nó trả về đúng. Vì vậy, đây là một sửa chữa:

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
}

Tuy nhiên, tôi sẽ đề xuất với bạn rằng cuộc gọi / dịch vụ http của bạn sẽ luôn trả về một dữ liệu có cùng định dạng. Vì vậy, nếu bạn gặp lỗi, hơn bạn nên có một đối tượng JSON bao bọc lỗi này:

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

Và có thể sử dụng trạng thái HTTP cũng như mã 5xx.

Chà ... Nó phụ thuộc vào cách bạn đang nhận dữ liệu của mình. Tôi nghĩ rằng máy chủ đang phản hồi với một chuỗi được tạo thành JSON (sử dụng json_encode () trong PHP, vd). Nếu bạn đang sử dụng bài đăng JQuery và đặt dữ liệu phản hồi thành định dạng JSON và đó là JSON không đúng định dạng, điều này sẽ gây ra lỗi:

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

Nhưng, nếu bạn đang sử dụng kiểu phản hồi dưới dạng văn bản, bạn cần sử dụng $ .parseJSON. Theo trang jquery: "Truyền chuỗi JSON không đúng định dạng có thể dẫn đến ngoại lệ bị ném". Do đó, mã của bạn sẽ là:

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

Có thể có các bài kiểm tra bạn có thể làm, ví dụ nếu bạn biết rằng JSON được trả về sẽ luôn được bao quanh {và }sau đó bạn có thể kiểm tra các ký tự đó hoặc một số phương thức hack khác. Hoặc bạn có thể sử dụng json.org thư viện JS để thử và phân tích nó và kiểm tra nếu nó thành công.

Tuy nhiên tôi sẽ đề nghị một cách tiếp cận khác. Tập lệnh PHP của bạn hiện trả về JSON nếu cuộc gọi thành công, nhưng một số thứ khác nếu không. Tại sao không luôn luôn trả về JSON?

Ví dụ

Cuộc gọi thành công:

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

Cuộc gọi đáng ghét:

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

Điều này sẽ làm cho việc viết JS phía máy khách của bạn dễ dàng hơn nhiều - tất cả những gì bạn phải làm là kiểm tra thành viên "trạng thái" và hành động tương ứng.

Tôi chỉ sử dụng 2 dòng để thực hiện điều đó:

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

Đó là tất cả!

Nhưng hãy nhớ rằng có 2 bẫy:
1. JSON.parse(null)trả về null
2. Bất kỳ số hoặc chuỗi nào có thể được phân tích cú pháp bằng JSON.parse()phương thức.
   JSON.parse("5")trả 5
   JSON.parse(5)về5

Hãy chơi một số mã:

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

Bạn có thể thử giải mã nó và bắt ngoại lệ (nguyên gốc hoặc json2.js ):

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

Tuy nhiên, tôi sẽ đề nghị làm cho phản hồi luôn là JSON hợp lệ. Nếu bạn gặp lỗi từ truy vấn MySQL của mình, chỉ cần gửi lại JSON với lỗi:

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

Và sau đó:

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

Cảnh báo: Đối với các phương thức dựa vào JSON.parse- Mảng và trích dẫn các chuỗi được bao quanh cũng sẽ vượt qua (ví dụ. console.log(JSON.parse('[3]'), JSON.parse('"\uD800"')))

Để tránh tất cả các nguyên hàm JSON không phải đối tượng (boolean, null, mảng, số, chuỗi), tôi khuyên bạn nên sử dụng như sau:

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

Giải thích mã

• !! o - Không giả mạo (không bao gồm null, đăng ký dưới dạng typeof 'object')
• (typeof o === 'object') - Không bao gồm boolean, số và chuỗi
• ! Array.isArray (o) - Loại trừ các mảng (đăng ký dưới dạng typeof 'object')
• thử ... JSON.opesify / JSON.parse - Yêu cầu công cụ JavaScript để xác định xem JSON hợp lệ

Tại sao không sử dụng câu trả lời hasJsonStr struct ()?

Dựa vào toString()không phải là một ý tưởng tốt. Điều này là do các Công cụ JavaScript khác nhau có thể trả về một đại diện chuỗi khác nhau. Nói chung, các phương pháp dựa vào điều này có thể thất bại trong các môi trường khác nhau hoặc có thể bị lỗi sau này nếu động cơ thay đổi kết quả chuỗi

Tại sao bắt một ngoại lệ không phải là hack?

Nó đã được đưa ra rằng bắt một ngoại lệ để xác định tính hợp lệ của một cái gì đó không bao giờ là cách đúng đắn. Đây thường là lời khuyên tốt, nhưng không phải lúc nào cũng vậy. Trong trường hợp này, việc bắt ngoại lệ có khả năng là con đường tốt nhất vì nó phụ thuộc vào việc triển khai xác thực dữ liệu JSON của công cụ JavaScript.

Dựa vào công cụ JS cung cấp các lợi thế sau:

1. Cẩn thận hơn và liên tục cập nhật hơn khi thông số JSON thay đổi
2. Có khả năng chạy nhanh hơn (vì nó là mã cấp thấp hơn)

Khi có cơ hội dựa vào công cụ JavaScript, tôi khuyên bạn nên làm điều đó. Đặc biệt là như vậy trong trường hợp này. Mặc dù có thể cảm thấy khó khăn khi bắt ngoại lệ, bạn thực sự chỉ cần xử lý hai trạng thái trả về có thể có từ một phương thức bên ngoài.

Đây là một mã với một số sửa đổi nhỏ trong câu trả lời của Bourne. Vì JSON.parse (số) hoạt động tốt mà không có ngoại lệ nên đã thêm isNaN.

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

Tất cả các chuỗi json bắt đầu bằng '{' hoặc '[' và kết thúc bằng '}' hoặc ']' tương ứng, vì vậy chỉ cần kiểm tra điều đó.

Đây là cách Angular.js thực hiện:

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

Tôi đề nghị trong chế độ Bản in:

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

Tôi đã sử dụng câu hỏi này (loại kết hợp các câu trả lời khác nhau, nhưng dù sao):

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

Bạn có thể thử câu sau vì nó cũng xác nhận số, null, chuỗi nhưng câu trả lời được đánh dấu ở trên không hoạt động chính xác, đó chỉ là một sửa chữa của hàm trên:

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

Ngoài các câu trả lời trước, trong trường hợp bạn cần xác thực định dạng JSON như "{}", bạn có thể sử dụng mã sau:

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

Ví dụ về việc sử dụng:

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