javascript专家,JAVASCRIPT

《第三方JavaScript编程》epub下载在线阅读全文，求百度网盘云资源

《第三方JavaScript编程》（[美] Ben Vinegar）电子书网盘下载免费在线阅读

链接:

提取码: qmx1

书名：第三方JavaScript编程

作者：[美] Ben Vinegar

译者：郭凯

出版社：人民邮电出版社

出版年份：2015-9-1

页数：237

内容简介：

第三方JavaScript应用程序是自包含的应用组件，通常都是小脚本或插件，能够为Web站点增加功能。它们往往是由独立的组织或个人提供的，代码和文件都是来自于远程的Web地址。

《第三方JavaScript编程》由两位第三方应用程序开发领域的专家编写完成，通过丰富的示例和讲解引导读者掌握第三方Web开发的相关技术及如何开发运行在第三方环境的JavaScript代码。《第三方JavaScript编程》共10章，分别介绍了第三方JavaScript的定义、如何加载和执行代码、DOM渲染、第三方脚本和数据服务器之间的通信、跨窗口的消息传递方法、身份验证和cookie、第三方应用程序的安全性、JavaScript SDK的发展、性能、测试和调试。

《第三方JavaScript编程》并非JavaScript语言的初级读本，适用于有一定第三方代码开发经验的开发者以及致力于研究其如何在外部环境运行的开发者们阅读。

作者简介：

Ben Vinegar

Ben Vinegar 是 Disqus 的一名软件工程师，Disqus 是一个第三方评论平台，为超过 30 万的博客、在线出版物以及其它Web网站提供服务，其中包括 CNN、连线杂志、每日电讯报和 IGN。Ben 在加入 Disqus 之前，在一个非常流行的 Web 记账应用公司 FreshBooks 担任软件开发团队的主管。

Anton Kovalyov

Anton Kovalyov 是 Disqus 的一名软件工程师，在公司初期就曾主导 Disqus 评论微件的开发工作。他还参与一些 JavaScript 开源项目的开发与维护，包括代码质量工具 JSHint，和跨域通信的 JS 库 easyXDM。

相关问答

Q1: 哪种物联网编程语言最热门

影响物联网IoT实施的最主要因素之一是人才缺口：现有市场供应无法跟上拥有物联网技术的工程师的需求。根据Canonical的研究，大约68%的公司正在努力为他们的物联网项目雇佣开发人员。但技能短缺的另一面是，职业前景对于具有物联网技术的专业人员来说是非常光明的。在这里，我们重点关注物联网中最常用的编程语言，即Java，C，C ++，Python，JavaScript和Go，然后分析专门从事这些语言的专业人员可以获得多少收入。我们还会考虑资历和地点等因素。

作为一个技术强国，美国在IT 薪资标准方面常常成为世界其他国家的基准。以下是根据Payscale的数据对美国顶级物联网IoT编程语言以及相应的开发者薪资数据的简要统计。

美国最热门的物联网编程语言的平均工资统计

平均而言，Java和C开发人员可以获得比物联网中使用其他语言的开发人员更高的薪水，尽管高级Go编程人员的薪水潜力最高、尽管初级和中级Go开发人员与其他同行相比低调，但Skilled Go的开发人员却是业内薪酬最高的开发人员之一。

从Java开始，我们来看看物联网IoT中最流行的编程语言的平均薪水。

Java：物联网技术最流行的编程语言

Java有多个应用领域，从后端编程到Android的移动应用。根据 Eclipse基金会执行的2017年物联网开发者调查，Java首次提供了用于物联网开发的编程语言列表，专门用于网关和云。

使用Java进行物联网开发的一个主要好处是便携性。Java没有任何硬件限制，这意味着您可以在计算机上编写和调试Java代码，并将其部署到几乎任何运行Java虚拟机的设备上。出于这个原因，许多公司选择聘请Java开发人员进行物联网项目。

根据Payscale的数据，美国Java开发者的平均薪水约为8.8万美元。瑞士的Java开发者的平均收入较高，每年约为96,000美元。与此同时，英国和以色列的Java开发人员的平均薪水则明显较低，分别为4万5千美元和33万美元。

Java开发人员的平均工资

但是，Java开发人员的平均工资可能不具代表性，因为根据相关技术人员的经验和资历，个人薪酬差别很大。例如，从Java初级到高级Java开发人员的薪酬跳跃在美国是6.6万美元到97万美元，在英国是从41,000美元到61,000美元。

Java在美国和英国的平均初级，中级和高级Java开发人员工资

