debug模块源码

1.debug日志打印模块

主要实现功能：带命名空间（模块名）、时间戳、色彩输出日志；将日志写入文件；浏览器端使用；格式化函数；支持自定义方法。

实现思路：通过环境变量设置配置项如是否启用有彩色输出、设定打印方法、设定命名空间（模块名）；

       也可以通过require("debug").enable(namespace)添加命名空间，require("debug").enabled.useColors是否启用有彩色输出，require("debug").enabled.log自定义打印方法，require("debug").enabled.color社会颜色1|2|3|4|5|6，exports.formatters.a=function(){}添加格式化函数

2.使用：默认使用process.stderr('%s',"error")标准错误输出，替换%s字符

require("debug").enable("app") // 添加待测试模块
var debug=require("debug")("app") // 选择测试模块
debug("%o funciton(){}") // 打印日志

3.源码：服务器端启动文件为node.js，通过node.js加载debug.js

node.js

// package.json约定node.js为入口文件

var tty=require('tty');
var util=require('util');

exports=module.exports=require('./debug');

exports.log=log;

// 带色彩打印消息
exports.formatArgs=formatArgs;

// 更新process.env.DEBUG环境变量
exports.save=save;

// 待测试的模块通过环境变DEBUG量赋值
exports.load=load;

// 是否开启带颜色打印消息
exports.useColors=useColors;

// 颜色码
exports.colors=[6, 2, 3, 4, 5, 1];

/**
 * The file descriptor to write the `debug()` calls to.
 * Set the `DEBUG_FD` env variable to override with another value. i.e.:
 *
 *   $ DEBUG_FD=3 node script.js 3>debug.log
 */
var fd=parseInt(process.env.DEBUG_FD, 10) || 2;
var stream= 1===fd ? process.stdout :// 标准输出
            2===fd ? process.stderr :// 标准错误输出，默认
            createWritableStdioStream(fd);// 流式写入文件

// 是否开启带颜色输出
function useColors(){
    var debugColors=(process.env.DEBUG_COLORS || '').trim().toLowerCase();
    if ( 0===debugColors.length ){
        return tty.isatty(fd);
    }else{
        return '0'!==debugColors
            && 'no'!==debugColors
            && 'false'!==debugColors
            && 'disabled'!==debugColors;
    }
}

// util.inspect(obj,showHidden,depth,color)方法将对象转换为字符串，
// showHidden显示更多数据，depth递归的层数，color设置颜色
var inspect=( 4===util.inspect.length ?
    // node <= 0.8.x
    function (v, colors){
        return util.inspect(v,void 0,void 0,colors);// 
    } :
    // node > 0.8.x
    function (v, colors){
        return util.inspect(v,{colors:colors});
    }
);

// 类型不是字符串时，使用util.inspect方法转化成字符串后输出
exports.formatters.o=function(v){
    return inspect(v,this.useColors).replace(/\s*\n\s*/g, ' ');
};

// 带色彩打印消息
function formatArgs() {
    var args=arguments;
    var useColors=this.useColors;
    var name=this.namespace;

    if ( useColors ){
        var c=this.color;

        args[0]='  \u001b[3'+c+';1m'+name+' '
          +'\u001b[0m'
          +args[0]+
          '\u001b[3'+c+'m'+' +'+exports.humanize(this.diff)+'\u001b[0m';
    }else{
        args[0]=new Date().toUTCString()+' '+name+' '+args[0];
    }
    return args;
}

/**
 * Invokes `console.error()` with the specified arguments.
 */
function log(){
    return stream.write(util.format.apply(this,arguments)+'\n');
}

// 更新process.env.DEBUG环境变量
function save(namespaces){
    if ( null==namespaces ){
        delete process.env.DEBUG;
    }else{
        process.env.DEBUG = namespaces;
    }
}

// 待测试的模块通过环境变DEBUG量赋值
function load(){
    return process.env.DEBUG;
}

/**
 * Copied from `node/src/node.js`.
 *
 * XXX: It's lame that node doesn't expose this API out-of-the-box. It also
 * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
 */
// 写入文件
function createWritableStdioStream (fd){
    var stream;
    var tty_wrap=process.binding('tty_wrap');

    // Note stream._type is used for test-module-load-list.js

    switch (tty_wrap.guessHandleType(fd)) {
        case 'TTY':
            stream = new tty.WriteStream(fd);
            stream._type = 'tty';

            // Hack to have stream not keep the event loop alive.
            // See https://github.com/joyent/node/issues/1726
            if (stream._handle && stream._handle.unref) {
              stream._handle.unref();
            }
            break;

        case 'FILE':
            var fs = require('fs');
            stream = new fs.SyncWriteStream(fd, { autoClose: false });
            stream._type = 'fs';
            break;

        case 'PIPE':
        case 'TCP':
            var net = require('net');
            stream = new net.Socket({
              fd: fd,
              readable: false,
              writable: true
            });

            // FIXME Should probably have an option in net.Socket to create a
            // stream from an existing fd which is writable only. But for now
            // we'll just add this hack and set the `readable` member to false.
            // Test: ./node test/fixtures/echo.js < /etc/passwd
            stream.readable = false;
            stream.read = null;
            stream._type = 'pipe';

            // FIXME Hack to have stream not keep the event loop alive.
            // See https://github.com/joyent/node/issues/1726
            if (stream._handle && stream._handle.unref) {
              stream._handle.unref();
            }
            break;

        default:
            // Probably an error on in uv_guess_handle()
            throw new Error('Implement me. Unknown stream file type!');
    }

    // For supporting legacy API we put the FD here.
    stream.fd=fd;

    stream._isStdio=true;

    return stream;
}

