Utilizzo di JavaScript non intrusivo e AJAX con Rails 3

Come ho accennato nel mio precedente tutorial su Ruby on Rails, UnoJavascript JavaScript (UJS) è una delle nuove funzionalità più interessanti di Rails 3. UJS consente al codice generato da Rails di essere molto più pulito, aiuta a separare la logica JavaScript dai tuoi layout HTML e disaccoppia Rotaie dalla libreria Prototype JavaScript. In questo tutorial, esamineremo queste funzionalità e impareremo come utilizzarle in una semplice applicazione Rails 3.


Background: cos'è JavaScript non intrusivo?

Per iniziare, cos'è esattamente UJS? Semplicemente, UJS è JavaScript che è separato dal tuo markup HTML. Il modo più semplice per descrivere UJS è con un esempio. Prendere un gestore di eventi onclick; potremmo aggiungerlo in modo obliquo:

 collegamento

O potremmo aggiungerlo in modo discreto collegando l'evento al link (usando jQuery in questo esempio):

 collegamento 

Come accennato nella mia introduzione, questo secondo metodo ha una serie di vantaggi, tra cui un debugging più semplice e un codice più pulito.

"Rails 3, d'altro canto, è indipendente dal framework JavaScript, in altre parole, è possibile utilizzare il framework JavaScript prescelto, a condizione che esista un'implementazione UJS Rails per quel framework."

Fino alla versione 3, Ruby on Rails ha generato JavaScript invadente. Il codice risultante non era pulito, ma ancora peggio, era strettamente accoppiato al framework Prototype JavaScript. Questo significava che a meno che non avessi creato un plugin o Rails hackerati, dovevi usare la libreria Prototype con i metodi helper JavaScript di Rail.

Rails 3, d'altra parte, è agnostico framework JavaScript. In altre parole, è possibile utilizzare il framework JavaScript prescelto, a condizione che esista un'implementazione UCHI Rails per quel framework. Le implementazioni UJS correnti includono quanto segue:

  • Prototipo (predefinito)
  • jQuery
  • MooTools

Rails 3 implementa ora in modo discreto tutte le funzionalità di JavaScript Helper (richieste AJAX, prompt di conferma, ecc.) Aggiungendo i seguenti attributi personalizzati HTML 5 agli elementi HTML.

  • data-method: il metodo REST da utilizzare negli invii di moduli.
  • data-confirm: il messaggio di conferma da utilizzare prima di eseguire qualche azione.
  • data-remote - se true, invia tramite AJAX.
  • data-disable-with - disabilita gli elementi del modulo durante l'invio di un modulo

Ad esempio, questo tag link

 Distruggere

invierebbe una richiesta di cancellazione AJAX dopo aver chiesto all'utente "Sei sicuro?"

Puoi immaginare quanto sarebbe più difficile leggere se tutto ciò che JavaScript fosse in linea.

Ora che abbiamo esaminato UJS e come Rails implementa UJS, impostiamo un progetto e guardiamo alcune applicazioni specifiche. In questa esercitazione utilizzeremo la libreria jQuery e l'implementazione UJS.


Passaggio 1: impostazione del progetto

Dal momento che stiamo creando un nuovo progetto da zero, la prima cosa che dobbiamo fare è creare il progetto digitando quanto segue:

 rota nuovo blog --skip-prototype

Si noti che sto istruendo Rails per saltare il file JavaScript prototipo, dal momento che sto per utilizzare la libreria jQuery.

Iniziamo il server solo per assicurarci che tutto funzioni correttamente.

E, voilà!

Ora che abbiamo impostato il nostro progetto, dobbiamo aggiungere jQuery e jQuery UJS al nostro progetto. Sei libero di organizzare il tuo JavaScript come vuoi, ma la convenzione di Rails per strutturare i tuoi file JavaScript è la seguente (tutti questi file sono pubblici / javascript):

  • file JavaScript framework (jquery.js, prototype.js o mootools.js)
  • rails.js - il codice che implementa le guide UJS (per qualsiasi framework tu abbia scelto)
  • application.js - il tuo codice JavaScript dell'applicazione

