# data[].attributes.attachment_link.readable_text
Une expression régulière est un modèle que le moteur des expressions régulières tente de faire correspondre dans le texte d'entrée. Un modèle se compose d'un ou de plusieurs littéraux de caractère, opérateurs ou constructions. Pour obtenir une brève présentation, consultez Expressions régulières .NET.

Chaque section dans cette référence rapide répertorie une catégorie particulière de caractères, d'opérateurs et de constructions que vous pouvez utiliser pour définir des expressions régulières.

Nous avons également fourni ces informations dans deux formats que vous pouvez télécharger et imprimer pour une référence facile :

Caractères d'échappement

La barre oblique inverse (\) dans une expression régulière indique que le caractère qui le suit est un caractère spécial (comme indiqué dans le tableau suivant), ou qu'il doit être interprété littéralement. Pour plus d'informations, consultez Caractères d'échappement.

Classes de caractères

Une classe de caractères fait correspondre tout caractère d'un jeu de caractères. Les classes de caractères incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez classes de caractères.

Ancres

Les ancres, ou assertions de largeur nulle atomiques, entraînent le succès ou l'échec d'une correspondance en fonction de la position actuelle dans la chaîne, mais elles n'entraînent pas l'avancement du moteur à travers la chaîne ou la consommation de caractères. Les métacaractères répertoriés dans le tableau suivant sont des ancres. Pour plus d'informations, consultez Ancres.

Par défaut, la correspondance doit se produire à la fin de la chaîne ou avant \n à la fin de la chaîne ; en mode multiligne, elle doit se produire avant la fin de la ligne ou avant \n à la fin de la ligne.

La correspondance doit se produire à l'emplacement où la correspondance précédente s'est terminée.

La correspondance doit se produire sur une limite entre un caractère \w (alphanumérique) et un caractère \W (non alphanumériques).

Constructions de regroupement

Les constructions de regroupement délimitent les sous-expressions d'une expression régulière et capturent généralement les sous-chaînes d'une chaîne d'entrée. Les constructions de regroupement incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Constructions de regroupement.

Lookarounds d'un coup d'œil

Lorsque le moteur des expressions régulières atteint une expression lookaround, il prend une sous-chaîne qui atteint la position actuelle jusqu'au début (postanalyse) ou à la fin (préanalyse) de la chaîne d'origine, puis s'exécute Regex.IsMatch sur cette sous-chaîne à l'aide du modèle lookaround. La réussite du résultat de cette sous-expression est ensuite déterminée par le fait qu'il s'agisse d'une assertion positive ou négative.

Préanalyse positive

Déclare que ce qui suit immédiatement la position actuelle dans la chaîne est " check "

Postanalyse positive

Déclare que ce qui précède immédiatement la position actuelle dans la chaîne est " check "

Préanalyse négative

Déclare que ce qui suit immédiatement la position actuelle dans la chaîne n'est pas " Check "

Postanalyse négative

Déclare que ce qui précède immédiatement la position actuelle dans la chaîne n'est pas " Check "

Une fois qu'elles sont mises en correspondance, les groupes atomiques ne sont pas réévalués, même lorsque le reste du modèle échoue en raison de la correspondance. Cela peut améliorer considérablement les performances lorsque les quantificateurs se produisent dans le groupe atomique ou le reste du modèle.

Quantificateurs

Un quantificateur indique combien d'instances de l'élément précédent (qui peut être un caractère, un groupe ou une classe de caractères) doivent être présentes dans la chaîne d'entrée pour qu'il y ait correspondance. Les quantificateurs incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Quantificateurs.

Constructions de référence arrière

Une backreference permet qu'une sous-expression précédemment mise en correspondance soit ensuite identifiée dans la même expression régulière. Le tableau suivant répertorie les constructions de backreference prises en charge par les expressions régulières dans .NET. Pour plus d'informations, consultez Backreference Constructs.

Constructions d'alternative

Les constructions d'alternative modifient une expression régulière pour permettre la correspondance de type inclusif/exclusif. Ces constructions incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Constructions d'alternative.

Substitutions

Les substitutions sont des éléments de langage d'expression régulière pris en charge dans les modèles de remplacement. Pour plus d'informations, consultez Substitutions. Les métacaractères répertoriés dans le tableau suivant sont des assertions de largeur nulle atomiques.

Options des expressions régulières

Vous pouvez définir des options qui contrôlent comment le moteur des expressions régulières interprète un modèle d'expression régulière. Bon nombre de ces options peuvent être spécifiées inline (dans le modèle d'expression régulière) ou sous la forme d'une ou de plusieurs constantes RegexOptions. Cette référence rapide répertorie uniquement les options inline. Pour plus d'informations sur les options inline et RegexOptions, consultez l'article Options des expressions régulières.

Vous pouvez spécifier une option inline de deux façons :

En utilisant la construction Miscellaneous (?imnsx-imnsx) , où un signe moins (-) avant une option ou un ensemble d'options désactive ces options. Par exemple, (?i-mn) active la correspondance qui ne respecte pas la casse (i), désactive le mode multiligne (m) et désactive les captures de groupe sans nom (n). L'option s'applique au modèle d'expression régulière depuis le point au niveau duquel l'option est définie et est effective jusqu'à la fin du modèle ou jusqu'au point au niveau duquel une autre construction inverse l'option.

En utilisant la construction de regroupementsous- (?imnsx-imnsx: expression ) , qui définit des options pour le groupe spécifié uniquement.

Le moteur d'expression régulière .NET prend en charge les options inline suivantes :

Utilise le mode multiligne. ^ et $ correspondent au début et à la fin d'une ligne, au lieu du début et de la fin d'une chaîne.

Pour obtenir un exemple, consultez la section " Mode multiligne " dans Options des expressions régulières.

Ne capture aucun groupe sans nom.

Pour obtenir un exemple, consultez la section " Captures explicites uniquement " dans Options des expressions régulières.

Utilise le mode à ligne simple.

Pour obtenir un exemple, consultez la section " Mode à ligne simple " dans Options des expressions régulières.

Constructions diverses

Diverses constructions modifient un modèle d'expression régulière ou fournissent des informations le concernant. Le tableau suivant répertorie les diverses constructions prises en charge par .NET. Pour plus d'informations, consultez Miscellaneous Constructs.

(?imnsx-imnsx)
Active ou désactive des options telles que le non-respect de la casse au milieu d'un modèle. Pour plus d'informations, consultez Options des expressions régulières.