// 待测试的模块通过环境变DEBUG量赋值
exports.enable(load());

debug.js

// 使用前需要调用require("debug").enable(namespace)添加待测试模块，debug函数方可用
// 因此可用于区分开发环境和线上环境，开发环境用enable函数开启测试功能，线上则否
exports=module.exports=debug;

// 若为错误，返回错误的堆栈信息或错误消息，否则原样输出
exports.coerce=coerce;

// 更新process.env.DEBUG环境变量，没有清空exports.skips、exports.names忽略和待测试模块队列
exports.disable=disable;

// exports.names、exports.skips添加待测试模块及忽略模块
exports.enable=enable;

// 待测试的模块返回真值，其余返回否，exports.skips需要忽略的模块
exports.enabled=enabled;

exports.humanize = require('ms');

exports.names=[];// 需要测试的模块
exports.skips=[];// 需要忽略的模块

// 以小写字母作为键(o存储非字符串时的格式化函数)，存储debug函数打印信息的格式化函数
// require("debug").formatters={a:function(str){return str.replace(/%/,"")}}
// var debug=require("debug").debug("app")
// debug("%123") 将打印app 123 +0ms
exports.formatters={};


var prevColor=0;// exports.colors起始位
var prevTime;// 缓存上次执行的时间

// 获取颜色码
function selectColor(){
    // 取余数，选择颜色码，用以拼接颜色字符串"\u001b[3"+"6|2|3|4|5|1"
    return exports.colors[prevColor++ % exports.colors.length];
}

// 参数namespace为模块名，返回函数，用于打印消息
function debug(namespace){

    function disabled(){
    }
    disabled.enabled=false;

    function enabled(){
        var self=enabled;

        // 计算执行时间
        var curr=+new Date();
        var ms=curr-(prevTime || curr);
        self.diff=ms;
        self.prev=prevTime;
        self.curr=curr;
        prevTime=curr;

        if ( null==self.useColors ) self.useColors=exports.useColors();// 是否开启带颜色输出
        if ( null==self.color && self.useColors ) self.color=selectColor();// 颜色码6|2|3|4|5|1

        var args=Array.prototype.slice.call(arguments);

        args[0]=exports.coerce(args[0]);// 处理错误(返回错误堆栈或错误消息)

        // exports.formatters.o方法，类型不是字符串时，使用util.inspect方法转化成字符串后输出
        if ( 'string'!==typeof args[0] ){
            args=['%o'].concat(args);
        }

        var index=0;

        // match匹配项，format括号内匹配项，没有匹配项将不执行回调函数
        args[0]=args[0].replace(/%([a-z%])/g, function(match,format){
            // %% 起始原样打印
            if ( match==='%%' ) return match;

            // %[a-z] 起始，且exports.formatters存在相应格式化函数，执行格式化、替换前两项后输出
            index++;
            var formatter=exports.formatters[format];
            if ( 'function'===typeof formatter ){
              var val=args[index];
              match=formatter.call(self, val);

              args.splice(index, 1);
              index--;
            }
            return match;
        });

        // 带色彩打印消息
        if ( 'function'===typeof exports.formatArgs ){
            args=exports.formatArgs.apply(self, args);
        }

        // enabled.log用户自定义打印方法; exports.log利用stream流打印消息
        var logFn=enabled.log || exports.log || console.log.bind(console);
        logFn.apply(self,args);
    }
    enabled.enabled=true;

    // 倘若namespace为待测试模块，fn引用enabled函数，否则引用disabled函数
    var fn=exports.enabled(namespace) ? enabled : disabled;

    fn.namespace=namespace;

    return fn;
}

// 字符串形式设置待测试以及忽略的模块，多个模块以空格分割，忽略的模块以"-"起始
// 将模块的正则式推入exports.names或exports.skips中
function enable(namespaces){
    exports.save(namespaces);// 更新process.env.DEBUG环境变量

    var split=(namespaces || '').split(/[\s,]+/);
    var len=split.length;

    for ( var i=0; i<len; i++ ){
        if (!split[i]) continue; // ignore empty strings
        namespaces=split[i].replace(/\*/g, '.*?');
        if (namespaces[0] === '-'){
            exports.skips.push(new RegExp('^'+namespaces.substr(1)+'$'));
        }else{
            exports.names.push(new RegExp('^'+namespaces+'$'));
        }
    }
}

// 没有清空exports.skips、exports.names忽略和待测试模块队列，函数的意义何在？？？
function disable() {
    exports.enable('');
}

// 待测试的模块返回真值，其余返回否，exports.skips需要忽略的模块
function enabled(name){
    var i,len;
    for ( i=0, len=exports.skips.length; i<len; i++ ){
        if ( exports.skips[i].test(name) ){
          return false;
        }
    }
    for ( i=0, len=exports.names.length; i<len; i++ ){
        if ( exports.names[i].test(name) ){
          return true;
        }
    }
    return false;
}

// 若为错误，返回错误的堆栈信息或错误消息，否则原样输出
function coerce(val){
  if ( val instanceof Error ) return val.stack || val.message;
  return val;
}

4.存疑：日志输出为文件，客户端使用