图片 9

你可能需要了解的知识点以及使用场景,是真的美

new

使用 bind 返回的结果还是个 function,是个 function 就可以被 new
运算符调用,那么结果呢?规范中说的很清楚了,当使用 new
操作符调用绑定函数时,bind 的第一个参数无效。

function Person(name, age) { this.name = name; this.age = age; } var
_Person = Person.bind({}); var p = new _Person(‘hanzichi’, 30); //
Person {name: “hanzichi”, age: 30}

1
2
3
4
5
6
7
function Person(name, age) {
  this.name = name;
  this.age = age;
}
 
var _Person = Person.bind({});
var p = new _Person(‘hanzichi’, 30); // Person {name: "hanzichi", age: 30}

一般我们不会去这么用,但是如果要写个 bind 的
polyfill(),还是需要考虑用 new
调用的情况。

我们也可以设置默认值(参考上一小节),原先提供的那些参数仍然会被前置到构造函数调用的前面。

function Person(name, age) { this.name = name; this.age = age; } var
_Person = Person.bind(null, ‘hanzichi’); var p = new _Person(30); //
Person {name: “hanzichi”, age: 30}

1
2
3
4
5
6
7
function Person(name, age) {
  this.name = name;
  this.age = age;
}
 
var _Person = Person.bind(null, ‘hanzichi’);
var p = new _Person(30); // Person {name: "hanzichi", age: 30}

这里我们还是继续上一篇博客中的例子,使用最新版本的flex布局来实现相同的效果。

html代码:

XHTML

<div>
<p>发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划哈萨克的骨灰撒块光辉卡萨很干净啊是高科技傻空给发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划哈萨克的骨灰撒块光辉卡萨很干净啊是高科技傻空给</p>
<p>发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划哈萨克的骨灰撒块光辉卡萨很干净啊是高科技傻空给</p>
<p>发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划</p>
</div>

1
2
3
4
5
<div>
    <p>发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划哈萨克的骨灰撒块光辉卡萨很干净啊是高科技傻空给发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划哈萨克的骨灰撒块光辉卡萨很干净啊是高科技傻空给</p>
    <p>发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划哈萨克的骨灰撒块光辉卡萨很干净啊是高科技傻空给</p>
    <p>发生过的空间还是看价格哈健康啊水果和卡刷卡更何况规划</p>
</div>

基础的css代码:

CSS

p{ width:150px; border:3px solid lightblue; background:lightgreen;
padding:5px; margin:5px; }

1
2
3
4
5
6
7
p{
    width:150px;
    border:3px solid lightblue;
    background:lightgreen;
    padding:5px;
    margin:5px;
}

此时我们给div元素设置display属性为flex :

CSS

div{ display:flex; }

1
2
3
div{
    display:flex;
}

刷新浏览器后的效果是:

图片 1

可以看到效果跟旧版本的-webkit-box是一样的。

在新版本中设置为弹性伸缩盒的display属性值有两个:

  • flex : 将容器盒模型作为块级弹性伸缩盒显示
  • inline-flex : 将容器盒模型作为内联级弹性伸缩盒显示

看一下新版本的flex布局的浏览器兼容情况:

图片 2

PS:可以看到,在一些比较旧的webkit内核的浏览器(Chrome,Safari)中,我们需要使用-webkit-flex来做兼容,但是这里我就省略了。

下面将逐一介绍flex布局的各个属性的基础用法:

闭包的应用的注意事项

闭包,在JS中绝对是一个高贵的存在,它让很多不可能实现的代码成为可能,但是物虽好,也要合理使用,不然不但不能达到我们想要的效果,有的时候可能还会适得其反。

  • 内存泄漏(Memory
    Leak)JavaScript分配给Web浏览器的可用内存数量通常比分配给桌面应用程序的少,这样做主要是防止JavaScript的网页耗尽全部系统内存而导致系统崩溃。因此,要想使页面具有更好的性能,就必须确保页面占用最少的内存资源,也就是说,我们应该保证执行代码只保存有用的数据,一旦数据不再有用,我们就应该让垃圾回收机制对其进行回收,释放内存。

    我们现在都知道了闭包阻止了垃圾回收机制对变量进行回收,因此变量会永远存在内存中,即使当变量不再被使用时,这样会造成内存泄漏,会严重影响页面的性能。因此当变量对象不再适用时,我们要将其释放。

    我们拿上面代码举例:

function foo() { let a = 2; function bar() { console.log( a ); }
return bar; } let baz = foo(); baz();
//baz指向的对象会永远存在堆内存中 baz = null;
//如果baz不再使用,将其指向的对象释放

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-5">
5
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-6">
6
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-7">
7
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-8">
8
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-9">
9
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-10">
10
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-11">
11
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-12">
12
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-13">
13
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da5441991997-14">
14
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da5441991997-15">
15
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f6bea87da5441991997-1" class="crayon-line">
 function foo() {
</div>
<div id="crayon-5b8f6bea87da5441991997-2" class="crayon-line crayon-striped-line">
     let a = 2;
</div>
<div id="crayon-5b8f6bea87da5441991997-3" class="crayon-line">

</div>
<div id="crayon-5b8f6bea87da5441991997-4" class="crayon-line crayon-striped-line">
     function bar() {
</div>
<div id="crayon-5b8f6bea87da5441991997-5" class="crayon-line">
         console.log( a );
</div>
<div id="crayon-5b8f6bea87da5441991997-6" class="crayon-line crayon-striped-line">
     }
</div>
<div id="crayon-5b8f6bea87da5441991997-7" class="crayon-line">

</div>
<div id="crayon-5b8f6bea87da5441991997-8" class="crayon-line crayon-striped-line">
     return bar;
</div>
<div id="crayon-5b8f6bea87da5441991997-9" class="crayon-line">
 }
</div>
<div id="crayon-5b8f6bea87da5441991997-10" class="crayon-line crayon-striped-line">

</div>
<div id="crayon-5b8f6bea87da5441991997-11" class="crayon-line">
 let baz = foo();
</div>
<div id="crayon-5b8f6bea87da5441991997-12" class="crayon-line crayon-striped-line">

</div>
<div id="crayon-5b8f6bea87da5441991997-13" class="crayon-line">
 baz(); //baz指向的对象会永远存在堆内存中
</div>
<div id="crayon-5b8f6bea87da5441991997-14" class="crayon-line crayon-striped-line">

</div>
<div id="crayon-5b8f6bea87da5441991997-15" class="crayon-line">
 baz = null; //如果baz不再使用,将其指向的对象释放
</div>
</div></td>
</tr>
</tbody>
</table>

