Panduan ini mencakup menginstal dan menjalankan Ruby on Rails.

Setelah membacanya, Anda akan tahu:

• Cara menginstal Rails, membuat aplikasi Rails baru, dan menghubungkan aplikasi Anda ke database.
• Struktur umum aplikasi Rails.
• Prinsip dasar MVC (Model, View Controller - "Model-View-Controller") dan desain berdasarkan RESTful.
• Cara cepat menghasilkan kode aplikasi Rails awal.

Asumsi dalam panduan ini

Panduan ini untuk pemula yang ingin memulai aplikasi Rails dari awal. Itu tidak mengasumsikan bahwa Anda telah bekerja dengan Rails sebelumnya.

Rails adalah framework pengembangan web yang ditulis dalam bahasa pemrograman Ruby. Jika Anda tidak memiliki pengalaman Ruby, Anda mungkin akan kesulitan untuk langsung mulai mempelajari Rails. Ada beberapa sumber daya berbahasa Inggris yang didedikasikan untuk mempelajari Ruby, misalnya:

Perhatikan bahwa beberapa sumber daya, meski masih bagus, masih mencakup versi lama Ruby seperti 1.6 dan 1.8 khususnya, dan tidak menyertakan beberapa sintaks yang akan Anda lihat dalam pengembangan Rails sehari-hari.

Apa itu Rel?

Rails adalah framework pengembangan web yang ditulis dalam bahasa pemrograman Ruby. Ini dirancang untuk membuat pemrograman aplikasi web lebih mudah dengan membuat sejumlah asumsi tentang apa yang dibutuhkan setiap pengembang untuk membuat proyek baru. Ini memungkinkan Anda menulis lebih sedikit kode saat memprogram dibandingkan dengan bahasa dan kerangka kerja lain. Pengembang profesional di Rails juga mencatat bahwa pengembangan aplikasi web menjadi lebih menyenangkan =)

Rails adalah perangkat lunak yang luar biasa. Itu membuat asumsi bahwa ada cara "terbaik" untuk melakukan sesuatu, dan dirancang untuk mendorong cara itu - dan dalam beberapa kasus bahkan mencegah alternatif. Jika Anda mempelajari "The Rails Way", Anda mungkin menemukan peningkatan produktivitas yang signifikan dalam diri Anda. Jika Anda bertahan dan membawa kebiasaan lama dari bahasa lain ke dalam pengembangan Rails dan mencoba menggunakan pola yang dipelajari di tempat lain, pengalaman pengembangan Anda akan kurang menyenangkan.

Filosofi Rails mencakup dua prinsip panduan penting:

• Jangan Ulangi Diri Anda Sendiri: KERING adalah prinsip rekayasa perangkat lunak yang menyatakan bahwa "Setiap bagian informasi harus memiliki representasi otoritatif tunggal, non-redundan, dalam sistem." Jangan menulis informasi yang sama berulang kali, kode akan lebih mudah dipelihara dan lebih dapat diperluas serta tidak banyak bug.
• Konvensi Atas Konfigurasi: Rails memiliki pendapat tentang cara terbaik untuk melakukan banyak hal dalam aplikasi web, dan default ke konvensi ini alih-alih memaksa Anda untuk menyempurnakan beberapa file konfigurasi.

Membuat Proyek Rails Baru

Cara terbaik untuk menggunakan panduan ini adalah melaluinya langkah demi langkah. Semua langkah penting untuk menjalankan aplikasi contoh, dan tidak diperlukan kode atau langkah tambahan.

Dengan mengikuti tutorial ini, Anda akan membuat proyek Rails bernama blog , sebuah blog web yang sangat sederhana. Sebelum kita mulai membuat aplikasi, kita perlu memastikan bahwa Rails sendiri sudah terinstal.

Contoh berikut menggunakan $ untuk menunjukkan jalur input terminal seperti UNIX sistem operasi ah, meskipun bisa dikonfigurasi secara berbeda. Jika menggunakan Windows, baris tersebut akan terlihat seperti c:\source_code>

3.1. Memasang Rel

Sebelum menginstal Rails, Anda perlu memastikan bahwa Anda telah menginstal prasyarat yang diperlukan di sistem Anda. Ini termasuk Ruby dan SQLite3.

Buka aplikasi untuk garis komando. Di macOS buka Terminal.app, di Windows pilih "Run" dari menu Start dan ketik "cmd.exe". Setiap perintah yang dimulai dengan tanda dolar $ harus dijalankan pada baris perintah. Pastikan Anda menginstal versi Ruby saat ini:

$ ruby ​​\u200b\u200b-v ruby ​​​​2.5.0

Rails membutuhkan Ruby versi 2.5.0 atau yang lebih baru untuk diinstal. Jika nomor versi kurang dari ini, Anda perlu memasang salinan baru Ruby.

Untuk menginstal Ruby dan Ruby on Rails dengan cepat di sistem Anda, pengguna Windows dapat menggunakan Rails Installer . Metode instalasi tambahan untuk sebagian besar sistem operasi dapat dilihat di ruby-lang.org.

Jika Anda menggunakan Windows, Anda harus memasang Ruby Installer Development Kit .

Anda juga perlu menginstal database SQLite3.

Banyak sistem operasi mirip UNIX yang populer dikirimkan dengan versi SQLite3 yang dapat diterima. Di Windows, jika Anda menginstal Rails menggunakan Rails Installer, Anda sudah menginstal SQLite. Pengguna lain dapat merujuk ke petunjuk penginstalan di situs SQLite3. Periksa apakah sudah terpasang dengan benar dan di PATH Anda:

$ sqlite3 --versi

Program harus melaporkan versinya.

Untuk menginstal Rails, gunakan perintah gem install yang disediakan oleh RubyGems:

rel pemasangan $ permata

Untuk memeriksa apakah semuanya sudah terpasang dengan benar, Anda perlu melakukan hal berikut:

$ rel --versi

Jika sesuatu seperti "Rails 6.0.0" ditampilkan, Anda dapat melanjutkan.

3.2. Membuat Aplikasi Blog

Rails hadir dengan sejumlah skrip, yang disebut generator, yang dirancang untuk membuat hidup pengembang lebih mudah dengan membuat semua yang mereka perlukan untuk memulai tugas tertentu. Salah satunya adalah generator aplikasi baru, yang memberi Anda dasar aplikasi Rails sehingga Anda tidak perlu menulisnya sendiri.

Untuk menggunakan generator ini, buka terminal, navigasikan ke folder tempat Anda memiliki izin untuk membuat file, dan tulis:

$ rel blog baru

Ini akan membuat aplikasi Rails bernama Blog di direktori blog dan menginstal permata yang dependensinya disebutkan di Gemfile saat menggunakan bundle install .

Pada menggunakan Windows Subsistem untuk Linux, ada beberapa batasan pada pesan berkas sistem untuk menonaktifkan permata musim semi dan mendengarkan, yang dapat dilakukan dengan menjalankan Rails new blog --skip-spring --skip-listen .

Anda dapat melihat semua kemungkinan opsi baris perintah yang diterima oleh pembuat aplikasi Rails dengan menjalankan Rails new -h .

Setelah Anda membuat aplikasi blog, navigasikan ke foldernya:

Direktori blog berisi beberapa file dan folder yang dibuat secara otomatis yang menentukan struktur aplikasi Rails. Sebagian besar pekerjaan dalam tutorial ini akan dilakukan di folder app, tetapi untuk saat ini, mari kita jalankan melalui fungsi dari setiap folder yang dibuat Rails di app default baru:

Berkas/Folder	Tujuan
aplikasi/	Berisi pengontrol, model, tampilan, pembantu, mailer, saluran, pekerjaan, dan aset aplikasi Anda. Kami akan melihat folder ini lebih terinci nanti.
tempat sampah/	Berisi skrip Rails yang memulai aplikasi Anda, dan direktori juga dapat berisi skrip lain yang Anda gunakan untuk mengonfigurasi, memperbarui, menerapkan, atau menjalankan.
konfigurasi/	Konfigurasi rute, database aplikasi Anda, dll. Ini dibahas lebih rinci dalam Mengonfigurasi Aplikasi Rails.
config.ru	Konfigurasi rak untuk server berbasis rak yang digunakan untuk menjalankan aplikasi. Untuk informasi lebih lanjut tentang Rack, lihat situs web Rack.
db/	Berisi skema database Anda saat ini serta migrasi database.
gemfile Gemfile.lock	File-file ini memungkinkan Anda menentukan dependensi permata mana yang dibutuhkan aplikasi Rails Anda. File-file ini digunakan oleh permata Bundler. Untuk informasi lebih lanjut tentang Bundler, lihat situs Bundler.
lib/	Modul eksternal untuk aplikasi Anda.
catatan/	File log aplikasi.
package.json	File ini memungkinkan Anda menentukan dependensi npm mana yang diperlukan untuk aplikasi Rails Anda. File ini digunakan oleh Yarn. Untuk informasi lebih lanjut tentang Yarn, lihat situs web Yarn.
publik/	Satu-satunya folder yang dapat diakses secara eksternal apa adanya. Berisi file statis dan aset yang dikompilasi.
Rakefile	File ini menemukan dan memuat tugas yang dapat dijalankan pada baris perintah. Tugas yang ditentukan tersedia di semua komponen Rails. Alih-alih mengubah Rakefile , Anda dapat menambahkan tugas Anda sendiri dengan menambahkan file ke direktori lib/tasks aplikasi.
README.md	Ini adalah panduan pengantar untuk aplikasi Anda. Itu harus diedit untuk memberi tahu orang lain apa yang dilakukan aplikasi Anda, cara menyiapkannya, dan sebagainya.
penyimpanan/	File Penyimpanan Aktif untuk layanan Disk. Ini tercakup dalam panduan Ikhtisar Penyimpanan Aktif.
tes/	Tes unit, perlengkapan dan peralatan pengujian lainnya. Ini tercakup dalam panduan Aplikasi Pengujian Rel.
tmp/	File sementara (seperti file cache dan pid)
penjaja/	Tempat untuk kode pihak ketiga. Dalam aplikasi Rails biasa, itu termasuk permata eksternal.
.gitignore	File ini memberi tahu git file mana (eksplisit atau wildcard) yang harus diabaikan. Lihat GitHub - Mengabaikan file untuk informasi selengkapnya tentang mengabaikan file.
.ruby-versi	File ini berisi versi default Ruby.

Halo Rel!

Pertama, mari kita tampilkan beberapa teks di layar. Ini membutuhkan server yang berjalan untuk aplikasi Rails Anda.

4.1. Memulai server web

Sebenarnya, Anda sudah memiliki aplikasi Rails yang berfungsi. Yang pasti, Anda perlu menjalankan server web di mesin Anda. Ini dapat dilakukan dengan menjalankan perintah berikut dari direktori blog:

Jika Anda menggunakan Windows, Anda harus meneruskan skrip dari folder bin langsung ke juru bahasa Ruby, yaitu server ruby ​​​​bin\rails .

Mengompresi aset JavaScript memerlukan lingkungan runtime JavaScript di sistem Anda, dan ketidakhadirannya akan mengakibatkan kesalahan eksekusi selama kompresi aset. Biasanya, macOS dan Windows dilengkapi dengan runtime JavaScript yang diinstal. therubyrhino adalah runtime yang direkomendasikan untuk pengguna JRuby dan ditambahkan ke Gemfile jika aplikasi dibuat untuk JRuby. Anda dapat mempelajari semua tentang runtime yang didukung di ExecJS

Ini akan memulai Puma, server web yang didistribusikan dengan Rails secara default. Untuk melihat aplikasi beraksi, buka jendela browser dan arahkan ke http://localhost:3000 . Anda akan melihat halaman info Rails default:

Untuk menghentikan server web, tekan Ctrl+C di terminal tempatnya berjalan. Untuk memverifikasi bahwa server telah dihentikan, Anda akan melihat kursor baris perintah lagi. Untuk sebagian besar sistem mirip UNIX, termasuk macOS, ini akan menjadi tanda dolar $ . Dalam mode pengembangan, Rails umumnya tidak mengharuskan Anda menghentikan server; semua perubahan yang Anda buat pada file secara otomatis diambil oleh server.

Halaman "Welcome Aboard" seperti tes untuk aplikasi Rails baru: halaman ini menunjukkan bahwa program Anda telah diatur dengan cukup baik untuk menampilkan halaman tersebut.

4.2. Katakan halo, Rails

Agar Rails mengatakan "Hai", Anda harus membuat setidaknya pengontrol dan melihat(perwakilan).

Tujuan dari pengontrol adalah untuk menerima permintaan khusus ke suatu aplikasi. Rute memutuskan pengontrol mana yang akan menerima permintaan mana. Seringkali ada lebih dari satu rute untuk setiap pengontrol, dan rute yang berbeda dapat ditangani secara berbeda. game aksi. Tujuan dari setiap tindakan adalah mengumpulkan informasi untuk memberikannya ke tampilan.

Tujuan dari tampilan adalah untuk menampilkan informasi ini dalam format yang dapat dibaca manusia. Perbedaan penting yang harus dibuat adalah tempat di mana informasi dikumpulkan pengontrol, bukan pemandangan. Tampilan seharusnya hanya menampilkan informasi ini. Secara default, templat tampilan ditulis dalam bahasa yang disebut eRuby (Embedded Ruby), yang diubah oleh loop permintaan di Rails sebelum dikirim ke pengguna.

Untuk membuat pengontrol baru, Anda perlu menjalankan generator "pengontrol" dan memberi tahu bahwa Anda menginginkan pengontrol bernama "Selamat Datang" dengan tindakan bernama "indeks", seperti ini:

$ rails menghasilkan indeks Selamat datang pengontrol

Rails akan membuat beberapa file dan rute.

Buat app/controllers/welcome_controller.rb rute dapatkan "welcome/index" panggil erb buat app/views/welcome buat app/views/welcome/index.html.erb panggil test_unit buat test/controllers/welcome_controller_test.rb panggil helper buat app/ helpers/welcome_helper.rb aktifkan test_unit aktifkan aset aktifkan scss buat aplikasi/aset/stylesheets/welcome.scss

Yang paling penting adalah, tentu saja, controller, terletak di app/controllers/welcome_controller.rb , dan view, terletak di app/views/welcome/index.html.erb .

Buka file app/views/welcome/index.html.erb di editor teks. Hapus semua kode yang ada di file dan ganti dengan baris kode berikut:

Jika Anda mengirimkan formulir lagi, Anda akan melihat sesuatu seperti berikut:

"Artikel Pertama!", "teks"=>"Ini adalah artikel pertama saya.") diizinkan: salah>

Tindakan ini sekarang menampilkan opsi untuk artikel yang berasal dari formulir. Namun, itu tetap tidak berguna. Ya, Anda melihat parameternya, tetapi Anda tidak benar-benar melakukan apa pun dengannya.

5.4. Membuat Model Artikel

