diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 57fe02f5d..33ed8e15c 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -1,119 +1,119 @@ -# Patterns and flags +# Pattern e flag -A regular expression (also "regexp", or just "reg") consists of a *pattern* and optional *flags*. +Una espressione regolare (regular expression, "regexp" o solo "reg") è formata da una sequenza di caratteri (*pattern*) e da eventuali *flag*. -There are two syntaxes to create a regular expression object. +Esistono due tipi di sintassi per creare un oggetto di tipo "regular expression". -The long syntax: +La versione più lunga: ```js regexp = new RegExp("pattern", "flags"); ``` -...And the short one, using slashes `"/"`: +...e la più corta, usando gli slash `"/"`: ```js -regexp = /pattern/; // no flags -regexp = /pattern/gmi; // with flags g,m and i (to be covered soon) +regexp = /pattern/; // senza flag +regexp = /pattern/gmi; // con le flag g,m e i (da approfondire a breve) ``` -Slashes `"/"` tell JavaScript that we are creating a regular expression. They play the same role as quotes for strings. +Gli slash `"/"` comunicano a JavaScript che stiamo creando una espressione regolare. Hanno lo stesso ruolo delle virgolette per le stringhe. -## Usage +## Uso -To search inside a string, we can use method [search](mdn:js/String/search). +Per cercare in una stringa, possiamo usare il metodo [search](mdn:js/String/search). -Here's an example: +Qui un esempio: ```js run -let str = "I love JavaScript!"; // will search here +let str = "I love Javascript!"; // cercherà qui let regexp = /love/; alert( str.search(regexp) ); // 2 ``` -The `str.search` method looks for the pattern `pattern:/love/` and returns the position inside the string. As we might guess, `pattern:/love/` is the simplest possible pattern. What it does is a simple substring search. +Il metodo `str.search` cerca la sequenza `pattern:/love/` e restituisce la sua posizione all'interno della stringa. Come si può immaginare, il pattern `pattern:/love/` è la sequenza più semplice possibile. Quel che fa è la semplice ricerca di una sottostringa. -The code above is the same as: +Il codice qui sopra fa lo stesso di: ```js run -let str = "I love JavaScript!"; // will search here +let str = "I love JavaScript!"; // cercherà qui let substr = 'love'; alert( str.search(substr) ); // 2 ``` -So searching for `pattern:/love/` is the same as searching for `"love"`. +Quindi se cerchiamo la sequenza `pattern:/love/` avremo lo stesso risultato che otteniamo cercando `"love"`. -But that's only for now. Soon we'll create more complex regular expressions with much more searching power. +Questo vale solo per il momento. Presto creeremo espressioni regolari più complesse e con maggiore potere di ricerca. ```smart header="Colors" -From here on the color scheme is: +Da qui in avanti, lo schema di colori è il seguente: -- regexp -- `pattern:red` -- string (where we search) -- `subject:blue` -- result -- `match:green` +- espressione regolare -- `pattern:rosso` +- stringa (all'interno della quale cerchiamo) -- `subject:blu` +- risultato -- `match:verde` ``` -````smart header="When to use `new RegExp`?" -Normally we use the short syntax `/.../`. But it does not support variable insertions `${...}`. +Quando usiamo la sintassi `new RegExp`? +Usualmente usiamo la sintassi più breve `/.../`. Ma non supporta inserimenti di variabli con `${...}`. -On the other hand, `new RegExp` allows to construct a pattern dynamically from a string, so it's more flexible. +Tuttavia, `new RegExp` permette di costruire dinamicamente una sequenza da una stringa, quindi è più flessibile. -Here's an example of a dynamically generated regexp: +Qui un esempio di un'espressione regolare generata dinamicamente: ```js run -let tag = prompt("Which tag you want to search?", "h2"); +let tag = prompt("Quale tag vuoi cercare?", "h2"); let regexp = new RegExp(`<${tag}>`); -// finds

by default +// trova

di default alert( "

".search(regexp)); ``` -```` -## Flags -Regular expressions may have flags that affect the search. +## Flag -There are only 6 of them in JavaScript: +Le espressioni regolari possono avere flag che modificano la ricerca. + +Ce ne sono solo 6 in JavaScript: `i` -: With this flag the search is case-insensitive: no difference between `A` and `a` (see the example below). +: Con questa flag la ricerca non è sensibile all'uso di maiuscole (è case-insensitive) : non ci sono differenze tra `A` e `a` (vedi esempio in basso). `g` -: With this flag the search looks for all matches, without it -- only the first one (we'll see uses in the next chapter). +: Con questa flag la ricerca trova tutte le corrispondenze, senza la flag troverà solo la prima corrispondenza (ne vedremo gli usi nel prossimo capitolo). `m` -: Multiline mode (covered in the chapter ). +: Modalità multilinea (multiline mode) (approfondita nel capitolo ). `s` -: "Dotall" mode, allows `.` to match newlines (covered in the chapter ). +: Modalità "dotall", permette a `.` di ottenere le corrispondenze per le andate a capo (approfondito nel capitolo ). `u` -: Enables full unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter . +: Attiva il pieno supporto unicode. La flag consente di processare correttamente le coppie surrogate. Di più a proposito nel capitolo . `y` -: Sticky mode (covered in the chapter ) +: "Sticky mode" (approfondita nel capitolo ) -We'll cover all these flags further in the tutorial. +Approfondiremo tutte queste flag successivamente nel tutorial. -For now, the simplest flag is `i`, here's an example: +Per ora, la flag più semplice è `i`, qui un esempio: ```js run let str = "I love JavaScript!"; -alert( str.search(/LOVE/i) ); // 2 (found lowercased) +alert( str.search(/LOVE/i) ); // 2 (trovata in minuscolo) -alert( str.search(/LOVE/) ); // -1 (nothing found without 'i' flag) +alert( str.search(/LOVE/) ); // -1 (non trova niente senza la flag 'i') ``` -So the `i` flag already makes regular expressions more powerful than a simple substring search. But there's so much more. We'll cover other flags and features in the next chapters. +Quindi la flag `i` già rende le espressioni regolari più potenti rispetto alla semplice ricerca di una sottostringa. Ma c'è molto di più. Parleremo delle altre flag e caratteristiche nei prossimi capitoli. -## Summary +## Riepilogo -- A regular expression consists of a pattern and optional flags: `g`, `i`, `m`, `u`, `s`, `y`. -- 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.search(regexp)` returns the index where the match is found or `-1` if there's no match. In the next chapter we'll see other methods. +- Una espressione regolare è formata da una sequenza e eventualmente da alcune flag: `g`, `i`, `m`, `u`, `s`, `y`. +- Senza flag e simboli speciali che studieremo in seguito, cercare con una regexp è lo stesso di cercare con una sottostringa. +- Il metodo `str.search(regexp)` restituisce l'indice dove viene trovata la corrispondenza, oppure `-1` se non ci sono corrispondenze. Nel prossimo capitolo vedremo altri metodi. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy