J'ai un objet JSON imbriqué que je dois parcourir, et la valeur de chaque clé peut être une chaîne, un tableau JSON ou un autre objet JSON. Selon le type d'objet, je dois effectuer différentes opérations. Existe-t-il un moyen de vérifier le type de l'objet pour voir s'il s'agit d'une chaîne, d'un objet JSON ou d'un tableau JSON?
J'ai essayé d'utiliser typeof
et instanceof
mais les deux ne semblaient pas fonctionner, tout comme typeof
le retour d'un objet pour l'objet JSON et le tableau, et instanceof
donnant une erreur lorsque je le fais obj instanceof JSON
.
Pour être plus précis, après avoir analysé le JSON dans un objet JS, existe-t-il un moyen de vérifier s'il s'agit d'une chaîne normale, ou d'un objet avec des clés et des valeurs (à partir d'un objet JSON), ou d'un tableau (à partir d'un tableau JSON )?
Par exemple:
JSON
var data = "{'hi':
{'hello':
['hi1','hi2']
},
'hey':'words'
}";
Exemple de 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
}
}
Comment effectuer la vérification des objets comme indiqué ci-dessus?
la source
.parse()
sur une chaîne JSON, et comment l'identifier?Réponses:
Je vérifierais l'attribut du constructeur.
par exemple
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])); }
Edit: Ajout d'une vérification nulle et d'une vérification non définie.
la source
else if
n'est pas nécessaire{}.constructor
me fait entrerERROR TypeError: Cannot read property 'constructor' of undefined
dans mon application angulaire.Vous pouvez utiliser Array.isArray pour rechercher des tableaux. Puis typeof obj == 'string' , et typeof 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));
la source
typeof null === 'object'
[{ "name":[ {"key": "any key" } ] }]
c'est également json valide mais son tableau de retour par votre code. check this - violonUn objet JSON est un objet. Pour vérifier si un type est un type d'objet, évaluez la propriété du constructeur.
function isObject(obj) { return obj !== undefined && obj !== null && obj.constructor == Object; }
La même chose s'applique à tous les autres types:
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; }
la source
JSON.parse()
que la ressource JSON devient un objet. Par conséquent, si vous testez une ressource provenant d'un serveur pour voir s'il s'agit de JSON, il est préférable de vérifier d'abord String, puis si n'est pas un<empty string>
et ensuite après avoir analysé s'il s'agit d'un objet.Si vous essayez de vérifier le type d'un
object
après avoir analysé uneJSON
chaîne, je vous suggère de vérifier l'attribut du constructeur:obj.constructor == Array || obj.constructor == String || obj.constructor == Object
Ce sera une vérification beaucoup plus rapide que typeof ou instanceof.
Si une bibliothèque JSON ne renvoie pas d'objets construits avec ces fonctions, je m'en méfierais beaucoup.
la source
La réponse de @PeterWilkinson n'a pas fonctionné pour moi car un constructeur pour un objet "typé" est personnalisé au nom de cet objet. Je devais travailler avec typeof
function isJson(obj) { var t = typeof obj; return ['boolean', 'number', 'string', 'symbol', 'function'].indexOf(t) == -1; }
la source
Vous pouvez créer votre propre constructeur pour l'analyse JSON:
var JSONObj = function(obj) { $.extend(this, JSON.parse(obj)); } var test = new JSONObj('{"a": "apple"}'); //{a: "apple"}
Vérifiez ensuite instanceof pour voir s'il avait besoin d'une analyse à l'origine
test instanceof JSONObj
la source
J'ai écrit un module npm pour résoudre ce problème. Il est disponible ici :
object-types
: un module pour trouver quels types littéraux sous-tendent les objetsInstaller
Usage
const objectTypes = require('object-types'); objectTypes({}); //=> 'object' objectTypes([]); //=> 'array' objectTypes(new Object(true)); //=> 'boolean'
Jetez un œil, cela devrait résoudre votre problème exact. Faites moi savoir si vous avez des questions! https://github.com/dawsonbotsford/object-types
la source
vous pouvez également essayer d'analyser les données, puis vérifier si vous avez un objet:
var testIfJson = JSON.parse(data); if (typeOf testIfJson == "object") { //Json } else { //Not Json }
la source
Je combine l'opérateur typeof avec une vérification de l'attribut constructeur (par 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')); });
Résultat:
typeOf() input parameter --------------------------- boolean true boolean false number 1 number 2.3 string "string" array [4,5,6] object {"foo":"bar"} null null undefined
la source
Je sais que c'est une question très ancienne avec de bonnes réponses. Cependant, il semble qu'il soit toujours possible d'y ajouter mes 2 ¢.
En supposant que vous essayez de tester non pas un objet JSON lui-même, mais une chaîne qui est formatée comme un JSON (ce qui semble être le cas dans votre
var data
), vous pouvez utiliser la fonction suivante qui renvoie un booléen (est ou n'est pas un ' 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 } }
Voici quelques exemples d'utilisation de la fonction ci-dessus:
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) );
Lorsque vous exécutez le code ci-dessus, vous obtiendrez les résultats suivants:
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
Veuillez essayer l'extrait ci-dessous et dites-nous si cela fonctionne pour vous. :)
IMPORTANT: la fonction présentée dans cet article a été adaptée de https://airbrake.io/blog/javascript-error-handling/syntaxerror-json-parse-bad-parsing où vous pouvez trouver plus de détails intéressants sur le JSON.parse ( ) fonction.
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) );
la source
Essaye ça
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 ; }
Cela fonctionne pour l'exemple ci-dessous
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 ) );
la source
Pourquoi ne pas vérifier Number - un peu plus court et fonctionne dans 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])); }
la source
Réponse de Peter avec un chèque supplémentaire! Bien sûr, pas garanti à 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!"); }
la source
essaie de cette manière sale
('' + obj).includes('{')
la source