Model di Rails menggunakan nama tunggal, dan tabel yang sesuai di database menggunakan nama jamak. Rails menyediakan generator model yang digunakan sebagian besar pengembang Rails untuk membuat model baru. Untuk membuat model baru, jalankan perintah ini di terminal Anda:

$ rails menghasilkan model Judul artikel: string teks: teks

Dengan perintah ini, kami memberi tahu Rails bahwa kami menginginkan model Article dengan atribut tersebut judul tipe string dan atribut teks jenis teks. Atribut ini secara otomatis ditambahkan ke tabel artikel dan terikat ke model Artikel.

Rails akan membuat serangkaian file sebagai tanggapan. Saat ini kami hanya tertarik pada app/models/article.rb dan db/migrate/20140120191729_create_articles.rb (nama Anda mungkin sedikit berbeda). Yang terakhir bertanggung jawab untuk membuat struktur database, oleh karena itu kita akan melihatnya lebih jauh.

Rekaman Aktif cukup pintar untuk secara otomatis mengaitkan nama kolom dengan atribut model, yang berarti Anda tidak perlu mendeklarasikan atribut di dalam model Rails, Rekaman Aktif melakukannya secara otomatis.

5.5. Menjalankan migrasi

Seperti yang telah Anda lihat, Rails generate model membuat file migrasi basis data di direktori db/migrasi. Migrasi adalah kelas Ruby yang dirancang untuk memudahkan pembuatan dan modifikasi tabel database. Rails menggunakan perintah rake untuk menjalankan migrasi, dan dimungkinkan untuk membatalkan migrasi setelah diterapkan ke database Anda. Nama file migrasi menyertakan stempel waktu untuk memastikannya berjalan sesuai urutan pembuatannya.

Jika Anda melihat file db/migrate/YYYYMMDDHHMMSS_create_articles.rb (ingat, file Anda memiliki nama yang sedikit berbeda), inilah yang akan Anda temukan:

Kelas Buat Artikel< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Migrasi ini membuat metode perubahan yang dipanggil saat migrasi ini dijalankan. Tindakan yang ditentukan dalam migrasi ini juga dapat dibalik, yang berarti Rails mengetahui cara membatalkan perubahan yang dibuat oleh migrasi ini jika Anda memutuskan untuk membatalkannya nanti. Saat Anda menjalankan migrasi ini, ini akan membuat tabel artikel dengan kolom string dan kolom teks. Itu juga akan membuat dua bidang stempel waktu untuk melacak kapan artikel itu dibuat dan diperbarui.

Sekarang kita perlu menggunakan perintah Rails untuk menjalankan migrasi:

$ rel db: bermigrasi

Rails akan menjalankan perintah migrasi ini dan melaporkan bahwa ia telah membuat tabel Articles.

Buat Artikel: bermigrasi ============================================= == = -- create_table(:articles) -> 0.0019s == BuatArtikel: migrasi (0.0020s) =========================== == ============

Karena Anda menjalankan lingkungan pengembangan secara default, perintah ini akan diterapkan ke database yang ditentukan di bagian pengembangan file config/database.yml Anda. Jika Anda ingin menjalankan migrasi di lingkungan lain, seperti produksi, Anda harus meneruskannya secara eksplisit saat memanggil perintah: Rails db:migrate RAILS_ENV=production .

5.6. Menyimpan data di pengontrol

Kembali ke ArticlesController , kita perlu memodifikasi tindakan create untuk menggunakan model Article baru untuk menyimpan data ke database. Buka app/controllers/articles_controller.rb dan ubah tindakan buat sebagai berikut:

def buat @artikel = Article.new(params[:article]) @article.save redirect_to @article end

Inilah yang terjadi di sini: setiap model Rails dapat diinisialisasi dengan atribut yang sesuai, yang secara otomatis akan terikat ke kolom database yang sesuai. Di baris pertama, kita melakukan hal itu (ingat bahwa params[:article] berisi atribut yang kita minati). Kemudian @article.save bertanggung jawab untuk menyimpan model ke database. Akhirnya, kami mengarahkan pengguna ke aksi pertunjukan, yang akan kami tentukan nanti.

Anda mungkin bertanya-tanya mengapa A di Article.new dikapitalisasi ketika semua tautan artikel lain dalam panduan ini menggunakan huruf kecil. Dalam konteks ini, kami mengacu pada kelas bernama Article , yang didefinisikan dalam app/models/article.rb . Nama kelas di Ruby harus dimulai dengan huruf kapital.

Sekarang setelah ada validasi, memanggil @article.save pada artikel yang tidak valid akan menghasilkan false . Jika Anda membuka app/controllers/articles_controller.rb lagi, Anda akan melihat bahwa kami tidak memeriksa hasil pemanggilan @article.save dalam tindakan pembuatan. Jika @article.save gagal dalam situasi ini, kita perlu menunjukkan formulir kepada pengguna lagi. Untuk melakukan ini, ganti yang baru dan buat tindakan di app/controllers/articles_controller.rb dengan ini:

Def baru @artikel = Artikel.baru akhir def buat @artikel = Artikel.baru(params artikel) jika @artikel.simpan redirect_to @artikel lain render "baru" akhiri def pribadi artikel_params params.require(:artikel).permit(:judul , :teks) selesai

Sekarang tindakan baru membuat variabel instan baru bernama @article , dan Anda akan melihat alasannya dalam beberapa paragraf.

Perhatikan bahwa dalam tindakan buat kami menggunakan render alih-alih redirect_to saat save mengembalikan false . Metode render digunakan agar objek @article diteruskan kembali ke template baru saat dirender. Rendering ini dilakukan dalam permintaan yang sama dengan pengiriman formulir, sementara redirect_to memberi tahu browser untuk membuat permintaan lain.

5.11. Pembaruan artikel

Kami telah mengungkapkan bagian "CR" dari CRUD. Sekarang mari kita fokus pada bagian "U", memperbarui artikel.

Langkah pertama adalah menambahkan tindakan edit ke ArticlesController , biasanya antara tindakan new dan create, seperti yang ditunjukkan.

def baru @artikel = Artikel.baru akhir def edit @artikel = Artikel.temukan(params[:id]) akhir def buat @artikel = Artikel.baru(artikel_params) if @artikel.save redirect_to @artikel lain render "baru" akhir akhir

Tampilan akan berisi formulir yang mirip dengan yang kami gunakan saat membuat artikel baru. Buat file bernama app/views/articles/edit.html.erb dan tambahkan berikut ini:

Mengedit artikel

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

Saat ini, kami mengarahkan formulir ke tindakan pembaruan, yang belum ditentukan, tetapi kami akan segera melakukannya.

Meneruskan objek artikel ke metode form_with akan secara otomatis menetapkan URL untuk mengirimkan formulir artikel yang telah diedit. Opsi ini memberi tahu Rails bahwa kami ingin formulir ini dikirimkan dengan PATCH , metode HTTP yang diharapkan digunakan untuk update sumber daya sesuai dengan protokol REST.

Selanjutnya, Anda perlu membuat tindakan pembaruan di app/controllers/articles_controller.rb . Tambahkan di antara tindakan buat dan metode pribadi:

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

Metode baru, update , digunakan saat Anda ingin memperbarui entri yang sudah ada, dan memerlukan hash berisi atribut yang ingin Anda perbarui. Seperti sebelumnya, jika ada kesalahan memperbarui artikel, kami ingin menampilkan kembali formulir kepada pengguna.

Kami telah menggunakan kembali metode article_params yang kami tentukan sebelumnya untuk tindakan pembuatan.