Se non lo hai già fatto, scarica jquery.js (o fai riferimento a un CDN) e rails.js e includili nel tuo pubblici / javascript elenco.

L'ultima cosa che dobbiamo fare per essere operativi è in realtà dire a Rails di includere questi file js su ciascuna delle nostre pagine. Per fare ciò, apri application.rb nella tua directory di configurazione e aggiungi la seguente riga

 config.action_view.JavaScript_expansions [: defaults] =% w (applicazione jquery rails)

Questo elemento di configurazione dice a Rails di includere i tre file JavaScript sopra menzionati per impostazione predefinita.

In alternativa, puoi afferrare jQuery da un CDN (ad esempio http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js) includendo manualmente un tag script che punta alla posizione corretta. Se lo fai, assicurati di rimuovere "jquery" dall'elemento di configurazione JavaScript_expansions.


Passaggio 2: generazione di un codice

Per dimostrare la funzionalità UJS dei binari, per prima cosa dovremo avere del codice con cui lavorare. Per questa demo avremo solo un semplice oggetto Post. Facciamolo ora

 rails genera scaffold Nome del messaggio: titolo stringa: contenuto stringa: testo

E poi migriamo il nostro database per creare la tabella dei post.

 rake db: migrate

Ok, siamo a posto! Se navighiamo http: // localhost: 3000 / messaggi / new, dovremmo vedere un modulo per creare un nuovo post.

Ok, funziona tutto! Ora analizziamo e vediamo come utilizzare la funzionalità UJS e AJAX in Rails.


Passaggio 3: aggiunta di AJAX

Ora che tutti i file JavaScript necessari sono stati inclusi, possiamo effettivamente iniziare a utilizzare Rails 3 per implementare alcune funzionalità AJAX. Sebbene tu possa scrivere tutto il codice JavaScript personalizzato che desideri, Rails offre alcuni buoni metodi integrati che puoi usare per eseguire facilmente chiamate AJAX e altre azioni JavaScript.

Diamo un'occhiata a un paio di aiutanti di rotaie comunemente usati e al codice JavaScript che generano

File di invio AJAX e file ERB Javascript

Se esaminiamo il nostro modulo Post, possiamo vedere che ogni volta che creiamo o modificiamo un post, il modulo viene inviato manualmente e quindi siamo reindirizzati a una visualizzazione di sola lettura di quel post. Cosa accadrebbe se volessimo inviare tale modulo tramite AJAX anziché utilizzare l'invio manuale?

Rails 3 semplifica la conversione di qualsiasi forma in AJAX. Primo, apri il tuo _form.html.erb parziale in app / views / posts e modifica la prima riga da:

 <%= form_for(@post) do |f| %>

a

 <%= form_for(@post, :remote => vero) do | f | %>

Prima di Rails 3, aggiungendo : remote => true avrebbe generato una serie di JavaScript inline all'interno del tag form, ma con Rails 3 UJS, l'unica modifica è l'aggiunta di un attributo personalizzato HTML 5. Puoi individuarlo?

 

L'attributo è dati remoto = "true", e il Rails UJS di Rails si lega a qualsiasi modulo con quell'attributo e li invia tramite AJAX anziché un POST tradizionale.

Questo è tutto ciò che è necessario per inviare AJAX, ma come eseguiamo una richiamata dopo il ritorno della chiamata AJAX?

Il modo più comune di gestire un ritorno da una chiamata AJAX è attraverso l'uso di file JavaScript ERB. Funzionano esattamente come i normali file ERB, ma contengono codice JavaScript anziché HTML. Proviamolo.

La prima cosa che dobbiamo fare è dire al nostro controller come rispondere alle richieste AJAX. Nel posts_controller.rb (app / controller) possiamo dire al nostro controller di rispondere a una richiesta AJAX aggiungendo

 format.js

