Gulp构建前端自动化

发表于   |   分类于   |     |   阅读次数

Gulp简介

gulp是前端开发过程中一种基于流的代码构建工具，是自动化项目的构建利器；她能自动化地完成 javascript、coffee、sass、less、html/image、css等文件的测试、检查、合并、压缩、格式化、浏览器自动刷新、部署文件生成，并监听文件在改动后重复指定的这些步骤。在实现上，她借鉴了Unix操作系统的管道（pipe）思想，前一级的输出，直接变成后一级的输入，使得在操作上非常简单。
demo.png

特点：

  • 易于使用：通过代码优于配置的策略，gulp 让简单的任务简单，复杂的任务可管理。
  • 构建快速：利用 Node.js 流的威力，你可以快速构建项目并减少频繁的 IO 操作。
  • 易于学习：通过最少的 API，掌握gulp毫不费力，如同一系列流管道。
  • 插件丰富：gulp 严格的插件指南确保插件如你期望的那样简洁高质得工作。

安装

首先确保你已经正确安装了nodejs环境。然后以全局方式安装gulp：

1
npm install -g gulp

全局安装gulp后，还需要在每个要使用gulp的项目中都单独安装一次。把目录切换到你的项目文件夹中，然后在命令行中执行：

1
npm install gulp

如果想在安装的时候把gulp写进项目package.json文件的依赖中，则可以加上–save-dev：

1
npm install --save-dev gulp

这样就完成了gulp的安装，接下来就可以在项目中应用gulp了。

使用

第一步：建立gulpfile.js文件

gulp需要一个文件作为它的主文件，这个文件就是gulpfile.js。新建一个文件名为gulpfile.js的文件，然后放到你的项目目录中。之后要做的事情就是在gulpfile.js文件中定义任务。下面是一个最简单的gulpfile.js文件内容示例，它定义了一个默认的任务。

1
2
3
4
var gulp = require('gulp');
gulp.task('default',function(){
    console.log('hello world');
});

第二步：运行gulp任务

要运行gulp任务，只需切换到存放gulpfile.js文件的目录，然后在命令行中执行gulp命令就行了，gulp后面可以加上要执行的任务名，例如gulp task1，如果没有指定任务名，则会执行任务名为default的默认任务。

常用方法

src()

gulp.src()方法正是用来获取流的，但要注意这个流里的内容不是原始的文件流，而是一个虚拟文件对象流，这个虚拟文件对象中存储着原始文件的路径、文件名、内容等信息。其语法为：

1
gulp.src(globs[, options]);

globs参数是文件匹配模式(类似正则表达式)，用来匹配文件路径(包括文件名)，当然这里也可以直接指定某个具体的文件路径。当有多个匹配模式时，该参数可以为一个数组;类型为String或 Array.

options为可选参数。

options.buffer

类型： Boolean 默认值： true

　　如果该项被设置为 false，那么将会以 stream 方式返回 file.contents 而不是文件 buffer 的形式。这在处理一些大文件的时候将会很有用。注意：插件可能并不会实现对 stream 的支持。

options.read

类型： Boolean 默认值： true

如果该项被设置为 false， 那么 file.contents 会返回空值（null），也就是并不会去读取文件。

options.base

类型： String ， 设置输出路径以某个路径的某个组成部分为基础向后拼接。

例如在一个路径为 client/js/somedir 的目录中，有一个文件叫 somefile.js ：

1
2
3
4
5
6
7
gulp.src('client/js/**/*.js') // 匹配 'client/js/somedir/somefile.js' 现在 `base` 的值为 `client/js/`
  .pipe(minify())
  .pipe(gulp.dest('build'));  // 写入 'build/somedir/somefile.js' 将`client/js/`替换为build
 
gulp.src('client/js/**/*.js', { base: 'client' }) // base 的值为 'client'
  .pipe(minify())
  .pipe(gulp.dest('build'));  // 写入 'build/js/somedir/somefile.js' 将`client`替换为build

desk()

gulp.dest()方法是用来写文件的，其语法为：

1
gulp.dest(path[,options])

path为写入文件的路径；options为一个可选的参数对象，以下为选项参数：

options.cwd

类型： String 默认值： process.cwd()

输出目录的 cwd 参数，只在所给的输出目录是相对路径时候有效。

options.mode

类型： String 默认值： 0777

八进制权限字符，用以定义所有在输出目录中所创建的目录的权限。

1
2
3
var gulp = require('gulp');
gulp.src('script/jquery.js')　       // 获取流
    .pipe(gulp.dest('dist/foo.js')); // 写放文件

下面再说说生成的文件路径与我们给gulp.dest()方法传入的路径参数之间的关系。 　　gulp.dest(path)生成的文件路径是我们传入的path参数后面再加上gulp.src()中有通配符开始出现的那部分路径。例如：

1
2
3
4
5
var gulp = reruire('gulp');
//有通配符开始出现的那部分路径为 **/*.js
gulp.src('script/**/*.js')
    .pipe(gulp.dest('dist')); //最后生成的文件路径为 dist/**/*.js
