Questo post è una traduzione autorizzata dall’autore, Roger Johansson, dell’articolo Bring on the tables, in cui si parla di come rendere l’utilizzo delle tabelle accessibile e corretto.
Secondo l’autore, bisogna evitare il più possibile l’utilizzo delle tabelle per elementi di layout, ma per mostrare dei dati tabulari, cioè informazioni presentate logicamente in righe e colonne, le tabelle sono lo strumento adatto!. Le tabelle mettono a disposizione molti più tag rispetto ai canonici td e tr, specialmente se si vuole rendere il contenuto più accesibile (e semantico!).

Ecco, per prima cosa, un po’ di informazioni generali.
L’affermazione "evitare l’uso di tabelle per il layout" si trova in "Introduzione alle tabelle" nelle specifiche HTML 4.01:

“Tables should not be used purely as a means to layout document content as this may present problems when rendering to non-visual media. Additionally, when used with graphics, these tables may force users to scroll horizontally to view a table designed on a system with a larger display. To minimize these problems, authors should use style sheets to control layout rather than tables.

”

Direi che il testo è abbastanza chiaro, anche se la parola usata è "should", non "must": le specifiche tecniche consentono una certa flessibilità.

Ma questo articolo non vuole parlare della questione se utilizzare le tabelle per il layout o no. Tratta dell’utilizzo delle tabelle per la loro funzione originaria: la marcatura di dati tabulari.

Quando le tabelle vengono utilizzate per contrassegnare i dati effettivi, non sono solo una griglia per il layout. Le persone senza problemi di vista possono farsi un’idea del rapporto che c’è tra l’intestazione e le celle di dati osservando il layout e la presentazione visiva della tabella. Al contrario, le persone non vedenti o ipovedenti non possono farlo. Affinchè una tabella sia accessibile a persone che usano uno screen reader o qualche altro user-agent non-visivo, bisogna comunicare all’user-agent che rapporto hanno tra loro le informazioni che essa contiene.

Fortunatamente, l’HTML fornisce in abbondanza elementi e attributi per questo scopo. Meno fortunatamente, può essere piuttosto difficile capire come usare alcune di queste caratteristiche di accessibilità. In questo articolo cercherò di spiegare come utilizzarne la maggior parte.

Intestazione della tabella: il tag th

Cominciamo con una tabella molto semplice, che ha solo una singola riga di intestazioni, ognuna delle quali definisce i dati in una colonna.
Ecco come appare il codice contrassegnato alla vecchia maniera, con solo le righe e le celle:

<table>
  <tr>
    <td>Compagnia</td>
    <td>Dipendenti</td>
    <td>Fondazione</td>
  </tr>
  <tr>
    <td>ACME Inc</td>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <td>XYZ Corp</td>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

Senza bordi o stili, nella maggior parte dei browser la tabella sarà più o meno così:

Per una persona senza problemi di vista, è facile e veloce fare il collegamento tra le intestazioni e le celle di dati che esse descrivono. Chi utilizza uno screen reader, d’altra parte, avrebbe sentito qualcosa del tipo "Compagnia Dipendenti ACME Fondata Inc 1000 1947 2000 1073 XYZ Corp". Non è molto facile trovare un senso in queste parole!!!

Il primo – e più semplice – passo per rendere più accessibile questa tabella, è quello di marcare le intestazioni in modo corretto.
E’ molto facile: basta utilizzare l’elemento th (Table Header: Intestazione di Tabella) invece di td (Table Data: Dati tabellari) per le celle di intestazione:

<table>
  <tr>
    <th>Compagnia</th>
    <th>Dipendenti</th>
    <th>Fondazione</th>
  </tr>
  <tr>
    <td>ACME Inc</td>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <td>XYZ Corp</td>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

Per questa semplice tabella, aver inserito le intestazioni è sufficiente per permettere a uno screen reader di informare l’utente su quale cella di intestazione dei dati è legata a quale cella. Un lettore di schermo potrebbe dire "Azienda: ACME Inc. dipendenti: 1000. Fondazione: 1947", e così via per ogni riga. Molto meglio, no?

Inserire le didascalie: caption

L’elemento caption può essere utilizzato per fornire una breve descrizione della tabella, in modo molto simile a alla funzione che ha una didascalia per l’immagine.
Come impostazione predefinita, la maggior parte dei browser rendono il caption in posizione centrata sopra la tabella.
La proprietà CSS caption-side può essere utilizzata per modificarlo, se necessario. La maggior parte dei browser visualizzerà la didascalia al di sopra (top) o sotto (bottom) il contenuto della tabella, mentre alcuni accettano anche i valori sinistra o destra. Vi lascio sperimentare!

Quando viene utilizzato, il caption deve comparire per primo subito dopo l’apertura del tag table, per esempio, così:

<table>
  <caption>Tabella 1: dati della Compagnia</caption>
  <tr>
    <th>Compagnia</th>
    <th>Dipendenti</th>
    <th>Fondazione</th>
  </tr>
  <tr>
    <td>ACME Inc</td>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <td>XYZ Corp</td>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

È possibile utilizzare i CSS per lo stile della didascalia, se lo si desidera. Tuttavia, bisogna essere consapevoli del fatto che potrebbe essere necessario usare alcuni trick per mantenere la coerenza di layout su tutti i browser. Vi lascio esercitare anche su questo!

L’attributo summary: come spiegare il contenuto della tabella!

Una persona vedente può facilmente decidere se studiare una tabella in dettaglio. Un rapido sguardo ci dirà quanto è grande la tabella, e più o meno ciò che contiene.
Una persona che utilizza uno screen reader invece non può farlo, a meno che il webdesigner non aggiunga alla tabella un attributo che sintetizzi il contenuto. In questo modo è possibile fornire una descrizione più dettagliata della tabella rispetto a quanto faccia l’elemento caption.

Il contenuto dell’attributo summary non viene reso visibile dai browser visuali: in questo modo è possibile scrivere una descrizione abbastanza lunga, per fare in modo che chi ascolta capisca a pieno di cosa parla la tabella. Non bisogna però esagerare: utilizziamo l’attributo di sintesi solo quando è necessario, cioè per più tabelle complesse, per cui una sintesi sarà più facile, per chi utilizza un lettore di schermo, comprendere il contenuto della tabella. Ecco la tabella di prima con il tag summary:

<table summary="Il numero di dipendenti e l'anno di
 fondazione di alcune compagnie immaginarie.">
  <caption>Tabella 1: dati della Compagnia</caption>
  <tr>
    <th>Compagnia</th>
    <th>Dipendenti</th>
    <th>Fondazione</th>
  </tr>
  <tr>
    <td>ACME Inc</td>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <td>XYZ Corp</td>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

Come accorciare le intestazioni? Con l’attributo abbr!

Quando uno screen reader incontra una tabella, può annunciare l’intestazione associata (o header) prima di ogni cella di dati.
Se la tabella dispone di intestazioni lunghe però, sentendole ripetere più e più volte, può risultare noioso per chi ascolta. Utilizzando l’attributo abbr per fornire una versione abbreviata di eventuali intestazioni lunghe, potete dare agli screen reader qualcosa che possono utilizzare al posto del testo nella stessa intestazione. L’uso dell’attributo abbr è opzionale, e la maggior parte delle volte gli header saranno (o meglio, dovrebbero essere!) comunque piuttosto brevi.

La tabella di esempio è stata leggermente modificata, per rendere le intestazioni più lunghe. Vediamo come viene utilizzato l’attributo abbr:

<table summary="Il numero di dipendenti e l'anno di
 fondazione di alcune compagnie immaginarie.">
<caption>Table 1: Compagnia data</caption>
  <tr>
    <th abbr="Compagnia">Compagnia Name</th>
    <th abbr="Impiegati">Numero di Impiegati</th>
    <th abbr="Fondazione">Anno di fondazione</th>
  </tr>
  <tr>
    <td>ACME Inc</td>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <td>XYZ Corp</td>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

Uno screen reader leggerà quindi leggere le intestazioni (con la descrizione lunga) per la prima riga dei dati, per poi utilizzare l’abbreviazione per le righe rimanenti.

Considerando quanto difficile possa essere l’inserimento di tabelle nei layout web, direi che è più comune l’esigenza contraria: per rendere le intestazioni più brevi possibile, o anche abbreviate, è meglio utilizzare l’attributo title o l’elemento abbr per fornire una spiegazione più lunga.

Come collegare le intestazioni con i dati?
Con gli attributi scope, ID e headers

