VerbalExpressions

JavaScript Regular expressions made easy

Regular expression
VerbalExpressions/JSVerbalExpressionsverbalexpressions.github.io/JSVerbalExpressions/verbal-expressions

README

VerbalExpressions

Build Status Latest Version jsDelivr License

JavaScript Regular Expressions made easy


VerbalExpressions is a JavaScript library that helps construct difficult regular expressions.

How to get started


In the browser


  1. ``` html
  2. <script src="VerbalExpressions.js"></script>
  3. ```

Or use the jsDelivr CDN.

On the server (node.js)


Install:

  1. ```sh
  2. npm install verbal-expressions
  3. ```

Require:

  1. ``` js
  2. const VerEx = require('verbal-expressions');
  3. ```

Or use ES6's import:

  1. ``` js
  2. import VerEx from 'verbal-expressions';
  3. ```

Running tests


  1. ```sh
  2. npm test
  3. ```

(or)

  1. ```sh
  2. npm run test:verbose
  3. ```

Creating a minified version


  1. ```sh
  2. npm run build
  3. ```

This will run Babel onVerbalExpressions.js and output the result to dist/verbalexpressions.js. A minified version of the same will also be written to dist/verbalexpressions.min.js.

A source map will also be created in dist, so you can use the original "un-babelified", unminified source file for debugging purposes.

Building the docs/ folder


The docs/ folder uses Jekyll for building the static HTML and is hosted at
gh-pages.

To install the Ruby dependencies, run:

  1. ```
  2. cd docs/
  3. bundle install
  4. ```

This installs all needed Ruby dependencies locally

After you've installed dependencies, you can run:

  1. ```
  2. bundle exec jekyll build
  3. ```

This builds all static files to docs/_site/ folder.

If you want to develop the files locally, you can run:

  1. ```
  2. bundle exec jekyll serve
  3. ```

This starts a local development web server and starts watching your files for
changes.

API documentation


You can find the API documentation at verbalexpressions.github.io/JSVerbalExpressions. You can find the source code for the docs in [docs](docs/).

Examples


Here are some simple examples to give an idea of how VerbalExpressions works:

Testing if we have a valid URL


  1. ``` js
  2. // Create an example of how to test for correctly formed URLs
  3. const tester = VerEx()
  4.     .startOfLine()
  5.     .then('http')
  6.     .maybe('s')
  7.     .then('://')
  8.     .maybe('www.')
  9.     .anythingBut(' ')
  10.     .endOfLine();

  12. // Create an example URL
  13. const testMe = 'https://www.google.com';

  15. // Use RegExp object's native test() function
  16. if (tester.test(testMe)) {
  17.     alert('We have a correct URL'); // This output will fire
  18. } else {
  19.     alert('The URL is incorrect');
  20. }

  22. console.log(tester); // Outputs the actual expression used: /^(http)(s)?(\:\/\/)(www\.)?([^\ ]*)$/
  23. ```

Replacing strings


  1. ``` js
  2. // Create a test string
  3. const replaceMe = 'Replace bird with a duck';

  5. // Create an expression that seeks for word "bird"
  6. const expression = VerEx().find('bird');

  8. // Execute the expression like a normal RegExp object
  9. const result = expression.replace(replaceMe, 'duck');

  11. // Outputs "Replace duck with a duck"
  12. alert(result);
  13. ```

Shorthand for string replace


  1. ``` js
  2. const result = VerEx().find('red').replace('We have a red house', 'blue');

  4. // Outputs "We have a blue house"
  5. alert(result);
  6. ```

Contributions


Pull requests are warmly welcome!

Clone the repo and fork:

  1. ```sh
  2. git clone https://github.com/VerbalExpressions/JSVerbalExpressions.git
  3. ```

Style guide


The Airbnb style guide is loosely used as a basis for creating clean and readable JavaScript code. Check [.eslintrc](.eslintrc).

Check out these slide decks for handy Github & git tips:

- Git and Github Secrets
- More Git and Github Secrets

Tools


- - it's a wrapper of JSVerbalExpressions; users can write down the code and compile to regex- - JSBin Playground

Other Implementations


You can see an up to date list of all ports on VerbalExpressions.github.io.

- Ruby
- C#
- Python
- Java
- Groovy
- PHP
- Haskell
- Haxe
- C++
- Objective-C
- Perl
- Swift

If you would like to contribute another port (which would be awesome!), please open an issue specifying the language in the VerbalExpressions/implementation repo. Please don't open PRs for other languages against this repo.

Similar projects


Here's a list of other similar projects that implement regular expression
builders:

- https://github.com/MaxArt2501/re-build
- https://github.com/mathiasbynens/regenerate