Guide e Tutorial

La ricerca in rete: l’operatore “” (doppi apici)  

realizzato da , il 29 mag. 2015, categoria Didattica Generale

Didattica Generale
Aumenta font Riduci font Stampa articolo Invia articolo

Un altro operatore che sembra avvicinarsi all’operatore + è quello dei doppi apici in apertura e chiusura di una locuzione.
Racchiudere fra i doppi apici una frase impone al motore di ricerca di ricercare tutte le pagine che contengano la frase o la locuzione mantenendo esattamente lo stesso ordine della sequenza cercata.

In ciò si vede subito la differenza con l’operatore logico AND e con l’operatore +.
Nel primo caso infatti il motore restituisce tutte le pagine in cui compaiano le parole chiave senza tener conto dell’ordine in cui sono presenti.
Nel secondo caso il motore restituisce tutte le pagine in cui compaiano le parole cercate e che obbligatoriamente contengano anche le parole precedute dal segno + (in genere stopword) ignorate nella ricerca con AND logico.
Ma anche in questo caso l’ordine delle parole non è rilevante nei risultati.

L’uso dei doppi apici quindi è più restrittivo dei due precedenti operatori in quanto impone sia di trovare tutte le parole racchiuse fra gli apici, sia di trovarle nell’esatta sequenza in cui sono state scritte.
Un esempio concreto può essere ad esempio: nel mezzo del cammin di nostra vita mi ritrovai

Google - Ricerca operatore doppi apici

È ovvio che l’utilizzo dei doppi apici non ha alcun senso se si cerca una sola parola.
Lo stesso vale anche se le parole siano più di due ma sono senza un reale nesso discorsivo che le leghi oppure non indicano nulla di specifico.
In tal caso molto meglio usare l’operatore AND o eventualmente l’operatore +.

È inutile ad esempio cercare dante alighieri vita nova cortese cortesia, perché è altamente improbabile che questa serie di termini ricorra esattamente come è scritta.

Google - Ricerca con doppi apici

Le frasi o locuzioni che si vorranno cercare con i doppi apici dovrebbero quini essere molto specifiche e possibilmente esatte, compreso l’ordine delle parole punteggiatura e stopwords.

L’esattezza comunque non è strettamente necessaria: se la punteggiatura manca o se vi sono piccoli errori ortografici spesso il motore riporta la frase correttamente, compresa la punteggiatura.
Ad esempio se inserite una frase errata come dagli atri muschiosi dai fori cadenti, Google, Bing e Duckduckgo vi daranno la frase corretta e punteggiata: «dagli altri muscosi, dai fori cadenti».

Google - Ricerca con doppi apici

Torna al menu articoli -> La ricerca in rete: Introduzione

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑


Spazio Pubblicitario

La ricerca in rete: l’operatore + (più)  

realizzato da , il 29 mag. 2015, categoria Didattica Generale

Didattica Generale
Aumenta font Riduci font Stampa articolo Invia articolo

Il comando + sembra ormai andarsi a sovrapporre al comando AND perché impone che tutti i termini con il + davanti compaiano nei risultati di una query.
In realtà tanto Google che gli altri motori dichiarano a proposito del segno + che esso impone di cercare in una query anche termini molto comuni che in genere sono ignorati in fase di elaborazione anche con un comando AND, perché rallentano la ricerca e non sono considerati reali portatori di informazione: si tratta delle stopwords; fra queste rientrano, ad esempio i numeri, le congiunzioni gli articoli certi verbi come gli ausiliari essere e avere coniugati o anche avverbi e preposizioni.

L’uso del segno + può effettivamente cambiare e di parecchio il numero dei risultati che il motore può visualizzare.
Se ad esempio inserisco come parole chiave “Calvino” e “romanzo”, su Google si ottengono circa 477.000 pagine di risposta:

Google - Comando + più

Se però si inserisce Calvino +il romanzo i risultati scendono vertiginosamente a 599:

Google - Operatore + più

La sequenza “calvino+nel romanzo porta addirittura a 20 le pagine trovate.

Google - Operatore + più

Anche in questo caso si deve fare attenzione.
Innanzitutto la sequenza delle parole inserite nella casella di ricerca non necessariamente restituirà risultati che mantengano lo stesso ordine.
Quindi la preposizione articolata potrà trovarsi tanto davanti a Calvino quanto davanti a romanzo.

Al motore infatti è stato chiesto di cercare tutte le pagine in cui compaiono contemporaneamente sia “Calvino” che “romanzo” e inoltre  che in queste stesse compia obbligatoriamente la preposizione articolata “nel”, di solito non considerata in quanto stopword.
Si potrebbe obiettare che fra i risultati che contemplano “calvino” e “romanzo” sicuramente sarebbe comparsa anche qualche pagina in cui appariva “nel”, ma si sarebbe trattato di un risultato più o meno aleatorio, in quanto sarebbe dipeso da fattori legati prima di tutto ai due termini principali (ranking, ecc) e sarebbero apparse magari molto in avanti nella ricerca.

Utilizzando “+nel” invece si impone che questa preposizione articolata venga considerata allo stesso modo di “calvino” e “romanzo” e i risultati saranno visualizzati a partire da questo vincolo, prima di altre eventuali stopword e quindi assai meno casualmente.

Torna al menu articoli -> La ricerca in rete: Introduzione

 

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

La ricerca in rete: gli operatori NOT e -  

realizzato da , il 29 mag. 2015, categoria Didattica Generale

Didattica Generale
Aumenta font Riduci font Stampa articolo Invia articolo

Quando si desidera cercare delle informazioni attraverso parole chiave, può capitare che alcune di esse presentino ambiguità semantiche tali da far comparire risultati indesiderati oltre a quelli cercati, portando via così spazio ad altre informazioni che si sarebbero potute visualizzare.
Oppure può capitare che un’informazione possa essere associata a due campi differenti e non legati fra loro.
In tal caso si può da un lato ulteriormente specificare la query aggiungendo altre parole chiave per disambiguare la richiesta e dall’altra si può imporre al motore di  escludere parole chiave che possono alterare i risultati della ricerca.
Il comando generale per escludere  alcune parole dal campo di ricerca è il seguente (kw è abbreviazione di keyword):

