基于Gulp的简易前端自动化工程搭建

上个月月底在公司提出关于前后端分离的想法，并且开始研究关于前后端分离，前端工程化，模块化的一些东西，上周开始我准备自己开始写基于Gulp流的前端工程文件，这两天有时间，着手开始实现这个想法，但是写的过程中，遇到了一些问题，正是因为这些问题的解决让我对Gulp的流式处理有了更深的理解，写下这篇文章，分享一下这俩天我在写Gulp的时候学到的一些东西。

准备工作

安装Node

首先Gulp是基于Nodejs的，所以安装Nodejs是前提，Node可以说是前端神器，基于Node有各种各样的工具，正是因为这些工具让我们非常方便的构建前端工程。

更改Node插件默认安装位置(非必需)

我自己一般不喜欢在C盘状太多与系统无关的东西，而通过Node自带的npm安装的插件默认在C盘，但是我将Node安装到D盘后，想让插件就安装在Nodejs的主目录下，怎么办呢?

  • 在Node主目录下新建"node_global"及"node_cache"两个文件夹
    •   
  
      
   
   
    1. 启动cmd，输入 
      2.    
   
    2. //后面的设置目录根据你的目录结构自行更改 
      3.    
   
    3. npm config set prefix "D:\Program\nodejs\node_global" 
      4.    
   
    4. npm config set cache "D:\Program\nodejs\node_cache" 
      5.
  • 关闭cmd，打开系统对话框，“我的电脑”右键“属性”-“高级系统设置”-“高级”-“环境变量”。
  • 进入环境变量对话框，在系统变量下新建"NODE_PATH"，输入"D:Programnodejsnode_globalnode_module"。 由于改变了module的默认地址，所以上面的用户变量都要跟着改变一下(用户变量"PATH"修改为"D:Programnodejsnode_global")，要不使用module的时候会导致输入命令出现“xxx不是内部或外部命令，也不是可运行的程序或批处理文件”这个错误。

经过这四步的设置就可以让安装的Node插件放在Nodejs的主目录了。

安装Gulp

 
 
    
  
  
  1. //全局安装Gulp 
    2.   
  
  2. npm install -g gulp 
    3.   
  
  3. //在项目中安装Gulp 
    4.   
  
  4. npm install --save-dev gulp  
    5.

运行gulp -v,如果不报错，表示安装成功

然后在命令行运行

 
 
    
  
  
  1. npm init 
    2.

让项目生产package.json文件

搭建工程

众所周知，在开发工程中有开发和上线两个过程，在开发中，我们一般需要自动刷新以及实时编译，但是如果上线，我们就需要考虑很多优化的东西，比如文件编译压缩，静态资源放缓存处理等等问题，我自己搭的这个工程只涉及到文件编译压缩，实时刷新，静态资源放缓存这三个基本的流程。

在项目的目录结构如下

 
 
    
  
  
  1. -------------------project 
    2.   
  
  2.     | 
    3.   
  
  3.     |--------------dist (该文件夹为打包生成的) 
    4.   
  
  4.     |   | 
    5.   
  
  5.     |   |----------css 
    6.   
  
  6.     |   |   | 
    7.   
  
  7.     |   |   |------index-9dcc24fe2e.css 
    8.   
  
  8.     |   | 
    9.   
  
  9.     |   |----------js 
    10.   
  
  10.     |   |   | 
    11.   
  
  11.     |   |   |------index-9dcc24fe2e.js 
    12.   
  
  12.     |   |----------index.html  
    13.   
  
  13.     | 
    14.   
  
  14.     |--------------src 
    15.   
  
  15.     |   | 
    16.   
  
  16.     |   |----------scss 
    17.   
  
  17.     |   |   | 
    18.   
  
  18.     |   |   |------index.scss 
    19.   
  
  19.     |   | 
    20.   
  
  20.     |   |----------js 
    21.   
  
  21.     |   |   | 
    22.   
  
  22.     |   |   |------index.js 
    23.   
  
  23.     |   | 
    24.   
  
  24.     |   |----------index.html 
    25.   
  
  25.     |--------------gulpfile.js 
    26.   
  
  26.     |--------------package.json  
    27.