我们对美国Java开发者工资的研究表明，不同州的平均薪水可能远高于全国平均水平。例如，加利福尼亚州的开发人员对美国开发人员的平均薪水最高(13.3万美元)。这一事实在很大程度上是该州IT总体高技能需求的一个功能。

C：嵌入式设备的关键编程语言

C编程语言接下来成为物联网IoT堆栈最喜欢的语言。然而，根据Eclipse基金会的说法，它被认为是受限设备开发的领先技术。

该编程语言提供对低级硬件API的直接访问。由于其与机器语言的相似性，C非常快速且灵活，使其成为处理能力有限的物联网系统的完美选择。

与Java类似，C开发人员的薪酬在世界各地差异很大。在美国，C开发人员每年可赚取约10万美元，而在瑞士，C开发人员的平均年薪为92,000美元。在我们分析的国家中，C专家的最低工资在英国。据Payscale称，英国年平均C开发人员薪水仅略高于4万美元。

C开发人员的平均工资。来源：Payscale

C级初级和高级开发人员的薪酬差异也很大。高级C开发人员的收入几乎是美国和英国入门级员工的两倍。

C在美国和英国的初级，中级和高级C开发人员的平均工资

C ++：Linux的第一语言

与其前身C一样，C ++已广泛用于嵌入式系统开发。但是，C ++的主要优势在于处理能力，在任务更加复杂时使其成为C的有用替代方案。

C ++最适合编写硬件特定的代码。它可与Linux，第一大物联网技术操作系统配合使用。但是，与Java相比，它具有有限的可移植性。

与C开发人员相比，C ++工程师的薪水更低。我们的研究发现，C ++开发人员在以色列和丹麦的预计收入约为82-86,000美元，而在美国，这个数字仅为71,000美元。

平均C ++开发人员工资统计。来源：Payscale

然而，尽管美国的C ++开发人员平均费用较低，但经验丰富的专家在职业生涯后期可以达到六位数。

美国和英国的初级，中级和高级C ++开发人员的平均工资。

Python：面向数据的物联网系统的解决方案

作为最受欢迎的网络编程语言之一，以及科学计算的前沿技术，Python在物联网开发中也获得了巨大的推动力。 对于数据密集型应用程序，Python是一个不错的选择，特别是在管理和组织复杂数据时。

此外，由于语言的清晰语法，用Python编写的源代码非常紧凑且非常易读。这对于计算能力和内存有限的小型设备来说效果特别好，尽管速度不如C / C ++快。

美国的平均Python开发人员薪水约在71k美元左右，而拥有类似技能的开发人员则分别在以色列和瑞士分别可以获得约68-67k的薪水。

Python开发人员的平均工资。来源：Payscale

与其他一样，初级和高级Python开发人员之间的薪酬差距很大。

美国和英国的平均初级，中级和高级Python开发人员薪水

仔细观察数据显示，尽管全国平均水平相对较低，但在美国，Python开发人员的薪水可能会非常高。由于开发商需求迫切，供应量有限，某些州的薪酬可能高达14万美元。传统上，加利福尼亚州是为技术专家提供最高工资的州之一。当地的Python开发人员平均赚取了大约13.5万美元。

JavaScript：事件驱动物联网应用的最佳解决方案

根据年度StackOverflow开发者调查显示，JavaScript是过去五年来最流行的编程语言之一，是现代Web开发中的核心技术。

在许多其他应用领域中，JavaScript是物联网编程语言中最常用的构建事件驱动系统。它可以管理连接设备的大型网络，并且在需要处理多个任务而无需等待其他任务完成时可以胜任。JavaScript对IoT的主要优势之一是非常节约资源。

随着IBM和三星等主要公司在他们的物联网项目中积极采用JavaScript(即Node.js)，对具有物联网(IoT)体验的JavaScript开发人员的需求仍然很高。这意味着能够全面的提高薪水。

瑞士的JavaScript开发者平均可以赚取约96k美元。令人惊讶的是，美国JavaScript专家的平均薪水要低得多，开发者可以得到6.9万美元。

全球JavaScript开发人员的平均工资。来源：Payscale

不同州之间的薪资数据差别很大：例如，研究发现，康涅狄格州，马萨诸塞州，加利福尼亚州和纽约州是JavaScript开发者收入最高的美国州，平均薪资介于10万美元至14万美元之间。

同样，根据经验，JavaScript开发人员的工资差别很大：美国的专业JavaScript开发人员平均可赚取10万美元，英国则可赚取6万美元左右。

