lorenzo

Oct 252012
 

Andiamo a leggere un file xml e a visualizzare i dati all’interno di una tabella.
Come prima cosa prepariamo l’html:
il div da utlizzare come avviso durante il caricamento con ajax che verrà nascosto dal css:

<div id="loader"><img alt="" src="http://www.lorenzodeambrosis.net/blog/2012/10/jquery-parsing-xml/images/ajax_loader.gif" /></div>

e la tabella dove andremo a visualizzare i dati:

<table id="lista">
	<thead>
    	<tr>
        	<th>Titolo</th>
        	<th>Link</th>
        	<th>Autore</th>
        </tr>
    </thead>
    <tr class="template">
    	<td><span class="item_titolo"></span></td>
    	<td><span class="item_link"></span></td>
    	<td><span class="item_autore"></span></td>
    </tr>
</table>

La prima riga della tabella contiene l’intestazione della stessa,
la seconda una riga “template”, nascosta dal css che verrà clonata nel corso della lettura del file xml

Rapidamente la struttura della nostra fonte di dati:

Al document.ready partirà la chiamata ajax come di consueto:

$.ajax({
type:’GET’,
url:’data/news2.xml’,
dataType:’xml’,
success:function(str_xml){
…
}
})

e una volta ricevuti i dati procediamo con il ciclo di lettura:


$(str_xml).find(‘item’).each(function(){
var titolo=$(this).find(‘titolo’).text();
var miolink=$(this).find(‘link’).text();
var autore=$(this).find(‘autore’).text();

e a questo prunto prepariamo l’output clonando il template e rimuovendo la class per renderlo visibile

var newRow=$(‘#lista .template’).clone().removeClass(‘template’);

prepariamo un oggetto litteral con i dati da iniettare nella nuova riga:

var listaItem={titolo:titolo, varlink:miolink, varautore:autore};

infine popoliamo e appendiamo la nostra riga:

popola_template(newRow, listaItem).appendTo(‘#lista’).fadeIn();

la funzione popola_template cerca i tag span dove andare a scrivere i contenuti dell’oggetto passato
e restituisce l’oggetto jQuery da appendere:

function popola_template(row, lista){
row.find(‘.item_titolo’).text(lista.titolo);
row.find(‘.item_link’).text(lista.varlink);
row.find(‘.item_autore’).text(lista.varautore);
return(row);
}

L’esempio completo

Oct 232012
 

Uno dei formati più popolari per l’interscambio dei dati e JSON.
Vediamo come fare una ricerca su twitter e gestire la risposta.

Per prima cosa al document.ready andremo a mappare sugli input che hanno type=button l’evento click,
in questo modo la parte di form relativa all’input verrà gestita.
Il nostro utente inserirà la sua keyword, al click avvieremo la ricerca chiamando l’opportuna funzione:


<p><input id="cerca" type="search" /><br />
<input type="button" value="cerca" /></p>


$(document).ready(function(e) {$(‘input[type="button"]‘).click(function(){cerca();})})

La nostra funzione come prima cosa leggerà il valore inserito e poi costruirà la urla da chiamare:


var searchTerm=$(‘#cerca’).val();
 var baseUrl=’http://search.twitter.com/search.json?q=’;

Passo successivo la chiamata vera e propria e il parsing della risposta:

 $.getJSON(baseUrl+searchTerm+’&callback=?’,function(data){

})

La variabile data conterrà i dati di ritorno che scorreremo con un ciclo each, meglio scorreremo data.results che contiene le informazioni che vorremo visualizzare.
all’interno del ciclo creeremo l’html da appendere a un contenitore opportunamente predisposto nella pagina:

 $.each(data.results,function(){
 $(‘<div></div>‘)
 .append(‘<img src="<a href="http://www.lorenzodeambrosis.net/blog/2012/10/jquery-ricerca-su-twitter-e-parsing-json/'+this.profile_image_url+'" target="_blank">'+this.profile_image_url+'</a>" alt="" />‘)
 .append(‘<a href="http://www.lorenzodeambrosis.net/blog/2012/10/jquery-ricerca-su-twitter-e-parsing-json/#">‘+this.from_user+’</a>‘+this.text+’‘)
 .appendTo(‘#contenitore’)
 })

L’esempio completo

Oct 232012
 

Quasi sempre creando una pagina e lavorando su di essa con jQuery andremo a mettere il codice da eseguire all’interno del document.ready
ovvero faremo in modo che le varie attività, come per esmepio binding degli eventi siano disponibili solo una volta che il browser abbia effettivamente caricato il DOM.
Per far questo abiamo due possibilità $(function) o il più esteso e autodescrittivo $(docuemnt).ready, ma sono equivalenti.
Altra cosa invece è porsi il problema di quando sia terminato il download delle risrose collegate alla pagina, come per esempio immagini:
in questo caso disponiamo solo dell’evento load, nel tutorial scritto con jQuery e con js nativo, ma che è deprecato in quanto non sufficientemente consistente nei vari browser e non sempre affidabile per via di interferenze di cache (per approfondimento).

Il codice seguente “prende i tempi” di caricamento:

</pre>
<pre id="line1">var date=new Date();
var start=date.getTime();

$(function(e) {
	var date0=new Date();
	var start0=date0.getTime();
	$('#box0').text(start0-start);
	});
$(document).ready(function(e) {
	var date1=new Date();
	var start1=date1.getTime();
	$('#box1').text(start1-start);
	});
$(window).load(function(){
	var date2=new Date();
	var start2=date2.getTime();
	$('#box2').text(start2-start);
	})
window.onload=function(){
	var date3=new Date();
	var start3=date3.getTime();
	$('#box3').text(start3-start);
	}


 

</pre>
<pre id="line1"><p>$(function(){})</p>
<div id="<a>box1</a>"></div>
<p>Document ready</p>
<div id="<a>box1</a>"></div>
<p>$(window).load [deprecated]</p>
<div id="<a>box2</a>"></div>
<p>window.onload</p>
<div id="<a>box3</a>"></div>
<img src="<a href="view-source:http://static.jquery.com/files/rocker/images/logo_jquery_215x53.gif">http://static.jquery.com/files/rocker/images/logo_jquery_215x53.gif</a>" />

L’esempio

Oct 232012
 

Quando ci troviamo ad utilizzare massicciamente ajax potremmo avere delle difficoltà nel monitorare correttamente gli accessi alle nostre pagine.

Supponiamo, per ipotesi, di costruire un sito a partire da un unico file e popolarlo iniettando dei contenuti con delle chiamate ajax; supponiamo inoltre di voler monitorare gli accessi a questi contenuti con un classico Google Analytics. Ora con l’approccio tradizionale potremmo trovarci nell’imbarazzante situazione di poter contare solamente gli accessi al file principale ma di non poter distinguere gli accessi ai contenuti particolari caricati via ajax. Infatti, in teoria e per un certo periodo anche nella pratica, gli strumenti di analisi basati su javascript attivavano la chiamata e il conteggio dell’accesso, di fatto, solo al caricamento della pagina quando il browser interpretava lo script di monitoraggio. Questo ovviamente causava una serie di limti fastidiosi legato non tanto e non solo al mancato monitoraggio delle chiamate ajax ma anche per esempio all’accesso a un file pdf.

Fortunatamente ora non è più così e possiamo tranquillamente monitorare tutto quello che ci occorre, serve solo un minimo di programmazione e qualche cautela.

Infatti una cosa alla quale fare attenzione è, innazitutto, inserire il codice di monitoraggio all’interno del tag <body>, per esempio così:


&lt;body&gt;
&lt;script type=”text/javascript”&gt;

var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-xxxxxxx-1']);
_gaq.push(['_trackPageview']);

(function() {
var ga = document.createElement(‘script’); ga.type = ‘text/javascript’; ga.async = true;
ga.src = (‘https:’ == document.location.protocol ? ‘https://ssl’ : ‘http://www’) + ‘.google-analytics.com/ga.js’;
var s = document.getElementsByTagName(‘script’)[0]; s.parentNode.insertBefore(ga, s);
})();

&lt;/script&gt;

Il secondo passaggio sarà quello di rendere esplicito la chiamata di monitoraggio, associandola per esempio a un evento javascript che richiama una funzione, all’interno della quale collocare un codice simile a questo:


_gaq.push(['_trackPageview', '/miapagina']);

dove al posto di /miapagina ci sarà il contenuto che leggeremo nel report di analytics

Ulteriori approfondimenti in merito sono disponibili nella guida di Google Analytics

Oct 192012
 

Questo tutorial è dedicato al parsing di un feed rss tramite jQuery.
Al caricamento del documento andremo a a caricare via ajax il file news.xml
e poi prepareremo la visualizzazione.

Trattandosi di una chiamata ajax useremo la tradizionale icona animata per avvisare del caricamento dati in corso.
Nell html predisponiamo un div nascosto via css:

<div id="loader"><img src=”http://www.lorenzodeambrosis.net/blog/tutorial/images/ajax_loader.gif” alt="" /></div>

Al document assegniamo la gestione della visualizzazione e della scompars del div in oggetto (che poi andrà posizionato al centro della pagina)

$(document)
.ajaxStart(function(){$(‘#loader’).show();})
.ajaxStop(function() {$(‘#loader’).hide();})

al caricamento invece inoltriamo la chiamata con il metodo .ajax():

$.ajax({
type:’GET’,
url:’data/news.xml’,
dataType:’xml’,
success:function(str_xml){

}
})

Per quanto riguarda la parte di visualizzaizone dei dati invece utilizzeremo le funzionalità tradizionali di jQuery di attraversamento del DOM.
Quindi come prima cosa andremo a cercare il tag “item” all’interno della stringa str_xml ottenuta in risposta e per ogni item andremo a caccia delle info contenute

$(str_xml).find(‘item’).each(function(){
…
})

Come prima cosa assegniamo delle variabili ottenute dall’estrazione del contenuto dai tag con il metodo .text(),
quindi $(this) rappresenta l’item sul quale ci troviamo, al suo interno andiamo alla ricerca del tag desisderato (.find())
e infine preleviamo il testo del tag


var titolo=$(this).find(‘title’).text();
var miolink=$(this).find(‘link’).text();
var description=$(this).find(‘description’).text();
var pubDate=$(this).find(‘pubDate’).text();
var category=$(this).find(‘category’).text();

A questo punto possiamo costruire la stringa html da appendere al contenitore target della visualizzazione:

var riga1=”+titolo+”;
var riga2=’<strong>‘+</strong>category<strong>+’</strong> – <em>‘+&lt;/em>pubDate&lt;em>+’</em>‘;
var riga3=”+description+”;

$(‘<div class=”item”></div>’).html(riga1+riga2+riga3).appendTo(‘#contenitore’)

Ecco l’esempio completo

Feb 232012
 

Riprendendo il post precedente potremmo aggiungere un’interessante integrazione: l’animazione al nostro grafico.

Questo significherà impostare nelle options la durata e l’easing dell’anomazione:


var options = {
width: 400,
height: 240,
animation:{duration: 1000,easing: ‘out’,},
vAxis: {minValue:0, maxValue:1200}
};

A questo punto impostiamo il nostro grafico a 0:


data.addRows([
['2008', 0, 0],
['2009', 0, 0],
['2010', 0, 0],
['2011', 0, 0]
]);

Predisponiamo un bottone sul quale mapperemo l’evento click:


var button = document.getElementById(‘button’);

e disbilitiamolo nell’esecuzione della funzione drawChart:


function drawChart() {
button.disabled = true;
google.visualization.events.addListener(chart, ‘ready’,
function() {button.disabled = false;});
chart.draw(data, options);
}

A questo punto sul click del bottone andiamo a modificare i value delle nostre righe che “cresceranno” con l’animazione prevista:


button.onclick = function() {
data.setValue(0, 1, 1000);
data.setValue(0, 2, 400);
data.setValue(1, 1, 1170);
data.setValue(1, 2, 460);
data.setValue(2, 1, 660);
data.setValue(2, 2, 1120);
data.setValue(3, 1, 1030);
data.setValue(3, 2, 540);
drawChart();
}

Ecco il nostro grafico animato

Feb 222012
 

Una versione molto popolare dei grafici è la rappresentazione a colonne.
Anche in questo caso, giusto per non inventare nulla, faremo ricorso a Google Chart:


<script type=”text/javascript” src=”https://www.google.com/jsapi”></script>
<script type=”text/javascript”>
google.load(“visualization”, “1″, {packages:["corechart"]});
google.setOnLoadCallback(drawChart);

Quindi colleghiamo la libreria, carichiamo il package opportuno e tramite un callback richiamiamo la funzione che ci permetterà di operare:

Aggiungimo le 3 colonne che compongono il nostro grafico e il tipo di dato che contengono:


var data = new google.visualization.DataTable();
data.addColumn(‘string’, ‘Anno’);
data.addColumn(‘number’, ‘Ricavi’);
data.addColumn(‘number’, ‘Spese’);

e infine i dati in nostro possesso ovvero le righe, il primo valore rappresenta l’asse x e poi a seguire gli N valori da rappresentare:


data.addRows([
['2008', 1000, 400],
['2009', 1170, 460],
['2010', 660, 1120],
['2011', 1030, 540]
]);

A questo punto andiamo a settare alcune opzioni di visualizzazione del grafico:


var options = {
width: 400, height: 240,
title: ‘Bilancio’,
hAxis: {title: ‘Anno’, titleTextStyle: {color: ‘red’}}
};

nell’ordine: dimensioni, titolo e formattazione della didascalia

Non resta che disegnare il grafico, agganciandolo agli elementi della pagina:


var chart = new google.visualization.ColumnChart(document.getElementById(‘chart_div’));
chart.draw(data, options);

Ed ecco il nostro grafico

Feb 212012
 

Possiamo creare cartine geografiche e colorare dinamicamente un paese sulla mappa facendoci restituire come output un’immagine.
La soluzione passa attraverso google chart e una chiamata particolare:
<img src=”https://chart.googleapis.com/chart?cht=map:auto=140,140,120,120&chs=300×300&chld=KE&chco=000000|FF0000″ alt=””>

tutto qui, quasi troppo facile!
Esaminiamo i parametri della chiamata e quindi prendiamo in esame la query string:
cht=map : è obbligatorio e specifica che verrà rstituita una mappa (auto è un’opzione che serve per zoom e centratura della mappa);
chs=300×300 : anche questo parametro è obbligatorio e serve per dichiarare le dimensioni dell’immagine
chld=KE : il paese da colorare, se sono più di uno vanno separati dal simbolo | (ricordarsi di usare la codifica standard per individuare i paesi)
chco=000000|FF0000 : i colori da usare per i paesi non selezionati e per quelli selezionati

L’esempio completo

Feb 202012
 

E’ possibile colorare dinamicamente una nazione su una cartina senza ricorrere alla tradizionale soluzione in flash?
La risposta è sì e ci sono due opzioni: la prima passa attraverso google chart e svg, maentre la seconda, sempre tramite google chart, presente l’output sotto forma di immagine.

Vediamo la prima opzione, come sempre occorr collegare la libreria e chiamare la funzione vera e proprai all’onload:

<script type=’text/javascript’ src=’https://www.google.com/jsapi’></script>
<script type=’text/javascript’>
google.load(‘visualization’, ’1′, {‘packages’: ['geochart']});
google.setOnLoadCallback(drawRegionsMap);

Nella funzione come prima cosa impostiamo la label:


var data = new google.visualization.DataTable();
data.addColumn(‘string’, ‘Country’);
data.addColumn(‘number’, ‘Articoli’);

e successivamente il paese da visualizzare, attenzione a utilizzare la nomeclatura standard ISO-3166-1


data.addRows([['Peru', 1]]);

potermmo già concludere il nostro lavoro con le seguenti istruzioni


var chart = new google.visualization.GeoChart(document.getElementById(‘chart_div’));
chart.draw(data, options);

che permettono di disegnare la cartina, tuttavia è opprtuno settare alcune opzioni:


var options = {
colorAxis: {colors: ['FF0000']},
displayMode: ‘regions’,
region: ’005′,
width:’300′,
height:’225′,
legend:’none’,
datalessRegionColor:’000000′,
resolution:’countries’
};

dove colorAxis è il colore del paese da evidenziare, displayMode serve per impostare il livello di zoom, region serve per definire la regione da visualizzare (sempre secondo le codifiche standard), quindi larghezza e altezza del nostro oggetto, se vogliamo o meno visualizzare la legenda e per concludere risoluzione e colore delle regioni senza dati.

Vedi l’esempio competo.

Feb 122012
 

Google chart può essere utilizzato per creare mappe del mondo, di continenti o regioni e colorare con diffrenti tonalità aree geografiche ben precise. Proveremo ora a descrivere una mappa dove verranno visualizzate le 10 economie più forti nel 2006, il grafico mostrerà colorati i nostri paesi e con una tonalità dal più scuro al più chiaro in relazione ai valori inseriti.

Il primo step è il collegamento alla libreria:

<script type=’text/javascript’ src=’https://www.google.com/jsapi’></script>

successivamente accediamo al package di nostro interesse e impostiamo il callbak al caricamento:

google.load(‘visualization’, ’1′, {‘packages’: ['geomap']});
google.setOnLoadCallback(drawMap);

Nella funzione vera e propria creiamo il nostro oggetto:

var data = new google.visualization.DataTable();

Impostiamo le label:

data.addColumn(‘string’, ‘Paese’);
data.addColumn(‘number’, ‘PIL, miliardi di $, 2006′);

e aggiungiamo i dati veri e propri:

data.addRows(10);
data.setValue(0, 0, ‘United States’);
data.setValue(0, 1, 13164);
data.setValue(1, 0, ‘Japan’);
data.setValue(1, 1, 4368);

una coppia per ciascun paese, dove i 3 parametri di setValue sono rispettivamente l’indice della riga, l’indice della colonna e il valore.
Nel nostro caso non useremo opzioni particolari:

var options = {};
options['dataMode'] = ‘regions’;

e quindi possiamo agganciare l’elemento della pagina e produrre la mappa:

var container = document.getElementById(‘mappa’);
var geomap = new google.visualization.GeoMap(container);
geomap.draw(data, options);

Vai all’esempio