İnstanceof neden bazı değişmez değerler için yanlış döndürür?

"foo" instanceof String //=> false
"foo" instanceof Object //=> false
true instanceof Boolean //=> false
true instanceof Object //=> false
false instanceof Boolean //=> false
false instanceof Object //=> false

// the tests against Object really don't make sense

Dizi değişmezleri ve Nesne değişmezleri eşleşiyor ...

[0,1] instanceof Array //=> true
{0:1} instanceof Object //=> true

Neden hepsi olmasın? Ya da neden hepsi olmasın ?
Peki, o zaman neye benziyorlar?

FF3, IE7, Opera ve Chrome için de aynı şey geçerli. Yani, en azından tutarlı.

Birkaç cevapsız.

12.21 instanceof Number //=> false
/foo/ instanceof RegExp //=> true

Temel öğeler, Javascript içinden oluşturulan nesnelerden farklı türde bir türdür. Gönderen Mozilla API docs :

var color1 = new String("green");
color1 instanceof String; // returns true
var color2 = "coral";
color2 instanceof String; // returns false (color2 is not a String object)

Kod ile ilkel türleri oluşturmak için herhangi bir yol bulamıyorum, belki de mümkün değildir. Muhtemelen insanlar typeof "foo" === "string"bunun yerine kullanıyor instanceof.

Bunun gibi şeyleri hatırlamanın kolay bir yolu kendinize "Aklı başında ve öğrenmesi kolay ne olacağını merak ediyorum" diye sormak mı? Cevap ne olursa olsun, Javascript başka bir şey yapar.

Kullanırım:

function isString(s) {
    return typeof(s) === 'string' || s instanceof String;
}

Çünkü JavaScript'te dizeler değişmezler veya nesneler olabilir.

JavaScript'te ilkelundefined öğeler (booleans, null, sayı, dize ve değer (ve ES6'daki sembol)) dışında her şey bir nesnedir (veya en azından bir nesne olarak ele alınabilir):

console.log(typeof true);           // boolean
console.log(typeof 0);              // number
console.log(typeof "");             // string
console.log(typeof undefined);      // undefined
console.log(typeof null);           // object
console.log(typeof []);             // object
console.log(typeof {});             // object
console.log(typeof function () {}); // function

Gördüğünüz gibi, diziler ve değerlerin nulltümü nesneler olarak kabul edilir ( nullvar olmayan bir nesneye referanstır). İşlevler ayırt edilebilir, çünkü bunlar özel olarak çağrılabilir nesnelerdir. Ancak hala nesnelerdir.

Değişmezleri Öte yandan true, 0,"" ve undefineddeğil nesneleri vardır. Bunlar JavaScript'teki ilkel değerlerdir. Ancak boolean, sayı ve dizeleri de kurucuya sahip Boolean, Numberve Stringek işlevsellik sağlamak amacıyla kendi temelögeye sarmak hangi sırasıyla:

console.log(typeof new Boolean(true)); // object
console.log(typeof new Number(0));     // object
console.log(typeof new String(""));    // object

İlkel değerlerin ne zaman sarıldığını görebileceğiniz gibi Boolean,Number ve Stringkurucular sırasıyla onlar nesneler haline gelir. instanceofOperatörü yalnızca (döndürür neden olan nesneler için çalışır falseilkel değerler için):

console.log(true instanceof Boolean);              // false
console.log(0 instanceof Number);                  // false
console.log("" instanceof String);                 // false
console.log(new Boolean(true) instanceof Boolean); // true
console.log(new Number(0) instanceof Number);      // true
console.log(new String("") instanceof String);     // true

Her ikisini de görebileceğiniz typeofve instanceofbir değerin bir boolean, sayı veya dize olup olmadığını test etmek için yetersiz - typeofyalnızca ilkel boole, sayı ve dize için çalışır; ve instanceofilkel boolelar, sayılar ve karakter dizileri için çalışmaz.

Neyse ki bu sorunun basit bir çözümü var. Varsayılan uygulaması toString(yani yerel olarak tanımlandığı gibi)Object.prototype.toString ) [[Class]], hem ilkel değerlerin hem de nesnelerin dahili özelliğini döndürür :

