¿El índice de la aclaración de JavaScript SHIM?

Question

Yo vi en MDN el código que debe usarse: si no hay indexOf implementación.

Este algoritmo coincide con el especificado en ECMA-262 ... como ellos dicen

Y aquí está el código:

/*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*/   }

Pero mi pregunta es sobre la línea #7:

Si escribo:

[].indexOf después - this es la matriz en sí. (Diablos, está unido a Array.prototype.indexOf - en primer lugar).

Quiero decir - this siempre será un valor verdadero. asi que por qué ¿Existe este cheque?

Además - Resharper me muestra esto (que es perfectamente lógico):

Entonces, ¿por qué existe este cheque? Me estoy perdiendo de algo ?

Answer 1

No necesariamente, es porque el indexOf() La función nativa usa el directo this El valor aprobado, no el convertido en un objeto (equivalente a lo que sucede en modo estricto), y tal cuña necesitaría verificar que esto sea cumplido. Por ejemplo, este código arrojará un TypeError:

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

Arrojará un TypeError, como el this El valor no se convierte en un objeto ni se cambia al objeto global. En las funciones no estrictas definidas por el usuario, el valor de this es el objeto global si no hay objeto principal, pero en el modo ES5 estricto se pasa como undefined sí mismo. Otra situación es cuando lo llamas específicamente con null o undefined:

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

En la especificación ES5, la este valor se refiere al valor original aprobado como el thisArg, sin ningún cambio. En modo no rictamente, la este valor no es accesible para el código en funciones definidas por el usuario, pero las funciones nativas pueden especificar explícitamente el uso de la este valor en lugar de lo que el this La palabra clave se evalúa (que se conoce como el ThisBinding en la especificación). En modo estricto, ambos evalúan lo mismo.

Porque la versión nativa puede acceder a la versión sin caja del this Valor en el modo no riguroso (que se pasa directamente a la función interna [[ToObject]], que arroja un TypeError Al intentar convertir null o undefined), esta verificación debe implementarse para satisfacer los requisitos de la especificación.

Nota: Técnicamente, la muestra de código en su pregunta no es bastante por la especificación ES5, como el this El valor podría ser fals., Lo que lo fallaría a pesar de que debería proceder en teoría (implementaciones nativas de indexOf() No tire si false se pasa como el this valor). Además, dado que el objeto global se pasaría si el valor este valor en realidad estaba indefinido o nulo, pasaría el if (!this) Prueba, incluso cuando se supone que no debe. Esto no se puede resolver simplemente verificando que el argumento no es el objeto global, porque esto fallaría si el objeto global se aprobara explícitamente (lo que está permitido).