kw1 kw2 kw3 NOT kw4 NOT kw5 NOT kw6

Alternativo ed equivalente al comando appena visto è il seguente:

kw1 kw2 kw3 -kw4 -kw5 -kw6

I motori di ricerca suggeriscono di posizionare le parole negate alla fine della query.
L’operatore – è entrato definitivamente in uso ed è riconosciuto da tutti i principali motori di ricerca.

Se ad esempio volessimo cercare informazioni sulle opere di Dante Alighieri escludendo tutti i riferimenti alla sua amata Beatrice potremmo digitare:

dante alighieri opere -beatrice

Google - Operatore NOT (o meno)
Da notare l’assenza tra i risultati della ricerca di pagine con riferimenti a “beatrice“.

Si noti infine anche la differente sintassi dei due comandi:

  • nel caso di NOT vi è spaziatura fra l’operatore logico e la parola negata,
  • nel caso di – l’operatore precede immediatamente la parola negata senza spazi interposti.

Nota: Google non accetta  più la sintassi NOT; è obbligatorio quindi usare il segno -.
Bing e Duckduckgo accettano entrambe. Anche in questo caso è consigliabile verificare gli aiuti online sulla sintassi che i motori di solito offrono.

Torna al menu articoli -> La ricerca in rete: Introduzione

 

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

La ricerca in rete: i comandi AND e OR  

realizzato da , il 29 mag. 2015, categoria Didattica Generale

Didattica Generale
Aumenta font Riduci font Stampa articolo Invia articolo

Come abbiamo detto in fase di introduzione il comando AND è un operatore logico booleano e può essere sostituito semplicemente dalla sua assenza.
I due comandi quindi si equivalgono.

parola1 AND parola2  <——-> parola1 parola2

Il comando AND comunque non è univocamente usato nei vari motori di ricerca.
Ad esempio la ricerca «Dante Bonagiunta» su Google restituisce (Giugno 2015) 43.900 risultati

Google AND

mentre la ricerca «Dante AND Bonagiunta» ne restituisce 18.800, perché inserisce anche pagine inglesi in cui and fa parte addirittura del titolo o del corpo del testo.

Google AND

Bing curiosamente ne restituisce 10100 se manca AND e 9950 se c’è AND.
Conviene in buona sostanza utilizzare la sintassi dichiarata dai motori ed ormai prevalente e spaziare le parole sottintendendo l’operatore AND.
In generale rimane sempre una buona prassi quella di studiare la sintassi dei differenti motori perché essa può anche subire variazioni.

Il comando OR (in maiuscolo come tutti gli operatori booleani) indica l’alternativa fra uno o più termini di ricerca ed ha valore disgiuntivo, come aut in latino, per cui x1 OR x2 OR … xn restituisce uno solo fra gli x(1,2,,n…z) termini.
Tuttavia alcuni motori restituiscono anche pagine con più d’uno dei termini cercati, pur avendo specificato l’uso di OR come disgiuntivo.

È chiaro che la ricerca con OR restituisce molti più risultati che non la ricerca con AND.
La prima infatti restituisce un insieme unione fra gli insiemi rappresentati dalle parole chiave, la seconda restituisce invece un insieme intersezione fra gli stessi insiemi.
A titolo di esempio per le parole chiave Alighieri, Guinnizzelli e Cavalcanti, per Bing e Google  si hanno questi risultati (non si valuti qui la pertinenza):

Motore Risultati AND Risultati OR
Bing ~ 132,000 ~ 6,690,000
Google ~ 102.000 ~ 15.700.000


AND E OR INSIEME.

Ricordiamo che il comando AND ha sostanzialmente un’azione di restringimento del campo di ricerca. Più termini collegati fra loro dall’operatore logico equivalgono in termini matematici, come abbiamo accennato sopra, a un insieme intersezione fra più insiemi parzialmente differenti e individua dunque quella sola porzione dell’insieme che è comune a tutti.
Il comando OR invece ha un effetto differente ma non esattamente opposto. Esso in effetti allarga il campo dei risultati possibili in quanto, posta una lista di elementi separati, accetta come risultato uno solo di ma li elenca comunque uno a uno tutti in forma disgiuntiva.
È intuitivo che il numero dei risultati con OR sia maggiore che con AND.
Lo si verifica chiaramente digitando i due seguenti comandi:
Alighieri OR bonagiunta OR Davanzati restituisce ad esempio oltre 16.000.000 di pagine:

Google OR

Alighieri bonagiunta Davanzati restituisce -solo- 2.570 risultati:

Google AND

I due comandi possono anche essere utilizzati insieme, tenendo conto delle loro caratteristiche.
Bisogna ricordare che OR agisce sia sul termine immediatamente precedente sia su quello immediatamente seguente.
Possiamo allora utilizzare le parentesi per ottenere dei raggruppamenti (AND) disgiuntivi (OR) dei vari termini secondo i criteri che ci interessano per tentare di trovare risultati non troppo restrittivi dovuti a AND, né troppo vasti causati da OR.
Riprendiamo la stessa query utilizzata precedentemente a solo scopo dimostrativo e vediamo gli effetti dell’applicazione contemporanea dei due comandi:

(Alighieri bonagiunta) OR Davanzati restituisce 360.000 risultati

Google - AND e OR insieme

Alighieri OR (bonagiunta Davanzati) restituisce 356.000 risultati

Google - AND e OR insieme

Si tenga sempre presente che OR è un comando che esclude la compresenza dei due termini su cui agisce (ricordarsi AUT latino).

