I'm trying to recreate the functionality of the underscore \_.invoke for learning purposes and I would like to really understand how it works as it seems to be something not too complicated.

The exercise is asking me to return an array with the result of calling "a" method to it. Ok, so here we start.

```js
_.invoke = function (collection, methodName) {
  let result = []; 
  // debugger;
  if (Array.isArray(collection)) { // check if collection is an array.
    for (let i = 0; i < collection.length; i++) { // iterate over collection
      result.push(Array.prototype.methodName.call(collection[i]));
    }
  }
  console.log('result:', result);
  return result;
};
```

I don't know exactly what *method* is being past to `methodName` nor if it has any extra arguments to be forwarded (this I understand it would be used in case I'd use a method that requires args like `.reduce` for instance if I'm not wrong).

As I understand, when I use the `.call` method on `methodName`, it should return (push) the iterated element with the "function" applied onto it. Obviously there is something not right, I have used the debugger to see what it does on each step and once it runs the loop and arrives to the *call*, it quits the loop and runs to check whatever it is it does in the config file of the test.

I get this message in the error log of the HTML file:

```js
_.invoke(mocks.arr, 'testCall').should.eql(mocks.arr);
_.invoke(mocks.obj, 'testCall').should.eql(mocks.objValuesArr);
```

```js
argsArr = [mocks.arr, mocks.obj];
_.invoke(mocks.arr, 'testArgs', mocks.arr, mocks.obj);
called.should.be.true;
called = false;
argsArr = [mocks.obj, mocks.arr];
_.invoke(mocks.obj, 'testArgs', mocks.obj, mocks.arr);
called.should.be.true;
```

The *this*, *thisArg* and such are still a little hard for me to understand, can someone explain to me what am I missing here..?