关于内存泄漏,推荐
[阮一峰老师博客](http://www.ruanyifeng.com/blog/2017/04/memory-leak.html)。

Read more

关于 bind 的介绍就到这里,下一篇文章将结合 underscore 来讲讲如何实现一个
bind 的 polyfill。

  • Function.prototype.bind()
  • ECMAScript 5(ES5) 中 bind
    方法简介备忘
  • Javascript 中的 Bind ,Call 以及
    Apply
  • Javascript 中 bind()
    方法的使用与实现

打赏支持我写出更多好文章,谢谢!

打赏作者

align-items属性

align-items
属性规定灵活容器内的各项的默认对齐方式,和旧版本中的box-align一样,处理伸缩项目容器的额外空间。

CSS

div{ display:flex; align-items:center; }

1
2
3
4
div{
    display:flex;
    align-items:center;
}

效果如下:

图片 3

那么,此属性的属性值有:

  • flex-start : 伸缩项目以顶部为基准,清理下部的额外空间
  • flex-end : 伸缩项目以底部为基准,清理上部的额外空间
  • center : 伸缩项目以中部为基准,平均清理上下部的额外空间
  • baseline : 伸缩项目以基线为基准,清理额外的空间
  • stretch : 伸缩项目填充整个容器,默认值

这些效果跟旧版本的box-align基本是一样的,具体怎么用,大家自己试一下就知道了。

拨开闭包神秘的面纱

我们先看一个闭包的例子:

function foo() { let a = 2; function bar() { console.log( a ); } return
bar; } let baz = foo(); baz();

1
2
3
4
5
6
7
8
9
10
11
12
13
function foo() {
    let a = 2;
 
    function bar() {
        console.log( a );
    }
 
    return bar;
}
 
let baz = foo();
 
baz();

大家肯定都写过类似的代码,相信很多小伙伴也知道这段代码应用了闭包,but,
Why does the closure be generated and Where is closure?

来,我们慢慢分析:

首先必须先知道闭包是什么,才能分析出闭包为什么产生和闭包到底在哪?

当一个函数能够记住并访问到其所在的词法作用域及作用域链,特别强调是在其定义的作用域外进行的访问,此时该函数和其上层执行上下文共同构成闭包。

需要明确的几点:

  1. 闭包一定是函数对象(wintercn大大的闭包考证)
  2. 闭包和词法作用域,作用域链,垃圾回收机制息息相关
  3. 当函数一定是在其定义的作用域外进行的访问时,才产生闭包
  4. 闭包是由该函数和其上层执行上下文共同构成(这点稍后我会说明)

闭包是什么,我们说清楚了,下面我们看下闭包是如何产生的。

接下来,我默认你已经读过我之前的两篇文章
原来JavaScript内部是这样运行的

彻底搞懂JavaScript作用域
,
建议先进行阅读理解JS执行机制和作用域等相关知识,再理解闭包,否则可能会理解的不透彻。

现在我假设JS引擎执行到这行代码

let baz = foo();

此时,JS的作用域气泡是这样的:

图片 4

这个时候foo函数已经执行完,JS的垃圾回收机制应该会自动将其标记为”离开环境”,等待回收机制下次执行,将其内存进行释放(标记清除)。

但是,我们仔细看图中粉色的箭头,我们将bar的引用指向baz,正是这种引用赋值,阻止了垃圾回收机制将foo进行回收,从而导致bar的整条作用域链都被保存下来

接下来,baz()执行,bar进入执行栈,闭包(foo)形成,此时bar中依旧可以访问到其父作用域气泡中的变量a。

这样说可能不是很清晰,接下来我们借助chrome的调试工具看下闭包产生的过程。

当JS引擎执行到这行代码let baz = foo();时:

图片 5

图中所示,let baz = foo();已经执行完,即将执行baz();,此时Call
Stack中只有全局上下文。

接下来baz();执行:

图片 6

我们可以看到,此时bar进入Call Stack中,并且Closure(foo)形成。

针对上面我提到的几点进行下说明:

  1. 上述第二点(闭包和词法作用域,作用域链,垃圾回收机制息息相关)大家应该都清楚了
  2. 上述第三点,当函数baz执行时,闭包才生成
  3. 上述第四点,闭包是foo,并不是bar,很多书(《you dont know
    JavaScript》《JavaScript高级程序设计》)中,都强调保存下来的引用,即上例中的bar是闭包,而chrome认为被保存下来的封闭空间foo是闭包,针对这点我赞同chrome的判断(仅为自己的理解,如有不同意见,欢迎来讨论)

参数

bind 的第一个参数会作为原函数运行时的 this
指向,不多说;而第二个开始的参数是可选的,当绑定函数被调用时,这些参数加上绑定函数本身的参数会按照顺序作为原函数运行时的参数。怎么理解?

function fn(a, b, c) { return a + b + c; } var _fn = fn.bind(null, 10);
var ans = _fn(20, 30); // 60

1
2
3
4
5
6
function fn(a, b, c) {
  return a + b + c;
}
 
var _fn = fn.bind(null, 10);
var ans = _fn(20, 30); // 60

fn 函数需要三个参数,_fn 函数将 10
作为默认的第一个参数,所以只需要传入两个参数即可,如果你不小心传入了三个参数,放心,也只会取前两个。

function fn(a, b, c) { return a + b + c; } var _fn = fn.bind(null, 10);
var ans = _fn(20, 30, 40); // 60

1
2
3
4
5
6
function fn(a, b, c) {
  return a + b + c;
}
 
var _fn = fn.bind(null, 10);
var ans = _fn(20, 30, 40); // 60

这有啥用呢?如果某些函数,前几个参数已经 “内定” 了,我们便可以用 bind
返回一个新的函数。也就是说,bind()
能使一个函数拥有预设的初始参数。这些参数(如果有的话)作为 bind()
的第二个参数跟在 this
后面,之后它们会被插入到目标函数的参数列表的开始位置,传递给绑定函数的参数会跟在它们的后面。

function list() { return Array.prototype.slice.call(arguments); } var
list1 = list(1, 2, 3); // [1, 2, 3] // Create a function with a preset
leading argument var leadingThirtysevenList = list.bind(undefined, 37);
var list2 = leadingThirtysevenList(); // [37] var list3 =
leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]

