carte Javascript méthodes d'objet natif

Question

En Python, vous pouvez quelque chose comme ceci:

>>> list(map(str.upper, ['foo','bar'])) 
['FOO', 'BAR'] 

Je voudrais pouvoir faire quelque chose de similaire en javascript:

J'ai essayé ce qui suit dans Chrome en utilisant la mise en œuvre de la carte native (https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/map):

['foo','bar'].map(String.prototype.toUpperCase) 

['foo','bar'].map(String.prototype.toUpperCase.call) 

Pourquoi ne pas appeler le travail? Existe-t-il une manière élégante de faire ceci ou dois-je emballer toUpperCase dans une fonction de rappel? Thx

Answer 1

Les navigateurs modernes prennent en charge ce (although it is a recent addition)

var a = ['foo','bar']; 
var b = a.map(String.toUpperCase); 

alert(b[1]); 

ou même

var a = ['foo','bar'].map(String.toUpperCase); 
alert(a[0]); 

exemple: http://www.jsfiddle.net/xPsba/

Answer 2

Vous pouvez utiliser quelque chose comme ceci:

function map(arr, fn){ 
    var i = 0, len = arr.length, ret = []; 
    while(i < len){ 
     ret[i] = fn(arr[i++]); 
    } 
    return ret; 
} 

Et pour l'utiliser:

var result = map(['foo', 'bar'], function(item) { 
    return item.toUpperCase(); 
}); 

console.log (result); // => ['FOO', 'BAR'] 

Answer 3

C'est parce que String.prototype.toUpperCase fonctionne sur objet this (contexte) mais map fonction ne peut pas définir l'élément de tableau en tant que contexte. Il le passe comme un argument. Une solution serait

['foo','bar'].map(function(k) { return String.prototype.toUpperCase.call(k) }); 

Answer 4

Essayez:

['foo','bar'].map(Function.prototype.call.bind(String.prototype.toUpperCase)) 

ou pour le même effet:

['foo','bar'].map(Function.call.bind("".toUpperCase)) 

traitement de JavaScript de this est un mauvais voyage.

Answer 5

Vous manquez tous le point. :-)

Nous voulons appeler une méthode (pas une fonction) sur tous les éléments d'un tableau. Vous pouvez utiliser map:

a.map(function(x){x.frob()}) 

mais c'est trop taper. Nous voulons dire:

a.mapm(A.frob) 

où A est la classe des éléments de a et mapm est une nouvelle méthode Array qui appelle sa méthode d'argument sur chaque élément de this (tableau a dans ce cas).Vous pouvez définir mapm ainsi:

Array.prototype.mapm = function (method) 
{ 
    return this.map(function (x) { return method.apply(x) }) 
}; 

et l'appeler ainsi:

["a", "b", "c"].mapm("".toUpperCase) ==>  ["A", "B", "C"] 

Le seul problème est que vous avez ajouté un nouvel élément, mapm à chaque tableau, si elle est ignorée par la plupart des Array méthodes , par exemple length et map.