Oggi ho trovato una storia su Internet su come qualcuno di nome James Fend ha imparato Ruby on Rails per 12 settimane. Di seguito puoi leggere una traduzione relativamente accurata di questa storia e, si spera, essere ispirato a esplorare questo meraviglioso contesto (e questo meraviglioso linguaggio).

Prima di iniziare, vorrei presentare Josh Crews (http://joshcrews.com) e ringraziarlo per avermi convinto a iniziare a imparare Ruby on Rails; senza di lui, il suo aiuto e senza le ore che ha trascorso come mio mentore, non scriverei questo oggi. Grazie.

Il 23 gennaio ho lanciato la mia idea da sogno, Freelancify.com. Esattamente 12 settimane fa, ero un imprenditore tecnologico che spendeva migliaia di dollari per creare un MVP (prodotto minimo vitale) decente perché mi mancava la conoscenza. Uno dei motivi (pensavo in quel momento) era che la formazione era troppo difficile per me o avrebbe richiesto tempi eccessivamente lunghi. Pensavo (come molti altri) che i programmatori fossero (e alcuni lo sono) nati con una serie di magiche abilità matematiche e di risoluzione dei problemi che li rendono dei geni della programmazione. Ed esattamente 12 settimane fa Ho preso la decisione migliore da molto, davvero molto tempo.. Nessuna delle mie idee resterà più niente più che un’idea. Ora ho l'opportunità di lanciare versioni di produzione, spendendo soldi solo per l'hosting e impegnandomi un po'. Oggi, queste abilità sono come trainare un gruppo di trattori durante la corsa all'oro in California mentre tutti gli altri usavano semplici pale. Suggerisco a tutti di imparare a scrivere codice. Qui vorrei aggiungere una precisazione: prima avevo intitolato il post “Come ho imparato Rails in 8 settimane”, però per la precisione, vista la data di lancio, risulta essere 12 settimane. Tuttavia, nel giro di 8 settimane ho sentito di saperne abbastanza e le quattro settimane successive sono state dedicate maggiormente a mettere in pratica le conoscenze che avevo acquisito piuttosto che ad apprendere.

Quali competenze avevo prima di iniziare a imparare Rails?

Ero un web designer con conoscenza di HTML e CSS e mi concentravo principalmente sulla progettazione di UI e UX. La cosa più difficile che ho fatto con il codice vero e proprio (senza contare l'HTML) è stata la possibilità di personalizzare Wordpress. In breve, non avevo assolutamente idea di cosa fosse un framework MVC o di come funzionassero i database in generale. Il design, il layout e l'HTML per Freelancify sono stati creati da me in due settimane nel giugno 2011.

Perché ho deciso di studiare?

Tornando al giugno 2011, quando il layout era pronto, ho iniziato a cercare un programmatore che rendesse funzionale il layout. Il layout era quasi pronto: avevo campi di testo, menu a tendina, moduli, pulsanti, collegamenti che portavano dove necessario e così via. Ho trovato uno sviluppatore e, in poche parole, il ragazzo non era adatto a me. Mi sono ritrovato con un sacco di debiti e nessun prodotto nemmeno vicino al completamento. Così ho contattato Josh Krius (l'ho incontrato a un incontro Ruby on Rails da lui organizzato a Nashville) e l'ho incontrato per vedere se potevo realizzare qualcosa di ciò che mi era rimasto come sviluppatore. Sfortunatamente, correggere e modificare il codice non richiederebbe meno tempo che svilupparlo da zero da parte di un programmatore competente. Mi sono scoraggiato, rendendomi conto che non potevo permettermi di spendere nuovamente migliaia di dollari per lo sviluppo da zero. E poi Josh ha detto... " Perché non impari semplicemente a gestire Ruby on Rails, questo progetto sarebbe un ottimo modo" poi " Posso anche incontrarti due volte a settimana e aiutarti con i tuoi studi" Ho passato tutta la notte a pensarci. Le mie opzioni erano: trovare un lavoro comodo e pagare le bollette O rischiare tutto per imparare Rails e infine banchettare con il miglior ramen che l'Italia ha da offrire. Ho deciso. Ho chiamato Josh la mattina dopo. Metto tutto. Ho stanziato i soldi del resto dei risparmi e li ho divisi in tre mesi (per un ragazzo single che vive da solo e senza figli bastano mille dollari al mese). È ora di mettersi al lavoro, ora sono un apprendista a tempo pieno. Tenendo presente che la ricerca Google, Stackoverflow, IRC #RubyOnRails e la comunità Rails mi proteggeranno quando rimarrò bloccato, sono sicuro che ce ne saranno molti.

I miei prossimi tre mesi: Missione: Ottieni un MVP, ottieni abbastanza per lavorare, ma non "abbastanza schifoso" per lasciare una pessima prima impressione.

Settimane 1 - 3

Probabilmente è stata la curva di apprendimento più grande, ma NON mi sono arreso.

I muri sono fatti per le persone che non vogliono davvero lasciarli.

Configurare un ambiente Rails funzionante per un principiante assoluto può essere incredibilmente fastidioso. Suggerimento n. 1: prendi un Mac. Suggerimento n. 2: usa Homebrew, RVM, Git e Heroku (è davvero tutto ciò che ti serve per iniziare). Ho impiegato un paio di giorni per l'installazione, quindi ho disinstallato tutto e installato di nuovo. Ripetilo un paio di volte e ti abituerai ad usarlo. riga di comando terminale (console) e capire perché le cose funzionano come funzionano. Quindi, la prima cosa che ho imparato è stata TryRuby, Rails for Zombies e Rails Tutorial di Michael Hartle. Non preoccuparti di comprendere il materiale al 120%, ciò non accadrà finché non inizierai effettivamente a studiare. Ho finito il tutorial di Rails e ho creato questa app simile a Twitter in circa una settimana, senza capire veramente cosa avevo fatto. Più tardi, man mano che progredivo, ho cominciato a rendermi conto che tutto cominciava ad avere un senso.

Settimane 3 - 6

Con un'app Twitter creata utilizzando il tutorial di Rails, ho acquisito una certa sicurezza. Il management non mi ha reso uno sviluppatore, ma ora lo so passaggi generali nella creazione di applicazioni, dalla creazione dell'applicazione stessa all'installazione su Heroku. Tutto quello che è successo nel frattempo è rimasto sfocato. Come posso VERAMENTE iniziare a studiare adesso? Lavorare ad un progetto reale che significa qualcosa per me. Josh e io abbiamo deciso che avrei dovuto lavorare liberamente su Freelancify e vedere cosa potevo fare. La prima cosa che ho fatto è stata spostare tutto l'HTML dal framework e organizzarlo in viste e file parziali. Ho creato piattaforme di modelli di impalcature per utenti e progetti. Poi ho iniziato a imparare il mio primo vero gioiello, Devise. Poi, la possibilità di avere relazioni, ad esempio ogni Utente avrà un portafoglio. Ma gli Utenti possono avere più portafogli, mentre ogni portafoglio può appartenere a un solo Utente. Una volta compreso come funzionano le relazioni tra i modelli e come chiamare/visualizzare cose che appartengono a qualcos'altro, la vita diventerà molto più semplice. Se rimani bloccato su una parte e non puoi muoverti, saltala, è probabile che mentre sviluppi un'altra funzionalità, capirai anche come implementare ciò che ti sei perso.

Settimane 6 - 9

Passo dopo passo, ho continuato a imparare, copiando e ripetendo. Avrei fatto funzionare alcune cose, e poi - bam - e mi sarei scontrato con un muro e non avrei assolutamente idea di cosa fare dopo. Sia che andassi su Stackoverflow, sulla chat IRC #RubyOnRails, RailsCasts o tirassi Josh, alla fine ho capito come procedere. Fai la stessa cosa più e più volte e ne imparerai abbastanza velocemente. Trascorrere ore fastidiose testando la risposta di qualcuno su Stackoverflow solo per rendersi conto che non funziona è effettivamente utile. Capisci cosa non fare. E quando troverai la risposta inizierai a capire PERCHÉ quest'ultimo non ha funzionato. È stato in questo periodo che ho cominciato a rendermi conto di quanto fosse grande il quadro delle cose e a capire veramente PERCHÉ tutto funziona esattamente come funziona. Mi sono sentito un idiota e sono tornato indietro e ho rifattorizzato il codice che avevo scritto prima per renderlo più efficiente. E ad un certo punto ho raggiunto uno stadio in cui tutto ha cominciato ad andare a posto.

Settimane 9 - 12

Ero in una modalità di energia incredibile portando Freelancify alla fase di lancio. In questa fase mi sentivo come se stessi volando, mettendo in azione le funzioni. L'ultima settimana è stata spesa per il debug di vari bug ed errori. Questo lunedì ho lanciato il sito. Ma sono ancora lontano dal completare gli studi... Questo è tutto. Ho omesso (in nome della brevità del post) piccoli dettagli e cenni tecnici. Tuttavia, sentitevi liberi di porre domande nei commenti, cercherò sicuramente di rispondere. James Fend.

PS - Sebbene sia stato di grande aiuto avere un mentore con cui poter incontrare, puoi sicuramente imparare Rails senza uno. Oppure prova a trovarti una persona simile, molti sviluppatori Rails adorano contribuire alla comunità. Cerca conferenze e incontri locali.

Questa voce ha già più di due anni (pubblicata il 27 gennaio 2012), ma, tuttavia, non ha perso la sua rilevanza. Durante questo periodo, James Fend è riuscito a vendere Freelancify e investire in una nuova startup, ha lasciato una nota al riguardo il 27 febbraio 2013. Credo che questo articolo sia un ottimo esempio di come una persona può raggiungere il suo obiettivo. Tutto quello che devi fare è iniziare. :)

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

Dopo averlo letto, imparerai:

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

Presupposti contenuti in questo manuale

Questo tutorial è rivolto ai 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 a imparare Rails. Esistono diverse buone risorse in lingua inglese dedicate all'apprendimento di Ruby, ad esempio:

Tieni presente che alcune risorse, sebbene ancora eccezionali, coprono ancora versioni precedenti di Ruby come 1.6 e soprattutto 1.8, 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 facendo 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 di Rails notano anche che rende lo sviluppo di applicazioni web più divertente =)

Rails è un software ribelle. Presuppone che esista un modo “migliore” di fare qualcosa, ed è progettato in modo tale da incoraggiare questo modo – e in alcuni casi addirittura scoraggiare le alternative. Se impari "The Rails Way" potresti scoprire un aumento significativo della tua produttività. Se persisti nel portare vecchie abitudini di altri linguaggi nello sviluppo di Rails e provi a utilizzare modelli appresi altrove, avrai un'esperienza di sviluppo meno felice.

La filosofia Rails comprende due importanti principi guida:

• Non ripeterti: DRY è un principio di sviluppo software che afferma che "Ogni informazione dovrebbe avere una rappresentazione unica, non ridondante e autorevole nel sistema". Non scrivere più e più volte le stesse informazioni, il codice sarà più facile da mantenere e sarà più estensibile e meno buggato.
• Convenzione sulla configurazione: Rails ha opinioni su i modi migliori fare molte cose in un'applicazione web e avere queste convenzioni impostate per impostazione predefinita, anziché costringerti ad armeggiare con numerosi file di configurazione.

Creazione di un nuovo progetto di rotaie

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

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

I seguenti esempi utilizzano $ per indicare una linea di input del terminale in stile UNIX sistemi operativi ah, anche se potrebbe essere configurato diversamente. Se stai utilizzando Windows, la riga sarà simile a c:\source_code>

3.1. Installazione delle guide

Prima di installare Rails, devi assicurarti che le pre-dipendenze richieste siano installate sul tuo sistema. Questi includono Ruby e SQLite3.

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

$ 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 su un sistema, gli utenti Windows possono utilizzare Rails Installer. Ulteriori metodi di installazione per la maggior parte dei sistemi operativi possono essere visualizzati su ruby-lang.org.

Se lavori su Windows, devi installare il Ruby Installer Development Kit.

Avrai anche bisogno di un'installazione del database SQLite3.

Molti popolari sistemi operativi simili a UNIX vengono forniti con una versione ragionevole di SQLite3. Su Windows, se hai installato Rails utilizzando Rails Installer, hai già installato SQLite. Altri utenti possono fare riferimento al sito Web SQLite3 per le istruzioni di installazione. Verifica che sia installato correttamente e che sia contenuto nel tuo PATH:

$sqlite3 --version

Il programma deve riportare la sua versione.

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

$ gemma installa i binari

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

$rails --versione

Se dice 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 generando tutto il necessario per iniziare un'attività specifica. Uno di questi è il New Application Generator, che ti fornisce il framework di un'applicazione Rails in modo che tu non debba scriverla tu stesso.

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

Nuovo blog di $rails

Questo creerà un'applicazione Rails denominata Blog nella directory blog e installerà i gem le cui dipendenze sono menzionate nel Gemfile quando si utilizza bundle install .

A utilizzando Windows Sottosistema per Linux, sono presenti alcune restrizioni sui messaggi file system, indicando che le gemme spring e listen dovrebbero essere disabilitate, cosa che può essere fatta eseguendo rails new blog --skip-spring --skip-listen .

Puoi vedere tutte le possibili opzioni della riga di comando accettate dal costruttore dell'applicazione Rails eseguendo rails new -h .

Una volta creata l'applicazione blog, vai alla sua cartella:

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

Cartella di file	Scopo
app/	Contiene controller, modelli, visualizzazioni, helper, mailer, canali, lavori e risorse della tua 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 del percorso, database dell'applicazione, ecc. Questo è trattato più dettagliatamente in Configurazione delle applicazioni Rails
config.ru	Configurazione rack per i server basati su rack utilizzati per eseguire l'applicazione. Per ulteriori informazioni su Rack, visitare il sito Web di Rack.
db/	Contiene lo schema del database corrente e le migrazioni del database.
Gemfile Gemfile.lock	Questi file ti consentono di specificare quali dipendenze gem sono necessarie per la tua applicazione Rails. Questi file vengono utilizzati dalla gemma Bundler. Per ulteriori informazioni su Bundler, visitare il sito Web 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, visitare il sito web di Yarn.
pubblico/	L'unica cartella accessibile dall'esterno così com'è. Contiene file statici e risorse compilate.
Rakefile	Questo file trova e carica attività che possono essere eseguite sulla riga di comando. Un'attività specifica è disponibile in tutti i componenti Rails. Invece di modificare il Rakefile, puoi aggiungere le tue attività aggiungendo file alla directory lib/tasks dell'applicazione.
README.md	Questa è una guida introduttiva alla tua candidatura. Dovrebbe essere modificato per dire agli altri cosa fa la tua applicazione, come configurarla, ecc.
magazzinaggio/	File di archiviazione attivi per il servizio disco. Questo argomento è trattato nella guida Panoramica di Active Storage.
test/	Test unitari, dispositivi 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 (esplicitamente o in base alla progettazione) dovrebbe ignorare. Per ulteriori informazioni su come ignorare i file, vedere GitHub - Ignorare i file.
.versione rubino	Questo file contiene la versione predefinita di Ruby.

Ciao Rails!

Innanzitutto, visualizziamo del testo sullo schermo. Per fare ciò, hai bisogno di 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 sicuro, devi eseguire un server web sul tuo computer. Questo può essere fatto eseguendo il seguente comando dalla directory del blog:

Se utilizzi Windows, dovresti passare gli script dalla cartella bin direttamente all'interprete Ruby, ovvero ruby ​​bin\rails server .

La compressione delle risorse JavaScript richiede un runtime JavaScript sul tuo sistema e la mancanza di uno 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 viene generata sotto JRuby. Puoi imparare tutto sui runtime supportati in ExecJS

Questo avvierà Puma, un server web distribuito con Rails per impostazione predefinita. Per vedere l'applicazione in azione, aprire una finestra del browser e andare su http://localhost:3000. Dovresti vedere la pagina delle informazioni di Rails predefinita:

Per arrestare il server Web, premere Ctrl+C nel terminale su 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 Sistemi simili a UNIX, incluso macOS, questo sarà il simbolo del dollaro $. In modalità sviluppo, Rails generalmente non richiede l'arresto del server; tutte le modifiche apportate ai file vengono automaticamente rilevate dal server.

La pagina Welcome Aboard è una sorta di test per una nuova applicazione Rails: mostra che i tuoi programmi sono configurati sufficientemente correttamente per visualizzare la pagina.

4.2. Saluta Rails

Affinché Rails possa dire "Ciao", è necessario creare almeno controllore E visualizzazione(prestazione).

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

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

Per creare un nuovo controller, devi eseguire il generatore "controller" e dirgli che desideri un controller chiamato "Benvenuto" con un'azione chiamata "indice", come questa:

$ rails genera l'indice di benvenuto del controller

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 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. Rimuovi 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>

Ora questa azione visualizza i parametri per l'articolo proveniente dal modulo. Tuttavia, è ancora inutile. Sì, vedi i parametri, ma in realtà non fai nulla con essi.

5.4. Creazione di un modello di articolo

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

$ rails genera il modello Titolo articolo:stringa testo:testo

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 verranno automaticamente aggiunti alla tabella degli articoli e associati al modello Articolo.

Rails risponderà creando una serie di file. Ora 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, quindi lo vedremo in seguito.

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

5.5. Avvio di una migrazione

Come hai già visto, rails generate model ha creato il file migrazione del database nella directory db/migrate. Migrations è una classe Ruby progettata per semplificare la creazione e la modifica delle tabelle del database. Rails utilizza 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 garantire che vengano eseguiti nell'ordine in cui sono stati creati.

Se cerchi nel file db/migrate/YYYYMMDDHHMMSS_create_articles.rb (ricorda, il tuo file ha un nome leggermente diverso), questo è quello che troverai:

Classe CreaArticoli< 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 la migrazione. Anche le azioni definite in questa migrazione sono reversibili, il che significa che Rails sa come annullare le modifiche apportate da questa migrazione nel caso in cui decidi di annullarle in seguito. Quando esegui questa migrazione verrà creata una tabella di articoli con una colonna di stringa e una colonna di testo. Creerà inoltre due campi timestamp per tenere traccia di quando l'articolo è stato creato e aggiornato.

Ora dobbiamo utilizzare il comando rails per avviare la migrazione:

$ rail db:migrate

Rails eseguirà questo comando di migrazione e segnalerà di aver creato la tabella Articles.

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

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

5.6. Salvataggio dei dati nel controller

Tornando a 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 in questo modo:

Def create @article = Article.new(params[:article]) @article.save reindirizzamento_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 corrispondenti. Nella prima riga facciamo proprio questo (ricordiamo che params[:article] contiene gli attributi che ci interessano). @article.save è quindi 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 è in maiuscolo quando tutti gli altri collegamenti ad articoli in questa guida sono in maiuscolo. In questo contesto ci riferiamo alla classe chiamata Article, definita in app/models/article.rb. I nomi delle classi in Ruby devono iniziare con una lettera maiuscola.

Ora che ci sono le convalide, chiamare @article.save su un articolo non valido restituirà false . Se apri di nuovo app/controllers/articles_controller.rb, vedrai che non stiamo controllando il risultato della chiamata @article.save nell'azione di creazione. Se @article.save fallisce in questa situazione, dobbiamo mostrare nuovamente il modulo all'utente. Per fare ciò, sostituisci le nuove 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 reindirizza_to @article else render "new" end end private def article_params params.require(:article).permit(:title , :testo) fine

La nuova azione ora crea una nuova variabile di istanza chiamata @article e ne vedrai il motivo tra un paio di paragrafi.

Tieni presente che nell'azione di creazione abbiamo utilizzato render invece di reindirizzare_to quando il salvataggio restituisce false. Il metodo render viene utilizzato per garantire che l'oggetto @article venga passato al nuovo modello quando viene renderizzato. Questo rendering viene eseguito all'interno della stessa richiesta di invio del modulo, mentre reindirizza_to indica al browser di effettuare una richiesta diversa.

5.11. Aggiornamenti dell'articolo

Abbiamo trattato la parte "CR" di CRUD. Ora concentriamoci sulla parte "U", aggiornamento degli 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 reindirizza_a @article else render "nuovo" 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 verso un'azione di aggiornamento, che non è stata ancora definita, ma lo faremo presto.

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

Quindi 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 reindirizza_to @article else rende "nuovo" end end def aggiorna @article = Article.find(params[:id]) if @article.update(article_params) reindirizza_to @article else render "modifica" end end private def article_params params.require(:article).permit(:title, :text) end

Il nuovo metodo, update , viene utilizzato quando si desidera aggiornare un record 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 che abbiamo definito in precedenza per l'azione di creazione.

Non è necessario passare tutti gli attributi da aggiornare. Ad esempio, se è stato chiamato @article.update(title: "A new title"), Rails aggiornerà solo l'attributo title, lasciando intatti 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 aggiungeremo anche app/views/articles/show.html.erb al modello in modo che il collegamento "Modifica" sia presente 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. Utilizzo dei partial per eliminare la ripetizione nelle visualizzazioni

La nostra pagina di modifica è molto simile alla nuova pagina, infatti utilizzano lo stesso codice per visualizzare il form. Rimuoviamo questa duplicazione utilizzando una vista 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. Eliminazione di articoli

Adesso siamo pronti per coprire la parte “D” del CRUD, cancellando dal database. Seguendo la convenzione REST, il percorso per rimuovere gli articoli nell'output dei percorsi ferroviari è il seguente:

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

Il metodo di eliminazione del routing dovrebbe essere utilizzato per i percorsi che distruggono risorse. Se venisse lasciato come un normale percorso di accesso, sarebbe possibile creare i seguenti URL dannosi:

guarda questo gatto!

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

Def distruggi @articolo = Article.find(params[:id]) @article.destroy reindirizza_al percorso_articoli end

L'intero ArticlesController nel file app/controllers/articles_controller.rb ora dovrebbe assomigliare a questo:

Articoli di classeController< 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 la distruzione 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 indice.

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 un modo diverso. Passiamo la route con nome come secondo argomento e le opzioni come altro argomento. Le opzioni metodo: :delete e data: ( confirm: "Sei sicuro?" ) vengono utilizzate come attributi html5, quindi quando si fa clic su un collegamento, Rails mostrerà prima all'utente una finestra di dialogo di conferma e quindi invierà il collegamento utilizzando 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 individualmente, aggiornare ed eliminare articoli.

Aggiunta di un secondo modello

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

6.1. Generazione del 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 il modello Commento commentatore:stringa corpo:testo articolo:riferimenti

Questo comando genera quattro file:

Per prima cosa diamo un'occhiata a app/models/comment.rb:

Commento di classe< ApplicationRecord belongs_to:article end

Questo è molto simile al modello Article che abbiamo visto in precedenza. La differenza sta nella riga appartiene_a:articolo, che imposta connessione Registrazione attiva. Imparerai a conoscere le connessioni nella sezione successiva della guida.

La parola chiave (:references) utilizzata nel comando bash è un tipo di dati speciale per i modelli. Lui crea nuova colonna nel database con il nome del modello rappresentato con un _id aggiunto che può contenere valori numerici. Per comprendere meglio, analizzare il file db/schema.rb dopo aver eseguito la migrazione.

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

Classe CreaCommenti< 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, iniziamo la migrazione:

$ rail db:migrate

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

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

6.2. Modelli di collegamento

Le relazioni dei record attivi consentono di dichiarare facilmente le relazioni tra due modelli. Nel caso di commenti e articoli, potresti descrivere la relazione come segue:

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

In effetti, è molto simile alla sintassi utilizzata da Rails per dichiarare questa connessione. Hai già visto la riga di codice nel modello Comment (app/models/comment.rb) che fa sì che ogni commento appartenga a un articolo:

Commento di classe< ApplicationRecord belongs_to:article end

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

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

Questi due annunci mettono automaticamente a disposizione un gran numero di possibilità. Ad esempio, se hai una variabile di istanza @article contenente un articolo, puoi ottenere tutti i commenti appartenenti 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 nuovamente il file config/routes.rb e modificalo come segue:

Risorse:gli articoli fanno risorse:fine dei commenti

Questo creerà commenti come risorsa nidificata negli articoli. Questo è l'altro lato della cattura delle relazioni gerarchiche che esistono tra articoli e commenti.

6.4. Generazione di un controllore

Avendo il modello, rivolgiamo la nostra attenzione alla creazione del controller appropriato. Utilizzeremo nuovamente lo stesso generatore che abbiamo usato prima:

$ rails genera commenti del controller

Verranno creati quattro file e una directory vuota:

Come qualsiasi altro blog, i nostri lettori creeranno i loro commenti immediatamente 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.

Per prima cosa estenderemo il modello di visualizzazione degli articoli (app/views/articles/show.html.erb) per consentire l'aggiunta di 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 %>

Ciò aggiungerà un modulo alla pagina di visualizzazione dell'articolo che crea un nuovo commento quando l'azione di creazione viene richiamata 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:

Commenti della classeController< 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

È 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 risolviamo innanzitutto il problema del recupero dell'articolo chiamando find sul modello Article.

Inoltre, il codice sfrutta alcuni dei metodi disponibili per le connessioni. 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.

Una volta creato un nuovo commento, riportiamo l'utente all'articolo originale utilizzando l'helper article_path(@article). Come abbiamo già visto, richiama l'azione show su ArticlesController, che a sua volta renderizza il template 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.

Refactoring

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

7.1. Rendering di raccolte di parziali

Per prima cosa creeremo un commento parziale mostrando tutti i commenti per un articolo. Crea un file app/views/comments/_comment.html.erb e inserisci quanto segue:

Commentatore: <%= comment.commenter %>

Commento: <%= comment.body %>

Quindi puoi 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 ora renderà app/views/comments/_comment.html.erb parziale una volta per ogni commento nella raccolta @article.comments. Poiché il metodo render scorre la raccolta @article.comments, assegna ciascun commento a una variabile locale denominata come partial, in questo caso comment , che è a nostra disposizione per la visualizzazione nel partial.

7.2. Rendering di un modulo in un parziale

Spostiamo anche la nuova sezione commenti sul nostro partial. 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 rendering definisce semplicemente il modello parziale che vogliamo renderizzare, comments/form . Rails è abbastanza intelligente da mettere un carattere di sottolineatura su questa riga e capire che intendevi rendere il file _form.html.erb nella directory app/views/comments.

L'oggetto @article è disponibile in tutti i partial renderizzati nella vista, poiché lo abbiamo definito come variabile di istanza.

Eliminazione dei commenti

Un'altra caratteristica importante del blog è la possibilità di rimuovere lo spam. Per fare ciò, è necessario inserire qualche collegamento 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" eseguirà DELETE /articles/:article_id/comments/:id nel 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):

Commenti della classeController< 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, dovranno essere eliminati anche i commenti ad esso associati, altrimenti occuperanno semplicemente spazio nel database. Rails ti consente di utilizzare l'opzione dipendente su un collegamento per raggiungere questo obiettivo. Modificare il modello 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 http_basic_authenticate_with di Rails 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 venga autenticato per ogni azione tranne index e show , quindi lo scriveremo in questo modo:

Articoli di classeController< 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 in CommentsController (app/controllers/comments_controller.rb) scriveremo:

Commenti della classeController< 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 chiamata di autenticazione HTTP di base:

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

9.2. Altre riflessioni sulla sicurezza

La sicurezza, soprattutto nelle applicazioni web, è un ambito ampio e articolato. La sicurezza della tua applicazione Rails è trattata in maggior dettaglio nella guida Sicurezza delle applicazioni Rails. 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 che appare nel browser. Un altro sintomo comune è la comparsa di simboli come "ü" al posto di "ü". Rails adotta una serie di passaggi interni per mitigare i casi comuni di problemi che possono essere rilevati e corretti 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 lo fa, i caratteri speciali inseriti nei tuoi pattern (come é) potrebbero apparire come un diamante con un punto interrogativo nel browser. Questo vale anche per i 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 l'impostazione predefinita in UTF-8. Fai questo.
• Il tuo database: Rails per impostazione predefinita converte i dati dal tuo database in UTF-8 sul perimetro. Tuttavia, se il tuo database non utilizza UTF-8 internamente, potrebbe non essere in grado di memorizzare tutti i caratteri che l'utente inserirà. Ad esempio, se il tuo database utilizza internamente Latin-1 e l'utente inserisce caratteri russi, ebraici o giapponesi, i dati andranno persi non appena verranno inseriti nel database. Se possibile, utilizza UTF-8 come memoria interna nel tuo database.

Molti dei miei amici sviluppatori parlavano molto bene di Rails, ma non riuscivo a capire perché. Cos'è Rails e in cosa differisce da Ruby on Rails? Quanto è difficile imparare? È anche questo un linguaggio di programmazione? Cosa devo sapere prima di imparare Ruby on Rails?

Queste e molte altre domande mi giravano costantemente in testa, ma, a quanto pare, non ero l'unica. Anche i nostri lettori erano interessati a questo problema, quindi per saperne di più ho deciso di porre a uno dei miei colleghi alcune domande fondamentali su Ruby. Ecco come è nato questo articolo.

Sei pronto? Andare!

13 fatti su Ruby on Rails: cosa devi sapere?

1. Cos'è Rails?

Rails è un framework per applicazioni web progettato per scrivere codice in Ruby. Sembra confuso, vero?

Proviamo di nuovo. Esiste un linguaggio di programmazione chiamato Ruby. E' un piacere scriverlo. A proposito, la persona che lo ha creato ha affermato che il suo obiettivo principale era creare un linguaggio che migliorasse la vita dei programmatori. Non è meraviglioso?

Lasciate che vi faccia un esempio.

Se voglio visualizzare il testo sullo schermo in PHP, devo scrivere

eco "Ciao mondo";

Vedi il punto e virgola? E questa "eco" - cosa significa?

D'altra parte, se avessi bisogno di fare la stessa cosa in Ruby, dovrei scrivere quanto segue:

mette "Hello World"

Non c'è il punto e virgola e, anche se "puts" può sembrare un po' infantile, per me ha più senso di "echo". Quando passi ore a scrivere codice, piccoli dettagli come questo fanno una GRANDE differenza.

L'unico problema con Ruby era che non era progettato per creare applicazioni web. Cioè, non potrai, ad esempio, creare un sito web su di esso. Questo era il caso prima di Rails. Non sono sicuro che Rails sia stato il primo framework web per Ruby, ma è diventato SICURAMENTE il più popolare.

Lo scopo di Rails è fornire una piattaforma e funzionalità che consentano di creare applicazioni, in particolare un sito Web, in Ruby. Sembra piuttosto vago al momento, quindi proverò a spiegarlo in questo modo. Se scrivessi

mette "Hello World"

quindi nel documento HTML vedresti l'intero testo. Ma voglio che tu veda SOLO questo:

Ciao mondo

In poche parole, Rails ti consente di farlo. Ma non è tutto.

2. Cos'è Ruby on Rails?

Ruby on Rails è il nome ufficiale COMPLETO del framework Rails. Ma nelle conversazioni, gli sviluppatori di solito non dicono la prima parte e la chiamano semplicemente Rails. Quindi, se vuoi essere "al corrente" e apparire esperto di tecnologia, dovresti sicuramente chiamarlo Rails, ma RICORDA cosa significa la prima parte - "Ruby on".

3. Ho sentito che Rails è ottimo per i principianti. Perché?

Ci sono diversi motivi per cui Rails è ottimo per i principianti. Il primo è che il linguaggio Ruby stesso è davvero ottimo per i principianti, e questo è il primo vantaggio. Imparare a programmare in Ruby è molto più semplice che in altri linguaggi, poiché il linguaggio è abbastanza flessibile e liberale, il che ti farà risparmiare i nervi e ti permetterà di dedicare più tempo all'apprendimento delle basi della programmazione.

Perché Rails è così divertente per i principianti? È semplicemente molto stabile e fa un ENORME lavoro per te.

Per me lavorare su Rails è come guidare un camion. È incredibilmente potente, guardati: stai guidando un camion!!! Tuttavia, quanto sai come funziona l'auto che guidi?

Il fatto che Rails si occupi di così tante attività in più, svolgendole per te, ti consentirà di godere subito di molti fantastici vantaggi. Tuttavia, a volte questo può anche funzionare contro di te se a volte vai troppo avanti e non impari completamente le basi che devi semplicemente conoscere.

Per questo motivo è molto importante imparare da zero Ruby on Rails. E, cosa più importante, devi assicurarti di sentirti veramente a tuo agio nel lavorare con Ruby. Altrimenti, scenderai dal camion a metà strada e dirai a te stesso: "Aspetta, stavo davvero guidando questa cosa?"

4. Qual è la differenza tra uno sviluppatore Rails e uno sviluppatore Ruby?

Formalmente, la differenza è che un puro “sviluppatore Ruby” creerà applicazioni in Ruby, ma non in Rails. Anche se questo, di regola, non accade. È certamente possibile creare applicazioni web in Ruby utilizzando altri framework come Sinatra, ma sono disposto a scommettere che il 99% delle volte difficilmente verrai assunto come programmatore solo Ruby. Pertanto, devi in ​​ogni caso imparare Rails.

5. Quanto bene dovrei conoscere Ruby? Cosa dovrei imparare prima di iniziare la mia formazione?

Le opinioni variano su questo, ma restando sull'esempio del grande camion, penso che tu debba sentirti a tuo agio con Ruby per approfondire Rails. Proprio come, ad esempio, è meglio imparare ad andare in bicicletta prima di passare all'auto, e poi pensare a guidare un camion.

Ed ecco un'altra cosa. Molto tempo quando si lavora su Rails verrà dedicato alla scrittura di codice in Ruby. Per questo motivo è necessario conoscere molto bene questo linguaggio, soprattutto le sue nozioni di base: tipi di dati, metodi, orientamento agli oggetti, debug e molto altro. E non devi essere un programmatore Ruby estremamente esperto: devi solo sentirti sicuro quando lavori con Ruby, come un'anatra nell'acqua.

6. Perché dovrei imparare Rails? Cosa lo rende speciale?

È squisito e semplicemente sbalorditivo. Cos'altro devi sapere? Quando Rails è apparso per la prima volta, è diventata una vera scoperta e conquista dell'arte del design. Tenendo a mente le migliori pratiche quando è stato creato, Rails ti mette praticamente sulla strada per scrivere un ottimo codice, anche quando non vuoi (o non sai come).

Se desideri creare applicazioni Web robuste che cresceranno in base alle necessità pur essendo facili da mantenere in futuro, Rails è un'ottima opzione. Inoltre, è popolare tra molte aziende interessanti. L'ultimo grande motivo per cui Rails è così popolare tra le startup è che è ottimo per la prototipazione rapida. In poche ore puoi immaginare, creare e lanciare l'applicazione Rails di cui hai bisogno. In realtà ci sono pochissimi altri framework in grado di gestirlo.

7. Cosa puoi creare con Rails?

Cosa vuoi creare? Rails è adatto a qualsiasi applicazione web. Per illustrare, dai un'occhiata a questi fantastici esempi di siti costruiti con Rails: Hulu, Airbnb e Basecamp.

8. Posso creare applicazioni mobili utilizzando Rails?

Sì e no. Non sarai in grado di creare applicazioni mobili con Rails, ma con Rails puoi sicuramente creare un'applicazione web e usarla come back-end per applicazione mobile.

C'è anche uno strumento chiamato RubyMotion che semplifica la creazione di app native per iOS e Android in Ruby (ma non in Rails). Cioè, non utilizzerai SPECIFICAMENTE Rails per creare un'applicazione mobile per l'App Store, ma Rails può sicuramente essere una componente importante del tuo progetto mobile. Spero che ora il quadro sia più chiaro.

9. Ruby on Rails - Che tipo di lavoro posso ottenere?

Rails è una delle competenze più richieste al giorno d'oggi, quindi ci sono molte aziende tra cui scegliere con cui lavorare. Le startup, come Zearn, amano particolarmente Rails. Questa è una società IT educativa start-up senza scopo di lucro. Puoi anche scegliere un'azienda più grande come Bloomberg e partecipare allo sviluppo di siti e applicazioni utilizzati da milioni di utenti. Anche il freelance è una buona opzione per gli sviluppatori Rails. Essendo indipendente, potrai scegliere a quali progetti vuoi partecipare: piccoli e a breve termine o seri e a lungo termine.

10. Ho provato un altro linguaggio di programmazione, ma non mi è piaciuto. Dovrei provare Rails?

Voglio sottolinearlo ancora una volta: Rails, infatti, non è un linguaggio di programmazione, ma un framework. Se ti sei mai chiesto se abbia senso cercare di innamorarsi di un linguaggio di programmazione, tutto quello che posso dire è che Ruby è il linguaggio di programmazione più venerato e amato dagli utenti al mondo. Quindi non cancellerei la programmazione finché non avrai provato Ruby.

11. Dovrei imparare JavaScript insieme a Rails?

Invece – no. Inoltre – SENZA DUBBIO.

Uno sviluppatore Rails dovrà imparare JavaScript(). Questo non è un requisito per imparare Rails, ma è un'abilità di cui avrai bisogno man mano che impari.

Siamo onesti, man mano che approfondirai gradualmente il campo tecnologico, inizierai a capire che dovrai possedere molte competenze (sostanzialmente, questo significa che tutti dovrebbero sforzarsi di diventare uno sviluppatore full-stack). Fortunatamente, man mano che acquisisci esperienza, troverai più facile imparare sia nuove lingue che nuovi framework.

Per quanto riguarda la scelta tra JavaScript o Rails, ti dirò subito che non puoi sbagliare in entrambi i casi. Trovo Ruby molto più facile da imparare rispetto a JavaScript. Inoltre, conosco molte persone che hanno trovato JavaScript più semplice dopo aver imparato Ruby. Ma, come ho detto sopra, sicuramente non puoi sbagliare se studi entrambi.

12. Quanto durerà la formazione?

Quanto tempo al giorno dovrai dedicare allo studio? Penso che una buona conoscenza di Rails richieda diversi mesi di formazione dedicata. Ma come qualsiasi altra abilità, avrai bisogno di decine di migliaia di ore per diventare un professionista di Rails, quindi è meglio iniziare adesso.

La tua velocità di apprendimento sarà fortemente influenzata dal tuo livello di conoscenza nel campo della programmazione in generale. Ma se sei un principiante assoluto, vale la pena provare a iniziare con Ruby e Rails.

13. Ruby on Rails - Da dove cominciare?

Consiglio di iniziare con il miglior corso Ruby on Rails disponibile oggi. Se non hai scritto una riga di codice in vita tua, la prima cosa che dovresti fare è seguire il corso HTML e CSS. Fortunatamente, è abbastanza facile trovare corsi su HTML e CSS. Successivamente, dovrai imparare Ruby, Git e la riga di comando.

Il programma di formazione in genere ti introdurrà gradualmente a Rails, mostrandoti come lavorare con Sinatra e ActiveRecord. Questo non ti dice ancora nulla, ma il punto è che prima di guidare quel "camion" di cui parlavo prima, dovresti iniziare con alcuni semplici corsi di guida su rotaia.

La cosa migliore da fare quando si studia è creare il proprio progetto, lavorare su qualcosa e svilupparlo, sapere che si sta andando nella giusta direzione e avere anche un buon supporto! Durante il processo di apprendimento avrai milioni di piccole domande da raggiungere miglior risultatoÈ importante che tu abbia qualcuno che possa aiutarti a capirlo e darti qualche consiglio in caso di difficoltà.

Alexander è il fondatore del progetto del sito web "Laboratorio Web del successo", creato per supportare gli imprenditori Internet principianti e continuativi. È un maniaco del lavoro convinto con esperienza professionale nella gestione della redazione di una rivista online, creando e gestendo il proprio negozio online. Occupazione principale: promuovere attività commerciali (compresi negozi online) tramite Facebook e Google Adwords. Hobby principale: monetizzare siti web attraverso strumenti di marketing di affiliazione e Google Adsense. Record personali confermati: 3 milioni di visitatori del blog al mese.

L'autore è stato spinto a scrivere questo testo studiando una serie di cose trovate in Rete globale materiali che potrebbero benissimo essere designati sotto la stessa intestazione/tag: Come ho imparato Ruby(o Ruby on Rails, PHP, JS, C++, ecc.) per tre giorni.

O qualcosa di simile. L'autore, a sua volta, ha subito ricordato (associazioni incontrollabili) una serie di aneddoti, uniti ancora da un tema comune, che consiste nella caratterizzazione valutativa di azioni che possono essere compiute stupidamente... la lingua russa è potente e incredibilmente aforistica, ma , purtroppo, non ci sembra possibile citare qui questi capolavori; Non resta quindi altro da fare che proporre all’attenzione del lettore una versione scritta personalmente del documento della serie Come imparare a lavorare in Ruby on Rails con piacere e in tempi relativamente brevi.

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 gli allori di uno scopritore: è necessario che sia interessante, e i risultati non si faranno aspettare. Non fa male provare a sfruttare le proprie debolezze, perché a volte la vanità può essere utile alla causa; i risultati dello sviluppo dovrebbero essere tali da poter essere presentati con orgoglio a lettori, amici e colleghi su Internet, distribuiti da qualche parte su Heroku O Amazzonia, inoltre, in modo che possiamo tornare a loro ancora e ancora, ricostruendo e migliorando, i forum e StackOwerflow aiutano tutti noi. Quindi dico, perché non scrivere, prima, sul tuo blog Rubino sui binari?

Suggerisco di iniziare dall'eccellente documento Getting Started with Rails o dal suo adattamento in lingua russa di Rails per principianti, anche Build a Blog with Ruby on Rails, e i materiali di questo blog, i cui collegamenti sono facilmente reperibili nella barra laterale di sinistra, possono anche aiutare. E poi - ecco fatto, allora magia, all'inizio tutto è disposto come per appunti, apri la console - e avanti... l'autore ritiene suo dovere fornire solo alcune spiegazioni e raccomandazioni tecniche pensate per facilitare il compito l'adepto per trovare e acquisire il Lato Chiaro della Forza, e non più Togo. Questa è solo la tua battaglia, vai avanti con coraggio e torna vittorioso.

COSÌ. Il passo passo del primo manuale è perfettamente calibrato e, spero, non vi creerà alcun problema; tutto quello che ti viene richiesto è stare attento, ripetendo scrupolosamente i passaggi dettagliati... e dopo un'ora il tuo primo blog è pronto, puoi fare una pausa e passare al secondo, un po' più interessante. Ed è qui che, forse, possono tornare utili alcuni consigli finali, ai quali procederemo ora.

Cominciamo con l'affermazione che questi metodi sono abbastanza capaci (come opzione) di assomigliare a quanto mostrato di seguito, ma non sono in alcun modo uguali all'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!" reindirizza_to posts_path else flash[:alert] = "Errore durante l'aggiornamento del post!" render:edit end end # L'azione show esegue il rendering del singolo post dopo aver recuperato l'id def show end # L'azione destroy rimuove il post permanentemente dal database def destroy @post = Post.find(params[:id]) if @post . destroy flash[:notice] = "Messaggio eliminato con successo!" reindirizza_to posts_path else flash[:alert] = "Errore durante l'aggiornamento del post!" fine fine

Ma prova questo e quello, perché no. Andiamo avanti.

Secondo blog, anche se più complesso (aggiunto editor articolo CKEditor E ideare, uno strumento flessibile per l'autenticazione nelle applicazioni ferroviarie), per qualche motivo non è possibile lasciare commenti nell'originale. Dovrai colmare tu stesso questa lacuna: procedi per analogia con la descrizione della creazione del primo blog, saranno necessarie solo piccolissime modifiche: in poche parole, invece di articolo E articoli avrai il primo blog inviare E post nel secondo blog, questa è fondamentalmente la differenza. Stai attento e tutto funzionerà.

Ricapitola Dovrai anche collegarti tu stesso ai commenti: sì, sì, questo non è Joomla per te, abituati. Tuttavia, non sono necessari sforzi titanici; il processo di connessione Ricapitolaè descritto in dettaglio nell'articolo Collegamento di Recaptcha nell'applicazione Rails. Successivamente, non è superfluo adattarsi ideare in modo tale che il blog funzioni (almeno all'inizio!) in modalità monoutente, consentendo a numerosi suoi lettori la modalità SOLA LETTURA, in altre parole proibiremo sin dall'inizio la registrazione di nuovi utenti. Ci sono diverse ricette su Internet su come farlo, ma, secondo me, l'hack più competente di questo tipo si trova in Wiki devise, nel materiale chiamato How To: Set up devise as a single user system. Vale a dire: creiamo un nuovo controller:

app/controllers/registrations_controller.rb:

Controller delle registrazioni delle classi< 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 Routes.rb e il gioco è fatto:

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

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

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

Config.autoParagraph = false; // interrompe l'inserimento automatico di

A fuoco);

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

config/applicazione.rb

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

Altrimenti CKEditor si rifiuterà di lavorare per te nel tuo nuovo posto.

Uno dei primi e più dettagliati libri di formazione su Rails su Internet. Il vantaggio principale è la copertura dettagliata delle questioni più necessarie, aggiornamenti regolari e contenuti di base gratuiti.

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

2. Trasmissioni ferroviarie

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

Non è concepito come un corso di formazione completo, ma come una serie di screencast: brevi lezioni su un argomento specifico. Ci sono molte lezioni, puoi trovarle su quasi tutti gli argomenti.

Sfortunatamente, il progetto ha smesso di aggiornarsi nel 2013.

3. Rotaie per zombie

Una divertente introduzione ai binari per principianti in stile gioco di ricerca con un'atmosfera da zombi. Molto popolare tra i principianti assoluti.

È comodo perché non è necessario installare nulla sul tuo computer. Tutti i problemi vengono risolti nel browser. Passo dopo passo attraverserai il gioco e inizierai a comprendere 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 videocorsi. Tra questi ce ne sono molti per rubino e rubino su rotaie. Non ha senso fornire link specifici: scegli in base ai tuoi gusti in base al prezzo o alla popolarità.

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

4. Rubino Bursa

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

È auspicabile la presenza personale dello studente al corso che si svolge solo nelle grandi città ucraine.

5. Sviluppo in Ruby on Rails da Evil Martians

Un corso intensivo di tre giorni tenuto 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 esperti; i principianti non hanno nulla da fare lì.

6. Corso intensivo online Ruby on Rails di “A Good Programmer”

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

Il programma intensivo di 3 mesi è progettato per principianti assoluti e promette di trasformarti in un programmatore junior con un portafoglio di non meno di 12 applicazioni intelligenti.

Il corso consiste in lezioni video, compiti pratici, supporto degli insegnanti e webinar regolari.

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