in ciascuna rispondi al blocco che chiameremo tramite AJAX. Ad esempio, potremmo aggiornare l'azione create per assomigliare a questo:

 def create @post = Post.new (params [: post]) answer_to do | format | if @ post.save format.html redirect_to (@post,: notice => 'Post creato.') format.js else format.html render: action => "new" format.js end end end

Poiché non abbiamo specificato alcuna opzione nel blocco respond_to, Rails risponderà alle richieste JavaScript caricando a .js ERB con lo stesso nome dell'azione del controller (create.js.erb, in questo caso).

Ora che il nostro controller sa come gestire le chiamate AJAX, dobbiamo creare le nostre visualizzazioni. Per l'esempio corrente, aggiungi create.js.erb nel tuo app / views / messaggi directory. Questo file verrà visualizzato e il JavaScript interno verrà eseguito al termine della chiamata. Per ora, semplicemente sovrascriviamo il tag form con il titolo e i contenuti del post del blog:

 $ ( 'Body'). Html ("

<%= escape_javaScript(@post.title) %>

").aggiungere("<%= escape_javaScript(@post.content) %>");

Ora se creiamo un nuovo post, otteniamo quanto segue sullo schermo. Successo!

Il vantaggio di questo metodo è che puoi intersponderare il codice ruby ​​che hai impostato nel tuo controller con il tuo JavaScript, rendendo davvero facile manipolare la tua vista con i risultati di una richiesta.

Callback AJAX che utilizzano eventi JavaScript personalizzati

Ogni implementazione di Rails UJS offre anche un altro modo per aggiungere callback alle nostre chiamate AJAX: eventi JavaScript personalizzati. Diamo un'occhiata ad un altro esempio. Nella nostra vista indice dei post (http: // localhost: 3000 / messaggi /), possiamo vedere che ogni post può essere cancellato tramite un link di cancellazione.

Diamo AJAXify il nostro link aggiungendo: remote => true e aggiungendo anche una classe CSS così possiamo facilmente trovare questo POST usando un selettore CSS.

 <%= link_to 'Destroy', post, :confirm => 'Sei sicuro?',: Metodo =>: delete,: remote => true,: class => 'delete_post'%>

Che produce il seguente output:

 Distruggere

Ogni rotaia chiamata UJS AJAX fornisce sei eventi personalizzati che possono essere allegati a:

  • Ajax: prima - giusto prima della chiamata ajax
  • Ajax: carico - prima della chiamata ajax, ma dopo la creazione dell'oggetto XmlHttpRequest)
  • Ajax: il successo - chiamata ajax di successo
  • Ajax: fallimento - chiamata ajax fallita
  • Ajax: completa - completamento della chiamata ajax (dopo ajax: successo e ajax: fallimento)
  • Ajax: dopo - dopo che è stata inviata una chiamata ajax (nota: non dopo il reso)

Nel nostro caso aggiungeremo un listener di eventi al Ajax: il successo evento sui nostri collegamenti di eliminazione e rende il post eliminato in dissolvenza anziché ricaricare la pagina. Aggiungeremo il seguente codice JavaScript al nostro file application.js.

 $ ('. delete_post'). bind ('ajax: success', function () $ (this) .closest ('tr'). fadeOut (););

Dovremo inoltre comunicare al nostro post_controller di non provare a eseguire il rendering di una vista al termine dell'eliminazione del post.

 def destroy @post = Post.find (params [: id]) @ post.destroy answer_to do | format | format.html redirect_to (posts_url) format.js render: nothing => true end

Ora, quando cancelliamo un post, questo si attenuerà gradualmente.


Conclusione

Beh, il gioco è fatto. Ora sai come effettuare chiamate AJAX usando Rails 3 UJS. Sebbene gli esempi illustrati fossero semplici, è possibile utilizzare le stesse tecniche per aggiungere tutti i tipi di interattività al progetto. Spero che tu sia d'accordo sul fatto che si tratta di un grande miglioramento rispetto alle versioni precedenti e che lo proverai nel tuo prossimo progetto Rails.

Quali tecniche utilizzate quando si implementa AJAX in Rails?