JavaScript 객체가 JSON인지 확인하는 방법

JavaScript 객체가 JSON인지 확인하는 방법

루프 통과해야 하는 중첩된 JSON 개체가 있으며 각 키의 값은 String, JSON 배열 또는 다른 JSON 개체일 수 있습니다.물건의 종류에 따라 다른 작업을 수행해야 합니다.객체의 종류를 확인하여 String, JSON 객체 또는 JSON 어레이 중 어느 쪽인지 확인할 수 있는 방법이 있습니까?

는 는는그용사 i를 사용해 보았다.typeof ★★★★★★★★★★★★★★★★★」instanceof 둘 다 것.typeof및 "JSON" 객체 합니다.instanceof를 실행하면 .obj instanceof JSON.

구체적으로는 JSON을 JS 오브젝트로 해석한 후 표준 문자열인지 키와 값이 있는 오브젝트인지(JSON 오브젝트에서), 배열인지(JSON 어레이에서) 확인할 수 있는 방법이 있습니까?

예를 들어 다음과 같습니다.

JSON

var data = "{'hi':
             {'hello':
               ['hi1','hi2']
             },
            'hey':'words'
           }";

샘플 JavaScript

var jsonObj = JSON.parse(data);
var path = ["hi","hello"];

function check(jsonObj, path) {
    var parent = jsonObj;
    for (var i = 0; i < path.length-1; i++) {
        var key = path[i];
        if (parent != undefined) {
            parent = parent[key];
        }
    }
    if (parent != undefined) {
        var endLength = path.length - 1;
        var child = parent[path[endLength]];
        //if child is a string, add some text
        //if child is an object, edit the key/value
        //if child is an array, add a new element
        //if child does not exist, add a new key/value
    }
}

위와 같이 객체 체크를 하려면 어떻게 해야 하나요?

컨스트럭터 속성을 확인해 보겠습니다.

예.

var stringConstructor = "test".constructor;
var arrayConstructor = [].constructor;
var objectConstructor = ({}).constructor;

function whatIsIt(object) {
    if (object === null) {
        return "null";
    }
    if (object === undefined) {
        return "undefined";
    }
    if (object.constructor === stringConstructor) {
        return "String";
    }
    if (object.constructor === arrayConstructor) {
        return "Array";
    }
    if (object.constructor === objectConstructor) {
        return "Object";
    }
    {
        return "don't know";
    }
}

var testSubjects = ["string", [1,2,3], {foo: "bar"}, 4];

for (var i=0, len = testSubjects.length; i < len; i++) {
    alert(whatIsIt(testSubjects[i]));
}

편집: null 체크와 정의되지 않은 체크가 추가되었습니다.

Array.isArray를 사용하여 어레이를 확인할 수 있습니다.그런 다음 유형 obj == 'string' 및 유형 obj == 'object'를 입력합니다.

var s = 'a string', a = [], o = {}, i = 5;
function getType(p) {
    if (Array.isArray(p)) return 'array';
    else if (typeof p == 'string') return 'string';
    else if (p != null && typeof p == 'object') return 'object';
    else return 'other';
}
console.log("'s' is " + getType(s));
console.log("'a' is " + getType(a));
console.log("'o' is " + getType(o));
console.log("'i' is " + getType(i));

는 끈의 's'입니다.
는 배열 'a'입니다.
는 목적어 'o'입니다.
는 다른 'i'를 .

JSON 개체는 개체입니다.유형이 개체 유형인지 확인하려면 생성자 속성을 평가하십시오.

function isObject(obj)
{
    return obj !== undefined && obj !== null && obj.constructor == Object;
}

다른 모든 유형에도 동일하게 적용됩니다.

function isArray(obj)
{
    return obj !== undefined && obj !== null && obj.constructor == Array;
}

function isBoolean(obj)
{
    return obj !== undefined && obj !== null && obj.constructor == Boolean;
}

function isFunction(obj)
{
    return obj !== undefined && obj !== null && obj.constructor == Function;
}

function isNumber(obj)
{
    return obj !== undefined && obj !== null && obj.constructor == Number;
}

function isString(obj)
{
    return obj !== undefined && obj !== null && obj.constructor == String;
}

