JavaScript - referencing arguments from within a function

Recently i found myself attaching function arguments to a variable inside the function scope so that i was not referencing the argument every time it was used.

Is there any benefit to this practice?

For example:

function populateResultCount(count){
    var count = count;
    return $('.resultCounter').text(count);     
};

Could easily be re-wr开发者_开发知识库itten like so:

function populateResultCount(count){
    return $('.resultCounter').text(count);     
};

And would still function correctly.

There's no functional difference between the two. Go with the simpler version.

If you're not using the argument that's passed in, there is no difference. In your first example, you can potentially confuse future maintainers because of var count = count, i.e., you're declaring a variable that has the same name as the argument, and that isn't a best practise.

So, if you can, use your second form. Its intent is clearer and there is no room for confusion.

I can see no benefit to this unless you are manipulating the data somehow. Your variable without the additional assingment can still not be accessed outside of the function.

function Test (count) {
    this.increment = function() {
        count++;
    }

    this.getCount = function() {
        return count;
    }
}

var test = new Test(10);


<button onclick="test.increment(); alert(test.getCount());">Increment</button>

You can do something like that even with the argument. So I think they are same.

All the other answers are correct: There's no reason to "re-assign" a passed argument inside the function.

The only thing I can think of, where you'd mess with reassigning arguments, is if you have optional arguments/default values

function xyz(optionalArgument) {
    optionalArgument = optionalArgument || "no argument given";
    ...
}

But in that case, it'd be better to write it as

function xyz( /* optionalArgument */ ) {
    var optionalArgument = arguments[0] || "no argument given";
    ...
}

Note that the || trick will give you the right-hand side's value, if the left-hand side is a falsy value. I.e. if you're ok with the optional argument being something that's falsy (like explicitly passing null, 0, etc), you'd have to do something like var arg = typeof arguments[x] === 'undefined' ? defaultValue : arguments[x];