Beaucoup utilisent le MDC de secours implémentations (eg. pour indexOf). Ils sont généralement rigoureusement conforme aux normes, à la limite même explicitement de vérifier les types de tous les arguments.
Malheureusement, alors qu'il est clair que les auteurs considèrent ce code comme trivial et librement utilisable, il ne semble pas être explicite d'une licence de subvention pour mettre cela par écrit. Le wiki est un tout CC Attribution-partage dans les mêmes conditions, si c'est une licence acceptable (si CC n'est pas conçu pour le code en tant que tel).
js-méthodes semble OK en général, mais n'est pas conforme aux normes sur les bords de la façon dont les fonctions sont censés être (eg. pas défini les éléments de la liste, les fonctions qui muter la liste). C'est aussi plein d'autres aléatoire de méthodes non normalisées, y compris quelques jeux comme les louches stripTags et l'incomplétude de l'UTF-8 codec (qui est aussi un peu inutile étant donné l' unescape(encodeURIComponent) truc).
Pour ce que ça vaut, voici ce que j'utilise (qui, je décharge dans le domaine public, si l'on peut dire pour être protégeable). C'est un peu plus court que le MDC versions qu'il ne tente pas de type-sentir que vous n'avez pas fait quelque chose de stupide comme le pass de non-fonctionnement des rappels ou des non-index entiers, mais en dehors de cela, il tente d'être conformes aux normes en vigueur. (Laissez-moi savoir si j'ai raté 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 ECMA262-5 méthodes qui ne sont pas mis en œuvre ici comprennent Array reduce/reduceRight, le JSON et les quelques nouveaux Object méthodes qui peuvent être mis en œuvre de manière fiable que JS fonctions.