美国和英国的平均初级，中级和高级JavaScript开发人员工资

Go：坚固的技术堆栈为复杂的物联网网络提供动力

Go是一款开源编程语言，由Google创建。尽管它不能像语言那样拥有同样广泛的用途，但我们之前专注于这一点，它是在您的物联网系统内建立通信层的强大技术。

Go语言关于物联网的主要优势是并发性和同时运行多个进程(数据输入和输出)的能力。这使得构建由多个传感器和设备组成的复杂IoT网络变得更加容易。

虽然它已被评为美国最高收入技术(根据最新的StackOverflow开发者调查)，但美国的Go平均薪水相当平稳 - 约为73,000美元，而英国则为43,000美元。

根据最近的调查显示，由于全球Go开发者工资数据不足，我们将重点关注美国和英国这些Go开发者人数最多的国家的薪水。

在美国和英国的平均Go开发者工资。来源：Payscale

高技能的Go开发者在美国可以获得高达14万美元的收入 - 几乎是初级Go程序员的三倍，是英国高级Go开发者的两倍。

在美国和英国的平均初级，中级和高级Go开发人员工资

结论

正如我们所看到的，物联网中最热门编程语言的开发人员的工资差别很大，并且取决于许多关键方面。为了理解这些信息，重要的是要看到更大的空间，并能够识别现有的市场趋势。

以上由物联传媒提供，如有侵权联系删除

Q2: javascript框架是什么意思？有什么作用？怎么理解？最好举个例子

浅谈js框架设计 在这个JavaScript框架随处乱跑的时代，你是否考虑过写一个自己的框架？下面的内容也许会有点帮助。

一个框架应该包含哪些内容？

1.语言扩展

大部分现有的框架都提供了这部分内容，语言扩展应当是以ECMAScript为基础进行的，不应当依赖任何宿主环境，也就是说，作为一个框架的设计者，你应当保证你的语言扩展可以工作在任何宿主环境中，而不是仅仅适合浏览器环境。你必须保证把它放到WScript,SpiderMonkeyShell,Rhino Shell,Adobe ExtendScript Toolkit甚至FlashActionScript等环境中都能正确的工作，举个现实一点的例子setTimeout不可以出现在其中，你也不能用XMLHTTP加载脚本运行，尽管它们看起来很贴近语言。保持这一部分的独立性可以让你方便的移植你的框架到其他宿主环境下。　

2.数据结构和算法

JS本身提供的内置对象非常有限，很多时候，框架应该提供一些数据结构和算法来帮助使用者更好的完成逻辑表达。但我认为随便翻本数据结构或者算法书用JS挑几个实现了加到框架中是不负责任的，多数数据结构应当以库的形式存在而非框架。框架中的数据结构应该足够常用而且实现不是非常复杂的，可以考虑的如集合、哈希表、链表、有序数组以及有序数组上的二分搜索。对JS来说，对象是一个天然的字符串哈希表，而集合很容易在哈希表上实现，因此只需要处理掉Object的内置方法，我们就可以实现一个高效的集合或哈希表。

3.DOM扩展

JS主要应用于Web开发，目前所有的框架也都用于浏览器环境，那么，浏览器端环境里重点中的重点DOM当然也是框架的扩展目标了，如果一个框架不提供DOM的扩展，那么其实基本没什么用处了。需要注意的是，DOM扩展也有w3c的标准可依，所以，不要尝试为各种浏览器做一些奇怪的扩展，比如FF下面的element们的prototype，框架的编写者应当无视它们。DOM扩展的主要任务之一是兼容性，不同浏览器上的DOM实现相差很多，框架必须消除这些实现带来的差异，提供统一的访问方式。当然，做为框架，应当提供一些更为方便的接口，将宿主提供的DOM对象用js对象封装是个不错的想法，但是同时这也很可能会造成内存泄露，所以做这事之前，了解内存泄露是必要的。实际上，自己想象的扩展远不如W3C的设计，比如如果你能更完整地实现XPath，你就能比JQuery做的更好。

4.AJAX扩展

大部分现有框架出现的原因都是因为AJAX，所以如果你想设计一个受欢迎的框架，AJAX是必须要做的。跟DOM扩展很相似，AJAX扩展的主要任务是兼容和内存泄露，对AJAX的核心组件XMLHttpRequest对象，必须在IE6中使用ActiveX创建，而ActiveX又有各种版本，而随之而来的内存泄露和兼容性变得非常麻烦，比如：事件函数名大小写、this指向、事件函数的null赋值。处理好这些兼容性的基础上，可以做进一步的工作，提供一些常用的实现。应该指出的是，除非你确定你提供的接口比原来的更好，否则不要改变原来的XMLHttpRequest对象的接口，比如写一个Request函数来代替open和send，如果你不清楚W3C的专家们为什么这么设计，请不要把他们想象成傻瓜。我想自己另外写一个兼容且内存安全的XMLHttpRequest加入到自己框架的命名空间里，使它从外部看上去跟W3C描述的XMLHttpRequest一模一样是不错的办法，对XMLHttpRequest我认为唯一可以考虑的修改是提供onsuccess事件。当然针对一些复杂功能的AJAX扩展也是可行的，比如HTMLHttpRequest类似的扩展可以让AJAX初学者喜欢你的框架。

5.效果

时间效果是最能刺激用户神经的，渐隐、缓动、滑动、颜色渐变这些都很不错，其实技术难度也不是很高。拖动效果则是浏览器中一个很重要的效果，用鼠标事件来模拟本来很容易，不过兼容和setCapture也是很麻烦的事情。这一部分内容量力而为就可以了。

7.脚本管理

因为大家非常喜欢C++风格的include或者JAVA风格的import，很多框架提供了基于AJAX的脚本管理，不过同步加载的效率问题是巨大的。之前我们曾经作过各种尝试，希望找到一个浏览器中不用XMLHTTP加载外部js的方法，但是最后得出的结论是：不可能。

关于这个，略微思考就可以知道，Java C++ C#都是编译型语言，include 和import都是编译期处理，在js中做到类似的事情是不太可能的。为了实现类似的功能，我想我们可以利用服务端程序或者编写一个文本工具来实现。

YUI将所有的js文件依赖关系提取出来的做法是可行的，不过这不能算是include的实现方式了，维护依赖关系不是一件很简单的事情。

8.控件

EXT的成功告诉我们：提供优质的控件才是框架的王道。你不能指望优质的扩展会吸引更多使用者。多数人只关心如何快速完成手边的工作。当然不是所有框架都要提供这部分内容。控件好坏取决于能力和美工，不过至少要保证框架里的控件不会内存泄露。

框架设计的若干原则：

1.不要做多余的事

对这框架设计来说，我认为一个非常必要的原则就是不要做多余的事情，举个极端的的例子：

function add(a,b)

{

return a+b;

}

这样的代码如果出现在框架中，就是个十足的笑话。不过大多数时候，事情不是那么明显，很多框架试图用某种形式在JS中"实现"OOP，但是实际上，JS本身是OO的（ECMA262中明确指出来的，不像某些人所说是基于对象云云）只是有一些语法跟Java等语言不同。那么显然这些OOP的"实现"其实是跟上面的例子一样的道理。另一个例子是Array.prototype.clone

Array.prototype.clone=function(){

return this.slice();

}

2.慎用prototype扩展

很多框架利用修改原生对象的prototype来做语言扩展，但我认为应当小心地看待这件事，毫无疑问这将造成一定的命名污染，你无法保证框架的使用者或者与你的框架共存的其他框架不会使用同样的名字来完成其他的事情。特别需要注意的是，Object和Array这两个对象的prototype扩展格外的危险，对Object来说，如果Object被修改，那么框架的使用者将无法创建一个未被修改的干净的对象，这是一个致命的问题，尤其如果你的使用者喜欢用forin来反射一个对象的属性。Array.prototype修改的危险来自js一个不知有意还是无意的小小设计，对原生的Array来说，任何情况下for和forin的遍历结果是相同的，而因为无法控制自定义的属性是不可枚举的，任何Array.prototype的修改都会破坏这种特性。一方面，我认为不应当推荐用forin遍历数组，这其中包含着错误的语义。另一方面，框架的设计者必须尊重这些使用者，因为对于ECMA所定义的语法而言，它是正确的做法。其中包含着这样一个简单的事实：假如你的框架中修改了Array.prototype，那么一些之前能正确工作的代码变得不可正确工作。

直接修改prototype看上去非常诱人，但是在考虑它之前应当先考虑两种可能的方案：

(1)函数

提供一个以对象为第一个参数的函数比如 Array.prototype.each =

function ForEach(arr,f)

{

if(arr instanceof Array)/*...*/;

}

(2)继承

以return的形式继承一个内置对象 比如考虑Array.prototype.each=

function ArrayCollection()

{

var r=Array.apply(this,arguments);

r.each=function(){/*......*/};

return r;

}

套用一句名言，不要修改原生对象的prototype，除非你认为必要。不过修改原生对象的prototype确实有一些特殊的用途（就是"必要的情况"），主要体现在2点：文字量支持和链式表达。举一个例子可以体现这两点：

var cf=function f(a,b,c,d)

{

/*........*/

}.$curry(3,4).$curry(5).$run();

如果希望实现类似上面的表达方式，可能就需要扩展Function.prototype，权衡一下的话，如果你认为命名污染的代价是值得的，那么也是可以提供给使用者的。

一个比较讨巧的办法是把选择权利交给使用者，提供一个扩展器：

function FunctionExtend()

{

this.$curry=function(){/*......*/};

this.$run=function(){/*......*/};

}

如果用户喜欢可以FunctionExtend.apply(Function.prototype); 如果不喜欢扩展 则可以

var r=function(){/*......*/};

FunctionExtend.apply(r);

3.保持和原生对象的一致

不知你有没有注意到，内置对象Function Array等都有这样的性质：

new Function()跟Function的结果完全一致（String Number Boolean这种封装型对象没有这样的性质）

如果框架中提供的类也具有这种性质，会是不错的选择。这仅仅是一个例子，如果你注意到了其他细节，并且让框架中的类和原生对象保持一致，对使用者来说是非常有益的。

4.尊重语言 尊重用户

编写框架应该尊重依赖的语言环境，在对原有的元素修改之前，首先应该考虑到原来的合理性，任何语言的原生环境提供的都是经过了精心设计的，在任何修改之前，至少应该考虑这几点：效率、命名规范、必要性、与其他功能是否重复。如果你没有付出至少跟语言的设计者相当的工作量，你的做法就是欠考虑的。

编写框架也应该尊重用户的所有习惯，将编写者的喜好强加给使用者并不是框架应该做的事情。框架应该保证大部分在没有框架环境下能运行的代码都能在框架下正常工作，这样用户不必为了使用你的框架而修改原有的代码。

5.规范命名和使用命名空间

减少命名污染可以让你的框架跟其他框架更好地共存。很多框架使用了命名空间来管理，这是良好的设计。命名应该是清晰且有实际意义的英文单词，如前面3所述，为了保持和原生对象的一致，命名规则最好贴近原生对象，比如类名第一字母大写，方法名用驼峰命名。捎带一提prototype中的$实在是非常糟糕的设计，无法想象$出现的目的仅仅是为了让使用者少写几个字母。这种事情应该交给你的用户在局部代码中使用

Q3: JavaScript清除历史记录的一点问题

1.不要做任何假设

（JavaScript是一个不可靠的助手）

可能不唐突的JavaScript 的最重要的一个特性就是——你要停止任何假设：

* 不要假设JavaScript是可用的，你最好认为它很有可能是不可用的，而不是直接依赖于它。

* 在你经过测试确认一些方法和属性可以使用之前，不要假设浏览器支持它们。

* 不要假设HTML代码如你想象的那样正确，每次都要进行检查，并且当其不可用的时候就什么也不要做。

* 让JavaScript的功能独立于输入设备

* 要记住其他的脚本可能会影响你的JavaScript的功能，所以要保证你的脚本的作用域尽可能地安全。

在开始设计你的脚本之前，要考虑的第一件事情就是检查一下你要为其编写脚本的HTML代码，看看有什么东西可以帮助你达到目的。

2.找出钩子和节点关系

（HTML是脚本的基石）

在开始编写脚本之前，要先看一下你要为之编写JavaScript的HTML。如果HTML是未经组织的或者未知的，那么你几乎不可能有一个好的脚本编写方案——很可能就会出现下面的情况：要么是会用JavaScript创建太多标记，要么就是应用太依赖于JavaScript。

在HTML中有一些东西需要考虑，那就是钩子和节点关系。

1.HTML 钩子

HTML最初的和最重要的钩子就是ID，而且ID可以通过最快的DOM方法——getElementById 访问到。如果在一个有效的HTML文档中所有的ID都是独一无二的话（在IE中关于name 和 ID 有一个bug，不过有些好的类库解决了这个问题），使用ID就是安全可靠的，并且易于测试。

其他一些钩子就是是HTML元素和CSS类，HTML元素可以通过getElementsByTagName方法访问，而在多数浏览器中都还不能通过原生的DOM方法来访问CSS类。不过，有很多外部类库提供了可以访问CSS类名（类似于 getElementsByClassName） 的方法。