NOTE SUL COMANDO AND.
Una ricerca basata su una sola parola chiave restituirà quasi sempre risultati scarsamente o del tutto improduttivi nell’insieme.
La prima ragione è nell’elevato numero di pagine che potrebbero contenere quella sola parola, specie se nota.
Al momento, una ricerca su “dante” restituisce 61.800.000 pagine su Google e 1.920.000 in Bing e si capisce bene che non è stata un granché utile.
Raffiniamo la ricerca utilizzando più parole chiave spaziate fra loro (equivalente ad AND logico) per ottenere tutte le pagine che contengano contemporaneamente le parole richieste.

È ovvio che in tal caso la ricerca si fa più selettiva.
Già solo cercare “Dante Alighieri” fa scendere il numero di pagine a 5.640.000 su Google mentre, curiosamente, le fa salire a 2.490.000 su Bing; si tratta comunque di un numero ancora troppo elevato.
Inserendo questa serie di parole:
dante alighieri beatrice portinari vita nova morte gentile cortese cortesia
le pagine scendono a 4.610 su Google e 130.000 su Bing.

Google - Restringere ricerca
Google a questo proposito permette di utilizzare fino a un massimo di 32 parole chiave.
Significa che esso è in grado di effettuare una ricerca con AND logico intersecando fino a 32 insiemi contemporaneamente.
È il solo motore a dichiarare questo valore.
Va comunque precisato che la ricerca con AND non restituisce la pagine contenenti le parole nello stesso ordine in cui sono state inserite. Per questo si veda più avanti l’operatore “”.
Queste osservazioni fanno comprendere l’importanza di scegliere con cura le parole chiave da utilizzare per la propria ricerca.
Più si è precisi nel definire cosa si cerca e più le parole chiave saranno mirate e le query saranno ben organizzate, più facile sarà ottenere risultati validi e in minor tempo.

A tal proposito un buon suggerimento è quello di valutare l’ordine delle parole mettendo ai primi posti quelle ritenute più importanti.
Questo perché spesso nelle pagine web i metadati inseriti manualmente nelle intestazioni sono pochi e di solito quelli ritenuti più importanti.

Se nella ricerca precedente le parole “dante” e “alighieri” venissero poste in fondo alla serie di parole chiave, i risultati diminuirebbero (seppur di poco), perché in genere nei metadati si tende a dare rilievo prima all’autore e poi alle sue opere.

I termini di ricerca inseriti compariranno in neretto nel titolo del link se fanno parte anche del titolo della pagina cui si riferiscono.
Google infatti ricerca le parole sia nel titolo sia nel corpo della pagina.

Google - In grassetto termini ricercati
La presenza nel titolo di determinate parole chiave dovrebbe teoricamente garantire una maggior possibilità di reperimento di pagine pertinenti con i propri desiderata.
I motori verificano anche se le parole del titolo ricorrono nel corpo; in caso affermativo aumenterebbe la probabilità di pertinenza del risultato. D’altronde, su diversi motori è possibile anche raffinare la ricerca per parole chiave, come vedremo,  specificando le sezioni della pagina web in cui queste devono trovarsi: titoli, URL, corpo del testo eccetera.

Torna al menu articoli -> La ricerca in rete: Introduzione

 

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

La ricerca in rete: Introduzione  

realizzato da , il 29 mag. 2015, categoria Didattica Generale

Didattica Generale
Aumenta font Riduci font Stampa articolo Invia articolo

Il più famoso ed utilizzato è indubbiamente Google, ma non possiamo trascurare Yahoo e Bing così come tantissimi altri meno noti come ad esempio Duckduckgo e l’italiano iStella; stiamo chiaramente parlando dei motori di ricerca, ognuno di noi li utilizza quotidianamente ma spesso sfruttando solo in minima parte la potenza di ricerca.

Esaminiamo quali sono i comandi che si possono dare ad un motore di ricerca per scandagliare il web in cerca di informazioni.
Gli operatori che saranno presentati sono comuni a tutti i motori più importanti, sono semplici e immediati ma già in grado, se usati in maniera adeguata, di fornire risposte precise a molte richieste di informazione.
In un secondo momento saranno presentati e commentati altri operatori, meno comuni e non presenti in tutti i motori di ricerca, benché utili ad un raffinamento della stessa.
In fondo all’articolo sono presenti i link agli articoli che compongono il programma (10 articoli).

Ricordiamo che non è detto che un motore di ricerca riesca a trovare tutte le pagine che ci interessano.
Ciò può essere dovuto sostanzialmente a due ragioni:

  • la prima, banale, è che la pagina non è ancora stata indicizzata dal motore o il sito non è stato segnalato;
  • la seconda invece dipende dal gestore delle pagine il quale può desiderare che esse non vengano indicizzate per qualche ragione, negando quindi l’accesso a parti di un sito.

I comandi principali dei motori di ricerca sono i seguenti:

  • AND
  • OR
  • NOT
  • +
  • -
  • “ “

I comandi avanzati sono i seguenti:

  • allinanchor:,
  • allintext:,
  • allintitle:,
  • allinurl:,
  • cache:,
  • define:,
  • filetype:,
  • id:,
  • inanchor:,
  • info:,
  • intext:,
  • intitle:,
  • inurl:,
  • link:,
  • related:,
  • site:

Cercheremo di vederli tutti nei prossimi articoli, capendone di volta in volta le potenzialità e soprattutto come questi comandi possono migliorare le nostre ricerche in rete.

Alcune Note Iniziali:
AND: È un operatore booleano in realtà non più necessario, perché ormai tutti i motori di ricerca lo usano di default, vale a dire che se si inseriscono due o più parole separate da spazi, il motore assume che l’operatore utilizzato sia AND.

NOT: Google non utilizza più l’operatore booleano NOT; negli altri motori consultati (bing, yahoo) esso è ancora riconosciuto ed opera insieme al suo sostituito – (segno meno).

OR:
Di norma ritorna risultati mutualmente esclusivi tranne in Yahho.

