Questa guida riguarda l'installazione e l'esecuzione di Ruby on Rails.

Dopo averlo letto, saprai:

• Come installare Rails, creare una nuova applicazione Rails e connettere la tua applicazione a un database.
• La struttura generale di un'applicazione Rails.
• Principi di base di MVC (Model, View Controller - "Model-View-Controller") e progettazione basata su RESTful.
• Come generare rapidamente il codice dell'applicazione Rails iniziale.

Presupposti in questa guida

Questa guida è per i principianti che desiderano avviare un'applicazione Rails da zero. Non presuppone che tu abbia già lavorato con Rails.

Rails è un framework di sviluppo web scritto nel linguaggio di programmazione Ruby. Se non hai esperienza con Ruby, potresti trovare difficile iniziare subito ad imparare Rails. Esistono diverse buone risorse in lingua inglese dedicate all'apprendimento di Ruby, ad esempio:

Si noti che alcune delle risorse, sebbene ancora ottime, coprono ancora versioni precedenti di Ruby come 1.6 e 1.8 in particolare, e non includono parte della sintassi che vedrai nello sviluppo quotidiano di Rails.

Cos'è Rails?

Rails è un framework di sviluppo web scritto nel linguaggio di programmazione Ruby. È progettato per semplificare la programmazione di applicazioni Web formulando una serie di ipotesi su ciò di cui ogni sviluppatore ha bisogno per creare un nuovo progetto. Ti consente di scrivere meno codice durante la programmazione rispetto ad altri linguaggi e framework. Gli sviluppatori professionisti su Rails notano anche che rende più divertente lo sviluppo di applicazioni web =)

Rails è un software magistrale. Parte dal presupposto che esista un modo "migliore" per fare qualcosa ed è progettato per incoraggiare quel modo - e in alcuni casi persino scoraggiare le alternative. Se studi "The Rails Way", potresti scoprire un aumento significativo della produttività in te stesso. Se persisti e porti vecchie abitudini da altri linguaggi nello sviluppo di Rails e provi a utilizzare modelli appresi altrove, la tua esperienza di sviluppo sarà tutt'altro che felice.

La filosofia Rails comprende due importanti principi guida:

• Non ripeterti: DRY è un principio di ingegneria del software che afferma che "Ogni pezzo di informazione dovrebbe avere una rappresentazione unica, non ridondante e autorevole nel sistema". Non scrivere le stesse informazioni più e più volte, il codice sarà più facile da mantenere, più estensibile e meno difettoso.
• Convenzione sulla configurazione: Rails ha opinioni sul modo migliore per fare molte cose in un'applicazione web e utilizza queste convenzioni per impostazione predefinita invece di costringerti a mettere a punto più file di configurazione.

Creazione di un nuovo progetto Rails

Il modo migliore per utilizzare questa guida è esaminarla passo dopo passo. Tutti i passaggi sono essenziali per l'esecuzione dell'applicazione di esempio e non sono richiesti codice o passaggi aggiuntivi.

Seguendo questo tutorial, creerai un progetto Rails chiamato blog , un web blog molto semplice. Prima di iniziare a creare l'applicazione, dobbiamo assicurarci che Rails stesso sia installato.

Gli esempi seguenti usano $ per denotare una riga di input del terminale in stile UNIX sistemi operativi ah, anche se potrebbe essere configurato diversamente. Se si utilizza Windows, la riga sarà simile a c:\source_code>

3.1. Installazione di binari

Prima di installare Rails, devi assicurarti di avere i prerequisiti richiesti installati sul tuo sistema. Questi includono Ruby e SQLite3.

Apri app per riga di comando. Su macOS apri Terminal.app, su Windows seleziona "Esegui" dal menu Start e digita "cmd.exe". Tutti i comandi che iniziano con il simbolo del dollaro $ devono essere eseguiti sulla riga di comando. Assicurati di avere la versione corrente di Ruby installata:

$ rubino -v rubino 2.5.0

Rails richiede l'installazione di Ruby versione 2.5.0 o successiva. Se il numero di versione è inferiore a questo, dovrai installare una nuova copia di Ruby.

Per installare rapidamente Ruby e Ruby on Rails sul tuo sistema, Utenti Windows può usare Rails Installer . Ulteriori metodi di installazione per la maggior parte dei sistemi operativi possono essere visualizzati su ruby-lang.org.

Se utilizzi Windows, dovrai installare il Ruby Installer Development Kit .

Sarà inoltre necessario installare il database SQLite3.

Molti popolari sistemi operativi simili a UNIX vengono forniti con una versione accettabile di SQLite3. Su Windows, se hai installato Rails utilizzando Rails Installer, hai già installato SQLite. Altri utenti possono fare riferimento alle istruzioni di installazione sul sito SQLite3. Verifica che sia installato correttamente e nel tuo PERCORSO:

$ sqlite3 --versione

Il programma dovrebbe riportare la sua versione.

Per installare Rails, usa il comando gem install fornito da RubyGems:

$ gemma installa binari

Per verificare che tutto sia installato correttamente, è necessario eseguire le seguenti operazioni:

$ rails --versione

Se viene visualizzato qualcosa come "Rails 6.0.0", puoi continuare.

3.2. Creazione di un'applicazione blog

Rails viene fornito con una serie di script, chiamati generatori, progettati per semplificare la vita di uno sviluppatore creando tutto ciò di cui ha bisogno per iniziare una particolare attività. Uno di questi è il nuovo generatore di applicazioni, che fornisce le fondamenta di un'applicazione Rails in modo da non doverla scrivere da soli.

Per utilizzare questo generatore, apri un terminale, vai a una cartella in cui hai il permesso di creare file e scrivi:

$ rotaie nuovo blog

Questo creerà un'app Rails chiamata Blog nella directory del blog e installerà le gemme le cui dipendenze sono menzionate nel Gemfile quando si utilizza bundle install .

A utilizzando Windows Sottosistema per Linux, ci sono alcune restrizioni sui messaggi sistema di file per disabilitare le gemme Spring e Listen, che possono essere eseguite eseguendo Rails new blog --skip-spring --skip-listen .

Puoi vedere tutte le possibili opzioni della riga di comando accettate dall'application builder di Rails eseguendo rails new -h .

Dopo aver creato l'app blog, vai alla sua cartella:

La directory del blog contiene diversi file e cartelle generati automaticamente che definiscono la struttura dell'applicazione Rails. La maggior parte del lavoro in questo tutorial si svolgerà nella cartella dell'app, ma per ora, esaminiamo le funzioni di ciascuna cartella creata da Rails nella nuova applicazione predefinita:

Cartella di file	Scopo
applicazione/	Contiene i controller, i modelli, le viste, gli helper, i mailer, i canali, i processi e le risorse dell'applicazione. Esamineremo questa cartella in modo più dettagliato in seguito.
bidone/	Contiene gli script Rails che avviano la tua applicazione e la directory può contenere anche altri script che utilizzi per configurare, aggiornare, distribuire o eseguire.
configurazione/	Configurazioni di percorso, database dell'applicazione, ecc. Questo è trattato più dettagliatamente in Configurazione delle applicazioni Rails.
config.ru	Configurazione del rack per i server basati su rack utilizzati per eseguire l'applicazione. Per ulteriori informazioni su Rack, vedere il sito Web di Rack.
dB/	Contiene lo schema corrente del database e le migrazioni del database.
gemfile Gemfile.lock	Questi file ti consentono di specificare di quali dipendenze gem la tua applicazione Rails ha bisogno. Questi file sono usati dalla gemma Bundler. Per ulteriori informazioni su Bundler, vedere il sito di Bundler.
lib/	Moduli esterni per la tua applicazione.
tronco d'albero/	File di registro dell'applicazione.
pacchetto.json	Questo file ti consente di specificare quali dipendenze npm sono richieste per la tua applicazione Rails. Questo file è utilizzato da Yarn. Per ulteriori informazioni su Yarn, vedere il sito web di Yarn.
pubblico/	L'unica cartella accessibile dall'esterno così com'è. Contiene file statici e risorse compilate.
Rastrello	Questo file trova e carica le attività che possono essere eseguite sulla riga di comando. L'attività definita è disponibile in tutti i componenti Rails. Invece di modificare il Rakefile , puoi aggiungere le tue attività aggiungendo file alla directory lib/tasks dell'applicazione.
LEGGIMI.md	Questo è un manuale introduttivo per la tua applicazione. Dovrebbe essere modificato per dire agli altri cosa fa la tua app, come configurarla e così via.
magazzinaggio/	File di archiviazione attivi per il servizio disco. Questo è trattato nella guida Panoramica dello storage attivo.
test/	Unit test, infissi e altri apparecchi di prova. Questo è trattato nella guida Testing Rails Applications.
tmp/	File temporanei (come file cache e pid)
venditore/	Posto per codice di terze parti. In una tipica applicazione Rails, include gemme esterne.
.gitignore	Questo file dice a git quali file (espliciti o jolly) deve ignorare. Vedere GitHub - Ignorare i file per ulteriori informazioni sull'ignorare i file.
.ruby-versione	Questo file contiene la versione predefinita di Ruby.

Ciao Rail!

Per prima cosa, visualizziamo del testo sullo schermo. Ciò richiede un server in esecuzione per la tua applicazione Rails.

4.1. Avvio del server web

In effetti, hai già un'applicazione Rails funzionale. Per essere sicuri, devi eseguire un server web sulla tua macchina. Questo può essere fatto eseguendo il seguente comando dalla directory del blog:

Se stai usando Windows, devi passare gli script dalla cartella bin direttamente all'interprete Ruby, cioè ruby ​​bin\rails server .

La compressione delle risorse JavaScript richiede un ambiente di runtime JavaScript sul sistema e la sua assenza comporterà un errore execjs durante la compressione delle risorse. In genere, macOS e Windows vengono forniti con un runtime JavaScript installato. therubyrhino è il runtime consigliato per gli utenti JRuby e viene aggiunto al Gemfile se l'applicazione è generata per JRuby. Puoi imparare tutto sui runtime supportati in ExecJS

Questo avvierà Puma, il web server distribuito con Rails per impostazione predefinita. Per vedere l'applicazione in azione, apri una finestra del browser e vai a http://localhost:3000 . Dovresti vedere la pagina informativa predefinita di Rails:

Per arrestare il server Web, premere Ctrl+C nel terminale in cui è in esecuzione. Per verificare che il server sia stato arrestato, dovresti vedere di nuovo il cursore della riga di comando. Per la maggior parte dei sistemi simili a UNIX, incluso macOS, questo sarà il simbolo del dollaro $ . In modalità di sviluppo, Rails generalmente non richiede di arrestare il server; tutte le modifiche apportate ai file vengono rilevate automaticamente dal server.

La pagina "Welcome Aboard" è come un test per una nuova applicazione Rails: mostra che i tuoi programmi sono impostati correttamente per visualizzare la pagina.

4.2. Salutami, Rails

Affinché Rails dica "Ciao", devi creare almeno controllore E visualizzazione(prestazione).

Lo scopo di un controller è ricevere richieste specifiche a un'applicazione. Instradamento decide quale controllore riceverà quali richieste. Spesso c'è più di un percorso per ciascun controller e diversi percorsi possono essere gestiti in modo diverso. giochi d'azione. Lo scopo di ogni azione è raccogliere informazioni per fornirle alla vista.

Lo scopo di una vista è visualizzare queste informazioni in un formato leggibile dall'uomo. Una distinzione importante da fare è che il luogo in cui vengono raccolte le informazioni è controllore, non una vista. La vista dovrebbe visualizzare solo queste informazioni. Per impostazione predefinita, i modelli di visualizzazione sono scritti in un linguaggio chiamato eRuby (Embedded Ruby), che viene convertito dal ciclo di richiesta in Rails prima di essere inviato all'utente.

Per creare un nuovo controller, è necessario eseguire il generatore "controller" e dirgli che si desidera un controller denominato "Welcome" con un'azione denominata "index", in questo modo:

$ rails generano il controller Indice di benvenuto

Rails creerà alcuni file e un percorso.

Crea app/controllers/welcome_controller.rb route ottieni "welcome/index" invoca erb crea app/views/welcome crea app/views/welcome/index.html.erb invoca test_unit crea test/controllers/welcome_controller_test.rb invoca helper crea app/ helpers/welcome_helper.rb richiama test_unit richiama asset richiama scss crea app/assets/stylesheets/welcome.scss

I più importanti di questi sono, ovviamente, il controller, che si trova in app/controllers/welcome_controller.rb , e la vista, che si trova in app/views/welcome/index.html.erb .

Apri il file app/views/welcome/index.html.erb in un editor di testo. Elimina tutto il codice esistente nel file e sostituiscilo con la seguente riga di codice:

Se invii nuovamente il modulo, vedrai qualcosa di simile al seguente:

"Primo articolo!", "text"=>"Questo è il mio primo articolo.") consentito: false>

Questa azione ora mostra le opzioni per l'articolo proveniente dal modulo. Tuttavia, è ancora inutile. Sì, vedi i parametri, ma in realtà non fai nulla con loro.

5.4. Creazione del modello articolo

I modelli in Rails usano il nome singolare e la tabella corrispondente nel database usa il nome plurale. Rails fornisce un generatore di modelli che la maggior parte degli sviluppatori di Rails utilizza per creare nuovi modelli. Per creare un nuovo modello, esegui questo comando nel tuo terminale:

$ rails genera modello Article title:string text:text

Con questo comando diciamo a Rails che vogliamo un modello Article con l'attributo titolo tipo di stringa e attributo testo tipo di testo. Questi attributi vengono aggiunti automaticamente alla tabella articoli e associati al modello Articolo.

Rails creerà una serie di file in risposta. Al momento siamo interessati solo a app/models/article.rb e db/migrate/20140120191729_create_articles.rb (il tuo nome potrebbe essere leggermente diverso). Quest'ultimo è responsabile della creazione della struttura del database, motivo per cui lo esamineremo ulteriormente.

Active Record è abbastanza intelligente da associare automaticamente i nomi delle colonne agli attributi del modello, il che significa che non devi dichiarare gli attributi all'interno dei modelli Rails, Active Record lo fa automaticamente.

5.5. Esecuzione della migrazione

Come hai visto, rails genera model ha creato il file migrazioni di database nella directory db/migrate. Le migrazioni sono una classe Ruby progettata per semplificare la creazione e la modifica delle tabelle del database. Rails utilizza i comandi rake per eseguire le migrazioni ed è possibile annullare una migrazione dopo che è stata applicata al database. Il nome del file di migrazione include un timestamp per assicurarsi che vengano eseguiti nell'ordine in cui sono stati creati.

Se guardi nel file db/migrate/YYYYMMDDHHMMSS_create_articles.rb (ricorda, il tuo file ha un nome leggermente diverso), ecco cosa troverai:

Classe CreateArticles< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Questa migrazione crea un metodo di modifica che viene chiamato quando viene eseguita questa migrazione. Anche l'azione definita in questa migrazione è reversibile, il che significa che Rails sa come annullare le modifiche apportate da questa migrazione nel caso in cui tu decida di annullarle in seguito. Quando esegui questa migrazione, creerà una tabella di articoli con una colonna di stringa e una colonna di testo. Creerà anche due campi timestamp per tenere traccia di quando l'articolo è stato creato e aggiornato.

Ora dobbiamo usare il comando rails per eseguire la migrazione:

$ rails db:migrate

Rails eseguirà questo comando di migrazione e riporterà di aver creato la tabella Articoli.

CreateArticles: migrazione ============================================== == = -- create_table(:articles) -> 0.0019s == CreateArticles: migrato (0.0020s) =========================== == ============

Poiché stai eseguendo l'ambiente di sviluppo per impostazione predefinita, questo comando verrà applicato al database definito nella sezione di sviluppo del tuo file config/database.yml. Se vuoi eseguire le migrazioni in un altro ambiente, come la produzione, devi passarle esplicitamente quando chiami il comando: rails db:migrate RAILS_ENV=production .

5.6. Salvataggio dei dati nel controller

Tornando ad ArticlesController , dobbiamo modificare l'azione create per utilizzare il nuovo modello Article per salvare i dati nel database. Apri app/controllers/articles_controller.rb e modifica l'azione di creazione come segue:

Def create @article = Article.new(params[:article]) @article.save redirect_to @article end

Ecco cosa succede qui: ogni modello Rails può essere inizializzato con gli attributi appropriati, che verranno automaticamente associati alle colonne del database appropriate. Nella prima riga, facciamo proprio questo (ricorda che params[:article] contiene gli attributi che ci interessano). Quindi @article.save è responsabile del salvataggio del modello nel database. Infine, reindirizziamo l'utente all'azione show, che definiremo in seguito.

Forse ti starai chiedendo perché la A in Article.new è maiuscola quando tutti gli altri collegamenti agli articoli in questa guida usano lettere minuscole. In questo contesto, ci riferiamo a una classe denominata Article , definita in app/models/article.rb . I nomi delle classi in Ruby devono iniziare con una lettera maiuscola.

Ora che ci sono convalide, chiamare @article.save su un articolo non valido restituirà false . Se apri di nuovo app/controllers/articles_controller.rb, vedrai che non controlliamo il risultato della chiamata a @article.save nell'azione di creazione. Se @article.save fallisce in questa situazione, dobbiamo mostrare nuovamente il modulo all'utente. Per fare ciò, sostituisci il nuovo e crea azioni in app/controllers/articles_controller.rb con queste:

Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end private def article_params params.require(:article).permit(:title , :testo) fine

Ora la nuova azione crea una nuova variabile di istanza chiamata @article , e vedrai perché in un paio di paragrafi.

Nota che nell'azione create abbiamo usato render invece di redirect_to quando save restituisce false . Il metodo render viene utilizzato per restituire l'oggetto @article al nuovo modello quando viene visualizzato. Questo rendering viene eseguito all'interno della stessa richiesta dell'invio del modulo, mentre redirect_to indica al browser di effettuare un'altra richiesta.

5.11. Aggiornamenti dell'articolo

Abbiamo rivelato la parte "CR" di CRUD. Ora concentriamoci sulla parte "U", aggiornando gli articoli.

Il primo passaggio consiste nell'aggiungere un'azione di modifica a ArticlesController , in genere tra le azioni new e create, come mostrato.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end FINE

La vista conterrà un modulo simile a quello che abbiamo utilizzato durante la creazione di nuovi articoli. Crea un file chiamato app/views/articles/edit.html.erb e aggiungi quanto segue:

Modifica articolo

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

In questo momento, stiamo indirizzando il modulo a un'azione di aggiornamento, che non è ancora stata definita, ma lo faremo presto.

Il passaggio dell'oggetto articolo al metodo form_with imposterà automaticamente l'URL per l'invio del modulo dell'articolo modificato. Questa opzione dice a Rails che vogliamo che questo modulo venga inviato con PATCH , un metodo HTTP che dovrebbe essere usato per aggiornamenti risorse secondo il protocollo REST.

Successivamente, devi creare un'azione di aggiornamento in app/controllers/articles_controller.rb . Aggiungilo tra l'azione create e il metodo privato:

Def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end private def article_params params.require(:article).permit(:title, :text) end

Il nuovo metodo, update , viene utilizzato quando si desidera aggiornare una voce già esistente e richiede un hash contenente gli attributi che si desidera aggiornare. Come prima, se si verifica un errore durante l'aggiornamento dell'articolo, vogliamo mostrare nuovamente il modulo all'utente.

Abbiamo riutilizzato il metodo article_params definito in precedenza per l'azione create.

Non è necessario passare tutti gli attributi a update . Ad esempio, se fosse stato chiamato @article.update(title: "A new title"), Rails aggiornerebbe solo l'attributo title, lasciando inalterati tutti gli altri attributi.

<% @articles.each do |article| %> <% end %>

Titolo	Testo
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

E aggiungi anche app/views/articles/show.html.erb al modello in modo che il link "Modifica" sia anche nella pagina dell'articolo. Aggiungi quanto segue alla fine del modello:

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Ed ecco come appare la nostra applicazione ora:

5.12. Uso dei parziali per ripulire la ripetizione nelle viste

La nostra pagina di modifica è molto simile alla nuova pagina, infatti usano lo stesso codice per visualizzare il form. Rimuoviamo questa duplicazione utilizzando una visualizzazione parziale. Per convenzione, i file parziali iniziano con un carattere di sottolineatura.

Crea un nuovo file app/views/articles/_form.html.erb con il seguente contenuto:

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

Aggiorniamo ora la vista app/views/articles/new.html.erb per utilizzare questo nuovo partial, riscrivendolo completamente:

nuovo articolo

<%= render "form" %> <%= link_to "Back", articles_path %>

E lo stesso per la vista app/views/articles/edit.html.erb:

Modifica articolo

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Cancellare articoli

Siamo ora pronti per coprire la parte "D" di CRUD, cancellando da un database. Seguendo la convenzione REST, il percorso per rimuovere gli articoli nell'output dei percorsi rails è il seguente:

DELETE /articles/:id(.:format) articoli#destroy

Il metodo di instradamento delete deve essere utilizzato per instradamenti che distruggono risorse. Se lasciato come normale percorso get, sarebbe possibile generare i seguenti URL dannosi:

guarda questo gatto!

Usiamo il metodo delete per distruggere le risorse e questo percorso è associato all'azione destroy in app/controllers/articles_controller.rb , che non esiste ancora. Il metodo destroy è in genere l'ultima azione CRUD nel controller e, come tutte le azioni CRUD pubbliche, deve essere posizionato prima di qualsiasi metodo privato o protetto. Aggiungiamolo:

Def destroy @article = Article.find(params[:id]) @article.destroy redirect_to article_path end

L'intero ArticlesController in app/controllers/articles_controller.rb dovrebbe ora apparire così:

Classe ArticlesController< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

È possibile chiamare destroy sugli oggetti Active Record quando si desidera rimuoverli dal database. Tieni presente che non è necessario aggiungere una vista per questa azione poiché stiamo reindirizzando all'azione index.

Elenco articoli

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Titolo	Testo
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Qui usiamo link_to in modo diverso. Passiamo la route denominata come secondo argomento e le opzioni come altro argomento. Le opzioni method: :delete e data: (conferma: "Are you sure?") sono usate come attributi html5, quindi quando si fa clic su un link, Rails prima mostrerà all'utente una finestra di dialogo di conferma e poi invierà il link usando il metodo delete . Questo viene fatto utilizzando il file JavaScript rails-ujs, che viene automaticamente incluso nel layout dell'applicazione (app/views/layouts/application.html.erb) quando l'applicazione viene generata. Senza questo file, la finestra di dialogo di conferma non verrà visualizzata.

Congratulazioni, ora puoi creare, visualizzare tutti e singolarmente, aggiornare ed eliminare gli articoli.

Aggiunta di un secondo modello

È ora di aggiungere il secondo modello all'applicazione. Il secondo modello gestirà i commenti sugli articoli.

6.1. Generazione di un modello

Intendiamo utilizzare lo stesso generatore utilizzato in precedenza durante la creazione del modello Article. Questa volta creeremo un modello di commento contenente un collegamento all'articolo. Esegui il seguente comando in un terminale:

$ rails genera modello Commento commentatore:stringa corpo:testo articolo:riferimenti

Questo comando genera quattro file:

Innanzitutto, diamo un'occhiata a app/models/comment.rb:

commento di classe< ApplicationRecord belongs_to:article end

Questo è molto simile al modello dell'articolo che abbiamo visto in precedenza. La differenza sta nella riga appartiene_to:article , che imposta connessione registro attivo. Imparerai a conoscere le connessioni nella prossima sezione della guida.

La parola chiave (:references) usata nel comando bash è un tipo di dati speciale per i modelli. Crea una nuova colonna nel database con il nome del modello sottoposto a rendering con _id aggiunto, che può contenere valori numerici. Per capire meglio, analizzare il file db/schema.rb al termine della migrazione.

Oltre al modello, Rails ha anche effettuato una migrazione per creare la corrispondente tabella del database:

Classe CreateComments< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, null: false, foreign_key: true t.timestamps end end end

La riga t.references crea una colonna numerica denominata article_id , un indice su di essa e un vincolo di chiave esterna che punta alla colonna id della tabella articoli. Successivamente, eseguiamo la migrazione:

$ rails db:migrate

Rails è abbastanza intelligente da eseguire solo quelle migrazioni che non sono state ancora eseguite sul database corrente, nel nostro caso vedrai:

CreateComments: migrazione =============================================== = = -- create_table(:comments) -> 0.0115s == CreateComments: migrato (0.0119s) =========================== == ==========

6.2. Collegamento di modelli

I collegamenti ai record attivi consentono di dichiarare facilmente le relazioni tra due modelli. Nel caso di commenti e articoli, puoi descrivere la relazione come segue:

• Ogni commento appartiene a un articolo.
• Un articolo può avere molti commenti.

Infatti, è molto simile alla sintassi che Rails usa per dichiarare questa relazione. Hai già visto la riga di codice nel modello Comment (app/models/comment.rb) che fa appartenere ogni commento a un articolo:

commento di classe< ApplicationRecord belongs_to:article end

Devi modificare app/models/article.rb per aggiungere l'altro lato del link:

articolo di classe< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Questi due annunci vengono automaticamente resi disponibili un gran numero di opportunità. Ad esempio, se hai una variabile di istanza @article contenente un articolo, puoi ottenere tutti i commenti che appartengono a quell'articolo in un array chiamando @article.comments .

6.3. Aggiunta di un percorso per i commenti

Come con il controller di benvenuto, dobbiamo aggiungere un percorso in modo che Rails sappia a quale indirizzo vogliamo andare per vedere i commenti. Apri di nuovo il file config/routes.rb e modificalo come segue:

Risorse: gli articoli fanno le risorse: i commenti finiscono

Questo creerà commenti come risorsa nidificata negli articoli. Questo è l'altro lato della cattura della relazione gerarchica che esiste tra articoli e commenti.

6.4. Genera un controllore

Con il modello in posizione, rivolgiamo la nostra attenzione alla creazione del controller appropriato. Ancora una volta useremo lo stesso generatore che abbiamo usato prima:

$ le rotaie generano il controller

Verranno creati quattro file e una directory vuota:

Come con qualsiasi altro blog, i nostri lettori creeranno i loro commenti subito dopo aver letto l'articolo e, dopo aver aggiunto un commento, verranno reindirizzati alla pagina di visualizzazione dell'articolo e vedranno che il loro commento è già stato riflesso. A questo proposito, il nostro CommentsController funge da mezzo per creare commenti e rimuovere lo spam, se presente.

