È possibile determinare se un oggetto creato con Object.create eredita dalla matrice in JavaScript?

Question

Identificare quali oggetti sono is complicated in JavaScript e determinare quali oggetti sono matrici ha qualcosa di hacky solution. Per fortuna, riesce a lavorare in entrambi i seguenti casi:

Object.prototype.toString.call([]);   // [object Array] 
Object.prototype.toString.call(new Array()); // [object Array] 

Grande, non [object Object] in vista! Purtroppo, questo metodo riesce ancora a fallire con questo:

var arr = Object.create(Array.prototype); 
Object.prototype.toString.call(arr);   // [object Object] 

Questo è frustrante, per non dire altro. Il mio oggetto arr ha tutti i metodi di un array, funziona come un array e, per tutti gli scopi, lo è un array. Tuttavia JavaScript non fornisce gli strumenti per identificarlo come tale.

C'è un modo per capire se un oggetto eredita da un particolare prototipo? Suppongo che si possa scorrere i prototipi in questo modo:

function inherits(obj, proto) { 
    while (obj != null) { 
     if (obj == proto) return true; 
     obj = Object.getPrototypeOf(obj); 
    } 
    return false; 
} 

inherits(Object.create(Array.prototype), Array.prototype); // true 

Ma ci si sente un po 'hacky. C'è un approccio più pulito?

Answer 1

Come su un operatore instanceof? Esso restituisce true per tutti i vostri casi:

[] instanceof Array //true 
new Array() instanceof Array //true 
Object.create(Array.prototype) instanceof Array //true 

Tuttavia:

Object.create(Array.prototype) instanceof Object //also true 

quindi state attenti.

Answer 2

ECMAScript 5 ha introdotto Array.isArray() in javascript che fornisce un modo affidabile per controllare. Per i vecchi browser, fissiamo che, (citato da questa book)

function isArray(value) { 
    if (typeof Array.isArray === "function") { 
     return Array.isArray(value); 
    } else { 
     return Object.prototype.toString.call(value) === "[object Array]"; 
    } 
} 

Ma ho appena scoperto la funzione built-in Array.isArray non funziona correttamente quando usiamo Object.create (testato in cromo). Mi si avvicinò con un metodo che funziona:

function isArray(value) { 
    if (typeof value === "undefined" || value === null) { 
      return false; 
    } 
    do { 
      if (Object.prototype.toString.call(value) === "[object Array]") { 
       return true; 
      } 
      value= Object.getPrototypeOf(value); 
    } while (value); 

    return false; 
} 

usarlo:

var arr = Object.create(Array.prototype); 
var arr1 = Object.create(Object.create(Array.prototype)); 
var arr2 = new Array(); 
var arr3 = []; 
isArray(arr); 
isArray(arr1); 
isArray(arr2); 
isArray(arr3); 

Answer 3

Come circa il controllo del costruttore?

function inherits(obj, proto) { 
    return obj.constructor === proto.constructor; 
} 

inherits(Object.create(Array.prototype), Array.prototype); // true 

Answer 4

Vedere http://perfectionkills.com/how-ecmascript-5-still-does-not-allow-to-subclass-an-array/ per l'esposizione definitiva dei problemi in eredita dalla matrice.

Ad ogni modo, nel caso più semplice, in cui si sta facendo

var sort_of_an_array = Object.create(Array.prototype); 

si può controllare usando isPrototypeOf:

Array.prototype.isPrototypeOf(sort_of_an_array) 

Vedi https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf.

Answer 5

funziona come una matrice, e in ogni caso, è un array

No. Non ha length struttura auto-aggiornamento. Vedi this article perché è quasi impossibile creare una sottoclasse di Array.

C'è un modo per capire se un oggetto eredita da un particolare prototipo? Suppongo che tu possa scorrere i prototipi, ma sembra un po 'hacky.

Questo è solo come farlo. Un approccio più pulito di una funzione di auto-scritta sarebbe quella di utilizzare il instanceof operator:

arr instanceof Array; // true