javascript 构建模块化开发过程解析

来源:脚本之家  责任编辑:小易  

JS文件应该存放在相同的地方。每个文本调不同的JS不就好了吗?

在使用 sea.js 、require.js 、 angular 的时候。

不仅仅是js,任何语言的项目都需要模块开发。只是不同语言,有着不同的体现,或者说呈现方式。模

我们使用到 define 、 module(require) 的方式,定义模块,和依赖模块

可维护性 灵活架构,焦点分离 方便模块间组合、分解 方便单个模块功能调试、升级 多人协作互不

下面给出 define 和 module 的简单实现。 其本质,就是往一个对象上面添加方法

模块化和合并,是矛和盾的问题。模块化,属于拆;合并,自然是合。你使用了矛,自然损失了部分盾的功能

var F = {}; F.define = function(str,fn){ var parts = str.split("."); var parent = this; // parent 当前模块的父模块 var i = len = 0; //如果第一个模块是模块单体对象,则移除 if(parts[0] == "F"){ parts = parts.slice(1); } //屏蔽对 define module 模块方法重写 if(parts[0] == "define" || parts[0] == "module"){ return ; } for(len = parts.length; i < len-1; i++){ //如果父模块中不存在当前模块 if(typeof parent[parts[i]] === 'undefined'){ //声明当前模块 parent[parts[i]] = {}; } //缓存下一层父模块 parent = parent[parts[i]]; } if(fn && parts[i]){ //如果给定模块方法,则绑定该模块的方法, parent[parts[i]] = fn(); } return this; } F.module = function(){ var args = [].slice.call(arguments);//复制参数 var fn = args.pop(); //获取回调 var parts = args[0] && args[0] instanceof Array ? args[0] : args; //模块的依赖 var modules = []; //模块的路由 var modIDs = ""; //依赖模块的索引 var i = 0; var len = parts.length; // 依赖模块的长度 var parent,j,jlen; //父级模块,模块路由层级索引,模块路由层级长度 while(i < len){ if(typeof parts[i] == "string"){ parent = this; //解析路由,并且屏蔽掉 F modIDs = parts[i].replace(/^F\./,"").split("."); //遍历模块层级 for( j = 0,jlen = modIDs.length; j < jlen; j++){ //迭代 父模块 parent = parent[modIDs[j]] || false; } modules.push(parent); //将模块添加到依赖列表 }else{ //直接将模块添加到依赖列表 modules.push(parts[i]); } //取下一个模块 i++; } //执行回调,将依赖的模块注入 fn.apply(null,modules); } //定义 string 模块 F.define("string",function(){ return { trim(str){ return str.replace(/^s+|\s+$/g,""); } } }); //定义 string 模块,的子模块 sub F.define("string.sub",function(){ return { low(str){ return str.toLowerCase(); } } }); console.log(F); //使用模块 F.module(["string","string.sub",document],function(str,strSub,doc){ console.log(str,strSub,doc) });

个人认为不是很有必要。 很多时候是设计切图前端后端同时开发,seajs或者requirejs除了可以

当然了,这里使用的,F 对象,实际应用中,应该写在闭包里面。不能让外界直接访问,于是有如下代码。

诺兰,他是真正的电影大师,我们称他诺兰大神。《盗梦空间》《星际穿越》都是他神一级的代表作,因为无数的诺兰迷爱上他。而今,他的又一力作《敦刻尔克》即将于中国观众见面,相信无数的粉丝已经摩拳擦掌协调时间跟友人一起准备走进影院。当下《敦刻尔克》在美国已经拿下1.7亿美金的票房,全球票房4亿美金,在中国,它能拿下多少票房呢?相信这是众多影迷所关心的话题,电影已经看过,笔者认为,《敦刻尔克》是一部伟大的电影,但它的票房不会大爆,这局限于它的类型,因为这类型的影片在中国没有大爆的先例。虽然,诺兰说《敦刻尔克》不是一部战争片,而是一部悬疑片。笔者更为期待国产片《红海行动》,因为《战狼2》的大爆让更多的人会对

var Sea = (function(){ var F = {}; F.define = function(str,fn){ var parts = str.split("."); var parent = this; // parent 当前模块的父模块 var i = len = 0; //如果第一个模块是模块单体对象,则移除 if(parts[0] == "F"){ parts = parts.slice(1); } //屏蔽对 define module 模块方法重写 if(parts[0] == "define" || parts[0] == "module"){ return ; } for(len = parts.length; i < len-1; i++){ //如果父模块中不存在当前模块 if(typeof parent[parts[i]] === 'undefined'){ //声明当前模块 parent[parts[i]] = {}; } //缓存下一层父模块 parent = parent[parts[i]]; } if(fn && parts[i]){ //如果给定模块方法,则绑定该模块的方法, parent[parts[i]] = fn(); } return this; } F.module = function(){ var args = [].slice.call(arguments);//复制参数 var fn = args.pop(); //获取回调 var parts = args[0] && args[0] instanceof Array ? args[0] : args; //模块的依赖 var modules = []; //模块的路由 var modIDs = ""; //依赖模块的索引 var i = 0; var len = parts.length; // 依赖模块的长度 var parent,j,jlen; //父级模块,模块路由层级索引,模块路由层级长度 while(i < len){ if(typeof parts[i] == "string"){ parent = this; //解析路由,并且屏蔽掉 F modIDs = parts[i].replace(/^F\./,"").split("."); //遍历模块层级 for( j = 0,jlen = modIDs.length; j < jlen; j++){ //迭代 父模块 parent = parent[modIDs[j]] || false; } modules.push(parent); //将模块添加到依赖列表 }else{ //直接将模块添加到依赖列表 modules.push(parts[i]); } //取下一个模块 i++; } //执行回调,将依赖的模块注入 fn.apply(null,modules); } return { define:function(){ F.define.apply(F,arguments); }, module:function(){ F.module.apply(F,arguments); } } })(); //定义 string 模块 Sea.define("string",function(){ return { trim(str){ return str.replace(/^s+|\s+$/g,""); } } }); //定义 string 模块,的子模块 sub Sea.define("string.sub",function(){ return { low(str){ return str.toLowerCase(); } } }); console.log(Sea); //使用模块 Sea.module(["string","string.sub",document],function(str,strSub,doc){ console.log(str,strSub,doc) });

邓婕是87红楼梦王熙凤的扮演者。当年87红楼梦播出以后,邓婕的王熙凤是受争议最小的!一直到现在都是一片赞扬和夸奖。如今邓婕已经是60岁了!617晚会现场,她从容大气淡定!这是邓婕的爱人张国立!当年邓婕嫁给张国立的时候,张国立还是一个无名小卒,邓婕在大红大紫之际下嫁给张国立!邓婕嫁给张国立之后,努力扶持张国立事业,张国立到北京什么东西都没有,想吃香烟一直都是邓婕买给他。张国立成功后,邓婕成了他背后的女人。默默支持他!617经常不在家的张国立,为了尽家属的责任跑来参加红楼梦60周年主持。邓婕这一生最可惜就是没有一个孩子!因为张国立奋斗事业经常不在家!把张默交给邓婕一人,为了给儿子张默完整母爱,张国

扩展阅读,根据您访问的内容系统为您准备了以下内容,希望对您有帮助。

如何正确理解javascript的模块化

模块化在项目中十分的重要,一个复杂的项目肯定有很多相似的功能模块,如果每次都需要重新编写模块肯定既费时又耗力。但是引用别人编写模块的前提是要有统一的“打开姿势”,如果每个人有各自的写法,那么肯定会乱套,下面介绍几种JS的模块化的规范。

一:模块化进程一:script标签

这是最原始的 JavaScript 文件加载方式,如果把每一个文件看做是一个模块,那么他们的接口通常是暴露在全局作用域下,也就是定义在 window 对象中,不同模块的接口调用都是一个作用域中,一些复杂的框架,会使用命名空间的概念来组织这些模块的接口。

缺点:

1、污染全局作用域

2、开发人员必须主观解决模块和代码库的依赖关系

3、文件只能按照script标签的书写顺序进行加载

4、在大型项目中各种资源难以管理,长期积累的问题导致代码库混乱不堪

二:模块化进程二:CommonJS规范

该规范的核心思想是允许模块通过require方法来同步加载所要依赖的其他模块,然后通过 exports 或 module.exports 来导出需要暴露的接口。

require("module");

require("../file.js");

exports.doStuff = function(){};

module.exports = someValue;

优点:

1、简单并容易使用

2、服务器端模块便于重用

缺点:

1、同步的模块加载方式不适合在浏览器环境中,同步意味着阻塞加载,浏览器资源是异步加载的

2、不能非阻塞的并行加载多个模块

module.exports与exports的区别

1、exports 是指向的 module.exports 的引用

2、module.exports 初始值为一个空对象 {},所以 exports 初始值也是 {}

3、require() 返回的是 module.exports 而不是 exports

exports示例:

// app.js

var circle = require('./circle');

console.log(circle.area(4));

// circle.js

exports.area = function(r){

return r * r * Math.PI;

}

module.exports示例:

// app.js

var area = require('./area');

console.log(area(4));

// area.js

module.exports = function(r){

return r * r * Math.PI;

}

错误的情况:

// app.js

var area = require('./area');

console.log(area(4));

// area.js

exports = function(r){

return r * r * Math.PI;

}

其实是对 exports 进行了覆盖,也就是说 exports 指向了一块新的内存(内容为一个计算圆面积的函数),也就是说 exports 和 module.exports 不再指向同一块内存,也就是说此时 exports 和 module.exports 毫无联系,也就是说 module.exports 指向的那块内存并没有做任何改变,仍然为一个空对象{},也就是说area.js导出了一个空对象,所以我们在 app.js 中调用 area(4) 会报 TypeError: object is not a function 的错误。

总结:当我们想让模块导出的是一个对象时, exports 和 module.exports 均可使用(但 exports 也不能重新覆盖为一个新的对象),而当我们想导出非对象接口时,就必须也只能覆盖 module.exports 。

三:模块化进程三:AMD规范

由于浏览器端的模块不能采用同步的方式加载,会影响后续模块的加载执行,因此AMD(Asynchronous Module Definition异步模块定义)规范诞生了。

AMD标准中定义了以下两个API

1、require([module], callback);

2、define(id, [depends], callback);

require接口用来加载一系列模块,define接口用来定义并暴露一个模块。

示例:

define("module", ["dep1", "dep2"], function(d1, d2){

return someExportedValue;

});

require(["module", "../file"], function(module, file){ /* ... */ });

优点:

1、适合在浏览器环境中异步加载模块

2、可以并行加载多个模块

缺点:

1、提高了开发成本,代码的阅读和书写比较困难,模块定义方式的语义不顺畅

2、不符合通用的模块化思维方式,是一种妥协的实现

四:模块化进程四:CMD规范

CMD(Common Module Definition)规范和AMD很相似,尽量保持简单,并与CommonJS和Node.js的 Modules 规范保持了很大的兼容性。在CMD规范中,一个模块就是一个文件。

示例:

define(function(require, exports, module){

var $ = require('jquery');

var Spinning = require('./spinning');

exports.doSomething = ...

module.exports = ...

})

优点:

1、依赖就近,延迟执行

2、可以很容易在 Node.js 中运行

缺点:

1、依赖 SPM 打包,模块的加载逻辑偏重

AMD和CMD的区别

AMD和CMD起来很相似,但是还是有一些细微的差别,让我们来看一下他们的区别在哪里:

1、对于依赖的模块,AMD是提前执行,CMD是延迟执行。

2、AMD推崇依赖前置;CMD推崇依赖就近,只有在用到某个模块的时候再去require。看代码:

// AMD

define(['./a', './b'], function(a, b){ // 依赖必须一开始就写好

a.doSomething()

// 此处略去 100 行

b.doSomething()

...

});

// CMD

define(function(require, exports, module){

var a = require('./a')

a.doSomething()

// 此处略去 100 行

var b = require('./b')

// 依赖可以就近书写

b.doSomething()

// ...

});

3、AMD 的 API 默认是一个当多个用,CMD 的 API 严格区分,推崇职责单一。

五:模块化进程五:ES6模块化

EcmaScript6标准增加了JavaScript语言层面的模块体系定义。ES6 模块的设计思想,是尽量的静态化,使得编译时就能确定模块的依赖关系,以及输入和输出的变量。CommonJS和AMD模块,都只能在运行时确定这些东西。

在 ES6 中,我们使用export关键字来导出模块,使用import关键字引用模块。需要说明的是,ES6的这套标准和目前的标准没有直接关系,目前也很少有JS引擎能直接支持。因此Babel的做法实际上是将不被支持的import翻译成目前已被支持的require。

尽管目前使用import和require的区别不大(本质上是一回事),但依然强烈推荐使用import关键字,因为一旦JS引擎能够解析ES6的import关键字,整个实现方式就会和目前发生比较大的变化。如果目前就开始使用import关键字,将来代码的改动会非常小。

示例:

import "jquery";

export functiondoStuff(){}

module "localModule" {}

优点:

1、容易进行静态分析

2、面向未来的 EcmaScript 标准

缺点:

1、原生浏览器端还没有实现该标准

2、全新的命令字,新版的 Node.js才支持

javascript模块化是什么及其优缺点介绍

如今backbone、emberjs、spinejs、batmanjs

等MVC框架侵袭而来。CommonJS、AMD、NodeJS、RequireJS、SeaJS、curljs等模块化的JavaScript扑面而

来。web前端已经演变成大前端,web前端的发展速度之快。

1)我们来看看什么是模块化?

模块化是一种将系统分离成独立功能部分的方法,可将系统分割成独立的功能部分,严格定义模块接口、模块间具有透明性。javascript中的模块在一些C、PHP、java中比较常见:

c中使用include 包含.h文件;php中使用require_once包含.php文件

java使用import导入包

此中都有模块化的思想。

2)模块化的优缺点:

a>优点:

可维护性

1.灵活架构,焦点分离

2.方便模块间组合、分解

3.方便单个模块功能调试、升级

4.多人协作互不干扰

可测试性

1.可分单元测试

b>缺点:

性能损耗

1.系统分层,调用链会很长

2.模块间通信,模块间发送消息会很耗性能

3)最近的项目中也有用到模块化,

使用的是seajs,但是当引用到jquery,jquery easyui/或者jquery

UI组件时,有可能会用到很多jquery插件,那这样要是实现一个很复杂的交互时,模块间的依赖会很多,使用define()方法引入模块会很多,不知

有么有什么好的方法?

4)附:

内聚度

内聚度指模块内部实现,它是信息隐藏和局部化概念的自然扩展,它标志着一个模块内部各成分彼此结合的紧密程度。好处也很明显,当把相关的任务分组后去阅读就容易多了。 设计时应该尽可能的提高模块内聚度,从而获得较高的模块独立性。

耦合度

耦合度则是指模块之间的关联程度的度量。耦合度取决于模块之间接口的复杂性,进入或调用模块的位置等。与内聚度相反,在设计时应尽量追求松散耦合的系统。

如何实现前端模块化开发

SeaJS 是一个适用于 Web 浏览器端的模块加载器。

使用 SeaJS,可以更好地组织 JavaScript 代码。

JavaScript模块化和可复用的代码,请教下面程序详细讲解

test是Array的变量,所以有个sort方法进行排序。

默认排序将元素转换为字符串以排序(这时11<3),所以此处传递一个函数来表示二者的大小关系。

这个函数在上面定义的。

sort是系统函数,在具体实现中应当为快速排序或在某些情况下使用堆排序。比较次数是不确定的,其数学期望为O(nlogn)。具体的实现你可以搜索快速排序去看看。

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

基础

我们首先简单地概述一下,自从三年前Eric Miraglia(YUI的开发者)第一次发表博客描述模块化模式以来的一些模块化模式。如果你已经对于这些模块化模式非常熟悉了,大可以直接跳过本节,从“进阶模式”开始阅读。

匿名闭包

这是一种让一切变为可能的基本结构,同时它也是Javascript最棒的特性。我们将简单地创建一个匿名函数并立即执行它。所有的代码将跑在这个函数内,生存在一个提供私有化的闭包中,它足以使得这些闭包中的变量能够贯穿我们的应用的整个生命周期。

复制代码 代码如下:

(function () {

// ... all vars and functions are in this scope only

// still maintains access to all globals

}());

注意这对包裹匿名函数的最外层括号。因为Javascript的语言特性,这对括号是必须的。在js中由关键词function开头的语句总是会被认为是函数声明式。把这段代码包裹在括号中就可以让解释器知道这是个函数表达式。

全局变量导入

Javascript有一个特性叫做隐式全局变量。无论一个变量名在哪儿被用到了,解释器会根据作用域链来反向找到这个变量的var声明语句。如果没有找到var声明语句,那么这个变量就会被视为全局变量。如果这个变量用在一句赋值语句中,同时这个变量又不存在时,就会创建出一个全局变量。这意味着在匿名闭包中使用或创建全局变量是很容易的。不幸的是,这会导致写出的代码极难维护,因为对于人的直观感受来说,一眼根本分不清那些是全局的变量。

幸运的是,我们的匿名函数提供了简单的变通方法。只要将全局变量作为参数传递到我们的匿名函数中,就可以得到比隐式全局变量更清晰又快速的代码了。下面是示例:

复制代码 代码如下:

(function ($, YAHOO) {

// now have access 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 access 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, access 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 access to _private, _seal, and _unseal

return my;

}(MODULE || {}));

所有文件可以在它们各自的_private变量上设置属性,并且它理解可以被其他文件访问。一旦这个模块加载完成,应用程序可以调用MODULE._seal()来防止外部对内部_private的调用。如果这个模块需要被重新放大,在任何一个文件中的内部方法可以在加载新的文件前调用_unseal(),并在新文件执行好以后再次调用_seal()。我如今在工作中使用这种模式,而且我在其他地方还没有见过这种方法。我觉得这是一种非常有用的模式,很值得就这个模式本身写一篇文章。

子模块

我们的最后一种进阶模式是显而易见最简单的。创建子模块有许多优秀的实例。这就像是创建一般的模块一样:

复制代码 代码如下:

MODULE.sub = (function () {

var my = {};

// ...

return my;

}());

虽然这看上去很简单,但我觉得还是值得在这里提一提。子模块拥有一切一般模块的进阶优势,包括了放大模式和私有化状态。

  • 本文相关:
  • 详解js中的模块化是如何实现的
  • 详谈js模块化规范
  • 关于js模块化的知识点分享
  • 详解webpack自动生成html页面
  • 使用原生js实现页面蒙灰(mask)效果示例代码
  • javascript函数节流概念与用法实例详解
  • 浅谈react-router@4.0 使用方法和源码分析
  • js弹出层包含flash 不能关闭隐藏的2种处理方法
  • 解析js原生方法创建表格效率测试
  • ajax 仿excel表格功能
  • 微信小程序webview与h5通过postmessage实现实时通讯的实现
  • 详解javascript的bug和错误
  • js弹出框、对话框、提示框、弹窗实现方法总结(推荐)
  • 如何正确理解javascript的模块化
  • javascript模块化是什么及其优缺点介绍
  • 如何实现前端模块化开发
  • JavaScript模块化和可复用的代码,请教下面程序详细讲解
  • js的模块化编程有哪些方式
  • 大型项目中javascript模块化开发完成后,javascript打包上线流程是怎么样的?
  • js为什么需要模块化开发
  • javascript模块化是什么?优缺点有哪些?
  • js模块化开发怎样处理后加载的问题
  • requrejs做模块化开发有什么问题
  • 免责声明 - 关于我们 - 联系我们 - 广告联系 - 友情链接 - 帮助中心 - 频道导航
    Copyright © 2017 www.zgxue.com All Rights Reserved