Get unlimited public & private packages + package-based permissions with npm Pro.Get started »

path-to-tree

0.1.0 • Public • Published

Build Status

A tiny(3kb) foundation for building fast router via Radix Tree strategy , high-performance alternative for famous path-to-regexp

You can use it both in browser or Node.js.

Install

npm i path-to-tree

Usage

 
const ptt = require('path-to-tree');
 
const tree = ptt()
 
tree.add('/user/:id', 2);
 
const { param } = tree.find('/user/1')
 
/**
 * ==> {
 *  param: {
 *     id: "1" 
 * } ,
 * marker: 2
 * }
 * 
 * /
 

API

ptt( routeMap )

create tree instance

param

  • routeMap: route map to add
 
const tree = ptt({
    '/blog/:id': 'blog',
    '/user/:id': 'user'
})
 

as same as

 
const tree = ptt()
 
tree.add( '/blog/:id', 'blog')
tree.add( '/user/:id', 'user')
 

tree.add( route, marker [, option ])

add a route pattern

  • route: route string like /api/blog/:id
  • marker: route marker which will return by find
  • option: route config
    • strict: when false , trailing delimiter is optional. (default: true)
    • end: when false, only match the prefix of the URL (default: true)
 
const ptt = require('path-to-tree');
 
const tree = ptt();
 
tree.add('/blog/:id', function(param)=>{
    console.log(param)
})
 

tree.find( path )

  • return : a object container marker and param
 
let ret = tree.find('/blog/1');
 
ret.marker(ret.param) // => {id: "1"}
 
 
 
// marker === 

support param

  • named param: '/api/blog/:id
  • anonymous param: '/api/(hello|world)'
  • optional param: /api/name-:id?/api/name-(id|co)?
  • complex param: /blog/dada-((?:hello|nice)?-world)

Example

Simple Koa Router

 
const ptt = require('../') // === require('path-to-tree')
 
function router(cfg) {
 
    const tree = ptt(cfg);
 
    return async function (ctx, next) {
        const match = tree.find(ctx.path)
        if (match) {
            ctx.param = match.param;
            await match.marker(ctx, next)
        } else {
            await next();
        }
    }
}
 
 
const Koa = require('koa');
const app = new Koa();
 
 
app.use(
    router({
        '/blog/:id': (ctx, next) => {
            ctx.body ='blog ' + ctx.param.id
        },
        '/user/:id(\\d+)': (ctx, next) => {
 
            ctx.body ='user ' + ctx.param.id
        }
    })
)
 
app.listen(8002, ()=>{
    console.log('server start at 8002')
})

Benchmark

router based on path-to-regexp , described as O(n) Time Complexity ( n means route's length )

By contrast, router based on path-to-tree described as O(1) Time Complexity .(consider the deepth of path as constant)

In my computer (MacBook Pro 15: 2.2 GHz Intel Core i7、16 GB 1600 MHz DDR3) , the result of the benchmark show as below.

size of routes is 3000, 200x fast

path-to-tree x 215 ops/sec ±0.45% (77 runs sampled)
path-to-regexp x 1.04 ops/sec ±0.39% (7 runs sampled)
Fastest is path-to-tree

Install

npm i path-to-tree

DownloadsWeekly Downloads

0

Version

0.1.0

License

MIT

Unpacked Size

30.5 kB

Total Files

15

Last publish

Collaborators

  • avatar