In particolare, ha bisogno di ordinare i post in modo casuale nell’archivio di categoria.

Dopo aver spulciato le librerie di Wordpress e aver eseguito un po’ di prove ho sfornato questa funzione che sembra funzionare a dovere.

La classe WP_Query

In Wordpress le query (interrogazioni) al database vengono gestite con la classe WP_Query che si trova in wp-includes/query.php.

Ecco le proprietà e i metodi della classe WP_Query che utilizziamo:

• con il metodo set($query_var, $value) impostiamo le caratteristiche della query
• il metodo get($query_var) restituisce il valore di una variabile
• per eseguire la query utilizziamo la funzione get_posts()

Tuttavia, questi tre metodi non bastano a modificare l’elenco dei post che verranno visualizzati.

Questo elenco è memorizzato all’interno della proprietà posts (di tipo array) che verrà sovrascritta con l’array restituito dal metodo get_posts(), nell’ultima riga.

Per saperne di più sulla classe WP_Query vai su http://codex.wordpress.org/Function_Reference/WP_Query.

Il codice

function jblog_orderbyRand()
{
	global $wp_query;

	// Imposta il tipo di ordinamento
	$wp_query->set('orderby', 'rand');

	// Disabilita la paginazione dei post
	$wp_query->set('nopaging', true);
	$wp_query->set('posts_per_page', -1);

	// Reimposta l'array dei post da stampare
	$wp_query->posts = $wp_query->get_posts();
}

Come utilizzare la funzione

Innanzitutto copiamo il codice precedente nel file functions.php (all’interno della directory del template). Se il file non esiste basterà crearlo.

Anche se la necessità originale era quella di modificare l’elenco dell’archivio di categoria, questa funzione è efficace in ogni pagina del blog che contenga un elenco di post, quindi nell’homepage, nell’archivio di tag, ecc.

Per utilizzarla basterà inserirla in testa alla pagina da modificare. Ad esempio, se vogliamo che tutti gli archivi vengano ordinati in modo casuale, dobbiamo aprire il file archive.php del template e inserirla in testa:

<? // Ordinamento casuale
   jblog_orderbyRand(); 	?>

<? get_header(); ?>
	<div id="content" class="narrowcolumn">
		<?php if (have_posts()) : ?>
			. . .

Se, come nel caso del lettore, si deve ordinare in modo casuale solo l’archivio di categoria scriveremo la funzione all’interno di un costrutto if in cui si controlla che l’archivio sia relativo a una categoria.

Questo controllo si esegue ottenendo l’id della categoria grazie alla funzione get_query_var('cat') che restituisce il valore di una variabile per la query. Nota che quella funzione è equivalente all’istruzione $wp_query->get('cat'). Entrambe restituiscono l’id (di tipo intero) della categoria. Questo sarà maggiore di zero se l’archivio che si sta visualizzando è di categoria.

<? // Ordinamento casuale (se id categoria è positivo)
   if(get_query_var('cat')>0)
   jblog_orderbyRand(); 	?>

<? get_header(); ?>
	<div id="content" class="narrowcolumn">
		<?php if (have_posts()) : ?>
		. . .

Svantaggio: non è possibile dividere i post per pagine

Ogni volta che si carica la pagina viene rigenerato l’elenco e, dato che viene ordinato in modo casuale, i post non vengono adeguatamente distribuiti nelle varie pagine. In pratica è concreto il rischio che dei post apparsi nella pagina 1 possano apparire nuovamente in altre pagine. Per questo motivo viene disabilitata la paginazione.

Inoltre, è necessario applicare un ultima modifica al tema della pagina che ospiterà l’elenco da ordinare in modo casuale. Cioé, è necessario evitare che appaiano i link “post precedenti” e “post successivi”. Nei casi più semplici basterà eliminare il codice relativo a questi link. Se invece l’ordinamento casuale è condizionato (come nel codice precedente) bisognerà applicare le condizioni (contrarie rispetto a quelle relative alla funzione) alla visualizzazione di questi link:

<? // Per la funzione la condizione era get_query_var('cat')>0 (con il ">" anziché "<=")
if(get_query_var('cat')<=0) : ?>
	<div class="navigation">
		<div class="alignleft"><?php next_posts_link(__('&laquo; Older Entries', 'kubrick')); ?></div>
		<div class="alignright"><?php previous_posts_link(__('Newer Entries &raquo;', 'kubrick')); ?></div>
	</div>
<? endif; ?>

Serve aiuto?

Come vedi quello che ho scritto nella pagina “Informazioni” riguardo l’aiuto ai lettori non sono solo un mucchio di frasi fatte per riempire una pagina. Quindi se hai bisogno di aiuto o, più semplicemente, di un consiglio ricordati di passare da qui. Finché ne avrò il tempo sarò felice di aiutarti!

Senza dubbio, il modo migliore per farlo consiste nell’utilizzo delle espressioni regolari, chiamate anche RegEx (da “regular expressions”).

Perché è il modo migliore? Anziché scrivere un’intera funzione composta da decine e decine di righe di codice, grazie alle RegEx basta defire il modello (o pattern) della stringa email e far eseguire il confronto da un’apposita funzione.

Caratteristiche di un indirizzo email

Il primo passo consiste nell’individuare le caratteristiche di un indirizzo email in modo da definirle successivamente in un modello (pattern).

Local part

Questa parte, che indica spesso l’username, può essere costituita da:

• un massimo di 64 caratteri
• lettere minuscole e maiuscole dell’alfabeto inglese, cioè a-z e A-Z
• numeri, da 0 a 9
• caratteri speciali . ! # $ % & ' * + - / = ? ^ _ ` { | } ~. Alcuni servizi email non permettono di creare indirizzi solo con i caratteri speciali più comuni come “.” , “-”, e “_”

N.B. il carattere “.” non può trovarsi né all’inizio né alla fine.

Domain name

La parte successiva alla “@” è il nome del dominio (es. example.com) che può essere costituito da:

• un massimo di 255 caratteri
• lettere minuscole dell’alfabeto inglese, cioè a-z
• numeri, da 0 a 9
• caratteri speciali “.” e “-”

N.B. il carattere “.” non può trovarsi né all’inizio né alla fine. Inoltre deve essere presente almeno un punto.

Il pattern per un indirizzo email

Ora che sappiamo la struttura di un indirizzo email possiamo definire precisamente il pattern che verrà confrontato all’indirizzo email da controllare.

Definiamo un pattern per indirizzi email semplici che contengano sono lettere, numeri, punti “.”, underscore “_” e trattini “-”. In seguito vedremo come modificare i pattern in modo da accettare anche i caratteri speciali.

Pattern per la “local part”

La prima parte impone che l’indirizzo inizi almeno con una lettera (maiuscola o minuscola) o con un numero. Vengono esclusi i caratteri con cui non può iniziare l’email.

La seconda parte è un po’ più complicata:

• vengono definiti tutti i caratteri accettati dall’email
• corrisponde a un punto seguito da a-z, A-Z, 0-9, – o 0
• il codice “\.?” indica che i successivi caratteri possono (opzionalmente) essere preceduti da un solo punto
• la parte [a-zA-Z0-9\-\_] è seguita dal carattere + perché deve essere trovato un carattere del tipo a-z, A-Z, 0-9, – o 0 almeno una volta
• viene racchiusa nelle parentesi tonde e seguita dal carattere * per impostare la condizione in base alla quale la seconda parte può essere presente facoltativamente

Pattern per il “domain name”

La prima parte impone che l’indirizzo inizi almeno con una lettera (maiuscola o minuscola) dell’alfabeto inglese. Vengono esclusi i caratteri con cui non può iniziare un nome di dominio.

Nella seconda parte, come per la “local part”:

• vengono definiti tutti i caratteri accettati dall’email
• corrisponde a un punto seguito da a-z, A-Z, 0-9, – o 0
• il codice “\.?” indica che i successivi caratteri possono (opzionalmente) essere preceduti da un solo punto
• la parte [a-zA-Z0-9\-\_] è seguita dal carattere + perché deve essere trovato un carattere del tipo a-z, A-Z, 0-9, – o 0 almeno una volta
• viene racchiusa nelle parentesi tonde e seguita dal carattere * per impostare la condizione in base alla quale la seconda parte può essere presente facoltativamente

La terza parte impone la presenza di un punto fra il nome del dominio e il codice del dominio di primo livello. In pratica, se il dominio è example.com, il punto di cui si impone la presenza è quello che si trova fra example e com.

L’ultima parte stabilisce il formato del codice del dominio di primo livello. Questo deve essere composto da almeno due caratteri e da sole lettere (del tipo a-z e A-Z) dell’alfabeto inglese.