Tidak perlu meneruskan semua atribut ke update . Misalnya, jika @article.update(title: "A new title") dipanggil, Rails hanya akan memperbarui atribut title, membiarkan semua atribut lainnya tidak tersentuh.

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

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

Dan tambahkan juga app/views/articles/show.html.erb ke template agar link "Edit" juga ada di halaman artikel. Tambahkan yang berikut di akhir templat:

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

Dan inilah tampilan aplikasi kita sekarang:

5.12. Menggunakan Partial untuk Membersihkan Pengulangan dalam Tampilan

Halaman edit kami sangat mirip dengan halaman baru, sebenarnya mereka menggunakan kode yang sama untuk menampilkan formulir. Mari hapus duplikasi ini dengan menggunakan tampilan parsial. Dengan konvensi, file parsial dimulai dengan garis bawah.

Buat file app/views/articles/_form.html.erb baru dengan konten berikut:

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

Sekarang mari perbarui tampilan app/views/articles/new.html.erb untuk menggunakan sebagian baru ini, menulis ulang seluruhnya:

artikel baru

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

Dan hal yang sama untuk tampilan app/views/articles/edit.html.erb:

Mengedit artikel

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

5.13. Menghapus artikel

Kami sekarang siap untuk menutupi bagian "D" dari CRUD, menghapus dari database. Mengikuti konvensi REST, rute untuk menghapus artikel di output rute rel adalah sebagai berikut:

HAPUS /articles/:id(.:format) articles#destroy

Metode hapus perutean harus digunakan untuk rute yang merusak sumber daya. Jika dibiarkan sebagai rute normal, dimungkinkan untuk menghasilkan URL jahat berikut:

lihat kucing ini!

Kami menggunakan metode hapus untuk menghancurkan sumber daya, dan rute ini dikaitkan dengan tindakan penghancuran di app/controllers/articles_controller.rb , yang belum ada. Metode penghancuran biasanya merupakan tindakan CRUD terakhir di pengontrol, dan seperti semua tindakan CRUD publik, metode ini harus ditempatkan sebelum metode pribadi atau yang dilindungi. Mari kita tambahkan:

def hancurkan @artikel = Article.find(params[:id]) @article.destroy redirect_to articles_path end

ArticlesController lengkap di app/controllers/articles_controller.rb sekarang akan terlihat seperti ini:

Artikel KelasController< 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

Anda dapat memanggil penghancuran pada objek Rekaman Aktif saat Anda ingin menghapusnya dari database. Perhatikan bahwa kami tidak perlu menambahkan tampilan untuk tindakan ini karena kami mengarahkan ulang ke tindakan indeks.

Daftar Artikel

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

Judul	Teks
<%= 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?" } %>

Di sini kami menggunakan link_to dengan cara yang berbeda. Kami melewati rute bernama sebagai argumen kedua, dan opsi sebagai argumen lainnya. Metode: :hapus dan data: ( konfirmasi: "Apakah Anda yakin?" ) opsi digunakan sebagai atribut html5, jadi ketika tautan diklik, Rails pertama-tama akan menampilkan dialog konfirmasi kepada pengguna dan kemudian mengirim tautan menggunakan metode hapus . Ini dilakukan dengan menggunakan file Rails-ujs JavaScript, yang secara otomatis disertakan dalam tata letak aplikasi (app/views/layouts/application.html.erb) saat aplikasi dibuat. Tanpa file ini, dialog konfirmasi tidak akan ditampilkan.

Selamat, sekarang Anda dapat membuat, melihat semua dan satu per satu, memperbarui dan menghapus artikel.

Menambahkan model kedua

Saatnya menambahkan model kedua ke aplikasi. Model kedua akan menangani komentar pada artikel.

6.1. Menghasilkan Model

Kami bermaksud menggunakan generator yang sama dengan yang kami gunakan sebelumnya saat membuat model Article. Kali ini kita akan membuat model Comment yang berisi link artikel. Jalankan perintah berikut di terminal:

$ rails generate model Comment commenter:string body:text article:references

Perintah ini menghasilkan empat file:

Pertama, mari kita lihat app/models/comment.rb:

komentar kelas< ApplicationRecord belongs_to:article end

Ini sangat mirip dengan model Article yang kita lihat sebelumnya. Perbedaannya ada pada baris owned_to:article , yang menetapkan koneksi rekaman aktif. Anda akan belajar tentang koneksi di bagian selanjutnya dari panduan ini.

Kata kunci (:references) yang digunakan dalam perintah bash adalah tipe data khusus untuk model. Itu membuat kolom baru di database Anda dengan nama model yang diberikan dengan _id ditambahkan, yang dapat berisi nilai numerik. Untuk lebih memahami, analisis file db/schema.rb setelah migrasi selesai.

Selain model, Rails juga melakukan migrasi untuk membuat tabel database yang sesuai:

Kelas BuatKomentar< 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

Baris t.references membuat kolom numerik bernama article_id , indeks di atasnya, dan batasan kunci asing yang menunjuk ke kolom id dari tabel articles. Selanjutnya, kami menjalankan migrasi:

$ rel db: bermigrasi

Rails cukup pintar untuk hanya menjalankan migrasi yang belum dijalankan terhadap database saat ini, dalam kasus kami, Anda akan melihat:

BuatKomentar: bermigrasi ========================================== = = -- create_table(:comments) -> 0.0115s == CreateComments: migrated (0.0119s) =========================== == ==========

6.2. Menghubungkan Model

Tautan Rekaman Aktif memungkinkan Anda mendeklarasikan hubungan antara dua model dengan mudah. Dalam hal komentar dan artikel, Anda dapat menggambarkan hubungannya sebagai berikut:

• Setiap komentar milik satu artikel.
• Satu artikel bisa memiliki banyak komentar.

Faktanya, ini sangat mirip dengan sintaks yang digunakan Rails untuk mendeklarasikan hubungan ini. Anda telah melihat baris kode dalam model Comment (app/models/comment.rb) yang membuat setiap komentar menjadi milik sebuah artikel:

komentar kelas< ApplicationRecord belongs_to:article end

Anda perlu mengedit app/models/article.rb untuk menambahkan sisi lain dari tautan:

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

Kedua pengumuman ini tersedia secara otomatis sejumlah besar peluang. Misalnya, jika Anda memiliki variabel instan @article yang berisi artikel, Anda bisa mendapatkan semua komentar milik artikel tersebut dalam sebuah array dengan memanggil @article.comments .

6.3. Menambahkan rute untuk komentar

Seperti pada welcome controller, kita perlu menambahkan route agar Rails mengetahui alamat mana yang ingin kita tuju untuk melihat komentar. Buka file config/routes.rb lagi dan edit sebagai berikut:

Sumber daya:artikel lakukan sumber daya:komentar akhir

Ini akan membuat komentar seperti sumber daya bersarang dalam artikel. Ini adalah sisi lain dari menangkap hubungan hierarkis yang ada antara artikel dan komentar.

6.4. Menghasilkan pengontrol

Dengan model yang ada, mari alihkan perhatian kita untuk membuat pengontrol yang sesuai. Sekali lagi kami akan menggunakan generator yang sama yang kami gunakan sebelumnya:

$ rails menghasilkan pengontrol

Empat file dan direktori kosong akan dibuat:

Seperti blog lainnya, pembaca kami akan membuat komentar mereka segera setelah membaca artikel, dan setelah menambahkan komentar, mereka akan diarahkan kembali ke halaman tampilan artikel dan melihat bahwa komentar mereka telah tercermin. Dalam hal ini, CommentsController kami berfungsi sebagai sarana untuk membuat komentar dan menghapus spam, jika ada.

