$scalaire =~ m/expr/[modificateur] 

équivalent à

$scalaire =~ /expr/[modificateur]

Les méta-caractères standards (\n, \t, …) gardent leurs significations.

L’utilisation de parenthèse permet de regrouper des motifs et de les réutiliser. Les variables $1, $2, $3, … mémorisent le motif apparié respectivement dans la première parenthèse, la seconde, la troisième … Ces opérateurs sont utilisables dans le code, mais aussi dans l’expression régulière.

$scalaire =~ s/motif/remplacement/[modificateurs]

Remplace « motif » par « remplacement » et retourne le nombre de substitutions effectuées, sinon renvoie vide.

Le caractère « ? » est une assertion de longueur nulle pour tester l’absence de quelque chose en avant.

tr/listerecherche/listeremplacement/cds

Substitue les occurrences des caractères recherchés par les caractères de la liste de remplacement et retourne le nombre de caractères remplacés ou supprimés.

split(/motif/,expr,limit)

Découpe une chaîne et en retourne un tableau de chaîne. Par défaut, les champs vides du début sont gardés et ceux de la fin sont éliminés.

Si limit est positif, il fixe le nombre max de champs du découpage (il est possible que le nombre de champs soit inférieur). Si limit est omis ou vaut 0, les champs vides de la fin sont supprimés.

/^\d+$/

/^\d+(.\d+)?$/

/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/

Avec ou sans http/https ou www

/^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/

$var=~s/∧([∧  ]*)  *([∧  ]*)/$2 $1/;  # Echange les 2 premiers mots  
$var=~s/∧\s*(.*?)\s*$/$1/;             # Supprime les espaces aux extrémités de $_  

/mot1(?!mot2)/                 # Reconnaît toutes les occurrences de mot1 qui ne sont pas suivies de mot2.
s/(\d)(\d\d\d)(?!\d)/$1  $2/g  # Formate un entier en mettant des espaces tous les 3 chiffres en partant de la droite.

tr/A-Z/a-z/;              # tout en minuscule dans $_
$i=tr/*/*/;               # compte les étoiles dans $_
$i=tr/0-9%%//%%;          # compte les chiffres dans $_
tr/a-zA-Z%%//%%s          # Hoooops devient Hops
tr/a-zA-Z/*/cs            # remplace tous les non-alphabétique par *
$texte =~ s/;/,/g         # remplace tous les ; par des , dans la variable $texte
$texte =~ s/^\s+|\s+$//g  # Supprime les espaces au début et à la fin

split(/ +/,`ls …`);             # split sur les blancs, quelque soit leur nombre.  
@noms=split(/\s/,`ls /etc`);    # split sur tous les caractères d’espacement (espace, tabulation,…)  

Exemple d'utilisation avec le fichier /etc/passwd en lisant dans la variable $ligne chaque ligne de la forme :

<user>:x:<id>:<gid>:<info>:<homepath>:<shellpath>

@tab=split(/:/,$ligne);                # récupère la liste en utilisant le séparateur « : »
($nom)= split(/:/,$ligne);             # récupère le nom d’utilisateur
($nom,undef,$uid)= split(/:/,$ligne);  # récupère le nom d’utilisateur et le user id 
($nom,$uid)=(split(/:/,$ligne))[0,2];  # récupère le nom d’utilisateur et le user id 

En perl on peut passer l'expression régulière dans une variable :

my $pattern = "motif";
if ($texte =~ /$pattern/) {
    print "Correspondance trouvée\n";
}

Pour une expression régulière utilisée plusieurs fois on peut optimiser en compilant l'expression régulière avant son utilisation :

my $regex = qr/motif/i;  # Compile l'expression régulière
if ($texte =~ $regex) {
    print "Correspondance trouvée\n";
}

• Si la variable contient des caractères spéciaux d'expression régulière, ils seront interprétés comme tels.
• Pour échapper automatiquement les caractères spéciaux il faut utiliser quotemeta() ou l'opérateur \Q…\E.

https://regex101.com/