In dieser Anleitung wird die Installation und Ausführung von Ruby on Rails behandelt.

Nach der Lektüre erfahren Sie:

• So installieren Sie Rails, erstellen eine neue Rails-Anwendung und hängen Ihre Anwendung an eine Datenbank an.
• Die allgemeine Struktur einer Rails-Anwendung.
• Grundprinzipien von MVC (Model, View Controller) und RESTful-basiertem Design.
• So generieren Sie schnell ersten Code für eine Rails-Anwendung.

Annahmen in diesem Handbuch

Dieses Tutorial richtet sich an Anfänger, die eine Rails-Anwendung von Grund auf starten möchten. Es wird nicht davon ausgegangen, dass Sie bereits mit Rails gearbeitet haben.

Rails ist ein Webentwicklungs-Framework, das in der Programmiersprache Ruby geschrieben ist. Wenn Sie keine Erfahrung mit Ruby haben, fällt es Ihnen möglicherweise schwer, sofort mit dem Erlernen von Rails zu beginnen. Es gibt mehrere gute englischsprachige Ressourcen zum Erlernen von Ruby, zum Beispiel:

Bitte beachten Sie, dass einige der Ressourcen zwar immer noch großartig sind, aber dennoch ältere Versionen von Ruby wie 1.6 und insbesondere 1.8 abdecken und einige der Syntax nicht enthalten, die Sie in der alltäglichen Rails-Entwicklung sehen.

Was ist Rails?

Rails ist ein Webentwicklungs-Framework, das in der Programmiersprache Ruby geschrieben ist. Es soll das Programmieren von Webanwendungen erleichtern, indem es eine Reihe von Annahmen darüber trifft, was jeder Entwickler zum Erstellen eines neuen Projekts benötigt. Im Vergleich zu anderen Sprachen und Frameworks können Sie beim Programmieren weniger Code schreiben. Professionelle Rails-Entwickler bemerken auch, dass die Entwicklung von Webanwendungen dadurch mehr Spaß macht =)

Rails ist eine eigensinnige Software. Es geht davon aus, dass es einen „besseren“ Weg gibt, etwas zu tun, und ist so konzipiert, dass es Alternativen fördert – und in manchen Fällen sogar davon abhält. Wenn Sie „The Rails Way“ erlernen, können Sie eine deutliche Steigerung Ihrer Produktivität feststellen. Wenn Sie weiterhin alte Gewohnheiten aus anderen Sprachen in die Rails-Entwicklung einbringen und versuchen, an anderer Stelle gelernte Muster zu verwenden, werden Sie eine weniger glückliche Entwicklungserfahrung haben.

Die Rails-Philosophie umfasst zwei wichtige Leitprinzipien:

• Wiederholen Sie sich nicht: DRY ist ein Prinzip der Softwareentwicklung, das besagt: „Jede Information sollte eine einzige, nicht redundante, maßgebliche Darstellung im System haben.“ Schreiben Sie nicht immer wieder dieselben Informationen, da der Code dadurch einfacher zu pflegen, erweiterbarer und weniger fehlerhaft ist.
• Konvention über Konfiguration: Rails hat Meinungen darüber, wie man viele Dinge in einer Webanwendung am besten erledigen kann, und verwendet standardmäßig diese Konventionen, anstatt Sie zu zwingen, an zahlreichen Konfigurationsdateien herumzubasteln.

Erstellen eines neuen Rails-Projekts

Der beste Weg, diesen Leitfaden zu nutzen, besteht darin, ihn Schritt für Schritt durchzugehen. Alle Schritte sind für die Ausführung der Beispielanwendung unerlässlich und es sind kein zusätzlicher Code oder zusätzliche Schritte erforderlich.

Wenn Sie diesem Tutorial folgen, erstellen Sie ein Rails-Projekt namens Blog, ein sehr einfaches Web-Blog. Bevor wir mit der Erstellung einer Anwendung beginnen, müssen wir sicherstellen, dass Rails selbst installiert ist.

In den folgenden Beispielen wird $ verwendet, um eine Terminal-Eingabezeile im UNIX-Stil anzugeben Betriebssysteme Ah, obwohl es möglicherweise anders konfiguriert ist. Wenn Sie Windows verwenden, sieht die Zeile etwa so aus: c:\source_code>

3.1. Schienen installieren

Vor der Installation von Rails müssen Sie sicherstellen, dass die erforderlichen Vorababhängigkeiten auf Ihrem System installiert sind. Dazu gehören Ruby und SQLite3.

Öffnen Sie Apps für Befehlszeile. Öffnen Sie unter macOS Terminal.app, unter Windows wählen Sie „Ausführen“ aus dem Startmenü und schreiben Sie „cmd.exe“. Alle Befehle, die mit einem Dollarzeichen $ beginnen, müssen in der Befehlszeile ausgeführt werden. Stellen Sie sicher, dass Sie die aktuelle Version von Ruby installiert haben:

$ Ruby ​​-v Ruby 2.5.0

Rails erfordert die Installation von Ruby Version 2.5.0 oder höher. Wenn die Versionsnummer niedriger ist, müssen Sie eine neue Kopie von Ruby installieren.

Um Ruby und Ruby on Rails schnell auf Ihrem System zu installieren, Windows-Benutzer kann den Rails Installer verwenden. Weitere Installationsmethoden für die meisten Betriebssysteme finden Sie unter ruby-lang.org.

Wenn Sie unter Windows arbeiten, müssen Sie das Ruby Installer Development Kit installieren.

Sie benötigen außerdem eine SQLite3-Datenbankinstallation.

Viele beliebte UNIX-ähnliche Betriebssysteme werden mit einer angemessenen Version von SQLite3 ausgeliefert. Wenn Sie Rails unter Windows mit dem Rails Installer installiert haben, ist SQLite bereits installiert. Andere Benutzer finden Installationsanweisungen möglicherweise auf der SQLite3-Website. Überprüfen Sie, ob es korrekt installiert ist und in Ihrem PATH enthalten ist:

$sqlite3 --version

Das Programm muss seine Version melden.

Um Rails zu installieren, verwenden Sie den von RubyGems bereitgestellten Befehl gem install:

$ gem Schienen installieren

Um zu überprüfen, ob alles korrekt installiert ist, müssen Sie Folgendes tun:

$rails --version

Wenn dort etwa „Rails 6.0.0“ steht, können Sie fortfahren.

3.2. Erstellen einer Blog-Anwendung

Rails verfügt über eine Reihe von Skripten, sogenannte Generatoren, die das Leben eines Entwicklers erleichtern sollen, indem sie alles generieren, was für den Einstieg in eine bestimmte Aufgabe erforderlich ist. Einer davon ist der New Application Generator, der Ihnen das Framework einer Rails-Anwendung bereitstellt, sodass Sie diese nicht selbst schreiben müssen.

Um diesen Generator zu verwenden, öffnen Sie ein Terminal, gehen Sie zu einem Ordner, in dem Sie die Berechtigung zum Erstellen von Dateien haben, und schreiben Sie Folgendes:

$rails neuer Blog

Dadurch wird eine Rails-Anwendung namens Blog im Blog-Verzeichnis erstellt und die Gems installiert, deren Abhängigkeiten in der Gemfile erwähnt werden, wenn bundle install verwendet wird.

Bei unter Verwendung von Windows Subsystem für Linux, es gibt einige Einschränkungen für Nachrichten Dateisystem, was darauf hinweist, dass die Spring- und Listen-Gems deaktiviert werden sollten, was durch Ausführen von „rails new blog --skip-spring --skip-listen“ erfolgen kann.

Sie können alle möglichen Befehlszeilenoptionen anzeigen, die der Rails-Anwendungs-Builder akzeptiert, indem Sie „rails new -h“ ausführen.

Nachdem Sie die Blog-Anwendung erstellt haben, wechseln Sie zu ihrem Ordner:

Das Blog-Verzeichnis enthält mehrere automatisch generierte Dateien und Ordner, die die Struktur einer Rails-Anwendung definieren. Die meiste Arbeit in diesem Tutorial wird im App-Ordner stattfinden, aber lassen Sie uns zunächst die Funktionen jedes Ordners durchgehen, den Rails standardmäßig in einer neuen Anwendung erstellt:

Aktenordner	Zweck
App/	Enthält Controller, Modelle, Ansichten, Helfer, Mailer, Kanäle, Jobs und Assets Ihrer Anwendung. Als nächstes werden wir uns diesen Ordner genauer ansehen.
Behälter/	Enthält Rails-Skripts, die Ihre Anwendung starten, und das Verzeichnis kann auch andere Skripts enthalten, die Sie zum Konfigurieren, Aktualisieren, Bereitstellen oder Ausführen verwenden.
config/	Routenkonfigurationen, Ihre Anwendungsdatenbank usw. Dies wird ausführlicher unter „Konfigurieren von Rails-Anwendungen“ behandelt
config.ru	Rack-Konfiguration für die Rack-basierten Server, auf denen die Anwendung ausgeführt wird. Weitere Informationen zu Rack finden Sie auf der Rack-Website.
db/	Enthält Ihr aktuelles Datenbankschema sowie Datenbankmigrationen.
Gemfile Gemfile.lock	Mit diesen Dateien können Sie angeben, welche Gem-Abhängigkeiten Ihre Rails-Anwendung benötigt. Diese Dateien werden vom Bundler-Gem verwendet. Weitere Informationen zu Bundler finden Sie auf der Bundler-Website.
lib/	Externe Module für Ihre Anwendung.
Protokoll/	Anwendungsprotokolldateien.
package.json	Mit dieser Datei können Sie angeben, welche NPM-Abhängigkeiten für Ihre Rails-Anwendung erforderlich sind. Diese Datei wird von Yarn verwendet. Weitere Informationen zu Yarn finden Sie auf der Yarn-Website.
öffentlich/	Der einzige Ordner, der unverändert von außen zugänglich ist. Enthält statische Dateien und kompilierte Assets.
Rakefile	Diese Datei findet und lädt Aufgaben, die auf der Befehlszeile ausgeführt werden können. Eine bestimmte Aufgabe ist in allen Rails-Komponenten verfügbar. Anstatt die Rakefile zu ändern, können Sie Ihre eigenen Aufgaben hinzufügen, indem Sie Dateien zum Verzeichnis lib/tasks der Anwendung hinzufügen.
README.md	Dies ist eine Einführung in Ihre Bewerbung. Es sollte bearbeitet werden, um anderen mitzuteilen, was Ihre Anwendung tut, wie sie konfiguriert wird usw.
Lagerung/	Aktive Speicherdateien für den Festplattendienst. Dies wird im Leitfaden „Active Storage Overview“ behandelt.
prüfen/	Unit-Tests, Vorrichtungen und andere Testgeräte. Dies wird im Leitfaden zum Testen von Rails-Anwendungen behandelt.
tmp/	Temporäre Dateien (z. B. Cache- und PID-Dateien)
Verkäufer/	Platz für Code von Drittanbietern. In einer typischen Rails-Anwendung enthält es externe Gems.
.gitignore	Diese Datei teilt Git mit, welche Dateien (explizit oder absichtlich) ignoriert werden sollen. Weitere Informationen zum Ignorieren von Dateien finden Sie unter GitHub – Dateien ignorieren.
.Ruby-Version	Diese Datei enthält die Standardversion von Ruby.

Hallo Rails!

Lassen Sie uns zunächst etwas Text auf dem Bildschirm anzeigen. Dazu benötigen Sie einen laufenden Server für Ihre Rails-Anwendung.

4.1. Starten des Webservers

Tatsächlich verfügen Sie bereits über eine funktionsfähige Rails-Anwendung. Um sicherzugehen, müssen Sie auf Ihrem Computer einen Webserver ausführen. Dies kann durch Ausführen des folgenden Befehls im Blog-Verzeichnis erfolgen:

Wenn Sie Windows verwenden, sollten Sie Skripte aus dem bin-Ordner direkt an den Ruby-Interpreter übergeben, d. h. Ruby bin\rails server .

Für die Komprimierung von JavaScript-Assets ist eine JavaScript-Laufzeitumgebung auf Ihrem System erforderlich. Wenn Sie keine haben, kommt es während der Asset-Komprimierung zu einem execjs-Fehler. In der Regel ist auf macOS und Windows eine JavaScript-Laufzeitumgebung installiert. therubyrhino ist die empfohlene Laufzeit für JRuby-Benutzer und wird zur Gemfile hinzugefügt, wenn die Anwendung unter JRuby generiert wird. Sie können alles über die unterstützten Laufzeiten in ExecJS erfahren

Dadurch wird Puma gestartet, ein Webserver, der standardmäßig mit Rails verteilt wird. Um die Anwendung in Aktion zu sehen, öffnen Sie ein Browserfenster und gehen Sie zu http://localhost:3000. Sie sollten die Standard-Rails-Infoseite sehen:

Um den Webserver zu stoppen, drücken Sie Strg+C in dem Terminal, in dem er ausgeführt wird. Um zu überprüfen, ob der Server gestoppt wurde, sollte der Befehlszeilencursor erneut angezeigt werden. Auf den meisten UNIX-ähnlichen Systemen, einschließlich macOS, ist dies das Dollarzeichen $. Im Entwicklungsmodus erfordert Rails im Allgemeinen kein Stoppen des Servers. Alle Änderungen, die Sie an Dateien vornehmen, werden automatisch vom Server übernommen.

Die Seite „Welcome Aboard“ ist eine Art Test für eine neue Rails-Anwendung: Sie zeigt, dass Ihre Programme korrekt genug konfiguriert sind, um die Seite anzuzeigen.

4.2. Sag Hallo zu Rails

Damit Rails „Hallo“ sagen kann, müssen Sie mindestens erstellen Regler Und Sicht(Leistung).

Der Zweck des Verantwortlichen besteht darin, spezifische Anfragen zur Anwendung entgegenzunehmen. Routenführung entscheidet, welcher Controller welche Anfragen erhält. Zu jedem Controller gibt es oft mehr als eine Route, und unterschiedliche Routen können unterschiedlich gehandhabt werden Aktion. Der Zweck jeder Aktion besteht darin, Informationen zu sammeln, um sie der Ansicht bereitzustellen.

Der Zweck der Ansicht besteht darin, diese Informationen in einem für Menschen lesbaren Format anzuzeigen. Ein wichtiger Unterschied besteht darin, dass es sich um den Ort handelt, an dem Informationen gesammelt werden Regler, keine Aussicht. Die Ansicht sollte nur diese Informationen anzeigen. Standardmäßig sind Ansichtsvorlagen in einer Sprache namens eRuby (Embedded Ruby) geschrieben, die durch eine Rails-Anforderungsschleife konvertiert wird, bevor sie an den Benutzer gesendet wird.

Um einen neuen Controller zu erstellen, müssen Sie den „Controller“-Generator ausführen und ihm mitteilen, dass Sie einen Controller namens „Willkommen“ mit einer Aktion namens „Index“ wünschen, wie folgt:

$ Rails generieren einen Controller-Willkommensindex

Rails erstellt einige Dateien und eine Route.

Erstellen Sie die Route „app/controllers/welcome_controller.rb“, rufen Sie „welcome/index“ ab und rufen Sie erb auf. Erstellen Sie app/views/welcome. Erstellen Sie app/views/welcome/index.html.erb. helpers/welcome_helper.rb test_unit aufrufen, Assets aufrufen, scss aufrufen, app/assets/stylesheets/welcome.scss erstellen

Die wichtigsten davon sind natürlich der Controller, der sich in app/controllers/welcome_controller.rb befindet, und die Ansicht, die sich in app/views/welcome/index.html.erb befindet.

Öffnen Sie die Datei app/views/welcome/index.html.erb in einem Texteditor. Entfernen Sie den gesamten vorhandenen Code in der Datei und ersetzen Sie ihn durch die folgende Codezeile:

Wenn Sie das Formular erneut absenden, sehen Sie etwa Folgendes:

„Erster Artikel!“, „text“=>„Dies ist mein erster Artikel.“) erlaubt: false>

Diese Aktion zeigt nun die Parameter für den Artikel an, der aus dem Formular stammt. Es ist jedoch immer noch nutzlos. Ja, Sie sehen die Parameter, aber Sie machen eigentlich nichts damit.