function classOf(value) {
    return Object.prototype.toString.call(value);
}

console.log(classOf(true));              // [object Boolean]
console.log(classOf(0));                 // [object Number]
console.log(classOf(""));                // [object String]
console.log(classOf(new Boolean(true))); // [object Boolean]
console.log(classOf(new Number(0)));     // [object Number]
console.log(classOf(new String("")));    // [object String]

[[Class]]Bir değerin iç özelliği, değerden çok daha kullanışlıdır typeof. KullanabilirizObject.prototype.toStringtypeofOperatörün kendi (daha kullanışlı) versiyonumuzu aşağıdaki gibi oluşturmak için :

function typeOf(value) {
    return Object.prototype.toString.call(value).slice(8, -1);
}

console.log(typeOf(true));              // Boolean
console.log(typeOf(0));                 // Number
console.log(typeOf(""));                // String
console.log(typeOf(new Boolean(true))); // Boolean
console.log(typeOf(new Number(0)));     // Number
console.log(typeOf(new String("")));    // String

Umarım bu makale yardımcı olmuştur. İlkel öğeler ve sarılmış nesneler arasındaki farklar hakkında daha fazla bilgi için aşağıdaki blog gönderisini okuyun: JavaScript İlkellerinin Gizli Yaşamı

Constructor özelliğini kullanabilirsiniz:

'foo'.constructor == String // returns true
true.constructor == Boolean // returns true

 typeof(text) === 'string' || text instanceof String; 

Bunu kullanabilirsiniz, her iki durum için de çalışacaktır.

1. var text="foo"; // typeof çalışacak

2. String text= new String("foo"); // instanceof çalışacak

Bu, ECMAScript spesifikasyonu Bölüm 7.3.19 Adım 3'te tanımlanmıştır. :If Type(O) is not Object, return false.

Başka bir deyişle , Objin Obj instanceof Callablebir nesne değilse, doğrudan instanceofdevreye kısa devre yapar false.

Uygun bir çözüm bulduğuma inanıyorum:

Object.getPrototypeOf('test') === String.prototype    //true
Object.getPrototypeOf(1) === String.prototype         //false

https://www.npmjs.com/package/typeof

instanceof(Yapıcı adı) dizesinin temsilini döndürür

function instanceOf(object) {
  var type = typeof object

  if (type === 'undefined') {
    return 'undefined'
  }

  if (object) {
    type = object.constructor.name
  } else if (type === 'object') {
    type = Object.prototype.toString.call(object).slice(8, -1)
  }

  return type.toLowerCase()
}

instanceOf(false)                  // "boolean"
instanceOf(new Promise(() => {}))  // "promise"
instanceOf(null)                   // "null"
instanceOf(undefined)              // "undefined"
instanceOf(1)                      // "number"
instanceOf(() => {})               // "function"
instanceOf([])                     // "array"

Benim için karışıklık

"str".__proto__ // #1
=> String

Öyleyse "str" istanceof Stringdönmeliyiz trueçünkü istanceof nasıl çalışır?

"str".__proto__ == String.prototype // #2
=> true

1 ve 2 numaralı ifadelerin sonuçları birbiriyle çelişmektedir, bu yüzden bunlardan biri yanlış olmalıdır.

# 1 yanlış

Ben neden __proto__standart dışı özelliği olduğunu anlamak , bu yüzden standart bir kullanın:Object.getPrototypeOf

Object.getPrototypeOf("str") // #3
=> TypeError: Object.getPrototypeOf called on non-object

Şimdi # 2 ve # 3 ifadeleri arasında karışıklık yok

Ya da sadece kendi işlevinizi şu şekilde yapabilirsiniz:

function isInstanceOf(obj, clazz){
  return (obj instanceof eval("("+clazz+")")) || (typeof obj == clazz.toLowerCase());
};

kullanımı:

isInstanceOf('','String');
isInstanceOf(new String(), 'String');

Bunların ikisi de doğru dönmelidir.