Beaucoup utilisent les implémentations de secours MDC (par exemple pour indexOf ). Ils sont généralement rigoureusement conformes aux normes, même au point de vérifier explicitement les types de tous les arguments.
Malheureusement, s'il est clair que les auteurs considèrent ce code comme trivial et librement utilisable, il ne semble pas y avoir de licence explicite pour le mettre par écrit. Le wiki dans son ensemble est CC Attribution-ShareAlike, si c'est une licence acceptable (bien que CC ne soit pas conçu pour le code en tant que tel).
js-methods semble correct en général, mais n'est pas aussi conforme aux normes sur les bords de la façon dont les fonctions sont supposées être (par exemple, des éléments de liste non définis, des fonctions qui mutent la liste). Il est également plein d'autres méthodes aléatoires non standard, y compris des méthodes douteuses comme le stripTags douteux et le codec UTF-8 incomplet (ce qui est également un peu inutile étant donné l' unescape(encodeURIComponent)astuce).
Pour ce que ça vaut, voici ce que j'utilise (que je publie par la présente dans le domaine public, si on peut dire que c'est sous copyright). C'est un peu plus court que les versions MDC car il n'essaie pas de renifler le type que vous n'avez pas fait quelque chose de stupide comme passer des rappels sans fonction ou des index non entiers, mais à part cela, il tente d'être conforme aux normes. (Faites-moi savoir si j'ai manqué quelque chose. ;-))
'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;
};
}
D'autres méthodes ECMA262-5 non implémentées ici incluent Array reduce/ reduceRight, les Objectméthodes JSON et les quelques nouvelles méthodes qui peuvent être implémentées de manière fiable en tant que fonctions JS.
Jetez un œil à Underscore.js .
la source
Kris Kowal a compilé une petite bibliothèque qui agit comme un shim pour les fonctions ECMAScript 5 qui peuvent manquer dans l'implémentation du navigateur. Certaines des fonctions ont été révisées à plusieurs reprises par d'autres personnes pour être optimisées pour la vitesse et pour contourner les bogues du navigateur. Les fonctions sont écrites pour suivre la spécification aussi étroitement que possible.
es5-shim.js a été publié sous la licence MIT, les extensions Array.prototype sont en haut et vous pouvez couper et supprimer toutes les fonctions dont vous n'avez pas besoin assez facilement. Je vous suggère également de réduire le script car les commentaires le rendent beaucoup plus volumineux que nécessaire.
la source
Par «ne pas mettre en œuvre les fonctions clés», vous entendez en fait «est conforme à l'ECMA 262 3ème éd», n'est-ce pas? :)
Les méthodes auxquelles vous faites référence font partie de la nouvelle 5ème édition - pour les navigateurs ne prenant pas en charge cela, vous pouvez utiliser le 'shim' suivant qui s'étend de 3'rd à 5'th http://github.com/kriskowal/narwhal- lib / blob / narwhal-lib / lib / global-es5.js .
la source
Ces scripts ne fonctionnent pas bien dans mes tests. Je crée un fichier avec les mêmes fonctions à partir de documents MDN .
Trop de zones de problèmes sont résolues dans Internet Explorer 8. Voir le code dans egermano / ie-fix.js .
la source
Avec le Underscore.js
var arr=['a','a1','b'] _.filter(arr, function(a){ return a.indexOf('a') > -1; })la source