Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/lukeed/matchit
Quickly parse & match URLs
https://github.com/lukeed/matchit
Last synced: 1 day ago
JSON representation
Quickly parse & match URLs
- Host: GitHub
- URL: https://github.com/lukeed/matchit
- Owner: lukeed
- License: mit
- Created: 2017-11-05T18:37:41.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2021-11-03T06:37:51.000Z (about 3 years ago)
- Last Synced: 2024-11-01T02:03:49.588Z (3 days ago)
- Language: JavaScript
- Size: 50.8 KB
- Stars: 322
- Watchers: 6
- Forks: 13
- Open Issues: 3
-
Metadata Files:
- Readme: readme.md
- License: license.md
Awesome Lists containing this project
- awesome-crafted-nodejs - matchit - Quickly parse & match URLs (Packages / HTTP)
- awesome-tiny-js - matchit - Route parser and matcher in <img align="top" height="24" src="./img/matchit.svg"> (Routers and URL Utils / Reactive Programming)
- awesome-star-libs - lukeed / matchit - router 的路由匹配，比如 /foo/:bar/:baz? (目录)
README
# matchit [](https://travis-ci.org/lukeed/matchit)
> Quickly parse & match URLs
## Install
```
$ npm install --save matchit
```
## Usage
```js
const { exec, match, parse } = require('matchit');
parse('/foo/:bar/:baz?');
//=> [
//=> { old:'/foo/:bar', type:0, val:'foo' },
//=> { old:'/foo/:bar', type:1, val:'bar' },
//=> { old:'/foo/:bar', type:3, val:'baz' }
//=> ]
const routes = ['/', '/foo', 'bar', '/baz', '/baz/:title','/bat/*'].map(parse);
match('/', routes);
//=> [{ old:'/', type:0, val:'/' }]
match('/foo', routes);
//=> [{ old:'/foo', type:0, val:'foo' }]
match('/bar', routes);
//=> [{ old:'bar', type:0, val:'bar' }]
match('/baz', routes);
//=> [{ old:'/baz', type:0, val:'baz' }]
let a = match('/baz/hello', routes);
//=> [{...}, {...}]
let b = exec('/baz/hello', a);
//=> { title:'hello' }
match('/bat/quz/qut', routes);
//=> [
//=> { old:'/bat/*', type:0, val:'bat' },
//=> { old:'/bat/*', type:2, val:'*' }
//=> ]
```
## API
### matchit.parse(route)
Returns: `Array`
The `route` is `split` and parsed into a "definition" array of objects. Each object ("segment") contains a `val`, `type`, and `old` key:
* `old` — The [`route`](#route)'s original value
* `type` — An numerical representation of the segment type.
* `0` - static
* `1` - parameter
* `2` - any/wildcard
* `3` - optional param
* `val` — The current segment's value. This is either a static value of the name of a parameter
#### route
Type: `String`
A single URL pattern.
> **Note:** Input will be stripped of all leading & trailing `/` characters, so there's no need to normalize your own URLs before passing it to `parse`!
### matchit.match(url, routes)
Returns: `Array`
Returns the [`route`](#route)'s encoded definition. See [`matchit.parse`](#matchitparseroute).
#### url
Type: `String`
The true URL you want to be matched.
#### routes
Type: `Array`
_All_ "parsed" route definitions, via [`matchit.parse`](#matchitparseroute).
> **Important:** Multiple routes will require an Array of `matchit.parse` outputs.
### matchit.exec(url, match)
Returns: `Object`
Returns an object an object of `key:val` pairs, as defined by your [`route`](#route) pattern.
#### url
Type: `String`
The URL (`pathname`) to evaluate.
> **Important:** This should be `pathname`s only as any `querystring`s will be included the response.
#### match
Type: `Array`
The route definition to use, via [`matchit.match`](#matchitmatchurl-routes).
## Benchmarks
> Running Node v10.13.0
```
# Parsing
matchit x 1,489,482 ops/sec ±2.89% (97 runs sampled)
regexparam x 406,824 ops/sec ±1.38% (96 runs sampled)
path-to-regexp x 83,439 ops/sec ±0.89% (96 runs sampled)
path-to-regexp.parse x 421,266 ops/sec ±0.13% (97 runs sampled)
# Match (index)
matchit x 132,338,546 ops/sec ±0.14% (96 runs sampled)
regexparam x 49,889,162 ops/sec ±0.21% (95 runs sampled)
path-to-regexp.exec x 7,176,721 ops/sec ±1.23% (94 runs sampled)
path-to-regexp.tokens x 102,021 ops/sec ±0.21% (96 runs sampled)
# Match (param)
matchit x 2,700,618 ops/sec ±0.92% (95 runs sampled)
regexparam x 6,924,653 ops/sec ±0.33% (94 runs sampled)
path-to-regexp.exec x 4,715,483 ops/sec ±0.28% (96 runs sampled)
path-to-regexp.tokens x 98,182 ops/sec ±0.45% (93 runs sampled)
# Match (optional)
matchit x 2,816,313 ops/sec ±0.64% (93 runs sampled)
regexparam x 8,437,064 ops/sec ±0.41% (93 runs sampled)
path-to-regexp.exec x 5,909,510 ops/sec ±0.22% (97 runs sampled)
path-to-regexp.tokens x 101,832 ops/sec ±0.43% (98 runs sampled)
# Match (wildcard)
matchit x 3,409,100 ops/sec ±0.34% (98 runs sampled)
regexparam x 9,740,429 ops/sec ±0.49% (95 runs sampled)
path-to-regexp.exec x 8,740,590 ops/sec ±0.43% (89 runs sampled)
path-to-regexp.tokens x 102,109 ops/sec ±0.35% (96 runs sampled)
# Exec
matchit x 1,558,321 ops/sec ±0.33% (96 runs sampled)
regexparam x 6,966,297 ops/sec ±0.21% (97 runs sampled)
path-to-regexp x 102,250 ops/sec ±0.45% (95 runs sampled)
```
## Related
- [regexparam](https://github.com/lukeed/regexparam) - A similar (285B) utility, but relies on `RegExp` instead of String comparisons.
## License
MIT © [Luke Edwards](https://lukeed.com)