Pertama, kami akan memperpanjang template Article show (app/views/articles/show.html.erb) untuk memungkinkan kami menambahkan komentar baru:

Judul: <%= @article.title %>

teks: <%= @article.text %>

Tambahkan komentar:

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

Ini akan menambahkan formulir ke halaman tampilan artikel yang membuat komentar baru saat tindakan buat di CommentsController dipanggil. Di sini panggilan form_with menggunakan array, yang akan membuat rute bersarang seperti /articles/1/comments .

Mari menulis buat di app/controllers/comments_controller.rb:

Komentar KelasController< 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

Ini sedikit lebih rumit daripada yang Anda lihat di pengontrol artikel. Ini adalah efek samping dari lampiran yang Anda atur. Setiap permintaan komentar melacak artikel yang dilampirkan komentar, jadi pertama-tama kami menyelesaikan pengambilan artikel dengan memanggil find pada model Article.

Selain itu, kode memanfaatkan beberapa metode yang tersedia untuk hubungan. Kami menggunakan metode buat di @article.comments untuk membuat dan menyimpan komentar. Ini secara otomatis menautkan komentar sehingga menjadi milik artikel tertentu.

Setelah kami membuat komentar baru, kami membawa pengguna kembali ke artikel asli menggunakan pembantu article_path(@article). Seperti yang telah kita lihat, ini memanggil aksi show pada ArticlesController , yang pada gilirannya merender template show.html.erb. Di sinilah kita ingin menampilkan komentar, jadi mari tambahkan baris berikut ke app/views/articles/show.html.erb .

Judul: <%= @article.title %>

teks: <%= @article.text %>

Komentar

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

pemberi komentar: <%= comment.commenter %>

Komentar: <%= comment.body %>

<% end %>

Tambahkan komentar:

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

Anda sekarang dapat menambahkan artikel dan komentar ke blog Anda dan menampilkannya di tempat yang tepat.

Pemfaktoran ulang

Sekarang setelah artikel dan komentar berfungsi, mari kita lihat template app/views/articles/show.html.erb. Itu menjadi lama dan tidak nyaman. Mari gunakan sebagian untuk membongkarnya.

7.1. Merender Koleksi Partial

Pertama, mari buat sebagian komentar yang menampilkan semua komentar untuk artikel tersebut. Buat file app/views/comments/_comment.html.erb dan masukkan yang berikut di dalamnya:

pemberi komentar: <%= comment.commenter %>

Komentar: <%= comment.body %>

Anda kemudian dapat mengubah app/views/articles/show.html.erb seperti ini:

Judul: <%= @article.title %>

teks: <%= @article.text %>

Komentar

<%= render @article.comments %>

Tambahkan komentar:

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

Ini sekarang akan merender sebagian app/views/comments/_comment.html.erb sekali untuk setiap komentar di koleksi @article.comments. Karena metode render beriterasi pada koleksi @article.comments, ia menugaskan setiap komentar ke variabel lokal bernama seperti parsial, dalam kasus kita comment , yang tersedia untuk kita dalam parsial untuk rendering.

7.2. Rendering Form secara Parsial

Mari kita pindahkan juga bagian komentar baru ke bagian kita. Sekali lagi, buat file app/views/comments/_form.html.erb yang berisi:

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

Kemudian ubah app/views/articles/show.html.erb seperti ini:

Judul: <%= @article.title %>

teks: <%= @article.text %>

Komentar

<%= render @article.comments %>

Tambahkan komentar:

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

Render kedua hanya mendefinisikan template untuk sebagian yang ingin kita render, comments/form . Rails cukup pintar untuk mengganti garis bawah di baris ini dan memahami bahwa Anda ingin merender file _form.html.erb di direktori app/views/comments.

Objek @article tersedia dalam sebagian yang dirender dalam tampilan karena kita telah mendefinisikannya sebagai variabel instan.

Menghapus komentar

Fitur penting lainnya dari blog adalah kemampuan untuk menghapus spam. Untuk melakukan ini, kita perlu menyisipkan beberapa tautan di tampilan dan tindakan penghancuran di CommentsController .

pemberi komentar: <%= comment.commenter %>

Komentar: <%= comment.body %>

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

Menekan ini tautan baru"Hancurkan Komentar" akan mengaktifkan DELETE /articles/:article_id/comments/:id pada CommentsController kita yang kemudian akan digunakan untuk menemukan komentar yang ingin kita hapus, jadi mari tambahkan tindakan penghancuran ke pengontrol kita (app/controllers/comments_controller .rb):

Komentar KelasController< 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

Tindakan penghancuran akan menemukan artikel yang sedang kita lihat, menemukan komentar di koleksi @article.comments, lalu menghapusnya dari database dan membawa kita kembali ke tampilan artikel.

8.1. Menghapus objek terkait

Jika Anda menghapus sebuah artikel, komentar yang terkait dengannya juga harus dihapus, jika tidak maka hanya akan menghabiskan ruang di database. Rails memungkinkan Anda menggunakan opsi dependen pada tautan untuk mencapainya. Modifikasi model Article, app/models/article.rb , sebagai berikut:

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

Keamanan

9.1. Otentikasi Dasar

Jika Anda mempublikasikan blog Anda secara online, siapa pun dapat menambah, mengedit, dan menghapus artikel atau menghapus komentar.

Rails menyediakan sistem autentikasi HTTP dasar yang bekerja dengan baik dalam situasi ini.

Di ArticlesController kita memerlukan cara untuk memblokir akses ke berbagai tindakan jika pengguna tidak diautentikasi. Di sini kita dapat menggunakan metode Rails http_basic_authenticate_with untuk mengizinkan akses ke tindakan yang diperlukan jika metode mengizinkannya.

Untuk menggunakan sistem otentikasi, kami akan mendefinisikannya di bagian atas ArticlesController kami di app/controllers/articles_controller.rb . Dalam kasus kami, kami ingin pengguna diautentikasi untuk setiap tindakan kecuali index dan show , jadi kami akan menulisnya seperti ini:

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

Kami juga ingin hanya mengizinkan pengguna yang diautentikasi untuk menghapus komentar, jadi di CommentsController (app/controllers/comments_controller.rb) kami akan menulis:

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

Sekarang, jika Anda mencoba membuat artikel baru, Anda akan menemukan panggilan autentikasi dasar HTTP:

Metode autentikasi lainnya juga tersedia untuk aplikasi Rails. Dua pengaya Rails yang populer antara lain adalah Rancangan dan Authlogic.

9.2. Pikiran Keamanan Lainnya

Keamanan, terutama dalam aplikasi web, adalah area yang luas dan terperinci. Keamanan aplikasi Rails Anda dibahas lebih detail dalam panduan Keamanan Aplikasi Rails Cara termudah untuk bekerja dengan Rails adalah dengan menyimpan semua data eksternal dalam UTF-8. Jika tidak, pustaka Ruby dan Rails sering kali dapat mengonversi data asli Anda ke UTF-8, tetapi ini tidak selalu berfungsi dengan baik, jadi sebaiknya pastikan bahwa semua data eksternal adalah UTF-8.

Jika Anda membuat kesalahan di area ini, gejala yang paling umum adalah berlian hitam dengan tanda tanya di dalamnya yang muncul di browser. Gejala umum lainnya adalah karakter seperti "ü" yang muncul alih-alih "ü". Rails mengambil sejumlah langkah internal untuk memitigasi kasus umum masalah yang dapat dideteksi dan diperbaiki secara otomatis. Namun, jika ada data eksternal yang tidak disimpan di UTF-8, ini dapat menyebabkan masalah seperti ini yang tidak dapat dideteksi dan diperbaiki oleh Rails secara otomatis.

