დიდი ხანია, მინდა ვისწავლო Ruby on Rails საბაზისო დონეზე. კონკრეტული მიზნის გარეშე. უფრო სწორად, მხოლოდ საკუთარი თავისთვის, რათა უკეთ გაიგოთ, რა არის მასში განსაკუთრებული (განსხვავებით 100,500 სხვა ტექნოლოგიებისა და ჩარჩოებისგან), რაც საშუალებას გაძლევთ სწრაფად შექმნათ და გააფართოვოთ საკმაოდ დატვირთული ინტერნეტ პროექტები. მეორეხარისხოვანი მიზეზი იყო სწავლის ახალი მიდგომების გამოცდის სურვილი. როცა პროგრამისტობაზე ვსწავლობდი, მხოლოდ წიგნები და ფორუმები გვქონდა, სადაც რჩევის მოთხოვნით შეგეძლო. ახლა არის ინტერაქტიული სახელმძღვანელოები და ონლაინ პროგრამირების სკოლები, უზარმაზარი თანხასკრინკასტები (თითქმის ოცნება: გურუს პროგრამის ყურება), ცოდნის ბაზები, როგორიცაა stackoverflow.com და ტონა წყარო კოდი GitHub-ზე, სადაც შეგიძლიათ საათობით გაატაროთ ნამდვილი პროფესიონალების საწყისი კოდის შესწავლა. გადავწყვიტე გამომეყო შემდეგი რამდენიმე ღამე (და უბრალოდ დრო არ იყო დღის განმავლობაში) სწავლის ახალი გზების პრაქტიკაში გამოსაცდელად.

ღამე პირველი

Ruby on Rails-ის სწავლის დაწყება თვით Ruby-ის მინიმუმ მინიმალური ცოდნის გარეშე უცნაური იქნებოდა. მე უკვე ავიღე ინტერაქტიული სახელმძღვანელო ruby-lang.org. მაგრამ როგორც კი ჩავაბარე, მაშინვე დამავიწყდა ყველაფერი. მისი შემქმნელები გვპირდებიან, რომ რუბის სინტაქსის დასრულებას და დაუფლებას თხუთმეტი წუთი დასჭირდება. ოცდაათი დამჭირდა. მართალია, Twitter-ზე მუდმივი ყურადღების გაფანტვით. პროცესი დაახლოებით ასე გამოიყურება. ისინი გეუბნებიან: „Ruby-ში მასივები დეკლარირებულია ასე და მონაცემები აღებულია მსგავსი მასივებიდან. ახლა ვცადოთ მასივის შექმნა და მისგან N ელემენტის ამოღება. ჩვენ შევამოწმებთ." თქვენ წაიკითხავთ, როგორ მუშაობს ყველაფერი და სცადეთ დაუყოვნებლივ. რა თქმა უნდა, თქვენ არ ისწავლით რუბის ამ გზით. უმჯობესია ვიფიქროთ, რომ ეს არის სუპერ-ექსპრეს კურსი, რომელიც მუშაობს.

და მაინც, თავად რუბი ძალიან შორს არის Ruby on Rails ჩარჩოსგან. რელსების დაუფლება მინდოდა. ჩვენი სტატიიდან ონლაინ განათლების შესახებ, ნამდვილად გამახსენდა სენსაციური Zombie for Rails კურსი railsforzombies.org. ეს იგივეა, რაც სცადე რუბი, ინტერაქტიული გაკვეთილი, რომელიც იწყებს თქვენ სწავლებას, თუ როგორ მოამზადოთ სარკინიგზო აპლიკაციები დაუყოვნებლივ. პირველ რიგში, ისინი გაწვდიან მინი ლექციას (ინგლისურად, მაგრამ ყველაფერი ძალიან ნათელია - ჩართეთ სუბტიტრები) სარკინიგზო აპლიკაციის ფაილის სტრუქტურის, მონაცემებთან მუშაობის CRUD მიდგომის შესახებ, ისინი განმარტავენ, თუ როგორ არის დანერგილი MVC მოდელი რელსებში. , და ასე შემდეგ. ყოველი ვიდეოს შემდეგ, თქვენ გთხოვენ დაასრულოთ დავალებები მასალის კონსოლიდაციის მიზნით. ყველაფერი მარტივი და გასაგები ჩანს, კურსი ერთ-ორ საათში შეუმჩნევლად მიფრინავს (მოკლეა). მაგრამ! კურსის შემდეგ, ვიგრძენი, რომ შემეძლო სარკინიგზო განაცხადის დაწერა? ვაი, არა!

ღამე მეორე

ერთ-ერთი მიზეზი, რის გამოც ზოგიერთი ადამიანი ჩნდება Rails for Zombies-ის შემდეგ ძირითადი ცოდნა, მაგრამ არ არის ნდობა - ეს არის ვირტუალური გარემო, რომელშიც ტრენინგი მიმდინარეობს. ერთის მხრივ, ის ამცირებს შესვლის ზღურბლს ზღვრამდე: თქვენ არ უნდა ინერვიულოთ თქვენს გარემოზე. მეორეს მხრივ, თქვენ არ ქმნით რაიმე რეალურს გზაზე - გასასვლელში არ არის თქვენთვის "Hello World". და რაც მთავარია, გაურკვეველია რომელი მხრიდან მივუდგეთ მის შექმნას. იმ მომენტიდან მოყოლებული მინდოდა Ruby on Rails-ის მოქმედებაში მეცადა, რეალურად დამეყენებინა სისტემაში (მანამდე არც კი მომიწია ცდა) და მარტივი აპლიკაციის შექმნა ნულიდან.

არ მახსოვს როგორ, მაგრამ სრულიად შემთხვევით წავაწყდი ძალიან წარმატებულ სკრინკასტის კურსს რუსულ rails.hasbrains.org-ში. მადლობა ავტორს მისი კომპეტენტური პრეზენტაციისთვის: ის მეთოდურად განმარტავს სარკინიგზო აპლიკაციის მუშაობის პრინციპებს, ჩაძირავს თქვენ გზაზე ყველა საჭირო დახვეწილობაში. მოკლედ, ექსპერიმენტის მთელი მეორე ღამე გავატარე ამ ეკრანიზაციის ოცდაათზე მეტი ეპიზოდის პირველ ნახევრის ყურებაში.

ჩემს თავში საბოლოოდ დაფიქსირდა სურათი იმის შესახებ, თუ როგორ იქმნება აპლიკაცია, როგორ ვიმუშაო სარკინიგზო კონსოლთან, როგორ შევქმნა მოდელები და მიგრაცია, როგორ განაახლოთ მოდელები და როგორ დავადასტუროთ მონაცემები მათში, RESTful კონტროლერები და ა.შ. თითოეული ეპიზოდის ყურებისას, მე მაშინვე ვცადე ყველაფერი მოქმედებაში, შევქმენი სრულად მოქმედი სარკინიგზო აპლიკაცია. გაირკვა, თუ როგორ არის რელსები დაპროექტებული პრინციპში.

ღამე სამი

მესამე ღამეს დარჩა ეკრანის ბოლო ეპიზოდები, რომელთა ყურება ერთ სესიაზე მოვახერხე: რელსებით მუშაობა აღარ მეჩვენებოდა ისეთი ველური. იმ მომენტში, ვიღაცამ მითხრა, რომ Rails for Zombies კურსს ჰქონდა გონივრული და ბევრად უფრო ღრმა გაგრძელება. მართალია, კურსი უკვე ფასიანია და მასპინძლობს Code School პროგრამირების სკოლაში www.codeschool.com. სირცხვილი არ იყო 25 დოლარის გადახდა სკოლის ყველა კურსზე წვდომისთვის. ეს არის ყოველთვიური ფასი, ასე რომ, თუ არ მოგწონთ, არ დაგავიწყდეთ გამოწერის გაუქმება.

Rails for Zombies 2-ის კურსი მართლაც ძალიან წარმატებული აღმოჩნდა. მართალია, ბევრი რამ იმის გამეორება იყო, რაც ეკრანებზე ვნახე, მაგრამ ნაწილობრივ სასიამოვნოც კი იყო. ხუთი დონე და სავარჯიშოების ხუთი ბლოკი, რომლებსაც პირდაპირ ინტერაქტიულ კონსოლში აკეთებთ. ამ დროისთვის რელსები უკვე ლოგიკური, გასაგები და გამოსაყენებელი ჩანდა.

Code School-ში შეგიძლიათ დაპროგრამება პირდაპირ ბრაუზერში კურსის დავალებების შესრულებისას

რა არის შემდეგი?

ვისწავლე რთული პროექტების გაკეთება? არა. მაგრამ მე ნამდვილად გავაცნობიერე რელსებში გამოყენებული მიდგომები და მივხვდი მათ მოხერხებულობას. ვისწავლე როგორ სწრაფად შევქმნა მარტივი აპლიკაციები და გავზარდო მისი ფუნქციონალობა სუპერ მოკლე დროში საზოგადოების მიერ დაწერილი ძვირფასი ქვების გამოყენებით. გამბედაობა დავიჭირე და სიამოვნებით ვაგრძელებ საუკეთესო პრაქტიკის სწავლას კოდების პროგრამებისკოლა (ამჟამად ვუყურებ კურსს ერთეული ტესტების შესახებ). და ძალიან მახარებს, რომ ტექნოლოგიების სწავლა ასე მარტივი გახდა.

იცოდით, რომ მომხმარებელთა 40% ტოვებს საიტებს ცუდი დიზაინით? რატომ კარგავს მოგებას? აირჩიეთ და დააინსტალირეთ ერთი მათგანი ახლავე 44 ათასი პრემიუმ ვებსაიტის შაბლონი.იდეალური არჩევანი თქვენი ბიზნესისთვის!

ბევრი ჩემი დეველოპერი მეგობარი საუბრობდა Rails-ზე, მაგრამ ვერ მივხვდი რატომ. რა არის Rails და რით განსხვავდება ის Ruby on Rails-ისგან? რამდენად რთულია სწავლა? ეს პროგრამირების ენაა? რა უნდა ვიცოდე Ruby on Rails-ის სწავლამდე?

ეს და სხვა მრავალი კითხვა გამუდმებით მიტრიალებდა თავში, მაგრამ, როგორც იქნა, მარტო მე არ ვიყავი. ჩვენი მკითხველებიც დაინტერესდნენ ამ საკითხით, ამიტომ მის შესახებ მეტის გასარკვევად გადავწყვიტე ჩემს ერთ-ერთ კოლეგას რამდენიმე ძირითადი შეკითხვა დავსვა რუბის შესახებ. ასე დაიბადა ეს სტატია.

მზად ხარ? მოდით წავიდეთ!

13 ფაქტი Ruby on Rails-ის შესახებ – რა უნდა იცოდეთ?

1. რა არის რელსი?

Rails არის ვებ აპლიკაციის ჩარჩო, რომელიც შექმნილია Ruby ენაზე კოდის დასაწერად. დამაბნეველად ჟღერს, არა?

კიდევ ვცადოთ. არსებობს პროგრამირების ენა სახელად Ruby. სასიამოვნოა მასზე წერა. სხვათა შორის, შემქმნელმა თქვა, რომ მისი მთავარი მიზანი იყო ენის შექმნა, რომელიც პროგრამისტების ცხოვრებას გააუმჯობესებდა. ეს მშვენიერი არ არის?

მოდი მაგალითს მოგიყვან.

თუ მსურს ტექსტის ჩვენება ეკრანზე PHP-ში, უნდა დავწერო

ექო "გამარჯობა სამყარო";

ხედავთ მძიმით? და ეს "ექო" - რას ნიშნავს ეს?

მეორეს მხრივ, თუ მჭირდებოდა იგივე რამის გაკეთება Ruby-ში, მე უნდა დავწერო შემდეგი:

აყენებს "Hello World"

არ არის მძიმით და მიუხედავად იმისა, რომ "აყენებს" შეიძლება ცოტათი არასრულწლოვანად გამოიყურებოდეს, ჩემთვის ეს უფრო ლოგიკურია, ვიდრე "ექო". როდესაც საათებს ხარჯავთ კოდის წერაში, მსგავსი პატარა დეტალები დიდ განსხვავებას ქმნის.

Ruby-ის ერთადერთი პრობლემა ის იყო, რომ ის არ იყო შექმნილი ვებ აპლიკაციების შესაქმნელად. ანუ, თქვენ ვერ შეძლებთ მასზე, მაგალითად, ვებსაიტის შექმნას. ასე იყო რელსამდე. დარწმუნებული არ ვარ, Rails იყო თუ არა პირველი ვებ ჩარჩო Ruby-სთვის, მაგრამ ის ნამდვილად გახდა ყველაზე პოპულარული.

Rails-ის მიზანია უზრუნველყოს პლატფორმა და შესაძლებლობები, რაც საშუალებას მოგცემთ შექმნათ აპლიკაციები, კერძოდ ვებსაიტი, Ruby-ში. ამჟამად საკმაოდ ბუნდოვნად ჟღერს, ამიტომ ვეცდები ასე ავხსნა. მე რომ დავწერე

აყენებს "Hello World"

შემდეგ HTML დოკუმენტში ნახავთ მთელ ტექსტს. მაგრამ მე მინდა რომ ნახოთ მხოლოდ ეს:

გამარჯობა მსოფლიო

მარტივად რომ ვთქვათ, Rails ამის გაკეთების საშუალებას გაძლევთ. მაგრამ ეს ყველაფერი არ არის.

2. რა არის Ruby on Rails?

Ruby on Rails არის Rails ჩარჩოს სრული ოფიციალური სახელი. მაგრამ საუბარში დეველოპერები, როგორც წესი, არ ამბობენ პირველ ნაწილს და მას მხოლოდ Rails-ს უწოდებენ. ასე რომ, თუ გსურთ იყოთ „ცნობილი“ და გამოიყურებოდეთ ტექნიკურად მცოდნე, აუცილებლად უნდა უწოდოთ მას Rails, მაგრამ გახსოვდეთ, რას ნიშნავს ეს პირველი ნაწილი - „Ruby on“.