In dettaglio, gli articoli:

La ricerca in rete: I comandi AND e OR
La ricerca in rete: Gli operatori NOT e -
La ricerca in rete: L’operatore +
La ricerca in rete: L’operatore “”
– La ricerca in rete: L’operatore * (asterisco)
– La ricerca in rete: Comandi di ricerca avanzati
– La ricerca in rete: Il comando CACHE
– La ricerca in rete: I comandi LINK e RELATED
– La ricerca in rete: Il comando SITE
– La ricerca in rete: Il comando FILETYPE

 

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , , , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

Fondamenti di Informatica (2014)  

realizzato da , il 20 nov. 2014, categoria Tutorial e Pubblicazioni

Tutorial e Pubblicazioni
Aumenta font Riduci font Stampa articolo Invia articolo

Fondamenti di Informatica
R. Botteri, F. Donatantonio , M. Ceracchi, I. Marcucci
(2014) Collana Quaderni di Ingegneria – Ed. C.E.S.D. srl

Fondamenti di Informatica (Ingegneria) - Botteri, Donatantonio, Ceracchi, Marcucci Il presente compendio raccoglie, in un unico testo, una selezione di temi tratti dalle lezioni del corso di “Fondamenti di Informatica” del corso di laurea in Ingegneria Civile e Ambientale, il cui obiettivo è quello di trasformare eventuali (e passivi) consumatori di tecnologia in utenti consapevoli di cosa si può fare con l’informatica al di là dei mutamenti tecnologici, per i quali:

– l’informatica è una scienza delle metodologie generali per risolvere numerosi problemi (analizzare un contesto o dei processi aziendali, definire un modello, ecc.);

– è presente in tutti i campi, essendo evidente la necessità di disporre di un linguaggio comune per interagire con gli informatici puri. Ad esempio, valutare l’opportunità e la scelta di un sistema informatico in una azienda, oppure collaborare da esperti di dominio allo sviluppo di un sistema informatico, ecc.;

- è particolarmente utile per il prosieguo degli studi, perché spesso si verifica la necessità pratica di dover sviluppare dei programmi di ausilio alle esercitazioni/simulazioni infracorso.

La natura semplificata della trattazione delle varie componenti del programma rende tale compendio fruibile anche al lettore che intende avvicinarsi all’Informatica, agli strumenti di produttività MS Office e Autocad e alla programmazione, indipendentemente dalla necessità di dover sostenere un esame universitario.

Disponibile in formato: Cartaceo – Ed. C.E.S.D.
Numero di Pagine: 564
Anno: 2014

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

tScroll (tabella con scroll) – Plugin jQuery  

realizzato da , il 06 ago. 2013, categoria Javascript

Javascript
Aumenta font Riduci font Stampa articolo Invia articolo

In questo articolo realizzeremo un plugin jQuery che ci permetta di implementare una tabella HTML con scrollbar incorporata.
In altre parole la nostra tabella avrà fissa l’intestazione (thead) e il fondo (tfoot) mentre la parte centrale (tbody) sarà scrollabile in un box con altezza da noi definita.

Iniziamo subito lo sviluppo del plugin, che chiameremo “tScroll“, determinando l’unico parametro da passare alla funzione:

  • h_box: altezza scroll della tabella

Una volta terminato il lavoro vorremmo poter invocare su una tabella con id=myTable il plugin con questa sintassi:

$('#myTable').tScroll({
      h_box: '300px'
});

Ottenendo ad esempio il seguente risultato:

Introduciamo il codice del plugin che successivamente commenteremo:

(function($){  
    $.fn.tScroll = function(options) {    
    return this.each(function() {
        // Recupero info tabella
        options.id_table = $(this).attr('id');
        var border = $('#'+options.id_table).attr('border');
        var cellspacing = $('#'+options.id_table).attr('cellspacing');
        var cellpadding = $('#'+options.id_table).attr('cellpadding');
        var classe = $('#'+options.id_table).attr('class');
        
        // Fisso thead
        var colonne = $('#'+options.id_table+' thead th').length;
        for(var i=0; i<colonne; i++){
            var w_th=$('#'+options.id_table+' thead th').eq(i).css('width').replace('px','');
            $('#'+options.id_table+' thead th').eq(i).css('width',w_th+'px');    
        }
        
        // Fisso tbody
        var colonne = $('#'+options.id_table+' tbody tr:eq(0) td').length;
        for(var i=0; i<colonne; i++){
            var w_th=$('#'+options.id_table+' tbody tr:eq(0) td').eq(i).width();
            $('#'+options.id_table+' tbody tr:eq(0) td').eq(i).width(w_th);    
        }
        
		var table2 = "";
        // Verifico se presente un tfoot
        if($('#'+options.id_table+' tfoot').length>0){
            // Fisso tfoot
            var colonne = $('#'+options.id_table+' tfoot td').length;
            for(var i=0; i<colonne; i++){
                var w_th=$('#'+options.id_table+' tfoot td').eq(i).css('width');
                $('#'+options.id_table+' tfoot td').eq(i).css('width',w_th);    
            }
			
			table2 = "<table id='tScroll_t2_"+options.id_table+"' border='"+border+"' cellspacing='"+cellspacing+"' cellpadding='"+cellpadding+"' class='"+classe+"'><tfoot>"+$('#'+options.id_table+' tfoot').html()+"</tfoot></table>";
        }
        
		var tbox = "<div id='tScroll_box_"+options.id_table+"'></div>";
        var table1 = "<table id='tScroll_t1_"+options.id_table+"' border='"+border+"' cellspacing='"+cellspacing+"' cellpadding='"+cellpadding+"' class='"+classe+"'><thead>"+$('#'+options.id_table+' thead').html()+"</thead></table>";
        var div = "<div id='tScroll_body_"+options.id_table+"'></div>";
		
        // Compongo le tre tabella in sequenza
        $(tbox).insertBefore('#'+options.id_table);
        $('#tScroll_box_'+options.id_table).append(table1);
        $('#tScroll_box_'+options.id_table).append(div);
        $('#tScroll_box_'+options.id_table).append(table2);
        
        $('#tScroll_body_'+options.id_table).append($('#'+options.id_table));
        
        $('#'+options.id_table).css('marginTop',0);
        $('#'+options.id_table).css('marginBottom',0);
        $('#'+options.id_table+" thead").remove();
        $('#'+options.id_table+" tfoot").remove();
        
        var w = $('#'+options.id_table).width() + 18;
        // Applico al box centrale l'altezza prefissata
        $('#tScroll_body_'+options.id_table).css('width',w)
                          .css('height',options.h_box)
                          .css('padding','0px')
                          .css('margin','0px')
                          .css('overflow-y','scroll')
                          .css('text-align','left');
		
		$('#tScroll_box_'+options.id_table).css('width',w)
										   .css('padding','0px')
										   .css('margin','0px')
										   .css('text-align','left');
    });
    
    return false;
    
    };  
})(jQuery);

