値がJavaScriptのオブジェクトかどうかを確認する

Question

JavaScriptで値がオブジェクトかどうかをどうやって確認しますか

Answer 1

typeof(var)やvar instanceof somethingを使ってみてください。

編集：この答えは変数のプロパティを調べる方法のアイデアを与えますが、それがはるかにそれから遠いオブジェクトであるかどうかをチェックするための防弾レシピ（結局、レシピはまったくありません！）not人々は何も調査せずにここからコピーするものを探す傾向があるので、私は彼らが他の、最も支持された（そして正しい！）答えに目を向けることを強く勧めます。

Answer 2

typeof yourVariable === 'object'の場合は、オブジェクトまたはnullです。 nullを除外したい場合は、typeof yourVariable === 'object' && yourVariable !== nullにしてください。

Answer 3

JavaScriptで "object"を定義しましょう 。 MDN docs によると、すべての値はオブジェクトまたはプリミティブのいずれかです。

プリミティブ、プリミティブ値 

オブジェクトではなく、メソッドも持たないデータ。 JavaScriptには、5つの基本的なデータ型があります。文字列、数値、ブール値、null、未定義です。 

プリミティブとは何ですか？

• 3
• 'abc'
• true
• null
• undefined

オブジェクトとは何ですか（つまり、プリミティブではありません）。

• Object.prototype
• すべてがObject.prototype から派生したものです。
  • Function.prototype
    • Object
    • Function
    • function C(){} - ユーザー定義関数
  • C.prototype - ユーザー定義関数のプロトタイププロパティ：これはnotCs prototypeです
    • new C() - ユーザ定義関数を "new"する
  • Math
  • Array.prototype
    • 配列
  • {"a": 1, "b": 2} - リテラル表記を使用して作成されたオブジェクト
  • new Number(3) - プリミティブの周りのラッパー
  • ... 他にもたくさんあります ...
• Object.create(null)
• すべてがObject.create(null)から派生したものです

値がオブジェクトかどうかをチェックする方法

instanceofだけではうまくいきません。2つのケースを見逃しているからです。

// oops:  isObject(Object.prototype) -> false
// oops:  isObject(Object.create(null)) -> false
function isObject(val) {
    return val instanceof Object; 
}

typeof x === 'object'は、誤検出（null）および誤検出（関数）のために機能しません。

// oops: isObject(Object) -> false
function isObject(val) {
    return (typeof val === 'object');
}

Object.prototype.toString.callは、すべてのプリミティブが誤検出されるため機能しません。

> Object.prototype.toString.call(3)
"[object Number]"

> Object.prototype.toString.call(new Number(3))
"[object Number]"

だから私は使用します：

function isObject(val) {
    if (val === null) { return false;}
    return ( (typeof val === 'function') || (typeof val === 'object') );
}

---

@大安の答えもうまくいくようです：

function isObject(obj) {
  return obj === Object(obj);
}

なぜなら、 MDN docs ：に従って）

Objectコンストラクタは、与えられた値に対してオブジェクトラッパーを作成します。値がnullまたは未定義の場合は、空のオブジェクトを作成して返します。それ以外の場合は、指定された値に対応する型のオブジェクトを返します。値がすでにオブジェクトの場合は、値を返します。

---

うまくいくように見える3つ目の方法（100％であるかどうかわからない）はObject.getPrototypeOf which 引数がオブジェクトでない場合は例外 をスローします）

// these 5 examples throw exceptions
Object.getPrototypeOf(null)
Object.getPrototypeOf(undefined)
Object.getPrototypeOf(3)
Object.getPrototypeOf('abc')
Object.getPrototypeOf(true)

// these 5 examples don't throw exceptions
Object.getPrototypeOf(Object)
Object.getPrototypeOf(Object.prototype)
Object.getPrototypeOf(Object.create(null))
Object.getPrototypeOf([])
Object.getPrototypeOf({})

Answer 4

公式の underscore.js は、このチェックを使用して、何かが本当にオブジェクトであるかどうかを調べます。

// Is a given variable an object?
_.isObject = function(obj) {
  return obj === Object(obj);
};

_ update _

更新されたunderscore.js ライブラリは、V8の以前のバグとマイナーなマイクロスピードの最適化のため、現在以下を使用しています。 

// Is a given variable an object?
_.isObject = function(obj) {
  return typeof obj === 'function' || (typeof obj === 'object' && !!obj);
};