1
2
3
4
5
6
7
8
9
10
11
function list() {
  return Array.prototype.slice.call(arguments);
}
 
var list1 = list(1, 2, 3); // [1, 2, 3]
 
// Create a function with a preset leading argument
var leadingThirtysevenList = list.bind(undefined, 37);
 
var list2 = leadingThirtysevenList(); // [37]
var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]

order属性

order 属性和旧版本的box-ordinal-group 属性一样控制伸缩项目出现的顺序。

CSS

p:nth-child(1) { order: 2; } p:nth-child(2) { order: 3; } p:nth-child(3)
{ order: 1; }

1
2
3
4
5
6
7
8
9
p:nth-child(1) {
    order: 2;
}
p:nth-child(2) {
    order: 3;
}
p:nth-child(3) {
    order: 1;
}

效果如下:

图片 7

闭包,是真的美

2018/04/11 · JavaScript
· 闭包

原文出处: 张建成   

欢迎评论和star

写这篇文章时的心情是十分忐忑的,因为对于我们今天的主角:闭包,很多小伙伴都写过关于它的文章,相信大家也读过不少,那些文章到底有没有把JS中这个近似神话的东西讲清楚,说实心里,真的有,但为数不多。

写这篇文章的初衷:让所有看到这篇文章的小伙伴都彻彻底底的理解闭包 =>
提高JS水平 => 能够写出更高质量的JS代码。

开文之所以说心情是忐忑的,就是怕达不到我写该文的初衷,但是我有信心同时我也会努力的完成我的目标。如行文中有丝毫误人子弟的陈述,欢迎大家指正,在这感激不尽。

我们开始吧:

相信众多JS的lovers都听说过这句话:闭包很重要但是很难理解

我起初也是这么觉得,但是当我努力学习了JS的一些深层的原理以后我倒觉得闭包并不是那么不好理解,反倒是让我感觉出一种很美的感觉。当我彻底理解闭包的那一刹那,心中油然产生一种十分愉悦感觉,就像**”酒酣尚醉,花未全开”**那种美景一样。

tip

bind 还能做一些有意思的事情。

通常来说,将一个类数组转为数组,我们会用 slice(ie9- 不支持)。参考

var slice = Array.prototype.slice; // slice.apply(arguments); //
slice(arguments, 1);

1
2
3
4
var slice = Array.prototype.slice;
 
// slice.apply(arguments);
// slice(arguments, 1);

bind 能让调用变的更加简单。

// same as “slice” in the previous example var unboundSlice =
Array.prototype.slice; var slice =
Function.prototype.call.bind(unboundSlice); // … slice(arguments); //
slice(arguments, 1);

1
2
3
4
5
6
7
8
// same as "slice" in the previous example
var unboundSlice = Array.prototype.slice;
var slice = Function.prototype.call.bind(unboundSlice);
 
// …
 