Analizziamo il codice focalizzando l’attenzione innanzitutto sulla sequenza di operazioni che vengono compiute:

  1. Recuperiamo alcune info dalla tabella, ad esempio l’eventuale bordo la classe e attributi come cellspacing e cellpadding
  2. Intercettiamo il THEAD della tabella e fissiamo la larghezza delle celle
  3. Intercettiamo il TBODY della tabella e fissiamo la largehzza delle celle
  4. Intercettiamo (se presente) il TFOOT della tabella e fissiamo la larghezza delle celle
  5. Estraiamo i tre blocchi che compongono la tabella e inseriamoli in 3 tabelle diverse, mantenendo la giusta sequenza (una tabella con il solo THEAD, una tabella con il solo TBODY e una tabella con il solo TFOOT)
  6. Alla tabella centrale (la tabella del TBODY) applichiamo l’altezza definita in h_box e impostiamo lo scroll dell’asse y

In altre parole il concetto di base racchiuso nel nostro plugin è così riassumibile:

dopo aver bloccato la larghezza delle cella che compongono la tabella, creiamo 3 tabelle in sequenza ognuna contenente una parte della tabella originale (thead, tbody, tfoot) e quindi solo alla tabella centrale fissiamo l’altezza in pixel e il conseguente scroll.

Più precisamente la tabella centrale contenente il body viene prima racchiuso -per comodità- in un DIV al quale poi tramite il metodo .css di jQuery viene fissata l’altezza (righe da 55 a 62):

var w = $('#'+options.id_table).width() + 18;

$('#tScroll_body_'+options.id_table).css('width',w)
                          .css('height',options.h_box)
                          .css('padding','0px')
                          .css('margin','0px')
                          .css('overflow-y','scroll')
                          .css('text-align','left');

Da notare che ogni tabella/blocco creato avrà un suo ID composto.
Inoltre la larghezza del box terrà conto dello spazio occupato dallo scroll aggiungendo 18px mentre l’altezza sarà il valore del parametro in option.h_box.

Chiaramente, come sempre, tengo a sottolineare che questa è solo una possibile soluzione dello spinoso problema riguardante le tabelle con scroll. Chi sviluppa quotidianamente per il web si sarà almeno una volta trovato dinnanzi questa richiesta da parte del committente e fortunatamente in rete sono proposte molte soluzioni, alcune ottime altre invece “poco funzionanti”.
La strada che abbiamo percorso è forse la più semplice e ovvia ma sicuramente è anche ottimizzabile e migliorabile.

Infine, qualora ce ne fosse bisogno, tengo a precisare che per il corretto funzionamento del plugin tScroll è necessario che la nostra tabella di partenza sia strutturata tenendo conto della presenza del tag thead, del tag tbody ed eventualmente del tag tfoot. Inoltre le celle che compongono l’intestazione (thead) devono essere definite utilizzando il tag TH; ciò comunque non toglie che il codice può essere facilmente modificato per essere adattato alle nostre tabelle esistenti.

Cliccando qui è possibile vedere in azione il plugin tScroll.

Cliccando qui è possibile scaricare il codice del plugin tScroll.

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

Esercizio 30 – Semplice gioco del TRIS  

realizzato da , il 11 feb. 2013, categoria Java

Java
Aumenta font Riduci font Stampa articolo Invia articolo

Implementare una semplice versione del gioco del tris.
Realizzare quindi una matrice (3×3) come struttura dati di base e fornire i seguenti metodi:

  • set(riga, colonna, simbolo) [inserisce una giocata]
  • toString() [stampa lo stato della matrice]
  • getWinner() [stampa l’eventuale vincitore]

Lanciare un’eccezione di tipo IllegalArgument qualora la posizione scelta per l’inserimento di una giocata sia già occupata.
Realizzare una classe di test denominata Gioca.java.

[In un prossimo esercizio riprenderemo il Tris fornendo un’interfaccia grafica  e ulteriori metodi]

La classe Tris.java:

public class Tris
{

  // Metodo Costruttore
  // Creo una matrice 3*3 vuota
  public Tris()
  {
    board = new String[rows][columns];
    for(int i=0; i<rows; i++)
      for(int j =0; j<columns; j++)
      {
          board[i][j] = " ";
      }
  }

  // Metodo che restituisce lo stato della matrice
  public String tostring()
  {
    String r = "";
    for(int i=0; i<rows; i++)
    {
        r = r + "|";
        for (int j=0; j<columns ; j++)
          r=r + board[i][j];
        r = r + "|\n";
    }
    return r;
  }

  // Metodo che permette di inserire una giocata
  public void set(int i, int j, String player)
  {
      if(board[i][j] != " ")
      {
        throw new IllegalArgumentException("Posizione occupata");
      }
      board[i][j] = player;
  }