//如果 **/*.js 匹配到的文件为 jquery/jquery.js ,则生成的文件路径为 dist/jquery/jquery.js

用gulp.dest()把文件流写入文件后，文件流仍然可以继续使用。

watch()

gulp.watch()用来监视文件的变化，当文件发生变化后，我们可以利用它来执行相应的任务，例如文件压缩等。其语法为

1
gulp.watch(glob[, opts], tasks);

glob 为要监视的文件匹配模式，规则和用法与gulp.src()方法中的glob相同。 opts 为一个可选的配置对象，通常不需要用到。tasks为文件变化后要执行的任务，为一个数组。

1
2
3
4
5
6
7
gulp.task('uglify',function(){
  //do something
});
gulp.task('reload',function(){
  //do something
});
gulp.watch('js/**/*.js', ['uglify','reload']);

gulp.watch()还有另外一种使用方式：

1
gulp.watch(glob[, opts, cb]);

glob和opts参数与第一种用法相同;

cb参数为一个函数。每当监视的文件发生变化时，就会调用这个函数,并且会给它传入一个对象，该对象包含了文件变化的一些信息，type属性为变化的类型，可以是added,changed,deleted；path属性为发生变化的文件的路径。

1
2
3
4
gulp.watch('js/**/*.js', function(event){
    console.log(event.type); //变化类型added为新增,deleted为删除，changed为改变 
    console.log(event.path); //变化的文件的路径
});

task()

gulp.task()方法用来定义任务，内部使用的是Orchestrator(用于排序、执行任务和最大并发依赖关系的模块)，其语法为：

1
gulp.task(name[, deps], fn)

name 为任务名；

deps 是当前定义的任务需要依赖的其他任务，为一个数组。当前定义的任务会在所有依赖的任务执行完毕后才开始执行。如果没有依赖，则可省略这个参数；

fn 为任务函数，任务执行的代码都写在里面。该参数也是可选的。

当你定义一个简单的任务时，需要传入任务名字和执行函数两个属性。

1
2
3
gulp.task('greet', function () {
   console.log('Hello world!');
});

执行gulp greet的结果就是在控制台上打印出“Hello world”。

你也可以定义一个在gulp开始运行时候默认执行的任务，并将这个任务命名为default：

1
2
3
gulp.task('default', function () {
   // Your default task
});

当有多个任务时，可以通过任务依赖来控制任务的执行顺序。

例如执行one,two,three这三个任务，那我们就可以定义一个空的任务，然后把那三个任务当做这个空的任务的依赖就行了：

1
2
//只要执行default任务，就相当于把one,two,three这三个任务执行了
gulp.task('default',['one','two','three']);

如果任务相互之间没有依赖，任务就会按你书写的顺序来执行，如果有依赖的话则会先执行依赖的任务。但是如果某个任务所依赖的任务是异步的，就要注意了，gulp并不会等待那个所依赖的异步任务完成，而是会接着执行后续的任务。例如：

1
2
3
4
5
6
7
8
9
10
11
gulp.task('one',function(){
  //one是一个异步执行的任务
  setTimeout(function(){
    console.log('one is done')
  },5000);
});
 
//two任务虽然依赖于one任务,但并不会等到one任务中的异步操作完成后再执行
gulp.task('two',['one'],function(){
  console.log('two is done');
});

上面的例子中执行two任务时，会先执行one任务，但不会去等待one任务中的异步操作完成后再执行two任务，而是紧接着执行two任务。所以two任务会在one任务中的异步操作完成之前就执行了。

那如果我们想等待异步任务中的异步操作完成后再执行后续的任务，该怎么做呢？

有三种方法可以实现：

第一：在异步操作完成后执行一个回调函数来通知gulp这个异步任务已经完成,这个回调函数就是任务函数的第一个参数。

1
2
3
4
5
6
7
8
9
10
11
12
gulp.task('one',function(cb){ //cb为任务函数提供的回调，用来通知任务已经完成
  //one是一个异步执行的任务
  exec(function(){
    console.log('one is finish');
    cb();  //执行回调，表示这个异步任务已经完成
  },5000);
});
 
//这时two任务会在one任务中的异步操作完成后再执行
gulp.task('two',['one'],function(){
  console.log('two is finish');
});

第二：定义任务时返回一个流对象。适用于任务就是操作gulp.src获取到的流的情况。

1
2
3
4
5
6
7
8
9
10
gulp.task('one',function(cb){
  var stream = gulp.src('client/**/*.js')
      .pipe(exec()) //exec()中有某些异步操作
      .pipe(gulp.dest('build'));
    return stream;
});
 
gulp.task('two',['one'],function(){
  console.log('two is done');
});

第三：返回一个promise对象，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var Q = require('q');
gulp.task('one', function() {
  var deferred = Q.defer();
 
  // 执行异步的操作
  setTimeout(function() {
    deferred.resolve();
  }, 1);
  return deferred.promise;
});
 
gulp.task('two',['one'],function(){
  console.log('two is done');
});

run()

gulp.run()表示要执行的任务。可能会使用单个参数的形式传递多个任务。如下代码：

1
2
3
gulp.task('end',function(){
    gulp.run('task1','task3','task2');
});

注意：任务是尽可能多的并行执行的，并且可能不会按照指定的顺序运行。

常用插件

自动加载

gulp-load-plugins这个插件能自动帮你加载package.json文件里的gulp插件。例如假设package.json文件里的依赖是这样的:

1
2
3
4
5
6
7
8
{
  "devDependencies": {
    "gulp": "~3.6.0",
    "gulp-rename": "~1.2.0",
    "gulp-ruby-sass": "~0.4.3",
    "gulp-load-plugins": "~0.5.1"
  }
}

然后我们可以在gulpfile.js中使用gulp-load-plugins来帮我们加载插件：

1
2
3
var gulp = require('gulp');
//加载gulp-load-plugins插件，并马上运行它
var plugins = require('gulp-load-plugins')();

然后我们要使用gulp-rename和gulp-ruby-sass这两个插件的时候，就可以使用plugins.rename和plugins.rubySass来代替了,也就是原始插件名去掉gulp-前缀，之后再转换为驼峰命名。

重命名

gulp-rename插件用来重命名文件流中的文件。用gulp.dest()方法写入文件时，文件名使用的是文件流中的文件名，如果要想改变文件名，那可以在之前用gulp-rename插件来改变文件流中的文件名。

1
2
3
4
5
6
7
8
9
10
var gulp = require('gulp'),
    rename = require('gulp-rename'),
    uglify = require("gulp-uglify");
 
gulp.task('rename', function () {
    gulp.src('src/1.js')
        .pipe(uglify())           //压缩
        .pipe(rename('1.min.js')) //会将1.js重命名为1.min.js
        .pipe(gulp.dest('js'));   // 压缩后的路径
});

js文件压缩

gulp-uglify插件用来压缩js文件。

1
2
3
4
5
6
7
var gulp = require('gulp'),
    uglify = require("gulp-uglify");
 
gulp.task('minify-js', function () {
    gulp.src('src/*.js')             // 要压缩的js文件
        .pipe(uglify())              // 使用uglify进行压缩
        .pipe(gulp.dest('dist/js'));

css文件压缩

gulp-minify-css插件用来压缩css文件。

1
2
3
4
5
6
7
8
var gulp = require('gulp'),
    minifyCss = require("gulp-minify-css");
 
gulp.task('minify-css', function () {
    gulp.src('src/*.css')     // 要压缩的css文件
        .pipe(minifyCss())    // 压缩css
        .pipe(gulp.dest('dist/css'));
});

html文件压缩

gulp-minify-html插件用来压缩html文件。

1
2
3
4
5
6
7
8
var gulp = require('gulp'),
    minifyHtml = require("gulp-minify-html");
 
gulp.task('minify-html', function () {
    gulp.src('src/*.html')      // 要压缩的html文件
        .pipe(minifyHtml())     // 压缩
        .pipe(gulp.dest('dist/html'));
});

js代码检查

使用gulp-jshint插件，用来检查js代码。

1
2
3
4
5
6
7
8
var gulp = require('gulp'),
    jshint = require("gulp-jshint");
 
gulp.task('jsLint', function () {
    gulp.src('src/*.js')
        .pipe(jshint())
        .pipe(jshint.reporter()); // 输出检查结果
});

文件合并

gulp-concat插件，用来把多个文件合并为一个文件,我们可以用它来合并js或css文件等。

1
2
3
4
5
6
7
var gulp = require('gulp'),
    concat = require("gulp-concat");
gulp.task('concat', function () {
    gulp.src('src/*.js')          // 要合并的文件
        .pipe(concat('all.js'))   // 合并匹配到的js文件并命名为 "all.js"
        .pipe(gulp.dest('dist/js'));
});

图片压缩

gulp-imagemin插件来压缩jpg、png、gif等图片。

1
2
3
4
5
6
7
8
9
10
11
var gulp = require('gulp');
var imagemin = require('gulp-imagemin');
var pngquant = require('imagemin-pngquant'); //png图片压缩插件
gulp.task('default', function () {
    return  gulp.src('src/images/*')
                .pipe(imagemin({
                    progressive: true,
                    use: [pngquant()] //使用pngquant来压缩png图片
                }))
                .pipe(gulp.dest('dist'));
});

自动刷新

使用gulp-livereload插件，当代码变化时，它可以帮我们自动刷新页面。

1
2
3
4
5
6
7
8
9
10
11
12
13
var gulp = require('gulp'),
    less = require('gulp-less'),
    livereload = require('gulp-livereload');
gulp.task('less', function() {
    gulp.src('less/*.less')
        .pipe(less())
        .pipe(gulp.dest('css'))
        .pipe(livereload());
});
gulp.task('watch', function() {
  livereload.listen(); //要在这里调用listen()方法
  gulp.watch('less/*.less', ['less']);
});

启动服务器

使用gulp-connect插件，可以启动一个本地服务器,常与gulp-livereload插件一块使用

1
2
3
4
5
6
7
8
9
var gulp = require("gulp"),
	connect = require('gulp-connect');
 
gulp.task('server', function() {
    connect.server({
        livereload: true,
        port: 5000  //端口号
    });
});