基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

v# 基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹

基础

基础使用

Webpack 是一个静态资源打包工具。

它会以一个或多个文件作为打包的入口，将我们整个项目所有文件编译组合成一个或多个文件输出出去。

输出的文件就是编译好的文件，就可以在浏览器段运行了。我们将 Webpack 输出的文件叫做 bundle。

功能介绍

Webpack 本身功能是有限的:

• 开发模式：仅能编译 JS 中的 ES Module 语法
• 生产模式：能编译 JS 中的 ES Module 语法，还能压缩 JS代码

开始使用

1.资源目录

webpack_code # 项目根目录（所有指令必须在这个目录运行）
    └── src # 项目源码目录
        ├── js # js文件目录
        │   ├── count.js
        │   └── sum.js
        └── main.js # 项目主文件

function debounce(callback, delay) {
	let timer = null;
	return function () {
		clearTimeout(timer);
		timer = setTimeout(() => {
			callback.bind(this)();
		}, delay);
	}
}

思路

1. 先创建一个临时文件夹，存储编写时的图片
2. 每次编写前清空临时文件夹
3. 发布时：修改text再请求
4. 将临时文件夹下文件移动到：文章文件夹