3. გამიგია, რომ Rails შესანიშნავია დამწყებთათვის. რატომ?

არსებობს რამდენიმე მიზეზი, რის გამოც Rails შესანიშნავია დამწყებთათვის. პირველი ის არის, რომ თავად Ruby ენა ნამდვილად კარგია დამწყებთათვის და ეს არის პირველი პლუსი. Ruby-ში კოდირების სწავლა ბევრად უფრო ადვილია, ვიდრე სხვა ენებზე, რადგან ენა საკმაოდ მოქნილი და ლიბერალურია, რაც დაზოგავს თქვენს ნერვებს და საშუალებას მოგცემთ მეტი დრო დაუთმოთ პროგრამირების საფუძვლების შესწავლას.

რატომ არის Rails ასე სასიამოვნო დამწყებთათვის? ის უბრალოდ ძალიან სტაბილურია და უზარმაზარ სამუშაოს აკეთებს თქვენთვის.

ჩემთვის Rails-ზე მუშაობა სატვირთო მანქანის მართვას ჰგავს. წარმოუდგენლად ძლიერია, უბრალოდ შემომხედე - სატვირთოს მართავ!!! თუმცა, რამდენად კარგად იცით, როგორ მუშაობს მანქანა, რომელსაც მართავთ?

ის ფაქტი, რომ Rails ზრუნავს კიდევ უამრავ დავალებაზე, აკეთებს მათ თქვენთვის, მოგცემთ დაუყოვნებლივ კმაყოფილებას დიდი რაოდენობამაგარი სარგებელი. თუმცა, ზოგჯერ ამან შეიძლება ასევე იმოქმედოს თქვენს წინააღმდეგ, თუ ხანდახან წინ უსწრებთ თავს და ბოლომდე არ ისწავლით საფუძვლებს, რომლებიც უბრალოდ უნდა იცოდეთ.

ამ მიზეზით, ძალიან მნიშვნელოვანია, რომ ისწავლოთ Ruby on Rails ნულიდან. და რაც მთავარია, თქვენ უნდა დარწმუნდეთ, რომ Ruby-თან მუშაობა ნამდვილად კომფორტულია. წინააღმდეგ შემთხვევაში, თქვენ უბრალოდ გადმოხვალთ იმ სატვირთოდან ნახევრად და იტყვით საკუთარ თავს: „მოიცადე, მართლა მე ვმართავდი ამ ნივთს?

4. რა განსხვავებაა Rails-ის დეველოპერსა და Ruby-ის დეველოპერს შორის?

ფორმალურად, განსხვავება ისაა, რომ სუფთა "Ruby დეველოპერი" შექმნის აპლიკაციებს Ruby-ში, მაგრამ არა Rails-ში. თუმცა ეს, როგორც წესი, არ ხდება. რა თქმა უნდა, შესაძლებელია Ruby-ში ვებ აპლიკაციების შექმნა სხვა ფრეიმორმების გამოყენებით, როგორიცაა Sinatra, მაგრამ მე მზად ვარ ფსონი დავდო, რომ შემთხვევების 99%-ში ნაკლებად სავარაუდოა, რომ დაქირავებული იქნები მხოლოდ Ruby-ის პროგრამისტად. ამიტომ, თქვენ უნდა ისწავლოთ Rails ნებისმიერ შემთხვევაში.

5. რამდენად კარგად უნდა ვიცოდე რუბი? რა უნდა ვისწავლო ტრენინგის დაწყებამდე?

არსებობს განსხვავებული მოსაზრებები, მაგრამ დიდი სატვირთო მანქანის მაგალითზე მიყევით, ვფიქრობ, რომ თქვენ კომფორტულად უნდა იყოთ Ruby-თან, რომ ჩაუღრმავდეთ Rails-ში. ისევე, როგორც, ვთქვათ, ჯობია ჯერ ველოსიპედის ტარება ვისწავლოთ მანქანაზე გადართვამდე და მერე ვიფიქროთ სატვირთო მანქანის მართვაზე.

და აქ არის კიდევ ერთი რამ. Rails-ზე მუშაობისას ბევრი დრო დაიხარჯება Ruby-ში კოდის წერაზე. ამ მიზეზით, თქვენ უნდა იცოდეთ ეს ენა ძალიან კარგად, განსაკუთრებით მისი საფუძვლები: მონაცემთა ტიპები, მეთოდები, ობიექტზე ორიენტაცია, გამართვა და მრავალი სხვა. და თქვენ არ უნდა იყოთ ძალიან გამოცდილი Ruby პროგრამისტი - თქვენ უბრალოდ უნდა იგრძნოთ თავდაჯერებულობა მასთან მუშაობისას, როგორც იხვი წყალში.

6. რატომ უნდა ვისწავლო რელსი? რა ხდის მას განსაკუთრებულს?

ეს არის დახვეწილი და უბრალოდ განსაცვიფრებელი. კიდევ რა უნდა იცოდე? როდესაც Rails პირველად გამოჩნდა, ის გახდა დიზაინის ხელოვნების ნამდვილი აღმოჩენა და მიღწევა. საუკეთესო პრაქტიკის გათვალისწინებით, როდესაც ის შეიქმნა, Rails პრაქტიკულად გიბიძგებთ შესანიშნავი კოდის დაწერის გზაზე, მაშინაც კი, როდესაც არ გსურთ (ან არ იცით როგორ).

თუ გსურთ შექმნათ ძლიერი ვებ აპლიკაციები, რომლებიც გაიზრდება საჭიროებისამებრ, ხოლო მომავალში მათი შენარჩუნება მარტივია, Rails შესანიშნავი ვარიანტია. გარდა ამისა, ის პოპულარულია ბევრ მაგარ კომპანიაში. ბოლო მნიშვნელოვანი მიზეზირა ხდის Rails-ს ასე პოპულარულს სტარტაპებში არის ის, რომ ის შესანიშნავია სწრაფი პროტოტიპებისთვის. სულ რამდენიმე საათში შეგიძლიათ წარმოიდგინოთ, შექმნათ და გაუშვათ თქვენთვის საჭირო Rails აპლიკაცია. რეალურად არის ძალიან ცოტა სხვა ჩარჩო, რომელსაც შეუძლია გაუმკლავდეს ამას.

7. რა შეგიძლიათ შექმნათ Rails-ით?

რისი შექმნა გსურთ? Rails განკუთვნილია ნებისმიერი ვებ აპლიკაციისთვის. საილუსტრაციოდ, იხილეთ Rails-ით აშენებული საიტების ეს შესანიშნავი მაგალითები: Hulu, Airbnb და Basecamp.

8. შემიძლია თუ არა მობილური აპლიკაციების შექმნა Rails-ის გამოყენებით?

კი და არა. თქვენ ვერ შეძლებთ მობილური აპლიკაციების შექმნას Rails-ით, მაგრამ Rails-ით თქვენ ნამდვილად შეგიძლიათ შექმნათ ვებ აპლიკაცია და გამოიყენოთ იგი როგორც back-end. მობილური აპლიკაცია.

ასევე არის ინსტრუმენტი სახელწოდებით RubyMotion, რომელიც ძალიან აადვილებს მშობლიური iOS და Android აპლიკაციების შექმნას Ruby-ში (მაგრამ არა Rails). ანუ, თქვენ კონკრეტულად არ გამოიყენებთ Rails-ს მობილური აპლიკაციის შესაქმნელად App Store, მაგრამ Rails ნამდვილად შეიძლება გახდეს თქვენი მნიშვნელოვანი ნაწილი მობილური პროექტი. იმედი მაქვს, სურათი ახლა უფრო ნათელია.

9. Ruby on Rails - რა სახის სამუშაო შემიძლია მივიღო?

Rails ამჟამად ერთ-ერთი ყველაზე მოთხოვნადი უნარ-ჩვევაა, ამიტომ უამრავი კომპანიაა, რომელთაგან უნდა აირჩიოთ სამუშაოდ. სტარტაპებს, როგორიცაა Zearn, განსაკუთრებით უყვართ Rails. ეს არის დამწყები არაკომერციული საგანმანათლებლო IT კომპანია. თქვენ ასევე შეგიძლიათ აირჩიოთ მეტი დიდი კომპანიამოსწონს ბლუმბერგი და მონაწილეობა მიიღოს ვებსაიტების და აპლიკაციების შემუშავებაში, რომელსაც იყენებს მილიონობით მომხმარებელი. Freelancing ასევე კარგი ვარიანტია Rails-ის დეველოპერებისთვის. დამოუკიდებლად ყოფნისას თქვენ შეძლებთ აირჩიოთ რომელ პროექტებში გსურთ მონაწილეობა: მცირე და მოკლევადიანი თუ სერიოზული და გრძელვადიანი.

10. სხვა პროგრამირების ენა ვცადე, მაგრამ არ მომეწონა. რელსი უნდა ვცადო?

კიდევ ერთხელ მინდა ხაზგასმით აღვნიშნო – Rails, ფაქტობრივად, პროგრამირების ენა კი არა, ჩარჩოა. თუ ოდესმე გიფიქრიათ, აზრი აქვს თუ არა რაიმე პროგრამირების ენის შეყვარებას, მხოლოდ ის შემიძლია ვთქვა, რომ Ruby არის ყველაზე პატივსაცემი და მომხმარებლისთვის საყვარელი პროგრამირების ენა მსოფლიოში. ასე რომ, მე არ დავწერ პროგრამირებას მანამ, სანამ Ruby-ს არ გამოსცადე.

11. უნდა ვისწავლო JavaScript რეილსთან ერთად?

სამაგიეროდ - არა. დამატებით - უდავოდ.

Rails-ის დეველოპერს მოუწევს ისწავლოს JavaScript(). ეს არ არის რელსების სწავლის მოთხოვნა, მაგრამ ეს არის უნარი, რომელიც დაგჭირდებათ სწავლის დროს.

მოდით ვიყოთ გულახდილები, როცა თანდათან უფრო ღრმავდებით ტექნოლოგიურ სფეროში, დაიწყებთ იმის გაცნობიერებას, რომ მოგიწევთ საკმაოდ ბევრი უნარ-ჩვევების ფლობა (ძირითადად, ეს ნიშნავს, რომ ყველა უნდა იბრძოდეს იყოს Full-Stack Developer). საბედნიეროდ, გამოცდილების მიღებისას გაგიადვილდებათ როგორც ახალი ენების, ასევე ახალი ჩარჩოების სწავლა.

რაც შეეხება არჩევას JavaScript თუ Rails, პირდაპირ გეტყვით, რომ ვერც ერთნაირად ვერ შეცდებით. Ruby-ის სწავლა ბევრად უფრო ადვილია, ვიდრე JavaScript. გარდა ამისა, მე ვიცნობ ბევრ ადამიანს, ვინც იპოვა JavaScript უფრო მარტივი მას შემდეგ, რაც ისწავლეს Ruby. მაგრამ, როგორც ზემოთ ვთქვი, თქვენ ნამდვილად არ შეცდებით, თუ ორივეს ისწავლით.

12. რამდენ ხანს გაგრძელდება ტრენინგი?

დღეში რამდენი დრო მოგიწევთ სწავლისთვის? ვფიქრობ, Rails-ის კარგი გაგება მოითხოვს რამდენიმე თვიან ერთგულ ტრენინგს. მაგრამ, როგორც ნებისმიერი სხვა უნარი, თქვენ დაგჭირდებათ ათიათასობით საათი იმისათვის, რომ გახდეთ Rails-ის პროფესიონალი, ამიტომ უმჯობესია დაიწყოთ ახლავე.

თქვენს სწავლის სიჩქარეზე დიდ გავლენას მოახდენს თქვენი ცოდნის დონე ზოგადად პროგრამირების სფეროში. მაგრამ თუ სრულიად დამწყები ხართ, ღირს სცადოთ დაიწყოთ Ruby და Rails.

13. Ruby on Rails – საიდან დავიწყოთ?

გირჩევთ დაიწყოთ დღეს არსებული საუკეთესო Ruby on Rails კურსით. თუ თქვენს ცხოვრებაში არ დაგიწერიათ კოდის ხაზი, პირველი რაც უნდა გააკეთოთ არის HTML და CSS კურსის გავლა. საბედნიეროდ, საკმაოდ მარტივია HTML და CSS კურსების პოვნა. ამის შემდეგ, თქვენ უნდა ისწავლოთ Ruby, Git და ბრძანების ხაზი.

ტრენინგის პროგრამა, როგორც წესი, გაგაცნობთ Rails-ს ეტაპობრივად და გაჩვენებთ, თუ როგორ უნდა იმუშაოთ Sinatra-სთან და ActiveRecord-თან. ეს ჯერ ვერაფერს გეტყვით, მაგრამ საქმე ისაა, რომ სანამ იმ „სატვირთო მანქანას“ აზიდავ, რომელიც ადრე აღვნიშნე, უნდა დაიწყო მარტივი კურსებირელსებზე მართვა.

სწავლის დროს საუკეთესო რამ არის საკუთარი პროექტის შექმნა, რაღაცაზე მუშაობა და განვითარება, იმის გაგება, რომ სწორი მიმართულებით მოძრაობ და ასევე გქონდეს კარგი მხარდაჭერა! სასწავლო პროცესის განმავლობაში თქვენ გექნებათ მილიონობით პატარა კითხვა და მიაღწიეთ საუკეთესო შედეგიმნიშვნელოვანია, რომ გყავდეთ ვინმე, რომელიც დაგეხმარებათ ამის გარკვევაში და მოგცეთ რჩევა, თუ სირთულეები წარმოიქმნება.

ალექსანდრე არის ვებ-გვერდის პროექტის "წარმატების ვებ ლაბორატორიის" დამფუძნებელი, რომელიც შეიქმნა დამწყები და მუდმივი ინტერნეტ მეწარმეების მხარდასაჭერად. ძირითადი საქმიანობა: ბიზნესის (მათ შორის ონლაინ მაღაზიების) პოპულარიზაცია ფეისბუქის და Google Adwords. მთავარი ჰობი: ვებსაიტების მონეტიზაცია შვილობილი მარკეტინგის ინსტრუმენტებისა და Google Adsense-ის მეშვეობით. პირადი დადასტურებული ჩანაწერები: ბლოგის 3 მილიონი ვიზიტორი თვეში.

2012 წლის 13 თებერვალი, 04:06 სთ

რელსების სწავლის საუკეთესო გზა

• Ruby on Rails

კარგი დღე!

წინასიტყვაობა

ოდესღაც მინდოდა რელსის უკეთ გაცნობა, მაგრამ არ ვიცოდი საიდან დამეწყო, სანამ ეს სტატია არ მომხვდა თვალში. შემდეგ ნახავთ თარგმანს, რომელიც შერეულია ჩემს გამოცდილებასთან და ჩემს საკუთარ ლექსიკურ და ფრაზეოლოგიურ გამონათქვამებთან. მაშ, წავიდეთ.

შესავალი

მაქვს PHP-თან მუშაობის დიდი გამოცდილება, მაგრამ ახლა ვმუშაობ Rails-ის დეველოპერად. ყველაზე დიდი გამოწვევა ადამიანების უმეტესობისთვის, რომლებიც ცდილობენ ისწავლონ რაიმე ახალი, არის თავად სწავლის პროცესი. როდესაც თქვენ ფლობთ ენას ან ჩარჩოს და იცით ეს შიგნიდან და გარედან, ახალზე გადასვლა საჭირო არ ჩანს.

თუმცა, Ruby on Rails-ის სწავლა საკმაოდ მარტივია. ეს წარმოუდგენლად ძლიერი ჩარჩოა, რომელსაც უზარმაზარი საზოგადოება უბიძგებს მას წინ. ასე რომ, ჩვენ გვაქვს კითხვა: რა არის საუკეთესო გზა რელსების შესასწავლად? აი - გაკვეთილის გეგმა.

ეს სტატია არის სრული გეგმასაჭირო გაკვეთილები იმისათვის, რომ გაეცნოთ Rails-ს და დაიწყოთ მასთან მუშაობა უმოკლეს დროში. ყველაფერი რაც თქვენ უნდა გააკეთოთ არის ქვემოთ მოცემული ნაბიჯების შესრულება, რომლებიც ჩამოთვლილია თანმიმდევრობით.

წერტილი 1: სავარჯიშოებთან მუშაობა Try Ruby-ში

შეიძლება ფიქრობთ, რომ რუბის სწავლა აქ საუკეთესოა მნიშვნელოვანი ნაბიჯი, მაგრამ ეს ასე არ არის. ზოგიერთი მათგანი, ვინც რუბის დეტალურ შესწავლას იწყებს, შეწყვეტს სწავლას და უბრალოდ რჩება მუშაობასთან მიმდინარე ენადა ჩარჩო. არ გააკეთო ეს!. ნუ შეგეშინდებათ ამ ენის (ან სხვა) სწავლის. Ruby არის სახალისო, შესანიშნავი და ადვილად შესასწავლი ენა. გარდა ამისა, არ დაგავიწყდეთ, რომ თქვენ არ გჭირდებათ მისი 100% შესწავლა. თქვენ უბრალოდ უნდა იცოდეთ საფუძვლები.

ყველაზე რეკომენდირებული ინსტრუმენტი რუბის სინტაქსში ჩასასვლელად არის TryRuby ვებსაიტი. ის უზრუნველყოფს ინტერაქტიულ გარემოს, რომელიც საშუალებას გაძლევთ სცადოთ სინტაქსი მოქმედებაში. თუ აკრიფეთ დახმარება, მოწვეული იქნებით თხუთმეტწუთიანი გაკვეთილის საყურებლად, რომელიც გასწავლით საფუძვლებს. არ დაგავიწყდეთ, რომ სახელმძღვანელოს აქვს ორი თავი, რომელთა წაკითხვა შეგიძლიათ აკრეფით დახმარება 2.

თუ ამ ამოცანებზე დიდი ხნის განმავლობაში იმუშავებთ, გექნებათ კარგი ბაზაცოდნა. პირველი რაც გავაკეთე ეს ორი სახელმძღვანელოს შესწავლა იყო. დანარჩენი ვისწავლე Rails-ზე საიტების შემუშავების პროცესში, ასევე Googling-ით და IRB-თან ვარჯიშით.

წერტილი 2: Ruby-ისა და Ruby-ის დაყენება Rails-ზე

თუ გსურთ Rails-ის სწავლა, მაშინ უეჭველად მოგიწევთ დააინსტალიროთ იგი თქვენს კომპიუტერში. აქ მოცემულია რამდენიმე გამოსავალი იმის მიხედვით, თუ რა OS გაქვთ. თუ თქვენ გაქვთ Mac ან Linux-ზე დაფუძნებული კომპიუტერი, გირჩევთ გამოიყენოთ RVM. ეს შესანიშნავი ინსტრუმენტია Ruby-ის ინსტალაციისთვის. სინამდვილეში, აქ არის ინსტრუქციები თავად ინსტალაციისთვის. თუ თქვენ გაქვთ Windows, მაშინ თქვენ უნდა გამოიყენოთ RubyInstaller.

შემდეგი ნაბიჯი არის თავად Rails-ის დაყენება. ამისათვის თქვენ უნდა დააინსტალიროთ RubyGems. თუ იყენებთ RVM-ს, მაშინ გილოცავთ - თქვენ უკვე გაქვთ დაინსტალირებული RubyGems. თუ თქვენ გაქვთ Windows, მაშინ გირჩევთ, აქ მიჰყვეთ. Rails-ის დასაყენებლად საჭიროა გამოიყენოთ ბრძანება ძვირფასი ქვის დამონტაჟების რელსებიდა შემდეგ ყველაფერი კეთდება!

პუნქტი 3: წაიკითხეთ ჯეფრი უეის შესავალი რელსებზე

ამ 40-წუთიან ეკრანიზაციაში ჯეფრი ვეი გაგაცნობთ იმას, რაც უნდა იცოდეთ Rails-ის გამოსაყენებლად. ის შეიცავს უამრავ სასარგებლო ინფორმაციას, მათ შორის ისეთი თემების ჩათვლით, როგორიცაა:

• მოდელები და გენერატორები
• ტესტზე ორიენტირებული განვითარება (TDD)
• ActiveRecord
• RSpec და Capybara
• ნაწილობრივი

და ბევრად მეტი...

წერტილი 4: გაიარეთ Rails For Zombies კურსი

მე ყოველთვის ვფიქრობდი, რომ მაგალითით სწავლა საუკეთესო საშუალებაა ენის ან ჩარჩოს შესასწავლად. უფასო და წარმოუდგენლად ძლიერი კურსი, რომელიც აუცილებლად უნდა ნახოთ, არის Rails For Zombies, შექმნილი EnvyLabs-ის ბიჭების მიერ. ეს კურსი არის ინტერაქტიული, რაც ნიშნავს, რომ თითოეული ვიდეოს ნახვის შემდეგ იმუშავებთ სასარგებლო და საინტერესო სავარჯიშოებზე.

ამ დრომდე გეუბნებოდი ინტერაქტიულ და უფასო ინსტრუმენტებზე. ფასდაკლების დრო დასრულდა! ახლა თქვენ უნდა შეიძინოთ წიგნი სახელწოდებით Agile Web Development with Rails. ის შექმნილია იმისთვის, რომ გასწავლოთ როგორ გამოიყენოთ Rails ვებსაიტის ნულიდან შექმნით. ის გადადის საფუძვლებზე, როგორიცაა კონტროლერები, მოდელები, ხარაჩოები, ფუნქციონალური ტესტირება და ასევე ცოტა AJAX. შეიძინეთ სულ მცირე უახლესი გამოცემა.

წერტილი 6: შექმენით მარტივი ბლოგი

ვიცი, რომ ეს საკმაოდ მოსაწყენად ჟღერს ( მაინცჩემთვის), მაგრამ ეს შესანიშნავი მაგალითი, რომელიც ყველგან გამოიყენება, რადგან საკმაოდ მარტივი და სწრაფი წერაა. ამ გზის გაყოლებით, თქვენ დაგეხმარებით თქვენი ცოდნისა და უნარების კონსოლიდაციაში. მაგრამ მე გირჩევთ, რომ არ გააკეთოთ კოპირ-პასტი (ამით ვერაფერს მიაღწევთ, გარდა შესაძლოა 10 წუთის დახარჯული ელექტროენერგიის გარდა), მაგრამ შეეცადეთ დაწეროთ თანდათანობით, მეხსიერებიდან, ზოგჯერ უბრალოდ შეხედეთ წიგნს, რომ ნახოთ როგორ ესა თუ ის მეთოდი მუშაობს.

წერტილი 7: დაამატეთ ახალი ფუნქციები თქვენს ბლოგს

ზღაპრული! ბოლოს და ბოლოს შენ ააშენე შენი? საკუთარი ბლოგი. და მაინც, მას არ აქვს სრულფასოვანი ფუნქციონირება, მაგრამ მხოლოდ წარმოადგენს ყველა ბლოგში თანდაყოლილ ძირითად ფუნქციებს. კარგი, მოდით ცოტა ვიმუშაოთ და დავამატოთ ავტორიზაციის სისტემა.

ახლა ნამდვილად არ მინდა გაიძულებთ რაიმე რთული გააკეთოთ, რადგან უკვე ბევრი იმუშავეთ. თქვენ შეგიძლიათ გამოიყენოთ მზა ძვირფასი ქვა (მაგალითად, Omniauth), როგორც ავთენტიფიკაციის სისტემა. ამავდროულად, თქვენ გაერკვევით, თუ როგორ განახორციელოთ ძვირფასი ქვები თქვენს პროექტში.

მე ასევე გირჩევთ ამ ეკრანის ყურებას რაიან ბეიტსისგან, რომელიც აღწერს მარტივი ავტორიზაციის სისტემის შექმნას ნულიდან. სისტემის დანერგვის შემდეგ თქვენ უნდა დაამატოთ პოსტების წაშლის/რედაქტირების შესაძლებლობა, თუ ეს უკვე არ გაგიკეთებიათ. თუ დავალება უკვე დასრულებულია, მაშინ დროა გადავიდეთ შემდეგ პუნქტზე.

წერტილი 8: შექმენით რაღაც საკუთარი

ამ ეტაპზე დროა გახდეთ უფრო კრეატიული და იფიქროთ რაიმე სახის სერვისის შექმნაზე (მაგალითად, ფოტო ჰოსტინგი). არ შეჩერდეთ თქვენი მეორე ვებსაიტის დიზაინზე. წაიღეთ რაღაც მზა. მაგალითად,

ეს სახელმძღვანელო მოიცავს Ruby on Rails-ის ინსტალაციას და გაშვებას.

წაკითხვის შემდეგ გაიგებთ:

• როგორ დააინსტალიროთ Rails, შექმნათ ახალი Rails აპლიკაცია და მიამაგროთ თქვენი აპლიკაცია მონაცემთა ბაზაში.
• Rails განაცხადის ზოგადი სტრუქტურა.
• MVC (მოდელი, ხედის კონტროლერი) და RESTful დაფუძნებული დიზაინის ძირითადი პრინციპები.
• როგორ სწრაფად შევქმნათ საწყისი კოდი Rails აპლიკაციისთვის.

ვარაუდები ამ სახელმძღვანელოში

ეს გაკვეთილი განკუთვნილია დამწყებთათვის, რომელთაც სურთ დაიწყონ Rails აპლიკაცია ნულიდან. არ ვარაუდობს, რომ თქვენ ადრე მუშაობდით Rails-თან.

Rails არის ვებ განვითარების ჩარჩო, რომელიც დაწერილია Ruby პროგრამირების ენაზე. თუ არ გაქვთ Ruby-ის გამოცდილება, შეიძლება გაგიჭირდეთ Rails-ის სწავლაში გადასვლა. არსებობს რამდენიმე კარგი ინგლისურენოვანი რესურსი, რომელიც ეძღვნება რუბის სწავლას, მაგალითად:

გთხოვთ გაითვალისწინოთ, რომ ზოგიერთი რესურსი, მიუხედავად იმისა, რომ ჯერ კიდევ შესანიშნავია, მაინც მოიცავს Ruby-ის ძველ ვერსიებს, როგორიცაა 1.6 და განსაკუთრებით 1.8, და არ შეიცავს ზოგიერთ სინტაქსს, რომელსაც ნახავთ ყოველდღიურ Rails-ის განვითარებაში.

რა არის რელსი?

Rails არის ვებ განვითარების ჩარჩო, რომელიც დაწერილია Ruby პროგრამირების ენაზე. ის შექმნილია იმისათვის, რომ გააადვილოს ვებ აპლიკაციების პროგრამირება მრავალი ვარაუდით იმის შესახებ, თუ რა სჭირდება თითოეულ დეველოპერს ახალი პროექტის შესაქმნელად. ის საშუალებას გაძლევთ დაწეროთ ნაკლები კოდი პროგრამირების დროს სხვა ენებთან და ჩარჩოებთან შედარებით. Professional Rails-ის დეველოპერები ასევე აღნიშნავენ, რომ ეს უფრო სახალისოს ხდის ვებ აპლიკაციების შემუშავებას =)

Rails არის უაზრო პროგრამული უზრუნველყოფა. ის აყენებს ვარაუდს, რომ არსებობს რაღაცის გაკეთების „უკეთესი“ გზა და ის ისეა შექმნილი, რომ ამ გზით წაახალისოს - და ზოგიერთ შემთხვევაში ალტერნატივებსაც კი აფერხებს. თუ ისწავლით "The Rails Way", თქვენ შეგიძლიათ აღმოაჩინოთ პროდუქტიულობის მნიშვნელოვანი მიღწევები. თუ თქვენ განაგრძობთ ძველი ჩვევების შემოტანას სხვა ენებიდან Rails-ის განვითარებაში და შეეცდებით გამოიყენოთ სხვაგან ნასწავლი ნიმუშები, გექნებათ ნაკლებად ბედნიერი განვითარების გამოცდილება.

