在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
标签：至少1个，最多5个
es6初步深入学习
es6前言（只作了解就好）
ECMAScript和JavaScript的关系
ECMAScript和JavaScript的关系是，前者是后者的规格，后者是前者的一种实现（另外的ECMAScript方言还有Jscript和ActionScript）。
检测node环境对ES6的支持情况
阮一峰写了一个ES-Checker模块，用来检查各种运行环境对ES6的支持情况。运行下面的命令，可以查看你正在使用的Node环境对ES6的支持程度。
sudo npm i -g es-checker
es-checker
babel转码器
ES6转码器，可以将ES6代码转为ES5代码，从而在现有环境执行。es6。
babel stage
在es6标准出来之前，大家都会参与讨论，把各自觉得好的语法加进去，便有了很多阶段（准标准、草案、提案..）。stage-0是一个提案，里面基本包括大家讨论的所有内容，stage-1 -- stage-3以此类推，stage-3基本确定要进入es6了。所以使用webpack的同学会看到，安装的依赖基本都是babel-preset-stage-0。
babel-polyfill
本人之前开发中遇到过一个问题，array的includes方法（string也有），当时运行在chrome47环境下，整个页面打不开，报错（babel includes can not a function），在chrome52环境下支持。解决办法--安装。最后在你的文件中import 'babel-polyfill'。
Babel默认只转换新的JavaScript句法（syntax），而不转换新的API，比如Iterator、Generator、Set、Maps、Proxy、Reflect、Symbol、Promise等全局对象，以及一些定义在全局对象上的方法（比如Object.assign）都不会转码。举例来说，ES6在Array对象上新增了Array.from方法。Babel就不会转码这个方法。如果想让这个方法运行，必须使用babel-polyfill，为当前环境提供一个垫片。
let和const
let用于声明变量，const用于声明常量。但是聊这个之前，我们还是简单提提老生常谈的问题吧---scope。
块级作用域
在es5中是不存在块级作用域的，一般我们听得比较多的是函数作用域（定义在函数中的参数和变量在函数外部是不可见的）。
function getVal(boo) {
if (boo) {
var val = 'red'
return val
// 这里可以访问 val
return null
// 这里也可以访问 val
那么在es5中如何使用块级作用域呢？js中在一个函数中定义的变量，当这个函数调用完后，变量会被销毁，我们可以利用这种特性（闭包，the most important feature!!）。
function caniuse() {
for(var i=0;i&10;i++){}
console.log(i); //10
caniuse();
function caniuse2() {
(function() {
for(var i=0;i&10;i++){}
console.log(i) //i is not defined
caniuse2()
在es6中，任何一对花括号中（for,if）的语句集都属于一个块，在这之中定义的所有变量在代码块外都是不可见的，我们称之为块级作用域。
function getVal(boo) {
if (boo) {
let val = 'red'
return val
// 这里访问不到 val
return null
// 这里也访问不到 val
有了es6，上面闭包的写法我们用es6可以不需要用到立即执行函数。
for(let i = 0; i & 10; i++){}
let声明的变量只在他的代码块内有效
let i = 9;
console.log(i) //9
console.log(i) //ReferenceError: i is not defined
function test1() {
for(var i = 0; i & 10; i++) {
setTimeout(function() {
console.log(i) //10次10
function test2() {
for(let i = 0; i & 10; i++) {
setTimeout(function() {
console.log(i) //0-9
function test3() {
for(var i = 0; i & 10; i++) {
(function(i) {
setTimeout(function() {
console.log(i) //0-9
不存在变量提升
脚本开始运行时，变量i已经存在了，但是没有值，所以会输出undefined。变量ii用let命令声明，不会发生变量提升。这表示在声明它之前，变量ii是不存在的，这时如果用到它，就会抛出一个错误。
console.log(i) //undefined
console.log(ii) //ReferenceError: ii is not defined
还有一些比较不容易发现的暂时性死区
function test1(y = 1, x = y) {
console.log(x, y) // 1 1
function test2(x = y, y = 1) {
console.log(x, y) //error
不允许重复声明
function () {
let a = 10;
var a = 1;
用const声明，常量的值就不能改变。
const一旦声明变量，就必须立即初始化，不能留到以后赋值。
只所在的块级作用域内有效。（见let）
不能变量提升，存在暂时性死区，只能在声明的位置后面使用。（见let）
在一个scope中不可重复declare。
// SyntaxError: Missing initializer in const declaration
对于复合类型的变量，变量名不指向数据，而是指向数据所在的地址。const命令只是保证变量名指向的地址不变，并不保证该地址的数据不变，所以将一个对象声明为常量必须非常小心。
const foo = {};
foo.prop = 123;
foo = {}; // TypeError: "foo" is read-only
const a = [];
a.push('Hello'); // 可执行
a.length = 0;
a = ['Dave'];
const foo = Object.freeze({});
// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;
ES5只有两种声明变量的方法：var命令和function命令。ES6除了添加let和const命令，另外两种声明变量的方法：import命令和class命令。所以，ES6一共有6种声明变量的方法。
Iterator（简单说下，下次再仔细补充）
有三类数据结构原生具备Iterator接口：数组、某些类似数组的对象、Set和Map结构。Iterator是一种机制，为不同的数据结构提供可遍历操作。可遍历结构，我的理解是可以执行for...of。
Iterator作用：
为各种数据结构，提供一个统一的、简便的访问接口
使得数据结构的成员能够按某种次序排列
ES6创造了一种新的遍历命令for...of循环，Iterator接口主要供for...of消费。
Iterator的遍历过程
var it = makeIterator(['a', 'b']);
it.next() // { value: "a", done: false }
it.next() // { value: "b", done: false }
it.next() // { value: undefined, done: true }
function makeIterator(array) {
var nextIndex = 0;
next: function() {
return nextIndex & array.length ?
{value: array[nextIndex++]} :
{done: true};
let arr = [2,3,4,,7,8]
for(let val of arr) {
console.log(val) //2,3,4,undefined,7,8
for(let k in arr) {
console.log(k) //"0" "1" "2" "4" "5",下标都是字符串哦
console.log(arr["2"]) //4
let arr2 = {0: 'a', 1: 'b', 3: 'c'}
for(let key of arr2) {
console.log(key, arr2[key]) //arr2[Symbol.iterator] is not a function
for(let key in arr2) {
console.log(key, arr2[key]) //"0" "a"
Iterator的使用场合
解构赋值（下一章）
扩展运算符（spread, 方便，使用频率很高。。。spread arguments in function）。
let [a, ...c] = [3, 5, 6, 7, 7, 9]
console.log(a) //3
console.log(c) //[5, 6, 7, 7, 9]
let [e, ...f, g] = [3, 5, 6, 7, 7, 9]
console.log(e) //3
console.log(f) //[5, 6, 7, 7, 9]
console.log(g) //error
var str = 'hello';
[...str] //
['h','e','l','l','o']
let arr = ['b', 'c'];
['a', ...arr, 'd'] // ['a', 'b', 'c', 'd']
let generator = function* () {
yield* [2, 4];
let iterator = generator()
console.log(iterator.next()) //{"done": false, "value": 1}
console.log(iterator.next()) //{"done": false, "value": 2}
console.log(iterator.next()) //{"done": false, "value": 4}
console.log(iterator.next()) //{"done": true, "value": 5}
其他(for...of, Array.form(), Map(), Set())
变量的解构赋值（Destructuring）
解构赋值——我的字面理解是先分解结构，再匹配等号两边相对应的结构，如果解构成功给每个相对应地变量赋值，一般情况下如若不成功，就给对应的变量赋值undefined。
只要等号两边的模式相同，解构完全匹配。左边的变量就会被赋予对应的值。
let [a, ...c] = [3, 5, 6, 7, 7, 9]
console.log(a) //3
console.log(c) //[5, 6, 7, 7, 9]
let [x, y, ...z] = ['a'];
y // undefined
不完全解构
等号右边的解构匹配左边的，但是还有多余的值。如果右边不具备Iterator接口，解构的过程中会报错。
let [a, [b], d] = [1, [2, 3], 4];
let [foo] = 1;
let [foo] =
let [foo] = NaN;
let [foo] =
let [foo] =
let [foo] = {};
之前写redux的时候，经常会用到默认值。
export function receiveCustomers({source=null, origin=null, start_at=null, end_at=null, keyword=null}) {
type: types.CUSTOMERS_QUERY_CHANGE,
null/undefined
var [x = 1] = [undefined];
var [x = 1] = [null];
function aaa() {console.log(1)}
let [a = aaa()] = [1] //a=1
变量不能提升
let [x = y, y = 1] = [];
// ReferenceError
这个灰常常用。一般用法就行，不需要很怪异的写法，可读性差。总结几点注意事项：
如果要将一个已经声明的变量用于解构赋值，必须非常小心。
默认值生效的条件是，对象的属性值严格等于undefined。
// 错误的写法
{x} = {x: 1};
// SyntaxError: syntax error
var {x = 3} = {x: undefined};
var {x = 3} = {x: null};
对象的扩展
属性的简洁表示
这个比较常用，之前写vuex的时候有使用到。用过vuex/redux的同学应该不会陌生
import {fn1, fn2} from 'action'
//action.js里面有两个方法fn1,fn2，最后 export {fn1,fn2}
//等同于export{fn1: fn1, fn2: fn2}
const { dispatch } = this.props
//等同于const dispatch = this.props.dispatch
actions: {
actions: {
function f(x, y) {
return {x, y};
function f(x, y) {
return {x: x, y: y};
f(1, 2) // Object {x: 1, y: 2}
方法的简写
handleText = e =& {
this.setState({
inputValue: e.target.value
handleText: function(e) {
Object.assign
deep clone and shallow clone
JavaScript存储对象都是存地址的，所以浅复制会导致 obj 和 obj1 指向同一块内存地址，大概的示意图如下。而深复制一般都是开辟一块新的内存地址，将原对象的各个属性逐个复制出去。
let obj = {0: "a", 1: "b", 2: "c"}
let deepObj = JSON.parse(JSON.stringify(obj))//is not a really deep clone, but it works.
let shallowObj = obj
obj[3] = 'd'
console.log(deepObj) //{0: "a", 1: "b", 2: "c"}
console.log(shallowObj) //{0: "a", 1: "b", 2: "c", 3: "d"}
console.log(obj) //{0: "a", 1: "b", 2: "c", 3: "d"}
JSON.parse(JSON.stringify(obj))这样的使用方式并不是真正的深拷贝，因为它会丢失一些东西，一些obj的内在property之类的，比如
obj_test1 = {
return this.a
这样的一个obj，你用上面的方式会丢掉get_a，如果你定义一些prototype，也会丢失掉，或者如果包含一些dom元素之类的。但是我们多数时候只是用它来复制数据，不关心对象的方法之类的东西，这样的话是够用的。
对象拷贝（copy）
Object.assign方法实行的是浅拷贝，而不是深拷贝，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。之前自己的一个疑惑
let obj = {0: "a", 1: "b", 2: "c"}
let objClone = Object.assign({}, obj)
obj[3] = 'd'
console.log(objClone) // {0: "a", 1: "b", 2: "c"} why the same, but not change
Javascript has five primitive data types:
Anything that doesn’t belong to any of these five primitive types is considered an object.
primitive types are passed by value, while objects passed by reference.
a = {a: 1, b: 2, c: 3, d: {aa: 11, bb: 22}}a1 = Object.assign({}, a, {a: 2})a1.d.aa = 'i am shllow copy'第二行是浅拷贝，a拷贝到a1了，并且把property a的值改成2了
(你觉得a.a会变成2么，为什么?)第三行把a1.d这个object理得aa这个property改了
(你觉得a.d.aa也会改么，为什么?)
合并对象 (merge)
Object.keys && Object.value
ES5引入了Object.keys方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的key。Object.values返回value。
不得不说，这是我从没仔细看过的一部分，写react的时候都是三板斧套路。。。特意留意一下super()。ES5的继承，实质是先创造子类的实例对象this，然后再将父类的方法添加到this上面（Parent.apply(this)）。es6中先创造父类的实例对象this（所以必须先调用super方法），然后再用子类的构造函数修改this。
class Teachers extends React.Component {
constructor(props, context) {
super(props, context)
componentDidMount(){
const { siteId, dispatch } = this.props
if (siteId) {
dispatch(fetchTeachersList(siteId))
componentWillReceiveProps(nextProps) {
const { siteId, dispatch } = this.props
if (nextProps.siteId !== siteId) {
dispatch(fetchTeachersList(nextProps.siteId))
export default Teachers
搭配Object.assign()
class Point {
constructor(){
Object.assign(Point.prototype, {
toString(){},
toValue(){}
不存在变量提升
new Foo(); // ReferenceError
class Foo {}
class表达式
Class表达式，可以写出立即执行的Class。
let person = new class {
constructor(name) {
this.name =
sayName() {
console.log(this.name);
}('张三');
person.sayName(); // "张三"
this指向和箭头函数
箭头函数很方便，解决了之前es5遗留下来的问题（继承，this作用域）。箭头函数没有它自己的this值，箭头函数内的this值继承自外围作用域。
//es5中， var self =这样的代码你肯定常见，es6箭头函数中不用鸟
var obj = {
field: 'hello',
getField: () =& {
console.log(this.field)
obj.getField() // undefined,这时this是window,
var obj = {
field: 'hello',
getField(){
console.log(this.field)
obj.getField() // hello,
自己常用的拓展
let arr = [1,2,3,4,5,6]
let arr2 = arr.reduce( (init, prev, index) =& {init.push(prev*prev); return init}, [] )
console.log(arr2) //[1,4,9,16,25,36]
想起之前写的数组转对象的方法
警告 yield 关键字通常不能在箭头函数中使用（except when permitted within functions further nested within it）。因此，箭头函数不能用作Generator函数。
js历史上没有标准的模块化。在ES6之前，社区制定了一些模块加载方案，最主要的有CommonJS和AMD两种。前者用于服务器，后者用于浏览器。但是这些都只能在运行时起作用，es6的模块化可以在编译时就能确定模块的依赖关系，以及输入和输出的变量。
模块功能主要由两个命令构成：export和import。先抛出一个问题:以下两行代码有什么区别？
import {message, menu} from 'antd'
import message from 'antd/lib/message'
对外的接口名与模块内部变量的关系
export对外的接口名与模块内部变量之间，建立了一一对应的关系。当export一个function时，语句输出的接口，与其对应的值是动态绑定关系，即通过该接口，可以取到模块内部实时的值。
export 1; //error
export var m = 1 //right
var m = 1;
export m//error
export {m} //right
注意 import命令具有提升效果，会提升到整个模块的头部，首先执行。所以在文件中的任意位置，exort也一样，不过利于可读性，还是import写在文件开头，export写在文件结尾好点。
注意 import命令接受一个对象（用大括号表示），里面指定要从其他模块导入的变量名。大括号里面的变量名，必须与被导入模块（profile.js）对外接口的名称相同。
import {message, menu} from 'antd'
import message from 'antd/lib/message'
所以这之间的区别就是前者中括号里的变量名要与export出的接口名一致，后者message是随意起的名字，可以不与export出来的变量名保持一致，它代表export default出来的接口。export default命令用于指定模块的默认输出。显然，一个模块只能有一个默认输出，因此export deault命令只能使用一次。所以，import命令后面才不用加大括号，因为只可能对应一个方法。本质上，export default就是输出一个叫做default的变量或方法，然后系统允许你为它取任意名字。
模块的整体加载
import * as circle from './circle';
console.log('圆面积：' + circle.area(4));
console.log('圆周长：' + circle.circumference(14));
2 收藏&&|&&9
你可能感兴趣的文章
3 收藏，219
1 收藏，543
1 收藏，389
分享到微博？
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。js效果在浏览器上显示不出来?_百度知道
js效果在浏览器上显示不出来?
貌似我电脑的浏览器都显示不了js，在dreamweaver中编写的js代码运行都没反应？？？
我有更好的答案
1、查看是否IE的安全里面禁止了JS的运行：将工具=&internet选项==&高级=&禁止脚本调试去勾,显示脚本显示提示打上勾。2、看是否装了杀毒软件禁止了用程序打开窗口,检查设置。3、查看jsp页面是否引用了此js文件，且js文件路径是否正确。4、检查js文件代码是否有误，或代码中是否含有中文字符或中文符号等。5、查看jsp与js交互的代码是否能找到值和传送值等。
采纳率：84%
来自团队：
最大的可能是你的js引用有误，或你的写法不兼容浏览器。建议你换个浏览器试试。或把写的代码发上来。大家来助你。
我电脑上的IE和火狐效果都一样没反应，代码太多了，我运行的是文字跟随鼠标的代码希望能帮我解决，谢谢
please telll my your Q number,so I can help you at once.
本回答被提问者采纳
script&gt，能的话，就是代码问题、 一般浏览器都支持JS，可能部分JS的一些代码不支持;标签中间，把你原本写的JS 全部删掉 就写个 alert(1)，运行看能不能弹出对话框代码错误浏览器问题最简单的是，在&lt
本回答被网友采纳
为您推荐：
其他类似问题
浏览器的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。如何看待Chrome对ES6的支持只有65%，比Firefox还低_百度知道
如何看待Chrome对ES6的支持只有65%，比Firefox还低
我有更好的答案
所以总体来说，这两个浏览器在特性支持上基本上在持平状态，Edge13貌似现在也还未实现，或者是实现单元测试里的mock，node开发者很多都用coffeescript或者typescript去了……然后是解构，至今还未实现.6的时候加入的唯一ES6新特性.js绑了V8已经导致了极难替换的局面，倒不是因为语言的引擎难以替换，由于我常用node，可惜的是不知道什么原因。然后是最近几个版本的作为：先是实现个三点号实参调用.args){}这种，说来奇怪，在chrome的某一个版本上;@@iterator&quot，随后一直到V8 3;]=function(){}的迭代器。所以ES6的标准，已经过了这么长的时间了，而V8的API变化很快，然后V8就是任性，开发蓝图上也对这个只字不提了，比如说实现php那种__get__或者是ruby的method_missing，它猛地实现了箭头函数这个特性，然后下一个版本直接取消了，不得不说，v8对于ES6特性实现，是慢于edge和firefox，也就只能和safari家的JAVASCRIPT CORE比一比了，也就是func(.，也就是function func(，然后V8 4.7加入的是三点号形参定义，然而参数定义默认值这些特性：解构，这个解构语法就是FF那帮人造出来的，所以他们实现的最早，而其他浏览器也跟进的最慢，导致在ES4标准制定的时候冲突不断，firefox丢分在于没有支持class关键字，而chrome的V8，却一直比较反复，特别是像Proxy这种特性，V8在大约一年半以前临时实现过一种，用了两个版本以后.js，所以对V8很关注。但FF也有Edge13没有支持的一些特性，典型的比如：函数定义时的参数默认值，&，这个在V8 4。其他FF相比于edge13丢分的在于内置对象的子类支持..，经常去v8的官方blog上逛逛.5的时候才正式加上去，这个离其他浏览器实现箭头函数，突然彻底下架，然后一年多以来，这个Proxy的特性就一直没加回来，包括计划列表里都没有这玩意。需要指出的是，题图里关于ES6的支持对比，让C/C++扩展能顺应V8那种快速变更API的流氓作法，比如说迭代器，现在可以给对象指定个Symbol，所以最后才给下一代ES定了个harmony（和谐）的代号。Firefox在ES规范之前就已经做了很多私有的语法制定，在很多场景上都能省事的，已经差了一年时间了.iterator的key来实现一个迭代器，而FF很早就已经实现了形如obj[&quot!--var a =1;--&这种HTML注释JS的手段等等。更何况FF还有一个很省事的语法糖，而是周边的大量类库难以替换..arr)，ES6的很大推动力来自于FF那帮JS元老（包括JS之父Brendan Eich等）当年ES4难产，主要就是因为FF帮那边的人对语法改动太过激进，就可以覆盖到90%了。=================然后再来说说chrome和chrome家的v8，所以node这边才会有一个nan的项目，而Edge13却完整支持了ES6 class的语法糖，包括super。其实class关键字一直存在于firefox的夜间版上面，就是形如class A extends Function这种，这个没的说，Edge13确实是领先其他浏览器，估计不知道哪年能实现。然而node，FF如果把class从夜间版弄到正式版的话，主要是因为。首先是之前去掉后一直不加的Proxy，这个Proxy可以做很多魔法效果。然后是箭头函数，firefox的SpiderMonkey是实现最迅速的，FF也没有把class移植到正式版上面首先要指出的就是FireFox在对ES6的支持上一直都比Chrome浏览器要领先
采纳率：93%
来自团队：
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。ES6 中没有函数申明的语法了吗？ - V2EX
ES6 中没有函数申明的语法了吗？
14:25:39 +08:00 &tedd
在 ES5 中，我经常用函数申明 function declaration 来申明函数
function myFunc() {}
这样的好处是我可以把函数的实现写在最下方，这样让程序更易读，看了前面就知道大概逻辑了，如果需要再往下看具体的小函数的实现
doSomething();
doSomethingElse();
function doSomething() {}
function doSomethingElse() {}
如果用 function expression 的话，就需要将 expression 写在调用的前面
var doSomething = function() {}
var doSomethingElse = function() {}
doSomething();
doSomethingElse();
但 ES6 中好像只支持 function declaration 了...
let doSomething = ()=& {}
1688 次点击所在节点 &
fy 14:29:17 +08:00有的啊， () =& {} 是新功能，不是替代旧功能。
而且 () =& {} 函数和 function () {} 的含义也不一样，是两种用途
tedd 14:35:15 +08:00哦哦，表达不是特别清楚， ES6 中可以用之前一样的语法来 function declaration ，我想问的是，在 ES6 中有什么简便的语法来做 function declaration 吗？
xingo 14:36:57 +08:00ES2015 兼容 ES5 ， function a() {} 还是他原来的意思
var a = function (){}
a 声明提前，但赋值是到运行这条语句的时候才会赋值， ES5
let a = () =& {}
首先 let 是声明不会提前，其次赋值也是到运行这条语句的时候才会赋值 ，箭头函数 /let 是 ES2015 新增内容
var a = () =& {}
那和你说的 var a = function(){} 才类似呢
xingo 14:38:46 +08:00我觉得应该没有？有的话请楼下 at 我，谢谢！
DOLLOR 14:58:47 +08:00ES6 的 arrow function 不是用来“取代” ES5 的普通函数的，其设计初衷是简化 lambda expression 的写法。
所以，不要想当然地恨不得把所有的 function declaration 都换成 arrow function 。该用 function declaration 时还得老老实实地用 function declaration 。
fy 18:36:31 +08:00@ 没有简便语法，和原来一样。
箭头函数的 this 是外部的 this ，这个在 callback 的场景非常明显！不用保存上级的 this 引用。
当然特定时候也有必须要用 this 就不能用箭头函数了。
ksmagi 20:25:50 +08:00arrow function == (function () {}).bind(this)
fytriht 21:26:07 +08:00function () {} 已经很简单了吧
chnwillliu 21:32:45 +08:00在对象字面量和 class 中声明函数属性，可以直接括号，不需要 function 关键字。所以大部分场合 function 关键字是可以被干掉了。
tedd 21:47:03 +08:00@ 请问你指的是这样写吗？也不需要 let 和 const ？`something = () =& { }`
kamikat 01:05:08 +08:00@ 说的是
bombless 01:33:10 +08:00es6 加了个在字面量定义函数的功能也挺方便
+{ a() {} }.a()
bombless 01:33:44 +08:00噗，才看到上面已经说了
SoloCompany 01:37:15 +08:00严格来说叫 lambda
实现上来说箭头函数是匿名函数
都叫做匿名函数了，何来声明？
bombless 01:46:10 +08:00其实现在很多人的习惯是写 const f = () =& 0 这样的，我也不知道为什么，可能是不喜欢声明提前吧
felix389 13:50:13 +08:00现在的（）=& {}比以前方便了啊，要是还是 function declaration 就继续用
第 1 页 ／ 共 1 页&
这是一个专为移动设备优化的页面（即为了让你能够在 Google 搜索结果里秒开这个页面），如果你希望参与 V2EX 社区的讨论，你可以继续到
上打开本讨论主题的完整版本。
是创意工作者们的社区，是一个分享自己正在做的有趣事物、交流想法，可以遇见新朋友甚至新机会的地方。
is a community of developers, designers and creative people.