Dua sumber data paling umum yang tidak ada di UTF-8 adalah:

• Milikmu editor teks: Sebagian besar editor teks (seperti TextMate) menyimpan file sebagai UTF-8 secara default. Jika editor teks Anda tidak melakukan ini, ini dapat menyebabkan karakter khusus yang diketik di template Anda (seperti é) muncul sebagai berlian tanda tanya di browser. Ini juga berlaku untuk file terjemahan i18N Anda. Sebagian besar editor yang tidak default ke UTF-8 (seperti beberapa versi Dreamweaver) menawarkan cara untuk mengubah default ke UTF-8. Lakukan.
• Basis data Anda: Rails secara default akan mengonversi data dari basis data Anda ke UTF-8 pada batas. Namun, jika database Anda tidak menggunakan UTF-8 secara internal, database Anda mungkin tidak dapat menyimpan semua karakter yang diketik pengguna Anda. Misalnya, jika database Anda secara internal menggunakan Latin-1 dan pengguna Anda memasukkan karakter Rusia, Ibrani, atau Jepang, data akan hilang segera setelah masuk ke database. Jika memungkinkan, gunakan UTF-8 sebagai penyimpanan internal di database Anda.

Penulis terdorong untuk menulis teks ini dengan mempelajari sejumlah materi yang ditemukan di Web Global, yang mungkin saja diberi tajuk / tag yang sama: Bagaimana Saya Mempelajari Ruby(atau Ruby on Rails, PHP, JS, C++, dll) untuk tiga hari.

Nah, atau sejenisnya. Penulis, pada gilirannya, segera mengingat (asosiasi yang tidak dapat dikendalikan) sejumlah anekdot, disatukan lagi oleh tema yang sama, yang terdiri dari menilai tindakan yang dapat dilakukan dengan bodoh ... bahasa Rusia sangat kuat dan sangat aphoristik, tetapi, sayangnya, sepertinya tidak mungkin mengutip mahakarya ini di sini; oleh karena itu, tidak ada yang tersisa selain menawarkan kepada pembaca versi doki yang ditulis sendiri dari siklus tersebut Cara menikmati dan belajar bekerja di Ruby on Rails dengan relatif cepat.

Contoh kerja dari kode yang dijelaskan dalam artikel, antara lain Contoh Rails - selalu dapat ditemukan di blog pengujian penulis di herokuapp.com , selamat datang.

Tekniknya sederhana, dan penulis sama sekali tidak berpura-pura menjadi pelopor di sini: itu harus menarik, dan hasilnya tidak akan lama lagi. Tidak ada salahnya mencoba mempermainkan kelemahan Anda sendiri, terkadang kesombongan pun bisa bermanfaat untuk penyebabnya; hasil pengembangan harus sedemikian rupa sehingga dapat disajikan dengan bangga kepada pembaca, teman, dan kolega di Web, disebarkan di suatu tempat di Heroku atau Amazon, juga - agar Anda dapat kembali lagi dan lagi, membangun kembali dan meningkatkan, forum dan StackOwerflow untuk membantu kita semua. Jadi saya katakan, mengapa tidak menulis, sebagai permulaan, blog Anda Ruby di Rel?

Saya sarankan mulai dari dermaga yang sangat baik Memulai dengan Rails atau adaptasi Rails bahasa Rusia untuk pemula, juga Membangun Blog dengan Ruby on Rails, juga untuk membantu materi blog ini, tautan yang mudah ditemukan di sidebar kiri . Dan kemudian - semuanya, lalu sihir, pada awalnya semuanya dicat seperti jarum jam, buka konsol - dan lanjutkan ... penulis menganggap tugasnya untuk membuat hanya beberapa penjelasan dan rekomendasi teknis yang dirancang untuk memudahkan mahir untuk mencari dan mendapatkan Sisi Cahaya Kekuatan, dan tidak ada lagi Togo. Ini hanya pertarunganmu, maju dan kembali dengan kemenangan.

Jadi. Langkah demi langkah dari manual pertama dikalibrasi dengan baik dan tidak akan menyebabkan Anda, saya harap, tidak merepotkan; semua yang diperlukan dari Anda adalah berhati-hati, dengan cermat mengulangi langkah-langkah komentar yang mendetail ... dan dalam satu jam blog pertama Anda siap, Anda dapat beristirahat dan beralih ke yang kedua, yang agak lebih menarik. Dan di sinilah, mungkin ternyata, Anda memerlukan beberapa kata perpisahan, yang sekarang akan kita lanjutkan.

Mari kita mulai dengan pernyataan bahwa metode ini cukup mampu (sebagai alternatif) terlihat seperti berikut, tetapi sama sekali tidak seperti aslinya:

app/controllers/posts_controller.rb

# Perbarui tindakan perbarui posting dengan informasi baru def update if @post.update_attributes(post_params) flash[:notice] = "Posting berhasil diperbarui!" redirect_to posts_path else flash[:alert] = "Kesalahan memperbarui posting!" render:edit end end # Tindakan tampilkan kiriman individual setelah mengambil id def tampilkan akhir # Tindakan penghancuran menghapus kiriman secara permanen dari basis data def destroy @post = Post.find(params[:id]) if @post .destroy flash[:notice] = "Postingan berhasil dihapus!" redirect_to posts_path else flash[:alert] = "Kesalahan memperbarui posting!" akhir akhir

Namun, coba cara ini dan itu, kenapa tidak. Kami melangkah lebih jauh.

Blog kedua, meski lebih kompleks (tambahan editor artikel CKEditor dan perangkat, alat autentikasi yang fleksibel untuk aplikasi Rails), untuk beberapa alasan tidak mengizinkan komentar dalam bahasa aslinya. Anda harus menebus sendiri kekurangan ini: lanjutkan dengan analogi dengan deskripsi pembuatan blog pertama, hanya diperlukan perubahan yang sangat kecil: sederhananya, alih-alih artikel dan artikel blog pertama yang akan Anda miliki pos dan posting di blog kedua, itu saja sebenarnya perbedaannya. Hati-hati dan semuanya akan berhasil.

Captcha Anda juga harus menautkan sendiri ke komentar: ya, ya, ini bukan Joomla untuk Anda, biasakanlah. Namun, upaya titanic tidak diperlukan, proses koneksi Captcha dijelaskan secara rinci dalam artikel Termasuk Recaptcha di aplikasi Rails . Selanjutnya, tidak berlebihan untuk menyesuaikan perangkat sedemikian rupa sehingga blog bekerja (setidaknya pada awalnya!) dalam mode pengguna tunggal, yang memungkinkan banyak pembacanya mode BACA HANYA, dengan kata lain, kami akan melarang pendaftaran pengguna baru untuk memulai. Ada banyak resep berbeda di Web tentang cara melakukan ini, tetapi, menurut pendapat saya, peretasan yang paling kompeten dari jenis ini ada di perangkat Wiki, dalam materi yang disebut Cara: Menyiapkan perangkat sebagai sistem pengguna tunggal . Yakni, kami membuat pengontrol baru:

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

lalu kami menimpanya di routes.rb dan hanya itu:

#devise_for:adminsdevise_for:admins, controllers: ( registrasi: "pendaftaran")

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

