【澳门葡京】Javascript模块化编制程序,管理模块之间的依赖

一、为啥要利用require.js

1、为啥要运用require.js

一、为什么要用require.js?

一、为何要用require.js?

     
首先二个页面借使在加载多个js文件的时候,浏览器会停止网页渲染,加载文件越多,网页失去响应的时刻就会越长;其次,由于js文件之间存在依据关系,由此必须严苛保障加载顺序,当正视关系很复杂的时候,代码的编辑和珍重都会变得紧Baba。

     
首先2个页面假如在加载八个js文件的时候,浏览器会甘休网页渲染,加载文件越多,网页失去响应的时刻就会越长;其次,由于js文件之间存在依附关系,由此必须严俊管教加载顺序,当正视关系很复杂的时候,代码的编排和尊崇都会变得辛苦。

最早的时候,全部Javascript代码都写在叁个文件之中,只要加载那3个文件就够了。后来,代码更加多,叁个文书不够了,必须分成多少个公文,依次加载。上面包车型大巴网页代码,相信广大人都见过。

最早的时候,全数Javascript代码都写在贰个文件之中,只要加载这么些文书就够了。后来,代码愈多,3个文书不够了,必须分成四个公文,依次加载。上边包车型大巴网页代码,相信广大人都见过。

   
  require.js,正是为着解决那多个难点:

   
  require.js,正是为了解决那五个难题:

1   <script src="1.js"></script>
2   <script src="2.js"></script>
3   <script src="3.js"></script>
4   <script src="4.js"></script>
5   <script src="5.js"></script>
6   <script src="6.js"></script>

 

  <script src=”1.js”></script>
  <script src=”2.js”></script>
  <script src=”3.js”></script>
  <script src=”4.js”></script>
  <script src=”5.js”></script>
  <script src=”6.js”></script>

  1.   达成js文件的异步加载,幸免网页失去响应;  
  2.   处理模块之间的借助,便于代码的编纂和掩护。
  1.   达成js文件的异步加载,防止网页失去响应;  
  2.   管理模块之间的依赖,便于代码的编纂和掩护。

那段代码依次加载八个js文件。

这段代码依次加载多个js文件。

 

 

如此的写法有相当的大的欠缺。首先,加载的时候,浏览器会甘休网页渲染,加载文件更加多,网页失去响应的时日就会越长;其次,由于js文件之间存在依赖关系,由此必须严苛管教加载顺序(举例上例的一.js要在二.js的前头),正视性最大的模块一定要放置最后加载,当依赖关系很复杂的时候,代码的编写和保卫安全都会变得困苦。

诸如此类的写法有十分大的短处。首先,加载的时候,浏览器会截止网页渲染,加载文件越来越多,网页失去响应的时光就会越长;其次,由于js文件之间存在凭借关系,由此必须从严厉管制教加载顺序(举个例子上例的一.js要在二.js的先头),依赖性最大的模块一定要松手最后加载,当注重关系很复杂的时候,代码的编排和敬服都会变得劳累。

二、require.js的加载

二、require.js的加载

require.js的出世,正是为着消除那多个难点:

require.js的降生,便是为了消除那七个难点:

     
第二步,去官方网址下载最新版本,直接放到页面实行加载

     
第一步,去官方网址下载最新版本,直接放到页面进行加载

  澳门葡京 1

  (一)达成js文件的异步加载,制止网页失去响应;

  (二)管理模块之间的正视,便于代码的编写和保卫安全。

  澳门葡京 2

  (1)实现js文件的异步加载,制止网页失去响应;

  (二)管理模块之间的重视,便于代码的编写制定和保证。

 <script src="js/require.js"></script>  
 <script src="js/require.js"></script>  

二、require.js的加载

二、require.js的加载

     
加载那些文件只怕会变成网页失去响应,可以将它放到页面包车型大巴尾部加载,也能够那样写 

     
加载那些文件或许会导致网页失去响应,能够将它内置页面包车型大巴底层加载,也足以如此写 

运用require.js的率先步,是先去官方网站下载最新版本。

使用require.js的第3步,是先去官方网站下载摩登版本。

 <script src="js/require.js" defer async="true" ></script>
 <script src="js/require.js" defer async="true" ></script>

下载后,假定把它位于js子目录上面,就足以加载了。

下载后,假定把它座落js子目录上边,就可以加载了。

   
  async属性评释这一个文件须求异步加载,制止网页失去响应。IE不扶助那么些天性,只帮助defer,所以把defer也写上。

   
  async属性注解那些文件供给异步加载,制止网页失去响应。IE不支持那几个特性,只协助defer,所以把defer也写上。

  <script src=”js/require.js”></script>

  <script src=”js/require.js”></script>

   
  加载require.js以往,下一步将要加载大家本身的代码了,也正是进口,能够叫主模块,假设文件名为main.js,写成上面那样就能够了:

   
  加载require.js未来,下一步将在加载我们团结的代码了,也便是进口,可以叫主模块,假设文件名为main.js,写成上面那样就足以了:

有人只怕会想到,加载这一个文件,也恐怕导致网页失去响应。化解办法有多个,两个是把它座落网页尾部加载,另一个是写成下边那样:

有人也许会想到,加载那么些文件,也大概引致网页失去响应。化解办法有三个,三个是把它身处网页尾巴部分加载,另一个是写成上边那样:

<script src="js/require.js" data-main="js/main"></script>    .js后缀可以省略
<script src="js/require.js" data-main="js/main"></script>    .js后缀可以省略

  <script src=”js/require.js” defer
async=”true”
 ></script>

  <script src=”js/require.js” defer
async=”true” ></script>

  

  

async属性声明那么些文件要求异步加载,制止网页失去响应。IE不辅助那么些特性,只协理defer,所以把defer也写上。

async属性表明那些文件须求异步加载,幸免网页失去响应。IE不辅助那性格格,只扶助defer,所以把defer也写上。

叁、主模块的写法

三、主模块的写法

加载require.js将来,下一步将在加载我们团结的代码了。假定大家自身的代码文件是main.js,也放在js目录上边。那么,只要求写成上边那样就行了:

加载require.js未来,下一步就要加载大家和好的代码了。假定大家团结的代码文件是main.js,也位于js目录上边。那么,只需求写成上边那样就行了:

     
假若主模块注重于jQuery能够这么写

     
借使主模块注重于jQuery能够那样写

  <script
src=”js/require.js” data-main=”js/main”></script>

  <script
src=”js/require.js” data-main=”js/main”></script>

 require(['jquery'], function ($){
   alert($);
});
 require(['jquery'], function ($){
   alert($);
});

data-main属性的效应是,钦命网页程序的主模块。在上例中,正是js目录上边的main.js,那一个文件会率先个被require.js加载。由于require.js暗中同意的文书后缀名是js,所以能够把main.js简写成main。

data-main属性的效用是,内定网页程序的主模块。在上例中,正是js目录上边包车型客车main.js,这么些文件会率先个被require.js加载。由于require.js暗中同意的文本后缀名是js,所以能够把main.js简写成main。

 

 

三、主模块的写法

三、主模块的写法

四、require.config()方法

四、require.config()方法

【澳门葡京】Javascript模块化编制程序,管理模块之间的依赖。上一节的main.js,作者把它称作”主模块”,意思是全方位网页的输入代码。它有点像C语言的main()函数,全体代码都从那时开端运维。

上1节的main.js,笔者把它叫做”主模块”,意思是成套网页的进口代码。它有点像C语言的main()函数,全体代码都从此时初步运行。

 

 

下边就来看,怎么写main.js。

上面就来看,怎么写main.js。

require.config({
  paths: {
    "jquery": "jquery.min",
    "underscore": "underscore.min",
    "backbone": "backbone.min"
  }
});
require.config({
  paths: {
    "jquery": "jquery.min",
    "underscore": "underscore.min",
    "backbone": "backbone.min"
  }
});

一经大家的代码不依附任何其余模块,那么能够一向写入javascript代码。

若是大家的代码不依赖任何其余模块,那么可以平素写入javascript代码。

 

 

  // main.js

  alert(“加载成功!”);

  // main.js

  alert(“加载成功!”);

 
  上边的代码给出了多少个模块的文本名,路线默许与main.js在同2个目录(js子目录)。借使那几个模块在任何目录,举个例子js/lib目录,则有三种写法。

 
  下面的代码给出了多少个模块的文件名,路线私下认可与main.js在同1个索引(js子目录)。假如那一个模块在其余目录,举例js/lib目录,则有三种写法。

但那样的话,就没供给选用require.js了。真寻常见的意况是,主模块注重于其余模块,那时将要动用英特尔规范定义的的require()函数。

但那样的话,就没须要接纳require.js了。真不奇怪见的意况是,主模块依赖于别的模块,那时就要选用英特尔标准定义的的require()函数。

  • 一种是逐一钦点路径

    require.config({
      paths: {
        ”jquery”: “lib/jquery.min”,
        ”underscore”: “lib/underscore.min”,
        ”backbone”: “lib/backbone.min”
      }
    });

  •  另一种则是直接改造基目录(baseUrl)。

    require.config({
      baseUrl: “js/lib”,
      paths: {
        ”jquery”: “jquery.min”,
        ”underscor: “underscore.min”,
        ”backbone”: “backbone.min”
      }
    });

  •  
       假设某些模块在另一台主机上,也得以直接钦赐它的网站,比方

    require.config({
      paths: {
        ”jquery”: “”
      }
    });

  • 壹种是各类钦命路径

    require.config({
      paths: {
        ”jquery”: “lib/jquery.min”,
        ”underscore”: “lib/underscore.min”,
        ”backbone”: “lib/backbone.min”
      }
    });

  •  另1种则是间接退换基目录(baseUrl)。

    require.config({
      baseUrl: “js/lib”,
      paths: {
        ”jquery”: “jquery.min”,
        ”underscor: “underscore.min”,
        ”backbone”: “backbone.min”
      }
    });

  •  
       若是有个别模块在另一台主机上,也得以直接钦赐它的网站,比如

    require.config({
      paths: {
        ”jquery”: “”
      }
    });

  // main.js

  require([‘moduleA’, ‘moduleB’, ‘moduleC’], function (moduleA,
moduleB, moduleC){

    // some code here

  });

  // main.js

  require([‘moduleA’, ‘moduleB’, ‘moduleC’], function (moduleA,
moduleB, moduleC){

    // some code here

  });

  

  

require()函数接受七个参数。第三个参数是3个数组,表示所依靠的模块,上例便是[‘moduleA’,
‘moduleB’,
‘moduleC’],即主模块重视那八个模块;第3个参数是三个回调函数,当后面钦命的模块都加载成功后,它将被调用。加载的模块会以参数方式传播该函数,从而在回调函数内部就可以利用这几个模块。

require()函数接受七个参数。第一个参数是2个数组,表示所注重的模块,上例正是[‘moduleA’,
‘moduleB’,
‘moduleC’],即主模块依赖那多个模块;第二个参数是一个回调函数,当前面内定的模块都加载成功后,它将被调用。加载的模块会以参数格局传播该函数,从而在回调函数内部就足以选取这一个模块。

五、英特尔模块的写法

五、AMD模块的写法

require()异步加载moduleA,moduleB和moduleC,浏览器不会失去响应;它钦点的回调函数,唯有前边的模块都加载成功后,才会运作,消除了借助的难点。

require()异步加载moduleA,moduleB和moduleC,浏览器不会失掉响应;它钦命的回调函数,唯有前面包车型地铁模块都加载成功后,才会运营,消除了依赖的主题素材。

   
 require.js加载的模块,选取AMD标准。也正是说,模块必须遵照速龙的明确来写。

   
 require.js加载的模块,选取英特尔标准。也等于说,模块必须依照英特尔的明确来写。

上边,大家看一个实在的例证。

上面,大家看3个事实上的例子。

   
 
具体来讲,就是模块必须选取一定的define()函数来定义。假如2个模块不借助于其余模块,那么能够平昔定义在define()函数之中。

   
 
具体来讲,便是模块必须接纳一定的define()函数来定义。假设四个模块不依赖别的模块,那么能够间接定义在define()函数之中。

设若主模块注重jquery、underscore和backbone那多少个模块,main.js就能够如此写:

即便主模块重视jquery、underscore和backbone那四个模块,main.js就足以那样写:

// math.js
define(function (){
  var add = function (x,y){
    return x+y;
  };
  return {
    add: add
  };
});
// math.js
define(function (){
  var add = function (x,y){
    return x+y;
  };
  return {
    add: add
  };
});

  require([‘jquery’, ‘underscore’, ‘backbone’], function ($, _,
Backbone){

    // some code here

  });

  require([‘jquery’, ‘underscore’, ‘backbone’], function ($, _,
Backbone){

    // some code here

  });

  加载方法如下:

  加载方法如下:

require.js会先加载jQuery、underscore和backbone,然后再运转回调函数。主模块的代码就写在回调函数中。

require.js会先加载jQuery、underscore和backbone,然后再运营回调函数。主模块的代码就写在回调函数中。

 // main.js
require(['math'], function (math){
  alert(math.add(1,1));
});
 // main.js
require(['math'], function (math){
  alert(math.add(1,1));
});

4、模块的加载

四、模块的加载

  假设那个模块还借助别的模块,那么define()函数的率先个参数,必须是三个数组,指明该模块的依附。

  如若那几个模块还借助别的模块,那么define()函数的首先个参数,必须是八个数组,指明该模块的借助。

上1节末段的以身作则中,主模块的依赖模块是[‘jquery’, ‘underscore’,
‘backbone’]。默许境况下,require.js假定那多少个模块与main.js在同贰个目录,文件名分别为
jquery.js,underscore.js和backbone.js,然后自行加载。

上壹节最终的言传身教中,主模块的依附模块是[‘jquery’, ‘underscore’,
‘backbone’]。暗中认可情状下,require.js假定这多个模块与main.js在同1个索引,文件名分别为jquery.js,underscore.js和backbone.js,然后自动加载。

 define(['myLib'], function(myLib){
  function foo(){
    myLib.doSomething();
  }
  return {     //返回模块中的函数
    foo : foo
  };
});
 define(['myLib'], function(myLib){
  function foo(){
    myLib.doSomething();
  }
  return {     //返回模块中的函数
    foo : foo
  };
});

运用require.config()方法,大家能够对模块的加载行为举行自定义。require.config()就写在主模块(main.js)的头顶。参数正是二个目标,这些目的的paths属性钦命各类模块的加载路线。

选择require.config()方法,我们能够对模块的加载行为张开自定义。require.config()就写在主模块(main.js)的头顶。参数正是一个对象,那些目的的paths属性钦赐种种模块的加载路线。

   
 当require()函数加载下面这一个模块的时候,就会先加载myLib.js文件。

   
 当require()函数加载上边那几个模块的时候,就会先加载myLib.js文件。

  require.config({

    paths: {

      ”jquery”: “jquery.min”,
      ”underscore”: “underscore.min”,
      ”backbone”: “backbone.min”

    }

  });

  require.config({

    paths: {

      ”jquery”: “jquery.min”,
      ”underscore”: “underscore.min”,
      ”backbone”: “backbone.min”

    }

  });

 

 

上边的代码给出了五个模块的公文名,路线暗中同意与main.js在同3个目录(js子目录)。假使那个模块在任何目录,举例js/lib目录,则有二种写法。壹种是逐一钦赐路径。

上边包车型客车代码给出了多少个模块的公文名,路径默许与main.js在同2个目录(js子目录)。若是那么些模块在别的目录,举个例子js/lib目录,则有二种写法。壹种是逐一钦赐路径。

陆、加载非标准的模块(shim的利用办法)

陆、加载非标准的模块(shim的施用方法)

  require.config({

    paths: {

      ”jquery”: “lib/jquery.min”,
      ”underscore”: “lib/underscore.min”,
      ”backbone”: “lib/backbone.min”

    }

  });

  require.config({

    paths: {

      ”jquery”:
“lib/jquery.min”,

      ”underscore”:
“lib/underscore.min”,

      ”backbone”:
“lib/backbone.min”

    }

  });

 

 

另一种则是向来退换基目录(baseUrl)。

另1种则是一贯退换基目录(baseUrl)。

 //  app.js
 function sayHello(name){
  alert('Hi '+name);
}
 //  app.js
 function sayHello(name){
  alert('Hi '+name);
}

  require.config({

    baseUrl: “js/lib”,

    paths: {

澳门葡京 ,      ”jquery”: “jquery.min”,
      ”underscore”: “underscore.min”,
      ”backbone”: “backbone.min”

    }

  });

  require.config({

    baseUrl: “js/lib”,

    paths: {

      ”jquery”: “jquery.min”,
      ”underscore”: “underscore.min”,
      ”backbone”: “backbone.min”

    }

  });

 

 

假诺有个别模块在另壹台主机上,也能够一向钦命它的网站,比方:

要是某些模块在另1台主机上,也得以平素钦赐它的网站,比方:

 //  main.js
require.config({
  shim: {
    'app': { //这个键名为要载入的目标文件的文件名,不能随便命名。
      exports: 'sayHello' //exports的值为my.js提供的 对外接口的名称
    }
  }
});

require(['app'], function(sayHello) {
    alert(sayHello())  
})
 //  main.js
require.config({
  shim: {
    'app': { //这个键名为要载入的目标文件的文件名,不能随便命名。
      exports: 'sayHello' //exports的值为my.js提供的 对外接口的名称
    }
  }
});

require(['app'], function(sayHello) {
    alert(sayHello())  
})

  require.config({

    paths: {

      ”jquery”:
“”

    }

  });

  require.config({

    paths: {

      ”jquery”:
“”

    }

  });

  

  

require.js要求,每种模块是3个独立的js文件。那样的话,假如加载八个模块,就会生出数次HTTP请求,会影响网页的加载速度。由此,require.js提供了二个优化学工业具,当模块安排实现之后,能够用那些工具将两个模块合并在3个文本中,减少HTTP请求数。

require.js供给,每一个模块是一个独门的js文件。那样的话,假如加载多少个模块,就会生出数次HTTP请求,会潜移默化网页的加载速度。因而,require.js提供了二个优化学工业具,当模块计划达成之后,能够用那些工具将多个模块合并在三个文件中,减弱HTTP请求数。

   
  导出3个函数,意味着我们赢得了叁个javaScript类

   
  导出三个函数,意味着大家获得了1个javaScript类

伍、英特尔模块的写法

5、速龙模块的写法

   
  可是只要在my.js中写了成千上万function,整合成一个function有点麻烦,想一向导出?方法如下:

   
  不过只要在my.js中写了许多function,整合成三个function有点费力,想直接导出?方法如下:

require.js加载的模块,选拔英特尔规范。也等于说,模块必须比照英特尔的规定来写。

require.js加载的模块,选拔英特尔标准。也便是说,模块必须坚守英特尔的明确来写。

 // app.js
function sayHi(name){
    alert('Hi '+name);
}
function sayHello(name){
    alert('Hiello  '+name);
}

// main.js  
  require.config({
    shim: {
      app: {
        init: function() { //这里使用init将2个接口返回
          return {
            sayHi: sayHi,
            sayHello: sayHello
          }
        }
      }
    }
  });

  require(['app'], function(a) {
    a.sayHi('zhangsan');
    a.sayHello('lisi');
  });
 // app.js
function sayHi(name){
    alert('Hi '+name);
}
function sayHello(name){
    alert('Hiello  '+name);
}

// main.js  
  require.config({
    shim: {
      app: {
        init: function() { //这里使用init将2个接口返回
          return {
            sayHi: sayHi,
            sayHello: sayHello
          }
        }
      }
    }
  });

  require(['app'], function(a) {
    a.sayHi('zhangsan');
    a.sayHello('lisi');
  });

具体来讲,正是模块必须采纳一定的define()函数来定义。借使2个模块不依赖其余模块,那么可以间接定义在define()函数之中。

具体来说,哪怕模块必须使用一定的define()函数来定义。万1二个模块不依赖其余模块,那么能够直接定义在define()函数之中。

 
  
 shim的稳步导入

 
  
 shim的不改变导入

设若未来有一个math.js文件,它定义了二个math模块。那么,math.js将要这么写:

假定以后有一个math.js文件,它定义了二个math模块。那么,math.js将要如此写:

   require.config({  

    shim: {  
      'jquery.ui.core': ['jquery'],  //表示在jquery导入之后导入
      'jquery.ui.widget': ['jquery'],  
      'jquery.ui.mouse': ['jquery'],  
      'jquery.ui.slider':['jquery']
     },  
    paths : {    
       jquery : 'jquery-2.1.1/jquery',    
       domReady : 'require-2.1.11/domReady',    
       'jquery.ui.core' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.core',    
       'jquery.ui.widget' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.widget',    
       'jquery.ui.mouse' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.mouse',    
       'jquery.ui.slider' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.slider' 
        }
  });    

  require(['jquery', 'domReady','jquery.ui.core','jquery.ui.widget','jquery.ui.mouse','jquery.ui.slider'],    function($) {            
      $("#slider" ).slider({              
       value:0,           
       min: 0,           
       max: 4,           
       step: 1,           
       slide: function( event, ui ) {}     
        });    
   });
   require.config({  

    shim: {  
      'jquery.ui.core': ['jquery'],  //表示在jquery导入之后导入
      'jquery.ui.widget': ['jquery'],  
      'jquery.ui.mouse': ['jquery'],  
      'jquery.ui.slider':['jquery']
     },  
    paths : {    
       jquery : 'jquery-2.1.1/jquery',    
       domReady : 'require-2.1.11/domReady',    
       'jquery.ui.core' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.core',    
       'jquery.ui.widget' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.widget',    
       'jquery.ui.mouse' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.mouse',    
       'jquery.ui.slider' : 'jquery-ui-1.10.4/development-bundle/ui/jquery.ui.slider' 
        }
  });    

  require(['jquery', 'domReady','jquery.ui.core','jquery.ui.widget','jquery.ui.mouse','jquery.ui.slider'],    function($) {            
      $("#slider" ).slider({              
       value:0,           
       min: 0,           
       max: 4,           
       step: 1,           
       slide: function( event, ui ) {}     
        });    
   });

  // math.js

  define(function (){

    var add = function (x,y){

      return x+y;

    };

    return {

      add: add
    };

  });

  // math.js

  define(function (){

    var add = function (x,y){

      return x+y;

    };

    return {

      add: add
    };

  });

  

  

加载方法如下:

加载方法如下:

  // main.js

  require([‘math’], function (math){

    alert(math.add(1,1));

  });

  // main.js

  require([‘math’], function (math){

    alert(math.add(1,1));

  });

若果那个模块还借助其他模块,那么define()函数的首先个参数,必须是三个数组,指明该模块的依赖。

假诺那个模块还依据其余模块,那正是说define()函数的率先个参数,必须是一个数组,指明该模块的重视。

  define([‘myLib’], function(myLib){

    function foo(){

      myLib.doSomething();

    }

    return {

      foo : foo

    };

  });

  define([‘myLib’],
function(myLib){

    function foo(){

style=”color: #ff0000″>      myLib.doSomething();

    }

    return {

      foo : foo

    };

  });

当require()函数加载下面这一个模块的时候,就会先加载myLib.js文件。

当require()函数加载上边那一个模块的时候,就会先加载myLib.js文件。

⑥、加载非标准的模块

6、加载非标准的模块

答辩上,require.js加载的模块,必须是服从AMD规范、用define()函数定义的模块。不过事实上,即使已经有局地流行的函数库(比方jQuery)符合英特尔标准,更加多的库并不吻合。那么,require.js是还是不是能够加载非规范的模块呢?回答是足以的。那样的模块在用require()加载以前,要先用require.config()方法,定义它们的一部分表征。举个例子来说,underscore和backbone那多个库,都不曾动用AMD标准编写。假设要加载它们来讲,必须先定义它们的风味。

反驳上,require.js加载的模块,必须是根据AMD规范、用define()函数定义的模块。然则事实上,即使壹度有局地风靡的函数库(举个例子jQuery)符合英特尔标准,越来越多的库并不合乎。那么,require.js是不是能够加载非标准的模块呢?

  require.config({

    shim: {

      ’underscore’:{
        exports: ‘_’
      },

      ’backbone’: {
        deps: [‘underscore’, ‘jquery’],
        exports: ‘Backbone’
      }

    }

  });

答问是能够的。

require.config()接受一个布局对象,那些目标除了有前方说过的paths属性之外,还有2个shim属性,专门用来布置不包容的模块。具体来讲,各种模块要定义(1)exports值(输出的变量名),申明那么些模块外部调用时的称谓;(二)deps数组,声明该模块的注重。

如此那般的模块在用require()加载从前,要先用require.config()方法,定义它们的局地表征。

比方,jQuery的插件能够这么定义:

比如来讲,underscore和backbone那七个库,都不曾应用AMD标准编写。要是要加载它们来讲,必须先定义它们的风味。

  shim: {

    ’jquery.scroll’: {

      deps: [‘jquery’],

      exports: ‘jQuery.fn.scroll’

    }

  }

  require.config({

    shim: {

      ’underscore’:{
        exports: ‘_’
      },

      ’backbone’: {
        deps: [‘underscore’, ‘jquery’],
        exports: ‘Backbone’
      }

    }

  });

七、require.js插件

require.config()接受三个布署对象,这么些目标除了有前方说过的paths属性之外,还有1个shim属性,专门用来布局不相称的模块。具体来讲,每一个模块要定义(壹)exports值(输出的变量名),申明这一个模块外部调用时的称呼;(二)deps数组,表明该模块的正视。

require.js还提供1体系插件,落成部分一定的效益。

比方,jQuery的插件能够如此定义:

domready插件,能够让回调函数在页面DOM结构加载成功后再运营。

  shim: {

    ’jquery.scroll’: {

      deps: [‘jquery’],

      exports: ‘jQuery.fn.scroll’

    }

  }

  require([‘domready!’], function (doc){

    // called once the DOM is ready

  });

七、require.js插件

text和image插件,则是允许require.js加载文本和图表文件。

require.js还提供壹多级插件,实现部分特定的遵从。

  define([

    ’text!review.txt’,

    ’image!cat.jpg’

    ],

    function(review,cat){

      console.log(review);

      document.body.appendChild(cat);

    }

  );

domready插件,可以让回调函数在页面DOM结构加载成功后再运转。

看似的插件还有json和mdown,用于加载json文件和markdown文件。

  require([‘domready!’], function (doc){

    // called once the DOM is ready

  });

text和image插件,则是同意require.js加载文本和图片文件。

  define([

    ‘text!review.txt’,

    ’image!cat.jpg’

    ],

    function(review,cat){

      console.log(review);

      document.body.appendChild(cat);

    }

  );

看似的插件还有json和mdown,用于加载json文件和markdown文件。

【转发至阮一峰的日记】

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website