onceCopy function (testFunc) { const copyFunc = (a) => { const copyFunc2 = (b) => { return testFunc(a); }; return copyFunc2; }; return copyFunc; };Entonces, la función devuelve la función interna en la primera invocación.
Luego devuelve la función interna de la función interna de la segunda invocación.
Luego, la segunda función interna (tercera invocación) en realidad devuelve el argumento pasado en la función principal y solo lo invoca con el carácter que le dimos en la segunda invocación.
Idealmente, quiero lograr lo que estoy logrando en muchas invocaciones después de solo la primera, si eso tiene sentido.
Editar: Sí, lo siento, _.once.
Editar: así que la primera invocación una vezCopia DEBE contener una copia del Func pasado La segunda invocación DEBE desencadenar la copia y da una salida La tercera invocación DEBE dar el resultado de la segunda invocación al igual que la cuarta, quinta, sexta y así sucesivamente...
Mi función hace esto, pero en la segunda invocación almacena una función (copyFunc2) nuevamente, pero lo hice porque necesito un lugar para almacenar "a".
así como tenemos
function multiplyBy3 (a) {return a*3} y luego, una vez que la copia almacena una copia de multiplicar por 3
const actualFunction = onceCopy(multiplyBy3)
luego en la segunda y tercera invocación lo que quiero
FunciónActual(1) = 3 FunciónActual(66) = 3
entonces la función pasada SOLO FUNCIONA UNA VEZ
No puedo explicar más que esto, está en los documentos de lodash.
Después de llamar a la función por primera vez y obtener el resultado, cree una nueva función que devuelva el resultado y utilícela siempre que se llame a la función envuelta:
const once = fn => { let func return (...args) => { if(func) return func() const result = fn(...args) func = () => result return result } } const multiply = (a, b) => a * b const demoFunction = once(multiply) console.log(demoFunction(1, 2)); // 2 console.log(demoFunction(3, 4)); // 2 console.log(demoFunction(5, 6)); // 2No estoy familiarizado con la función que está tratando de volver a implementar, así que siéntase libre de corregirme si entendí mal. Para envolver una función y asegurarse de que solo se llame una vez, no necesita múltiples envoltorios anidados, solo uno con algún estado.
Debe realizar un seguimiento de si ya tiene un resultado para devolver ( hasResult ) y, de ser así, cuál es ese resultado ( result ). Mantener estas dos variables separadas le permite cubrir el caso cuando el result no está undefined mientras mantiene el código fácil de leer y comprender.
function once(wrappedFunction) { let hasResult = false; let result; return (...args) => { if (hasResult) { return result; } result = wrappedFunction.apply(this, args); hasResult = true; return result; } } // An example function to wrap function multiply(a, b) { return a * b; } const demoFunction = once(multiply) console.log(demoFunction(1, 2)); // 2 console.log(demoFunction(3, 4)); // 2 console.log(demoFunction(5, 6)); // 2Esto es lo que estabas buscando?
El retorno de la función inicial se mantiene en llamadas posteriores. Utilicé una segunda variable called en caso de que la primera llamada devuelva indefinido, que también debería devolverse en llamadas posteriores.
const once = (onceFn) => { let called; let value; return (...args) => { if (called) return value; called = true; return (value = onceFn(...args)); }; }; function multiplyBy3(a) { return a * 3; } const fn = once(multiplyBy3); console.log(fn(3)); // 9 console.log(fn(66)); // 9