How to express .filter() function recursively in JavaScript?

if (arr.length = 1) {

This assigns 1 to arr.length, effectively trimming the array if there are more than 1 items in it. You probably meant arr.length ===.

Secondly, the Array#push method returns the new length of the array, not the array itself, so where you have:

return myList.push(arr[0]);

You probably want:

myList.push(arr[0]);
return myList;

If you don't want to modify the original array and make copy of the original array on each recursive call, here could be an ugly solution

function exclude(arr, fn, result, index) {
    if (!result) {
        result = [];
        index = -1;
    }
    index++;
    if (index < arr.length && fn(arr[inndex]))
        result.push(arr[index]);
    if (index === arr.length)
        return result;
    return exclude(arr, fn, result, index);
}

console.log(exclude([1,2,3,4], function(i){return i%2===0;})); // prints "2,4"

IMHO, your example doesn't really fit with recursion. It is much more readable and less prone to errors to use the for loop here. Recursion can easily mess things up in JS because of contexts and scopes. If you really want to do it as a test case, i recommend you not to transform the array, it will be slow and not of much use. Anyway at the end, you will end with same behaviour as a for loop, but less efficient. here is an example:

var list = [1,2,3,4,5];

function isOdd(v) {
    return v % 2 == 1;
}

function exclude(arr, fn, optionalIndex) {
    var myList = [];
    if(!optionalIndex){
        optionalIndex = 0;
    }
    if(optionalIndex < arr.length){
        if(fn(arr[optionalIndex])){
            myList.push(arr[optionalIndex]);
        }
        myList = myList.concat(exclude(arr, fn, optionalIndex + 1));
    }
    return myList;
}

console.log(exclude(list, isOdd));

It actually would be more interesting for you to try to do it with a real recursion case, for example, using your version with for loop to filter this array with sub-arrays in it:

var list = [1, 2, 3, [0, 1, 2, [0, 10, 20, 30], 4], 5, [1 ,2 ,3]];

Just for fun of it, one line solution:

function exclude(a, fn, c) {
  return (c = c || (c !== 0 ? a.length - 1 : c)) >= a.splice(c, fn(a[c]) ? 0:1)*0 ? exclude(a, fn, c - 1) : a;
}

Snippet:

var list = [0,1,2,3,4,5];

function isOdd(v) {
    return v % 2 != 0;
}

function exclude(a, fn, c) {
  return (c = c || (c !== 0 ? a.length - 1 : c)) >= a.splice(c, fn(a[c]) ? 0:1)*0 ? exclude(a, fn, c - 1) : a;
}

console.log(exclude(list, isOdd));

Since JavaScript doesn't have tail call elimination a recursive solution over a large array will blow your stack. However a functional and recursive approach to the problem would look something like this:

function filter(arr, fn) {
    var stopAt = arr.length;
    function helper (index, acc) {
        return index === stopAt ? 
               acc : 
               helper(index+1, fn(arr[index]) ?
                               acc.concat([arr[index]]) :
                               acc) ;
    }
    return helper(0, []);
}

Of course this should never be production code. Having a functional interface while allowing for mutating internal structures is probably the best approach. If you were to look at the source for the functional library Rambda you see that they do mutate internal state.