在JavaScript有二个特性，
第一个特性是js可直接使用变量，甚至无需声明。如
function sum(x,y){
result = x + y; //result是全局变量。
console.log(result);
}
sum(1,2);
console.log(result); //3
如果使用var可以避免这个：
function sum(x,y){
var result = x + y;
console.log(result);
}
sum(1,2);
console.log(result); //报错，找不到这个变量
创建隐式全局变量的反模式是带有var声明的链式赋值
function foo() {
var a = b = 0;
}
foo();
// console.log(a); //a is not defined
console.log(b); //0,因为 var a = (b = 0 );此时b未经声明，表达式的返回值是0，在赋给var声明的局部变量a。
对链式赋值的所有变量都进行声明。
function foo() {
var a , b;
a = b =0; //这样均为局部变量。
}
foo();
变量释放时的副作用
- 使用var创建的全局变量（这类变量在函数外部创建）不能删除
- 不使用var创建的隐含全局变量（尽管它是在函数内部创建）可以删除
var global_var = 1;
global_novar = 2; //反模式
(function(){
global_fromfunc = 3; //反模式
}());
delete global_var; //false
delete global_novar; //true
delete global_fromfunc; //true
console.log(typeof global_var); //number
console.log(typeof global_novar); //undefined
console.log(typeof global_fromfunc); //undefined
在ES5 strict模式中，为没有声明的变量赋值会抛出错误（类似上述代码中的两种反模式）
访问全局对象
从内嵌函数的作用域访问
var global = (function(){
return this;
}());
单一var模式（Single var Patten）
只使用一个var在函数顶部进行变量声明是一种非常有用的模式。
function func() {
var a = 1,
b = 2,
sum = a + b,
myobject = {},
i,
j;
//函数体。。。
}
提升：凌散变量的问题
JavaScript允许在函数的任意地方声明多个变量，无论在哪里声明，效果都等同于在函数顶部进行声明。这就是所谓的提升。在JavaScript中，只要变量是在同一个范围（同一函数）里，就视为已经声明，哪怕是在变量声明就使用。
//反模式
myname = "global";//全局变量
function func() {
alert(myname);//未定义
var myname = "local";
alert(myname); //局部变量
}
func();
前面的代码片断运行结果和以下代码一样。
//反模式
myname = "global";//全局变量
function func() {
var myname; //等同于 -> var myname = undefined;
alert(myname);//未定义
myname = "local";
alert(myname); //局部
}
func();
for循环
这种模式的问题在于每次循环迭代时都要访问数据的长度。特别是当myarray不是数据，而是HTML容器对时。
//次优循环
for(var i = 0; i< myarray.length; i++) {
//对myarray[i]的操作
}
以下代码：在这种方式在，对长度的值值提取一次，但应用到整个循环中。
for(var i = 0, max = myarray.length; i< max; i++) {
//对myarray[i]的操作
}
for-in 循环
var man = {
hand: 2,
legs: 2,
heads: 1
};
if(typeof Object.prototype.clone === "undefined") {
Object.prototype.clone = function () {};
}
var i,
hasOwn = Object.prototype.hasOwnProperty;
// for-in循环
for(i in man) {
if(hasOwn.call(man, i )) { //过滤
console.log(i, ":", man[i]);
}
}
避免使用隐式类型转换
var zero = 0;
if (zero === false) {
// 因为zero是0，而不是false，所以代码未执行
}
// 反模式
if (zero == false) {
//改代码会被执行。
}
避免使用eval()
该函数会将任意字符串当做一个JavaScript代码来执行。当需要讨论的代码是预先就编写好了（不是在动态运行时决定），是没有理由需要使用eval()。如果是运行时动态生成的，则也有更好的方法代替eval()。
//反模式
var property = "name";
alert(eval("obj." + property));
// 推荐的方法
var property = "name";
alert(obj[property]);
使用parseInt()的数值约定
该函数的第二个函数是一个进制参数，通常可以忽略该参数，但最后不要这么做。
var month = "06",
year = "09";
month = parseInt(month,10);
year = parseInt(yaer,10);
在ECMAScript 3版本中，0开始字符串会被当做一个八进制。而在ECMAScript 6 版本发生了改变。
对象字面量语法
- 将对象包装在大括号中(左大括号 “{” 和右大括号 “}”)
- 对象中以逗号分隔属性和方法。
- 用冒号来分隔属性名称和属性的值
- 当给变量赋值时，请不要忘记右大括号 “}” 后的分号。
来自构造函数的对象
在下面的例子中展示了以两种等价的方法来创建两个相同的对象：
第一种方法-使用了字面量
var car = {goes："far"};
//另一种方法-使用内置构造函数
//反模式
var car = new Object();
car.goes = "far";
自定义构造函数
下面是对Person构造函数的定义：
var Person = function (name) {
this.name = name;
this.say = function () {
return "I am" + this.name;
};
};
当new操作符调用构造函数的时候，函数内部会发生以下情况：
- 创建一个空对象并且this变量引用了该对象，同时还继承了该函数的原型。
- 属性和方法被加入到this引用的对象中。
-
新创建的对象有this所引用，并且最后隐式地返回this（如果没有显示地返回其他对）
以上情况看起就像在后台发生了如下事情：var Person = function (name) { // 使用对象字面量模式创建一个新对象 // var this = {}; // 向this添加属性和方法 this.name = name; this.say = function () { return "I am" + this.name; } // return this; }在以上代码中，为了简单起见，将say()方法添加到this中。其造成的结果是在任何时候调用new Person()时都会在内存中创建一个新的函数。这种方法的效率显然非常低下。因为多个实例之间的say()方法实际上没有改变。更好的选择应该是将方法添加到Person类的原型中。
Person.prototype.say = function() { return "I am" + this.name; };以上语句并不是真相的全部。因为空对象实际上并不空，它已经从Person的原型中继承了许多成员。因此，它更像是下面的语句。
``//var this = Object.create(Person.prototype);
自调用构造函数
为了解决前面模式的缺点，并使得原型属性可以在实例对象中使用，可以在构造函数中检查this是否为构造函数的一个实例，如果为否，构造函数可以再次调用自身，并且在这次调用中正确地使用new操作符：
function Waffle() {
if (!(this instanceof Waffle)) {
return new Waffle();
}
this.tastes = "yummy";
}
Waffle.prototype.wantAnother = true;
//测试调用
var first = new Waffle(),
second = Waffle();
console.log(first.tastes); // 输出"yummy"
console.log(second.tastes); // 输出"yummy"
console.log(first.wantAnother); // 输出true
console.log(second.wantAnother); // 输出true
数组字面量
在下面的例子中，可以相同的元素，并以两种不同的方法创建两个数组，即使用Array()构造函数和使用字面量模式。
// 具有三个元素的数组
// 反模式
var a= new Array("itsy","bitsy","spider");
// 完全相同的数组
var a = ["itsy","bitsy","spider"];
console.log(typeof a ); //输出"object",这是由于数组本身也是对象类型。
console.log(a.constructor === Array); // true
数组构造函数的特殊性
避开new Array() 的另一个理由是避免构造函数中可能产生的陷阱。
当想Array()构造函数传递单个数字时，它并不会成为第一个数组元素的值。相反，它却设定了数组的长度。
//具有一个元素的数组
var a = [3];
console.log(a.length); //1
console.log(a[0]); // 3
//具有三个元素的数组
var a = new Array(3);
console.log(a.length); // 3
console.log(typeof a[0]); //输出undefined
上面例子中，可能并非预期的效果，但是与new Array()传递一个整数相比，如果向构造函数传递一个浮点数，则情况变得更加糟糕。
//使用数组字面量
var a = [3.14];
console.log(a[0]); // 3.14
var a = new Array(3.14); //输出RangeError：invalid array length
console.log(typeof a);
为了避免在运行时创建动态数组可能产生的潜在错误，坚持使用数组字面量表示法。
即时函数
即时函数模式是一种可以支持在定义函数后立即执行该函数的语法。
(function(){
alert('wathc out');
}());
下面的替代语法也是很常见的，但JSLint偏好使用第一种语法：
(function(){
alert('wathc out');
})();
这种模式非常有用，因为它为初始化代码提供了一个作用域沙箱（sandbox）。
(function(){
var days = ['Sun','Mon','Tus','Wed','Thu','Fri','Sat'];
today = new Date();
msg = 'Today is '+ days[today.getDay()] + ',' + today.getDate();
alert(msg);
}()); // 输出 "Today is Fri, 13"
如果上面这些代码没有包装到即时函数中，那么days，today和msg等变量将会成为全局变量，并遗留在初始化代码中。
即时函数的参数
也可以将参数传递到即时函数中，如下例子：
(function (who, when) {
console.log("I met " + who + " on " + when);
}("Joe Black", new Date()));
一般情况下，全局对象是以参数形式传递给即时函数的，以便在不使用Window：指定全局作用域限定的情况下可以在函数内部访问该函数，这样将使得代码在浏览器环境之外时具有更好的互操作性。
(function (who, when) {
// 通过 `global`访问全局变量
}(this);
即时函数的返回值：
正如任何其他函数一样，即时函数可以返回值，并且这些返回值也可以分配给变量：
var result = (function(){
return 2 + 2;
}());
另一种语法：
var result = (function(){
return 2 + 2;
})();
下面这个例子中，即时函数返回的值是一个函数，它将分配给变量getResult，并且将简单地返回res值，该值被预计算并存储在即时函数的闭包中：
var getResutl = (function() {
var res = 2 + 2;
return function() {
return res;
}
} ());
当定义对象属性时可以使用即时函数。如果需要定义一个在对象生成期内永远都不会改变的属性，但是在定义它之前需要执行一些工作以找出正确的值。
var o = {
message: (function() {
var who = "me",
what = "call";
return what + " " + who;
}()),
getMsg: function(0 {}
return this.message;
)
};
//用法
o.getMsg(); //输出call me
o.message; // 输出call me
初始化时分支
var utils = {
addListener : function (el, type, fn) {
if (typeof window.addEventListener === 'function') {
el.addEventListener(type, fn, false);
} else if (typeof document.attachEvent === 'function') { // IE
} else { // 更早版本的浏览器
el['on' + type] = fn;
}
},
removeListener: function (el, type, fn) {
}
};
此段代码的问题在于效率比较低下。每次在调用utils.addListener()或utils.removeListener()时，都将会重复地执行相同的检查。
当使用初始化分支的时候，可以在脚本初始化加载时一次性特侧出浏览器特征。此时，可以在整个页面生命期内重定义函数运行方式。下面是一个可以处理这个任务的例子。
//接口
var utils = {
addListener: null,
removeListener: null
};
//实现
if(typeof window.addEventListener === 'function') {
utils.addListener =function (el, type, fn) {
el.addEventListener(type, fn, false);
};
utils.removeListener = function (el, type, fn) {
el.removeEventListener(type, fn, false);
};
} else if(typeof document.attachEvent === 'function') { //IE
utils.addListener('on' + type, fn );
utils.removeListener('on' + type, fn );
} else {
utils.addListener = function (el, type, fn) {
el['on' + type] = fn;
};
utils.removeListener = function (el, type, fn) {
e['on' + type] = null;
};
}
函数属性
var myFunc = function() {
var cachekey = JSON.stringify(Array.prototype.slice.call(arguments)),result;
if (!myFunc.cache[cachekey]) {
result = {};
//开销很大的操作
myFunc.cache[cachekey] = result;
}
return myFunc.cache[cachekey];
};
// 缓存存储
myFunc.cache = {};
请注意在序列化过程中，对象的“标识”将会丢失。如果有两个不同的对象并且恰好都具有相同的属性，这两个对象将会共享同一个缓存条目。
配置对象
配置对象模式是一种提供更整洁的API的方法。
function addPerson(conf);
var conf = {
username: "batman",
first: "Bruce",
last: "Wayne"
};
addPerson(conf);
配置对象的优点在于：
- 不需要记住众多的参数以及其顺序。
- 可以安全忽略可选参数。
- 更加易于阅读和维护
- 更加易于添加和删除参数。
而配置对象的不利之处在于：
- 需要记住参数名称。
- 属性名称无法被压缩。
当函数创建DOM元素时，这种模式可能是非常有用的，例如，可以用在设置元素的CSS样式中，以为元素和样式可能具有大量可选特征和属性。
Curry化
函数应用
在一些纯粹的函数式编程语言中，函数并不描述被调用，而是描述为应用。
//定义函数
var sayHi = function(who) {
return "Hello" + (who ? ", " + who : "") + "!";
};
//调用函数
sayHi(); //输出Hello
sayHi('world'); // 输出hello world
//应用函数
sayHi.apply(null, ["hello"]); // 输出Hello world！
部分应用
Curry化
//curry化的add()函数
// 接受部分参数列表
function add(x, y) {
var oldx = x, oldy = y;
if(typeof oldy === "undefined") {
return function (newy) {
return oldx + newy;
};
}
//完全应用
return x + y;
}
//测试
console.log(typeof add(5)); // 输出 "function"
console.log(add(3,4)); // 7
//创建并存储一个新函数
var add2000 = add(2000);
console.log(add2000(10)); // 输出2010
更精简的版本
//curry化的add()函数
//接受部分参数列表
function add(x, y) {
if(typeof y === "undefined") { //部分
return function (y) {
return x + y;
};
}
// 完全应用
return x + y;
}
下面是一个通用curry化函数的示例
function schonfinkelize(fn) {
var slice = Array.prototype.slice,
stored_args = slice.call(arguments,1);
return function() {
var new_args = slice.call(arguments),
args = stored_args.concat(new_args);
return fn.apply(null,args);
}
}
//普通函数
function add(x, y) {
return x + y;
}
//将一个函数curry化以获得一个新的函数
var newadd = schonfinkelize(add,5);
console.log(newadd(4)); // 输出9
console.log(schonfinkelize(add,6)(7)); // 输出13
转换函数schonfinkelize()并不局限于单个参数或者单步Curry化。
下面是更多示例：
//普通函数
function add(a, b, c, d, e) {
return a + b + c + d + e;
}
// 可运行于任意数量的参数
schonfinkelize(add, 1, 2, 3)(5, 5); // 16
//两步curry化
var addOne = schonfinkelize(add, 1);
addOne(10,10,10,10);
var addSix = schonfinkelize(addOne, 2, 3);
addSix(5, 5); //输出16