onceCopy function (testFunc) {
  const copyFunc = (a) => {
    const copyFunc2 = (b) => {
      return testFunc(a);
    };    
    return copyFunc2;
  };
  return copyFunc;
};

So the function returns the inner function upon first invocation.

Then returns the inner function of the inner function of the second invocation.

Then the second inner function (third invocation) actually returns the passed argument in the parent function and only invokes it with the character we gave it on the second invocation.

Ideally I want to achieve what I'm achieving over many invocations after only the first one if that makes sense.

Edit: Yes sorry, _.once.

Edit: so first invocation onceCopy SHOULD hold a copy of the Func passed Second invocation SHOULD trigger the copy and gives an ouput Third invocation SHOULD give the result of the second invocation so should the fourth, fifth, sixth and so on...

My function does do this, but on the second invocation it stores a function (copyFunc2) again, but I just made that because I need somewhere to store "a".

so like we have

function multiplyBy3 (a) {return a*3} and then once copy stores a copy of multiplyBy3

const actualFunction = onceCopy(multiplyBy3)

then upon second and third invocation what I want

actualFunction(1) = 3 actualFunction(66) = 3

so the passed function ONLY RUNS ONCE

Cant explain more than this, its in the lodash docs.

CodePudding user response：

I'm not familiar with the function you're trying to reimplement, so feel free to correct me if I misunderstood. To wrap a function and ensure it's only called once you don't need multiple nested wrappings, only one with some state.

You need to keep track of whether you already have a result to return (hasResult) and if so, what that result is (result). Keeping these two variables separate allows you to cover the case when result is undefined while keeping the code easy to read and understand.

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)); // 2

CodePudding user response：

Is this what you were looking for?

The initial function return is kept on subsequent calls. I used a second variable called in case the first call returns undefined, which should also be returned on subsequent calls.

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

CodePudding user response：

After calling the function for the 1st time, and getting the result, create a new function that returns the result, and use it whenever the wrapped function is called:

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)); // 2