Post in evidenza

Guida alla sintassi delle espressioni regolari (con esempi)

È da un po’ di tempo che meditavo la creazione di una guida alle espressioni regolari: in giro per la rete ce ne sono a bizzeffe, ma poche complete e pochissime in italiano; inoltre scrivere una guida dà la possibilità di ampliare le proprie conoscenze! Infatti scrivendola ho imparato cose di cui ignoravo l’esistenza!

Bisogna dire che molti preferiscono copiare ed incollare righe su righe di incomprensibili caratteri piuttosto che imparare questa strana sintassi, poiché a prima vista questa appare criptica ed incomprensibile e le espressioni sono solo lunghe serie di caratteri messi a casaccio senza un nesso logico!

Ma vedrete che non c’è nulla di difficile: basta un po’ di elasticità mentale, un pizzico di memoria e soprattutto un buon manuale da consultare spesso 😀 .

Cercherò di utilizzare una linearità nella descrizione, anche se questo mi risulterà difficile poiché è complicato spiegare un singolo elemento senza utilizzarne altri.

A che cosa servono le espressioni regolari?

Le espressioni regolari sono molto utili nell’ambito della ricerca e della sostituzione. Immaginiamo di avere un testo storico enorme e di dover convertire tutte le date in formato americano (yyyy/mm/dd) in quello classico italiano…

Sarebbe un lavoraccio doverlo fare tutto a mano! E probabilmente ci sfuggirebbero degli errori!

Ecco, con le espressioni regolari è possibile farlo in pochi caratteri! Con un risparmio di tempo, di errori e di… fegato!

La sintassi
Uguale per tutti i programmi / linguaggi?

Solitamente sì, in JavaScript e in Perl la sintassi è simile, come anche in PHP ed in altri linguaggi .
Anche Ide e programmi di testo come vim, notepad++, Komodo edit, Dreamweaver, PhpStorm, Android Studio etc. supportano il search & replace con le espressioni regolari.
Diciamo che la sintassi potrebbe cambiare, ma non di molto. E comunque se ne imparate una potrete comunque cavarvela con qualsiasi altra variante.

Gli esempi che utilizzerò qui di seguito utilizzeranno JavaScript, in modo da poterli testare al volo.

Ma passiamo alla descrizione dettagliata di ogni singolo elemento:

Come si scrive un’espressione regolare

La sintassi di una espressione regolare di per sé è semplice: è sempre racchiusa da due delimitatori (in JavaScript ed in molti altri linguaggi è lo slash /, in altri è possibile anche definirlo) all’interno dei quali sono presenti le regole di ricerca e alla fine sono presenti i modificatori (come per esempio i per il case insensitive, g per ricercare tutte le occorrenze e non solo la prima, ecc.).

/espressione/m
delimitatore inizialeespressione regolaredelimitatore finalemodificatore

Ecco un esempio di espressione regolare per ricercare un URL in un testo. Non spaventatevi, alla fine della guida riuscirete a comprenderla 🙂

// Espressione regolare per ricercare un url in un testo e dividere protocollo, dominio e indirizzo
let testo = "Questa è una frase con un URL https://www.example.com/dir/subdir/demo.html nel testo";
let regex = /\b(https?):\/\/([a-z\.]+)(\/[^ $]*)*/

Ah, tutti gli esempi sono editabili ed eseguibili cliccando sul pulsante Esegui, quindi potete divertirvi e sbizzarrirvi come volete! 🙂

Gli esempi verranno eseguiti utilizzando javascript in questo modo questo modo: [testo].match([regex]), mentre se è presente la variabile replace: [testo].replace([regex], [replace])

I metacaratteri

Nelle espressioni regolari esistono diversi “caratteri speciali” dalle diverse funzioni:

Meta

Descrizione

Esempio

.

(punto)

Il punto significa qualsiasi carattere ad eccezione di quelli che identificano una riga nuova (\n e \r per intenderci)

let testo = 'Espressioni regolari!';
let regex = /s./;
// Trova una s seguita da qualsiasi carattere

^

L’accento circonflesso identifica l’inizio di una riga; inoltre all’inizio di un gruppo nega il gruppo stesso (vedi gruppi)

let testo = 'Espressioni regolari!';
let regex = /^../;
// Trova i primi due caratteri

$