5.4. Erstellen eines Artikelmodells

Modelle in Rails verwenden einen Singularnamen und ihre entsprechende Tabelle in der Datenbank verwendet einen Pluralnamen. Rails bietet einen Modellgenerator, den die meisten Rails-Entwickler zum Erstellen neuer Modelle verwenden. Um ein neues Modell zu erstellen, führen Sie diesen Befehl in Ihrem Terminal aus:

$ Rails generieren Modell Artikeltitel:string text:text

Mit diesem Befehl teilen wir Rails mit, dass wir ein Article-Modell mit dem Attribut wollen Titel String-Typ und Attribut Text Texttyp. Diese Attribute werden automatisch zur Artikeltabelle hinzugefügt und an das Artikelmodell gebunden.

Rails reagiert, indem es eine Reihe von Dateien erstellt. Jetzt interessieren uns nur noch app/models/article.rb und db/migrate/20140120191729_create_articles.rb (Ihr Name kann etwas anders sein). Letzterer ist für die Erstellung der Datenbankstruktur verantwortlich, daher werden wir uns als nächstes damit befassen.

Active Record ist intelligent genug, um Spaltennamen automatisch mit Modellattributen zu verknüpfen. Dies bedeutet, dass innerhalb von Rails-Modellen keine Attribute deklariert werden müssen. Active Record erledigt dies automatisch.

5.5. Eine Migration starten

Wie Sie bereits gesehen haben, hat Rails Generate Model die Datei erstellt Datenbankmigration im db/migrate-Verzeichnis. Migrations ist eine Ruby-Klasse, die das Erstellen und Ändern von Datenbanktabellen vereinfacht. Rails verwendet Rake-Befehle, um Migrationen auszuführen, und es ist möglich, eine Migration rückgängig zu machen, nachdem sie auf Ihre Datenbank angewendet wurde. Der Name der Migrationsdatei enthält einen Zeitstempel, um sicherzustellen, dass sie in der Reihenfolge ausgeführt werden, in der sie erstellt wurden.

Wenn Sie in der Datei db/migrate/YYYYMMDDHHMMSS_create_articles.rb nachsehen (denken Sie daran, dass Ihre Datei einen etwas anderen Namen hat), finden Sie dort Folgendes:

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

Diese Migration erstellt eine Änderungsmethode, die aufgerufen wird, wenn diese Migration ausgeführt wird. Die in dieser Migration definierten Aktionen sind auch umkehrbar, was bedeutet, dass Rails weiß, wie die durch diese Migration vorgenommenen Änderungen rückgängig gemacht werden können, falls Sie sie später rückgängig machen möchten. Wenn Sie diese Migration ausführen, wird eine Artikeltabelle mit einer Zeichenfolgenspalte und einer Textspalte erstellt. Außerdem werden zwei Zeitstempelfelder erstellt, um zu verfolgen, wann der Artikel erstellt und aktualisiert wurde.

Jetzt müssen wir den Befehl „Rails“ verwenden, um die Migration zu starten:

$ Schienen db:migrate

Rails führt diesen Migrationsbefehl aus und meldet, dass die Articles-Tabelle erstellt wurde.

CreateArticles: Migration ============================================= === -- create_table(:articles) -> 0,0019s == CreateArticles: migriert (0,0020s) =========================== ==============

Da Sie standardmäßig in der Entwicklungsumgebung arbeiten, wird dieser Befehl auf die Datenbank angewendet, die im Entwicklungsabschnitt Ihrer Datei config/database.yml definiert ist. Wenn Sie Migrationen in einer anderen Umgebung, beispielsweise der Produktion, durchführen möchten, müssen Sie dies beim Aufruf des Befehls explizit übergeben: Rails db:migrate RAILS_ENV=produktion .

5.6. Daten im Controller speichern

Zurück zum ArticlesController müssen wir die Erstellungsaktion ändern, um das neue Artikelmodell zum Speichern von Daten in der Datenbank zu verwenden. Öffnen Sie app/controllers/articles_controller.rb und ändern Sie die Erstellungsaktion so, dass sie wie folgt aussieht:

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

Hier passiert Folgendes: Jedes Rails-Modell kann mit den entsprechenden Attributen initialisiert werden, die automatisch an die entsprechenden Datenbankspalten gebunden werden. In der ersten Zeile machen wir genau das (denken Sie daran, dass params[:article] die Attribute enthält, die uns interessieren). @article.save ist dann für das Speichern des Modells in der Datenbank verantwortlich. Abschließend leiten wir den Benutzer zur Show-Aktion weiter, die wir später definieren werden.

Sie fragen sich vielleicht, warum das A in Article.new großgeschrieben wird, während alle anderen Artikellinks in diesem Handbuch großgeschrieben werden. In diesem Zusammenhang beziehen wir uns auf eine Klasse namens Article, die in app/models/article.rb definiert ist. Klassennamen in Ruby müssen mit einem Großbuchstaben beginnen.

Da nun Validierungen vorliegen, wird beim Aufruf von @article.save für einen ungültigen Artikel false zurückgegeben. Wenn Sie app/controllers/articles_controller.rb erneut öffnen, werden Sie feststellen, dass wir das Ergebnis des @article.save-Aufrufs in der Erstellungsaktion nicht überprüfen. Wenn @article.save in dieser Situation fehlschlägt, müssen wir dem Benutzer das Formular erneut anzeigen. Ersetzen Sie dazu die neuen und erstellten Aktionen in app/controllers/articles_controller.rb durch diese:

Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save restart_to @article else render "new" end end private def Article_params params.require(:article).permit(:title , :text) Ende

Die neue Aktion erstellt nun eine neue Instanzvariable namens @article , und Sie werden in ein paar Absätzen sehen, warum.

Beachten Sie, dass wir in der Erstellungsaktion „render“ anstelle von „redirect_to“ verwendet haben, wenn „save“ „false“ zurückgibt. Die Render-Methode wird verwendet, um sicherzustellen, dass das @article-Objekt beim Rendern an die neue Vorlage zurückgegeben wird. Dieses Rendern erfolgt innerhalb derselben Anfrage wie die Formularübermittlung, während „redirect_to“ den Browser anweist, eine andere Anfrage zu stellen.

5.11. Artikelaktualisierungen

Wir haben den „CR“-Teil von CRUD erweitert. Konzentrieren wir uns nun auf den „U“-Teil, die Aktualisierung von Artikeln.

Der erste Schritt besteht darin, eine Bearbeitungsaktion zum ArticlesController hinzuzufügen, normalerweise zwischen der Neu- und der Erstellungsaktion, wie gezeigt.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save restart_to @article else rendere „new“ end Ende

Die Ansicht enthält ein Formular, das dem ähnelt, das wir beim Erstellen neuer Artikel verwendet haben. Erstellen Sie eine Datei mit dem Namen app/views/articles/edit.html.erb und fügen Sie Folgendes hinzu:

Artikel bearbeiten

<%= 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 %>

Im Moment verweisen wir das Formular auf eine Aktualisierungsaktion, die noch nicht definiert wurde, aber das werden wir bald tun.

Durch die Übergabe des Artikelobjekts an die form_with-Methode wird automatisch die URL zum Senden des bearbeiteten Artikelformulars festgelegt. Diese Option teilt Rails mit, dass dieses Formular mit PATCH übermittelt werden soll, einer HTTP-Methode, die voraussichtlich für verwendet wird Aktualisierung Ressourcen gemäß dem REST-Protokoll.

Dann müssen Sie eine Update-Aktion in app/controllers/articles_controller.rb erstellen. Fügen Sie es zwischen der Erstellungsaktion und der privaten Methode hinzu:

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

Die neue Methode update wird verwendet, wenn Sie einen bereits vorhandenen Datensatz aktualisieren möchten, und benötigt einen Hash, der die Attribute enthält, die Sie aktualisieren möchten. Wie zuvor möchten wir dem Benutzer das Formular erneut anzeigen, wenn beim Aktualisieren des Artikels ein Fehler auftritt.

Wir haben die Methode „article_params“ wiederverwendet, die wir zuvor für die Aktion „Erstellen“ definiert haben.

Es ist nicht notwendig, alle Attribute an update zu übergeben. Wenn beispielsweise @article.update(title: „Ein neuer Titel“) aufgerufen wurde, aktualisiert Rails nur das Titelattribut und lässt alle anderen Attribute unberührt.

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

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

Außerdem fügen wir der Vorlage app/views/articles/show.html.erb hinzu, sodass sich der Link „Bearbeiten“ auch auf der Artikelseite befindet. Fügen Sie am Ende der Vorlage Folgendes hinzu:

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

Und so sieht unsere Bewerbung jetzt aus:

5.12. Verwenden von Teiltönen, um Wiederholungen in Ansichten zu bereinigen

Unsere Bearbeitungsseite ist der neuen Seite sehr ähnlich, tatsächlich verwenden sie denselben Code, um das Formular anzuzeigen. Entfernen wir diese Duplikate, indem wir eine Teilansicht verwenden. Konventionsgemäß beginnen Teildateien mit einem Unterstrich.

Erstellen Sie eine neue Datei app/views/articles/_form.html.erb mit folgendem Inhalt:

<%= 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 %>

Aktualisieren wir nun die Ansicht app/views/articles/new.html.erb, um diesen neuen Teil zu verwenden, indem wir ihn komplett neu schreiben:

Neuer Artikel

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

Und das Gleiche gilt für die Ansicht app/views/articles/edit.html.erb:

Artikel bearbeiten

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

5.13. Artikel löschen

Jetzt sind wir bereit, Teil „D“ von CRUD zu behandeln und aus der Datenbank zu löschen. Gemäß der REST-Konvention lautet die Route zum Entfernen von Artikeln in der Rails-Routenausgabe wie folgt:

LÖSCHEN /articles/:id(.:format) Articles#destroy

Für Routen, die Ressourcen zerstören, sollte die Lösch-Routing-Methode verwendet werden. Wenn es eine normale Get-Route bleiben würde, wäre es möglich, die folgenden schädlichen URLs zu erstellen:

Schau dir diese Katze an!

Wir verwenden die Löschmethode, um Ressourcen zu zerstören. Diese Route ist mit der Zerstörungsaktion in app/controllers/articles_controller.rb verknüpft, die noch nicht vorhanden ist. Die Destroy-Methode ist normalerweise die letzte CRUD-Aktion in einem Controller und muss wie andere öffentliche CRUD-Aktionen vor allen privaten oder geschützten Methoden platziert werden. Fügen wir es hinzu:

Def destroy @article = Article.find(params[:id]) @article.destroy restart_to Articles_path Ende

Der gesamte ArticlesController in der Datei app/controllers/articles_controller.rb sollte nun wie folgt aussehen:

Klasse 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

Sie können destroy für Active Record-Objekte aufrufen, wenn Sie diese aus der Datenbank entfernen möchten. Beachten Sie, dass wir für diese Aktion keine Ansicht hinzufügen müssen, da wir zur Indexaktion umleiten.

Auflisten von Artikeln

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

Titel	Text
<%= 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?" } %>

Hier verwenden wir link_to auf andere Weise. Wir übergeben die benannte Route als zweites Argument und die Optionen als weiteres Argument. Die Optionen „Methode: :delete“ und „Daten: (Bestätigen: „Sind Sie sicher?“) werden als HTML5-Attribute verwendet. Wenn also auf einen Link geklickt wird, zeigt Rails dem Benutzer zunächst einen Bestätigungsdialog an und sendet den Link dann mit der Methode „Löschen“. . Dies erfolgt mithilfe der JavaScript-Datei „rails-ujs“, die beim Generieren der Anwendung automatisch in das Anwendungslayout (app/views/layouts/application.html.erb) eingebunden wird. Ohne diese Datei wird der Bestätigungsdialog nicht angezeigt.

Herzlichen Glückwunsch, Sie können jetzt Artikel erstellen, alle und einzeln anzeigen, aktualisieren und zerstören.

Ein zweites Modell hinzufügen

Es ist Zeit, der Anwendung ein zweites Modell hinzuzufügen. Das zweite Modell verarbeitet Kommentare zu Artikeln.

6.1. Generieren des Modells

Wir beabsichtigen, denselben Generator zu verwenden, den wir zuvor beim Erstellen des Artikelmodells verwendet haben. Dieses Mal erstellen wir ein Kommentarmodell, das einen Link zum Artikel enthält. Führen Sie den folgenden Befehl in einem Terminal aus:

$ Rails generieren Modellkommentar kommentar:string körper:text artikel:referenzen

Dieser Befehl generiert vier Dateien:

Werfen wir zunächst einen Blick auf app/models/comment.rb:

Klassenkommentar< ApplicationRecord belongs_to:article end

Dies ist dem Artikelmodell, das wir zuvor gesehen haben, sehr ähnlich. Der Unterschied liegt in der Zeile „gehört_zu:artikel“, die festgelegt wird Verbindung Aktiver Rekord. Im nächsten Abschnitt des Leitfadens erfahren Sie mehr über Zusammenhänge.

Das im Bash-Befehl verwendete Schlüsselwort (:references) ist ein spezieller Datentyp für Modelle. Es erstellt eine neue Spalte in Ihrer Datenbank mit dem Namen des dargestellten Modells und angehängter _id, die numerische Werte enthalten kann. Analysieren Sie zum besseren Verständnis die Datei db/schema.rb nach der Migration.

Zusätzlich zum Modell hat Rails auch eine Migration durchgeführt, um die entsprechende Datenbanktabelle zu erstellen:

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

Die t.references-Zeile erstellt eine numerische Spalte namens „article_id“, einen Index dafür und eine Fremdschlüsseleinschränkung, die auf die „id“-Spalte der „articles“-Tabelle verweist. Als nächstes starten wir die Migration:

$ Schienen db:migrate

Rails ist intelligent genug, um nur Migrationen auszuführen, die noch nicht in der aktuellen Datenbank ausgeführt wurden. In unserem Fall sehen Sie Folgendes:

CreateComments: migrieren ============================================= == -- create_table(:comments) -> 0,0115s == CreateComments: migriert (0,0119s) ============================ ============

6.2. Modelle verbinden

Mithilfe von Active Record-Beziehungen können Sie ganz einfach Beziehungen zwischen zwei Modellen deklarieren. Im Falle von Kommentaren und Artikeln könnte man den Zusammenhang wie folgt beschreiben:

• Jeder Kommentar gehört zu einem Artikel.
• Ein Artikel kann viele Kommentare enthalten.

Tatsächlich kommt es der Syntax, die Rails zum Deklarieren dieser Verbindung verwendet, sehr nahe. Sie haben bereits die Codezeile im Kommentarmodell (app/models/comment.rb) gesehen, die dafür sorgt, dass jeder Kommentar zu einem Artikel gehört:

Klassenkommentar< ApplicationRecord belongs_to:article end

Sie müssen app/models/article.rb bearbeiten, um die andere Seite des Links hinzuzufügen:

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

Diese beiden Anzeigen werden automatisch zur Verfügung gestellt große Menge Gelegenheiten. Wenn Sie beispielsweise eine @article-Instanzvariable haben, die einen Artikel enthält, können Sie alle zu diesem Artikel gehörenden Kommentare in einem Array abrufen, indem Sie @article.comments aufrufen.

6.3. Hinzufügen einer Route für Kommentare

Wie beim Welcome-Controller müssen wir eine Route hinzufügen, damit Rails weiß, zu welcher Adresse wir gehen wollen, um die Kommentare zu sehen. Öffnen Sie die Datei config/routes.rb erneut und bearbeiten Sie sie wie folgt:

Ressourcen:Artikel enden. Ressourcen:Kommentare enden

Dadurch werden Kommentare wie „Gefällt mir“ erstellt verschachtelte Ressource in Artikeln. Dies ist die andere Seite der Erfassung der hierarchischen Beziehungen, die zwischen Artikeln und Kommentaren bestehen.

6.4. Generieren eines Controllers

Nachdem wir das Modell haben, richten wir unsere Aufmerksamkeit auf die Erstellung des geeigneten Controllers. Wir werden wieder denselben Generator verwenden, den wir zuvor verwendet haben:

$ Rails generieren Controller-Kommentare

Es werden vier Dateien und ein leeres Verzeichnis erstellt:

Wie bei jedem anderen Blog erstellen unsere Leser ihre Kommentare unmittelbar nach dem Lesen des Artikels. Nachdem sie einen Kommentar hinzugefügt haben, werden sie zurück zur Artikelanzeigeseite weitergeleitet und sehen, dass ihr Kommentar bereits angezeigt wurde. In diesem Zusammenhang dient unser CommentsController als Mittel zum Erstellen von Kommentaren und zum Entfernen von Spam, falls vorhanden.

Zuerst erweitern wir die Artikel-Show-Vorlage (app/views/articles/show.html.erb), damit Sie sie hinzufügen können neuer Kommentar:

Titel: <%= @article.title %>

Text: <%= @article.text %>

Einen Kommentar hinzufügen:

<%= 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 %>

Dadurch wird der Artikelanzeigeseite ein Formular hinzugefügt, das einen neuen Kommentar erstellt, wenn die Erstellungsaktion auf dem CommentsController aufgerufen wird. Hier verwendet der form_with-Aufruf ein Array, das eine verschachtelte Route wie /articles/1/comments erstellt.

Schreiben wir create in app/controllers/comments_controller.rb:

Klasse 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

Hier ist alles etwas komplizierter, als Sie es im Artikel-Controller gesehen haben. Dies ist ein Nebeneffekt des von Ihnen eingerichteten Anhangs. Bei jeder Anfrage nach einem Kommentar wird der Artikel verfolgt, an den der Kommentar angehängt ist. Daher lösen wir zunächst das Problem des Abrufens des Artikels, indem wir „find“ im Artikelmodell aufrufen.

Darüber hinaus nutzt der Code einige der für Verbindungen verfügbaren Methoden. Wir verwenden die Methode create für @article.comments, um einen Kommentar zu erstellen und zu speichern. Dadurch wird der Kommentar automatisch so verknüpft, dass er zu einem bestimmten Artikel gehört.

Sobald wir einen neuen Kommentar erstellt haben, leiten wir den Benutzer mit dem Hilfsprogramm „article_path(@article)“ zurück zum ursprünglichen Artikel. Wie wir bereits gesehen haben, ruft es die Show-Aktion auf dem ArticlesController auf, der wiederum die Vorlage show.html.erb rendert. Hier möchten wir Kommentare anzeigen, also fügen wir Folgendes zu app/views/articles/show.html.erb hinzu.

Titel: <%= @article.title %>

Text: <%= @article.text %>

Kommentare

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

Kommentator: <%= comment.commenter %>

Kommentar: <%= comment.body %>

<% end %>

Einen Kommentar hinzufügen:

<%= 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 %>

Jetzt können Sie Ihrem Blog Artikel und Kommentare hinzufügen und diese an den richtigen Stellen anzeigen.

Refactoring

Nachdem wir nun Arbeitsartikel und Kommentare haben, werfen wir einen Blick auf die Vorlage app/views/articles/show.html.erb. Es wurde lang und unangenehm. Lassen Sie uns Teiltöne verwenden, um es zu entlasten.

7.1. Rendering von Partialsammlungen

Zuerst erstellen wir einen Kommentarteil, der alle Kommentare zu einem Artikel anzeigt. Erstellen Sie eine Datei app/views/comments/_comment.html.erb und fügen Sie Folgendes ein:

Kommentator: <%= comment.commenter %>

Kommentar: <%= comment.body %>

Dann können Sie app/views/articles/show.html.erb wie folgt ändern:

Titel: <%= @article.title %>

Text: <%= @article.text %>

Kommentare

<%= render @article.comments %>

Einen Kommentar hinzufügen:

<%= 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 %>

Dadurch wird der app/views/comments/_comment.html.erb-Teil nun einmal für jeden Kommentar in der @article.comments-Sammlung gerendert. Da die Render-Methode die @article.comments-Sammlung durchläuft, weist sie jeden Kommentar einer lokalen Variablen mit dem Namen Partial zu, in diesem Fall comment , die uns im Partial zur Anzeige zur Verfügung steht.

7.2. Ein Formular teilweise rendern

Verschieben wir auch den neuen Kommentarbereich in unseren Teil. Erstellen Sie erneut eine Datei app/views/comments/_form.html.erb, die Folgendes enthä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 %>

Dann ändern Sie app/views/articles/show.html.erb wie folgt:

Titel: <%= @article.title %>

Text: <%= @article.text %>

Kommentare

<%= render @article.comments %>

Einen Kommentar hinzufügen:

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

Das zweite Rendering definiert lediglich die Teilvorlage, die wir rendern möchten, comments/form . Rails ist schlau genug, einen Unterstrich in diese Zeile einzufügen und zu verstehen, dass Sie die Datei _form.html.erb im Verzeichnis app/views/comments rendern wollten.

Das @article-Objekt ist in allen in der Ansicht gerenderten Partials verfügbar, da wir es als Instanzvariable definiert haben.

Kommentare löschen

Ein weiteres wichtiges Feature des Blogs ist die Möglichkeit, Spam zu entfernen. Dazu müssen Sie einen Link in die Ansicht und eine Zerstörungsaktion im CommentsController einfügen.

Kommentator: <%= comment.commenter %>

Kommentar: <%= comment.body %>

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

Drücken Sie dies Neuer Link„Kommentar zerstören“ führt DELETE /articles/:article_id/comments/:id in unserem CommentsController aus, der dann verwendet wird, um den Kommentar zu finden, den wir löschen möchten. Fügen wir also eine Zerstörungsaktion zu unserem Controller hinzu (app/controllers/comments_controller). .rb):

Klasse 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

Die Zerstörungsaktion findet den Artikel, den wir gerade ansehen, findet den Kommentar in der @article.comments-Sammlung, entfernt ihn dann aus der Datenbank und kehrt zur Anzeige des Artikels zurück.

8.1. Verwandte Objekte löschen

Wenn Sie einen Artikel löschen, müssen auch die damit verbundenen Kommentare gelöscht werden, da diese sonst lediglich Platz in der Datenbank belegen. Rails ermöglicht Ihnen die Verwendung der abhängigen Option für einen Link, um dies zu erreichen. Ändern Sie das Artikelmodell app/models/article.rb wie folgt:

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

Sicherheit

9.1. Basisauthentifizierung

Wenn Sie Ihren Blog online veröffentlichen, kann jeder Artikel hinzufügen, bearbeiten und löschen oder Kommentare löschen.

Rails bietet ein grundlegendes HTTP-Authentifizierungssystem, das in dieser Situation gut funktioniert.

In ArticlesController benötigen wir eine Möglichkeit, den Zugriff auf verschiedene Aktionen zu blockieren, wenn der Benutzer nicht authentifiziert ist. Hier können wir die Rails-Methode http_basic_authenticate_with verwenden, um den Zugriff auf die erforderlichen Aktionen zu ermöglichen, sofern die Methode dies zulässt.

Um das Authentifizierungssystem zu verwenden, definieren wir es oben in unserem ArticlesController in app/controllers/articles_controller.rb. In unserem Fall möchten wir, dass der Benutzer für jede Aktion außer index und show authentifiziert wird, also schreiben wir es so:

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

Wir möchten außerdem nur authentifizierten Benutzern erlauben, Kommentare zu löschen. Daher schreiben wir in CommentsController (app/controllers/comments_controller.rb) Folgendes:

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

Wenn Sie nun versuchen, einen neuen Artikel zu erstellen, werden Sie auf einen HTTP-Basisauthentifizierungsaufruf stoßen:

Für Rails-Anwendungen stehen auch andere Authentifizierungsmethoden zur Verfügung. Zwei beliebte Add-ons für Rails sind unter anderem Devise und Authlogic.

9.2. Weitere Gedanken zur Sicherheit

Sicherheit, insbesondere bei Webanwendungen, ist ein weites und detailliertes Gebiet. Die Sicherheit Ihrer Rails-Anwendung wird im Leitfaden Sicherheit von Rails-Anwendungen ausführlicher behandelt. Die einfachste Möglichkeit, mit Rails zu arbeiten, besteht darin, alle externen Daten in UTF-8 zu speichern. Wenn nicht, können die Ruby- und Rails-Bibliotheken Ihre nativen Daten häufig in UTF-8 konvertieren. Dies funktioniert jedoch nicht immer zuverlässig. Stellen Sie daher am besten sicher, dass alle externen Daten UTF-8 sind.

Wenn Sie in diesem Bereich einen Fehler machen, ist das häufigste Symptom, dass im Browser eine schwarze Raute mit einem Fragezeichen darin erscheint. Ein weiteres häufiges Symptom ist das Erscheinen von Symbolen wie „ü“ anstelle von „ü“. Rails ergreift eine Reihe interner Schritte, um häufige Probleme zu entschärfen, die automatisch erkannt und behoben werden können. Wenn jedoch externe Daten vorhanden sind, die nicht in UTF-8 gespeichert sind, kann dies zu solchen Problemen führen, die Rails nicht automatisch erkennen und beheben kann.

Die beiden häufigsten Datenquellen, die nicht in UTF-8 vorliegen, sind:

• Dein Texteditor: Die meisten Texteditoren (wie TextMate) speichern Dateien standardmäßig im UTF-8-Format. Wenn Ihr Texteditor dies nicht tut, kann es dazu führen, dass in Ihren Mustern eingegebene Sonderzeichen (z. B. é) im Browser als Raute mit einem Fragezeichen angezeigt werden. Dies gilt auch für Ihre i18N-Übersetzungsdateien. Die meisten Editoren, die UTF-8 nicht standardmäßig verwenden (z. B. einige Versionen von Dreamweaver), bieten eine Möglichkeit, die Standardeinstellung auf UTF-8 zu ändern. Mach das.
• Ihre Datenbank: Rails konvertiert standardmäßig Daten aus Ihrer Datenbank am Edge in UTF-8. Wenn Ihre Datenbank jedoch intern nicht UTF-8 verwendet, kann sie möglicherweise nicht alle Zeichen speichern, die Ihr Benutzer eingeben wird. Wenn Ihre Datenbank beispielsweise intern Latin-1 verwendet und Ihr Benutzer russische, hebräische oder japanische Zeichen eingibt, gehen die Daten verloren, sobald sie in die Datenbank eingegeben werden. Verwenden Sie nach Möglichkeit UTF-8 als internen Speicher in Ihrer Datenbank.

Der Autor wurde zum Verfassen dieses Textes angeregt, indem er eine Reihe von Materialien im Global Network studierte, die leicht unter derselben Überschrift/dem gleichen Tag zusammengefasst werden könnten: Wie ich Ruby gelernt habe(oder Ruby on Rails, PHP, JS, C++ usw.) drei Tage lang.

Oder etwas ähnliches. Der Autor wiederum erinnerte sich sofort (unkontrollierbare Assoziationen) an eine Reihe von Anekdoten, die wiederum durch ein gemeinsames Thema vereint waren, das in der bewertenden Charakterisierung von Handlungen besteht, die dumm ausgeführt werden können... Die russische Sprache ist kraftvoll und unglaublich aphoristisch, aber Leider scheint es nicht möglich, diese Meisterwerke hier zu zitieren; Es bleibt also nichts anderes übrig, als dem Leser eine persönlich verfasste Version des Dokuments aus der Serie zur Verfügung zu stellen Wie man mit Freude und relativ schnell lernt, mit Ruby on Rails zu arbeiten.

Ein funktionierendes Beispiel des im Artikel beschriebenen Codes finden Sie neben anderen Rails-Beispielen immer im Testblog des Autors auf herokuapp.com, herzlich willkommen.

Die Technik ist einfach, und der Autor beansprucht hier keineswegs die Lorbeeren eines Entdeckers: Es muss interessant sein, und die Ergebnisse werden nicht lange auf sich warten lassen. Es schadet nicht, die eigenen Schwächen auszunutzen, denn manchmal kann Eitelkeit der Sache zugute kommen; Die Ergebnisse der Entwicklung sollten so sein, dass sie stolz den Lesern, Freunden und Kollegen im Internet präsentiert und irgendwo eingesetzt werden können Heroku oder Amazonas Außerdem helfen uns Foren und StackOwerflow dabei, immer wieder auf sie zurückzukommen, sie neu aufzubauen und zu verbessern. Also sage ich, warum schreiben Sie nicht zuerst Ihren Blog? Ruby auf Schienen?

Ich schlage vor, mit der ausgezeichneten Broschüre „Erste Schritte mit Rails“ oder der russischsprachigen Adaption von Rails für Anfänger zu beginnen, auch „Build a Blog with Ruby on Rails“ und die Materialien dieses Blogs, zu denen Links in der linken Seitenleiste leicht zu finden sind auch helfen. Und dann - das ist alles, dann Zauberei, zunächst wird alles wie in Notizen angeordnet, Konsole auf - und weiter... Der Autor sieht es als seine Pflicht an, nur ein paar Erklärungen und technische Empfehlungen zu geben, die es einfacher machen sollen der Adept, der die helle Seite der Macht finden und erwerben muss, und nicht mehr Togo. Dies ist nur Ihr Kampf. Gehen Sie mutig voran und kehren Siegreich zurück.

Also. Die Schritt-für-Schritt-Anleitung des ersten Handbuchs ist perfekt abgestimmt und wird Ihnen hoffentlich keine Probleme bereiten; Sie müssen lediglich aufmerksam sein und die einzelnen Schritte gewissenhaft wiederholen ... und nach einer Stunde ist Ihr erster Blog fertig, Sie können eine Pause einlegen und mit dem zweiten, etwas interessanteren Blog fortfahren. Und hier könnten vielleicht ein paar abschließende Ratschläge nützlich sein, mit denen wir jetzt fortfahren.

Beginnen wir mit der Aussage, dass diese Methoden (als Option) durchaus in der Lage sind, wie das unten Gezeigte auszusehen, aber in keiner Weise mit dem Original identisch sind:

app/controllers/posts_controller.rb

# Update-Aktion aktualisiert den Beitrag mit den neuen Informationen def update if @post.update_attributes(post_params) flash[:notice] = „Beitrag erfolgreich aktualisiert!“ Redirect_to posts_path else flash[:alert] = „Fehler beim Aktualisieren des Beitrags!“ render:edit end end # Die Show-Aktion rendert den einzelnen Beitrag nach dem Abrufen der ID. def show end # Die Destroy-Aktion entfernt den Beitrag dauerhaft aus der Datenbank. Def destroy @post = Post.find(params[:id]) if @post . destroy flash[:notice] = „Beitrag erfolgreich gelöscht!“ Redirect_to posts_path else flash[:alert] = „Fehler beim Aktualisieren des Beitrags!“ Ende Ende

Aber versuchen Sie dies und das, warum nicht. Lass uns weitermachen.

Zweiter Blog, wenn auch komplexer (Artikeleditor hinzugefügt). CKEditor Und entwickeln, ein flexibles Tool zur Authentifizierung in Rails-Anwendungen), fehlt aus irgendeinem Grund die Möglichkeit, Kommentare im Original zu hinterlassen. Diesen Mangel müssen Sie selbst beheben: Gehen Sie analog zur Beschreibung zur Erstellung des ersten Blogs vor, es sind nur sehr geringfügige Änderungen erforderlich: einfach gesagt, statt Artikel Und Artikel Du wirst den ersten Blog haben Post Und Beiträge Im zweiten Blog ist das im Grunde der Unterschied. Seien Sie vorsichtig und alles wird gut.

ReCaptcha Sie müssen auch selbst auf Kommentare verlinken: Ja, ja, das ist nicht Joomla für Sie, gewöhnen Sie sich daran. Der Verbindungsprozess erfordert jedoch keine gigantischen Anstrengungen ReCaptcha wird ausführlich im Artikel Recaptcha in der Rails-Anwendung verbinden beschrieben. Als nächstes ist es nicht überflüssig, sich anzupassen entwickeln und zwar so, dass der Blog (zumindest zunächst!) im Einzelbenutzermodus funktioniert und vielen seiner Leser den READ-NUR-Modus ermöglicht, d. h. wir werden die Registrierung neuer Benutzer zunächst untersagen. Es gibt im Internet eine ganze Reihe verschiedener Rezepte, wie man das macht, aber meiner Meinung nach ist der kompetenteste Hack dieser Art in Wiki devise zu finden, in dem Material mit dem Titel „How To: Set up devise as a single user system“. Nämlich: Wir erstellen einen neuen Controller:

app/controllers/registrations_controller.rb:

Klassenregistrierungscontroller< 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

dann überschreiben wir es in Routes.rb, und das war's:

#devise_for:admins devise_for:admins, Controller: ( Registrierungen: „Registrierungen“)

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

Vollständig config.enterMode = CKEDITOR.ENTER_BR // Drücken der Eingabetaste
config.shiftEnterMode = CKEDITOR.ENTER_P; //Drücken der Eingabetaste SHIFT + ENTER KEYS

Config.autoParagraph = false; // stoppt das automatische Einfügen von

Im Fokus);

Vielleicht ist das für den Anfang wirklich alles ... verdammt, ich hätte fast das Wichtigste vergessen. Wenn Sie Ihr neues Blog bereitstellen möchten Heroku- Fügen Sie diese drei Zeilen hinzu

config/application.rb

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

Ansonsten CKEditor wird sich weigern, an Ihrem neuen Arbeitsplatz für Sie zu arbeiten.

Ruby ist eine leistungsstarke und beliebte Programmiersprache. Neben seiner Beliebtheit ist es die Grundlage für ein bekanntes Framework, mit dem Sie coole und dynamische Websites zu verschiedenen Themen erstellen können. Schaut man sich das TIOBE-Rating an, gehört die Sprache zu den zwanzig beliebtesten Sprachen der Welt.

Die Sprache erschien 1995 und gilt im Vergleich zu C bzw. C++, die 1972 bzw. 1983 erschienen, als junge Sprache. Die Sprache verfügt im Vergleich zu anderen gängigen Programmiersprachen über eine Reihe von Vorteilen und spezifischen Funktionen, die ausschließlich in ihr implementiert sind.

Kursplan

Während des Videokurses lernen Sie die Ruby-Sprache, ohne zusätzliche Frameworks zu verwenden. Zusätzliche Kurse auf Rubin Sie finden es unter .

Während des Kurses lernen wir, wie man die Sprache installiert und damit arbeitet, wir lernen die Syntax Rubin(Variablen, Schleifen, bedingte Anweisungen) sowie komplexere Dinge: OOP, Arbeiten mit Dateien, Ausnahmen, Methoden und wir werden auf viele andere Themen eingehen.

Ruby unter Windows installieren

Um Ruby unter Windows zu installieren, verwenden Sie RubyInstaller, das über diesen Link von der offiziellen Website heruntergeladen werden kann. Herunterladen letzte Version und installieren Sie es wie ein normales Programm. Nachdem die Installation abgeschlossen ist, sehen Sie ein ähnliches Fenster:

Stellen Sie sicher, dass in diesem Fenster das Kontrollkästchen aktiviert ist. Dann wird eine andere Anwendung zur Installation geöffnet. Rubin in das System ein.

Geben Sie im sich öffnenden Fenster nacheinander 1 ein und drücken Sie die Eingabetaste, warten Sie, bis die Installation abgeschlossen ist, drücken Sie 2 und die Eingabetaste und führen Sie am Ende den dritten Befehl aus, indem Sie 3 und die Eingabetaste drücken.

Ruby auf dem Mac installieren

Auf einem Mac ist Ruby standardmäßig installiert, Sie müssen also nichts weiter tun. Sie können die Sprachversion im Terminal mit dem folgenden Befehl überprüfen:

Wenn die Version veraltet ist, können Sie eine neue herunterladen. Zuerst müssen Sie den Ruby-Versionsmanager herunterladen. Dies geschieht über das Terminal mit dem Befehl:

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

Nach der Installation des Managers müssen Sie das Terminal neu starten. Führen Sie den folgenden Befehl aus:

RVM-Liste bekannt

Nach dem Neustart können Sie die gewünschte Version installieren. In unserem Fall wurde Version 2.4.2 installiert:

RVM installiert Ruby-2.4.2

Am Ende können Sie die Version noch einmal überprüfen und wenn sie noch alt ist, dann installieren Sie einfach die neue Version standardmäßig.

Eines der ersten und ausführlichsten Rails-Trainingsbücher im Internet. Der Hauptvorteil ist die detaillierte Abdeckung der wichtigsten Themen, regelmäßige Updates und kostenlose Basisinhalte.

Die Ressource ist zwar vollständig auf Englisch. Und es ist wichtig zu verstehen, dass dies in Form eines Buches aufgebaut ist – Sie müssen alle Probleme selbst herausfinden. Aus diesem Grund können Dauer und Komplexität der Ausbildung nicht vorhergesagt werden.

2. Railcasts

Eine weitere bekannte Bildungsressource im Internet. Mehr als eine Generation von Rails-Entwicklern ist damit aufgewachsen. Auch auf Englisch.

Es ist nicht als vollständiger Schulungskurs konzipiert, sondern als eine Reihe von Screencasts – kurze Lektionen zu einem bestimmten Thema. Es gibt viele Lektionen, die man zu fast jedem Thema finden kann.

Leider wurde die Aktualisierung des Projekts im Jahr 2013 eingestellt.

3. Schienen für Zombies

Eine unterhaltsame Einführung in das Thema On-Rails für Anfänger im Questspielstil mit Zombie-Atmosphäre. Sehr beliebt bei absoluten Anfängern.

Dies ist praktisch, da Sie nichts auf Ihrem Computer installieren müssen. Alle Probleme werden im Browser gelöst. Schritt für Schritt gehen Sie durch das Spiel und beginnen, die Grundlagen von Ruby on Rails zu verstehen.

Wenn Sie überhaupt keine Programmierkenntnisse haben, ist dies Ihre Wahl. Es gibt keine komplexen Themen im Kurs, nichts lenkt von den Grundlagen ab. Auf Englisch.

3.Udemy

Große Sammlung von Videokursen. Darunter sind viele für Ruby und Ruby on Rails. Es macht keinen Sinn, bestimmte Links bereitzustellen – wählen Sie nach Ihrem Geschmack, basierend auf Preis oder Beliebtheit.

Das Udemy-Format umfasst relativ kurze Kurse mit Schwerpunkt auf Videolektionen. Erwarten Sie keine ernsthaften Hausaufgaben oder schnelle Unterstützung von den Lehrern.

4. Ruby Bursa

Ein leistungsstarker Kurzkurs über die Grundlagen der Rails-Entwicklung. Erfahrene Lehrer, gutes Programm.

Die persönliche Anwesenheit des Studierenden beim Kurs ist erwünscht und dieser findet nur in großen ukrainischen Städten statt.

5. Entwicklung in Ruby on Rails von Evil Martians

Ein dreitägiger Intensivkurs von einem der erfahrensten Ruby on Rails-Teams in Russland.

Selten gemacht. Es ist teuer (den Bewertungen nach zu urteilen, es lohnt sich). Erfordert persönliche Anwesenheit. Nur für fortgeschrittene Programmierer geeignet; Anfänger haben dort nichts zu tun.

6. Ruby on Rails Online-Intensivkurs von „A Good Programmer“

Ein frisches Projekt von einem Team, das auf YouTube für seine Ruby-Kurse für Anfänger bekannt ist.

Das dreimonatige Intensivprogramm richtet sich an absolute Anfänger und verspricht, Sie mit einem Portfolio von nicht weniger als 12 intelligenten Anwendungen zu einem Junior-Programmierer zu machen.

Der Kurs besteht aus Videolektionen, praktischen Aufgaben, Lehrerunterstützung und regelmäßigen Webinaren.

Gemessen an Youtube Kanal und Benutzerkommentare – diese Jungs wissen, was sie tun, und Sie werden sich mit ihnen nicht langweilen.

Der größte Vorteil eines jeden Webdesigners besteht darin, zu verstehen und sogar zu organisieren, was hinter den Kulissen vor sich geht.

Zumindest sollten Sie einige Programmierstunden nehmen. Ich spreche nicht von Frontend-Sprachen wie HTML und CSS – Sie wissen wahrscheinlich schon viel davon. Ich spreche von Back-End-Dingen.

Wenn Sie wissen, wie man den Grundstein legt, können Sie besser verstehen, wie der Rest der Website gestaltet wird. Der Punkt ist, dass Sie durch das Erlernen des Programmierens zu einem gebildeteren Designer werden. Und wer würde nicht gerne einen Designer engagieren, der sich vom Design bis zur Website-Entwicklung mit allem auskennt?

Der Trick besteht darin, zu entscheiden, wo man anfangen soll. Das Erlernen des Programmierens kann ein herausfordernder Prozess sein, insbesondere wenn Sie sich für eines der häufigsten Programme entscheiden komplexe Sprachen wie C++ oder PHP.

Wo fängt man also am besten an? Es gibt nur eine Antwort: Ruby on Rails ist eine der besten Programmiersprachen und Frameworks zum Erlernen der Grundlagen des Designs.

Warum ist Ruby die beste Wahl?

Für Anfänger ist Ruby eines der beliebtesten einfache Sprachen zum Verdauen, insbesondere wenn Sie etwas Erfahrung im Schreiben von HTML oder CSS haben, was die meisten Designer tun.

Eines der ersten Programme, die Sie ausführen, wenn Sie mit dem Erlernen einer Sprache beginnen, ist das berüchtigte „Hello World!“, bei dem diese Wörter auf dem Bildschirm gedruckt werden.

Bei Sprachen wie C++ kann es zwischen fünf und sieben Codezeilen geben, nur um diese beiden Wörter anzuzeigen. Wenn Sie jedoch Ruby verwenden, gibt es nur eine Zeile und einen Befehl.

Setzt „Hallo, Welt!“

Das ist alles! Das ist alles, was Sie brauchen, um die Worte „Hallo Welt!“ einzugeben. auf dem Bildschirm. Ziemlich einfach, oder?

Ruby on Rails ist ebenfalls eine sehr trockene Sprache. Als eines der Entwicklungsprinzipien steht DRY für „Don't Repeat Yourself“ – das heißt, programmieren Sie kein Element erneut, wenn Sie ein bereits erstelltes Element verwenden könnten. Dies macht Ruby zu einer sehr einfachen und häufig verwendeten Programmiersprache für die Entwicklung, da sie darauf abzielt, ein Projekt schnell und effizient abzuschließen.

Ruby oder Rails?

Ruby ist eine Programmiersprache. Rails ist ein Framework, das Ruby verwendet, um die Arbeit zu erledigen. Das Ruby on Rails-Framework ist eine Sammlung vorgefertigten oder vorab geschriebenen Codes, der dazu beiträgt, den Prozess der Erstellung neuer Projekte zu beschleunigen. Ursprünglich wurde es gegründet, um das Projektmanagement-Tool Basecamp zu entwickeln. Neben Basecamp gibt es weitere beliebte Webanwendungen, die mit Rails erstellt wurden, wie 500px, ThemeForest und MyFitnessPal.

Sobald Sie wissen, wie Sie mit der Ruby-Sprache arbeiten und die Dinge im Ruby On Rails-Framework zum Laufen bringen, können Sie mit der Erstellung von Webanwendungen beginnen.

Ruby ist auf dem Höhepunkt seiner Popularität!

Dank der Explosion der Popularität mobile Geräte und Technologie, die immer vernetzt ist, ist Ruby mittlerweile unglaublich beliebt. Und das wird wohl auch weiterhin so bleiben. Der TIOBE-Index stuft Ruby auf Platz 13 der beliebtesten Programmiersprachen ein. Passend zu den aufkommenden Trends verzeichnet Ruby laut Indeed.com auch eine überraschend hohe Nachfrage.

TIOBE-Index

Unabhängig davon, ob Nachfrage oder Beliebtheit, Ruby ist sehr beliebt. Das macht ihn zu einem der beste Orte Zunächst einmal, denn wenn man die Sprache erst einmal beherrscht, kann man ziemlich schnell einen Job bekommen. Und das, bevor Sie anfangen, eine andere Sprache zu lernen, um Ihre Fähigkeiten zu erweitern.

Ruby hat ein solides Fundament!

Einige der anderen Sprachen gibt es zwar häufiger, aber dennoch verblassen die Unterstützung und Dokumentation im Vergleich zu dem, was für Ruby verfügbar ist. Auch anderen Sprachen mangelt es an gemeinschaftlichem Zusammenhalt rund um ein stark unterstütztes Framework.

Dank des Ruby On Rails-Frameworks gibt es bereits jede Menge bereits vorhandenen Code, den Sie in Ihren eigenen Projekten verwenden können. Ruby Gems, eine Bibliothek von Ruby-Frameworks, bietet über 600.000 Bibliotheken zur Auswahl.

Jedes Mal, wenn Sie etwas Neues lernen, benötigen Sie viel Dokumentation und Unterstützung. Es gibt unzählige Orte, an denen Sie Lernmaterialien, Tutorials, Leitfäden und sogar Frage-und-Antwort-Foren finden können. Wenn Sie auf ein bestimmtes Problem stoßen, lässt sich das Problem wahrscheinlich durch eine einfache Websuche beheben. Es ist wichtig.

Eine einfache Dokumentation und ein einfacher Zugang zur Unterstützung sind unerlässlich, wenn Sie eine neue Sprache lernen – wenn Sie tatsächlich etwas Neues lernen.

Ruby „ermöglicht“ mehr Kontrolle über das Design

Wenn Sie nur ein Webdesigner sind, kann die Erstellung einer Website ein langer und komplizierter Prozess sein. Wenn Sie sich mit einem Programmierer zusammensetzen und das erforderliche Back-End für Ihre Website besprechen, müssen Sie oft auf das Front-End verzichten, damit alles richtig funktioniert.

Letztendlich kann dies dazu führen, dass ein Produkt völlig anders aussieht, als Sie es sich ursprünglich vorgestellt haben. Dem Programmierer ist es vielleicht egal, aber für Sie wird es wahrscheinlich problematisch sein.

Wenn Sie die Programmierung selbst durchführen, werden Sie nicht auf solche Probleme stoßen. Sie müssen sich nicht unbedingt auf andere verlassen, um ein Projekt fertigzustellen, und Sie haben ein viel besseres Verständnis dafür, was aus Entwicklungsperspektive erreicht werden kann. Sicherlich gab es ein oder zwei Zeiten, in denen die Ziele Ihres Projekts für einen Programmierer oder ein Entwicklungsteam zu hoch waren? Wenn Sie eine Sprache wie Ruby lernen, können Sie einerseits die Leichtigkeit des Verständnisses der Anforderungen und andererseits die Fähigkeiten genießen.

Ruby ist im Wesentlichen für den Einsatz in Webanwendungen und Webentwicklung konzipiert und somit ein idealer Ort für angehende Webdesigner. Sobald Sie die Sprache verstehen und lernen, das Ruby on Rails-Framework zu verwenden, haben Sie viel mehr Kontrolle über Ihre Projekte.

Wo kann man Ruby lernen?

Am meisten Der beste Weg Eine Sprache zu lernen bedeutet, in sie einzutauchen und damit zu arbeiten. Es gibt auch viele Anleitungen und Tutorials, auf die Sie zurückgreifen können. Wenn Sie ein starkes visuelles Gedächtnis haben und durch visuelle Präsentationen besser verstehen, dann besuchen Sie YouTube – dort gibt es eine große Auswahl an Lehrvideos.

Wenn Sie eine traditionelle Schulung im Klassenzimmer wünschen, können Sie eine Schulung auf speziellen Programmierwebsites absolvieren. Für eine Berufsausbildung ist es nicht notwendig, eine Universität oder Hochschule zu besuchen.

Eine meiner Lieblingsressourcen – und völlig kostenlos – zum Erlernen von Rails ist Michael Hartles Rails-Tutorial. Es führt Sie in Ihrem eigenen Lerntempo von einfachen zu komplexen Projekten und Sie können ganz von vorne beginnen, ohne jegliche Kenntnisse von Ruby on Rails.

Egal für welchen Lernweg Sie sich entscheiden, denken Sie daran: Übung macht den Meister. Setzen Sie sich persönliche Ziele, um jeden Tag eine bestimmte Zeit mit Ruby zu verbringen. Halten Sie an diesen Zielen fest und seien Sie beharrlich. Bevor Sie die Sprache vollständig verstehen, sind Sie bereits ein Experte, der fantastische Projekte erstellen kann.