Answer 5

Object.prototype.toString.call(myVar)は以下を返します。

• myVarがオブジェクトの場合は"[object Object]"
• myVarが配列の場合は"[object Array]"
• 等.

これに関するより多くの情報とそれがなぜtypeofに代わる良い方法なのか、 この記事をチェックしてください 。

Answer 6

追加の関数呼び出し（速度）なしで、単にObjectまたはArrayに対して検査するためのものです。また投稿されたように ここ 。

isArray（）

isArray = function(a) {
    return (!!a) && (a.constructor === Array);
};
console.log(isArray(        )); // false
console.log(isArray(    null)); // false
console.log(isArray(    true)); // false
console.log(isArray(       1)); // false
console.log(isArray(   'str')); // false
console.log(isArray(      {})); // false
console.log(isArray(new Date)); // false
console.log(isArray(      [])); // true

isObject（） - 注：new Dateやnew YourCustomObjectなどのカスタムオブジェクトではfalseが返されるため、オブジェクトリテラルにのみ使用します。

isObject = function(a) {
    return (!!a) && (a.constructor === Object);
};
console.log(isObject(        )); // false
console.log(isObject(    null)); // false
console.log(isObject(    true)); // false
console.log(isObject(       1)); // false
console.log(isObject(   'str')); // false
console.log(isObject(      [])); // false
console.log(isObject(new Date)); // false
console.log(isObject(      {})); // true

Answer 7

私は単純に好きです： 

function isObject (item) {
  return (typeof item === "object" && !Array.isArray(item) && item !== null);
}

アイテムがJSオブジェクトで、JS配列ではなく、nullでもない場合…3つすべてが当てはまる場合、trueを返します。 3つの条件のいずれかが失敗した場合、&&テストは短絡し、falseが返されます。 nullテストは、必要に応じて省略することができます（nullの使い方によって異なります）。 

DOCS： 

http://devdocs.io/javascript/operators/typeof

http://devdocs.io/javascript/global_objects/object

http://devdocs.io/javascript/global_objects/array/isarray

http://devdocs.io/javascript/global_objects/null

Answer 8

関数Array.isArrayを使って：

function isObject(o) {
  return o !== null && typeof o === 'object' && Array.isArray(o) === false;
}

Array.isArray関数がない場合：

間違った答えに賛成投票がいくつあるかだけ驚いたのですか????
私のテストに合格したのは 1回答 だけです!!!ここで私は私の簡易版を作成しました：

function isObject(o) {
  return o instanceof Object && o.constructor === Object;
}

私にとっては、それは明確かつ単純であり、そしてただうまくいくだけです！ここで私のテスト：

console.log(isObject({}));             // Will return: true
console.log(isObject([]));             // Will return: false
console.log(isObject(null));           // Will return: false
console.log(isObject(/.*/));           // Will return: false
console.log(isObject(function () {})); // Will return: false

もう1つの時間：すべての回答がこのテストに合格するわけではありません。 ????

---

オブジェクトが特定のクラスのインスタンスであることを確認する必要がある場合は、次のように特定のクラスでコンストラクタをチェックする必要があります。

function isDate(o) {
  return o instanceof Object && o.constructor === Date;
}

簡単なテスト：

var d = new Date();
console.log(isObject(d)); // Will return: false
console.log(isDate(d));   // Will return: true

結果として、厳密で堅牢なコードになります。

---

isDatename__、isErrorname__、isRegExpname__などのような関数を作成しない場合は、この一般化関数を使用するオプションを検討してください。

function isObject(o) {
  return o instanceof Object && typeof o.constructor === 'function';
}

前述のすべてのテストケースで正しく機能するわけではありませんが、すべてのオブジェクト（プレーンまたは構築済み）には十分です。

---

ここ で説明されているObject.createの内部実装のため、Object.create(null)の場合はisObjectname__は機能しませんが、より洗練された実装ではisObjectname__を使用できます。

function isObject(o, strict = true) {
  if (o === null || o === undefined) {
    return false;
  }
  const instanceOfObject = o instanceof Object;
  const typeOfObject = typeof o === 'object';
  const constructorUndefined = o.constructor === undefined;
  const constructorObject = o.constructor === Object;
  const typeOfConstructorObject = typeof o.constructor === 'function';
  let r;
  if (strict === true) {
    r = (instanceOfObject || typeOfObject) && (constructorUndefined || constructorObject);
  } else {
    r = (constructorUndefined || typeOfConstructorObject);
  }
  return r;
};