开发所用流程

文件编译

在工程中准备使用scss作为css的预编译，所以需要利用gulp对scss进行编译，所以首先安装gulp-sass。

 
 
    
  
  
  1. npm install --save-dev gulp-sass 
    2.

安装完成之后，直接在gulpfile.js引用配置

 
 
    
  
  
  1. const sass = require('gulp-sass'); //scss编译 
    2.   
  
  2.  
    3.   
  
  3. gulp.task('scss:dev',()=>{ 
    4.   
  
  4.     gulp.src('src/scss/*.scss') 
    5.   
  
  5.     .pipe(sass()) 
    6.   
  
  6.     .pipe(gulp.dest('dist/css')); //将生成好的css文件放到dist/css文件夹下 
    7.   
  
  7. });  
    8.

这里简单介绍下gulp的两个api：

gulp.src()输入符合所提供的匹配模式或者匹配模式的数组的文件。将返回一个stream或者可以被piped到别的插件中。读文件

gulp.dest()能被pipe进来，并且将会写文件。并重新输出(emits)所有数据，因此可以将它pipe到多个文件夹，如果文件夹不存在则将会自动创建。写文件

实时刷新

实现实时刷新的工具有很多，我自己使用browser-sync，这个工具的功能非常强大，想了解它更多的用法可以查看官网：http://www.browsersync.cn/。

首先我们在项目中安装该模块

 
 
    
  
  
  1. npm install --save-dev browser-sync 
    2.

根据官网的browser-sync与gulp的配置，得到如下配置：

 
 
    
  
  
  1. const browserSync = require('browser-sync').create(); //实时刷新 
    2.   
  
  2. const reload = browserSync.reload; 
    3.   
  
  3.  
    4.   
  
  4. gulp.task('dev',['scss:dev'],function () { 
    5.   
  
  5.     browserSync.init({ 
    6.   
  
  6.         server:{ 
    7.   
  
  7.             baseDir:'./'  //设置服务器的根目录 
    8.   
  
  8.         }, 
    9.   
  
  9.         logLevel: "debug", 
    10.   
  
  10.         logPrefix:"dev", 
    11.   
  
  11.         browser:'chrome', 
    12.   
  
  12.         notify:false //开启静默模式 
    13.   
  
  13.     }); 
    14.   
  
  14.     //使用gulp的监听功能，实现编译修改过后的文件 
    15.   
  
  15.     gulp.watch('src/scss/*.scss',['scss:dev']); 
    16.   
  
  16.     gulp.watch(('*.html')).on('change',reload); 
    17.   
  
  17. });  
    18.

这样，一个简单的gulp开发流程就出来了，仅仅只是一个编译scss和一个实时刷新。

打包上线所有流程

打包上线，我们更多的是考虑，静态资源防缓存，优化。对css，js的压缩，对图片的处理，我写的这个简单的流程中并没有涉及对图片的处理，所以这里仅针对css，js，html处理。

压缩css我们使用gulp-sass就可以，因为它在编译scss的时候有一个配置选项可以直接输出被压缩的css。压缩js我使用了gulp-uglify，静态资源防缓存使用gulp-rev和gulp-rev-collector。

对css，js的处理

 
 
    
  
  
  1. //scss编译 
    2.   
  
  2. gulp.task('css',()=> { 
    3.   
  
  3.     gulp.src('src/scss/*.scss') 
    4.   
  
  4.         .pipe(sass({ 
    5.   
  
  5.             outputStyle: 'compressed'               //编译并输出压缩过的文件 
    6.   
  
  6.         })) 
    7.   
  
  7.         .pipe(rev())                                //给css添加哈希值 
    8.   
  
  8.         .pipe(gulp.dest('dist/css')) 
    9.   
  
  9.         .pipe(rev.manifest())                       //给添加哈希值的文件添加到清单中 
    10.   
  
  10.         .pipe(gulp.dest('rev/css')); 
    11.   
  
  11. }); 
    12.   
  
  12. //压缩js 
    13.   
  
  13. gulp.task('js', ()=> { 
    14.   
  
  14.     gulp.src('src/js/*js') 
    15.   
  
  15.         .pipe(uglify()) 
    16.   
  
  16.         .pipe(rev())                                //给js添加哈希值 
    17.   
  
  17.         .pipe(gulp.dest('dist/js')) 
    18.   
  
  18.         .pipe(rev.manifest())                       //给添加哈希值的文件添加到清单中 
    19.   
  
  19.         .pipe(gulp.dest('rev/js')); 
    20.   
  
  20. });  
    21.

其中gulp-rev是为css文件名添加哈希值，而rev.manifest()会生成一个json文件，这个json文件中记录了原文件名和添加哈希值后的文件名的一个对应关系，这个对应关系在***对应替换html的引用的时候会用到。

生成的json文件如下：

 
 
    
  
  
  1. { 
    2.   
  
  2.  
    3.   
  
  3. "index.css": "index-9dcc24fe2e.css" 
    4.   
  
  4.  
    5.   
  
  5. }  
    6.

由于给文件添加了哈希值，所以每次编译出来的css和js都是不一样的，这会导致有很多冗余文件，所以我们可以每次在生成文件之前，先将原来的文件全部清空。

gulp中也有做这个工作的插件---gulp-clean，因此我们可以在编译压缩添加哈希值之前先将原文将清空。

清空生成的项目文件

 
 
    
  
  
  1. const clean = require('gulp-clean');                 //清空文件夹里所有的文件 
    2.   
  
  2. //每次打包时先清空原有的文件夹 
    3.   
  
  3. gulp.task('clean', ()=> { 
    4.   
  
  4.     gulp.src(['dist', 'rev'], {read: false}) //这里设置的dist表示删除dist文件夹及其下所有文件 
    5.   
  
  5.         .pipe(clean()); 
    6.   
  
  6. });  
    7.

让添加哈希编码的文件自动添加到html中

前面提到的gulp-rev实现了给文件名添加哈希编码，但是在打包完成后如何让原来未添加哈希值的引用自动变为已经添加哈希值的引用，这里用到gulp-rev的一个插件gulp-rev-collector，配置如下：

 
 
    
  
  
  1. //将处理过的css，js引入html 
    2.   
  
  2. gulp.task('reCollector',()=>{ 
    3.   
  
  3.     gulp.src(['rev/**/*.json','src/*.html']) 
    4.   
  
  4.         .pipe(reCollector({ 
    5.   
  
  5.             replaceReved: true,  //模板中已经被替换的文件是否还能再被替换,默认是false 
    6.   
  
  6.             dirReplacements: {   //标识目录替换的集合, 因为gulp-rev创建的manifest文件不包含任何目录信息, 
    7.   
  
  7.                 'css/': '/dist/css/', 
    8.   
  
  8.                 'js/': '/dist/js/' 
    9.   
  
  9.             } 
    10.   
  
  10.         })) 
    11.   
  
  11.         .pipe(gulp.dest('dist')) 
    12.   
  
  12. });  
    13.

并没有正常替换?

在我自己写的时候，出现这个问题，运行完成该任务后，html中的css和js引用并没有发生变化，网上搜了半天，才知道是由于自己用了gulp-rename插件，然后将文件名都添加了.min(至于为什么添加，仅仅是因为是压缩过的，应该写个)而在自己写的html里面引用的文件并没有.min，由于gulp-rev-collector在替换的时候根据生成的json文件替换，在json中，文件都有了.min而在html中没有，所以无法匹配，自然也就不能实现替换了，所以在替换的时候一定要注意gulp-rev生成的json文件中的css，js与html中的引用的一样，否则无法实现替换。

在gulp-rev-collector的api中有一个revSuffix，这个看起来可以实现类似于gulp-rename的功能，但是不知道该怎么用，大家如果知道的话请告诉我...

执行所有任务

完成上面几个步骤后我们将所有任务串起来，让其可以一条命令然后全部执行

 
 
    
  
  
  1. gulp.task('build',['clean', 'css', 'js', 'reCollector']); 
    2.

再次理解gulp

gulp---它的task是顺序执行吗?

本以为到这里，就算是写完了，运行，***，打包生成文件，再运行一次，报错了!!!!

 
 
    
  
  
  1. [19:04:57] Finished 'default' after 7.38 μs 
    2.   
  
  2. stream.js:74 
    3.   
  
  3.       throw er; // Unhandled stream error in pipe. 
    4.   
  
  4.       ^ 
    5.   
  
  5.  
    6.   
  
  6. Error: ENOENT: no such file or directory, stat 'D:\project\dist\js\index-6045b384e6.min.js' 
    7.   
  
  7.     at Error (native)  
    8.

提示我找不到这个文件，这让我很郁闷啊，然后我分开执行，很ok，可以确定是执行顺序有问题，很可能在没有清理完成就执行后面了，查了gulp的官网文档才知道本身gulp的pipe是一个一个任务进行的，是同步的，但是每个task之间是不同步的，是一起进行的，这也验证了我的猜想，所以在网上找如何解决这个问题，找到一个叫run-sequence的npm插件，配置文件如下：

 
 
    
  
  
  1. //进行打包上线 
    2.   
  
  2. gulp.task('build', ()=> { 
    3.   
  
  3.     runSequence('clean', ['css', 'js'], 'reCollector'); 
    4.   
  
  4. });  
    5.

本以为运行就ok，结果，还是报错，这里就涉及到对gulp的另一个理解

run-sequence插件对异步任务的处理

在用这个插件让任务有序进行后，我想进一步直观的看到它对任务的序列化，自己写了一个demo，如下：

 
 
    
  
  
  1. gulp.task('a',function(){ 
    2.   
  
  2.     setTimeout(function () { 
    3.   
  
  3.         console.log(1); 
    4.   
  
  4.     },30); 
    5.   
  
  5. }); 
    6.   
  
  6. gulp.task('b',function() { 
    7.   
  
  7.     console.log(2); 
    8.   
  
  8. }); 
    9.   
  
  9. gulp.task('ab',function(){ 
    10.   
  
  10.     runSequence('a','b'); 
    11.   
  
  11. });  
    12.

但是这里就出现问题了，runSequence不管用了，找插件的说明和gulp官方文档，原来异步任务，像setTimeout，readFile等，需要添加一个callback的执行，这里的callback()就会返回一个promise的resolve()，告诉后面的任务，当前任务已经完成，后面可以继续执行了，所以在task a里面执行callback。

 
 
    
  
  
  1. gulp.task('a',function(cb){ 
    2.   
  
  2.     setTimeout(function () { 
    3.   
  
  3.         console.log(1); 
    4.   
  
  4.         cb(); 
    5.   
  
  5.     },30); 
    6.   
  
  6. });  
    7.

那为什么前面写的那些任务不需要添加一个callback呢?由于gulp的pipe流让每一个task中的小任务(每一个pipe)顺序执行，从而整个pipe流是同步的，并不是异步任务，所以并不需要手动让其返回promise，run-sequence会自动帮我们管理。

总结

至此，我们就完成了一个简易的基于gulp的前端工程的搭建，很多东西确实，想着并不难，做起来会出现各种各样意想不到的问题，gulp很早就知道，都是单个任务在写，然后用哪个执行哪个命令，直到自己写完这个这个简单的工程，才对gulp有了更深入的理解。

分享名称：基于Gulp的简易前端自动化工程搭建
标题网址：http://www.hantingmc.com/qtweb/news7/390407.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

静态网站知识

分类信息网

成都申请ssl证书　　 　成都网站制作　　 　成都酒店服定制　　 　犀浦防护栏定制　　 　成都微信开发　　 　成都托管服务器　　 　wap网站建设　　 　网站搜索引擎优化　　 　兴发搬家　　 　自适应网站　　 　成都网站推广公司　　 　双流做网站　　 　网站域名　　 　关键词排名优化　　 　香港空间腾讯云　　 　主动防护网　　 　橡塑保温管　　 　成都移动服务器托管　　 　添翼二手车鉴定　　 　资阳做网站