Il dollaro identifica la fine di una riga

let testo = 'Espressioni regolari!';
let regex = /..$/;
// Trova gli ultimi due caratteri

( )

Le parentesi tonde identificano dei gruppi di caratteri

|

Il pipe è una condizione OR da inserire in un gruppo

let testo = 'Espressioni regolari!';
let regex = /r(a|i|u|o|e)/g;
// Trova tutte le lettere r seguite da una vocale

[ ]

Le parentesi quadrate identificano intervalli e classi di caratteri

\

La barra (backslash) annulla gli effetti del metacarattere successivo

let testo = 'Espressioni . regolari!';
let regex = /\./;
// Trova solo il punto

I Quantificatori

I quantificatori, come dice il termine stesso, indicano quante volte ricercare una data sequenza di caratteri.

Q.re

Descrizione

Esempio

+

Indica 1 o più occorrenze

let testo = 'Espressioni, pesi, piume';
let regex = /s+i/g;
// Troverà tutte le i precedute da 1 o più s

*

Indica 0 o più occorrenze

let testo = 'Espressioni, pesi, piume';
let regex = /s*i/g;
// Troverà tutte le i precedute da 0 o più s

?

Indica 1 o 0 occorrenze

let testo = 'Espressioni, pesi, piume';
let regex = /s?i/g;
// Troverà tutte le i precedute da 0 o 1 s

{n}

Ricerca esattamente n occorrenze, dove n è un numero intero; Da ricordare che le parentesi graffe vengono considerate caratteri normali in tutti gli altri contesti

let testo = 'ese, esse, essse, esssse!';
let regex = /es{2}e/g;
// Troverà solamente la parola esse

{n,}

Ricerca un minimo di n occorrenze, vedi sopra;

let testo = 'ese, esse, essse, esssse!';
let regex = /es{2,}e/g;
// Troverà le parole che iniziano e finiscono con e e che contengono 2 o più s

{n,m}

Ricerca tra le n e le m occorrenze, vedi sopra

let testo = 'ese, esse, essse, esssse!';
let regex = /es{2,3}e/g;
// Troverà le parole che iniziano e finiscono con e e che contengono 2 o 3 s

I quantificatori ungreedy
(ovvero… non golosi)

Quasi tutti inciampano prima o poi in questo problema: se utilizzo una espressione del tipo /"(.*)"/ troverò tutte le parole racchiuse tra doppi apici? Purtroppo no!

Questo perché i quantificatori normali sono “golosi” (in inglese greedy), cioè cercano sempre l’occorrenza il più grande possibile.
Vediamo con un esempio:

// Voglio cercare tutte le parole racchiuse da doppi apici
var testo = '"Pluto" è un cane come "Pippo"';
var regex = /"(.*)"/g
// WTF? Non proprio il risultato sperato, vero?

WTF? Come vedete non è il risultato sperato! Come fare quindi?
Basta aggiungere un ? (punto interrogativo) subito dopo i quantificatori:

// Voglio cercare tutte le parole racchiuse da doppi apici
var testo = '"Pluto" è un cane come "Pippo"';
var regex = /"(.*?)"/g
// Magic!

Ovviamente questo vale per qualsiasi quantificatore descritto in precedenza!

È inoltre possibile specificare il modificatore U alla fine della nostra espressione regolare per indicare che tutti i quantificatori sono da considerarsi ungreedy.

Le classi e gli intervalli

Le classi determinano un elenco di caratteri, di classi di caratteri o di POSIX (vedi la sezione successiva) da ricercare. Vengono racchiusi tra parentesi quadre e possono essere seguiti dai quantificatori.

var testo = 'Questa è una stringa lunga lunga di esempio';
var regex = /[aiuoe]{2}/g
// Troverà due vocali consecutive nella stringa

Per identificare un intervallo invece si utilizza il segno - (trattino alto). Per esempio a-z identificherà tutti i caratteri minuscoli dalla a alla z, F-R i caratteri maiuscoli dalla F alla R, 0-5 i numeri da 0 a 5 e così via.

var testo = 'Un codice aa12bb ed un colore esadecimale 94fa3c';
var regex = /[0-9a-f]{6}/g
// Troverà 6 caratteri che siano numeri o lettere dalla a alla f