この実装に基づいて npmのパッケージ v1がすでに作成されています。そしてそれはすべての前述のテストケースに有効です。 ????

Answer 9

質問に答える前に、まずこの概念を説明しましょう。JavaScript関数では、Object、null、Object、Array、さらにはDateであるため、nottypeof obj === 'object'のような簡単な方法なので、上記のすべてがtrueを返しますが、それをチェックする方法があります関数を記述するか、JavaScriptフレームワークを使用して、OK：

ここで、実際のオブジェクト（nullまたは関数または配列ではない）であるこのオブジェクトがあると想像してください。

var obj = {obj1: 'obj1', obj2: 'obj2'};

純粋なJavaScript：

//that's how it gets checked in angular framework
function isObject(obj) {
  return obj !== null && typeof obj === 'object';
}

または

//make sure the second object is capitalised 
function isObject(obj) {
   return Object.prototype.toString.call(obj) === '[object Object]';
}

または

function isObject(obj) {
    return obj.constructor.toString().indexOf("Object") > -1;
}

または

function isObject(obj) {
    return obj instanceof Object;
}

上記のように、これらの関数のいずれかをコードで呼び出すだけで使用でき、オブジェクトの場合はtrueを返します。

isObject(obj);

JavaScriptフレームワークを使用している場合、通常、これらの種類の関数が用意されていますが、これらはほとんどありません。

jQuery：

 //It returns 'object' if real Object;
 jQuery.type(obj);

角度：

angular.isObject(obj);

アンダースコアとロダッシュ：

//(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null)
_.isObject(obj);

Answer 10

それはあなたが "オブジェクトである"という意味によって異なります。 primitiveではないものすべて、つまり新しいプロパティを設定できるものが必要な場合は、次のようにします。

function isAnyObject(value) {
    return value != null && (typeof value === 'object' || typeof value === 'function');
}

プリミティブ（プレーン番号/ NaN/Infinity、プレーン文字列、シンボル、true/false、undefined、およびnull）は除外されます。他のすべてのもの（Number、Boolean、およびStringオブジェクトを含む）に対してtrueを返す必要があります。 windowやconsoleのような "Host"オブジェクトがtypeofと一緒に使用された場合に返すべきJSはJSでは定義されていないため、このようなチェックでカバーするのは困難です。

何かが「普通の」オブジェクトかどうか、つまりそれがリテラル{}として、またはObject.create(null)を使って作成されたものかどうかを知りたい場合は、次のようにします。

function isPlainObject(value) {
    if (Object.prototype.toString.call(value) !== '[object Object]') {
        return false;
    } else {
        var prototype = Object.getPrototypeOf(value);
        return prototype === null || prototype === Object.prototype;
    }
}

編集2018 ： Symbol.toStringTag はObject.prototype.toString.call(...)の出力をカスタマイズできるようになったため、オブジェクトがaとして初期化された場合でも、上記のisPlainObject関数はfalseを返す場合があります。リテラル。間違いなく、慣例により、カスタム文字列タグを持つオブジェクトは、もはや単なるプレーンオブジェクトではなくなりましたが、これはさらに、プレーンオブジェクトがJavascript内にあるものの定義を曖昧にしました。

Answer 11

何てことだ！これはこれまでよりも短くなると思います。これを見てみましょう。

短いコードと最終的なコード

function isObject(obj)
{
    return obj != null && obj.constructor.name === "Object"
}

console.log(isObject({})) // returns true
console.log(isObject([])) // returns false
console.log(isObject(null)) // returns false

説明した

戻り型

typeof JavaScriptオブジェクト（nullを含む）は"object"を返します

console.log(typeof null, typeof [], typeof {})

コンストラクターの確認

constructorプロパティをチェックすると、関数の名前が返されます。

console.log(({}).constructor) // returns a function with name "Object"
console.log(([]).constructor) // returns a function with name "Array"
console.log((null).constructor) //throws an error because null does not actually have a property

Function.nameの紹介

Function.nameは、関数の読み取り専用名、またはクロージャーの場合は"anonymous"を返します。

console.log(({}).constructor.name) // returns "Object"
console.log(([]).constructor.name) // returns "Array"
console.log((null).constructor.name) //throws an error because null does not actually have a property

