Ruby on Rails პროგრამირების კურსები. რუბი დამწყებთათვის: რა არის საინტერესო ამ ენაში და როგორ ვისწავლოთ ის ეფექტურად

"გამარჯობა! Რას აკეთებ?" - დიახ, მე დავაპროგრამებ ერთ რამეს Ruby-ში. - "გადამდებია:-)"
აქ არის საუბარი დღეს მეგობართან. რატომ რუბი?

რატომ ვისწავლოთ რუბი

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

1. ცნობისმოყვარეობა. მაგალითად, ჩემთვის ძალიან საინტერესო იყო ღია კლასებით მუშაობა. აი, როგორ ავიღოთ და შეიყვანოთ თქვენი მეთოდი სისტემის კლასში - ჩემი აზრით, ეს შესანიშნავია. იქნება დაბნეულობა? მაგრამ როგორ გავაკეთოთ ეს? ზოგადად, ყველაფერი ახალი საინტერესოა.
2. . იმიტომ რომ დიდი ხანია ვპროგრამირებ PHP-ში, მაინტერესებს რითი შეიძლება დაიკვეხნოს რუბი PHP-ის წინაშე /
3. Ruby Speed. ტვიტერი დამზადებულია რუბიში (თუმცა ის ახლახან მიტოვებულია). მინდა შევამოწმო მისი შესრულება რეალურად.
4. პრობლემის კლასი. Ruby კარგია ვებ აპლიკაციებისთვის. ასეა?
5. მეტაპროგრამირება.ალბათ ყველაზე მნიშვნელოვანი მიზეზი.

როგორ ვისწავლოთ რუბი. აკადემიური გეგმა.

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

1. ფუნქციები, კლასები, საჯარო კლასები. ატრიბუტები (აქსესორები და მუტაციები).
2. სტრიქონებთან მუშაობა, მასივებით. ქვესტრიქონების პოვნა და ჩანაცვლება და ა.შ. ტიპის კონვერტაცია.
3. ფაილებთან მუშაობა.
4. სისტემურ გარემოსთან მუშაობა.
5. აპლიკაციის დიზაინი, თვლებით მუშაობა (მოდულები).
6. მუშაობა DB-თან.
7. Ruby-ის ინსტალაცია რელსებზე,.

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

ერთად ვისწავლოთ რუბი!

გაკვეთილი 1. პირველი აპლიკაცია Ruby-ში.

ამოცანა ეს არის. ჰოსტინგზე არის DNS სერვერი და Ruby-ის კონსოლის კომუნალურ პროგრამაზე დარეკვისას, თქვენ უნდა დაამატოთ ზონა დომენისთვის, ასევე ზონის ჩანაწერი ზონების სიაში (domains.list) და შეცვალოთ ერთი ჩანაწერი მონაცემთა ბაზა, სადაც უნდა დაარეგისტრიროთ ეს დომენი. მონაცემთა ბაზის წვდომის პარამეტრები ინახება php აპლიკაციაში, კონკრეტულად მის INI ფაილში. ყველა ნაბიჯის შემდეგ, თქვენ უნდა გადატვირთოთ DNS სერვერი (bind).

სამუშაო მაგიდა რუბისთვის

როგორც IDE, გამოვიყენებ RubyMine-ს JetBrains-ისგან. მე ძალიან მომეწონა ისინი. მიუხედავად იმისა, რომ საუბარი იყო phpStorm-ზე, ხარისხი მაშინვე ჩანს. ჩვენ ვაინსტალირებთ რუბს RVM-ის მეშვეობით ჯერ ყველა მომხმარებლისთვის, შემდეგ დავაყენეთ root და ჩვენი მომხმარებლისთვის.

Ruby საჯარო კლასების გაფართოება

Ruby-ში INI ფაილებთან მუშაობისთვის ჩვენ ვიყენებთ gem inifile-ს. მაგრამ მას აქვს პატარა პრობლემა. ZF INI ფაილში შეგიძლიათ უსაფრთხოდ გამოიყენოთ მუდმივები და ხაზები ასე გამოიყურება:

IncludePaths = APPLICATION_PATH "/../vendors/Doctrine/"

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

@rgxp_comment = %r/\A\s*\z|\A\s*[#(@ კომენტარი)]/ @rgxp_section = %r/\A\s*\[([^\]]+)\] /o @rgxp_param = %r/\A([^#(@param)]+)#(@param)\s*"?([^"]*)"?\z/

აქ არის სიტუაცია საჯარო კლასების გამოყენებისთვის. შევცვალოთ IniFile::parse ფუნქცია ჩვენით. მე დავამატებ ყველა დამატებას funntion.rb ფაილში

კლასი IniFile private # # call-seq # parse # # გაანალიზეთ ini ფაილის შინაარსი. # def parse return თუ File.file?(@fn) section = nil tmp_value = "" tmp_param = "" fd = (RUBY_VERSION >= "1.9" && @encoding) ? File.open(@fn, "r", :encoding => @encoding) : File.open(@fn, "r") while line = fd.gets line = line.chomp # mutline start # შექმნა tmp ცვლადები მითითებისთვის რომ multine დაიწყო # და ini ფაილის შემდეგი სტრიქონები მოწმდება # სხვა mutline rgxps-თან. თუ ხაზი =~ @rgxp_multiline_start მაშინ tmp_param = $1.strip tmp_value = $2 + "\n" # mutline end-delimiter ნაპოვნია # გაასუფთავეთ tmp vars და დაამატეთ პარამეტრი / მნიშვნელობა წყვილი განყოფილებაში elsif ხაზი =~ @rgxp_multiline_end && tmp_param != "" შემდეგ განყოფილება = tmp_value + $1 tmp_value, tmp_param = "", "" # სხვა რამ მრავალხაზოვანი დასაწყისისა და დასრულების elsif ხაზს შორის =~ @rgxp_multiline_value && tmp_param != "" შემდეგ tmp_value += $1 + "\n" # იგნორირება ცარიელი ხაზები და კომენტარების ხაზები elsif ხაზი =~ @rgxp_comment შემდეგ შემდეგი # ეს არის სექციის დეკლარაცია elsif ხაზი =~ @rgxp_section შემდეგ სექცია = @ini[$1.strip] # წინააღმდეგ შემთხვევაში ჩვენ გვაქვს პარამეტრი elsif ხაზი =~ @rgxp_param მაშინ დაწყების განყოფილება[$1.strip] = $2.strip rescue NoMethodError raise შეცდომა, "პარამეტრი შეხვედროდა პირველ განყოფილებამდე" დასასრული elsif ხაზი =~ %r/APPLICATION_/ შემდეგ სხვა raise Error, "ვერ გავაანალიზე ხაზი "#(ხაზი)" ბოლოს დასასრული # ხოლო უზრუნველყოს fd.close თუ განსაზღვრულია?fd და fd ბოლოს დასასრული

მე ასევე გავაფართოვებ String კლასს დომენების ვალიდაციის დასაშვებად.

Class String განსაზღვრავს valid_domain_name? domain_name = self.split(".") name = /(?:+)+/.match(domain_name).nil? tld = /(?:(2)|aero|ag|asia|at|be|biz|ca|cc|cn|com|de|edu|eu|fm|gov|gs|ვაკანსიები|jp|in|info| me|mil|mobi|მუზეუმი|ms|სახელი|net|nu|nz|org|tc|tw|tv|uk|us|vg|ws)/.match(domain_name).nil? (domain_name.count > 1 და სახელი != false და tld != false) ბოლოს დასასრული

წყაროები

კარგი, ახლა მე გაჩვენებთ რეალურ წყაროს.
index.rb

#coding: utf-8 მოითხოვს "mysql2" მოითხოვს "სოკეტს" მოითხოვს "inifile" მოითხოვს "./functions.rb" # სერვერის აპარატის მისამართების ჰოსტების ჰეში = ( :production => "83.168.22.1", :test => " 84.22 .11.1" ) util = Util.new(hosts) util.releative_config_path="/site.com/application/config/application.ini" # შეამოწმეთ პარამეტრები დატოვეთ, თუ (ARGV.count != 2) დომენი = ARGV ჰოსტის სახელი = ARGV . split(".") quit("დომენის არასწორი სახელი") if (not domain.valid_domain_name?) # მოძებნეთ კომპანია მონაცემთა ბაზის შედეგებში = Mysql2::Client.new(util.get_db_settings).query("SELECT id FROM `sites` WHERE `hostname` = "#(hostname)") quit ("კომპანია ვერ მოიძებნა") if result.count != 1 # განაახლეთ მისი ჰოსტის სახელის რიგები = Array.new result.each(|სტრიქონი| რიგები<< row} company_id = rows["id"] result = Mysql2::Client.new(util.get_db_settings).query("UPDATE `dbname`.`sites` SET `domain` = "#{domain}" WHERE `dao_companies`.`id` =#{company_id};") # Добавление зоны bind_config_path = "/etc/bind" default_zone_file = bind_config_path + "/zones/DEFALT" new_zone_file = bind_config_path + "/zones/#{domain}.zone" zones_list_file = bind_config_path + "/domains.lst" quit("File with default zone does not exists") unless File.exist?(default_zone_file) quit("File with zones list does not exists") unless File.exist?(zones_list_file) zone = IO.read(default_zone_file).gsub("SERIAL",Time.now.strftime("%Y%m%d%S")).gsub("DOMAIN", domain) if not File.exist?(new_zone_file) then File.open(new_zone_file, "w") {|f| f.puts(zone) } else quit("Domain "+domain+" zone already exists!") end # Добавление зоны в список zone = "zone \"#{domain}\" { type master; file \"/etc/bind/zones/#{domain}.zone\"; };" if not IO.read(zones_list_file).include?(domain) then File.open(zones_list_file, "a") {|f| f.puts(zone) } end # Перезапуск сервисов (bind9) system("service bind9 restart") puts "Completed"

ძვირფასი ფაილი
ეს ფაილი აღწერს პროექტის დამოკიდებულებებს.

წყარო:rubygems gem "mysql2", "0.2.6" gem "inifile"

ისე, რეალურად მოიცავდა ფუნქციებს.
ფუნქციები.rb

#coding: utf-8 კლასის სიმებიანი განსაზღვრულია valid_domain_name? domain_name = self.split(".") name = /(?:+)+/.match(domain_name).nil? tld = /(?:(2)|aero|ag|asia|at|be|biz|ca|cc|cn|com|de|edu|eu|fm|gov|gs|ვაკანსიები|jp|in|info| me|mil|mobi|მუზეუმი|ms|სახელი|net|nu|nz|org|tc|tw|tv|uk|us|vg|ws)/.match(domain_name).nil? (domain_name.count > 1 and name != false and tld != false) end end class IniFile private # # call-seq # parse # # გაანალიზეთ ini ფაილის შინაარსი. # def parse return თუ File.file?(@fn) section = nil tmp_value = "" tmp_param = "" fd = (RUBY_VERSION >= "1.9" && @encoding) ? File.open(@fn, "r", :encoding => @encoding) : File.open(@fn, "r") while line = fd.gets line = line.chomp # mutline start # შექმნა tmp ცვლადები მითითებისთვის რომ multine დაიწყო # და ini ფაილის შემდეგი სტრიქონები მოწმდება # სხვა mutline rgxps-თან. თუ ხაზი =~ @rgxp_multiline_start მაშინ tmp_param = $1.strip tmp_value = $2 + "\n" # mutline end-delimiter ნაპოვნია # გაასუფთავეთ tmp vars და დაამატეთ პარამეტრი / მნიშვნელობა წყვილი განყოფილებაში elsif ხაზი =~ @rgxp_multiline_end && tmp_param != "" შემდეგ განყოფილება = tmp_value + $1 tmp_value, tmp_param = "", "" # სხვა რამ მრავალხაზოვანი დასაწყისისა და დასრულების elsif ხაზს შორის =~ @rgxp_multiline_value && tmp_param != "" შემდეგ tmp_value += $1 + "\n" # იგნორირება ცარიელი ხაზები და კომენტარების ხაზები elsif ხაზი =~ @rgxp_comment შემდეგ შემდეგი # ეს არის სექციის დეკლარაცია elsif ხაზი =~ @rgxp_section შემდეგ სექცია = @ini[$1.strip] # წინააღმდეგ შემთხვევაში ჩვენ გვაქვს პარამეტრი elsif ხაზი =~ @rgxp_param მაშინ დაწყების განყოფილება[$1.strip] = $2.strip rescue NoMethodError raise შეცდომა, "პარამეტრი შეხვედროდა პირველ განყოფილებამდე" დასასრული elsif ხაზი =~ %r/APPLICATION_/ შემდეგ სხვა raise Error, "ვერ გავაანალიზე ხაზი "#(ხაზი)" ბოლოს დასასრული # ხოლო უზრუნველყოს fd.close თუ განსაზღვრულია? =========================== | DNS დამატების ინსტრუმენტი | ============================ გამოყენება: რუბი ./index.rb domain.com olddomain.site.com" თუ არა შეტყობინება .nil შემდეგ ბანერი = შეტყობინების ბოლოს აყენებს ბანერის გასვლის ბოლო კლასს Util attr_accessor:hosts, :releative_config_path, :environment def initialize(hosts =Array.new) self.hosts = ჰოსტების დასასრული # მიიღეთ ადგილობრივი IP მისამართი def local_ip orig, Socket.do_notverse_re = Socket.do_not_reverse_lookup, true # გამორთეთ DNS-ის უკუ გარჩევადობა დროებით UDPSocket.open do |s|s.connect "64.233.187.99", 1 s.addr.last end უზრუნველყოს Socket.do_not_reverse_lookup = orig end get #Get the denvironf @ ambient.nil? შემდეგ მასპინძლები = self.hosts.invert if(hosts.include?(self.local_ip)) შემდეგ @environment = მასპინძლებს სხვა @environment = "განვითარება" end else @environment.to_s end end def get_config_path local_username = get_local_username "/home/" +local_username+"/sandbox"+self.releative_config_path end # აბრუნებს მომხმარებლის სახელს, თუ პროგრამა გაშვებულია rvmsudo-ს მეშვეობით ან პირდაპირ def get_local_username თუ ENV["SUDO_USER"].nil? quit ("Util უნდა გაუშვათ rmvsudo-ზე, \r\nexample: rvmsudo ruby ​​./index.rb domain.ru some.subdomain.ru") სხვაგვარად ENV["SUDO_USER"] ბოლოს დასასრული def get_db_settings config = IniFile:: load(self.get_config_path) section_name = self.get_environment.to_s + " : bootstrap" quit("არ არის შესაფერისი განყოფილება კონფიგურაციის ფაილში") თუ config.has_section?(section_name) dsn = config.to_h["resources.doctrinedata.connections. ნაგულისხმევი. dsn"] # გაანალიზეთ dsn dsn.sub!("mysql://", "") arr = dsn.split("@") dbconfig = ( :username => arr.split(":"), : პაროლი = > arr.split(":"), :host => arr.split("/"), :database => arr.split("/") ) დასასრული

მაგრამ რაც შეეხება PHP-ს?

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

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

ეს წიგნი არის დინამიური პროგრამირების ენის Ruby-ის ოფიციალური სახელმძღვანელო. ავტორთა გუნდი მართლაც ვარსკვლავურია: დევიდ ფლენეგანი არის პროგრამირების სფეროში ცნობილი სპეციალისტი, არაერთი ყველაზე გაყიდვადი წიგნის ავტორი JavaScript-სა და Java-ზე; Yukihiro "Matz" Matsumoto არის Ruby-ის შემქმნელი და წამყვანი დეველოპერი.
წიგნში მოცემულია ენის ყველა ასპექტის დეტალური აღწერა: რუბის ლექსიკური და სინტაქსური სტრუქტურა, მონაცემთა მრავალფეროვნება და ელემენტარული გამონათქვამები, მეთოდების განმარტებები, კლასები და მოდულები. გარდა ამისა, წიგნი შეიცავს ინფორმაციას Ruby პლატფორმის API-ების შესახებ.

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

მოუთმენლად ველი თქვენს კომენტარს კოდზე და ნებისმიერ საინტერესო იდეას!)

Გმადლობთ!

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

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

Ruby-ის ძირითადი მახასიათებლები და განსხვავებები

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

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

Ruby არის ინტერპრეტირებული, სრულად ობიექტზე ორიენტირებული პროგრამირების ენა ძლიერი დინამიური აკრეფით. ის აერთიანებს პერლის მსგავს სინტაქსს ობიექტზე ორიენტირებულ მიდგომასთან. ასევე, ზოგიერთი ფუნქცია ნასესხებია პროგრამირების ენებიდან Python, Lisp, Dylan და CLU. Ruby ენის თარჯიმნის კროს-პლატფორმული დანერგვა განაწილებულია ღია კოდის პროგრამული უზრუნველყოფის პირობებით. რუბიში დაწერილი კოდი შეიძლება გაიგოს იმ ადამიანსაც კი, ვისაც პროგრამირება არ ესმის. RoR-ზე შეიქმნა ისეთი პროექტები, როგორიცაა Redmine, Twitter, Shopify, Basecamp, GitHub, Kickstarter, Airbnb და სხვა.

Node.js-ის ამაღლებასთან ერთად, Ruby on Rails-ის პოპულარობა გარკვეულწილად შემცირდა, მაგრამ ტექნიკური სტარტაპები ხშირად იყენებენ RoR-ს პროტოტიპების სიმარტივის გამო. რუბი მე-11 ყველაზე პოპულარული ენაა TIOBE ინდექსში.

რუბის სარგებელი

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

ახლა მოდით ვისაუბროთ Ruby-ის ზოგიერთ უპირატესობაზე უფრო დეტალურად.

განვითარების სიჩქარე

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

რეგულარული მონაცემთა ქეშირების ხელსაწყოები

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

ჯერ ტესტები, შემდეგ კოდი

ხშირად დიდი პროექტების შემუშავების პროცესში ჩნდება ტესტირების საკითხი და არც ისე იშვიათია, როდესაც არ არის დამატებითი სახსრები ტესტერების ცალკეული გუნდისთვის. რელსს აქვს ამ პრობლემის გადაწყვეტაც. თუ აპლიკაციის ტესტირების კონტექსტში ადარებთ RoR-ს სხვა ჩარჩოებთან, მაშინ ნახავთ უამრავ მზა გადაწყვეტილებას ნებისმიერი სახის ტესტისთვის, იქნება ეს ინტეგრაცია თუ ერთეული ტესტები. ყველა ეს ბიბლიოთეკა მუშაობს ყუთში. იდეალურ შემთხვევაში, Ruby on Rails პროექტში კოდი არ იწერება მანამ, სანამ მასზე ტესტები არ დაიწერება. RoR იდეოლოგია მოიცავს BDD (Behavior Driven Development) ან TDD (Test Driven Development) მეთოდების თავდაპირველ გამოყენებას.

ზოგადად მიღებული განვითარების პროცესის სტანდარტები Ruby დეველოპერებისთვის

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

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

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

მზა გადაწყვეტილებები პროექტის მულტილინგვიზმისთვის

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

მონაცემთა დაცვის მაღალი დონე

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

რუბის სწავლა

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

თეორია

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

• რუბი 20 წუთში კარგი რესურსია სრული დამწყებთათვის. ის საშუალებას გაძლევთ ნახევარ საათზე ნაკლებ დროში გაეცნოთ ენის ძირითად კონსტრუქციებს და დაიწყოთ საკუთარი მცირე პროგრამების წერა.
• Codecademy არის პლატფორმა ონლაინ კურსებით ბევრ სფეროში, მათ შორის სუფთა Ruby და Rails. აქ სასწავლო პროცესი საკმაოდ საინტერესოდ არის აგებული, მოცემულია თეორიული მასალა და დაუყოვნებლივ პრაქტიკული დავალება მისი კონსოლიდაციის მიზნით. საბოლოო დავალებები ფასიანია, მაგრამ მათ გარეშე შეგიძლიათ მიიღოთ საჭირო უნარები.
• Ruby and Rails რესურსები - ბმულების კოლექცია სხვადასხვა საიტებზე და წიგნებზე, რომლებიც ეძღვნება Ruby-სა და Rails-ის სწავლას.
• ცალკე შემიძლია გირჩიოთ წიგნი Flanagan D., Matsumoto Y. "The Ruby Programming Language". იგი ითვლება ერთ-ერთ საუკეთესოდ, მისი ავტორი თავად რუბის ენის შემქმნელია.
• გუგლი :)

აქ არის რამოდენიმე რესურსი დასაწყებად:

• w3schools.com/sql - წაიკითხეთ, სცადეთ და შეამოწმეთ თქვენი ცოდნა SQL-ის შესახებ აქ.
• quizful.net/test - აქ ნახავთ კითხვებს, რომლებსაც ხშირად სვამენ ინტერვიუებში.

ინგლისური

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

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

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

ივარჯიშე

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

კურსები

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

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

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

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

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

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

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

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

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

სულ

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

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

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

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

წარმატებებს გისურვებთ სწავლაში! შემდეგ სტატიაში კი კოდზე ვისაუბრებთ.

გამოიწერეთ ჩვენი Telegram არხი იუნიორებისთვის, რათა არ გამოტოვოთ საინტერესო ვაკანსიები, სტაჟირება, კურსები, სტატიები.

Კარგი დღე!

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

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

შესავალი

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

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

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

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

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

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

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

ნაბიჯი 2: Ruby-ისა და Ruby-ის ინსტალაცია Rails-ზე

თუ გსურთ Rails-ის სწავლა, მაშინ უეჭველად დაგჭირდებათ მისი დაყენება თქვენს კომპიუტერში. აქ მოცემულია რამდენიმე გამოსავალი, რომელიც დაფუძნებულია თქვენს ოპერაციულ სისტემაზე. თუ თქვენ გაქვთ 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: შექმენით რაღაც საკუთარი

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

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

ღამე ერთი

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

მიუხედავად ამისა, თავად რუბი ძალიან შორს არის Ruby on Rails ჩარჩოსგან. რელსების დაუფლება მინდოდა. ჩვენი სტატიიდან ონლაინ განათლების შესახებ, ნამდვილად გამახსენდა სენსაციური Zombie for Rails railsforzombies.org კურსი. ეს არის ისევე, როგორც Try Ruby, ინტერაქტიული გაკვეთილი, რომელიც გასწავლით როგორ მოამზადოთ სარკინიგზო აპლიკაციები. პირველ რიგში, ისინი გაწვდიან მინი ლექციას (ინგლისურად, მაგრამ ყველაფერი ძალიან ნათელია - ჩართეთ სუბტიტრები) სარკინიგზო აპლიკაციის ფაილის სტრუქტურის, მონაცემებთან მუშაობის 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-ში შეგიძლიათ დაპროგრამება პირდაპირ ბრაუზერში, კურსის დავალებების შესრულებით

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

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