1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
# 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)
|
