关于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

    },

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