注：2018年以降、Function.nameはで動作しない場合がありますhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

Answer 12

値の型をチェックする最も合理的な方法はtypeof演算子のようです。唯一の問題はそれがひどく壊れているということです。

• Null型に属するnullに対して"object"を返します。
• Object型に属する呼び出し可能オブジェクトに対しては"function"を返します。
• 非標準の呼び出し不可能なオブジェクトに必要なもの（ほとんど）を返すことができます。たとえば、IEは"unknown"を気に入っているようです。唯一の禁止された結果は"function"とプリミティブ型です。

typeofは、非nullプリミティブに対してのみ信頼性があります。したがって、値がオブジェクトであるかどうかをチェックする方法は、typeofによって返される文字列がプリミティブに対応していないこと、およびオブジェクトがnullではないことを確認することです。しかし問題は、将来の標準が新しいプリミティブ型を導入する可能性があり、私たちのコードではそれがオブジェクトであると見なされることです。新しい型は頻繁には現れませんが、例えばECMAScript 6ではSymbol型が導入されました。

したがって、typeofの代わりに、値がオブジェクトかそうでないかによって結果が異なるアプローチのみをお勧めします。次のようになります 

値がObject型に属しているかどうかをテストするための適切な方法の包括的ではあるが網羅的なリスト。

• Objectコンストラクタ

  Objectコンストラクタは、渡された引数をオブジェクトに強制変換します。すでにオブジェクトの場合は、同じオブジェクトが返されます。

  したがって、それを使用して値をオブジェクトに強制し、そのオブジェクトを元の値と厳密に比較することができます。

  次の関数にはECMAScript 3が必要です。これにより===が導入されました。

  function isObject(value) { /* Requires ECMAScript 3 or later */
    return Object(value) === value;
  }
  

  私はこのアプローチが好きです。なぜならそれは単純で自己記述的であり、そして同様のチェックはブール値、数字、そして文字列に対してもうまくいくからです。ただし、グローバルなObjectがシャドウされたり変更されたりしていないことに依存していることに注意してください。

• コンストラクタ

  コンストラクタをインスタンス化すると、作成したばかりのインスタンスとは異なる値を返すことがあります。しかし、その値はオブジェクトでない限り無視されます。

  次の関数にはECMAScript 3が必要です。これにより、コンストラクタは非オブジェクトを返すことができます。 ECMAScript 3の前はエラーを投げましたが、当時はtryステートメントは存在しませんでした。

  function isObject(value) { /* Requires ECMAScript 3 or later */
    return new function() { return value; }() === value;
  }
  

  前の例よりも少し単純ではありませんが、これはグローバルプロパティに依存しないため、最も安全な方法です。

• this値

  古いECMAScriptの仕様では、thisの値をオブジェクトにする必要がありました。 ECMAScript 3ではFunction.prototype.callが導入されました。これにより、任意のthis値で関数を呼び出すことができましたが、オブジェクトに強制変換されました。

  ECMAScript 5では、この動作を削除する厳密なモードが導入されましたが、ずさんなモードではまだそれに頼ることができます（おそらく間違いはしないでください）。

  function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */
    return function() { return this === value; }.call(value);
  }
  

• [[プロトタイプ]]

  通常のすべてのオブジェクトは[[Prototype]]と呼ばれる内部スロットを持ち、その値は他のどのオブジェクトから継承されるかを決定します。値はオブジェクトまたはnullのみです。したがって、目的の値から継承するオブジェクトを作成し、それが機能するかどうかを確認することができます。

  Object.createとObject.getPrototypeOfの両方にECMAScript 5が必要です。

  function isObject(value) { /* Requires ECMAScript 5 or later */
    try {
      Object.create(value);
      return value !== null;
    } catch(err) {
      return false;
    }
  }
  

  function isObject(value) { /* Requires ECMAScript 5 or later */
    function Constructor() {}
    Constructor.prototype = value;
    return Object.getPrototypeOf(new Constructor()) === value;
  }
  

• 新しいECMAScript 6の方法

  ECMAScript 6では、値がオブジェクトであることを確認するための新しい間接的な方法がいくつか導入されています。それらは、エラーをキャッチするためにtryステートメントの内側にラップされた、オブジェクトを必要とするいくつかのコードに値を渡すために以前に見られたアプローチを使います。コメントする価値がないいくつかの隠された例

  function isObject(value) { /* Requires ECMAScript 6 or later */
    try {
      Object.setPrototypeOf({}, value);
      return value !== null;
    } catch(err) {
      return false;
    }
  }

  function isObject(value) { /* Requires ECMAScript 6 or later */
    try {
      new WeakSet([value]);
      return true;
    } catch(err) {
      return false;
    }
  }

