2013年8月 Web 开发大版内专家分月排行榜第一2010年2月 Web 开发大版内专家分月排行榜第一
2013年7月 Web 开发大版内专家分月排行榜第二2013年6月 Web 开发大版内专家分月排行榜第二
匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。4453人阅读
JavaScript（3）
我们接下来写一个系列，关于JavaScript的学习。希望能跟大家一起来学习JavaScript，至于为什么要学JavaScript呢?我们不用JavaScript也可以编程，对，但是学了会有什么作用，我给大家百度一下：
Javascript是一种由Netscape的LiveScript发展而来的原型化继承的面向对象的动态类型的区分大小写的客户端脚本语言，主要目的是为了解决服务器端语言，比如Perl，遗留的速度问题，为客户提供更流畅的浏览效果。当时服务端需要对数据进行验证，由于网络速度相当缓慢，只有28.8kbps，验证步骤浪费的时间太多。于是Netscape的浏览器Navigator加入了Javascript，提供了数据验证的基本功能。 简而言之JavaScript就是一种提高用户体验的语言。
好了废话不多说，我们接下来先了解一下JavaScript的常见的问题，以便在稍后的编写代码中我们能轻而易举的实现我们的代码。这部分的内容我们主要讲以下几点：
区分大小写：
其实这部分的内容主要是为了区分咱们用别的语言来编写；咱们之前使用过的语言：vb就不区分大小写，而咱们讲的这个JavaScript就区分大小写。
JS中方法和变量都是区分大小写的，因此function myFunction{}和function&Myfunction()是不同的。
这一规则也适用于JavaScript核心对象例如:Array和Object.我们在定义一个数组的时候Array，就必须是大写开头，当你写成小写之后，你会发现array的字体颜色会发生变化。
单引号、双引号：
单引号、双引号在JS中没有特殊的区别，都可以用来创建字符串。但作为一般性规则，大多数Js开发人员喜欢使用单引号而不是双引号，但是因为XHTML规范要求所有属性值都必须使用双引号括起来。这样在JS中使用单引号，而对XHTML属性使用双引号会使混合两者代码更方便也更清晰。
单引号中可以包含双引号，反之双引号也可以包含单引号。
我们看一个例子：
在这个代码段里边，因为a是一个属性值，所以用双引号，然后我们的单引号可以包含双引号，所以整个单引号括起了的地方就是一个字符串，然后+是一个连接符，所以这一个整个部分也就连接了起来。那么我们看到第二部分的代码，由于a的旁边多了一个转移字符，要是没有这个转义字符，那么当这个代码运行到class=\的时候就结束了。我们很清楚的看到，下面这个代码明显没有上面这个代码清晰，舒服。
但是对于下面情况还是需要转义字符的：
var temp='&p class=&a&& What\'s this?';如果一个单引号里边还有单引号的话，还是需要转义字符的。
首先需要说明的是：JS中括号包含2种语义，可以是分隔符也可以是表达式。
分隔符大家非常熟悉，我们举个例子来说明：（1+3）*3等于12。
表达式是这么个类型，我们看一下：
(function(){})();这里边，function之前的一对括号作为分隔符，后面的括号表示立刻执行这个方法。举个例子吧：
&title&括号的意义&/title&
&script type=&text/javascript&&
var a='123';
function aa(){
&body onload=&aa();&&
&title&括号的意义&/title&
&script type=&text/javascript&&
var a='123';
(function (){
提前说明一下，这两个结果一样的；然后我们观察发现这两段代码的区别。第一个代码直接在onload里边就加载了；然而第二段代码是使用了括号表示立即执行的效果，而且我们干脆用匿名的效果，立即就执行了这个function。所以达到了一样的效果。还有另一种写法：
&title&括号的意义&/title&
&script type=&text/javascript&&
var a='123';
function aa(){
window.onload=
这种写法跟第一种写法其实一样，我在这里想说的是：onload什么时候开始加载呢？就是在整个页面加载全部结束之后才会调用，整个页面加载包括图片加载；有时候当图片非常多的时候，我们调用这个onload就会很慢。当然我们还有别的办法，就是先加载文字部分，然后并行调用onload，同时我们再加载其他图片。我们是可以这么做的。我们简单的提一下。
函数调用和引用：
我们刚才写的两个形式，一种是带小括号的，在body里边的。然后我们直接在window里边写的就没有小括号；这就涉及到了我们函数调用和引用的问题。我们看一下：
var foo=example();
我们看得出来，前面的一个带小括号的，小括号在这里的意思就是立即执行的意思。这个的意思就是我们调用example并且把函数的返回值付给foo。第二个就是我们把这个example的函数指针指给这个foo1。所以带括号的表示一个函数的返回值；不带括号的表示一个函数的引用
换行：我们可以使用反斜杠转义字符来连接或者使用+来连接。
分号、大括号可选：
JS中每行语句的最后并不是必须用分号结尾。因此我们看：
是没有区别的。
但是对于一下代码，如：
不会翻译为
而是翻译成：
JS中不支持重载因此这里所说的重载其实更类似于替换。如：
function myFunction(a,b){}
function myFunction(a){}
由于没有重载所以上面的声明将导致下面的myFunction函数覆盖上面的函数。如：
&title&重载&/title&
&script type=&text/javascript&&
var a='123';
function aa(){
function aa(){
alert(&这是第二个&);
window.onload=
我们看到的结果是：
其实就是替换了第一个了。还有一点需要注意的是，JavaScript里边调用只与function的名字有关，与function的参数无关。如：
&title&重载&/title&
&script type=&text/javascript&&
var a='123';
function aa(){
function aa(x,y,z){
alert(&这是第二个&);
window.onload=
显示的结果还是和刚才一样。
当我们写JavaScript的方法的时候，一定要注意，名字不要使用保留字，除非你说我一定要覆盖他的保留方法，否则将导致你的代码覆盖JS核心函数：如：
&title&重载&/title&
&script type=&text/javascript&&
var a='123';
function aa(){
function aa(x,y,z){
alert(&这是第二个&);
function alert(){}
window.onload=
则将什么也没显示，但是也不报错。
作用域、闭包：
作用域指对某一属性或方法具有访问权限的代码空间。
function myFunction(){
&&&& var temp=&abc&;
上面的temp在函数外面无法访问。
闭包是与作用域相关的一个概念，它指的是内部函数即使在外部函数执行完成并终止后仍然可以访问其外部函数的属性。如：
&title&闭包&/title&
&script type=&text/javascript&&
function newaa(){
for(var i=1;i&=3;i++){
var anchor=document.getElementById(&anchor&+i);
anchor.onclick=function(){
alert(&My anchor is anchor&+i);
window.onload=
&/head&http://write.blog.csdn.net/postedit/8200870
&a id=&anchor1& href=&#&&abc&/a&&br /&
&a id=&anchor2& href=&#&&abc&/a&&br /&
&a id=&anchor3& href=&#&&abc&/a&&br /&
&/html&我们看一下效果：
无论我们点击那个abc都会出现这种情况，这是为什么？我们看一下，当我们点击事件发生后，我们的onload事件已经加载完了，所以i就变成了4了。所以就造成了这种情况。我们看一下应该如何来解决这个问题呢：
&title&闭包&/title&
&script type=&text/javascript&&
function newaa(){
for(var i=1;i&=3;i++){
var anchor=document.getElementById(&anchor&+i);
registerListener(anchor,i);
function registerListener(anchor,i){
anchor.onclick=function(){
alert(&My anchor is anchor&+i);
window.onload=
&a id=&anchor1& href=&#&&abc&/a&&br /&
&a id=&anchor2& href=&#&&abc&/a&&br /&
&a id=&anchor3& href=&#&&abc&/a&&br /&
&/html&&&& 这样我们就能达到我们想要的结果了。这就是闭包的一个作用。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：848031次
积分：6522
积分：6522
排名：第3547名
原创：62篇
评论：1661条
阅读：30295
文章：11篇
阅读：124579
文章：11篇
阅读：111887
(9)(5)(6)(4)(4)(3)(4)(8)(4)(8)(7)(4)(1)JavaScript 的常见“陷阱” - 文章 - 伯乐在线
& JavaScript 的常见“陷阱”
PHP是我的第一门编程语言，之后通过像jQuery这样的库首次接触JavaScript。由于JavaScript与PHP的工作原理不同，开始时总有一些JavaScript问题困扰着我。即使现在，仍有让我感到疑惑的东西。我想分享一些开始使用JavaScript时我苦苦思考的问题。这些问题将涉及：全局命名空间、this、ECMAScript 3 和ECMAScript 5的区别、异步调用、原型以及 简单的JavaScript继承。
全局命名空间
在PHP中，特别地，当你在类（或命名空间块）之外声明一个函数变量时，你实质上往全局命名空间添加了一个函数。在JavaScript中，没有所谓的命名空间，然而所有的东西都附属于全局对象。在Web浏览器中，全局对象就是windows对象。另一个主要区别是：在JavaScript中，函数和变量均是全局对象的属性，即我们通常指代的properties。
因为，当你覆盖一个全局函数或属性，JavaScript不会给出任何警告，所以这会很麻烦，实际上是相当危险的。
JavaScript
function globalFunction() {
console.log('I am the original global function');
function overWriteTheGlobal() {
globalFunction = function() {
console.log('I am the new global function');
globalFunction(); //输出 "I am the original global function"
overWriteTheGlobal(); //重写最初的全局函数
globalFunction(); //输出 "I am the new global function"
123456789101112
function globalFunction() {&&console.log('I am the original global function');}&function overWriteTheGlobal() {&&globalFunction = function() {&&&&console.log('I am the new global function');&&}}globalFunction(); //输出 "I am the original global function"overWriteTheGlobal(); //重写最初的全局函数globalFunction(); //输出 "I am the new global function"
JavaScript中的一种技术是立即执行函数表达式，一般称为自执行匿名函数。它对于保持变量和函数的独立性是非常有用的。通常，我通过传入对象方式将函数暴露给外界。这是模块模式的一个变种。
JavaScript
var module = {};
(function(exports){
exports.notGlobalFunction = function() {
console.log('I am not global');
}(module));
function notGlobalFunction() {
console.log('I am global');
notGlobalFunction(); //输出 "I am global"
module.notGlobalFunction(); //输出 "I am not global"
12345678910111213141516
var module = {};&(function(exports){&&&exports.notGlobalFunction = function() {&&&&console.log('I am not global');&&};&&&}(module));&function notGlobalFunction() {&&console.log('I am global');}&notGlobalFunction(); //输出 "I am global"module.notGlobalFunction(); //输出 "I am not global"
在自执行匿名函数里，所有的全局作用域是封闭的，通过将之依附到module变量实现。从技术上讲，你可以直接把属性附加到module变量，但我们将它传递给函数的原因是：明确地表明函数所附加的地方。它允许我们给传入函数的对象起别名。这里的关键是：我们预先声明依赖于模块变量，而不依赖于全局变量。
你也许已经注意到了var关键字。如果你不知道如何使用它，基本的解释是：在声明变量前使用var，为离之最近的函数创建了一个属性。如果省略var关键字，那么意味着给现有变量分配一个新值，并提升了作用域链。这个作用域链可能是全局范围的。
JavaScript
var imAGlobal =
function globalGrabber() {
imAGlobal =
return imAG
console.log(imAGlobal); //输出 "true"
console.log(globalGrabber()); //输出 "false"
console.log(imAGlobal); //输出 "false"
12345678910
var imAGlobal = true;&function globalGrabber() {&&imAGlobal = false;&&return imAGlobal;}&console.log(imAGlobal); //输出 "true"console.log(globalGrabber()); //输出 "false"console.log(imAGlobal); //输出 "false"
正如你所看到的一样，在你的函数中依赖全局变量是相当危险的，因为可能产生副作用，造成难以预料的冲突。当你使用var关键字时，会发生什么呢？
JavaScript
var imAGlobal =
function globalGrabber() {
var imAGlobal =
return imAG
console.log(imAGlobal); //输出 "true"
console.log(globalGrabber()); //输出 "false"
console.log(imAGlobal); //输出 "true"
12345678910
var imAGlobal = true;&function globalGrabber() {&&var imAGlobal = false;&&return imAGlobal;}&console.log(imAGlobal); //输出 "true"console.log(globalGrabber()); //输出 "false"console.log(imAGlobal); //输出 "true"
JavaScript将var声明变量提升到函数块顶部，接着初始化变量。这就是所谓的变量提升。
总结：所有变量的作用于一个函数内（函数本身就是一个对象），并使用var声明这些变量就确定它们的函数作用域，不使用var意味着声明一个全局变量。
让我们来看看使用变量提升的情况：
JavaScript
function variableHoist() {
console.log(hoisty);
hoisty = 1;
console.log(hoisty);
var hoisty = 2;
console.log(hoisty);
variableHoist();
//输出 undefined (如果在作用域内不存在var声明，将得到一个引用错误(ReferenceError))
//输出 "1"
//输出 "2"
console.log(hoisty); //输出 ReferenceError (不存在全局变量"hoisty")
} catch (e) {
console.log(e);
123456789101112131415161718
function variableHoist() {&&console.log(hoisty);&&hoisty = 1;&&&&console.log(hoisty);&&var hoisty = 2;&&console.log(hoisty);}&variableHoist(); //输出 undefined (如果在作用域内不存在var声明，将得到一个引用错误(ReferenceError))//输出 "1"//输出 "2"&try {&&console.log(hoisty); //输出 ReferenceError (不存在全局变量"hoisty")} catch (e) {&&console.log(e);}
之所以像你所看到的一样：把var声明放在函数的哪个位置实际上并不重要，是因为属性是在函数执行任何代码之前创建好的。在目前实践中，通常把var声明放在函数顶部，因为其作用域终止于该函数。在函数的顶部初始化变量也是完全可以接受的，只可以清楚事件的执行顺序。
在JavaScript中，使用function关键字声明的函数（不赋给变量）也会被提升。实际上，整个函数被提升，可供执行。
JavaScript
myFunction(); //输出 "i exist"
function myFunction() {
console.log('i exist');
myFunction(); //输出 "i exist"&function myFunction() {&&console.log('i exist');}
当使用var形式来声明函数时，整个函数不会被提升：
JavaScript
myFunction();
} catch (e) {
console.log(e); //抛出 "Uncaught TypeError: undefined is not a function"
var myFunction = function() {
console.log('i exist');
myFunction();
//输出 "i exist"
12345678910
try {&&myFunction();} catch (e) {&&console.log(e); //抛出 "Uncaught TypeError: undefined is not a function"}var myFunction = function() {&&console.log('i exist');}&myFunction();&&//输出 "i exist"
理解“this”
由于JavaScript使用了函数域，this的意义与PHP中的截然不同，引起了诸多疑惑。考虑下面的情形：
JavaScript
console.log(this); // 输出 window object
var myFunction = function() {
console.log(this);
myFunction(); //输出 window object
var newObject = {
myFunction: myFunction
newObject.myFunction(); //输出 newObject
12345678910111213
console.log(this); // 输出 window object&var myFunction = function() {&&console.log(this);}&myFunction(); //输出 window object&var newObject = {&&myFunction: myFunction}&newObject.myFunction(); //输出 newObject
默认情况下，this指向包含在函数内的对象。由于myFunction()是全局对象的一个属性，this是全局对象window的引用。现在，当我们把myFunction()封装到newObject中，现在this指向newObject。在PHP和其他类似的语言中，this往往指向包含该方法的类的实例。你可能认为JavaScript在这里干着一些蠢事，但确实很多JavaScript语言的力量正来源于此。事实上，当我们使用call()或apply()来调用JavaScript函数时，甚至可以替换this的值。
JavaScript
var myFunction = function(arg1, arg2) {
console.log(this, arg1, arg2);
var newObject = {};
myFunction.call(newObject, 'foo', 'bar'); //输出 newObject "foo" "bar"
myFunction.apply(newObject, ['foo', 'bar']); //输出 newObject "foo" "bar"
var myFunction = function(arg1, arg2) {&&console.log(this, arg1, arg2);};&var newObject = {};&myFunction.call(newObject, 'foo', 'bar'); //输出 newObject "foo" "bar" myFunction.apply(newObject, ['foo', 'bar']); //输出 newObject "foo" "bar"
但不要急着往下看，让我们认真思考一下。这里我们所做的是：通过传入对象值作为函数内部this的替代值来调用函数myFunction函数。 call()与apply()的根本区别在于传入参数的方式：call()函数接收第一个参数后，接着可接收无限量的参数；apply()函数则规定将参数数组作为第二个参数。
像jQuery这样的库，采用上述方式进行调用，表现出惊人能力。让我们看看jQuery的$.each()方法：
JavaScript
var $els = [$('div'), $('span')];
var handler = function() {
console.log(this);
$.each($els, handler);
//迭代器 1 输出包裹在div里面的jquery dom元素
//迭代器 2 输出包裹在tag里面的jquery dom元素
handler.apply({}); //输出 object
1234567891011
var $els = [$('div'), $('span')];var handler = function() { &&console.log(this);};&$.each($els, handler);&//迭代器 1 输出包裹在div里面的jquery dom元素//迭代器 2 输出包裹在tag里面的jquery dom元素&handler.apply({}); //输出 object
jQuery经常重写this的值，所以你要试图理解this在jQuery事件处理程序上下文中或其他类似结构中的含义。
弄清楚ECMAScript 3和ECMAScript 5的区别
长久以来，ECMAScript 3已经成为大多数浏览器的标准，但最近ECMAScript 5融入大部分现代浏览器（IE浏览器仍然滞后）。ECMAScript 5向JavaScript中引入了很多常见的功能以及一些你以前只能靠某个库提供的原生函数，如String.trim()和Array.forEach()。然而问题是：如果你使用Internet Explorer浏览器，这些方法在浏览器环境中仍不可用。
看看当你在IE8中试图使用String.trim会发生什么呢：
JavaScript
var fatString = "
//in modern browsers
console.log(fatString); //输出 "
console.log(fatString.trim()); //输出 "my string"
console.log(fatString.trim()); //error: Object doesn't support property or method 'trim'
var fatString = "&& my string&& ";&//in modern browsersconsole.log(fatString); //输出 "&& my string&& "console.log(fatString.trim()); //输出 "my string"&//in IE 8console.log(fatString.trim()); //error: Object doesn't support property or method 'trim'
因此在此期间，我们可以像使用jQuery.trim方法来做到这一点。我相信如果浏览器支持，jQuery会回退到String.trim，以提高性能（浏览器原生函数更快）。
你可能不关心甚至不需要了解ECMAScript3和ECMAScript5之间的所有差异，但首先查阅作为函数参考手册的（MDN），看看函数适用的语言版本：这通常是一个好主意。一般来说，如果你使用库像jQuery或者underscore这样的库来处理，效果应该也不错。 如果您有兴趣在旧版浏览器中使用类似ECMAScript 5的插件，请查阅
在实践中开始编写JavaScript代码时，特别是jQuery，让我吃尽苦头的是一些异步操作。有很多次遇到这样的情况：我所编写过程式代码希望立即返回一个结果，但并未发生。
看看下面的代码片段：
JavaScript
var remoteValue =
success: function() {
remoteValue =
console.log(remoteValue); //输出 "false"
var remoteValue = false;$.ajax({&&url: '',&&success: function() {&&&&remoteValue = true;&&}});&console.log(remoteValue); //输出 "false"
我花了一段时间才弄清楚，当进行异步编程时，需要使用回调函数来处理ajax返回的结果。
JavaScript
var remoteValue =
var doSomethingWithRemoteValue = function() {
console.log(remoteValue); //当调用成功时，输出 true
complete: function() {
remoteValue =
doSomethingWithRemoteValue();
12345678910111213
var remoteValue = false;&var doSomethingWithRemoteValue = function() {&&console.log(remoteValue); //当调用成功时，输出 true }&$.ajax({&&url: '',&&complete: function() {&&&&remoteValue = true;&&&&doSomethingWithRemoteValue();&&&&&&}});
另一个厉害的东西是deferred对象（有时称为promises），可用于倾向过程风格的编程：
JavaScript
var remoteValue =
var doSomethingWithRemoteValue = function() {
console.log(remoteValue);
var promise = $.ajax({
//输出 "true"
promise.always(function() {
remoteValue =
doSomethingWithRemoteValue();
//输出 "foobar"
promise.always(function() {
remoteValue = 'foobar';
doSomethingWithRemoteValue();
123456789101112131415161718192021
var remoteValue = false;&var doSomethingWithRemoteValue = function() {&&console.log(remoteValue); }&var promise = $.ajax({&&url: ''});&//输出 "true"promise.always(function() {&&remoteValue = true;&&doSomethingWithRemoteValue();&&&&});&//输出 "foobar"promise.always(function() {&&remoteValue = 'foobar';&&doSomethingWithRemoteValue();&&&&});
您可以使用promises完成链式回调。在我看来，这种方式比嵌套回调方式更容加易用，额外地，这些对象还提供了大量其他好处。
浏览器中的动画也是异步的，因此这也是容易混乱的地方。这里不打算深究，但是你应该像处理ajax请求一样，通过回调函数来处理动画。然而，我还不算是这方面的专家，所以请自行参考 。
JavaScript的简单继承
粗略概括一下，JavaScript通过克隆对象来扩展它们，而PHP、Ruby、Python和Java使用、继承类。在JavaScript中每个对象都拥有一个所谓的原型。事实上，所有的函数，字符串，数字以及对象有一个共同的祖先：Object。关于原型有两件事情要记住：蓝本（blueprints）和链。
基本上，每个原型本身就是一个对象。在创建一个对象的实例时，它描述了可用的属性。原型链就是允许原型继承其他原型的东西。事实上，原型本身也有原型。当对象实例没有某个方法或属性时，那么它会在该对象的原型、原型的原型中寻找。依此类推，直至发现该属性不存在，最终报错undefined。
值得庆幸的是，初学者一般不必要沾惹这东西，因为创建一个对象字面量相当容易，然后在运行时附加属性即可。
JavaScript
var obj = {};
obj.newFunction = function() {
console.log('I am a dynamic function');
obj.newFunction();
var obj = {};&obj.newFunction = function() {&&console.log('I am a dynamic function');};&obj.newFunction();
一直以来，我使用jQuery.extend()这种简单的方法来继承对象：
JavaScript
var obj = {
a: 'i am a lonely property'
var newObj = {
b: function() {
return 'i am a lonely function';
var finalObj = $.extend({}, obj, newObj);
console.log(finalObj.a); //输出 "i am a lonely property"
console.log(finalObj.b()); //输出 "i am a lonely function"
1234567891011121314
var obj = {&&a: 'i am a lonely property'};&var newObj = {&&b: function() {&&&&return 'i am a lonely function';&&}};&var finalObj = $.extend({}, obj, newObj);&console.log(finalObj.a); //输出 "i am a lonely property"console.log(finalObj.b()); //输出 "i am a lonely function"
ECMAScript 5提供了Object.create()方法，你可用它从对现有对象进行继承。然而，如果你需要支持旧版浏览器，请勿使用。在创建属性和设置属性的属性（是的，属性也有属性）方面，它确实具有明显的优势。
JavaScript
var obj = {
a: 'i am a lonely property'
var finalObj = Object.create(obj, {
get: function() {
return "i am a lonely function";
console.log(finalObj.a); //输出 "i am a lonely property"
console.log(finalObj.b); //输出 "i am a lonely function"
1234567891011121314
var obj = {&&a: 'i am a lonely property'}; &var finalObj = Object.create(obj, {&&b: {&&&&get: function() {&&&&&&return "i am a lonely function";&&&&}&&}});&console.log(finalObj.a); //输出 "i am a lonely property" console.log(finalObj.b); //输出 "i am a lonely function"
由于JavaScript具有强大能力和灵活性，你可以深入JavaScript继承方面。而好在这里又不必深究。
意外陷阱：在for循环中忘记使用var
JavaScript
var i = 0;
function iteratorHandler() {
function iterate() {
//迭代器仅运行一次
for (i = 0; i & 10; i++) {
console.log(i); //输出 0
iteratorHandler();
console.log(i); //输出 10
iterate();
12345678910111213141516
var i = 0;&function iteratorHandler() {&&&&i = 10;}&function iterate() { //迭代器仅运行一次&&for (i = 0; i & 10; i++) {&&&&console.log(i); //输出 0&&&&iteratorHandler();&&&&console.log(i); //输出 10&&} }&iterate();
该例子是刻意的，但你可意识到这里的危险。解决的办法是，使用var声明迭代器变量。
JavaScript
var i = 0;
function iteratorHandler() {
function iterate() {
//迭代器会运行10次
for (var i = 0; i & 10; i++) {
iteratorHandler();
console.log(i);
iterate();
123456789101112131415
var i = 0;&function iteratorHandler() {&&&&i = 10;}&function iterate() {&&//迭代器会运行10次&&for (var i = 0; i & 10; i++) {&&&&&&&&iteratorHandler();&&&&console.log(i);&&}}&iterate();
这一切可追溯到我们之前说的作用域规则。请记住，恰当使用var。
JavaScript或许是唯一一门使用前不需要学习的语言，但最终你将陷入一些不明原因的麻烦之中。在这些日子里，除了避免犯错之外，学习JavaScript收获良多，考虑到其重生与广泛适用性。这篇博文并不是尝试着解决所有问题的灵丹妙药，但希望在人们被迫编写可怕的JavaScript代码之前，可以帮助他们了解一些基本情况；暗地里希望重回幸福之地 — 充满着数据库查询的PHP后端项目。
关于作者：
可能感兴趣的话题
点个赞……学到不少呀……尤其是var……有时候忘记写。
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2017 伯乐在线