JavaScript： 零基础轻松学闭包
JavaScript： 零基础轻松学闭包（1）
http://www.jianshu.com/p/6f5833e261ac
JavaScript： 零基础轻松学闭包（2）
http://www.jianshu.com/p/17bf0e33abb7
浅谈js回调函数
http://www.jianshu.com/p/1baa3916842d
JavaScript： 零基础轻松学闭包（1）
1、在js中，函数和变量本质上是一个东西。函数也是一个数据类型。
var cheese = '奶酪';
var test = function(){
alert(cheese);
}
// test 和 cheese 就共享一个全局作用域。在js中，函数和变量本质上是一个东西。函数也是一个数据类型。
-------------------------
// 查看 test 和 cheese各是什么类型
alert(typeof test);
alert(typeof cheese);
-------------------------
// 函数需要打个括号()才能执行
test();
2、我们刚才定义了一个 test 函数，{ } 包裹起来的部分就形成了一个新的作用域，也就是所谓的闭包。
var cheese = '奶酪';
var test = function(){
alert(cheese);
}
function test2(){
var cheese = null;
test();
}
test2();
// 对test而言，他能访问到的作用域只有它本身的闭包和全局作用域;也就是说，正常情况下他访问不到其他闭包里的内容，在 test2 里面定义的变量跟它没有半毛钱关系，所以弹出来的 cheese 依旧是全局作用域里的 cheese。
我们给出闭包的第一个注解：
1、闭包就是在函数被创建的时候，存在的一个私有作用域，并且能够访问所有的父级作用域。
需要注意的点就是：如果某一个闭包中对全局作用域（或父级作用域）中的变量进行了修改，那么任何引用该变量的闭包都会受到牵连。
3、当我们在定义一个函数，就产生了一个闭包，如果这个函数里面又有若干的内部函数，就是闭包嵌套着闭包。
function house(){
var footBall = '足球';
/* 客厅 */
function livingRoom(){
var table = '餐桌';
var sofa = '沙发';
alert(footBall);
}
/* 卧室 */
function bedRoom(){
var bed = '大床';
}
livingRoom();
}
house();
函数house是一个闭包，里面又定义了两个函数，分别是livingRoom客厅，和bedRoom卧室，它们各自形成一个自己的闭包。对它们而言，父级作用域就是house。
如果我们希望在客厅里踢足球，在livingRoom函数执行的时候，它会先在自己的闭包中找足球，如果没找到，就去house里面找。一层一层往上找，直至找到了为止。当然，这个例子可能不是很恰当。但起码展示了作用域，闭包之间的联系。
总结：
闭包就是在函数被创建的时候，存在的一个私有作用域，并且能够访问所有的父级作用域。因此，从理论上讲，任何函数都是一个闭包！
JavaScript： 零基础轻松学闭包（2）
1. 如何将私有数据暴露出去
var test = function(){
var i = 10;
}
function test2(){
alert(i);
}
test2();
函数 test 和 test2 各自形成一个闭包，两个闭包之间无法访问对方的私有数据。比如，在 test 中定义的变量，在 test2 里面是无法直接访问到的。
在js中
- 如果函数被当做参数传进去了，它就是所谓的回调函数。
- 如果函数被当做返回值return出去了，它就是把一个闭包return出去了。
上面这两句话感觉同样适用OC中，iOS开发；
我们希望在 test2 中可以访问到 test 里面的变量，可以这样做：
var test = function(){
var i = 10;
/* 定义一个函数将变量i暴露出去 */
var get = function(){
return i ;
}
return get; // 将获得i的函数暴露出去
}
function test2(){
var fn= test(); // 接收test暴露出来的函数
alert(fn()); // 获得test中的私有数据
}
test2();
test 函数中的 get 方法是一个内部函数，它自己也形成了一个闭包， test 是他的父级作用域，因此它可以获取i的值。
i 进入 get 方法的闭包，被包了起来，然后最终被返回了出去。
而对于 test2 来说，是可以访问到 test函数的，因此可以调用并执行 test 函数，从而获取其返回值。
关于闭包的第二个注解：
2. 从应用的角度来看，闭包可以将函数或者对象的私有数据暴露出去，而不影响全局作用域。
2、将私有数据包装成json对象
刚才的例子说明，在js中，return出去的可以是基本数据类型，也可以是函数类型。
其实，JavaScript是一种基于对象的语言，也有对象的概念，所以，我们可以把你需要东西包裹成一个对象返回出去！
var test = function(){
var apple = '苹果';
var pear = '梨子';
/* 定义一个函数将水果暴露出去 */
var getFruit = {
apple : apple,
pear : pear
}
return getFruit; //将获得i的函数暴露出去
}
function test2(){
var getFruit = test();//接收test暴露出来的函数
console.log(getFruit);
}
test2();
像这样用 { } 括起来的东西就是一个js对象，也就是所谓json。你可能经常会听到json这个词，觉得还挺高大上的。其实它就是一个用 { } 包起来数据而已。
因为是 js 对象，alert 不能看到里面的具体内容，所以我们使用 console.log()。
3. 我们来做一个紫金葫芦
<body>
<div id='box' style='width:50px;height:50px;background:#333;color:#fff;text-align:center;line-height:50px'>小妖</div>
</body>
var 紫金葫芦 = function(id){
var domElement = document.getElementById(id);
var returnObject = {
domElement : domElement ,
backgroundColor : function(color){
domElement.style.backgroundColor = color;
},
click : function(fn){
domElement.onclick = fn;
}
};
return returnObject;
}
我们在返回出去的对象上加了三个东西：
1.domElement
你传进来一个id，我就用 document.getElementById 来包一下，得到一个dom元素，最终要操作的也就是这个dom元素。也就是说：
var box1 = 紫金葫芦('box').domElement;
var box2 = document.getElementById('box');
alert(box1 === box2);
2.backgroundColor 给元素添加背景色的方法
var box = 紫金葫芦('box');
box.backgroundColor('red');
3.click 给元素添加点击事件，需要传入一个回调函数
var box = 紫金葫芦('box');
box.click(function(){
alert('就没人吐槽这个无聊的作者么，小妖也有尊严的好么，啊喂！！');
});
总结：将私有数据暴露出去，可以通过闭包、json对象；
1、闭包可以将函数或者对象的私有数据暴露出去，而不影响全局作用域。
2、{ } 括起来的东西就是一个js对象，也就是所谓json。使用":"组成的键值对；
浅谈js回调函数
http://www.jianshu.com/p/1baa3916842d
var person;
person= {}; // 在JavaScript中，花括号就代表是一个对象
person.name = '小明';
person.money = '10块钱';
person.spendMoney =function(){ alert(this.name +"用 "+this.money +" 块钱买了漫画书！"); }
// log下
alert(person.name);
// 运行
person.spendMoney();
// 打了个括号()就是执行函数的意思。
person.spendMoney =function(doSomeThing){ doSomeThing(); }
// 函数传入spendMoney方法的目的就是让函数在里面执行的。
// 具体做什么，自己决定。
person.spendMoney(function(){ alert('还是把钱存起来吧！'); });
总结一下，就是可以将函数作为一个参数，传入一个方法内，并且能够在该方法中执行这个函数，这也就是js特有的回调函数的魔力。
