关于js中的命名

一、 重复声明和遗漏声明

使用 var 语句重复声明变量是合法且无害的。如果重复声明带有初始化器，那就和赋值语句没什么两样。读取一个没有声明的变量的值时，JavaScript 会报错。

二、关于局部变量

声明局部变量时必须使用 var 语句，如果缺少 var 语句，则会给全局对象创建一个同名属性。ES5 严格模式中，给一个没有声明的变量赋值会报错。

三、函数作用域和申明提前

在一些类C编程语言中，花括号内的代码有各自的作用域，而且在变量在声明它们的代码段外是不可见的，这称为块级作用域（block scope）。JavaScript 中没有块级作用域，而是使用函数作用域（function scope），即变量在申明它的函数及这个函数嵌套的任意函数内都是可访问的。

    for(var k=0; k<10; k++){
    console.log(k);
    }
    console.log(k);// 10，for 语句创建的变量for循环结束后，依然会存在于循环外部的环境中

JavaScript 函数里声明的所有变量（不涉及赋值）都被提前至函数顶部，即声明提前（hoisting）。（声明提前在 JavaScript 引擎“预编译”时进行，细节参考 JavaScript Engine）

    var scope = "global";
     
    function f() {
    console.log(scope); //输出global？不，undefined。 why?
    var scope = "local"; //在这里声明变赋值，但变量在函数体内任何地方是有定义的
    console.log(scope); // => local
    }
    //上面的函数执行时顺序如下：
    function f() {
    var scope; //变量声明提前至函数体顶部
    console.log(scope); //变量没有初始化，所以undefined
    scope = "local"; //变量初始化（赋值）保留在原来的位置
    console.log(scope);
    }

 在有块级作用域的编程语言中，让变量声明和使用变量的代码尽量靠近，可以提高程序性能。JavaScript 没有块级作用域，因此可以把所有变量都放在函数体顶部，直观反映变量作用域。

四、作为对象属性的变量

声明 JavaScript 全局变量时，实际上就是定义全局对象的一个属性（对于浏览器而言，全局对象就是window），ES 中规定全局变量是全局对象的属性。

• 使用 var 声明全局变量时，创建一个不可配置的属性，无法用 delete 运算符删除
• 非严格模式下给未声明变量赋值创建的全局变量，是全局对象的可配置属性，可以删除
• 可以使用 this 关键字引用全局对象

•     var var1 = 1; // 不可配置全局属性
      var2 = 2; // 可配置全局属性
       
      console.log(this.var1); // 1
      console.log(window.var1); // 1
       
      delete var1; // false 无法删除
      console.log(var1); //1
       
      delete var2;
      console.log(delete var2); // true
      console.log(var2); // 已经删除 报错变量未定义
  

  部变量可以当做跟调用函数相关的某个对象的属性，ES3 称该对象为调用对象（call object），ES5 称为 声明上下文对象（declarative environment record），JavaScript 目前没有方法可以引用局部变量中存放的对象。

五、变量值的数据类型

ES 变量值分为两种类型：

• 基本类型，指的是简单的数据段。5种基本数据类型：Undefined、Null、Boolean、Number、String，这5中基本类型都是按值访问的，因为可以操作保存在变量中的实际值。
• 引用类型，指可能有多个值构成的对象。引用类型的值时保存在内存中的对象，JavaScript 不能直接操作对象的内存空间，操作对象时，实际上是操作对象的引用而不是实际的对象。引用类型的值是按引用访问的。

5.1、引用类型值的动态属性

定义基本类型和引用类型的方式类似：创建一个变量并赋值。区别在于引用类型的值，可以添加属性和方法，也可以改变和删除属性。基本类型的值不能添加属性。

    var person = new Object(); // 引用类型
    person.name = "Minhui"; // 添加属性
    console.log(person.name); // => "Minhui"
     
    var name = "Minhui";
    name.age = 28; // 为基本类型添加属性不会导致错误，但没用
    console.log(name.age);// => undefined

 5.2、变量值复制

从一个变量向另一个变量复制基本类型的值，会在变量对象上创建一个新值，然后把该值复制到位新变量分配的位置上。复制完成后，改变其中一个变量不会影响到另一个。

从一个变量向另一个变量复制引用类型的值时，同样会将存储在变量的值复制一份放到为新变量分配的空间中。区别是，这个值的副本实际上是一个指针，指针指堆内存中的一个对象。复制完成后，两个变量引用同一个对象。改变其中一个变量，就会影响到另一个变量。

    var obj1 = new Object();
    var obj2 = obj1;
    obj1.name = "Minhui";
    console.log(obj2.name); // => "Minhui"
     
    obj2.name = "Luo"; //修改obj2的属性值会影响obj1
    obj2.firstName = "LUO"; // 添加属性
     
    console.log(obj1.name); //=> Luo
    console.log(obj1.firstName); //=> LUO

 向参数传递引用类型的值时，会把这个值在内存中的地址复制给一个局部变量，这个局部变量的的变化会反映在函数外部。

