Underscore.js: la forma de las funciones habituales de la cadena

Question

Usando Underscore.js, puedo escribir lo siguiente que devuelve 42:

_([42, 43]).chain() 
    .first() 
    .value() 

He función personalizada, que no forma parte de la llamada Underscore.js double():

function double(value) { return value * 2; }; 

me gustaría ser capaz de llamar a esta función en una cadena de subrayado, como si fuera parte de un guión bajo. Me gustaría escribir lo siguiente, que me gustaría volver 84:

_([42, 43]).chain() 
    .first() 
    .double() 
    .value() 

Esto no puede trabajar desde subrayado no define double(). Podría usar tap() como en:

_([42, 43]).chain() 
    .first() 
    .tap(double) 
    .value() 

Esto es válido, pero tap se aplica la función a su argumento y devuelve el argumento, no el resultado de la función. Por lo tanto, me parece que necesitaría una especie de tap que devuelve el resultado de la función aplicada a su argumento. ¿Hay algo como esto en Underscore.js? ¿Me estoy perdiendo algo terriblemente obvio?

Answer 1

Al no encontrar un tap que devuelve los rendimientos de valor por la función se ejecuta, que definen una que puedo take y añadir a _:

_.mixin({take: function(obj, interceptor) { 
    return interceptor(obj); 
}}); 

A continuación, suponiendo que tienen:

function double(value) { return value * 2; }; 

me puede escribir:

_([42, 43]).chain() 
    .first()    // 42 
    .take(double)  // Applies double to 42 
    .value()    // 84 

Puede mirar take como map en objetos, en lugar de listas. ¿Quieres experimentar con esto? Ver este example on jsFiddle.

Answer 2

lo que tiene una función personalizada:

function double(value) { return value * 2; } 

Usted puede utilizar mixin extender subrayado con él:

_.mixin({ double:double }); 

Ahora puede llamar a la función del objeto subrayado _:

_.double(42); // 84 

y desde el objeto envuelto de regresar de chain:

_([42, 43]).chain() 
    .first() 
    .double() // double made it onto the wrapped object too 
    .value(); // 84 

Answer 3

¿Funciona map para esto?

_([42, 43]).chain() 
    .first() 
    .map(double) 
    .value() 

edición

de la documentación, parece que map sólo funcionaría si se coloca antes de la llamada a first:

_([42, 43]).chain() 
    .map(double) 
    .first() 
    .value() 

Answer 4

Usando compose es otra manera de hacer frente a la situación, pero creo que agregar una función como takeas I suggested earlier es una mejor solución. Sin embargo, aquí es cómo el código se vería con compose:

function double(value) { return value * 2; }; 

_.compose(
    double, 
    _.first, 
    _.bind(_.identity, _, [42, 43]) 
)(); 

El valor inicial debe ser proporcionada a través de una función que devuelve ese valor (en este caso realizado por currying identity), y las funciones deben ser enumerados en otro que es el reverso de lo que tienes con una cadena, que a mí me parece antinatural.

Answer 5

Bien, recién estoy leyendo el código fuente anotado por primera vez. Pero creo que se puede hacer algo como esto:

function double(value) { return value * 2; }; 

var obj = _([42, 43]).addToWrapper({double:double}); 

obj.chain() 
    .first() 
    .double() 
    .value(); 

la sintaxis/detalles podrían no ser correcta, pero el punto central es la siguiente: cuando se llama a _([42,43]), que está llamando subrayado como una función. Cuando lo hace, crea una instancia de un nuevo objeto y luego mezcla en ese objeto la mayoría de las funciones de subrayado. Entonces, te devuelve ese objeto. A continuación, puede agregar sus propias funciones a ese objeto, y nada de esto contamina el espacio de nombres "_".

Así es como me pareció el código de underscore.js. Si me equivoco, me gustaría averiguarlo y espero que alguien me explique por qué.

EDITAR: En realidad, he usado underscore.js en gran medida durante aproximadamente un mes, y me he familiarizado bastante con él. Yo ahora sé se comporta como he dicho aquí. Cuando llamas _ como función de Constructor, recuperas tu propio "espacio de nombres" (solo un objeto), y puedes agregarle cosas con addToWrapper() que aparece en tu espacio de nombres pero no en el "_" global. espacio de nombres Así que la función que OP quería ya está incorporada. (Y he quedado realmente impresionado con el guión bajo, por cierto, está muy bien hecho).

Answer 6

Nadie realmente respondió esto como solicitado así que aquí está mi respuesta a la solicitud que he probado. Lea primero la nota a continuación.

function doubleValue(x) { return x * 2; } 
var rt = _.chain([42,43]) 
     .first(1) 
     .map(doubleValue) 
     .value(); 
console.log(rt); // prints out [84] 

// Tenga en cuenta que es importante contar .First() el número de elementos que desea lo contrario puede obtener una matriz vacía de otra manera. Piensa primero porque QUIERO la primera cantidad de artículos, entonces.primero (2) devuelve [84], [86] etc.

Answer 7

muchas maneras de lograr esto fácilmente, aquí es una solución de este tipo:

_.chain([42,43]) 
    .first(1) 
    .map(double) 
    .first() 
    .value(); 
    // 84 

Sin embargo, yo recomendaría usar Ramda continuación, con auto-curry y tubería/componer este tipo de tareas son triviales:

R.pipe(R.head, R.multiply(2))([42, 43]); // 84 

equivalent to: 

R.compose(R.multiply(2), R.head)([42, 43]); // 84 

Si quería extender la solución para sacar decir los 2 primeros artículos, en lugar de un único valor, según lo solicitado por el PO, entonces:

R.pipe(R.take(2), R.map(R.multiply(2)))([42, 43]) // [84, 86] 

Sin embargo, en Ramda se recomienda Rposepose. De cualquier manera, para tareas triviales como esta, tiende a ser más conveniente y fácil de usar.

Answer 8

Parece que lodash ha implementado exactamente lo que busca:

_.thru(value, interceptor) 

de los documentos:

Este método es como _.tap excepto que devuelve el resultado de interceptor

https://lodash.com/docs#thru