Molte tabelle sono più complesse rispetto alla tabella di esempio che abbiamo visto finora. La renderemo un po’ più complessa, eliminando l’intestazione "Compagnia" e modificando le celle di dati nella prima colonna, e nelle celle dell’intestazione

<table summary="Il numero di dipendenti e l'anno di
 fondazione di alcune compagnie immaginarie.">
  <caption>
  Table 1: Compagnia data
  </caption>
  <tr>
    <td></td>
    <th>Dipendenti</th>
    <th>Fondazione</th>
  </tr>
  <tr>
    <th>ACME Inc</th>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <th>XYZ Corp</th>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

In questa tabella, ogni cella di dati ha due intestazioni. Il metodo più semplice, cioè per un markup più "saggio", per fare in modo che un browser non-visivo possa dare un senso a questa tabella, è quello di aggiungere un attributo scope a tutte le celle di intestazione:

<table summary="Il numero di dipendenti e l'anno di
fondazione di alcune compagnie immaginarie.">
  <caption>
  Table 1: Compagnia data
  </caption>
  <tr>
    <td></td>
    <th scope="col">Dipendenti</th>
    <th scope="col">Fondazione</th>
  </tr>
  <tr>
    <th scope="row">ACME Inc</th>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <th scope="row">XYZ Corp</th>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

L’attributo scope definisce se una cella di intestazione fornisce informazioni di intestazione per una colonna o una riga:

• col: informazioni di intestazione per la colonna in cui si trova
• row: informazioni di intestazione per la riga in cui si trova

L’aggiunta di un attributo scope con il valore col alle intestazioni nella prima riga dichiara che sono le intestazioni per le celle di dati sotto di esse.
Allo stessa maniera, dando uno scope con valore row alle intestazioni che iniziano ogni riga, le rendiamo intestazioni per tutte le celle di dati che si trovano alla loro destra.

L’attributo scope può assumere altri due valori:

• colgroup: informazioni di intestazione per il resto del gruppo di colonne che la contiene
• rowgroup: informazioni di intestazione per il resto del gruppo di righe che la contiene

Un gruppo di colonne è definito dall’ elemento colgroup. Ragruppamenti di rige sono definiti dagli elementi thead , tfoot e tbody.
Ma di quest’ultimi torneremo a parlare tra poco.

Che cosa succede se si desidera: sia mantenere l’intestazione "Compagnia", e che i nomi delle società siano le intestazioni di riga?
Ciò farebbe sì che le celle che contengono i nomi delle società debbano fornire sia le informazioni di intestazione, sia i dati. In questo caso, td dovrebbe essere usato assieme all’attributo scope:

<table summary="Il numero di dipendenti e l'anno di
fondazione di alcune compagnie immaginarie.">
  <caption>
  Table 1: Compagnia data
  </caption>
  <tr>
    <th scope="col">Compagnia</th>
    <th scope="col">Dipendenti</th>
    <th scope="col">Fondazione</th>
  </tr>
  <tr>
    <td scope="row">ACME Inc</td>
    <td>1000</td>
    <td>1947</td>
  </tr>
  <tr>
    <td scope="row">XYZ Corp</td>
    <td>2000</td>
    <td>1973</td>
  </tr>
</table>

In questo modo, nei browser visuali non verranno visualizzati i nomi delle società come intestazioni di default, quindi è necessario un po’ di CSS per rimediare.
Per questo esempio, ho usato il seguente codice CSS:

td[scope] {
	font-weight:bold;
}

Si noti che questa regola utilizza un selettore di attributo, che Internet Explorer non supporta. Una soluzione sarebbe aggiungere una classe a qualsiasi celle di dati da stilare come intestazione.

Un’altra tecnica per collegare le celle di una tabella con l’intestazione cui fanno riferimento comporta il dover dare a ogni intestazione un ID univoco.
Va poi aggiunto ad ogni cella un attributo headers. Questo attributo contiene un elenco, separato da spazi, degli id di ogni cella di intestazione che si applica a quella cella di dati. Questa tecnica è più complicata, e deve essere utilizzata solo quando le celle di dati che devono essere collegate a più di due celle di intestazione e l’attributo scope è insufficiente, come può accadere in una tabella molto complessa o irregolare.

Per illustrare questo caso, ho cambiato la tabella in modo tale da mostrare, per ogni socità, il numero di dipendenti di ciascun sesso:

<table class="extbl" summary="Il numero di dipendenti e l'anno di
fondazione di alcune compagnie immaginarie.">
  <caption>
  Tabella 1: dati della Compagnia
  </caption>
  <tr>
    <td rowspan="2"></td>
    <th id="employees" colspan="2">Dipendenti</th>
    <th id="founded" rowspan="2">Fondazione</th>
  </tr>
  <tr>
    <th id="men">Uomini</th>
    <th id="women">Donne</th>
  </tr>
  <tr>
    <th id="acme">ACME Inc</th>
    <td headers="acme employees men">700</td>
    <td headers="acme employees women">300</td>
    <td headers="acme founded">1947</td>
  </tr>
  <tr>
    <th id="xyz">XYZ Corp</th>
    <td headers="xyz employees men">1200</td>
    <td headers="xyz employees women">800</td>
    <td headers="xyz founded">1973</td>
  </tr>
</table>

Come si può ben vedere, questo metodo diventa rapidamente molto complicato, quindi se è possibile, è meglio utilizzare l’attributo scope.

Raggruppare celle con rowspan e colspan

Nel vecchio approccio web (layout con tabelle), gli attributi rowspan e colspan erano spesso usati per unire le celle delle tabelle in diverse righe o colonne, al fine di metterci dentro, in fila una dopo l’altra, tutte le immagini ritagliate. Tali attributi sopravvivono ancora, dato che non vi è alcun modo per usare i CSS per specificare lo "spanning".
Se ci pensate bene, è abbastanza logico: le fusioni di righe e di colonne sono parte della struttura di una tabella, non sono la sua presentazione!

Colonne e gruppi di colonne: col e colgroup

L’HTML mette a disposizione gli elementi colgroup e col per raggruppare colonne correlate . Questo permette (in alcuni browser) l’uso di CSS per dare alle colonne dello stile in modo indipendente. Per fare gruppi di colonne, può essere utilizzato anche l’attributo scope, per specificare che una cella contiene informazioni di intestazione per il resto del gruppo di colonne che la contiene.

Questo è tutto ciò che diremo in questo articolo su colonne e gruppi di colonne.
Per informazioni più dettagliate, date un’occhiata ai collegamenti nella sezione "What I didn’t tell you" dell’articolo originale, oppure in fondo a questa pagina.

Creare gruppi di righe: <caption>, <thead>, <tfoot>, <tbody>

Le righe della tabella possono essere raggruppate in una sezione intestazione di tabella racchiusa nei tag thead, in una sezione piè pagina nel tag tfoot, e in uno o più sezioni corpo della tabella mediante il tag tbody. Ogni gruppo di righe deve contenere una o più righe di tabella.

Se una tabella contiene una sezione di testa thead, quest’ultima deve comparire prima del piè pagina e delle sezioni del corpo tabellare.
La sezione tfoot deve sempre comparire prima del (o dei) tag tbody.
Se nella tabella non è usata nè thead nè tfoot, l’elemento tbody non è richiesto (ma non vietato: potete aggiungerlo, se volete).

La struttura di una tabella che contiene i gruppi di righe appare così:

<table>
  <thead>
    <tr></tr>
  … altre righe per la table-head
  </thead>
  <tfoot>
    <tr></tr>
  … altre righe per la table-foot
  </tfoot>
  <tbody>
    <tr></tr>
  … altre righe per la table-body
  </tbody>
  <tbody>
    <tr></tr>
  … altre righe per la seconda table-body
  </tbody>
  … altre righe per le altre eventuali table-body
</table>

Raggruppare le righe è essere utile per diversi motivi:

1. Si può facilmente applicare lo stile al tfoot, thead, e alle sezioni tbody di una tabella in modo indipendente l’uno dall’altro, senza dover aggiungere classi.
2. Quando si stampano tabelle molto lunghe, alcuni browser (come quelli basati su Mozilla) ripeteranno le informazioni dell’intestazione e del piè pagina in ogni pagina stampata, rendendo più facile leggere la tabella stampata.
3. Separare l’intestazione e il piè pagina dal corpo vero e proprio permette anche ad alcuni browser di scorrere solo il corpo della tabella.

Solo per le tabelle di dati

Tutto quanto fin qui descritto riguarda l’uso di tabelle HTML per strutturare e presentare i dati. Se si utilizzano tabelle per il layout, nessuna delle tecniche qui descritte qui dovrebbero essere usate. Nessun attributo summary, nessuna intestazione, né caption, niente. Solo una semplice, tabella con layout vecchio stile, composta nientaltro che dai tag table, tr e td.
Altrimenti si rischia di confondere ancora di più gli utenti che utilizzano screen-reader.

I vantaggi

Può sembrare un sacco di lavoro per creare tabelle di dati accessibili in HTML. Per le tabelle complesse, lo è. A volte al punto in cui diventa quasi impossibile scriverle manualmente.
Per le tabelle semplici, però, utilizzare celle di intestazione con un attributo scope è veloce e facile.

E ‘ovvio che le persone che usano screen-reader o altra tecnologia assistiva, trovano beneficio dalle tabelle che utilizzano le funzioni di accessibilità disponibili. Cercare di dare un senso a un grande e complessa tabella per chi ascolta può ancora essere molto difficile, quindi, se possibile, cerchiamo di semplificare la tabella.

Meno è ovvio che traggono beneficio anche i progettisti e gli utilizzatori di browser grafici: una tabella accessibile è ricca di ganci strutturali da applicare ai CSS, e uno stile scritto bene può rendere la tavola più fruibile per tutti.

Quello che non vi ho detto

Ma ci sarebbe molto altro da dire sulle tabelle di dati che qui non ho citato. Per esempio, non ho menzionato per niente (fino ad ora) l’attributo axis, e non ho descriitto nel dettaglio gli elementi colgroup e col. Non ho nemmeno accennato alla formattazione e allo stile, o ai tipi di bordo. Inoltre, manca un esempio di una tabella estremamente complessa.

Per quelli di voi che cercano informazioni più dettagliate, ecco dei link ad alcuni ulteriori approfondimenti:

• Tables in HTML documents
• CSS formatting of tables
• Techniques for Accessible HTML Tables
• Building accessible websites: Tables and frames
• A table, s’il vous plaît

Articoli correlati:

1. HTML: capire la differenza tra elementi block e inline

Il grafico tratteggia le principali novità e tutte le caratteristiche del nuovo standard, mettendo anche a confronto i maggiori browser per verificare quali tra essi sia già pronti per affrontare la rivoluzione.

Articoli correlati:

1. HTML5: tag nuovi e anteprima delle novità
2. 10+ HTML5-CSS3 Website Template: per iniziare a progettare il web di domani!

La compatibilità con i browser sembra non essere più un grosso problema, da quando hanno iniziato a circolare risorse come Modernizr, ExplorerCanvas o IE7.js, per "modernizzare" i browser non compatibili con le nuove tecnologie, oppure per attivare i tag HTML5 su tutti i browser.

Dopo aver dato una occhiata alle maggiori novità di HTML5, e dopo aver dato uno sguardo alle tecniche per utilizzare già oggi i CSS3, ecco più di 10 template HTML5-CSS3 tutti da testare, con cui iniziare a progettare per il web di domani. Se li hai gà testati, dimmi cosa ne pensi nei commenti in fondo al post!

HTML5 Starter Pack

HTML5 Starter Kit è un template che non costringe a costruire un particolare tipo di sito web, ma si adatta a seconda delle esigenze.
Ecco le sue caratteristiche: gratuito, HTML5 cross-browser (compreso IE6), possibilità di utilizzare immediatamente Cufón @font-face, disponibilità di alcune classi strutturali riutilizzabili.
Infine, viene offerto il file .PSD per aggiornare il layout.

Gotta’ love HTML5 & CSS3

Template per le gallerie di immagini, sviluppato con HTML5-CSS3, che comprende:
transizioni animate (come l'hover animato per la descrizione delle immagini) e un’interfaccia a schede per diverse gallerie con CSS3 (che usa solo il selettore :target).

A Free HTML5 and CSS3 Theme

Il template permette di creare sotto-pagine funzionanti, tra cui un modulo di contatto con validazione lato server, e codice PHP per l’invio della posta elettronica.
Utilizza la griglia 960.gs, e ha un font personalizzato chiamato Chunkfive che fa uso di @font-face.

Coding A HTML 5 Layout From Scratch

Tutorial da Smashing Magazine: il template proposto è una vetrina per la maggior parte dei nuovi elementi di intestazione, piè di pagina, sezione, ecc.
Nelle strutture CSS3, c’è il popolare text-shadow e altri selettori come last-child o selection.

52framework

52framework è uno strumento completo per iniziare a progettare con HTML5 e CSS3 con l’uso dei nuovi tag, campi di input, angoli arrotondati, text-shadows, ecc…
Include un sistema di layout a griglia e un CSS-reset (modificato per HTML5).

iPhone App. Website With HTML5

Un tutorial molto dettagliato sulla creazione di una applicazione web per iPhone che utilizza HTML5 e CSS3.

Creare un sito elegante con HTML 5 e CSS3

Questo tutorial pemette di creare pagine web con HTML5 e CSS3, e di condividere il risultato sotto forma di download gratuito.
Molti nuovi elementi HTML5 vengono qui utilizzati e viene integrato Modernizr per la compatibilità di IE.

Free HTML5 Template

Template per layout HTML a 2 o 3 colonne, compreso il file .PSD per gli elementi di layout.

HTML5 & CSS3 Vertical One-Page Template

Un template per siti one-page a svluppo verticale, che utilizza jQuery per lo scorrimento del contenuto in verticale per la visualizzazione dei link.

OWMX 1 HTML5-CSS3 Template

Template per blog a 2 colonne che utilizza molte delle nuove caratteristiche CSS3 e dei tag HTML5.
Utilizza il microformato: hCalendar microformat.

FlipThru HTML5 and CSS3 Template

Il template è piuttosto semplice ma utilizza le maggiori funzionalità di HTML5-CSS3.
Tuttavia, è da notare la disponibilità di un accordion che fa solo uso di CSS3.

HTML5-CSS3 Starting Template

Questo template offre una struttura completa per siti web HTML5 costruiti con PHP.
Comprende inoltre gli stili CSS per il layout, per la tipografia, per la stampa e il CSS reset.
Sono già disponibili nel modello le funzioni include PHP per header, footer, ecc

Articoli correlati:

1. CSS3: compatibilità cross-browser…da oggi!
2. HTML5: tag nuovi e anteprima delle novità
3. CSS3 Columns e jQuery: layout multi-colonne ad altezza pari

Di seguito sono riportati alcuni piccoli trucchi e consigli molto utili, raccolti da varie fonti in Internet, che permettono di migliorare l’interazione dell’utente e di risolvere alcune problematiche in modo semplice ed efficace, anche per i webdesigner meno esperti e gli sviluppatori principianti. Dal momento che questi esempi sono incentrati su jQuery, il codice proposto non entra nei dettagli dei CSS.

CSS diversi per browser diversi

Ecco come dichiarare codice JavaScript per browser specifici:

jQuery.each(jQuery.browser, function(i) {
   if($.browser.msie && $.browser.version <= 6 ){
     // fai questo e quello
   }
});

//Target Safari
  if( $.browser.safari )
//Target IE6+
  if ($.browser.msie && $.browser.version > 6 )
//Target IE6 e precedenti
  if ($.browser.msie && $.browser.version <= 6 )
//Target Firefox 2 e successivi
  if ($.browser.mozilla && $.browser.version >= "1.8" )

Disabilitare il tasto destro del mouse dal menu contestuale

Ci sono molti frammenti JavaScript disponibili per disattivare il tasto destro del mouse dal menu contestuale, ma jQuery rende le cose molto più facili:

$(document).bind("contextmenu",function(e){
	return false;
 });

Verifichiamo che un elemento esista in jQuery...

if ($('#id').length) {
 // fai questo e quello
 }

...per caricare un plugin solo quando serve!

Quando il lavoro su un determinato sito cresce, gli script esterni iniziano ad accumularsi nella sezione <head> del documento, e alla fine ciò impatta sulle prestazioni.
Grazie al metodo $.getScript, ecco una soluzione elegante a questo problema.

if ($('a.email').length > 0){
	$.getScript('js/jquery.mailto.js',function(){
		$('a.email').mailto();
	});
}

Eseguire solo ciò che serve veramente

Ogni programmatore/webdesigner per comodità di solito scrive tutto il codice JS per il sito web in un unico file.
jQuery però impiega tempo per cercare gli elementi nella pagina, anche se non esistono, e questo rallenta le cose. Ci sono due modi con cui è possibile aggirare questa situazione terribile. Quella più semplice è quello mettere un ID al tag body (il nome della pagina, ad esempio) ed eseguire il codice necessario per quell'unica pagina:

$(document).ready (function () {
	if ('body').hasClass ('home') {
  // codice per home page}else if ('body').hasClass ('blog') {
  // codice per la pagina blog
}
// e così via
});

Modalità non conflittuale

Per evitare conflitti quando si utilizzano più framework in un sito web, è possibile utilizzare questo Metodo jQuery, e assegnare un nome diverso alla variabile invece che il segno di dollaro. Ecco tutte le informazioni per utilizzare jQuery con altre librerie.

var $j = jQuery.noConflict();
$j('#mioDiv').hide();

Aggiungere un'icona per link diversi

Questo trucco è molto semplice e utile per l'usabilità. Se i link portano a siti Web esterni, vogliamo che una immagine venga visualizzata accanto al link, così come se sono presenti link a documenti .pdf, o .doc. Dopo aver definito delle regole CSS per ogni tipo di collegamento, associamole ai link corrispondenti:

// Link a pdf
		$("a[href$='.pdf']").addClass("pdf");
// Link a documenti (doc, rtf, txt)
		$("a[href$='.doc'], a[href$='.txt'], a[href$='.rft']").addClass("txt");
// Link ad archivi compressi (zip, rar)
		$("a[href$='.zip'], a[href$='.rar']").addClass("zip");
// Email link
		$("a[href^='mailto:']").addClass("email");
//Aggiungiamo uno stile per i link esterni:
		$('a').filter(function() {
//Compariamo l'host name nell'anchor tag con 's host name location
		return this.hostname && this.hostname !== location.hostname;
    }).addClass("external");
//Possimao anche aggiungere l'attributo _blank al terget dei link esterni:
/*
	$('a').filter(function() {
  //Compariamo l'host name nell'anchor tag con 's host name location
  	return this.hostname && this.hostname !== location.hostname;
    }).addClass("external").attr("target", "_blank");
*/

Applicare un effetto hover a qualsiasi elemento

$('#hover-demo2 p').hover(function() {
  $(this).addClass('pretty-hover');
}, function() {
  $(this).removeClass('pretty-hover');
});

Rendere cliccabile qualsiasi elemento

Vogliamo rendere cliccabile qualsiasi elemento (attenzione: il nostro HTML non sarà più validato!):

<div class="clickable" url="http://google.com">
	Contenuto del div
</div>

Ecco come fare:

$("div.clickable").click(
function()
	{
  window.location = $(this).attr("url");
});

Imparare ad usare correttamente le animazioni

Il metodo animate() prende semplicemente qualsiasi stile CSS e lo fa passare in modo fluido da un valore all'altro. Quindi, è possibile modificare width, height, opacity, background-color, top, left, margin, color, font-size tutto quello che accetta un valore numerico. Ecco per esempio come è facile animare tutte le voci di un menù facendole crescere a 100 pixel di altezza quando si passa sopra il mouse:

$('#miaLista li').mouseover(function() {
		$(this).animate({"height": 100}, "slow");
});

A differenza di altre funzioni jQuery, le animazioni sono automaticamente eseguite in coda, quindi se si desidera eseguire una seconda animazione una volta che la prima è finita, basta chiamare il metodo animate() per due volte, senza funzioni di callback ulteriori:

$('#mioBox').mouseover(function() {
		$(this).animate({ "width": 200 }, "slow");
   $(this).animate({"height": 200}, "slow");
});

Se si desidera che le animazioni avvengano in concomitanza, basta mettere entrambi gli stili nei parametri di una singola chiamata, così:

$('#mioBox').mouseover(function() {
	$(this).animate({ "width": 200, "height": 200 }, "slow");
});

È possibile animare qualsiasi proprietà che sia numerica. È però possibile scaricare un plugin per animare le proprietà che non sono numeriche, come i colori.

Shorthand per l'evento ready

Ecco un piccolo trucco che permette di salvare alcuni caratteri utilizzando una scorciatoia per la $(document).ready(function(){}).
Invece di:

$(document).ready(function (){
	// codice da eseguire
});

...possiamo scrivere:

$(function (){
	// codice da eseguire
});

Scorrere fino alla parte superiore di una pagina web

Per tornare a inizio pagina in modo fluido utilizzando le animazioni di jQuery, inseriamo questo codice HTML in pagina:

<a href="#top">Torna a inizio pagina</a>

...e settiamo l'animazione così:

$('a[href=#top]').click(function(){
	$('html, body').animate({scrollTop:0}, 'slow');
	return false;
});

Come personalizzare le liste

Aggiungiamo a ogni list-item ,per esempio, l'elemento "»":

$("ul").addClass("Replaced");
$("ul > li").prepend("»");
 

Impostiamo i CSS in modo tale da nascondere i bullet-point preimpostati:

ul.Replaced {
 list-style : none;
}

Cambiare i fogli di stile

Vogliamo aggiungere uno "style-switch" in modo che i navigatori del nostro sito possano scegliere, per esempio, tra uno stile ad alto contrasto e uno stile di stampa? E' molto facile da fare: quello che ci serve è una serie di link con ID univoco:

<h1>Scegli uno stile:</h1>
	<ul>
  <li><a id="StyleContrast" href="#">Contrast</a></li>
  <li><a id="StylePrint" href="#">Print</a></li>
  <li><a id="StyleNormal" href="#">Normal</a></li>
</ul>

Ecco come impostare i comandi JavaScript:

$("#StyleContrast").click(function() {
	$("link[media='screen']").attr("href", "Contrast.css");
  });
$("#StylePrint").click(function() {
	$("link[media='screen']").attr("href", "Print.css");
});
$("#StyleNormal").click(function() {
	$("link[@media='screen']").attr("href", "Normal.css");
});

Campi di ricerca personalizzati

Un piccolo script, che popola un campo di testo di un modulo con un testo predefinito come descrizione.
Questo testo sparisce se l'input è in focus, e ricompare se il focus è perso senza alcun input:

<form action="#" method="post">
	<input id="SearchText" name="text" />
  <button>Cerca</button>
</form>

Dato che questo compito può essere usato in diverse situazioni, è una buona idea scrivere una funzione riutilizzabile. Il primo parametro è un selettore (nel nostro caso "#Testo di ricerca", ma qualcosa come "input[@name=search]" potrebbe andare bene), il secondo parametro è il nuovo valore predefinito di tale elemento di input (ad esempio "Inserisci i termini di ricerca qui ..").

function populateElement(selector, defvalue) {
 $(selector).each(function() {
         if($.trim(this.value) == "") {
                     this.value = defvalue;
         }
})
 $(selector).focus(function() {
        if(this.value == defvalue) {
                    this.value = "";
         }
});
$(selector).blur(function() {
        if($.trim(this.value) == "") {
        this.value = defvalue;
        }
      });
}

Nel nostro caso particolare il codice JavaScript potrebbe apparire così:

populateElement('#SearchText', 'Inserisci la parola che cerchi..');

Prevenire il comportamento di default

Supponiamo di avere una pagina molto lunga, e di avere un link simile a quello qui sotto che viene utilizzato per scopi diversi da un collegamento ipertestuale. Se si fa clic su di esso, ci porterà in cima alla pagina. La ragione di questo comportamento è la presenza del simbolo #.

<a href="#" id="chiudi"></a>

Per risolvere questo problema, è necessario annullare il comportamento predefinito, in questo modo:

$('#chiudi).click(function(e){
     e.preventDefault();
}); 

/* oppure */

$('#chiudi).click(function(){
    return false;
});

Font resizing

Questo è una delle più usate funzionalità in una pagina web, cioè la possibilità di permettere all'utente aumentare/diminuire la dimensione del carattere.
Siamo in grado di specificare l'ID, le classi o gli elementi HTML di cui si desidera regolare il carattere tramite un array.

$(document).ready(function(){
	 //Inseriamo un un array gli ID, classi e tag di cui vogliamo ridimensionare i font
  //Mettiamo html or body se vogliamo rendere tutti i caratteri ridimensionabili:
  var section = new Array('span','.section2');
  section = section.join(',');

	 //Resettiamo il font-size
  var originalFontSize = $(section).css('font-size');
  $(".resetFont").click(function(){
  $(section).css('font-size', originalFontSize);
  });

  //Aumentiamo il font-size
  $(".increaseFont").click(function(){
  var currentFontSize = $(section).css('font-size');
  var currentFontSizeNum = parseFloat(currentFontSize, 10);
  var newFontSize = currentFontSizeNum*1.2;
  $(section).css('font-size', newFontSize);
  return false;
  });

  //Diminuiamo il font-size
  $(".decreaseFont").click(function(){
  var currentFontSize = $(section).css('font-size');
  var currentFontSizeNum = parseFloat(currentFontSize, 10);
  var newFontSize = currentFontSizeNum*0.8;
  $(section).css('font-size', newFontSize);
  return false;
  });
  });

Impostiamo adesso un pannello per passare da un font-size a un altro:

<div>
		<a class="increaseFont">+</a> |
		<a class="decreaseFont">-</a> |
		<a class="resetFont">=</a>
</div>
	<span>Questo font può cambiare di dimensione</span>
  <div class="section1">Questa sezione non cambia il font!</div>
  <div class="section2">Questa invece sì!</div>
 

Rimuovere una parola

Ecco il modo più semplice: usiamo le espressioni regolari:

var el = $('#id');el.html(el.html().replace(/parolaDaRimuovere+parolaDaRimuovere/ig, ""));

Ottimizziamo l'uso dei Plugin

I plugin di jQuery devono essere inclusi nella pagina principale dopo il core jquery.js, così:

<script type="text/javascript" src="jquery-core.js"></script>
<script type="text/javascript" src="jquery.plugin-1.0.js"></script>
<script type="text/javascript" src="jquery.plugin-2.4.js"></script>

Il metodo migliore però è quello di copiare tutti i file JavaScript in un singolo file e poi comprimerli con YUI e impacchettarli.

Aggiungere / inserire elementi HTML dentro un elemento

Il metodo .append() inserisce il contenuto specificato come l'ultimo figlio di ciascun elemento della collezione jQuery (per inserirlo come primo figlio, usare. .prepend()).

I metodi .append() e .appendTo() svolgono lo stesso compito. La principale differenza è nella sintassi, in particolare, nel posizionamento dei contenuti e di destinazione.
Con append(), l'espressione che precede il metodo di selezione è il contenitore in cui è inserito il contenuto. Con .appendTo(), al contrario, il contenuto precede il metodo, sia come espressione di selezione o di markup creati al volo, ed è inserita nel contenitore di destinazione. Ecco cosa scrivere:

$('#questoDiv').append("<b>testo inserito</b>");

..che equivale a:

$('<p>testo inserito</p>').appendTo('#questoDiv');

Aggiungere / inserire elementi HTML dopo un elemento

Dobbiamo usare .insertAfter(), oppure .after()

Rimpiazzare un <div> con jQuery

$('#questoDiv').replaceWith('<div>Altro div</div>');

Rimuoviamo un elemento dopo gli effetti Fadeout e Slideup

Combiniamo più effetti in jQuery per animare e rimuovere un elemento dal DOM:

$("#myButton").click(function() {
        $("#myDiv").fadeTo("slow", 0.01, function(){ //fade
            $(this).slideUp("slow", function() { //slide up
            $(this).remove(); //e rimozione dal DOM
        });
});
});

...alla fine: Javascript Error Checker!

Adesso che abbiamo tutti questi script da utilizzare nel nostro sito, come testarli? Il debug di script javascript possono essere molto lunghi in termini di tempo. Così, se non riusciamo a risalire a che cosa sta causando gli errori, è possibile utilizzare questo strumento online gratuito: JSLint

Articoli correlati:

1. jQuery: imparare le basi con toggle. Mostra e nascondi con stile!
2. CSS3 Columns e jQuery: layout multi-colonne ad altezza pari

Purtroppo, anche se alcune di esse appartengono già alle specifiche CSS 2.1, non sono supportate da nesusn browser IE. Ecco allora che ci vengono in aiuto alcune librerie JavaScript che uniformano il comportamento di IE ai browser più recenti.

IE7.js è una libreria JavaScript (100kb) per far sì che Internet Explorer 6+ si comporti come un browser standard-compliant. Essa risolve molti problemi legati a HTML, CSS e fa funzionare correttamente con IE5 e IE6 le PNG trasparenti.
Scarichiamola e scegliamo di includere il JavaScript che ci permette di aggiornare tutti gli IE alla versione 9, così:

<!--[if lt IE 9]>
  <script src="IE9.js"></script>
<![endif]-->

Pseudoclassi: sintassi

Tutte le pseudo-classi seguono questa sintassi:

elemento:pseudoClasse {
...
}

Alcune pseudo-classi fanno uso anche delle parentesi. Per esempio, la pseudo-classe :not() dichiara quale regola CSS non applicare. Ciò è utile quando si desidera applicare qualcosa a tutto tranne a un certa classe/ID. Per esempio, questa dichiarazione:

.miaClasse:not(div) {
 background:#CCC;
}  

imposta uno sfondo di colore #CCC per tutti gli elementi che non siano div.

Utilizzo delle pseudo-classi

Pseudo-classi correlate ai link

Queste pseudo-classi applicano degli stili ai diversi stati di un link. Ecco di seguito la lista completa e cosa possiamo ottenere:

• :link applica uno stile a un link non visitato
• :visited applica uno stile a un link visitato
• :hover applica uno stile su un elemento al passaggio del mouse
• :active applica uno stile a un elemento attivo. Per esempio, un link è attivo da quando ci si clicca a quando si rilascia il click

A questo riguardo occorre ricordare che l’ordine sopra indicato non è casuale: in fatti, ogni pseudo-classe link-related ha una sua specificità.
Esiste una sorta di short-hand per ricordarsi la corretta successione: prendendo la lettera iniziale di ogni stato si ottiene "LVHA", che può essere ampliato a "LoVe HAte".

Pseudo-classi correlate a Input & link

• :focus applica uno stile a un elemento in uso. Per esempio, quando si scrive dentro una textarea, in quel momento essa è in uso
• :target se si dispone di un URL tipo index.html#about, questo permetterà di applicare i CSS per l’elemento con id="about"
• :enabled seleziona tutti gli elementi input in stato enable
• :disabled seleziona tutti gli elementi input in stato disabled
• :checked controllato nelle caselle di immissione selezionate
• :indeterminate seleziona i radio e i check-box, quando essi non sono né selezionata né non selezionata
• :required seleziona gli elementi input che sono required
• :optional seleziona gli elementi input che sono optional
• :invalid seleziona input non validi
• :in-range selziona elementi che sono in un range (da utilizzare con input type="range" in HTML5)
• :out-of-range seleziona elementi fuori dal range
• :default seleziona l’elemento di default, per esempio, in un form il bottone submit
• :valid seleziona un campo input valido (HTML5)

Pseudo-classi correlate alla posizione/numero

Ecco un esempio:

• :root applica uno stile CSS all’elemento radice, ossia il tag <html> in un documento HTML
• :first-child applica uno stile al primo figlio di un elemento
• :last-childapplica i CSS all’ultimo elemento contenuto. Esempio div p:last-child seleziona l’ultimo paragrafo d un div
• :nth-child(N) seleziona elementi numerati, su base 1. Per esempio, p:nth-child(3) seleziona l’elemento p che è il terzo figlio. Si possono anche aggiungere regole, per esempio p:nth-child(2n+1), dove n è il numero di partenza partendo da 0 e viene incrementato di 1. Perciò, questa regola seleziona tutti gli elementi pari (odd): in questo caso è equivalente a scrivere nth-child(odd), così come per i dispari si scrive nth-child(even)
• :nth-of-type(N) applicare i CSS a un elemento numerato di un certo tipo. Per esempio: div:nth-of-type(2) seleziona il secondo di quel tipo
• :nth-last-of-type(N) seleziona un elemento in base alla sua posizione, per esempio nth-last-of-type(4)
• :first-of-type applica i CSS solo al primo alemento di quel genere. Per esempio, se ci sono due div consecutivi, applica la regola solo al primo
• :last-of-type Seleziona l’utlimo elemento di un genere
• :only-child seleziona un elemento solo se è l’unico figlio del contenitore padre
• :only-of-type seleziona un elemento solo se esso è l’unico nel suo genere contenuto nell’elemento padre

Pseudo-classi relazionali

• :not(elemento | classe) applica una regola CSS solo agli elementi che non sono specificati tra le parentesi
• :empty applica i CSS a un elemento solo se è vuoto

Pseudo classi e paseudo elementi legati al testo

Pseudo-elementi

• :first-line definisce lo stile CSS della prima riga di un elemento
• :first-letter definisce lo stile CSS del primo carattere di un elemento

Pseudo-classi

• :lang() applica uno stile a un elemento che usa una lingua specifica, per esempio :lang(en) per l’inglese. È quindi possibile mettere lang = "en" in un tag HTML e impostare gli stili solo per esso
• ::selection permette di cambiare lo stile del testo selezionato nel browser
• :read-only seleziona gli elementi che sono read-only
• :read-write seleziona la parte editabile in un elemento

Content-related pseudo-elementi

• :before è in grado di aggiungere contenuti prima di un certo elemento
• :after è in grado di aggiungere contenuti, dopo un certo elemento

jQuery: pseudo-selettori CSS3

jQuery permette di usare tutti questi selettori, per esempio:

• :first funziona come :nth-child(1)
• :eq(X) è uguale a :nth-child(X)
• :contains('text')
• :lt(X)come :nth-child(-n+X), seleziona “i primi X elementi”
• :gt(X) è come :nth-child(n+X), seleziona tutto tranne “i primi (X-1) elementi”
• :even è come :nth-child(even) o :nth-child(2n)
• :odd è uguale a :nth-child(odd) o :nth-child(2n+1)
• :has(S) controlla se l’elemento contiene un certo discendente

Oltre a questi ve ne sono molti altri.

Selettori di discendenza

C’è una differenza tra figli e discendenti?

Vediamo come impostare degli stili CSS per capire come funzionano il combinatore figlio diretto, il combinatore fratello adiacente, e il combinatore fratello di pari livello.

Child: combinatore "figlio diretto"

Nel codice sottostante, dichiariamo una discendenza generica (Combinatore del discendente – Descendant), e di seguito, una diretta.

#child  p { color: #000;font-weight:normal; }
#child > p { color: #F00;font-weight:bold; }  

Adjacent sibling: combinatore "fratello adiacente"

Ecco come funziona adjacent sibling: in pratica appica lo stile all’elemento, se e solo se, esso è immediatamente successivo altro elemento indicato.

p + p { font-size: smaller; }
/* Applica lo stile solo al paragrafo che ne segue un altro (adiacente) */
#intro + ul { margin-top: 0; }
/* Applica lo stile solo alla lista che segue direttamente un elemento con  ID intro */

General sibling: combinatore "fratello generico"

General sibling è molto simile ad adiacent sibling: la differenza è che l’elemento che viene selezionato non ha bisogno di essere immediatamente successivo al primo elemento, ma può apparire ovunque dopo di esso. Ecco un esempio di general sibling:

p ~ p { background-color:#0F0; color:#FFF; padding:10px; }

Articoli correlati:

1. Tabelle HTML: come usarle, quando usarle
2. CSS3: compatibilità cross-browser…da oggi!
3. 10+ HTML5-CSS3 Website Template: per iniziare a progettare il web di domani!

CSS3 Columns

Attualmente solo Firefox, Safari e Chrome sono compatibili con il multi-columns. Mozilla utilizza il prefisso speciale moz-, mentre l’implementazione per Safari utilizza il prefisso -webkit, che abbinati alle regole ufficiali, permettono di creare layout multi-columns:

.columns {
  -moz-column-count: 3;
  -moz-column-gap: 1em;
  -moz-column-rule: 1px solid black;
  -webkit-column-count: 3;
  -webkit-column-gap: 1em;
  -webkit-column-rule: 1px solid black;
  column-count: 3;
  column-gap: 1em;
  column-rule: 1px solid black;
}

I browser ad oggi compatibili sono:

• Firefox 1.5+
• Safari 3+
• Chrome
• IE 9

Di seguito nel dettaglio ecco cosa abbiamo appena specificato per dividere il layout in colonne.

Column-count: come definire il numero di colonne

Abbiamo impostato column-count:3 per dividere il div che contiene il testo in tre colonne di uguale larghezza. Abbiamo inoltre specificato uno spazio tra le colonne, il column-gap:1em, che agisce come la proprietà padding, aumentando notevolmente la leggibilità. Notiamo che l’altezza delle colonne si adatta al contenuto di testo e che, aumentando il numero dei caratteri o la dimensione del testo, essa si adatterà per contenerlo. Di seguito il codice CSS3 che dovremo scrivere:

  column-count: 3;
  column-gap: 1em;

Column-width: impostare la larghezza delle colonne

Un altro modo per definire le colonne è impostare solo il column-width (e, come per l’esempio precedente, il column-gap). Per esempio, defininendo un column-width di 200px, tutte le colonne avranno 200 pixel di larghezza: il browser calcola di conseguenza quante colonne di questa larghezza possono inserirsi nell’elemento contenitore, e le crea in base a questo valore. Anche in questo caso, l’altezza delle colonne è definita dal contenuto testuale. Ecco cosa dobbiamo scrivere:

  column-width: 200px;
  column-gap: 1em;

Column-rule: dividere le colonne con dei filetti

La proprietà column-rule agisce come una sorta di border tra le colonne. Questa regola ha infatti le stesse proprietà del border: (larghezza, stile e colore), e come per esso, possono essere scritte tramite "shorthand":

/*Shorthand per column-rule*/
column-rule:1px solid black;
/*che equivale a:*/
column-rule-color: #000;
column-rule-style: solid;
column-rule-width: 1px;

Column-span: intestazione su più colonne

Questa proprietà non è ancora supportata da nessun browser.
Ecco cosa imposteremo nei fogli di stile con la regola CSS3 per espandere il titolo su più colonne::

/*Settiamo il numero delle colonne: n | all*/
column-span: all;

Colonne CSS3 cross-browser: Columnizer jQuery

Come abbiamo potuto notare, siamo ancora lontani dal poter utilizzare nella pratica la proprietà CSS3 multi-columns. Il framework jQuery ci mette però a disposizione un plugin che fa esattamente quanto abbiamo visto fin’ora. Ecco cosa dobbiamo fare: scarichiamo Columnizer jQuery Plugin e colleghiamolo alla nostra pagina HTML da dividere in colonne, così:

<script type="text/javascript" src="script/jquery-1.4.2.min.js"></script>
<script type="text/javascript" src="script/jquery.autocolumn.min.js"></script>  

Scriviamo poi in pagina il nostro contenuto, agganciandovi una classe, per esempio columns:

<h1>CSS3 e jQuery multi-column module</h1>
<div class="columns">
  <p>The Columnizer jQuery Plugin will automatically layout your content
  in newspaper column format. You can specify either column width or a static
  number of columns. And, of course, it’s easy to use!</p>
</div>  

Adesso agganciamo il plugin a questa classe, così:

$(document).ready (function() {
  $('.columns').columnize({columns:2});
});

Ecco cosa succede: il plugin suddivide il contenuto in div ai quali assegna una classe column: alla prima aggancia la classe first, all’ultima la classe last.

jQuery e le colonne ad altezza uguale

Terminiamo con un ottima funzione che permette di impostare uguale altezza per elementi flottanti, semplicemente includendo questo script e agganciandolo al .mioElementoFloattante:

$(document).ready(function(){
function equalHeight(group) {
   tallest = 0;
   group.each(function() {
      thisHeight = $(this).height();
      if(thisHeight > tallest) {
         tallest = thisHeight;
      }
   });
   group.height(tallest);
} ;
equalHeight($(".mioElementoFloattante"));

});
 

Di questa funzione è stato realizzato anche un plugin.

Articoli correlati:

1. CSS e float: blocchi flottanti e altezza del contenitore. Le soluzioni
2. CSS3: compatibilità cross-browser…da oggi!
3. 10+ HTML5-CSS3 Website Template: per iniziare a progettare il web di domani!

Server Side Include: cosa sono

I comandi Server Side Include sono dei semplici script utilizzati nelle pagine HTML e permettono di includere il contenuto (che può essere dinamico) di un documento in un altro, rendendo più facile la manutenzione del sito.
Il comando SSI "include" è probabilmente il comando più usato.
Il file o il parametro virtuale specifica il file (pagina HTML, file di testo, script, ecc.) da includere. Di solito, i server web non supportano SSI, tranne pochi, tra cui i Apache. Con Apache il file che include deve avere estensione shtml (cioèserver-parsed HTML, o Secure HTML), .shtm, o .stm, mentre il file che viene incluso può avere qualsiasi estensione. Se non viene attribuita al file che include un’estensione "shtml", l’inclusione non avviene. Solo i file con queste estensioni vengono infatti processati per trovare ed effettuare le direttive di inclusione. I files "html" e "htm" invece vengono "serviti" al client così come sono, senza essere processati, dal momento che Apache in questo modo sa a priori che non contengono inclusioni. Quando un file SSI viene analizzato (parsing) nel server, il server prende l’intero contenuto del file e lo inserisce nella pagina, sostituendo il codice incluso:

<!--#include file="mioFile.html" -->  

Come aggiungere il supporto SSI in Wamp

Ecco come procedere:

1. Cercare la cartella C:\wamp\bin\apache\Apache2.2.11\conf
2. Aprire il file http.conf
3. Cercare

   <IfModule mime_module>...</IfModule>

   e aggiungervi il seguente codice:

   AddType text/html .shtml
Options +Includes
AddOutputFilter INCLUDES .shtml

4. poi trovare Options Indexes FollowSymLinks e sostituirlo con:

   Options +Indexes +FollowSymLinks +Includes

5. Riavviare tutti i servizi.

Suggeriscimi un argomento!

L’introduzione dei CSS3 permetterà di realizzare siti web più flessibili e di ridurre i costi di sviluppo e di manutenzione. Per utilizzare già adesso la maggior parte delle proprietà CSS3, dobbiamo usare le specifiche estensioni del browser assieme alle proprietà originali. Le estensioni più comuni sono quelle usate per i browser basati su WebKit (per esempio, Safari), che iniziano con -WebKit, e browser basati su Gecko (per esempio, Firefox), che si aprono con -moz-. Konqueror (-KHTML-), Opera (-o) e Internet Explorer (-ms-) hanno le loro estensioni proprietarie. Come designer professionisti, dobbiamo tenere a mente che l’utilizzo di queste proprietà specifiche non permettere di validare i fogli di stile. Ma in alcuni casi, per sperimentare o per apprendimento, possiamo affiancarla alle proprità CSS validate.

Ma esattamente quali tecniche CSS3 possiamo già usare oggi?

Ecco di seguito le principali novità CSS3 e la compatibilità con i maggiori browser, da testare con i file di esempio.

CSS3: angoli arrotondati

Ecco il codice, utilizzato per realizzare i bordi arrotondati:

.box_round {
     -moz-border-radius: 12px; /* FF1+ */
     -webkit-border-radius: 12px; /* Saf3+, Chrome */
     border-radius: 12px; /* Opera 10.5, IE 9 */
	}

• Firefox 1+
• Safari3+
• Chrome
• Opera 10.5
• IE 9

Una valida soluzione alternativa, realmente cross-browser (compreso IE6+), basata su JavaScript, è rappresentata da jQuery Corner. Update! Ecco come risolvere il bug dei bordi arrotondati su immagini di sfondo.

CSS3: ombra esterna

Le nuove dichiarazioni CSS3 permettono di proiettare ombra esterna da un oggetto. Per tutti i browser, tranne IE6-7-8, dopo la dichiarazione della proprietà, il primo valore consente di spostare l’ombra lungo l’asse x, il secondo la muove sull’asse delle y, il terzo gestisce il livello di blur, mentre l’ultimo definisce il colore. le versioni di IE sotto la 9, utilizzano invece filter.

Ecco un un esempio di elementi con ombra esterna:

.box_shadow {
	-moz-box-shadow: 0px 0px 4px #000000; /* FF3.5+ */
	-webkit-box-shadow: 0px 0px 4px #000000; /* Saf3.0+, Chrome */
    box-shadow: 0px 0px 4px #000000; /* Opera 10.5, IE 9.0 */
    filter: /* IE6,IE7 e IE8 */
    progid:DXImageTransform.Microsoft.Shadow(color=#dddddd,direction=0,strength=5) /* top */
    progid:DXImageTransform.Microsoft.Shadow(color=#dddddd,direction=90,strength=5) /* left */
    progid:DXImageTransform.Microsoft.Shadow(color=#dddddd,direction=180,strength=5) /* bottom */
    progid:DXImageTransform.Microsoft.Shadow(color=#dddddd,direction=270,strength=5);  /* right */
}

• Firefox 3.5+
• Safari3+
• Chrome
• Opera 10.5
• IE6+

CSS3: sfumatura a gradiente verticale

Ecco cosa usare e per ottenere una sfumatura verticale. Da notare il mancato supporto di Opera:

.box_gradient {
  background-image: -moz-linear-gradient(top, #444444, #999999); /* FF3.6 */
  background-image: -webkit-gradient(linear,left top,left bottom,color-stop(0, #444444),color-stop(1, #999999)); /* Saf4+, Chrome */
  filter:  progid:DXImageTransform.Microsoft.gradient(startColorstr='#444444', endColorstr='#999999'); /* IE6,IE7 */
  -ms-filter: "progid:DXImageTransform.Microsoft.gradient(startColorstr='#444444', endColorstr='#999999')"; /* IE8 */
}

• Firefox 3.6
• Safari4
• Chrome
• IE6+

CSS3: effetto traparenza

Ecco come settare i CSS per ottenere un effetto trasparenza cross-browser. Di seguito il codice (notiamo che il filtro si comporta in questa maniera: il codice completo è #60CCFF00 dove 60 è l’Alpha, mentre il codice colore vero e proprio è CCFF00. Attenzione!):

.box_rgba_1 {
	background-color: rgba(204, 255, 0, 0.6);  /* FF3+, Saf3+, Opera 10.10+, Chrome */
   filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#60CCFF00',endColorstr='#60CCFF00'); /* IE6,IE7 */
   -ms-filter: "progid:DXImageTransform.Microsoft.gradient(startColorstr='#60CCFF00',endColorstr='#60CCFF00')"; /* IE8 */
}

• Firefox 3+
• Safari3+
• Opera 10.10+
• Chrome
• IE6+

CSS3: rotazione

Ecco come realizzare una rotazione cross-browser solo con i CSS: per prima cosa scaricate il file -ms-transform.htc e salvatelo nella cartella dei file CSS. Poi settate le regole come segue:

.rotate {
	behavior:url(-ms-transform.htc); /* IE6+ */
    -moz-transform:rotate(45deg); /* FF3.5+  */
    -webkit-transform:rotate(45deg); /* Saf3.1+, Chrome */
    -o-transform:rotate(45deg); /* Opera 10.5 */
    -ms-transform:rotate(45deg); /* IE */
}

• Firefox 3.5+
• Safari3.1+
• Opera 10.5+
• Chrome
• IE6+

…ed ecco come appaiono dei div ruotati.

CSS3: @font-face

Prima di iniaziare, ecco una guida essenziale al @font-face.
Scarichiamo un font e generiamo le regole CSS3.
La regola di base che ci serve per includere i font in pagina poggia sulla direttiva @font-face: occorre definire una regola @font-face per ciascun font che intendiamo utilizzare:

@font-face {
	font-family: 'IlMioFont';
	src: url('ballpark_weiner.eot'); /* IE6+ */
	src: local('Ballpark'),
		 local('IlMioFont'),
		 url('ballpark_weiner.woff') format('woff'), /* FF3.6 */
		 url('ballpark_weiner.ttf') format('truetype') /* Saf3+,Chrome,Opera10+ */
	;
}

…e usare i nostri font nelle dichiarazioni CSS consuete. In questo modo:

#ilMioSelettore {
	font:30px 'IlMioFont', Georgia, serif;
	color:#000;
}

• Firefox 3.6+
• Safari3+
• Opera 10+
• Chrome
• IE6+

Articoli correlati:

1. 10+ HTML5-CSS3 Website Template: per iniziare a progettare il web di domani!
2. CSS3 Columns e jQuery: layout multi-colonne ad altezza pari
3. CSS Pseudo-classi: come usarle su IE6+!

Novità in HTML5

HTML5 introduce nuove caratteristiche per uno sviluppo più facile delle applicazioni web improntate alla multimedialità e una gestione più sofisticata dei form, assieme a una presentazione più semantica del codice: nuovi elementi tag, nuovi input type, nuovi attributi ed eventi, nuove API.
Ecco di seguito una lista di tutte le principali novità e le anteprime:

1. Nuovi elementi HTML5

Elementi strutturali più semantici

• article contrassegna gli articoli di una sezione
• aside delimita informazioni aggiuntive
• footer rappresenta la sezione conclusiva della pagina
• header contiene i contenuti principali eventualmente raggruppati con hgroup
• nav raggruppa gli elementi di navigazione principale
• section distingue le sezioni di un documento, come se fossero capitoli di un libro

e torna nell’HTML, dopo essere stato deprecato dalla versione 4.01, il tag

• menu usato per una specifica lista di comandi

Interattività

• canvas permette il rendering dinamico delle bitmap
• command definisce un command button
• details rappresenta informazioni aggiuntive

Maggiore semantica in pagina e lingue asiatiche

• figure raggruppa elementi multimediali e le loro didascalie
• mark mette in risalto una porzione di testo rilevante
• rp, rt e ruby sono usati per le parentesi e per le annotazioni di Ruby

Multimedialità nativa

• audio consente la riproduzione audio nativa nel browser
• embed inserisce una applicazione esterna
• source specifica più sorgenti di un video o di un audio
• video definisce un video

Form migliorati

• datalist fornisce una sorta di auto-complete
• keygen definisce una coppia di keygen generate
• output rappresenta il risultato di un calcolo

Tempo e unità di misura

• meter definisce le unità di misura
• progress indica lo stato di avanzamento di un compito
• time specifica il formato di una data

Alcuni tag già definiti nella versione 4.01, in HTML5 assumono nuove proprietà. Ecco i principali nel dettaglio:

• il tag a potrà contenere elementi a livello di blocco, è potrà essere privo dell’attributo href, per essere usato come "link placeholder"
• l’elemento address potrà essere applicato a una specifica sezione section o articolo article
• l’elemento b verrà utilizzato solo per rendere il testo più marcato, senza particolari valenze keyword-SEO
• blockquote diventa un elemento sectioning root
• l’elemento dl rappresenta un elenco di associazioni composto da zero o più coppie nome-valore
• i tag h1, h2… possono essere ripetuti all’interno di ogni sezione della pagina
• l’elemento html potrà avere un proprio id
• il tag i verrà usato per indicare il testo da pronunciare con un particolare tono di voce, o testo che appartiene a un linguaggio tecnico, o una frase che nel contesto da cui è presa viene rappresentata con testo "italic"

2. Nuovi input type

Ecco la lista dei campi input si potranno utilizzare con HTML5:

• color
• date
• datetime
• datetime-local
• email
• number
• range
• search
• tel
• time
• url
• week

Articoli correlati:

1. 10+ HTML5-CSS3 Website Template: per iniziare a progettare il web di domani!
2. Cosa è HTML5? Ecco una infografica che lo spiega!
3. Cheat Sheets per il Web Design

Eccoli riassunti:

• i visitatori devono avere Flash e JavaScript installati e attivati: altrimenti verrà mostrato il testo con l’eventuale presentazione CSS
• sIFR non offre piena compatibilità per dispositivi mobili quali PDA e telefoni cellulari
• il suo utilizzo potrebbe rallentare il caricamento del sito

sIFR: come funziona

Il principio di funzionamento di sIFR è un misto tra CSS, Javascript e Flash. Vediamolo in dettaglio:

• Javascript, se abilitato, verifica la presenza del Flash Player
• In caso positivo, lo script individua gli elementi definiti da un sorta di selettore CSS passato come argomento della funzione principale
• Questi elementi vengono nascosti da Javascript, e il loro contenuto è passato attraverso le flashVars ad un filmato Flash che incorpora un font specifico
• Il filmato Flash, contenente il testo da rimpiazzare (che sarà selezionabile con il mouse) verrà quindi mostrato, cercando di occupare la stessa area del testo che sostituisce (da qui il termine "scalable").

sIFR: dove usarlo

Con sIFR potremo rimpiazzare titoli, link (anche con effetto hover) e intere sezioni di testo, dato che ha il supporto per il testo multi-linea. Andrebbe però usato esclusivamente per i titoli, e preferibilmente andrebbe evitato sui link. Questi infatti vengono "mascherati" da Flash, e non sarà possibile con sIFR attivo controllare dove porta un link sulla barra di stato del browser.

sIFR: file necessari

Per prima cosa occorre scaricare l’utlima versione di sIFR o la versione ufficiale 2.0.7. Per questo tutorial useremo la versione sIFR 3 r419, contenente solo i file di cui abbiamo bisogno:

• css/sIFR-print.css, che contiene gli stili per la stampa
• css/sIFR-screen.css, che contiene gli stili per il Web
• js/sifr.js, che contiene il "core" di sIFR (da non modificare)
• js/sifr-config.js, che serve per definire e attivare sIFR
• flash/sifr.fla (con i relativi file .as), che serve per inserire il font

Di seguito tutte le risorse usate per completare l’esempio, e una anteprima del risultato.

sIFR: impostare Flash per inserire il font

Per prima cosa occorre procurarsi il font da includere nel file swf. Per questo esempio useremo Fontin, liberamente utilizzabile.
Per formattare correttamente i diversi stili, il font deve essere OpenType TT, cioè avere tutti gli stili inclusi.
Scarichiamolo e installiamolo nel sistema operativo.
Fatto questo, apriamo con Flash il file sifr.fla: il file è suddiviso in livelli. Facciamo doppio clic sulla stage per visualizzare il testo Bold, Italic e Normal.
Clicchiamo poi nella riga di testo: nel pannello Proprietà scegliamo Fontin. Per includere gli stili, applichiamoli rispettivamente al testo Bold, Italic e Normal.
Senza modificare altro esportiamo il filmato: File->Export->Export Movie, facendo attenzione a selezionare Filmato SWF tra le impostazioni. Chiamiamo il filmato fontin.swf

sIFR: caricare i file in pagina

All’interno del tag head inseriamo i collegamenti ai file necessari:

<link rel="stylesheet" href="css/sIFR-screen.css" type="text/css" media="screen" />
<link rel="stylesheet" href="css/sIFR-print.css" type="text/css" media="print" />
<script src="js/sifr.js" type="text/javascript"></script>
<script src="js/sifr-config.js" type="text/javascript"></script>

sIFR: configurare e attivare il font

Per configurare sIFR apriamo il file vuoto sifr-config.js.
Quello che ci accingiamo a fare è definire il nome del font e il link al file flash:

var fontin = {
   src: 'flash/fontin.swf'
};

Abbiamo definito una variabile che si collega al nostro file Flash. Questo comando non fa ancora niente, fintantoché non la attiviamo digitando il comando di attivazione:

sIFR.activate(fontin);

Adesso abbiamo bisogno di definire quale testo deve essere sostituito con il testo in flash. Per fare questo, usiamo il comando di sostituzione in sIFR3:

sIFR.replace(fontin, {
   selector: 'h2'
});

Abbiamo appena sostituito tutto il testo contenuto nel tag h2, ma possiamo sostituire il testo dentro qualsiasi tag, anche se questo, come detto prima, potrebbe rallentare sensibilmente il caricamento del sito.

sIFR: applicare gli stili

Ora che sIFR3 funziona, abbiamo bisogno di applicare gli stili, cosa che facciamo modificando di nuovo il file sifr-config.js file e il file sIFR-screen.css.
Apriamo il file sIFR-screen.css: non modifichiamo le righe di codice che si trovano dopo /*---- sIFR ---*/, e occupiamoci di ciò che si trova dopo /*---- Header styling ---*/.
Specifichiamo la classe .sIFR-active e impostiamo la visibilità su "nascosto", per rendere visibile solo il testo rimpiazzato:

/*---- Header styling ---*/

.sIFR-active h2 {
  visibility:hidden;
  font-size:40px;
  padding:0;
  margin:0;
}

Adesso andiamo a modificare il colore del font, il colore di sfondo e il line-height, ma non solo.
Per modificarle, dobbiamo inserirle nel file sifr-config.js, in questo modo, richiamando la funzione CSS, facendo attenzione alla posizione delle virgole:

sIFR.replace(fontin,{
  selector: 'h2'
  ,css: [
  	'.sIFR-root { color: #FAC421; background-color: #FFFC7F; }'
 ]
});

Ecco a cosa fare attenzione: i comandi sono posti tra " ‘ "e una "," deve essere aggiunta dopo ogni comando, fatta eccezione per l'ultimo. Una cosa importante è che bisogna scrivere i codici dei colori nella loro forma completa, cioè #FFFFFF, non #FFF. Inoltre, come anticipato sopra, per ottenere la proprietà line-height, dobbiamo utilizzare leading, oppure ricorrere ai metodi JavaScript.

sIFR: modifiche avanzate sul testo

Adesso ci accingiamo a settare il file sifr-config.js in modo che il testo assuma comportamenti personalizzati, per esempio, cambiare colore del carattere e dello sfondo, o applicare i filtri (di Flash).
Applichiamo le modfiche a una classe CSS chiamata multicolor associata a un altro titolo, questa volta h3:

sIFR.replace(fontin,{	selector: 'h3.multicolor'
	,css: [
    	'.sIFR-root { color: #775555; background-color: #010101; }'
        ,'em { font-style: italic; color: #444477; }'
        ,'strong { color: #44aa44; }'
        ,'.bold { font-style:bold; text-decoration:underline; }'
        ,'a { color: #aa4444; }'
        ,'a:hover { color: #bbbb44; }'
    ]
});

Facciamo la stessa cosa con la classe glow e shadow. Nell’esempio vediamo cosa succede.

Come potete notare, quando clicchiamo sul testo rimpiazzato da sIFR, si forma un bordo tratteggiato. Possiamo rimuoverlo agendo sul tag object, così:

.sIFR-active object  {
	outline:none;
	display: block;
}

Articoli correlati:

1. GDI++: come installare il font rendering del Mac su Pc