登录以解锁更多InfoQ新功能
获取更新并接收通知
给您喜爱的内容点赞
关注您喜爱的编辑与同行
966,690 七月 独立访问用户
语言 & 开发
架构 & 设计
文化 & 方法
您目前处于：
深入浅出ES6（十四）：let和const
深入浅出ES6（十四）：let和const
Jason Orendorff
7&他的粉丝
22&他的粉丝
日. 估计阅读时间:
关注大数据平台技术选型、搭建、系统迁移和优化的经验。
Author Contacted
语言 & 开发
492 他的粉丝
架构 & 设计
1111 他的粉丝
1 他的粉丝
深入浅出ES6
80 他的粉丝
ECMAScript
0 他的粉丝
JavaScript
73 他的粉丝
2 他的粉丝
249 他的粉丝
相关厂商内容
告诉我们您的想法
允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p
当有人回复此评论时请E-mail通知我
这一段似乎不完整
那么请问树上的毛毛虫在哪？
新项目应用
特意注册来好评
允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p
当有人回复此评论时请E-mail通知我
允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p
当有人回复此评论时请E-mail通知我
赞助商链接
InfoQ每周精要
订阅InfoQ每周精要，加入拥有25万多名资深开发者的庞大技术社区。
文化 & 方法
架构 & 设计
语言 & 开发
InfoQ.com及所有内容，版权所有 ©
C4Media Inc. InfoQ.com 服务器由 提供, 我们最信赖的ISP伙伴。
极客邦控股（北京）有限公司
找回密码....
InfoQ账号使用的E-mail
关注你最喜爱的话题和作者
快速浏览网站内你所感兴趣话题的精选内容。
内容自由定制
选择想要阅读的主题和喜爱的作者定制自己的新闻源。
设置通知机制以获取内容更新对您而言是否重要
注意：如果要修改您的邮箱，我们将会发送确认邮件到您原来的邮箱。
使用现有的公司名称
修改公司名称为：
公司性质：
使用现有的公司性质
修改公司性质为:
使用现有的公司规模
修改公司规模为：
使用现在的国家
使用现在的省份
Subscribe to our newsletter?
Subscribe to our industry email notices?
通过订阅此邮件，我们可能会根据您以往感兴趣的主题向您发送内容。关于更多详情，请参阅我们的。
我们发现您在使用ad blocker。
我们理解您使用ad blocker的初衷，但为了保证InfoQ能够继续以免费方式为您服务，我们需要您的支持。InfoQ绝不会在未经您许可的情况下将您的数据提供给第三方。我们仅将其用于向读者发送相关广告内容。请您将InfoQ添加至白名单，感谢您的理解与支持。Javascript 严格模式详解 - 阮一峰的网络日志
Javascript 严格模式详解
除了正常运行模式，ECMAscript 5添加了第二种运行模式：（strict mode）。顾名思义，这种模式使得Javascript在更严格的条件下运行。
设立"严格模式"的目的，主要有以下几个：
- 消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为;
- 消除代码运行的一些不安全之处，保证代码运行的安全；
- 提高编译器效率，增加运行速度；
- 为未来新版本的Javascript做好铺垫。
"严格模式"体现了Javascript更合理、更安全、更严谨的发展方向，包括IE 10在内的主流浏览器，都已经它，许多大项目已经开始全面拥抱它。
另一方面，同样的代码，在"严格模式"中，可能会有不一样的运行结果；一些在"正常模式"下可以运行的语句，在"严格模式"下将不能运行。掌握这些内容，有助于更细致深入地理解Javascript，让你变成一个更好的程序员。
本文将对"严格模式"做详细介绍。
二、进入标志
进入"严格模式"的标志，是下面这行语句：
"use strict";
老版本的浏览器会把它当作一行普通字符串，加以忽略。
三、如何调用
"严格模式"有两种调用方法，适用于不同的场合。
3.1 针对整个脚本文件
将"use strict"放在脚本文件的第一行，则整个脚本都将以"严格模式"运行。如果这行语句不在第一行，则无效，整个脚本以"正常模式"运行。如果不同模式的代码文件合并成一个文件，这一点需要特别注意。
(严格地说，只要前面不是产生实际运行结果的语句，"use strict"可以不在第一行，比如直接跟在一个空的分号后面。)
&script&
"use strict";
console.log("这是严格模式。");
&/script&
&script&
console.log("这是正常模式。");kly, it's almost 2 years ago now. I can admit it now - I run it on my school's network that has about 50 computers.
&/script&
上面的代码表示，一个网页中依次有两段Javascript代码。前一个script标签是严格模式，后一个不是。
3.2 针对单个函数
将"use strict"放在函数体的第一行，则整个函数以"严格模式"运行。
function strict(){
"use strict";
return "这是严格模式。";
function notStrict() {
return "这是正常模式。";
3.3 脚本文件的变通写法
因为第一种调用方法不利于文件合并，所以更好的做法是，借用第二种方法，将整个脚本文件放在一个立即执行的匿名函数之中。
(function (){
"use strict";
// some code here
})();
四、语法和行为改变
严格模式对Javascript的语法和行为，都做了一些改变。
4.1 全局变量显式声明
在正常模式中，如果一个变量没有声明就赋值，默认是全局变量。严格模式禁止这种用法，全局变量必须显式声明。
"use strict";
v = 1; // 报错，v未声明
for(i = 0; i < 2; i++) { // 报错，i未声明
因此，严格模式下，变量都必须先用var命令声明，然后再使用。
4.2 静态绑定
Javascript语言的一个特点，就是允许"动态绑定"，即某些属性和方法到底属于哪一个对象，不是在编译时确定的，而是在运行时（runtime）确定的。
严格模式对动态绑定做了一些限制。某些情况下，只允许静态绑定。也就是说，属性和方法到底归属哪个对象，在编译阶段就确定。这样做有利于编译效率的提高，也使得代码更容易阅读，更少出现意外。
具体来说，涉及以下几个方面。
（1）禁止使用with语句
因为with语句无法在编译时就确定，属性到底归属哪个对象。
"use strict";
with (o){ // 语法错误
v = 2;
（2）创设eval作用域
正常模式下，Javascript语言有两种变量作用域（scope）：全局作用域和函数作用域。严格模式创设了第三种作用域：eval作用域。
正常模式下，eval语句的作用域，取决于它处于全局作用域，还是处于函数作用域。严格模式下，eval语句本身就是一个作用域，不再能够生成全局变量了，它所生成的变量只能用于eval内部。
"use strict";
var x = 2;
console.info(eval("var x = 5; x")); // 5
console.info(x); // 2
4.3 增强的安全措施
（1）禁止this关键字指向全局对象
function f(){
return !
// 返回false，因为"this"指向全局对象，"!this"就是false
function f(){
"use strict";
return !
// 返回true，因为严格模式下，this的值为undefined，所以"!this"为true。
因此，使用构造函数时，如果忘了加new，this不再指向全局对象，而是报错。
function f(){
"use strict";
this.a = 1;
f();// 报错，this未定义
（2）禁止在函数内部遍历调用栈
function f1(){
"use strict";
f1.
f1. // 报错
4.4 禁止删除变量
严格模式下无法删除变量。只有configurable设置为true的对象属性，才能被删除。
"use strict";
// 语法错误
var o = Object.create(null, {'x': {
value: 1,
configurable: true
delete o.x; // 删除成功
4.5 显式报错
正常模式下，对一个对象的只读属性进行赋值，不会报错，只会默默地失败。严格模式下，将报错。
"use strict";
var o = {};
Object.defineProperty(o, "v", { value: 1, writable: false });
o.v = 2; // 报错
严格模式下，对一个使用getter方法读取的属性进行赋值，会报错。
"use strict";
var o = {
get v() { return 1; }
o.v = 2; // 报错
严格模式下，对禁止扩展的对象添加新属性，会报错。
"use strict";
var o = {};
Object.preventExtensions(o);
o.v = 1; // 报错
严格模式下，删除一个不可删除的属性，会报错。
"use strict";
delete Object. // 报错
4.6 重名错误
严格模式新增了一些语法错误。
（1）对象不能有重名的属性
正常模式下，如果对象有多个重名属性，最后赋值的那个属性会覆盖前面的值。严格模式下，这属于语法错误。
"use strict";
var o = {
p: 1,
p: 2
}; // 语法错误
（2）函数不能有重名的参数
正常模式下，如果函数有多个重名的参数，可以用arguments[i]读取。严格模式下，这属于语法错误。
"use strict";
function f(a, a, b) { // 语法错误
4.7 禁止八进制表示法
正常模式下，整数的第一位如果是0，表示这是八进制数，比如0100等于十进制的64。严格模式禁止这种表示法，整数第一位为0，将报错。
"use strict";
var n = 0100; // 语法错误
4.8 arguments对象的限制
arguments是函数的参数对象，严格模式对它的使用做了限制。
（1）不允许对arguments赋值
"use strict";
arguments++; // 语法错误
var obj = { set p(arguments) { } };
// 语法错误
try { } catch (arguments) { }
// 语法错误
function arguments() { }
// 语法错误
var f = new Function("arguments", "'use strict'; return 17;");
// 语法错误
（2）arguments不再追踪参数的变化
function f(a) {
a = 2;
return [a, arguments[0]];
f(1); // 正常模式为[2,2]
function f(a) {
"use strict";
a = 2;
return [a, arguments[0]];
f(1); // 严格模式为[2,1]
（3）禁止使用arguments.callee
这意味着，你无法在匿名函数内部调用自身了。
"use strict";
var f = function() { return arguments. };
f(); // 报错
4.9 函数必须声明在顶层
将来Javascript的新版本会引入"块级作用域"。为了与新版本接轨，严格模式只允许在全局作用域或函数作用域的顶层声明函数。也就是说，不允许在非函数的代码块内声明函数。
"use strict";
if (true) {
function f() { } // 语法错误
for (var i = 0; i < 5; i++) {
function f2() { } // 语法错误
4.10 保留字
为了向将来Javascript的新版本过渡，严格模式新增了一些保留字：implements, interface, let, package, private, protected, public, static, yield。
使用这些词作为变量名将会报错。
function package(protected) { // 语法错误
"use strict";
// 语法错误
此外，ECMAscript第五版本身还规定了另一些保留字（class, enum, export, extends, import, super），以及各大浏览器自行增加的const保留字，也是不能作为变量名的。
五、参考链接
- Dr. Axel Rauschmayer，
- Douglas Crockford,
一、问题的由来
学懂 JavaScript 语言，一个标志就是理解下面两种写法，可能有不一样的结果。
JavaScript 程序越来越复杂，调试工具的重要性日益凸显。客户端脚本有浏览器，Node 脚本怎么调试呢？下面是我对ES6和古老的JS(ES3)一些数组操作的总结，附带了一些我曾经用上的。
map处有待更内容。
贴一下有借鉴的网站：
首先先来讲讲ES3的数组方法
split() 方法用于把一个字符串分割成字符串数组。
为什么我们要这要转换呢，比如下文中我们的splice，它只能对数组进行操作，这就要利用到我们的split了。（该方法不改变原数组）
var a=&hello,wold&;
a.split('').splice(8,0,'r');
console.log(a);
// hello,wold
没有改变，虽然 splice 是改变的，但split不改变所以最后不变
我目前使用到的地方比如有
1.rgb颜色值转换为十六进制
const rgb_to_hex = (color) =& {
let rgb=color.split(',');
let r=parseInt(rgb[0].split('(')[1]),
g=parseInt(rgb[1]),
b=parseInt(rgb[2].split(')')[0]);
return '#'+((1&&24)+(r&&16)+(g&&8)+b).toString(16).slice(1);
let color='rgb(10,128,233)';
console.log(rgb_to_hex(color));
这里还用到了parseInt方法将字符串转为数字，默认为十进制。
用到了slice方法，主要是避免当我们r位颜色数字小于16的时候出现#rggbb的情况，因为颜色值应该是六个十六进制数组成的
2.一道OJ题目，输出文件的后缀名
const extname = (filename) =& {
let position =filename.indexOf('.');
if(position!==0 && position!==-1){
filename=filename.split('.');
postfix=filename.pop();
return '.'+postfix
return ''
slice方法:slice(start,end) end是可选参数
如我们上面那个颜色的例子，我们用于将我们的那个1去掉，所以我们slice(1)，它规定了从第2位开始取值，因为计算机是从0开始的，看下例
const a=[12,324];
console.log(a.slice(0));
// [12,324];
---& 从第0位开始取
console.log(a.slice(1));
---& 从第1位开始取
1个参数：从开始位置截取到结尾
2个参数：从开始位置截取到结束位置（！不包括结束位置本身哦！厉害的是结束位置还可以是负数！长见识了吧
var a=[1,2,3,5];
console.log(a.slice(2,-1)); //3;
console.log(a.slice(2,3)); //3;
console.log(a.slice(2,4)); //3,5
push方法 :方法可向数组的末尾添加一个或多个元素，并返回新的长度。
好像没有什么可说的？
var a=[1];
a.push(2);
console.log(a); // [1,2]
console.log(a.push(8));
function getArray(str) {
tmp_Array.length = 0;
str = str.split(&,&);
for (var i in str) {
alert(str[i]);
tmp_Array.push(str[i]);
上例将str按&,&分割，并将其添加进tmp_Array数组之中。
pop方法：用于弹出数组最后一个元素，返回该元素的值
其实就是 push 和 pop 就是后进先出的栈数据结构。
var a=[1,2,3];
console.log(a.pop()); //3
console.log(a); //[1,2]
shift：将数组第一个元素从其中删除，并且返回第一个元素的值
和pop差不多
var a=[1,2,3];
console.log(a.shift()); //1
console.log(a); //[2,3]
unshift: 在数组开头添加元素，返回该元素值
pop，unshift，shift，push 这几个都是直接对原数组进行操作的。
unshift和shift组成的数据结构也是栈，只是栈顶和栈尾位置交换了罢了。
var a=[1,2,3];
console.log(a.unshift(4)); //4
console.log(a); //[4,1,2,3]
这里说一句题外话，那么现在，往开头插入数和往尾部插入数都有了，那么该怎么往我们指定的地方插入数字呢？
这里面的学问就很多了，等我们讲完ES6部分的数组操作我们再来回头看一看，标上记号哦，朋友们。
join：将数组元素通过指定的字符连接成字符串(这其实是两句话，1.将每个元素都转成字符串2.用自定义的连接符分割)
它接受0参数或者1个参数，若是传了多个参数只有第一个是有效的。
参数若是为无，默认为','
join不操作原数组
我们来看一个挺有趣的地方
var num=new Array('hello','world');
console.log(num.join());
//hello,world
想象，这和toString方法是不是很像呢，加空格拼接说不定还能造句呢。
如果使用join(&&),返回空白，可以有效判断数组是否是空字符数组
var array=['1','2','3'];
var html=&&h1&&+array.join(&&/h1&&h1&&)+&&/h1&&;
上述可以生成用array作为数据的指定结构的html
还有一个有趣的现象时，join的过程会把 数字 07 中的0去掉？这是 js自己本身的机制。
var array=[07,15];
console.log(array.join('-'));
我们可以用来复制一个数组
var a=&hello,wold&;
a.split('').splice(8,0,'r');
console.log(a);
// hello,wold
b=a.split('').splice(0).join('');
// hello,wold
复制了一个a赋值给b
这里还要提出的一点就是，join的逆向操作就是split
concat：用于连接两个或者多个数组
concat是不会改变原来的数组的
var a=[1,4];
var b=[2,4];
console.log(c.concat(a,b));
// [1,4,2,4]
console.log(a,b);
// [1,4] [2,4]
reverse：用于将数组元素颠倒顺序
无参数，无视参数,!!!!!操作的是数组本身，会改变原数组
var a=[1,2,3,5];
console.log(a.reverse());
// [5,3,2,1]
sort(fn)：将数组元素排序: sort() 是会改变原数组的！
参数：fn(a,b):比较函数 ;无参数的时候按照字母表升顺排序;该方法操作的是数组元素本身
var a=[1,2,3,5,10,25];
console.log(a.sort()); // [1,10,2,25,3,5]
看，我们发现了什么？这个排序结果明显不是我们所想要的结果，对吧哈哈？是不是很有趣!
这是因为 sort()默认对每一个 子项 调用转型方法 toString()，之后才进行判断。而这个时候其实是根据 ASCII 码的大小来判断的。因此 &15& & &5&。先比较第一位，再比较第二位。
即使每一项都是 Number ，如果我们不后期加工，sort()比较的也是每一项转化为的String的大小。
参数a,b分别表示数组中的任意两个元素，若 return & 0 则表示 则b前a后（后来居上原则！！死记吧！！）。若 return & 0 则表示 a前b后。
简化： (a-b)从小到大(正序); (b-a)从大到小(逆序)。
var array=[15,5,10,2,0];
array.sort((a,b)=&{return a-b});
console.log(array);
// [0,2,5,10,15]
对简单对象的排序
let obj_list=[{
name:'li',
name:'chen',
name:'huang',
console.log(obj_list.sort((a,b)=&{return a.value-b.value}))
// 排序结果：'huang','li','chen'
在一次面试中，我还得知了这个函数还可以用于随机排序，其实就是利用了sort的特性。官方的sort解释是这样的:
1.可选参数compare需为函数，sort函数使用compare函数比较数组中的两个元素，因此，compare函数需要两个参数compare(a,b)。
2.当compare函数返回任何大于0的值时，它将使第1个参数的索引值小于第2个参数的索引值
3.当compare函数返回任何小于0的值时，它将使第2个参数的索引值小于第1个参数的索引值
所以！！！如果我们要乱序，我们只要让返回的随机数 大于0和小于0 的概率一样即可！上代码：
let array=[1,2,3,5,7,8,11,21,33];
function ran(){
return 0.5 - Math.random();
array.sort(ran());
console.log(array);
[1,11,2,21,3,33,5,7,8]
但是这还不够(试着思考，用户每一次进入游戏都是一样的环境？)，我们可以发现，这里的js每一次的运行都是一样，我们需要给它一个每次都改变的种子！----让每一次程序的运行的random()都不一样。
先贴网上的：
但是按照C++和C#的写法貌似应该是根据系统时间改变随机种子。这个以后有时间再写。
splice：用于截取数据，插入数据，删除数据。！！操作的是数据本身
这里郑重地提一句，字符串不能借用splice，即使使用了Array.porotpye.splice.call，因为在规范中，字符串是不可变的，使用splice会改变原数组。所以slice可以在字符串中用，而splice不能。所以，如果我们要在字符串中使用，需要注意。a.转换成数组 b.注意splice返回的是被替换的东西，而不是本身。
参数有三：1.开始位置 2.截断的个数 3.插入的数据
辗转之后，回到了我们的按需插入的问题，但是在这里还是先不细说，待到ES6经验之处，再来好好品评这个问题。
一.当只有1个参数的时候：从开始位置截取剩下的所有数据。slice就像只是我们想象中的裁剪，而splice则是现实中的，从splice中醒来，已是物是人非。splice是直接对数组进行操作的。
var array=[15,5,10,2,0];
console.log(array.slice(1));
// [5,10,2,0]
console.log(array.splice(1)); // [5,10,2,0]
二.若有两个参数，则第一个是删除位置的下标，第二个是从包括下标在内数的删除的数量，结果返回删除的元素，剩余的就是被手术刀裁剪过的数组了。
var array=[15,5,10,2,0];
console.log(array.splice(0,2)); // [15,5]
console.log(array);
// [10,2,0]
三.替换大法瞒天过海，这里是三个参数的，这里返回的值依旧是我们替换掉的那个值，仿佛是要给一个机会让我们去保存它，不让我们忘却历史啊
var array=[15,5,10,2,0];
console.log(array.splice(0,1,4));
console.log(array);
// [4,5,10,2,0]
然后就是添加的功能了，依旧是三个参数，不过是把数量改成0
var array=[15,5,10,2,0];
console.log(array.splice(0,0,4));
console.log(array);
// [4,15,5,10,2,0]
返回的依然是 所被替换的数值 ，因为没有，此处自然为 []
若是直接扩展一个对象函数
Array.prototype.insert = function (index, item) {
this.splice(index, 0, item);
就这样，ES3的数组方法告一段落，下面就是随着时代的进步所衍生出的ES5,6的方法了，我们曾经所有的复杂的，麻烦的操作，在新技术中，都被简化，就像拖把和拖把一样，这就是进步，拥有进步能力的语言往往不容易被这个时代所淘汰。
ES5,6数组操作
indexOf：返回在该数组中第一个找到的元素位置，若不存在则返回 -1
我们可以首先来用ES3来模拟一下先，有助于我们理解。
Array.prototype.indexOf=function(index){
var res=-1,
if(len==0)
for(var i=0;i&i++){
now=this[i];
if(index==now){
var test=['234','23424','30'];
console.log(test.indexOf('30'));
对于正则不好的同学，indexOf是个利器（来自网上的说法），我们演示一下主要用处
let str=&chuyin&;
console.log(str.indexOf('u')); // 2
console.log(str.indexOf('j')); // -1
还需要注意的一点是，数组也和字符串类型一样，拥有这个函数，我们可以数组进行indexOf操作
var arr=['234','orange','apple'];
console.log(arr.indexOf('app'),arr.indexOf('apple'));
forEach：这个依旧是ES5的方法，老实说我没怎么用过，我学习的时候ES6已经出了，这个已经是不推荐的方法了。ES6有个for of和map，为了效率我们还是用最普通的for(;i++)格式。
参数为function类型，默认有传参(遍历数组内容，对应数组索引，数组本身)
在这里引用一个segmentfault的回答：
// 题目是，添加一个 fullName
var users = [
lastName: 'Li',
firstName: 'Lei'
lastName: 'Han',
firstName: 'Meimei'
// 在这里，我们用原始的语法处理
for(var i=0;i&users.i++){
users[i].fullName=users[i].firstName+users[i].lastN
// 分析缺点：我们多了个 i 变量，直观上多了个 for 循环
// 若是用forEach
users.forEach(function(user,index,arr){
user.fullName=user.firstName+user.lastN
console.log(users);
这里，你只需要关注主业务(fullName的生成)，无需关注遍历的过程及方法。(来自segmentfault某回答)
但是我觉得是有利有弊的，毕竟其实还是有for循环，降低了效率。而且forEach不能中断，我们不能加一些其他的骚操作。
map：重头戏。我们能够在Redux中的reducer看到大量的map函数，因为redux追求这种函数式极简的酷炫的风格。可以说在react中map的出现率非常高，侧面反映出其非常好用！
map是指映射，和英文中的地图不同。
map不会修改原来的数组。
一.回调函数中0或者1个参数
var a=[1,32,442,234];
b=a.map((item)=&{return item+1;});
// ES6箭头函数语法，看不懂的同学可以先去学下ES6
console.log(a,b);
// [1,32,442,234]
[2,33,443,235]
如果我们什么都不做，则每一项都会返回 undefined
var a=[1,32,442,234];
c=a.map(()=&{});
// 打印 4个 undefined
console.log(c);
二.回调函数中第二个参数 index 的作用,在react中我们主要将它赋值给key
d=a.map((item,i)=&{
console.log(i);
// 0,1,2,3
三.回调函数中第三个参数，包含该元素的数组对象
e=a.map((item,i,array)=&{
console.log(array);
// 最后会打印四遍
[1,34,442,234]
四.map函数中的第二个参数(可选的this)
d=a.map((item,i,array)=&{
console.log(i);
// 0,1,2,3
这种情况在我的实习过程中用过一次，不过是教我的大佬用的，主要是在React中使用，目前不解其意？此处还需学习，待更。
filter：筛选函数
不改变原数组。
以上不改变原数组的函数如果结果需要多次使用，最好都定义一个新的变量来存储。
和map结构差不多，在filter里面包着一个callback回调函数。
让我看一个简短的filter，是不是有一种四两拨千斤的感觉。
flag:false,
name:'lihua'
flag:true,
name:'zengcuo'
console.log(a.filter(item=&item.flag));
// [{flag:true,name:'zengcuo'}]
其实一般的情况是这样的，上面是函数式的写法，所以简洁。PS：偶尔是会出大问题的，函数式，有时候函数式可能会比普通的for循环效率低。
name:'lihua'
name:'zengcuo'
function isBig(element,index,array){
return (element.age&=30);
a.filter(isBig);
console.log(a);
//与原来相同，说明不改变原数组
var filtered=a.filter(isBig);
console.log(filtered); // [{age:100,name:'zengcuo'}]
不定参数和默认参数
!!! 补充一个 fill 方法 !!!!!!!
tmp_Array=getArray(oDiv[1].innerHTML);
oDiv[1].innerHTML=tmp_Array.concat(tmp_Array).toString().replace(/\s/g,&&);
replace为正则中的替换，//中的为正则表达式，g表示全局，\s表示制表符，意为将全部的制表符转化为空，即删去所有制表符。
上例的部分代码
PS:有趣的几个问题
String类型使用splice插入的问题，虽然实现了，但是非常麻烦
var a=&hello,wold&;
// 因为a是String类型，不能直接使用Array类型的方法splice
// a.splice(8,0,'r');
a.splice is not a function
b=a.split('');
b.splice(8,0,'r');
b=b.join('');
console.log(a,b);
阅读(...) 评论()
