A un certo punto, però, vi accorgete che nel pc degli utenti il vostro sito risente in alcuni casi dei rallentamenti. Quello che per voi era un codice «perfetto» (una parola che non si dovrebbe mai usare nella programmazione) in realtà ha degli scogli che gli utenti si trovano a dover aggirare.

Provate a immaginare un ecommerce complesso: centinaia di prodotti nello store e migliaia di query processate ogni giorno; se il sito è visitato, le pagine aperte dall’utente possono essere decine. Con il tempo sempre più agli sgoccioli in quest’Era moderna, l’utente non ha la pazienza per aspettare che una pagina pesante si carichi del tutto o che la sua adsl (se la possiede) superi i blocchi di linea che ogni tanto si presentano in Italia.
Nella peggiore delle ipotesi, potrebbe decidere di abbandonare il sito e cercare un altro negozio online.

C’è altro che possiamo fare per velocizzare l’apertura delle pagine del nostro sito?
La risposta, naturalmente, è affermativa: c’è sempre qualcosa da imparare e da migliorare.
In questo articolo vi propongo alcuni spunti di sbocco e alcune accortezze da seguire per ridurre al minimo i tempi di caricamento della pagina lato utente.

Teniamo presente, comunque, che esistono online ottimi strumenti per monitorare la velocità delle nostre pagine e capire dove mettere le mani per migliorare. Uno di questi strumenti è il Page Speed di Google: basta inserire l’url del sito e avrete una lista di “problemi” che stanno indigesti al più grande motore di ricerca e che pertanto dovrebbero essere risolti il prima possibile.

Accortezze generali

Prima di entrare in “fase avanzata”, vediamo qualche linea di base da seguire nella costruzione di un qualsiasi sito internet. Se avete qualche anno di esperienza nel settore probabilmente avrete già evaso tutti o quasi i seguenti punti, ma una ripassata non fa mai male.
Cito i punti senza addentrarmi nella questione, perché potete facilmente informarvi con una ricerca online.

– Usare i CSS Sprites per le immagini, ovvero combinare le immagini di sfondo in un’unica immagine e usare le direttive “background-image” e “background-position” per mostrare il segmento voluto.

– Usare un sistema di caching (vedi sotto).

– Usare la compressione delle pagine (vedi sotto).

– Mettere i fogli di stile in alto nella pagina: in questo modo le pagine si renderizzano progressivamente.

– Quando possibile, mettere i javascript in basso nella pagina.

– Quando possibile, evitare stili in linea e javascript nella pagina: meglio caricare css e javascript da file esterni.

– Quando possibile, evitare i redirect 301 e 302.

– Nelle chiamate Ajax al di sotto dei 2K di dati, usare GET anziché POST: con i POST, infatti, prima invia l’header e poi i dati; invece con i GET invia un unico pacchetto.

– Ridurre il più possibile le dimensioni dei cookies.

Htaccess e html – Abilitare il caching delle pagine

Abilitando il sistema di headers caching, se un utente torna a visitare il nostro sito eviterà di scaricare di nuovo le risorse – con ovvio incremento di prestazioni e di velocità.
Il sistema di caching andrebbe applicato a tutti gli elementi statici: immagini, js, css, pdf, media files, ecc.

La cosa migliore è settare il tempo di “Expires”, cioè il periodo dopo il quale le risorse vengono di nuovo scaricate, da un minimo di una settimana a un massimo di un anno (oltre un anno non è consigliabile).

Impostando il tempo nei metatag “Expires” oppure “Cache-Control: max-age”, il browser eviterà di controllare nel web server la disponibilità di nuove versioni dell’elemento.

Con il seguente metatag si abiliterà il caching delle pagine:

1

<meta http-equiv="Cache-control" content="public">

Il valore “public” significa che le risorse saranno messe in una cache pubblica. All’occorrenza il valore può essere sostituito con “private” (=cache privata) oppure “no-cache” (=la pagina non viene messa in cache).

Entriamo più nello specifico.
Copiate il seguente codice nell’htaccess: in questo modo si abiliterà l’expires per gli elementi “statici” della pagina. Nel seguente esempio, dopo 1 settimana (604800 secondi) gli elementi saranno scaricati di nuovo:

1
2
3
4

# caching 1 settimana (in secondi)
<FilesMatch "\.(ico|pdf|flv|jpg|jpeg|png|gif|js|css|swf)$">
Header set Cache-Control "max-age=604800, public"
</FilesMatch>

Compressione delle pagine con php

Nota: i file già compressi non hanno bisogno di compressione, per cui se possibile evitare di comprimere file come mp3, zip, ecc.

Usando un sistema di compressione delle pagine, si può velocizzare (a volte di molto) il tempo di risposta HTTP. L’header “Accept-Econding” supporta la compressione tramite gzip e deflate.
In pratica, grazie a questo header, il browser invia la richiesta “Accept-Encoding: gzip, deflate” e il server risponderà con “Contenet-Encoding: gzip”; se il server non invia questa risposta, allora qualcosa è andato storto.

Gzip è il più efficiente (può ridurre fino al 70% le dimensioni di risposta) rispetto a deflate.

Prima di tutto occorre verificare che il server che ospita il nostro sito supporti la libreria gzip. In PHP basta lanciare il comando phpinfo() e controllare se il modulo “mod_gzip” (la libreria “zlib”) è abilitato.
A questo punto, in ogni nostra pagina e, prima di qualsiasi altro codice, dobbiamo far uso dell’ob_start e dell’ob_gzhandler in modo che richiedano la compressione:

1

ob_start( 'ob_gzhandler' );

