ჟანგი- ახალი ექსპერიმენტული ენის პროგრამირება, რომელსაც Mozilla არღვევს. ენა არის კომპილირებული და მრავალპარადიგმატული, პოზიციონირებული, როგორც C/C++-ის ალტერნატივა, რაც თავისთავად კარგია, ვინაიდან კონკურენციის ამდენი პრეტენდენტი არ არის. თქვენ შეგიძლიათ გამოიცნოთ D Walter Bright and Go Google-იდან.
Rust ხელს უწყობს ფუნქციურ, პარალელურ, პროცედურულ და ობიექტზე ორიენტირებულ პროგრამირებას და ა.შ. ასევე არსებობს მთელი რიგი პარადიგმები, რომლებიც რეალურად შეიძლება იქნას შესწავლილი გამოყენებით პროგრამირებაში.

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

პირველი მტერი

დასაკეცი კონდახი - ფაქტორული გაფართოების ფუნქცია:

Fn fac(n: int) -> int ( შედეგი = 1, i = 1; ხოლო i<= n { result *= i; i += 1; } ret result; }

როგორც კონდახიდან ჩანს, ფუნქციები განსხვავდება „ფუნქციური“ სტილისგან (ამ სტილს აქვს გარკვეული უპირატესობები ტრადიციულ „int fac (int n)“-თან შედარებით). ბაჩიმო ავტომატური ტიპის იდენტიფიკაცია(let საკვანძო სიტყვა), roundels-ების არსებობა while არგუმენტში (გოს მსგავსი). კიდევ ერთი მნიშვნელოვანი ასპექტია საკვანძო სიტყვების კომპაქტურობა. Rust-ის შემქმნელებმა ეფექტურად და მიზანმიმართულად შეინახეს ყველა საკვანძო სიტყვა მოკლედ და, მართალი გითხრათ, ეს ნაკლებად მიზანშეწონილია.

მეგობრული, მაგრამ ასევე სინტაქსური თვისებები

• ციფრულ მუდმივში შესაძლებელია ალიასის ჩასმა. ეს არის მოსახერხებელი რამ, შეგიძლიათ სწრაფად დაამატოთ მას ბევრი ახალი ენა.
  0xffff_ffff_ffff_ffff_ffff_ffff
• ორმაგი მუდმივები. რა თქმა უნდა, სწორი პროგრამისტი პასუხისმგებელია ბინების ექვსკუთხედად გონივრულად გადაქცევაზე, წინააღმდეგ შემთხვევაში ეს ბევრად უფრო ადვილია! 0b1111_1111_1001_0000
• ნებისმიერი ოპერატორის სხეულები (როგორც ჩანს, ისინი წარმოიქმნება ერთი სტრუქტურისგან) მოთავსებულია მჭიდრო მდგომარეობაში თაღის ფიგურასთან. მაგალითად, შეგიძლიათ დაწეროთ if(x>0) foo(); , Rust-ში საჭიროა მკაცრად დააყენოთ მშვილდის ფორმები foo() გვერდით.
• არ არსებობს არგუმენტები თუ, ხოლო განცხადებებისა და მსგავსი განცხადებების სათავეში განთავსება არ არის საჭირო.
• ხშირ შემთხვევაში, კოდის ბლოკები შეიძლება განსხვავებულად იქნას ხილული. ზოკრემა, შეიძლება ასე:
  მოდით x = if the_stars_align() ( 4 ) else if something_else() ( 3 ) else ( 0 );
• ფუნქციის სინტაქსია ჯერ საკვანძო სიტყვა fn, შემდეგ არგუმენტების სია, არგუმენტის ტიპი მითითებულია სახელის შემდეგ, შემდეგ როცა ფუნქცია ატრიალებს მნიშვნელობას - ისარი „->“ და დასაბრუნებელი მნიშვნელობის ტიპი.
• ანალოგიურად, შეგიძლიათ მიუთითოთ ცვლილება: საკვანძო სიტყვა let, ცვლილების სახელი, ცვლილების შემდეგ შეგიძლიათ გამოიყენოთ ორმაგი ველი ტიპის დასაზუსტებლად და შემდეგ მივანიჭოთ cob მნიშვნელობები.
  დაითვალეთ: int = 5;
