https://github.com/jribbens/verbose-regexp

Verbose Regular Expressions
https://github.com/jribbens/verbose-regexp

javascript regex regexp regular-expression

Last synced: 2 months ago
JSON representation

Verbose Regular Expressions

• Host: GitHub
• URL: https://github.com/jribbens/verbose-regexp
• Owner: jribbens
• License: mit
• Created: 2021-05-24T19:43:17.000Z (over 3 years ago)
• Default Branch: main
• Last Pushed: 2023-06-04T16:04:07.000Z (over 1 year ago)
• Last Synced: 2024-11-17T10:49:52.739Z (3 months ago)
• Topics: javascript, regex, regexp, regular-expression
• Language: TypeScript
• Homepage:
• Size: 209 KB
• Stars: 9
• Watchers: 3
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# verbose-regexp

This module provides a way to use verbose regular expressions in

JavaScript and TypeScript, similar to `re.VERBOSE` in Python. It

provides that white-space at the start and end of lines are ignored,

as are newlines, and anything following `//` to the end of the line.

It allows you to easily write multi-line regular expressions, and to

make your regular expressions more self-documenting using formatting

and comments.

Example:

```javascript

    import { rx } from 'verbose-regexp'

    // or: const { rx } = require('verbose-regexp')

    const dateTime = rx`

      (\d{4}-\d{2}-\d{2}) // date

      T                   // time separator

      (\d{2}:\d{2}:\d{2}) // time

    `

    console.log(dateTime.exec(new Date().toISOString()))

```

You can also embed regular expressions within each other, to allow a

complicated regular expression to be built up in steps from simpler parts,

e.g.:

```javascript

    const date = rx`\d{4}-\d{2}-\d{2}`

    const time = rx`\d{2}:\d{2}:\d{2}`

    const dateTime = rx`

      (${date})           // date

      T                   // time separator

      (${time})           // time

    `

    console.log(dateTime.exec(new Date().toISOString()))

```

Note that embedded sub-expressions are automatically surrounded with `(?:`

and `)`, so that they are always treated as a self-contained unit. Also note

that embedded sub-expressions will be run using the flags of the parent

expression, regardless of what flags were on the sub-expression - so, for

example, if the sub-expression had the 'case insensitive' flag set but the

parent expression didn't, then the sub-expression will be executed in a

case sensitive manner.

You can use regular expression flags by accessing them as a property of `rx`,

e.g.:

```javascript

    const alpha = rx.i`[a-z]+`

    const allAlpha = rx.gi`[a-z]+`

```

If you want to use a string that would otherwise be ignored (i.e. whitespace

or `//`), you can simply escape it with backslashes or a character class:

```javascript

    const url = rx.i`

      [ ]*([a-z]+):\/\/  // scheme

      ([^/]+)           // location

      (?:/(.*))         // path

    `

```

## History

### 3.0.0 (2023-06-04)

  * Allow embedding of other RegExp objects.

### 2.0.0 (2022-05-03)

  * Use 'Proxy' objects to avoid having to create static properties for

    every permutation of the possible flags.

### 1.0.0 (2021-05-24)

  * Initial release.