【原生】---模块化开发----node.js--------认识 CommonJS （模块化编程）

 模块化开发的重点是独立，内部不收到外部影响，通过传参改变获取信息

 

没有模块化开发时：，内部状态容易被外部修改

 var obj={
　　a:1, 
　　c:function () {

 }
 }       //这样写，内部状态可以被外部改写，

 

 模块化方法1： 方法模式

 模块化的扩展，
1、obj 作为参数，传入下面的函数中，赋值添加了d属性和e方法。
2、为什么可以对obj  进行扩展？  因为obj是对象，存在堆中，这样只是从操作的地址，地址修改了 上面的内容也引起了修改

 这样写的前提是知道obj   是已经存在的了

 

 

var obj=(function () {   //声明一个obj,模块化开发，这个obj  接受return 返回的值
            var i=0;       //闭包关系
            return {    //利用return把  函数的内容返回出去，返回的是一个对象{ }，对象里面有a:1,c:fucntion(）{  }
                a:1,
                c:function () {
                    
                }
            }
        })();    //（）  表示的是自执行，

       obj=(function (obj) {
            obj.d=10;
            obj.e=function () {

            };
            return obj;
        })(obj);     //0.1、把上面的obj当做参数传入

 

2、模块化方法2：宽放大模式

当不确定obj 是否存在的时候用这样的方法

 

//方法2：
    var obj=(function () {
            var i=0;
            return {
                a:1,
                c:function () {
                    
                }
            }
        })();

    obj=(function (obj) {
        obj.d=10;
        obj.e=function () {

        };
        return obj;
    })(obj || {});//宽放大   就是说，如果obj有就之前的obj，如果没有就给一个空对象
//详细解析一下：obj 要是存在，说明是真，（ || 或， 熔断？ 还记的不？） 就把obj当做参数参入，如果没有就给一个空对象传入

 

 

 

在node 中使用模块化开发

 

 2017，需要点这部从操作。如果用的是2018就不用了，因为自动的啦！！！

 

 

 

模块化开发中，
必不可少的，require（） 和 module.exports  
a.j、b.js、c.js  分别导出
在模块化开发中：

可以导出：对象、函数、类（类，只能es5能够导出，es6不能够到导出）

 从大体上了解一下：

 

 

 

下面代码介绍

1、模块化开发：  导出  对象           利用return导出的 对象

a.js  文件

module.exports=(function () {  //导出
    return {//  自执行，导出的是一个对象，对象属性/对象方法
        a:function () {  //对象方法
            console.log(this.b);  //打印对象属性
        },
        b:5  //对象属性
    }
})();//自执行

/*
导出的是一个对象

  return {//  自执行，导出的是一个对象，对象属性/对象方法
        a:function () {  //对象方法
            console.log(this.b);  //打印对象属性
        },
        b:5  //对象属性
    }


*/

 

 

 

2、模块化开发：  导出  函数          利用return导出的 函数

 b.js  文件

module.exports=(function () {  //导出
    return function () {//导出一个函数
        console.log("aaaa");//打印aaaa
    }
})();//自执行

/*
导出的是一个函数


 return function () {//导出一个函数
        console.log("aaaa");//打印aaaa
    }

*/

 

3、模块化开发：  导出  类          利用return导出的 类

 c.js   文件

module.exports=(function () {  //导出
    function Box() {  //Box  类
  
    }
    //object.assign  是什么还记得不？  复制，后面的方法给前面,
    Object.assign(Box.prototype,{  //Box.prototype  是原型，这样写的优点是，新增，如果不这样可能出现覆盖
        a:1, //属性
        b:2,
        play:function () { //方法
            console.log(this.a+this.b);
        }
    });
    return Box;   //导出的是Box
})(); //自执行函数

/*

类，只能es5能够导出，es6不能够到导出

*/

 

 

4、如何进入模块？  利用require （） 引入模块 

 

//导入方式
//node中的require就是同步加载
var obj=require("./a");   //
var fn=require("./b");
var Box=require("./c");
var http=require("http");  //这个在node  安装包里面
var queryString=require("querystring"); 
var request=require("request");
obj.a();//这样就可以执行 导入的var obj=require("./a");  文件中的a的方法
fn();  //执行第4行的代码
var b=new Box();  //实例化
b.play();  // 实例化 执行方法 


/*
一般的文件下引入都有路径

默认的引入没有路径，比如：http、querystring

后期会用到第三方的模块。

npm  i  "模块名称"    这样就下载了   （npm  install  "模块名称"）


*/

 

 

 

 

CommonJS，模块化开发介绍

2009年，美国程序员Ryan Dahl创造了node.js项目
这标志"Javascript模块化编程"正式诞生.当时在浏览器环境下，没有模块也不是特别大的问题，毕竟网页程序的复杂性有限；但是在服务器端，一定要有模块，与操作系统和其他应用程序互动，否则根本没法编程。ode.js的模块系统，就是参照CommonJS规范实现的。在CommonJS中，有一个全局性方法require()，用于加载模块。假定有一个数学模块math.js，就可以像下面这样加载。

　var math = require('math');

　var math = require('math');
　　math.add(2,3); // 5

注意此处是同步

 

 模块化规范

因为有了模块，我们就可以更方便地使用别人的代码，想要什么功能，就加载什么模块。
但是，这样做有一个前提，那就是大家必须以同样的方式编写模块，否则你有你的写法，我有我的写法，岂不是乱了套！考虑到Javascript模块现在还没有官方规范，这一点就更重要了。
目前，通行的Javascript模块规范共有两种：CommonJS和AMD

 js的加载

 

模块化开发

服务器 逐行执行 （同步的意思 ）  
require只能应用于同步加载（加载完毕了之后再去赋值）


CommonJS  （模块化编程）

全局方法  require( ) 用于加载模块   

定义这个方法就要用到，module.exports

 

 

 

 

总结：
1、介绍什么是模块化开发？
    
2、模块化开发的特点？
     模块化开发的重点是独立，内部不收到外部影响，通过传参改变获取信息
3、知道了什么是：  宽放大  （ obj || {}）
4、模块化的规范 ？