2.HTML 节点关系

关于HTML的另外比较有意思的一点就是标记之间的关系，思考下面的问题：

* 要怎样才可以最容易地、通过最少的DOM遍历来到达目标节点？

* 通过修改什么标记，可以尽可能多地访问到需要修改的子节点？

* 一个给定的元素有什么属性或信息可以用来到达另外一个元素？

遍历DOM很耗资源而且速度很慢，这就是为什么要尽量使用浏览器中已经在使用的技术来做这件事情。

3.把遍历交给专家来做

（CSS，更快地遍历DOM）

有关DOM的脚本和使用方法或属性（getElementsByTagName, nextSibling, previousSibling, parentNode以及其它）来遍历DOM似乎迷惑了很多人，这点很有意思。而有趣的是，我们其实早已经通过另外一种技术—— CSS ——做了这些事情。

CSS 是这样一种技术，它使用CSS选择器，通过遍历DOM来访问目标元素并改变它们的视觉属性。一段复杂的使用DOM的JavaScript可以用一个CSS选择器取代：

Java代码 var n = document.getElementById('nav'); if(n){ var as = n.getElementsByTagName('a'); if(as.length 0){ for(var i=0;as[i];i++){ as[i].style.color = ‘#369′; as[i].style.textDecoration = ‘none’; } } } /* 下面的代码与上面功能一样 */ #nav a{ color:#369; text-decoration:none; } var n = document.getElementById('nav'); if(n){ var as = n.getElementsByTagName('a'); if(as.length 0){ for(var i=0;as[i];i++){ as[i].style.color = ‘#369′; as[i].style.textDecoration = ‘none’; } } } /* 下面的代码与上面功能一样 */ #nav a{ color:#369; text-decoration:none; }

这是一个可以好好利用的很强大的技巧。你可以通过动态为DOM中高层的元素添加class 或者更改元素ID来实现这一点。如果你使用DOM为文档的body添加了一个CSS类，那么设计师就很可以容易地定义文档的静态版本和动态版本。

Java代码 JavaScript: var dynamicClass = 'js'; var b = document.body; b.className = b.className ? b.className + ' js' : 'js'; CSS: /* 静态版本 */ #nav { .... } /* 动态版本 */ body.js #nav { .... } JavaScript: var dynamicClass = 'js'; var b = document.body; b.className = b.className ? b.className + ' js' : 'js'; CSS: /* 静态版本 */ #nav { .... } /* 动态版本 */ body.js #nav { .... }

4.理解浏览器和用户

（在既有的使用模式上创建你所需要的东西）

不唐突的JavaScript 中很重要的一部分就是理解浏览器是如何工作的（尤其是浏览器是如何崩溃的）以及用户期望的是什么。不考虑浏览器你也可以很容易地使用JavaScript 创建一个完全不同的界面。拖拽界面，折叠区域，滚动条和滑动块都可以使用JavaScript创建，但是这个问题并不是个简单的技术问题，你需要思考下面的问题：

* 这个新界面可以独立于输入设备么？如果不能，那么可以依赖哪些东西？

* 我创建的这个新界面是否遵循了浏览器或者其它富界面的准则（你可以通过鼠标在多级菜单中直接切换吗？还是需要使用tab键？）

* 我需要提供什么功能但是这个功能是依赖于JavaScript的?

最后一个问题其实不是问题，因为如果需要你就可以使用DOM来凭空创建HTML。关于这点的一个例子就是“打印”链接，由于浏览器没有提供一个非 JavaScript的打印文档功能，所以你需要使用DOM来创建这类链接。同样地，一个实现了展开和收缩内容模块的、可以点击的标题栏也属于这种情况。标题栏不能被键盘激活，但是链接可以。所以为了创建一个可以点击的标题栏你需要使用JavaScript将链接加入进去，然后所有使用键盘的用户就可以收缩和展开内容模块了。

解决这类问题的极好的资源就是设计模式库。至于要知道浏览器中的哪些东西是独立于输入设备的，那就要靠经验的积累了。首先你要理解的就是事件处理机制。

5.理解事件

（事件处理会引起改变）

事件处理是走向不唐突的JavaScript的第二步。重点不是让所有的东西都变得可以拖拽、可以点击或者为它们添加内联处理，而是理解事件处理是一个可以完全分离出来的东西。我们已经将HTML,CSS和JavaScript分离开来，但是在事件处理的分离方面却没有走得很远。

事件处理器会监听发生在文档中元素上的变化，如果有事件发生，处理器就会找到一个很奇妙的对象（一般会是一个名为e的参数），这个对象会告诉元素发生了什么以及可以用它做什么。

对于大多数事件处理来说，真正有趣的是它不止发生在你想要访问的元素上，还会在DOM中较高层级的所有元素上发生（但是并不是所有的事件都是这样，focus和blur事件是例外）。举例来说，利用这个特性你可以为一个导航列表只添加一个事件处理器，并且使用事件处理器的方法来获取真正触发事件的元素。这种技术叫做事件委托，它有几点好处：

* 你只需要检查一个元素是否存在，而不需要检查每个元素

* 你可以动态地添加或者删除子节点而并不需要删除相应的事件处理器

* 你可以在不同的元素上对相同的事件做出响应

需要记住的另一件事是，在事件向父元素传播的时候你可以停止它而且你可以覆写掉HTML元素（比如链接）的缺省行为。不过，有时候这并不是个好主意，因为浏览器赋予HTML元素那些行为是有原因的。举个例子，链接可能会指向页面内的某个目标，不去修改它们能确保用户可以将页面当前的脚本状态也加入书签。

6.为他人着想

（命名空间，作用域和模式）

你的代码几乎从来不会是文档中的唯一的脚本代码。所以保证你的代码里没有其它脚本可以覆盖的全局函数或者全局变量就显得尤为重要。有一些可用的模式可以来避免这个问题，最基础的一点就是要使用 var 关键字来初始化所有的变量。假设我们编写了下面的脚本：

Java代码 var nav = document.getElementById('nav'); function init(){ // do stuff } function show(){ // do stuff } function reset(){ // do stuff } var nav = document.getElementById('nav'); function init(){ // do stuff } function show(){ // do stuff } function reset(){ // do stuff }

上面的代码中包含了一个叫做nav的全局变量和名字分别为 init,show 和 reset 的三个函数。这些函数都可以访问到nav这个变量并且可以通过函数名互相访问：

Java代码 var nav = document.getElementById('nav'); function init(){ show(); if(nav.className === 'show'){ reset(); } // do stuff } function show(){ var c = nav.className; // do stuff } function reset(){ // do stuff } var nav = document.getElementById('nav'); function init(){ show(); if(nav.className === 'show'){ reset(); } // do stuff } function show(){ var c = nav.className; // do stuff } function reset(){ // do stuff }

你可以将代码封装到一个对象中来避免上面的那种全局式编码，这样就可以将函数变成对象中的方法，将全局变量变成对象中的属性。 你需要使用“名字+冒号”的方式来定义方法和属性，并且需要在每个属性或方法后面加上逗号作为分割符。

Java代码 var myScript = { nav:document.getElementById('nav'), init:function(){ // do stuff }, show:function(){ // do stuff }, reset:function(){ // do stuff } } var myScript = { nav:document.getElementById('nav'), init:function(){ // do stuff }, show:function(){ // do stuff }, reset:function(){ // do stuff } }

所有的方法和属性都可以通过使用“类名+点操作符”的方式从外部和内部访问到。

Java代码 var myScript = { nav:document.getElementById('nav'), init:function(){ myScript.show(); if(myScript.nav.className === 'show'){ myScript.reset(); } // do stuff }, show:function(){ var c = myScript.nav.className; // do stuff }, reset:function(){ // do stuff } } var myScript = { nav:document.getElementById('nav'), init:function(){ myScript.show(); if(myScript.nav.className === 'show'){ myScript.reset(); } // do stuff }, show:function(){ var c = myScript.nav.className; // do stuff }, reset:function(){ // do stuff } }

这种模式的缺点就是，你每次从一个方法中访问其它方法或属性都必须在前面加上对象的名字，而且对象中的所有东西都是可以从外部访问的。如果你只是想要部分代码可以被文档中的其他脚本访问，可以考虑下面的模块（module）模式：

Java代码 var myScript = function(){ //这些都是私有方法和属性 var nav = document.getElementById('nav'); function init(){ // do stuff } function show(){ // do stuff } function reset(){ // do stuff } //公有的方法和属性被使用对象语法包装在return 语句里面 return { public:function(){ }, foo:'bar' } }(); var myScript = function(){ //这些都是私有方法和属性 var nav = document.getElementById('nav'); function init(){ // do stuff } function show(){ // do stuff } function reset(){ // do stuff } //公有的方法和属性被使用对象语法包装在return 语句里面 return { public:function(){ }, foo:'bar' } }();

你可以使用和前面的代码同样的方式访问返回的公有的属性和方法，在本示例中可以这么访问：myScript.public() 和 myScript.foo 。但是这里还有一点让人觉得不舒服：当你想要从外部或者从内部的一个私有方法中访问公有方法的时候，还是要写一个冗长的名字（对象的名字可以非常长）。为了避免这一点，你需要将它们定义为私有的并且在return语句中只返回一个别名：

Java代码 var myScript = function(){ // 这些都是私有方法和属性 var nav = document.getElementById('nav'); function init(){ // do stuff } function show(){ // do stuff // do stuff } function reset(){ // do stuff } var foo = 'bar'; function public(){ } var myScript = function(){ // 这些都是私有方法和属性 var nav = document.getElementById('nav'); function init(){ // do stuff } function show(){ // do stuff // do stuff } function reset(){ // do stuff } var foo = 'bar'; function public(){ }

//只返回指向那些你想要访问的私有方法和属性的指针

Java代码 return { public:public, foo:foo } }(); return { public:public, foo:foo } }();

这就保证了代码风格一致性，并且你可以使用短一点的别名来访问其中的方法或属性。

如果你不想对外部暴露任何的方法或属性，你可以将所有的代码封装到一个匿名方法中，并在它的定义结束后立刻执行它：

Java代码 (function(){ // these are all private methods and properties var nav = document.getElementById('nav'); function init(){ // do stuff show(); // 这里不需要类名前缀 } function show(){ // do stuff } function reset(){ // do stuff } })(); (function(){ // these are all private methods and properties var nav = document.getElementById('nav'); function init(){ // do stuff show(); // 这里不需要类名前缀 } function show(){ // do stuff } function reset(){ // do stuff } })();

对于那些只执行一次并且对其它函数没有依赖的代码模块来说，这种模式非常好。

通过遵循上面的那些规则，你的代码更好地为用户工作，也可以使你的代码在机器上更好地运行并与其他开发者的代码和睦相处。不过，还有一个群体需要考虑到。

7.为接手的开发者考虑

（使维护更加容易）

使你的脚本真正地unobtrusive的最后一步是在编写完代码之后仔细检查一遍，并且要照顾到一旦脚本上线之后要接手你的代码的开发者。考虑下面的问题：

* 所有的变量和函数名字是否合理并且易于理解？

* 代码是否经过了合理的组织？从头到尾都很流畅吗？

* 所有的依赖都显而易见吗？

* 在那些可能引起混淆的地方都添加了注释吗？

最重要的一点是：要认识到文档中的HTML和CSS代码相对于JavaScript来说更有可能被改变（因为它们负责视觉效果）。所以不要在脚本代码中包含任何可以让终端用户看到的class和ID，而是要将它们分离出来放到一个保存配置信息的对象中。

Java代码 myscript = function(){ var config = { navigationID:'nav', visibleClass:'show' }; var nav = document.getElementById(config.navigationID); function init(){ show(); if(nav.className === config.visibleClass){ reset(); }; // do stuff }; function show(){ var c = nav.className; // do stuff }; function reset(){ // do stuff }; }(); myscript = function(){ var config = { navigationID:'nav', visibleClass:'show' }; var nav = document.getElementById(config.navigationID); function init(){ show(); if(nav.className === config.visibleClass){ reset(); }; // do stuff }; function show(){ var c = nav.className; // do stuff }; function reset(){ // do stuff }; }();

这样维护者就知道去哪里修改这些属性，而不需要改动其他代码。

Q4: 在js中事件和事件属性各指的是什么？二者有何区别？

事件：

是js中特有的东西。js就是基于事件驱动的一门语言。

想一下js的实现，都（大多数）是通过用户与浏览器的交互，比如你点击某个控件，鼠标放上，ajax请求等等，你的这些操作其实都是触发了js中定义的具体的事件，你可以给具体的事件绑定处理事件的函数。

我们常用的事件有：click，mouseover，mouseout等等。

事件属性：

表示的是具体的事件的一些特性，这些属性是让你更好的去控制这个事件，比如点击事件有属性可以判断点击的位置，点击时候是不是按下了哪个键盘按键，点击是鼠标左键还是鼠标右键。

关于事件的一些知识，强烈建议你去看下《javascript权威指南》，里面对事件，事件属性，事件目标，事件触发等等各种含义都解释的相当到位，相信你看了一定有帮助。

同时很希望帮到你，看到下面专家的回答，我压力还是蛮大的，真心希望我的回答能解决你的问题。