Sepenuhnya config.enterMode = CKEDITOR.ENTER_BR // menekan input KUNCI ENTER
config.shiftEnterMode = CKEDITOR.ENTER_P; //menekan input SHIFT + ENTER KEYS

Config.autoParagraph = false; // menghentikan penyisipan otomatis

sedang fokus);

Mungkin, sebagai permulaan, itu saja ... sial, saya hampir melupakan hal terpenting. Jika Anda akan menggunakan blog baru Anda di Heroku- tambahkan tiga baris ini ke

config/application.rb

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

Sebaliknya CKEditor menolak untuk bekerja untuk Anda di tempat baru.

Ruby adalah bahasa pemrograman yang kuat dan populer. Selain popularitasnya, kerangka kerja terkenal didasarkan padanya, yang memungkinkan Anda membuat situs web keren dan dinamis dari berbagai subjek. Jika melihat peringkat TIOBE, maka bahasa tersebut termasuk dalam dua puluh bahasa terpopuler di dunia.

Bahasa tersebut muncul pada tahun 1995 dan dianggap sebagai bahasa yang lebih muda dibandingkan dengan C atau C ++ yang masing-masing muncul pada tahun 1972 dan 1983. Bahasa tersebut memiliki sejumlah keunggulan dan fitur khusus yang diimplementasikan secara eksklusif di dalamnya, jika dibandingkan dengan bahasa pemrograman populer lainnya.

Rencana kursus

Selama kursus video, Anda akan mempelajari bahasa Ruby tanpa menggunakan framework tambahan. Kursus tambahan di rubi Anda dapat menemukan di.

Selama kursus, kita akan belajar cara menginstal dan bekerja dengan bahasa tersebut, mempelajari sintaksnya Rubi(variabel, loop, pernyataan bersyarat), serta hal-hal yang lebih kompleks: OOP, bekerja dengan file, pengecualian, metode, dan banyak topik lainnya.

Menginstal Ruby di Windows

Untuk menginstal Ruby di Windows, gunakan Penginstal Ruby, yang dapat diunduh dari situs web resmi di tautan ini. Unduh versi terbaru dan instal seperti program biasa. Setelah instalasi selesai, Anda akan melihat jendela serupa:

Di jendela ini, pastikan kotak centang dicentang, lalu aplikasi lain akan terbuka untuk penginstalan rubi ke dalam sistem.

Di jendela yang terbuka, masukkan 1 secara bergantian dan tekan Enter, setelah menunggu penginstalan selesai, tekan 2 dan Enter dan pada akhirnya jalankan perintah ketiga dengan menekan 3 dan Enter.

Memasang Ruby di Mac

Di Mac, Ruby diinstal secara default, jadi Anda tidak perlu melakukan apa pun. Anda dapat memeriksa versi bahasa di terminal dengan perintah berikut:

Jika versinya kedaluwarsa, Anda dapat mengunduh yang baru. Pertama, Anda perlu mengunduh manajer versi Ruby. Ini dilakukan melalui terminal dengan perintah:

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

Setelah menginstal manajer, restart terminal. Jalankan perintah berikut:

Daftar Rvm dikenal

Setelah memulai ulang, Anda dapat menginstal versi apa pun yang Anda inginkan. Dalam kasus kami, versi 2.4.2 diinstal:

rvm instal ruby-2.4.2

Terakhir bisa dicek kembali versinya dan jika masih lama maka tinggal set default ke versi yang baru.

Salah satu tutorial Rails pertama dan terlengkap di web. Keuntungan utama adalah liputan mendetail tentang masalah yang paling penting, pembaruan rutin, dan konten gratis.

Benar, sumber dayanya sepenuhnya dalam bahasa Inggris. Dan penting untuk dipahami bahwa ini dibuat dalam bentuk buku - Anda harus memikirkan sendiri semua masalahnya. Karena itu, durasi dan kompleksitas pelatihan tidak dapat diprediksi.

2. Kereta api

Sumber daya pelatihan Internet terkenal lainnya. Lebih dari satu generasi pengembang Rails tumbuh di sana. Juga dalam bahasa Inggris.

Itu tidak dibangun sebagai kursus pelatihan holistik, tetapi sebagai serangkaian screencast - pelajaran singkat tentang topik tertentu. Ada banyak pelajaran, Anda dapat menemukan hampir semua topik.

Sayangnya, proyek tersebut berhenti diperbarui pada tahun 2013.

3. Rel untuk Zombie

Pengantar kickass ke Rails untuk pemula dalam game bergaya pencarian dengan getaran zombie. Ini sangat populer di kalangan pemula.

Akan lebih mudah jika Anda tidak perlu menginstal apa pun di komputer Anda. Semua teka-teki diselesaikan di browser. Langkah demi langkah Anda menjalani permainan dan mulai memahami dasar-dasar Ruby on Rails.

Jika Anda sama sekali tidak mengerti pemrograman, ini adalah pilihan Anda. Tidak ada topik yang rumit dalam kursus, tidak ada yang mengalihkan perhatian dari dasar-dasarnya. Dalam bahasa Inggris.

3.Udemi

Banyak koleksi kursus video. Diantaranya banyak di ruby ​​​​dan ruby ​​​​di atas rel. Tidak masuk akal untuk memberikan tautan spesifik - pilih sesuai selera Anda berdasarkan harga atau popularitas.

Format Udemy melibatkan kursus yang cukup singkat dengan penekanan pada pelajaran video. Jangan mengharapkan pekerjaan rumah yang serius atau dukungan segera dari guru.

4. Bursa Ruby

Kursus singkat yang ampuh tentang dasar-dasar pengembangan Rails. Guru berpengalaman, program bagus.

Di kursus, kehadiran pribadi siswa diinginkan dan hanya terjadi di kota-kota besar Ukraina.

5. Pengembangan Ruby on Rails dari Evil Marsians

Intensif tiga hari dari salah satu tim Ruby on Rails paling berpengalaman di Rusia.

Jarang dilakukan. Itu mahal (dilihat dari ulasannya, itu sepadan). Membutuhkan kehadiran pribadi. Hanya cocok untuk pemrogram tingkat lanjut, tidak ada yang bisa dilakukan pemula di sana.

6. Ruby on Rails Online Intensif dari Good Programmer

Proyek baru dari tim yang dikenal di Youtube untuk kursus Ruby mereka untuk pemula.

Program intensif 3 bulan dirancang untuk pemula yang lengkap dan berjanji untuk menjadikan Anda seorang programmer junior dengan portofolio tidak lebih dari 12 aplikasi pintar.

Kursus ini terdiri dari pelajaran video, tugas praktis, dukungan guru, webinar reguler.

Dilihat oleh saluran Youtube dan komentar pengguna - orang-orang ini tahu apa yang mereka lakukan dan tidak akan bosan dengan mereka.

Keuntungan utama dari setiap desainer web adalah untuk dapat memahami - dan bahkan mengatur - apa yang terjadi "di balik layar".

Paling tidak, Anda harus mengambil beberapa pelajaran pemrograman. Saya tidak berbicara tentang bahasa front-end seperti HTML dan CSS - Anda mungkin sudah tahu banyak tentang hal ini. Aku sedang berbicara tentang hal-hal back end.

Jika Anda tahu cara meletakkan fondasi, maka Anda dapat lebih memahami cara mendesain sisa situs. Faktanya adalah belajar kode akan membuat Anda menjadi desainer yang lebih terpelajar. Selain itu, siapa yang tidak ingin mempekerjakan seorang desainer yang mengetahui segalanya mulai dari desain hingga pengembangan situs web?

