如何检查JavaScript对象是否是JSON
我有一个嵌套的JSON对象，我需要循环，每个键的值可以是一个string，JSON数组或另一个JSON对象。 根据对象的types，我需要执行不同的操作。 有什么办法可以检查对象的types，看它是一个string，JSON对象或JSON数组？
我尝试过使用typeof和instanceof但两者似乎并没有工作，因为typeof将返回一个对象的JSON对象和数组，和instanceof提供了一个错误，当我做obj instanceof JSON 。
更具体地说，在将JSONparsing为JS对象之后，是否有任何方法可以检查它是否是普通string，或者是具有键和值的对象（来自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"; } else if (object === undefined) { return "undefined"; } else if (object.constructor === stringConstructor) { return "String"; } else if (object.constructor === arrayConstructor) { return "Array"; } else if (object.constructor === objectConstructor) { return "Object"; } else { 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])); }
编辑：添加了空检查和未定义的检查。
你可以使用Array.isArray来检查数组。 然后typeof obj =='string' ，以及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));
's'是string
'a'是数组
'o'是对象
“我”是另一个
您可以为JSONparsing创build自己的构造函数：
var JSONObj = function(obj) { $.extend(this, JSON.parse(obj)); } var test = new JSONObj('{"a": "apple"}'); //{a: "apple"}
然后检查instanceof是否需要parsing
test instanceof JSONObj
如果在分析JSONstring之后尝试检查object的types，build议检查构造函数属性：
obj.constructor == Array || obj.constructor == String || obj.constructor == Object
这将比typeof或instanceof快得多。
如果一个JSON库没有返回用这些函数构造的对象，我会非常怀疑它。
@PeterWilkinson的答案不适合我，因为“types”对象的构造函数被定制为该对象的名称。 我不得不使用typeof
function isJson(obj) { var t = typeof obj; return ['boolean', 'number', 'string', 'symbol', 'function'].indexOf(t) == -1; }
我写了一个npm模块来解决这个问题。 它在这里可用：
object-types ：用于查找底层对象的文字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
尝试这个
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 ) );
我将typeof运算符与构造函数属性（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
彼得的答案与额外的检查！ 当然，不是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!"); }
你也可以尝试parsing数据，然后检查是否有对象：
var testIfJson = JSON.parse(data); if (typeOf testIfJson == "object") { //Json } else { //Not Json }
一个JSON对象是一个对象。 要检查天气，任何types都是对象types，请评估构造函数属性。
function isObject(obj) { return obj !== undefined && obj !== null && obj.constructor == Object; }
所有其他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; }
试试这个肮脏的方式
('' + obj).includes('{')