Rails-ის ფილოსოფია მოიცავს ორ მნიშვნელოვან სახელმძღვანელო პრინციპს:

• არ გაიმეორო საკუთარი თავი: DRY არის პროგრამული უზრუნველყოფის განვითარების პრინციპი, რომელიც აცხადებს, რომ „თითოეულ ინფორმაციას უნდა ჰქონდეს ერთიანი, არაზედმეტი, ავტორიტეტული წარმომადგენლობა სისტემაში“. ნუ დაწერთ ერთსა და იმავე ინფორმაციას განმეორებით, კოდის შენარჩუნება უფრო ადვილი იქნება და უფრო გაფართოებული და ნაკლებად აურზაური.
• კონვენცია კონფიგურაციაზე: Rails-ს აქვს მოსაზრებები ვებ-აპლიკაციაში ბევრი საქმის გასაკეთებლად საუკეთესო გზებზე და ნაგულისხმევია ამ კონვენციების შესაბამისად, ვიდრე აიძულებს თქვენ შეცვალოთ მრავალი კონფიგურაციის ფაილი.

ახალი რელსის პროექტის შექმნა

ამ სახელმძღვანელოს გამოყენების საუკეთესო გზაა მისი ეტაპობრივად გავლა. ყველა ნაბიჯი აუცილებელია მაგალითის აპლიკაციის გასაშვებად, გარდა ამისა, დამატებითი ნაბიჯები არ არის საჭირო. დამატებითი კოდიან ნაბიჯები.

ამ გაკვეთილის შემდეგ, თქვენ შექმნით Rails პროექტს, სახელწოდებით ბლოგი, ძალიან მარტივი ვებ ბლოგი. სანამ აპლიკაციის შექმნას დავიწყებთ, უნდა დავრწმუნდეთ, რომ თავად Rails არის დაინსტალირებული.

შემდეგი მაგალითები იყენებს $ ტერმინალის შეყვანის ხაზს UNIX-ის მსგავსი ოპერაციული სისტემებიაჰ, თუმცა შეიძლება სხვაგვარად იყოს კონფიგურირებული. თუ იყენებთ Windows-ს, ხაზი გამოიყურება რაღაც c:\source_code>

3.1. რელსების დაყენება

Rails-ის დაყენებამდე უნდა დარწმუნდეთ, რომ თქვენს სისტემაზე დაყენებულია საჭირო წინასწარი დამოკიდებულებები. მათ შორისაა Ruby და SQLite3.

გახსენით აპლიკაციები ბრძანების ხაზი. macOS-ზე გახსენით Terminal.app, Windows-ზე აირჩიეთ "Run" საწყისი მენიუდან და ჩაწერეთ "cmd.exe". $$ ნიშნით დაწყებული ნებისმიერი ბრძანება უნდა იყოს გაშვებული ბრძანების სტრიქონზე. დარწმუნდით, რომ დააინსტალირეთ მიმდინარე ვერსიარუბი:

$ რუბი - v რუბი 2.5.0

Rails მოითხოვს Ruby ვერსიის 2.4.1 ან უფრო ახალი ინსტალაციისთვის. თუ ვერსიის ნომერი ამაზე ნაკლებია, დაგჭირდებათ ინსტალაცია ახალი ასლირუბი.

სისტემაზე Ruby-ისა და Ruby on Rails-ის სწრაფად დასაყენებლად, Windows-ის მომხმარებლებს შეუძლიათ გამოიყენონ Rails Installer. ოპერაციული სისტემების უმეტესობისთვის ინსტალაციის დამატებითი მეთოდები შეგიძლიათ იხილოთ ruby-lang.org-ზე.

თუ Windows-ზე მუშაობთ, უნდა დააინსტალიროთ Ruby Installer Development Kit.

თქვენ ასევე დაგჭირდებათ SQLite3 მონაცემთა ბაზის ინსტალაცია.

ბევრი პოპულარული UNIX-ის მსგავსი OS-ები იგზავნება SQLite3-ის გონივრული ვერსიით. Windows-ზე, თუ Rails დააინსტალირეთ Rails Installer-ის გამოყენებით, თქვენ უკვე გაქვთ დაინსტალირებული SQLite. სხვა მომხმარებლებს შეუძლიათ მიმართონ SQLite3 ვებსაიტს ინსტალაციის ინსტრუქციებისთვის. შეამოწმეთ, რომ ის სწორად არის დაინსტალირებული და შეიცავს თქვენს PATH-ში:

$sqlite3 --ვერსია

პროგრამამ უნდა მოახსენოს თავისი ვერსია.

Rails-ის ინსტალაციისთვის გამოიყენეთ RubyGems-ის მიერ მოწოდებული gem install ბრძანება:

$ ძვირფასი ქვის სამონტაჟო რელსები

იმის შესამოწმებლად, რომ ყველაფერი სწორად არის დაინსტალირებული, თქვენ უნდა გააკეთოთ შემდეგი:

$rails --ვერსია

თუ ის ამბობს რაღაცას "Rails 5.1.1", შეგიძლიათ გააგრძელოთ.

3.2. ბლოგის აპლიკაციის შექმნა

Rails მოყვება რამდენიმე სკრიპტს, სახელწოდებით გენერატორები, რომლებიც შექმნილია დეველოპერების ცხოვრების გასაადვილებლად, კონკრეტული ამოცანის დასაწყებად საჭირო ყველაფრის გენერირებით. ერთ-ერთი მათგანია ახალი აპლიკაციის გენერატორი, რომელიც გაძლევთ Rails-ის აპლიკაციის ჩარჩოს, ასე რომ თქვენ არ მოგიწევთ მისი დაწერა.

ამ გენერატორის გამოსაყენებლად გახსენით ტერმინალი, გადადით საქაღალდეში, სადაც გაქვთ ფაილების შექმნის უფლება და დაწერეთ:

$rails ახალი ბლოგი

ეს შექმნის Rails აპლიკაციას სახელად Blog ბლოგის დირექტორიაში და დააინსტალირებს ძვირფასი ქვები, რომელთა დამოკიდებულებები ნახსენებია Gemfile-ში, როდესაც პაკეტის გამოყენებითდააინსტალირეთ.

ზე Windows-ის გამოყენებითქვესისტემა Linux-ისთვის, არსებობს გარკვეული შეზღუდვები ფაილური სისტემის შეტყობინებებზე, რაც ნიშნავს, რომ უნდა გამორთოთ Spring და მოუსმინოთ ძვირფასი ქვებს, რაც შეგიძლიათ გააკეთოთ ახალი ბლოგის რელსების გაშვებით --skip-spring --skip-listen .

თქვენ შეგიძლიათ იხილოთ ბრძანების ხაზის ყველა შესაძლო ვარიანტი, რომელსაც Rails აპლიკაციის შემქმნელი იღებს რელსების ახალი -h გაშვებით.

ბლოგის აპლიკაციის შექმნის შემდეგ გადადით მის საქაღალდეში:

ბლოგის დირექტორია შეიცავს რამდენიმე ავტომატურად გენერირებულ ფაილს და საქაღალდეს, რომლებიც განსაზღვრავენ Rails აპლიკაციის სტრუქტურას. ამ სახელმძღვანელოში სამუშაოს უმეტესი ნაწილი განხორციელდება აპლიკაციის საქაღალდეში, მაგრამ ახლა მოდით გადავიდეთ თითოეული საქაღალდის ფუნქციებზე, რომელსაც Rails ქმნის ახალ აპლიკაციაში ნაგულისხმევად:

ფაილი/საქაღალდე	მიზანი
აპლიკაცია/	შეიცავს კონტროლერებს, მოდელებს, ხედებს, დამხმარეებს, მეილერებს, არხებს, სამუშაოებს და თქვენი განაცხადის აქტივებს. ამ საქაღალდეს უფრო დეტალურად განვიხილავთ შემდეგში.
ურნა/	შეიცავს Rails-ის სკრიპტებს, რომლებიც იწყებენ თქვენს აპლიკაციას და დირექტორია შეიძლება ასევე შეიცავდეს სხვა სკრიპტებს, რომლებსაც იყენებთ კონფიგურაციის, განახლების, განლაგების ან გასაშვებად.
კონფიგურაცია/	მარშრუტის კონფიგურაციები, თქვენი აპლიკაციის მონაცემთა ბაზა და ა.შ. ეს უფრო დეტალურად არის აღწერილი რელსების აპლიკაციების კონფიგურაციაში
config.ru	Rack-ის კონფიგურაცია Rack-ზე დაფუძნებული სერვერებისთვის, რომლებიც გამოიყენება აპლიკაციის გასაშვებად. Rack-ის შესახებ დამატებითი ინფორმაციისთვის ეწვიეთ Rack ვებსაიტს.
დბ/	შეიცავს თქვენი მიმდინარე მონაცემთა ბაზის სქემას, ასევე მონაცემთა ბაზის მიგრაციას.
Gemfile Gemfile.lock	ეს ფაილები საშუალებას გაძლევთ მიუთითოთ რომელი ძვირფასი ქვების დამოკიდებულებები სჭირდება თქვენს Rails აპლიკაციას. ეს ფაილები გამოიყენება Bundler Gem-ის მიერ. Bundler-ის შესახებ დამატებითი ინფორმაციისთვის ეწვიეთ Bundler ვებსაიტს.
lib/	გარე მოდულები თქვენი აპლიკაციისთვის.
შესვლა/	განაცხადის ჟურნალის ფაილები.
პაკეტი.json	ეს ფაილი საშუალებას გაძლევთ მიუთითოთ რომელი npm დამოკიდებულებებია საჭირო თქვენი Rails აპლიკაციისთვის. ეს ფაილი გამოიყენება Yarn-ის მიერ. ნარნის შესახებ დამატებითი ინფორმაციისთვის ეწვიეთ ნართის ვებსაიტს.
საჯარო/	ერთადერთი საქაღალდე, რომელიც ხელმისაწვდომია გარედან, როგორც არის. შეიცავს სტატიკურ ფაილებს და კომპილირებული აქტივებს.
რაკეფაილი	ეს ფაილი პოულობს და ატვირთავს ამოცანებს, რომელთა შესრულებაც შესაძლებელია ბრძანების სტრიქონზე. კონკრეტული დავალება ხელმისაწვდომია Rails-ის ყველა კომპონენტში. Rakefile-ის შეცვლის ნაცვლად, შეგიძლიათ დაამატოთ თქვენი საკუთარი ამოცანები აპლიკაციის lib/tasks დირექტორიაში ფაილების დამატებით.
README.md	ეს არის თქვენი განაცხადის შესავალი გზამკვლევი. ის უნდა იყოს რედაქტირებული, რათა სხვებს უთხრათ რას აკეთებს თქვენი აპლიკაცია, როგორ დააკონფიგურიროთ იგი და ა.შ.
შენახვა/	აქტიური შენახვის ფაილები დისკის სერვისისთვის. ეს მოცემულია აქტიური მეხსიერების მიმოხილვის სახელმძღვანელოში.
ტესტი/	ერთეულის ტესტები, მოწყობილობები და სხვა სატესტო აპარატურა. ეს მოცემულია ტესტირების რელსების აპლიკაციების სახელმძღვანელოში.
tmp/	დროებითი ფაილები (როგორიცაა ქეში და pid ფაილები)
გამყიდველი/	ადგილი მესამე მხარის კოდისთვის. რელსების ტიპურ აპლიკაციაში, ის მოიცავს გარე ძვირფას ქვებს.
.გიგინორე	ეს ფაილი ეუბნება git-ს, თუ რომელი ფაილი (მკაფიოდ ან დიზაინით) უნდა იგნორირება. ფაილების იგნორირებასთან დაკავშირებით დამატებითი ინფორმაციისთვის იხილეთ GitHub - ფაილების იგნორირება.
.რუბი-ვერსია	ეს ფაილი შეიცავს Ruby-ის ნაგულისხმევ ვერსიას.

გამარჯობა რელსები!

პირველ რიგში, მოდით გამოვაჩინოთ ტექსტი ეკრანზე. ამისათვის თქვენ გჭირდებათ გაშვებული სერვერი თქვენი Rails აპლიკაციისთვის.

4.1. ვებ სერვერის გაშვება

სინამდვილეში თქვენ უკვე გაქვთ ფუნქციური აპლიკაციარელსებზე. დარწმუნებისთვის, თქვენ უნდა გაუშვათ ვებ სერვერი თქვენს აპარატზე. ეს შეიძლება გაკეთდეს ბლოგის დირექტორიადან შემდეგი ბრძანების გაშვებით:

$ bin/rails სერვერი

თუ იყენებთ Windows-ს, უნდა გადასცეთ სკრიპტები ბინ საქაღალდეებიპირდაპირ Ruby თარჯიმანში, ანუ Ruby bin\rails სერვერზე.

CoffeeScript-ის შედგენა და JavaScript აქტივების შეკუმშვა მოითხოვს გარემოს JavaScript-ის შესრულებათქვენს სისტემაზე და მისი არარსებობა გამოიწვევს execjs შეცდომას აქტივების შედგენისას. როგორც წესი, MacOS და Windows მოყვება ჩამოყალიბებული გარემო JavaScript-ის შესრულება. Rails ამატებს mini_racer ძვირფასეულობას ახალი აპლიკაციის გენერირებულ Gemfile-ში, საჭიროების შემთხვევაში, შეგიძლიათ გააუქმოთ იგი. therubyrhino არის რეკომენდირებული გაშვების დრო JRuby-ის მომხმარებლებისთვის და ემატება Gemfile-ს, თუ აპლიკაცია გენერირდება JRuby-ის ქვეშ. თქვენ შეგიძლიათ გაიგოთ ყველაფერი ExecJS-ში მხარდაჭერილი გაშვებების შესახებ