function isInstanced(obj)
{
    if(obj === undefined || obj === null) { return false; }

    if(isArray(obj)) { return false; }
    if(isBoolean(obj)) { return false; }
    if(isFunction(obj)) { return false; }
    if(isNumber(obj)) { return false; }
    if(isObject(obj)) { return false; }
    if(isString(obj)) { return false; }

    return true;
}

데이터를 해석하고 오브젝트가 있는지 여부를 확인할 수도 있습니다.

try {
    var testIfJson = JSON.parse(data);
    if (typeof testIfJson == "object"){
        //Json
    } else {
        //Not Json
    }
}
catch {
    return false;
}

의 object를 한 후에JSONstring, 컨스트럭터 속성을 확인하는 것이 좋습니다.

obj.constructor == Array || obj.constructor == String || obj.constructor == Object

이는 유형 또는 인스턴스보다 훨씬 빠른 검사입니다.

JSON 라이브러리가 이러한 함수로 구성된 개체를 반환하지 않으면 매우 의심스러울 수 있습니다.

@PeterWilkinson의 답변은 효과가 없었습니다.왜냐하면 "유형" 오브젝트의 컨스트럭터는 그 오브젝트의 이름에 맞게 커스터마이즈 되어 있기 때문입니다.나는 이런 유형의 일을 해야 했다.

function isJson(obj) {
    var t = typeof obj;
    return ['boolean', 'number', 'string', 'symbol', 'function'].indexOf(t) == -1;
}

JSON 구문 분석용 자체 생성자를 만들 수 있습니다.

var JSONObj = function(obj) { $.extend(this, JSON.parse(obj)); }
var test = new JSONObj('{"a": "apple"}');
//{a: "apple"}

그런 다음 instance of에서 원래 해석할 필요가 있었는지 확인합니다.

test instanceof JSONObj

이 문제를 해결하기 위해 npm 모듈을 작성했습니다.다음 사이트에서 이용하실 수 있습니다.

object-types: " " " " " " " 。

설치하다

  npm install --save object-types

사용.

const objectTypes = require('object-types');

objectTypes({});
//=> 'object'

objectTypes([]);
//=> 'array'

objectTypes(new Object(true));
//=> 'boolean'

보세요, 당신의 정확한 문제를 해결할 수 있을 거예요.궁금하신 점 있으시면 말씀하세요!https://github.com/dawsonbotsford/object-types

Number(번호)를 체크하는 것은 어떨까요?- 조금 짧아지고 IE/Crome/FF/node.js에서 동작합니다.

function whatIsIt(object) {
    if (object === null) {
        return "null";
    }
    else if (object === undefined) {
        return "undefined";
    }
    if (object.constructor.name) {
            return object.constructor.name;
    }
    else { // last chance 4 IE: "\nfunction Number() {\n    [native code]\n}\n" / node.js: "function String() { [native code] }"
        var name = object.constructor.toString().split(' ');
        if (name && name.length > 1) {
            name = name[1];
            return name.substr(0, name.indexOf('('));
        }
        else { // unreachable now(?)
            return "don't know";
        }
    }
}

var testSubjects = ["string", [1,2,3], {foo: "bar"}, 4];
// Test all options
console.log(whatIsIt(null));
console.log(whatIsIt());
for (var i=0, len = testSubjects.length; i < len; i++) {
    console.log(whatIsIt(testSubjects[i]));
}

연산자 유형을 생성자 속성 체크와 결합합니다(by Peter).

var typeOf = function(object) {
    var firstShot = typeof object;
    if (firstShot !== 'object') {
        return firstShot;
    } 
    else if (object.constructor === [].constructor) {
        return 'array';
    }
    else if (object.constructor === {}.constructor) {
        return 'object';
    }
    else if (object === null) {
        return 'null';
    }
    else {
        return 'don\'t know';
    } 
}

// Test
var testSubjects = [true, false, 1, 2.3, 'string', [4,5,6], {foo: 'bar'}, null, undefined];

console.log(['typeOf()', 'input parameter'].join('\t'))
console.log(new Array(28).join('-'));
testSubjects.map(function(testSubject){
    console.log([typeOf(testSubject), JSON.stringify(testSubject)].join('\t\t'));
});

결과:

typeOf()    input parameter
---------------------------
boolean     true
boolean     false
number      1
number      2.3
string      "string"
array       [4,5,6]
object      {"foo":"bar"}
null        null
undefined       

좋은 답변이 있는 아주 오래된 질문이라는 것을 알고 있습니다.하지만 제 2 to를 추가할 수 있을 것 같습니다.

(JSON의 인 것 같습니다합니다.var data을를 사용할 수 있습니다.

function isJsonString( jsonString ) {

  // This function below ('printError') can be used to print details about the error, if any.
  // Please, refer to the original article (see the end of this post)
  // for more details. I suppressed details to keep the code clean.
  //
  let printError = function(error, explicit) {
  console.log(`[${explicit ? 'EXPLICIT' : 'INEXPLICIT'}] ${error.name}: ${error.message}`);
  }


  try {
      JSON.parse( jsonString );
      return true; // It's a valid JSON format
  } catch (e) {
      return false; // It's not a valid JSON format
  }

}

위의 함수를 사용하는 예를 몇 가지 나타냅니다.

console.log('\n1 -----------------');
let j = "abc";
console.log( j, isJsonString(j) );

console.log('\n2 -----------------');
j = `{"abc": "def"}`;
console.log( j, isJsonString(j) );

console.log('\n3 -----------------');
j = '{"abc": "def}';
console.log( j, isJsonString(j) );

console.log('\n4 -----------------');
j = '{}';
console.log( j, isJsonString(j) );

console.log('\n5 -----------------');
j = '[{}]';
console.log( j, isJsonString(j) );

console.log('\n6 -----------------');
j = '[{},]';
console.log( j, isJsonString(j) );

console.log('\n7 -----------------');
j = '[{"a":1, "b":   2}, {"c":3}]';
console.log( j, isJsonString(j) );

위의 코드를 실행하면 다음과 같은 결과가 나타납니다.

1 -----------------
abc false

2 -----------------
{"abc": "def"} true

3 -----------------
{"abc": "def} false

4 -----------------
{} true

5 -----------------
[{}] true

6 -----------------
[{},] false

7 -----------------
[{"a":1, "b":   2}, {"c":3}] true

아래의 스니펫을 사용해 보시고, 이것이 도움이 되는지 알려주시기 바랍니다.:)

중요: 이 투고에서 제시된 함수는 https://airbrake.io/blog/javascript-error-handling/syntaxerror-json-parse-bad-parsing에서 수정되었습니다.여기서 JSON.parse() 함수에 대한 자세한 내용을 확인할 수 있습니다.

function isJsonString( jsonString ) {

  let printError = function(error, explicit) {
  console.log(`[${explicit ? 'EXPLICIT' : 'INEXPLICIT'}] ${error.name}: ${error.message}`);
  }


  try {
      JSON.parse( jsonString );
      return true; // It's a valid JSON format
  } catch (e) {
      return false; // It's not a valid JSON format
  }

}


console.log('\n1 -----------------');
let j = "abc";
console.log( j, isJsonString(j) );

console.log('\n2 -----------------');
j = `{"abc": "def"}`;
console.log( j, isJsonString(j) );

console.log('\n3 -----------------');
j = '{"abc": "def}';
console.log( j, isJsonString(j) );

console.log('\n4 -----------------');
j = '{}';
console.log( j, isJsonString(j) );

console.log('\n5 -----------------');
j = '[{}]';
console.log( j, isJsonString(j) );

console.log('\n6 -----------------');
j = '[{},]';
console.log( j, isJsonString(j) );

console.log('\n7 -----------------');
j = '[{"a":1, "b":   2}, {"c":3}]';
console.log( j, isJsonString(j) );

시도해 보십시오. Catch block이 이 문제를 해결하는 데 도움이 됩니다.

함수를 만들다

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

예:

console.log(IsJson('abc')) // false
console.log(IsJson('[{"type":"email","detail":"john@example.com"}]')) // true

이거 드셔보세요

if ( typeof is_json != "function" )
function is_json( _obj )
{
    var _has_keys = 0 ;
    for( var _pr in _obj )
    {
        if ( _obj.hasOwnProperty( _pr ) && !( /^\d+$/.test( _pr ) ) )
        {
           _has_keys = 1 ;
           break ;
        }
    }

    return ( _has_keys && _obj.constructor == Object && _obj.constructor != Array ) ? 1 : 0 ;
}

아래 예에서 사용할 수 있습니다.

var _a = { "name" : "me",
       "surname" : "I",
       "nickname" : {
                      "first" : "wow",
                      "second" : "super",
                      "morelevel" : {
                                      "3level1" : 1,
                                      "3level2" : 2,
                                      "3level3" : 3
                                    }
                    }
     } ;

var _b = [ "name", "surname", "nickname" ] ;
var _c = "abcdefg" ;

console.log( is_json( _a ) );
console.log( is_json( _b ) );
console.log( is_json( _c ) );

@Martin Wantke 답변에 근거하지만 권장되는 개선/조정을 통해...

// NOTE: Check JavaScript type. By Questor
function getJSType(valToChk) {

    function isUndefined(valToChk) { return valToChk === undefined; }
    function isNull(valToChk) { return valToChk === null; }
    function isArray(valToChk) { return valToChk.constructor == Array; }
    function isBoolean(valToChk) { return valToChk.constructor == Boolean; }
    function isFunction(valToChk) { return valToChk.constructor == Function; }
    function isNumber(valToChk) { return valToChk.constructor == Number; }
    function isString(valToChk) { return valToChk.constructor == String; }
    function isObject(valToChk) { return valToChk.constructor == Object; }

    if(isUndefined(valToChk)) { return "undefined"; }
    if(isNull(valToChk)) { return "null"; }
    if(isArray(valToChk)) { return "array"; }
    if(isBoolean(valToChk)) { return "boolean"; }
    if(isFunction(valToChk)) { return "function"; }
    if(isNumber(valToChk)) { return "number"; }
    if(isString(valToChk)) { return "string"; }
    if(isObject(valToChk)) { return "object"; }

}

메모: 저는 이 접근방식이 매우 교훈적이라고 생각했기 때문에 이 답변을 제출했습니다.

피터의 답변에 추가 수표로!물론 100% 보장되는 것은 아닙니다!

var isJson = false;
outPutValue = ""
var objectConstructor = {}.constructor;
if(jsonToCheck.constructor === objectConstructor){
    outPutValue = JSON.stringify(jsonToCheck);
    try{
            JSON.parse(outPutValue);
            isJson = true;
    }catch(err){
            isJson = false;
    }
}

if(isJson){
    alert("Is json |" + JSON.stringify(jsonToCheck) + "|");
}else{
    alert("Is other!");
}

문자열이나 다른 값을 해석하려고 해도 오류가 발생하지 않는 매우 느린 답변이 있습니다.

const checkForJson = (value) => {
    if (typeof value !== "string") return false;

    return value[0] === "{" && value[value.length - 1] === "}";
}

재귀 펑크를 만드는 동안 키 값을 확인할 수 있습니다. 질문에 완전히 답하지 못했다면 죄송합니다.

물론 이것이 가장 우아한 솔루션은 아니며 문자열이 실제로 {}로 시작하고 "}"로 끝나는 경우 오류가 발생합니다. 이러한 사용 사례는 드물지만, 실제로 필요한 경우 따옴표나 기타 의미 없는 내용이 있는지 확인할 수 있습니다.어쨌든, 독자적으로 사용하세요.

TLDR: 방탄은 아니지만 단순하고 대부분의 사용 사례에 적합합니다.

lodash는 또한 이러한 것들을 확인하는 가장 좋은 방법입니다.

function Foo() {
  this.a = 1;
}
 
_.isPlainObject(new Foo);
// => false
 
_.isPlainObject([1, 2, 3]);
// => false
 
_.isPlainObject({ 'x': 0, 'y': 0 });
// => true
 
_.isPlainObject(Object.create(null));
// => true

https://www.npmjs.com/package/lodash
https://lodash.com/docs/ #isPlain Object

lodash-contrib을 사용하여 JSON 구조를 빠르게 확인합니다.

const _ = require('lodash-contrib');

_.isJSON('{"car": "ferarri"}'); //true for stringified
_.isJSON({car: "ferarri"}); //true  

사용 가이드: 이 블로그 엔트리

이 더러운 방법으로 시도하다

 ('' + obj).includes('{')

언급URL : https://stackoverflow.com/questions/11182924/how-to-check-if-javascript-object-is-json