Un modo più sicuro è far controllare a php se sia possibile abilitare la compressione; in caso contrario lanciare un comune ob_start:

1
2
3
4
5

if(substr_count($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip')){
	ob_start('ob_gzhandler');
}else{
	ob_start();
}

Subito dopo aver effettuate le modifiche, un modo per testare se il sito ha preso correttamente la compressione è passare il link della pagina a un tool dedicato per questo tipo di monitoraggio. Uno degli strumenti lo mette a disposizione GIDZipTest.

Se il codice è stato correttamente settato, la risposta mostrerà tra gli header il tipo di compressione (voce “content-encoding”).

Comprimere determinati tipi di file con htaccess

In questo caso il server deve avere abilitato il modulo “mod_deflate” (controllate lanciando sempre phpinfo()).
Inserire nell’htaccess i seguenti codici:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# per comprire i file di tipo text, html, javascript, css, xml:
AddOutputFilterByType DEFLATE text/plain
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/xml
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE application/xml
AddOutputFilterByType DEFLATE application/xhtml+xml
AddOutputFilterByType DEFLATE application/rss+xml
AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/x-javascript

# per comprire i file con estensione .html:
<files *.html>
SetOutputFilter DEFLATE
</files>

Faccio una premessa.
Gli articoli che siamo abituati a usare hanno in realtà un «tipo» associato: il tipo “post”. Allo stesso modo, le pagine hanno associato il tipo “page”. Di default troviamo poi altri tre tipi: “attachment”, “revision” e “nav_menu_item”.

WordPress ci dà la possibilità di creare dei nuovi tipi, in pratica delle aree separate in cui possiamo inserire articoli e categorie senza intaccare quelli principali.
Se, per esempio, abbiamo un sito che si occupa di musica e a un certo punto decidiamo di inserire una sezione per i film, ci sarà utile creare una nuova area per i film, i cui articoli saranno tenuti ben distinti da quelli della musica.
I tipi personalizzati vengono denominati tecnicamente Custom Post Type (CPT).

In questo articolo vedremo un esempio completo e minimale su come realizzare i CPT.
Nello specifico, il nostro cliente immaginario ci ha commissionato la realizzazione di un’area per inserire i calendari delle partite di andata e ritorno di una squadra di pallavolo.
Quello di cui abbiamo bisogno è di creare un’area personalizzata chiamata “Calendario”, che si occupa esattamente come un qualsiasi post ma che in lato sito sarà visualizzata in una sezione a parte.

I file completi sono scaricabili gratuitamente al seguente link. All’interno troverete un txt contenente la descrizione generale con i passi da seguire.

Scarica gli script di questo articolo in formato zip

Il plugin “MM Custom Type Calendario” [mm_custom_types.php]

Le basi del CPT le costruiremo attraverso un comodo plugin, che potrà quindi essere esportato facilmente in altri progetti.
Il file “mm_custom_types.php” nello zip va inserito così com’è nella cartella dei plugin di WordPress. Il plugin va poi attivato come al solito nell’apposita area dell’admi.

Vediamo il contenuto del plugin.
Ho cercato di introdurre quanti più parametri possibili nella funzione, così da averli sottomano. Ogni parametro è commentato. In realtà, i valori attributi a gran parte di questi parametri sono quelli di default e quindi potevano essere omessi.
Per personalizzare i parametri vedete la documentazione ufficiale della funzione “register_post_type()” di WordPress (a fondo articolo trovate il link diretto).

Per prima cosa creiamo la funzione crea_calendari(). Sarà questa a definire i parametri per comporre il nostro CPT.
All’interno della funzione richiameremo register_post_type(), facendogli passare il riferimento (“calendario”, che in pratica sarà il nome univoco che identificherà il nostro CPT) e l’array contenente tutti i parametri definiti.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

function crea_calendari(){

    $labels = array(
        'name'               => __('Calendari'), //nome plurale dell'etichetta
        'singular_name'      => __('Calendario'), //nome singolare dell'etichetta
	'menu_name'	     => __('Calendari Menu'), //nome del menu
	'all_items'          => __('Elenco Calendari'), //testo per mostrare tutti gli elementi
        'add_new'            => __('Aggiungi Calendario'), //testo del pulsante di aggiunta nuovo elemento
        'add_new_item'       => __('Nuovo Calendario'), //testo da mostrare quando siamo all'interno di un nuovo elemento
        'edit_item'          => __('Modifica Calendario'), //testo di modifica dell'elemento
        'new_item'           => __('Nuovo Calendario'), //testo del nuovo elemento
        'view_item'          => __('Visualizza Calendario'), //testo di visualizzazione dell'elemento
        'search_items'       => __('Cerca Calendario'), //testo per la ricerca degli elementi
        'not_found'          => __('Calendario non trovato'), //testo quando non esistono elementi nell'elenco
        'not_found_in_trash' => __('Calendario non trovato nel cestino'), //testo quando non esistono elementi nel cestino
    );

    $args = array(
                'labels'             => $labels,
		'description'	     => 'Raccolta dei Calendari', //breve descrizione del post type
                'public'             => true, //se =true, viene visto sia da admin che in front-end
		'exclude_from_search' => false, //se =true gli elementi sono esclusi dalla ricerca front-end
		'publicly_queryable' => true, //indica se possono essere eseguite query lato front-end
		'show_ui'		=> true, //se =false, in admin non sarà mostrare l'interfaccia per la gestione del post type
		'show_in_nav_menus'	 => true, //indica se il post type può essere inserito nel nav menu
		'show_in_admin_bar'	 => true, //se =false, il post type non viene mostrato nel menu superiore "Nuovo" dell'admin

		//indica la posizione nei confronti degli altri elementi nel menu dell'admin.
		// 5 = sotto a Posts; 10 = a Media; 15 = a Links; 20 = a Pages; 25 = a Comments; 60 = al primo separatore;
		// 65 = a Plugins; 70 = a Users; 75 = a Tools; 80 = a Settings; 100 = al secondo separatore
		'menu_position'      => 5,

		'hierarchical'       => false, //indica se il post type ha un genitore (in genere usato solo per le pagine)

		//indica i valori del add_post_type_support() , ovvero quali elementi standard associare al post type
                'supports'      => array(
                                'title',
                                'editor',
                                'thumbnail',
				'excerpt'
                                ),

		//indica quali taxonomies associare al post type
		//il seguente, per esempio, permette di inserire categorie a cui associare i post type
		//in mancanza non sarà possibile creare categorie di post
		'taxonomies'		 => array('category'),

		'has_archive'        => true, //abilita la pagina di archivio per il post type

		//permette di riscrivere alcuni parametri per il post type, che altrimenti sarebbero uguali a quelli standard
		//
		'rewrite'            => array(
					'slug' => 'calendari' //il post type è raggiungibile all'indirizzo "mio_sito.it/calendari"
					)
    );

	//registra l'elemento "calendario" come post type, con gli argomenti definiti sopra
	register_post_type('calendario', $args);

}

La nostra funzione sarà poi inizializzata con questa riga:

1

add_action('init', 'crea_calendari');

Una volta attivato il plugin, nel menu laterale dell’admin avremo una nuova area: “Calendari Menu”. Da qui sarà possibile visualizzare l’elenco dei calendari, aggiungere un nuovo calendario e associare a ognuno di essi una categoria da creare. Proprio come nei normali post.

Visualizzare la pagina nel front-end : creare il link nel menu

A questo punto possiamo gestire tutto in lato amministrazione, ma in lato front-end non abbiamo ancora una struttura adatta. Infatti, dobbiamo manipolare il “single.php” e il “archive.php” perché visualizzino i nostri CPT e non i soliti post.

Innanzitutto, dobbiamo creare un link per permettere all’utente di raggiungere la nostra area CPT, che nel nostro caso sarà “mio_sito.it/calendari”.
Nell’admin entrate in “Aspetto => Menu”. Si presume che abbiate un’idea di dove ci troviamo e di come si gestiscono i menu in WordPress (se non è così vi consiglio di provare a smanettare: è piuttosto intuitivo; quest’area permette infatti di creare a piacere un menu di navigazione da mostrare in lato front-end).
Nello spazio “link” a sinistra, aggiungete al vosto menu l’url “mio_sito.it/calendari” e il nome “Calendari”. Ricordate di salvare le modifiche.

Single-calendario.php e Archive-calendario.php

Passiamo adesso a creare i nuovi file.
Quello che dobbiamo fare è creare una nuova versione di “single.php” e “archive.php”, aggiungendo al loro nome il suffisso “-calendario” (in pratica creeremo “single-calendario.php” e “archive-calendario.php”).

Nello zip troverete due file: “single-calendario.php” e “archive-calendario.php”. Non dovrete fare altro che copiarli nella cartella del vostro tema.
Da notare il suffisso di entrambi i file, “-calendario”, che è lo stesso nome con cui abbiamo registrato il nostro CPT. In pratica, WordPress riconoscerà automaticamente che questi due file sono rispettivamente il single e l’archive da usare per il nostro CPT.

Come li ho creati?
Semplicemente, ho preso esattamente il contenuto di “single.php” e l’ho copiato in “single-calendario.php” (nota: nel mio caso faccio riferimento al tema “twentyfourteen” messo in dotazione durante l’installazione di WordPress: in base al tema che voi usate, il contenuto del single potrebbe variare leggermente).
Dopodiché, ho aggiunto queste righe subito prima del ciclo che stampa gli articoli:

1
2
3
4
5
6

$args = array(      
	'post_type' => 'calendario',
	'post__in' => array(get_the_ID()), 
	'posts_per_page' => 1
);
query_posts($args);

In pratica sto dicendo a WordPress: «Prendi tutti gli articoli di tipo “calendario” e stampami solo quello con id del post attuale».
Questo perché ci troviamo all’interno di un articolo e quello che ci serve è estrarre e stampare le informazioni di quell’articolo.

Allo stesso modo, ho creato “archive-calendario.php” copiandolo da “archive.php” e aggiungendogli questa query iniziale:

1
2
3
4
5

$args = array(      
	'post_type' => 'calendario',
	'posts_per_page' => 10
);
query_posts($args);

In questo caso specifico a WordPress di prendere tutti gli articoli di tipo “calendario” e di stamparmi nella pagina solo i primi 10.

Note di chiarezza conclusive

Come abbiamo capito, la particolarità di WordPress è che leggerà automaticamente la presenza di un nuovo “single-{nome_custom}.php” e “archive-{nome_custom}.php”, dove a {nome_custom} dobbiamo inserire il nome del nostro CPT.

Entrando più nello specifico, quando nel front-end cliccheremo sul link “mio_sito.php/calendari” finiremo nella pagina di “archive-calendario.php”, che conterrà l’elenco dei primi 10 articoli-calendario.
Se cliccherete su uno degli articoli, verrete indirizzati alla pagina “single-calendario.php”, che mostrerà le informazioni del singolo articolo.

Naturalmente il contenuto di “single-calendario.php” e “archive-calendario.php” potrete personalizzarlo a piacere, a seconda delle vostre competenze nell’uso del codice php e di WordPress.

Per avere un’idea sul campo di cosa stiamo parlando, provate a creare alcuni articoli e vedete cosa accade quando visitere la pagina “mio_sito.php/calendari”.

I Post Type e i Custom Post Type sul codex ufficiale di WordPress

La funzione register_post_type sul codex ufficiale di WordPress

Con la funzione che andiamo a vedere, basta creare un array di parole: lo script si occuperà di rintracciarle nel testo e di sostituirle con un’altra parola data.
Se la parola di sostituzione non è stata passata, le stringhe da “eliminare” saranno semplicemente censurate da una serie di cancelletti (“#”).

Lo script, completo di esempio, è liberamente scaricabile dal link qui sotto.
Non necessita di modifiche, a meno che non la vogliate integrare con ulteriori controlli sui parametri (che per semplicità ho ridotto al minimo).

Scarica gli script di questo articolo in formato zip

La funzione di sostituzione stringa

La funzione permette il passaggio di due parametri e di un terzo opzionale.

$string è il testo da analizzare, dove presumibilmente potrebbero trovarsi le parole da censurare.

$bad_words è l’ array contenente le stringhe da convertire.

$new_string è la stringa con cui le parole da censurare saranno convertite. E’ un parametro opzionale: se non passato, le stringhe di $bad_words saranno semplicemente oscurate con # (uno per carattere).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

function replace_words( $string = '', $bad_words, $new_string = '' ){

	//controllo di sicurezza: $bad_words deve essere un array
	if(!is_array($bad_words)){
		return $string;
	}

	$string = ' '.$string.' ';

	//delimitatori per caratteri non Unicode
	$delimiter = '[-_\'\"`(){}<>\[\]|!?@#%&,.:;^~*+=\/ 0-9\n\r\t]';

	foreach($bad_words as $value){

		//stringhe sostituite da un'altra stringa
		if($new_string != ''){
			$string = preg_replace("/({$delimiter})(".str_replace('\*', '\w*?', preg_quote($value, '/')).")({$delimiter})/i", "\\1{$new_string}\\3", $string);

		//caratteri sostituiti con #	
		}else{
			$string = preg_replace("/({$delimiter})(".str_replace('\*', '\w*?', preg_quote($value, '/')).")({$delimiter})/ie", "'\\1'.str_repeat('#', strlen('\\2')).'\\3'", $string);

		}

	}

	return trim($string);

}

Esempio d’uso

Di seguito prendiamo come esempio un testo generico, un array di due parole da censurare e una breve stringa con cui sostituire le parole:

1
2
3

$text = "Qualunque bug sufficientemente avanzato è indistinguibile da una caratteristica del software.";
$no_words = array('sufficientemente', 'indistinguibile');
$string = ' [eliminata] ';

Ogni occorrenza di «sufficientemente» e di «indistinguibile» sarà sostituira con « [eliminata] » (notare spazi laterali compresi).

I risultati saranno i seguenti:

1
2
3
4
5

// " Qualunque bug [eliminata] avanzato è [eliminata] da una caratteristica del software. "
echo replace_words($text, $no_words, $string);

// " Qualunque bug ################ avanzato è ############### da una caratteristica del software. "
echo replace_words($text, $no_words);

In questo articolo vedremo uno script per aggiungere una cartella a un archivio. Ogni sua sottocartella e relativi file saranno aggiunti all’archivio allo stesso modo.
Se l’archivio non esiste già, sarà creato.

Lo script può essere usato così com’è, modificando esclusivamente le variabili:
$dir : cartella di destinazione dell’archivio
$name : nome dell’archivio da creare/leggere
$dir_name : nome della cartella da aggiungere all’archivio

L’archivio zip sarà creato allo stesso livello della cartella da aggiungervi. Naturalmente, con piccole modifiche alle varibili è possibile dargli in pasto qualsiasi percorso.

Scarica gli script di questo articolo in formato zip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

 
/**
* Aggiunge una cartella e le sue sottocartelle e i file contenuti a un archivio
* se l'archivio non esiste, lo crea
*/

//creazione dell'oggetto di classe
$zip = new ZipArchive();

//cartella generale
$dir = "test/zip_example/";

$name = "test_with_subfolders.zip"; //nome dell'archivio
$filename = $dir.$name; //indirizzo completo dell'archivio

$zip->open($filename, ZipArchive::CREATE); 

$dir_name = 'folder_to_add'; //nome della cartella da zippare
$dir_path = $dir.$dir_name; //indirizzo completo della cartella da zippare

if(!is_dir($dir_path)){ 
    throw new Exception('La cartella ' . $dir.$dir_path . ' non esiste'); 
} 

//aggiunge lo slash finale (o corrispettivo) se non presente nel nome cartella
if(substr($dir_path, -1) != DIRECTORY_SEPARATOR){ 
    $dir_path.= DIRECTORY_SEPARATOR; 
} 

$dirStack = array($dir_path); 

//trova l'indice da cui inizia l'ultima cartella
$cutFrom = strrpos(substr($dir_path, 0, -1), '/')+1;

while(!empty($dirStack)){

    $currentDir = array_pop($dirStack); 
    $filesToAdd = array(); 

    $dir_folder = dir($currentDir); 
    while( false !== ($node = $dir_folder->read()) ){ 

        if( ($node == '..') || ($node == '.') ){ 
            continue; 
        } 

        if(is_dir($currentDir . $node)){ 
            array_push($dirStack, $currentDir . $node . '/'); 
        } 

        if(is_file($currentDir . $node)){ 
            $filesToAdd[] = $node; 
        } 

    } 

    $localDir = substr($currentDir, $cutFrom); 
    $zip->addEmptyDir($localDir); 

    foreach($filesToAdd as $file){ 
        $zip->addFile($currentDir . $file, $localDir . $file); 
    } 

} 

$zip->close();

La classe ZipArchive su php.net

Se avete bisogno di leggere un feed rss dotato di una struttura xml abbastanza standard non avrete grandi difficoltà: bastano poche righe di codice.
Nell’esempio che vedremo sotto prenderò in esame i feed rss di www.onemind.it, che hanno una struttura ad albero molto semplice. Per ogni articolo presente, estrarremo e recupereremo link, titolo e descrizione, che potremo immagazzinare in apposite variabili php oppure utilizzare come più ci aggrada.

Naturalmente strutture più complesse richiedono qualche sforzo in più. In genere, comunque, troverete le informazioni di un prodotto internate in un unico nodo xml.
Lo script è scaricabile dal link qui sotto e liberamente personalizzabile.

Scarica gli script di questo articolo in formato zip

Il nodo xml

La struttura base del feed rss sarà qualcosa simile al seguente esempio.
Ogni articolo sarà compreso tra i tag (nodo xml) “item”. Al suo interno troveremo i tag da estrarre: title, link, description.
Per comodità ho eliminato tutti gli altri sotto-nodi non necessari.

1
2
3
4
5
6
7
8
9
10
11
12
13

<item>
<title>
15 immagini sulla Shadow Art: l’arte illusoria con le ombre
</title>
<link>

15 immagini sulla Shadow Art: l’arte illusoria con le ombre 


</link>
<description>
<![CDATA[
La shadow art mescola luce e oggetti comuni, come legni o fili di ferro, per creare opere realistiche fatte di ombra. Gli autori migliori e le loro immagini.
]]>
</description>
</item>

Lo script per il recupero del feed

I commenti dovrebbe bastare per coprire i dubbi. Nella pratica, non facciamo altro che scorrere tutti i tag “item” e recuperare i suoi tag interni, immagazzinandolo in variabili. Da un punto di vista logico, potete identificare il nodo “item” come un array e i suoi tag interni come gli elementi da recuperare.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<?php
//crea un nuovo oggetto XML DOM
$xmldom = new DOMDocument();

//carica il contenuto del feed presente al link indicato
$xmldom->load("https://www.manuelmarangoni.it/onemind/feed/");

//recupera il nodo rappresentato da <item>
$nodo = $xmldom->getElementsByTagName("item");

//scorre tutti i nodi <item> della pagina
for($i=0; $i<=$nodo->length-1; $i++){

	// Estraggo il contenuto dei singoli tag del nodo <item>
	$titolo = $nodo->item($i)->getElementsByTagName("title")->item(0)->childNodes->item(0)->nodeValue;
	$collegamento = $nodo->item($i)->getElementsByTagName("link")->item(0)->childNodes->item(0)->nodeValue;
	$descrizione = $nodo->item($i)->getElementsByTagName("description")->item(0)->childNodes->item(0)->nodeValue;

	// Stampo a video i risultati
	?>
	<p>
		<a href="<?php echo $collegamento;?>"><?php echo $titolo;?></a><br />
		<?php echo $descrizione;?>
	</p>
<?php
}

La seguente funzione prende un testo in entrate e converte tutti i caratteri stranieri in una forma normalizzata (per dirla terra a terra, in una forma più simile all’italiano).
Vi sarà utile anche se gestite un blog con commenti aperti, visto che ormai è usanza sostituire coppie di lettere con caratteri stranieri: pensate per esempio alla “ß” tedesca, che tra i più giovani (per qualche ragione non ben comprensibile, dato lo sforzo per crearla su una tastiera comune) va spesso a sostituire la doppia “s”.

La funzione non è complessa e i commenti dovrebbero essere sufficienti per chiarire i piccoli dubbi.
Tenete presente che la funzione è stata creata per sostituire i caratteri stranieri, ma nulla vieta di aggiungere nell’array altri caratteri da sostituire automaticamente quando si passa il testo (il mio consiglio è sempre quello, però, di separare le funzioni in base al loro scopo).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

function foreign_text_normalize($string = ''){
 
	if(empty($string)){
		return $string;
	}
 
	$return = $string; //stringa da ritornare
 
	//array contenente i caratteri stranieri da convertire
	$foreign_characters = array(
		'ä|æ|ǽ' => 'ae',
		'ö|œ' => 'oe',
		'ü' => 'ue',
		'Ä' => 'Ae',
		'Ü' => 'Ue',
		'Ö' => 'Oe',
		'À|Á|Â|Ã|Ä|Å|Ǻ|Ā|Ă|Ą|Ǎ' => 'A',
		'à|á|â|ã|å|ǻ|ā|ă|ą|ǎ|ª' => 'a',
		'Ç|Ć|Ĉ|Ċ|Č' => 'C',
		'ç|ć|ĉ|ċ|č' => 'c',
		'Ð|Ď|Đ' => 'D',
		'ð|ď|đ' => 'd',
		'È|É|Ê|Ë|Ē|Ĕ|Ė|Ę|Ě' => 'E',
		'è|é|ê|ë|ē|ĕ|ė|ę|ě' => 'e',
		'Ĝ|Ğ|Ġ|Ģ' => 'G',
		'ĝ|ğ|ġ|ģ' => 'g',
		'Ĥ|Ħ' => 'H',
		'ĥ|ħ' => 'h',
		'Ì|Í|Î|Ï|Ĩ|Ī|Ĭ|Ǐ|Į|İ' => 'I',
		'ì|í|î|ï|ĩ|ī|ĭ|ǐ|į|ı' => 'i',
		'Ĵ' => 'J',
		'ĵ' => 'j',
		'Ķ' => 'K',
		'ķ' => 'k',
		'Ĺ|Ļ|Ľ|Ŀ|Ł' => 'L',
		'ĺ|ļ|ľ|ŀ|ł' => 'l',
		'Ñ|Ń|Ņ|Ň' => 'N',
		'ñ|ń|ņ|ň|ʼn' => 'n',
		'Ò|Ó|Ô|Õ|Ō|Ŏ|Ǒ|Ő|Ơ|Ø|Ǿ' => 'O',
		'ò|ó|ô|õ|ō|ŏ|ǒ|ő|ơ|ø|ǿ|º' => 'o',
		'Ŕ|Ŗ|Ř' => 'R',
		'ŕ|ŗ|ř' => 'r',
		'Ś|Ŝ|Ş|Š' => 'S',
		'ś|ŝ|ş|š|ſ' => 's',
		'Ţ|Ť|Ŧ' => 'T',
		'ţ|ť|ŧ' => 't',
		'Ù|Ú|Û|Ũ|Ū|Ŭ|Ů|Ű|Ų|Ư|Ǔ|Ǖ|Ǘ|Ǚ|Ǜ' => 'U',
		'ù|ú|û|ũ|ū|ŭ|ů|ű|ų|ư|ǔ|ǖ|ǘ|ǚ|ǜ' => 'u',
		'Ý|Ÿ|Ŷ' => 'Y',
		'ý|ÿ|ŷ' => 'y',
		'Ŵ' => 'W',
		'ŵ' => 'w',
		'Ź|Ż|Ž' => 'Z',
		'ź|ż|ž' => 'z',
		'Æ|Ǽ' => 'AE',
		'ß'=> 'ss',
		'IJ' => 'IJ',
		'ij' => 'ij',
		'Œ' => 'OE',
		'ƒ' => 'f'
	);
 
	foreach($foreign_characters as $key=>$value){
 
		//suddivido la chiave nei suoi elementi (che sono separati da |)
		$ar = explode('|', $key);
 
		foreach($ar as $value2){
 
			//sostituisce ogni carattere straniero con il suo corrispondente normalizzato
			$return = str_replace($value2, $key, $return);
 
		}
 
	}
 
	return $return;
 
}

Ecco un esempio di utilizzo della funzione:

1
2
3
4
5

$testo= "L'albero del viale non era poi così großo";
$risultato = foreign_text_normalize($testo);
 
//darà come risultato:
//L'albero del viale non era poi così grosso

Anteprima di una Facebook Like Box. Attraverso il sito, permette agli utenti di seguire la vostra fan page su Facebook

Al giorno d’oggi, Facebook è probabilmente il principale canale per promuovere gli articoli di un sito e certamente è il primo “flusso social” da tenere in considerazione. Ecco perché costruire una fan page su Facebook è diventato ormai essenziale.

Vi sarete accorti che molti dei siti dotati di una fan page implementano un plugin particolare: non si tratta del solito pulsante “I like”, ma di un gadget più complesso che permette di visualizzare gli ultimi post della fan page e gli utenti che seguono la vostra pagina.
Inoltre, attraverso questo plugin i visitatori potranno cliccare sul “mi piace” direttamente nel sito, senza cercare la vostra fan page direttamente su Facebook.

Vediamo brevemente come fare. Il processo è semplice e non richiede grandi competenze.

Le opzioni della Facebook Like Box

Prima di tutto raggiungete la pagina degli sviluppatori della Like Box. Vedrete immediatamente un’anteprima generale (la prima immagine di questo articolo).

Le opzioni disponibili per la creazione della Facebook Like Box

Le opzioni a disposizione sono poche e comprensibili. Inserite innanzitutto il link alla vostra pagina Facebook nell’input “Facebook Page URL”. Se non avete particolari esigenze, la larghezza e l’altezza potete lasciarle così come sono (per l’altezza, in default è pensata per far comparire dieci facce-profilo di utenti).

Decidete quindi se volete un tema chiaro (light) o scuro (dark), a seconda del layout del vostro sito.

Le ultime quattro opzioni identificano cosa mostrare:
– Show header : se spuntata mostra l’intestazione del plugin.
– Show stream : se spuntata mostra gli ultimi post pubblicati sulla vostra fan page.
– Show faces : se spuntata mostra le foto profilo degli utenti iscritti alla fan page.
– Show border : se spuntata mantiene un bordo attorno al plugin.

Ottenere il codice

Una volta scelte le opzioni, non vi resta che cliccare sul pulsante “Get Code”.
Si aprirà una finestra che vi permette di scegliere tra quattro tipologie di importazione. Sceglietene una e copiate il codice nel vostro sito come richiesto:

– HTML5 : è la mia scelta consigliata, visto che quasi tutti i siti moderni riescono a supportarlo. In questo caso dovete copiare la prima parte del codice presentato in un qualsiasi punto all’interno del corpo della pagina. La seconda parte, invece, è il codice che effettivamente stamperà il plugin a video, per cui inseritelo dove volete che appaia.

– XFBML : la sigla sta per «eXtended Facebook Markup Language». Come dice il nome, è un linguaggio avanzato, sicuramente migliore dell’alternativa con iframe, visto che permette funzionalità avanzate. Tra le altre cose, attivando l’XFBML avrete l’opportunità di utilizzare l’Open Graph. Per l’attivazione e una spiegazione approfondita dell’XFBML vi rimando all’articolo di Salvatore Capolupo.

– Iframe e URL: l’iframe è un’alternativa che sconsiglio per i motivi visti sopra. In ogni caso questa opzione vi permette di implementare il plugin senza nessuno sforzo, se non il copiare il codice dove voluto all’interno della pagina web.

Il procedimento è molto semplice e si basa sulla grandezza di $number, che viene confrontata prima con i valori più alti e, scalando, con valori sempre più bassi.

Per fare un esempio pratico, poniamo che a $number attribuiamo un valore di 20.971.520 byte (che corrisponde esattamente a 20 megabyte).
I primi due if nella funzione risulteranno falsi, perché $number è inferiore a 1.000.000.000 . Pertanto entreremo nella condizione successiva, quella relativa ai megabyte.
$number sarà convertito in megabyte e assumerà il nuovo valore di “20”.
La funzione quindi stamperà “20 MB”.

Il secondo argomento della funzione, $precision, serve per specificare il grando di precisione del numero risultante, cioè quante cifre dopo la virgola dobbiamo prendere.

Scarica gli script di questo articolo in formato zip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

function byte_convert($number = 0, $precision = 1){

	//il numero passato deve essere intero
	if( !is_numeric($number) ){
		return false;
	}

	$unit = ''; //suffisso dell'unità di misura

	//terabyte
	if($number >= 1000000000000){

		$number = round($number / 1099511627776, $precision);
		$unit = 'TB';

	//gigabyte
	}elseif($number >= 1000000000){

		$number = round($number / 1073741824, $precision);
		$unit = 'GB';

	//megabyte
	}elseif($number >= 1000000){

		$number = round($number / 1048576, $precision);
		$unit = 'MB';

	//kilobyte
	}elseif($number >= 1000){

		$number = round($number / 1024, $precision);
		$unit = 'KB';

	//byte
	}else{

		$unit = 'byte';
		return number_format($number).' '.$unit;

	}

	return number_format($number, $precision).' '.$unit;

}

Vediamo un paio di esempi pratici, che trovate nello script da scaricare:

1
2
3
4
5
6
7

//stampa: 48.7 MB
$byte = 51107725;
echo byte_convert($byte)."<br /><br />";

//stampa: 1.2 KB
$byte = 1179;
echo byte_convert($byte);

La funzione può essere facilmente personalizzata a piacere. Con un po’ di adattamento, per esempio, è possibile stampare a video tutti i formati possibile in base ai byte passati come argomento.

La connessione tra due database non è sempre immediata.
Prima di tutto dobbiamo distinguere due situazioni:
1) i due database si trovano sullo stesso server: in questo caso host, user e password di connessione potrebbero coincidere
2) i due database si trovano su server diversi: è necessario eseguire per forza due connessioni diverse