ეს გამოუშვებს Puma-ს, ვებ სერვერს, რომელიც განაწილებულია Rails-ით ნაგულისხმევად. განაცხადის მოქმედებაში სანახავად გახსენით ბრაუზერის ფანჯარა და გადადით http://localhost:3000. თქვენ უნდა ნახოთ ნაგულისხმევი ინფორმაციის გვერდირელსები:

ვებ სერვერის შესაჩერებლად დააჭირეთ Ctrl+C ტერმინალში, სადაც ის მუშაობს. სერვერის გაჩერების დასადასტურებლად, კვლავ უნდა ნახოთ ბრძანების ხაზის კურსორი. უმეტესობისთვის UNIX-ის მსგავსი სისტემები, MacOS-ის ჩათვლით, ეს იქნება დოლარის ნიშანი $. განვითარების რეჟიმში, Rails ზოგადად არ მოითხოვს სერვერის გაჩერებას; ყველა ცვლილება, რომელსაც თქვენ განახორციელებთ ფაილებში, ავტომატურად აისახება სერვერის მიერ.

Welcome Aboard გვერდი არის ერთგვარი ტესტი ახალი Rails აპლიკაციისთვის: ის აჩვენებს, რომ თქვენი პროგრამები საკმარისად სწორად არის კონფიგურირებული გვერდის საჩვენებლად.

4.2. მიესალმები რელსს

იმისათვის, რომ რელსმა თქვას "გამარჯობა", თქვენ უნდა შექმნათ მინიმუმ კონტროლერიდა ხედი(სპექტაკლი).

კონტროლერის მიზანია განაცხადისადმი კონკრეტული მოთხოვნების მიღება. მარშრუტიზაციაწყვეტს რომელი კონტროლერი რომელ თხოვნებს მიიღებს. ხშირად არის ერთზე მეტი მარშრუტი თითოეულ კონტროლერთან და სხვადასხვა მარშრუტი შეიძლება განსხვავებულად დამუშავდეს მოქმედება. თითოეული მოქმედების მიზანია ინფორმაციის შეგროვება ხედვისთვის.

ხედის მიზანია ამ ინფორმაციის ჩვენება ადამიანისთვის წასაკითხად ფორმატში. მნიშვნელოვანი განსხვავებაა ის, რომ არის ადგილი, სადაც ინფორმაცია გროვდება კონტროლერი, არა ხედი. ხედში მხოლოდ ეს ინფორმაცია უნდა იყოს ნაჩვენები. ნაგულისხმევად, ხედვის შაბლონები იწერება ენაზე, სახელწოდებით eRuby (Embedded Ruby), რომელიც გარდაიქმნება Rails-ის მოთხოვნის ციკლის მიერ მომხმარებლისთვის გაგზავნამდე.

ახალი კონტროლერის შესაქმნელად, თქვენ უნდა გაუშვათ "კონტროლერის" გენერატორი და უთხრათ, რომ გსურთ კონტროლერი სახელწოდებით "Welcome" მოქმედებით სახელწოდებით "index", ასე:

$ bin/rails გენერირება კონტროლერი მისასალმებელი ინდექსი

Rails შექმნის რამდენიმე ფაილს და მარშრუტს.

შექმენით app/controllers/welcome_controller.rb მარშრუტი მიიღეთ "welcome/index" გამოძახება erb შექმნა app/views/welcome შექმნა app/views/welcome/index.html.erb invoke test_unit შექმნა test/controllers/welcome_controller_test.rb გამოძახება დამხმარე აპის შექმნა/ helpers/welcome_helper.rb გამოძახება test_unit გამოძახება აქტივების გამოძახება ყავის შექმნა app/assets/javascripts/welcome.ყავის გამოძახება scss შექმნა app/assets/stylesheets/welcome.scss

მათგან ყველაზე მნიშვნელოვანია, რა თქმა უნდა, კონტროლერი, რომელიც მდებარეობს app/controllers/welcome_controller.rb-ში და ხედი, რომელიც მდებარეობს app/views/welcome/index.html.erb-ში.

გახსენით ფაილის app/views/welcome/index.html.erb ტექსტურ რედაქტორში. წაშალეთ ყველა არსებული კოდი ფაილში და შეცვალეთ იგი შემდეგი კოდის ხაზით:

თუ კვლავ გაგზავნით ფორმას, დაინახავთ შემდეგს:

"პირველი სტატია!", "text"=>"ეს ჩემი პირველი სტატიაა.") დასაშვებია: false>

ახლა ეს მოქმედება აჩვენებს ფორმიდან მოსულ სტატიის პარამეტრებს. თუმცა მაინც უსარგებლოა. დიახ, თქვენ ხედავთ პარამეტრებს, მაგრამ რეალურად არაფერს აკეთებთ მათთან.

5.4. სტატიის მოდელის შექმნა

Rails-ში მოდელები იყენებენ სინგულარულ სახელს, ხოლო მონაცემთა ბაზაში მათი შესაბამისი ცხრილი იყენებს მრავლობით სახელს. Rails უზრუნველყოფს მოდელის გენერატორს, რომელსაც Rails-ის დეველოპერების უმეტესობა იყენებს ახალი მოდელების შესაქმნელად. ახალი მოდელის შესაქმნელად, გაუშვით ეს ბრძანება თქვენს ტერმინალში:

$ bin/rails მოდელის გენერირება სტატიის სათაური: სიმებიანი ტექსტი: ტექსტი

ამ ბრძანებით ჩვენ ვეუბნებით Rails-ს, რომ გვსურს მუხლის მოდელი ატრიბუტით სათაურისტრიქონის ტიპი და ატრიბუტი ტექსტიტექსტის ტიპი. ეს ატრიბუტები ავტომატურად დაემატება სტატიების ცხრილში და შეკრული იქნება სტატიის მოდელთან.

Rails უპასუხებს ფაილების სერიის შექმნით. ახლა ჩვენ გვაინტერესებს მხოლოდ app/models/article.rb და db/migrate/20140120191729_create_articles.rb (თქვენი სახელი შეიძლება ოდნავ განსხვავებული იყოს). ეს უკანასკნელი პასუხისმგებელია მონაცემთა ბაზის სტრუქტურის შექმნაზე, ამიტომ მას შემდეგში განვიხილავთ.

Active Record საკმარისად ჭკვიანია იმისათვის, რომ ავტომატურად დააკავშიროს სვეტების სახელები მოდელის ატრიბუტებთან, რაც ნიშნავს, რომ Rails მოდელების შიგნით არ არის საჭირო ატრიბუტების გამოცხადება, Active Record ამას ავტომატურად გააკეთებს.

5.5. მიგრაციის დაწყება

როგორც უკვე ნახე, bin/rails გენერირება მოდელი შექმნა ფაილი მონაცემთა ბაზის მიგრაცია db/migrate დირექტორიაში. Migrations არის Ruby კლასი, რომელიც შექმნილია მონაცემთა ბაზის ცხრილების შექმნასა და შეცვლაზე. Rails იყენებს rake ბრძანებებს მიგრაციის გასაშვებად და შესაძლებელია მიგრაციის გაუქმება თქვენს მონაცემთა ბაზაში გამოყენების შემდეგ. მიგრაციის ფაილის სახელი შეიცავს დროის ნიშანს იმის უზრუნველსაყოფად, რომ ისინი შესრულებულია იმ თანმიმდევრობით, რომლითაც ისინი შეიქმნა.

თუ ჩახედავთ ფაილს db/migrate/YYYYMMDDHHMMSS_create_articles.rb (გახსოვდეთ, თქვენს ფაილს ოდნავ განსხვავებული სახელი აქვს), აი, რას ნახავთ იქ:

კლასი CreateArticles< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

ეს მიგრაცია ქმნის ცვლილების მეთოდს, რომელიც გამოიძახება ამ მიგრაციის გაშვებისას. ამ მიგრაციაში განსაზღვრული ქმედებები ასევე შექცევადია, რაც ნიშნავს, რომ Rails-მა იცის როგორ გააუქმოს ამ მიგრაციის შედეგად განხორციელებული ცვლილებები, თუ მოგვიანებით გადაწყვეტთ მათ გაუქმებას. როდესაც თქვენ აწარმოებთ ამ მიგრაციას, ის შექმნის სტატიების ცხრილს სტრიქონის სვეტით და ტექსტის სვეტით. ის ასევე შექმნის დროის ორ ველს, რათა თვალყური ადევნოთ როდის შეიქმნა და განახლდა სტატია.

ახლა ჩვენ უნდა გამოვიყენოთ bin/rails ბრძანება მიგრაციის დასაწყებად:

$ bin/rails db:migrate

Rails გაუშვებს ამ მიგრაციის ბრძანებას და იტყობინება, რომ მან შექმნა სტატიების ცხრილი.

სტატიების შექმნა: მიგრაცია =============================================== === -- შექმნა_ცხრილი(:სტატიები) -> 0.0019s == სტატიების შექმნა: მიგრაცია (0.0020წ) ========================== ===============

ვინაიდან ნაგულისხმევად მუშაობთ განვითარების გარემოში, ეს ბრძანება გავრცელდება მონაცემთა ბაზაზე, რომელიც განსაზღვრულია თქვენი config/database.yml ფაილის განვითარების განყოფილებაში. თუ გსურთ შეასრულოთ მიგრაცია სხვა გარემოში, როგორიცაა წარმოება, ცალსახად უნდა გაიაროთ იგი ბრძანების გამოძახებისას: bin/rails db:migrate RAILS_ENV=production .

5.6. მონაცემების შენახვა კონტროლერში

დავუბრუნდეთ ArticlesController-ს, ჩვენ უნდა შევცვალოთ შექმნის მოქმედება, რათა გამოვიყენოთ ახალი მუხლის მოდელი მონაცემთა ბაზაში მონაცემების შესანახად. გახსენით app/controllers/articles_controller.rb და შეცვალეთ შექმნის მოქმედება ასე რომ გამოიყურებოდეს:

შექმენით @article = Article.new(params[:article]) @article.save redirect_to @article end

აი, რა ხდება აქ: თითოეული Rails მოდელის ინიციალიზაცია შესაძლებელია შესაბამისი ატრიბუტებით, რომლებიც ავტომატურად იქნება დაკავშირებული მონაცემთა ბაზის შესაბამის სვეტებთან. პირველ სტრიქონში ჩვენ სწორედ ამას ვაკეთებთ (გახსოვდეთ, რომ params[:article] შეიცავს ჩვენთვის საინტერესო ატრიბუტებს). @article.save მაშინ პასუხისმგებელია მოდელის მონაცემთა ბაზაში შენახვაზე. საბოლოოდ, ჩვენ გადავიყვანთ მომხმარებელს შოუს მოქმედებაზე, რომელსაც მოგვიანებით განვსაზღვრავთ.

შეიძლება გაინტერესებთ, რატომ იწერება A მუხლის ახალში, როდესაც ამ სახელმძღვანელოს ყველა სხვა სტატიის ბმული არის დიდი ასოებით. ამ კონტექსტში ჩვენ ვგულისხმობთ კლასს სახელწოდებით Article, რომელიც განსაზღვრულია app/models/article.rb-ში. კლასების სახელები რუბიში უნდა დაიწყოს დიდი ასოებით.

ახლა, როდესაც არსებობს ვალიდაციები, გამოძახება @article.save არასწორ სტატიაზე დააბრუნებს false-ს. თუ კვლავ გახსნით app/controllers/articles_controller.rb-ს, ნახავთ, რომ ჩვენ არ ვამოწმებთ @article.save ზარის შედეგს შექმნის მოქმედებაში. თუ @article.save ვერ მოხერხდა ამ სიტუაციაში, ჩვენ უნდა ვაჩვენოთ ფორმა მომხმარებელს. ამისათვის შეცვალეთ ახალი და შექმენით მოქმედებები app/controllers/articles_controller.rb-ში ამით:

Def new @article = მუხლი.ახალი დასასრული def შექმნა @article = Article.new(article_params) თუ @article.save redirect_to @article სხვაგვარად გამოიტანოს "ახალი" ბოლო ბოლოს კერძო def article_params params.require(:article).permit(:title , :text) დასასრული

ახალი მოქმედება ახლა ქმნის ახალ ინსტანციის ცვლადს, სახელწოდებით @article, და თქვენ ნახავთ, რატომ, რამდენიმე აბზაცში.

გაითვალისწინეთ, რომ შექმნის მოქმედებაში ჩვენ გამოვიყენეთ render-ის ნაცვლად redirect_to, როდესაც შენახვა აბრუნებს false-ს. რენდერის მეთოდი გამოიყენება იმის უზრუნველსაყოფად, რომ @article ობიექტი გადაეცემა ახალ შაბლონს მისი რენდერის დროს. ეს რენდერი კეთდება იმავე მოთხოვნის ფარგლებში, როგორც ფორმის გაგზავნა, ხოლო redirect_to ეუბნება ბრაუზერს, გააკეთოს სხვა მოთხოვნა.

5.11. სტატიის განახლებები

ჩვენ გავაშუქეთ CRUD-ის "CR" ნაწილი. ახლა მოდით გავამახვილოთ ყურადღება "U" ნაწილზე, სტატიების განახლებაზე.

პირველი ნაბიჯი არის ArticlesController-ში რედაქტირების მოქმედების დამატება, როგორც წესი, ახალ და შექმნის მოქმედებებს შორის, როგორც ნაჩვენებია.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) დასასრული def შექმნა @article = Article.new(article_params) თუ @article.save redirect_to @article else ასახავს "ახალი" ბოლოს დასასრული

ხედი შეიცავს ფორმას, როგორიც ჩვენ ვიყენებდით ახალი სტატიების შექმნისას. შექმენით ფაილი სახელწოდებით app/views/articles/edit.html.erb და დაამატეთ მას შემდეგი:

სტატიის რედაქტირება

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

ახლა ჩვენ მივუთითებთ ფორმას განახლების მოქმედებაზე, რომელიც ჯერ არ არის განსაზღვრული, მაგრამ ამას მალე გავაკეთებთ.