• ულვაშის დაბანის შემდეგ ცვლილებები უცვლელია; ცვალებადი ცვალებადი საკვანძო სიტყვების დასადუმებლად გამოიყენება ცვალებადი საკვანძო სიტყვა.
• ძირითადი ტიპების სახელები ყველაზე კომპაქტურია, რომლებიც ნაკლებად გავრცელებულია: i8, i16, i32, i64, u8, u16, u32, u64, f32, f64.
• პროდუქტის დანიშნულების შემდეგ, წახალისებულია ტიპების ავტომატური ჩანაცვლება

Tipi ხარკი

პირიქით, ნომინატიური აკრეფა მიიღება C, C++, C# და ჯავა არ იძლევა ასეთ კონსტრუქციებს. ნომინაციული ტიპაჟის მიხედვით, კანის სტრუქტურა უნიკალური ტიპია, რომელიც არ არის გავრცელებული სხვა ტიპებთან.

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

Є ვექტორები - ზოგიერთ ასპექტში მსგავსია პირველადი მასივების მსგავსი, ხოლო ზოგიერთ შემთხვევაში - როგორიცაა std:: ვექტორი stl. სიის ინიციალიზაციისას, კვადრატული მკლავები გამოიყენება ისეთი ფორმების ნაცვლად, როგორიცაა C/C++

მოდით myvec =;

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

მოდით v: ცვალებადი =; v + =;

ჩნდება შაბლონები. მისი სინტაქსი სრულიად ლოგიკურია, C++-ის „თარგების“ არევის გარეშე. მხარდაჭერილია ფუნქციების შაბლონები და მონაცემთა ტიპები.

Fn for_rev (v: [T], აქტი: ბლოკ(T)) ( მოდით i = std::vec::len(v); ხოლო i > 0u ( i -= 1u; act(v[i]); ) ) აკრიფეთ წრიული_ბუფი = (დაწყება: uint, დასასრული: uint, buf:);

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

თეგის ფორმა (წრე (წერტილი, ათწილადი); მართკუთხედი (წერტილი, წერტილი); )

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

მონიშნე ცხოველი ( ძაღლი; კატა; ) ნება ა: ცხოველი = ძაღლი; a = კატა;
დაკეცილი კანის დაზიანებების დროს „გადატვირთვის“ ელემენტი არის დამოუკიდებელი სტრუქტურა, რომელსაც აქვს საკუთარი „კონსტრუქტორი“.
კიდევ ერთი სასარგებლო მაგალითია რეკურსიული სტრუქტურა, რომელშიც მითითებულია „სიის“ ტიპის ობიექტი:
ტეგების სია ( ნულ; მინუსები (T, @list ); ) მოდით: სია = cons(10, @cons(12, @nil));
ტეგებს შეუძლია მონაწილეობა მიიღოს ვიზუალიზაციაში, რომელიც შეიძლება დასაკეცი იყოს.
alt x ( cons(a, @cons(b, _)) (process_pair(a,b); ) cons(10, _) (process_ten(); ) _ ( ვერ; ) )

შაბლონის შესატყვისი

საშხაპეები.ყველაზე გავრცელებული „ჭკვიანი“ ინდიკატორების გარდა, Rust მხარს უჭერს სპეციალურ „ჭკვიან“ ინდიკატორებს სპეციალური მხარდაჭერით - საერთო ყუთები და უნიკალური ყუთები. მას აქვს shared_ptr და unique_ptr სუნი C++-დან. სინტაქსია: @ გაზიარებისთვის და ~ უნიკალურისთვის. უნიკალური ინდიკატორებისთვის, კოპირების ნაცვლად, მთავარი სპეცოპერაცია მოძრაობს:
მოდით x = ~ 10; ნება y<- x;
ასეთი ნაბიჯის შემდეგ x ინდიკატორი დეინიციალიზებულია.