Innanzitutto, estenderemo il modello Article show (app/views/articles/show.html.erb) per consentirci di aggiungere un nuovo commento:

Titolo: <%= @article.title %>

testo: <%= @article.text %>

Aggiungi un commento:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Questo aggiungerà un modulo alla pagina di visualizzazione dell'articolo che crea un nuovo commento quando viene chiamata l'azione di creazione su CommentsController. Qui la chiamata form_with utilizza un array, che creerà un percorso nidificato come /articles/1/comments .

Scriviamo create in app/controllers/comments_controller.rb:

Classe CommentiController< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

Questo è un po' più complicato di quello che hai visto nell'articolo controller. Questo è un effetto collaterale dell'allegato che hai impostato. Ogni richiesta di commento tiene traccia dell'articolo a cui è allegato il commento, quindi per prima cosa risolviamo il recupero dell'articolo chiamando find sul modello Article.

Inoltre, il codice sfrutta alcuni dei metodi disponibili per le relazioni. Usiamo il metodo create su @article.comments per creare e salvare un commento. Questo collega automaticamente il commento in modo che appartenga a un articolo specifico.

Dopo aver creato un nuovo commento, riportiamo l'utente all'articolo originale utilizzando l'helper article_path(@article). Come abbiamo visto, chiama l'azione show su ArticlesController , che a sua volta esegue il rendering del modello show.html.erb. Qui è dove vogliamo visualizzare i commenti, quindi aggiungiamo quanto segue a app/views/articles/show.html.erb .

Titolo: <%= @article.title %>

testo: <%= @article.text %>

Commenti

<% @article.comments.each do |comment| %>

commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

<% end %>

Aggiungi un commento:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Ora puoi aggiungere articoli e commenti al tuo blog e visualizzarli nei posti giusti.

Rifattorizzazione

Ora che abbiamo articoli e commenti funzionanti, diamo un'occhiata al template app/views/articles/show.html.erb. È diventato lungo e scomodo. Usiamo i partial per scaricarlo.

7.1. Rendering di raccolte di parziali

Per prima cosa, facciamo un commento parziale che mostri tutti i commenti per l'articolo. Crea un file app/views/comments/_comment.html.erb e inserisci quanto segue:

commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

Puoi quindi modificare app/views/articles/show.html.erb in questo modo:

Titolo: <%= @article.title %>

testo: <%= @article.text %>

Commenti

<%= render @article.comments %>

Aggiungi un commento:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Questo renderà parziale app/views/comments/_comment.html.erb una volta per ogni commento nella raccolta @article.comments. Poiché il metodo render esegue un'iterazione sulla raccolta @article.comments, assegna ogni commento a una variabile locale denominata come partial, nel nostro caso comment , che è a nostra disposizione nel partial per il rendering.

7.2. Rendering di una forma in un parziale

Spostiamo anche la nuova sezione dei commenti al nostro parziale. Ancora una volta, crea un file app/views/comments/_form.html.erb contenente:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

Quindi modifica app/views/articles/show.html.erb in questo modo:

Titolo: <%= @article.title %>

testo: <%= @article.text %>

Commenti

<%= render @article.comments %>

Aggiungi un commento:

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Il secondo render definisce semplicemente il template per il partial che vogliamo renderizzare, comments/form . Rails è abbastanza intelligente da sostituire un trattino basso in questa riga e capire che volevi rendere il file _form.html.erb nella directory app/views/comments.

L'oggetto @article è disponibile in qualsiasi parziale visualizzato nella vista perché lo abbiamo definito come variabile di istanza.

Eliminare i commenti

Un'altra caratteristica importante del blog è la possibilità di rimuovere lo spam. Per fare ciò, abbiamo bisogno di inserire un link nella vista e un'azione di distruzione nel CommentsController .

commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

Premendo questo nuovo collegamento"Destroy Comment" attiverà un DELETE /articles/:article_id/comments/:id sul nostro CommentsController che verrà quindi utilizzato per trovare il commento che vogliamo eliminare, quindi aggiungiamo un'azione di distruzione al nostro controller (app/controllers/comments_controller .rb):

Classe CommentiController< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

L'azione di distruzione troverà l'articolo che stiamo visualizzando, troverà il commento nella raccolta @article.comments, quindi lo rimuoverà dal database e ci riporterà alla visualizzazione dell'articolo.

8.1. Eliminazione di oggetti correlati

Se elimini un articolo, devono essere eliminati anche i commenti ad esso associati, altrimenti occuperanno solo spazio nel database. Rails ti consente di utilizzare l'opzione dipendente sul collegamento per raggiungere questo obiettivo. Modifica il modello dell'articolo, app/models/article.rb , come segue:

articolo di classe< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Sicurezza

9.1. Autenticazione di base

Se pubblichi il tuo blog online, chiunque può aggiungere, modificare ed eliminare articoli o eliminare commenti.

Rails fornisce un sistema di autenticazione HTTP di base che funziona bene in questa situazione.

In ArticlesController abbiamo bisogno di un modo per bloccare l'accesso a varie azioni se l'utente non è autenticato. Qui possiamo utilizzare il metodo Rails http_basic_authenticate_with per consentire l'accesso alle azioni richieste se il metodo lo consente.

Per utilizzare il sistema di autenticazione, lo definiremo nella parte superiore del nostro ArticlesController in app/controllers/articles_controller.rb . Nel nostro caso, vogliamo che l'utente sia autenticato per ogni azione ad eccezione di index e show , quindi lo scriveremo così:

Classe ArticlesController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

Vogliamo anche consentire solo agli utenti autenticati di eliminare i commenti, quindi nel CommentsController (app/controllers/comments_controller.rb) scriveremo:

Classe CommentiController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

Ora, se provi a creare un nuovo articolo, incontrerai una richiesta di autenticazione di base HTTP:

Sono disponibili anche altri metodi di autenticazione per le applicazioni Rails. Due popolari componenti aggiuntivi di Rails sono Devise e Authlogic, tra gli altri.

9.2. Altri pensieri sulla sicurezza

La sicurezza, specialmente nelle applicazioni web, è un'area vasta e articolata. La sicurezza della tua applicazione Rails è trattata in modo più dettagliato nella guida Rails Application Security.Il modo più semplice per lavorare con Rails è archiviare tutti i dati esterni in UTF-8. In caso contrario, le librerie Ruby e Rails saranno spesso in grado di convertire i tuoi dati nativi in ​​UTF-8, ma questo non sempre funziona in modo affidabile, quindi è meglio essere sicuri che tutti i dati esterni siano UTF-8.

