grunt

是一套前端自动化工具，一个基于nodeJs的命令行工具，一般用于：
① 压缩文件
② 合并文件
③ 简单语法检查

对于其他用法，我还不太清楚，我们这里简单介绍下grunt的压缩、合并文件，初学，有误请包涵

准备阶段

1、nodeJs环境

因为grunt是基于nodeJs的，所以首先各位需要安装nodeJS环境，这块我们便不管了
http://www.cnblogs.com/yexiaochai/p/3527418.html

2、安装grunt

有了nodeJs环境后，我们便可以开始搞grunt了，因为我们可能在任何目录下运行打包程序，所以我们需要安装CLI
官方推荐在全局安装CLI（grunt的命令行接口）

  1. npm install -g grunt-cli

这条命令将会把grunt命令植入系统路径，这样就能在任意目录运行他，原因是

每次运行grunt时，它都会使用node的require查找本地是否安装grunt，如果找到CLI便加载这个本地grunt库
然后应用我们项目中的GruntFile配置，并执行任务
PS：这段先不要管，安装完了往下看

实例学习：打包zepto

一些东西说多了都是泪，直接先上实例吧，实例结束后再说其它的
首先在D盘新建一个项目（文件夹就好）
在里面新增两个文件（不要问为什么，搞进去先）

① package.json

  1. {
  2.   "name": "demo",
  3.   "file": "zepto",
  4.   "version": "0.1.0",
  5.   "description": "demo",
  6.   "license": "MIT",
  7.   "devDependencies": {
  8.     "grunt": "~0.4.1",
  9.     "grunt-contrib-jshint": "~0.6.3",
  10.     "grunt-contrib-uglify": "~0.2.1",
  11.     "grunt-contrib-requirejs": "~0.4.1",
  12.     "grunt-contrib-copy": "~0.4.1",
  13.     "grunt-contrib-clean": "~0.5.0",
  14.     "grunt-strip": "~0.2.1"
  15.   },
  16.   "dependencies": {
  17.     "express": "3.x"
  18.   }
  19. }
 

② Gruntfile.js

完了我们需要在grunt目录下执行 npm install将相关的文件下载下来：

  1. $ cd d:
  2. $ cd grunt

然后我们的目录就会多一点东西：

多了很多东西，先别管事干什么的，我们后面都会用到，这个时候在目录下新建src文件夹，并且搞一个zepto进去

然后在Gruntfile中新增以下代码（先别管，增加再说）

 
  1. module.exports = function (grunt) {
  2.   // 项目配置
  3.   grunt.initConfig({
  4.     pkg: grunt.file.readJSON('package.json'),
  5.     uglify: {
  6.       options: {
  7.         banner: '/*! <%= pkg.file %> <%= grunt.template.today("yyyy-mm-dd") %> */\n'
  8.       },
  9.       build: {
  10.         src: 'src/<%=pkg.file %>.js',
  11.         dest: 'dest/<%= pkg.file %>.min.js'
  12.       }
  13.     }
  14.   });
  15.   // 加载提供"uglify"任务的插件
  16.   grunt.loadNpmTasks('grunt-contrib-uglify');
  17.   // 默认任务
  18.   grunt.registerTask('default', ['uglify']);
  19. }

然后运行 grunt命令后

  1. grunt

嗯嗯，多了一个文件，并且是压缩的，不差！！！第一步结束

认识Gruntdile与package.json

不出意外，每一个gurnt都会需要这两个文件，并且很可能就只有这两个文件（复杂的情况有所不同）

package.json

这个文件用来存储npm模块的依赖项（比如我们的打包若是依赖requireJS的插件，这里就需要配置）
然后，我们会在里面配置一些不一样的信息，比如我们上面的file，这些数据都会放到package中
对于package的灵活配置，我们会在后面提到

Gruntfile

这个文件尤其关键，他一般干两件事情：
① 读取package信息
② 插件加载、注册任务，运行任务（grunt对外的接口全部写在这里面）

Gruntfile一般由四个部分组成
① 包装函数
这个包装函数没什么东西，意思就是我们所有的代码必须放到这个函数里面

  1. module.exports = function (grunt) {
  2. //你的代码
  3. }

这个不用知道为什么，直接将代码放入即可

② 项目/任务配置
我们在Gruntfile一般第一个用到的就是initConfig方法配置依赖信息

  1. pkg: grunt.file.readJSON('package.json')

这里的 grunt.file.readJSON就会将我们的配置文件读出，并且转换为json对象

然后我们在后面的地方就可以采用pkg.XXX的方式访问其中的数据了
值得注意的是这里使用的是underscore模板引擎，所以你在这里可以写很多东西

uglify是一个插件的，我们在package依赖项进行了配置，这个时候我们为系统配置了一个任务
uglify（压缩），他会干这几个事情：

① 在src中找到zepto进行压缩（具体名字在package中找到）
② 找到dest目录，没有就新建，然后将压缩文件搞进去
③ 在上面加几个描述语言

这个任务配置其实就是一个方法接口调用，按照规范来就好，暂时不予关注，内幕后期来
这里只是定义了相关参数，但是并未加载实际函数，所以后面马上就有一句：

  1. grunt.loadNpmTasks('grunt-contrib-uglify');

用于加载相关插件

最后注册一个自定义任务（其实也是默认任务），所以我们下面的命令行是等效的：

  1. grunt == grunt uglify

至此，我们就简单解析了一番grunt的整个操作，下面来合并文件的例子

合并文件

合并文件依赖于grunt-contrib-concat插件，所以我们的package依赖项要新增一项

 
  1. "devDependencies": {
  2.   "grunt": "~0.4.1",
  3.   "grunt-contrib-jshint": "~0.6.3",
  4.   "grunt-contrib-concat": "~0.3.0",
  5.   "grunt-contrib-uglify": "~0.2.1",
  6.   "grunt-contrib-requirejs": "~0.4.1",
  7.   "grunt-contrib-copy": "~0.4.1",
  8.   "grunt-contrib-clean": "~0.5.0",
  9.   "grunt-strip": "~0.2.1"
  10. },

