实现一个简单的路由匹配组件 - Kori

// register
router.get('/user/id/:id/', ({id}) => {
  console.log(id);
});
 
router.post('/test/', () => {
  console.log('this is a test');
});
 
// use
router.handle('https://www.example.com/user/id/123456/');

digraph G {
  rankdir=LR;
	start -> a0 -> p0 -> p1 -> l0 -> e0 -> end0;
  e1 -> end1;
  y0 -> end2;
  start -> b0 -> y0 -> t0 -> e1 -> d0 -> a1 -> n0 -> c0 -> e2 -> end3;
  y0 -> e3 -> end4;
  
  a0[label="a"];
  a1[label="a"];
  b0[label="b"];
  c0[label="c"];
  d0[label="d"];
  e0[label="e"];
  e1[label="e"];
  e2[label="e"];
  e3[label="e"];
  n0[label="n"];
  p0[label="p"];
  p1[label="p"];
  l0[label="l"];
  t0[label="t"];
  y0[label="y"];
  end0[label="end"];
  end1[label="end"];
  end2[label="end"];
  end3[label="end"];
  end4[label="end"];
}

/**
* The trie's node
*
* @constructor
* @param {String} word this part of path.
* @param {Boolean} [isWild = false] if is wild, eg. app/user/{id}.
*/
function Node(word, isWild = false) {
  this.word = word;
  this.isWild = isWild;
  this.children = [];
  this.father = null;
  this.canEnd = false;
  this.callback = null;
}

Node.prototype.equals = function(node) {
  return (
    this.word === node.word this.isWild === node.isWild
  );
};
 
 
Node.prototype.match = function(word) {
  if (this.word === '*') return true;
  if (this.isWild) return true;
  if (this.word === word) return true;
  return false;
};
 
 
Node.prototype.getUrl = function() {
  const getPart =  ({ word, isWild }) => isWild ? `{${word}}` : word;
  let url = this.isWild ? getPart(this) : this.word;
  let node = this.father;
  while (node) {
    url = `${getPart(node)}/${url}`;
    node = node.father;
  }
  return url;
};
 
 
Node.prototype.debug = function(depth = 0) {
  const part = `${this.isWild ? '\{' : ''}${this.word}${this.isWild ? '\}' : ''}`;
  if (depth === 0) {
    console.log(` ┌  ${part}`);
  } else {
    const blank = [...new Array(depth)].map(() => ' │ ').join('').slice(0, -2) + '├─ ';
    console.log(blank + part);
  }
  for (let i = 0; i < this.children.length; i++) {
    this.children[i].debug(depth + 1);
  }
};

function Trie() {
  this.root = new Node('', false);
}

/**
* add a path to this trie.
*
* @param {String} path if it doesn't start with '/', it will be added a '/'.
* @param {Function} callback callback function.
*/
Trie.prototype.addRouter = function(path, callback) {
  // ...
};

if (path[0] === '/') {
  path = path.slice(1);
};
const parts = path.split('/');
const partsLength = parts.length;
 
let currentNode = this.root;

for (let i = 0; i < parts.length; i++) {
    let word = parts[i];
    let isEnd = i === partsLength - 1 || word === '*';
    let length = word.length;
    let isWild = false;
    
    if (length > 1 && word[0] === '{' && word[length - 1] === '}') {
      isWild = true;
      word = word.slice(1, length - 1);
    }
    let tempNode = new Node(word, isWild);
 
    const foundNode = currentNode.children.find(node => node.equals(tempNode));
 
    if (foundNode) {
      if (isEnd) {
        foundNode.callback = callback;
        foundNode.canEnd = true;
      } else {
        currentNode = foundNode;
      }
    } else {
      if (isEnd) {
        tempNode.callback = callback;
        tempNode.canEnd = true;
      }
      currentNode.children.push(tempNode);
      tempNode.father = currentNode;
      currentNode = tempNode;
    }
 
    if (isEnd) break;
  }

for (let i = 0; i < parts.length; i++) {
  let word = parts[i];
  const matchNode = currentNode.children.find(node => node.word !== '*' && node.match(word));
 
  if (matchNode) {
    haveMatched = true;
    if (matchNode.isWild) {
      keys[matchNode.word] = word;
    }
    currentNode = matchNode;
  } else {
    const starNode = currentNode.children.find(node => node.word === '*');
    if (starNode) {
      return {
        node: starNode,
        keys,
        splat: parts.slice(i).join('/'),
      };
    }
    // looc back for '*'
    for (let j = i - 1; j >= 0; j--) {
      currentNode = currentNode.father;
      const starNode = currentNode.children.find(node => node.word === '*');
      if (starNode) {
        return {
          node: starNode,
          keys,
          splat: parts.slice(j).join('/'),
        };
      }
    }
    return nullResult;
  }
}

var qs = require('qs');
var parse = require('url-parse');
var Trie = require('./trie');
 
const methods = [
  'get', 'post', 'put', 'head', 'delete',
  'options', 'trace', 'copy', 'lock', 'mkcol',
  'move', 'purge', 'propfind', 'proppatch', 'unlock',
  'report', 'mkactivity', 'checkout', 'merge', 'm-search',
  'notify', 'subscribe', 'unsubscribe', 'patch', 'search', 'connect',
];
 
/**
*
* @constructor
*/
function Kori(base) {
  this.methods = Object.create(null);
}
 
/**
* set a route, support chain call.
*
* @param {String} path
* @param {String} method case insensitive。
* @param {Function} callback callback function.
*/
Kori.prototype._setRouter = function(path, method, callback) {
  if(!this.methods[method]) this.methods[method] = new Trie();
  this.methods[method].addRouter(path, callback);
  return this;
};
 
/**
* handle a function request
*
* @param {String} path
* @param {String} method case insensitive.
* @param {Object[]} ...args transparent transmission parameters.
*/
Kori.prototype.handle = function(url, method, ...args) {
  const parsedUrl = parse(url);
  const {pathname: path, query} = parsedUrl;
  method = method.toLowerCase();
 
  const trie = this.methods[method];
  if (!trie) { 
    throw new Error('not match');
    return;
  }
 
  const result = trie.getRouter(path);
  if (!result.node) {
    throw new Error('not match');
    return;
  }
 
  const { node, keys, splat }= result;
  const callback = node.callback;
  return callback({
    url,
    path,
    match: node.getUrl(),
    keys, 
    splat, 
    query: qs.parse(query.slice(1)),
    method,
  }, ...args);
};
 
methods.forEach(method => {
  Kori.prototype[method] = function(path, callback) {
    return this._setRouter(path, method, callback);
  }
});