जावास्क्रिप्ट ऑब्जेक्ट JSON है, तो कैसे जांचें

Question 1

मेरे पास एक नेस्टेड JSON ऑब्जेक्ट है जिसे मुझे लूप करने की आवश्यकता है, और प्रत्येक कुंजी का मान एक स्ट्रिंग, JSON सरणी या अन्य JSON ऑब्जेक्ट हो सकता है। ऑब्जेक्ट के प्रकार के आधार पर, मुझे विभिन्न ऑपरेशन करने की आवश्यकता है। वहाँ किसी भी तरह से मैं वस्तु के प्रकार की जाँच कर सकता हूँ यह देखने के लिए कि क्या यह स्ट्रिंग, JSON ऑब्जेक्ट या JSON सरणी है?

मैंने उपयोग करने की कोशिश की typeofऔर instanceofदोनों काम नहीं कर रहे थे, जैसा typeofकि JSON ऑब्जेक्ट और एरे दोनों के लिए एक ऑब्जेक्ट लौटाएगा, और instanceofजब मैं करता हूं तो एक त्रुटि देता है obj instanceof JSON।

JSON को जेएस ऑब्जेक्ट में पार्स करने के बाद अधिक विशिष्ट होने के लिए, क्या कोई तरीका है जो मैं जांच सकता हूं कि क्या यह सामान्य स्ट्रिंग है, या चाबियाँ और मान के साथ ऑब्जेक्ट (JSON ऑब्जेक्ट से), या एक सरणी (JSON सरणी से) )?

उदाहरण के लिए:

JSON

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

नमूना जावास्क्रिप्ट

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

जैसा कि ऊपर दिखाया गया है, मैं ऑब्जेक्ट चेकिंग कैसे करूं?

Question 2

मैं कंस्ट्रक्टर विशेषता की जांच करूंगा।

जैसे

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

संपादित करें: एक अशक्त चेक और एक अपरिभाषित चेक जोड़ा गया।

Question 3

सरणियों की जांच के लिए आप Array.isArray का उपयोग कर सकते हैं । फिर टाइपोफ ओब्ज == 'स्ट्रिंग' , और टाइपोफ ओज == 'ऑब्जेक्ट' ।

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' है अन्य

Question 4

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

Question 5

अगर आप स्ट्रिंग को objectपार्स करने के बाद उसके प्रकार की जाँच करने की कोशिश कर रहे हैं JSON, तो मेरा सुझाव है कि कंस्ट्रक्टर विशेषता की जाँच करें:

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

यह टाइपोफ या इंस्टोफ की तुलना में बहुत तेज जांच होगी।

यदि कोई JSON लाइब्रेरी इन कार्यों के साथ निर्मित वस्तुओं को वापस नहीं करता है, तो मैं इसके लिए बहुत ही संदिग्ध होगा।

Question 6

@PeterWilkinson के जवाब ने मेरे लिए काम नहीं किया क्योंकि एक "टाइप" ऑब्जेक्ट के लिए एक निर्माता उस ऑब्जेक्ट के नाम से अनुकूलित है। मुझे टाइपोफ के साथ काम करना था

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

Question 7

आप JSON पार्सिंग के लिए अपना खुद का कंस्ट्रक्टर बना सकते हैं:

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

फिर यह देखने के लिए कि क्या इसे मूल रूप से पार्स करने की जरूरत है, उदाहरण देखें

test instanceof JSONObj

Question 8

मैंने इस समस्या को हल करने के लिए एक 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

Question 9

आप डेटा पार्स करने की कोशिश भी कर सकते हैं और फिर जाँच सकते हैं कि क्या आपको ऑब्जेक्ट मिला:

var testIfJson = JSON.parse(data);
if (typeOf testIfJson == "object")
{
//Json
}
else
{
//Not Json
}

Question 10

मैं कंस्ट्रक्टर विशेषता (पीटर द्वारा) की जांच के साथ टाइपो ऑपरेटर को जोड़ती हूं:

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

Question 11

मुझे पता है कि यह एक बहुत पुराना प्रश्न है जिसके अच्छे उत्तर हैं। हालाँकि, ऐसा लगता है कि अभी भी इसमें मेरा 2 it's जोड़ना संभव है।

यह मानते हुए कि आप स्वयं JSON ऑब्जेक्ट का परीक्षण करने की कोशिश नहीं कर रहे हैं, लेकिन एक स्ट्रिंग जिसे JSON (जो आपके मामले में ऐसा प्रतीत होता है var data) के रूप में स्वरूपित है , आप निम्नलिखित फ़ंक्शन का उपयोग कर सकते हैं जो एक बूलियन (या नहीं 'है) JSON '):

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

स्निपेट का विस्तार करें

Question 12

इसे इस्तेमाल करे

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

Question 13

क्यों नहीं संख्या की जाँच करें - थोड़ा छोटा और IE / Chrome / 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]));
}

स्निपेट का विस्तार करें

Question 14

एक अतिरिक्त जांच के साथ पीटर का जवाब! बेशक, 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!");
}

Question 15

इस गंदे तरीके की कोशिश करो

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