javascript 对象里的闭包怎样调用自身的参数 - ITeye问答
var bar = {
init: (function() {
var bar = {
init: (function() {
alert(this.x);
var bar = {
init: (function(cx) {
alert(cx);
}(this.x))
怎样自执行的时候输出正确的x值？
采纳的答案
楼主的样例代码实际上是javascript对象定义的语法，并不是闭包。楼主可能混淆了它们之间的区别。
闭包应该是这样：
var bar = function(){
&&& var x = 200;
&&& var init = function(){
&&&&&&& alert(x);
&&& }
};
init函数被bar函数所包裹，叠加了bar函数的作用域，因此在init函数中的代码可以访问到bar函数的局部变量x，形成闭包。
javascript对象定义：
var bar = {&
&&& x: 200,&
&&& init: (function() {&
&&&&&&& alert(x);&
因为对象定义不会形成作用域，所以init指向的那个匿名函数并不会得到有关bar的任何信息，更不会知道x的存在，所以无论如何努力，都是无法访问到x的。
我猜测楼主的本意可能是想有个初始化函数init，可以初始化对象bar中的成员变量x。
那还是得这样写：
var bar = {&
&&& x: 200,&
&&& init: function() {&
&&&&&&& alert(this.x);&
bar.init(); // 需手动呼叫init函数出场，初始化x。如果在定义bar对象的同时，就通过init所指向的函数完成bar对象的初始化，这是不可能的。
这是不行的。
因为(function() {&
&&&&&&& alert(this.x);&
&&&&& }())&& 这是一个匿名函数调用 上下文不是bar 而是整个全局 此时bar在window上海没有绑定 所以无法调用& 此处this是window
实在不行可以
var bar = {
&&& x: 200
};
bar.init = function() {
&&&&&&&&&&&&&&&&& alert(bar.x);
&&&&&&&&&&&&& }();
已解决问题
未解决问题php的闭包（Closure）匿名函数详解
来源：易贤网&& 阅读：2402 次&&日期：
温馨提示：易贤网小编为您整理了“php的闭包（Closure）匿名函数详解”,方便广大网友查阅！
本文主要给大家介绍的是php5.3引入的PHP匿名函数，也就是闭包（Closure），以及闭包的作用，非常详细，这里推荐给有需要的小伙伴们。
php的闭包（Closure）也就是匿名函数，是PHP5.3引入的。
闭包的语法很简单，需要注意的关键字就只有use，use是连接闭包和外界变量。
$a = function() use($b) {}
简单例子如下：
function callback($fun) {
$msg = "Hello, everyone";
$fun = function () use($msg) {
print "This is a closure use string value, msg is: $msg. &br /&/n";
$msg = "Hello, everybody";
callback($fun);
结果是：This is a closure use string value, msg is: Hello, everyone. &br /&/n
在PHP新开放的闭包语法中， 我们用use来使用闭包外部定义的变量的。这里我们使用了外部变量$msg，定义完之后，又对其值进行了改变，闭包被执行后输出的是原始值。以传值方式传递的基础类型参数，闭包use的值在闭包创建是就确定了。
小应用如下：
* 一个利用闭包的计数器产生器
* 这里其实借鉴的是python中介绍闭包时的例子...
* 我们可以这样考虑:
* 1. counter函数每次调用, 创建一个局部变量$counter, 初始化为1.
* 2. 然后创建一个闭包, 闭包产生了对局部变量$counter的引用.
* 3. 函数counter返回创建的闭包, 并销毁局部变量, 但此时有闭包对$counter的引用,
* 它并不会被回收, 因此, 我们可以这样理解, 被函数counter返回的闭包, 携带了一个游离态的
* 4. 由于每次调用counter都会创建独立的$counter和闭包, 因此返回的闭包相互之间是独立的.
* 5. 执行被返回的闭包, 对其携带的游离态变量自增并返回, 得到的就是一个计数器.
* 结论: 此函数可以用来生成相互独立的计数器.
function counter() {
$counter = 1;
return function() use(&$counter) {return $counter ++;};
$counter1 = counter();
$counter2 = counter();
echo "counter1: " . $counter1() . "&br /&/n";
echo "counter1: " . $counter1() . "&br /&/n";
echo "counter1: " . $counter1() . "&br /&/n";
echo "counter1: " . $counter1() . "&br /&/n";
echo "counter2: " . $counter2() . "&br /&/n";
echo "counter2: " . $counter2() . "&br /&/n";
echo "counter2: " . $counter2() . "&br /&/n";
echo "counter2: " . $counter2() . "&br /&/n";
闭包的作用
1. 减少foreach的循环的代码
比如手册中的例子Cart
// 一个基本的购物车，包括一些已经添加的商品和每种商品的数量。
// 其中有一个方法用来计算购物车中所有商品的总价格。该方法使用了一个closure作为回调函数。
class Cart
const PRICE_BUTTER = 1.00;
const PRICE_MILK = 3.00;
const PRICE_EGGS = 6.95;
protected $products = array();
public function add($product, $quantity)
$this-&products[$product] = $
public function getQuantity($product)
return isset($this-&products[$product]) ? $this-&products[$product] :
public function getTotal($tax)
$total = 0.00;
$callback =
function ($quantity, $product) use ($tax, &$total)
$pricePerItem = constant(__CLASS__ . "::PRICE_" .
strtoupper($product));
$total += ($pricePerItem * $quantity) * ($tax + 1.0);
//使用用户自定义函数对数组中的每个元素做回调处理
array_walk($this-&products, $callback);
return round($total, 2);;
$my_cart = new C
// 往购物车里添加条目
$my_cart-&add('butter', 1);
$my_cart-&add('milk', 3);
$my_cart-&add('eggs', 6);
// 打出出总价格，其中有 5% 的销售税.
print $my_cart-&getTotal(0.05) . "\n";
// The result is 54.29
这里如果我们改造getTotal函数必然要使用到foreach。
2. 减少函数的参数
function html($code , $id="", $class=""){
if ($id !== "") $id = " id = \"$id\"" ;
$class = ($class !== "")? " class =\"$class\"&":"&";
$open = "&$code$id$class";
$close = "&/$code&";
return function ($inner = "") use ($open, $close){
return "$open$inner$close";
如果是使用平时的方法，我们会把inner放到html函数参数中，这样不管是代码阅读还是使用都不如使用闭包。
3. 解除递归函数
$fib = function($n) use(&$fib) {
if($n == 0 || $n == 1) return 1;
return $fib($n - 1) + $fib($n - 2);
echo $fib(2) . "\n"; // 2
$fib = function(){die('error');};//rewrite $fib variable
echo $lie(5); // error because $fib is referenced by closure
注意上题中的use使用了&，这里不使用&会出现错误fib(n-1)是找不到function的（前面没有定义fib的类型）
所以想使用闭包解除循环函数的时候就需要使用
$recursive = function () use (&$recursive){
// The function is now available as $recursive
这样的形式。
4. 延迟绑定
如果你需要延迟绑定use里面的变量，你就需要使用引用，否则在定义的时候就会做一份拷贝放到use中
$result = 0;
$one = function()
var_dump($result);
$two = function() use ($result)
var_dump($result);
$three = function() use (&$result)
var_dump($result);
$result++;
$one(); // outputs NULL: $result is not in scope
$two(); // outputs int(0): $result was copied
$three(); // outputs int(1)
使用引用和不使用引用就代表了是调用时赋值，还是申明时候赋值
小伙伴们是否对PHP的匿名函数也就是闭包函数有了新的认识了呢，希望本文能给大家一些提示，希望大家能够喜欢。
更多信息请查看
更多信息请查看
【】&&&&&【点此处查询各地各类考试咨询QQ号码及交流群】
易贤网手机网站地址：
由于各方面情况的不断调整与变化，易贤网提供的所有考试信息和咨询回复仅供参考，敬请考生以权威部门公布的正式信息和咨询为准！
相关阅读 & & &
&nbsp&nbsp&nbsp &nbsp&nbsp&nbsp会员注册
本站不参与评论！（）
自觉遵守：爱国、守法、自律、真实、文明的原则
尊重网上道德，遵守中华人民共和国各项有关法律法规
严禁发表危害国家安全，破坏民族团结、国家宗教政策和社会稳定，含侮辱、诽谤、教唆、淫秽等内容的评论
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
您在本站发表的评论，本站有权保留、转载、引用或者删除
参与本评论即表明您已经阅读并接受上述条款JavaScript--匿名函数和闭包
/ 匿名函数:没有名字的函数;
// 闭包:可访问一个函数作用域里的变量的函数;
一 匿名函数
&1 // 普通函数
&2 & & function box(){ & & & & & & & & & & & // 函数名是
&3 & & & & return 'Lee'; & & & & & & & & & &&
&5 & & box(); & & & & & & & & & & & & & & & &// =&L 调用函数;
&6 // 匿名函数
&7 & & function(){ & & & & & & & & & & & & & // 匿名函数,会报错;
&8 & & & & return 'Lee';
10 // 通过表达式自我执行
11 & & (function(name){
12 & & & & console.log(name); & & & & & & & // =&L
13 & & })(&Lee&); & & & & & & & & & & & & & // &()&表示执行函数,并且可以传参;
14 // 把匿名函数赋值给变量
15 & & var box = function(){ & & & & & & & &// 将匿名函数赋给变量;
16 & & & & return 'Lee';
18 & & console.log(box()); & & & & & & & & &// 调用方式和函数调用相似;
19 // 函数里的匿名函数
20 & & function box(){
21 & & & & return function(name){ & & & & & &// 函数里的匿名函数,产生闭包;
22 & & & & & &
23 & & & & };
25 & & console.log(box()(&Lee&)); & & & & & &// 函数box()调用匿名函数,并传参;
// 闭包:有权访问另一个函数作用域中的变量的函数;
// 创建闭包的常见方式:在一个函数内部创建另一个函数;通过另一个函数访问这个函数的局部变量;
&1 // 通过闭包可以返回局部变量
&2 & & function box(){
&3 & & & & var user = 'Lee';
&4 & & & & return function(){ & & & & & & & &// 通过匿名函数返回box()的局部变量
&5 & & & & & &
&6 & & & & };
&8 & & console.log(box()()); & & & & & & & &// =&L 直接调用box()()来获得匿名函数的返回值;
10 & & var b = box();
11 & & console.log(b()); & & & & & & & & & &// =&L 另一种调用匿名函数方式;
13 // 优点:可以把局部变量驻留在内存中,可以避免使用全局变量; &
14 // (全局变量污染导致应用程序不可预测性,每个模块都可调用必将引来灾难;所以推荐使用私有的,封装的局部变量);
&1 // 缺点:
&2 // 通过全局变量来累加
&3 & & var age = 100; & & & & & & & & & & & &// 全局变量;
&4 & & function box(){
&5 & & & & age++; & & & & & & & & & & & & & &// 模块级可以调用全局变量,进行累加;
&7 & & box(); & & & & & & & & & & & & & & & &// 执行函数,累加一次;
&8 & & console.log(age); & & & & & & & & & & // =&101; 输出全局变量;
&9 & & box(); & & & & & & & & & & & & & & & &// 执行函数,累加一次;
10 & & console.log(age); & & & & & & & & & & // =&102; 输出全局变量;
11 // 通过局部变量无法实现累加
12 & & function box(){
13 & & & & var age = 100;
14 & & & & age++; & & & & & & & & & & & & & &// 实现累加;
15 & & & &
17 & & console.log(box()); & & & & & & & & & // =&101;
18 & & console.log(box()); & & & & & & & & & // =&101; 无法实现累加,因为第二次调用函数时,函数内部变量age又被初始化了;
20 // 通过闭包可以实现局部变量的累加
21 & & function box(){
22 & & & & var age = 100;
23 & & & & return function(){ & & & & & & & &// 匿名函数内实现累加;
24 & & & & & & age++;
25 & & & & & & & & & & & & & & & // 并返回累加后的变量;&
26 & & & & }; & & & & & & & & & & & & & & & &// 此时box()函数的局部变量age的值已经被修改为累加后的值;
28 & & var b = box(); & & & & & & & & & & & &// 给box()函数赋值给变量;
29 & & console.log(b()); & & & & & & & & & & // =&101; 调用匿名函数,累加一次;
30 & & console.log(b()); & & & & & & & & & & // =&102; 第二次调用匿名函数,累加两次;
32 // PS:由于闭包里作用域返回的局部变量资源不会被立刻销毁回收,所以可能会占用更多的内存;所以过度使用闭包会导致性能下降;(将闭包引用在&私有作用域&中即可实现变量销毁)
33 // 作用域链的机制导致一个问题,在循环中里的匿名函数取得的任何变量都是最后一个值; ?
&1 // 循环里包含匿名函数
&2 & & function box(){
&3 & & & & var arr = [];
&4 & & & & for(var i=0; i&5; i++){ & & & & // 当声明变量i=5时,循环停止;而此时循环里的变量i==5;&
&5 & & & & & & arr[i] = function(){ & & & &// arr[i]得到的只是没有执行的匿名函数function(){};
&6 & & & & & & & & & & & & & & & &
&7 & & & & & & };
&8 & & & & };
&9 & & & & & & & & & & & & & & // arr = [function,function,function,function,function];
11 & & var b = box(); & & & & & & & & & & &// =&[function,function,function,function,function]; 得到函数box()返回的数组
12 & & console.log(b.length); & & & & & & &// =&5; 得到函数集合数组长度;
13 & & for(var i=0; i&b. i++){
14 & & & & console.log(box()[i]()); & & & &// =&5,5,5,5,5; 输出每个函数的值,都是最后一个值;
16 & & // 上面的例子输出的结果都是5,也就是循环后得到的最大i值;
17 & & // 因为b[i]调用的是匿名函数,匿名函数并没有自我执行,等到调用的时候,box()已执行完毕,i早已变成5;
19 // 循环里包含匿名函数-改1,自我执行匿名函数
20 & & function box(){
21 & & & & var arr = [];
22 & & & & for(var i=0; i&5; i++){
23 & & & & & & arr[i] = (function(num){ & &// arr[i]得到的是匿名函数执行后的结果数值0-4;
24 & & & & & & & &&
25 & & & & & & })(i); & & & & & & & & & & &// 自我执行并传参;
26 & & & & }
27 & & & &&
29 & & var b = box(); & & & & & & & & & & &// =&[0,1,2,3,4]; &此时b代表box()返回的数组;
30 & & for (var i = 0; i & b. i++) {
31 & & & & console.log(b[i]); & & & & & & &// 0 1 2 3 4; 这里返回的是数值;
33 & & // 例子中,我们让匿名函数进行自我执行,导致最终返回给a[i]的是数组而不是函数了;最终导致b[0]-b[4]中保留了0,1,2,3,4的值;
35 // 循环里包含匿名函数-改2,匿名函数里再做个匿名函数;
36 & & function box(){
37 & & & & var arr = [];&
38 & & & & for(var i=0; i&5; i++){
39 & & & & & & arr[i] = (function(num){
40 & & & & & & & & return function(){ & & &// 返回函数;
41 & & & & & & & & & & & & & & & &
42 & & & & & & & & }
43 & & & & & & })(i);
44 & & & & }
45 & & & & & & & & & & & & & & // arr = [function,function,function,function,function];
47 & & var b = box();
48 & & for (var i = 0; i & b. i++) {
49 & & & & console.log(b[i]()); & & & & & &// 0,1,2,3,4;&
52 // 改1和改2中,我们通过匿名函数自我执行,立即把结果赋值给arr[i];
53 // 每一个i,是调用方通过按值传递的,所以最终返回的都是指定的递增的i;而不是box()函数中的变量i;
三 this对象
&1 // 在闭包中使用this对象可能会导致一些问题;this对象是在运行时基于函数的执行环境绑定的;
&2 // 如果this在全局范围就是指向window,如果在对象内部就指向这个对象;
&3 // 而闭包却在运行时指向window的,因为闭包并不属于这个对象的属性或方法;&
&4 & & var user = 'Window';
&5 & & var obj = {
&6 & & & & user:'Object',
&7 & & & & getUserFunction:function(){
&8 & & & & & & return function(){ & & & & & & & & & & & &// 闭包不属于obj,里面的this指向
&9 & & & & & & & & return this.
10 & & & & & & };
11 & & & & }
13 & & console.log(obj.getUserFunction()()); & & & & & &// =&W
15 & & // 可以强制指向某个对象
16 & & console.log(obj.getUserFunction().call(obj)); & &// =&O
18 & & // 也可以从上一个作用域中的得到对象
19 & & getUserFunction:function(){
20 & & & & var that = & & & & & & & & & & & & & & // 从对象的方法里得到此时that指向obj对象;
21 & & & & return function(){
22 & & & & & & return that.
23 & & & & }
25 & & console.log(obj.getUserFunction()()); & & & & & &// =&O
四 内存泄漏
&1 // 由于IE的JScript对象和DOM对象使用不同的垃圾收集方式,因此闭包在IE中会导致内存泄漏问题,也就是无法销毁驻留在内存中的元素;
&2 & & function box(){
&3 & & & & var oDiv = document.getElementById('oDiv'); &// oDiv用完之后一直驻留在内存中;
&4 & & & & oDiv.onclick = function(){
&5 & & & & & & alert(oDiv.innerHTML); & & & & & & & & & // 这里用oDiv导致内存泄漏;
&6 & & & & };
&7 & & & & oDiv = & & & & & & & & & & & & & & & & // 解除引用;
&9 & & box();
10 & & // 由于匿名函数保存了一个对box()的活动对象的引用,因此就会导致无法减少oDiv的引用数;
11 & & // 只要匿名函数存在,oDiv的引用数至少也是1;因此它所占用的内存就永远不会被回收;
12 & & // PS:如果没有使用解除引用,那么要等到关闭才得以释放;
五 模仿块级作用域(定义并立即调用一个匿名函数)
&1 // JS没有块级作用域的概念;
&2 // 这意味着在块语句(for语句/if语句)中定义的变量,实际上是在包含函数中而非语句中创建的;
&3 & & function box(count){
&4 & & & & for(var i=0; i& i++){} & & & & & & & &// box(2); =& count=2; i=2时循环停止,此时i=2;
&5 & & & & console.log(i); & & & & & & & & & & & & & & // =&2; i不会因为离开了for块就失效;
&7 & & box(2);
&9 & & function box(count){
10 & & & & for(var i=0; i& i++){}
11 & & & & & & & & & & & & & & & & & & & & & & &// 就算重新声明,也不会覆盖前面的值;
12 & & & & console.log(i);
14 & & box(2);
15 // 在Script中,变量i是定义在box()的活动对象中的,因此从它有定义开始,就可以在函数内部随处访问它;
16 // 以上两个例子,说明没有块级语句的作用域,if(){}/for(){}等没有作用域;
17 // 如果有作用域的话,出了这个范围i就应该被销毁;
19 // JavaScript不会提醒是否多次声明了同一个变量;遇到这种情况,它只会对后续的声明视而不见(如果是初始化并赋值,还是会执行的);
21 // 模仿块级作用域(私有作用域)
22 & & (function(){
23 & & & & // 这里是块级作用域;
24 & & })();
25 & & // 以上代码定义并立即调用了一个匿名函数;将函数声明包含在一对圆括号中,表示它实际上是一个函数表达式;
27 // 使用块级作用域(私有作用域)改写
28 & & function box(count){
29 & & & & (function(){
30 & & & & & & for(var i=0; i& i++){}
31 & & & & })();
32 & & & & console.log(i); & & & & & & & & & & & & & & & &// 报错,无法访问;变量i在私有作用域中,出了私有作用域即被销毁了.
34 & & box(2);
35 // 使用了块级作用域后,匿名函数中定义的任何变量,都会在执行结束时被销毁;(i只能在循环中使用,使用后即被销毁);
36 // 而私有作用域中能够访问变量count,是因为这个匿名函数是一个闭包,他能够访问包含作用域中的所有变量;
37 // 这种技术经常在全局作用域中被用在函数外部,从而限制向全局作用域中添加过多的变量和函数;
38 // 一般来说,我们都应该尽可能少向全局作用域中添加变量和函数;过多的全局变量和函数很容易导致命名冲突;
39 // 使用块级作用域,每个开发者既可以使用自己的变量,又不必担心搞乱全局作用域;
40 & & (function(){
41 & & & & var box = [1,2,3,4];
42 & & & & console.log(box); & & & & & & & & & & & & & &// =&[1,2,3,4]; box出来就不被认识了;
43 & & })(); & & & & & & & & & & & & & & & & & & & & & &// 销毁匿名函数中的变量;
44 & & console.log(box); & & & & & & & & & & & & & & & &// =&
45 & & // 在全局作用域中使用块级作用域可以减少闭包占用的内存问题;因为没有指向匿名函数的引用
46 & & // 只要函数执行完毕,就可以立即销毁其作用域链了;
六 私有变量
&1 // JavaScript没用私有属性的概念;所有的属性都是公用的;
&2 // 不过有一个私有变量的概念:在任何函数中定义的变量,都可以认为是私有变量,因为不能在函数外部访问这些变量;
&3 // 私有变量包括函数的参数/局部变量和在函数内部定义的其他函数;
&4 & & function box(){
&5 & & & & var age = 100; & & & & & & & & & & & & & & & & // 私有变量,外部无法访问;
&8 // 而通过内部创建一个闭包,那么闭包通过自己的作用域链也可以访问这些变量;
&9 // 而利用这一点,可以创建用于访问私有变量的公用方法;特权方法;
10 & & function Box(){ & & & & & & & & & & & & & & & & & &// 构造函数;
11 & & & & var age = 100; & & & & & & & & & & & & & & & & // 私有变量;
12 & & & & function run(){ & & & & & & & & & & & & & & & &// 私有函数;
13 & & & & & & return '运行中...';
14 & & & & };
15 & & & & this.get = function(){ & & & & & & & & & & & & // 对外公共的特权方法;
16 & & & & & & return age+run(); & & & & & & & & & & & & &// 将闭包赋值给变量;
17 & & & & };
19 & & var box = new Box();
20 & & console.log(box.get());
22 // 可以通过构造方法传参来访问私有变量
23 & & function Person(name){
24 & & & & var user = & & & & & & & & & & & & & &// 这句其实可以省略;
25 & & & & this.getUser = function(){
26 & & & & & &
27 & & & & };
28 & & & & this.setUser = function(name){
29 & & & & & & user =
30 & & & & }
32 & & var p = new Person('Lee');
33 & & console.log(p.getUser()); & & & & & & & & & & & &// =&L
34 & & console.log(p.setUser('Jack'));
35 & & console.log(p.getUser()); & & & & & & & & & & & &// =&J
36 & & // 但是,构造函数模式的缺点是针对每个实例都会创建同样一组新方法;而使用静态私有变量来实现特权方法就可以避免这个问题;
七 静态私有变量
&1 // 通过块级作用域(私有作用域)中定义私有变量或函数,同样可以创建对外公共的特权方法;
&2 & & (function(){ & & & & & & & & & & & & & & & & & &// 创建私有作用域;
&3 & & & & var age = 100; & & & & & & & & & & & & & & &// 静态私有变量;
&4 & & & & function run(){
&5 & & & & & & return '运行中...';
&6 & & & & };
&7 & & & & Box = function(){}; & & & & & & & & & & & & // 使用函数表达式定义构造函数;
&8 & & & & Box.prototype.go = function(){ & & & & & & &// 公有(特权)方法;在原型上定义的;
&9 & & & & & & return age+run();
10 & & & & };
11 & & })();
12 & & var box = new Box();
13 & & console.log(box.go()); & & & & & & & & & & & & &// 100运行中...;
14 // 上面的对象声明,采用的是Box = function(){}而不是functiong Box(){};并且在声明Box时没有使用var关键字
15 // 导致:初始化未经声明的变量,总是会创建一个全局变量;因此,Box就成了一个全局变量,能够在私有作用域之外被访问到;
16 // 因为如果用函数声明定义构造函数,那么就变成私有函数了,无法在全局访问到了,所以要使用函数式定义构造方法;
17 & & (function(){
18 & & & & var user = &&;
19 & & & & Person = function(value){ & & & & & & & & & // 此处定义的Person是全局变量;
20 & & & & & & user = & & & & & & & & & & & & & // 这里的构造函数有权访问私有变量
21 & & & & };
22 & & & & Person.prototype.getUser = function(){
23 & & & & & &
24 & & & & };
25 & & & & Person.prototype.setUser = function(value){
26 & & & & & & user =
27 & & & & }
28 & & })();
29 & & var person = new Person();
30 & & person.setUser('Lee');
31 & & console.log(person.getUser()); & & & & & & & & & &// =&L
32 // 使用了prototype导致方法共享了,而user也就变成静态属性了;
33 // 所谓静态属性:即共享于不同对象中的属性;?
八 模块模式
&1 // 简言之,如果必须创建一个对象并以某些数据对其进行初始化,同时还要公开一些能够访问这些私有数据的方法,那么就可以使用模块模式;
&2 // 之前采用的都是构造函数的方式来创建私有变量和特权方法;
&3 // 那么对象字面量方式就采用模块模式来创建;
&4 & & var box = { & & & & & & & & & & & & & & & & & & &// 字面量对象,也是单例对象:只有一个实例的对象;
&5 & & & & age:100, & & & & & & & & & & & & & & & & & & // 这是公有属性,将要改成私有;
&6 & & & & run:function(){
&7 & & & & & & return '运行中...';
&8 & & & & };
11 // 模块模式私有化变量和函数:
12 & & var box = function(){
13 & & & & var age = 100;
14 & & & & function run(){
15 & & & & & & return '运行中...';
16 & & & & }
17 & & & & return { & & & & & & & & & & & & & & & & & & // 将一个字面量对象作为函数的值返回;
18 & & & & & & go:function(){ & & & & & & & & & & & & & // 返回的对象字面量中只包含可以公开的属性和方法;
19 & & & & & & & & return age+run(); & & & & & & & & & &// 由于这个对象是在匿名函数内部定义的,因此它的公有方法有权访问私有变量和函数;
20 & & & & & & } & & & & & & & & & & & & & & & & & &
21 & & & & }; & & & & & & & & & & & & & & & & & & & & & // 从本质上讲,这个对象字面量定义的是单例的公共接口;
22 & & }();
23 // 这种模式在需要对单例进行某些初始化,同时又需要维护其私有变量时是非常有用的;&
25 // 上面直接返回对象的例子,也可以这么写:
26 & & var box = function(){
27 & & & & var age = 100;
28 & & & & function run(){
29 & & & & & & return '运行中...';
30 & & & & }
31 & & & & var obj = { & & & & & & & & & & & & & & & & & // 创建字面量对象;
32 & & & & & & go:function(){
33 & & & & & & & & return age+run();
34 & & & & & & }
35 & & & & };
36 & & & & & & & & & & & & & & & & & & & & & // 返回刚创建的对象;
37 & & }();
39 // 字面量的对象声明,其实在设计模式中可以看作是一种单例模式;
40 // 所谓单例模式,就是永远保持对象的只有一个实例;
42 // 增强的模块模式:适合返回自定义对象,也就是构造函数;
43 & & function Desk(){};
44 & & var box = function(){
45 & & & & var age = 100;
46 & & & & function run(){
47 & & & & & & return '运行中...';
48 & & & & };
49 & & & & var desk = new Desk();
50 & & & & desk.go = function(){
51 & & & & & & return age+run();
52 & & & & };
53 & & & &
54 & & }();
// 在JavaScript中,函数表达式是一种非常有用的技术;使用函数表达式可以无须对函数命名,从而实现动态编程;
1.函数表达式
1 // 函数表达式不同于函数声明;函数声明要求有名字,但函数表达式不需要;
2 // 没有名字的函数表达式叫做匿名函数;
1 // 当在函数内部定义了其他函数时,就创建了闭包.闭包有权访问包含函数内部的所有变量;原理如下:
2 // 在后台执行环境中,闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域；
3 // 通常，函数的作用域及其所有变量都会在函数执行结束后被销毁；
4 // 但是，当函数返回了一个闭包时，这个函数的作用域将会一直在内存中保存到闭包不存在为止；
3.块级作用域
1 // 使用闭包可以在JavaScript中模仿块级作用域(JavaScript本身没有块级作用域的概念);要点如下:
2 // 创建并立即调用一个函数,这样既可以执行其中的代码,又不会在内存中留下对该函数的引用;
3 // 结果就是函数内部的所有变量都会被立即销毁--除非将某些变量赋值给了包含作用域(即外部作用域)中的变量;
4.私有变量
1 // 闭包还可以用于在对象中创建私有变量,要点如下:
2 // 即使JavaScript中没有真是的私有对象属性的概念,但是可以使用闭包来实现公有方法,而通过公有方法可以访问包含作用域中定义的变量;
3 // 可以使用构造函数模式、原型模式来实现自定义类型的特权方法，也可以使用模块模式来实现单例的特权方法；
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'