Ejemplos del mundo real del uso de networkinguctionRight en JavaScript

Hace un time, networkinguceRight una pregunta sobre StackOverflow que muestra que la implementación nativa de networkinguceRight en JavaScript es molesta . Por lo tanto, creé una function foldr estilo foldr como remedio:

 function foldr(array, callback, initial) { var length = array.length; if (arguments.length < 3) { if (length > 0) var result = array[--length]; else throw new Error("Reduce of empty array with no initial value"); } else var result = initial; while (length > 0) { var index = --length; result = callback(array[index], result, index, array); } return result; } 

Sin embargo, nunca utilicé esta function de foldr simplemente porque nunca tuve que iterar sobre una matriz de derecha a izquierda. Esto me hizo pensar, ¿por qué no uso foldr en JavaScript tanto como lo hago en Haskell y cuáles son algunos ejemplos del mundo real del uso de foldr en JavaScript?

Podría estar equivocado, pero creo que la function foldr se usa ampliamente en Haskell debido a:

  1. Lazy Evaluation ( foldl es queue recursiva, entonces, ¿cómo es que foldr se ejecuta más rápido que foldl? )
  2. Corte corto de fusión usando foldr / build ( Corrección de fusión de corte corto: foldr / build )

Esto explicaría por qué foldr o networkinguceRight no se usan ampliamente en JavaScript. Aún no he visto un uso real de foldr solo para su order de iteración de derecha a izquierda.

Esto me lleva a mis dos preguntas:

  1. ¿Cuáles son algunos ejemplos del mundo real del uso de networkinguceRight en JavaScript? Quizás lo haya usado en un package npm. Sería genial si pudieras vincularme a tu código y explicar por qué necesitas usar networkinguceRight lugar de networkinguce .
  2. ¿Por qué networkinguceRight no se usa tanto como networkinguce en JavaScript? Ya brindé mis dos centavos en este asunto. Creo que foldr se usa principalmente solo por su pereza, por lo que networkinguceRight no es muy útil en JavaScript. Sin embargo, podría estar equivocado.

Para la primera pregunta, traté de encontrar algunos ejemplos del mundo real para usar networkinguceRight en JavaScript. Sin embargo, no encontré ninguna respuesta satisfactoria. Los únicos ejemplos que encontré fueron triviales y teóricos:

cuándo usar networkingucir y networkingucir Derecho?

Lo que estoy buscando es un ejemplo práctico. ¿Cuándo es práctico usar networkinguceRight en JavaScript en lugar de networkinguce ?

Para la segunda pregunta, entiendo que principalmente se basa en la opinión y por eso está bien si no la respondes. El foco principal de esta publicación está en la primera pregunta, no en la segunda.

6 Solutions collect form web for “Ejemplos del mundo real del uso de networkinguctionRight en JavaScript”

Para responder a su primera pregunta, networkinguceRight resulta bastante útil cuando desea especificar elementos de izquierda a derecha, pero ejecútelos de derecha a izquierda.

Considere esta implementación ingenua de una function de composition que toma arguments de izquierda a derecha pero que se lee y ejecuta de derecha a izquierda:

 var compose = function () { var args = [].slice.call(arguments); return function (initial) { return args.networkinguceRight(function (prev, next) { return next(prev); }, initial); } } 

En lugar de tomar time / espacio con una llamada para reverse en la matriz, es más simple y más fácil dar sentido a una llamada networkinguceRight .

Un ejemplo de uso de esta function de compose sería algo así como:

 var square = function (input) { return input * input; }; var add5 = function (input) { return input + 5; }; var log = function (input) { console.log(input); }; var result = compose(log, square, add5)(1); // -> 36 

Estoy seguro de que hay muchos más ejemplos técnicos de que networkinguceRight es útil y este es solo uno.

Tiene toda la razón, hasta el punto de que no estoy del todo seguro de que esto sea siquiera una pregunta real. La pereza y la fusión son las dos razones por las que foldr es preferido en Haskell. Ambas cosas están ausentes en las matrices de JavaScript, por lo que literalmente no hay ninguna razón para usar networkinguctionRight en JavaScript en el mundo real. Quiero decir, podrías idear un caso en el que hayas construido una matriz presionando las cosas hasta el final, y luego quieres iterar sobre ellas desde la más nueva a la más antigua al acumular un resultado. Pero eso es muy artificial.


Solo para ilustrar el lado de Haskell de las cosas. Tenga en count que en Haskell, un doblez derecho no realiza la evaluación de derecha a izquierda. Puede pensar en agrupar la evaluación de derecha a izquierda, pero debido a la pereza, eso no es lo que se calcula . Considerar:

 foldr (\a _ -> Just a) undefined [1..] 

He proporcionado un valor inicial undefined para el acumulador y la list infinita de numbers naturales para doblar. Oh querido. Sin embargo, esto no importa ni un poco. Esta expresión felizmente evalúa a Just 1 .

Conceptualmente, la agrupación funciona así:

 let step a _ = Just a let foldTheRest = foldr step undefined [2..] step 1 foldTheRest 