Triknya adalah memilih tempat untuk memulai. Belajar memprogram bisa menjadi proses yang sulit, terutama jika Anda memilih salah satu dari yang paling banyak bahasa yang kompleks seperti C++ atau PHP.

Jadi apa tempat terbaik untuk memulai? Jawabannya hanya satu: Ruby on Rails adalah salah satu bahasa pemrograman dan kerangka kerja terbaik untuk mempelajari dasar-dasar desain.

Mengapa Ruby adalah pilihan terbaik?

Untuk pemula, Ruby adalah salah satu bahasa yang paling mudah dipelajari, terutama jika Anda memiliki pengalaman HTML atau CSS yang dimiliki sebagian besar desainer.

Salah satu program pertama yang akan Anda buat saat mulai belajar bahasa adalah program terkenal "Hello World!" yang melibatkan pencetakan kata-kata tersebut di layar.

Dengan bahasa seperti C++, bisa dari lima hingga tujuh baris kode hanya untuk menampilkan dua kata tersebut. Tetapi jika Anda menggunakan Ruby, hanya akan ada satu baris, dan satu perintah.

Menempatkan "halo, dunia!"

Itu saja! Hanya itu yang Anda butuhkan untuk mencetak kata-kata "Halo dunia!" di layar. Cukup mudah, bukan?

Ruby on Rails juga merupakan bahasa yang sangat kering. Menjadi salah satu prinsip pengembangan, KERING (kering) berarti "Jangan Ulangi Diri Sendiri" (Jangan ulangi sendiri!) - yaitu, jangan memprogram elemen lagi saat Anda dapat menggunakan elemen yang sudah Anda buat. Ini menjadikan Ruby bahasa pemrograman yang sangat ringan dan umum digunakan untuk pengembangan, karena bertujuan untuk menyelesaikan proyek dengan cepat dan efisien.

Ruby atau Rel?

Ruby adalah bahasa pemrograman. Rails adalah kerangka kerja yang menggunakan Ruby untuk menyelesaikan pekerjaan. Kerangka kerja Ruby on Rails adalah kumpulan kode prefabrikasi atau pra-tertulis yang membantu mempercepat proses pembuatan proyek baru. Awalnya, itu dibuat untuk mengembangkan alat manajemen proyek Basecamp. Selain Basecamp, ada aplikasi web populer lainnya yang dibangun dengan Rails, seperti 500px, ThemeForest, dan MyFitnessPal.

Setelah Anda memahami cara bekerja dengan bahasa Ruby dan membuat hal-hal bekerja dalam kerangka kerja Ruby On Rails, Anda dapat mulai membuat aplikasi web.

Ruby - di puncak popularitas!

Berkat ledakan popularitas perangkat seluler dan teknologi yang selalu berhubungan, Ruby sangat populer saat ini. Dan mungkin akan terus begitu. Indeks TIOBE menempatkan Ruby sebagai bahasa pemrograman paling populer ke-13. Sejalan dengan tren baru, menurut Memang. com, Ruby juga mengalami permintaan yang sangat tinggi.

Indeks TIOBE

Either way, apakah Anda memilih permintaan atau popularitas, Ruby cukup populer. Ini membuatnya menjadi salah satu tempat terbaik untuk memulainya, karena begitu Anda memahami bahasanya, Anda bisa mendapatkan pekerjaan dengan cukup cepat. Dan itu sebelum Anda mulai belajar bahasa lain untuk memperluas keterampilan Anda.

Ruby memiliki pijakan yang kuat!

Beberapa bahasa lain lebih banyak mendukung kami, memang benar, tetapi meskipun demikian, dukungan dan dokumentasinya tidak seberapa jika dibandingkan dengan apa yang tersedia untuk Ruby. Bahasa lain juga kekurangan kohesi komunitas di sekitar satu kerangka kerja yang sangat didukung.

Berkat framework Ruby On Rails, sudah ada banyak sekali kode yang sudah ada sebelumnya yang dapat Anda gunakan dalam proyek Anda sendiri. Ruby Gems, pustaka framework Ruby, memiliki lebih dari 600.000 pustaka untuk dipilih.

Setiap kali Anda mempelajari sesuatu yang baru, Anda memerlukan banyak dokumentasi dan dukungan. Ada banyak sekali tempat untuk menemukan tutorial, tutorial, panduan, dan bahkan forum tanya jawab. Jika Anda mengalami masalah tertentu, pencarian web sederhana mungkin akan memperbaikinya. Itu penting.

Dokumentasi sederhana dan akses mudah ke dukungan sangat penting saat Anda mempelajari bahasa baru - saat Anda benar-benar mempelajari sesuatu yang baru.

Ruby "memungkinkan" lebih banyak kontrol atas desain

Jika Anda hanya seorang desainer web, membuat situs web bisa menjadi proses yang panjang dan rumit. Ketika Anda duduk untuk bekerja dengan programmer dan mendiskusikan back-end yang diperlukan untuk situs Anda, Anda sering kali harus mengorbankan front-end agar semuanya berfungsi dengan baik.

Pada akhirnya, ini dapat menghasilkan produk yang terlihat sangat berbeda dari visi awal Anda. Pemrogram mungkin tidak peduli, tetapi mungkin akan bermasalah bagi Anda.

Anda tidak akan mengalami masalah seperti ini jika Anda memprogram diri sendiri. Anda tidak harus bergantung pada orang lain untuk menyelesaikan proyek, dan Anda akan memiliki pemahaman yang jauh lebih baik tentang apa yang dapat dicapai dalam pengembangan. Tentunya ada satu atau dua waktu ketika tujuan proyek Anda terlalu tinggi untuk satu programmer atau tim pengembangan? Saat Anda mempelajari bahasa seperti Ruby, Anda dapat menikmati kemudahan memahami kebutuhan, dan kemungkinannya, di sisi lain.

Pada dasarnya, Ruby dirancang untuk digunakan dalam aplikasi web dan pengembangan web, jadi ini adalah tempat yang sempurna untuk desainer web yang bercita-cita tinggi. Setelah Anda memahami bahasanya dan mempelajari cara menggunakan framework Ruby on Rails, Anda akan memiliki kontrol lebih besar atas proyek Anda.

Di mana belajar Ruby?

Paling Jalan terbaik belajar bahasa berarti membenamkan diri di dalamnya dan bekerja dengannya. Ada banyak panduan dan tutorial yang bisa Anda rujuk juga. Jika Anda memiliki memori visual yang berkembang, dan memahami lebih baik melalui presentasi visual, buka YouTube - ada banyak pilihan video pendidikan.

Jika Anda menginginkan pengalaman belajar seperti ruang kelas tradisional, Anda dapat belajar dari situs web pembelajaran pemrograman. Anda tidak harus pergi ke universitas atau perguruan tinggi untuk mendapatkan pendidikan kerja.

Salah satu sumber daya favorit saya - dan sepenuhnya gratis - untuk mempelajari Rails adalah Tutorial Rails Michael Hartle. Ini akan membawa Anda dari proyek sederhana ke kompleks dengan kecepatan Anda sendiri dan Anda dapat memulai dari awal tanpa pengetahuan sama sekali tentang Ruby on Rails.

Apa pun jalur pembelajaran yang Anda pilih, ingatlah bahwa hanya latihan yang membuat sempurna. Tetapkan tujuan pribadi untuk menghabiskan waktu tertentu setiap hari bekerja dengan Ruby. Tetap berpegang pada tujuan itu dan gigih. Sebelum Anda mengetahui bahasa ini sampai akhir, Anda sudah menjadi ahli yang dapat membuat beberapa proyek fantastis.