სტატიის ობიექტის მეთოდზე გადაცემა ავტომატურად დააყენებს URL-ს რედაქტირებული სტატიის ფორმის გაგზავნისთვის. ეს ოფცია ეუბნება Rails-ს, რომ ჩვენ გვინდა, რომ ეს ფორმა წარმოდგენილი იყოს PATCH-ის გამოყენებით, HTTP მეთოდი, რომელიც სავარაუდოდ გამოყენებული იქნება განახლებებირესურსები REST პროტოკოლის შესაბამისად.

შემდეგ თქვენ უნდა შექმნათ განახლების მოქმედება app/controllers/articles_controller.rb-ში. დაამატეთ იგი შექმნის მოქმედებასა და კერძო მეთოდს შორის:

შექმენით @article = Article.new(article_params) თუ @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 რენდერი "რედაქტირება" ბოლოს ბოლოს კერძო def article_params params.require(:article).permit(:title, :text) დასასრული

ახალი მეთოდი, განახლება, გამოიყენება მაშინ, როდესაც გსურთ განაახლოთ ჩანაწერი, რომელიც უკვე არსებობს და მას სჭირდება ჰეში, რომელიც შეიცავს ატრიბუტებს, რომელთა განახლებაც გსურთ. როგორც ადრე, თუ სტატიის განახლებისას მოხდა შეცდომა, გვსურს ისევ ვაჩვენოთ ფორმა მომხმარებელს.

ჩვენ ხელახლა გამოვიყენეთ article_params მეთოდი, რომელიც ადრე განვსაზღვრეთ შექმნის მოქმედებისთვის.

განახლებისთვის არ არის აუცილებელი ყველა ატრიბუტის გადაცემა. მაგალითად, თუ @article.update (სათაური: "ახალი სათაური") გამოიძახეს, Rails განაახლებს მხოლოდ სათაურის ატრიბუტს და ყველა სხვა ატრიბუტს ხელუხლებლად დატოვებს.

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

სათაური	ტექსტი
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

ჩვენ ასევე დავამატებთ app/views/articles/show.html.erb შაბლონს ისე, რომ ბმული „რედაქტირება“ ასევე იყოს სტატიის გვერდზე. შაბლონის ბოლოს დაამატეთ შემდეგი:

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

და ასე გამოიყურება ჩვენი აპლიკაცია ახლა:

5.12. ნაწილობრივების გამოყენება ხედებში გამეორების გასასუფთავებლად

ჩვენი რედაქტირების გვერდი ძალიან ჰგავს ახალ გვერდს, ფაქტობრივად ისინი იყენებენ იმავე კოდს ფორმის საჩვენებლად. მოდით წავშალოთ ეს დუბლირება ნაწილობრივი ხედის გამოყენებით. პირობითად, ნაწილობრივი ფაილები იწყება ქვედა ხაზით.

შექმენით ახალი ფაილი app/views/articles/_form.html.erb შემდეგი შინაარსით:

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

მოდით ახლა განვაახლოთ app/views/articles/new.html.erb ხედი, რათა გამოვიყენოთ ეს ახალი ნაწილობრივი სრულად გადაწერით:

ახალი სტატია

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

და იგივე app/views/articles/edit.html.erb ხედისთვის:

სტატიის რედაქტირება

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

5.13. სტატიების წაშლა

ახლა ჩვენ მზად ვართ დავფაროთ CRUD-ის ნაწილი "D" ბაზიდან წაშლით. REST-ის კონვენციის შემდეგ, ურნის/ლიანდაგის მარშრუტებში სტატიების ამოღების მარშრუტი შემდეგია:

წაშლა /სტატიები/:id(.:format) articles#destroy

წაშლის მარშრუტიზაციის მეთოდი უნდა იყოს გამოყენებული მარშრუტებისთვის, რომლებიც ანადგურებენ რესურსებს. თუ ის დარჩეს ჩვეულებრივ მისაღებად მარშრუტად, შესაძლებელი იქნებოდა შემდეგი მავნე URL-ების შექმნა:

შეხედე ამ კატას!

ჩვენ ვიყენებთ წაშლის მეთოდს რესურსების განადგურებისთვის და ეს მარშრუტი ასოცირდება განადგურების მოქმედებასთან app/controllers/articles_controller.rb-ში, რომელიც ჯერ არ არსებობს. განადგურების მეთოდი, როგორც წესი, არის ბოლო CRUD ქმედება კონტროლერში და ისევე როგორც სხვა საჯარო CRUD ქმედებები, ის უნდა განთავსდეს ნებისმიერ კერძო ან დაცულ მეთოდზე. დავამატოთ:

გაანადგურე @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end

მთელი ArticlesController app/controllers/articles_controller.rb ფაილში ახლა ასე უნდა გამოიყურებოდეს:

კლასის სტატიების კონტროლერი< 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

შეგიძლიათ დარეკოთ განადგურება აქტიური ობიექტებიჩაწერეთ, როდესაც გსურთ მათი ბაზიდან ამოღება. გაითვალისწინეთ, რომ ჩვენ არ გვჭირდება ხედის დამატება ამ მოქმედებისთვის, რადგან ჩვენ გადამისამართდებით ინდექსის მოქმედებაზე.

სტატიების ჩამონათვალი

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

სათაური	ტექსტი
<%= 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?" } %>

აქ ჩვენ ვიყენებთ link_to-ს სხვაგვარად. მეორე არგუმენტად გადავიტანთ დასახელებულ მარშრუტს, მეორე არგუმენტად ოფციონებს. მეთოდი: :delete და data: (დაადასტურეთ: "დარწმუნებული ხართ?" ) ოფციები გამოიყენება როგორც html5 ატრიბუტები, ასე რომ, როდესაც ბმულს დააწკაპუნებთ, Rails ჯერ უჩვენებს მომხმარებელს დადასტურების დიალოგს და შემდეგ გაუგზავნის ბმულს წაშლის მეთოდის გამოყენებით. . ეს კეთდება rails-ujs JavaScript ფაილის გამოყენებით, რომელიც ავტომატურად შედის აპლიკაციის განლაგებაში (app/views/layouts/application.html.erb) განაცხადის გენერირებისას. ამ ფაილის გარეშე, დადასტურების დიალოგი არ გამოჩნდება.

გილოცავთ, ახლა შეგიძლიათ შექმნათ, ნახოთ ყველა და ინდივიდუალურად, განაახლოთ და გაანადგუროთ სტატიები.

მეორე მოდელის დამატება

დროა დავამატოთ მეორე მოდელი აპლიკაციას. მეორე მოდელი დაამუშავებს კომენტარებს სტატიებზე.

6.1. მოდელის გენერირება

ჩვენ ვაპირებთ გამოვიყენოთ იგივე გენერატორი, რომელიც ადრე გამოვიყენეთ Article მოდელის შექმნისას. ამჯერად ჩვენ შევქმნით კომენტარის მოდელს, რომელიც შეიცავს სტატიის ბმულს. გაუშვით შემდეგი ბრძანება ტერმინალში:

$ bin/rails მოდელის გენერირება კომენტარის კომენტატორი:სტრიქონის სხეული:ტექსტური სტატია:მინიშნებები

ეს ბრძანება ქმნის ოთხ ფაილს:

ჯერ მოდით გადავხედოთ app/models/comment.rb:

კლასის კომენტარი< ApplicationRecord belongs_to:article end

ეს ძალიან ჰგავს სტატიის მოდელს, რომელიც ადრე ვნახეთ. განსხვავება ეკუთვნის_to:article ხაზში, რომელიც ადგენს კავშირიაქტიური ჩანაწერი. თქვენ შეიტყობთ კავშირების შესახებ სახელმძღვანელოს შემდეგ ნაწილში.

bash ბრძანებაში გამოყენებული საკვანძო სიტყვა (:references) არის სპეციალური ტიპიმონაცემები მოდელებისთვის. ის ქმნის ახალ სვეტს თქვენს მონაცემთა ბაზაში წარმოდგენილი მოდელის სახელთან ერთად _id დართული, რომელიც შეიძლება შეიცავდეს რიცხვითი მნიშვნელობები. უკეთ გასაგებად, გაანალიზეთ db/schema.rb ფაილი მიგრაციის შესრულების შემდეგ.

მოდელის გარდა, Rails-მა ასევე განახორციელა მიგრაცია მონაცემთა ბაზის შესაბამისი ცხრილის შესაქმნელად:

კლასი შექმენით კომენტარები< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, foreign_key: true t.timestamps end end end

t.references ხაზი ქმნის ციფრულ სვეტს სახელწოდებით article_id, მასზე ინდექსს და სტატიების ცხრილის id სვეტზე მითითებულ უცხო გასაღების შეზღუდვას. შემდეგი, ჩვენ ვიწყებთ მიგრაციას:

$ bin/rails db:migrate

Rails საკმარისად ჭკვიანია იმისთვის, რომ შეასრულოს მხოლოდ მიგრაციები, რომლებიც ჯერ არ განხორციელებულა მიმდინარე მონაცემთა ბაზაში, ჩვენს შემთხვევაში თქვენ ნახავთ:

კომენტარების შექმნა: მიგრაცია =============================================== == -- create_table(:comments) -> 0.0115s == კომენტარების შექმნა: მიგრაცია (0.0119s) =========================== =============

6.2. დამაკავშირებელი მოდელები

Active Record ურთიერთობები საშუალებას გაძლევთ მარტივად გამოაცხადოთ ურთიერთობები ორ მოდელს შორის. კომენტარებისა და სტატიების შემთხვევაში, თქვენ შეგიძლიათ აღწეროთ ურთიერთობა შემდეგნაირად:

• თითოეული კომენტარი ეკუთვნის ერთ სტატიას.
• ერთ სტატიას შეიძლება ჰქონდეს ბევრი კომენტარი.

სინამდვილეში, ის ძალიან ახლოს არის სინტაქსთან, რომელსაც Rails იყენებს ამ კავშირის გამოცხადებისთვის. თქვენ უკვე ნახეთ კოდის ხაზი კომენტარების მოდელში (app/models/comment.rb), რომელიც აქცევს თითოეულ კომენტარს სტატიას:

კლასის კომენტარი< ApplicationRecord belongs_to:article end

თქვენ უნდა შეცვალოთ app/models/article.rb ბმულის მეორე მხარის დასამატებლად:

კლასის სტატია< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

ეს ორი რეკლამა ავტომატურად გახდება ხელმისაწვდომი დიდი რაოდენობაშესაძლებლობები. მაგალითად, თუ თქვენ გაქვთ @article ინსტანციის ცვლადი, რომელიც შეიცავს სტატიას, შეგიძლიათ მიიღოთ ამ სტატიის ყველა კომენტარი მასივში @article.comments დარეკვით.

6.3. მარშრუტის დამატება კომენტარებისთვის

როგორც მისასალმებელი კონტროლერის შემთხვევაში, ჩვენ უნდა დავამატოთ მარშრუტი, რათა Rails-მა იცოდეს, რომელ მისამართზე გვინდა წასვლა, რათა ნახოთ კომენტარები. კვლავ გახსენით config/routes.rb ფაილი და შეცვალეთ იგი შემდეგნაირად:

რესურსები: სტატიები ამზადებენ რესურსებს: კომენტარები მთავრდება

ეს შექმნის მსგავს კომენტარებს ჩადგმული რესურსისტატიებში. ეს არის სტატიებსა და კომენტარებს შორის არსებული იერარქიული ურთიერთობების აღქმის მეორე მხარე.

6.4. კონტროლერის გენერირება

მოდელის არსებობისას, მოდით, ყურადღება მივაქციოთ შესაბამისი კონტროლერის შექმნას. ჩვენ კვლავ გამოვიყენებთ იმავე გენერატორს, რომელსაც ადრე ვიყენებდით:

$ bin/rails გენერირება კონტროლერის კომენტარები

შეიქმნება ხუთი ფაილი და ცარიელი დირექტორია:

ნებისმიერი სხვა ბლოგის მსგავსად, ჩვენი მკითხველები სტატიის წაკითხვისთანავე შექმნიან თავიანთ კომენტარებს, ხოლო კომენტარის დამატების შემდეგ, ისინი გადაიყვანენ სტატიის ჩვენების გვერდზე და ნახავენ, რომ მათი კომენტარი უკვე ასახულია. ამასთან დაკავშირებით, ჩვენი CommentsController ემსახურება კომენტარების შექმნისა და სპამის წაშლის საშუალებას, ასეთის არსებობის შემთხვევაში.

ჯერ გავაფართოვებთ სტატიის ჩვენების შაბლონს (app/views/articles/show.html.erb), რათა დაამატოთ ახალი კომენტარი:

სათაური: <%= @article.title %>

ტექსტი: <%= @article.text %>

დაამატეთ კომენტარი:

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

ეს დაამატებს ფორმას სტატიის ჩვენების გვერდზე, რომელიც ქმნის ახალ კომენტარს CommentsController-ზე შექმნის მოქმედების გამოძახებისას. აქ form_with ზარი იყენებს მასივს, რომელიც შექმნის ჩადგმულ მარშრუტს, როგორიცაა /articles/1/comments.

მოდით დავწეროთ create in app/controllers/comments_controller.rb:

კლასის კომენტარების კონტროლერი< 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

ეს ცოტა უფრო რთულია, ვიდრე ის, რაც იხილეთ სტატიის კონტროლერში. ეს არის თქვენს მიერ დაყენებული დანართის გვერდითი ეფექტი. კომენტარის ყოველი მოთხოვნა თვალყურს ადევნებს იმ სტატიას, რომელსაც კომენტარი მიმაგრებულია, ამიტომ ჩვენ ჯერ სტატიის მოძიების საკითხს ვწყვეტთ სტატიის მოდელის პოვნის გამოძახებით.

გარდა ამისა, კოდი სარგებლობს კავშირებისთვის ხელმისაწვდომი ზოგიერთი მეთოდით. ჩვენ ვიყენებთ შექმნის მეთოდს @article.comments-ზე კომენტარის შესაქმნელად და შესანახად. ეს ავტომატურად აკავშირებს კომენტარს ისე, რომ იგი ეკუთვნის კონკრეტულ სტატიას.

მას შემდეგ, რაც ჩვენ შევქმნით ახალ კომენტარს, მომხმარებელს ვაბრუნებთ თავდაპირველ სტატიაში article_path(@article) დამხმარე გამოყენებით. როგორც უკვე ვნახეთ, ის უწოდებს შოუს მოქმედებას ArticlesController-ზე, რომელიც თავის მხრივ წარმოქმნის show.html.erb შაბლონს. სწორედ აქ გვინდა კომენტარების ჩვენება, ასე რომ, მოდით დავამატოთ შემდეგი app/views/articles/show.html.erb.

სათაური: <%= @article.title %>

ტექსტი: <%= @article.text %>

კომენტარები

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

კომენტატორი: <%= comment.commenter %>

კომენტარი: <%= comment.body %>

<% end %>

დაამატეთ კომენტარი:

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

ახლა შეგიძლიათ დაამატოთ სტატიები და კომენტარები თქვენს ბლოგზე და აჩვენოთ ისინი სწორ ადგილებში.

რეფაქტორირება

ახლა, როდესაც გვაქვს სამუშაო სტატიები და კომენტარები, მოდით გადავხედოთ app/views/articles/show.html.erb შაბლონს. ეს გახდა ხანგრძლივი და არასასიამოვნო. გამოვიყენოთ ნაწილობრივი მის შესამსუბუქებლად.

7.1. ნაწილობრივების კოლექციების გაფორმება

პირველ რიგში, ჩვენ ნაწილობრივ გავაკეთებთ კომენტარს, რომელიც აჩვენებს სტატიის ყველა კომენტარს. შექმენით ფაილი app/views/comments/_comment.html.erb და ჩადეთ მასში შემდეგი:

კომენტატორი: <%= comment.commenter %>

კომენტარი: <%= comment.body %>

შემდეგ შეგიძლიათ შეცვალოთ app/views/articles/show.html.erb ასე:

სათაური: <%= @article.title %>

ტექსტი: <%= @article.text %>

კომენტარები

<%= render @article.comments %>

დაამატეთ კომენტარი:

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

ეს ახლა აპს/views/comments/_comment.html.erb-ს ნაწილობრივ აქცევს ერთხელ თითოეული კომენტარისთვის @article.comments კოლექციაში. ვინაიდან რენდერის მეთოდი მეორდება @article.comments კოლექციის მეშვეობით, ის თითოეულ კომენტარს ანიჭებს ლოკალურ ცვლადს, სახელწოდებით ნაწილობრივი, ამ შემთხვევაში კომენტარი , რომელიც ჩვენთვის ნაწილობრივ ხელმისაწვდომია ჩვენებისთვის.

7.2. ფორმის ნაწილობრივი გაწევა

მოდით ასევე გადავიტანოთ ახალი კომენტარების განყოფილება ჩვენს ნაწილობრივ. კვლავ შექმენით ფაილი app/views/comments/_form.html.erb, რომელიც შეიცავს:

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

შემდეგ შეცვალეთ app/views/articles/show.html.erb ასე:

სათაური: <%= @article.title %>

ტექსტი: <%= @article.text %>

კომენტარები

<%= render @article.comments %>

დაამატეთ კომენტარი:

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

მეორე რენდერი უბრალოდ განსაზღვრავს ნაწილობრივ შაბლონს, რომლის რენდერიც გვინდა, კომენტარები/ფორმა. Rails საკმარისად ჭკვიანია იმისათვის, რომ ამ ხაზს ხაზგასმით დააყენოს და გაიგოს, რომ თქვენ გულისხმობდით _form.html.erb ფაილის გადმოცემას app/views/comments დირექტორიაში.

@article ობიექტი ხელმისაწვდომია ხედში გამოსახული ნებისმიერი ნაწილობრივი სახით, რადგან ჩვენ განვსაზღვრეთ ის, როგორც ინსტანციის ცვლადი.

კომენტარების წაშლა

ბლოგის კიდევ ერთი მნიშვნელოვანი მახასიათებელია სპამის წაშლის შესაძლებლობა. ამისათვის თქვენ უნდა ჩასვათ რაიმე ბმული ხედში და განადგურების მოქმედება CommentsController-ში.

კომენტატორი: <%= comment.commenter %>

კომენტარი: <%= comment.body %>

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

ამ ახალ "კომენტარის განადგურების" ბმულზე დაწკაპუნებით გაშვებული იქნება DELETE /articles/:article_id/comments/:id ჩვენს CommentsController-ში, რომელიც შემდეგ გამოყენებული იქნება იმ კომენტარის საპოვნელად, რომლის წაშლა გვინდა, ასე რომ, მოდით დავამატოთ განადგურების მოქმედება ჩვენს კონტროლერს (აპი/ controllers/ comments_controller.rb):

კლასის კომენტარების კონტროლერი< 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

განადგურების მოქმედება იპოვის სტატიას, რომელსაც ჩვენ ვუყურებთ, იპოვის კომენტარს @article.comments კოლექციაში, შემდეგ ამოშლის მას მონაცემთა ბაზიდან და დაგვიბრუნდება სტატიის სანახავად.

8.1. დაკავშირებული ობიექტების წაშლა

თუ სტატიას წაშლით, მასთან დაკავშირებული კომენტარებიც უნდა წაიშალოს, წინააღმდეგ შემთხვევაში ისინი უბრალოდ ადგილს დაიკავებენ მონაცემთა ბაზაში. Rails გაძლევთ საშუალებას გამოიყენოთ ბმულზე დამოკიდებული ვარიანტი ამის მისაღწევად. შეცვალეთ სტატიის მოდელი, app/models/article.rb შემდეგნაირად:

კლასის სტატია< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

უსაფრთხოება

9.1. ძირითადი ავთენტიფიკაცია

თუ თქვენს ბლოგს ონლაინ აქვეყნებთ, ნებისმიერს შეუძლია სტატიების დამატება, რედაქტირება და წაშლა ან კომენტარების წაშლა.

Rails უზრუნველყოფს ძირითადი HTTP ავტორიზაციის სისტემას, რომელიც კარგად მუშაობს ამ სიტუაციაში.

ArticlesController-ში გვჭირდება გზა სხვადასხვა მოქმედებებზე წვდომის დასაბლოკად, თუ მომხმარებელი არ არის დამოწმებული. აქ ჩვენ შეგვიძლია გამოვიყენოთ Rails http_basic_authenticate_with მეთოდი საჭირო მოქმედებებზე წვდომის დასაშვებად, თუ მეთოდი ამის საშუალებას იძლევა.

ავტორიზაციის სისტემის გამოსაყენებლად, ჩვენ განვსაზღვრავთ მას ჩვენი ArticlesController-ის ზედა ნაწილში app/controllers/articles_controller.rb. ჩვენს შემთხვევაში, ჩვენ გვინდა, რომ მომხმარებლის ავთენტიფიკაცია მოხდეს ყველა მოქმედებისთვის, გარდა ინდექსისა და ჩვენების, ასე რომ, ჩვენ დავწერთ მას ასე:

კლასის სტატიების კონტროლერი< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

ჩვენ ასევე გვინდა მივცეთ უფლება მხოლოდ ავტორიზებულ მომხმარებლებს წაშალონ კომენტარები, ამიტომ CommentsController-ში (app/controllers/comments_controller.rb) დავწერთ:

კლასის კომენტარების კონტროლერი< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

ახლა, თუ ახალი სტატიის შექმნას ცდილობთ, შეხვდებით HTTP ძირითადი ავთენტიფიკაციის ზარს:

ავთენტიფიკაციის სხვა მეთოდები ასევე ხელმისაწვდომია Rails აპლიკაციებისთვის. Rails-ისთვის ორი პოპულარული დანამატი არის Devise და Authlogic, სხვათა შორის.

9.2. სხვა აზრები უსაფრთხოების შესახებ

უსაფრთხოება, განსაკუთრებით ვებ აპლიკაციებში, ფართო და დეტალური სფეროა. თქვენი Rails აპლიკაციის უსაფრთხოება უფრო დეტალურად არის აღწერილი სახელმძღვანელოში Security of Rails Applications Rails-თან მუშაობის უმარტივესი გზაა ყველა გარე მონაცემების შენახვა UTF-8-ში. თუ არა, Ruby და Rails ბიბლიოთეკები ხშირად შეძლებენ თქვენი მშობლიური მონაცემების UTF-8-ად გადაქცევას, მაგრამ ეს ყოველთვის არ მუშაობს საიმედოდ, ამიტომ უმჯობესია დარწმუნებული იყოთ, რომ ყველა გარე მონაცემი არის UTF-8.

თუ ამ სფეროში შეცდომას უშვებთ, ყველაზე გავრცელებული სიმპტომია შავი ბრილიანტი, რომლის შიგნითაც ბრაუზერში ჩნდება კითხვის ნიშანი. კიდევ ერთი გავრცელებული სიმპტომია სიმბოლოები, როგორიცაა "ü" გამოჩნდება "ü"-ს ნაცვლად. Rails იღებს უამრავ შიდა ნაბიჯს პრობლემების საერთო შემთხვევების შესამსუბუქებლად, რომლებიც შეიძლება ავტომატურად გამოვლინდეს და გამოსწორდეს. თუმცა, თუ არის გარე მონაცემები, რომლებიც არ არის შენახული UTF-8-ში, ამან შეიძლება გამოიწვიოს ისეთი სახის პრობლემები, რომლებსაც Rails ავტომატურად ვერ აღმოაჩენს და გამოასწორებს.

მონაცემთა ორი ყველაზე გავრცელებული წყარო, რომელიც არ არის UTF-8-ში, არის:

• თქვენი ტექსტური რედაქტორი: ტექსტური რედაქტორების უმეტესობა (როგორიცაა TextMate) ინახავს ფაილებს სტანდარტულად UTF-8 სახით. თუ თქვენი ტექსტური რედაქტორი ამას არ აკეთებს, ამან შეიძლება გამოიწვიოს თქვენს შაბლონებში შეყვანილი სპეციალური სიმბოლოები (როგორიცაა é) ბრაუზერში კითხვის ნიშნით ბრილიანტის სახით გამოჩნდეს. ეს ასევე ეხება თქვენს i18N თარგმანის ფაილებს. რედაქტორების უმეტესობა, რომლებიც ნაგულისხმევად არ ადგენენ UTF-8-ს (როგორიცაა Dreamweaver-ის ზოგიერთი ვერსია), გვთავაზობენ ნაგულისხმევი UTF-8-ით შეცვლას. გააკეთე ეს.
• თქვენი მონაცემთა ბაზა: Rails ნაგულისხმევად გარდაქმნის მონაცემებს თქვენი მონაცემთა ბაზიდან UTF-8-ში ზღვარზე. თუმცა, თუ თქვენი მონაცემთა ბაზა არ იყენებს UTF-8-ს შიდა, მან შეიძლება ვერ შეინახოს ყველა სიმბოლო, რომელსაც თქვენი მომხმარებელი შეიყვანს. მაგალითად, თუ თქვენი მონაცემთა ბაზა იყენებს ლათინურ-1-ს შიგნიდან და თქვენი მომხმარებელი შეიყვანს რუსულ, ებრაულ ან იაპონურ სიმბოლოებს, მონაცემები დაიკარგება მონაცემთა ბაზაში შესვლისთანავე. თუ შესაძლებელია, გამოიყენეთ UTF-8 როგორც შიდა მეხსიერებათქვენს მონაცემთა ბაზაში.

ამ სტატიაში მინდა გითხრათ, თუ როგორ უნდა შექმნათ მარტივი აპლიკაცია, რომელიც მუშაობს MySQL მონაცემთა ბაზაში Ruby on Rails 3-ის გარემოში ნაბიჯ ნაბიჯ სახელმძღვანელო Rails-ის დამწყები პროგრამისტებისთვის.

ასე რომ, სამუშაოსთვის ჩვენ გვჭირდება დამონტაჟებული რელსები და რუბიგემები. გუშინ ამ უკანასკნელის პრობლემა მქონდა, მომიწია rubygems1.8 პაკეტის ამოღება (გაურკვეველია როგორ აღმოჩნდა სისტემაში) და დააინსტალირე rubygems1.9 შეგახსენებთ, რომ ვამუშავებ Ubuntu-ზე, თუმცა ვინდოუსისთვის. ვფიქრობ, Rails კონსოლის ბრძანებები იგივე იქნება. როგორც განვითარების გარემო, მე ვიყენებ NetBeans-ს Ruby on Rails-ის მოდულით. ჩემმა კოლეგამ კარგად დაწერა ინსტალაციის შესახებ.

ბმულების შემოწმება

თქვენ უნდა დარწმუნდეთ, რომ /usr/bin დირექტორია შეიცავს სიმბოლური ბმულები rails, rake, ruby, bundler ფაილებისთვის /usr/local/ruby/bin დირექტორიადან. ბმულების სანახავად გამოიყენეთ ბრძანება:

იმის მიხედვით, თუ რისი გაფილტვრა გსურთ.

აპლიკაციის შექმნა

მე შევქმენი სპეციალური დირექტორია ჩემი რუბი აპლიკაციებისთვის.

mkdir /სახლი/ანდრეი/რუბი
cd /home.andrey/ruby

Rails-ს აქვს მრავალი კონსოლის კომუნალური პროგრამა, რაც მნიშვნელოვნად ამარტივებს თქვენს მუშაობას, განსაკუთრებით პროტოტიპისთვის. აპლიკაციის შესაქმნელად mysql მონაცემთა ბაზის გამოყენებით, გაუშვით ბრძანება:

აპლიკაცია ჩვენი ახალი აპლიკაციის სახელია. ბრძანების შესრულების შემდეგ, ჩვენ ვნახავთ, როგორ დაგვაქცია რელსებმა მომავალი აპლიკაციის ჩარჩო.

root@vaio:~/ruby# rails new app -d mysql
შექმნა
შექმენით README
შექმენით Rakefile
შექმენით config.ru
შექმნა.gitignore
შექმენით Gemfile
აპლიკაციის შექმნა
შექმენით app/controllers/application_controller.rb
შექმენით app/helpers/application_helper.rb
შექმენით აპლიკაცია/ფოსტა
შექმენით აპლიკაცია/მოდელები
შექმენით app/views/layouts/application.html.erb
კონფიგურაციის შექმნა
შექმნა config/routes.rb
შექმნა config/application.rb
შექმნა config/environment.rb
კონფიგურაციის/გარემოების შექმნა
შექმნა config/environments/development.rb
შექმნა config/environments/production.rb
შექმნა config/environments/test.rb
კონფიგურაციის/ინიციალიზატორების შექმნა
შექმნა config/initializers/backtrace_silencers.rb
შექმნა config/initializers/inflections.rb
შექმნა config/initializers/mime_types.rb
შექმნა config/initializers/secret_token.rb
შექმნა config/initializers/session_store.rb
კონფიგურაციის/ლოკალების შექმნა
შექმნა config/locales/en.yml
შექმენით config/boot.rb
შექმენით config/database.yml
შექმენით db
შექმნა db/seeds.rb
შექმენით დოკუმენტი
შექმენით დოკუმენტი/README_FOR_APP
lib-ის შექმნა
lib/tasks-ის შექმნა
შექმნა lib/tasks/.gitkeep
ჟურნალის შექმნა
შექმენით log/server.log
შექმენით log/production.log
შექმენით log/development.log
შექმენით log/test.log
შექმნა საჯარო
შექმნა public/404.html
შექმნა public/422.html
შექმნა public/500.html
შექმენით public/favicon.ico
შექმენით public/index.html
შექმნა public/robots.txt
საჯარო/გამოსახულებების შექმნა
შექმნა public/images/rails.png
საჯარო/სტილის ფურცლების შექმნა
შექმნა public/stylesheets/.gitkeep
საჯარო/ჯავასკრიპტების შექმნა
შექმენით public/javascripts/application.js
შექმნა public/javascripts/controls.js
შექმენით public/javascripts/dragdrop.js
შექმნა public/javascripts/effects.js
შექმნა public/javascripts/prototype.js
შექმნა public/javascripts/rails.js
სკრიპტის შექმნა
სკრიპტის/რელსების შექმნა
ტესტის შექმნა
შექმენით ტესტი / მოწყობილობები
ტესტის/ფუნქციონალურის შექმნა
ტესტის/ინტეგრაციის შექმნა
შექმენით test/performance/browsing_test.rb
შექმენით test/test_helper.rb
ტესტის/ერთეულის შექმნა
შექმენით tmp
შექმენით tmp/სესიები
შექმენით tmp/სოკეტები
შექმენით tmp/ქეში
შექმენით tmp/pids
გამყიდველის/მოდულების შექმნა
შექმენით გამყიდველი/პლაგინები/.gitkeep

ჩვენ მასთან ერთად მივდივართ საქაღალდეში და ვამონტაჟებთ საჭირო თვლებს. ძვირფასი ქვები არის პროექტისთვის საჭირო დანამატი ბიბლიოთეკები (PHP-ის PECL-ისა და PEAR-ის ანალოგი).

ამის შემდეგ, კონსოლი გამოჩნდება მსგავსი რამ:

andrey@vaio:~/ruby/app> sudo პაკეტის ინსტალაცია
საკომისიოს გამოყენება (0.8.7)
აბსტრაქტის გამოყენება (1.0.0)
აქტიური მხარდაჭერის გამოყენება (3.0.0)
Builder-ის გამოყენება (2.1.2)
i18n (0.4.2) გამოყენებით
აქტიური მოდელის გამოყენება (3.0.0)
ერუბის გამოყენება (2.6.6)
თაროს გამოყენება (1.2.1)
თაროზე სამაგრის გამოყენებით (0.6.13)
rack-ტესტის გამოყენებით (0.5.6)
tzinfo-ს გამოყენება (0.3.23)
მოქმედების პაკეტის გამოყენება (3.0.0)
mime-ტიპების გამოყენება (1.16)
პოლიგლოტის გამოყენება (0.3.1)
ხის მწვერვალის გამოყენება (1.4.8)
ფოსტის გამოყენება (2.2.9)
actionmailer-ის გამოყენება (3.0.0)
arel-ის (1.0.1) გამოყენება
აქტიური ჩანაწერის გამოყენება (3.0.0)
აქტიური რესურსის გამოყენება (3.0.0)
ბანდლერის გამოყენება (1.0.3)
mysql2 (0.2.6) გამოყენებით
Thor-ის გამოყენებით (0.14.4)
რაილის გამოყენება (3.0.0)
რელსების გამოყენება (3.0.0)
თქვენი პაკეტი დასრულებულია! გამოიყენეთ `Bundle Show`, რომ ნახოთ სად არის დაინსტალირებული შეფუთული ძვირფასი ქვა.

ეს ნიშნავს, რომ ყველა ძვირფასი ქვა დამონტაჟებულია და დაკავშირებულია. თუ რამე აკლია, მაშინ bundle თავად ჩამოტვირთავს მათ rubygems-დან და დააინსტალირებს. ეს არის ის, რაც მე მაკლდა PHP-ში არსებითად, თურმე პროექტის ინსტალერია. დამოკიდებული ძვირფასი ქვების სია განთავსებულია Gemfile-ში პროექტის ძირში.

კონფიგურაცია

ახლა ჩვენ უნდა მივუთითოთ ჩვენი პროექტის მონაცემთა ბაზაში წვდომის დეტალები. გახსენით პროექტი NetBeans-ში: New Project -> Ruby -> Ruby on Rails აპლიკაციაში არსებული წყაროთ. ჩვენ მივუთითებთ გზას, ჩემს შემთხვევაში ეს იქნება (/home/andrey/ruby/app) და პროექტის სახელწოდება (app). Ruby პლატფორმისთვის ჩვენ ვირჩევთ სისტემაში დაინსტალირებულს და არა NetBeans-ში ჩაშენებულს. დააჭირეთ Finish და პროექტი იქმნება. გახსენით კონფიგურაციის ფსევდო-საქაღალდე და database.yml ფაილი. აქ თქვენ უნდა მიუთითოთ შესვლა და პაროლი მონაცემთა ბაზაში შესასვლელად, სასურველია სამივე გარემოსთვის (დამუშავება, ტესტირება, წარმოება) ერთდროულად. გარემო არის გარემო, რომელშიც ჩვენი აპლიკაცია იმუშავებს,

• განვითარება - დეველოპერის კომპიუტერი,
• საწარმოო - სამრეწველო ოპერაციის სერვერი,
• ტესტი - მუშაობა ტესტირების რეჟიმში უწყვეტი ინტეგრაციის სერვერზე ან ტესტერის კომპიუტერზე.

rails გენერირება მოდელი მომხმარებლის სახელი:string hashed_password:string salt:string

თქვენ შეგიძლიათ დაუყოვნებლივ ნახოთ რა შექმნა Rails ჩვენთვის:

აქტიური_ჩანაწერის გამოძახება
შექმნა db/migrate/20101107054200_create_users.rb
შექმენით app/models/user.rb
გამოძახება test_unit
შექმენით test/unit/user_test.rb
შექმენით test/fixtures/users.yml

კარგია, ახლა ჩვენ უნდა შევქმნათ მონაცემთა ბაზა. ამისათვის ჩვენ ვაკეთებთ:

andrey@vaio:~/ruby/app$ rake db:create
(/home/andrey/ruby/app)
andrey@vaio:~/ruby/app$ rake db:migrate
(/home/andrey/ruby/app)
== CreateUsers: მიგრაცია ============================================= =======
— შექმნა_მაგიდა (:მომხმარებლები)
-> 0.0061 წმ
== CreateUsers: მიგრაცია (0.0063s) =================================================================== ==================

კონსოლი აჩვენებს დამატებულ მონაცემებს. ჩვენ ვუყურებთ phpmyadmin-ში და ვხედავთ ახალ app_development და app_test მონაცემთა ბაზებს, ასევე მათში არსებულ ცხრილებს. ახლა დროა დაამატოთ რეალური მონაცემები. ამისათვის გაუშვით რელსების კონსოლი

კონსოლი არ არის მხოლოდ კონსოლი, არამედ IRB კონსოლი თქვენი განაცხადის კონტექსტში. მაგალითად, მოდით შევქმნათ ორი მომხმარებელი:

andrey@vaio:~/ruby/app$ rails კონსოლი
იტვირთება განვითარების გარემო (Rails 3.0.0)
irb(main):001:0> user1 = მომხმარებელი.ახალი
=> #
irb(main):002:0> user1.name = "ანდრეი"
=> "ანდრეი"
irb(main):003:0> user1.save
=> მართალია
irb(main):004:0> user2 = მომხმარებელი.ახალი
=> #
irb(main):005:0> user2.name = “vasiliy”
=> "ვასილი"
irb(main):006:0> user2.save
=> მართალია

irb(main):007:0> გასასვლელი
andrey@vaio:~/ruby/app$

მოდით შევხედოთ მონაცემთა ბაზას და ნამდვილად გვყავს ორი მომხმარებელი. მინდა აღვნიშნო, რომ Rails-მა თავად დაამატა ძირითადი გასაღების სვეტები და მოდელს ველები create_at (შექმნის თარიღი) და updated_at (შეცვლილი თარიღი) ველები.

ჩვენ გვაქვს მოდელი და გვაქვს მონაცემებიც. ჩვენი აპლიკაციის გაშვების დროა.

andrey@vaio:~/ruby/app$ rails სერვერი
=> WEBrick-ის ჩატვირთვა
=> Rails 3.0.0 აპლიკაციის განვითარება იწყება http://0.0.0.0:3000-ზე
=> დარეკეთ -d-ით გასასვლელად
=> Ctrl-C სერვერის გამორთვისთვის
INFO WEBrick 1.3.1
INFO ruby ​​1.9.2 (2010-08-18)
INFO WEBrick::HTTPSserver#start: pid=4193 port=3000

აპლიკაცია გაშვებულია, გახსენით ბრაუზერი მისამართზე და იხილეთ სატესტო გვერდი.

მშვენიერია, აპლიკაცია მუშაობს. მაგრამ ის აჩვენებს ჩვეულებრივ HTML გვერდს /public/index.html საქაღალდედან. და ჩვენ გვინდა დინამიური. გახსენით კონსოლის მეორე ფანჯარა (რადგან პირველში გაშვებულია Ruby სერვერი - WebRick), გადადით პროექტის საქაღალდეში და იქ ჩაწერეთ შემდეგი ბრძანება:

andrey@vaio:~/ruby/app$ რელსები გენერირება კონტროლერის ინდექსი
შექმენით app/controllers/index_controller.rb
მარშრუტის მიღება "ინდექსი/ინდექსი"
გამოძახება ერბ
შექმენით აპლიკაცია/ნახვები/ინდექსი
შექმენით app/views/index/index.html.erb
გამოძახება test_unit
შექმნა test/functional/index_controller_test.rb
მოიწვიე დამხმარე
შექმენით app/helpers/index_helper.rb
გამოძახება test_unit
შექმენით test/unit/helpers/index_helper_test.rb
andrey@vaio:~/ruby/app$

ამით ჩვენ შევქმენით Index controller, მასში არის Index action და ამ მოქმედების ტიპია index.html.erb ვაკეთებთ Refresh-ს (F5) NetBeans-ში და ვუყურებთ ჩვენს ფაილებს. საოცარი. ახლა ჩვენ გვჭირდება როგორმე გადამისამართოთ მთავარი გვერდის მარშრუტი ჩვენს მიერ შექმნილ კონტროლერის მოქმედებაზე. გახსენით მარშრუტების ფაილი (Configuration/routes.rb) და გააუქმეთ შემდეგი ხაზი იქ:

# თქვენ შეგიძლიათ თქვენი საიტის ფესვის მარშრუტი „root“-ით
# უბრალოდ გახსოვდეთ საჯარო/index.html წაშლა.
root:to => "welcome#index"

მხოლოდ მისალმების ნაცვლად ვწერთ ინდექსსაც. ისე, მე მიჩვეული ვარ Zend Framework-ს, რომ კონტროლერს და მოქმედებას ნაგულისხმევად უწოდებენ ინდექსს. არ დაგავიწყდეთ საჯარო/index.html ფაილის წაშლა (ან გადარქმევა).

root:to => "index#index"

ჩვენ ვაახლებთ გვერდს ბრაუზერში და ვხედავთ, რომ ჩვენი ხედი ახლა არის ნაჩვენები.

ინდექსი#ინდექსი

დიდი. ახლა ჩვენ შეგვიძლია გადავიდეთ ჩვენს ახლად შექმნილ კონტროლერზე (Controllers -> index_controller.rb) და იქ დავწეროთ შემდეგი მოქმედების ტექსტი:

კლასის IndexController< ApplicationController
დეფ ინდექსი
@users = User.find(:all)
დასასრული
დასასრული

ახლა გახსენით Views/index/index.html.erb ხედი და დაწერეთ იქ შემდეგი კოდი:

ინდექსი#ინდექსი

მომძებნე app/views/index/index.html.erb-ში

<% for user in @users -%>
<%=user.name%>

<% end %>

ამით ჩვენ ვეუბნებით Rails-ს, გაიმეოროს მომხმარებელთა მასივი და აჩვენოს მათი სახელები. ჩვენ ვაახლებთ გვერდს და ქვემოთ ვნახავთ მომხმარებელთა სიას.

ინდექსი#ინდექსი

მომძებნე app/views/index/index.html.erb-ში

ანდრეი
ვასილი

დიდი! აპლიკაცია შეიქმნა!

გმადლობთ!

თუ ეს სტატია დაგეხმარათ, ან გსურთ მხარი დაუჭიროთ ჩემს კვლევას და ბლოგს, აქ არის ამის საუკეთესო გზა: