argumental reference inconsistency in javascript

Question

I have recently encountered a nasty issue in JS.

Let say we pass a map, an array of objects to a function f.

var o=[{a:0}];
function f(a){
    for(var i in a){
        if (a.hasOwnProperty(i)){
            a[i]=null;
        }
    }
    return a;
};
var outp=f(o);

alert(outp[0]+" === "+o[0]+" : "+(outp[0]===o[0]));

// here we expect loose equality, and equality in type, 
//furthermore it should identically equal as well, and we got right!

But, we can not pass total responsibility of an object to a function as argument, same like in functional paradigm o=(function(o){return o})(), because any kind of modification to o is not referenced!

var o=[];
function ff(a){
    return (a=undefined);
};
var outp=ff(o);
alert(outp+" === "+o.constructor+" : "+(outp===o));
// here we expect true, but we got false!

Why is the above described reference loss and presumably different referencce handling in the second use case, though in both case, functions got the array argument in the 0. position?

Answer 1

Javascript always passes arguments by value, so this won't work:

 function foo(x) {
    x = 100;
 }

 y = 5
 foo(y)
 y == 100 // nope

However this does work:

 function foo(x) {
    x.bar = 100;
 }

 y = {}
 foo(y)
 y.bar == 100 // yes

In the second snippet x is still passed by value, but this very value is a reference (pointer) to an object. So it's possible in a function to dereference it and access what's "inside" the object.