Tämä opas kattaa Ruby on Railsin asennuksen ja käytön.
Luettuasi sen opit:
- Kuinka asentaa Rails, luoda uusi Rails-sovellus ja liittää sovelluksesi tietokantaan.
- Rails-sovelluksen yleinen rakenne.
- MVC:n (Model, View Controller) ja RESTful-pohjaisen suunnittelun perusperiaatteet.
- Kuinka nopeasti luoda ensimmäinen koodi Rails-sovellukselle.
Tämän oppaan oletukset
Tämä opetusohjelma on suunnattu aloittelijoille, jotka haluavat aloittaa Rails-sovelluksen tyhjästä. Se ei edellytä, että olet työskennellyt Railin kanssa aiemmin.
Rails on Ruby-ohjelmointikielellä kirjoitettu web-kehityskehys. Jos sinulla ei ole kokemusta Rubysta, sinun voi olla vaikea hypätä suoraan Railsin oppimiseen. Rubyn oppimiseen on omistettu useita hyviä englanninkielisiä resursseja, esimerkiksi:
Huomaa, että jotkin resurssit, vaikka ne ovat edelleen mahtavia, kattavat edelleen Rubyn vanhemmat versiot, kuten 1.6 ja erityisesti 1.8, eivätkä sisällä joitain jokapäiväisessä Rails-kehityksessä näkemääsi syntaksia.
Mikä on Rails?
Rails on Ruby-ohjelmointikielellä kirjoitettu web-kehityskehys. Se on suunniteltu helpottamaan verkkosovellusten ohjelmointia tekemällä useita oletuksia siitä, mitä kukin kehittäjä tarvitsee uuden projektin luomiseksi. Sen avulla voit kirjoittaa vähemmän koodia ohjelmoinnin aikana verrattuna muihin kieliin ja kehyksiin. Professional Rail -kehittäjät huomauttavat myös, että se tekee verkkosovellusten kehittämisestä hauskempaa =)
Rails on sekava ohjelmisto. Se olettaa, että on olemassa "parempi" tapa tehdä jotain, ja se on suunniteltu siten, että se kannustaa siihen - ja joissain tapauksissa jopa estää vaihtoehtoja. Jos opit "The Rails Way", saatat huomata tuottavuuden merkittävän kasvun. Jos jatkat vanhojen tapojen tuomista muista kielistä Rails-kehitykseen ja yrität käyttää muualla opittuja malleja, sinulla on vähemmän onnellinen kehityskokemus.
Rails-filosofia sisältää kaksi tärkeää periaatetta:
- Älä toista itseäsi: DRY on ohjelmistokehityksen periaate, jonka mukaan "Jokaisella tiedolla tulee olla yksi, ei-redundantti, arvovaltainen esitys järjestelmässä." Älä kirjoita samoja tietoja uudestaan ja uudestaan, sillä koodia on helpompi ylläpitää ja se on laajennettavissa ja vähemmän bugiinen.
- Konfiguroinnin yleissopimus: Railsilla on mielipiteitä parhaista tavoista tehdä monia asioita verkkosovelluksessa, ja se käyttää oletuksena näitä käytäntöjä sen sijaan, että se pakottaisi sinua käsittelemään lukuisia määritystiedostoja.
Uuden kiskoprojektin luominen
Paras tapa käyttää tätä opasta on käydä se läpi vaihe vaiheelta. Kaikki vaiheet ovat välttämättömiä esimerkkisovelluksen suorittamiselle, eikä lisäkoodia tai -vaiheita tarvita.
Seuraamalla tätä opetusohjelmaa luot Rails-projektin nimeltä blogi, hyvin yksinkertaisen verkkoblogin. Ennen kuin aloitamme sovelluksen luomisen, meidän on varmistettava, että itse Rails on asennettu.
Seuraavissa esimerkeissä käytetään $ ilmaisemaan terminaalin tuloriviä UNIX-tyyppisessä muodossa käyttöjärjestelmät ah, vaikka se voidaan määrittää eri tavalla. Jos käytät Windowsia, rivi näyttää tältä c:\source_code>
3.1. Kiskojen asennus
Ennen kuin asennat Railsin, sinun on varmistettava, että vaaditut esiriippuvuudet on asennettu järjestelmääsi. Näitä ovat Ruby ja SQLite3.
Avaa hakemukset komentorivi. Avaa macOS:ssä Terminal.app, Windowsissa valitse Käynnistä-valikosta "Suorita" ja kirjoita "cmd.exe". Kaikki dollarimerkillä $ alkavat komennot on suoritettava komentorivillä. Varmista, että sinulla on uusin Rubyn versio asennettuna:
$ rubiini - v rubiini 2.5.0
Rails vaatii Rubyn version 2.5.0 tai uudemman asennuksen. Jos versionumero on tätä pienempi, sinun on asennettava uusi Rubyn kopio.
Asenna Ruby ja Ruby on Rails nopeasti järjestelmääsi Windows-käyttäjät voi käyttää Rails Installeria. Lisää asennusmenetelmiä useimmille käyttöjärjestelmille löytyy osoitteesta ruby-lang.org.
Jos käytät Windowsia, sinun on asennettava Ruby Installer Development Kit.
Tarvitset myös SQLite3-tietokantaasennuksen.
Monet suositut UNIX-tyyppiset käyttöjärjestelmät toimitetaan kohtuullisella SQLite3-versiolla. Jos asensit Railsin Windowsissa Rails Installerilla, sinulla on jo asennettuna SQLite. Muut käyttäjät voivat katsoa asennusohjeet SQLite3-verkkosivustolta. Tarkista, että se on asennettu oikein ja sisältyy polkuun:
$sqlite3 --versio
Ohjelman on raportoitava sen versio.
Asenna Rails käyttämällä RubyGemsin toimittamaa gem install -komentoa:
$ gem asennuskiskot
Tarkistaaksesi, että kaikki on asennettu oikein, sinun on tehtävä seuraavat:
$rails -- versio
Jos siinä lukee esimerkiksi "Rails 6.0.0", voit jatkaa.
3.2. Blogisovelluksen luominen
Railsissa on useita komentosarjoja, joita kutsutaan generaattoreiksi ja jotka on suunniteltu helpottamaan kehittäjän elämää luomalla kaikki tietyn tehtävän aloittamiseen tarvittava. Yksi niistä on New Application Generator, joka antaa sinulle puitteet Rails-sovellukselle, joten sinun ei tarvitse kirjoittaa sitä itse.
Voit käyttää tätä generaattoria avaamalla päätelaitteen, siirtymällä kansioon, jossa sinulla on oikeus luoda tiedostoja ja kirjoittaa:
$rails uusi blogi
Tämä luo blogihakemistoon Blog-nimisen Rails-sovelluksen ja asentaa jalokivet, joiden riippuvuudet mainitaan Gemfile-tiedostossa nippuasennusta käytettäessä.
klo Windowsin avulla Linux-alijärjestelmä, viesteille on joitain rajoituksia tiedostojärjestelmä, mikä osoittaa, että jousi- ja kuunteluhelmet tulisi poistaa käytöstä, mikä voidaan tehdä ajamalla kiskoja uusi blogi --skip-spring --skip-listen .
Näet kaikki mahdolliset komentorivivaihtoehdot, jotka Rails-sovellusten rakentaja hyväksyy suorittamalla rails new -h .
Kun olet luonut blogisovelluksen, siirry sen kansioon:
Blogihakemisto sisältää useita automaattisesti luotuja tiedostoja ja kansioita, jotka määrittävät Rails-sovelluksen rakenteen. Suurin osa tämän opetusohjelman työstä tapahtuu sovelluskansiossa, mutta nyt käydään läpi kunkin kansion toiminnot, jotka Rails luo oletuksena uuteen sovellukseen:
| Tiedostokansio | Tarkoitus |
|---|---|
| sovellus/ | Sisältää sovelluksesi ohjaimia, malleja, näkymiä, apuohjelmia, postittajia, kanavia, työpaikkoja ja resursseja. Tarkastelemme tätä kansiota seuraavassa tarkemmin. |
| roskakori/ | Sisältää Rails-komentosarjoja, jotka käynnistävät sovelluksesi, ja hakemisto voi sisältää myös muita komentosarjoja, joita käytät määrityksessä, päivittämisessä, käyttöönotossa tai suorittamisessa. |
| config/ | Reittimääritykset, sovellustietokantasi jne. Tätä käsitellään tarkemmin kohdassa Rails-sovellusten määrittäminen |
| config.ru | Sovelluksen suorittamiseen käytettyjen telinepohjaisten palvelimien telineasetukset. Lisätietoja Rackista on Rack-verkkosivustolla. |
| db/ | Sisältää nykyisen tietokantaskeeman sekä tietokannan siirrot. |
| Gemfile Gemfile.lock |
Näiden tiedostojen avulla voit määrittää, mitä helmiriippuvuuksia Rails-sovelluksesi tarvitsee. Bundler-helmi käyttää näitä tiedostoja. Lisätietoja Bundlerista on Bundlerin verkkosivustolla. |
| lib/ | Ulkoiset moduulit sovelluksellesi. |
| Hirsi/ | Sovelluksen lokitiedostot. |
| package.json | Tämän tiedoston avulla voit määrittää, mitä npm-riippuvuuksia Rails-sovelluksellesi tarvitaan. Tätä tiedostoa käyttää Yarn. Lisätietoja langasta saat Lanka-verkkosivustolta. |
| julkinen/ | Ainoa kansio, johon pääsee käsiksi ulkopuolelta sellaisenaan. Sisältää staattisia tiedostoja ja koottuja resursseja. |
| Rakefile | Tämä tiedosto etsii ja lataa tehtäviä, jotka voidaan suorittaa komentorivillä. Tietty tehtävä on käytettävissä kaikissa Rails-komponenteissa. Rakefile-tiedoston muuttamisen sijaan voit lisätä omia tehtäviäsi lisäämällä tiedostoja sovelluksen lib/tasks-hakemistoon. |
| README.md | Tämä on hakemuksesi johdanto-opas. Sitä tulee muokata kertomaan muille, mitä sovelluksesi tekee, kuinka se määritetään jne. |
| varastointi/ | Levypalvelun aktiiviset tallennustiedostot. Tämä käsitellään Active Storage Overview -oppaassa. |
| testata/ | Yksikkötestit, kalusteet ja muut testauslaitteet. Tämä käsitellään Testing Rails Applications -oppaassa. |
| tmp/ | Väliaikaiset tiedostot (kuten välimuisti- ja pid-tiedostot) |
| myyjä/ | Paikka kolmannen osapuolen koodille. Tyypillisessä Rails-sovelluksessa se sisältää ulkoisia helmiä. |
| .gitignore | Tämä tiedosto kertoo gitille, mitkä tiedostot (eksplisiittisesti tai suunnitelmallisesti) sen tulee jättää huomiotta. Lisätietoja tiedostojen ohittamisesta on kohdassa GitHub – Tiedostojen ohittaminen. |
| .ruby-versio | Tämä tiedosto sisältää Rubyn oletusversion. |
Hei Rails!
Näytetään ensin tekstiä näytöllä. Tätä varten tarvitset käynnissä olevan palvelimen Rails-sovelluksellesi.
4.1. Web-palvelimen käynnistäminen
Itse asiassa sinulla on jo toimiva Rails-sovellus. Jotta voit olla varma, sinun on käytettävä verkkopalvelinta koneessasi. Tämä voidaan tehdä suorittamalla seuraava komento blogihakemistosta:
Jos käytät Windowsia, sinun tulee siirtää komentosarjat bin-kansiosta suoraan Ruby-tulkkiin, eli ruby bin\rails -palvelimeen.
JavaScript-sisällön pakkaaminen edellyttää JavaScript-ajonaikaa järjestelmässäsi, ja sen puuttuminen johtaa execjs-virheeseen sisällön pakkaamisen aikana. Yleensä macOS:ssä ja Windowsissa on asennettuna JavaScript-ajoaika. therubyrhino on suositeltu ajonaika JRuby-käyttäjille, ja se lisätään Gemfile-tiedostoon, jos sovellus luodaan JRubylla. Voit oppia kaiken tuetuista suoritusajoista ExecJS:ssä
Tämä käynnistää Puman, verkkopalvelimen, joka on jaettu oletuksena Railsin kanssa. Näet sovelluksen toiminnassa avaamalla selainikkunan ja siirtymällä osoitteeseen http://localhost:3000. Sinun pitäisi nähdä oletusarvoinen Rails-tietosivu:
Pysäytä verkkopalvelin painamalla Ctrl+C terminaalissa, jossa se on käynnissä. Varmistaaksesi, että palvelin on pysäytetty, sinun pitäisi nähdä komentorivikohdistin uudelleen. Useimmissa UNIX-tyyppisissä järjestelmissä, mukaan lukien macOS, tämä on dollarimerkki $. Kehitystilassa Rails ei yleensä vaadi palvelimen pysäyttämistä; palvelin poimii automaattisesti kaikki tiedostoihin tekemäsi muutokset.
Tervetuloa Aboard -sivu on eräänlainen testi uudelle Rails-sovellukselle: se osoittaa, että ohjelmasi on konfiguroitu tarpeeksi oikein sivun näyttämiseksi.
4.2. Sano hei Railsille
Jotta Rails voisi sanoa "Hei", sinun on luotava vähintään ohjain Ja näkymä(esitys).
Rekisterinpitäjän tehtävänä on vastaanottaa erityisiä pyyntöjä sovellukselle. Reititys päättää, mikä rekisterinpitäjä vastaanottaa mitkä pyynnöt. Jokaiselle ohjaimelle on usein useampi kuin yksi reitti, ja eri reittejä voidaan käsitellä eri tavalla toiminta. Jokaisen toiminnon tarkoituksena on kerätä tietoja, jotta ne voidaan näyttää näkymässä.
Näkymän tarkoituksena on näyttää nämä tiedot ihmisen luettavassa muodossa. Tärkeä huomioitava ero on se, että paikka, jossa tiedot kerätään, on ohjain, ei näkymää. Näkymän tulee näyttää vain nämä tiedot. Oletusarvoisesti näkymämallit kirjoitetaan kielellä nimeltä eRuby (Embedded Ruby), joka muunnetaan Rails-pyyntösilmukalla ennen kuin ne lähetetään käyttäjälle.
Luodaksesi uuden ohjaimen, sinun on suoritettava "ohjain"-generaattori ja kerrottava sille, että haluat "Tervetuloa"-nimisen ohjaimen toiminnolla "index", kuten tämä:
$ kiskot generoivat ohjaimen Tervetuloa-indeksi
Rails luo useita tiedostoja ja reitin.
Luo app/controllers/welcome_controller.rb reitti get "welcome/index" invoke erb create app/views/welcome luo app/views/welcome/index.html.erb invoke test_unit luo test/controllers/welcome_controller_test.rb kutsu apulainen luo sovellus/ helpers/welcome_helper.rb invoke test_unit invoke resurssit invoke scss luo app/assets/stylesheets/welcome.scss
Tärkeimmät niistä ovat tietysti ohjain, joka sijaitsee osoitteessa app/controllers/welcome_controller.rb, ja näkymä, joka sijaitsee osoitteessa app/views/welcome/index.html.erb.
Avaa tiedosto app/views/welcome/index.html.erb tekstieditorissa. Poista kaikki olemassa oleva koodi tiedostosta ja korvaa se seuraavalla koodirivillä:
Jos lähetät lomakkeen uudelleen, näet jotain seuraavanlaista:
Tämä toiminto näyttää nyt lomakkeesta tulleen artikkelin parametrit. Se on kuitenkin edelleen hyödytön. Kyllä, näet parametrit, mutta et itse tee niillä mitään.
5.4 Artikkelimallin luominen
Rails-mallit käyttävät yksikkönimeä, ja niitä vastaava tietokannan taulukko käyttää monikkonimeä. Rails tarjoaa malligeneraattorin, jota useimmat Rails-kehittäjät käyttävät uusien mallien luomiseen. Luo uusi malli suorittamalla tämä komento päätteessäsi:
$ rails luo malli Artikkelin otsikko:merkkijono teksti:teksti
Tällä komennolla kerromme Railsille, että haluamme artikkelimallin attribuutilla otsikko merkkijonotyyppi ja attribuutti teksti tekstin tyyppi. Nämä määritteet lisätään automaattisesti artikkelitaulukkoon ja sidotaan artikkelimalliin.
Rails vastaa luomalla sarjan tiedostoja. Nyt meitä kiinnostaa vain app/models/article.rb ja db/migrate/20140120191729_create_articles.rb (nimesi voi olla hieman erilainen). Jälkimmäinen vastaa tietokantarakenteen luomisesta, joten tarkastelemme sitä seuraavaksi.
Active Record on tarpeeksi älykäs liittämään sarakkeiden nimet automaattisesti mallin attribuutteihin, mikä tarkoittaa, että Rails-malleissa ei tarvitse ilmoittaa attribuutteja, vaan Active Record tekee sen automaattisesti.
5.5. Siirron aloittaminen
Kuten olet jo nähnyt, kiskot luovat mallin, joka loi tiedoston tietokannan siirto db/migrate-hakemistossa. Migrations on Ruby-luokka, joka on suunniteltu helpottamaan tietokantataulukoiden luomista ja muokkaamista. Rails käyttää rake-komentoja siirtojen suorittamiseen, ja on mahdollista peruuttaa siirto sen jälkeen, kun se on otettu käyttöön tietokantaan. Siirtotiedoston nimi sisältää aikaleiman, jolla varmistetaan, että ne suoritetaan siinä järjestyksessä, jossa ne luotiin.
Jos katsot tiedostoa db/migrate/YYYYMMDDHHMMSS_create_articles.rb (muista, että tiedostollasi on hieman eri nimi), löydät sieltä seuraavan:
Luokka CreateArticles< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end
Tämä siirto luo muutosmenetelmän, jota kutsutaan, kun tämä siirto suoritetaan. Tässä siirrossa määritellyt toiminnot ovat myös peruutettavissa, mikä tarkoittaa, että Rails osaa kumota tämän siirron tekemät muutokset, jos päätät kumota ne myöhemmin. Kun suoritat tämän siirron, se luo artikkelitaulukon, jossa on merkkijonosarake ja tekstisarake. Se luo myös kaksi aikaleimakenttää, joiden avulla seurataan, milloin artikkeli luotiin ja päivitettiin.
Nyt meidän on käytettävä rails-komentoa siirtymisen aloittamiseen:
$ rails db:migrate
Rails suorittaa tämän siirtokomennon ja raportoi, että se on luonut artikkelitaulukon.
Luo artikkeleita: siirto ================================================ === -- luo_taulukko(:artikkelit) -> 0.0019s == Luo artikkeleita: siirretty (0.0020s) =========================== ===============
Koska käytät oletusarvoisesti kehitysympäristöä, tätä komentoa sovelletaan tietokantaan, joka on määritetty config/database.yml-tiedoston kehitysosiossa. Jos haluat suorittaa siirrot toisessa ympäristössä, kuten tuotannossa, sinun on välitettävä se erikseen kutsuttaessa komentoa: rails db:migrate RAILS_ENV=production .
5.6. Tietojen tallentaminen ohjaimeen
Takaisin ArticlesControlleriin, meidän on muutettava luomistoimintoa, jotta voimme käyttää uutta artikkelimallia tietojen tallentamiseen tietokantaan. Avaa app/controllers/articles_controller.rb ja muuta luontitoiminto näyttämään tältä:
Oletusluo @article = Artikkeli.uusi(params[:artikkeli]) @article.save redirect_to @article end
Tässä tapahtuu näin: Jokainen Rails-malli voidaan alustaa asianmukaisilla attribuuteilla, jotka sidotaan automaattisesti vastaaviin tietokannan sarakkeisiin. Ensimmäisellä rivillä teemme juuri niin (muista, että params[:article] sisältää attribuutit, joista olemme kiinnostuneita). @article.save vastaa sitten mallin tallentamisesta tietokantaan. Lopuksi ohjaamme käyttäjän esitystoimintoon, jonka määrittelemme myöhemmin.
Saatat ihmetellä, miksi Article.new-kirjain A on isolla kirjaimella, kun kaikki muut tämän oppaan artikkelilinkit kirjoitetaan isoilla kirjaimilla. Tässä yhteydessä viittaamme luokkaan nimeltä Artikkeli, joka on määritelty tiedostossa app/models/article.rb. Rubiinin luokkanimien tulee alkaa isolla kirjaimella.
Nyt kun vahvistukset on tehty, virheellisen artikkelin kutsuminen @article.save palauttaa false . Jos avaat app/controllers/articles_controller.rb uudelleen, huomaat, että emme tarkista @article.save-kutsun tulosta luontitoiminnossa. Jos @article.save epäonnistuu tässä tilanteessa, meidän on näytettävä lomake käyttäjälle uudelleen. Voit tehdä tämän korvaamalla uudet ja luomalla toimintoja tiedostossa app/controllers/articles_controller.rb näillä:
Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save redirect_to @article muuten renderöi "uusi" end end private def article_params params.require(:article).permit(:title , :teksti) loppu
Uusi toiminto luo nyt uuden ilmentymämuuttujan nimeltä @article , ja näet miksi muutamassa kappaleessa.
Huomaa, että luomistoiminnossa käytimme renderöintiä redirect_to sijaan, kun tallennus palauttaa false. Renderöintimenetelmää käytetään varmistamaan, että @article-objekti välitetään takaisin uuteen malliin, kun se renderöidään. Tämä renderöinti tapahtuu samassa pyynnössä kuin lomakkeen lähetys, kun taas redirect_to käskee selaimen tekemään toisen pyynnön.
5.11. Artikkelin päivitykset
Olemme käsitelleet CRUD:n "CR"-osan. Keskitytään nyt "U"-osaan, artikkeleiden päivittämiseen.
Ensimmäinen vaihe on lisätä muokkaustoiminto ArticlesControlleriin, tyypillisesti uuden ja luomisen väliin, kuten kuvassa.
Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) jos @article.save redirect_to @article muuten renderöi "uusi" loppu loppu
Näkymä sisältää lomakkeen, joka on samanlainen kuin mitä käytimme luodessamme uusia artikkeleita. Luo tiedosto nimeltä app/views/articles/edit.html.erb ja lisää siihen seuraava:
Artikkelin muokkaaminen
<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %><%= pluralize(@article.errors.count, "error") %>
-
<% @article.errors.full_messages.each do |msg| %>
- <%= msg %> <% end %>
<%= form.label:title %>
<%= form.text_field:title %>
<%= form.label:text %>
<%= form.text_area:text %>
<%= form.submit %>
<% end %> <%= link_to "Back", articles_path %>Tällä hetkellä osoitamme lomakkeella päivitystoimintoa, jota ei ole vielä määritetty, mutta teemme sen pian.
Artikkeliobjektin välittäminen form_with-menetelmälle määrittää automaattisesti URL-osoitteen muokatun artikkelilomakkeen lähettämistä varten. Tämä vaihtoehto kertoo Railsille, että haluamme tämän lomakkeen lähetettävän käyttämällä PATCHia, HTTP-menetelmää, jota odotetaan käytettävän päivitykset resurssit REST-protokollan mukaisesti.
Sitten sinun on luotava päivitystoiminto tiedostossa app/controllers/articles_controller.rb. Lisää se luomistoiminnon ja yksityisen menetelmän väliin:
Oletusluo @article = Artikkeli.uusi(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 "muokkaa" end end private def article_params params.require(:article).permit(:title, :text) end
Uutta menetelmää, update , käytetään, kun haluat päivittää jo olemassa olevan tietueen, ja se ottaa tiivisteen, joka sisältää päivitettävät attribuutit. Kuten ennenkin, jos artikkelin päivityksessä tapahtuu virhe, haluamme näyttää lomakkeen uudelleen käyttäjälle.
Käytimme uudelleen artikkelin_params-menetelmää, jonka määritimme aiemmin luontitoiminnolle.
Päivitystä varten ei tarvitse välittää kaikkia määritteitä. Jos esimerkiksi @article.update(title: "Uusi otsikko") kutsuttiin, Rails päivittää vain title-attribuutin jättäen kaikki muut määritteet koskemattomiksi.
| Otsikko | Teksti | ||
|---|---|---|---|
| <%= article.title %> | <%= article.text %> | <%= link_to "Show", article_path(article) %> | <%= link_to "Edit", edit_article_path(article) %> |
Ja lisäämme malliin myös app/views/articles/show.html.erb, jotta "Muokkaa"-linkki on myös artikkelisivulla. Lisää seuraavat tiedot mallin loppuun:
... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>
Ja sovelluksemme näyttää nyt tältä:
5.12 Osioiden käyttäminen näkymien toiston poistamiseen
Muokkaussivumme on hyvin samanlainen kuin uusi sivu, itse asiassa he käyttävät samaa koodia lomakkeen näyttämiseen. Poistetaan tämä päällekkäisyys käyttämällä osittaista näkymää. Sopimuksen mukaan osittaiset tiedostot alkavat alaviivalla.
Luo uusi tiedosto app/views/articles/_form.html.erb seuraavalla sisällöllä:
<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>
<%= pluralize(@article.errors.count, "error") %>kielsi tämän artikkelin tallentamisen:
-
<% @article.errors.full_messages.each do |msg| %>
- <%= msg %> <% end %>
<%= form.label:title %>
<%= form.text_field:title %>
<%= form.label:text %>
<%= form.text_area:text %>
<%= form.submit %>
<% end %>Päivitetään nyt app/views/articles/new.html.erb-näkymä käyttämään tätä uutta osaa kirjoittamalla se kokonaan uudelleen:
Uusi artikkeli
<%= render "form" %> <%= link_to "Back", articles_path %>Ja sama koskee näkymää app/views/articles/edit.html.erb:
Muokkaa artikkelia
<%= render "form" %> <%= link_to "Back", articles_path %>5.13. Artikkelien poistaminen
Nyt olemme valmiita kattamaan CRUD:n osan "D" poistamalla tietokannasta. REST-yleissopimuksen mukaisesti reitti kappaleiden poistamiseen kiskoreittien tulosteesta on seuraava:
POISTA /articles/:id(.:format) artikkelit#detroy
Poista reititysmenetelmää tulisi käyttää reiteille, jotka tuhoavat resursseja. Jos se jätettäisiin normaaliksi hakureitiksi, olisi mahdollista luoda seuraavat haitalliset URL-osoitteet:
katso tätä kissaa!
Käytämme poistomenetelmää resurssien tuhoamiseen, ja tämä reitti liittyy tuhoamistoimintoon tiedostossa app/controllers/articles_controller.rb, jota ei vielä ole olemassa. Tuhoa-menetelmä on yleensä viimeinen CRUD-toiminto ohjaimessa, ja kuten muutkin julkiset CRUD-toiminnot, se on sijoitettava ennen yksityisiä tai suojattuja menetelmiä. Lisätään se:
Def tuhota @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end
App/controllers/articles_controller.rb-tiedoston koko ArticlesControllerin pitäisi nyt näyttää tältä:
Class 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
Voit kutsua tuhoamaan Active Record -objekteja, kun haluat poistaa ne tietokannasta. Huomaa, että meidän ei tarvitse lisätä näkymää tälle toiminnolle, koska ohjaamme uudelleen hakemistotoimintoon.
Listaus artikkelit
<%= link_to "New article", new_article_path %>| Otsikko | Teksti | |||
|---|---|---|---|---|
| <%= 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?" } %> |
Tässä käytämme link_to:ta eri tavalla. Ohjaamme nimetyn reitin toisena argumenttina ja vaihtoehdot toisena argumenttina. Menetelmää: :delete ja data: ( vahvista: "Oletko varma?" ) käytetään html5-attribuutteina, joten kun linkkiä napsautetaan, Rails näyttää ensin käyttäjälle vahvistusikkunan ja lähettää sitten linkin poistomenetelmällä . Tämä tehdään käyttämällä rails-ujs JavaScript-tiedostoa, joka sisällytetään automaattisesti sovelluksen ulkoasuun (app/views/layouts/application.html.erb), kun sovellus luodaan. Ilman tätä tiedostoa vahvistusikkunaa ei näytetä.
Onnittelut, voit nyt luoda, tarkastella kaikkia ja yksitellen, päivittää ja tuhota artikkeleita.
Lisätään toinen malli
On aika lisätä sovellukseen toinen malli. Toinen malli käsittelee artikkelien kommentit.
6.1. Mallin luominen
Aiomme käyttää samaa generaattoria, jota käytimme aiemmin artikkelimallia luotaessa. Tällä kertaa luomme kommenttimallin, joka sisältää linkin artikkeliin. Suorita seuraava komento terminaalissa:
$ rails luo mallin Kommentti commenter:string body:text article:references
Tämä komento luo neljä tiedostoa:
Katsotaanpa ensin osoitteesta app/models/comment.rb:
Luokan kommentti< ApplicationRecord belongs_to:article end
Tämä on hyvin samanlainen kuin aiemmin näkemämme artikkelimalli. Ero on belongs_to:article rivillä, joka asettaa yhteys Aktiivinen tallennus. Opit yhteyksistä oppaan seuraavassa osiossa.
Bash-komennossa käytetty avainsana (:viittaukset) on mallien erityinen tietotyyppi. Se luo tietokantaan uuden sarakkeen, jossa on esitellyn mallin nimi, johon on liitetty _id ja joka voi sisältää numeerisia arvoja. Jotta ymmärrät paremmin, analysoi db/schema.rb-tiedosto siirron jälkeen.
Mallin lisäksi Rails teki myös migraation luodakseen vastaavan tietokantataulukon:
Luokka LuoKommentit< 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
t.references-rivi luo numeerisen sarakkeen nimeltä article_id, siihen indeksin ja viiteavaimen rajoitteen, joka osoittaa artikkelitaulukon id-sarakkeeseen. Seuraavaksi aloitamme siirron:
$ rails db:migrate
Rails on tarpeeksi älykäs suorittamaan vain siirtoja, joita ei ole vielä suoritettu nykyisessä tietokannassa. Tässä tapauksessa näet:
Luo kommentteja: siirto ================================================ == -- luo_taulukko(:kommentit) -> 0,0115s == LuoKommentit: siirretty (0,0119s) ============================ ============
6.2. Yhdistettävät mallit
Active Record -suhteiden avulla voit helposti ilmoittaa kahden mallin väliset suhteet. Kommenttien ja artikkelien suhteen voit kuvata suhdetta seuraavasti:
- Jokainen kommentti kuuluu yhteen artikkeliin.
- Yhdessä artikkelissa voi olla monta kommenttia.
Itse asiassa se on hyvin lähellä syntaksia, jota Rails käyttää ilmoittaessaan tämän yhteyden. Olet jo nähnyt kommenttimallissa koodirivin (app/models/comment.rb), joka saa jokaisen kommentin kuulumaan artikkeliin:
Luokan kommentti< ApplicationRecord belongs_to:article end
Sinun on muokattava app/models/article.rb lisätäksesi linkin toisen puolen:
Luokan artikkeli< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end
Nämä kaksi mainosta tulevat automaattisesti saataville suuri määrä mahdollisuudet. Jos sinulla on esimerkiksi @article-instanssimuuttuja, joka sisältää artikkelin, voit saada kaikki kyseiseen artikkeliin kuuluvat kommentit taulukkona kutsumalla @article.comments .
6.3. Reitin lisääminen kommenteille
Kuten tervetuloohjaimen kanssa, meidän on lisättävä reitti, jotta Rails tietää, mihin osoitteeseen haluamme mennä nähdäkseen kommentit. Avaa config/routes.rb-tiedosto uudelleen ja muokkaa sitä seuraavasti:
Resurssit:artikkelit tekevät resurssit:kommentit loppuvat
Tämä luo kommentteja, kuten sisäkkäinen resurssi artikkeleissa. Tämä on artikkelien ja kommenttien välisten hierarkkisten suhteiden vangitsemisen toinen puoli.
6.4 Ohjaimen luominen
Kun malli on saatu, käännämme huomiomme sopivan ohjaimen luomiseen. Käytämme jälleen samaa generaattoria, jota käytimme aiemmin:
$ kiskot generoivat ohjaimen Kommentit
Neljä tiedostoa ja tyhjä hakemisto luodaan:
Kuten kaikki muutkin blogit, lukijamme luovat kommenttinsa heti artikkelin lukemisen jälkeen, ja kommentin lisäämisen jälkeen heidät ohjataan takaisin artikkelin näyttösivulle ja näkevät, että heidän kommenttinsa on jo otettu huomioon. Tässä suhteessa CommentsController-työkalumme toimii keinona luoda kommentteja ja poistaa roskapostia, jos sellaista on.
Ensin laajennamme artikkeliesitysmallia (app/views/articles/show.html.erb), jotta uusi kommentti voidaan lisätä:
Otsikko: <%= @article.title %>
Teksti: <%= @article.text %>
Lisää kommentti:
<%= 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 %>Tämä lisää artikkelin näyttösivulle lomakkeen, joka luo uuden kommentin, kun luontitoimintoa kutsutaan CommentsControllerissa. Tässä form_with-kutsu käyttää taulukkoa, joka luo sisäkkäisen reitin, kuten /articles/1/comments .
Kirjoitetaan Create tiedostoon app/controllers/comments_controller.rb:
Class CommentsController< 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
Se on hieman monimutkaisempi kuin mitä näit artikkeliohjaimessa. Tämä on määrittämäsi liitteen sivuvaikutus. Jokainen kommenttipyyntö pitää kirjaa artikkelista, johon kommentti on liitetty, joten ratkaisemme ensin artikkelin hakemisen soittamalla artikkelimallin etsimiseen.
Lisäksi koodi hyödyntää joitain yhteyksiin käytettävissä olevia menetelmiä. Käytämme @article.commentsin luontimenetelmää kommentin luomiseen ja tallentamiseen. Tämä linkittää kommentin automaattisesti siten, että se kuuluu tiettyyn artikkeliin.
Kun olemme luoneet uuden kommentin, viemme käyttäjän takaisin alkuperäiseen artikkeliin artikkelin_polku(@article) -apuohjelman avulla. Kuten olemme jo nähneet, se kutsuu esitystoimintoa ArticlesControllerissa, joka puolestaan hahmontaa show.html.erb-mallin. Tässä haluamme näyttää kommentit, joten lisätään seuraava tiedostoon app/views/articles/show.html.erb.
Otsikko: <%= @article.title %>
Teksti: <%= @article.text %>
Kommentit
<% @article.comments.each do |comment| %>Kommentoija: <%= comment.commenter %>
Kommentti: <%= comment.body %>
<% end %>Lisää kommentti:
<%= 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 %>Nyt voit lisätä artikkeleita ja kommentteja blogiisi ja näyttää ne oikeissa paikoissa.
Refaktorointi
Nyt kun meillä on toimivia artikkeleita ja kommentteja, katsotaanpa app/views/articles/show.html.erb-mallia. Siitä tuli pitkä ja epämiellyttävä. Käytetään osittaisia lievittääksesi sitä.
7.1. Osakokoelmien renderöinti
Ensin kirjoitamme osittaisen kommentin, joka näyttää kaikki artikkelin kommentit. Luo tiedosto app/views/comments/_comment.html.erb ja lisää siihen seuraavat:
Kommentoija: <%= comment.commenter %>
Kommentti: <%= comment.body %>
Sitten voit muuttaa app/views/articles/show.html.erb seuraavasti:
Otsikko: <%= @article.title %>
Teksti: <%= @article.text %>
Kommentit
<%= render @article.comments %>Lisää kommentti:
<%= 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 %>Tämä tekee nyt app/views/comments/_comment.html.erb osittaisen kerran jokaiselle @article.comments-kokoelman kommentille. Koska renderöintimenetelmä toistuu @article.comments-kokoelman läpi, se määrittää jokaisen kommentin paikalliselle muuttujalle, jonka nimi on osittaismuuttuja, tässä tapauksessa kommentti , joka on käytettävissämme osiossa näytettäväksi.
7.2. Lomakkeen renderöiminen osittaisena
Siirretään myös uusi kommenttiosio osaamme. Luo uudelleen tiedosto app/views/comments/_form.html.erb, joka sisältää:
<%= 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 %>Muuta sitten app/views/articles/show.html.erb seuraavasti:
Otsikko: <%= @article.title %>
Teksti: <%= @article.text %>
Kommentit
<%= render @article.comments %>Lisää kommentti:
<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>Toinen renderöinti määrittelee vain osittaisen mallin, jonka haluamme hahmontaa, kommentit/lomake . Rails on tarpeeksi älykäs laittaakseen alaviivan tälle riville ja ymmärtämään, että tarkoitit _form.html.erb-tiedoston hahmontamista app/views/comments-hakemistossa.
@article-objekti on käytettävissä kaikissa näkymässä hahmonnetuissa osissa, koska määritimme sen ilmentymämuuttujaksi.
Kommenttien poistaminen
Toinen tärkeä blogin ominaisuus on kyky poistaa roskapostia. Tätä varten sinun on lisättävä jokin linkki näkymään ja tuhottava CommentsController-toiminto.
Kommentoija: <%= comment.commenter %>
Kommentti: <%= comment.body %>
<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>
Painamalla tätä uusi linkki"Destroy Comment" suorittaa DELETE /articles/:article_id/comments/:id CommentsControllerissamme, jota käytetään sitten poistettavan kommentin löytämiseen, joten lisätään tuhoamistoiminto ohjaimellemme (app/controllers/comments_controller .rb) :
Class CommentsController< 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
Tuhoa-toiminto löytää katsomamme artikkelin, löytää kommentin @article.comments-kokoelmasta, poistaa sen tietokannasta ja palauttaa artikkelin katseluun.
8.1. Aiheeseen liittyvien objektien poistaminen
Jos poistat artikkelin, myös siihen liittyvät kommentit on poistettava, muuten ne vievät vain tilaa tietokannassa. Rails antaa sinun käyttää linkissä riippuvaa vaihtoehtoa tämän saavuttamiseksi. Muokkaa artikkelimallia app/models/article.rb seuraavasti:
Luokan artikkeli< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end
Turvallisuus
9.1. Perustodennus
Jos julkaiset blogisi verkossa, kuka tahansa voi lisätä, muokata ja poistaa artikkeleita tai poistaa kommentteja.
Rails tarjoaa HTTP-perustodennusjärjestelmän, joka toimii hyvin tässä tilanteessa.
ArticlesControllerissa tarvitsemme tavan estää pääsy eri toimiin, jos käyttäjää ei ole todennettu. Tässä voimme käyttää Rails http_basic_authenticate_with -menetelmää salliaksemme pääsyn vaadittuihin toimiin, jos menetelmä sen sallii.
Jotta voit käyttää todennusjärjestelmää, määritämme sen ArticlesControllerin yläosassa osoitteessa app/controllers/articles_controller.rb. Meidän tapauksessamme haluamme, että käyttäjä todennetaan jokaiselle toiminnolle paitsi indeksi ja näyttö , joten kirjoitamme sen seuraavasti:
Class ArticlesController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости
Haluamme myös sallia vain todettujen käyttäjien poistaa kommentteja, joten CommentsControllerissa (app/controllers/comments_controller.rb) kirjoitamme:
Class CommentsController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости
Jos yrität nyt luoda uuden artikkelin, kohtaat HTTP-perustodennuskutsun:
Rails-sovelluksiin on saatavilla myös muita todennusmenetelmiä. Kaksi suosittua Railsin lisäosaa ovat muun muassa Devise ja Authlogic.
9.2. Muita ajatuksia turvallisuudesta
Turvallisuus, erityisesti verkkosovelluksissa, on laaja ja yksityiskohtainen alue. Rails-sovelluksesi turvallisuutta käsitellään tarkemmin oppaassa Turvallisuus Rails Sovellukset Yksinkertaisin tapa työskennellä Railsin kanssa on tallentaa kaikki ulkoiset tiedot UTF-8:aan. Jos ei, Ruby- ja Rails-kirjastot pystyvät usein muuttamaan alkuperäiset tietosi UTF-8-muotoon, mutta tämä ei aina toimi luotettavasti, joten on parasta varmistaa, että kaikki ulkoiset tiedot ovat UTF-8:aa.
Jos teet virheen tällä alueella, yleisin oire on selaimessa näkyvä musta timantti, jonka sisällä on kysymysmerkki. Toinen yleinen oire on symbolien, kuten "ü", ilmestyminen "ü":n sijaan. Rails ottaa useita sisäisiä toimenpiteitä lieventääkseen yleisiä ongelmia, jotka voidaan havaita ja korjata automaattisesti. Jos kuitenkin on ulkoista dataa, jota ei ole tallennettu UTF-8:aan, tämä voi johtaa tällaisiin ongelmiin, joita Rails ei pysty havaitsemaan ja korjaamaan automaattisesti.
Kaksi yleisintä tietolähdettä, jotka eivät ole UTF-8:ssa, ovat:
- Sinun tekstieditori: Useimmat tekstieditorit (kuten TextMate) tallentavat tiedostot oletuksena UTF-8-muodossa. Jos tekstieditorisi ei tee tätä, kuvioihisi syötetyt erikoismerkit (kuten é) voivat näkyä selaimessa timanttina, jossa on kysymysmerkki. Tämä koskee myös i18N-käännöstiedostojasi. Useimmat editorit, jotka eivät käytä oletuksena UTF-8:aa (kuten jotkin Dreamweaver-versiot), tarjoavat tavan vaihtaa oletusasetukseksi UTF-8. Toimi näin.
- Tietokantasi: Rails oletusarvoisesti muuntaa tiedot tietokannastasi UTF-8:ksi reunassa. Jos tietokantasi ei kuitenkaan käytä sisäisesti UTF-8:aa, se ei välttämättä pysty tallentamaan kaikkia käyttäjän syöttämiä merkkejä. Jos tietokantasi esimerkiksi käyttää sisäisesti Latin-1:tä ja käyttäjä kirjoittaa venäjän, heprean tai japanin merkkejä, tiedot menetetään heti, kun ne tulevat tietokantaan. Jos mahdollista, käytä UTF-8:aa tietokannan sisäisenä tallennustilana.
Kirjoittajaa kehotettiin kirjoittamaan tämä teksti tutkimalla useita maailmanlaajuisesta verkostosta löytyviä materiaaleja, jotka voitaisiin helposti nimetä saman otsikon/tunnisteen alle: Kuinka opin Rubyn(tai Ruby on Rails, PHP, JS, C++ jne.) kolmen päivän ajan.
Tai jotain sellaista. Kirjoittaja puolestaan muistutti välittömästi (hallittamattomista assosiaatioista) useita anekdootteja, joita yhdistää jälleen yhteinen teema, joka koostuu typerästi suoritettavien toimien arvioivasta luonnehdinnasta... venäjän kieli on voimakas ja uskomattoman aforistinen, mutta Valitettavasti ei näytä mahdolliselta lainata näitä mestariteoksia täällä; Ei siis auta muuta kuin tarjota lukijan huomiolle henkilökohtaisesti kirjoitettu versio sarjan dokumentista. Kuinka oppia työskentelemään Ruby on Railsissa iloisesti ja suhteellisen nopeasti.
Toimiva esimerkki artikkelissa kuvatusta koodista muiden Rails-esimerkkien ohella löytyy aina kirjoittajan testiblogista osoitteessa herokuapp.com, tervetuloa.
Tekniikka on yksinkertainen, eikä kirjoittaja väitä tässä ollenkaan löytäjän laakereita: sen on oltava mielenkiintoinen, eivätkä tulokset jätä sinua odottamaan. Ei haittaa yrittää leikkiä omilla heikkouksillaan, koska joskus turhamaisuus voi olla hyödyksi asian kannalta; Kehityksen tulosten tulee olla sellaisia, että ne voidaan ylpeänä esitellä lukijoille, ystäville ja työtovereille Internetissä, levitettynä jonnekin Heroku tai Amazon, myös - jotta voimme palata niihin yhä uudelleen, uudelleenrakentaminen ja parantaminen, foorumit ja StackOwerflow auttavat meitä kaikkia. Joten sanon, miksi et kirjoita ensin blogiisi Ruby on Rails?
Suosittelen aloittamaan erinomaisesta Getting Started with Rails -asiakirjasta tai sen venäjänkielisestä Rails-versiosta aloittelijoille, myös Build a Blog with Ruby on Rails, ja tämän blogin materiaalit, joiden linkit löytyvät helposti vasemmasta sivupalkista, myös auttaa. Ja sitten - siinä se, sitten taikuutta, aluksi kaikki on asetettu kuin muistiinpanoihin, avaa konsoli - ja eteenpäin... kirjoittaja pitää velvollisuutenaan tehdä vain muutamia selityksiä ja teknisiä suosituksia, jotka on suunniteltu helpottamaan taitava löytämään ja hankkimaan Voiman valopuolen, eikä enää Togoa. Tämä on vain sinun taistelusi, mene rohkeasti eteenpäin ja palaa voittajana.
Niin. Ensimmäisen oppaan vaiheittaiset ohjeet on kalibroitu täydellisesti, ja toivon, että se ei aiheuta sinulle ongelmia; sinulta vaaditaan vain tarkkaavaisuutta ja tarkkoja vaiheita toistamista... ja tunnin kuluttua ensimmäinen blogisi on valmis, voit pitää tauon ja siirtyä toiseen, hieman mielenkiintoisempaan. Ja juuri tässä saattaa olla hyötyä muutamasta eroavaisuuksien sanasta, joihin jatkamme nyt.
Aloitetaan toteamuksella, että nämä menetelmät ovat melko kykeneviä (vaihtoehtona) näyttämään alla esitetyltä, mutta eivät millään tavalla samoja kuin alkuperäisessä:
app/controllers/posts_controller.rb
# Päivitystoiminto päivittää viestin uudella tietojen oletuspäivityksellä, jos @post.update_attributes(post_params) flash[:notice] = "Viesti päivitetty onnistuneesti!" redirect_to posts_path else flash[:alert] = "Virhe päivitettäessä viestiä!" render:edit end end # Show-toiminto renderöi yksittäisen viestin haettuaan id:n def show end # Hävittäminen poistaa viestin pysyvästi tietokannasta def tuhota @post = Post.find(params[:id]), jos @post . tuhota flash[:notice] = "Viesti poistettiin onnistuneesti!" redirect_to posts_path else flash[:alert] = "Virhe päivitettäessä viestiä!" loppu loppu
Mutta kokeile tätä ja sitä, miksipä ei. Siirrytään eteenpäin.
Toinen blogi, vaikkakin monimutkaisempi (lisätty artikkelieditori CKE-editori Ja suunnitella, joustava työkalu rail-sovellusten todentamiseen), jostain syystä puuttuu kyky jättää kommentteja alkuperäiseen. Sinun on täytettävä tämä puute itse: jatka analogisesti ensimmäisen blogin luomisen kuvauksen kanssa, vain hyvin pieniä muutoksia tarvitaan: yksinkertaisesti sanottuna sen sijaan, että artikla Ja artikkeleita sinulla on ensimmäinen blogi lähettää Ja viestit toisessa blogissa se on pohjimmiltaan ero. Ole varovainen ja kaikki järjestyy.
Recaptcha Sinun on myös linkitettävä kommentteihin itse: kyllä, kyllä, tämä ei ole sinulle Joomla, totu siihen. Titaanisia ponnisteluja ei kuitenkaan tarvita, vaan yhteysprosessi Recaptcha on kuvattu yksityiskohtaisesti artikkelissa Recaptchan yhdistäminen Rails-sovelluksessa. Seuraavaksi ei ole tarpeetonta säätää suunnitella siten, että blogi toimii (ainakin aluksi!) yhden käyttäjän tilassa sallien lukuisille lukijoilleen VAIN LUKU -tilan, eli kiellämme uusien käyttäjien rekisteröinnin heti alussa. Internetissä on melko erilaisia reseptejä tämän tekemiseen, mutta mielestäni pätevin tällainen hakkerointi on Wiki-suunnittelussa, materiaalissa nimeltä How To: Set up device as a one user system . Nimittäin: luomme uuden ohjaimen:
app/controllers/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
sitten ohitamme sen routes.rb:ssä, ja siinä kaikki:
#devise_for:admins devise_for:admins, controllers: ( rekisteröinnit: "rekisteröinnit")
CKEDITOR.editorConfig = function(config) ( // config.enterMode = 2; //pois käytöstä
Täysin config.enterMode = CKEDITOR.ENTER_BR // painamalla ENTER-näppäintä
config.shiftEnterMode = CKEDITOR.ENTER_P; //painamalla SHIFT + ENTER KEYS -syötettä
Config.autoParagraph = false; // lopettaa automaattisen lisäyksen
Tarkennettuna);
Ehkä aluksi tässä on kaikki... hitto, melkein unohdin tärkeimmän. Jos aiot ottaa uuden blogisi käyttöön Heroku- lisää nämä kolme riviä
config/application.rb
Config.assets.precompile += Ckeditor.assets config.assets.precompile += %w(ckeditor/*) config.autoload_paths += %W(#(config.root)/app/models/ckeditor)
Muuten CKE-editori kieltäytyy työskentelemästä sinulle uudessa paikassasi.
Ruby on tehokas ja suosittu ohjelmointikieli. Suosionsa lisäksi se on perusta tunnetulle viitekehykselle, jonka avulla voit luoda upeita ja dynaamisia verkkosivustoja eri aiheista. Jos katsot TIOBE-luokitusta, kieli on yksi maailman 20 suosituimmasta kielestä.
Kieli ilmestyi vuonna 1995, ja sitä pidetään nuorena kielenä verrattuna C- tai C++-kieleen, jotka ilmestyivät vuonna 1972 ja 1983. Kielellä on useita etuja ja erityisominaisuuksia, jotka on toteutettu yksinomaan siinä, jos vertaamme muita suosittuja ohjelmointikieliä.
Kurssisuunnitelma
Videokurssin aikana opit Ruby-kielen ilman lisäkehyksiä. Lisäkurssit päällä Rubiini löydät sen osoitteesta.
Kurssin aikana opimme asentamaan ja työskentelemään kielen kanssa, opimme syntaksin Rubiini(muuttujat, silmukat, ehdolliset lauseet), sekä monimutkaisempia asioita: OOP, tiedostojen käsittely, poikkeukset, menetelmät ja käsittelemme monia muita aiheita.
Rubyn asentaminen Windowsiin
Rubyn asentaminen Windowsiin käytä Ruby Installer, jonka voi ladata viralliselta verkkosivustolta tämän linkin kautta. ladata uusin versio ja asenna se tavallisen ohjelman tavoin. Kun asennus on valmis, näet samanlaisen ikkunan:
Varmista tässä ikkunassa, että valintaruutu on valittuna, jolloin toinen sovellus avautuu asennusta varten. Rubiini järjestelmään.
Syötä avautuvaan ikkunaan 1 yksitellen ja paina Enter, odota, kunnes asennus on valmis, paina 2 ja Enter ja suorita lopuksi kolmas komento painamalla 3 ja Enter.
Rubyn asentaminen Maciin
Macissa Ruby on asennettu oletusarvoisesti, joten sinun ei tarvitse tehdä mitään ylimääräistä. Voit tarkistaa kieliversion terminaalista käyttämällä seuraavaa komentoa:
Jos versio on vanhentunut, voit ladata uuden. Ensin sinun on ladattava Ruby-versionhallinta. Tämä tehdään päätteen kautta komennolla:
Curl -L https://get.rvm.io | bash -s vakaa
Kun olet asentanut hallinnan, sinun on käynnistettävä päätelaite uudelleen. Suorita seuraava komento:
Rvm lista tiedossa
Uudelleenkäynnistyksen jälkeen voit asentaa haluamasi version. Meidän tapauksessamme versio 2.4.2 asennettiin:
Rvm asennus ruby-2.4.2
Lopuksi voit tarkistaa version uudelleen ja jos se on edelleen vanha, asenna uusi versio oletuksena.
Yksi ensimmäisistä ja yksityiskohtaisimmista Rails-koulutuskirjoista Internetissä. Suurin etu on yksityiskohtainen kattavuus tärkeimmistä ongelmista, säännölliset päivitykset ja ilmainen perussisältö.
Totta, resurssi on kokonaan englanninkielinen. Ja on tärkeää ymmärtää, että tämä on rakennettu kirjan muotoon - sinun on selvitettävä kaikki ongelmat itse. Tästä johtuen koulutuksen kestoa ja monimutkaisuutta ei voida ennustaa.
2. Railcasts
Toinen hyvin tunnettu koulutusresurssi Internetissä. Useampi kuin yksi Rails-kehittäjien sukupolvi kasvoi siinä. Myös englanniksi.
Sitä ei ole rakennettu täydelliseksi koulutuskurssiksi, vaan sarjana screencasteja - lyhyitä oppitunteja tietystä aiheesta. Oppitunteja on paljon, löydät ne melkein mistä tahansa aiheesta.
Valitettavasti projektin päivitys lopetettiin vuonna 2013.
3. Kiskot zombeille
Hauska johdatus on-railsiin aloittelijoille seikkailupelityyliin zombietunnelmalla. Erittäin suosittu täysin aloittelijoiden keskuudessa.
Se on kätevä, koska sinun ei tarvitse asentaa mitään tietokoneellesi. Kaikki ongelmat ratkaistaan selaimessa. Askel askeleelta käyt pelin läpi ja alat ymmärtää Ruby on Railsin perusasiat.
Jos et ymmärrä ohjelmointia ollenkaan, tämä on sinun valintasi. Kurssilla ei ole monimutkaisia aiheita, mikään ei häiritse perusteista. Englanniksi.
3. Udemy
Laaja kokoelma videokursseja. Niiden joukossa on monia rubiinia ja rubiinia kiskoilla. Ei ole mitään järkeä tarjota tiettyjä linkkejä - valitse makusi mukaan hinnan tai suosion perusteella.
Udemy-muoto sisältää melko lyhyitä kursseja, joissa painotetaan videotunteja. Älä odota vakavia kotitehtäviä tai nopeaa tukea opettajilta.
4. Ruby Bursa
Tehokas lyhytkurssi Rails-kehityksen perusteista. Kokeneet opettajat, hyvä ohjelma.
Opiskelijan henkilökohtainen läsnäolo kurssilla on toivottavaa ja se tapahtuu vain Ukrainan suurissa kaupungeissa.
5. Kehitys Ruby on Railsissa Evil Marsilta
Kolmen päivän intensiivikurssi yhdeltä Venäjän kokeneimmista Ruby on Rails -tiimeistä.
Harvoin tehty. Se on kallista (arvostelujen perusteella se on sen arvoista). Vaatii henkilökohtaista läsnäoloa. Sopii vain edistyneille ohjelmoijille; aloittelijoilla ei ole siellä mitään tekemistä.
6. Ruby on Rails -verkko-intensiivikurssi "A Good Programmer" -sivustolta
Tuore projekti aloittelijoille suunnatuista Ruby-kursseistaan tunnetulta tiimiltä.
Kolmen kuukauden intensiivinen ohjelma on suunniteltu aloittelijoille, ja se lupaa tehdä sinusta nuoremman ohjelmoijan, jonka valikoimassa on vähintään 12 älysovellusta.
Kurssi koostuu videotunneista, käytännön harjoituksista, opettajan tuesta ja säännöllisistä webinaareista.
Päätellen jostakin youtube kanava ja käyttäjien kommentit - nämä kaverit tietävät mitä tekevät, etkä kyllästy heihin.
Jokaisen web-suunnittelijan tärkein voimavara on ymmärtää – ja jopa järjestää – mitä kulissien takana tapahtuu.
Ainakin sinun pitäisi ottaa ohjelmointitunteja. En puhu käyttöliittymäkielistä, kuten HTML:stä ja CSS:stä – tiedät todennäköisesti jo paljon niistä. Puhun takapään asioista.
Jos osaat luoda perustan, ymmärrät paremmin, kuinka muu sivusto suunnitellaan. Pointti on, että koodaamisen oppiminen tekee sinusta oppineemman suunnittelijan. Sitä paitsi, kukapa ei haluaisi palkata suunnittelijaa, joka tietää kaiken suunnittelusta verkkosivustojen kehittämiseen?
Temppu on valita mistä aloittaa. Ohjelmoinnin oppiminen voi olla haastava prosessi, varsinkin jos valitset yhden niistä monimutkaiset kielet kuten C++ tai PHP.
Joten mikä on paras paikka aloittaa? On vain yksi vastaus: Ruby on Rails on yksi parhaista ohjelmointikielistä ja puitteista suunnittelun perusteiden oppimiseen.
Miksi Ruby on paras valinta?
Aloittelijoille Ruby on yksi helpoimmin opittavia kieliä, varsinkin jos sinulla on kokemusta HTML- tai CSS-kirjoituksesta, mikä useimmilla suunnittelijoilla on.
Yksi ensimmäisistä ohjelmista, joita teet, kun aloitat kielen opiskelun, on surullisen kuuluisa "Hello World!", joka sisältää näiden sanojen tulostamisen näytölle.
C++:n kaltaisilla kielillä voi olla viidestä seitsemään koodiriviä näiden kahden sanan näyttämiseksi. Mutta jos käytät Rubyä, siellä on vain yksi rivi ja yksi komento.
Laittaa "hei, maailma!"
Siinä kaikki! Tämä on kaikki mitä sinun tarvitsee kirjoittaaksesi sanat "Hei, maailma!" näytöllä. Aika helppoa, eikö?
Ruby on Rails on myös erittäin kuiva kieli. Yhtenä kehitysperiaatteena DRY tarkoittaa "Älä toista itseäsi" eli älä ohjelmoi elementtiä uudelleen, kun voit käyttää jo luomaasi elementtiä. Tämä tekee Rubysta erittäin helpon ja yleisesti käytetyn ohjelmointikielen kehittämiseen, sillä se pyrkii saattamaan projektin päätökseen nopeasti ja tehokkaasti.
Ruby vai Rails?
Ruby on ohjelmointikieli. Rails on kehys, joka käyttää Rubyä työn suorittamiseen. Ruby on Rails -kehys on kokoelma esivalmistettua tai valmiiksi kirjoitettua koodia, joka auttaa nopeuttamaan uusien projektien luontiprosessia. Alun perin se luotiin kehittämään Basecamp-projektinhallintatyökalua. Basecampin lisäksi on olemassa muita suosittuja verkkosovelluksia, jotka on rakennettu Railsilla, kuten 500px, ThemeForest ja MyFitnessPal.
Kun ymmärrät, miten Ruby-kieltä käytetään ja saat asiat toimimaan Ruby On Rails -kehyksessä, voit aloittaa verkkosovellusten rakentamisen.
Ruby on suosion huipulla!
Suosion räjähdysmäisen ansiosta mobiililaitteet ja teknologia, joka on aina yhteydessä, Ruby on uskomattoman suosittu nyt. Ja niin se todennäköisesti tulee olemaan jatkossakin. TIOBE-indeksin mukaan Ruby on 13. suosituin ohjelmointikieli. Nousevien trendien mukaisesti Rubylla on myös yllättävän suurta kysyntää Indeed.comin mukaan.
TIOBE-indeksi
Joka tapauksessa, kysyntä tai suosio, Ruby on melko suosittu. Tämä tekee hänestä yhden parhaat paikat Ensinnäkin, koska kun olet oppinut kielen, voit saada työpaikan melko nopeasti. Ja se on ennen kuin alat oppia toista kieltä laajentaaksesi taitojasi.
Rubylla on vankka perusta!
Joitakin muita kieliä on tosin käytetty enemmän, mutta silti tuki ja dokumentaatio kalpenevat Rubyn saatavilla olevaan verrattuna. Myös muilta kieliltä puuttuu yhteisön yhteenkuuluvuus yhden vahvasti tuetun kehyksen ympärillä.
Ruby On Rails -kehyksen ansiosta on jo olemassa paljon olemassa olevaa koodia, jota voit käyttää omissa projekteissasi. Ruby Gems, Ruby-kehysten kirjasto, sisältää yli 600 000 kirjastoa, joista valita.
Joka kerta kun opit jotain uutta, tarvitset paljon dokumentaatiota ja tukea. On olemassa lukuisia paikkoja, joista löydät oppimateriaalia, opetusohjelmia, oppaita ja jopa Q&A-foorumeita. Jos kohtaat tietyn ongelman, yksinkertainen verkkohaku todennäköisesti korjaa sen. On tärkeää.
Yksinkertainen dokumentaatio ja helppo pääsy tukeen ovat tärkeitä, kun opit uutta kieltä – kun opit itse asiassa jotain uutta.
Ruby "sallii" enemmän suunnittelun hallintaa
Jos olet vain web-suunnittelija, verkkosivuston luominen voi olla pitkä ja monimutkainen prosessi. Kun istut ohjelmoijan kanssa ja keskustelet sivustollesi tarvittavasta taustajärjestelmästä, sinun on usein uhrattava käyttöliittymä, jotta kaikki toimisi oikein.
Loppujen lopuksi tämä voi johtaa tuotteeseen, joka näyttää täysin erilaiselta kuin alkuperäinen visiosi. Ohjelmoija ei ehkä välitä, mutta sinulle se on todennäköisesti ongelmallista.
Et törmää tällaisiin ongelmiin, jos teet ohjelmoinnin itse. Sinun ei välttämättä tarvitse olla riippuvainen muista saadaksesi valmiin projektin, ja sinulla on paljon parempi käsitys siitä, mitä kehitysnäkökulmasta voidaan saavuttaa. Varmasti on ollut hetki tai kaksi, jolloin projektisi tavoitteet ovat olleet liian korkeat yhdelle ohjelmoijalle tai kehitystiimille? Kun opit Rubyn kaltaisen kielen, voit nauttia tarpeiden ja toisaalta kykyjen ymmärtämisen helppoudesta.
Pohjimmiltaan Ruby on suunniteltu käytettäväksi verkkosovelluksissa ja verkkokehityksessä, joten se on ihanteellinen paikka pyrkiville web-suunnittelijoille. Kun ymmärrät kielen ja opit käyttämään Ruby on Rails -kehystä, voit hallita projektejasi paljon paremmin.
Mistä oppia Ruby?
Suurin osa Paras tapa kielen oppiminen tarkoittaa uppoamista siihen ja työskentelemistä sen kanssa. On olemassa monia oppaita ja opetusohjelmia, joihin voit myös viitata. Jos sinulla on vahva visuaalinen muisti ja ymmärrät paremmin visuaalisten esitysten avulla, siirry YouTubeen – siellä on laaja valikoima opetusvideoita.
Jos haluat perinteistä luokkahuonetyyppistä koulutusta, voit suorittaa koulutuksen erityisillä ohjelmointisivustoilla. Sinun ei tarvitse käydä yliopistossa tai korkeakoulussa saadaksesi työkoulutuksen.
Yksi suosikkiresursseistani - ja täysin ilmaisista - Railin oppimiseen on Michael Hartlen Rails Tutorial. Se vie sinut yksinkertaisista monimutkaisiin projekteihin omassa oppimisvauhdissasi, ja voit aloittaa alusta ilman Ruby on Rails -tietoa.
Riippumatta siitä, minkä oppimispolun valitset, muista, harjoitus tekee mestarin. Aseta henkilökohtaiset tavoitteet viettääksesi joka päivä tietyn ajan Rubyn kanssa työskentelemiseen. Pysy näissä tavoitteissa ja ole sinnikäs. Ennen kuin ymmärrät kieltä täysin, olet jo asiantuntija, joka voi luoda upeita projekteja.