Lunghezza della “local part” e del “domain name”

Purtroppo non è possibile imporre la lunghezza totale dei due segmenti (o almeno io non ci sono riuscito).

Scrivendo (\.?[a-zA-Z0-9\-\_]){0,63} la condizione {0,63} viene attribuita sia \. sia a [a-zA-Z0-9\-\_]. Quindi, l’indirizzo email risulterà troppo lungo se sia i punti sia i restanti caratteri corrispondenti a [a-zA-Z0-9\-\_] saranno più di 63. Ecco cosa succederebbe:

• punti<=63, caratteri<=63: indirizzo ok
• punti>=63, caratteri<=63: indirizzo errato
• punti<=63, caratteri>=63: indirizzo ok (non è ciò che vogliamo)
• punti>=63, caratteri>=63: indirizzo errato

Il terzo caso non va bene a causa dei controlli sul numero dei caratteri. Infatti, se i caratteri sono più di 63 l’indirizzo email viene considerato corretto.

Ho fatto diverse prove ma ho sempre avuto esiti negativi. Come ho detto prima, probabilmente non ci sono riuscito io.

Sono ben accetti suggerimenti e soluzioni alternative.

La mia soluzione

In seguito vedremo che per controllare se i due segmenti rispettano le dimensioni massime, rispettivamente 64 e 255, si possono scrivere un paio di righe di codice per:

• dividere l’indirizzo email in due in corrispondenza della @
• controllare la lunghezza di ciascuna stringa

Accettare i caratteri speciali

Per fare in modo che la tua funzioni accetti alcuni o tutti i caratteri speciali basterà sostituire la stringa [a-zA-Z0-9\-\_] (presente nella “local part”) con la stringa [a-zA-Z0-9\-\_\!\#\$\%\&\'\*\+\/\=\?\^\`\{\|\}\~].

Se non vuoi accettare alcuni caratteri bisogna eliminare il carattere speciale e il “\” che lo precede.

Codice Javascript

function isEmail(string)
{
	/* Confronta la stringa con il pattern RegEx */
	if(string.search(/^[a-zA-Z0-9]+(\.?[a-zA-Z0-9\-\_]+)*\@[a-zA-Z]+(\.?[a-zA-Z0-9\-\_]+)*\.[a-zA-Z]{2,}$/)==-1)
	return false;

	/* Divide l'indirizzo in due parti: "local part" e "domain name" */
	var parts = string.split("@");

	/* Controlla se "local part" supera i 64 caratteri */
	if(parts[0].length>64) return false;

	/* Controlla se "local part" supera i 255 caratteri */
	if(parts[1].length>255) return false;

	return true;
}

Codice PHP

function isEmail($string)
{
	/* Confronta la stringa con il pattern RegEx */
	if(!eregi("[a-zA-Z0-9]+(\.?[a-zA-Z0-9\-\_]+)*\@[a-zA-Z]+(\.?[a-zA-Z0-9\-\_]+)*\.[a-zA-Z]{2,}$",$string))
	return false;

	/* Divide l'indirizzo in due parti: "local part" e "domain name" */
	$parts = explode("@",$string);

	/* Controlla se "local part" supera i 64 caratteri */
	if(strlen($parts[0])>64) return false;

	/* Controlla se "local part" supera i 255 caratteri */
	if(strlen($parts[1])>255) return false;

	return true;
}

Demo e download

Per vedere lo script vai su http://test.jblog.it/email_checker/email_checker.txt

Per vedere una demo vai su http://test.jblog.it/email_checker/

Per scaricare l’esempio vai su http://download.jblog.it/email_checker.zip

Conclusione

Le espressioni regolari sono un potente strumento, ma fanno lavorare la cpu.

Quindi, ti consiglio di utilizzare le espressioni regolari solo quando la stringa da controllare ha un formato complesso come, appunto, un indirizzo email o un numero di telefono. Se invece devi verificare che contenga solo caratteri numerici è meglio ricorrere a funzioni che controllano carattere per carattere.

Per quanto riguarda le funzioni email, personalmente le ritengo buone ma non le migliori. Le ho provate e sembrano funzionare adeguatamente. Per qualsiasi errore o malfunzionamento io sono qui… Sono graditi consigli, critiche e opinioni in genere.

Crediti

Wikipedia (english) – E-mail address

Foto1 – Formatear cadenas de Texto/String como númericas con o sin decimales – Regex – Expresiones Regulares