unction setName(obj) {
obj.name = "Minhui"; //函数内部，obj和penson引用同一个对象
}
var person = new Object();
setName(person);
console.log(person.name); // => "Minhui"，函数内部的变化函数外部也会有反映，因为堆内存中只有一个对象

 上面的例子很容易让开发者误以为参数是按引用传递的，下面经过修改的例子证明对象是按值传递的：

    function setName(obj) {
    obj.name = "Minhui";
    obj = new Object(); //函数内部重写obj时，这个变量的引用就是一个局部对象，函数执行完毕后就被销毁
    obj.name = "Django";
    }
    var person = new Object();
    setName(person);
    console.log(person.name); // => "Minhui"，如果按引用传递，name属性应该被改为 Django

 

5.3变量类型检测

• 基本数据类型检测：使用 typeof，注意对象和 null 都返回 object。
• 引用类型：instanceof，语法为 variable instanceof constructor；使用instanceof 检测基本类型值时始终返回 false。

    var person = new Object(),
    colors = ["red", "blue"],
    pattern = "";
     
    console.log(person instanceof Object); // true
    console.log(colors instanceof Array); // true
    console.log(pattern instanceof RegExp); //false

 注意：typeof 检测函数返回 function；Safari 5 之前版本和 Chrome 7 之前版本使用 typeof 检测正则表达式返回 function（规范原因）；IE 和 Firefox 对正则表达式应用 typeof 返回 object。

六、一个面试题

    var v = 1;
    function f1() {
    console.log(v);
    }
     
    function f2() {
    v = 2;
    console.log(v);
    }
     
    function f3(v) {
    var a = function() {
    console.log(v);
    }
    return a;
    }
     
    function f4() {
    //alert(v);
    v = 4;
    var v = 5;
    console.log(v);
    }
     
    var f = f3(v);
     
    f1(); // 1 没问题
    f(); // 1 没问题
    f2(); // 2 很容易理解，全局变量v被修改为2
    f1(); // 2 没问题
    f(); // 2? -> 错，1
    f4(); // 5 没问题：函数体内，局部变量优先级大于同名全局变量
    f1(); // 4? -> 错：声明提前，2
    f(); //4? -> 错，1

 

注释中有问号的三个地方是最容易出错的。

先来看倒数第二个，如果没有理解声明提前，就会认为 f4() 执行的时候将全局变量v的值覆盖了。实际不是，将上面 f4 函数体内的 alert 前面的注释删了试试，弹出来的是 2 吗？ 不是！f4 执行时其实被“预编译”成下面的样子：

    function f4() {
    var v; // 声明提前至最前面，甚至在alert之前
    alert(v); // undefined
    v = 4; // 局部变量，全局变量中的 v 没有被修改
    v = 5;
    console.log(v);
    }

 关于 f 的值始终是 1，我刚开始看的时候也有点迷惑。事实上，f3(v) 中的 v 和全局变量 v 并不是同一个东西，给变量 f 赋值时，其实相当于 var f = f3(1) ，传入的是全局变量 v 的值，而不是 v 本身（按值传递？）。赋完值的函数 f 其实等同于：

    f = function() {
    console.log(1); // v 再怎么变跟我有一毛钱关系
    }

 

参考：http://csspod.com/archives/javascript-variable

 

附录：对于单个字母的命名变量：

经常见单个字母的命名，如HAO123和豆瓣网时，常怀疑这样有什么好处，其实这是他们发布的压缩的版本：

jS优化工具，分两类，一种是压缩(去无用字符等等)，一种是打包（变量替换）。

T = function(j, h, k) {

         var  m =  "-" ,

         i;

         if  (!S(j) && !S(h) && !S(k)) {

             i = j[z](h);

             if  (i > -1) {

                 k = j[z](k, i);

                 if  (k < 0) k = j[D];

                 m = j[H](i + h[z](N) + 1, k)

             }

         }

         return  m

     },

对于写来说，标识符当然是短的好，方便输入，方便记忆
对于读则是，标识符长的好，长的标识符包含的信息量相对的也多，结合上下文，可以很方便的理解语句块的意思作用
但如果太短的话，写的时候就因为信息量太少，导致记混了，反而变成不方便
太长也是，可能看一眼就明白，也可看过就忘了，另外屏幕空间有限，如果都是长长的……
＝＝＝＝
对于编译型语言，标识符长短不影响运行效率、执行文件大小，编译的时候编译器会将标识符替换为内存地址
对于解释型语言，理论上对运行效率应该是有影响的，但……