slice(arguments);
// slice(arguments, 1);

再举个类似的例子,比如说我们要添加事件到多个节点,for
循环当然没有任何问题,我们还可以 “剽窃” forEach 方法:

Array.prototype.forEach.call(document.querySelectorAll(‘input[type=”button”]’),
function(el){ el.addEventListener(‘click’, fn); });

1
2
3
Array.prototype.forEach.call(document.querySelectorAll(‘input[type="button"]’), function(el){
  el.addEventListener(‘click’, fn);
});

更进一步,我们可以用 bind 将函数封装的更好:

var unboundForEach = Array.prototype.forEach , forEach =
Function.prototype.call.bind(unboundForEach);
forEach(document.querySelectorAll(‘input[type=”button”]’), function
(el) { el.addEventListener(‘click’, fn); });

1
2
3
4
5
6
var unboundForEach = Array.prototype.forEach
  , forEach = Function.prototype.call.bind(unboundForEach);
 
forEach(document.querySelectorAll(‘input[type="button"]’), function (el) {
  el.addEventListener(‘click’, fn);
});

同样类似的,我们可以将 x.y(z) 变成 y(x,z) 的形式:

var obj = { num: 10, getCount: function() { return this.num; } }; var
unboundBind = Function.prototype.bind , bind =
Function.prototype.call.bind(unboundBind); var getCount =
bind(obj.getCount, obj); console.log(getCount()); // 10

1
2
3
4
5
6
7
8
9
10
11
12
var obj = {
  num: 10,
  getCount: function() {
    return this.num;
  }
};
 
var unboundBind = Function.prototype.bind
  , bind = Function.prototype.call.bind(unboundBind);
 
var getCount = bind(obj.getCount, obj);
console.log(getCount());  // 10

再举个栗子。每隔一秒在控制台打印 1-5,看起来是道考察闭包的经典题目。

for(var i = 1; i <= 5; i++) { !function(i) { setTimeout(function() {
console.log(i); }, i * 1000); }(i); }

1
2
3
4
5
6
7
for(var i = 1; i <= 5; i++) {
  !function(i) {
    setTimeout(function() {
      console.log(i);
    }, i * 1000);
  }(i);
}

ES6 下能用 let

for(let i = 1; i <= 5; i++) { setTimeout(function() { console.log(i);
}, i * 1000); }

1
2
3
4
5
for(let i = 1; i <= 5; i++) {
  setTimeout(function() {
    console.log(i);
  }, i * 1000);
}

也可以用 bind,瞬间逼格提升:

for(var i = 1; i <= 5; i++) { setTimeout(console.log.bind(console,
i), i * 1000); }

1
2
3
for(var i = 1; i <= 5; i++) {
  setTimeout(console.log.bind(console, i), i * 1000);
}

Flex 布局教程:语法篇:

闭包的应用

  1. 模块一个模块应该具有私有属性、私有方法和公有属性、公有方法。而闭包能很好的将模块的公有属性、方法暴露出来。
var myModule = (function (window, undefined) { let name = "echo";
function getName() { return name; } return { name, getName }
})(window); console.log( myModule.name ); // echo console.log(
myModule.getName() ); // echo

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-5">
5
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-6">
6
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-7">
7
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-8">
8
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-9">
9
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-10">
10
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-11">
11
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-12">
12
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-13">
13
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87da9603634463-14">
14
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87da9603634463-15">
15
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f6bea87da9603634463-1" class="crayon-line">
var myModule = (function (window, undefined) {
</div>
<div id="crayon-5b8f6bea87da9603634463-2" class="crayon-line crayon-striped-line">
 let name = &quot;echo&quot;;
</div>
<div id="crayon-5b8f6bea87da9603634463-3" class="crayon-line">

</div>
<div id="crayon-5b8f6bea87da9603634463-4" class="crayon-line crayon-striped-line">
 function getName() {
</div>
<div id="crayon-5b8f6bea87da9603634463-5" class="crayon-line">
 return name;
</div>
<div id="crayon-5b8f6bea87da9603634463-6" class="crayon-line crayon-striped-line">
 }
</div>
<div id="crayon-5b8f6bea87da9603634463-7" class="crayon-line">

</div>
<div id="crayon-5b8f6bea87da9603634463-8" class="crayon-line crayon-striped-line">
 return {
</div>
<div id="crayon-5b8f6bea87da9603634463-9" class="crayon-line">
 name,
</div>
<div id="crayon-5b8f6bea87da9603634463-10" class="crayon-line crayon-striped-line">
 getName
</div>
<div id="crayon-5b8f6bea87da9603634463-11" class="crayon-line">
 }
</div>
<div id="crayon-5b8f6bea87da9603634463-12" class="crayon-line crayon-striped-line">
})(window);
</div>
<div id="crayon-5b8f6bea87da9603634463-13" class="crayon-line">
 
</div>
<div id="crayon-5b8f6bea87da9603634463-14" class="crayon-line crayon-striped-line">
console.log( myModule.name ); // echo
</div>
<div id="crayon-5b8f6bea87da9603634463-15" class="crayon-line">
console.log( myModule.getName() ); // echo
</div>
</div></td>
</tr>
</tbody>
</table>

“return”关键字将对象引用导出赋值给myModule,从而应用到闭包。
  1. 延时器(setTimeout)、计数器(setInterval)这里简单写一个常见的关于闭包的面试题。
for( var i = 0; i &lt; 5; i++ ) { setTimeout(() =&gt; { console.log(
i ); }, 1000 \* i) }

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f6bea87dad912221241-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87dad912221241-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87dad912221241-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87dad912221241-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87dad912221241-5">
5
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f6bea87dad912221241-1" class="crayon-line">
for( var i = 0; i &lt; 5; i++ ) {
</div>
<div id="crayon-5b8f6bea87dad912221241-2" class="crayon-line crayon-striped-line">
 setTimeout(() =&gt; {
</div>
<div id="crayon-5b8f6bea87dad912221241-3" class="crayon-line">
 console.log( i );
</div>
<div id="crayon-5b8f6bea87dad912221241-4" class="crayon-line crayon-striped-line">
 }, 1000 * i)
</div>
<div id="crayon-5b8f6bea87dad912221241-5" class="crayon-line">
}
</div>
</div></td>
</tr>
</tbody>
</table>

答案大家都知道:**每秒钟输出一个5,一共输出5次**。

那么如何做到**每秒钟输出一个数,以此为0,1,2,3,4**呢?

我们这里只介绍闭包的解决方法,其他类似块作用域等等的解决方法,我们这里不讨论。



for( var i = 0; i &lt; 5; i++ ) { ((j) =&gt; { setTimeout(() =&gt; {
console.log( j ); }, 1000 \* j) })(i) }

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f6bea87db1013292990-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87db1013292990-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87db1013292990-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87db1013292990-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87db1013292990-5">
5
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87db1013292990-6">
6
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87db1013292990-7">
7
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f6bea87db1013292990-1" class="crayon-line">
for( var i = 0; i &lt; 5; i++ ) {
</div>
<div id="crayon-5b8f6bea87db1013292990-2" class="crayon-line crayon-striped-line">
 ((j) =&gt; {
</div>
<div id="crayon-5b8f6bea87db1013292990-3" class="crayon-line">
 setTimeout(() =&gt; {
</div>
<div id="crayon-5b8f6bea87db1013292990-4" class="crayon-line crayon-striped-line">
 console.log( j );
</div>
<div id="crayon-5b8f6bea87db1013292990-5" class="crayon-line">
 }, 1000 * j)
</div>
<div id="crayon-5b8f6bea87db1013292990-6" class="crayon-line crayon-striped-line">
 })(i) 
</div>
<div id="crayon-5b8f6bea87db1013292990-7" class="crayon-line">
}
</div>
</div></td>
</tr>
</tbody>
</table>

