labjsjs的模块化编程有哪些方式

Node.js是属于前端还是后端的技术

首先你得了解什么nodejs，其次了解什么后端技术及作用 1.node.js组成:谷歌浏览器的V8引擎、C++语言编写的,本质上是一个JavaScript的运行环境。

提到js,就能想到浏览器里面的各种交互组件,异步请求等等，它们依靠浏览器JavaScript 的引擎,来解析页面的js代码。

2.目前流行的后端语言就是PHP、Java、.Net，使用后端语言实现服务器上的开发叫做后端技术。

3.nodejs就是让JavaScript(js)可以实现服务器上的开发。

4.JavaScript(前端语言)+nodejs(JavaScript的运行环境)=实现服务器上的开发(后端技术)，也就是说js+nodejs实现了后端开发的技术

labjs，requirejs，sea.js 哪个最好用？为什么

LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。

LABjs 是一个文件加载器。

RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更简单自然。

模块加载器一般可降级为文件加载器用，因此使用 RequireJS 和 SeaJS，也可以达成 LABjs 的性能优化目的。

RequireJS 和 SeaJS 都是很不错的模块加载器，两者区别如下： 1. 两者定位有差异。

RequireJS 想成为浏览器端的模块加载器，同时也想成为 Rhino / Node 等环境的模块加载器。

SeaJS 则专注于 Web 浏览器端，同时通过 Node 扩展的方式可以很方便跑在 Node 服务器端 2. 两者遵循的标准有差异。

RequireJS 遵循的是 AMD（异步模块定义）规范，SeaJS 遵循的是 CMD （通用模块定义）规范。

规范的不同，导致了两者 API 的不同。

SeaJS 更简洁优雅，更贴近 CommonJS Modules/1.1 和 Node Modules 规范。

3. 两者社区理念有差异。

RequireJS 在尝试让第三方类库修改自身来支持 RequireJS，目前只有少数社区采纳。

SeaJS 不强推，而采用自主封装的方式来“海纳百川”，目前已有较成熟的封装策略。

4. 两者代码质量有差异。

RequireJS 是没有明显的 bug，SeaJS 是明显没有 bug。

5. 两者对调试等的支持有差异。

SeaJS 通过插件，可以实现 Fiddler 中自动映射的功能，还可以实现自动bo 等功能，非常方便便捷。

RequireJS 无这方面的支持。

6. 两者的插件机制有差异。

RequireJS 采取的是在源码中预留接口的形式，源码中留有为插件而写的代码。

SeaJS 采取的插件机制则与 Node 的方式一致：开放自身，让插件开发者可直接访问或修改，从而非常灵活，可以实现各种类型的插件。

还有不少细节差异就不多说了。

总之，SeaJS 从 API 到实现，都比 RequireJS 更简洁优雅。

如果说 RequireJS 是 Prototype 类库的话，则 SeaJS 是 jQuery 类库。

最后，向 RequireJS 致敬！RequireJS 和 SeaJS 是好兄弟，一起努力推广模块化开发思想，这才是最重要的。

如何把相对地址转换为绝对地址

在看LABjs源代码时，发现里面有个将相对地址转为绝对地址的函数，将其拿出纪录如下： 复制代码代码如下: function canonical_uri(src, base_path) { var root_page = /^[^?#]*//.exec(location.href)[0], root_domain = /^w+:///?[^/]+/.exec(root_page)[0], absolute_regex = /^w+:///; // is `src` is protocol-relative (begins with // or ///), prepend protocol if (/^///?/.test(src)) { src = location.protocol + src; } // is `src` page-relative? (not an absolute URL, and not a domain-relative path, beginning with /) else if (!absolute_regex.test(src) && src.charAt(0) != "/") { // prepend `base_path`, if any src = (base_path || "") + src; } // make sure to return `src` as absolute return absolute_regex.test(src) ? src : ((src.charAt(0) == "/" ? root_domain : root_page) + src); }

js的模块化编程有哪些方式

基础 我们首先简单地概述一下，自从三年前Eric Miraglia（YUI的开发者）第一次发表博客描述模块化模式以来的一些模块化模式。

如果你已经对于这些模块化模式非常熟悉了，大可以直接跳过本节，从“进阶模式”开始阅读。

匿名闭包 这是一种让一切变为可能的基本结构，同时它也是Javascript最棒的特性。

我们将简单地创建一个匿名函数并立即执行它。

所有的代码将跑在这个函数内，生存在一个提供私有化的闭包中，它足以使得这些闭包中的变量能够贯穿我们的应用的整个生命周期。

复制代码 代码如下: (function () { // ... all vars and functions are in this scope only // still maintains ess to all globals }()); 注意这对包裹匿名函数的最外层括号。

因为Javascript的语言特性，这对括号是必须的。

在js中由关键词function开头的语句总是会被认为是函数声明式。

把这段代码包裹在括号中就可以让解释器知道这是个函数表达式。

全局变量导入 Javascript有一个特性叫做隐式全局变量。

无论一个变量名在哪儿被用到了，解释器会根据作用域链来反向找到这个变量的var声明语句。

如果没有找到var声明语句，那么这个变量就会被视为全局变量。

如果这个变量用在一句赋值语句中，同时这个变量又不存在时，就会创建出一个全局变量。

这意味着在匿名闭包中使用或创建全局变量是很容易的。

不幸的是，这会导致写出的代码极难维护，因为对于人的直观感受来说，一眼根本分不清那些是全局的变量。

幸运的是，我们的匿名函数提供了简单的变通方法。

只要将全局变量作为参数传递到我们的匿名函数中，就可以得到比隐式全局变量更清晰又快速的代码了。

下面是示例： 复制代码 代码如下: (function ($, YAHOO) { // now have ess to globals jQuery (as $) and YAHOO in this code }(jQuery, YAHOO)); 模块导出 有时你不仅想要使用全局变量，你还想要声明它们，以供反复使用。

我们可以很容易地通过导出它们来做到这一点——通过匿名函数的返回值。

这样做将会完成一个基本的模块化模式雏形，接下来会是一个完整的例子： 复制代码 代码如下: var MODULE = (function () { var my = {}, privateVariable = 1; function privateMethod() { // ... } my.moduleProperty = 1; my.moduleMethod = function () { // ... }; return my; }()); 注意我们已经声明了一个叫做MODULE的全局模块，它拥有2个公有的属性：一个叫做MODULE.moduleMethod的方法和一个叫做MODULE.moduleProperty的变量。

另外，它还维护了一个利用匿名函数闭包的、私有的内置状态。

同时，我们可以很容易地导入需要的全局变量，并像之前我们所学到的那样来使用这个模块化模式。

进阶模式 上面一节所描述的基础已经足以应对许多情况，现在我们可以将这个模块化模式进一步的发展，创建更多强大的、可扩展的结构。

让我们从MODULE模块开始，一一介绍这些进阶模式。

放大模式 整个模块必须在一个文件中是模块化模式的一个限制。

任何一个参与大型项目的人都会明白将js拆分多个文件的价值。

幸运的是，我们拥有一个很棒的实现来放大模块。

首先，我们导入一个模块，并为它添加属性，最后再导出它。

下面是一个例子——从原本的MODULE中放大它： 复制代码 代码如下: var MODULE = (function (my) { my.anotherMethod = function () { // added method... }; return my; }(MODULE)); 我们用var关键词来保证一致性，虽然它在此处不是必须的。

在这段代码执行完之后，我们的模块就已经拥有了一个新的、叫做MODULE.anotherMethod的公有方法。

这个放大文件也会维护它自己的私有内置状态和导入的对象。

宽放大模式 我们的上面例子需要我们的初始化模块最先被执行，然后放大模块才能执行，当然有时这可能也不一定是必需的。

Javascript应用可以做到的、用来提升性能的、最棒的事之一就是异步执行脚本。

我们可以创建灵活的多部分模块并通过宽放大模式使它们可以以任意顺序加载。

每一个文件都需要按下面的结构组织： 复制代码 代码如下: var MODULE = (function (my) { // add capabilities... return my; }(MODULE || {})); 在这个模式中，var表达式使必需的。

注意如果MODULE还未初始化过，这句导入语句会创建MODULE。

这意味着你可以用一个像LABjs的工具来并行加载你所有的模块文件，而不会被阻塞。

紧放大模式 宽放大模式非常不错，但它也会给你的模块带来一些限制。

最重要的是，你不能安全地覆盖模块的属性。

你也无法在初始化的时候，使用其他文件中的属性（但你可以在运行的时候用）。

紧放大模式包含了一个加载的顺序序列，并且允许覆盖属性。

这儿是一个简单的例子（放大我们的原始MODULE）： 复制代码 代码如下: var MODULE = (function (my) { var old_moduleMethod = my.moduleMethod; my.moduleMethod = function () { // method override, has ess to old through old_moduleMethod... }; return my; }(MODULE)); 我们在上面的例子中覆盖了MODULE.moduleMethod的实现，但在需要的时候，可以维护一个对原来方法的引用。

克隆与继承 复制代码 代码如下: var MODULE_TWO = (function (old) { var my = {}, key; for (key in old) { if (old.hasOwnProperty(key)) { my[key] = old[key]; } } var super_moduleMethod = old.moduleMethod; my.moduleMethod = function () { // override method on the clone, ess to super through super_moduleMethod }; return my; }(MODULE)); 这个模式可能是最缺乏灵活性的一种选择了。

它确实使得代码显得很整洁，但那是用灵活性的代价换来的。

正如我上面写的这段代码，如果某个属性是对象或者函数，它将不会被复制，而是会成为这个对象或函数的第二个引用。

修改了其中的某一个就会同时修改另一个（译者注：因为它们根本就是一个啊！）。

这可以通过递归克隆过程来解决这个对象克隆问题，但函数克隆可能无法解决，也许用eval可以解决吧。

因此，我在这篇文章中讲述这个方法仅仅是考虑到文章的完整性。

跨文件私有变量 把一个模块分到多个文件中有一个重大的限制：每一个文件都维护了各自的私有变量，并且无法访问到其他文件的私有变量。

但这个问题是可以解决的。

这里有一个维护跨文件私有变量的、宽放大模块的例子： 复制代码 代码如下: var MODULE = (function (my) { var _private = my._private = my._private || {}, _seal = my._seal = my._seal || function () { delete my._private; delete my._seal; delete my._unseal; }, _unseal = my._unseal = my._unseal || function () { my._private = _private; my._seal = _seal; my._unseal = _unseal; }; // permanent ess to _private, _seal, and _unseal return my; }(MODULE || {})); 所有文件可以在它们各自的_private变量上设置属性，并且它理解可以被其他文件访问。

一旦这个模块加载完成，应用程序可以调用MODULE._seal()来防止外部对内部_private的调用。

如果这个模块需要被重新放大，在任何一个文件中的内部方法可以在加载新的文件前调用_unseal()，并在新文件执行好以后再次调用_seal()。

我如今在工作中使用这种模式，而且我在其他地方还没有见过这种方法。

我觉得这是一种非常有用的模式，很值得就这个模式本身写一篇文章。

子模块 我们的最后一种进阶模式是显而易见最简单的。

创建子模块有许多优秀的实例。

这就像是创建一般的模块一样： 复制代码 代码如下: MODULE.sub = (function () { var my = {}; // ... return my; }()); 虽然这看上去很简单，但我觉得还是值得在这里提一提。

子模块拥有一切一般模块的进阶优势，包括了放大模式和私有化状态。