es6 - La reparación de las funciones de la matriz de JavaScript en Internet Explorer(indexOf, forEach, etc.)

map javascript

Question

Como se detalla en elsewhere , y de otro modo aparentemente bien conocido, Internet Explorer (definitivamente la versión 7, y en algunos casos, la versión 8) no implementa funciones clave, en particular en Array (como forEach , indexOf , etc.).

Hay una serie de soluciones aquí y allá, pero me gustaría doblar un conjunto apropiado de implementaciones canónicas en nuestro sitio en lugar de copiar y pegar o piratear en nuestras propias implementaciones. He encontrado js-methods , que parece prometedor, pero pensé en publicar aquí para ver si otra biblioteca es más recomendada. Un par de criterios misceláneos:

• La biblioteca debería ser simplemente una no operación para aquellas funciones que un navegador ya tiene implementadas (parece que a js-methods va bastante bien aquí).
• No GPL , por favor, aunque LGPL es aceptable.

Answer 1

Con "no implementar funciones clave", en realidad quiere decir que "se ajusta al ECMA 262 3''rd ed" ¿verdad? :)

Los métodos a los que se refiere son parte de la nueva 5ª edición. Para los navegadores que no lo soportan, puede usar la siguiente ''shim'' que se extiende de 3''rd a 5''th http://github.com/kriskowal/narwhal-lib/blob/narwhal-lib/lib/global-es5.js .

Answer 2

Con el Underscore.js

var arr=[''a'',''a1'',''b''] _.filter(arr, function(a){ return a.indexOf(''a'') > -1; })

Answer 3

Eche un vistazo a Underscore.js .

Answer 4

Esos scripts no funcionan bien en mis pruebas. Creo un archivo con las mismas funciones basadas en documentos MDN .

Demasiadas áreas problemáticas se resuelven en Internet Explorer 8. Consulte el código en egermano / ie-fix.js .

Answer 5

Muchos usan las implementaciones de indexOf MDC (por ejemplo, para indexOf ). Por lo general, cumplen rigurosamente con los estándares, incluso hasta el punto de verificar explícitamente los tipos de todos los argumentos.

Desafortunadamente, aunque está claro que los autores consideran que este código es trivial y utilizable libremente, no parece haber una concesión de licencia explícita para poner esto por escrito. El wiki en su conjunto es CC Attribution-ShareAlike, si es una licencia aceptable (aunque CC no está diseñado para código como tal).

js-methods se ve bien en general, pero no cumple con los estándares sobre cómo deberían ser las funciones (por ejemplo, elementos de lista indefinidos, funciones que modifican la lista). También está lleno de otros métodos aleatorios no estándar, incluidos algunos dudosos como los trozos de etiqueta dudosos y el códec UTF-8 incompleto (que también es un poco innecesario dado el truco de unescape(encodeURIComponent) ).

Por lo que vale, esto es lo que uso (que por este medio lanzo al dominio público, si se puede decir que es susceptible de derechos de autor). Es un poco más corto que las versiones de MDC, ya que no intenta escribir-oler que no has hecho algo tonto como pasar devoluciones de llamada no funcionales o índices no enteros, pero aparte de eso, intenta ser compatible con los estándares. (Avíseme si me he perdido algo. ;-))

''use strict'';

// Add ECMA262-5 method binding if not supported natively
//
if (!(''bind'' in Function.prototype)) {
    Function.prototype.bind= function(owner) {
        var that= this;
        if (arguments.length<=1) {
            return function() {
                return that.apply(owner, arguments);
            };
        } else {
            var args= Array.prototype.slice.call(arguments, 1);
            return function() {
                return that.apply(owner, arguments.length===0? args : args.concat(Array.prototype.slice.call(arguments)));
            };
        }
    };
}

// Add ECMA262-5 string trim if not supported natively
//
if (!(''trim'' in String.prototype)) {
    String.prototype.trim= function() {
        return this.replace(/^/s+/, '''').replace(//s+$/, '''');
    };
}

// Add ECMA262-5 Array methods if not supported natively
//
if (!(''indexOf'' in Array.prototype)) {
    Array.prototype.indexOf= function(find, i /*opt*/) {
        if (i===undefined) i= 0;
        if (i<0) i+= this.length;
        if (i<0) i= 0;
        for (var n= this.length; i<n; i++)
            if (i in this && this[i]===find)
                return i;
        return -1;
    };
}
if (!(''lastIndexOf'' in Array.prototype)) {
    Array.prototype.lastIndexOf= function(find, i /*opt*/) {
        if (i===undefined) i= this.length-1;
        if (i<0) i+= this.length;
        if (i>this.length-1) i= this.length-1;
        for (i++; i-->0;) /* i++ because from-argument is sadly inclusive */
            if (i in this && this[i]===find)
                return i;
        return -1;
    };
}
if (!(''forEach'' in Array.prototype)) {
    Array.prototype.forEach= function(action, that /*opt*/) {
        for (var i= 0, n= this.length; i<n; i++)
            if (i in this)
                action.call(that, this[i], i, this);
    };
}
if (!(''map'' in Array.prototype)) {
    Array.prototype.map= function(mapper, that /*opt*/) {
        var other= new Array(this.length);
        for (var i= 0, n= this.length; i<n; i++)
            if (i in this)
                other[i]= mapper.call(that, this[i], i, this);
        return other;
    };
}
if (!(''filter'' in Array.prototype)) {
    Array.prototype.filter= function(filter, that /*opt*/) {
        var other= [], v;
        for (var i=0, n= this.length; i<n; i++)
            if (i in this && filter.call(that, v= this[i], i, this))
                other.push(v);
        return other;
    };
}
if (!(''every'' in Array.prototype)) {
    Array.prototype.every= function(tester, that /*opt*/) {
        for (var i= 0, n= this.length; i<n; i++)
            if (i in this && !tester.call(that, this[i], i, this))
                return false;
        return true;
    };
}
if (!(''some'' in Array.prototype)) {
    Array.prototype.some= function(tester, that /*opt*/) {
        for (var i= 0, n= this.length; i<n; i++)
            if (i in this && tester.call(that, this[i], i, this))
                return true;
        return false;
    };
}

Otros métodos ECMA262-5 no implementados aquí incluyen Array reduce / reduceRight , los JSON y los pocos nuevos métodos Object que se pueden implementar de manera confiable como funciones JS.

Answer 6

Kris Kowal compiló una pequeña biblioteca que funciona como un complemento para las funciones de ECMAScript 5 que pueden faltar en la implementación del navegador. Algunas de las funciones han sido revisadas en numerosas ocasiones por otras personas para optimizar su velocidad y solucionar los errores del navegador. Las funciones están escritas para seguir la especificación lo más cerca posible.

es5-shim.js fue lanzado bajo la licencia de MIT, las extensiones de Array.prototype están cerca de la parte superior y usted puede cortar y eliminar cualquier función que no necesite con bastante facilidad. También sugiero que minimices la secuencia de comandos ya que los comentarios la hacen mucho más grande de lo necesario.