“setTimeout”方法里应用了闭包,使其内部能够记住每次循环所在的词法作用域和作用域链。

由于setTimeout中的回调函数会在当前任务队列的尾部进行执行,因此上面第一个例子中每次循环中的setTimeout回调函数记住的i的值是for循环作用域中的值,此时都是5,而第二个例子记住的i的数为setTimeout的父级作用域自执行函数中的j的值,依次为0,1,2,3,4。
  1. 监听器
var oDiv = document.querySeletor("\#div");
oDiv.addEventListener('click', function() { console.log( oDiv.id );
})

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f6bea87db4035872148-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87db4035872148-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87db4035872148-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f6bea87db4035872148-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f6bea87db4035872148-5">
5
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f6bea87db4035872148-1" class="crayon-line">
var oDiv = document.querySeletor(&quot;#div&quot;);
</div>
<div id="crayon-5b8f6bea87db4035872148-2" class="crayon-line crayon-striped-line">
 
</div>
<div id="crayon-5b8f6bea87db4035872148-3" class="crayon-line">
oDiv.addEventListener('click', function() {
</div>
<div id="crayon-5b8f6bea87db4035872148-4" class="crayon-line crayon-striped-line">
 console.log( oDiv.id );
</div>
<div id="crayon-5b8f6bea87db4035872148-5" class="crayon-line">
})
</div>
</div></td>
</tr>
</tbody>
</table>

=- 关于闭包,我觉得我说清楚了,你看清楚了吗?留言告诉我吧 -=

如果你觉得写的还不是很烂,请关注我的
github
吧,让我们一起成长。。。

1 赞 3 收藏
评论

图片 8

bind 简介

Ok,今天要讲的正是 bind。关于 bind,可以先移步楼主以前写的文章
ECMAScript 5(ES5) 中 bind
方法简介备忘,有个基本的概念。

bind() 方法会创建一个新函数,当这个新函数被调用时,它的 this 值是传递给
bind() 的第一个参数, 它的参数是 bind() 的其他参数和其原本的参数。

语法是这样样子的:

fun.bind(thisArg[, arg1[, arg2[, …]]])

1
fun.bind(thisArg[, arg1[, arg2[, …]]])
  • thisArg 当绑定函数被调用时,该参数会作为原函数运行时的 this
    指向。当使用 new 操作符调用绑定函数时,该参数无效。
  • arg1, arg2, …
    (可选)当绑定函数被调用时,这些参数加上绑定函数本身的参数会按照顺序作为原函数运行时的参数。

CSS3弹性伸缩布局(二)——flex布局

2015/09/02 · CSS ·
CSS3

原文出处: 郭锦荣   

上一篇博客《CSS3弹性伸缩布局(一)——box布局》介绍了旧版本的box布局,而这篇博客将主要介绍最新版本的flex布局的基础知识。

新版本简介

新版本的Flexbox模型是2012年9月提出的工作草案,这个草案是由W3C
推出的最新语法。这个版本立志于指定标准,让新式的浏览器全面兼容,在未来浏览器的更新换代中实现统一。

闭包的艺术性

我相信这个世界上最美的事物往往就存在我们身边,通常它并不是那么神秘,那么不可见,只是我们缺少了一双发现美的眼睛。

生活中,我们抽出一段时间放慢脚步,细细品味我们所过的每一分每一秒,会收获到生活给我们的另一层乐趣。

闭包也一样,它不是很神秘,反而是在我们的程序中随处可见,当我们静下心来,品味闭包的味道,发现它散发出一种艺术的美,朴实、精巧又不失优雅。

图片 9

细想,在我们作用域气泡模型中,作用域链让我们的内部bar气泡能够”看到”外面的世界,而闭包则让我们的外部作用域能够”关注到”内部的情况成为可能。可见,只要我们愿意,内心世界和外面世界是可以相通的

发表评论

电子邮件地址不会被公开。 必填项已用*标注

标签:, ,
网站地图xml地图