Think about it this way:

var name = name;

The only way name can be set to the value of name is if name is already defined. There's no need to do it twice if name already has the value you want.

Well, I suppose some explanation won't hurt. )

First, all the function's params are already declared as local for this function. (it's a bit more complex, but let's say this explanation covers most of it). So it's really no use defining them again: they won't become 'more local' after it. ))

Second, it's possible to write var name = name within the function(name) for the same reasons why it's possible to write var name = 123; var name = 345;. The second var will be just silently ignored.

And if you write var name = 123; var name = name;, you'll just waste some keystrokes - as, again, it's the same as you write name = name; somewhere in your code. )

And that, btw, explains messing up the arguments. See, name is actually an alias for its element.

Sure you can run into problems. Take a look at this.

function mytask(name,title){
            console.log(name);
            console.log(title)
            var name = "oops";
            var title = "rawr";
            console.log(name);
            console.log(title)
}

mytask("dan", "administrator");

Apart from being very confusing, calling console.log(name); gives us two different results (because we redefined it). It's allowed, but it's not a good idea to do.

Edit: Interestingly (I didn't know this), doing the above screws up the implicit arguments[] array as well. For example, doing:

for( var i = 0; i < arguments.length; ++i ) {
    console.log(arguments[i]);
}

somewhere inside our function (post-reassignment) still outputs oops and rawr. Obviously, this is a bad, bad idea.

Actually there's no reason to do it. Once you pass them to the function, they are initialized and you can use them without reassigning them to other variables.

You can use variables with the same name as the parameters, as the value will be the same anyway, unless the variable with the same name will have a different value than the parameter.

<script>

    //this function returns what you give as argument
    function func1(name1) {
        let name1 = "mess shahadat"; //can't declare name, cause already getting name as parameter. thus this gives error if you define a variable same name as parameter with let. cause you can't redeclare let variable in javascript
    }

    document.write(func1("mike"))


</script>

in javascript, function parameters works like local variables. inside function, if you declare variable with var keyword and use same name as parameter, then it will return undefined. and if you declare the variable with let keyword, you will get an error. cause let variables are not redeclarable.

so don't use the same variable name as parameter when you need the variable with the same name to have a different value than the parameter, cause unknownly it can become a bug in your project.

example:

<script>

    //constructor function
    let mobile = function (modelNo, ram, price) {
        this.model = modelNo;
        this.ram = ram;
        let price = price + 1000; //can't declare price, cause already getting price as parameter. and let variables are not redeclarable
        this.price2 = function () { return price };
        this.totalPrice = function () { return "total price is: " + this.price2 }
    }

    let samsung = new mobile("samsung dous", "2gb", 3000);

    document.write(samsung.price2());

</script>