Dec 302012
 

Una delle basi necessarie per lavorare agevolmente con jQuery è padroneggiare gli array. In questo esempio vedremo come aggiungere alla pagina gli elementi dell’array scorrendolo tramite un ciclo each.

Partiamo dall’html:

 <!DOCTYPE html>
 <html lang="en">
 <head>
 <title>La funzione each()</title>
 </head>
 <body>
 <h2>Questo esempio mostra come usare la funzione each() per appendere una lettera prima di ogni paragrafi</h2>
 <p>Primo</p>
 <p>Secondo</p>
 <p>Terzo</p>
 </body>
 </html>
 

Lo script verrà  aggiunto alla fine dell’html prima della chiusura del tag body: questo darà  come vantaggio un più veloce rendering dell’html senza attendere il download delle risorse altrimenti poste nel tag head.

 <script src="http://code.jquery.com/jquery-1.7.2.min.js"></script>
 <script>
 $(document).ready(function() {
 var values = ['a', 'b', 'c', 'd'];
 });
 </script>
 

Posizionarci alla fine dell’html non ci dispensa dall’utilizzare il $(document).ready
L’ideale sarebbe mettere tutto questo codice in un file esterno.
Dichiarato l’array, possiamo procedere con il primo ciclo:

 $.each(values, function(index, value) {
 values[index] = value.toUpperCase();
 });
 

Con questo ciclo trasformamo in lettere maiuscole gli elementi del nostro array,
l’esempio evidenzia sia l’indice del ciclo, sia l’elemento (value) in esame nello step.

Il secondo ciclo aggiunge un trattino prima di ogni paragrafo, infatto si tratta di un ciclo sui ‘p’:

 $('p').each(function(index, el) {
 $(el).prepend(' - ');
 });
 

Infine il terzo ciclo, sempre sui paragrafi, aggiunge l’elemento preso dall’array:

 $('p').each(function(index) {
 $(this).prepend(values[index]);
 });
 

L’esempio

Dec 082012
 

Proviamo a costruire un feetto lightbox fatto in casa.

Ovviamente esistono molti plugin che fanno questo in modo estremamente evoluto, ma il nostro scopo è vedere un po’ cosa c’è dietro le quinte e magari avere una base per delle personalizzazioni.

Come risorse esterne serve solo jQuery e due immagini, un ajax loader per avvisare l’utente della richiesta e l’immagine naturalmente.

Nell’html mettiamo solo un contenitore on un link dove specifichiamo nell’href il path dell’immagine.


<div id=”contenitore”>
<a href=”images/mare.jpg”>pic</a>
</div>

Il css conterrà la formattazione per un overlay fra la pagine e l’immagine e l’id lightbox vero e proprio:


#overlay {position: fixed;top: 0;left: 0;height: 100%;width: 100%;background: black url(images/loader.gif) no-repeat scroll center center;}
#lightbox {position: fixed;}

Quindi prima cosa al caricamento bind del click sul nostro link:


$(‘a.lightbox’).click(function(e) {

Quindi nascondiamo la scrollbar:


$(‘body’).css(‘overflow-y’, ‘hidden’);

E poi appendiamo al body il div overlay, va appeso al top della pagina e animato in modo che da opacità 0, completamente opaco, arriva a semitrasparente:


$(‘<div id=”overlay”></div>’)
.css(‘top’, $(document).scrollTop())
.css(‘opacity’, ’0′)
.animate({‘opacity’: ’0.5′}, ‘slow’)
.appendTo(‘body’);

Appendiamo al body anche il div lightbox, ma nascosto:


$(‘<div id=”lightbox”></div>’)
.hide()
.appendTo(‘body’);

Creiamo l’immagine leggendo il src dall’href su cui c’è stato il click:


$(‘<img>’)
.attr(‘src’, $(this).attr(‘href’))

 

e la carichiamo:


.load(function() {
positionLightboxImage();
})

A caricamento avvenuto la posizioniamo con una funzione ad hoc al centro della pagina e la mostriamo con il adeIn(), era nascosta prima:


function positionLightboxImage() {
var top = ($(window).height() – $(‘#lightbox’).height()) / 2;
var left = ($(window).width() – $(‘#lightbox’).width()) / 2;
$(‘#lightbox’)
.css({
‘top’: top + $(document).scrollTop(),
‘left’: left
})
.fadeIn();
}

Al click sull’immagine al contrario la nascondiamo, o meglio, la rimuoviamo del tutto:


.click(function() {
removeLightbox();
})
function removeLightbox() {
$(‘#overlay, #lightbox’)
.fadeOut(‘slow’, function() {
$(this).remove();
$(‘body’).css(‘overflow-y’, ‘auto’); // show scrollbars!
});
}

Rirpistinando con questa funzione quindi lo stato iniziale della pagina:

Esempio

Nov 202012
 

jQuery nelle sue successive versioni ha cambiato più volte la modalità di associazione degli eventi agli oggetti html.
Il problema è particolarmente evidente quando dobbiamo assegnare un evento a un oggetto che viene aggiunto successivamente al caricamento alla nostra pagina, come, per esempio, nel caso di ajax.

All’inizio si usava il live, successivamente delegate, adesso on; i vecchi metodi sono supportati ma sconsigliati.

Proviamo quindi l’on, costruiremo una pagina con un bottone, al click creeremo un secondo bottone sul quale gestire a sua volta il click.
Partiamo dall’html:


<div id=”pulsanti”>
<input type=”button” id=”btn1″ value=”box1″>
</div>
<div id=”box1″></div>

Il css minimo:

.box{ width:300px; min-height:100px; border:1px solid #000; margin:10px;}

Al document.ready procediamo con la creazione del pulsante:

$(document).ready(function(e) {
$(‘#btn1′).click(function(){$(‘#pulsanti’).append(‘<input type=”button” id=”btn2″ value=”Append”>’);})
});

A questo punto si tratta di gestire l’evento click sul btn2 e useremo appunto on:

$(‘#pulsanti’).on(‘click’,'#btn2′,aggiungi)

con i parametri evento, selettore, callback, in questo caso si poteva anche usare una funzione anonima.

E se volessimo disablitare il click dopo l’esecuzione di un aggiungi? La risposta è intuitiva: off,
così gestiremo uno e un solo click sul btn2:


function aggiungi(){
$(‘#pulsanti’).off(‘click’,'#btn2′)
}

Esempio

Nov 172012
 

Oggi proviamo a usare il trigger. Che cos’è?
Beh diciamo un evento virtuale, o meglio nel nostro codice associamo un evento a un azione che l’utente dovrebbe compiere,
ma indeterminate circostanze scateneremo noi l’evento da programmazione.

Preparimao due bottoni e due div, semplicemente ciascun bottone nasconde un div.
L’html:


<input type=”button” id=”btn1″ value=”box1″>
<input type=”button” id=”btn2″ value=”box2″>
<div></div>
<div id=”box1″></div>
<div id=”box2″></div>

Il css:

.pulisci{ clear:left;}
.box{ width:100px; height:100px; float:left; margin:10px;}
#box1{ background-color:#F60;}
#box2{ background-color:#F6F;}

Il comportamento normale sarebbe questo:


$(document).ready(function(e) {
$(‘#btn1′).click(function(){$(‘#box1′).hide();})
$(‘#btn2′).click(function(){$(‘#box2′).hide();})
});

Bottone->click->nascondo div associato.

Ora supponiamo di voler far in modo che cliccando sul secondo div si nasconda anche il primo,
ovviamente potremmo lavorare sui selettori, ma seguiremo la via del trigger, così:


$(‘#btn2′).click(
function(){
$(‘#box2′).hide();
$(‘#btn1′).trigger(‘click’);
})

Cioè oltre a nascondere il box verrà scatenato un click sul btn1 che quindi nasconderà il primo box.

Esempio

Nov 142012
 

Proseguiamo il lavoro impostato nel precendete post e concretizziamo il drag&drop memorizzando le informazioni con opportune chiamate ajax.
Andremo ad aggiungere anche alcune funzionalità piuttosto comuni.

Ci portiamo nell’area droppable e aggiungiamo l’evento drop:

drop:function(event,ui){
var id=ui.draggable.attr(‘id’);

recuperiamo l’id dell’elemento trascinato, quindi lo mandiamo al server web per l’inserimento nel db:

$.ajax({
type:’GET’,
url:’dati/inserisci.php?id=’+id,
success:function(str){
if(str==’OK’){

se va tutto bene aggiungiamo l’elemento alla landing area, insieme a un campo quantità e a un link elimina:


if(str==’ok’){
$(‘<div id=”elemento_’+id+’”></div>’)
.append(ui.draggable.html())
.append(‘<input type=”text” id=”qt_’+id+’” value=”1″ /><br />’)
.append(‘<a href=”#’+id+’”>Elimina</a>’)
.appendTo(‘#landing_area’)
$(‘#’+id).fadeOut(2000);
}

infine nascondiamo l’elemento dalla lista dei draggable

Restano da gestire l’input della quantità e il link elimina.
Useremo il metodo live perché vengono creati runtime, anche se sarebbe preferibile usare on

Quindi procediamo con 3 operazioni relative all’elimina:
1. rimettiamo l’elemnto nella lista
2. lo rimuoviamo dalla landing area
3. lo cancelliamo dal database:

$(‘#landing_area a’).live(‘click’, function(){
var id=$(this).attr(‘href’);
$(id).fadeIn(2000);
$(this).parent().remove();
//rimuovere dal db
$.get(‘data/test.php?id=’+id,function(){/**/})
})

si noti la forimula this parente per rimuovere l’elemnto padre del link

Per quanto riguarda la quantità molto più semplicemente si tratta di fare un update:

$(‘#landing_area input’).live(‘blur’, function(){
var id=$(this).attr(‘id’);
var qt=$(this).val();
//aggiorna qt su db
$.get(‘data/test.php?id=’+id+’&qt=’+qt,function(){/**/})
})

quindi leggo i valori e li invio al server web.

L’esempio

Nov 112012
 

Vediamo come trascinare determinati elementi all’interno di un’area di atterraggio selezionata.
Nell’html andiamo ad impostare, all’interno di un contenitore, 5 div che trascineremo e un’area di atterraggio:

<div id="contenitore"><div id=”box1″><p>Prodotto 1</p></div>
<div id=”box2″><p>Prodotto 2</p></div>
<div id=”box3″><p>Prodotto 3</p></div>
<div id=”box4″><p>Prodotto 4</p></div>
<div id=”box5″><p>Prodotto 5</p></div>
<div id=”landing_area”></div></div>
<div>

Per comodità i div da trascinare hanno id e la medesima classe, questo velocizzerà anche la creazione del css:

.box{ width:100px; height:60px; border:1px solid #000; margin-bottom:10px; padding:5px; z-index:1;}
#box1{ background-color:#FC0;}
#box2{ background-color:#9CF;}
#box3{ background-color:#96F;}
#box4{ background-color:#6C9;}
#box5{ background-color:#9F3;}
#landing_area{ width:200px; height:300px; position:absolute; top:8px; left:200px; padding:5px; border:2px solid #900; z-index:0; }

Lo stile è spartano, serve solo per distinguere gli oggetti.
Si noti però che gli elementoi da trascinare hanno uno z-index superiore all’area di atterraggio.

Per la nostra attività necessitiamo di Jquery e jQuery UI:


<script src=”https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js”></script>
<script src=”http://code.jquery.com/ui/1.9.0/jquery-ui.js”></script>

che includiamo nell’head della pagina insieme al css di default:


<link rel=”stylesheet” type=”text/css” href=”http://code.jquery.com/ui/1.9.0/themes/base/jquery-ui.css” />

A questo punto rendiamo trascinabile tutti gli elementi di classe box:

$(document).ready(function(e) {
$(‘.box’).draggable();
})

Se vogliamo arricchire i comportamenti, possiamo aggiungere una classe che rende trasparente l’oggetto appena iniziamo a trascinarlo e facciamo in modo che una volta rilasciato torni al suo posto:

$(‘.box’).draggable({
revert:true,
start:function(event,ui){$(this).addClass(‘movimento’);},
stop:function(event,ui){
$(this).removeClass(‘movimento’);
}
});

La classe movimento aggiunge solo l’opacità:

.movimento{ opacity:0.5;}

al rilascio ovviamente la togliamo

Volete sapere dove avete rilasciato il vostro oggetto?
La pagina è un piano cartesiano, quindi:

var top=ui.position['top'];
var left=ui.position['left'];
alert(top+’ ‘+left);

Infine predisponiamo l’area di atterraggio:

$(‘#landing_area’).droppable({
accept:’.box’,
tolerance:’fit’
});

Dove stabiliamo gli elementi che accettiamo, tutta la classe box e quando li possiamo considerare all’interno dell’area
con il parametro tolerance, a volte potrebbe bastare toccare le pareti, altre volte bisognerà essere completamente all’interno

Esempio

Nov 082012
 

Fra le animazioni previste dal core di jQuery allo stato attuale non è possibile laovrare con il colore,

per esempio per modificare il colore di sfondo. Per raggiungere questo effetto è necessario fare ricorso a jQuery UI

Prepariamo una pagina con il collegamento al tema base a jQuery e a jQuery UI:


<link rel=”stylesheet” href=”http://code.jquery.com/ui/1.9.0/themes/base/jquery-ui.css” />
<script src=”http://code.jquery.com/jquery-1.8.2.js”></script>
<script src=”http://code.jquery.com/ui/1.9.0/jquery-ui.js”></script>

Inseriamo nell’html un link trasformato in pulsante e un div sul quale applicare l’effetto:


<a href=”#” id=”button” class=”ui-state-default ui-corner-all”>Cambia colore</a>
<div id=”effect”><p>Etiam libero neque, luctus a, eleifend nec, semper at, lorem. Sed pede. Nulla lorem metus, adipiscing ut, luctus sed, hendrerit vitae, mi.</p></div>

Lo stile ci servirà solo per determinare le dimensioni:


<style>
#button { padding: .5em 1em; text-decoration: none; }
#effect { width: 240px; height: 135px; padding: 0.4em; background: #fff; }
</style>

Al caricamento potremo associare il click sul nostro bottone che animerà il div modificando il colore di sfondo:


$( “#effect” ).animate({backgroundColor: “#aa0000″,color: “#fff”}, 1000 );

Se poi vogliamo ripristinare la situazione possiamo usare una variabile state e gestire tutto nello stesso click:


$(function() {
var state = true;
$( “#button” ).click(function() {
if ( state ) {$( “#effect” ).animate({backgroundColor: “#aa0000″,color: “#fff”}, 1000 );}
else {$( “#effect” ).animate({backgroundColor: “#fff”,color: “#000″}, 1000 );
}
state = !state;
});
});

L’esempio

Nov 062012
 

Proviamo alcuni effetti contenuti nella nota libreria jQuery UI.

Come prima cosa prepariamo nell’html della pagina un bottone e un elemento sul quale applicare il nostro effetto:


<a href=”#” id=”button”  class=”ui-state-default ui-corner-all”>Run Effect</a>
<div id=”effect”  class=”ui-widget-content ui-corner-all”>
<p>Etiam libero neque, luctus a, eleifend nec, semper at, lorem. Sed pede. Nulla lorem metus, adipiscing ut, luctus sed, hendrerit vitae, mi.</p>
</div>

Come si può notare  sia al link sia al div sono state applicate delle classi standard dei temi di jQuery UI per ottenere degli effetti un po’ più gradevoli dove questi sono supportati.

Lo stile è essenziale e nemmeno troppo significativo nel nostro esempio:


<style>
#button { padding: .5em 1em; text-decoration: none; }
#effect { width: 240px; height: 135px; padding: 0.4em; }
</style>

Mentre da non trascurare è l’inclusione del tema e delle librerie nell’head della nostra pagina:


<link rel=”stylesheet” href=”http://code.jquery.com/ui/1.9.0/themes/base/jquery-ui.css” />
<script src=”http://code.jquery.com/jquery-1.8.2.js”></script>
<script src=”http://code.jquery.com/ui/1.9.0/jquery-ui.js”></script>

Quindi al caricamento dell’html possiamo mappare l’evento click sul link e lanciare l’animazione:


$(document).ready(function(){
$(“#button”).click(function() {
$(“#effect”)
…
})
});

L’animazione userà il metodo animate() di jQuery esteso da effetti presenti in jQuery UI:


.animate({height: “hide”}, 1500, “easeOutBounce”)

easeOutBounce mi serve per dare l’effetto “rimbalzo”

A questo punto aspettimao un momento prima di srotolare nuovemnte il nostro div:


.delay( 800 )
.animate({height: “show”}, 1500, “easeOutBounce”)

L’esempio

Nov 022012
 

Creiamo una pila di foto dandogli come effetto quello di essere buttate a caso una sopra l’altra nel loro contenitore e le sfogliamo cliccandoci sopra.

Come prima cosa pre pariamo in javascript l’array delle nostre immagini:


var foto=new Array(12);
foto[0]=’/foto/DSC00077.JPG’;
foto[1]=’/foto/DSC00078.JPG’;

tutte quelle che vogliamo.

In secondo luogo prepariamo un div contenitore e una lista che popoleremo con le nostre foto.


<div id=”contenitore”><ul id=”griglia”></ul></div>

Passiamo al css, quello di routine innanzitutto:


body {font-family: “Lucida Grande”, Verdana, Arial, sans-serif;}
#contenitore{ margin:50px auto; width:300px;}
#griglia { padding:0; margin:0; list-style:none; width:300px; height:300px; }
#griglia li { padding:0; margin:0; list-style:none; }

Poi passiamo alle cose specifiche, le liste saranno posizionate in modo assoluto:


.foto{position: absolute;}

questo ci serve per posizionarle una sopra l’altra.

Per dare l’effetto di sovrapposizione casuale, le foto dopo la prima saranno leggermente ruotate ciascuna in una direzione diversa, usando quindi le proproetà di css3:


.foto:nth-last-child(2) img{-webkit-transform: rotate(-5deg);-moz-transform: rotate(-5deg);-o-transform: rotate(-5deg);-ms-transform: rotate(-5deg);transform: rotate(-5deg);}
.foto:nth-last-child(3) img{-webkit-transform: rotate(5deg);-moz-transform: rotate(5deg);-o-transform: rotate(5deg);-ms-transform: rotate(5deg);transform: rotate(5deg);}
.foto:nth-last-child(4) img{-webkit-transform: rotate(7deg);-moz-transform: rotate(7deg);-o-transform: rotate(7deg);-ms-transform: rotate(7deg);transform: rotate(7deg);}
.foto:nth-last-child(5) img{-webkit-transform: rotate(-7deg);-moz-transform: rotate(-7deg);-o-transform: rotate(-7deg);-ms-transform: rotate(-7deg);transform: rotate(-7deg);}

in questo modo non risulteranno esattamente sovrapposte.

Successivamente diamo dimensioni, bordo e ombra alle nostre foto:


.foto img { max-width: 100%; height: auto; border: 5px solid #fff; -webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;-webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4);-moz-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4);box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4);}

Non resta che aggiungerle alla pagina tramite jQuery.

Al document.ready

facciamo un ordinamento random dell’array

e poi sullo stesso un ciclo foreach per creare tutti gli elementi:


foto.sort(randomFunct);
$.each(foto, function(i, el) {$(‘#griglia’).append(‘<li><img src=”‘+foto[i]+’”></li>’);});

A questo punto la visualizzazione è fatta, come ultima cosa possiamo mettere queste istruzioni in una funzione

al fine di intercettare il click sulle foto stesse e mostrare la pila riorganizzata.

Particolare interessante non potremo usare il semplice gestore ‘click’ sul document.ready poiché

la lista viene creata dopo, useremo quindi on in modo da evitare il ricorso al deprecato live.


function randomFunct() { return 0.5 – Math.round(Math.random()); }
$(document).ready(function(e) {mostra_foto();}).on(‘click’,'#griglia li img’,function(){mostra_foto();});

function mostra_foto(){
foto.sort(randomFunct);
$.each(foto, function(i, el) {$(‘#griglia’).append(‘<li><img src=”‘+foto[i]+’”></li>’);});
}

L’esempio

Oct 312012
 

Affontiamo il problema della validazione dei form, problema annoso in passato ma oggi risolvibile più agevolemnte.

Useremo jQuery e il suo plugin jQuery Validate per risolvere la nostra questione, per inciso il plugin è in sé interessante poiché definisce i metodi di validazione più comuni, inoltre permette l’estensione con l’aggiunta di personalizzazioni.

Partiamo dal form con 3 campi di input obbligatori: il nome, l’email e lo username:


<form name=”info” id=”info”>
<fieldset>
<legend>Dati</legend>
<label for=”nome”>Nome</label><br />
<input type=”text” id=”nome” name=”nome” /><br /><br />
<label for=”email”>Email</label><br />
<input type=”text” id=”email” name=”email” /><br /><br />
<label for=”username”>Username</label><br />
<input type=”text” id=”username” name=”username” /><br /><br />
<input type=”button” id=”submit” value=”invia” />
</fieldset>
</form>

Nell’html mettiamo anche un div nascosto che useremo per dialogare con i nostri utenti:


<div id=”dialog” title=”Test”></div>

Prepariamo anche lo stile della label per la gestione degli errori:


label.error{ font:bold 14px Arial; color:#900;}

Passiamo alla parte di validazione vera e propria. Come prima cosa al caricamento della pagina agganciamo gli eventi che vogliamo gestire.

Il primo sarà relativo alla validazione dello username e andremo a verificare che non sia presente nel db con una chiamata ajax (si osservi che questa verifica non esenta dalla verifica server-side).

Quindi all’evento blur sul nostro campo, andremo a leggere il valore digitato dall’utente e manderemo una chiamata ajax al server web, in caso di risposta negativa, rimuoviamo la label dell’errore,

per evitare duplicazioni, la rimettiamo, svuotiamo il campo, altrimenti semplicemnte rimuoviamo la label dell’errore.


$(‘#username’).blur(function(){
var username=$(‘#username’).val();
$.ajax({
type:’GET’,
url:’data/test_username.php?username=’+username,
success:function(str){
if(str==’KO’){
$(“#username_error”).remove();
$(‘#username’).val(”);
$(‘#username’).after(‘<label for=”username” id=”username_error”>Username presente</label>’);
$(‘#username’).focus();
}
else{$(“#username_error”).remove();}
}
})
})

La successiva porzione di codice validerà il form e ci faremo restituire un valore booleano in base all’esito dell’operazione,

quindi al click sul submit, ma sipoteva anche dire al submit del form, aggiungiamo la vera validazione:


$(‘#submit’).click(function(){
var valido=$(‘#info’).validate().form();

})

Nel metodo validate specificheremo rules e messagges come ben spiegato nella pagina del plugin


rules:{
nome:’required’,
email:{
required:true,
email:true
},
username:{
required:true,
minlength:2
}
},
messages:{
nome:’Campo obbligatorio’,
email:{
required:’Campo obbligatorio’,
email:’Devi inserire un indirizzo valido’
},
username:{
required:’Campo obbligatorio’,
minlength:’Devi inserire almeno 2 caratteri’
}
}

Nel nostro caso ci siamo semplicemente limitati ai campi obbligatori e alla validazione dell’email.

Ultimo step l’invio del form.

Se la validazione ha avuto successo invieremo una chiamata ajax al nostro server web, passando i dati del form serializzati:


$.post(‘dati/inserisci.php’,$(‘#info’).serialize()

per poi gestire con una callback l’esito della risposta che se positivo implicherà:

1. nascondere il form

2. mostrare un messaggio di avviso all’utente

3. sostituire un contenuto visuale al posto del form


function(){
$(‘#info’).hide();
$(‘#dialog’).dialog().html(‘<p>Tutto ok!</p>’);
$(‘#contenitore’).append(‘<p>Record inserito</p>’);
}

Per testare tutte le funzionalità dell’esempio lo username presente è “pippo”