Commentaire inline. Le commentaire se termine à la première parenthèse fermante.
\bA(?#Matches words starting with A)\w+\b

# [to end of line]

Commentaire en mode X. Le commentaire commence au caractère # sans séquence d'échappement et se poursuit jusqu'à la fin de la ligne.
(?x)\bA\w+\b#Matches words starting with A

Voir aussi

# data[].attributes.attachment_link.title
Langage des expressions régulières - Aide-mémoire

# data[].attributes.attachment_link.description
Une expression régulière est un modèle que le moteur des expressions régulières tente de faire correspondre dans le texte d'entrée. Un modèle se compose d'un ou de plusieurs littéraux de caractère, opérateurs ou constructions. Pour obtenir une brève présentation, consultez Expressions régulières .NET.

# data[].attributes.attachment_link.description
Regular expression tester with syntax highlighting, explanation, cheat sheet for PHP/PCRE, Python, GO, JavaScript, Java, C#/.NET, Rust.

# data[].attributes.attachment_link.description
RegExr is an online tool to learn, build, & test Regular Expressions (RegEx / RegExp).

# data[].attributes.attachment_link.readable_text
Regular expressions play a vital role in every high-level programming language and so in JavaScript. Let's know them all in detail...

A Regular Expression (RegEx) is a sequence of characters that defines a search pattern. It helps you to "match" part of the text (string) by given rule.

 const regex = /[A-Z]\w+/g; const str = `Rahul, Taylor and Susanne are coders who live in India`;

You can do the same operation by using plain JavaScript, but regex can save you hundreds of lines & you can use it with almost any language (and even CLI tools)

The Core and Some Basics

When you write a RegEx, it always starts with / and ends with /. Your write the code in between the two slashes. The simplest example - to match the word 'apple' use /apple/ RegEx. This, however, won't match 'APPLE' or 'aPpLe', because RegEx is case sensitive.

To disable case sensitivity in RegEX, use what is called an i flag /apple/i now it will match 'apple', 'APPLE' & 'aPpLe'. To match both 'apple' and 'nut' use apple|nut/ RegEx. Simple, ugh?

How to use in JavaScript

Let's learn the most basic methods in JS for working with RegEx'es

str.match(regex) : Returns an array with all the matches it has found. Actually. there's a little catch here😉. If you try doing this: "apple apple" .match(/apple/) you would expect to get ['apple', 'apple'] nut that's not the case. In reality it returns just ['apple']. To get a full array with multiple matches, you should add g flag.

str.test(str) : regex is a variable assigned to your RegEx. str is the string you test with the RegEx. The method returns true if it finds any matches or false.

 let regex = /code|easy/i; const str = 'this code is EaSy super easy'; regex.test(str) str.match(regex) regex = /code|easy/ig; str.match(regex)

Concept of Wildcard Period

We learned how to statically match a word, let's say 'hug' (/hug/). But what if we want to match 'huh', 'hug', 'hum' at the same time? Wildcard period! That's the answer. /hu./ This will match all 3 letters long words starting with 'hu'.

Match single character with multiple possibilities

A lot of times you want something in-between. Instead of targeting every character by using . you might want to target only a, b, c, d, e characters. That's when the nest 'tricks' come in handy.

Reverse the character classes

a-z will match all letters from a to z. To match all symbols, EXCEPT the letters from a to z, use [^a-z]. The ^ operator reverses the behaviours when used in[ ].

Matching characters that occur more than one times

Search for patterns from the beginning of the end of the string

To search a character exactly at the beginning of a string using ^

Optional character

let regex = /colou?r/; let american = "color"; let british = "colour"; regex.test(american); regex.test(british); regex.test("cologr");

Let's take this to advance level

Common shorthands

Specify the upper and lower limit of matches

What if you want to match a sequence of characters that repeats X times, for example - match exactly a sequence of 5 letters 'a'? Here we go a{5} This would match only 'aaaaa' but not 'aa' or 'aaaaaaa'.

Let's see...

You saw how to match an exact number of repeating characters a{5} matches "aaaaa". But what if you want to match not exactly 5, but in a more flexible manner - from 1 to 3 repeating characters? Here we go a{1,3} which will match "a" , "aa", "aaa", but not "aaaa".

We can go even further - by omitting the first or the second parameter a{3} will not match "a", "aa", but will match "aaa", "aaaa" or higher.

Match characters t#hat occur multiple times

Above we have briefly covered this topic, now is the moment to go deep.

To match one or more characters, use after the target character.

To match zero or more characters, ue after the target character

To match zero or one character, use after the target character

Positive and Negative lookahead

This is considered one of the abstract topics in regex, but I will try to cover 80/100 of what you need to know.

a(?=g) - Positive lookahead Matches all "a" that is followed by "g", without making the "g" part of the match.

a(?!g) - Negative lookahead Matches all "a" that are NOT followed by "g", without making "g" part of the match.

But it can be even more flexible. See this example -> (?=regex) ?!regex

On the place of regex, you can put any valid regex expression. Let's hang with this...

What if you want the opposite - check the character before, not after the target character? You use a LookBehind ;P

Reusing patterns with capture groups

We all know the DRY programming principle - Don't Repeat Yourself. Capture groups help us to do exactly this.

Now let's learn how to unleash this potential regex power and fuel it all to your JavaScript skills!

Creating RegEx in JavaScript

-> Compiles when script is loaded

FLAGS

In JavaScript we have 6 flags which affect the match:

i - Makes the match case-insensitive. No difference between 'C' and 'c'

g - Without this flag, only the first match will be returned

m - Multiline more; only affects the behavior of ^ and $

s - Dotall mode; allows wildcard period . to match newline character \n

u - Enabled full Unicode support

y - Sticky mode. Enabled searching at a specific position

LET'S SEE JS METHODS THAT USE RegEx IN SOME FORM OR ANOTHER

str.match(regexp) - Finds all matches of regexp in the string str and returns an array of those matches

regexp.exec(str) - Similar to the match method but it's meant to be used in a loop when the regexp is stored in global variable but not passed directly

str.matchAll(regexp) - A new JS feature and improvement on the match method. 3 Differences:

Returns an iterable object with matches instead of an array.

Each match is in the same format as str.match without the 'g' flag.

If there are no matches it returns empty iterable object rather than null if you used to match.

Always add g flag when using this one!

regexp.test(str) - Looks for at least one match of regexp in str. If found, returns true. Otherwise false.

str.search(regexp) - Returns the index of the first available match. If no match is found returns -1.

str.match(separator) - Instead of passing a simple string to separator like ' ', we can also pass regex for more precise split/

str.replace(from, to) - from is what to match. It can be a string or regex. The first match will be replaced with the string you have passed to the to argument. Instead of a string, you can pass a function too, but this is outside of the scope of this tutorial.

str.repalceAll(from,to) - Same as replace, except instead of replacing only the first match it will replace all matches with the provided to. Example:

A bit tough and lengthy. Hope you liked it! Use the comments for sharing your views and questions.

🔐Thanks For Reading | Happy Coding 📘

# data[].attributes.attachment_link.title
Super ultimate guide to Regex in 2021 (how to use in JavaScript)

# data[].attributes.attachment_link.description
Regular expressions play a vital role in every high-level programming language and so in JavaScript. Let's know them all in detail... A Regular Expression (RegEx) is a sequence of characters that defines a search pattern. It helps you to "match" par...

# data[].attributes.attachment_link.description
Une expression régulière est un groupement de caractères ou symboles utilisés pour trouver un schéma spécifique dans un texte. Une expression régulière est un schéma qui est comparé à une chaîne de caractères (string) de gauche à droite. Le mot "Expression régulière" est un terme entier, souvent abrégé par "regex" ou "regexp".

# data[].attributes.attachment_link.readable_text
Hi everyone, This is my first blog on this platform in which we are going to learn regex with the help of a cool mini project.

Outline

What is RegEx?

RegEx is short for Regular Expresssions. RegEx are strings of special characters that are used as patterns to match against strings.

Use cases of RegEx.

For validations (email validation, phone validation etc).

Match and replace programs.

Password pattern matching etc.

Ways to define RegEx in JavaScript.

There are basically two ways to define RegEx in JavaScript.

Let's have a look at how to define RegEx using both ways.

For the RegEx object part, you do not need to import/require anything to use it. Since, it is a global object that is available to you everywhere in your code file.

For this blog, I'll be using the literal way

RegEx Cheatsheet

Some useful Flags.

1. i --> It is used to ignore case sensitivity.

2. g --> It is used to perform global search.

3. s --> It is used to match newline character.

4. m --> It is used to perform multi-line search.

You can use more than one flag in your RegEx pattern but it is important to write flags at the end.

this will output to true because i flag at the end will ignore the case senstivity.

Metacharacters

Metacharacters are used to match the following character either as the special character or the literals.
Some of the metacharacters are written below.

1. \d --> to match the next character from [0-9]

2. \D --> to match the following character anything but digits.

3. \s --> to match the next character as whitespace/space.

4. \w --> to match the alphabets(both capital and small ones).

5. \W --> to match anything but alphabets.

Quantifiers.

Quantifiers are used to tell how many number of characters or expressions you want to match.

For example: If you want to match 10 digits you will do something like this

Some of the quantifiers are as follow
Project.

We will be building a cool mini project using RegEx to validate mobile number in US format.

It will return true for every format that respects the US mobile number format otherwise false will be returned.

Following are the valid US phone number format

555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555

--

I hope I was able to deliver something good to you guys ☺. Feedback, suggestions, etc are always welcomed.

Have a fun and safe time and Thank you so much for dedicating your time to go through this blog ❤.

You can follow me on Twitter 💜😅

"Let's Learn and Grow Together. Adios amigos/amigas hasta la proxima vez 💜☕"

# data[].attributes.attachment_link.title
RegEx in JavaScript with a cool project 🔥

# data[].attributes.attachment_link.description
Hi everyone, This is my first blog on this platform in which we are going to learn regex with the help of a cool mini project. RegEx is short for Regular Expresssions. RegEx are strings of special characters that are used as patterns to match against strings.

# data[].attributes.attachment_link.readable_text
Thanks for contributing an answer to Stack Overflow!

Please be sure to answer the question. Provide details and share your research!

Asking for help, clarification, or responding to other answers.

Making statements based on opinion; back them up with references or personal experience.

To learn more, see our tips on writing great answers.

# data[].attributes.attachment_link.description
Thanks for contributing an answer to Stack Overflow! Please be sure to answer the question. Provide details and share your research! Asking for help, clarification, or responding to other answers. Making statements based on opinion; back them up with references or personal experience. To learn more, see our tips on writing great answers.

# data[].attributes.attachment_link.readable_text
Regular expressions are patterns that provide a powerful way to search and replace in text.

In JavaScript, they are available via the RegExp object, as well as being integrated in methods of strings.

A regular expression (also "regexp", or just "reg") consists of a pattern and optional flags.

There are two syntaxes that can be used to create a regular expression object.

The "long" syntax:

And the "short" one, using slashes "/":

Slashes /.../ tell JavaScript that we are creating a regular expression. They play the same role as quotes for strings.

In both cases regexp becomes an instance of the built-in RegExp class.

The main difference between these two syntaxes is that pattern using slashes /.../ does not allow for expressions to be inserted (like string template literals with ${...}). They are fully static.

Slashes are used when we know the regular expression at the code writing time - and that's the most common situation. While new RegExp is more often used when we need to create a regexp "on the fly" from a dynamically generated string. For instance:

Regular expressions may have flags that affect the search.

There are only 6 of them in JavaScript:

With this flag the search is case-insensitive: no difference between A and a (see the example below).

With this flag the search looks for all matches, without it - only the first match is returned.

Multiline mode (covered in the chapter Multiline mode of anchors ^ $, flag "m").

Enables "dotall" mode, that allows a dot . to match newline character \n (covered in the chapter Character classes).

Enables full Unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter Unicode: flag "u" and class \p{...}.

"Sticky" mode: searching at the exact position in the text (covered in the chapter Sticky flag "y", searching at position)

As mentioned previously, regular expressions are integrated with string methods.

The method str.match(regexp) finds all matches of regexp in the string str.

It has 3 working modes:

1. If the regular expression has flag g, it returns an array of all matches:

Please note that both We and we are found, because flag i makes the regular expression case-insensitive.

2. If there's no such flag it returns only the first match in the form of an array, with the full match at index 0 and some additional details in properties:

The array may have other indexes, besides 0 if a part of the regular expression is enclosed in parentheses. We'll cover that in the chapter Capturing groups.

3. And, finally, if there are no matches, null is returned (doesn't matter if there's flag g or not).

This a very important nuance. If there are no matches, we don't receive an empty array, but instead receive null. Forgetting about that may lead to errors, e.g.:

If we'd like the result to always be an array, we can write it this way:

The method str.replace(regexp, replacement) replaces matches found using regexp in string str with replacement (all matches if there's flag g, otherwise, only the first one).

For instance:

The second argument is the replacement string. We can use special character combinations in it to insert fragments of the match:

An example with $&:

The method regexp.test(str) looks for at least one match, if found, returns true, otherwise false.

Later in this chapter we'll study more regular expressions, walk through more examples, and also meet other methods.

Full information about the methods is given in the article Methods of RegExp and String.

Without flags and special symbols (that we'll study later), the search by a regexp is the same as a substring search.

The method str.match(regexp) looks for matches: all of them if there's g flag, otherwise, only the first one.

The method str.replace(regexp, replacement) replaces matches found using regexp with replacement: all of them if there's g flag, otherwise only the first one.

The method regexp.test(str) returns true if there's at least one match, otherwise, it returns false.

# data[].attributes.attachment_link.readable_text
We've detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using twitter.com. You can see a list of supported browsers in our Help Center.
Help Center

# data[].attributes.attachment_link.title
Chris Achard on Twitter: "🔥 Intro to regex for web developers 👇 / Twitter"

# data[].attributes.attachment_link.embed_code
🔥 Intro to regex for web developers 👇
— Chris Achard (@chrisachard) October 8, 2019

# data[].attributes.attachment_link.readable_text
Hello everyone!!💝

Are you confused with the title😅? Do you also stay away from regular expressions? Do you use google while solving regex problems? Not after reading this article!😋

C'mon, let's learn it together.🤗

CONTENTS

Why Regular Expressions?

Regex(Regular Expressions) is used to define various types of string patterns which can be used for manipulating, searching, or editing a string. It can be used in all types of text search and text replace operations. Simply, a regular expression is a sequence of characters that helps us to match or find strings.

As we are now aware of regex, let's see how to write it.🤩

Cheatsheets
Matching Symbols

Note: [^regex] and ^regex are totally different.
Meta Characters

Quantifiers

How to write regular expressions?

We should write a regular expression pattern in such a way that it satisfies the required output. Many of them feel regex is hard because of this. So, let's solve some examples to understand this more clearly.

disclaimer: I am using java methods in solutions below. If you are willing to use other languages just check with the regular expression, which is our main goal.😉

Output: [I, love, Hashnode, It, is, a, wonderful, platform]

trim() is used to remove trailing and leading spaces. After replacing alphabets with a white-space, we get trailing spaces because of in " I love Hashnode". Since trailing spaces cannot be identified with [\\s]+ we used trim().

That's all people😍. Now, we can write any regex patterns in any language by using these cheat sheets.

Say bye-bye to google!😁

Articles you may like

# data[].attributes.attachment_link.description
Hello everyone!!💝 Are you confused with the title😅? Do you also stay away from regular expressions? Do you use google while solving regex problems? Not after reading this article!😋 C'mon, let's learn it together.🤗 Regex(Regular Expressions) is used to define various types of string patterns which can be used for manipulating, searching, or editing a string.

# data[].attributes.attachment_link.readable_text
So here's the meat and potatoes of RegEx. The core of what it is to use Regular Expression. Let's start at the beginning...

Declaring a RegEx method

There are a few ways to declare your Regular Expressions, the below is the easiest way I've found and is the most common.

The second method is a little bit more verbose as it uses the RegExp() method.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp

The RegExp constructor creates a regular expression object for matching text with a pattern. Fancy huh? With most things fancy, it's also usually unnecessary. Use the first method.

'Testing' a Regular Expression

Now how do we see if our RegEx declaration matches a given string.

Luckily, a simple test method .test() is already in place natively to see whether your RegEx pattern matches or not, returning a boolean.

'Executing' the search for a particular match

The exec() method executes a search for a match in a specified string. Returns a result array, or .

In this case, it will return an array.

Match

Though executing a pattern search is great, but what if we want to actually do the matching? Well I've got you covered with the .match() method.

The .match() method searches a string for a match against a regular expression, and returns the matches, as an Array object. However, in this case, we want to return the array with some further useful information like the specific instances our pattern occurs. We do this by appending the g (global) method to our reg variable declaration like this...

That now returns an array of instances that the pattern outlined in reg occurs.

Replace

Now you don't always need to declare a regular expression pattern. You can always just use your string and a method. As is the case with the .replace() method.

Which simply just replaces whatever matches your pattern with something of your choice...

Search

Another cool regEx method is the .search() method which searches a string for a specified value, and returns the position of the match.

One of the great things about regEx is here in this method in that search value can be string or a regular expression. The customisability is quite varied and its why you'll see so many differing opinions on what the best way to do anything in regEx is throughout the developer community.

This method also returns -1 if no match is found.

# data[].attributes.attachment_link.title
What is RegEx Really and Important RegEx Functions

# data[].attributes.attachment_link.description
So here's the meat and potatoes of RegEx. The core of what it is to use Regular Expression. Let's start at the beginning... There are a few ways to declare your Regular Expressions, the below is the easiest way I've found and is the most common.

# data[].attributes.attachment_link.readable_text
A regular expression (regex or regexp for short) is a special text string for describing a search pattern. You can think of regular expressions as wildcards on steroids. You are probably familiar with wildcard notations such as *.txt to find all text files in a file manager. The regex equivalent is .

But you can do much more with regular expressions. In a text editor like EditPad Pro or a specialized text processing tool like PowerGREP, you could use the regular expression to search for an email address. Any email address, to be exact. A very similar regular expression (replace the first with and the last one with ) can be used by a programmer to check whether the user entered a properly formatted email address. In just one line of code, whether that code is written in Perl, PHP, Java, a .NET language, or a multitude of other languages.

Regular Expressions Quick Start

If you just want to get your feet wet with regular expressions, take a look at the one-page regular expressions quick start. While you can't learn to efficiently use regular expressions from this brief overview, it's enough to be able to throw together a bunch of simple regular expressions. Each section in the quick start links directly to detailed information in the tutorial.

Complete Regular Expressions Tutorial

Do not worry if the above example or the quick start make little sense to you. Any non-trivial regex looks daunting to anybody not familiar with them. But with just a bit of experience, you will soon be able to craft your own regular expressions like you have never done anything else. The free Regular-Expressions.info Tutorial explains everything bit by bit.

This tutorial is quite unique because it not only explains the regex syntax, but also describes in detail how the regex engine actually goes about its work. You will learn quite a lot, even if you have already been using regular expressions for some time. This will help you to understand quickly why a particular regex does not do what you initially expected, saving you lots of guesswork and head scratching when writing more complex regexes.

Replacement Strings Tutorial

A replacement string, also known as the replacement text, is the text that each regular expression match is replaced with during a search-and-replace. In most applications, the replacement text supports special syntax that allows you to reuse the text matched by the regular expression or parts thereof in the replacement. This website also includes a complete replacement strings tutorial that explains this syntax. While replacement strings are fairly simple compared with regular expressions, there is still great variety between the syntax used by various applications and their actual behavior.

Applications & Languages That Support Regexes

There are many software applications and programming languages that support regular expressions. If you are a programmer, you can save yourself lots of time and effort. You can often accomplish with a single regular expression in one or a few lines of code what would otherwise take dozens or hundreds.

Many applications and programming languages have their own implementation of regular expressions, often with slight and sometimes with significant differences from other implementations. When two applications use a different implementation of regular expressions, we say that they use different "regular expression flavors". Unlike most other regex tutorials, the tutorial on this website covers all the popular regular expression flavors, and indicates the differences that you should watch out for.

Not Only for Programmers

If you are not a programmer, you can use regular expressions in many situations just as well. They make finding information a lot easier. You can use them in powerful search and replace operations to quickly make changes across large numbers of files. A simple example is which finds both spellings of the word gray in one operation, instead of two. There are many text editors and search and replace tools with decent regex support.

Further Reading

If you're hungry for more information on regular expressions after reading this website, there are a variety of books on the subject.

Make a Donation

Did this website just save you a trip to the bookstore? Please make a donation to support this site, and you'll get a lifetime of advertisement-free access to this site!

# data[].attributes.attachment_link.title
Regular-Expressions.info - Regex Tutorial, Examples and Reference - Regexp Patterns

# data[].attributes.attachment_link.description
A regular expression (regex or regexp for short) is a special text string for describing a search pattern. You can think of regular expressions as wildcards on steroids. You are probably familiar with wildcard notations such as *.txt to find all text files in a file manager. The regex equivalent is .

# data[].attributes.attachment_link.readable_text
In general, a string represents a sequence of characters in a programming language.

Let's look at an example of a string created using a sequence of characters, "Yes, You Can DO It!". In JavaScript, we can create a string in a couple of ways:

Using the string literal as a primitive

const msg = "Yes, You Can DO It!";

Using the String() constructor as an object

const msg = new String("Yes, You Can DO It!");

One interesting fact about strings in JavaScript is that we can access the characters in a string using its index. The index of the first character is 0, and it increments by 1. So, we can access each of the characters of a string like this:

let str = "Yes, You Can Do It!"; console.log(str[0]); // Y console.log(str[1]); // e console.log(str[2]); // s console.log(str[3]); // , console.log(str[10]); // a

The image below represents the same thing:

Apart from its ability to access string characters by their indices, JavaScript also provides plenty of utility methods to access characters, take out a part of a string, and manipulate it.

In this article will learn about a handy string method called split(). I hope you enjoy reading it.

The split() method splits (divides) a string into two or more substrings depending on a splitter (or divider). The splitter can be a single character, another string, or a regular expression.

After splitting the string into multiple substrings, the split() method puts them in an array and returns it. It doesn't make any modifications to the original string.

Let's understand how this works with an example. Here is a string created using string literals:

let message = 'I am a Happy Go lucky Guy';

We can call the split() method on the message string. Let's split the string based on the space (' ') character. Here the space character acts as a splitter or divider.

// Split using a space character let arr = message.split(' '); // The array console.log(arr); // ["I", "am", "a", "Happy", "Go", "lucky", "Guy"] // Access each of the elements of the array. console.log(arr[0]); // "I" console.log(arr[1]); // "am" console.log(arr[2]); // "a" console.log(arr[3]); // "Happy" console.log(arr[4]); // "Go", console.log(arr[5]); // "lucky" console.log(arr[6]); // "Guy"

The main purpose of the split() method is to get the chunks you're interested in from a string to use them in any further use cases.

How to Split a String by Each Character

You can split a string by each character using an empty string('') as the splitter. In the example below, we split the same message using an empty string. The result of the split will be an array containing all the characters in the message string.

console.log(message.split('')); // ["I", " ", "a", "m", " ", "a", " ", "H", "a", "p", "p", "y", " ", "G", "o", " ", "l", "u", "c", "k", "y", " ", "G", "u", "y"]

💡 Please note that splitting an empty string('') using an empty string as the splitter returns an empty array. You may get this as a question in your upcoming job interviews!

''.split(''); // returns []

How to Split a String into One Array

You can invoke the split() method on a string without a splitter/divider. This just means the split() method doesn't have any arguments passed to it.

When you invoke the split() method on a string without a splitter, it returns an array containing the entire string.

let message = 'I am a Happy Go lucky Guy'; console.log(message.split()); // returns ["I am a Happy Go lucky Guy"]

💡 Note again, calling the split() method on an empty string('') without a splitter will return an array with an empty string. It doesn't return an empty array.

Here are two examples so you can see the difference:

// Returns an empty array ''.split(''); // returns [] // Returns an array with an empty string ''.split() // returns [""]

How to Split a String Using a Non-matching Character

Usually, we use a splitter that is part of the string we are trying to split. There could be cases where you may have passed a splitter that is not part of the string or doesn't match any part of it. In that case, the split() method returns an array with the entire string as an element.

In the example below, the message string doesn't have a comma (,) character. Let's try to split the string using the splitter comma (,).

let message = 'I am a Happy Go lucky Guy'; console.log(message.split(',')); // ["I am a Happy Go lucky Guy"]

💡 You should be aware of this as it might help you debug an issue due to a trivial error like passing the wrong splitter in the split() method.

If you thought that the split() method only takes the splitter as an optional parameter, let me tell you that there is one more. You can also pass the limit as an optional parameter to the split() method.

string.split(splitter, limit);

As the name indicates, the limit parameter limits the number of splits. It means the resulting array will only have the number of elements specified by the limit parameter.

In the example below, we split a string using a space (' ') as a splitter. We also pass the number 4 as the limit. The split() method returns an array with only four elements, ignoring the rest.

let message = 'I am a Happy Go lucky Guy'; console.log(message.split(' ', 4)); // ["I", "am", "a", "Happy"]

We can also pass a regular expression (regex) as the splitter/divider to the split() method. Let's consider this string to split:

let message = 'The sky is blue. Grass is green! Do you know the color of the Cloud?';

Let's split this string at the period (.), exclamation point (!), and the question mark (?). We can write a regex that identifies when these characters occur. Then we pass the regex to the split() method and invoke it on the above string.

let sentences = message.split(/[.,!,?]/); console.log(sentences);

The output looks like this:

You can use the limit parameter to limit the output to only the first three elements, like this:

sentences = message.split(/[.,!,?]/, 3); console.log(sentences);

The output looks like this:

💡 If you want to capture the characters used in the regular expressions in the output array, you need to tweak the regex a bit. Use parenthesis to capture the matching characters. The updated regex will be /([.,!,?])/.

You can solve many interesting problems using the split() method combined with other string and array methods. Let's see one here. It could be a common use case to replace all the occurrences of a character in the string with another character.

For example, you may want to create the id of an HTML element from a name value. The name value may contain a space (' '), but in HTML, the id value must not contain any spaces. We can do this in the following way:

let name = 'Tapas Adhikary'; let subs = name.split(' '); console.log(subs); // ["Tapas", "Adhikary"] let joined = subs.join('-'); console.log(joined); // Tapas-Adhikary

Consider the name has the first name (Tapas) and last name (Adhikary) separated by a space. Here we first split the name using the space splitter. It returns an array containing the first and last names as elements, that is['Tapas', 'Adhikary'].

Then we use the array method called join() to join the elements of the array using the - character. The join() method returns a string by joining the element using a character passed as a parameter. Hence we get the final output as Tapas-Adhikary.

ECMAScript2015 (ES6) introduced a more innovative way to extract an element from an array and assign it to a variable. This smart syntax is known as Array Destructuring. We can use this with the split() method to assign the output to a variable easily with less code.

let name = 'Tapas Adhikary'; let [firstName, lastName] = name.split(' '); console.log(firstName, lastName);

Here we split the name using the space character as the splitter. Then we assign the returned values from the array to a couple of variables (the firstName and lastName) using the Array Destructuring syntax.

👋 Do you want to code and learn along with me? You can find the same content here in this YouTube Video. Just open up your favorite code editor and get started.

I hope you've found this article insightful, and that it helps you understand JavaScript String's split() method more clearly. Please practice the examples multiple times to get a good grip on them. You can find all the code examples in my GitHub repository.

Let's connect. You will find me active on Twitter (@tapasadhikary). Please feel free to give a follow.

You may also like these articles:

If you read this far, tweet to the author to show them you care. Tweet a thanks

# data[].attributes.attachment_link.title
JavaScript Split - How to Split a String into an Array in JS

# data[].attributes.attachment_link.description
In general, a string represents a sequence of characters in a programming language. Let's look at an example of a string created using a sequence of characters, "Yes, You Can DO It!". In JavaScript, we can create a string in a couple of ways: Using the string literal as a

# data[].attributes.attachment_link.description
Regex is the thing that you only learn when you need it. Unless you are processing a considerable amount of data, you likely won’t use it. Does that imply that, as a software engineer, we should forget about it and worry about it when that time come...

# data[].attributes.attachment_link.readable_text
Hi everyone, This is my first blog on this platform in which we are going to learn regex with the help of a cool mini project.

Outline

What is RegEx?

RegEx is short for Regular Expresssions. RegEx are strings of special characters that are used as patterns to match against strings.

Use cases of RegEx.

For validations (email validation, phone validation etc).

Match and replace programs.

Password pattern matching etc.

Ways to define RegEx in JavaScript.

There are basically two ways to define RegEx in JavaScript.

Let's have a look at how to define RegEx using both ways.

For the RegEx object part, you do not need to import/require anything to use it. Since, it is a global object that is available to you everywhere in your code file.

For this blog, I'll be using the literal way

RegEx Cheatsheet

Some useful Flags.

1. i --> It is used to ignore case sensitivity.

2. g --> It is used to perform global search.

3. s --> It is used to match newline character.

4. m --> It is used to perform multi-line search.

You can use more than one flag in your RegEx pattern but it is important to write flags at the end.

this will output to true because i flag at the end will ignore the case senstivity.

Metacharacters

Metacharacters are used to match the following character either as the special character or the literals.
Some of the metacharacters are written below.

1. \d --> to match the next character from [0-9]

2. \D --> to match the following character anything but digits.

3. \s --> to match the next character as whitespace/space.

4. \w --> to match the alphabets(both capital and small ones).

5. \W --> to match anything but alphabets.

Quantifiers.

Quantifiers are used to tell how many number of characters or expressions you want to match.

For example: If you want to match 10 digits you will do something like this

Some of the quantifiers are as follow
Project.

We will be building a cool mini project using RegEx to validate mobile number in US format.

It will return true for every format that respects the US mobile number format otherwise false will be returned.

Following are the valid US phone number format

555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555

--

I hope I was able to deliver something good to you guys ☺. Feedback, suggestions, etc are always welcomed.

Have a fun and safe time and Thank you so much for dedicating your time to go through this blog ❤.

You can follow me on Twitter 💜😅

"Let's Learn and Grow Together. Adios amigos/amigas hasta la proxima vez 💜☕"

# data[].attributes.attachment_link.title
RegEx in JavaScript with a cool project 🔥

# data[].attributes.attachment_link.description
Hi everyone, This is my first blog on this platform in which we are going to learn regex with the help of a cool mini project. RegEx is short for Regular Expresssions. RegEx are strings of special characters that are used as patterns to match against strings.

# data[].attributes.attachment_link.readable_text
Les expressions régulières, ou plus communément regex (contraction de regular expression) permettent de représenter des modèles de chaînes de caractère. Ce sont des outils très puissants et très utilisés : on peut les retrouver dans de nombreux langages comme le PHP, MySQL, Javascript... ou encore dans des logiciels d'édition de code ! Cependant, si cet outil est très puissant, il est relativement difficile à appréhender au début car les expressions régulières peuvent prendre des formes de ce genre :

#^[a-zA-Z-]+@[a-zA-Z-]+\.[a-zA-Z]{2,6}$#

Cet expression régulière permettant, par exemple, de représenter toutes les adresses emails contenues dans un texte. Vous pouvez donc voir que la syntaxe est peu commune et qu'un petit tutoriel s'impose pour pouvoir comprendre et utiliser le concept des expressions régulières. Pour suivre ce tutoriel, il vous faudra utiliser un éditeur de code qui comprend les expressions régulières : si vous n'en avez pas encore un, vous pouvez télécharger et installer notepad++.

La limite des recherches classiques

Pour commencer simplement, ouvrons notre éditeur de code et collons y le texte suivant :

Bonjour et au revoir ! Je m'appelle John Doe, j'ai 27 ans, j'habite en France et travaille depuis que j'ai 20 ans. Ma passion : écrire des mots, mits, mets, mats, mat... Pour me contacter, vous pouvez envoyer un email à contact@johndoe.fr ou contact@johndoe.com ou bien m'appeler au 06 07 08 09 10. Vous pouvez aussi aller voir mon blog à l'adresse johndoe-blog.fr. Bonjour et au revoir

Puis, recherchons y, en rendant la recherche sensible à la casse (voir image précédente), le mot Bonjour. La façon la plus simple est alors de faire un simple Ctrl+F comme on en a l'habitude : pas besoin d'utiliser les regex. Suite à cette recherche, les 2 occurrences de Bonjour devraient être sélectionné. Normal.

Maintenant, imaginons que nous voulons rechercher, cette fois-ci, seulement le mot Bonjour qui se trouve au tout début du texte. Comment faire avec un simple Ctrl+F ? Ce n'est tout simplement pas possible : voici donc la limite des recherches classiques. Pour faire des recherches plus complexes, il nous faudra utiliser les regex.

Regex simple

Reprenons notre recherche du mot Bonjour du début de texte, mais cette fois, en utilisant les regex, et plus particulièrement les caractères de début et fin de chaîne.

Les caractères de début et fin de chaîne

Les caractères de début et de fin de chaîne, respectivement ^ et $, représentent, comme leur nom l'indique, le début et la fin de la chaîne. Donc, si nous retournons dans notre éditeur de code, que nous faisons de nouveau Ctrl+F, que nous activons les expressions régulières au passage et que nous entrons dans le champ de recherche la regex suivante :

^Bonjour

L'éditeur de code devrait sélectionner seulement le mot Bonjour se trouvant au début du texte. Et si nous remplaçons la regex que nous venons d'entrer par celle-ci :

revoir$

L'éditeur de code devrait sélectionner seulement le mot revoir qui se situe à la fin du texte.

Le caractères OU

Imaginons maintenant que nous voulons rechercher, dans le texte, les mots Bonjour et revoir, c'est à dire le mot Bonjour OU le mot revoir : nous devrons alors utiliser la barre verticale |. Ainsi la regex suivante sélectionnera toutes les occurrences de Bonjour et revoir :

Bonjour|revoir

Il est aussi possible de sélectionner les occurrences du mot Bonjour se trouvant au début du texte et du mot revoir se trouvant à la fin, ce qui revient à fusionner, en les séparant par une barre verticale, les 2 regex vues dans la sous partie précédente. Voici donc la regex correspondant :

^Bonjour|revoir$

Les ensembles de caractères

Passons maintenant à des regex un peu plus complexes, et beaucoup plus puissantes, en nous attardons sur les ensembles de caractères.

Les différents ensembles

Maintenant, nous voulons chercher dans notre texte, les mots mots, mats et mits. Nous pourrions très bien utiliser cette regex :

mots|mats|mits

Mais il y a plus simple et ce grâce aux ensembles de caractères qui font office, en quelques sortes, de OU en plus courts et plus puissants. Un ensemble de caractère est délimité par des crochets dans lesquels se trouvent les caractères faisant parti du OU. Ainsi, la regex suivante :

m[oai]ts

est beaucoup plus succincte que la précédente et sélectionne les mêmes mots. Cette regex peut être expliciter par la phrase suivante : "Sélectionne les parties du texte où il y a un m, suivi d'un o ou d'un a ou d'un i, suivi d'un t, suivi d'un s." Les ensembles de caractères permettent aussi d'exclure des caractères grâce à l'accent circonflexe ^. La regex suivante :

m[^oai]ts

sélectionnera, cette fois-ci, seulement le mots mets et peut être explicitée par la phrase suivante : "Sélectionne les parties du texte où il y a un m, suivi d'une lettre qui n'est ni o, ni a, ni i, suivi d'un t, suivi d'un s." Enfin, imaginons que nous voulons sélectionner tous les mots commençant par un m, suivi de n'importe quelle lettre, suivi d'un t, suivi d'un s. La regex qui nous viendrait à l'esprit serait une regex de ce type :

m[abcdefghijklmnopqrstuvwxyz]ts

La regex serait donc longue et fastidieuse à écrire, surtout que pour celle-ci, seules les minuscules ont été sélectionnées ! Heureusement, un moyen plus simple existe pour écrire de telles regex : cela s'appelle les intervalles et se note [ debut intervalle- fin intervalle]. Voici quelques petites exemples :

Reprenons donc notre regex et utilisons les intervalles. Nous obtenons alors :

m[a-z]ts

ce qui sélectionne le mot mets en plus des mots mots, mats et mits.

Les ensembles préconçus

Un ensemble préconçu est une façon très simple de représenter plusieurs intervalles. Voici quelques exemples :

Ainsi, cette regex :

m\wts

sélectionnera les mêmes éléments que celle-ci :

m[a-zA-Z0-9_]ts

Les quantificateurs

Nous venons de voir qu'un ensemble de caractères permet de définir de manière très simple les valeurs possible d'un caractère. Mais qu'en est-il si l'on définir les mêmes valeurs possibles pour plusieurs caractères ? Par exemple, si l'on veut sélectionner les parties du texte où il y a un m, suivi d'un a, suivi de 3 fois n'importe quelle lettre minuscule, est-on obligé d'utiliser une regex de ce type :

ma[a-z][a-z][a-z]

Non. Il existe une méthode plus simple qui consiste à utiliser les quantificateurs : ce sont des caractères qui indiquent le nombre de répétition du caractère ou de la suite de caractère qui les précèdent. Le quantificateur, dans sa forme explicite, peut s'écrire de 4 façons :

{min,max} : le nombre de répétition varie entre la valeur minimale et la valeur maximale incluses

{min,} : le nombre de répétition varie entre la valeur minimale incluse et l'infini

{,max} : le nombre de répétition varie entre 0 et la valeur maximale incluse

{nombre} : le nombre de répétition correspond au nombre marqué entre les accolades

Par exemple, la regex suivante :

[a-zA-Z]{6}

permet de sélectionner les parties du texte où il y a 6 lettres consécutives. Celle-ci :

[0-9]{2,4}

permet de sélectionner les parties du texte où il y a entre 2 et 4 chiffres consécutifs. Comme pour les ensembles de caractères, il existe aussi des quantificateurs préconçus. En voici la liste :

L'échappement

Reprenons notre texte et imaginons que l'on veuille y sélectionner les noms de domaine des adresse email contact@johndoe.fr et contact@johndoe.com. La regex qui nous viendrait donc à la tête serait la suivante :

johndoe.[a-z]{2,3}

Et malheureusement, ce n'est pas exactement celle-là, car même si les 2 noms de domaine sont bien sélectionnés, la chaîne de caractère johndoe-blo l'est aussi.

Ce problème vient alors du point présent dans la regex car rappelez-vous que le point est un ensemble de caractères préconçus qui représente n'importe quel caractère : il peut représenter un a, un 2 mais aussi un tiret. Pour faire comprendre que le point présent dans la regex est bien un point et non pas un ensemble de caractères, il nous faut échapper le point avec le caractère d'échappement qui est le backslash \. Ainsi la regex correcte est la suivante :

johndoe\.[a-z]{2,3}

Cet échappement n'est pas seulement valable pour le point, mais pour tous les caractères qui ont, de base, une valeur différente que celle habituelle. En voici la liste : ^ $ \ | { } [ ] ( ) ? # ! + * .

Mise en pratique

Maintenant que vous possédez d'assez bonnes bases pour comprendre et utiliser les expressions régulières, il est temps de sortir des simples recherches dans l'éditeur de code et de passer à des cas plus pratiques par l'étude de 2 exemples d'utilisation des regex dans le langage de programmation PHP.

Vérifier si un numéro de téléphone est correcte

Le premier exemple consiste à vérifier si un numéro de téléphone est correcte. Pour se faire, imaginons que l'on ait créé, dans une page form.html, un formulaire contenant plusieurs champs dont un nommé numero dans lequel l'utilisateur saisirait son numéro de téléphone. Une fois le formulaire complété, l'utilisateur cliquerait sur Valider et enverrait ses données vers une page traitement.php dans laquelle on les vérifierait avant de les entrer dans une base de donnée. La partie nous concernant donc est de vérifier la validité de ce numéro de téléphone.

Commençons par la regex et admettons qu'elle permette de rechercher les numéros français, commençant par 0 ou +33 et possédant 9 chiffres sans compter le 0 ou +33. Ainsi, voici une écriture possible de celle-ci :

(0|\+33)[1-9]( *[0-9]{2}){4}

Peut-être venez vous de remarquer l'apparition de parenthèses. Celles-ci permettent de créer des suites (ou groupe) de caractères et de les stocker en mémoire. Ainsi, si, par exemple, le caractère précédent un quantificateur est en fait une suite de caractère, ce n'est pas le caractère précédent mais la suite de caractère qui sera répétée plusieurs fois. Voici maintenant ce que donne le code PHP entier comprenant la regex :

<?php
$numero = $_POST['numero'];
if (preg_match('#(0|\+33)[1-9]( *[0-9]{2}){4}#', $numero)) {
    echo "Le numéro de téléphone entré est correct.";
    // On peut ajouter le numéro à la base de donnée
} else {
    echo "Le numéro de téléphone entré est incorrect.";
    // On ne peut pas ajouter le numéro à la base de donnée
}
?>

Là aussi, 2 remarques sont à faire sur ce code :

la fonction preg_match fait son apparition : celle-ci prend en paramètre la regex ainsi que le texte dans lequel chercher et retourne true si la chaîne a été trouvée dans le texte, false sinon.

l'ajout d'un dièse # avant et après notre regex. Celui, pas forcément un dièse, permet de délimiter le début et la fin de notre regex, et ainsi, offre la possibilité d'ajouter, après le caractère marquant la fin de la regex, des options de recherche comme, par exemple, un i permettant de rendre une regex insensible à la casse

Détecter les liens et les rendre cliquable

Passons maintenant au second exemple qui est aussi assez pratique et qui consiste à détecter la présence d'url dans un texte et à les convertir en liens cliquables. Imaginons que le contexte soit le même que celui de l'exemple précédent et que, en plus de saisir son numéro de téléphone, l'utilisateur saisisse du texte pouvant contenir des url. Cette fois-ci, la partie nous intéressant consiste à rechercher ces url dans le texte et à les transformer en liens cliquables.

Pour commencer, définissons la forme que peuvent prendre les url. Celles-ci commenceront par http ou https, seront suivies de ://, suivies des sous-domaines et du nom de domaine, ne contenant que des chiffres, lettres, tirets et points et une extension de 2 à 4 caractères, suivies enfin du chemin d'accès (facultatif) comprenant tous les caractères sauf l'espace. Voici donc une regex possible pour rechercher des url :

https?://[a-zA-Z0-9\.-]+\.[a-zA-Z]{2,4}(/\S*)?

où \S signifie tout sauf l'espace et où, petit rappel, le ? permet de rendre facultatif le caractère le précédent. Voici maintenant le code entier :

<?php
$message = $_POST['message'];
$message = preg_replace(
    '#https?://[a-zA-Z0-9-\.]+\.[a-zA-Z]{2,4}(/\S*)?#',
    '<a href="$0" target="_blank">$0</a>',
    $message
);
echo $message;
?>

Comme dans l'exemple précédent, vous avez pu remarquer l'apparition d'une nouvelle fonction, preg_replace, permettant de remplacer des caractères dans un texte en utilisant les regex. Celle-ci prend en paramètre la regex, la chaîne de remplacement, et le texte contenant les chaînes à remplacer, et retourne le texte une fois les remplacements effectués.

Vous avez aussi pu remarquer la présence de $0 (appelées référence) dans le second paramètre de cette fonction. Ces références correspondent au texte satisfaisant toute la regex. D'autres références existent comme $1, $2, $3... qui, elles, correspondent au texte satisfaisant la première parenthèse de la regex, la seconde, la troisième... Si vous n'avez pas bien compris le fonctionnement de ces références, je vous conseille de bien regarder les exemples données dans la documentation PHP de cette fonction.

Le tutoriel touche à sa fin. J'espère qu'il vous aura permis de comprendre le fonctionnement des expressions régulières et d'en acquérir de bonnes bases. N'hésitez pas aussi à me donner votre avis en laissant un commentaire ou en m'envoyant un mail.

Voici les recherches relatives à cette page :

regex tuto

tuto regex

tutoriel regex

regex tutorial

regex tutoriel

tuto expression régulière

regex pour les nuls

Commentaires

Qu'en pensez-vous ? Donnez moi votre avis (positif ou négatif) pour que je puisse l'améliorer.

# data[].attributes.attachment_link.title
Tutoriel pour maîtriser les expressions régulières (regex)

# data[].attributes.attachment_link.description
Les expressions régulières, ou plus communément regex (contraction de regular expression) permettent de représenter des modèles de chaînes de caractère. Ce sont des outils très puissants et très utilisés : on peut les retrouver dans de nombreux langages comme le PHP, MySQL, Javascript... ou encore dans des logiciels d'édition de code !