---

注意：Object.getPrototypeOf(value)（ES5）やReflectメソッド（ES6）のようないくつかのアプローチは意図的にスキップしました。 valueがプロキシの場合安全上の理由から、私の例では直接アクセスせずにvalueのみを参照しています。

Answer 13

これを試して

if (objectName instanceof Object == false) {
  alert('Not an object');
}
else {
  alert('An object');
}

Answer 14

私の神、他の答えにあまりにも混乱しています。

短い答え 

typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array)

これをテストするには、クロムコンソールで次のステートメントを実行します。

ケース1 -

var anyVar = {};
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // true

ケース2 /

anyVar = [];
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // false

ケース3 /

anyVar = null;
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array); // false

説明

それを分解しましょう

typeof anyVar == 'object'は、3つの候補 - [], {} and nullからtrueが返されます。

anyVar instanceof Objectは、これらの候補を2つに絞り込みます - [], {}

!(anyVar instanceof Array)は1つだけに絞り込みます - {}

ドラムロールしてください！

これでJavascriptでArrayをチェックする方法をすでに学んだかもしれません。

Answer 15

チェックに関数を使う準備ができて

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// Loose equality operator (==) is intentionally used to check
// for undefined too

// Also note that, even null is an object, within isDerivedObject
// function we skip that and always return false for null

---

説明

• Javascriptでは、null、Object、Array、Date、およびfunctionsはすべてオブジェクトです。ただし、nullは少し工夫が必要です。それで、それがnullではないことを検出するために、最初にnullをチェックするのが良いです。

• typeof o === 'object'をチェックすることで、oがオブジェクトであることが保証されます。このチェックがなければ、undefinedやnullであっても、Object.prototype.toStringは反転のためのオブジェクトを返すので意味がありません。例えば、toString(undefined)は[object Undefined]！を返します。

  typeof o === 'object'チェックの後、toString.call（o）はoがオブジェクトであるか、Array、Dateまたはfunctionのような派生オブジェクトであるかをチェックするための優れた方法です。

• isDerivedObject関数では、oが関数であることを確認します。なぜなら、機能はオブジェクトでもあるからです。そうでなければ、functionはfalseを返します。例：isDerivedObject(function() {})はfalseを返しますが、現在はtrueを返します。

• オブジェクトとは何かの定義はいつでも変更できます。したがって、それに応じてこれらの機能を変更することができます。

---

テスト

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// TESTS

// is null an object?

console.log(
  'is null an object?', isObject(null)
);

console.log(
  'is null a derived object?', isDerivedObject(null)
);

// is 1234 an object?

console.log(
  'is 1234 an object?', isObject(1234)
);

console.log(
  'is 1234 a derived object?', isDerivedObject(1234)
);

// is new Number(1234) an object?

console.log(
  'is new Number(1234) an object?', isObject(new Number(1234))
);

console.log(
  'is new Number(1234) a derived object?', isDerivedObject(1234)
);

// is function object an object?

console.log(
  'is (new (function (){})) an object?', 
  isObject((new (function (){})))
);

console.log(
  'is (new (function (){})) a derived object?', 
  isObject((new (function (){})))
);

// is {} an object?

console.log(
  'is {} an object?', isObject({})
);

console.log(
  'is {} a derived object?', isDerivedObject({})
);

// is Array an object?

console.log(
  'is Array an object?',
  isObject([])
)

console.log(
  'is Array a derived object?',
  isDerivedObject([])
)

// is Date an object?

console.log(
  'is Date an object?', isObject(new Date())
);

console.log(
  'is Date a derived object?', isDerivedObject(new Date())
);

// is function an object?

console.log(
  'is function an object?', isObject(function(){})
);

console.log(
  'is function a derived object?', isDerivedObject(function(){})
);

Answer 16

var a = [1]
typeof a //"object"
a instanceof Object //true
a instanceof Array //true

var b ={a: 1}
b instanceof Object //true
b instanceof Array //false

var c = null
c instanceof Object //false
c instanceof Array //false

