jQuery in modo succinto core jQuery

Concetto base dietro jQuery

Mentre esistono alcune variazioni concettuali (ad esempio funzioni come $ .ajax) nell'API jQuery, il concetto centrale di jQuery è "trova qualcosa, fai qualcosa". Più specificamente, seleziona gli elementi DOM da un documento HTML e poi fai qualcosa con loro usando i metodi jQuery. Questo è il concetto di grande immagine.

Per guidare questo concetto a casa, rifletti sul codice qui sotto.

          

Si noti che in questo documento HTML stiamo usando jQuery per selezionare un elemento DOM (). Con qualcosa selezionato, facciamo qualcosa con la selezione invocando i metodi jQuery testo(), attr (), e appendTo ().

Il testo metodo chiamato sul pacchetto elemento e imposta il testo di visualizzazione dell'elemento da "jQuery". Il attr chiamata imposta il href attributo al sito Web jQuery.

Groking il concetto di "trovare qualcosa, fare qualcosa" è fondamentale per avanzare come sviluppatore di jQuery.


Il concetto, dietro il concetto, dietro jQuery

Mentre selezionare qualcosa e fare qualcosa è il concetto alla base di jQuery, mi piacerebbe estendere questo concetto includendo anche la creazione di qualcosa. Pertanto, il concetto alla base di jQuery potrebbe essere esteso per includere prima la creazione di qualcosa di nuovo, selezionarlo e quindi fare qualcosa con esso. Potremmo chiamare questo concetto, dietro il concetto, dietro jQuery.

Quello che sto cercando di rendere ovvio è che non sei bloccato solo selezionando qualcosa che è già nel DOM. È inoltre importante aggiungere che jQuery può essere utilizzato per creare nuovi elementi DOM e quindi fare qualcosa con questi elementi.

Nell'esempio di codice seguente, creiamo un nuovo elemento che non è nel DOM. Una volta creato, viene selezionato e quindi manipolato.

       

Il concetto chiave da raccogliere qui è che stiamo creando il elemento al volo e quindi operare su di esso come se fosse già nel DOM.


jQuery richiede HTML per l'esecuzione in modalità standard o quasi standard

Esistono problemi noti con i metodi jQuery che non funzionano correttamente quando un browser esegue il rendering di una pagina HTML in modalità quirk. Assicurati che quando usi jQuery il browser interpreti l'HTML in modalità standard o quasi standard usando un doctype valido.

Per garantire la corretta funzionalità, gli esempi di codice in questo libro utilizzano il doctype HTML 5.

 

Aspettando che il DOM sia pronto

jQuery attiva un evento personalizzato denominato pronto quando il DOM è caricato e disponibile per la manipolazione. Il codice che manipola il DOM può essere eseguito in un gestore per questo evento. Questo è un modello comune visto con l'uso di jQuery.

Il seguente esempio presenta tre esempi codificati di questo evento personalizzato in uso.

        

Tieni presente che puoi associarne altrettanti pronto() eventi sul documento come desideri. Non sei limitato a uno solo. Sono eseguiti nell'ordine in cui sono stati aggiunti.


Esecuzione del codice jQuery quando la finestra del browser è stata caricata completamente

In genere, non vogliamo aspettare il window.onload evento. Questo è il punto di usare un evento personalizzato come pronto() che eseguirà il codice prima che la finestra venga caricata, ma dopo che il DOM è pronto per essere attraversato e manipolato.

Tuttavia, a volte in realtà vogliamo aspettare. Mentre l'abitudine pronto() l'evento è ottimo per eseguire codice una volta che il DOM è disponibile, possiamo anche usare jQuery per eseguire il codice una volta che l'intera pagina Web (incluse tutte le risorse) è completamente caricata.

Questo può essere fatto allegando un gestore di eventi di caricamento a finestra oggetto. jQuery fornisce il caricare() metodo di evento che può essere utilizzato per richiamare una funzione una volta che la finestra è stata caricata completamente. Di seguito, fornisco un esempio di caricare() metodo di evento in uso.

        

Includi tutti i file CSS prima di includere jQuery

A partire da jQuery 1.3, la libreria non garantisce più che tutti i file CSS vengano caricati prima che venga attivata l'abitudine pronto() evento. A causa di questo cambiamento in jQuery 1.3, dovresti sempre includere tutti i file CSS prima di qualsiasi codice jQuery. Ciò assicurerà che il browser abbia analizzato il CSS prima di passare al JavaScript incluso più avanti nel documento HTML. Naturalmente, le immagini a cui si fa riferimento tramite CSS possono o non possono essere scaricate in quanto il browser analizza il codice JavaScript.


Utilizzo di una versione ospitata di jQuery

Quando si incorpora jQuery in una pagina Web, la maggior parte delle persone sceglie di scaricare il codice sorgente e di collegarsi ad esso da un dominio / host personale. Tuttavia, ci sono altre opzioni che coinvolgono qualcun altro che ospita il codice jQuery per te.

Google ospita diverse versioni del codice sorgente di jQuery con l'intento che venga utilizzato da chiunque. Questo è davvero molto utile. Nell'esempio di codice qui sotto sto usando a

Google ospita anche diverse versioni precedenti del codice sorgente di jQuery e per ciascuna versione sono fornite varianti miniate e non miniate. Raccomando di utilizzare la variante non minified durante lo sviluppo, poiché gli errori di debugging sono sempre più facili quando si ha a che fare con codice non minified.

Un vantaggio dell'utilizzo di una versione di jQuery ospitata da Google è che è affidabile, veloce e potenzialmente memorizzato nella cache.


Esecuzione del codice jQuery quando il DOM viene analizzato senza utilizzare Ready ()

L'abitudine pronto() l'evento non è interamente necessario. Se il tuo codice JavaScript non influenza il DOM, puoi includerlo ovunque nel documento HTML. Questo significa che puoi evitare il pronto() evento del tutto se il tuo codice JavaScript non dipende dal fatto che il DOM sia intatto.

La maggior parte dei JavaScript al giorno d'oggi, in particolare il codice jQuery, comporterà la manipolazione del DOM. Ciò significa che il DOM deve essere completamente analizzato dal browser per poter operare su di esso. Questo è il motivo per cui gli sviluppatori sono rimasti bloccati su window.onload giro sulle montagne russe per un paio d'anni.

Per evitare di usare il pronto() evento per codice che opera sul DOM, puoi semplicemente inserire il codice in un documento HTML prima della chiusura elemento. Ciò garantisce che il DOM sia completamente caricato, semplicemente perché il browser analizzerà il documento dall'alto verso il basso. Se si inserisce il codice JavaScript nel documento dopo gli elementi DOM che manipola, non è necessario utilizzare il pronto() evento.

Nell'esempio qui sotto, ho dimenticato l'uso di pronto() semplicemente posizionando il mio script prima che il corpo del documento si chiuda. Questa è la tecnica che uso in questo libro e nella maggior parte dei siti che costruisco.

    

Ciao, sono il DOM! Script via!

Se dovessi collocare il


Rompere la catena con metodi distruttivi

Come accennato in precedenza, non tutti i metodi jQuery mantengono la catena. Metodi come  testo() può essere concatenato quando viene usato per impostare il nodo di testo di un elemento. però, testo() in realtà rompe la catena quando viene utilizzato per ottenere il nodo di testo contenuto all'interno di un elemento.

Nell'esempio qui sotto, testo() è usato per impostare e quindi ottenere il testo contenuto all'interno del

 elemento.

        

Ottenere il testo contenuto all'interno di un elemento usando testo() è un primo esempio di catena spezzata perché il metodo restituirà una stringa contenente il nodo di testo, ma non il set di wrapper jQuery.

Non dovrebbe sorprendere il fatto che se un metodo jQuery non restituisce il set di wrapper jQuery, la catena viene quindi interrotta. Questo metodo è considerato distruttivo.


Utilizzo di metodi jQuery distruttivi e distruzione in uscita con End ()

I metodi jQuery che alterano il set di wrapper jQuery originale sono considerati distruttivi. Il motivo è che non mantengono lo stato originale del set di wrapper. Da non preoccuparsi; nulla è veramente distrutto o rimosso. Piuttosto, l'ex set di wrapper è collegato a un nuovo set.

Tuttavia, il divertimento con il concatenamento non deve fermarsi una volta che il set originale avvolto viene alterato. Usando il fine() metodo, è possibile annullare qualsiasi modifica distruttiva apportata al set di wrapper originale. Esaminare l'uso del fine() metodo nel seguente esempio per capire come operare dentro e fuori dagli elementi DOM.

     