Qua sotto vi mostrerò due sistemi per connettervi a database multipli.
In entrambe le situazioni:
– i due database avranno il nome (poco fantasioso ma immediato) di primo_database e secondo_database
– in entrambi i database è presente una tabella chiamata prodotti, al cui interno ha un campo chiamato id (che rappresenta il campo autoincrementale dei record) e un campo chiamato nome (varchar di lunghezza a piacere)
– poniamo per semplicità che in entrambe le tabelle “prodotti” ci siano dei record con id=2 . L’unica differenza sta nel campo nome, che avrà i seguenti valori:
– tabella di “primo_database”: nome=”libro”
– tabella di “secondo_database”: nome=”film”

In questo modo, quando stamperemo a video il campo “nome” del record con id=2 avremo la possibilità di capire se proviene dal primo database o dal secondo.

Connessione a due database sullo stesso server

Se i due database si trovano sullo stesso server (probabilmente un server dedicato), in gran parte dei casi la connessione a entrambi avverrà con lo stesso host, user e password.
Per distingue quale database coinvolge una delle nostre query, ci basta far precedere il nome della tabella prodotti dal nome del database.
Quindi, se la tabella di ricerca della select sarà “primo_database.prodotti” significa che coinvolgerà la tabella “prodotti” di “primo_database”.
Viceversa, se la tabella di ricerca della select sarà “secondo_database.prodotti” significa che coinvolgerà la tabella “prodotti” di “secondo_database”.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/**
* Connessione a due database sullo stesso server 
*/
 
