js模块化学习

最新推荐文章于 2023-10-09 23:00:02 发布
最新推荐文章于 2023-10-09 23:00:02 发布
阅读量138 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45446099/article/details/113884012
版权

摘自 b站视频

js 模块化_笔记

JS模块化

  • 模块化的理解
  • 什么是模块?
    • 将一个复杂的程序依据一定的规则(规范)封装成几个块(文件), 并进行组合在一起
    • 块的内部数据/实现是私有的, 只是向外部暴露一些接口(方法)与外部其它模块通信
  • 一个模块的组成
    • 数据—>内部的属性
    • 操作数据的行为—>内部的函数
  • 模块化
    • 编码时是按照模块一个一个编码的, 整个项目就是一个模块化的项目
  • 模块化的进化过程
    • 全局function模式 :
      • 编码: 全局变量/函数
      • 问题: 污染全局命名空间, 容易引起命名冲突/数据不安全
    • namespace模式 :
      • 编码: 将数据/行为封装到对象中
      • 解决: 命名冲突(减少了全局变量)
      • 问题: 数据不安全(外部可以直接修改模块内部的数据)
    • IIFE模式/增强
      • IIFE : 立即调用函数表达式—>匿名函数自调用
      • 编码: 将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口
      • 引入依赖: 通过函数形参来引入依赖模块
        (function(window, module2){
  var data = 'atguigu.com'
  function foo() {
     module2.xxx()
     console.log('foo()'+data)
  }
  function bar() {
     console.log('bar()'+data)
  }
  
  window.module = {foo}
})(window, module2)
  • 模块化规范
    • CommonJS
      • Node.js : 服务器端
      • Browserify : 浏览器端 也称为js的打包工具
      • 基本语法:
        • 定义暴露模块 : exports
          exports.xxx = value