然后再将代码写成这个样子

 
  1. module.exports = function (grunt) {
  2.   // 项目配置
  3.   grunt.initConfig({
  4.     pkg: grunt.file.readJSON('package.json'),
  5.     concat: {
  6.       options: {
  7.         separator: ';'
  8.       },
  9.       dist: {
  10.         src: ['src/zepto.js', 'src/underscore.js', 'src/backbone.js'],
  11.         dest: 'dest/libs.js'
  12.       }
  13.     }
  14.   });
  15.   grunt.loadNpmTasks('grunt-contrib-concat');
  16.   // 默认任务
  17.   grunt.registerTask('default', ['concat']);
  18. }

运行后，神奇的一幕发生了：

三个文件被压缩成了一个，但是没有压缩，所以，我们这里再加一步操作，将之压缩后再合并

  1. module.exports = function (grunt) {
  2.   // 项目配置
  3.   grunt.initConfig({
  4.     pkg: grunt.file.readJSON('package.json'),
  5.     concat: {
  6.       options: {
  7.         separator: ';'
  8.       },
  9.       dist: {
  10.         src: ['src/zepto.js', 'src/underscore.js', 'src/backbone.js'],
  11.         dest: 'dest/libs.js'
  12.       }
  13.     },
  14.     uglify: {
  15.       build: {
  16.         src: 'dest/libs.js',
  17.         dest: 'dest/libs.min.js'
  18.       }
  19.     }
  20.   });
  21.   grunt.loadNpmTasks('grunt-contrib-uglify');
  22.   grunt.loadNpmTasks('grunt-contrib-concat');
  23.   // 默认任务
  24.   grunt.registerTask('default', ['concat', 'uglify']);
  25. }

我这里的做法是先合并形成一个libs，然后再将libs压缩成libs.min.js

所以我们这里换个做法，先压缩再合并，其实unglify已经干了这些事情了

 
  1. module.exports = function (grunt) {
  2.   // 项目配置
  3.   grunt.initConfig({
  4.     pkg: grunt.file.readJSON('package.json'),
  5.     uglify: {
  6.       "my_target": {
  7.         "files": {
  8.           'dest/libs.min.js': ['src/zepto.js', 'src/underscore.js', 'src/backbone.js']
  9.         }
  10.       }
  11.     }
  12.   });
  13.   grunt.loadNpmTasks('grunt-contrib-uglify');
  14.   // 默认任务
  15.   grunt.registerTask('default', ['uglify']);
  16. }

所以，我们就暂时不去关注concat了

最后，今天时间不早了，我们最后研究下grunt配合require于是便结束今天的学习吧

合并requireJS管理的文件

有了前面基础后，我们来干一件平时很头疼的事情，便是将require管理的所有js文件给压缩了合并为一个文件
首先我们建立一个简单的程序，里面使用了zepto、backbone、underscore（事实上我并未使用什么）

在main.js中新增代码：

 
  1. require.config({
  2.  baseUrl: '',
  3.  shim: {
  4.   $: {
  5.       exports: 'zepto'
  6.   },
  7.   _: {
  8.    exports: '_'
  9.   },
  10.   B: {
  11.    deps: [
  12.     '_',
  13.     '$'
  14.      ],
  15.    exports: 'Backbone'
  16.   }
  17.  },
  18.  paths: {
  19.   '$': 'src/zepto',
  20.   '_': 'src/underscore',
  21.   'B': 'src/backbone'
  22.  }
  23. });
  24. requirejs(['B'], function (b) {
  25. });
 

这样的话运行会自动加载几个文件，我们现在希望将之合并为一个libs.js该怎么干呢？？？

我们这里使用自定义任务方法来做，因为我们好像没有介绍他

要使用requireJS相关需要插件

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

因为我们以后可能存在配置文件存在各个项目文件的情况，所以我们这里将requireJs相关的配置放入gruntCfg.json中

这样我们的package.json就没有什么实际意义了：

 
  1. {
  2.   "name": "demo",
  3.   "version": "0.1.0",
  4.   "description": "demo",
  5.   "license": "MIT",
  6.   "devDependencies": {
  7.  "grunt": "~0.4.1",
  8.  "grunt-contrib-jshint": "~0.6.3",
  9.  "grunt-contrib-concat": "~0.3.0",
  10.  "grunt-contrib-uglify": "~0.2.1",
  11.  "grunt-contrib-requirejs": "~0.4.1",
  12.  "grunt-contrib-copy": "~0.4.1",
  13.  "grunt-contrib-clean": "~0.5.0",
  14.  "grunt-strip": "~0.2.1"
  15.  
  16.   },
  17.   "dependencies": {
  18.     "express": "3.x"
  19.   }
  20. }

我们这里设置的require相关的grunt配置文件如下（gruntCfg.json）：

 
  1. {
  2.   "requirejs": {
  3.     "main": {
  4.       "options": {
  5.         "baseUrl": "",
  6.         "paths": {
  7.           "$": "src/zepto",
  8.           "_": "src/underscore",
  9.           "B": "src/backbone",
  10.           "Test": "src/Test"
  11.         },
  12.         "web": {
  13.           "include": [
  14.             "$",
  15.             "_",
  16.             "B",
  17.             "Test"
  18.           ],
  19.           "out": "dest/libs.js"
  20.         }
  21.       }
  22.     }
  23.   }
  24. }
 

这里我们要打包这些文件搞到dest的libs.js文件中，这个文件照做就行，最后核心代码如下：

 
  1. module.exports = function (grunt) {
  2.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  3.   //为了介绍自定义任务搞了一个这个
  4.   grunt.registerTask('build', 'require demo', function () {
  5.     //任务列表
  6.     var tasks = ['requirejs'];
  7.     //源码文件
  8.     var srcDir = 'src';
  9.     //目标文件
  10.     var destDir = 'dest';
  11.     //设置参数
  12.     grunt.config.set('config', {
  13.       srcDir: srcDir,
  14.       destDir: destDir
  15.     });
  16.     //设置requireJs的信息
  17.     var taskCfg = grunt.file.readJSON('gruntCfg.json');
  18.     var options = taskCfg.requirejs.main.options,
  19.         platformCfg = options.web,
  20.         includes = platformCfg.include,
  21.         paths = options.paths;
  22.     var pos = -1;
  23.     var requireTask = taskCfg.requirejs;
  24.     options.path = paths;
  25.     options.out = platformCfg.out;
  26.     options.include = includes;
  27.     //运行任务
  28.     grunt.task.run(tasks);
  29.     grunt.config.set("requirejs", requireTask);
  30.   });
  31. }

搞完了运行就好：grunt build

  1. grunt build

最后发现叶小钗三字，我就放心了，安全！！！！！！

配置任务/grunt.initConfig

前面我们简单的介绍了grunt相关的知识，这里我们这里还需要再熟悉下Gruntfile相关的知识点，比如说配置任务

grunt的任务配置都是在Gruntfile中的grunt.initConfig方法中指定的，这个配置主要都是一些命名性属性
比如我们上次用到的合并以及压缩的任务配置：

 
  1. grunt.initConfig({
  2.     concat: {
  3.         //这里是concat任务的配置信息
  4.     },
  5.     uglify: {
  6.         //这里是uglify任务的配置信息
  7.     },
  8.     //任意非任务特定属性
  9.     my_property: 'whatever',
  10.     my_src_file: ['foo/*.js', 'bar/*.js']
  11. });
 

其中的my_property完全可能读取外部json配置文件，然后在上面任务配置中便可以，比如我们要压缩的文件为准或者最后要放到哪里，便可以在此配置

我们使用grunt的时候，主要工作就是配置任务或者创建任务，实际上就是做一个事件注册，然后由我们触发之，所以grunt的核心还是事件注册
每次运行grunt时，我们可以指定运行一个或者多个任务，通过任务决定要做什么，比如我们同时要压缩和合并还要做代码检查

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

当运行一个基本任务时，grunt并不会查找配置和检查运行环境，他仅仅运行指定的任务函数，可以传递冒号分割参数，比如：

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

运行结果如下：

 
  1. $ grunt foo:testing:123
  2. Running "foo:testing:123" (foo) task
  3. foo, testing 123
  4.  
  5. $ grunt foo:testing
  6. Running "foo:testing" (foo) task
  7. foo, testing undefined
  8.  
  9. $ grunt foo
  10. Running "foo" task
  11. foo, no args
 

这里有个多任务的情况，就是一个任务里面实际上第一了多个东东，这个时候就有所不同

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

如果我们运行，运行情况如下：

???????

更多时候，我们实际场景中都会需要自定义任务，而在我们任务内部使用 grunt.task.run({}) 运行任务
这块的知识点，我们后面以实际例子说明

grunt插件

学习grunt主要就是学习grunt的插件使用，所以我们今天先来学习常用的几个插件

grunt-contrib-unglify

我们仍然以简单例子学习

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     uglify: {
  4.       my_target: {
  5.         files: {
  6.           'dest/libs.min.js': ['src/zepto.js', 'src/underscoce.js']
  7.         }
  8.       }
  9.     }
  10.   });
  11.   grunt.loadNpmTasks('grunt-contrib-uglify');
  12. }
 

这样会将src里面的zepto等文件打包值dest的lib.min.js中

压缩一个文件夹的所有文件

然后这段代码非常有意思，他会将一个文件目录里面的所有js文件打包到另一个文件夹

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     uglify: {
  4.       my_target: {
  5.         files: [{
  6.           expand: true,
  7.           cwd: 'src',
  8.           src: '**/*.js',
  9.           dest: 'dest'
  10.         }]
  11.       }
  12.     }
  13.   });
  14.   grunt.loadNpmTasks('grunt-contrib-uglify');
  15. }

若是你希望给你文件的头部加一段注释性语言配置banner信息即可

  1. grunt.initConfig({
  2.   pkg: grunt.file.readJSON('package.json'),
  3.   uglify: {
  4.     options: {
  5.       banner: '/*! 注释信息 */'
  6.     },
  7.     my_target: {
  8.       files: {
  9.         'dest/output.min.js': ['src/input.js']
  10.       }
  11.     }
  12.   }
  13. });
 

grunt-contrib-concat

该插件主要用于代码合并，将多个文件合并为一个，我们前面的uglify也提供了一定合并的功能
在可选属性中我们可以设置以下属性：
① separator 用于分割各个文件的文字，
② banner 前面说到的文件头注释信息，只会出现一次
③ footer 文件尾信息，只会出现一次
④ stripBanners去掉源代码注释信息（只会清楚/**/这种注释）

一个简单的例子：

  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.   concat: {
  4.     options: {
  5.       separator: '/*分割*/',
  6.       banner: '/*测试*/',
  7.       footer: '/*footer*/'
  8.  
  9.     },
  10.     dist: {
  11.       src: ['src/zepto.js', 'src/underscore.js', 'src/backbone.js'],
  12.       dest: 'dist/built.js',
  13.     }
  14.   }
  15. });
  16.   grunt.loadNpmTasks('grunt-contrib-concat');
  17. }
 

合并三个文件为一个，这种在我们源码调试时候很有意义

构建两个文件夹

有时候我们可能需要将合并的代码放到不同的文件，这个时候可以这样干

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     concat: {
  4.       basic: {
  5.         src: ['src/zepto.js'],
  6.         dest: 'dest/basic.js'
  7.       },
  8.       extras: {
  9.         src: ['src/underscore.js', 'src/backbone.js'],
  10.         dest: 'dest/with_extras.js'
  11.       }
  12.     }
  13.   });
  14.   grunt.loadNpmTasks('grunt-contrib-concat');
  15. }
 

这种功能还有这样的写法：

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     concat: {
  4.       basic_and_extras: {
  5.         files: {
  6.           'dist/basic.js': ['src/test.js', 'src/zepto.js'],
  7.           'dist/with_extras.js': ['src/underscore.js', 'src/backbone.js']
  8.         }
  9.       }
  10.     }
  11.   });
  12.   grunt.loadNpmTasks('grunt-contrib-concat');
  13. }
 

第二种写法便于使用配置文件，具体各位选取吧，至于读取配置文件的东西我们这里就先不关注了

grunt-contrib-jshint

该插件用于检测文件中的js语法问题，比如我test.js是这样写的：

  1. alert('我是叶小钗')
 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     jshint: {
  4.       all: ['src/test.js']
  5.     }
  6.   });
  7.   grunt.loadNpmTasks('grunt-contrib-jshint');
  8. }
 

