JavaScriptオブジェクトがJSONであるかどうかを確認する方法

87

ループする必要のあるネストされたJSONオブジェクトがあり、各キーの値はString、JSON配列、または別のJSONオブジェクトである可能性があります。オブジェクトの種類に応じて、さまざまな操作を実行する必要があります。オブジェクトのタイプをチェックして、それが文字列、JSONオブジェクト、またはJSON配列であるかどうかを確認する方法はありますか？

を使用typeofしてみましたinstanceofが、typeofJSONオブジェクトと配列の両方のオブジェクトが返され、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
    }
}

上記のようにオブジェクトチェックを実行するにはどうすればよいですか？

javascript  json 
— 魏ハオ
ソース
3
JSONは、文字列として格納される単なる表記法です。用語を混同していないと思いますか？
— zerkms 2012年
いいえ、質問を更新して明確にしました。私の主な質問は.parse()、JSON文字列に対してを実行した後に何が起こるか、そしてそれをどのように識別するかということだと思います。
— Wei Hao 2012年
1
変更はそれをより明確にしませんでした（私にとっては少なくとも）。扱っているJSONの例を挙げたらどうなるでしょうか
— zerkms 2012年
質問を例で更新しました。（：
— Wei Hao 2012年
本当の問題は、なぜ気にするのかということです。
— アシェラ2012年

回答:

130

コンストラクター属性を確認します。

例えば

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チェックと未定義のチェックを追加しました。

— プログラミングガイ
ソース
9
else if不要
— McSonk 2017
これはinstanceofを使用することと同じではありませんか？developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/…–
— ペレイラ
@Pereira：JavaScriptにはいくつかの紛らわしいしわがあります。Stringの「surely_this_is_a_string」インスタンスを試してください。
— プログラミングガイ
{}.constructorERROR TypeError: Cannot read property 'constructor' of undefined角度のあるアプリケーションに入る原因になっています。
— ケバブ-ケース
@ Minyc510：ブラウザの動作が変更されたようです。角かっこで囲むと修正されるようです。これを反映するように回答を編集しました。
— プログラミングガイ
25

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'は文字列
'a'は配列
'o'はオブジェクト
'i'はその他

— マクガーナグル
ソース
5
それを考慮に入れることを忘れないでくださいtypeof null === 'object'
— hugomg 2012年
[{ "name":[ {"key": "any key" } ] }] これも有効なjsonですが、コードによって配列が返されます。これをチェックしてください-フィドル
— -SudhirK Gupta 2018
15

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;
}
— マーティン・ウォントケ
ソース
2
JSONでエンコードされたリソースはオブジェクトではありません。文字列です。それをデコードするか、JavascriptJSON.parse()でのみ、JSONリソースがオブジェクトになります。したがって、サーバーからのリソースをテストしてJSONであるかどうかを確認する場合は、最初にStringをチェックし、次にそれがaでない場合はチェックし、次に<empty string>それがオブジェクトであるかどうかを解析した後にチェックするのが最善です。
— Hmerman6006
8

文字列objectを解析した後にタイプをチェックしようとしている場合はJSON、コンストラクター属性をチェックすることをお勧めします。

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

これは、typeofやinstanceofよりもはるかに高速なチェックになります。

JSONライブラリがこれらの関数で構築されたオブジェクトを返さない場合、私はそれを非常に疑っています。

— JoshRagem
ソース
はるかに直接的なアプローチ。ありがとう！= D
— Eduardo Lucio
優先回答。パフォーマンス上のメリットに関する情報はどこから入手できますか？
— ダニエル
@DanielFそれは、それが保持している場合、私は知らないので、物事が今、すべて異なっている、'12に共通の知恵バックだった
— JoshRagem
5

「型指定された」オブジェクトのコンストラクターがそのオブジェクトの名前にカスタマイズされているため、@ PeterWilkinsonによる回答は私には機能しませんでした。私はtypeofで作業しなければなりませんでした

function isJson(obj) {
    var t = typeof obj;
    return ['boolean', 'number', 'string', 'symbol', 'function'].indexOf(t) == -1;
}
— ドミトリー・エフィメンコ
ソース
4

JSON解析用に独自のコンストラクターを作成できます。

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

次に、instanceofをチェックして、元々解析が必要かどうかを確認します

test instanceof JSONObj
— matt3141
ソース
4

この問題を解決するために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

— ドーソンB
ソース
2

データの解析を試みてから、オブジェクトを取得したかどうかを確認することもできます。

var testIfJson = JSON.parse(data);
if (typeOf testIfJson == "object")
{
//Json
}
else
{
//Not Json
}
— arielhad
ソース
2

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
— マーティン・スコルプスキー
ソース
2

私はこれが良い答えのある非常に古い質問であることを知っています。ただし、2¢を追加することはまだ可能のようです。

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) );
スニペットを展開

— アルミールカンポス
ソース
1

これを試して

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 ) );
— サンドロローザ
ソース
1

番号を確認してみませんか-少し短く、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]));
}
スニペットを展開

— トム
ソース
0

追加のチェックでピーターの答え！もちろん、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!");
}
— エドゥアルド・ルシオ
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.