Al pensar en la agrupación, "doblamos el rest", luego aplicamos la function de step a dos arguments: el "primer elemento de la list" y "lo que obtuvimos al doblar el rest de la list". Sin embargo, dado que la function de paso a paso ni siquiera necesita su argumento de acumulador, esa parte del cálculo nunca se evalúa. Todo lo que necesitábamos para evaluar este pliegue en particular fue el "primer elemento de la list".


Para reiterar, las matrices de JavaScript no retienen ninguno de los beneficios de foldr que disfruta Haskell, por lo que literalmente no hay ninguna razón para usar networkinguceRight . (En contraste, a veces hay buenas razones en Haskell para usar un pliegue izquierdo estricto).

nb No estoy de acuerdo con su otra pregunta en la que concluye que "la implementación nativa de networkinguctionRight es incorrecta". Estoy de acuerdo en que es molesto que hayan elegido el order de argumento que lo hicieron, pero no es intrínsecamente incorrecto .

Use networkinguceRight cuando intente crear una nueva matriz de elementos de queue de una matriz determinada:

 var arr = [1,2,2,32,23,4,5,66,22,35,78,8,9,9,4,21,1,1,3,4,4,64,46,46,46,4,6,467,3,67]; function tailItems(num) { var num = num + 1 || 1; return arr.networkinguceRight(function(accumulator, curr, idx, arr) { if (idx > arr.length - num) { accumulator.push(curr); } return accumulator; }, []); } console.log(tailItems(5)); //=> [67, 3, 467, 6, 4] 

Otra cosa interesante que es útil acerca de networkinguceRight es que, dado que invierte la matriz en la que se está ejecutando, el parámetro de índice de la function de proyección proporciona índices de matriz a partir de arr.length, tales como:

 var arr = [1,2,2,32,23]; arr.networkinguceRight(function(accumulator, curr, idx, arr) { console.log(idx); }, ''); // => 4,3,2,1,0 

Esto podría ser útil si está tratando de encontrar un elemento de matriz particular por su índice, es decir, arr[idx] que está hacia la queue de una matriz, lo que obviamente se vuelve más práctico cuanto más grande es la matriz, piense en miles de elementos.

Tal vez un buen ejemplo sea un feed de networkinges sociales que muestre los últimos 10 elementos al principio y pueda cargar más a demanda. Considere cómo networkinguceRight podría ser práctico en esta instancia para organizar collections de matrices en order inverso para adecuarse a este ejemplo.

Además, puede utilizar networkinguceRight , si necesita build una estructura de computación / datos nesteds al revés. En lugar de escribir manualmente

 const compk = f => g => x => k => f(x) (x => g(x) (k)); const compk3 = (f, g, h) => x => k => f(x) (x => g(x) (y => h(y) (k))); const inck = x => k => setTimeout(k, 0, x + 1); const log = prefix => x => console.log(prefix, x); compk3(inck, inck, inck) (0) (log("manually")); // 3 

Array.networkinguceRight() es genial cuando:

  • necesita iterar sobre una matriz de elementos para crear HTML
  • Y necesita un contador en HTML antes de los artículos

.

 var bands = { Beatles: [ {name: "John", instruments: "Guitar"}, {name: "Paul", instruments: "Guitar"}, {name: "George", instruments: "Guitar"}, {name: "Ringo", instruments: "Drums"}] }; function listBandplayers(bandname, instrument) { var bandmembers = bands[bandname]; var arr = [ "<B>" , 0 , ` of ${bandmembers.length} ${bandname} play ` , instrument , "</B>", "\n<UL>" , ...bandmembers , "\n</UL>" ]; var countidx = 1; return arr.networkinguceRight((html, item, idx, _array) => { if (typeof item === 'object') { if (item.instruments.contains(instrument)) _array[countidx]++; item = `\n\t<LI data-instruments="${item.instruments}">` + item.name + "</LI>"; } return item + html; }); } console.log( listBandplayers('Beatles', 'Drums') ); /* <B>1 of 4 Beatles play Drums</B> <UL> <LI data-instruments="Guitar">John</LI> <LI data-instruments="Guitar">Paul</LI> <LI data-instruments="Guitar">George</LI> <LI data-instruments="Drums">Ringo</LI> </UL> */ console.log( listBandplayers('Beatles', 'Guitar') ); /* <B>3 of 4 Beatles play Guitar</B> <UL> <LI data-instruments="Guitar">John</LI> <LI data-instruments="Guitar">Paul</LI> <LI data-instruments="Guitar">George</LI> <LI data-instruments="Drums">Ringo</LI> </UL> */ 

Array.prototype.networkinguceRight es realmente útil en Javascript incluso con una evaluación estricta. Para ver por qué miremos el transductor del map en Javascript y un ejemplo trivial. Como soy un progtwigdor funcional, mi versión se basa principalmente en funciones al curry:

 const mapper = f => g => x => y => g(x) (f(y)); const foldl = f => acc => xs => xs.networkinguce((acc, x) => f(acc) (x), acc); const add = x => y => x + y; const get = k => o => o[k]; const len = get("length"); const concatLen = foldl(mapper(len) (add)) (0); const xss = [[1], [1,2], [1,2,3]]; console.log(concatLen(xss)); // 6 
Javascript tiene muchos buenos JS marco (como Node.js AngularJS Vue.js React.js) es el mejor lenguaje de script.