  // Metodo che restituisce il nome del giocatore vincitore
  public String getWinner()
  {
    int k = 0;
    int h = 0;
    // Verifico se il tris è presente in una riga
    for(int i=0; i<rows; i++)
    {
        for (int j=0; j<columns ; j++)
        {
          if(board[i][j]== "x")
          {
            k++;
            if(k==3){ return " VINCE IL GIOCATORE X "; }
          }
          else
          {
             if(board[i][j] == "o")
             {
                h++;
                if(h==3){ return " VINCE IL GIOCATORE O "; }
             }
          }
        }
        k=0;
        h=0;
    }
    // Verifico se il tris è presente in una colonna
    for(int i=0; i<columns; i++)
    {
        for (int j=0; j<rows ; j++)
        {
          if(board[j][i]== "x")
          {
            k++;
            if(k==3){ return " VINCE IL GIOCATORE X "; }
          }
          else
          {
             if(board[j][i] == "o")
             {
                h++;
                if(h==3){ return " VINCE IL GIOCATORE O "; }
             }
          }
        }
        k=0;
        h=0;
    }

    // Verifico se il tris è presente in una diagonale
    for(int i=0; i<rows; i++)
    {
        int j = i;
        if(board[i][j]== "x")
        {
            k++;
            if(k==3){ return " VINCE IL GIOCATORE X "; }
        }
        else
        {
           if(board[i][j] == "o")
           {
              h++;
              if(h==3){ return " VINCE IL GIOCATORE O "; }
           }
        }
    }
    k=0;
    h=0;
    int j = 2;
    for(int i=0; i<rows; i++)
    {
        if(board[i][j] == "x")
        {
            k++;
            if(k==3){ return " VINCE IL GIOCATORE X "; }
        }
        else
        {
           if(board[i][j] == "o")
           {
              h++;
              if(h==3){ return " VINCE IL GIOCATORE O "; }
           }
        }
        j--;
    }
    return "" ;
  }

  private String[][] board;
  private static final int rows = 3;
  private static final int columns = 3;
}

La classe di test, Gioca.java:

import java.util.Scanner;
public class Gioca
{

  public static void main(String[] args)
  {
      int numGiocate = 0;
      String player = "x";

      // Costruisco un nuovo oggetto Tris
      Tris game = new Tris();
      Scanner in = new Scanner(System.in);

      // Procedo con il gioco
      while(true)
      {
          // Giocata del giocatore
          System.out.println(game.toString());
          System.out.print("inserisci riga per " + player);
          System.out.println(" (-1 per uscire): ");

          int riga = in.nextInt();

          if (riga < 0) return;

          System.out.print("Inserisci colonna per " +player);
          System.out.println(" : ");

          int colonna = in.nextInt();

          // Inserimento giocata
          game.set(riga,colonna,player);

          // Visualizzo lo stato del tris
          System.out.println(game.tostring());

          // Verifico se è presente un vincitore
          String verifica = game.getWinner();
          if(verifica.equalsIgnoreCase(" VINCE IL GIOCATORE X ") || verifica.equalsIgnoreCase(" VINCE IL GIOCATORE O "))
          {
              // Il gioco termina se un giocatore vince la partita
              System.out.println(verifica);
              return;
          }

          numGiocate++;
          if(numGiocate==9)
          {
            // Se il tris è pieno e non c'è vincitore, la partita termina
            System.out.println("NESSUN VINCITORE");
            return;
          }

          // Se ha giocato X allora dopo gioca O, altrimenti viceversa
          if(player=="x") player = "o";
          else player = "x";
      }

  }
}

Cliccando qui è possibile scaricare il codice completo.

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

CSS: pseudo-classi e pseudo-elementi  

realizzato da , il 31 gen. 2013, categoria Html/Css

Html/Css
Aumenta font Riduci font Stampa articolo Invia articolo

Pseudo-classi

Una pseudo-classe non definisce un elemento ma un particolare stato di quest’ultimo.
In buona sostanza imposta uno stile per un elemento al verificarsi di certe condizioni.

A livello sintattico, una pseudo-classe non può essere mai dichiarata da sola, bensì deve appoggiarsi ad un elemento. La sintassi è la seguente:

elemento:pseudo_classe { … }

Il segno di due punti (:) divide, senza ulteriori spazi, l’elemento dal nome della pseudo-classe ad esso associato.

a:link {
	color : green;
}
a:visited {
	color : yellow;
}

Traduciamo così le regole appena definite:
i collegamenti ipertestuali (<a>) che non siano stati ancora visitati (:link) avranno il colore verde; i collegamenti che invece risultato già visitati (:visited) avranno il colore giallo.
Da qui risulta più chiaro il concetto espresso in precedenza: la pseudo-classe link definisce lo stile (colore verde) solo in una determinata situazione, ovvero quando il link non è stato attivato (cliccato). Appena ciò dovesse avvenire, il testo non sarà più verde, perchè la condizione originaria è venuta meno e di conseguenza diventerà valida la condizione visited e le regole della relativa pseudo-classe (colore giallo).

Pseudo-classi CSS

Una pseudo-classe può anche essere associata a selettori di tipo classe.
In questo caso la pseudo-classe deve seguire la dichiarazione della classe e le regole di stile definite saranno applicate esclusivamente all’elemento con attributo class dichiarato.

a.collegamento:link {
	color : green;
}
a.collegamento:visited {
	color : yellow;
}

La regola verrà così letta:
Avranno il testo verde solo i link non ancora visitati che abbiano come attributo class=‘collegamento’, di conseguenza il testo sarà giallo se il link è visitato e il class è uguale a ‘collegamento’.

First-Child

La pseudo classe first-child permette di selezionare e formattare un elemento che si trovi ad essere il primo elemento figlio di un altro elemento.

elemento:first-child { … }

Vediamo un esempio concreto a chiarimento:

p:first-child {
	color : green;
}

