http-hash-router源码阅读

var http = require('http');
var HttpHashRouter = require('http-hash-router');

var router = HttpHashRouter();

router.set('/health', function health(req, res) {
    res.end('OK');
});

var server = http.createServer(function handler(req, res) {
    router(req, res, {}, onError);

    function onError(err) {
        if (err) {
            // use your own custom error serialization.
            res.statusCode = err.statusCode || 500;
            res.end(err.message);
        }
    }
});
server.listen(3000);

function RouteNode(parent, segment, isSplat) {
    this.parent = parent || null; // 上级结点
    this.segment = segment || null; // 当前结点元素
    this.handler = null; // handler方法
    this.staticPaths = {}; // 静态路径
    this.variablePaths = null; // 可变路径
    this.isSplat = !!isSplat; // 是否带*号路径
    this.src = null; // 完整path
}

function set(pathname, handler) {
    var pathSegments = pathname.split('/');
    var hash = this._hash;
    var lastIndex = pathSegments.length - 1;
    var splatIndex = pathname.indexOf('*');
    var hasSplat = splatIndex >= 0;

    if (hasSplat && splatIndex !== pathname.length - 1) {
        throw SplatError(pathname);
    }

    for (var i = 0; i < pathSegments.length; i++) {
        var segment = pathSegments[i];
        // 路径元素为空，遍历下一个
        if (!segment) {
            continue;
        }
        // 如果该路径元素是*号 且是最后一个元素 则增加可变路径结点
        if (hasSplat && i === lastIndex) {
            // 同一路径下如果已经有了可变路径，维持之前的可变路径不变, 否则增加可变结点
            hash = (
                hash.variablePaths ||
                (hash.variablePaths = new RouteNode(hash, segment, true))
            );
            
            // 如果该可变路径不是* 而是：,则抛出冲突的异常，即不可以同时在同一路径下分别设置*和：两种通配符可变路径
            if (!hash.isSplat) {
                throw RouteConflictError(pathname, hash);
            }
        } else if (segment.indexOf(':') === 0) { // 如果是：通配符，增加可变路径结点
            segment = segment.slice(1); // 获取：后的元素
            // 同一路径下如果已经有了可变路径，维持之前的可变路径不变, 否则增加可变结点
            hash = (
                hash.variablePaths ||
                (hash.variablePaths = new RouteNode(hash, segment))
            );
            // 如果设置的可变路径元素跟之前的不一致 或者之前设置是*可变路径，则抛出冲突异常
            if (hash.segment !== segment || hash.isSplat) {
                throw RouteConflictError(pathname, hash);
            }
        } else if (segment === '__proto__') {
            hash = (
                (
                    hash.hasOwnProperty('proto') &&
                    hash.proto
                ) ||
                (hash.proto = new RouteNode(hash, segment))
            );
        } else { // 设置静态路径 查找当前has下的静态路径是否已经存在该路径元素 如果存在，直接复制结点，否则创建新的结点
            hash = (
                (
                    hash.staticPaths.hasOwnProperty(segment) &&
                    hash.staticPaths[segment]
                ) ||
                (hash.staticPaths[segment] = new RouteNode(hash, segment))
            );
        }
    }
    // 判断是否设置了重复路径，重复则抛出冲突异常
    if (!hash.handler) {
        hash.src = pathname;
        hash.handler = handler;
    } else {
        throwRouteConflictError(pathname, hash);
    }
}

function get(pathname) {
    var pathSegments = pathname.split('/');
    // 当前路由hash结点树
    var hash = this._hash;
    var splat = null;
    var params = {};
    var variablePaths;

    for (var i = 0; i < pathSegments.length; i++) {
        var segment = pathSegments[i];

        if (!segment && !hash.isSplat) {
            continue;
        } else if (
            segment === '__proto__' &&
            hash.hasOwnProperty('proto')
        ) {
            hash = hash.proto;
        } else if (hash.staticPaths.hasOwnProperty(segment)) {
            hash = hash.staticPaths[segment];
        } else if ((variablePaths = hash.variablePaths)) {
            if (variablePaths.isSplat) {
                splat = pathSegments.slice(i).join('/');
                hash = variablePaths;
                break;
            } else {
                params[variablePaths.segment] = segment;
                hash = variablePaths;
            }
        } else {
            hash = null;
            break;
        }
    }

    return new RouteResult(hash, params, splat);
}