$db_host = "localhost";
$db_user = "root";
$db_password = "password";
 
$db_name1 = "primo_database";
$db_name2 = "secondo_database";
 
$db1 = mysql_connect($db_host, $db_user, $db_password);
 
$db2 = mysql_connect($db_host, $db_user, $db_password);
 
 
define('DB1', $db1);
define('DB2', $db2);
define('DBNAME1', $db_name1);
define('DBNAME2', $db_name2);
 
 
 
$q = "SELECT * FROM ".DBNAME1.".prodotti WHERE id=2";
$result = mysql_query($q, DB1);
$row = mysql_fetch_array($result);
echo $row['nome']."<br /><br />"; //stamperà "libro"
 
$q = "SELECT * FROM ".DBNAME2.".prodotti WHERE id=2";
$result = mysql_query($q, DB2);
$row = mysql_fetch_array($result);
echo $row['nome']; //stamperà "film"

Connessione a due database (su stesso server o su server diversi)

Un po’ più macchinoso è il sistema da usare qualora i database risiedano su due server diversi.
In questo caso host, user e password saranno diversi e le connessioni saranno completamente distinte.

Il modo migliore per gestire la situazione è di creare una funzione ad hoc, che ho chiamato dbconn, in cui come argomento passiamo semplice il valore “1” o “2” per far capire che vogliamo connetterci rispettivamente a “primo_database” e a “secondo_database”.
Per connettersi al secondo database, quindi, dovremo semplicemente richiamare la funzione:

dbconn(2);

Una volta effettuata la connessione in questo modo, ci basterà eseguire normalmente la query sulla tabella “prodotti”.

L’aspetto macchinoso? Un simile sistema tiene aperta una sola connessione alla volta, per cui a ogni cambio di database dovremo richiamare la funzione “dbconn”.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

/**
* Connessione a due database
* utilizzabile sia per database nello stesso server che in server diversi
*/
function dbconn($type){
 
	switch($type){
 
		case "1":
			$db1 = mysql_connect("host1", "root", "password1");
			mysql_select_db("primo_database", $db1);
			break;
 
		case "2":
			$db2 = mysql_connect("host2", "root", "password2");
			mysql_select_db("second_database", $db2);
			break;
 
	}
 
}
 
 
dbconn(1);
$q = "SELECT * FROM prodotti WHERE id=2";
$result = mysql_query($q);
$row = mysql_fetch_array($result);
echo $row['nome']."<br /><br />"; //stamperà "libro"
 
dbconn(2);
$q = "SELECT * FROM prodotti WHERE id=2";
$result = mysql_query($q);
$row = mysql_fetch_array($result);
echo $row['nome']; //stamperà "film"

La sua gratuità e il suo codice libero sono un’ottima cosa, perché permettono agli esperti di personalizzare le pagine discostandosi dalle caratteristiche base e di offrire agli altri plugin a costo zero. Tuttavia, proprio il suo essere libero è anche motivo di preoccupazione in alcuni casi.
Un eventuale cracker (la versione “cattiva” degli hacker) può studiarsi il codice di un tema che magari è stato mal costruito e trovare un buco nel quale entrare. Oppure può “allungarvi” un plugin da lui costruito per sottrarvi dati preziosi o per arrivare persino al database.