A tutti i paragrafi viene assegnato il colore verde solo se il singolo paragrafo è il primo elemento figlio di qualsiasi altro elemento.
Esaminiamo questa porzione di codice html:

<div>
	<p>Questo paragrafo è il primo figlio</p>
	<p>Questo paragrafo è il secondo figlio</p>
</div>
<div>
	<p>Questo paragrafo è il primo figlio</p>
	<p>Questo paragrafo è il secondo figlio</p>
	<p>Questo paragrafo è il terzo figlio</p>
</div>

Solo i primi paragrafi dei due div presenti saranno di colore verde:

First-child CSS

Pseudo-elementi

Vi sono parti in un documento HTML che non sono rappresentate da nessun tag in particolare, ma che è possibile comunque modificare e formattare secondo i propri desideri con i CSS grazie ai cosiddetti pseudo-elementi.

Nel momento in cui in un foglio di stile si costruisce una regola che ad essi fa riferimento è come se nel documento venissero inseriti nuovi elementi che hanno la caratteristica di essere appunto fittizi, presenti nel CSS ma non nel codice che definisce la struttura della pagina.

Il supporto di questo tipo speciale di selettore è garantito solo dai browser più recenti.

Ad esempio con il selettore :first-letter è possibile formattare la prima lettera di qualunque elemento contenente testo. Le proprietà modificabili sono ovviamente tutte quelle relative al carattere e al testo, ma anche quelle legate al colore, allo sfondo, ai margini e al padding.

La sintassi è la seguente:

elemento:first-letter { … }

In pratica scrivendo la seguente regola CSS:

p:first-letter {
	color : red;
	font-size : 20px;
}

definiamo che la prima lettera di ogni paragrafo sarà di colore rosso e con un font di 20px.

First-letter CSS

Un altro pseudo-elemento di uso comune è :first-line la cui sintassi è uguale a first-letter con l’unica differenza che le regole CSS verranno applicate alla prima riga di un elemento contenente testo.

Ad esempio, riprendendo il codice precedente:

p:first-line {
	color : red;
	font-size : 20px;
}

otterremo il seguente risultato:

First-line CSS

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:, , , ,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

CSS: selettori speciali  

realizzato da , il 31 gen. 2013, categoria Html/Css

Html/Css
Aumenta font Riduci font Stampa articolo Invia articolo

Gli attributi CLASS e ID

Dall’HTML 4 sono stati introdotti due importanti attributi applicabili a qualsivoglia elemento html. Gli attributi sono: class e id.
ID assume un valore arbitrario, scelto dallo sviluppatore, purché esso sia univoco in tutto il documento. In altre parole l’id è un valore, alfanumerico, che permette di identificare un elemento all’interno del codice html. Un esempio è:

<p id='paragrafo'>
...
</p>

CLASS può assumere un valore stringa qualunque e differisce dall’id perché più elementi possono condividere lo stesso valore.
E’ quindi permesso definire:

<p class='blocco'> ... </p>
<div class='blocco'> ... </div>

Applicare questi attributi ai tag di una pagina html non muta il loro aspetto, ma ci permette innanzitutto di identificare gli elementi, classificarli e distinguerli tra loro.
In questo modo class e id diventano una delle chiavi principali per sfruttare al meglio le potenzialità dei fogli di stile.
Sarà possibile applicare una definizione di stile ad un singolo elemento grazie all’id, oppure a più elementi di tipo diverso grazie all’attributo class.
Negli esempi visti nella lezione precedente, non eravamo sufficientemente in grado di applicare uno stile solo ad un determinato elemento, bensì eravamo in grado di applicare un regola CSS a tutti gli elementi di uno stesso tipo o al massimo in relazione alla loro gerarchia (elemento discendente o figlio).

Selettore classe

Per identificare una classe si usa far precedere il nome da un semplice punto (.):

. nome_della_classe

Questa è la sintassi base.
Un selettore classe così definito può essere applicato a tutti gli elementi di un documento HTML. Vediamo quindi un esempio concreto del selettore classe:

.testo_rosso {
	color : red;
}
.testo_verde {
	color : green;
}

Analizziamo ora la seguente porzione di codice html, nel quale verranno definiti alcuni elementi che utilizzano le classi definite sopra:

<div>Questo è un div che non appartiene ad alcuna classe.</div>
<div class='testo_rosso'>Questo div appartiene alla classe testo_rosso.</div>
<div class='testo_verde'>Questo div appartiene alla classe testo_verde.</div>
<span class='testo_verde'>Anche questo span appartiene alla classe testo_verde!</span>

Il risultato finale è il seguente:

Selettore classe

Nell’esempio, la classe testo_verde è stata applicata ad elementi di natura diversa come un div e uno span. Questo modo di operare ci fornisce un grado di personalizzazione e flessibilità molto alto al cospetto dei semplici selettori di elementi.

Esiste un secondo tipo di sintassi per il selettore di classe:

elemento.nome_della_classe

E’ una regola più restrittiva rispetto alla sintassi generica. Se infatti definiamo le seguenti regole CSS:

p.testo_rosso {
	color : red;
}
div.testo_verde {
	color : green;
}

Lo stile verrà applicato esclusivamente ai paragrafi che presentino attributo class=‘testo_rosso’ e ai div con class=‘testo_verde’.
In pratica se definiamo all’interno del codice html un paragrafo con classe ‘testo_verde’ questo non acquisirà lo stile definito nel CSS perché ‘testo_verde’ è riferito esclusivamente ad elementi div.

Questo secondo tipo di sintassi va usata solo se si pensa di applicare una classe ad uno specifico tipo di elemento (solo paragrafi o solo div, e così via). Se invece si ritiene di doverla applicare a tipi diversi è necessaria la sintassi generica.

Selettore ID

La sintassi di un selettore ID risulta essere ancor più semplice di quella del selettore classe.

#nome_id

In questo caso è necessaria esclusivamente questa sintassi essendo per natura l’ID univoco all’interno del codice html,  specificare l’elemento al quale è associato l’id sarebbe superfluo.