运行结果是：

  1. $ grunt jshint
  2. Running "jshint:all" (jshint) task
  3. Linting src/test.js ...ERROR
  4. [L1:C15] W033: Missing semicolon.
  5. alert('我是叶小钗')

说我缺少一个分号，好像确实缺少.....如果在里面写明显的BUG的话会报错
多数时候，我们认为没有分号无伤大雅，所以，我们文件会忽略这个错误：

  1. jshint: {
  2.   options: {
  3.     '-W033': true
  4.   },
  5.   all: ['src/test.js']
  6. }

这里有一个稍微复杂的应用，就是我们合并之前做一次检查，合并之后再做一次检查，我们可以这样写

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     concat: {
  4.       dist: {
  5.         src: ['src/test01.js', 'src/test02.js'],
  6.         dest: 'dist/output.js'
  7.       }
  8.     },
  9.     jshint: {
  10.       options: {
  11.         '-W033': true
  12.       },
  13.       pre: ['src/test01.js', 'src/test02.js'],
  14.       after: ['dist/output.js']
  15.     }
  16.   });
  17.   grunt.loadNpmTasks('grunt-contrib-concat');
  18.   grunt.loadNpmTasks('grunt-contrib-jshint');
  19. }
 
 
  1. $ grunt jshint:pre concat jshint:after
  2. Running "jshint:pre" (jshint) task
  3. >> 2 files lint free.
  4. Running "concat:dist" (concat) task
  5. File "dist/output.js" created.
  6. Running "jshint:after" (jshint) task
  7. >> 1 file lint free.
 

这里连续运行了三个任务，先做检查再合并，然后做检测，我这里写了两个简单的文件，如果将jquery搞进去的话，好像还出了不少BUG......
所以真的要用它还要自定一些规范，我们这里暂时到这里，先进入下一个插件学习

grunt-contrib-requirejs

我们的grunt打包程序极有可能与requirejs一起使用，但是几个插件学习下来又属requireJs的使用最为麻烦，因为网上资源很少，搞到这一段耗掉了我很多精力

这个时候你就会感叹，英语好不一定编程好，英语差想成为高手还是不简单啊！！！

 
  1. requirejs: {
  2.   compile: {
  3.     options: {
  4.       baseUrl: "path/to/base",
  5.       mainConfigFile: "path/to/config.js",
  6.       name: "path/to/almond", // assumes a production build using almond
  7.       out: "path/to/optimized.js"
  8.     }
  9.   }
  10. }
 

官方的例子首先就是这几个属性：

baseUrl 代表所有的js文件都会相对于这个目录

mainConfigFile 配置文件目录

name ？？？

out 输出文件

一些参数我们不太了解，这个时候就只能以例子破之了

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     requirejs: {
  4.       compile: {
  5.         "options": {
  6.           "baseUrl": "./",
  7.           "paths": {
  8.             "$": "src/zepto",
  9.             "_": "src/underscore",
  10.             "B": "src/backbone",
  11.             "Test": "src/Test01"
  12.           },
  13.           "include": [
  14.             "$",
  15.             "_",
  16.             "B",
  17.             "Test"
  18.           ],
  19.           "out": "dest/libs.js"
  20.         }
  21.       }
  22.     }
  23.   });
  24.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  25. }
 

这样配置后，会将include里面的文件打包为out对应的文件，paths的本身意义不大，就是用于配置include里面的指向

这个时候我们来加个name看看有神马作用：

 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     requirejs: {
  4.       compile: {
  5.         "options": {
  6.           "baseUrl": "./",
  7.           "name": 'src/test02.js',
  8.           "paths": {
  9.             "$": "src/zepto",
  10.             "_": "src/underscore",
  11.             "B": "src/backbone",
  12.             "Test": "src/Test01"
  13.           },
  14.           "include": [
  15.             "$",
  16.             "_",
  17.             "B",
  18.             "Test"
  19.           ],
  20.           "out": "dest/libs.js"
  21.         }
  22.       }
  23.     }
  24.   });
  25.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  26. }
 

这样的话，会将name对应文件压缩到压缩文件的最前面，但是具体是干什么的，还是不太清楚，其英文注释说是单个文件或者其依赖项优化，不知道优化什么啊。。。囧！！！

requireJS基本的用法就是这样了，其详细信息，我们过段时间再来看看，下面说一下requireJS的其它用法

我们这里将requireJS的配置信息放在外面，而Gruntfile采用自定义任务的方式完成上面的功能

配置文件/cfg.json

 
  1. {requirejs: {
  2.   "options": {
  3.     "baseUrl": "./",
  4.     "paths": {
  5.       "$": "src/zepto",
  6.       "_": "src/underscore",
  7.       "B": "src/backbone",
  8.       "Test": "src/Test01"
  9.     },
  10.     "include": [
  11.       "$",
  12.       "_",
  13.       "B",
  14.       "Test"
  15.     ],
  16.     "out": "dest/libs.js"
  17.   }
  18. }}
 

然后，这里我们便不是有initConfig的做法了，直接使用自定义任务

 
  1. module.exports = function (grunt) {
  2.  
  3.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  4.  
  5.   grunt.registerTask('build', 'require demo', function () {
  6.  
  7.     //第一步，读取配置信息
  8.     var cfg = grunt.file.readJSON('cfg.json');
  9.     cfg = cfg.requirejs;
  10.     grunt.config.set('requirejs', { test: cfg });
  11.  
  12.     //第二步，设置参数
  13.     grunt.log.debug('参数：' + JSON.stringify(grunt.config()));
  14.  
  15.     //第三步跑任务
  16.     grunt.task.run(['requirejs']);
  17.  
  18.   });
  19.  
  20. }
 
 
  1. $ grunt build --debug
  2. Running "build" task
  3. [D] Task source: d:\grunt\Gruntfile.js
  4. [D] 参数：{"requirejs":{"test":{"options":{"baseUrl":"./","paths":{"$":"src/zept
  5. o","_":"src/underscore","B":"src/backbone","Test":"src/Test01"},"include":["$","
  6. _","B","Test"],"out":"dest/libs.js"}}}}
  7.  
  8. Running "requirejs:test" (requirejs) task
  9. [D] Task source: d:\grunt\node_modules\grunt-contrib-requirejs\tasks\requirejs.j
  10. s
  11. >> Tracing dependencies for: d:/grunt/dest/libs.js
  12. >> Uglifying file: d:/grunt/dest/libs.js
  13. >> d:/grunt/dest/libs.js
  14. >> ----------------
  15. >> d:/grunt/src/zepto.js
  16. >> d:/grunt/src/underscore.js
  17. >> d:/grunt/src/backbone.js
  18. >> d:/grunt/src/Test01.js
 

效果还是有的，最后我们介绍下requireJS打包模板文件

require与模板文件

我们知道，模板文件一般都是html，比如我们这里的demo01.html，对于这个文件我们应该怎么打包呢？其实很简单......

需要干两件事情：

① 引入require.text

② 加入模板文件

 
  1. {
  2.   "requirejs": {
  3.     "options": {
  4.       "baseUrl": "./",
  5.       "paths": {
  6.         "$": "src/zepto",
  7.         "_": "src/underscore",
  8.         "B": "src/backbone",
  9.         "test": "src/test01",
  10.         "text": "src/require.text"
  11.  
  12.       },
  13.       "include": [
  14.         "$",
  15.         "_",
  16.         "B",
  17.         "test",
  18.         "text!src/demo01.html"
  19.       ],
  20.       "out": "dest/libs.js"
  21.     }
  22.   }
  23. }
 

于是，我们便成功将模板打入了

 
  1. $ grunt build --debug
  2. Running "build" task
  3. [D] Task source: d:\grunt\Gruntfile.js
  4. [D] 参数：{"requirejs":{"test":{"options":{"baseUrl":"./","paths":{"$":"src/zept
  5. o","_":"src/underscore","B":"src/backbone","test":"src/test01","text":"src/requi
  6. re.text"},"include":["$","_","B","test","text!src/demo01.html"],"out":"dest/libs
  7. .js"}}}}
  8.  
  9. Running "requirejs:test" (requirejs) task
  10. [D] Task source: d:\grunt\node_modules\grunt-contrib-requirejs\tasks\requirejs.j
  11. s
  12. >> Tracing dependencies for: d:/grunt/dest/libs.js
  13. >> Uglifying file: d:/grunt/dest/libs.js
  14. >> d:/grunt/dest/libs.js
  15. >> ----------------
  16. >> d:/grunt/src/zepto.js
  17. >> d:/grunt/src/underscore.js
  18. >> d:/grunt/src/backbone.js
  19. >> d:/grunt/src/test01.js
  20. >> d:/grunt/src/require.text.js
  21. >> text!src/demo01.html
 

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

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

过滤关键字

 
  1.  1 module.exports = function (grunt) {
  2.  2   grunt.initConfig({
  3.  3     requirejs: {
  4.  4       compile: {
  5.  5         "options": {
  6.  6           optimize: 'uglify2',
  7.  7           uglify2: {
  8.  8             mangle: {
  9.  9               except: ["$super"]
  10. 10             }
  11. 11           },
  12. 12           "baseUrl": "./",
  13. 13           "paths": {
  14. 14             "UIAbstractView": "ui_beta/ui.abstract.view",
  15. 15             "UILayer": "ui_beta/ui.layer"
  16. 16           },
  17. 17           "include": [
  18. 18             "UIAbstractView"
  19. 19           ],
  20. 20           "out": "dest/libs.js"
  21. 21         }
  22. 22       }
  23. 23     }
  24. 24   });
  25. 25   grunt.loadNpmTasks('grunt-contrib-requirejs');
  26. 26   grunt.registerTask('default', ['requirejs']);
 

打包样式文件

样式文件的打包方式与js不太一样，这里我们下载css-min插件，并且在package.json中新增依赖项

 
  1. {
  2.   "name": "demo",
  3.   "version":         "0.1.0",
  4.   "description":     "demo",
  5.   "license":         "MIT",
  6.   "devDependencies": {
  7.     "grunt":                   "~0.4.1",
  8.     "grunt-contrib-jshint":    "~0.6.3",
  9.     "grunt-contrib-concat":    "~0.3.0",
  10.     "grunt-contrib-uglify":    "~0.2.1",
  11.     "grunt-contrib-requirejs": "~0.4.1",
  12.     "grunt-contrib-copy":      "~0.4.1",
  13.     "grunt-contrib-clean":     "~0.5.0",
  14.     "grunt-strip":             "~0.2.1",
  15.     "grunt-contrib-watch": "~0.6.0",
  16.     "grunt-contrib-cssmin": "~0.5.0"
  17.   },
  18.   "dependencies":    {
  19.     "express": "3.x"
  20.   }
  21. }
 
 
  1. module.exports = function (grunt) {
  2.   grunt.initConfig({
  3.     cssmin: {
  4.       compress: {
  5.         files: {
  6.           'dest/car.min.css': [
  7.           "src/car.css",
  8.           "src/car01.css"
  9.         ]
  10.         }
  11.       }
  12.     }
  13.   });
  14.  
  15.   grunt.loadNpmTasks('grunt-contrib-cssmin');
  16.  
  17. }
 

如此一来我们便可以压缩合并CSS文件了：

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

移动打包文件

其实，grunt本身具有这样的功能，但是我们实际项目重会出现这种可能：

我们核心框架会有一套压缩代码，并且会在对应目录生成文件用于发布，但是这个地方的权限对各个频道团队是不可见的

所以，我们在各个频道的公共文件夹内应该将刚刚的文件给复制过去，这块代码其实很简单，不需要任何新知识都能实现：

我们这里依旧采用昨天的require相关的代码，但是一有个不同的地方就是，我们要同时在D盘的common文件夹中生成该文件

这个代码其实比较简单，这里我们先介绍一个新的插件copy

grunt-contrib-copy

该插件用于复制文件到你想要的文件夹处

 
  1. grunt.initConfig({ copy: {
  2.   main: {
  3.     flatten: true,
  4.     src: 'src/*.js',
  5.     dest: 'dest/'
  6.   }
  7. }
  8. });
 

这段代码就会将src中的js文件搞到dest里面，并且新建src文件夹：

  1. $ grunt copy
  2. Running "copy:main" (copy) task
  3. Copied 7 files

若是不想复制文件夹只要文件应该这样干：

 
  1. grunt.initConfig({ copy: {
  2.   main: {
  3.     flatten: true,
  4.     //    filter: 'isFile',
  5.     expand: true,
  6.     src: 'src/**.js',
  7.     dest: 'dest/'
  8.   }
  9. }
  10. });
 

这块完了，我们就来移动打包文件至D盘了

移动打包文件

这个时候代码这样写就好（也许移动前我们还想将其文件夹里面的东西销毁，暂时不考虑了）

 
  1. module.exports = function (grunt) {
  2.  
  3.   grunt.initConfig({ copy: {
  4.     main: {
  5.       //      flatten: true,
  6.       //      expand: true,
  7.       src: 'dest/**.js',
  8.       dest: 'd:/common/'
  9.     }
  10.   }
  11.   });
  12.  
  13.   grunt.loadNpmTasks('grunt-contrib-copy');
  14.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  15.  
  16.   grunt.registerTask('build', 'require demo', function () {
  17.  
  18.     //第一步，读取配置信息
  19.     var cfg = grunt.file.readJSON('cfg.json');
  20.     cfg = cfg.requirejs;
  21.     grunt.config.set('requirejs', { test: cfg });
  22.  
  23.     //第二步，设置参数
  24.     grunt.log.debug('参数：' + JSON.stringify(grunt.config()));
  25.  
  26.     //第三步跑任务
  27.     grunt.task.run(['requirejs']);
  28.  
  29.   });
  30.  
  31.   grunt.registerTask('default', 'test demo', ['build', 'copy']);
  32.  
  33. }
 
 
  1. Running "build" task
  2.  
  3. Running "requirejs:test" (requirejs) task
  4. >> Tracing dependencies for: d:/grunt/dest/libs.js
  5. >> Uglifying file: d:/grunt/dest/libs.js
  6. >> d:/grunt/dest/libs.js
  7. >> ----------------
  8. >> d:/grunt/src/zepto.js
  9. >> d:/grunt/src/underscore.js
  10. >> d:/grunt/src/backbone.js
  11. >> d:/grunt/src/test01.js
  12. >> d:/grunt/src/require.text.js
  13. >> text!src/demo01.html
  14.  
  15. Running "copy:main" (copy) task
  16. Copied 8 files
 

关于移动相关的知识点暂时介绍到这里，我们进入下一话题

分支/频道处理

我们在实际项目重会遇到这种情况，我们一个主干分支上可能拉出很多分支完成不同的功能，而各个分支就有那么一点点不同，那么这个时候打包工具该怎么办呢？

我们一般是这样处理的：

① 首先全局只会有一个打包工具

② 其次每一个分支都会有一个gruntCfg.json的配置文件，存储相关的打包信息

③ 每次打包时候便把响应的分支打印到各自的dest目录里面

为了模拟这一情况我们将grunt打包相关的文件放到D盘的grunt目录里面，并在D盘新建gruntDemo目录

然后我们在gruntDemo中建立一个项目，并且为这个项目拉一个分支，比如现在项目是地demo01与demo02

现在文件结构如下：

 
  1. D:\GRUNTDEMO
  2. ├─demo01
  3. │  │  gruntCfg.json
  4. │  │
  5. │  └─src
  6. │          backbone.js
  7. │          require.js
  8. │          require.text.js
  9. │          test01.js
  10. │          test02.js
  11. │          underscore.js
  12. │          zepto.js
  13. │
  14. └─demo02
  15.     │  gruntCfg.json
  16.     │
  17.     └─src
  18.             backbone.js
  19.             require.js
  20.             require.text.js
  21.             test01.js
  22.             test02.js
  23.             underscore.js
  24.             zepto.js
 

这个时候，要实现功能最好的方法就是写自定义任务了，其它方案不好使，这个时候起配置文件也需要有一定修改，比如其中的路径需要加入参数信息

 
  1. {
  2.   "requirejs": {
  3.     "options": {
  4.       "baseUrl": "<%= config.srcDir %>",
  5.       "paths": {
  6.         "$": "src/zepto",
  7.         "_": "src/underscore",
  8.         "B": "src/backbone",
  9.         "test": "src/test01",
  10.         "text": "src/require.text"
  11.  
  12.       },
  13.       "include": [
  14.         "$",
  15.         "_",
  16.         "B",
  17.         "test",
  18.         "text!src/demo01.html"
  19.         ],
  20.         "out": "<%= config.destDir %>/libs.js"
  21.       }
  22.   }
  23. }
 

这个时候initConfig相关信息时候，首先得传入path依赖的文件目录，以及输出的文件目录

 
  1. module.exports = function (grunt) {
  2.  
  3.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  4.  
  5.   //channel为频道名称，project为项目名称，这里对应gruntDemo，branch为其分支，默认与grunt目录为平行关系，佛则package.json里面应该有配置信息
  6.   grunt.registerTask('build', 'require demo', function (channel, project, branch) {
  7.  
  8.     var path = '../' + channel + '/' + project + branch;
  9.     grunt.log.debug('path: ' + path);
  10.  
  11.     //第一步，读取配置信息
  12.     var cfg = grunt.file.readJSON(path + '/gruntCfg.json');
  13.     cfg = cfg.requirejs;
  14.  
  15.     grunt.config.set('config', {
  16.       srcDir: path,
  17.       destDir: path + '/dest'
  18.     });
  19.  
  20.     grunt.config.set('requirejs', { main: cfg });
  21.  
  22.     //第二步，设置参数
  23.     grunt.log.debug('param: ' + JSON.stringify(grunt.config()));
  24.  
  25.     //第三步跑任务
  26.     grunt.task.run(['requirejs']);
  27.  
  28.   });
  29.  
  30.   grunt.registerTask('default', 'test demo', ['build', 'copy']);
  31.  
  32. }

于是我们第一步工作成功了：

  1. $ grunt build:gruntDemo:demo:02 --debug
  2. Running "build:gruntDemo:demo:02" (build) task
  3. [D] Task source: d:\grunt\Gruntfile.js
  4. [D] path: ../gruntDemo/demo02
  5. [D] param: {"config":{"srcDir":"../gruntDemo/demo02","destDir":"../gruntDemo/dem
  6. o02/dest"},"requirejs":{"main":{"options":{"baseUrl":"../gruntDemo/demo02","path
  7. s":{"$":"src/zepto","_":"src/underscore","B":"src/backbone","test":"src/test01",
  8. "text":"src/require.text"},"include":["$","_","B","test","text!src/demo01.html"]
  9. ,"out":"../gruntDemo/demo02/dest/libs.js"}}}}
  10.  
  11. Running "requirejs:main" (requirejs) task
  12. [D] Task source: d:\grunt\node_modules\grunt-contrib-requirejs\tasks\requirejs.j
  13. s
  14. >> Tracing dependencies for: d:/gruntDemo/demo02/dest/libs.js
  15. >> Uglifying file: d:/gruntDemo/demo02/dest/libs.js
  16. >> d:/gruntDemo/demo02/dest/libs.js
  17. >> ----------------
  18. >> d:/gruntDemo/demo02/src/zepto.js
  19. >> d:/gruntDemo/demo02/src/underscore.js
  20. >> d:/gruntDemo/demo02/src/backbone.js
  21. >> d:/gruntDemo/demo02/src/test01.js
  22. >> d:/gruntDemo/demo02/src/require.text.js
  23. >> text!src/demo01.html
 

如果改变一下任务命令呢：

  1. grunt build:gruntDemo:demo:01 --debug

结果证明也是没有问题的，这个地方我就不贴出来了，各位自己去试试，我们分支处理一块暂时到这里

频道处理其实我们这里已经做了，第一个参数是频道，第二个参数是项目，第三个参数为分支，所以频道相关我们暂时就不说了

native与HTML5打包

最后让我们来看看如何打包native文件，native文件的打包其实与打包HTML5的方式类似，只不过我们这里需要一点点配置，让一个项目可以打包成不同的效果

仍然以上面demo01为例，他的配置文件可能就需要做一定调整：

 
  1. {
  2.     "requirejs": {
  3.         "options": {
  4.             "baseUrl": "<%= config.srcDir %>",
  5.             "paths": {
  6.                 "$": "src/zepto",
  7.                 "_": "src/underscore",
  8.                 "B": "src/backbone",
  9.                 "test": "src/test01",
  10.                 "text": "src/require.text"
  11.             },
  12.             "web": {
  13.                 "include": [
  14.                     "$",
  15.                     "_",
  16.                     "B",
  17.                     "test"
  18.                 ],
  19.                 "out": "<%= config.destDir %>/libs.js"
  20.             },
  21.             "app": {
  22.                 "include": [
  23.                     "$",
  24.                     "_",
  25.                     "B",
  26.                     "test",
  27.                     "text!src/demo01.html"
  28.                 ],
  29.                 "out": "<%= config.destDir %>/libs_app.js"
  30.             }
  31.         }
  32.     }
  33. }
 

这里为了表现一点web与native的不同，我特意将web中少包含一个text文件，具体还得各位项目中去实践

如此一来，我们的代码需要做些许调整：

 
  1. module.exports = function (grunt) {
  2.  
  3.   grunt.loadNpmTasks('grunt-contrib-requirejs');
  4.  
  5.   //type 打包app包还是web包，channel为频道名称，project为项目名称，这里对应gruntDemo，branch为其分支，默认与grunt目录为平行关系，佛则package.json里面应该有配置信息
  6.   grunt.registerTask('build', 'require demo', function (type, channel, project, branch) {
  7.  
  8.     var path = '../' + channel + '/' + project + branch;
  9.     grunt.log.debug('path: ' + path);
  10.  
  11.     //第一步，读取配置信息
  12.     var cfg = grunt.file.readJSON(path + '/gruntCfg.json');
  13.     cfg = cfg.requirejs.options;
  14.  
  15.     grunt.config.set('config', {
  16.       srcDir: path,
  17.       destDir: path + '/dest'
  18.     });
  19.  
  20.     grunt.log.debug('param: ' + JSON.stringify(cfg));
  21.     grunt.log.debug('param: ' + cfg[type]['include']);
  22.  
  23.     var taskCfg = {};
  24.     taskCfg.options = {};
  25.     taskCfg.options.baseUrl = cfg.baseUrl;
  26.     taskCfg.options.paths = cfg.paths;
  27.     taskCfg.options['include'] = cfg[type]['include'];
  28.     taskCfg.options.out = cfg[type].out;
  29.  
  30.     grunt.config.set('requirejs', { main: taskCfg });
  31.  
  32.     //第二步，设置参数
  33.     grunt.log.debug('param: ' + JSON.stringify(grunt.config()));
  34.  
  35.     //第三步跑任务
  36.     grunt.task.run(['requirejs']);
  37.  
  38.   });
  39.  
  40.   grunt.registerTask('default', 'test demo', ['build', 'copy']);
  41.  
  42. }
 

于是便可以运行了！！！

 
  1. $ grunt build:app:gruntDemo:demo:01 --debug
  2. Running "build:app:gruntDemo:demo:01" (build) task
  3. [D] Task source: d:\grunt\Gruntfile.js
  4. [D] path: ../gruntDemo/demo01
  5. [D] param: {"baseUrl":"<%= config.srcDir %>","paths":{"$":"src/zepto","_":"src/u
  6. nderscore","B":"src/backbone","test":"src/test01","text":"src/require.text"},"we
  7. b":{"include":["$","_","B","test"],"out":"<%= config.destDir %>/libs.js"},"app":
  8. {"include":["$","_","B","test","text!src/demo01.html"],"out":"<%= config.destDir
  9.  %>/libs_app.js"}}
  10. [D] param: $,_,B,test,text!src/demo01.html
  11. [D] param: {"config":{"srcDir":"../gruntDemo/demo01","destDir":"../gruntDemo/dem
  12. o01/dest"},"requirejs":{"main":{"options":{"baseUrl":"../gruntDemo/demo01","path
  13. s":{"$":"src/zepto","_":"src/underscore","B":"src/backbone","test":"src/test01",
  14. "text":"src/require.text"},"include":["$","_","B","test","text!src/demo01.html"]
  15. ,"out":"../gruntDemo/demo01/dest/libs_app.js"}}}}
  16.  
  17. Running "requirejs:main" (requirejs) task
  18. [D] Task source: d:\grunt\node_modules\grunt-contrib-requirejs\tasks\requirejs.j
  19. s
  20. >> Tracing dependencies for: d:/gruntDemo/demo01/dest/libs_app.js
  21. >> Uglifying file: d:/gruntDemo/demo01/dest/libs_app.js
  22. >> d:/gruntDemo/demo01/dest/libs_app.js
  23. >> ----------------
  24. >> d:/gruntDemo/demo01/src/zepto.js
  25. >> d:/gruntDemo/demo01/src/underscore.js
  26. >> d:/gruntDemo/demo01/src/backbone.js
  27. >> d:/gruntDemo/demo01/src/test01.js
  28. >> d:/gruntDemo/demo01/src/require.text.js
  29. >> text!src/demo01.html
 

结语

若是文中有误请一并提出，后续若是这块有所得我们再一起总结吧

【grunt整合版】学会使用grunt打包前端代码的更多相关文章

  1. 【grunt第二弹】30分钟学会使用grunt打包前端代码（02）

    前言 上一篇博客,我们简单的介绍了grunt的使用,一些基础点没能覆盖,我们今天有必要看看一些基础知识 [grunt第一弹]30分钟学会使用grunt打包前端代码 配置任务/grunt.initCon ...

  2. 【grunt整合版】30分钟学会使用grunt打包前端代码

    grunt 是一套前端自动化工具,一个基于nodeJs的命令行工具,一般用于:① 压缩文件② 合并文件③ 简单语法检查 对于其他用法,我还不太清楚,我们这里简单介绍下grunt的压缩.合并文件,初学, ...

  3. 【grunt整合版】 30分钟学会使用grunt打包前端代码

    grunt 是一套前端自动化工具,一个基于nodeJs的命令行工具,一般用于:① 压缩文件② 合并文件③ 简单语法检查 对于其他用法,我还不太清楚,我们这里简单介绍下grunt的压缩.合并文件,初学, ...

  4. 【grunt第一弹】30分钟学会使用grunt打包前端代码

    前言 以现在前端js激增的态势,一个项目下来几十个js文件轻轻松松对于复杂一点的单页应用来说,文件上百简直是家常便饭,那么这个时候我们的js文件应该怎么处理呢?另外,对于css文件,又该如何处理呢?? ...

  5. 30分钟学会使用grunt打包前端代码【mark】

    grunt 是一套前端自动化工具,一个基于nodeJs的命令行工具,一般用于:① 压缩文件② 合并文件③ 简单语法检查 对于其他用法,我还不太清楚,我们这里简单介绍下grunt的压缩.合并文件,初学, ...

  6. 使用grunt打包前端代码

    grunt 是一套前端自动化工具,一个基于nodeJs的命令行工具,一般用于:① 压缩文件② 合并文件③ 简单语法检查 对于其他用法,我还不太清楚,我们这里简单介绍下grunt的压缩.合并文件,初学, ...

  7. Grunt 5分钟上手：合并+压缩前端代码

    Grunt 的各种优点这里就不扯了,对于 新手来说 合并(concat) + 压缩(uglify) 前端代码的需求量应该是最大的,这里以这俩种功能为主做一个5分钟的入门吧! 工作环境 $ node - ...

  8. Linux安装npm并打包前端代码

    查看node版本$ node -v查看npm版本$ npm -v如果没有安装node及npm,需要先安装node及npm#yum install node# yum install npm安装cnpm ...

  9. 30分钟学会使用grunt打包前端代码

    http://www.cnblogs.com/yexiaochai/p/3603389.html

随机推荐

  1. Emmet 插件使用教程

    1)使用 Emmet 生成 HTML 的语法详解生成 HTML 文档初始结构 HTML 文档的初始结构,就是包括 doctype.html.head.body 以及 meta 等内容.你只需要输入一个 ...

  2. csss3 2D转换

    CSS3 转换 通过 CSS3 转换,我们能够对元素进行移动.缩放.转动.拉长或拉伸. 它如何工作? 转换是使元素改变形状.尺寸和位置的一种效果. 您可以使用 2D 或 3D 转换来转换您的元素. 浏 ...

  3. 总结PHP中几种常用的网页跳转代码

    网页跳转的意思就是指当你在浏览器中访问A页面时,会自动跳转到B页面,往往网页跳转用在404页面中会比较多点.至于怎么实现网页跳转,网上已经提供了很多的方法,有些方法是不可行的,经过测试,叶德华今天就在 ...

  4. linux 删除和安装java

    一.jdk1.4卸载 由于redhat Enterprise 5 中自带安装了jdk1.4的,所以在安装jdk1.6前我把jdk1.4的卸了,步骤如下:   1.打开终端输入#rpm -qa | gr ...

  5. php中json_encode中文编码问题

    1 <?php 2 class myClass { 3 public$item1=1; 4 public$item2='中文'; 5 6 function to_json() { 7 //url ...

  6. LinuxCmd

    Q1.关掉字符界面下的屏保 A:setterm -blank 0 Q2.top Top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器. ...

  7. List和Tuple类型

    list列表,list是一种有序的集合,可以随时添加和删除其中的元素,L=[]   索引从0开始,第一个元素的索引是0,第二个是1,倒数第一个是-1,倒数第二个是-2,以此类推,使用索引,不要越界   ...

  8. make file 详

    一: linux的touch命令不常用,一般在使用make的时候可能会用到,用来修改文件时间戳,或者新建一个不存在的文件. 1．命令格式: touch [选项]... 文件... 2．命令参数: -a ...

  9. aix运维

    AIX操作系统中有很多程序,为了进行程序版本控制,每一个程序集都有自己的版本号.版本号是由小数点分隔的四位数字,例如5.3.0.9其含义是:操作系统版本号(version).发行版本号(release ...

  10. Linux学习之二十、循环

    原文地址:http://vbird.dic.ksu.edu.tw/linux_basic/0340bashshell-scripts_5.php 回圈 (loop) 除了 if...then...fi ...