Una delle accortezze di base è quella di scegliere siti ufficiali da cui scaricare il materiale gratuito. Ma esistono anche tecniche a portata di mano che permettono di migliorare la sicurezza in WordPress. Sono in realtà tecniche che si consigliano per qualsiasi sito: nascondere le informazioni che non devono essere mostrare, impedire l’accesso in determinate zone, ecc.

Vediamo la lista, che ho recuperato dopo uno studio in rete su diversi siti specifici.

Permessi, prefisso delle tabelle, username e password sicure

Partiamo dalle basi.
Prima di tutto, è buona norma modificare il prefisso delle tabelle che WordPress ci propone (“wp_”). In questo modo l’intruso, se raggiunge il database, non può conoscere il nome esatto delle tabelle da estrarre. Se il danno è già fatto, cioè avete installato il cms mantenendo il prefisso tabelle proposto, potete modificarlo in un secondo momento agendo direttamente nel database e modificando il nome di ogni singola tabella con questa query:

1

RENAME table 'nomeTabella' to 'nuovoNome'

Seconda cosa, fondamentale è la modifica di username e l’uso di password sicure. Non usate il classico username “admin” per entrare, usatene uno personalizzato, e adoperate password possibilmente complesse (le solite raccomandazioni: uso combinato di numeri, lettere maiuscole e minuscole e simboli; soprattutto, non usate parole che si possono recuperare dal comune vocabolario).

Ancora meglio sarebbe modificare l’id del record che corrisponde all’utente amministratore. Poiché è il primo utente creato, l’admin avrà un ID=1 . Una cosa semplice è assegnargli nella tabella del database un ID differente.

Infine, è buona cosa modificare i permessi dei singoli file e cartelle: tolte particolari esigenze, i permessi dei file dovrebbero essere settati a 644, mentre quelli delle cartelle a 755.

Impedire l’accesso ai file più importanti

Il file config.php contiene i parametri di accesso al database. Se un cracker riesce ad aprirlo, avrà libero accesso a ogni vostro dato. Il modo più semplice per impedire l’accesso al file di configurazione è tramite l’htaccess. Aprite il file .htaccess presente nella root del sito e inserite queste righe (fatevi sempre un backup dell’htaccess, per eventuali malfunzionamenti):

1
2
3
4

<files wp-config.php>
order allow,deny
deny from all
</files>

Dopodiché, nessuno potrà accedervi direttamente attraverso l’uso di un codice.

Un altro file “caldo” è quello di login, che un malintenzionato potrebbe modificare, dirottando la destinazione dell’accesso verso una sua pagina e catturandovi così i dati immessi (username e password). Se accedete sempre con lo stesso indirizzo IP, inserite nell’htaccess queste righe (avendo cura di modificare gli ultimi numeri con il vostro indirizzo IP):