Il carattere ^ posto subito dopo la parentesi quadra aperta nega tutto l’intervallo, cioè indica di non ricercare i caratteri inclusi.

var testo = 'Questa è una stringa lunga lunga di esempio';
var regex = /[^aiuoe ]{3}/g
// Troverà 3 caratteri minuscoli che non siano vocali o spazi

Le classi di caratteri e i POSIX

Le classi di caratteri e i POSIX servono per specificare una serie di caratteri allo stesso tempo, senza dover scomodare gli intervalli.
Da ricordarsi che i POSIX in JavaScript non sono implementati, mentre in PHP devono essere racchiusi da una doppia parentesi quadra.

Classe

Posix

Corrisponde a

Descrizione

Esempio

\w

[:word:]

[a-zA-Z0-9_]

Ricerca un carattere “parola” (w sta per word), cioè lettere, numeri e “_”

var testo = '[[Le_Regex sono_belle!!!]]';
var regex = /\w+/g;
// Troverà solo i caratteri word

\W

[^a-zA-Z0-9_]

L’opposto di \w, cioè qualsiasi cosa che non sia una lettera, numero o “_”

var testo = '[[Le_Regex sono_belle!!!]]';
var regex = /\W+/g;
// Troverà solo i caratteri non word

\d

[:digit:]

[0-9]

Ricerca un numero (d sta per digit)

var testo = '123 stella! 456 cometa!';
var regex = /\d+/g;
// Troverà solo i numeri

\D

[^0-9]

L’opposto di \d, cioè qualsiasi cosa che non sia un numero

var testo = '123 stella! 456 cometa!';
var regex = /\D+/g;
// Troverà tutto quello che non è numero...
// Anche gli spazi!

\s

[:space:]

[ \t\r\n\v\f]

Ricerca uno spazio, comprese tabulazioni e caratteri di fine riga

var testo = `Manuale	sulle 
	espressioni   regolari!`;
var regex = /\s+/g;
var replace = '*';
// Sostituirà tutti gli spazi con *

\S

[^ \t\r\n\v\f]

L’inverso di \s, ricerca qualsiasi cosa non sia uno spazio, una tabulazione o dei caratteri di fine riga

var testo = "Questa è una !frase_lunga!";
var regex = /\S+/g;
// Troverà tutte le parole separate da spazi

[:alnum:]

[a-zA-Z0-9]

Ricerca caratteri alfanumerici, senza “_”, non implementato in JavaScript

[:alpha:]

[a-zA-Z]

Ricerca caratteri alfabetici, non implementato in JavaScript

[:blank:]

[ \t]

Ricerca solo spazi e tabulazioni, non implementato in JavaScript

[:lower:]

[a-z]

Ricerca solo lettere minuscole, non implementato in JavaScript

[:upper:]

[A-Z]

Ricerca solo lettere maiuscole, non implementato in JavaScript

[:graph:]

[\x21-x7E]

Ricerca tutti i caratteri visibili a video della tabella ASCII non estesa, dal numero 33 (!) al 126 (~), non implementato in JavaScript

[:print:]

[\x20-x7E]

Ricerca tutti i caratteri visibili a video della tabella ASCII non estesa, dal numero 32 (spazio) al 126 (~), non implementato in JavaScript

[:punct:]

[\-!”#\$%&’\(\)*+,\.\\/:;<=>\?@\[\]\^_`{\|}~]

Ricerca tutti i caratteri di punteggiatura, non implementato in JavaScript

I modificatori

Ogni operazione di ricerca può utilizzare vari modificatori, che, come dice il nome stesso, possono modificare i criteri di ricerca predefiniti.
Questi modificatori devono essere posizionati alla fine della stringa di ricerca, subito dopo il carattere di limitazione.
È possibile combinare più effetti accodando senza spazi i modificatori (per esempio: /im applicherà tutti e due gli effetti sotto descritti).

Mod.

Descrizione

Esempio

g

In JavaScript indica una ricerca “globale”, cioè non si ferma solo alla prima corrispondenza

var testo = 'E uno, due tre e quattro! ';
var regex = /[a-zA-Z]{3,}/g;
// Troverà tutte le parole di almeno 3 lettere

i

La ricerca diventa case-insensitive, cioè maiuscole e minuscole vengono considerate uguali

var testo = 'Le Espressioni Regolari sono regolari?';
var regex = /regolari/gi;
// Troverà sia Regolari che regolari

m

La ricerca verrà considerata “per riga”, cioè le ancore tipo ^ e $ verranno applicate per ogni riga di testo

var testo = `Questa è una
frase su più righe e una sentenza
con molta fortuna`;
var regex = /una$/gm;
// Troverà sole le "una" a fine riga

s

Il testo viene considerato un’unica riga e . ora identifica anche i caratteri di fine riga, che normalmente non troverebbe

var testo = `Questa è una
frase su più righe e una sentenza
con molta fortuna`;
var regex = /una./gs;
// Troverà tutte le "una" seguite da un carattere

u

Vengono abilitati i caratteri Unicode estesi

var testo = 'Espressioni regolari, 正则表达式, रेग्युलर ऍक्सप्रैशन';
var regex = /\p{sc=Han}/gu;

U

Attiva l’opzione ungreedy a tutti i quantificatori, non applicabile in JavaScript

Le ancore

Le ancore identificano la posizione in cui ricercare il testo.

Descrizione

Esempio

^

Identifica l’inizio della stringa; con il modificatore /m identifica l’inizio di ogni riga

var testo = `Questo è un testo
su più righe`;
var regex = /^\w+/g;
// Troverà la prima parola

$

Identifica la fine della stringa; con il modificatore /m identifica la fine di ogni riga

var testo = `Questo è un testo
su più righe`;
var regex = /\w+$/gm;
// Troverà l'ultima parola di ogni riga 

\A

Similmente a ^, identifica solo l’inizio della stringa, anche se è presente il modificatore /m
Non è presente in JavaScript

\Z

Similmente a $, identifica solo la fine della stringa, anche se è presente il modificatore /m
Non è presente in JavaScript

\b

Indentifica quel punto tra un carattere \w ([a-zA-Z0-9_]) ed uno che non lo è. Il punto non ha lunghezza e può indentificare anche l’inizio o la fine della stringa.

Per esempio troverà il punto tra una lettera ed un simbolo ma non il punto tra una lettera ed un’altra lettera.

È un concetto un po’ complicato, per questo è meglio chiarirlo con 3 esempi 🙂

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\bsi/g;
// troverà solo le parole che iniziano per "si"
var testo = 'si, è simpatico e positivo in certi casi';
var regex = /si\b/g;
// troverà solo le parole che finiscono per "si"
var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\bsi\b/g;
// troverà solo i "si" non all'interno di altre parole

\B

L’opposto di \b, in pratica identifica quel punto tra due caratteri \w oppure tra due caratteri non \w.

Per esempio troverà il punto tra due lettere oppure il punto tra due simboli.

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\Bsi/g;
// troverà solo i "si" preceduti da una lettera
var testo = 'si, è simpatico e positivo in certi casi';
var regex = /si\B/g;
// troverà solo i "si" seguiti da una lettera
var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\Bsi\B/g;
// troverà solo i "si" all'interno di una parola

I caratteri speciali

Chi ha un po’ di conoscenza di programmazione avrà già avuto a che fare con quei segnaposto che identificano dei caratteri speciali, come quelli di fine riga o le tabulazioni. Tali segnaposto iniziano tutti con il carattere \ (barra)
Ecco un elenco molto più che dettagliato, da sottolineare l’importanza di \Q e \E, purtroppo non implementati in javaScript.

Descrizione

\t

Carattere di tabulazione (HT, TAB), il tasto sulla tastiera

\n

Carattere di fine riga (LF, LN)

\r

Carattere di ritorno a capo (CR)

\Q

disabilita qualsiasi metacarattere presente fino a \E, molto utile per inserire delle variabili nella stringa. Non implementato in javascript

\E

Vedi sopra. Non implementato in javascript

\nnn

Carattere in forma ottale dove n è un numero da 0 a 7

\xnn

Carattere in forma esadecimale dove n è un numero esadecimale [a-z0-9]

\f

Carattere di Form feed (FF)

\a

Carattere di alarm/bell (BEL)

\e

Carattere di escape (ESC)

I gruppi

I gruppi vengono racchiusi dalle parentesi tonde e diventano essenziali nel momento della sostituzione, poiché è possibile richiamarli. Un esempio per chiarire tutto:

var testo = 'Questo è una data: 2010-01-28'; // data in formato anno-mese-giorno
var regex = /(\d{4})-(\d{2})-(\d{2})/g;
var replace = '$3/$2/$1'
// Ora il testo avrà la data in formato giorno/mese/anno

Come vedete l’espressione contiene tre gruppi e nella sostituzione compaiono dei dollari seguiti da un numero: questo numero rappresenta il testo trovato dal gruppo corrispondente. Così $1 identificherà il primo gruppo, $2 il secondo e così via.

In alcuni linguaggi è possibile utilizzare \1 e \2 invece che $1 e $2, ma ve lo sconsiglio in quanto le barre dentro una stringa devono essere precedute da un’altra barra e questo rende tutto meno leggibile.

Molto utile invece è la possibilità di dare dei nomi ai gruppi, così da evitare fraintendimenti con i numeri od errori in caso di spostamenti o creazioni di nuovi gruppi. Per fare questo basta aggiungere ?<nome> subito dopo l’apertura della parentesi e richiamarli con $<nome>:

var testo = 'Questo è una data: 2010-01-28'; // data in formato anno-mese-giorno
var regex = /(?<anno>\d{4})-(?<mese>\d{2})-(?<giorno>\d{2})/g;
var replace = '$<giorno>/$<mese>/$<anno>'
// Ora il testo avrà la data in formato giorno/mese/anno

Nei gruppi inoltre è possibile aggiungere un’espressione logica “OR”, cioè poter ricercare una serie di caratteri oppure un’altra:

var testo = 'In italiano si può dire sia aveva piovuto o era piovuto!'; 
var regex = /\b((aveva|era) piovuto)\b/g;
// L'espressione cercherà "ha piovuto" oppure "è piovuto"

Questa funzione ritornerà sia aveva piovuto che era piovuto; ma fate attenzione, poiché anche in questo caso le parentesi tonde rappresentano un gruppo e quindi verrà considerato nelle variabili di sostituzione, in questo caso $1 conterrà aveva piovuto, $2 conterrà aveva, $3 era piovuto e in $4 era.
Qui non sembra un problema, ma nelle espressioni più complesse ricercare cose non necessarie complica orrendamente le cose. Come fare allora? Basta utilizzare i gruppi passivi, aggiungendo un ?: subito dopo la parentesi tonda aperta:

var testo = 'In italiano si può dire sia aveva piovuto o era piovuto!'; 
var regex = /\b((?:aveva|era) piovuto)\b/g;
// L'espressione cercherà "ha piovuto" oppure "è piovuto" senza raggruppare "aveva" e "era"

Se analizzate il risultato ora conterrà solamente “aveva piovuto” e “era piovuto”.

Le asserzioni

Ho lasciato appositamente per ultime le asserzioni, visto che la maggior parte delle persone ha molta difficoltà ad assimilarle. Però una volta imparate le userete spesso e volentieri!

Esponiamo un problema: è possibile ricercare solo quelle parole che iniziano con la lettera “c” ma che la seconda lettera non sia una vocale? Certo, basta utilizzare le asserzioni!

In pratica sono degli elementi di controllo che vengono applicati alle nostre ricerche.
Inoltre tutte le asserzioni sono passive, cioè, come spiegato prima nei gruppi, non vengono aggiunte fra le variabili di ricerca.

È un po’ complicato da spiegare, ma vedrete che con gli esempi qui sotto tutto risulterà più chiaro!

Asserzione

Descrizione

Esempio

(?=cond)

asserzione lookahead positiva, cioè valida l’espressione precedente solo se la condizione cond è verificata.

var testo = "cane crotalo canarino criceto cervo";
var regex = /\b(c(?=[aiuoe])\w+)/g;
// L'espressione cercherà le parole che iniziano con la c 
// solo se sono seguite da una vocale

(?!cond)

asserzione lookahead negativa, cioè valida l’espressione precedente solo se la condizione cond non è verificata.

var testo = "cane crotalo canarino criceto cervo";
var regex = /\b(c(?![aiuoe])\w+)/g;
// L'espressione cercherà le parole che iniziano con la c 
// solo se non sono seguite da una vocale

(?<=cond)

asserzione lookbehind positiva, cioè valida l’espressione successiva solo se la condizione cond è verificata.

var testo = "cesto pasto fasto pesto costo";
var regex = /(\w+(?<=a)sto)/g;
// L'espressione cercherà le parole che finiscono con sto
// solo se la lettera precendente è una a

(?<!cond)

asserzione lookbehind negativa, cioè valida l’espressione successiva solo se la condizione cond non è verificata.

var testo = "cesto pasto fasto pesto costo";
var regex = /(\w+(?<!a)sto)/g;
// L'espressione cercherà le parole che finiscono con sto
// solo se la lettera precendente non è una a

(?>cond)

sottoespressione indipendente, cioè l’espressione viene considerata singolarmente senza considerare altre cose. Non disponibile in javaScript

In questi esempi ho fatto delle asserzioni solamente su dei caratteri, ma è possibile utilizzarle anche su interi gruppi!

Conclusioni

Bene, ora avete una infarinatura sulle espressioni regolari!
Per creare e testare la vostra regex potete utilizzare il servizio offerto da regex101.com, il quale vi mostra il risultato della vostra espressione al volo con pure la descrizione 🙂 (esempio)

In futuro aggiornerò questa guida aggiungendo esempi e nuove descrizioni, quindi vi consiglio di aggiungerla ai preferiti!
Ovviamente se avete cose da aggiungere potete farlo nei commenti!

Ultimo aggiornamento: 02/05/2021


Dominio sospeso. Come fare?

Se il tuo domino improvvisamente non funziona e i suoi nameserver puntano a “ns1.verification-hold.suspended-domain.com” significa che il tuo dominio è stato sospeso direttamente dal registry perché non hai verificato l’indirizzo email associato al dominio.

L’ICANN obbliga i nuovi domini a verificare l’indirizzo email fornito entro 15 giorni dalla data di acquisto inviando una email di conferma.

Quindi per rimuovere la sospensione basta trovare la email, aprirla e cliccare sul link incluso e la sospensione verrà immediatamente rimossa.

Bisognerà quindi attendere la propagazione dei DNS per poter visualizzare nuovamente il proprio dominio.

Immagine di loading… senza immagine: spin.js

Un bel modo per generare una immagine di caricamento generata automaticamente da javascript: spin.js.

Ecco l’elenco delle caratterisitche:

  • Nessuna immagine o CSS da aggiungere
  • Nessuna dipendeza (jQuery è supportato ma non è richiesto)
  • Facile da configuare
  • Funziona con tutti  i maggiori browser, anche il pessimo IE6

 

Come aggiornare la cache del browser

Quando capita di dover dire ad una persona “Cancella la cache del browser” risulta un problema dover spiegare l’operazione se tale persona non ha la più pallida idea di come si faccia.

Dopo 20 o 30 volte che ciò accade risulta un po’ noioso dover rispiegare gli stessi concetti sempre alla stessa maniera, per cui pensavo di risolvere il problema cercando una pagina dove poter ridirigere la spiegazione.

Purtroppo però ho constatato che non esiste in italiano una guida completa e semplice che descrivi chiaramente il procedimento anche ad una persona estremamente neofita.
Quindi ho deciso di crearne io 🙂

Per prima cosa bisogna Leggi tutto “Come aggiornare la cache del browser”

Periferica USB non riconosciuta – Soluzioni banali

Avete appena acceso il vostro PC, magari mentre state sorseggiando una tazza di buon the, quando vi appare una piccola notifica in basso a destra vicino all’orologio.

Sulle prime non ci badate, pensate solo ad un qualche errore innocuo o inutile…

Ma quando vi accorgete che l’errore è:

Il dispositivo ha riportato un problema ed è stato interrotto (Codice 43)

Un terribile sospetto entra nelle vostre teste: “Oddio la chiavetta!” o un ben più agghiacciante: “Il disco fisso esterno?”

Magari non è nulla, pensate. Ma quando entrate nell’esplora risorse e non vedete la vostra amata periferica ripiena di documenti importantissimi e foto uniche, arriva l’angoscia. È tutto irrimediabilmente PERSO ?

Corri a cercare soluzioni su internet, aggiornare driver, invocare santi…

STOP. FERMATEVI.

Prima di iniziare procedure complicate ed enigmatiche, provate queste semplici procedure:

  1. riavviate;
  2. controllate che la presa USB sia correttamente inserita;
  3. se è presente un alimentatore esterno, controllate che sia acceso e collegato correttamente;
  4. provate a cambiare porta usb;
  5. se la periferica è collegata tramite un cavo USB, provate a sostituirlo con un altro;

Sono troppo banali?  Si.
Ma in buona parte dei casi risolvono il problema, come me l’hanno risolto a me questa sera: è bastato sostituire un malefico cavetto USB!

Avete risolto?
Se si, ora correte subito a farvi un buckup dei vostri dati (se non lo avete).

Altrimenti…
Impanicatevi pure e cercate qualche altra soluzione! 😀

Area admin di wordpress lenta? Problema risolto!

Da giorni stavo combattendo con un problema che mi stava assillando su wordpress 3.0.1:

La lentezza dell’area amministrazione per quanto concerne le pagine.

Per lentezza intendo un caricamento della pagina wp-admin/edit.php?post_type=page di più di un minuto!

Pensavo che il problema fosse la mole di pagine (più di 4000) o un limite intrinseco di wordpress, ma cercando in rete ho scoperto che non ero l’unico ad averlo…

Ho seguito mille suggerimenti, dall’ottimizzazione delle tabelle alla disattivazione dei pingback, ma nulla… L’unica cosa che mi restava da fare era dare un occhio ai sorgenti di wordpress…

Tra commenti e die() vari finalmente ho scoperto cosa rendeva lento il caricamento: la funzione inline_edit_row !

Cioè quella che permette l’editing veloce delle pagine direttamente sulla lista delle stesse.

Commentando il richiamo alla funzione in wp-admin/edit.php (nelle ultime righe) il problema scompare e il caricamento risulta moooooooooooooooooooooolto più veloce!

P.S.

Non usate MAI wordpress come CMS se non ne avete veramente bisogno !!!

Controllo validazione email con php seguendo le specifiche RFC

validazione.email

Rileggendo il mio post precedente sulla validazione email tramite javascript e considerando il fatto che non sono riuscito a trovare una funzione equivalente in PHP, ho pensato di convertire la funzione io stesso.
I passaggi sono stati pochi, poiché le espressioni regolari non cambiano più di tanto tra javascript e perl.

Leggi tutto “Controllo validazione email con php seguendo le specifiche RFC”

Controllo validazione email con javascript anche con i nuovi domini accentati

validazione.email
Sempre la solita solfa!

Come fare a validare un indirizzo email con javascript?

La risposta quasi sempre è una questa semplice funzioncina:

function validEmail(email){
  return  /^([a-zA-Z0-9_.-])+@([a-zA-Z0-9_.-])+.([a-zA-Z])+([a-zA-Z])+/.test(email);
}

Bene… questa è sbagliata!!! Non riesce a validare alcuni indirizzi email! non ci credete? Leggi tutto “Controllo validazione email con javascript anche con i nuovi domini accentati”

Come eseguire uno script all’uscita della pagina

onunload

Uscire da questa pagina?
Premere OK per continuare o Annulla per rimanere nella pagina corrente.

Quante volte abbiamo visto questo messaggio mentre cercavamo di uscire da una pagina?
Non so voi, ma io molte 🙂

In questo articolo parleremo di come aggiungere e personalizzare questo messaggio, rendendolo il meno intrusivo possibile.

Innanzi tutto, a cosa serve?

Leggi tutto “Come eseguire uno script all’uscita della pagina”

Come effettuare backup di database mysql (Importazione ed Esportazione)

esportazione.mysql

Il metodo più semplice che si può utilizzare per un backup di MySQL è tramite phpMyAdmin oppure Navicat, un paio di click e si ha il proprio backup sul proprio disco fisso.

Il problema nasce quando il database in questione è di notevoli dimensioni. Tali processi possono durare decine di minuti, occupando tempo, banda e fegato 🙂

Infatti phpMyAdmin tende ad usare molta CPU e non ha nessun riscontro visivo, il che fa impazientire anche i più calmi. Inoltre se per sbaglio non mettiamo l’opzione “Scarica il file compresso” (succede molto spesso) phpMyAdmin ci mostrerà a video tutte le query, occupando una miriade di RAM del nostro PC e nella maggior parte dei casi crashando il nostro browser e quindi rendendo inutile tutto il tempo perso. Leggi tutto “Come effettuare backup di database mysql (Importazione ed Esportazione)”