私はより多くの詳細を提供するように頼まれました。私たちの変数がオブジェクトであるかどうかを確認するための最も明快でわかりやすい方法はtypeof myVarです。それはタイプ（例えば"object"、"undefined"）を持つ文字列を返します。

残念ながら、Arrayとnullのどちらにもobjectという型があります。実際のオブジェクトのみを取得するには、instanceof演算子を使用して継承チェーンをチェックする必要があります。それはnullを排除しますが、Arrayは継承チェーンにObjectを持ちます。

だから解決策は：

if (myVar instanceof Object && !(myVar instanceof Array)) {
  // code for objects
}

Answer 17

ちょっと遅れて… "普通のオブジェクト"（{'x'：5、 'y'：7}のように）のために、私はこの小さな断片を持っています。

function isPlainObject(o) {
   return ((o === null) || Array.isArray(o) || typeof o == 'function') ?
           false
          :(typeof o == 'object');
}

次の出力が生成されます。

console.debug(isPlainObject(isPlainObject)); //function, false
console.debug(isPlainObject({'x': 6, 'y': 16})); //literal object, true
console.debug(isPlainObject(5)); //number, false
console.debug(isPlainObject(undefined)); //undefined, false
console.debug(isPlainObject(null)); //null, false
console.debug(isPlainObject('a')); //string, false
console.debug(isPlainObject([])); //array?, false
console.debug(isPlainObject(true)); //bool, false
console.debug(isPlainObject(false)); //bool, false

それはいつも私のために働きます。 「o」の型が「object」で、null、配列、または関数でない場合に限り、「true」が返されます。 :)

Answer 18

lodashは isPlainObject を持っています。関数や配列を与えるとfalseを返します。

Answer 19

他のすべてが失敗するとき、私はこれを使います：

var isObject = function(item) {
   return item.constructor.name === "Object";
}; 

Answer 20

これはうまくいくでしょう。これは、true、false、または場合によってはnullを返す関数です。

const isObject = obj => obj && obj.constructor && obj.constructor === Object;

console.log(isObject({})); // true
console.log(isObject([])); // false
console.log(isObject(new Function)); // false
console.log(isObject(new Number(123))); // false
console.log(isObject(null)); // null

Answer 21

Ramda 関数ライブラリはJavaScriptの型を検出するための素晴らしい機能を持っています。

全機能を言い換えると ：

function type(val) {
  return val === null      ? 'Null'      :
         val === undefined ? 'Undefined' :
         Object.prototype.toString.call(val).slice(8, -1);
}

解決策がどれほどシンプルで美しいかを実感したとき、私は笑わなければならなかった。

Ramda ドキュメント ：からの使用例

R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type('s'); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp"
R.type(() => {}); //=> "Function"
R.type(undefined); //=> "Undefined"

Answer 22

この問題を正しく処理する方法について多くの混乱があるように思われるので、私は2セントを残します（この答えは仕様に準拠しており、あらゆる状況下で正しい結果を生成します）。

プリミティブのテスト： undefinednullbooleanstringnumber

function isPrimitive(o){return typeof o!=='object'||null}

オブジェクトはプリミティブではありません。

function isObject(o){return !isPrimitive(o)}

あるいは、

function isObject(o){return o instanceof Object}
function isPrimitive(o){return !isObject(o)}

任意の配列に対するテスト

const isArray=(function(){
    const arrayTypes=Object.create(null);
    arrayTypes['Array']=true;
    arrayTypes['Int8Array']=true;
    arrayTypes['Uint8Array']=true;
    arrayTypes['Uint8ClampedArray']=true;
    arrayTypes['Int16Array']=true;
    arrayTypes['Uint16Array']=true;
    arrayTypes['Int32Array']=true;
    arrayTypes['Uint32Array']=true;
    arrayTypes['Float32Array']=true;
    arrayTypes['Float64Array']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!!arrayTypes[o.constructor.name];
    }
}());

以下を除くオブジェクトのテスト：DateRegExpBooleanNumberStringFunction any Array

const isObjectStrict=(function(){
    const nativeTypes=Object.create(null);
    nativeTypes['Date']=true;
    nativeTypes['RegExp']=true;
    nativeTypes['Boolean']=true;
    nativeTypes['Number']=true;
    nativeTypes['String']=true;
    nativeTypes['Function']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!isArray(o)&&!nativeTypes[o.constructor.name];
    }
}());

Answer 23

if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}

Answer 24

  var isObject = function(obj) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

!!objはオブジェクトが真実かどうかをチェックするための省略形です（null/undefinedを除外するため） 

Answer 25

私が使いたいのはこれです

function isObject (obj) {
  return typeof(obj) == "object" 
        && !Array.isArray(obj) 
        && obj != null 
        && obj != ""
        && !(obj instanceof String)  }

ほとんどの場合、DateはチェックをObjectとして渡す必要があるため、日付を除外することはしません。

Answer 26

私はこのSO questionからちょうどこの種の型チェックをするための "新しい"方法を見つけました： instanceofがなぜいくつかのリテラルに対してfalseを返すのですか？

それから、私は次のように型チェックのための関数を作成しました：

function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return false;         //fallback for null or undefined
    }
}

それならあなたはただできる：

console.log(isVarTypeOf('asdf', String));   // returns true
console.log(isVarTypeOf(new String('asdf'), String));   // returns true
console.log(isVarTypeOf(123, String));   // returns false
console.log(isVarTypeOf(123, Number));   // returns true
console.log(isVarTypeOf(new Date(), String));   // returns false
console.log(isVarTypeOf(new Date(), Number));   // returns false
console.log(isVarTypeOf(new Date(), Date));   // returns true
console.log(isVarTypeOf([], Object));   // returns false
console.log(isVarTypeOf([], Array));   // returns true
console.log(isVarTypeOf({}, Object));   // returns true
console.log(isVarTypeOf({}, Array));   // returns false
console.log(isVarTypeOf(null, Object));   // returns false
console.log(isVarTypeOf(undefined, Object));   // returns false
console.log(isVarTypeOf(false, Boolean));   // returns true

これはChrome 56、Firefox 52、Microsoft Edge 38、Internet Explorer 11、Opera 43でテストされています。

編集：
もし変数がnullか未定義かどうかも確認したいなら、代わりにこれを使うことができます：

function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return _var == _type;   //null and undefined are considered the same
        // or you can use === if you want to differentiate them
    }
}

var a = undefined, b = null;
console.log(isVarTypeOf(a, undefined)) // returns true
console.log(isVarTypeOf(b, undefined)) // returns true
console.log(isVarTypeOf(a, null)) // returns true

inancのコメントからの更新：チャレンジ承認：D

オブジェクトを比較したくない場合は、次の方法で試すことができます。

function isVarTypeOf(_var, _type, looseCompare){
    if (!looseCompare){
        try {
            return _var.constructor === _type;
        } catch(ex){
            return _var == _type;
        }
    } else {
        try{
            switch(_var.constructor){
                case Number:
                case Function:
                case Boolean:
                case Symbol:
                case Date:
                case String:
                case RegExp:
                    // add all standard objects you want to differentiate here
                    return _var.constructor === _type;
                case Error:
                case EvalError:
                case RangeError:
                case ReferenceError:
                case SyntaxError:
                case TypeError:
                case URIError:
                    // all errors are considered the same when compared to generic Error
                    return (_type === Error ? Error : _var.constructor) === _type;
                case Array:
                case Int8Array:
                case Uint8Array:
                case Uint8ClampedArray:
                case Int16Array:
                case Uint16Array:
                case Int32Array:
                case Uint32Array:
                case Float32Array:
                case Float64Array:
                    // all types of array are considered the same when compared to generic Array
                    return (_type === Array ? Array : _var.constructor) === _type;
                case Object:
                default:
                    // the remaining are considered as custom class/object, so treat it as object when compared to generic Object
                    return (_type === Object ? Object : _var.constructor) === _type;
            }
        } catch(ex){
            return _var == _type;   //null and undefined are considered the same
            // or you can use === if you want to differentiate them
        }
    }
}

そのように、あなたはちょうどinancのコメントのようにすることができます：

isVarTypeOf(new (function Foo(){}), Object); // returns false
isVarTypeOf(new (function Foo(){}), Object, true); // returns true

または

Foo = function(){};
Bar = function(){};
isVarTypeOf(new Foo(), Object);   // returns false
isVarTypeOf(new Foo(), Object, true);   // returns true
isVarTypeOf(new Bar(), Foo, true);   // returns false
isVarTypeOf(new Bar(), Bar, true);   // returns true
isVarTypeOf(new Bar(), Bar);    // returns true

Answer 27

prototypeのobjectがもっぱらObjectから来ているかどうかをチェックしたい場合String、Number、Array、Argumentsなどを除外します。

function isObject(n) {
  if (n == null) return false;
  return Object.prototype.toString.call(n) === '[object Object]';
}

Answer 28

use typeof(my_obj)は、それがどのタイプの変数かを示します。 

それがオブジェクトであれば 'object'が表示されます

単純なJS関数、

function isObj(v) {
    return typeof(v) == "object"
}

例：

function isObj(v) {
    return typeof(v) == "object"
}

var samp_obj = {
   "a" : 1,
   "b" : 2,
   "c" : 3
}

var num = 10;
var txt = "Hello World!"
var_collection = [samp_obj, num, txt]
for (var i in var_collection) {
  if(isObj(var_collection[i])) {
     console.log("yes it is object")
  }
  else {
     console.log("No it is "+ typeof(var_collection[i]))
  }
}

Answer 29

すでにAngularJSを使用している場合は、そのオブジェクトがオブジェクトであるかどうかをチェックする組み込みメソッドがあります（nullを受け入れずに）。 

angular.isObject(...)

Answer 30

ほとんどの場合typeof obj[index] === 'object'が使用されますが、オブジェクトであるfunctionと#documentも返します。それが結果に含まれる必要があるかどうかはあなた次第です。

基本的には、コンソールの出力を確認することで、特定の要素がオブジェクトである場合に除外するテストコードを作成できます。ここでは、サンプル用にコードを実行することができます。

function cekObject(obj, index) {  
  if (!obj.tagName) {

    //test case #1      
    if (typeof obj === 'object') {
      console.log('obj['+ index +'] is listed as an object');
    }	
    
  }
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.2.3/jquery.min.js"></script>
<script>
  function updateFilters() {
    var object = $('.j-image');
    $('.juicer-feed').empty();
    
    for(var index in object) {
      cekObject(object[index], index);
    }; 
  }
</script>

<ul class="juicer-feed" data-feed-id="chetabahana" data-after="updateFilters()"></ul>
<script src="https://assets.juicer.io/embed.js"></script>

Answer 31

これはユースケースに依存します。配列や関数をObjectにしたくない場合は、underscore.js組み込み関数を使用できます。 

function xyz (obj) { 
   if (_.isObject(obj) && !_.isFunction(obj) && !.isArray(obj)) {
     // now its sure that obj is an object 
   } 
}

Answer 32

barがオブジェクトであるかどうかを判別するために - typeof bar === "object"を検討してください

typeof bar === "object"はbarがオブジェクトであるかどうかを確認する信頼できる方法ですが、JavaScriptで驚くべきことはnullもオブジェクトと見なされることです。

したがって、次のコードは、ほとんどの開発者にとって驚くことに、コンソールにtrue（falseではない）のログを記録します。

var bar = null;console.log(typeof bar === "object"); // logs true! これを知っている限り、barがnullであるかどうかも確認することで問題を簡単に回避できます。

console.log((bar !== null) && (typeof bar === "object")); // logs false 答えを完全に理解するために、注目に値する他の2つのことがあります。

まず、barが関数の場合、上記の解決策はfalseを返します。ほとんどの場合、これは望ましい動作ですが、関数に対してもtrueを返したい場合は、上記の解決策を次のように修正できます。

console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function"))); 次に、barが配列の場合（例えばvar bar = [];の場合）、上記の解法はtrueを返します。配列は確かにオブジェクトなので、ほとんどの場合、これは望ましい動作ですが、配列についてもfalseにしたい場合は、上記の解決策を次のように修正できます。

console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]")); しかし、null、配列、および関数に対してはfalseを返すが、オブジェクトに対してはtrueを返すもう1つの選択肢があります。

console.log((bar !== null) && (bar.constructor === Object)); あるいは、jQueryを使っているのなら：

console.log((bar !== null) && (typeof bar === "object") && (! $.isArray(bar)));

ES5では、独自のnullチェックを含めて、配列のケースが非常に単純になります。

console.log(Array.isArray(bar));

Answer 33

指定された値が{}であるかどうかを明示的に確認する場合。

function isObject (value) {
 return value && typeof value === 'object' && value.constructor === Object;
}

Answer 34

このように、JSON.stringifyを使ってオブジェクトをテストすることができます。

var test = {}
if(JSON.stringify(test)[0] === '{') {
  console.log('this is a Object')
}