Se commetti un errore in quest'area, il sintomo più comune è un diamante nero con un punto interrogativo al suo interno che appare nel browser. Un altro sintomo comune sono i caratteri come "ü" che appaiono al posto di "ü". Rails adotta una serie di passaggi interni per mitigare i casi comuni di problemi che possono essere rilevati e risolti automaticamente. Tuttavia, se sono presenti dati esterni che non sono archiviati in UTF-8, ciò può portare a questo tipo di problemi che Rails non è in grado di rilevare e risolvere automaticamente.

Le due origini dati più comuni che non sono in UTF-8 sono:

• Tuo editor di testo: la maggior parte degli editor di testo (come TextMate) salva i file come UTF-8 per impostazione predefinita. Se il tuo editor di testo non esegue questa operazione, è possibile che i caratteri speciali digitati nei tuoi modelli (come é) appaiano come un rombo punto interrogativo nel browser. Questo vale anche per i tuoi file di traduzione i18N. La maggior parte degli editor che non utilizzano UTF-8 per impostazione predefinita (come alcune versioni di Dreamweaver) offrono un modo per modificare le impostazioni predefinite in UTF-8. Fare così.
• Il tuo database: Rails convertirà per impostazione predefinita i dati dal tuo database in UTF-8 sul confine. Tuttavia, se il database non utilizza UTF-8 internamente, potrebbe non essere in grado di memorizzare tutti i caratteri digitati dall'utente. Ad esempio, se il tuo database utilizza internamente Latin-1 e il tuo utente inserisce caratteri russi, ebraici o giapponesi, i dati andranno persi non appena entrano nel database. Se possibile, usa UTF-8 come memoria interna nel tuo database.

L'autore è stato spinto a scrivere questo testo studiando una serie di materiali trovati sul Web globale, che potrebbero essere contrassegnati dalla stessa intestazione / tag: Come ho imparato Ruby(o Ruby on Rails, PHP, JS, C++, ecc.) per tre giorni.

Bene, o simili. L'autore, a sua volta, ha subito ricordato (associazioni incontrollabili) una serie di aneddoti, uniti ancora una volta da un tema comune, che consiste nel valutare azioni che possono essere compiute scioccamente ... la lingua russa è potente e incredibilmente aforistica, ma, purtroppo, non sembra possibile citare qui questi capolavori; di conseguenza, non resta altro che offrire all'attenzione del lettore una versione del doki scritta da lui stesso dal ciclo Come divertirsi e imparare in tempi relativamente brevi a lavorare in Ruby on Rails.

Un esempio funzionante del codice descritto nell'articolo, tra gli altri esempi di Rails, può sempre essere trovato nel blog di test dell'autore su herokuapp.com , benvenuto.

La tecnica è semplice, e qui l'autore non pretende affatto di essere un pioniere: è necessario che sia interessante, ei risultati non tarderanno ad arrivare. Non fa male cercare di giocare sulle proprie debolezze, a volte anche la vanità può giovare alla causa; i risultati dello sviluppo dovrebbero essere tali da poter essere presentati con orgoglio a lettori, amici e colleghi sul Web, distribuiti da qualche parte su Eroku O Amazzonia, anche - in modo che tu possa tornare da loro ancora e ancora, ricostruendo e migliorando, forum e StackOwerflow per aiutare tutti noi. Quindi dico, perché non scrivere, per cominciare, il tuo blog su Rubino sulle rotaie?

Suggerisco di partire dall'ottimo dock Getting Started with Rails o dal suo adattamento in lingua russa di Rails per principianti, anche Costruisci un blog con Ruby on Rails, anche per aiutare i materiali di questo blog, i cui link si trovano facilmente nella barra laterale di sinistra . E poi - tutto, poi magia, all'inizio tutto è dipinto come un orologio, apri la console - e vai avanti ... l'autore ritiene suo dovere fare solo alcune spiegazioni e consigli tecnici pensati per rendere più facile per l'esperto cercare e ottenere il Lato Chiaro della Forza, e non più Togo. Questa è solo la tua battaglia, vai avanti e torna con una vittoria.

COSÌ. Il passo dopo passo del primo manuale è ben calibrato e non ti causerà, spero, nessun fastidio; tutto ciò che ti viene richiesto è essere attento, ripetendo meticolosamente i passaggi dettagliati commentati ... e in un'ora il tuo primo blog è pronto, puoi fare una pausa e passare al secondo, un po' più interessante. Ed è qui che, a quanto pare, avrai bisogno di alcune parole di commiato, a cui ora procederemo.

Cominciamo con l'affermazione che questi metodi sono abbastanza capaci (in alternativa) di assomigliare ai seguenti, ma in nessun modo come l'originale:

app/controllers/posts_controller.rb

# L'azione di aggiornamento aggiorna il post con le nuove informazioni def update if @post.update_attributes(post_params) flash[:notice] = "Post aggiornato con successo!" redirect_to posts_path else flash[:alert] = "Errore durante l'aggiornamento del post!" render:edit end end # L'azione show visualizza il singolo post dopo aver recuperato l'id def show end # L'azione destroy rimuove definitivamente il post dal database def destroy @post = Post.find(params[:id]) if @post .destroy flash[:notice] = "Post cancellato con successo!" redirect_to posts_path else flash[:alert] = "Errore durante l'aggiornamento del post!" fine fine

Eppure, prova in questo modo e in quello, perché no. Andiamo oltre.

Il secondo blog, anche se più complesso (aggiunto l'editor dell'articolo CK Editor E dispositivo, uno strumento di autenticazione flessibile per le applicazioni ferroviarie), per qualche motivo non consente commenti nell'originale. Dovrai sopperire tu stesso a questa mancanza: procedi per analogia con la descrizione della creazione del primo blog, saranno necessarie solo piccolissime modifiche: in poche parole, invece di articolo E articoli il primo blog che avrai inviare E post nel secondo blog, questa è tutta, infatti, la differenza. Stai attento e tutto funzionerà.