module.exports = value
        引入模块 : require
        var module = require('模块名/模块相对路径')
      • 引入模块发生在什么时候?
        • Node : 运行时, 动态同步引入
        • Browserify : 在运行前对模块进行编译/转译/打包的处理(已经将依赖的模块包含进来了),
          运行的是打包生成的js, 运行时不存在需要再从远程引入依赖模块
    • AMD : 浏览器端
      • require.js
      • 基本语法
        • 定义暴露模块: define([依赖模块名], function(){return 模块对象})
        • 引入模块: require([‘模块1’, ‘模块2’, ‘模块3’], function(m1, m2){//使用模块对象})
        • 配置:
          require.config({
  //基本路径
  baseUrl : 'js/',
  //标识名称与路径的映射
  paths : {
    '模块1' : 'modules/模块1',
    '模块2' : 'modules/模块2',
    'angular' : 'libs/angular',
    'angular-messages' : 'libs/angular-messages'
  },
  //非AMD的模块
  shim : {
    'angular' : {
        exports : 'angular'
    },
    'angular-messages' : {
        exports : 'angular-messages',
        deps : ['angular']
    }
  }
})
    • CMD : 浏览器端
      • sea.js
      • 基本语法
        • 定义暴露模块:
          define(function(require, module, exports){
  通过require引入依赖模块
  通过module/exports来暴露模块
  exports.xxx = value
})
        • 使用模块seajs.use([‘模块1’, ‘模块2’])
    • ES6
      • ES6内置了模块化的实现
      • 基本语法

        • 定义暴露模块 : export

          • 暴露一个对象:
            export default 对象
          • 暴露多个:
            export var xxx = value1
export let yyy = value2

var xxx = value1
let yyy = value2
export {xxx, yyy}

        • 引入使用模块 : import

          • default模块:
            import xxx  from '模块路径/模块名'
          • 其它模块
            import {xxx, yyy} from '模块路径/模块名'
import * as module1 from '模块路径/模块名'
      • 问题: 所有浏览器还不能直接识别ES6模块化的语法
      • 解决:
        • 使用Babel将ES6—>ES5(使用了CommonJS) ----浏览器还不能直接支行
        • 使用Browserify—>打包处理----浏览器可以运行

1_模块化进化史教程

模块化进化史教程

  1. 全局function模式
  • module1.js
    //数据
let data = 'atguigu.com'

//操作数据的函数
function foo() {
  console.log(`foo() ${data}`)
}
function bar() {
  console.log(`bar() ${data}`)
}
  • module2.js
    let data2 = 'other data'

function foo() {  //与另一个模块中的函数冲突了
  console.log(`foo() ${data2}`)
}
  • test1.html
    <script type="text/javascript" src="module1.js"></script>
<script type="text/javascript" src="module2.js"></script>
<script type="text/javascript">

  let data = "修改后的数据"
  foo()
  bar()
</script>
  • 说明:
    • 全局函数模式: 将不同的功能封装成不同的全局函数
    • 问题: Global被污染了, 很容易引起命名冲突
  1. namespace模式
  • module1.js
    let myModule = {
  data: 'atguigu.com',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}
  • module2.js
    let myModule2 = {
  data: 'atguigu.com2222',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}
  • test2.html
    <script type="text/javascript" src="module2.js"></script>
<script type="text/javascript" src="module22.js"></script>
<script type="text/javascript">
  myModule.foo()
  myModule.bar()

  myModule2.foo()
  myModule2.bar()

  myModule.data = 'other data' //能直接修改模块内部的数据
  myModule.foo()

</script>
  • 说明
    • namespace模式: 简单对象封装
    • 作用: 减少了全局变量
    • 问题: 不安全
  1. IIFE模式
  • module3.js
    (function (window) {
  //数据
  let data = 'atguigu.com'

  //操作数据的函数
  function foo() { //用于暴露有函数
    console.log(`foo() ${data}`)
  }

  function bar() {//用于暴露有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }

  function otherFun() { //内部私有的函数
    console.log('otherFun()')
  }

  //暴露行为
  window.myModule = {foo, bar}
})(window)
  • test3.html
    <script type="text/javascript" src="module3.js"></script>
<script type="text/javascript">
  myModule.foo()
  myModule.bar()
  //myModule.otherFun()  //myModule.otherFun is not a function
  console.log(myModule.data) //undefined 不能访问模块内部数据
  myModule.data = 'xxxx' //不是修改的模块内部的data
  myModule.foo() //没有改变

</script>
  • 说明:
    • IIFE模式: 匿名函数自调用(闭包)
    • IIFE : immediately-invoked function expression(立即调用函数表达式)
    • 作用: 数据是私有的, 外部只能通过暴露的方法操作
    • 问题: 如果当前这个模块依赖另一个模块怎么办?
  1. IIFE模式增强
  • 引入jquery到项目中
  • module4.js
    (function (window, $) {
  //数据
  let data = 'atguigu.com'

  //操作数据的函数
  function foo() { //用于暴露有函数
    console.log(`foo() ${data}`)
    $('body').css('background', 'red')
  }

  function bar() {//用于暴露有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }

  function otherFun() { //内部私有的函数
    console.log('otherFun()')
  }

  //暴露行为
  window.myModule = {foo, bar}
})(window, jQuery)
  • test4.html
    <script type="text/javascript" src="jquery-1.10.1.js"></script>
<script type="text/javascript" src="module4.js"></script>
<script type="text/javascript">
  myModule.foo()
</script>
  • 说明
    • IIFE模式增强 : 引入依赖
    • 这就是现代模块实现的基石
  1. 页面加载多个js的问题
  • 页面:
    <script type="text/javascript" src="module1.js"></script>
<script type="text/javascript" src="module2.js"></script>
<script type="text/javascript" src="module3.js"></script>
<script type="text/javascript" src="module4.js"></script>
  • 说明
    • 一个页面需要引入多个js文件
    • 问题:
      • 请求过多
      • 依赖模糊
      • 难以维护
    • 这些问题可以通过现代模块化编码和项目构建来解决

2_CommonJS_Node模块化教程

Node.js模块化教程

  1. 下载安装node.js
  2. 创建项目结构
|-modules
  |-module1.js
  |-module2.js
  |-module3.js
|-app.js
|-package.json
  {
    "name": "commonJS-node",
    "version": "1.0.0"
  }
  1. 下载第三方模块
  • npm install uniq --save
  1. 模块化编码
  • module1.js
    module.exports = {
  foo() {
    console.log('moudle1 foo()')
  }
}
  • module2.js
    module.exports = function () {
  console.log('module2()')
}
  • module3.js
    exports.foo = function () {
  console.log('module3 foo()')
}

exports.bar = function () {
  console.log('module3 bar()')
}
  • app.js
    /**
  1. 定义暴露模块:
    module.exports = value;
    exports.xxx = value;
  2. 引入模块:
    var module = require(模块名或模块路径);
 */
"use strict";
//引用模块
let module1 = require('./modules/module1')
let module2 = require('./modules/module2')
let module3 = require('./modules/module3')

let uniq = require('uniq')
let fs = require('fs')

//使用模块
module1.foo()
module2()
module3.foo()
module3.bar()

console.log(uniq([1, 3, 1, 4, 3]))

fs.readFile('app.js', function (error, data) {
  console.log(data.toString())
})
  1. 通过node运行app.js
  • 命令: node app.js
  • 工具: 右键–>运行

3_CommonJS-Browserify模块化教程

Browserify模块化使用教程

  1. 创建项目结构
|-js
  |-dist //打包生成文件的目录
  |-src //源码所在的目录
    |-module1.js
    |-module2.js
    |-module3.js
    |-app.js //应用主源文件
|-index.html
|-package.json
  {
    "name": "browserify-test",
    "version": "1.0.0"
  }
  1. 下载browserify
  • 全局: npm install browserify -g
  • 局部: npm install browserify --save-dev
  1. 定义模块代码
  • module1.js
    module.exports = {
  foo() {
    console.log('moudle1 foo()')
  }
}
  • module2.js
    module.exports = function () {
  console.log('module2()')
}
  • module3.js
    exports.foo = function () {
  console.log('module3 foo()')
}

exports.bar = function () {
  console.log('module3 bar()')
}
  • app.js (应用的主js)
    //引用模块
let module1 = require('./module1')
let module2 = require('./module2')
let module3 = require('./module3')

let uniq = require('uniq')

//使用模块
module1.foo()
module2()
module3.foo()
module3.bar()

console.log(uniq([1, 3, 1, 4, 3]))
  • 打包处理js:
    • browserify js/src/app.js -o js/dist/bundle.js
  • 页面使用引入:
    <script type="text/javascript" src="js/dist/bundle.js"></script>

4_AMD-RequireJS模块化教程

require.js使用教程

  1. 下载require.js, 并引入
  • 官网: http://www.requirejs.cn/
  • github : https://github.com/requirejs/requirejs
  • 将require.js导入项目: js/libs/require.js
  1. 创建项目结构
|-js
  |-libs
    |-require.js
  |-modules
    |-alerter.js
    |-dataService.js
  |-main.js
|-index.html
  1. 定义require.js的模块代码
  • dataService.js
    define(function () {
  let msg = 'atguigu.com'

  function getMsg() {
    return msg.toUpperCase()
  }

  return {getMsg}
})
  • alerter.js
    define(['dataService', 'jquery'], function (dataService, $) {
  let name = 'Tom2'

  function showMsg() {
    $('body').css('background', 'gray')
    alert(dataService.getMsg() + ', ' + name)
  }

  return {showMsg}
})
  1. 应用主(入口)js: main.js
(function () {
  //配置
  require.config({
    //基本路径
    baseUrl: "js/",
    //模块标识名与模块路径映射
    paths: {
      "alerter": "modules/alerter",
      "dataService": "modules/dataService",
    }
  })
  //引入使用模块
  require( ['alerter'], function(alerter) {
    alerter.showMsg()
  })
})()
  1. 页面使用模块:
  1. 使用第三方基于require.js的框架(jquery)
  • 将jquery的库文件导入到项目:
    • js/libs/jquery-1.10.1.js
  • 在main.js中配置jquery路径
    paths: {
          'jquery': 'libs/jquery-1.10.1'
      }
  • 在alerter.js中使用jquery
    define(['dataService', 'jquery'], function (dataService, $) {
    var name = 'xfzhang'
    function showMsg() {
        $('body').css({background : 'red'})
        alert(name + ' '+dataService.getMsg())
    }
    return {showMsg}
})
  1. 使用第三方不基于require.js的框架(angular/angular-messages)
  • 将angular.js和angular-messages.js导入项目
    • js/libs/angular.js
    • js/libs/angular-messages.js
  • 在main.js中配置
    (function () {
  require.config({
    //基本路径
    baseUrl: "js/",
    //模块标识名与模块路径映射
    paths: {
      //第三方库
      'jquery' : 'libs/jquery-1.10.1',
      'angular' : 'libs/angular',
      'angular-messages' : 'libs/angular-messages',
      //自定义模块
      "alerter": "modules/alerter",
      "dataService": "modules/dataService"
    },
    /*
     配置不兼容AMD的模块
     exports : 指定导出的模块名
     deps  : 指定所有依赖的模块的数组
     */
    shim: {
      'angular' : {
        exports : 'angular'
      },
      'angular-messages' : {
        exports : 'angular-messages',
        deps : ['angular']
      }
    }
  })
  //引入使用模块
  require( ['alerter', 'angular', 'angular-messages'], function(alerter, angular) {
    alerter.showMsg()
    angular.module('myApp', ['ngMessages'])
    angular.bootstrap(document,["myApp"])
  })
})()
  • 页面:
    <form name="myForm">
  用户名: <input type="text" name="username" ng-model="username" ng-required="true">
  <div style="color: red;" ng-show="myForm.username.$dirty&&myForm.username.$invalid">用户名是必须的</div>
</form>

5_CMD-SeaJS模块化教程

sea.js简单使用教程

  1. 下载sea.js, 并引入
  • 官网: http://seajs.org/
  • github : https://github.com/seajs/seajs
  • 将sea.js导入项目: js/libs/sea.js
  1. 创建项目结构
|-js
  |-libs
    |-sea.js
  |-modules
    |-module1.js
    |-module2.js
    |-module3.js
    |-module4.js
    |-main.js
|-index.html
  1. 定义sea.js的模块代码
  • module1.js
    define(function (require, exports, module) {
  //内部变量数据
  var data = 'atguigu.com'
  //内部函数
  function show() {
    console.log('module1 show() ' + data)
  }

  //向外暴露
  exports.show = show
})
  • module2.js
    define(function (require, exports, module) {
  module.exports = {
    msg: 'I Will Back'
  }
})
  • module3.js
    define(function (require, exports, module) {
  const API_KEY = 'abc123'
  exports.API_KEY = API_KEY
})
  • module4.js
    define(function (require, exports, module) {
  //引入依赖模块(同步)
  var module2 = require('./module2')

  function show() {
    console.log('module4 show() ' + module2.msg)
  }

  exports.show = show
  //引入依赖模块(异步)
  require.async('./module3', function (m3) {
    console.log('异步引入依赖模块3  ' + m3.API_KEY)
  })
})
  • main.js : 主(入口)模块
    define(function (require) {
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
})
  1. index.html:
<!--
使用seajs:
  1. 引入sea.js库
  2. 如何定义导出模块 :
    define()
    exports
    module.exports
  3. 如何依赖模块:
    require()
  4. 如何使用模块:
    seajs.use()
-->
<script type="text/javascript" src="js/libs/sea.js"></script>
<script type="text/javascript">
  seajs.use('./js/modules/main')
</script>

6_ES6模块化教程

ES6-Babel-Browserify使用教程

  1. 定义package.json文件
{
  "name" : "es6-babel-browserify",
  "version" : "1.0.0"
}
  1. 安装babel-cli, babel-preset-es2015和browserify
  • npm install babel-cli browserify -g
    • npm install babel-preset-es2015 --save-dev
  1. 定义.babelrc文件
    {
"presets": ["es2015"]

}
```
4. 编码

  • js/src/module1.js
    export function foo() {
  console.log('module1 foo()');
}
export let bar = function () {
  console.log('module1 bar()');
}
export const DATA_ARR = [1, 3, 5, 1]
  • js/src/module2.js
    let data = 'module2 data'

function fun1() {
  console.log('module2 fun1() ' + data);
}

function fun2() {
  console.log('module2 fun2() ' + data);
}

export {fun1, fun2}
  • js/src/module3.js
    export default {
  name: 'Tom',
  setName: function (name) {
    this.name = name
  }
}
  • js/src/app.js
    import {foo, bar} from './module1'
import {DATA_ARR} from './module1'
import {fun1, fun2} from './module2'
import person from './module3'

import $ from 'jquery'

$('body').css('background', 'red')

foo()
bar()
console.log(DATA_ARR);
fun1()
fun2()

person.setName('JACK')
console.log(person.name);
  1. 编译
  • 使用Babel将ES6编译为ES5代码(但包含CommonJS语法) : babel js/src -d js/lib
  • 使用Browserify编译js : browserify js/lib/app.js -o js/lib/bundle.js
  1. 页面中引入测试
<script type="text/javascript" src="js/lib/bundle.js"></script>
  1. 引入第三方模块(jQuery)
    1). 下载jQuery模块:
    • npm install jquery@1 --save
      2). 在app.js中引入并使用
    import $ from 'jquery'
$('body').css('background', 'red')
把爱放在心底的朋友圈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaScript |（一）JavaScript简介及基本语法 | 尚硅谷JavaScript基础&实战
知识库搭建ing
07-25 648
JavaScript简介及基本知识 | 尚硅谷JavaScript基础&实战
JavaScript 中的模块
我的博客，不一样的自我表达
06-18 218
在浏览器中，模块是异步获取的，而在 Node.js 中，模块是同步加载的。模块允许您定义私有和公共成员，从其他模块导入功能，以及导出功能以在其他模块中使用。此外，JavaScript 中的模块还有其他高级功能，例如模块命名空间、重新导出和动态导入，这些功能在使用模块时提供了更大的灵活性。它可以是变量、函数、类或对象。导入模块：要使用其他模块的功能，可以使用关键字，import后跟模块名称和要导入的元素。使用导入的功能：导入后，您可以使用导入的元素，就好像它们是在当前模块中定义的一样。
JavaScript模块化开发
weixin_56663198的博客
04-24 1684
1 认识模块化开发 2 CommonJS和Node 3 require函数解析 4 AMD和CMD（了解） 5 ESModule用法详解 6 ESModule运行原理
JS模块化说明视频-张晓飞-专题视频课程
尚硅谷教育的专栏
01-16 339
当项目功能越来越多，代码量便也会越来越多，后期的维护难度会增大，此时在JS方面就会考虑使用模块化规范去管理。 本视频内容涵盖：理解模块化，为什么要模块化，模块化的优缺点以及模块化规范。并且将带领大家学习开发中流行的commonjs, AMD, ES6、CMD规范。 建议同学们学习完模块化规范以后再学习项目构建，以更好的武装自己的技能。...
javascript模块 (Module) 简介
影子
08-19 8821
随着ES6的出现，js模块已经成为正式的标准了。曾经为了解决js模块问题而发展起来的民间秘籍，requireJs(AMD)、SeaJs(CMD)、Node(CommonJs)，已经或者不久的将来会成为历史。了解历史也是很重要的，因为正式标准就是以民间秘籍为基础而发展起来的，有些规范仍然被广泛应用于开发中（CommonJS）。 ES6的class是面向对象的语法糖，升级了ES5的构造函数的原型链继承的写法，并没有解决模块化问题。Module功能则是为了解决这一问题而提出的。 在ES6之前，...
关于JS模块化的知识点分享
10-16
在本篇文章里小编给大家整理的是关于JS模块化的知识点分享，有需要的朋友们可以学习下。
浅析js的模块化编写 require.js
10-20
总之，require.js是一个强大的JavaScript模块化工具，它提供了异步加载和依赖管理的能力，使开发者能够构建大型、复杂的JavaScript应用，而不用担心代码组织和性能问题。通过学习和熟练掌握require.js，开发者可以更...
JavaScript 模块化编程(笔记)
01-19
第一章 JavaScript模块化编程 (一):模块的写法 一 原始写法 // 模块就是实现特定功能的一组方法;只要把不同的函数(以及记录状态的变量)简单地放在一起,就算是一个模块;  function m1(){  // …  }  function m2...
Vuex 模块化使用详解
12-10
前言 上回我们说了一下 vuex 的简单使用，最后面的时候有说了，由于使用单一状态树，应用的所有...文件结构的话，模块化的使用要多一个 modules 的文件夹，里面放着细分模块的 js 文件/模块名文件夹。 这里官方的标准
js模块编程学习笔记
10-17
总的来说，JavaScript模块化编程通过CommonJS和AMD规范，以及require.js这样的加载器，为开发者提供了强大的代码组织和管理能力，使得大型JavaScript项目更加有序和高效。在实际应用中，应根据项目需求选择合适的...
尚硅谷-前端培训视频
01-07
尚硅谷前端开发全套视频，H5,JS,jquery,React，自动化构建工具。
经典尚硅谷JavaScript视频
06-15
精心收藏 上百本经典前端电子书 总有基本合适你的 节省大家时间
JavaScript新特性： 模块 （module）
u011863822的博客
05-26 3997
对于模块进行了简单讲解，毕竟模块侧重于使用，然后再通过export和import中的一些注意事项。其它还有模块的动态加载，import可以当作方法一样，然后返回一个promise。下面都通过实例演示，方便理解。
js模块化（CommonJS、ES6模块化规范）
qq_48617322的博客
09-15 793
js模块化（CommonJS、ES6模块化规范）
JavaScript 模块化介绍
最新发布
weixin_43790019的博客
10-09 464
模块通常指的是一个独立的可重用软件组件，它包含了一组相关的函数、方法、类、变量等，能够实现特定的功能或提供特定的服务。在编程中，可以将程序的功能划分成不同的模块，每个模块负责不同的任务JavaScript的模块化是一种将代码组织到独立的、可重用的、可维护的单元中的方式，使代码更易于管理和复用。模块化可以帮助开发者将代码分解成更小的部分，这样更容易理解和维护，同时也可以防止命名冲突和全局污染。在JavaScript中，有多种模块化的标准和实现，如CommonJS、AMD、ES6等。
尚硅谷vue笔记 详细讲解版（尚硅谷 天禹老师）
abjtxf的博客
03-01 6509
详细版的意思就是把老师课上讲的内容都结合自己的思考记录了下来，很适合只会应用而不知原理的同学参考
JS模块详解
起风了
01-04 1237
模块是什么？ 模块通常是指编程语言所提供的代码组织机制，利用此机制可将程序拆解为独立且通用的代码单元。所谓模块化主要是解决代码分割、作用域隔离、模块之间的依赖管理以及发布到生产环境时的自动化打包与处理等多个方面。 模块的优点？ 1.可维护性。因为模块是独立的，一个设计良好的模块会让外面的代码对自己的依赖越少越好，这样自己就可以独立去更新和改进。 2.命名空间。在js里面，如果一个变量在最顶级的函数...
web前端培训-模块化规范CMD
zjjcchina的博客
09-01 206
CMD规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。在 Sea.js 中，所有 JavaScript 模块都遵循 CMD模块定义规范。CMD的加载方式更加优秀，是通过按需加载的方式，而不是必须在模块开始就加载所有的依赖。然后将sea.js导入项目: js/libs/sea.js。// module1.js文件。// module2.js文件。// module3.js文件。// module4.js文件。//引入依赖模块(同步)//引入依赖模块(异步)// main.js文件。...
彻底搞清楚javascript中的require、import和export
weixin_34302798的博客
07-06 1358
为什么有模块概念 理想情况下，开发者只需要实现核心的业务逻辑，其他都可以加载别人已经写好的模块。 但是，Javascript不是一种模块化编程语言，在es6以前，它是不支持”类”（class），所以也就没有”模块”（module）了。 require时代 Javascript社区做了很多努力，在现有的运行环境中，实现”模块”的效果。 原始写法 模块就是实现特定功能的一组方法。只要把不同的函数（以及...
Node.js与Webpack学习笔记：模块化构建详解
"这是关于Node.js、模块化以及Webpack的学习...总结来说，这份笔记是关于Node.js基础知识、JavaScript模块化、以及Webpack在前端项目中的实践，对于想要深入学习Vue+Webpack开发的开发者来说，是一份宝贵的参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值