Dlaczego instanceof zwraca false dla niektórych literałów?

"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

Literały tablicowe i literalne obiektowe pasują ...

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

Dlaczego nie wszyscy? Albo, dlaczego nie wszyscy oni nie ?
A zatem, co to za przykład?

Tak samo jest w FF3, IE7, Opera i Chrome. Więc przynajmniej jest spójny.

Brakowało kilku.

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

Prymitywy są innego rodzaju niż obiekty tworzone z poziomu Javascript. Z dokumentacji API Mozilla :

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

Nie mogę znaleźć żadnego sposobu na zbudowanie prymitywnych typów za pomocą kodu, być może nie jest to możliwe. Prawdopodobnie dlatego ludzie używają typeof "foo" === "string"zamiast instanceof.

Łatwym sposobem na zapamiętanie takich rzeczy jest zadawanie sobie pytania „Zastanawiam się, co byłoby rozsądne i łatwe do nauczenia się”? Jakakolwiek jest odpowiedź, Javascript robi to samo.

Używam:

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

Ponieważ w JavaScript ciągi znaków mogą być literałami lub obiektami.

W JavaScript wszystko jest obiektem (lub przynajmniej może być traktowane jako obiekt), z wyjątkiem prymitywów (booleany, null, liczby, łańcuchy i wartość undefined(i symbol w ES6)):

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

Jak widać obiekty, tablice i wartość nullsą uważane za obiekty ( nulljest odniesieniem do obiektu, który nie istnieje). Funkcje są rozróżniane, ponieważ są specjalnym rodzajem obiektów, które można wywoływać . Jednak nadal są obiektami.

Z drugiej strony literały true, 0, ""a undefinednie obiektów. Są to prymitywne wartości w JavaScript. Jednak logicznych, liczby i ciągi mają także konstruktorów Boolean, Numbera Stringodpowiednio który owinąć swoje odpowiednie prymitywów, aby zapewnić dodatkową funkcjonalność:

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

Jak widać, gdy prymitywne wartości są zawinięte w odpowiednio Boolean, Numberi Stringkonstruktory stają się obiektami. instanceofOperator działa tylko dla obiektów (dlatego wraca falsedo wartości pierwotnych):

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

Jak widać oba typeofi instanceofsą niewystarczające do sprawdzenia, czy wartość jest wartością logiczną, liczbą lub łańcuchem - typeofdziała tylko dla prymitywnych boolanów, liczb i łańcuchów; i instanceofnie działa dla prymitywnych boolanów, liczb i łańcuchów.

Na szczęście istnieje proste rozwiązanie tego problemu. Domyślna implementacja toString(tzn. Jak jest natywnie zdefiniowana Object.prototype.toString) zwraca wewnętrzną [[Class]]właściwość zarówno pierwotnych wartości, jak i obiektów:

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]

Wewnętrzna [[Class]]właściwość wartości jest znacznie bardziej użyteczna niż typeofwartość. Możemy użyć Object.prototype.toStringdo stworzenia własnej (bardziej użytecznej) wersji typeofoperatora w następujący sposób:

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

Mam nadzieję, że ten artykuł pomógł. Aby dowiedzieć się więcej o różnicach między prymitywami a opakowanymi obiektami, przeczytaj następujący post na blogu: Sekretne życie prymitywów JavaScript

Możesz użyć właściwości konstruktora:

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

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

możesz tego użyć, zadziała w obu przypadkach jako

1. var text="foo"; // typeof będzie działać

2. String text= new String("foo"); // instanceof będzie działać

Jest to zdefiniowane w specyfikacji ECMAScript w rozdziale 7.3.19 Krok 3 :If Type(O) is not Object, return false.

Innymi słowy, jeśli Objw Obj instanceof Callablenie jest przedmiotem, instanceofbędzie zwarcie do falsebezpośrednio.

Myślę, że wpadłem na realne rozwiązanie:

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

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

Zwraca ciąg znaków reprezentujący instanceof(nazwa konstruktora)

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"

Dla mnie zamieszanie spowodowane przez

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

Więc "str" istanceof Stringpowinien wrócić, trueponieważ jak działa istanceof, jak poniżej:

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

Wyniki ekspresji nr 1 i nr 2 sobą sprzeczne, więc jeden z nich powinien być nieprawidłowy.

# 1 jest zły

Rozumiem, że jest to spowodowane __proto__niestandardową właściwością, więc użyj standardowej:Object.getPrototypeOf

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

Teraz nie ma zamieszania między wyrażeniem nr 2 i nr 3

Lub możesz po prostu stworzyć własną funkcję:

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

stosowanie:

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

Oba powinny zwrócić wartość true.