Recaptcha dovrai anche collegarti tu stesso ai commenti: sì, sì, questo non è Joomla per te, abituati. Tuttavia, non sono richiesti sforzi titanici, il processo di connessione Recaptcha descritto in dettaglio nell'articolo Includere Recaptcha nell'applicazione Rails. Inoltre, non è superfluo adeguarsi dispositivo in modo tale che il blog funzioni (almeno all'inizio!) in modalità utente singolo, consentendo a molti dei suoi lettori la modalità SOLA LETTURA, in altre parole vieteremo in partenza la registrazione di nuovi utenti. Ci sono molte ricette diverse sul Web su come farlo, ma, secondo me, l'hacking più competente di questo tipo è nel Wiki devise, in un materiale chiamato How To: Set up devise as a single user system . Vale a dire, creiamo un nuovo controller:

app/controller/registrations_controller.rb:

Class RegistrationsController< Devise::RegistrationsController before_action:one_admin_registered?, only: [:new, :create] protected def one_admin_registered? if ((Admin.count == 1) & (admin_signed_in?)) redirect_to root_path elsif Admin.count == 1 redirect_to new_admin_session_path end end end

quindi lo sovrascriviamo in route.rb e il gioco è fatto:

#devise_for:admins devise_for:admins, controllers: (registrazioni: "registrazioni")

CKEDITOR.editorConfig = function(config) ( // config.enterMode = 2; //disabilitato

Completamente config.enterMode = CKEDITOR.ENTER_BR // premendo l'input KEY ENTER
config.shiftEnterMode = CKEDITOR.ENTER_P; //premendo l'ingresso SHIFT + ENTER KEYS

Config.autoParagraph = falso; // arresta l'inserimento automatico di

a fuoco);

Forse, tanto per cominciare, è davvero tutto... accidenti, quasi dimenticavo la cosa più importante. Se hai intenzione di distribuire il tuo nuovo blog su Eroku- aggiungi queste tre righe a

config/application.rb

Config.assets.precompile += Ckeditor.assets config.assets.precompile += %w(ckeditor/*) config.autoload_paths += %W(#(config.root)/app/models/ckeditor)

Altrimenti CK Editor si rifiuta di lavorare per te in un posto nuovo.

Ruby è un linguaggio di programmazione potente e popolare. Oltre alla sua popolarità, su di esso si basa un noto framework, che consente di creare siti Web interessanti e dinamici di vari argomenti. Se guardi la classifica TIOBE, la lingua è tra le venti lingue più popolari al mondo.

La lingua è apparsa nel 1995 ed è considerata una lingua giovane rispetto a C o C ++, apparse rispettivamente nel 1972 e nel 1983. Il linguaggio ha una serie di vantaggi e caratteristiche specifiche che sono implementate esclusivamente in esso, se confrontiamo altri linguaggi di programmazione popolari.

Piano del corso

Durante il video corso imparerai il linguaggio Ruby senza utilizzare framework aggiuntivi. Ulteriori corsi su rubino puoi trovare su .

Durante il corso impareremo come installare e lavorare con la lingua, impareremo la sintassi Rubino(variabili, loop, istruzioni condizionali), così come cose più complesse: OOP, lavorare con file, eccezioni, metodi e molti altri argomenti.

Installare Ruby su Windows

Per installare Ruby su Windows, usa Ruby Installer, scaricabile dal sito ufficiale a questo link. Scaricamento ultima versione e installalo come un normale programma. Al termine dell'installazione, verrà visualizzata una finestra simile:

In questa finestra, assicurati che la casella di controllo sia selezionata, quindi si aprirà un'altra applicazione per l'installazione rubino nel sistema.

Nella finestra che si apre digitare a turno 1 e premere Invio, dopo aver atteso la fine dell'installazione premere 2 e Invio e al termine eseguire il terzo comando premendo 3 e Invio.

Installare Ruby su un Mac

Su un Mac, Ruby è installato di default, quindi non devi fare altro. Puoi controllare la versione della lingua nel terminale con il seguente comando:

Se la versione è obsoleta, puoi scaricarne una nuova. Per prima cosa devi scaricare il gestore delle versioni di Ruby. Questo viene fatto attraverso il terminale con il comando:

Curl -L https://get.rvm.io | bash -s stabile

Dopo aver installato il gestore, riavviare il terminale. Esegui il seguente comando:

Elenco RVM noto

Dopo il riavvio, puoi installare qualsiasi versione desideri. Nel nostro caso è stata installata la versione 2.4.2:

rvm installa ruby-2.4.2

Alla fine, puoi controllare di nuovo la versione e se è ancora vecchia, imposta semplicemente l'impostazione predefinita sulla nuova versione.

Uno dei primi e più completi tutorial di Rails sul web. Il vantaggio principale è una copertura dettagliata dei problemi più necessari, aggiornamenti regolari e contenuti gratuiti.

È vero, la risorsa è completamente in inglese. Ed è importante capire che questo è costruito sotto forma di un libro: devi capire tu stesso tutti i problemi. Per questo motivo, la durata e la complessità della formazione non possono essere previste.

2. Railcast

Un'altra ben nota risorsa di formazione su Internet. Più di una generazione di sviluppatori di Rails è cresciuta su di esso. Anche in inglese.

Non è costruito come un corso di formazione olistico, ma come una serie di screencast, brevi lezioni su un argomento specifico. Ci sono molte lezioni, puoi trovare quasi tutti gli argomenti.

Sfortunatamente, il progetto ha smesso di essere aggiornato nel 2013.

3. Rotaie per gli zombi

Un'incredibile introduzione ai binari per principianti in un gioco in stile ricerca con un'atmosfera da zombi. È molto popolare tra i principianti assoluti.

È conveniente che non sia necessario installare nulla sul tuo computer. Tutti i puzzle sono risolti nel browser. Passo dopo passo segui il gioco e inizi a capire le basi di Ruby on Rails.

Se non capisci affatto la programmazione, questa è la tua scelta. Non ci sono argomenti complessi nel corso, niente distrae dalle basi. In inglese.

3. Udemy

Ampia raccolta di video corsi. Tra questi ce ne sono molti su rubino e rubino su rotaie. Non ha senso fornire collegamenti specifici: scegli in base ai tuoi gusti in base al prezzo o alla popolarità.

Il formato Udemy prevede corsi piuttosto brevi con un'enfasi sulle lezioni video. Non aspettarti compiti seri o un supporto tempestivo da parte degli insegnanti.

4. Borsa rubino

Un potente breve corso sulle basi dello sviluppo di Rails. Insegnanti esperti, buon programma.

Al corso è auspicabile la presenza personale dello studente e si svolge solo nelle grandi città ucraine.

5. Sviluppo su Ruby on Rails di Evil Martians

Un intensivo di tre giorni da uno dei team Ruby on Rails più esperti in Russia.

Fatto raramente. È costoso (a giudicare dalle recensioni, ne vale la pena). Richiede la presenza personale. Adatto solo a programmatori avanzati, non c'è niente da fare per i principianti lì.

6. Ruby on Rails Online Intensive da Good Programmer

Un nuovo progetto di un team noto su Youtube per i suoi corsi Ruby per principianti.

Il programma intensivo di 3 mesi è progettato per principianti assoluti e promette di renderti un programmatore junior con un portafoglio di nient'altro che 12 applicazioni intelligenti.

Il corso consiste in lezioni video, compiti pratici, supporto dell'insegnante, webinar regolari.

A giudicare da canale Youtube e commenti degli utenti: questi ragazzi sanno cosa stanno facendo e non si annoieranno con loro.

Il vantaggio principale di qualsiasi web designer è quello di essere in grado di capire - e persino organizzare - cosa sta succedendo "dietro le quinte".

Per lo meno, dovresti prendere qualche lezione di programmazione. Non sto parlando di linguaggi front-end come HTML e CSS: probabilmente conosci già molte di queste cose. Sto parlando di cose di back-end.

Se sai come gettare le basi, allora puoi capire meglio come progettare il resto del sito. Il fatto è che imparare a programmare ti renderà un designer più erudito. Inoltre, chi non vorrebbe assumere un designer che sa tutto, dal design allo sviluppo del sito web?

Il trucco è scegliere un punto da cui iniziare. Imparare a programmare può essere un processo difficile, soprattutto se scegli uno dei più linguaggi complessi come C++ o PHP.

Quindi qual è il posto migliore per iniziare? C'è solo una risposta: Ruby on Rails è uno dei migliori linguaggi di programmazione e framework per apprendere le basi del design.

Perché Ruby è la scelta migliore?

Per i principianti, Ruby è uno dei linguaggi più facili da imparare, specialmente se hai un po' di esperienza con HTML o CSS che hanno la maggior parte dei designer.

Uno dei primi programmi che creerai quando inizi a imparare una lingua è il famigerato "Hello World!" che prevede la stampa di quelle parole sullo schermo.

Con linguaggi come C++, possono essere da cinque a sette righe di codice solo per visualizzare quelle due parole. Ma se usi Ruby, ci sarà solo una riga e un comando.

Mette "ciao, mondo!"

È tutto! Questo è tutto ciò di cui hai bisogno per stampare le parole "Ciao mondo!" sullo schermo. Abbastanza facile, vero?

Ruby on Rails è anche un linguaggio molto secco. Essendo uno dei principi dello sviluppo, DRY (secco) significa "Non ripeterti" (Non ripeterti!) - cioè, non programmare di nuovo un elemento quando puoi usarne uno che hai già creato. Questo rende Ruby un linguaggio di programmazione molto leggero e comunemente usato per lo sviluppo, poiché mira a portare a termine un progetto in modo rapido ed efficiente.

Rubino o Rails?

Ruby è un linguaggio di programmazione. Rails è un framework che usa Ruby per portare a termine il lavoro. Il framework Ruby on Rails è una raccolta di codice prefabbricato o pre-scritto che aiuta ad accelerare il processo di creazione di nuovi progetti. Inizialmente, è stato creato per sviluppare lo strumento di gestione del progetto Basecamp. Oltre a Basecamp, ci sono altre app web popolari create con Rails, come 500px, ThemeForest e MyFitnessPal.

Una volta capito come lavorare con il linguaggio Ruby e far funzionare le cose nel framework Ruby On Rails, puoi iniziare a creare applicazioni web.

Ruby - al culmine della popolarità!

Grazie all'esplosione di popolarità dispositivi mobili e la tecnologia sempre in contatto, Ruby è incredibilmente popolare in questo momento. E probabilmente continuerà ad esserlo. L'indice TIOBE classifica Ruby come il 13° linguaggio di programmazione più popolare. In linea con le nuove tendenze, secondo Indeed.com, anche Ruby sta registrando una domanda sorprendentemente elevata.

Indice TIOBE

Ad ogni modo, che tu scelga la domanda o la popolarità, Ruby è piuttosto popolare. Questo lo rende uno di i posti migliori tanto per cominciare, perché una volta che hai imparato la lingua, puoi trovare un lavoro abbastanza velocemente. E questo prima di iniziare a imparare un'altra lingua per espandere le tue abilità.

Ruby ha un forte punto d'appoggio!

Alcuni degli altri linguaggi sono stati più al nostro fianco, è vero, ma anche così, il supporto e la documentazione impallidiscono rispetto a ciò che è disponibile per Ruby. Anche altre lingue mancano di coesione comunitaria attorno a un framework fortemente supportato.

Grazie al framework Ruby On Rails, ci sono già tonnellate di codice preesistente che puoi utilizzare nei tuoi progetti. Ruby Gems, la libreria del framework Ruby, ha oltre 600.000 librerie tra cui scegliere.

Ogni volta che impari qualcosa di nuovo, hai bisogno di molta documentazione e supporto. Ci sono un sacco di posti dove trovare tutorial, tutorial, guide e persino forum di domande e risposte. Se stai riscontrando un problema specifico, una semplice ricerca sul Web probabilmente lo risolverà. È importante.

Una documentazione semplice e un facile accesso al supporto sono essenziali quando stai imparando una nuova lingua, quando stai effettivamente imparando qualcosa di nuovo.

Ruby "consente" un maggiore controllo sul design

Se sei solo un web designer, la creazione di un sito web può essere un processo lungo e complicato. Quando ti siedi per lavorare con un programmatore e discuti del back-end necessario per il tuo sito, spesso devi sacrificare il front-end affinché tutto funzioni correttamente.

In definitiva, questo può portare a un prodotto che sembra completamente diverso dalla tua visione originale. Al programmatore potrebbe non interessare, ma probabilmente sarà problematico per te.

Non incontrerai problemi di questo tipo se ti programmi da solo. Non devi dipendere dagli altri per ottenere un progetto finito e avrai una comprensione molto migliore di ciò che può essere raggiunto in termini di sviluppo. Sicuramente c'è stato un momento o due in cui gli obiettivi del tuo progetto erano troppo alti per un programmatore o un team di sviluppo? Quando impari una lingua come Ruby, puoi goderti la facilità di comprendere i bisogni e le possibilità, d'altra parte.

Essenzialmente, Ruby è progettato per essere utilizzato nelle applicazioni web e nello sviluppo web, quindi è il posto perfetto per aspiranti web designer. Una volta compreso il linguaggio e imparato a utilizzare il framework Ruby on Rails, avrai molto più controllo sui tuoi progetti.

Dove imparare Ruby?

Maggior parte Il modo migliore imparare una lingua è immergersi in essa e lavorare con essa. Ci sono anche molte guide e tutorial a cui puoi fare riferimento. Se hai una memoria visiva sviluppata e comprendi meglio attraverso presentazioni visive, vai su YouTube: c'è un'ampia selezione di video educativi.

Se desideri un'esperienza di apprendimento tradizionale simile a quella di una classe, puoi imparare dai siti Web di apprendimento della programmazione. Non devi andare all'università o al college per ottenere un'istruzione lavorativa.

Una delle mie risorse preferite - e completamente gratuita - per imparare Rails è il Rails Tutorial di Michael Hartle. Ti porterà dal progetto semplice a quello complesso al tuo ritmo e puoi iniziare dall'inizio senza alcuna conoscenza di Ruby on Rails.

Indipendentemente dal percorso di apprendimento che scegli, ricorda che solo la pratica rende perfetti. Stabilisci obiettivi personali per dedicare una certa quantità di tempo ogni giorno a lavorare con Ruby. Attieniti a questi obiettivi e sii persistente. Prima di conoscere fino in fondo questa lingua, sarai già un esperto in grado di creare dei fantastici progetti.