L'indice di JavaScript del chiarimento dello spessore?

Question

vidi a mdn il codice che dovrebbe essere utilizzato - se non esiste indexOf implementazione .

Questo algoritmo corrisponde a quello specificato in ECMA-262 ... come dicono

Ed ecco il codice:

/*1*/   if (!Array.prototype.indexOf) {
/*2*/     Array.prototype.indexOf = function (searchElement , fromIndex) {
/*3*/       var i,
/*4*/           pivot = (fromIndex) ? fromIndex : 0,
/*5*/           length;
/*6*/   
/*7*/       if (!this) {
/*8*/         throw new TypeError();
/*9*/       }
/*10*/   
/*11*/       length = this.length;
/*12*/   
/*13*/       if (length === 0 || pivot >= length) {
/*14*/         return -1;
/*15*/       }
/*16*/   
/*17*/       if (pivot < 0) {
/*18*/         pivot = length - Math.abs(pivot);
/*19*/       }
/*20*/   
/*21*/       for (i = pivot; i < length; i++) {
/*22*/         if (this[i] === searchElement) {
/*23*/           return i;
/*24*/         }
/*25*/       }
/*26*/       return -1;
/*27*/     };
/*28*/   }

Ma la mia domanda riguarda la linea n. 7:

Se scrivo:

[].indexOf poi - this è l'array stesso. (Diamine, è attaccato a Array.prototype.indexOf - in primo luogo).

Intendo - this sarà sempre un valore verità. Così perché Questo controllo esiste?

Inoltre - Resharper mi mostra questo (che è perfettamente logico):

Allora - perché questo assegno esiste? Mi manca qualcosa qui?

Answer 1

Non necessariamente - è perché il indexOf() La funzione nativa utilizza la diretta this Il valore è passato, non quello convertito in un oggetto (equivalente a ciò che accade in modalità rigorosa) e tale spessore dovrebbe verificare che ciò sia conforme. Ad esempio, questo codice lancerà a TypeError:

var a = Array.prototype.indexOf;
a();

Lancerà un TypeError, come la this Il valore non viene convertito in un oggetto o modificato in oggetto globale. Nelle funzioni non restrizioni definite dall'utente, il valore di this è l'oggetto globale se non esiste un oggetto genitore, ma in modalità rigorosa ES5 viene superato come undefined si. Un'altra situazione è quando la chiami specificamente con null o undefined:

"use strict";
Array.prototype.indexOf.call(null); // TypeError, what else can we do?

Nella specifica ES5, il questo valore si riferisce al valore originale approvato come il thisArg, senza alcun cambiamento. In modalità non restriciata, il questo valore non è accessibile al codice nelle funzioni definite dall'utente, ma le funzioni native sono in grado di specificare esplicitamente l'uso di il questo valore invece di cosa this La parola chiave valuta (che viene definita come ThisBinding Nella specifica). In modalità rigorosa, entrambi valutano la stessa cosa.

Perché la versione nativa è in grado di accedere alla versione non boxd del this Valore in modalità non restringente (che viene passato direttamente alla funzione interna [[ToObject]], che lancia a TypeError Dopo aver tentato di convertire null o undefined), questo controllo deve essere implementato per soddisfare i requisiti delle specifiche.

Nota: tecnicamente, il campione di codice nella tua domanda non lo è piuttosto dalla specifica ES5, come il this Il valore potrebbe essere falsy, il che lo fallirebbe anche se dovrebbe procedere in teoria (implementazioni native di indexOf() Non lanciare se false è passato come il this valore). Inoltre, poiché l'oggetto globale sarebbe passato se il questo valore era effettivamente indefinito o nullo, avrebbe superato il if (!this) Test, anche quando non dovrebbe. Ciò non può essere risolto semplicemente verificando che l'argomento non è l'oggetto globale, perché ciò non fallisce se l'oggetto globale fosse esplicitamente approvato (che è consentito).