【grunt第二彈】30分鍾學會使用grunt打包前端代碼（02）

前言

上一篇博客，我們簡單的介紹了grunt的使用，一些基礎點沒能覆蓋，我們今天有必要看看一些基礎知識

【grunt第一彈】30分鍾學會使用grunt打包前端代碼

配置任務/grunt.initConfig

前面我們簡單的介紹了grunt相關的知識，這里我們這里還需要再熟悉下Gruntfile相關的知識點，比如說配置任務

grunt的任務配置都是在Gruntfile中的grunt.initConfig方法中指定的，這個配置主要都是一些命名性屬性
比如我們上次用到的合並以及壓縮的任務配置：

grunt.initConfig({
    concat: {
        //這里是concat任務的配置信息
    },
    uglify: {
        //這里是uglify任務的配置信息
    },
    //任意非任務特定屬性
    my_property: 'whatever',
    my_src_file: ['foo/*.js', 'bar/*.js']
});

其中的my_property完全可能讀取外部json配置文件，然后在上面任務配置中便可以，比如我們要壓縮的文件為准或者最后要放到哪里，便可以在此配置

我們使用grunt的時候，主要工作就是配置任務或者創建任務，實際上就是做一個事件注冊，然后由我們觸發之，所以grunt的核心還是事件注冊
每次運行grunt時，我們可以指定運行一個或者多個任務，通過任務決定要做什么，比如我們同時要壓縮和合並還要做代碼檢查

grunt.registerTask('default', ['jshint','qunit','concat','uglify']);

當運行一個基本任務時，grunt並不會查找配置和檢查運行環境，他僅僅運行指定的任務函數，可以傳遞冒號分割參數，比如：

grunt.registerTask('foo', 'A sample task that logs stuff.', function (arg1, arg2) {
  if (arguments.length === 0) {
    grunt.log.writeln(this.name + ", no args");
  } else {
    grunt.log.writeln(this.name + ", " + arg1 + " " + arg2);
  }
});

運行結果如下：

$ grunt foo:testing:123
Running "foo:testing:123" (foo) task
foo, testing 123

$ grunt foo:testing
Running "foo:testing" (foo) task
foo, testing undefined

$ grunt foo
Running "foo" task
foo, no args

這里有個多任務的情況，就是一個任務里面實際上第一了多個東東，這個時候就有所不同

grunt.initConfig({
    log: {
        demo01: [1,2,3],
        demo02: 'hello world',
        demo03: false
    }
});
grunt.registerTask('log','log stuff.', function(){
    grunt.log.writeln(this.target + ': ' + this.data);
});

如果我們運行，運行情況如下：

???????

更多時候，我們實際場景中都會需要自定義任務，而在我們任務內部使用 grunt.task.run({}) 運行任務
這塊的知識點，我們后面以實際例子說明

grunt插件

學習grunt主要就是學習grunt的插件使用，所以我們今天先來學習常用的幾個插件

grunt-contrib-unglify

我們仍然以簡單例子學習

module.exports = function (grunt) {
  grunt.initConfig({
    uglify: {
      my_target: {
        files: {
          'dest/libs.min.js': ['src/zepto.js', 'src/underscoce.js']
        }
      }
    }
  });
  grunt.loadNpmTasks('grunt-contrib-uglify');
}

這樣會將src里面的zepto等文件打包值dest的lib.min.js中

壓縮一個文件夾的所有文件

然后這段代碼非常有意思，他會將一個文件目錄里面的所有js文件打包到另一個文件夾

module.exports = function (grunt) {
  grunt.initConfig({
    uglify: {
      my_target: {
        files: [{
          expand: true,
          cwd: 'src',
          src: '**/*.js',
          dest: 'dest'
        }]
      }
    }
  });
  grunt.loadNpmTasks('grunt-contrib-uglify');
}

若是你希望給你文件的頭部加一段注釋性語言配置banner信息即可

grunt.initConfig({
  pkg: grunt.file.readJSON('package.json'),
  uglify: {
    options: {
      banner: '/*! 注釋信息 */'
    },
    my_target: {
      files: {
        'dest/output.min.js': ['src/input.js']
      }
    }
  }
});

grunt-contrib-concat

該插件主要用於代碼合並，將多個文件合並為一個，我們前面的uglify也提供了一定合並的功能
在可選屬性中我們可以設置以下屬性：
① separator 用於分割各個文件的文字，
② banner 前面說到的文件頭注釋信息，只會出現一次
③ footer 文件尾信息，只會出現一次
④ stripBanners去掉源代碼注釋信息（只會清楚/**/這種注釋）

一個簡單的例子：

module.exports = function (grunt) {
  grunt.initConfig({
  concat: {
    options: {
      separator: '/*分割*/',
      banner: '/*測試*/',
      footer: '/*footer*/'
     
    },
    dist: {
      src: ['src/zepto.js', 'src/underscore.js', 'src/backbone.js'],
      dest: 'dist/built.js',
    }
  }
});
  grunt.loadNpmTasks('grunt-contrib-concat');
}

合並三個文件為一個，這種在我們源碼調試時候很有意義

構建兩個文件夾

有時候我們可能需要將合並的代碼放到不同的文件，這個時候可以這樣干

module.exports = function (grunt) {
  grunt.initConfig({
    concat: {
      basic: {
        src: ['src/zepto.js'],
        dest: 'dest/basic.js'
      },
      extras: {
        src: ['src/underscore.js', 'src/backbone.js'],
        dest: 'dest/with_extras.js'
      }
    }
  });
  grunt.loadNpmTasks('grunt-contrib-concat');
}

這種功能還有這樣的寫法：

module.exports = function (grunt) {
  grunt.initConfig({
    concat: {
      basic_and_extras: {
        files: {
          'dist/basic.js': ['src/test.js', 'src/zepto.js'],
          'dist/with_extras.js': ['src/underscore.js', 'src/backbone.js']
        }
      }
    }
  });
  grunt.loadNpmTasks('grunt-contrib-concat');
}

第二種寫法便於使用配置文件，具體各位選取吧，至於讀取配置文件的東西我們這里就先不關注了

grunt-contrib-jshint

該插件用於檢測文件中的js語法問題，比如我test.js是這樣寫的：

alert('我是葉小釵')

module.exports = function (grunt) {
  grunt.initConfig({
    jshint: { 
      all: ['src/test.js']
    }
  });
  grunt.loadNpmTasks('grunt-contrib-jshint');
}

運行結果是：

$ grunt jshint
Running "jshint:all" (jshint) task
Linting src/test.js ...ERROR
[L1:C15] W033: Missing semicolon.
alert('我是葉小釵')

說我缺少一個分號，好像確實缺少.....如果在里面寫明顯的BUG的話會報錯
多數時候，我們認為沒有分號無傷大雅，所以，我們文件會忽略這個錯誤：

jshint: {
  options: {
    '-W033': true
  },
  all: ['src/test.js']
}

這里有一個稍微復雜的應用，就是我們合並之前做一次檢查，合並之后再做一次檢查，我們可以這樣寫

module.exports = function (grunt) {
  grunt.initConfig({
    concat: {
      dist: {
        src: ['src/test01.js', 'src/test02.js'],
        dest: 'dist/output.js'
      }
    },
    jshint: {
      options: {
        '-W033': true 
      },
      pre: ['src/test01.js', 'src/test02.js'],
      after: ['dist/output.js']
    }
  });
  grunt.loadNpmTasks('grunt-contrib-concat');
  grunt.loadNpmTasks('grunt-contrib-jshint');
}

$ grunt jshint:pre concat jshint:after
Running "jshint:pre" (jshint) task
>> 2 files lint free.
Running "concat:dist" (concat) task
File "dist/output.js" created.
Running "jshint:after" (jshint) task
>> 1 file lint free.

這里連續運行了三個任務，先做檢查再合並，然后做檢測，我這里寫了兩個簡單的文件，如果將jquery搞進去的話，好像還出了不少BUG......
所以真的要用它還要自定一些規范，我們這里暫時到這里，先進入下一個插件學習

grunt-contrib-requirejs

我們的grunt打包程序極有可能與requirejs一起使用，但是幾個插件學習下來又屬requireJs的使用最為麻煩，因為網上資源很少，搞到這一段耗掉了我很多精力

這個時候你就會感嘆，英語好不一定編程好，英語差想成為高手還是不簡單啊！！！

requirejs: {
  compile: {
    options: {
      baseUrl: "path/to/base",
      mainConfigFile: "path/to/config.js",
      name: "path/to/almond", // assumes a production build using almond
      out: "path/to/optimized.js"
    }
  }
}

官方的例子首先就是這幾個屬性：

baseUrl 代表所有的js文件都會相對於這個目錄

mainConfigFile 配置文件目錄

name ？？？

out 輸出文件

一些參數我們不太了解，這個時候就只能以例子破之了

module.exports = function (grunt) {
  grunt.initConfig({
    requirejs: {
      compile: {
        "options": {
          "baseUrl": "./",
          "paths": {
            "$": "src/zepto",
            "_": "src/underscore",
            "B": "src/backbone",
            "Test": "src/Test01"
          },
          "include": [
            "$",
            "_",
            "B",
            "Test"
          ],
          "out": "dest/libs.js"
        }
      }
    }
  });
  grunt.loadNpmTasks('grunt-contrib-requirejs');
}

這樣配置后，會將include里面的文件打包為out對應的文件，paths的本身意義不大，就是用於配置include里面的指向

這個時候我們來加個name看看有神馬作用：

module.exports = function (grunt) {
  grunt.initConfig({
    requirejs: {
      compile: {
        "options": {
          "baseUrl": "./",
          "name": 'src/test02.js',
          "paths": {
            "$": "src/zepto",
            "_": "src/underscore",
            "B": "src/backbone",
            "Test": "src/Test01"
          },
          "include": [
            "$",
            "_",
            "B",
            "Test"
          ],
          "out": "dest/libs.js"
        }
      }
    }
  });
  grunt.loadNpmTasks('grunt-contrib-requirejs');
}

這樣的話，會將name對應文件壓縮到壓縮文件的最前面，但是具體是干什么的，還是不太清楚，其英文注釋說是單個文件或者其依賴項優化，不知道優化什么啊。。。囧！！！

requireJS基本的用法就是這樣了，其詳細信息，我們過段時間再來看看，下面說一下requireJS的其它用法

我們這里將requireJS的配置信息放在外面，而Gruntfile采用自定義任務的方式完成上面的功能

配置文件/cfg.json

{requirejs: {
  "options": {
    "baseUrl": "./",
    "paths": {
      "$": "src/zepto",
      "_": "src/underscore",
      "B": "src/backbone",
      "Test": "src/Test01"
    },
    "include": [
      "$",
      "_",
      "B",
      "Test"
    ],
    "out": "dest/libs.js"
  }
}}

然后，這里我們便不是有initConfig的做法了，直接使用自定義任務

module.exports = function (grunt) {

  grunt.loadNpmTasks('grunt-contrib-requirejs');

  grunt.registerTask('build', 'require demo', function () {

    //第一步，讀取配置信息
    var cfg = grunt.file.readJSON('cfg.json');
    cfg = cfg.requirejs;
    grunt.config.set('requirejs', { test: cfg });

    //第二步，設置參數
    grunt.log.debug('參數：' + JSON.stringify(grunt.config()));

    //第三步跑任務
    grunt.task.run(['requirejs']);
    
  });

}

$ grunt build --debug
Running "build" task
[D] Task source: d:\grunt\Gruntfile.js
[D] 參數：{"requirejs":{"test":{"options":{"baseUrl":"./","paths":{"$":"src/zept
o","_":"src/underscore","B":"src/backbone","Test":"src/Test01"},"include":["$","
_","B","Test"],"out":"dest/libs.js"}}}}

Running "requirejs:test" (requirejs) task
[D] Task source: d:\grunt\node_modules\grunt-contrib-requirejs\tasks\requirejs.j
s
>> Tracing dependencies for: d:/grunt/dest/libs.js
>> Uglifying file: d:/grunt/dest/libs.js
>> d:/grunt/dest/libs.js
>> ----------------
>> d:/grunt/src/zepto.js
>> d:/grunt/src/underscore.js
>> d:/grunt/src/backbone.js
>> d:/grunt/src/Test01.js

效果還是有的，最后我們介紹下requireJS打包模板文件

require與模板文件

我們知道，模板文件一般都是html，比如我們這里的demo01.html，對於這個文件我們應該怎么打包呢？其實很簡單......

需要干兩件事情：

① 引入require.text

② 加入模板文件

{
  "requirejs": {
    "options": {
      "baseUrl": "./",
      "paths": {
        "$": "src/zepto",
        "_": "src/underscore",
        "B": "src/backbone",
        "test": "src/test01",
        "text": "src/require.text"

      },
      "include": [
        "$",
        "_",
        "B",
        "test",
        "text!src/demo01.html"
      ],
      "out": "dest/libs.js"
    }
  }
}

於是，我們便成功將模板打入了

$ grunt build --debug
Running "build" task
[D] Task source: d:\grunt\Gruntfile.js
[D] 參數：{"requirejs":{"test":{"options":{"baseUrl":"./","paths":{"$":"src/zept
o","_":"src/underscore","B":"src/backbone","test":"src/test01","text":"src/requi
re.text"},"include":["$","_","B","test","text!src/demo01.html"],"out":"dest/libs
.js"}}}}

Running "requirejs:test" (requirejs) task
[D] Task source: d:\grunt\node_modules\grunt-contrib-requirejs\tasks\requirejs.j
s
>> Tracing dependencies for: d:/grunt/dest/libs.js
>> Uglifying file: d:/grunt/dest/libs.js
>> d:/grunt/dest/libs.js
>> ----------------
>> d:/grunt/src/zepto.js
>> d:/grunt/src/underscore.js
>> d:/grunt/src/backbone.js
>> d:/grunt/src/test01.js
>> d:/grunt/src/require.text.js
>> text!src/demo01.html

在文件中我們引用方式是：

"text!src/demo01.html" => '具體文件'

打包樣式文件

樣式文件的打包方式與js不太一樣，這里我們下載css-min插件，並且在package.json中新增依賴項

{
  "name": "demo",
  "version":         "0.1.0",
  "description":     "demo",
  "license":         "MIT",
  "devDependencies": {
    "grunt":                   "~0.4.1",
    "grunt-contrib-jshint":    "~0.6.3",
    "grunt-contrib-concat":    "~0.3.0",
    "grunt-contrib-uglify":    "~0.2.1",
    "grunt-contrib-requirejs": "~0.4.1",
    "grunt-contrib-copy":      "~0.4.1",
    "grunt-contrib-clean":     "~0.5.0",
    "grunt-strip":             "~0.2.1",
    "grunt-contrib-watch": "~0.6.0",
    "grunt-contrib-cssmin": "~0.5.0"
  },
  "dependencies":    {
    "express": "3.x"
  }
}

module.exports = function (grunt) {
  grunt.initConfig({
    cssmin: {
      compress: {
        files: {
          'dest/car.min.css': [
          "src/car.css",
          "src/car01.css"
        ]
        }
      }
    }
  });

  grunt.loadNpmTasks('grunt-contrib-cssmin');

}

如此一來我們便可以壓縮合並CSS文件了：

$ grunt cssmin --debug
Running "cssmin:compress" (cssmin) task
[D] Task source: d:\grunt\node_modules\grunt-contrib-cssmin\tasks\cssmin.js
File dest/car.min.css created.

下集預告

今天，我們一起來學習了一些grunt打包的基礎知識，明天我們就進行下面的學習，簡單結束這一輪grunt相關的知識

1 移動打包文件

我們的開發版本與使用版本可能不在一個位置哦

2 分支處理

不同分支打包

3 native包與HTML5包

在HTML5嵌入webview的時代，我們當然存在一次打包既要形成網站文件也要形成app文件

4 分頻道打包

當然可能存在分頻道分分支打包的情況

今日到此為止，待續......