Zamikannya, ნაწილობრივი სტაგნაცია, iterator

1. საკვანძო სიტყვა ლამბდა Vikoryst გამოიყენება ჩადგმული ფუნქციისა და ფუნქციური მონაცემთა ტიპის გასარკვევად.

Fn make_plus_function(x: int) -> lambda(int) -> int ( lambda(y: int) -> int (x + y) ) მოდით plus_two = make_plus_function(2); ამტკიცებს პლუს_ორი(3) == 5;

ეს აპლიკაცია იყენებს make_plus_function ფუნქციას, რომელიც იღებს ერთ არგუმენტს "x" int ტიპის და აქცევს ფუნქციას "int->int" ტიპად (აქ ლამბდა არის საკვანძო სიტყვა). ეს ფუნქცია აღწერს მის ფუნქციას. "დაბრუნების" ოპერატორის მნიშვნელობა მნიშვნელოვანია, თუმცა, FP-სთვის მას უპირველესი მნიშვნელობა აქვს მარჯვნივ.

2. საკვანძო სიტყვა ბლოკიეს გამოიყენება ფუნქციის ტიპის ასახსნელად - ფუნქციის არგუმენტი, რომელიც შეიძლება შეიცვალოს, საწყის კოდის ბლოკის მსგავსი.
fn map_int(f: block(int) -> int, vec: ) -> (დავუშვათ შედეგი = ;

აქ გვაქვს ფუნქცია, რომლის შეყვანა არის ბლოკი - არსებითად "int->int" ტიპის ლამბდა ფუნქცია და int ტიპის ვექტორი (დაწვრილებით ვექტორების სინტაქსის შესახებ ქვემოთ). თავად „ბლოკი“ კოდში, რომელიც გამოძახებულია, იწერება არაპირველადი სინტაქსის ანალოგიურად (| x | x + 1). განსაკუთრებით უფრო შესაფერისი ჩემთვის არის C# lambdi, სიმბოლო | იგი ჯერ განიხილება, როგორც ცოტა ABO (როგორც, საუბრის წინ, Rust-ში ის იგივეა, რაც ყველა სხვა მსგავსი ოპერაცია).

3. ნაწილობრივი სტასი - სხვა ფუნქციის საფუძველზე ფუნქციის შექმნა არგუმენტების დიდი რაოდენობით სხვა ფუნქციისთვის გარკვეული არგუმენტების მნიშვნელობის ჩასმით. რისთვის არის საკვანძო სიტყვა? შებოჭვაეს არის ჩანაცვლების სიმბოლო "_":

მოდით daynum = bind std::vec::position(_, ["mo", "tu", "we", "do", "fr", "sa", "su"])

უფრო გასაგებად რომ ვთქვათ, მაშინვე ვიტყვი, რომ თქვენ ასევე შეგიძლიათ ფულის გამომუშავება პირველ რიგში უმარტივესი დამწვრობის შექმნით, როგორიცაა:
const char * daynum (int i) (const char * s = ("mo", "tu", "we", "do", "fr", "sa", "su"); დაბრუნება s [i]; )

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

კიდევ ერთი მაგალითი: გამოიყენება add ფუნქცია ორი int არგუმენტით, რომელიც ბრუნავს int. შემდეგ მოდის ფუნქციური ტიპი single_param_fn, რომელიც იღებს ერთ არგუმენტს int და ბრუნავს int. bind ფუნქციას მხარს უჭერს ორი ფუნქციური ობიექტი add4 და add5, რომლებიც შექმნილია add ფუნქციის საფუძველზე, რომლებსაც ხშირად აქვთ არგუმენტები.

Fn add(x: int, y: int) -> int ( ret x + y; ) type single_param_fn = fn(int) -> int; მოდით add4: single_param_fn = bind add(4, _); მოდით add5: single_param_fn = bind add(_, 5);

ფუნქციური ობიექტების გამოძახება შესაძლებელია ისევე, როგორც პირველადი ფუნქციები.
assert (add(4,5) == add4(5)); assert (add(4,5) == add5(4));

4. წმინდა ფუნქციები და პრედიკატები
სუფთა ფუნქციები - ეს არის ფუნქციები, რომლებსაც შეიძლება ჰქონდეთ გვერდითი მოვლენები (გარდა სხვა ფუნქციებისა, რომლებიც სუფთაა). ასეთი ფუნქციები წარმოდგენილია სუფთა საკვანძო სიტყვით.
სუფთა fn lt_42 (x: int) -> bool ( ret (x< 42); }
პრედიკატები არის სუფთა ფუნქციები, რომლებიც ატრიალებენ bool ტიპის. ასეთი ფუნქციები შეიძლება შეიცვალოს ენერგეტიკული ტიპის სისტემაში (დაყოფა შემდგომში), რათა მათი გამოყენება შედგენის ეტაპზე სხვადასხვა სტატიკური შემოწმებისთვის.

სინტაქსური მაკროები
ფუნქცია იგეგმება, მაგრამ ეს ნამდვილად მაგარია. ჟანგი ჯერ კიდევ კობის განვითარების ეტაპზეა.
std::io::println(#fmt("%s არის %d", "პასუხი", 42));
ჩვენი printf-ის მსგავსი ვირუსი, მაგრამ კომპილაციის დროს (როგორც ჩანს, ყველა არგუმენტის ცვლილება გამოვლენილია კომპილაციის ეტაპზე). სამწუხაროდ, ძალიან ცოტა მასალაა სინტაქსურ მაკროებზე და თავად სუნი ჯერ კიდევ განვითარების ეტაპზეა, მაგრამ არსებობს იმედი, რომ ის ნემერლის ტიპის მაკროებს ჰგავს.
საუბრის წინ, ნემერლის გარდა, გადავწყვიტე, დამატებითი სიმბოლოს მიღმა სინტაქსურად მენახა მაკროები, პატივს ვცემ წიგნიერებსაც კი: მაკრო არის არსი, თუნდაც ფუნქციად დაყოფილი და მნიშვნელოვანს პატივს ვცემ ერთი შეხედვით. კოდები იძახიან ფუნქციებს და სად - მაკროებს

ატრიბუტები

პარალელური გამოთვლები

ამოცანა შედგება მინიმუმ ერთი ფუნქციისგან არგუმენტების გარეშე. დავალების გაშვება ხორციელდება დამატებითი ქვირითის ფუნქციის გამოყენებით. კანს ასევე შეუძლია გამოიყენოს არხები, რომელთა მეშვეობითაც ის ინფორმაციას სხვა ნაწილებს გადასცემს. არხი არის სპეციალური შაბლონის ტიპის ჭანი, რომელიც პარამეტრიზებულია არხის მონაცემთა ტიპის მიხედვით. მაგალითად, chan არის არხი ხელმოუწერელი ბაიტების გადასაცემად.
არხის გადასაცემად გამოიყენება გაგზავნის ფუნქცია, რომლის პირველი არგუმენტია არხი, მეორე კი გადაცემის მნიშვნელობა. სინამდვილეში, ეს ფუნქცია არის შიდა ბუფერის მნიშვნელობების არხზე გადატანა.
მონაცემების ამოსაღებად, თქვენ უნდა გამოიყენოთ vikory პორტი. პორტი არის შაბლონის ტიპის პორტი, რომელიც პარამეტრიზებულია პორტის მონაცემთა ტიპის მიხედვით: პორტი - პორტი ხელმოუწერელი ბაიტების მისაღებად.
პორტებიდან წასაკითხად გამოიყენეთ recv ფუნქცია, რომლის არგუმენტი არის პორტი, ხოლო მნიშვნელობები, რომლებიც ბრუნავს, არის მონაცემები პორტიდან. კითხვა ბლოკავს გაურკვევლობას. თუ პორტი ცარიელია, ბრძანება უნდა გადავიდეს აღდგენის სადგურზე, სანამ სხვა შეკვეთა არ გაიგზავნება პორტთან დაკავშირებულ მონაცემთა არხზე.
არხების პორტებთან დაკავშირება ისეთივე მარტივია, როგორც არხის ინიციალიზაცია პორტით chan საკვანძო სიტყვის გამოყენებით:
მოდით reqport = port();
მოდით reqchan = chan(reqport);
რამდენიმე არხის დაკავშირება შესაძლებელია ერთ პორტთან, მაგრამ არა ერთი და იგივე - ერთი არხი ერთდროულად ბევრ პორტთან დაკავშირება შეუძლებელია.

Typestate

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

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

შეზღუდვები - ეს არის სპეციალური ცვლილებები, რომლებიც შეიძლება განხორციელდეს შედგენის ეტაპზე. ამ მიზნით გამოიყენება საკვანძო სიტყვა Check.
სუფთა fn არის_უფრო ნაკლები(int a, int b) -< bool { ret a < b; } fn test() { let x: int = 10; let y: int = 20; check is_less_than(x,y); }
პრედიკატები შეიძლება "ჩამოკიდებული" იყოს ფუნქციის შეყვანის პარამეტრებზე ამ გზით:
fn ტესტი (int x, int y) : არის_უფრო ნაკლები (x,y) (...)

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

Სულ ეს არის.

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

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

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

• კვლევის ბევრ მონაწილეს, ვინაიდან ისინი არ მუშაობდნენ ვებ სერვერებთან და მასთან დაკავშირებულ გამოსვლებთან, არ ესმოდათ რისი მიღწევა გვინდოდა. ვინაიდან ეს საკითხები განიხილებოდა 1.0 ვერსიის საათებში, არ შემიძლია არ შევამჩნიო ის, რაც აქამდე არასდროს ყოფილა განხილული. Როგორია -?
• ასინქრონული I/O როგორია კორუტინი ( )?
• კორუტინები რა არის სამგზავრო ნაკადები ( )?

მსუბუქი ძაფები რა არის ფუტური? )?

• ფიუჩერსები

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

ჩვენ ყველანი მოკლე კოდში ვიყავით გახვეული. იაკ? მარველი ჭრის ქვეშ.

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

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

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

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

Rust-ში ახალი ვიყავი, დაბნეული ვიყავი მწკრივების განსაზღვრის სხვადასხვა ხერხით. წიგნს ენის შესახებ Rust აქვს განყოფილება „ცნობები და სესხება“, რომელშიც აღწერილია კონდახებში მწკრივის ცვლილებების სამი განსხვავებული ტიპი: String, & String და & str.

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

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

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

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

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

ამ სტატიაში მინდა განვიხილო დიზაინის შაბლონი ახალი ტიპის(ახალი ტიპი), ასევე From და Into ტიპები, რომლებიც ეხმარება ხელახლა შექმნილ ტიპებს.

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

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

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

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

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

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

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

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

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

• 1 ნატურალური რიცხვია
• ნატურალურის შემდეგ მოდის რიცხვიც ბუნებრივია.

დახმარებისთვის სიტყვასიტყვით ჩავწეროთ ჟანგში:

Nat არის ნული ან ნატურალური რიცხვი.

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

დავიწყოთ ფიუჩერსებით მუშაობა

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

ეს დოკუმენტაცია დაყოფილია რამდენიმე ნაწილად:

• "გამარჯობა, სინათლე!";
• ტიპის მომავალი;
• ტიპი Stream;
• კონკრეტული ფიუჩერსები და ნაკადი (Stream);
• მომავლის შემობრუნება;
• ამოცანა და მომავალი;
• ადგილობრივი მონაცემები.

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

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

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

მიმზიდველი მიზნები არის ციფრული ტიპები, რომლებსაც მხარს უჭერს პროცესორები, რომლებიც ახლოსაა მთელი რიცხვების უსასრულო კრებულთან, რომლებიც გამოიყენება რეალურ ცხოვრებაში. ეს გამონათქვამი ყოველთვის შედარებადია რეალურ რიცხვებთან, მაგალითად 255_u8 + 1 == 0. ყველაზე ხშირად, პროგრამისტი ივიწყებს ყველა ამ განსხვავებას, რამაც შეიძლება გამოიწვიოს შეცდომები.

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

ცოტა რამ რკინის შესახებ

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

ფილოსოფია

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

• "შუალედური" ტიპები - გამოიყენება შეკითხვის დამუშავების ჯვარედინი ფუნქციების განსახორციელებლად;
• მოდიფიკატორები გამოიყენება შეყვანის და გამოსავლების შესაცვლელად ყველაზე ერგონომიული გზით.

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

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

დასაწყისისთვის, მოდით შევქმნათ პროექტი Cargo-ს, ვიკორის გუნდის დახმარებით:

კომპილირებული ფაილი ამოღებულია:

632 კილობაიტი მარტივი ბეჭდვისთვის? Rust პოზიციონირებულია, როგორც სისტემური ენა, რომელსაც აქვს C/C++ ჩანაცვლების პოტენციალი, არა? რატომ არ გამოსცადეთ მსგავსი პროგრამა თქვენს უახლოეს კონკურენტზე?

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

ეს პოსტი აჩვენებს, თუ როგორ, როგორც Rust ვიკი, შეგიძლიათ განახორციელოთ მეხსიერების მართვის API მონაცემთა კონკურენტული სტრუქტურებისთვის, როგორიცაა:

• წაახალისეთ მონაცემთა დაბლოკვის გარეშე სტრუქტურის დანერგვა GC-ის გასააქტიურებლად;
• შექმენით სტატიკური დაცვა კეროვანი მეხსიერების არასწორი ვიკორისტანური სქემებისგან;
• GC ინვოისები გათანაბრდება (და მეტი გადაირიცხება).

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

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

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

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

ბევრი აზრი მაქვს ჩვენი პროგრამირების შესახებ.

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

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

ეს ძალიან ჰგავს მანქანების განხილვას. Chi chuli ახალი UAZ Ribak-ის შესახებ? რამდენად შვედია ის? შემიძლია თუ არა ახალი ნავით გადავიყვანო ტბაზე?

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

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

შენიშვნა: ამ სტატიაში ნათქვამია, რომ მკითხველი იცნობს Rust FFI (თარგმანი), endianness და ioctl.

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

აბა, გვსურს გაგაცნოთ თქვენი პატივისცემა ახლახანს დაბადების დღის ბიჭს (2016 წლის 15 მარტი ჩამოვარდნილი მდინარის ბედზე) - რუსთ. ამ უნივერსალურ პროგრამირებას, რომელიც შემუშავებულია Mozilla-ს მიერ, აქვს სამი ძირითადი პრინციპი: სითხე, უსაფრთხოება და ერგონომიკა. თავად ავტორები უხამსად მიიჩნევენ მას, როგორც C/C++-ის ერთ-ერთ უდიდეს კლებულს. StackOverflow პორტალზე დაფუძნებული, Rust დღეს ყველაზე მეტად უყვარს ენის შემქმნელებს. მამაო, მოდით უფრო ახლოს მივხედოთ რა არის ის.

ჟანგი დამწყებთათვის

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

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

იაკ ვივჩატი

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

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

• 9-10 გაზაფხული RustConf კონფერენცია პორტლენდში, აშშ;
• ევროპული სოლიდარობის RustFest-ის მე-17 საგაზაფხულო კონფერენცია ბერლინში, გერმანია;
• 27-ე Rust Belt Rust კონფერენცია პიტსბურგში, აშშ;

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

მახასიათებლები

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

Დადებითი:

• უსაფრთხო მუშაობა მეხსიერებასთან;
• ვისოკა შვიდკოდია;
• ალგებრული მონაცემთა ტიპი;
• კომპილაციის გადაცემის შესაძლებლობა;

ნაკლოვანებები:

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

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

მოთხოვნა

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

მეტი მოთხოვნა: პროფესია "სტატი".

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

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

რამდენადაც მე ვიცი, ჯერ კიდევ არ არსებობს რუსტის ვებსაიტზე საუკეთესო პრაქტიკის ერთი კოლექცია. ოფიციალურ დოკუმენტაციაში (ე.წ. წიგნები) არის უამრავი წითელი ზღაპარი და ასევე მიმოფანტული სხვადასხვა დაკავშირებულ სტატიებს შორის. პროტე, არის საინტერესო სტატიების სიები, რომლებიც დაგეხმარება მათ შუაშის პოვნაში. მაგალითად, qi:
https://github.com/ctjhoa/rust-learning
https://github.com/brson/rust-anthology/blob/maste...

ახალ პროექტებში Rust ვითარდება და ტენდენცია კვლავ ფართოვდება. ამ გვერდზე შეგიძლიათ ნახოთ რომელი კომპანიები ავრცელებენ Rust-ს და რატომ: https://www.rust-lang.org/en-US/friends.html

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

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

1. პროგრამის მაღალი პროდუქტიულობა, მეხსიერების ავტომატური მართვა მეხსიერების გადატვირთვის გარეშე.
2. პროგრამების მაღალი საიმედოობა და უსაფრთხოება, რაც გამორიცხავს დიდი რაოდენობით პოტენციურ პრობლემებს კომპილაციის ეტაპზე.
3. დაასრულეთ მარტივი და უპრობლემოდ გადამუშავების პროცესი და პროგრამების დამატებითი მოდიფიკაცია ტიპის სისტემის დარღვევისთვის.
4. პროექტისთვის დეპოზიტების სისტემა გაფართოვდა.
5. მართლაც კარგი უნივერსალური ინსტრუმენტი: Rust შესაფერისია როგორც პროტოტიპისთვის, ასევე განვითარებისთვის და ნებისმიერი ტიპის პროგრამისთვის (კომუნალური, დესკტოპის პროგრამები, ვებ დანამატები, მობილური პროგრამები, სისტემები და ა.შ.). კარგი შეხება ჯერ არ არის ყველასთვის, მაგრამ მომავალში ეს დიდი პლუსია.

2013 წელს Mozilla-მ Samsung-თან ერთად გამოაცხადა ახალი ვებ ბრაუზერის მექანიზმის, Servo-ს შექმნის შესახებ. იგი შეიქმნა სპეციალურად მობილური მოწყობილობების მაღალი ბირთვიანი პროცესორებისთვის, რომლებიც შექმნილია ამოცანების პარალელურ ძაფებად დაყოფისა და ვებ გვერდების წვდომის დროის შესაცვლელად. Servo ეფუძნება ჩემი Rust პროგრამის დაწერას, როგორც თავად Mozilla-მ შეიმუშავა მობილური აპლიკაციების დასაწერად.

ენის შესახებ

Rust არის პროცედურული პროგრამირების ენა, რომელიც ხელს უწყობს კოდირების მრავალფეროვან სტილს. დეველოპერმა გრეიდონ ჰოარმა ენის შექმნა 2006 წელს დაიწყო და სამი წლით ადრე, სანამ Mozilla შეუერთდებოდა პროექტს. 2010 Rust წარმოდგენილი იყო Mozilla Summit კონფერენციაზე. რაიმე მიზეზით, განვითარება გადაეცა შემდგენელს, რომელიც წერდა Rust-ში. შემდგენელმა გამოიყენა უნივერსალური სისტემა LLVM პროგრამების ანალიზისა და ტრანსფორმაციისთვის, როგორც მონაცემთა ბაზა.

ფილმის პირველი სტაბილური ვერსია 2015 წელს გამოვიდა. Rust-ის ალფა ვერსიის გამოშვების შემდეგ, ცვლილებების ამოცნობის შემდეგ, შემდგენლის შუამა დაკარგა არშეცვლის შესაძლებლობა. რაშტა გადაიყვანეს ექსპერიმენტულ განყოფილებაში.

ფილმის გულში გრეიდონ გუნდს აქვს შემდეგი გაგება:

• Უსაფრთხოება
• Rust-ს აქვს დაბალი ღირებულება პროგრამისტისთვის, რომელიც ჩართულია პროცესში. ბლოკებსა და ფუნქციებში მათი ჩასართავად საჭიროა არაუსაფრთხო ეტიკეტი.
• შვიდკისტი. Mova შეიძლება შევადაროთ თავისი სიჩქარით სხვა C++ პროგრამირებას, რაც უზრუნველყოფს პროგრამისტისთვის უპირატესობებს.
• პარალელიზმი. სისტემას შეუძლია გააუქმოს რამდენიმე გამოთვლა ერთდროულად და ამავე დროს მათ შეუძლიათ ურთიერთქმედება ერთმანეთთან.

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

Rust-ის ერთ-ერთი პირველი კოდის მაგალითი

• თუმცა, Rust-ს არ აქვს რაიმე დადებითი ან უარყოფითი მხარე, აქ არის მაჩვენებლები:
• კოდის ზემუნჯობა.
• ლიტერატურისა და ენის სუბსტანცია.

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

უფრო მეტიც, ენა რეგულარულად მოდერნიზებულია და განახლდება: ის ახლდება 6 წელიწადში ერთხელ.

Rust-ის განახლება C++-დან

• Rust-ის შემქმნელები პატივს სცემენ მას, როგორც C++-ის შთამომავალს, რომელიც არის 1980-იანი წლების ღვინო, თუ დეველოპერს გაუჩნდა იდეა S-ის ენაზე გაუმჯობესების შესახებ. ამიტომ, შესაძლებელია გაათანაბროს ახალგაზრდა ენა დროის ცვლილებით.
• დაუბრუნდით შორეულ მეხსიერებას. C++-ში არის რამდენიმე პრობლემა, რომელიც შეიძლება წარმოიშვას ამ ცვლილებების შედეგად. Rust-ში ასეთი სირთულე შეუძლებელია, რადგან არ არსებობს დისტანციური მეხსიერების ბრძანებები. შემდგენელი სწრაფად შეგატყობინებთ, რომ კოდი შესწორებულია და C++ შემდგენელი აჩვენებს შედეგს მნიშვნელობების წაშლის გარეშე და არ გაგაცნობთ პრობლემის შესახებ.
• სპეკა კომით. თქვენს კოდზე წერტილის დამატებით, თქვენ უწოდებთ შესვენებას C++-ში, ისევე როგორც Rust-ში მარყუჟის სხეული დევს მშვილდის ფიგურასთან ახლოს.

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

არის Firefox-ის რეალური დანერგვები C++-ში: ეს პრიმიტიული ენა დეტალების ყურადღებას მოითხოვს. წინააღმდეგ შემთხვევაში, ცვლილებები სერიოზულ შედეგებად გადაიზარდა. Rust მოუწოდებს ამ პრობლემის თავიდან აცილებას.

პერსპექტივები

RedMonk-ის რეიტინგში 2018 წლის მესამე კვარტალში, Mozilla პროგრამული უზრუნველყოფა მუდმივად 23-ე ადგილზეა. ექსპერტები პატივს სცემენ, რომ თქვენი პოზიციის შემცირება არ გემუქრებათ. სამწუხაროდ, 2018 წელს შემქმნელებმა გამოუშვეს Rust 1.28 განახლება.

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

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