1
2
3
4
5

<files wp-login.php>
Order deny,allow
Deny from All
Allow from 262.263.264.0
</files>

Ancora, è utile impedire l’accesso a tutte quelle cartelle che sono prive del file “index.php” (e che quindi non dovrebbero mai essere direttamente accessibili). All’inizio dell’htaccess scrivete:

1

Options -Indexes

Protezioni più avanzate

WordPress mette a disposizione delle chiavi segrete per crittografare i cookies. Per inserirne di personalizzate, aprite il file config.php e cercate la riga dove viene definita la costante (al posto di “stringa_di_sicurezza” troverete una lunga stringa alfanumerica e simbolica):

1

define('AUTH_KEY', 'stringa_di_sicurezza');

La stringa_di_sicurezza deve essere sostituita con quella che potete recuperare al seguente indirizzo:
https://api.wordpress.org/secret-key/1.1/salt/

Un sistema ancora più efficiente in campo di sicurezza è l’uso del protocollo https. Il vostro dominio deve poter disporre di un certificato SSL, naturalmente, ma accedere nel pannello di amministrazione via “https” (invece che “http”) significa che i dati da voi inseriti saranno crittografati e pertanto più difficili da recuperare da un cracker.

Un ottimo articolo su Your Inspiration Web sulla sicurezza in WordPress