Vediamo un esempio pratico, riprendendo il codice descritto per il selettore classe:

#testo_rosso {
	color : red;
}
#testo_verde {
	color : green;
}

Riscriviamo la porzione di codice html, utilizzando al posto dell’attributo class l’attributo id:

<div>Questo è un div che non appartiene ad alcuna classe.</div>
<div id='testo_rosso'>Questo div ha come ID testo_rosso.</div>
<div id='testo_verde'>Questo div ha come ID testo_verde.</div>

Il primo div non ha un id settato, mentre il secondo e il terzo hanno come id rispettivamente ‘testo_rosso’ e ‘testo_verde’. Il risultato nella finestra del browser è il seguente:

Selettore ID

Condividi Share on FacebookTweet about this on TwitterShare on Google+Share on LinkedInShare on Tumblr

Leave a Comment
Invia questo articolo Invia ad un amico (Send this to a friend)
 Stampa questo articolo (Print now)  Stampa questo articolo (Print now)
:,
Ti è piaciuto? Ti è piaciuto quest'articolo, guida o riflessione? Scoprine tanti altri nel menu articoli.

Torna sopra ↑

Fabio Donatantonio - Salerno - Città di Castello (PG) - fabio@donatantonio.net



About me

Fabio Donatantonio Fabio Donatantonio nasce a Salerno il 17 Settembre 1983.
Cresce coltivando due grandi passioni: la musica e l'informatica.
... [continua]

Bing

Tutti gli articoli per categoria

Html/Css [35]

· CSS: pseudo-classi e pseudo-elementi
· CSS: selettori speciali
· CSS: i selettori (parte II)
· CSS: i selettori (parte I)
· CSS: sintassi di una regola CSS
· CSS: introduzione ai fogli di stile
· Html: bordi, margini e spaziatura
· Html: dimensione degli elementi
· Html: i colori e gli sfondi
· Html: altri campi di input
· Html: checkbox e radio button
· Html: le select
· Html: ulteriori campi di testo
· Html: i bottoni
· Html: i form
· Html: unione di celle
· Html: le tabelle
· Html: immagini come link e mappe
· Html: allineamento delle immagini e altri attributi
· Html: le immagini
· Html: realizzare un menu (esercizio guidato)
· Html: i segnalibri
· Html: i collegamenti ipertestuali
· Html: annidamento, indentazione e commenti
· Html: le entità
· Html: separatori ed elenchi
· Html: stile per il testo
· Html: i tag di uso frequente
· Validazione del codice HTML
· Il tag HTML, HEAD e META
· I documenti HTML
· Html: concetti preliminari
· Regole di progettazione ipertestuale
· Tipologie di Ipertesto
· Ipertesti, ipermedia e multimedialità

Java [30]

· Esercizio 30 – Semplice gioco del TRIS
· Esercizio 29 – Simulazione banca (ArrayList)
· Esercizio 28 – Implementazione di un portafoglio
· Esercizio 27 – Simulazione Casinò
· Esercizio 26 – Ricerca e conteggio di parole
· Esercizio 25 – Generatore numeri primi
· Esercizio 24 – Generatore numeri di Fibonacci
· Esercizio 23 – Triangolo con asterischi
· Esercizio 22 – Tasso di cambio
· Esercizio 21 – Serratura
· Esercizio 20 – Simple Calendario
· Esercizio 19 – Ordine lessicografico
· Esercizio 18 – Stampa stringa in base ad input
· Esercizio 17 – Numeri in virgola mobile (ordinamento)
· Esercizio 16 – Nomi dei mesi
· Esercizio 15 – Stampa al contrario
· Esercizio 14 – Erogazione del resto
· Esercizio 13 – Calcola quadrato
· Esercizio 12 – Simulatore lancio dado
· Esercizio 11 – Contatore di monete
· Esercizio 10 – Cartoline con testo fisso
· Esercizio 9 – Popolazione scarafaggi
· Esercizio 8 – Voto medio studente
· Esercizio 7 – Distributore di bibite (simple version)
· Esercizio 6 – Gestione conto bancario (con interessi)
· Esercizio 5 – Classe Rectangle
· Esercizio 4 – Cliente e gestione Conto Bancario
· Esercizio 3 – Realizzazione di Classi (Punto – Rettangolo)
· Esercizio 2 – Menu di scelta (istruzione if)
· Esercizio 1 – Modifica di stringhe

JavaScript [33]

· tScroll (tabella con scroll) – Plugin jQuery
· Finestra news con effetto fade (news ticker) – v 2.0 news da file esterno
· toolTitle (simple toolTip) – Plugin jQuery
· Number_format Javascript
· Testo animato: macchina da scrivere
· Str_replace Javascript
· Maxlength textarea
· tZebra (tabella zebrata) – Plugin jQuery
· JQuery, il metodo .remove()
· JQuery, il metodo .text()
· JQuery, il metodo .html()
· JQuery, il metodo .val()
· Ricerca in tabella html
· News a scorrimento (news ticker)
· Finestra news con effetto fade (news ticker)
· Div al centro che segue lo scrolling
· Aggiungere righe a tabella in maniera dinamica
· Presentazione di diapositive con JQuery
· Presentazione di diapositive temporizzata
· Costruire un orologio con cicli di temporizzazione
· Gestione dei link con Javascript
· Form dinamico – Aggiunta elementi di input
· Controllo importo in Javascript e messaggio di errore
· Div con bordo lampeggiante
· Controllo data in Javascript e messaggio di errrore
· Formattare una data in Javascript
· Finestra popup sempre in primo paino
· Barra di caricamento in Javascript
· Stampare contenuto di un div con Javascript
· Attesa caricamento pagina in Javascript
· Div al centro della finestra del browser
· Ultimo giorno del mese
· Funzione Trim
Chiudi tra 5 secondi...