Aspetti della funzione jQuery

La funzione jQuery è multiforme. Possiamo passare a valori e formazioni di stringhe diversi che possono quindi utilizzare per eseguire funzioni uniche. Ecco alcuni usi della funzione jQuery:

  • Seleziona gli elementi dal DOM utilizzando le espressioni CSS e le espressioni jQuery personalizzate, nonché selezionando gli elementi usando i riferimenti DOM: jQuery ('p> a') o jQuery ( ': primo') e jQuery (document.body)
  • Crea HTML al volo passando strutture di stringhe HTML o metodi DOM che creano elementi DOM: jQuery ('
    ')
    o jQuery (document.createElement ( 'div'))
  • Una scorciatoia per il pronto() evento passando una funzione alla funzione jQuery: jQuery (function ($) / * Collegamento per ready () * /)

Ognuno di questi usi è dettagliato nell'esempio di codice riportato di seguito.

       

Groking quando la parola chiave si riferisce agli elementi DOM

Quando si collegano eventi a elementi DOM contenuti in un set di wrapper, la parola chiaveQuesto può essere usato per riferirsi all'attuale elemento DOM che richiama l'evento. L'esempio seguente contiene il codice jQuery che allegherà una personalizzata MouseEnter evento a ciascuno elemento nella pagina. Il codice JavaScript nativo mouseover l'evento si attiva quando il cursore entra o esce da un elemento figlio, mentre quello di jQuery MouseEnter non.

    jQuery.com jQuery.com jQuery.com    

All'interno della funzione anonima che viene passata al MouseEnter () metodo, usiamo la parola chiave Questo per riferirsi alla corrente elemento. Ogni volta che il mouse tocca il testo "jQuery.com", il browser avviserà quale elemento è stato sostituito con il mouse identificando il suo id valore dell'attributo.

Nell'esempio precedente, è anche possibile prendere il Questo fare riferimento e passarlo alla funzione jQuery in modo che l'elemento DOM sia incluso nella funzionalità jQuery.

Quindi, invece di questo:

 // Accesso all'attributo ID dell'elemento DOM. alert (this.id);

Avremmo potuto farlo:

 // Avvolge l'elemento DOM con un oggetto jQuery, // e quindi usa attr () per accedere al valore dell'ID. alert ($ (this) .attr ( 'id'));

Questo è possibile perché la funzione jQuery non prende solo le espressioni del selettore, ma prenderà anche riferimenti agli elementi DOM. Nel codice, Questo è un riferimento a un elemento DOM.

La ragione per cui potresti voler includere la funzionalità jQuery attorno a un elemento DOM dovrebbe essere ovvia. Ciò ti dà la possibilità di usare il concatenamento jQuery, nel caso tu ne abbia bisogno.

L'iterazione su un insieme di elementi contenuti nel set di wrapper jQuery è in qualche modo simile al concetto appena discusso. Usando il jQuery ogni() metodo, possiamo scorrere su ogni elemento DOM contenuto in un set di wrapper. Ciò consente l'accesso a ciascun elemento DOM individualmente, tramite l'utilizzo di Questo parola chiave.

Basandoci sul markup dell'esempio precedente, possiamo selezionare tutto elementi nella pagina e utilizzare il ogni() metodo per iterare su ciascuno elemento nel set di wrapper, accedendo al suo id attributo. Ecco un esempio.

   jQuery.com jQuery.com jQuery.com    

Se dovessi caricare l'HTML in un browser, il browser avviserà per id valore di ciascuno elemento nella pagina. Dato che ce ne sono tre elementi nella pagina, ottieni tre iterazioni tramite il ogni() metodo e tre finestre di avviso.


Estrarre elementi da un set wrapper, utilizzarli direttamente senza jQuery

Solo perché avvolgi la funzionalità jQuery attorno a un elemento HTML non significa che perdi l'accesso all'effettivo elemento DOM stesso. Puoi sempre estrarre un elemento dal set di wrapper e operare sull'elemento tramite JavaScript nativo. Ad esempio, nel codice qui sotto sto impostando l'attributo title del elemento nella pagina HTML manipolando la proprietà del titolo nativo del Elemento DOM.

    jQuery.com    

Come dimostrato, jQuery fornisce il pratico ottenere() metodo per accedere agli elementi DOM ad un indice specifico nel set di wrapper.

Ma c'è un'altra opzione qui. Puoi evitare di usare il ottenere() metodo semplicemente usando la notazione degli array parentesi quadre sull'oggetto jQuery stesso. Nel contesto del nostro esempio di codice precedente:

Questo codice:

 $ ('a'). get (0) .title = 'jQuery.com';

Potrebbe diventare questo:

 $ ('a') [0] .title = 'jQuery.com';

Entrambi consentono l'accesso all'elemento DOM reale. Personalmente, preferisco la notazione a parentesi quadre. È più veloce perché usa JavaScript nativo per recuperare l'elemento da una matrice, invece di passarlo a un metodo.

comunque, il ottenere() Il metodo fornisce una soluzione intelligente per collocare tutti gli elementi DOM in un array nativo. Semplicemente chiamando il ottenere() metodo senza passare un parametro indice, il metodo restituirà tutti gli elementi DOM nel set di wrapper in un array JavaScript nativo.

Per dimostrare, prendiamo ottenere() per un test drive. Nel codice qui sotto, sto mettendo tutto il elementi in un array. Quindi utilizzo la matrice per accedere alla proprietà del titolo del terzo Oggetto DOM sulla pagina.

    jQuery.com jQuery.com jQuery.com    

Gli appunti: utilizzando ottenere() finirà il concatenamento di jQuery. Prenderà il wrapper set e lo cambierà in una semplice serie di elementi DOM che non sono più racchiusi nella funzionalità jQuery. Pertanto, utilizzando il .fine() il metodo non può ripristinare il concatenamento dopo .ottenere().


Verifica se il set di wrapper è vuoto

Prima di iniziare a operare su un set di wrapper, è logico verificare di aver selezionato qualcosa. La soluzione più semplice è usare un Se dichiarazione per verificare se il set di wrapper contiene elementi DOM.

    jQuery    

La verità della questione è sopra Se le istruzioni non sono del tutto necessarie, perché jQuery fallirà silenziosamente se non vengono trovati elementi. Tuttavia, ogni metodo incatenato a qualsiasi set di wrapper vuoto viene ancora richiamato. Quindi, mentre potremmo effettivamente rinunciare all'uso del Se dichiarazioni, è probabile che sia una buona regola per usarle. Il richiamo di metodi su un set di wrapper vuoto potrebbe potenzialmente causare un'elaborazione non necessaria, nonché risultati indesiderati se i metodi restituiscono valori diversi dal set di wrapper e tali valori vengono applicati su.


Creare un alias rinominando l'oggetto jQuery stesso

jQuery fornisce il noConflict () metodo che ha diversi usi, vale a dire la capacità di sostituire $ con un altro alias. Questo può essere utile in tre modi: può rinunciare all'uso del $ accedere a un'altra libreria, evitare conflitti potenziali e fornire la possibilità di personalizzare lo spazio dei nomi / alias per l'oggetto jQuery.

Ad esempio, diciamo che stai creando un'applicazione Web per la società XYZ. Potrebbe essere bello personalizzare jQuery in modo che invece di dover usare jQuery ( 'div'). show () o $ ( 'Div'). Show () potresti usare XYZ ( 'div'). Show () anziché.

    
Syncfusion., Inc.

Gli appunti:Passando il noConflict () funzione un valore booleano di true, è possibile annullare completamente ciò che jQuery ha introdotto nella pagina Web. Questo dovrebbe essere usato solo in casi estremi perché, molto probabilmente, causerà problemi con i plugin jQuery.


Uso di .each () quando l'iterazione implicita non è sufficiente

Speriamo sia ovvio che se hai una pagina HTML (esempio sotto) con tre vuote

elementi, la seguente istruzione jQuery selezionerà tutti e tre gli elementi nella pagina, eseguirà un'iterazione sui tre elementi (iterazione implicita) e inserirà il testo "I am a div" in tutti e tre gli elementi.
elementi.

    

Questa è considerata iterazione implicita perché il codice jQuery presuppone che si desideri manipolare tutti e tre gli elementi, che richiede l'iterazione sugli elementi selezionati e l'impostazione del valore del nodo di testo di ciascun

con il testo "I am a div." Quando viene eseguito per impostazione predefinita, viene indicato come iterazione implicita.

Questo è abbastanza utile. Per la maggior parte, la maggior parte dei metodi jQuery applicherà l'iterazione implicita. Tuttavia, altri metodi si applicano solo al primo elemento nel set di wrapper. Ad esempio, il metodo jQuery attr () accederà al primo elemento del set wrapper solo quando viene utilizzato per ottenere un valore di attributo.

Gli appunti:Quando si usa il attr () metodo per impostare un attributo, jQuery applicherà effettivamente l'iterazione implicita per impostare l'attributo e il suo valore su tutti gli elementi nel set di wrapper.

Nel codice qui sotto, il set di wrapper contiene tutto

elementi nella pagina, ma il attr () metodo restituisce solo il id valore del primo elemento contenuto nel set di wrapper.

    
Sono un div
Sono un div
Sono un div

Per motivi di dimostrazione, supponiamo che il tuo obiettivo sia in realtà quello di ottenere il id valore attributo per ciascun elemento nella pagina. Potresti scrivere tre istruzioni jQuery separate che accedono a ciascuna di esse

elementi id valore dell'attributo. Se dovessimo farlo, potrebbe sembrare qualcosa del genere:

 $ ( '# Div1') attr ( 'id').; $ ( '# Div2') attr ( 'id').; $ ( '# Div3') attr ( 'id').; // o var $ divs = $ ('div'); // Query memorizzata nella cache $ divs.eq (0) .attr ('id'); // Inizia con 0 invece di 1 $ divs.eq (1) .attr ('id'); $ Divs.eq (2) .attr ( 'id');

Sembra un po 'prolisso, no? Non sarebbe bello se potessimo ricorrere al set di wrapper e semplicemente estrarre il id valore attributo da ciascuno dei

elementi? Usando il $ (). Each () metodo, invochiamo un altro round di iterazione quando il nostro set di wrapper richiede un'iterazione esplicita per gestire più elementi.

Nell'esempio di codice seguente, utilizzo il $ (). Each () metodo per eseguire il looping del set di wrapper, accedere a ciascun elemento nel set e quindi estrarlo id valore dell'attributo.

    
div1
div2
div3

Immagina le possibilità che ti aspettano con la possibilità di far rispettare l'iterazione ogni volta che vuoi.

Gli appunti: jQuery fornisce anche a $ .Ogni funzione, da non confondere con il $ (). Ogni metodo, che viene utilizzato in modo specifico per iterare su un set di wrapper jQuery. Il $ .Ogni il metodo può essere effettivamente utilizzato per iterare su qualsiasi vecchio array o oggetto JavaScript. È essenzialmente un sottotitolo per i loop nativi di JavaScript.


Elementi nel set wrapper jQuery Restituito nell'ordine del documento

Il motore di selezione restituirà i risultati nell'ordine del documento anziché nell'ordine in cui sono stati passati i selettori. Il set di wrapper verrà popolato con gli elementi selezionati in base all'ordine in cui ogni elemento appare nel documento, dall'alto verso il basso.

    

h1

h2

h3


Determinazione del contesto usato dalla funzione jQuery

Il contesto predefinito utilizzato dalla funzione jQuery quando si selezionano gli elementi DOM è l'elemento del documento (ad es. $ ('a', documento)). Ciò significa che se non si fornisce la funzione jQuery (ad es. jQuery ()) con un secondo parametro da utilizzare come contesto per la query DOM, il contesto predefinito utilizzato è l'elemento del documento, più comunemente noto come .

È possibile determinare il contesto in cui la funzione jQuery sta eseguendo una query DOM utilizzando il contesto proprietà. Di seguito vengono mostrati due esempi codificati di recupero del valore della proprietà context.

    
jQuery

Creazione di un'intera struttura DOM, compresi gli eventi DOM, in una catena singola

Sfruttando i metodi di concatenamento e jQuery, puoi creare non solo un singolo elemento DOM, ma intere strutture DOM. Di seguito creo un elenco non ordinato di collegamenti jQuery che aggiungo al DOM.

       

Il concetto che devi rimuovere dall'esempio precedente è che jQuery può essere utilizzato per creare e gestire strutture DOM complesse. Usando solo i metodi jQuery, puoi creare la maggior parte delle strutture DOM che potresti avere bisogno.