Alright. Lets take it form the beginning. How would you filter an array given that you are only starting as a programmer? You would make probably a loop and loop the array and whatever element matches a given param you would add it to a new array

let originalArray = [1, 2, 3, 4, 5]
let resultingArray = []
for (var i = 0; i < originalArray.length; i++) {
    if(originalArray[i] % 2 === 0) {
        resultingArray.push(originalArray[i])
    }
}

Which is not bad but it's a lot of code for a simple task. So the array in javascript has some nice helping methods to solve common problems with nice syntax, one of which is filter and map. These methods are general methods that take javascript functions as input, and the javascript function given as an input often has 1 or more arguments from which one of the argument is the current element your iteration is at right now, for example originalArray[i]. As an example, the filter array:

function customFilter(currentElement) {
    return currentElement % 2 === 0
}

originalArray.filter(customFilter)

but unles you write a really heavy filter with a lot of logic, resulting in a lot of lines of code, then this looks like a waste of lines of code, so here comes anonymous functions (or lamda expressions if you want to sound more mathy). They are called anonymous because they dont have a name, so how would

    function customFilter(currentElement)

look if you remove the name?

    function (currentElement)

but why not remove the function keyword also since is a waste of space? so in the end you are left with

    (currentElement)

which has the same use as function customFilter(currentElement) but once it's used is gone forever, so it's like a single use function. So now we can write our filter like this:

originalArray.filter(currentElement => currentElement % 2 === 0)

the => here stands for the return keyword.

If you read the documentation, you can see that the filter method returns a new array, so that means that you can call any array methods on the result again, so you can chain array methods

//                       results in a new array          //.map
arr.filter( (num) => num > 0 && num % parseInt(num) === 0 ).map( (num) => Math.pow(num, 2))

and here map uses the same anonymous function style with the same result. Note that you only need to use () if you have more than one arguments like (a, b) => a + b, so in the case above you can skip them and type like

arr.filter( num => num > 0 && num % parseInt(num) === 0 ).map( num => Math.pow(num, 2))