GitLocker: The Coding Marketplace

Description:

path to regexp

path_to_regexp #

Converts a path such as /user/:id into a regular expression.
Matching #
pathToRegExp() converts a path specification into a regular expression that
matches conforming paths.
final regExp = pathToRegExp('/user/:id');
regExp.hasMatch('/user/12'); // => true
regExp.hasMatch('/user/alice'); // => true
copied to clipboard
Custom Parameters #
By default, parameters match anything until the next delimiter. This behavior
can be customized by specifying a regular expression in parentheses following
a parameter name.
final regExp = pathToRegExp(r'/user/:id(\d+)');
regExp.hasMatch('/user/12'); // => true
regExp.hasMatch('/user/alice'); // => false
copied to clipboard
Extracting Parameters #
Parameters can be extracted from a path specification during conversion into a
regular expression.
final parameters = <String>[];
final regExp = pathToRegExp('/user/:id', parameters: parameters);
parameters; // => ['id']
copied to clipboard
Extracting Arguments #
extract() maps the parameters of a path specification to their corresponding
arguments in a match.
final parameters = <String>[];
final regExp = pathToRegExp('/user/:id', parameters: parameters);
final match = regExp.matchAsPrefix('/user/12');
extract(parameters, match); // => {'id': '12'}
copied to clipboard
Generating #
pathToFunction() converts a path specification into a function that generates
matching paths.
final toPath = pathToFunction('/user/:id');
toPath({'id': '12'}); // => '/user/12'
copied to clipboard
Tokens #
parse() converts a path specification into a list of tokens, which can be
used to create a regular expression or path generating function.
final tokens = parse('/users/:id');
final regExp = tokensToRegExp(tokens);
final toPath = tokensToFunction(tokens);
copied to clipboard
Similar to pathToRegExp(), parameters can also be extracted during parsing.
final parameters = <String>[];
final tokens = parse('/users/:id', parameters: parameters);
copied to clipboard
If you intend to match and generate paths from the same path specification,
parse() and the token-based functions should be preferred to their path-based
counterparts. This is because the token-based functions can reuse the same
tokens, whereas each path-based function must parse the path specification anew.
Options #
Prefix Matching #
By default, a regular expression created by pathToRegExp or tokensToRegExp
matches the entire input. However, if the optional prefix argument is true, it
may also match as a prefix until a delimiter.
final regExp = pathToRegExp('/user/:id', prefix: true);
regExp.hasMatch('/user/12/details'); // => true
copied to clipboard
Case Sensitivity #
By default, a regular expression created by pathToRegExp or tokensToRegExp
is case sensitive. To create a case insensitive regular expression, set
caseSensitive to false.
final regExp = pathToRegExp('/user/:id', caseSensitive: false);
regExp.hasMatch('/USER/12'); // => true
copied to clipboard
Demo #
Try the path_to_regexp_demo to experiment with this
library.
Credit #
This package is heavily inspired by its JavaScript namesake
path-to-regexp.