Rust dasturlash tili

Steve Klabnik va Carol Nicholsning, Rust hamjamiyatining hissasi bilan

Kitobning ushbu versiyasi siz Rust 1.67.1 (2023-02-09-da chiqarilgan) yoki undan keyingi versiyasidan foydalanayotganingizni taxmin qiladi. Rustni o'rnatish yoki yangilash uchun 1-bobning ”O'rnatish” bo'limiga qarang.

HTML formati https://doc.rust-lang.org/stable/book/ saytida va oflayn rejimda rustup bilan qilingan Rust o'rnatishlari mavjud; ochish uchun rustup docs --book ni ishga tushiring.

Bir nechta hamjamiyat tarjimalari ham mavjud.

Ushbu kitob qog'oz va elektron kitob formatida No Starch Press nashrida mavjud.

🚨 Ko'proq interaktiv o'rganishni xohlaysizmi? Rust Bookning boshqa versiyasini sinab koʻring: viktorinalar, alohida chizilgan belgilashlar, vizualizatsiya va boshqalar: https://rust-book.cs.brown.edu

Muqaddima

Bu har doim ham unchalik aniq bo'lmagan, lekin Rust dasturlash tili asosan imkoniyatlarni kengaytirishga qaratilgan: hozir qanday kod yozayotganingizdan qat'iy nazar, Rust sizga oldinga qaraganda kengroq domenlarda ishonch bilan dasturlash imkonini beradi.

Masalan, memory managementning low-leveldagi tafsilotlari, ma'lumotlarni taqdim etish va parallellik bilan shug'ullanadigan "systems-leveldagi" ishni olaylik. An'anaga ko'ra, dasturlashning bu sohasi sirli bo'lib ko'rinadi, unga faqat o'zining dahshatli tuzoqlaridan qochish uchun zarur yillarini o'rganishga bag'ishlagan tanlanganlargina foydalanishi mumkin. Va hatto buni amalda qo'llayotganlar ham, ularning kodi ekspluatatsiyalar, buzilishlar yoki korruptsiyaga ochiq bo'lmasligi uchun buni ehtiyotkorlik bilan bajaradilar.

Rust eski tuzoqlarni yo'q qilish va sizga yordam berish uchun do'stona, sayqallangan vositalar to'plamini taqdim etish orqali bu to'siqlarni yo'q qiladi. Low-leveldagi boshqaruvga ”pastga tushishi” kerak bo'lgan dasturchilar buni Rust bilan odatiy holga tushib qolish xavfi yoki xavfsizlik teshiklarisiz va o'zgaruvchan toolchainning nozik tomonlarini o'rganmasdan amalga oshirishlari mumkin. Yaxshisi, bu til sizni tabiiy ravishda tezlik va xotiradan foydalanish jihatidan samarali bo'lgan ishonchli kodga yo'naltirish uchun mo'ljallangan.

Low leveldagi kod bilan ishlayotgan dasturchilar o'zlarining bilimlarini oshirish uchun Rust-dan foydalanishlari mumkin. Masalan, Rust-da parallelizmni joriy qilish nisbatan low-riskli operatsiya: kompilyator siz uchun klassik xatolarni aniqlaydi. Va siz tasodifan nosozliklar yoki zaifliklarni kiritmasligingizga ishonch bilan kodingizdagi yanada tajovuzkor optimallashtirishlarni hal qilishingiz mumkin.

Ammo Rust low-leveldagi tizimlarni dasturlash bilan cheklanmaydi. Bu CLI ilovalari, veb-serverlar va boshqa ko'plab turdagi kodlarni yozishni juda yoqimli qilish uchun yetarlicha ifodali va samarador - siz ikkalasining oddiy misollarini keyinroq kitobda topasiz. Rust bilan ishlash sizga bir domendan boshqasiga o'tadigan ko'nikmalarni shakllantirish imkonini beradi; veb-ilovani yozish orqali Rustni o'rganishingiz mumkin, so'ngra Raspberry Pi-ni nishonga olish uchun xuddi shu ko'nikmalarni qo'llashingiz mumkin.

Ushbu kitob o'z foydalanuvchilarini kuchaytirish uchun Rust imkoniyatlarini to'liq qamrab oladi. Bu sizga nafaqat Rust haqidagi bilimingizni, balki umuman dasturchi sifatidagi ishonchingizni oshirishga yordam beradigan samimiy va qulay kitob. Shunday qilib, sho'ng'ing, o'rganishga tayyor bo'ling va Rust hamjamiyatiga xush kelibsiz!

— Nicholas Matsakis va Aaron Turon

Kirish

Eslatma: Kitobning ushbu nashri No Starch Press-dan bosma va elektron kitob formatida mavjud bo'lgan Rust dasturlash tili bilan bir xil.

Rust dasturlash tiliga xush kelibsiz, Rust haqida kirish kitobi. Rust dasturlash tili tezroq va ishonchli dasturlarni yozishga yordam beradi. Yuqori darajadagi samaradorlik va low-leveldagi boshqaruv ko'pincha dasturlash tilini loyihalashda bir-biriga zid keladi; Rust bu ziddiyatga qarshi turadi. Kuchli texnik imkoniyatlar va ishlab chiquvchilarning ajoyib tajribasini muvozanatlash orqali Rust sizga an'anaviy ravishda bunday nazorat bilan bog'liq bo'lgan barcha qiyinchiliklarsiz low-leveldagi tafsilotlarni (masalan, xotiradan foydalanish) boshqarish imkoniyatini beradi.

Rust kim uchun

Rust turli sabablarga ko'ra ko'p odamlar uchun idealdir. Keling, eng muhim guruhlarning bir nechtasini ko'rib chiqaylik.

Dasturchilar jamoalari

Rust turli darajadagi tizimlarni dasturlash bo'yicha bilimga ega bo'lgan yirik ishlab chiquvchilar guruhlari o'rtasida hamkorlik qilish uchun samarali vosita ekanligini isbotlamoqda. Low-leveldagi kod turli xil nozik xatolarga moyil bo'lib, ko'pchilik boshqa tillarda ularni faqat keng ko'lamli sinov va tajribali ishlab chiquvchilar tomonidan sinchkovlik bilan tekshirish orqali aniqlash mumkin.Rust-da kompilyator ushbu qiyin xatolar, jumladan, parallellik xatolari bilan kodni kompilyatsiya qilishni rad etib, darvozabon rolini o'ynaydi. Kompilyator bilan birga ishlash orqali jamoa xatolarni ta'qib qilishdan ko'ra, vaqtini dastur mantig'iga qaratishga sarflashi mumkin.

Rust shuningdek, tizim dasturlash dunyosiga zamonaviy ishlab chiquvchilar vositalarini olib keladi:

• Cargo dependency menejeri va build toolni o'z ichiga oladi, Rust ekotizimida bog'liqliklarni qo'shish, kompilyatsiya qilish va boshqarishni qiyinchiliksiz va davomli qiladi.
• Rustfmt formatlash vositasi ishlab chiquvchilar orasida barqaror kodlash uslubini ta'minlaydi.
• Rust Language Server kodni toʻldirish va inline xato xabarlari uchun Integrated Development Environment (IDE) integratsiyasini quvvatlaydi.

Rust ekotizimidagi ushbu va boshqa vositalardan foydalangan holda, ishlab chiquvchilar tizim darajasidagi kodni yozishda samarali bo'lishi mumkin.

Talabalar

Rust talabalar va tizim tushunchalarini o'rganishga qiziquvchilar uchun. Rust-dan foydalanib, ko'p odamlar operatsion tizimlarni ishlab chiqish kabi mavzular haqida bilib oldilar. Jamiyat juda mehmondo'st va talabalar savollariga javob berishdan xursand. Ushbu kitob kabi sa'y-harakatlar orqali Rust guruhlari tizim tushunchalarini ko'proq odamlar, ayniqsa dasturlash uchun yangi bo'lganlar uchun qulayroq qilishni xohlashadi.

Kompaniyalar

Yuzlab yirik va kichik kompaniyalar ishlab chiqarishda Rust-dan CLI dasturlar, veb-xizmatlar, DevOps toollari, embedded qurilmalar, audio va video tahlillari va transkodlar, kriptovalyutalar, bioinformatika, qidiruv tizimlari, Internet of Things ilovalari kabi turli vazifalar uchun foydalanadilar. , machine learning va hatto Firefox veb-brauzerining asosiy qismlari.

Open Source dasturchilar

Rust Rust dasturlash tilini, hamjamiyatini, ishlab chiquvchilar vositalarini va kutubxonalarini yaratmoqchi bo'lgan odamlar uchundir. Rust tiliga o'z hissangizni qo'shishingizni istardik.

Tezlik va barqarorlikni qadrlaydigan odamlar

Rust dasturlash tili tezlik va barqarorlikni xohlaydigan odamlar uchundir. Tezlik deganda biz Rust kodi qanchalik tez ishlashini va Rust sizga dasturlar yozish imkonini beradigan tezligini nazarda tutamiz. Rust kompilyatorining tekshiruvlari qo'shimcha funksiyalar va refaktoring orqali barqarorlikni ta'minlaydi. Bu ishlab chiquvchilar ko'pincha o'zgartirishdan qo'rqadigan ushbu tekshiruvlarsiz tillardagi mo'rt eski koddan farqli o'laroq. Nol xarajatli abstraktsiyalarga, qo'lda yozilgan kod kabi tezroq lower-leveldagi kodni kompilyatsiya qiladigan higher-leveldagi funktsiyalarga intilish orqali Rust xavfsiz kodni ham tezkor kod qilishga intiladi.

Rust tili boshqa ko'plab foydalanuvchilarni ham qo'llab-quvvatlashga umid qiladi; Bu yerda tilga olinganlar faqat eng katta manfaatdor tomonlardan biri hisoblanadi. Umuman olganda, Rustning eng katta ambitsiyalari xavfsizlik va unumdorlik, tezlik va samaradorlikni ta'minlash orqali dasturchilar o'nlab yillar davomida qabul qilgan kelishuvlarni yo'q qilishdir. Rust-ni sinab ko'ring va uning tanlovlari sizga mos keladimi yoki yo'qligini tekshiring.

Bu kitob kim uchun

Ushbu kitobda siz boshqa dasturlash tilida kod yozgansiz deb taxmin qilinadi, lekin qaysi biri haqida hech qanday taxminlar yo'q. Biz materialni turli xil dasturlash tajribasiga ega bo'lganlar uchun keng foydalanishga harakat qildik. Biz dasturlash nima ekanligi yoki u haqida qanday fikr yuritish haqida gapirishga ko'p vaqt sarflamaymiz. Agar siz dasturlashda mutlaqo yangi bo'lsangiz, dasturlash bilan tanishishni ta'minlaydigan kitobni o'qisangiz yaxshi bo'lardi.

Ushbu kitobdan qanday foydalanish kerak

Umuman olganda, bu kitob siz uni oldindan orqaga ketma-ket o'qiyotganingizni taxmin qiladi. Keyingi boblar oldingi boblardagi tushunchalarga asoslanadi va oldingi boblar ma'lum bir mavzu bo'yicha tafsilotlarni o'rganmasligi mumkin, lekin keyingi bobda mavzuni qayta ko'rib chiqadi.

Ushbu kitobda siz ikki xil bo'limni topasiz: kontseptsiya bo'limlari va loyiha bo'limlari. Kontseptsiya boblarida siz Rustning bir tomoni haqida bilib olasiz. Loyiha bo'limlarida biz hozirgacha o'rganganlaringizni qo'llagan holda kichik dasturlarni birgalikda tuzamiz. 2, 12 va 20-boblar loyiha boblari; qolganlari kontseptsiya boblari.

1-bobda Rustni qanday o'rnatish, "Hello, world!" dasturi va Cargo, Rust paket menejeri va build tooldan qanday foydalanishni ko'rib chiqamiz. 2-bob Rustda dastur yozish bo'yicha amaliy kirish bo'lib, siz raqamlarni taxmin qilish o'yinini tuzasiz. Bu yerda biz tushunchalarni yuqori darajada yoritamiz va keyingi boblarda qo'shimcha tafsilotlar beriladi. Agar siz darhol qo'llaringizni ifloslantirmoqchi bo'lsangiz, 2-bob buning uchun joy. 3-bobda boshqa dasturlash tillariga oʻxshash Rust funksiyalari yoritilgan va 4-bobda siz Rustning ownershp tizimi haqida bilib olasiz. Agar siz keyingisiga o‘tishdan oldin har bir tafsilotni o‘rganishni ma’qul ko‘radigan, ayniqsa sinchkov o‘quvchi bo‘lsangiz, 2-bobni o‘tkazib yuborib, to‘g‘ridan-to‘g‘ri 3-bobga o‘tishingiz va loyiha ustida ishlashni hohlaganingizda 2-bobga qaytishingiz mumkin. siz o'rgangan tafsilotlar.

5-bobda structlar va metodlar muhokama qilinadi, 6-bob esa enumlar, match expressionlari va if let control flow konstruksiyasini qamrab oladi. Rust-da maxsus turlarni yaratish uchun struclar va enumlardan foydalanasiz.

7-bobda siz Rust modul tizimi va kodingizni va uning umumiy amaliy dasturlash interfeysini (API) tashkil qilish uchun maxfiylik qoidalari haqida bilib olasiz. 8-bobda standart kutubxona taqdim etadigan vektorlar, stringlar va hash maplar kabi umumiy yig'ish ma'lumotlar tuzilmalari muhokama qilinadi. 9-bob Rustning xatolarni hal qilish falsafasi va usullarini o'rganadi.

10-bob generiklar, traitlar va lifetimeni o'rganadi, bu sizga bir nechta turlarga tegishli kodni aniqlash imkoniyatini beradi. 11-bob sinovdan o'tadi, bu hatto Rustning xavfsizlik kafolatlari bilan ham dasturingiz mantig'ining to'g'riligini ta'minlash uchun zarurdir. 12-bobda biz fayllar ichidagi matnni qidiradigan grep buyruq qatori vositasidan o'zimizning funksiyalar to'plamini yaratamiz. Buning uchun biz oldingi boblarda muhokama qilgan ko'plab tushunchalardan foydalanamiz.

13-bob yopilishlar va iteratorlarni o'rganadi: Rustning funktsional dasturlash tillaridan kelib chiqadigan xususiyatlari. 14-bobda biz Cargolarni chuqurroq ko'rib chiqamiz va kutubxonalaringizni boshqalar bilan baham ko'rishning eng yaxshi amaliyotlari haqida gaplashamiz. 15-bobda standart kutubxona taqdim etadigan smart pointerlar va ularning funksionalligini ta'minlaydigan traitlar muhokama qilinadi.

16-bobda biz bir vaqtning o'zida dasturlashning turli modellarini ko'rib chiqamiz va Rust sizga bir nechta mavzularda qo'rqmasdan dasturlashda qanday yordam berishi haqida gaplashamiz. 17-bobda Rust idiomlari sizga tanish bo'lishi mumkin bo'lgan obyektga yo'naltirilgan(OOP) dasturlash tamoyillari bilan qanday taqqoslanishi ko'rib chiqiladi.

18-bobda Rust dasturlari bo'ylab g'oyalarni ifodalashning kuchli usullari bo'lgan patternlar va patternlarni moslashtirish haqida ma'lumot berilgan. 19-bobda ilg'or qiziqarli mavzular, jumladan xavfli Rust, makroslar va boshqa ko'p narsalar mavjud.

20-bobda biz low-leveldagi ko'p tarmoqli veb-serverni amalga oshiradigan loyihani yakunlaymiz!

Va nihoyat, ba'zi qo'shimchalarda til haqida foydali ma'lumotlar ko'proq mos yozuvlar formatida mavjud. A ilovasida Rustning kalit so'zlari, B ilovasida Rust operatorlari va belgilari, C ilovasi standart kutubxona tomonidan taqdim etilgan hosila traitlarini o'z ichiga oladi, D ilovasi ba'zi foydali ishlab chiqish vositalarini qamrab oladi va E ilovasida Rust nashrlari tushuntiriladi. F ilovasida siz kitobning tarjimalarini topishingiz mumkin, G ilovasida esa Rust qanday qilinganligi va nightlyli Rust nima ekanligini ko'rib chiqamiz.

Ushbu kitobni o'qishning noto'g'ri usuli yo'q: agar siz oldinga o'tmoqchi bo'lsangiz, unga boring! Agar chalkashliklarga duch kelsangiz, avvalgi boblarga qaytishingiz kerak bo'lishi mumkin. Lekin siz uchun nima ish qilsa, shuni qiling.

Rustni o'rganish jarayonining muhim qismi kompilyator ko'rsatadigan xato xabarlarini o'qishni o'rganishdir: ular sizni ish kodiga yo'naltiradi. Shunday qilib, biz kompilyator har bir vaziyatda sizga ko'rsatadigan xato xabari bilan birga kompilyatsiya qilinmaydigan ko'plab misollarni keltiramiz. Bilingki, agar siz tasodifiy misol kiritsangiz va ishlatsangiz, u kompilyatsiya qilinmasligi mumkin! Ishlamoqchi bo'lgan misol xato uchun mo'ljallanganligini bilish uchun atrofdagi matnni o'qiganingizga ishonch hosil qiling. Ferris, shuningdek, ishlash uchun mo'ljallanmagan kodni ajratishga yordam beradi:

Ferris	Ma'nosi
	Bu kod kompilyatsiya qilinmaydi!
	Bu kod panic!
	Ushbu kod kerakli xatti-harakatni keltirib chiqarmaydi.

Aksariyat hollarda biz sizni kompilyatsiya qilinmagan har qanday kodning to'g'ri versiyasiga olib boramiz.

Manba kodi

Ushbu kitob yaratilgan manba fayllarni GitHubda topish mumkin.

Ishni boshlash

Rust sayohatingizni boshlaymiz! O'rganish uchun ko'p narsa bor, lekin har bir sayohat bir joydan boshlanadi. Ushbu bobda biz muhokama qilamiz:

• Rustni Linux, macOS va Windows-ga o'rnatish
• Hello, world! ni chop etuvchi dasturni yozish
• cargo dan foydalanib, Rust paketlar menejeri va build systemdan foydalanish

O'rnatish

Birinchi qadam Rustni o'rnatishdir.Rustni Rust versiyalari va tegishli vositalarni boshqarish uchun buyruq qatori vositasi bo‘lgan rustup orqali yuklab olamiz. Yuklab olish uchun sizga internet ulanishi kerak bo'ladi.

Eslatma: Agar biron sababga ko'ra rustup dan foydalanmaslikni xohlasangiz, boshqa variantlar uchun Rustni o'rnatishning boshqa usullari sahifasiga qarang.

Quyidagi qadamlar Rust kompilyatorining so'nggi barqaror versiyasini o'rnatadi. Rustning barqarorligi kafolati kitobdagi kompilyatsiya qilingan barcha misollar Rustning yangi versiyalari bilan kompilyatsiya qilishda davom etishini ta'minlaydi. Chiqish versiyalar orasida biroz farq qilishi mumkin, chunki Rust ko'pincha xato xabarlari va ogohlantirishlarni yaxshilaydi. Boshqacha qilib aytadigan bo'lsak, ushbu qadamlar yordamida o'rnatgan har qanday yangi, barqaror Rust versiyasi ushbu kitob mazmuni bilan kutilganidek ishlashi kerak.

Buyruqlar qatori yozuvi

Ushbu bobda va butun kitobda biz terminalda ishlatiladigan ba'zi buyruqlarni ko'rsatamiz. Terminalga kiritishingiz kerak bo'lgan barcha qatorlar $ bilan boshlanadi. $ belgisini kiritishingiz shart emas; bu har bir buyruqning boshlanishini ko'rsatish uchun ko'rsatilgan buyruq qatori. $ bilan boshlanmagan qatorlar odatda oldingi buyruqning natijasini ko'rsatadi. Bundan tashqari, PowerShell-ga xos misollarda $ emas, > ishlatiladi.

Linux yoki macOS-ga rustup o'rnatish

Agar siz Linux yoki macOS dan foydalansangiz, terminalni oching va quyidagi buyruqni kiriting:

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

Buyruq skriptni yuklab oladi va Rustning eng so'nggi barqaror versiyasini o'rnatadigan rustup vositasini o'rnatishni boshlaydi. Sizdan parol so'ralishi mumkin. O'rnatish muvaffaqiyatli bo'lsa, quyidagi qator paydo bo'ladi:

Rust is installed now. Great!

Shuningdek, sizga linker, kerak bo'ladi, ya'ni Rust o'zining kompilyatsiya qilingan natijalarini bitta faylga birlashtirish uchun foydalanadigan dastur. Ehtimol,bu sizda allaqachon mavjud. Agar linker xatolarga duch kelsangiz, odatda linkerni o'z ichiga olgan C kompilyatorini o'rnatishingiz kerak. C kompilyatori ham foydalidir, chunki ba'zi umumiy Rust paketlari C kodiga bog'liq va C kompilyatoriga muhtoj bo'ladi.

MacOS-da siz C kompilyatorini ishga tushirish orqali olishingiz mumkin:

$ xcode-select --install

Linux foydalanuvchilari odatda distributiv texnik hujjatlariga muvofiq GCC yoki Clang o'rnatishlari kerak. Misol uchun, agar siz Ubuntu'dan foydalansangiz, build-essential paketini o'rnatishingiz mumkin.

Windows-ga rustup o'rnatish

Windows tizimida https://www.rust-lang.org/tools/install saytiga o'ting va Rustni o'rnatish bo'yicha ko'rsatmalarga amal qiling. O'rnatishning bir nuqtasida sizga Visual Studio 2013 yoki undan keyingi versiyalari uchun MSVC yaratish vositalari kerakligi haqida xabar keladi.

Build toolsini olish uchun Visual Studio 2022 ni o'rnatishingiz kerak bo'ladi. Qaysi ish dasturlarini o'rnatish kerakligi so'ralganda, quyidagilarni kiriting:

• “Desktop Development with C++”
• TWindows 10 yoki 11 SDK
• Ingliz tili to'plami komponenti va siz tanlagan boshqa tillar to'plami

Ushbu kitobning qolgan qismi cmd.exe va PowerShell da ishlaydigan buyruqlardan foydalanadi. Agar aniq farqlar bo'lsa, qaysi birini ishlatishni tushuntiramiz.

Muammolarni bartaraf etish

Rust to'g'ri o'rnatilganligini tekshirish uchun shellni oching va quyidagi qatorni kiriting:

$ rustc --version

Quyidagi formatda chiqarilgan so‘nggi barqaror versiya uchun versiya raqami, xesh va tasdiqlangan sanani ko‘rishingiz kerak:

rustc x.y.z (abcabcabc yyyy-mm-dd)

Agar siz ushbu ma'lumotni ko'rsangiz, Rustni muvaffaqiyatli o'rnatdingiz! Agar siz ushbu ma'lumotni ko'rmasangiz, Rust %PATH% tizim o'zgaruvchingizda quyidagi tarzda ekanligini tekshiring.

Windows CMD-da quyidagilardan foydalaning:

> echo %PATH%

PowerShell-da foydalaning:

> echo $env:Path

Linux va macOS-da quyidagilardan foydalaning:

$ echo $PATH

Agar hammasi to'g'ri bo'lsa va Rust hali ham ishlamasa, yordam olishingiz mumkin bo'lgan bir qancha joylar mavjud. Boshqa Rustaceanlar (biz o'zimizni chaqiradigan ahmoqona taxallus) bilan qanday bog'lanishni hamjamiyat sahifasida bilib oling.

Yangilash va o'chirish

Rust rustup orqali o'rnatilgandan so'ng, yangi chiqarilgan versiyaga yangilash oson. Shelldan quyidagi yangilash skriptini ishga tushiring:

$ rustup update

Rust va rustup-ni o'chirish uchun shelldan quyidagi o'chirish skriptini ishga tushiring:

$ rustup self uninstall

Mahalliy texnik hujjatlar

Rust-ning o'rnatilishi texnik hujjatlarning mahalliy nusxasini ham o'z ichiga oladi, shunda siz uni oflayn rejimda o'qishingiz mumkin. Brauzeringizda mahalliy texnik hujjatlarni ochish uchun rustup doc dasturini ishga tushiring.

Istalgan vaqtda standart kutubxona tomonidan tur yoki funksiya taqdim etilsa va siz u nima qilishini yoki undan qanday foydalanishni bilmasangiz, bilish uchun amaliy dasturlash interfeysi (API) texnik hujjatlaridan foydalaning!

Hello, World!

Endi siz Rustni o'rnatdingiz, hozir sizning birinchi Rust dasturingizni yozishning ayni vaqti. Yangi dasturlash tilini o'rganishda Hello, World! matnini ekranga chop etuvchi kichik va sodda dastur tuzish an'anaga aylangan, shunday ekan biz ham sinab ko'ramiz!

Eslatma: Bu kitob terminal bilan ishlay olishning boshlang'ich ko'nikmalarini talab qiladi. Rust sizning kod muxarriringiz foydalanadigan asboblaringiz va kodingizni qayerda joylayishi bo'yicha talablar qo'ymaydi, shuning uchun agar siz terminal o'rniga integratsiyalashgan ishlab chiqish muhitidan (IDE) foydalanishni afzal ko'rsangiz, o'zingizning sevimli IDE-dan foydalaning. Ko'pgina IDElar endi ma'lum darajada Rust-ni qo'llab-quvvatlaydi; tafsilotlar uchun IDE hujjatlarini tekshiring. Rust jamoasi rust-analyzer orqali ajoyib IDE yordamini ta'minlashga e'tibor qaratdi. Batafsil ma’lumot uchun D ilovasini ko'zdan kechiring.

Loyiha jildini yaratish

Siz ishni Rust kodingizni joylaytirish uchun jild yaratishdan boshlaysiz. Rust uchun sizning kodingiz qayerda joylashining ahamiyati yo'q, lekin biz bu kitobdagi mashq va loyihalarni joylash uchun projects nomli jild yaratishingizni maslahat beramiz.

Terminalni oching va projects jildini yaratish va uning ichidan “Hello, world!” loyihasi jildini yaratish uchun quyidagi buyruqlarni kiriting.

Linux, macOS va Windows Powershell uchun:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

Windows CMD uchun:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

Rust dasturi yozish va ishga tushirish.

Endi, main.rs nomli yangi fayl yarating. Rust kodlar har doim .rs kengaytmasi bilan tugaydi. Agar fayl nomida bir nechta so'zlardan foydalansangiz, ularni ajratish uchun pastki chiziqdan foydalanish shart. Masalan, helloworld.rs o'rniga hello_world.rs dan foydalaning.

Endi hozirgina yaratgan main.rs faylingizni kod muharririda oching.

Fayl nomi: main.rs

fn main() {
    println!("Hello, world!");
}

Ro'yxat 1-1: Hello, world! ni chop etuvchi dastur

Faylni saqlang va Terminalda ~/projects/hello_world jildiga qayting. Linux yoki macOS da faylni kompilyatsiya qilish va ishga tushirish uchun quyidagi buyruqlarni kiriting:

$ rustc main.rs
$ ./main
Hello, world!

Windowsda ./main ning o'rniga .\main.exe buyrug'ini kiriting:

> rustc main.rs
> .\main.exe
Hello, world!

Operatsion tizimingizdan qat'i nazar, terminalda Hello, world! qatori chop etilishi kerak.Agar siz ushbu chiqishni ko'rmasangiz, yordam olish usullari uchun O'rnatish bo'limining ”Muammolarni bartaraf etish” bo'limiga qayting.

Agar Hello, world! chop etilgan bo'lsa, tabriklaymiz! Siz rasmiy ravishda Rust dasturini yozdingiz. Bu sizni Rust dasturchisiga aylantiradi - xush kelibsiz!

Rust dasturining tuzilishi.

Keling "Hello, world!" dasturiga chuqurroq nazar solamiz. Boshqotirmaning 1-qismi:

fn main() {

}

Bu qatorlar main nomli funksiyani e'lon qiladi. main funksiyasi alohida: u har doim bajariladigan Rust dasturida ishlaydigan birinchi koddir. Bu yerda birinchi satr hech qanday parametrga ega boʻlmagan va hech narsani qaytarmaydigan main funksiyasini eʼlon qiladi. Agar parametrlar mavjud bo'lsa, ular () qavslar ichiga kiradi.

Funksiyasing tanasi {} bilan o'ralgan. Rust har bir funksiyalarda e'lon qilishda {} dan foydalanishni talab qiladi.

Eslatma: Agar siz Rust loyihalarda standart usulda kod yozmoqchi bo'lsangiz kodingizni maʼlum bir uslubda formatlash uchun rustfmt nomli avtomatik formatlash vositasidan foydalanishingiz mumkin (batafsilroq rustfmt D ilovasi -da) Rust jamoasi ushbu vositani standart Rust distributiviga kiritdi, chunki rustc kabi, u allaqachon kompyuteringizga o'rnatilgan bo'lishi kerak!

main funksiyaning tanasi quyidagi kodni o'z ichiga oladi:

#![allow(unused)]
fn main() {
    println!("Hello, world!");
}

Shu bir qator kod shu kichik dasturdagi barcha ishni amalga oshiardi: u matnni ekranga chop etadi.Bu yerda ahamiyat qaratish zarur bo'lgan to'rtta muhim narsalar bor.

Birinchidan, Rust style to'rtta bo'shliqdan iborat tab emas

Ikkinchidan, println! Rust makrosini chaqiradi. Agar u funktsiyani o'rniga chaqirgan bo'lsa, u println (! belgisiz) sifatida kiritiladi. Biz Rust makrolari haqida 19-bobda batafsilroq muhokama qilamiz.Hozircha siz shuni bilishingiz kerakki, ! belgisidan foydalanish oddiy funksiya o‘rniga makrosni chaqirayotganingizni anglatadi va makrolar har doim ham funksiyalar bilan bir xil qoidalarga amal qilmaydi.

Uchinchidan, siz "Hello, world!" qatorini ko'rasiz. Bu satrni argument sifatida println! ga uzatamiz va satr ekranga chop etiladi.

To'rtinchidan, satrni nuqtali vergul (;) bilan tugatamiz, bu esa bu ifoda tugaganligini va keyingisi boshlashga tayyorligini bildiradi. Rust kodining aksariyat satrlari nuqtali vergul bilan tugaydi.

Kompilyatsiya va ishga tushirish alohida bosqichlardir

Siz yangi yaratilgan dasturni ishga tushirdingiz, shuning uchun jarayonning har bir bosqichini ko'rib chiqamiz.

Rust dasturini ishga tushirishdan oldin uni Rust kompilyatoridan foydalanib, rustc buyrug‘ini kiritib, unga manba faylingiz nomini quyidagi tarzda kiritishingiz kerak:

$ rustc main.rs

Agar siz C yoki C++ bilan ishlagan bo'lsangiz, bu gcc yoki clang ga o'xshashligini sezasiz. Muvaffaqiyatli kompilyatsiyadan so'ng Rust binary bajariladigan faylni chiqaradi.

Linux, macOS va Windows-dagi PowerShell-da siz shelldagi ls buyrug'ini kiritish orqali bajariladigan faylni ko'rishingiz mumkin:

$ ls
main  main.rs

Linux va macOS-da siz ikkita faylni ko'rasiz. Windows-dagi PowerShell bilan siz CMD-dan foydalangan holda ko'rgan uchta faylni ko'rasiz. Windows-da CMD bilan siz quyidagilarni kiritasiz:

> dir /B %= the /B faqat fayl nomlarini ko'rsatishni aytadi =%
main.exe
main.pdb
main.rs

Bu sizga .rs kengaytmali kod faylini, bajariluvchi faylni(Windowsda main.exe boshqa barcha tizimlarda main), va Windowsdan foydalanayotganingizda, debugging ma'lumotlarini o'z ichida saqlovchi .pdb kengaytmali faylni ko'rsatadi.

Bu yerdan siz main yoki main.exe faylini ishga tushirasiz, masalan:

$ ./main # or .\Windows-da main.exe

Agar sizning main.rs faylingiz “Hello, world!” dasturi bo'lsa, bu dastur ekranga Hello, world! matnini chop etadi.

Agar siz Ruby, Python yoki JavaScript kabi dinamik tilni yaxshi bilsangiz, dasturni alohida bosqichlar sifatida kompilyatsiya qilish va ishga tushirishga odatlanmagan bo'lishingiz mumkin. Rust - bu oldindan tuzilgan kompilyatsiya tili, ya'ni siz dasturni kompilyatsiya qilishingiz va bajariladigan faylni boshqa birovga berishingiz mumkin va ular Rustni o'rnatmasdan ham uni ishga tushirishlari mumkin.Agar siz kimgadir .rb, .py yoki .js faylini bersangiz, ularda Ruby, Python yoki JavaScript ilovasi oʻrnatilgan boʻlishi kerak (mos ravishda). Ammo bu tillarda dasturni kompilyatsiya qilish va ishga tushirish uchun faqat bitta buyruq kerak bo'ladi. Til dizaynida hamma narsa o'zaro kelishuvdir.

Oddiy dasturlar uchun rustc bilan kompilyatsiya qilish juda mos keladi, lekin loyihangiz o'sib borishi bilan siz barcha variantlarni boshqarishni va kodingizni almashishni osonlashtirishni xohlaysiz. Endi, biz siz bilan haqiqiy Rust dasturlarini tuzishda qulaylik yaratuvchi Cargo yordamchisi bilan tanishamiz.

Hello, Cargo!

Cargo - bu Rustning build tizimi va paketlar menejeri. Aksariyat Rustaceanlar o'zlarining Rust loyihalarini boshqarish uchun ushbu vositadan foydalanadilar, chunki Cargo siz uchun kodni yaratish, kodingizga bog'liq kutubxonalarni yuklab olish va ushbu kutubxonalarni yaratish kabi ko'plab vazifalarni bajaradi.(Biz sizning kodingizga kerak bo'lgan kutubxonalarni chaqiramiz dependencies.)

Eng oddiy Rust dasturlari, biz hozirgacha yozganimiz kabi, hech qanday dependencylarga ega emas. Agar biz “Hello, world!” Cargo bilan loyiha bo'lsa, u faqat sizning kodingizni yaratish bilan shug'ullanadigan Cargo qismidan foydalanadi. Murakkab Rust dasturlarini yozganingizda, siz dependencylarni qo'shasiz va agar siz Cargo yordamida loyihani boshlasangiz, dependencylarni qo'shish osonroq bo'ladi.

Rust loyihalarining aksariyati Cargolardan foydalanganligi sababli, ushbu kitobning qolgan qismida siz ham Cargodan foydalanasiz deb taxmin qilinadi. O'rnatish bo'limida muhokama qilingan rasmiy o'rnatuvchilardan foydalansangiz, Cargo Rust bilan birga keladi. Agar siz Rust-ni boshqa vositalar orqali o'rnatgan bo'lsangiz, terminalingizga quyidagilarni kiritish orqali Cargo o'rnatilganligini tekshiring:

$ cargo --version

Agar siz versiya raqamini ko'rsangiz, sizda bor! Agar siz command not found kabi xatolikni ko'rsangiz, Cargoni qanday qilib alohida o'rnatish bo'yicha texnik hujjatlarni ko'rib chiqing.

Cargo bilan loyiha yaratish

Keling, Cargo-dan foydalanib yangi loyiha yarataylik va u bizning asl “Hello, world!” loyihadan qanday farq qilishini ko'rib chiqaylik. O'zingizning projects jildigiga (yoki kodingizni saqlashga qaror qilgan joyingizga) qayting. Keyin istalgan operatsion tizimda quyidagilarni bajaring:

$ cargo new hello_cargo
$ cd hello_cargo

Birinchi buyruq hello_cargo nomli yangi jild va loyihani yaratadi. Biz loyihamizga hello_cargo deb nom berdik va Cargo o'z fayllarini xuddi shu nomdagi jildda yaratadi.

hello_cargo jildiga o'ting va fayllar ro'yxatini ko'ring.Cargo biz uchun ikkita fayl va bitta jild yaratganini ko'rasiz: Cargo.toml fayli va ichida main.rs fayli bo'lgan src jildi.

Shuningdek, u .gitignore fayli bilan birga yangi Git repositoryni ishga tushirdi. Mavjud Git repositoryda cargo new ni ishga tushirsangiz, Git fayllari yaratilmaydi; cargo new - vcs=git yordamida bu xatti-harakatni bekor qilishingiz mumkin.

Eslatma: Git keng tarqalgan versiya boshqaruv tizimidir. Siz --vcs buyrugʻi yordamida cargo new ni boshqa versiyani boshqarish tizimidan foydalanishga yoki versiyani boshqarish tizimisiz foydalanishga oʻzgartirishingiz mumkin. Mavjud variantlarni ko'rish uchun cargo new --help ni ishga tushiring.

Siz tanlagan matn muharririda Cargo.tomlni oching. U 1-2 ro'yxatdagi kodga o'xshash bo'lishi kerak.

Fayl nomi: Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Ro'yxat 1-2: cargo new tomonidan yaratilgan Cargo.toml tarkibi

Bu fayl TOML da (Tom’s Obvious, Minimal Language) formati, bu Cargo konfiguratsiya formati.

Birinchi qator, [package], bo'lim sarlavhasi bo'lib, quyidagi iboralar paketni sozlayotganligini bildiradi.Ushbu faylga qo'shimcha ma'lumot qo'shsak, biz boshqa bo'limlarni qo'shamiz.

Keyingi uchta qatorda Cargo dasturingizni kompilyatsiya qilish uchun kerak bo'lgan konfiguratsiya ma'lumotlarini o'rnatadi: Rustning nomi, versiyasi va foydalanish uchun nashri. E ilovasida edition kaliti haqida gaplashamiz.

Oxirgi qator, [dependencies], loyihangizning har qanday dependencylarini ro'yxatlash uchun bo'limning boshlanishi. Rustda kod paketlari crates deb ataladi. Ushbu loyiha uchun bizga boshqa cratelar kerak bo'lmaydi, lekin biz 2-bobdagi birinchi loyihada bo'lamiz, shuning uchun biz ushbu dependencies bo'limidan foydalanamiz.

Endi src/main.rs oching va qarang:

Fayl nomi: src/main.rs

fn main() {
    println!("Hello, world!");
}

Cargo “Hello, world!” siz uchun dastur, xuddi biz Ro'yxat 1-1 da yozganimiz kabi! Hozircha, bizning loyihamiz va yaratilgan Cargo loyihasi o'rtasidagi farq shundaki, Cargo kodni src jildiga joylashtirgan va bizda yuqori jildda Cargo.toml konfiguratsiya fayli mavjud.

Cargo sizning manba fayllaringiz src jildida turishini kutadi. Yuqori darajadagi loyiha jildi faqat README fayllari, litsenziya maʼlumotlari, konfiguratsiya fayllari va kodingizga aloqador boʻlmagan boshqa narsalar uchun moʻljallangan. Cargo-dan foydalanish loyihalaringizni tartibga solishga yordam beradi. Hamma narsaning o'rni bor va hamma narsa o'z o'rnida.

Agar siz “Hello, world!” bilan qilganimizdek, Cargo-dan foydalanmaydigan loyihani boshlagan bo'lsangiz, uni Cargo-dan foydalanadigan loyihaga aylantirishingiz mumkin. Loyiha kodini src jildiga o'tkazing va tegishli Cargo.toml faylini yarating.

Cargo loyihasini qurish va ishga tushirish

Keling, “Hello, world!” ni qurish va ishga tushirishda nima farq qilishini ko'rib chiqaylik. Cargo bilan dasturni hello_cargo jildidan quyidagi buyruqni kiritish orqali loyihangizni build qiling:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Ushbu buyruq bajariladigan faylni joriy jildingizda emas, balki target/debug/hello_cargo da (yoki Windowsda target\debug\hello_cargo.exe)da yaratadi. Odatiy tuzilish debug tuzilishi bo'lgani uchun Cargo binary faylni debug nomli jildga joylashtiradi. Ushbu buyruq bilan bajariladigan faylni ishga tushirishingiz mumkin:

$ ./target/debug/hello_cargo # yoki .\target\debug\hello_cargo.exe Windowsda
Hello, world!

Agar hammasi yaxshi bo'lsa, Hello, world! terminalga chop etilishi kerak.cargo build ni birinchi marta ishga tushirish ham Cargoning yuqori darajadagi yangi faylni yaratishiga olib keladi: Cargo.lock. Ushbu fayl loyihangizdagi dependencylarning aniq versiyalarini kuzatib boradi. Ushbu loyihada dependencylar yo'q, shuning uchun faylda kod biroz kam. Siz hech qachon ushbu faylni qo'lda o'zgartirishingiz shart emas; Cargo uning tarkibini siz uchun boshqaradi.

Biz hozirgina cargo build orqali loyihasini build qildik va uni ./target/debug/hello_cargo bilan ishga tushirdik, lekin kodni kompilyatsiya qilish uchun cargo run dan ham foydalanishimiz va natijada bajariladigan faylni bitta buyruqda ishga tushirishimiz mumkin:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

cargo run dan foydalanish cargo build ni ishga tushirishdan ko'ra qulayroqdir va keyin binary yo'lni to'liq ishlatadi, shuning uchun ko'pchilik ishlab chiquvchilar cargo run dan foydalanadilar.

E'tibor bering, bu safar biz Hello_cargo ni kompilyatsiya qilayotganini ko'rsatadigan natijani ko'rmadik. Cargo fayllar o'zgarmaganligini aniqladi, shuning uchun u qayta tiklanmadi, balki binary faylni ishga tushirdi. Agar siz manba kodingizni o'zgartirgan bo'lsangiz, Cargo loyihani ishga tushirishdan oldin uni qayta build qilgan bo'lar edi va siz ushbu natijani ko'rgan bo'lar edingiz:

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/hello_cargo`
Hello, world!

Cargo shuningdek, cargo check deb nomlangan buyruqni taqdim etadi. Bu buyruq kompilyatsiya qilish uchun kodingizni tezda tekshiradi, lekin bajariladigan fayl yaratmaydi:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Nima uchun bajariladigan faylni xohlamaysiz? Ko'pincha cargo check cargo builddan ko'ra tezroq bo'ladi,, chunki u bajariladigan faylni yaratish bosqichini o'tkazib yuboradi. Agar siz kod yozish paytida ishingizni doimiy ravishda tekshirayotgan bo'lsangiz, cargo check dan foydalanish loyihangiz hali ham kompilyatsiya qilinayotganligini bildirish jarayonini tezlashtiradi! Shunday qilib, ko'plab Rustaceanlar vaqti-vaqti bilan cargo check ni amalga oshiradilar, chunki ular o'z dasturlarini kompilyatsiya qilishiga ishonch hosil qilish uchun yozadilar. Keyin ular bajariladigan fayldan foydalanishga tayyor bo'lgach, cargo build ni ishga tushiradilar.

Cargo haqida shu paytgacha o'rganganlarimizni takrorlaymiz:

• Biz cargo new yordamida loyiha yaratamiz.
• cargo build yordamida loyihani build qilishimiz mumkin.
• Biz cargo run yordamida bir bosqichda loyiha build qilishimiz va ishga tushirishimiz mumkin.
• cargo check yordamida xatolarni tekshirish uchun binary ishlab chiqarmasdan loyihani build qilishimiz mumkin.
• Build natijasini bizning kodimiz bilan bir xil jildda saqlash o'rniga, Cargo uni target/debug jildida saqlaydi.

Cargo-dan foydalanishning qo'shimcha afzalligi shundaki, qaysi operatsion tizimda ishlayotganingizdan qat'i nazar, buyruqlar bir xil bo'ladi. Shunday qilib, biz endi Linux va MacOS uchun Windows-ga nisbatan maxsus ko'rsatmalar bermaymiz.

Loyihani Reliz qilish

Loyihangiz nihoyat relizga tayyor bo'lgach, uni optimallashtirish bilan kompilyatsiya qilish uchun cargo build --release dan foydalanishingiz mumkin. Ushbu buyruq target/debug o'rniga target/release da bajariladigan fayl yaratadi. Optimizatsiya Rust kodingizni tezroq ishga tushiradi, lekin bu kompilyatsiya vaqtini uzaytiradi. Shuning uchun ikkita turli profil mavjud: biri tez va tez-tez qayta tiklamoqchi bo'lganingizda ishlab chiqish uchun, ikkinchisi esa oxirgi dasturni yaratish uchun siz foydalanuvchiga qayta tiklanmaydigan va mkon qadar tez ishlaydigan oxirgi dastur. Agar siz kodingizning ishlash vaqtini solishtirmoqchi bo'lsangiz, cargo build --release dasturini ishga tushiring va target/release da bajariladigan fayl bilan taqqoslang.

Konventsiya sifatida Cargo

Oddiy loyihalar bilan Cargo rustc dan foydalanishdan ko'ra unchalik katta foyda keltirmaydi, ammo dasturlaringiz yanada murakkablashgani sayin u o'z qiymatini isbotlaydi. Dasturlar bir nechta fayllarga ko'payib rivojlanganda yoki ularga dependency kerak bo'lsa, Cargo-ga buildni muvofiqlashtirishga ruxsat berish ancha oson bo'ladi.

hello_cargo loyihasi oddiy bo'lsa ham, u endi Rust karyerangizning qolgan qismida foydalanadigan haqiqiy asboblarning ko'p qismini ishlatadi. Haqiqatan ham, mavjud loyihalar ustida ishlash uchun siz Git yordamida kodni tekshirish, ushbu loyiha jildiga oʻzgartirish va build qilish uchun quyidagi buyruqlardan foydalanishingiz mumkin:

$ git clone github.com/birorta-loyiha
$ cd birorta-loyiha
$ cargo build

Cargo haqida ko'proq ma'lumot olish uchun uning texnik hujjatlarini tekshiring.

Xulosa

Siz allaqachon Rust sayohatingizni ajoyib boshladingiz! Ushbu bobda siz quyidagilarni o'rgandingiz:

• Rust-ning so'nggi barqaror versiyasini rustup yordamida o'rnatish
• Rustning yangi versiyasiga yangilash
• Mahalliy o'rnatilgan texnik hujjatlarni ochish
• “Hello, world!” deb yozing va ishga tushiring. to'g'ridan-to'g'ri rustc dan foydalangan holda dastur
• Cargo konventsiyalaridan foydalangan holda yangi loyiha yaratish va ishga tushirish

Bu Rust kodini o'qish va yozishga odatlanish uchun yanada muhimroq dastur yaratish uchun ajoyib vaqt. Shunday qilib, 2-bobda biz taxminiy o'yin dasturini tuzamiz. Agar siz Rust-da umumiy dasturlash tushunchalari qanday ishlashini o'rganishni afzal ko'rsangiz, 3-bobga qarang va keyin 2-bobga qayting.

Taxmin qilish o'yinini dasturlash

Keling, birgalikda amaliy loyiha orqali Rustga o'taylik! Ushbu bob sizni bir nechta umumiy Rust tushunchalari bilan tanishtirib, ulardan haqiqiy dasturda qanday foydalanishni ko'rsatib beradi. Siz let, match, metodlari, bog'langan funksiyalar, external cratelardan foydalanish va boshqalar haqida bilib olasiz! Keyingi boblarda biz ushbu fikrlarni batafsilroq ko'rib chiqamiz. Ushbu bobda siz faqat asoslarni mashq qilasiz.

Biz klassik boshlang'ich dasturlash muammosini amalga oshiramiz: taxmin qilish o'yini. Bu qanday ishlaydi: dastur 1 dan 100 gacha tasodifiy butun son hosil qiladi. Keyin u o'yinchini taxmin qilishni taklif qiladi.Tahmin kiritilgandan so'ng, dastur taxmin kichik yoki katta ekanligini ko'rsatadi. Agar taxmin to'g'ri bo'lsa, o'yin tabrik xabarini chop etadi va chiqadi.

Yangi loyiha yaratish

Yangi loyihani o'rnatish uchun 1-bobda yaratgan projects jildiga o'ting va Cargo-dan foydalanib yangi loyiha yarating, masalan:

$ cargo new taxminiy_raqam
$ cd taxminiy_raqam

Birinchi cargo new buyrug'i birinchi argument sifatida loyiha nomini (taxminiy_raqam)ni oladi. Ikkinchi buyruq yangi loyiha jildiga kiradi.

Yaratilgan Cargo.toml fayliga qarang:

Fayl nomi: Cargo.toml

[package]
name = "taxminiy_raqam"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

1-bobda ko'rganingizdek, cargo new siz uchun “Hello, world!” so'zini chop etadigan dastur yaratadi. src/main.rs faylini tekshiring:

Fayl nomi: src/main.rs

fn main() {
    println!("Hello, world!");
}

Keling, ushbu "Hello, world!" dasturni yarating va cargo run buyrug'i yordamida ishga tushiring :

$ cargo run
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/taxminiy_raqam`
Hello, world!

run buyrug‘i loyihani tezda takrorlash kerak bo‘lganda foydali bo‘ladi, biz bu o‘yinda qilganimizdek, keyingisiga o‘tishdan oldin har bir iteratsiyani tezda sinab ko‘ramiz.

src/main.rs faylini qayta oching. Siz ushbu fayldagi barcha kodlarni yozasiz.

Taxmin qilish o'yiniga ishlov berish

Taxmin qilish o'yini dasturining birinchi qismi foydalanuvchi kiritishini so'raydi, ushbu kiritishni qayta ishlaydi va kirish kutilgan shaklda ekanligini tekshiradi. Boshlash uchun biz o'yinchiga taxmin kiritishga ruxsat beramiz. 2-1 ro'yxatdagi kodni src/main.rs ichiga kiriting.

Fayl nomi: src/main.rs

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Ro'yxat 2-1: Foydalanuvchi tomonidan taxmin qilinadigan va uni chop etadigan kod

Ushbu kod juda ko'p ma'lumotlarni o'z ichiga oladi, shuning uchun uni satrga o'tkazamiz. Foydalanuvchi kiritishini olish va natijani chiqish sifatida chop etish uchun biz io input/output kutubxonasini qamrab olishimiz kerak. io kutubxonasi std deb nomlanuvchi standart kutubxonadan keladi:

use std::io;

Odatda, Rust standart kutubxonada belgilangan elementlar to'plamiga ega bo'lib, u har bir dastur doirasiga kiradi. Ushbu to'plam prelude deb ataladi va siz undagi hamma narsani standart kutubxona texnik hujjatlarida ko'rishingiz mumkin.

Agar siz foydalanmoqchi bo'lgan tur preludeda bo'lmasa, siz ushbu turni use iborasi bilan aniq kiritishingiz kerak. std::io kutubxonasidan foydalanish sizga bir qator foydali xususiyatlarni, jumladan, foydalanuvchi kiritishini qabul qilish imkoniyatini beradi.

1-bobda ko'rganingizdek, main funksiya dasturga kirish nuqtasidir:

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

fn sintaksisi yangi funktsiyani e'lon qiladi; Qavslar, (), hech qanday parametr yo'qligini bildiradi; va jingalak qavs, {, funksiyaning asosiy qismini boshlaydi.

1-bobda ham bilib olganingizdek, println! bu ekranga satrni chop etuvchi makros:

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Ushbu kod o'yin nima ekanligini ko'rsatuvchi va foydalanuvchidan ma'lumot so'rashni chop etadi.

O'zgaruvchilar bilan qiymatlarni saqlash

Keyinchalik, foydalanuvchi ma'lumotlarini saqlash uchun o'zgaruvchi yaratamiz, masalan:

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Endi dastur qiziqarli bo'lib bormoqda! Bu kichik satrda juda ko'p narsa bor. O'zgaruvchini yaratish uchun let iborasidan foydalanamiz. Mana yana bir misol:

let olmalar = 5;

Bu qator olmalar nomli yangi o‘zgaruvchini yaratadi va uni 5 qiymatiga bog‘laydi. Rustda o'zgaruvchilar standard bo'yicha o'zgarmasdir, ya'ni o'zgaruvchiga qiymat berganimizdan keyin qiymat o'zgarmaydi.Biz ushbu kontseptsiyani 3-bobdagi ”O'zgaruvchilar va O'zgaruvchanlik” bo'limida batafsil muhokama qilamiz. Oʻzgaruvchini oʻzgaruvchan qilish uchun oʻzgaruvchi nomidan oldin mut qoʻshamiz:

let olmalar = 5; // o'zgarmas
let mut bananlar = 5; // o'zgaruvchan

Eslatma: // sintaksisi satr oxirigacha davom etadigan izohni boshlaydi. Rust izohlarda hamma narsani e'tiborsiz qoldiradi. Izohlarni 3-bobda batafsilroq muhokama qilamiz.

Taxmin qilish o'yin dasturiga qaytsak, endi bilasizki, let mut taxmin taxmin nomli o'zgaruvchan o'zgaruvchini kiritadi. Teng belgisi (=) Rustga biz hozir biror narsani oʻzgaruvchiga bogʻlamoqchi ekanligimizni bildiradi. Tenglik belgisining o'ng tomonida taxmin bog'langan qiymat joylashgan bo'lib, u String::new funksiyasini chaqirish natijasidir, bu Stringning yangi nusxasini qaytaradi. String standart kutubxona tomonidan taqdim etilgan string turi bo'lib, u rivojlantirib boriladigan, UTF-8 kodlangan matn bitidir.

::new qatoridagi :: sintaksisi new String tipidagi bog'langan funksiya ekanligini bildiradi. Assosiatsiyalangan funksiya bu funksiya turida amalga oshiriladi, bu holda String. Ushbu new funksiya yangi, bo'sh qatorni yaratadi. Siz ko'p turdagi new funksiyani topasiz, chunki u qandaydir yangi qiymatni yaratadigan funksiyaning umumiy nomi.

To'liq let mut taxmin = String::new(); qatori hozirda String ning yangi, bo'sh nusxasiga bog'langan o'zgaruvchan o'zgaruvchini yaratadi.

Foydalanuvchi ma'lumotlarini qabul qilish

Eslatib o'tamiz, biz dasturning birinchi qatoriga use std::io; bilan standart kutubxonadan input/output funksiyasini kiritgan edik. Endi biz io modulidan stdin funksiyasini chaqiramiz, bu bizga foydalanuvchi kiritishini boshqarish imkonini beradi:

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Agar biz dasturning boshida use std::io; bilan io kutubxonasini import qilmagan bo'lsak, biz ushbu funktsiya chaqiruvini std::io::stdin sifatida yozish orqali funksiyadan foydalanishimiz xam mumkin. stdin funksiyasi std::io::Stdin misolini qaytaradi, bu sizning terminalingiz uchun standart kirish uchun asosni ifodalovchi tur.

Keyinchalik, .read_line(&mut taxmin) qatori foydalanuvchidan ma'lumot olish uchun standart kiritish nuqtasidagi read_line metodini chaqiradi. Shuningdek, foydalanuvchi kiritgan maʼlumotlarni qaysi qatorda saqlash kerakligini aytish uchun read_line ga argument sifatida &mut taxmin ni oʻtkazamiz. read_line ning toʻliq vazifasi foydalanuvchi nima yozganidan qatʼiy nazar standart kiritishga olish va uni satrga qoʻshishdir (uning mazmunini qayta yozmasdan), shuning uchun biz bu qatorni argument sifatida beramiz. String argumenti o'zgaruvchan bo'lishi kerak, shuning uchun metod string tarkibini o'zgartirishi mumkin.

& bu argument reference(havola) ekanligini bildiradi, bu sizga kodingizning bir nechta qismlariga ushbu ma'lumotni xotiraga bir necha marta nusxalash kerak bo'lmasdan bitta ma'lumotga kirish imkonini beradi. Referencelar murakkab xususiyat bo'lib, Rustning asosiy afzalliklaridan biri havolalardan foydalanish qanchalik xavfsiz va oson ekanligidir. Ushbu dasturni tugatish uchun ko'p bilimlrga ega bo'lishingiz shart emas. Hozircha siz bilishingiz kerak bo'lgan narsa shundaki, o'zgaruvchilar singari, havolalar ham standard bo'yicha o'zgarmasdir. Demak, uni oʻzgaruvchan qilish uchun &taxmin oʻrniga &mut taxmin yozish kerak. (4-bobda havolalar ko'proq va yaxshiroq tushuntiriladi)

Potensial nosozlikni Result turi bilan hal qilish

Biz hali ham ushbu kod qatori ustida ishlayapmiz. Biz hozir matnning uchinchi qatorini muhokama qilmoqdamiz, lekin u hali ham bitta mantiqiy kod qatorining bir qismi ekanligini unutmang. Keyingi qism bu metod:

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Biz ushbu kodni quyidagicha yozishimiz mumkin edi:

io::stdin().read_line(&mut taxmin).expect("Satrni o‘qib bo‘lmadi");

Biroq, bitta uzun qatorni o'qish qiyin, shuning uchun uni bo'lish yaxshidir. .method_name() sintaksisi bilan metodni chaqirganda uzun qatorlarni ajratishga yordam berish uchun yangi qator va boshqa bo'shliqlarni kiritish ko'pincha oqilona. Endi bu kod nima qilishini muhokama qilaylik.

Yuqorida aytib o'tilganidek, read_line foydalanuvchi kiritgan narsani biz unga o'tkazadigan qatorga qo'yadi, lekin u Result qiymatini ham qaytaradi. Result - ko'pincha enum deb ataladigan enumeration, bu bir nechta mumkin bo'lgan holatlardan birida bo'lishi mumkin bo'lgan tur. Har bir mumkin bo'lgan holatni variant deb ataymiz.

6-bobda enumlar batafsilroq yoritiladi. Ushbu Result turlarining maqsadi xatolarni qayta ishlash ma'lumotlarini kodlashdir.

Result variantlari Ok va Err. Ok varianti operatsiya muvaffaqiyatli bo'lganligini bildiradi va Ok ichida muvaffaqiyatli yaratilgan qiymat. Err varianti operatsiya bajarilmaganligini bildiradi va Err operatsiya qanday yoki nima uchun bajarilmagani haqida maʼlumotni oʻz ichiga oladi.

Result turidagi qiymatlar, har qanday turdagi qiymatlar kabi, ularda aniqlangan metodlarga ega. Result misolida siz murojat qilishingiz mumkin bo'lgan expect metodi mavjud. Agar Result ning ushbu namunasi Err qiymati bo'lsa, expect dasturning ishlamay qolishiga olib keladi va expect ga argument sifatida siz uzatgan xabarni ko'rsatadi. Agar read_line metodi Errni qaytarsa, bu asosiy operatsion tizimdan kelgan xato natijasi bo'lishi mumkin.

Agar Resultning ushbu namunasi Ok qiymati bo‘lsa, expect Ok ushlab turgan qaytarish qiymatini oladi va siz undan foydalanishingiz uchun aynan shu qiymatni sizga qaytaradi. Bunday holda, bu qiymat foydalanuvchi kiritishidagi baytlar soni.

Agar siz expect ga murojat qilmasangiz, dastur kompilyatsiya qilinadi, lekin siz ogohlantirish olasiz:

$ cargo build
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
warning: unused `Result` that must be used
  --> src/main.rs:10:5
   |
10 |     io::stdin().read_line(&mut taxmin);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` on by default

warning: `taxminiy_raqam` (bin "taxminiy_raqam") generated 1 warning
    Finished dev [unoptimized + debuginfo] target(s) in 0.59s

Rust read_line dan qaytarilgan Result qiymatini ishlatmaganligingiz haqida ogohlantiradi, bu dastur mumkin bo'lgan xatoni hal qilmaganligini ko'rsatadi.

Ogohlantirishni yo'qotishning to'g'ri yo'li aslida xatolarni qayta ishlash kodini yozishdir, ammo bizning holatlarimizda muammo yuzaga kelganda biz ushbu dasturni ishdan chiqarishni xohlaymiz, shuning uchun biz expect dan foydalanishimiz mumkin. Xatolarni tiklash haqida [9-bobda]recover] bilib olasiz.

Qiymatlarni println! bilan chop etish

Yopuvchi jingalak qavsdan tashqari, kodda hozirgacha muhokama qilinadigan yana bitta satr mavjud:

use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Ushbu satr foydalanuvchi kiritishini o'z ichiga olgan qatorni chop etadi. {} jingalak qavslar to'plami o'rnini egallaydi: {} qiymatini joyida ushlab turadigan qisqichbaqa qisqichlari deb tasavvur qiling. O'zgaruvchining qiymatini chop etishda o'zgaruvchi nomi jingalak qavslar ichiga kirishi mumkin. Ifodani baholash natijasini chop etishda format satriga bo'sh jingalak qavslarni joylashtiring, so'ngra har bir bo'sh jingalak qavs o'rnini egallagan holda bir xil tartibda chop etish uchun vergul bilan ajratilgan iboralar ro'yxati bilan format qatoriga amal qiling. O‘zgaruvchini va ifoda natijasini println! ga bitta chaqiruvda chop etish quyidagicha ko‘rinadi:

#![allow(unused)]
fn main() {
let x = 5;
let y = 10;

println!("x = {x} va y + 2 = {}", y + 2);
}

Bu kod x = 5 va y + 2 = 12 ni chop etadi.

Birinchi qismni sinovdan o'tkazish

Keling, taxmin qilish o'yinining birinchi qismini sinab ko'raylik. Uni cargo run yordamida ishga tushiring:

$ cargo run
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 6.44s
     Running `target/debug/taxminiy_raqam`
Raqamni topish o'yini!
Iltimos, taxminingizni kiriting.
6
Sizni taxminingiz: 6

Shu nuqtada, o'yinning birinchi qismi tugadi: biz klaviaturadan ma'lumotlarni olamiz va keyin uni chop etamiz.

Yashirin raqam yaratish

Keyinchalik, foydalanuvchi taxmin qilishga harakat qiladigan maxfiy raqamni yaratishimiz kerak. Yashirin raqam har safar boshqacha bo'lishi kerak, shuning uchun o'yinni bir necha marta o'ynash qiziqarli bo'ladi. O'yin juda qiyin bo'lmasligi uchun biz 1 dan 100 gacha bo'lgan tasodifiy raqamdan foydalanamiz. Rust hali o'zining standart kutubxonasida tasodifiy raqamlar funksiyasini o'z ichiga olmaydi. Biroq, Rust jamoasi ushbu funksiyaga rand cratei taqdim etadi.

Ko'proq funksionallikka ega bo'lish uchun Cratedan foydalanish

Esda tutingki, crate Rust manba kodi fayllari to'plamidir. Biz qurayotgan loyiha binary crate bo'lib, u bajariladigan. rand crate boshqa dasturlarda foydalanish uchun moʻljallangan va mustaqil ravishda bajarib boʻlmaydigan kodni oʻz ichiga olgan library crate.

Cargoning tashqi cratelarni muvofiqlashtirishi bu erda Cargp haqiqatan ham ishlaydi. rand dan foydalanadigan kodni yozishdan oldin, biz Cargo.toml faylini rand cratesini dependency sifatida qo‘shish uchun o‘zgartirishimiz kerak. Hozir o‘sha faylni oching va Cargo siz uchun yaratgan[dependencies] bo‘limi sarlavhasi ostiga quyidagi qatorni qo‘shing.rand ni aynan bizda boʻlganidek, ushbu versiya raqami bilan belgilaganingizga ishonch hosil qiling, aks holda ushbu qoʻllanmadagi kod misollari ishlamasligi mumkin:

Fayl nomi: Cargo.toml

[dependencies]
rand = "0.8.5"

Cargo.toml faylida sarlavhadan keyingi hamma narsa boshqa bo'lim boshlanmaguncha davom etadigan bo'limning bir qismidir. [dependencies] da siz Cargo loyihangiz qaysi tashqi cratelarga bog'liqligini va bu cratelarning qaysi versiyalari kerakligini aytasiz. Bunday holda, biz rand crateni 0.8.5 semantik versiya spetsifikatsiyasi bilan belgilaymiz. Cargo versiya raqamlarini yozish uchun standart bo'lgan Semantic Versioningni (ba'zan SemVer deb ataladi) tushunadi. 0.8.5 spetsifikatsiyasi aslida ^0.8.5 ning qisqartmasi boʻlib, kamida 0.8.5, lekin 0.9.0 dan past boʻlgan har qanday versiyani bildiradi.

Cargo ushbu versiyalarni 0.8.5 versiyasiga mos keladigan umumiy API-larga ega deb hisoblaydi va bu spetsifikatsiya sizga ushbu bobdagi kod bilan tuziladigan so‘nggi patch versiyasini olishingizni kafolatlaydi. 0.9.0 yoki undan kattaroq versiyalar quyidagi misollar ishlatadigan API bilan bir xil bo'lishi kafolatlanmaydi.

Endi, hech qanday kodni o'zgartirmasdan, 2-2 ro'yxatda ko'rsatilganidek, loyihani build qilaylik.

$ cargo build
    Updating crates.io index
  Downloaded rand v0.8.5
  Downloaded libc v0.2.127
  Downloaded getrandom v0.2.7
  Downloaded cfg-if v1.0.0
  Downloaded ppv-lite86 v0.2.16
  Downloaded rand_chacha v0.3.1
  Downloaded rand_core v0.6.3
   Compiling libc v0.2.127
   Compiling getrandom v0.2.7
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.16
   Compiling rand_core v0.6.3
   Compiling rand_chacha v0.3.1
   Compiling rand v0.8.5
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53s

Ro'yxat 2-2: rand cratesini dependency sifatida qo'shgandan so'ng cargo build dan olingan natija

Siz turli xil versiya raqamlarini (lekin ularning barchasi SemVer tufayli kod bilan mos keladi!) va turli xil satrlarni (operatsion tizimga qarab) ko'rishingiz mumkin va satrlar boshqa tartibda bo'lishi mumkin.

Biz tashqi dependency qo'shganimizda, Cargo Crates.io ma'lumotlarining nusxasi bo'lgan registry dan dependency uchun zarur bo'lgan barcha narsalarning so'nggi versiyalarini oladi.Crates.io - bu Rust ekotizimidagi odamlar o'zlarining ochiq manbali Rust loyihalarini boshqalar foydalanishi uchun joylashtiradigan joy.

registrni yangilagandan so'ng, Cargo [dependencies] bo'limini tekshiradi va ro'yxatda hali yuklab olinmagan cratelarni yuklab oladi. Bu holatda, garchi biz faqat rand ni dependency sifatida ko'rsatgan bo'lsak-da, Cargo rand ishlashga bog'liq bo'lgan boshqa cratelarni ham oldi. Cratelarni yuklab olgandan so'ng, Rust ularni kompilyatsiya qiladi va keyin mavjud bo'lgan dependency bilan loyihani tuzadi.

Agar siz hech qanday o'zgartirishlarsiz darhol cargo build ni qayta ishga tushirsangiz, Finished qatoridan boshqa hech qanday natija olmaysiz. Cargo allaqachon dependencylarni yuklab olganini va kompilyatsiya qilganini biladi va siz Cargo.toml faylida ular haqida hech narsani o'zgartirmagansiz. Cargo, shuningdek, kodingiz haqida hech narsani o'zgartirmaganligingizni biladi, shuning uchun u ham uni qayta kompilyatsiya qilmaydi. Hech narsa qilmasdan, u shunchaki chiqib ketadi.

Agar siz src/main.rs faylini ochsangiz, ahamiyatsiz o'zgarishlarni amalga oshirsangiz va keyin uni saqlab va qayta build qilsangiz, siz faqat ikkita chiqish qatorini ko'rasiz:

$ cargo build
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs

Bu satrlar shuni ko'rsatadiki, Cargo faqat src/main.rs fayliga kichik o'zgartirishingiz bilan buildni yangilaydi. Sizning dependencylaringiz o'zgarmadi, shuning uchun Cargo allaqachon yuklab olingan va ular uchun tuzilgan narsadan qayta foydalanishi mumkinligini biladi..

Cargo.lock fayli bilan qayta tiklanadigan tuzilmalarni ta'minlash

Cargoda siz yoki boshqa birov kodingizni har safar yaratganingizda bir xil artefaktni qayta tiklashingiz mumkinligini ta'minlaydigan mexanizm mavjud: Siz aksini ko'rsatmaguningizcha, cargo faqat siz ko'rsatgan dependency versiyalaridan foydalanadi. Masalan, kelasi hafta rand cratening 0.8.6 versiyasi chiqadi va bu versiyada muhim xatoliklar tuzatilgan, lekin u sizning kodingizni buzadigan regressiyani ham o‘z ichiga oladi. Buni hal qilish uchun Rust birinchi marta cargo build dasturini ishga tushirganingizda Cargo.lock faylini yaratadi, shuning uchun biz endi bu guessing_game jildida mavjud.

Loyihani birinchi marta yaratganingizda, Cargo mezonlarga mos keladigan dependencylarning barcha versiyalarini aniqlaydi va keyin ularni Cargo.lock fayliga yozadi. Keyingi loyihangizni yaratganingizda, Cargo Cargo.lock fayli mavjudligini ko'radi va versiyalarni qayta aniqlash uchun barcha ishlarni bajarishdan ko'ra, u erda ko'rsatilgan versiyalardan foydalanadi. Bu sizga avtomatik ravishda takrorlanadigan tuzilishga ega bo'lish imkonini beradi. Boshqacha qilib aytganda, Cargo.lock fayli tufayli loyihangiz aniq yangilanmaguningizcha 0.8.5 da qoladi. Cargo.lock fayli qayta tiklanadigan tuzilmalar uchun muhim bo'lgani uchun u ko'pincha loyihangizdagi kodning qolgan qismi bilan manba nazoratida tekshiriladi.

Yangi versiyani olish uchun Crateni yangilash

Crateni yangilamoqchi bo'lsangiz, Cargo update buyrug'ini beradi, bu buyruq Cargo.lock faylini e'tiborsiz qoldiradi va Cargo.toml dagi texnik xususiyatlaringizga mos keladigan barcha so'nggi versiyalarni aniqlaydi. Keyin Cargo ushbu versiyalarni Cargo.lock fayliga yozadi. Aks holda, standart bo'yicha, Cargo faqat 0.8.5 dan katta va 0.9.0 dan kichik versiyalarni qidiradi. Agar rand cratesi ikkita yangi 0.8.6 va 0.9.0 versiyalarini chiqargan bo'lsa, cargo update ni ishga tushirgan bo'lsangiz, quyidagilarni ko'rasiz:

$ cargo update
    Updating crates.io index
    Updating rand v0.8.5 -> v0.8.6

Cargo 0.9.0 versiyasiga e'tibor bermaydi. Bu vaqtda siz Cargo.lock faylingizda oʻzgarishlarni ham sezasiz, bunda siz hozir foydalanayotgan rand cratesi versiyasi 0.8.6. rand 0.9.0 versiyasidan yoki 0.9.x seriyasining istalgan versiyasidan foydalanish uchun Cargo.toml faylini quyidagi koʻrinishda yangilashingiz kerak boʻladi:

[dependencies]
rand = "0.9.0"

Keyingi safar cargo buildni ishga tushirganingizda, Cargo mavjud cratelar reestrini yangilaydi va siz ko‘rsatgan yangi versiyaga muvofiq rand talablaringizni qayta baholaydi.

Cargo va uning ekotizimlari haqida ko'p gapirish mumkin, biz ularni 14-bobda muhokama qilamiz, ammo hozircha bilishingiz kerak bo'lgan narsa shu. Cargo kutubxonalarni qayta ishlatishni juda osonlashtiradi, shuning uchun Rustaceans bir nechta paketlardan yig'ilgan kichikroq loyihalarni yozishga qodir.

Tasodifiy raqamni yaratish

Keling, taxmin qilish uchun raqam yaratishda rand dan foydalanishni boshlaylik. Keyingi qadam 2-3 ro'yxatda ko'rsatilganidek src/main.rs ni yangilashdir.

Fayl nomi: src/main.rs

use std::io;
use rand::Rng;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Ro'yxat 2-3: Tasodifiy raqam yaratish uchun kod qo'shiladi

Avval use rand::Rng; qatorini qo'shamiz. Rng traiti tasodifiy sonlar generatorlari qo'llaydigan metodlarni belgilaydi va biz ushbu usullardan foydalanishimiz uchun bu trait mos bo'lishi kerak. 10-bobda traitlar batafsil yoritiladi.

Keyin o'rtada ikkita qator qo'shamiz. Birinchi qatorda biz rand::thread_rng funksiyasini chaqiramiz, bu bizga biz foydalanmoqchi bo'lgan tasodifiy sonlar generatorini beradi: joriy bajarilish oqimi uchun mahalliy bo'lgan va operatsion tizim tomonidan ekilgan. Keyin tasodifiy sonlar generatorida gen_range metodini chaqiramiz. Bu metod biz use rand::Rng; iborasi bilan qamrab olgan Rng traiti bilan aniqlanadi. gen_range metodi argument sifatida diapazon ifodasini oladi va diapazonda tasodifiy son hosil qiladi. Biz bu yerda foydalanayotgan diapazon ifodasi turi start..=end shaklini oladi va pastki va yuqori chegaralarni qamrab oladi, shuning uchun biz 1 va 100 oralig‘idagi raqamni so‘rash uchun 1..=100 ni belgilashimiz kerak. .

Eslatma: Siz faqat qaysi traitlardan foydalanishni va qaysi metodlar va funktsiyalarni cratedan chaqirishni bila olmaysiz, shuning uchun har bir crateda foydalanish bo'yicha ko'rsatmalar mavjud. Cargo-ning yana bir qulay xususiyati shundaki, cargo doc --open buyrug'ini ishga tushirish sizning barcha dependencylar tomonidan taqdim etilgan texnik hujjatlarni mahalliy sifatida tuzadi va uni brauzeringizda ochadi. Agar siz rand cratedagi boshqa funksiyalarga qiziqsangiz, masalan, cargo doc --open ni ishga tushiring va chap tomondagi yon paneldagi rand tugmasini bosing.

Ikkinchi yangi qator maxfiy raqamni chop etadi. Bu dasturni ishlab chiqishda uni sinab ko'rishimiz uchun foydalidir, lekin biz uni oxirgi versiyadan o'chirib tashlaymiz. Agar dastur boshlanishi bilanoq javobni chop etsa, bu unchalik o'yin emas!

Dasturni bir necha marta ishga tushirishga harakat qiling:

$ cargo run
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53s
     Running `target/debug/taxminiy_raqam`
Raqamni topish o'yini!
Yashirin raqam: 7
Iltimos, taxminingizni kiriting.
4
Siznig taxminingiz: 4

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/taxminiy_raqam`
Raqamni topish o'yini!
Yashirin raqam: 83
Iltimos, taxminingizni kiriting.
5
Siznig taxminingiz: 5

Siz turli xil tasodifiy raqamlarni olishingiz kerak va ularning barchasi 1 dan 100 gacha raqamlar bo'lishi kerak. Ajoyib ish!

Taxminni maxfiy raqam bilan solishtirish

Endi bizda foydalanuvchi kiritishi va tasodifiy raqam bor, biz ularni solishtirishimiz mumkin. Ushbu qadam 2-4 ro'yxatda ko'rsatilgan. E'tibor bering, bu kod hozircha kompilatsiya bo'lmaydi, biz tushuntiramiz.

Fayl nomi: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    // --snip--
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");

    match taxmin.cmp(&yashirin_raqam) {
        Ordering::Less => println!("Raqam Kichik!"),
        Ordering::Greater => println!("Raqam katta!"),
        Ordering::Equal => println!("Siz yutdingiz!"),
    }
}

Ro'yxat 2-4: Ikki raqamni solishtirishning mumkin bo'lgan qaytish qiymatlarini boshqarish

Avval biz standart kutubxonadan std::cmp::Ording deb nomlangan turni olib keladigan yana bir use iborasini qo'shamiz. Ordering turi boshqa raqam boʻlib, Less, Greater va Equal variantlariga ega. Bu ikkita qiymatni solishtirganda mumkin bo'lgan uchta natijadir.

Keyin pastki qismida Ordering turidan foydalanadigan beshta yangi qator qo'shamiz. cmp metodi ikkita qiymatni solishtiradi va uni solishtirish mumkin bo'lgan har qanday narsani chaqirish mumkin. Siz solishtirmoqchi bo'lgan narsaga reference kerak: bu erda taxmin bilan yashirin_raqam solishtiriladi. Keyin u biz use iborasi bilan qamrab olgan Ordering raqamining variantini qaytaradi. Biz taxmin va yashirin_raqam qiymatlari bilan cmp ga murojatdan Ordering ning qaysi varianti qaytarilganiga qarab, keyin nima qilish kerakligini hal qilish uchun match ifodasidan foydalanamiz.

Match ifodasi arms dan tuzilgan. Arm mos keladigan pattern va agar match ga berilgan qiymat armning patterniga mos kelsa, bajarilishi kerak bo'lgan koddan iborat. Rust match ga berilgan qiymatni oladi va har bir armning patternini o'z navbatida ko'rib chiqadi. Patternlar va match konstruksiyasi Rust-ning kuchli xususiyatlari hisoblanadi: ular sizning kodingiz duch kelishi mumkin bo'lgan turli vaziyatlarni ifodalash imkonini beradi va ularning barchasini boshqarishingizga ishonch hosil qiladi. Bu xususiyatlar mos ravishda 6-bobda va 18-bobda batafsil yoritiladi.

Keling, bu yerda ishlatadigan match iborasi bilan bir misolni ko'rib chiqaylik. Aytaylik, foydalanuvchi 50 ni taxmin qilgan va bu safar tasodifiy yaratilgan maxfiy raqam 38 ni tashkil qiladi.

Kod 50 ni 38 ga solishtirganda, cmp metodi Ordering::Greater ni qaytaradi, chunki 50 38 dan katta. match ifodasi Ordering::Greater qiymatini oladi va har bir armning patternini tekshirishni boshlaydi. U birinchi armning Ordering::Less patternini koʻrib chiqadi va Ordering::Greater qiymati Ordering::Less qiymatiga mos kelmasligini koʻradi, shuning uchun u armdagi kodga eʼtibor bermaydi va keyingi armga oʻtadi. Keyingi armning namunasi Ordering::Greater boʻlib, Ordering::Greater bilan does match keladi! Oʻsha armdagi bogʻlangan kod ishga tushadi va ekranga Raqam katta! deb chop etiladi. match iborasi birinchi muvaffaqiyatli o'yindan keyin tugaydi, shuning uchun bu senariydagi oxirgi armni ko'rib chiqmaydi.

Biroq, 2-4 ro'yxatdagi kod hali kompilyatsiya qilinmaydi. Keling, sinab ko'raylik:

$ cargo build
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_core v0.6.2
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.5
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
error[E0308]: mismatched types
  --> src/main.rs:22:21
   |
22 |     match taxmin.cmp(&yashirin_raqam) {
   |                 --- ^^^^^^^^^^^^^^ expected struct `String`, found integer
   |                 |
   |                 arguments to this function are incorrect
   |
   = note: expected reference `&String`
              found reference `&{integer}`
note: associated function defined here
  --> /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/cmp.rs:783:8

For more information about this error, try `rustc --explain E0308`.
error: could not compile `taxminiy_raqame` due to previous error

Xatoning asosi mos kelmaydigan turlar mavjudligini bildiradi. Rust kuchli, statik turdagi tizimga ega. Biroq, u ham turdagi inference ega. Biz let mut taxmin = String::new() deb yozganimizda, Rust taxmin String bo'lishi kerak degan xulosaga keldi va bizni turni yozishga majburlamadi. Boshqa tomondan, yashirin_raqam raqam turidir. Rust raqamlarining bir nechta turlari 1 dan 100 gacha qiymatga ega bo'lishi mumkin: i32, 32 bitli raqam; u32, unsigned 32-bitli raqam; i64, 64-bitli raqam; boshqalar kabi. Agar boshqacha koʻrsatilmagan boʻlsa, Rust standart boʻyicha i32 ga oʻrnatiladi, bu yashirin_raqam turiga, agar siz Rustning boshqa raqamli turini chiqarishiga olib keladigan turdagi maʼlumotlarni boshqa joyga qoʻshmasangiz. Xatoning sababi shundaki, Rust string va raqam turini taqqoslay olmaydi.

Oxir-oqibat, biz dastur tomonidan kiritilgan String ni haqiqiy son turiga aylantirmoqchimiz, shuning uchun uni raqamli raqam bilan yashirin raqam bilan solishtirishimiz mumkin.Buni main funksiya tanasiga ushbu qatorni qo'shish orqali qilamiz:

Fayl nomi: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    println!("Iltimos, taxminingizni kiriting.");

    // --snip--

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    let taxmin: u32 = taxmin.trim().parse().expect("Iltimos, raqam yozing!");

    println!("Sizning taxminingiz: {taxmin}");

    match taxmin.cmp(&yashirin_raqam) {
        Ordering::Less => println!("Raqam Kichik!"),
        Ordering::Greater => println!("Raqam katta!"),
        Ordering::Equal => println!("Siz yutdingiz!"),
    }
}

Satr

let taxmin: u32 = taxmin.trim().parse().expect("Iltimos, raqam yozing!");

Biz taxmin nomli o'zgaruvchini yaratamiz. Ammo shoshilmang, dasturda allaqachon taxmin nomli o'zgaruvchi mavjud emasmi? Bu shunday, lekin foydali Rust bizga taxmin ning oldingi qiymatini yangisi bilan ergashtirish imkonini beradi. Shadowing bizga ikkita noyob oʻzgaruvchini yaratish oʻrniga, taxmin oʻzgaruvchi nomidan qayta foydalanish imkonini beradi, masalan, taxmin_str va taxmin. Biz buni 3-bobda batafsil ko'rib chiqamiz, ammo hozircha shuni bilingki, bu xususiyat ko'pincha qiymatni bir turdan boshqa turga aylantirmoqchi bo'lganingizda ishlatiladi.

Biz bu yangi o'zgaruvchini taxmin.trim().parse() ifodasiga bog'laymiz. Ifodadagi taxmin matni qator sifatida kiritilgan asl taxmin o'zgaruvchisiga ishora qiladi. String misolidagi trim metodi boshida va oxiridagi har qanday bo‘shliqni yo‘q qiladi, bu qatorni faqat raqamli ma’lumotlarni o‘z ichiga olishi mumkin bo‘lgan u32 bilan solishtirishimiz uchun buni qilishimiz kerak. Foydalanuvchi read_line ni to'ldirish uchun entertugmasini bosib, ularni kiritishi kerak satrga yangi satr belgisini qo'shadigan taxmin. Masalan, agar foydalanuvchi 5 raqamini kiritsa va va enter tugmasini bossa taxmin shunday ko'rinadi: 5\n. \n “yangi qator”ni bildiradi. (Windows tizimida enter tugmasini bosish natijasida carriage qaytariladi va yangi qator \r\n chiqadi.) trim metodi \n yoki \r\nni yo'q qiladi, natijada atigi 5 bo`ladi.

Satrlardagi parse metodi qatorni boshqa turga aylantiradi. Bu yerda biz uni stringdan raqamga aylantirish uchun foydalanamiz. Biz Rustga let taxmin: u32 yordamida kerakli raqam turini aytishimiz kerak. taxmin dan keyin ikki nuqta (:) Rustga o'zgaruvchining turiga izoh berishimizni aytadi. Rust bir nechta o'rnatilgan raqam turlariga ega; Bu yerda koʻrilgan u32 unsigned, 32-bitli butun son. Bu kichik ijobiy raqam uchun yaxshi standart tanlovdir. Boshqa raqamlar turlari haqida 3-bobda bilib olasiz.

Bundan tashqari, ushbu misol dasturidagi u32 annotation va yashirin_raqam bilan taqqoslash Rust yashirin_raqam ham u32 bo'lishi kerak degan xulosaga keladi. Shunday qilib, endi taqqoslash bir xil turdagi ikkita qiymat o'rtasida bo'ladi!

parse metodii faqat mantiqiy ravishda raqamlarga aylantirilishi mumkin bo'lgan belgilarda ishlaydi va shuning uchun osongina xatolarga olib kelishi mumkin. Agar, masalan, satrda A👍% bo'lsa, uni raqamga aylantirishning hech qanday metodi bo'lmaydi. Muvaffaqiyatsiz bo'lishi mumkinligi sababli, parse metodii read_line metodi kabi Result turini qaytaradi (oldingi ["Result bilan potentsial muvaffaqiyatsizlikni ko'rib chiqish"] bo'limida muhokama qilingan)(#handling-potential-failure-with-result)). Biz ushbu Result ga yana expect metodini qo'llash orqali xuddi shunday munosabatda bo'lamiz. Agar parse qatordan raqam yarata olmagani uchun Err Result variantini qaytarsa, expect chaqiruvi o‘yinni buzadi va biz bergan xabarni chop etadi. Agar parse qatorni raqamga muvaffaqiyatli aylantira olsa, u Resultning Ok variantini qaytaradi va expect biz xohlagan raqamni Ok qiymatidan qaytaradi.

Endi dasturni ishga tushiramiz:

$ cargo run
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/taxminiy_raqam`
Raqamni topish o'yini!
Yashirin raqam: 58
Iltimos, taxminingizni kiriting.
  76
Sizning taxminingiz: 76
Raqam katta!

Yaxshi! Tahmindan oldin bo'shliqlar qo'shilgan bo'lsa ham, dastur foydalanuvchi 76 ni taxmin qilganini aniqladi. Har xil turdagi kirishlar bilan turli xatti-harakatlarni tekshirish uchun dasturni bir necha marta ishga tushiring: raqamni to'g'ri taxmin qiling, katta raqamni taxmin qiling va kichik raqamni taxmin qiling.

Hozir bizda o'yinning ko'p qismi ishlayapti, lekin foydalanuvchi faqat bitta taxmin qila oladi. Keling, buni loop qo'shish orqali o'zgartiraylik!

Loop bilan bir nechta taxminlarga ruxsat berish

loop kalit so'zi cheksiz tsiklni yaratadi. Biz foydalanuvchilarga raqamni taxmin qilishda ko'proq imkoniyat berish uchun tsikl qo'shamiz: Fayl nomi: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    // --snip--

    println!("Yashirin raqam: {yashirin_raqam}");

    loop {
        println!("Iltimos, taxminingizni kiriting.");

        // --snip--


        let mut taxmin = String::new();

        io::stdin()
            .read_line(&mut taxmin)
            .expect("Satrni o‘qib bo‘lmadi");

        let taxmin: u32 = taxmin.trim().parse().expect("Iltimos, raqam yozing!");

        println!("Sizning taxminingiz: {taxmin}");

        match taxmin.cmp(&yashirin_raqam) {
            Ordering::Less => println!("Raqam Kichik!"),
            Ordering::Greater => println!("Raqam katta!"),
            Ordering::Equal => println!("Siz yutdingiz!"),
        }
    }
}

Ko'rib turganingizdek, biz hamma narsani taxminiy kiritish so'rovidan boshlab tsiklga o'tkazdik. Ilova ichidagi satrlarni har birida yana to'rtta bo'sh joydan o'tkazganingizga ishonch hosil qiling va dasturni qayta ishga tushiring. Dastur endi boshqa bir taxminni abadiy yani har doim so'raydi, bu aslida yangi muammoni keltirib chiqaradi. Foydalanuvchi chiqa olmaydiganga o'xshaydi!

Foydalanuvchi har doim ctrl-c klaviatura yorlig'i yordamida dasturni to'xtatishi mumkin. Ammo bu to'yib bo'lmaydigan yirtqich hayvondan qochishning yana bir yo'li bor, “Taxminni maxfiy raqam bilan solishtirish“: mavzusidagi parse muhokamasida aytib o'tilganidek, agar foydalanuvchi raqam bo'lmagan javobni kiritsa, dastur buziladi. Bu yerda ko'rsatilganidek, foydalanuvchiga chiqishga ruxsat berish uchun undan foydalanishimiz mumkin

$ cargo run
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/taxminiy_raqam`
Raqamni topish o'yini!
Yashirin raqam: 59
Iltimos, taxminingizni kiriting.
45
Sizning taxminingiz: 45
Raqam Kichik!
Iltimos, taxminingizni kiriting.
60
Sizning taxminingiz: 60
Raqam katta!
Iltimos, taxminingizni kiriting.
59
Sizning taxminingiz: 59
Siz yutdingiz!
Iltimos, taxminingizni kiriting.
quit
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/main.rs:28:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

quit deb yozsangiz, o‘yin tugaydi, lekin siz ko‘rganingizdek, boshqa raqam bo‘lmagan ma’lumotlarni kiritish ham shunday bo‘ladi. Bu, eng kamida, suboptimaldir; Biz to'g'ri raqam taxmin qilinganda ham o'yin to'xtashini xohlaymiz.

To'g'ri taxmindan keyin chiqish

Keling, foydalanuvchi g'alaba qozonganida break iborasini qo'shish orqali o'yinni to'xtatish uchun dasturlashtiramiz:

Fayl nomi: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    loop {
        println!("Iltimos, taxminingizni kiriting.");

        let mut taxmin = String::new();

        io::stdin()
            .read_line(&mut taxmin)
            .expect("Satrni o‘qib bo‘lmadi");

        let taxmin: u32 = taxmin.trim().parse().expect("Iltimos, raqam yozing!");

        println!("Sizning taxminingiz: {taxmin}");

        // --snip--

        match taxmin.cmp(&yashirin_raqam) {
            Ordering::Less => println!("Raqam Kichik!"),
            Ordering::Greater => println!("Raqam katta!"),
            Ordering::Equal => {
                println!("Siz yutdingiz!");
                break;
            }
        }
    }
}

Siz yutdingiz! so‘ng break qatorini qo‘shish foydalanuvchi maxfiy raqamni to‘g‘ri taxmin qilganda dasturni tsikldan chiqadi. Loopdan chiqish dasturdan chiqishni ham anglatadi, chunki sikl main ning oxirgi qismidir.

Noto'g'ri kiritish

O'yinning xatti-harakatlarini yanada yaxshilash uchun, foydalanuvchi raqamlardan boshqa belgilar kiritganda dasturni ishdan chiqargandan ko'ra, foydalanuvchi taxmin qilishni davom ettirishi uchun o'yinni raqam bo'lmagan belgilarga e'tibor bermaslikka harakat qildiraylik. Buni 2-5 roʻyxatda koʻrsatilganidek, taxmin satrdan u32 ga aylantirilgan qatorni oʻzgartirish orqali amalga oshirishimiz mumkin.

Fayl nomi: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    loop {
        println!("Iltimos, taxminingizni kiriting.");

        let mut taxmin = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut taxmin)
            .expect("Satrni o‘qib bo‘lmadi");

        let taxmin: u32 = match taxmin.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("Sizning taxminingiz: {taxmin}");

        // --snip--

        match taxmin.cmp(&yashirin_raqam) {
            Ordering::Less => println!("Raqam Kichik!"),
            Ordering::Greater => println!("Raqam katta!"),
            Ordering::Equal => {
                println!("Siz yutdingiz!");
                break;
            }
        }
    }
}

Ro'yxat 2-5: Raqamsiz taxminga e'tibor bermaslik va dasturni ishdan chiqarish o'rniga boshqa taxminni so'rash

Xato ustida ishlamay qolishdan xatoni hal qilishga o‘tish uchun biz expect chaqiruvidan match ifodasiga o‘tamiz. Esda tutingki, parse Result turini qaytaradi, Result esa Ok va Err variantlariga ega bo'lgan raqamdir. Biz bu yerda cmp metodining Ordering natijasi bilan bo‘lgani kabi match ifodasidan foydalanmoqdamiz.

Agar parse qatorni raqamga muvaffaqiyatli aylantira olsa, natijada olingan raqamni o'z ichiga olgan Ok qiymatini qaytaradi. Bu Ok qiymati birinchi armning patterniga mos keladi va match ifodasi parse ishlab chiqarilgan va Ok qiymatiga qo'ygan num qiymatini qaytaradi. Bu raqam biz yaratayotgan yangi taxmin o'zgaruvchisida biz xohlagan joyda tugaydi

Agar parse satrni raqamga aylantira olmasa xato haqida qo'shimcha ma'lumotni o'z ichiga olgan Err qiymatini qaytaradi. Err qiymati birinchi match bo‘limidagi Ok(num) patterniga mos kelmaydi, lekin ikkinchi armdagi Err(_) patterniga mos keladi. Pastki chiziq, _, diqqatga sazovor qiymatdir; bu misolda biz barcha Err qiymatlariga, ular ichida qanday ma'lumotlar bo'lishidan qat'iy nazar, mos kelmoqchimiz deymiz. Shunday qilib, dastur ikkinchi armning continue kodini bajaradi, bu dasturga loop ning keyingi iteratsiyasiga o'tishni va boshqa taxminni so'rashni aytadi. Shunday qilib, dastur parse duch kelishi mumkin bo'lgan barcha xatolarga e'tibor bermaydi!

Endi dasturdagi hamma narsa kutilganidek ishlashi kerak. Keling, sinab ko'raylik:

$ cargo run
   Compiling taxminiy_raqam v0.1.0 (file:///projects/taxminiy_raqam)
    Finished dev [unoptimized + debuginfo] target(s) in 4.45s
     Running `target/debug/taxminiy_raqam`
Raqamni topish o'yini!
Yashirin raqam: 61
Iltimos, taxminingizni kiriting.
10
Sizning taxminingiz: 10
Raqam Kichik!
Iltimos, taxminingizni kiriting.
99
Sizning taxminingiz: 99
Raqam katta!
Iltimos, taxminingizni kiriting.
foo
Iltimos, taxminingizni kiriting.
61
Sizning taxminingiz: 61
Siz yutdingiz!

Ajoyib! Bitta kichik so'nggi tweak bilan biz taxmin qilish o'yinini tugatamiz. Eslatib o'tamiz, dastur hali ham maxfiy raqamni chop etmoqda. Bu sinov uchun yaxshi ishladi, lekin o'yinni buzadi. Maxfiy raqamni chiqaradigan println!ni o'chirib tashlaymiz. 2-6 ro'yxat yakuniy kodni ko'rishingiz mumkin.

Fayl nomi: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Iltimos, taxminingizni kiriting.");

        let mut taxmin = String::new();

        io::stdin()
            .read_line(&mut taxmin)
            .expect("Satrni o‘qib bo‘lmadi");

        let taxmin: u32 = match taxmin.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("Sizning taxminingiz: {taxmin}");

        match taxmin.cmp(&yashirin_raqam) {
            Ordering::Less => println!("Raqam Kichik!"),
            Ordering::Greater => println!("Raqam katta!"),
            Ordering::Equal => {
                println!("Siz yutdingiz!");
                break;
            }
        }
    }
}

Ro'yxat 2-6: To'liq taxmin qilish o'yin kodini

Shu nuqtada, siz taxmin qilish o'yinini muvaffaqiyatli yaratdingiz. Tabriklaymiz!

Xulosa

Ushbu loyiha sizni Rustning ko'plab yangi tushunchalari bilan tanishtirishning amaliy usuli bo'ldi: let, match, funktsiyalar, tashqi cratelardan foydalanish va boshqalar. Keyingi bir necha boblarda siz ushbu tushunchalar haqida batafsilroq bilib olasiz. 3-bob ko'pchilik dasturlash tillarida mavjud bo'lgan o'zgaruvchilar, ma'lumotlar turlari va funktsiyalari kabi tushunchalarni qamrab oladi va ulardan Rustda qanday foydalanishni ko'rsatadi. 4-bobda Rust tilini boshqa tillardan ajratib turadigan egalik huquqi o‘rganiladi. 5-bobda tuzilmalar va metodlar sintaksisi muhokama qilinadi va 6-bobda enumlar qanday ishlashi tushuntiriladi.

Umumiy dasturlash tushunchalari

Ushbu bob deyarli barcha dasturlash tillarida paydo bo'ladigan tushunchalarni va ular Rustda qanday ishlashini o'z ichiga oladi. Ko'pgina dasturlash tillari o'rtasida juda ko'p umumiylik mavjud. Ushbu bobda keltirilgan tushunchalarning hech biri Rustga xos emas, lekin biz ularni Rust kontekstida ko'rib chiqamiz va ushbu tushunchalardan foydalanish bo'yicha konventsiyalarni tushuntiramiz.

Xususan, siz o'zgaruvchilar, asosiy turlar, funktsiyalar, izohlar va control flow haqida bilib olasiz. Ushbu asoslar har bir Rust dasturida bo'ladi va ularni erta o'rganish sizga boshlash uchun kuchli asos bo'ladi.

Kalit so'zlar

Rust dasturlash tilida boshqa tillardagi kabi faqat til tomonidan foydalanish uchun ajratilgan kalit so'zlar to'plami mavjud. Shuni yodda tutingki, siz ushbu so'zlarni o'zgaruvchilar yoki funksiyalar nomi sifatida ishlata olmaysiz. Kalit so'zlarning aksariyati maxsus ma'noga ega va siz ulardan Rust dasturlarida turli vazifalarni bajarish uchun foydalanasiz; ba'zilarida ular bilan bog'liq bo'lgan joriy funksionallik yo'q, lekin kelajakda Rustga qo'shilishi mumkin bo'lgan funksiyalar uchun ajratilgan. Kalit so'zlar ro'yxatini A ilovasida. topishingiz mumkin.

O'zgaruvchilar va o'zgaruvchanlik

”O'zgaruvchilar bilan qiymatlarni saqlash” bo'limida aytib o'tilganidek, standart bo'yicha o'zgaruvchilar o'zgarmasdir.Rust sizga o'z kodingizni Rust taqdim etgan xavfsizlik va qulay parallellikdan foydalanadigan tarzda yozish uchun beradigan ko'plab qulayliklardan biridir. Biroq, siz hali ham o'zgaruvchilaringizni o'zgaruvchan qilish imkoniyatiga egasiz. Keling, Rust sizni qanday qilib va nima uchun o'zgarmaslikni afzal ko'rishga undashini va nega ba'zan siz undan voz kechishingiz mumkinligini bilib olaylik.

Agar o'zgaruvchi o'zgarmas bo'lsa, qiymat nomga bog'langandan keyin siz bu qiymatni o'zgartira olmaysiz. Buni ko'rsatish uchun cargo new variables yordamida projects jildingizda variables nomli yangi loyihani yarating.

Keyin, yangi variables jildida src/main.rs ni oching va uning kodini quyidagi kod bilan almashtiring. Bu kod hozircha kompilyatsiya qilinmaydi, biz avval o'zgarmaslik xatosini ko'rib chiqamiz.

Fayl nomi: src/main.rs

fn main() {
    let x = 5;
    println!("x qiymati: {x}");
    x = 6;
    println!("x qiymati: {x}");
}

Kodni saqlang va dasturni cargo run yordamida ishga tushiring. Ushbu chiqishda ko'rsatilganidek, o'zgarmaslik xatosi haqida xato xabarini olishingiz kerak:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("x qiymati: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error

Ushbu misol kompilyator sizning dasturlaringizdagi xatolarni topishga qanday yordam berishini ko'rsatadi. Kompilyatordagi xatolar sizni asabiylashtirishi mumkin, lekin aslida ular sizning dasturingiz hali siz xohlagan narsani xavfsiz bajarmayotganligini anglatadi; ular sizning yaxshi dasturchi emasligingizni bildirmaydi! Tajribali Rustaceanlar hali ham kompilyator xatolariga duch kelishadi.

Siz oʻzgarmas x oʻzgaruvchisiga ikkinchi qiymatni belgilashga harakat qilganingiz uchun ````x` oʻzgaruvchisiga ikki marta tayinlab boʻlmaydi``` xato xabarini oldingiz.

O'zgarmas deb belgilangan qiymatni o'zgartirishga urinayotganda kompilyatsiya vaqtida xatolarga duch kelishimiz muhim, chunki bu holat xatolarga olib kelishi mumkin.Agar bizning kodimizning bir qismi qiymat hech qachon o'zgarmasligi haqidagi faraz asosida ishlayotgan bo'lsa va kodimizning boshqa qismi bu qiymatni o'zgartirsa, kodning birinchi qismi uni bajarish uchun mo'ljallangan narsani qilmasligi mumkin. Bunday xatoning sababini aniqlash qiyin bo'lishi mumkin, ayniqsa kodning ikkinchi qismi faqat ba'zan qiymatini o'zgartirganda. Rust kompilyatori qiymat o'zgarmasligini bildirganingizda, u haqiqatan ham o'zgarmasligini kafolatlaydi, shuning uchun uni o'zingiz kuzatib borishingiz shart emas. Shunday qilib, kodingizni tushunish osonroq.

Ammo o'zgaruvchanlik juda foydali bo'lishi mumkin va kodni yozishni qulayroq qilishi mumkin. Garchi oʻzgaruvchilar standart boʻyicha oʻzgarmas boʻlsa-da, 2-bobda boʻlgani kabi oʻzgaruvchi nomi oldiga mut qoʻshish orqali ularni oʻzgaruvchan qilish mumkin. mut qo'shilishi, shuningdek, kodning boshqa qismlari ushbu o'zgaruvchining qiymatini o'zgartirishini ko'rsatib, kelajakdagi kod o'quvchilariga niyatni bildiradi.

Masalan, src/main.rs ni quyidagiga o'zgartiramiz:

Fayl nomi: src/main.rs

fn main() {
    let mut x = 5;
    println!("x qiymati: {x}");
    x = 6;
    println!("x qiymati: {x}");
}

Dasturni hozir ishga tushirganimizda, biz quyidagilarni olamiz:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
x qiymati: 5
x qiymati: 6

mut ishlatilganda x ga bog‘langan qiymatni 5 dan 6 ga o‘zgartirishga ruxsat beriladi. Oxir oqibat, o'zgaruvchanlikni qo'llash yoki qilmaslikni hal qilish sizga bog'liq va bu vaziyatda eng aniq deb o'ylagan narsangizga bog'liq.

Konstantalar

O'zgarmas o'zgaruvchilar singari, konstantalar nomga bog'langan va o'zgarishi mumkin bo'lmagan qiymatlardir, lekin konstantalar va o'zgaruvchilar o'rtasida bir nechta farqlar mavjud.

Birinchidan, mut dan konstantalar bilan foydalanishga ruxsat berilmagan. Konstantalar standart bo'yicha shunchaki o'zgarmas emas - ular har doim o'zgarmasdir.Siz konstantalarni let kalit so'zi o'rniga const kalit so'zidan foydalanib e'lon qilasiz va qiymat turiga annotatsiya qilinishi kerak. Biz turlar va izohlarni keyingi "Ma'lumotlar turlari" bo'limida ko'rib chiqamiz, shuning uchun hozir tafsilotlar haqida qayg'urmang. Bilingki, siz har doim turga annotate qo'yishingiz kerak.

Konstantalar har qanday miqyosda, shu jumladan global miqyosda e'lon qilinishi mumkin, bu ularni kodning ko'p qismlari bilishi kerak bo'lgan qiymatlar uchun foydali qiladi.

Oxirgi farq shundaki, konstantalar faqat ish vaqtida hisoblanishi mumkin bo'lgan qiymatning natijasi emas, balki faqat konstanta ifodaga o'rnatilishi mumkin.

Mana konstanta deklaratsiyaga misol:

#![allow(unused)]
fn main() {
const SONIYADA_UCH_SOAT: u32 = 60 * 60 * 3;
}

Konstanta nomi SONIYADA_UCH_SOAT va uning qiymati 60 ni (bir daqiqadagi soniyalar soni) 60 ga (bir soatdagi daqiqalar soni) 3 ga (biz hisoblamoqchi bo'lgan soatlar soni) ko'paytirish natijasiga o'rnatiladi. Rustning konstantalar uchun nomlash konventsiyasi so'zlar orasida barcha bosh harflarni pastki chiziq bilan ishlatishdir. Kompilyator kompilyatsiya vaqtida cheklangan operatsiyalar to'plamini baholashga qodir, bu bizga ushbu qiymatni 10,800 qiymatiga o'rnatmasdan, tushunish va tekshirish osonroq bo'lgan tarzda yozishni tanlash imkonini beradi. Konstantalarni e'lon qilishda qanday operatsiyalardan foydalanish mumkinligi haqida qo'shimcha ma'lumot olish Rust Referencening konstantalar bo'limiga qarang

Konstantalar dastur ishlayotgan butun vaqt davomida, ular e'lon qilingan doirada amal qiladi. Bu xususiyat dasturning bir nechta qismlari bilishi kerak bo'lgan, masalan, o'yinning har qanday o'yinchisi olishi mumkin bo'lgan maksimal ball soni yoki yorug'lik tezligi kabi, ilova domeningizdagi qiymatlar uchun foydali konstantalarni qiladi.

Dasturingiz davomida ishlatiladigan qattiq kodlangan qiymatlarni konstantalar sifatida nomlash ushbu qiymatning ma'nosini kodning kelajakdagi maintainerlariga yetkazishda foydalidir. Bu, shuningdek, kodingizda faqat bitta joyga ega bo'lishga yordam beradi, agar kelajakda qattiq kodlangan qiymat yangilanishi kerak bo'lsa, o'zgartirishingiz kerak bo'ladi.

Shadowing

2-bobdagi Taxmin qilish oʻyini boʻyicha qoʻllanmada koʻrganingizdek, oldingi oʻzgaruvchi bilan bir xil nomli yangi oʻzgaruvchini eʼlon qilishingiz mumkin.Rustaceanlarning aytishicha, birinchi o'zgaruvchi ikkinchi o'zgaruvchi tomonidan shadow qilingan ya'ni ikkinchi o'zgaruvchi o'zgaruvchi nomidan foydalanganda kompilyator ko'radigan narsadir. Darhaqiqat, ikkinchi o'zgaruvchi birinchisiga shadow qilib, o'zgaruvchi nomidan har qanday foydalanishni uning o'zi shadowli bo'lmaguncha yoki doirasi tugaguncha oladi. Biz bir xil oʻzgaruvchining nomidan foydalanib, let kalit soʻzidan foydalanishni quyidagi tarzda takrorlash orqali oʻzgaruvchini shadow qilishimiz mumkin:

Fayl nomi: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("x ning ichki doiradagi qiymati: {x}");
    }

    println!("x qiymati: {x}");
}

Bu dastur avval x ni 5 qiymatiga bog'laydi. Keyin u let x = ni takrorlab, asl qiymatni olib, 1 qo'shish orqali yangi x o'zgaruvchisini yaratadi, shunda x qiymati 6 bo'ladi. Keyin, jingalak qavslar bilan yaratilgan ichki doirada uchinchi let iborasi ham x ga shadow qiladi va yangi o'zgaruvchini yaratadi va oldingi qiymatni 2 ga ko'paytirib, x ga 12 qiymatini beradi. Bu doira tugagach, ichki shadow tugaydi va x 6 ga qaytadi. Ushbu dasturni ishga tushirganimizda, u quyidagilarni chiqaradi:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
x ning ichki doiradagi qiymati: 12
x qiymati: 6

Shadowing o‘zgaruvchini mut deb belgilashdan farq qiladi, chunki let kalit so‘zidan foydalanmasdan tasodifan ushbu o‘zgaruvchiga qayta tayinlashga harakat qilsak, kompilyatsiya vaqtida xatolikka yo‘l qo‘yamiz. let dan foydalanib, biz qiymat bo'yicha bir nechta o'zgarishlarni amalga oshirishimiz mumkin, lekin bu o'zgarishlar tugagandan so'ng o'zgaruvchi o'zgarmas bo'lishi mumkin.

Mut va shadow o'rtasidagi boshqa farq shundaki, biz let kalit so'zini qayta ishlatganimizda yangi o'zgaruvchini samarali yaratayotganimiz sababli, qiymat turini o`zgartirishimiz mumkin, lekin bir xil nomni qayta ishlatishimiz ham mumkin. Misol uchun, bizning dasturimiz foydalanuvchidan bo'sh joy belgilarini kiritish orqali ba'zi matnlar orasida qancha bo'sh joy bo'lishini ko'rsatishni so'raydi va biz ushbu kiritishni raqam sifatida saqlamoqchimiz:

fn main() {
    let joylar = "   ";
    let joylar = joylar.len();
}

Birinchi joylar o'zgaruvchisi satr turi, ikkinchi joylar o'zgaruvchisi esa raqam turi. Shadowing shu tariqa bizni turli nomlar bilan chiqishdan saqlaydi, masalan, joylar_str va joylar_num; Buning o'rniga biz oddiyroq joylar nomini qayta ishlatishimiz mumkin. Biroq, bu erda ko'rsatilganidek, buning uchun mut dan foydalanmoqchi bo'lsak, kompilyatsiya vaqtida xatoga duch kelamiz:

fn main() {
    let mut joylar = "   ";
    joylar = joylar.len();
}

Xato bizga o'zgaruvchining turini mutatsiyaga o'tkazishga ruxsat yo'qligini aytadi:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut joylar = "   ";
  |                      ----- expected due to this value
3 |     joylar = joylar.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` due to previous error

Endi biz o'zgaruvchilar qanday ishlashini o'rganib chiqdik, keling, ular bo'lishi mumkin bo'lgan ko'proq ma'lumotlar turlarini ko'rib chiqaylik.

Ma'lumotlar turlari

Rust-dagi har bir qiymat ma'lum bir ma'lumot turiga tegishli bo'lib, Rustga qanday ma'lumotlar ko'rsatilayotganligini bildiradi, shuning uchun u ushbu ma'lumotlar bilan qanday ishlashni biladi. Biz ikkita ma'lumotlar turini ko'rib chiqamiz: skalyar va birikma.

Esda tutingki, Rust statik tarzda yozilgan tildir, ya'ni kompilyatsiya vaqtida barcha o'zgaruvchilarning turlarini bilishi kerak. Kompilyator odatda qiymat va uni qanday ishlatishimiz asosida biz qaysi turdan foydalanmoqchi ekanligimiz haqida xulosa chiqarishi mumkin. Ko‘p turlar mumkin bo‘lgan hollarda, masalan, 2-bobdagi “Tahminni maxfiy raqam bilan solishtirish” bo‘limidagi parse yordamida Stringni raqamli turga o‘zgartirganimizda, quyidagi turdagi izohni qo‘shishimiz kerak:

#![allow(unused)]
fn main() {
let taxmin: u32 = "42".parse().expect("Raqam emas!");
}

Oldingi kodda ko'rsatilgan : u32 turidagi izohni qo'shmasak, Rust quyidagi xatoni ko'rsatadi, ya'ni kompilyator bizdan qaysi turdan foydalanishni xohlayotganimizni bilish uchun qo'shimcha ma'lumotga muhtoj:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let taxmin = "42".parse().expect("Raqam emas!");
  |         ^^^^^
  |
help: consider giving `taxmin` an explicit type
  |
2 |     let taxmin: _ = "42".parse().expect("Raqam emas!");
  |              +++

For more information about this error, try `rustc --explain E0282`.
error: could not compile `no_type_annotations` due to previous error

Boshqa ma'lumotlar turlari uchun turli turdagi izohlarni ko'rasiz.

Skalyar Turlar

Skalyar turi bitta qiymatni ifodalaydi. Rust to'rtta asosiy skalyar turga ega: integerlar, floating-point number, boolean va belgilar. Siz ularni boshqa dasturlash tillaridan bilishingiz mumkin. Keling, ularning Rustda qanday ishlashini ko'rib chiqaylik.

Integer Turlari

Integer kasr komponenti bo‘lmagan sondir. Biz 2-bobda u32 tipidagi bitta integer sonni ishlatdik. Ushbu turdagi deklaratsiya u bilan bog'langan qiymat 32 bit bo'sh joyni egallagan belgisiz butun son bo'lishi kerakligini bildiradi (Signed integer sonlar u o'rniga i bilan boshlanadi). 3-1-jadvalda Rust-da o'rnatilgan integer son turlari ko'rsatilgan. Integer son qiymatining turini e'lon qilish uchun biz ushbu variantlardan foydalanishimiz mumkin.

3-1-jadval: Rustdagi Integer sonlar turlari

Signedlar kichkina i harfi bilan boshlanadi, Unsigned esa kichik u harfi bilan boshlanadi.

Har bir variant signed yoki unsigned bo'lishi mumkin va aniq o'lchamga ega. Signed va Unsigned raqam manfiy boʻlishi mumkinmi yoki yoʻqligini anglatadi, boshqacha qilib aytganda, raqam u bilan birga belgiga ega boʻlishi (signed) boʻlishi kerakmi yoki u faqat ijobiy bo'ladimi va shuning uchun belgisiz (unsigned) ifodalanishi mumkinmi. Bu raqamlarni qog'ozga yozishga o'xshaydi: belgi muhim bo'lsa, raqam ortiqcha yoki minus belgisi bilan ko'rsatiladi; ammo, agar raqamni ijobiy deb hisoblash xavfsiz bo'lsa, u hech qanday belgisiz ko'rsatiladi. Signed raqamlar ikkita to'ldiruvchi ko'rinish yordamida saqlanadi.

Har bir signed variant -(2^{n - 1}) dan 2^{n - 1} -1 gacha bo'lgan raqamlarni saqlashi mumkin, bu erda n variant foydalanadigan bitlar soni. Shunday qilib, i8 -(2⁷) dan 2⁷ - 1, gacha bo'lgan raqamlarni saqlashi mumkin, bu tengdir -128 dan 127 gacha. Unsigned variantlar 0 dan 2ⁿ - 1 gacha raqamlarni saqlashi mumkin, shuning uchun u8 0 dan 2⁸ - 1 gacha bo'lgan raqamlarni saqlashi mumkin, bu 0 dan 255 gacha.

Bundan tashqari, isize va usize turlari dasturingiz ishlayotgan kompyuterning arxitekturasiga bog'liq bo'lib, u jadvalda “arch” sifatida ko'rsatilgan: agar siz 64 bitli arxitekturada bo'lsangiz 64 bit va 32 bitli arxitekturada bo'lsangiz 32 bit.

Integer sonlarni 3-2-jadvalda ko'rsatilgan istalgan shaklda yozishingiz mumkin. E'tibor bering, bir nechta raqamli turlar bo'lishi mumkin bo'lgan son harflari turni belgilash uchun 57u8 kabi tur qo'shimchasiga ruxsat beradi. Raqamni o'qishni osonlashtirish uchun _ dan raqamli harflar ham foydalanishi mumkin, masalan, 1_000, siz 1000 ni ko'rsatganingizdek bir xil qiymatga ega bo'ladi.

3-2-jadval: Rustdagi Integer literallar

Xo'sh, qaysi turdagi integer sonni ishlatishni qanday bilasiz? Agar ishonchingiz komil bo'lmasa, Rustning standart sozlamalari odatda boshlash uchun yaxshi joylardir: integer son turlari standart bo'yicha i32 dir. isize yoki usize dan foydalanadigan asosiy holat to'plamning bir turini indekslashdir.

Integer Overflow

Aytaylik, sizda 0 dan 255 gacha bo'lgan qiymatlarni ushlab turadigan u8 tipidagi o'zgaruvchi bor. Agar siz o'zgaruvchini ushbu diapazondan tashqaridagi qiymatga o'zgartirishga harakat qilsangiz, masalan, 256, integer overflow sodir bo'ladi, bu ikki xatti-harakatdan biriga olib kelishi mumkin. Debug mode rejimida kompilyatsiya qilayotganingizda, Rust butun sonlarning to'lib ketishini tekshirishni o'z ichiga oladi, bu esa dasturni ishga tushirish vaqtida panic chiqaradi. Rust dastur xato bilan chiqqanda panicking atamasini ishlatadi; Biz panic haqida 9-bobdagi “panic bilan tuzatib bo'lmaydigan xatolar” bo'limda batafsil ko'rib chiqamiz

--release buyrug'i bilan reliz rejimida kompilyatsiya qilayotganingizda, Rust panic keltirib chiqaradigan butun sonlarni tekshirishni o'z ichiga olmaydi. overflow occur sodir bo'ladi Rust ikkitasini to'ldiruvchi wrapni bajaradi. Qisqa qilib aytganda, turdagi maksimal qiymatdan kattaroq qiymatlar, tur ushlab turishi mumkin bo'lgan minimal qiymatlargacha "wrap" ni tashkil qiladi. u8 holatida 256 qiymati 0 ga, 257 qiymati 1 ga aylanadi va hokazo. Dastur panic qo'ymaydi, lekin o'zgaruvchi siz kutgan qiymatga ega bo'lmaydi. Butun sonlarni wrapga tayanish xato hisoblanadi. Owerflow ehtimolini aniq ko'rib chiqish uchun siz prime sonlar uchun standart kutubxona tomonidan taqdim etilgan ushbu metodlar oilalaridan foydalanishingiz mumkin:

• Barcha modelarni wrapping_* metodlari bilan oʻrash, masalan, wrapping_add.
• Agar checked_* metodlari owerflow boʻlsa, None qiymatini qaytaring.
• Qiymat va boolean qiymatni qaytaring, bu overflowing_* metodlari bilan overflow bo'lganini ko'rsatadi.
• Qiymatning minimal yoki maksimal qiymatlarida saturating_* metodllari bilan saturate bo'lgan.

Floating-Point Turlari

Rust shuningdek floating-point raqamlar uchun ikkita primitive turga ega, ular kasrli raqamlardir. Rust-ning floating-point turlari f32 va f64 bo'lib, ular mos ravishda 32 bit va 64 bit o'lchamga ega. Standart tur f64 dir, chunki zamonaviy protsessorlarda u f32 bilan bir xil tezlikda, lekin aniqroq bo'lishga qodir. Barcha floating-point turlari signeddir.

Bu yerda harakatdagi floating-point raqamlarni ko'rsatadigan misol:

Fayl nomi: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Floating-point raqamlari IEEE-754 standartiga muvofiq taqdim etiladi. f32 turi bitta aniqlikdagi floatdir va f64 ikki tomonlama aniqlikka ega.

Raqamli operatsiyalar

Rust barcha turdagi raqamlar uchun kutilgan asosiy matematik operatsiyalarni qo'llab-quvvatlaydi: qo'shish, ayirish, ko'paytirish, bo'lish va qoldiq. Butun sonni bo'lish noldan eng yaqin butun songa qisqaradi. Quyidagi kod let iborasida har bir raqamli operatsiyadan qanday foydalanishni ko'rsatadi:

Fayl nomi: src/main.rs

fn main() {
    // qo'shish
    let qoshish = 5 + 10;

    // ayirish
    let ayrish = 95.5 - 4.3;

    // ko'paytirish
    let kopaytirish = 4 * 30;

    // bo'lish
    let bolish = 56.7 / 32.2;
    let manfiy = -5 / 3; // Natijalar -1

    // qoldiq
    let qoldiq = 43 % 5;
}

Ushbu bayonotlardagi har bir ifoda matematik operatordan foydalanadi va bitta qiymatga baholanadi, keyin esa o'zgaruvchiga bog'lanadi. B ilovasi da Rust taqdim etgan barcha operatorlar ro'yxati mavjud.

Boolean turi

Ko'pgina boshqa dasturlash tillarida bo'lgani kabi, Rust-da ham Boolean turi ikkita mumkin bo'lgan qiymatga ega: true va false. Boolean hajmi bir baytga teng. Rustdagi boolean turi bool yordamida belgilanadi. Misol uchun:

Fayl nomi: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // aniq turdagi izoh bilan
}

Boolean qiymatlardan foydalanishning asosiy metodi shartlardir, masalan, if ifodasidir. Rustda if iboralari qanday ishlashini “Control Flow” bo‘limida ko‘rib chiqamiz.

Belgilar(Character) turi

Rustning char turi tilning eng primitive alifbo turidir. Mana char qiymatlarini e'lon qilishning ba`zi misollari:

Fayl nomi: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // aniq turdagi izoh bilan
    let yurak_kozli_mushuk = '😻';
}

E'tibor bering, biz qo'sh tirnoq ishlatadigan satr harflaridan farqli o'laroq, char harflarini bitta tirnoq bilan belgilaymiz. Rustning char turi to'rt bayt o'lchamga ega va Unicode Scalar qiymatini ifodalaydi, ya'ni u ASCIIdan ko'ra ko'proq narsani anglatishi mumkin. Urg'uli harflar; Xitoy, yapon va koreys belgilar; emoji; va nol kenglikdagi boʻshliqlar Rust-dagi barcha haqiqiy char qiymatlaridir. Unicode Scalar qiymatlari U+0000dan U+D7FFgacha va U+E000dan U+10FFFFgacha. Biroq, “character” aslida Unicode-da tushuncha emas, shuning uchun “character” nima ekanligi haqidagi Rustdagi char bilan mos kelmasligi mumkin. Biz ushbu mavzuni 8-bobdagi “UTF-8 kodlangan matnni satrlar bilan saqlash” bo'limida batafsil muhokama qilamiz.

Murakkab turlar

Murakkab turlar bir nechta qiymatlarni bir turga to'plashi mumkin.Rust ikkita primitive birikma turiga ega: tuplelar va arraylar.

Tuple turi

tuple - bu turli xil turlarga ega bo'lgan bir qator qiymatlarni bitta qo'shma turga birlashtirishning umumiy metodi.Tuplelar belgilangan uzunlikka ega: bir marta e'lon qilingandan so'ng, ular o'sishi yoki kichrayishi mumkin emas.

Qavslar ichida vergul bilan ajratilgan qiymatlar ro'yxatini yozish orqali tuple yaratamiz. Tupledagi har bir pozitsiya o'z turiga ega va tupledagi turli qiymatlarning turlari bir xil bo'lishi shart emas. Ushbu misolda biz ixtiyoriy turdagi izohlarni qo'shdik:

Fayl nomi: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

tup o'zgaruvchisi butun tuplega bog'lanadi, chunki tuple bitta birikma element hisoblanadi. Tupledan individual qiymatlarni olish uchun biz tuple qiymatini buzish uchun pattern moslashuvidan foydalanishimiz mumkin, masalan:

Fayl nomi: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("y qiymati: {y}");
}

Bu dastur avval tuple yaratadi va uni tup o'zgaruvchisiga bog'laydi.Keyin u tupni olish va uni uchta alohida o‘zgaruvchiga, x, y va z ga aylantirish uchun let bilan pattern ishlatadi. Bu destruktura deb ataladi, chunki u bitta tupleni uch qismga ajratadi. Nihoyat, dastur y qiymatini chop etadi, bu 6,4.

Shuningdek, biz to'g'ridan-to'g'ri nuqta (.) va undan keyin kirishni xohlagan qiymat indeksidan foydalanib, tuple elementiga kirishimiz mumkin. Misol uchun:

Fayl nomi: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let besh_yuz = x.0;

    let olti_butun_tort= x.1;

    let bir = x.2;
}

Bu dastur x tuplesini yaratadi va so'ngra o'z indekslari yordamida tuplening har bir elementiga kiradi. Ko'pgina dasturlash tillarida bo'lgani kabi, tupledagi birinchi indeks 0 ga teng.

Hech qanday qiymatsiz tuple maxsus nomga, unit ega. Bu qiymat va unga mos keladigan tur () yoziladi va bo'sh qiymat yoki bo'sh qaytish turini ifodalaydi. Ifodalar, agar ular boshqa qiymatni qaytarmasa, bilvosita birlik qiymatini qaytaradi.

Array Turi

Bir nechta qiymatlar to'plamiga ega bo'lishning yana bir usuli arraydir. Tupledan farqli o'laroq, arrayning har bir elementi bir xil turdagi bo'lishi kerak. Ba'zi boshqa tillardagi arraylardan farqli o'laroq, Rustdagi arraylar belgilangan uzunlikka ega.

Biz arraydagi qiymatlarni kvadrat qavslar ichida vergul bilan ajratilgan ro'yxat sifatida yozamiz:

Fayl nomi: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

Arraylar maʼlumotlaringizni toʻplamga emas, balki stekga ajratishni istasangiz foydali boʻladi (biz 4-bobda) stek va toʻplam haqida koʻproq gaplashamiz yoki sizda har doim maʼlum miqdordagi elementlar mavjudligini taʼminlashni istasangiz). Array vektor turi kabi moslashuvchan emas. Vektor standart kutubxona tomonidan taqdim etilgan o'xshash to'plam turi bo'lib, uning hajmini o'stirish yoki kichraytirishi mumkin. Agar array yoki vektordan foydalanishga ishonchingiz komil bo'lmasa, vektordan foydalanishingiz mumkin. 8-bobda vektorlar batafsilroq muhokama qilinadi.

Biroq, agar elementlar sonini o'zgartirish kerak bo'lmasligini bilsangiz, arraylar foydaliroq bo'ladi. Misol uchun, agar siz dasturda oy nomlaridan foydalansangiz, vektordan ko'ra massivdan foydalanar edingiz, chunki u har doim 12 ta elementdan iborat bo'lishini bilasiz:

#![allow(unused)]
fn main() {
let oylar = ["Yanvar", "Fevral", "Mart", "Aprel", "May", "Iyun", "Iyul",
              "Avgust", "Setabr", "Oktabr", "Noyabr", "Dekabr"];
}

Siz har bir element turi, nuqta-vergul va arraydagi elementlar soni bilan kvadrat qavslar yordamida array turini yozasiz, masalan:

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

Bu erda i32 har bir elementning turi. Nuqtali verguldan keyin 5 raqami array beshta elementdan iboratligini bildiradi.

Bundan tashqari, har bir element uchun bir xil qiymatni o'z ichiga olgan arrayni boshlang'ich qiymatdan keyin nuqta-vergul qo'yib, so'ngra bu yerda ko'rsatilgandek kvadrat qavs ichida array uzunligini belgilash orqali ishga tushirishingiz mumkin:

#![allow(unused)]
fn main() {
let a = [3; 5];
}

a nomli array dastlab 3 qiymatiga o'rnatiladigan 5 elementni o'z ichiga oladi. Bu let a = [3, 3, 3, 3, 3]; yozish bilan bir xil, ammo qisqaroq tarzda.

Array elementlariga kirish

Array - bu stekda taqsimlanishi mumkin bo'lgan ma'lum, qat'iy o'lchamdagi xotiraning bitta bo'lagi. Siz indekslash yordamida array elementlariga kirishingiz mumkin, masalan:

Fayl nomi: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let birinchi = a[0];
    let ikkinchi = a[1];
}

Bu misolda birinchi deb nomlangan o‘zgaruvchi 1 qiymatini oladi, chunki bu arraydagi [0] indeksidagi qiymatdir. ikkinchi deb nomlangan ozgaruvchi arraydagi [1] indeksidan 2 qiymatini oladi.

Yaroqsiz Array elementlariga kirish

Keling, array oxiridan o‘tgan array elementiga kirishga harakat qilsangiz nima bo‘lishini ko‘rib chiqamiz. Aytaylik, foydalanuvchidan array indeksini olish uchun 2-bobdagi taxminiy o‘yinga o‘xshash ushbu kodni ishlatasiz:

Fayl nomi: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Iltimos, array indeksini kiriting.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("Satrni o‘qib bo‘lmadi");

    let index: usize = index
        .trim()
        .parse()
        .expect("Kiritilgan indeks raqam emas");

    let element = a[index];

    println!("{index} indeksidagi elementning qiymati: {element}");
}

Ushbu kod muvaffaqiyatli kompilyatsiya qilinadi.Agar siz ushbu kodni cargo run yordamida ishga tushirsangiz va 0, 1, 2, 3 yoki 4 kiritsangiz, dastur arraydagi ushbu indeksdagi mos qiymatni chop etadi. Buning o'rniga array oxiridan o'tgan raqamni kiritsangiz, masalan, 10, siz shunday chiqishni ko'rasiz:

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Dastur indekslash operatsiyasida yaroqsiz qiymatdan foydalanish nuqtasida runtime xatosiga olib keldi. Dastur xato xabari bilan chiqdi va yakuniy println! bayonotini bajarmadi. Indekslash yordamida elementga kirishga harakat qilganingizda, Rust siz ko'rsatgan indeks array uzunligidan kamroq ekanligini tekshiradi. Agar indeks uzunlikdan kattaroq yoki unga teng bo'lsa, Rust panic chiqaradi. Bu tekshirish runtimeda amalga oshirilishi kerak, ayniqsa bu holatda, chunki kompilyator foydalanuvchi kodni keyinroq ishga tushirganda qanday qiymat kiritishini bila olmaydi.

Bu Rustning xotira xavfsizligi tamoyillarining amaldagi namunasidir. Ko'pgina low-leveldagi tillarda bunday tekshirish amalga oshirilmaydi va noto'g'ri indeksni taqdim etganingizda, yaroqsiz xotiraga kirish mumkin. Rust xotiraga kirishga ruxsat berish va davom ettirish o'rniga darhol chiqish orqali sizni bunday xatolardan himoya qiladi. 9-bobda Rust-ning xatolarini qanday hal qilish va siz panic qo'ymaydigan va yaroqsiz xotiraga kirishga ruxsat bermaydigan o'qilishi mumkin bo'lgan xavfsiz kodni qanday yozishingiz mumkinligi muhokama qilinadi.

Funksiyalar

Funksiyalar Rust kodida keng tarqalgan. Siz allaqachon tildagi eng muhim funksiyalardan birini ko'rgansiz: ko'plab dasturlarning kirish nuqtasi bo'lgan main funksiya. Siz yangi funksiyalarni e'lon qilish imkonini beruvchi fn kalit so'zini ham ko'rdingiz.

Rust kodi funksiya va oʻzgaruvchilar nomlari uchun anʼanaviy uslub sifatida snake case dan foydalanadi, unda barcha harflar kichik va alohida soʻzlarning tagiga chiziladi. Mana, misol funksiya ta'rifini o'z ichiga olgan dastur:

Fayl nomi: src/main.rs

fn main() {
    println!("Hello, world!");

    boshqa_funksiya();
}

fn boshqa_funksiya() {
    println!("Boshqa funksiya.");
}

Rust-da funksiyani fn so'ng funksiya nomi va qavslar to'plamini kiritish orqali aniqlaymiz. Jingalak qavslar kompilyatorga funksiya tanasi qayerda boshlanishi va tugashini bildiradi.

Biz belgilagan har qanday funksiyani uning nomidan keyin qavslar to'plamini kiritish orqali chaqirishimiz mumkin. Dasturda boshqa_funksiya ni aniqlanganligi sababli uni main funksiya ichidan chaqirish mumkin. E'tibor bering, biz boshqa_funksiya ni manba kodidagi main funksiyadan keyin belgilaganmiz; uni avval ham belgilashimiz mumkin edi. Rust sizning funksiyalaringizni qayerda belgilashingizning ahamiyati yo'q, faqat ular so'rov yuboruvchi tomonidan ko'rinadigan doirada aniqlangan.

Keling, funksiyalarni ko'proq o'rganish uchun funksiyalar nomli yangi binary loyihani boshlaylik. boshqa_funksiya misolini src/main.rs ga joylashtiring va uni ishga tushiring.Quyidagi chiqishni ko'rishingiz kerak:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.28s
     Running `target/debug/functions`
Hello, world!
Boshqa funksiya.

Qatorlar main funksiyada paydo bo'ladigan tartibda bajariladi. Avvaliga "Hello, world!" xabar chop etiladi, keyin boshqa_funksiya chaqiriladi va uning xabari chop etiladi.

Parametrlar

Biz funksiyalarni parametrlari bo'lishi uchun belgilashimiz mumkin, ular funksiya imzosining bir qismi bo'lgan maxsus o'zgaruvchilardir. Agar funksiya parametrlarga ega bo'lsa, siz unga ushbu parametrlar uchun aniq qiymatlarni berishingiz mumkin. Texnik jihatdan aniq qiymatlar argumentlar deb ataladi, ammo tasodifiy suhbatda odamlar funksiya taʼrifidagi oʻzgaruvchilar yoki funksiyani chaqirganingizda qabul qilingan aniq qiymatlar uchun parametr va argument soʻzlarini bir-birining oʻrniga ishlatishga moyildirlar.

boshqa_funksiya ning ushbu versiyasida biz parametr qo'shamiz:

Fayl nomi: src/main.rs

fn main() {
    boshqa_funksiya(5);
}

fn boshqa_funksiya(x: i32) {
    println!("x qiymati: {x}");
}

Ushbu dasturni ishga tushirishga harakat qiling; quyidagi chiqishni olishingiz kerak:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 1.21s
     Running `target/debug/functions`
x qiymati: 5

boshqa_funksiya deklaratsiyasi x nomli bitta parametrga ega. x turi i32 sifatida belgilangan. Biz 5ni boshqa_funksiyaga o‘tkazganimizda, println! makros 5 ni xni o‘z ichiga olgan jingalak qavslar juftligi format satrida joylashgan joyga qo‘yadi.

Funksiya signaturelarda siz har bir parametr turini e'lon qilishingiz kerak. Bu Rust dizaynidagi ataylab qabul qilingan qaror: funksiya taʼriflarida turdagi izohlarni talab qilish kompilyatorga qaysi turni nazarda tutayotganingizni tushunish uchun ularni kodning boshqa joylarida ishlatishingizga deyarli hech qachon ehtiyoj sezmasligini anglatadi. Kompilyator, shuningdek, funksiya qanday turlarni kutayotganini bilsa, yanada foydali xato xabarlarini berishi mumkin.

Bir nechta parametrlarni belgilashda parametr deklaratsiyasini vergul bilan ajrating, masalan:

Fayl nomi: src/main.rs

fn main() {
    belgilangan_vaqt(5, 'h');
}

fn belgilangan_vaqt(value: i32, unit_label: char) {
    println!("Belgilangan Vaqt: {value}{unit_label}");
}

Ushbu misol ikkita parametrli belgilangan_vaqt nomli funksiyani yaratadi. Birinchi parametr value deb nomlangan va i32 dir. Ikkinchisi unit_label deb nomlanadi va char turidir. Keyin funksiya value va ``unit_label` ni o‘z ichiga olgan matnni chop etadi.

Keling, ushbu kodni ishga tushirishga harakat qilaylik. Hozirda funksiyalar loyihangizning src/main.rs faylidagi dasturni oldingi misol bilan almashtiring va uni cargo run yordamida ishga tushiring:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/functions`
Belgilangan Vaqt: 5h

Biz funksiyani value qiymati sifatida 5 va unit_label qiymati sifatida 'h' deb ataganimiz sababli, dastur chiqishi ushbu qiymatlarni o`z ichiga oladi.

Statementlar va Expressionlar

Funksiya qismlari ixtiyoriy ravishda statement bilan tugaydigan bir qator expressionlardan iborat. Hozircha biz ko'rib chiqqan funksiyalar yakuniy expressionni o'z ichiga olmagan, lekin siz expressionni statementning bir qismi sifatida ko'rdingiz. Rust expressionga asoslangan til bo'lganligi sababli, bu tushunish uchun muhim farqdir. Boshqa tillar bir xil farqlarga ega emas, shuning uchun keling, qanday statementlar va expressionlar ekanligini va ularning farqlari funksiyalar tanasiga qanday ta'sir qilishini ko'rib chiqaylik.

• Statementlar ba'zi amallarni bajaradigan va qiymat qaytarmaydigan ko'rsatmalardir.
• Expressionlar qiymatga baholanadi. Keling, ba'zi misollarni ko'rib chiqaylik.

Biz allaqachon statementlar va expressionlarni ishlatganmiz. O'zgaruvchini yaratish va unga let kalit so'zi bilan qiymat berish - bu statement. 3-1 ro'yxatda let y = 6; - bu statement.

Fayl nomi: src/main.rs

fn main() {
    let y = 6;
}

Ro'yxat 3-1: Bitta statementni o'z ichiga olgan main funksiya deklaratsiyasi

Funksiya definitionlari ham statementlardir; oldingi misol o'z-o'zidan bir statementdir.

Statementlar qiymatlarni qaytarmaydi. Shuning uchun siz boshqa o'zgaruvchiga let iborasini tayinlay olmaysiz, chunki quyidagi kod bunga harakat qiladi; siz xatoga duch kelasiz:

Fayl nomi: src/main.rs

fn main() {
    let x = (let y = 6);
}

Ushbu dasturni ishga tushirganingizda, sizda paydo bo'ladigan xato quyidagicha ko'rinadi:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found `let` statement
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^

error: expected expression, found statement (`let`)
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^^^^^^^
  |
  = note: variable declaration using `let` is a statement

error[E0658]: `let` expressions in this position are unstable
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^^^^^^^
  |
  = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information

warning: unnecessary parentheses around assigned value
 --> src/main.rs:2:13
  |
2 |     let x = (let y = 6);
  |             ^         ^
  |
  = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
  |
2 -     let x = (let y = 6);
2 +     let x = let y = 6;
  |

For more information about this error, try `rustc --explain E0658`.
warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` due to 3 previous errors; 1 warning emitted

let y = 6 statementi qiymat qaytarmaydi, shuning uchun x bog'lanishi uchun hech narsa yo'q. Bu boshqa tillarda sodir bo'ladigan narsadan farq qiladi, masalan, C va Ruby, bu yerda assignment assignmentning qiymatini qaytaradi. Bu tillarda siz x = y = 6 yozishingiz mumkin va x va y ham 6 qiymatiga ega; Rustda bunday emas.

Expressionlar qiymatga baholanadi va siz Rust-da yozadigan kodning qolgan qismini tashkil qiladi. 5 + 6 kabi matematik amalni ko'rib chiqing, bu 11 qiymatini beruvchi expressiondir. Expressionlar statementlarning bir qismi bo'lishi mumkin: 3-1 ro'yxatdagi let y = 6; ifodasidagi 6, 6 qiymatini beruvchi expressiondir. Funksiyani chaqirish expressiondir. Makroni chaqirish expressiondir. Jingalak qavslar bilan yaratilgan yangi qamrov bloki expressiondir, masalan:

Fayl nomi: src/main.rs

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("y qiymati: {y}");
}

Bu expression:

{
    let x = 3;
    x + 1
}

blok bo'lib, bu holda 4 ga evaluate bo'ladi. Bu qiymat let statementining bir qismi sifatida y ga bog'lanadi. E'tibor bering, "x + 1 qatorining oxirida nuqta-vergul yo'q, bu siz ko'rgan ko'pgina qatorlardan farqli o'laroq. Expressionlar yakuniy nuqtali vergullarni o'z ichiga olmaydi. Ifodaning oxiriga nuqtali vergul qo'shsangiz, uni statementga aylantirasiz va u keyinchalik qiymatni qaytarmaydi. Keyingi funksiyani qaytarish qiymatlari va expressionlarini o'rganayotganda buni yodda tuting.

Return qiymatlari bilan funksiyalar

Funksiyalar qiymatlarni ularni chaqiradigan kodga return qaytarishi mumkin. Return qiymatlarini nomlamaymiz, lekin ularning turini o'qdan keyin e'lon qilishimiz kerak (->). Rustda funksiyaning return qiymati funksiya tanasi blokidagi yakuniy ifodaning qiymati bilan sinonimdir. Siz return kalit so'zidan foydalanib va qiymatni belgilash orqali funksiyadan erta qaytishingiz mumkin, lekin ko'pchilik funksiyalar oxirgi expressionni bevosita qaytaradi. Mana qiymatni return qiladigan funksiyaga misol:

Fayl nomi: src/main.rs

fn besh() -> i32 {
    5
}

fn main() {
    let x = besh();

    println!("x qiymati: {x}");
}

besh funksiyasida funksiya chaqiruvlari, makroslar va hatto let iboralari ham yo‘q – faqat 5 raqamining o‘zi. Bu Rust-da juda to'g'ri funksiya. Funksiyaning return turi ham -> i32 sifatida ko'rsatilganligini unutmang.Ushbu kodni ishga tushirishga harakat qiling; chiqish quyidagicha ko'rinishi kerak:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/functions`
x qiymati: 5

besh dagi 5 funksiyaning return qiymatidir, shuning uchun return turi i32dir. Keling, buni batafsilroq ko'rib chiqaylik. Ikkita muhim bit mavjud: birinchidan, let x = besh(); qatori biz o'zgaruvchini ishga tushirish uchun funksiyaning return qiymatidan foydalanayotganimizni ko'rsatadi. Chunki besh funksiyasi 5ni qaytaradi, bu qator quyidagi bilan bir xil:

#![allow(unused)]
fn main() {
let x = 5;
}

Ikkinchidan, besh funksiyasi hech qanday parametrga ega emas va return qiladigan qiymat turini belgilaydi, lekin funksiyaning tanasi nuqta-vergulsiz yolg‘iz 5 bo‘ladi, chunki bu biz qiymatini qaytarmoqchi bo‘lgan ifodadir.

Keling, yana bir misolni ko'rib chiqaylik:

Fayl nomi: src/main.rs

fn main() {
    let x = qoshilgan_bir(5);

    println!("x qiymati: {x}");
}

fn qoshilgan_bir(x: i32) -> i32 {
    x + 1
}

Ushbu kodni ishga tushirish x qiymati: 6 ni chop etadi. Ammo, agar biz x + 1 bo'lgan satr oxiriga nuqta-vergul qo'ysak, uni expressiondan statementga o'zgartirsak, xatoga yo'l qo'yamiz:

Fayl nomi: src/main.rs

fn main() {
    let x = qoshilgan_bir(5);

    println!("x qiymati: {x}");
}

fn qoshilgan_bir(x: i32) -> i32 {
    x + 1;
}

Ushbu kodni kompilyatsiya qilish quyidagi kabi xatoga olib keladi:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
 --> src/main.rs:7:24
  |
7 | fn qoshilgan_bir(x: i32) -> i32 {
  |    --------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: remove this semicolon to return this value

For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` due to previous error

Asosiy xato xabari, mismatched types(mos kelmaydigan turlar) ushbu kod bilan bog'liq asosiy muammoni ochib beradi. qoshilgan_bir funksiyasining taʼrifida aytilishicha, u i32 ni qaytaradi, lekin statementlar birlik turi boʻlgan () bilan expression bo'lgan qiymatga evaluate bo'lmaydi. Shuning uchun, hech narsa return qilinmaydi, bu funksiya definitioniga zid keladi va xatolikka olib keladi. Ushbu chiqishda Rust bu muammoni tuzatishga yordam beradigan xabarni taqdim etadi: u nuqta-vergulni olib tashlashni taklif qiladi, bu xatoni tuzatadi.

Izohlar

Barcha dasturchilar o'z kodlarini tushunishni osonlashtirishga harakat qilishadi, lekin ba'zida qo'shimcha tushuntirish kerak. Bunday hollarda dasturchilar o'zlarining manba kodlarida izohlar qoldiradilar, ularni kompilyator e'tiborsiz qoldiradi, ammo manba kodini o'qiyotgan odamlar uchun foydali bo'lishi mumkin.

Mana oddiy izoh:

#![allow(unused)]
fn main() {
// hello, world
}

Rustda idiomatik izoh uslubi izohni ikki qiyshiq chiziq bilan boshlaydi va izoh satr oxirigacha davom etadi. Bitta satrdan tashqariga chiqadigan izohlar uchun har bir satrga // qo'shishingiz kerak bo'ladi, masalan:

#![allow(unused)]
fn main() {
// Shunday qilib, biz bu erda murakkab ish qilyapmiz,
// bizga bir nechta izohlar kerak bo'ladi! Vou! Umid qilamanki,
// bu izoh nima bo'layotganini tushuntiradi.
}

Izohlar, shuningdek, kodni o'z ichiga olgan qatorlar oxirida joylashtirilishi mumkin:

Fayl nomi: src/main.rs

fn main() {
    let omadli_raqam = 7; // Bugun o'zimni omadli his qilyapman
}

Ammo siz ularni ushbu formatda ko'proq ko'rasiz, izohli kod ustidagi alohida satrda izoh bilan:

Fayl nomi: src/main.rs

fn main() {
    // Bugun o'zimni omadli his qilyapman
    let omadli_raqam = 7;
}

Rustda yana bir turdagi izohlar, hujjatlar izohlari mavjud, biz ularni 14-bobning “Crates.io-ga crateni nashr qilish“ bo'limida muhokama qilamiz.

Control Flow

Shartning true yoki yo'qligiga qarab ba'zi kodlarni ishga tushirish va shart true bo'lganda ba'zi kodlarni qayta-qayta ishga tushirish qobiliyati ko'pchilik dasturlash tillarida asosiy building bloklari hisoblanadi. Rust kodining bajarilishini nazorat qilish imkonini beruvchi eng keng tarqalgan konstruksiyalar if expressionlari va looplaridir.

if ifodalari

if ifodasi shartlarga qarab kodingizni branchga ajratish imkonini beradi. Siz shartni taqdim etasiz va keyin shunday deb aytasiz: “Agar bu shart bajarilsa, ushbu kod blokini ishga tushiring. Agar shart bajarilmasa, ushbu kod blokini ishga tushirmang."

If ifodasini oʻrganish uchun loyihalar jildingizda branchlar nomli yangi loyiha yarating. src/main.rs faylida quyidagilarni kiriting:

Fayl nomi: src/main.rs

fn main() {
    let raqam = 3;

    if raqam < 5 {
        println!("shart true edi");
    } else {
        println!("shart true edi");
    }
}

Barcha if expressionlari if kalit so‘zidan boshlanadi, undan keyin shart keladi. Bunday holda, shart raqam o'zgaruvchisi 5 dan kichik qiymatga ega yoki yo'qligini tekshiradi. Agar shart true bo'lsa, biz kod blokini shartdan keyin darhol jingalak qavslar ichiga joylashtiramiz. if expressionlaridagi shartlar bilan bog‘langan kod bloklari ba’zan arms deb ataladi, xuddi biz 2-bobning “Tahminni maxfiy raqam bilan solishtirish” bo‘limida muhokama qilgan match expressionlaridagi qurollar kabi.

Ixtiyoriy ravishda, agar shart false deb baholansa, dasturga bajarilishi uchun muqobil kod blokini berish uchun biz tanlagan else expressionini ham kiritishimiz mumkin. Agar else ifodasini bermasangiz va shart false bo‘lsa, dastur shunchaki if blokini o‘tkazib yuboradi va kodning keyingi bitiga o‘tadi.

Ushbu kodni ishga tushirishga harakat qiling; quyidagi chiqishni ko'rishingiz kerak:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branchlar)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branchlar`
shart true edi

Keling, nima sodir bo'lishini ko'rish uchun raqam qiymatini shartni false qiladigan qiymatga o'zgartirib ko'raylik:

fn main() {
    let raqam = 7;

    if raqam < 5 {
        println!("shart true edi");
    } else {
        println!("shart false edi");
    }
}

Dasturni qayta ishga tushiring va natijaga qarang:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
shart false edi

Shuni ham ta'kidlash kerakki, ushbu koddagi shart bool bo'lishi kerak. Agar shart bool bo'lmasa, biz xatoga yo'l qo'yamiz. Masalan, quyidagi kodni ishga tushirishga harakat qiling:

Fayl nomi: src/main.rs

fn main() {
    let raqam = 3;

    if raqam {
        println!("raqam uchta edi");
    }
}

if sharti bu safar 3 qiymatiga teng bo'ladi va Rust xato qiladi:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if raqam {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error

Xato shuni ko'rsatadiki, Rust bool kutgan, lekin integer(butun) son olgan. Ruby va JavaScript kabi tillardan farqli o'laroq, Rust boolean bo'lmagan turlarni boolean tilga o'zgartirishga avtomatik ravishda urinmaydi. Siz aniq bo'lishingiz va har doim if ni mantiqiy shart sifatida ko'rsatishingiz kerak. Agar biz if kod bloki faqat raqam 0 ga teng bo‘lmaganda ishlashini istasak, masalan, if ifodasini quyidagiga o‘zgartirishimiz mumkin:

Fayl nomi: src/main.rs

fn main() {
    let raqam = 3;

    if raqam != 0 {
        println!("raqam noldan boshqa narsa edi");
    }
}

Ushbu kodni ishga tushirish raqam noldan boshqa narsa edi chop etiladi.

else if bilan bir nechta shartlarni boshqarish

if va else ni else if ifodasida birlashtirib, bir nechta shartlardan foydalanishingiz mumkin.Misol uchun:

Fayl nomi: src/main.rs

fn main() {
    let raqam = 6;

    if raqam % 4 == 0 {
        println!("raqam 4 ga bo'linadi");
    } else if raqam % 3 == 0 {
        println!("raqam 3 ga bo'linadi");
    } else if raqam % 2 == 0 {
        println!("raqam 2 ga bo'linadi");
    } else {
        println!("raqam 4, 3 yoki 2 ga bo'linmaydi");
    }
}

Ushbu dasturda to'rtta yo'l bor. Uni ishga tushirgandan so'ng siz quyidagi chiqishni ko'rishingiz kerak:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
raqam 3 ga bo'linadi

Ushbu dastur bajarilganda, u har bir if expressionni navbatma-navbat tekshiradi va shart true deb baholanadigan birinchi tanani bajaradi. E'tibor bering 6, 2 ga bo'linsa ham, biz son 2 ga bo'linmaydi chiqishini ko'rmayapmiz va else blokidagi raqam 4, 3 yoki 2 ga bo'linmaydi matnini ko'rmaymiz.Buning sababi, Rust faqat birinchi true shart uchun blokni bajaradi va bir marta topilsa, qolganlarini ham tekshirmaydi. Juda ko'p else if expressionlaridan foydalanish kodingizni buzishi mumkin, shuning uchun sizda bir nechta bo'lsa, kodingizni qayta tahrirlashni xohlashingiz mumkin. 6-bobda bu holatlar uchun match deb nomlangan kuchli Rust tarmoqli konstruksiyasi tasvirlangan.

let statementida if dan foydalanish

if expression bo‘lganligi sababli, biz 3-2-listdagi kabi natijani o‘zgaruvchiga belgilash uchun let statementining o‘ng tomonida foydalanishimiz mumkin.

Fayl nomi: src/main.rs

fn main() {
    let shart = true;
    let raqam = if shart { 5 } else { 6 };

    println!("Raqamning qiymati: {raqam}");
}

Ro'yxat 3-2: if expressioni natijasini o‘zgaruvchiga tayinlash

raqam o'zgaruvchisi if expressioni natijasiga asoslangan qiymatga bog'lanadi. Nima sodir bo'lishini ko'rish uchun ushbu kodni ishga tushiring:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/branches`
Raqamning qiymati: 5

Esda tutingki, kod bloklari ulardagi oxirgi expressiongacha evaluate qilianadi va raqamlar o'zlari ham expressionlardir. Bu holda butun if expressionning qiymati qaysi kod bloki bajarilishiga bog'liq. Bu if ning har bir armidan result bo'lish potentsialiga ega bo'lgan qiymatlar bir xil turdagi bo'lishi kerakligini anglatadi; 3-2 ro'yxatda if va else armllarining natijalari i32 butun sonlari edi. Agar turlar mos kelmasa(mismatched), quyidagi misolda bo'lgani kabi, biz xatoga duch kelamiz:

Fayl nomi: src/main.rs

fn main() {
    let shart = true;

    let raqam = if shart { 5 } else { "olti" };

    println!("Raqamning qiymati: {raqam}");
}

Ushbu kodni kompilyatsiya qilmoqchi bo'lganimizda, biz xatoga duch kelamiz. if va else armllari mos kelmaydigan qiymat turlariga ega va Rust muammoni dasturda qayerdan topish mumkinligini aniq ko'rsatadi:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let raqam = if shart { 5 } else { "olti" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error

if blokidagi expression butun songa, else blokidagi expression esa satrga baholanadi. Bu ishlamaydi, chunki oʻzgaruvchilar bitta turga ega boʻlishi kerak va Rust kompilyatsiya vaqtida raqam oʻzgaruvchisi qaysi turini aniq bilishi kerak. raqam turini bilish kompilyatorga ushbu tur biz raqam ishlatadigan hamma joyda yaroqliligini tekshirish imkonini beradi. Agar raqam turi faqat runtimeda aniqlangan bo'lsa, Rust buni qila olmaydi; kompilyator murakkabroq bo'lar edi va agar u har qanday o'zgaruvchi uchun bir nechta gipotetik turlarni kuzatib borishi kerak bo'lsa, kod haqida kamroq kafolatlar beradi.

Looplar bilan takrorlash

Ko'pincha kod blokini bir necha marta bajarish foydali bo'ladi. Ushbu vazifani bajarish uchun Rust bir nechta looplarni taqdim etadi, ular sikl tanasi ichidagi kod orqali oxirigacha ishlaydi va keyin darhol boshida boshlanadi. Looplar bilan tajriba o'tkazish uchun keling, looplar deb nomlangan yangi loyiha yarataylik.

Rustda uch xil looplar mavjud: loop, while va for. Keling, har birini sinab ko'raylik.

Kodni loop bilan takrorlash

loop kalit so'zi Rustga kod blokini abadiy qayta-qayta bajarishni yoki uni to'xtatishni aniq aytmaguningizcha bajarishni aytadi.

Misol tariqasida, looplar jildingizdagi src/main.rs faylini quyidagicha o'zgartiring:

Fayl nomi: src/main.rs

fn main() {
    loop {
        println!("yana!");
    }
}

Ushbu dasturni ishga tushirganimizda, dasturni qo'lda to'xtatmagunimizcha, yana! so'zi doimiy ravishda chop etilishini ko'ramiz.Aksariyat terminallar uzluksiz siklda ishlab qolgan dasturni to'xtatish uchun ctrl-c klaviatura yorliqlarini qo'llab-quvvatlaydi. Sinab ko'ring:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/looplar)
    Finished dev [unoptimized + debuginfo] target(s) in 0.29s
     Running `target/debug/looplar`
yana!
yana!
yana!
yana!
^Cyana!

^C belgisi ctrl-c tugmalarini bosgan joyni bildiradi. Kod uzilish signalini qabul qilganda siklning qayerda bo'lganiga qarab, ^C dan keyin chop etilgan yana! so'zini ko'rishingiz yoki ko'rmasligingiz mumkin.

Yaxshiyamki, Rust kod yordamida loopdan chiqish yo'lini ham taqdim etadi. Siz dasturga siklni bajarishni qachon to'xtatish kerakligini aytish uchun break kalit so'zini siklga qo'yishingiz mumkin. Eslatib o'tamiz, biz buni 2-bobning ”To'g'ri taxmindan keyin chiqish” bo'limidagi taxminiy o'yinda, foydalanuvchi to'g'ri raqamni taxmin qilish orqali o'yinda g'alaba qozonganida dasturdan chiqish uchun qilganmiz.

Shuningdek, biz taxmin qilish o'yinida continue dan foydalandik, bu siklda dasturga siklning ushbu iteratsiyasida qolgan har qanday kodni o'tkazib yuborish va keyingi iteratsiyaga o'tishni aytadi.

Looplardan qiymatlarni qaytarish(return)

loop dan foydalanishdan biri bu ish bajarilmasligi mumkin bo'lgan operatsiyani qaytadan urinish, masalan, thread o'z ishini tugatganligini tekshirish. Bundan tashqari, ushbu operatsiya natijasini kodingizning qolgan qismiga sikldan o'tkazishingiz kerak bo'lishi mumkin. Buning uchun siklni toʻxtatish uchun foydalanadigan break ifodasidan keyin return qilinishi kerak boʻlgan qiymatni qoʻshishingiz mumkin; bu qiymat loopdan qaytariladi, shuning uchun uni bu yerda ko'rsatilganidek ishlatishingiz mumkin:

fn main() {
    let mut hisoblagich = 0;

    let natija = loop {
        hisoblagich += 1;

        if hisoblagich == 10 {
            break hisoblagich * 2;
        }
    };

    println!("Natija: {natija}");
}

Loopdan oldin biz hisoblagich nomli o‘zgaruvchini e’lon qilamiz va uni 0 ga ishga tushiramiz. Keyin sikldan qaytarilgan qiymatni ushlab turish uchun natija nomli o'zgaruvchini e'lon qilamiz. Loopning har bir iteratsiyasida biz hisoblagich o‘zgaruvchisiga 1 qo‘shamiz va keyin hisoblagich 10 ga teng yoki yo‘qligini tekshiramiz. Bu bo'lganda, biz hisoblagich * 2 qiymati bilan break kalit so'zidan foydalanamiz. Loopdan so'ng biz natija qiymatini belgilaydigan statementni tugatish uchun nuqta-verguldan foydalanamiz. Nihoyat, biz qiymatni natijada chop qilamiz, bu holda 20.

Bir nechta looplar orasidagi farqni ajratish uchun loop labellari

Agar sizda looplar ichida looplaringiz bo'lsa, o'sha nuqtada eng ichki loopga break va continue amallari qo'llaniladi. Siz ixtiyoriy ravishda siklda loop label belgilashingiz mumkin, undan so‘ng break yoki continue bilan o‘sha kalit so‘zlar eng ichki loop o‘rniga belgilangan loopga qo‘llanilishini belgilashingiz mumkin. Loop labellari bitta tirnoqcha bilan boshlanishi kerak. Mana ikkita ichki loop bilan bir misol:

fn main() {
    let mut hisob = 0;
    'hisoblash: loop {
        println!("hisob = {hisob}");
        let mut qolgan = 10;

        loop {
            println!("qolgan = {qolgan}");
            if qolgan == 9 {
                break;
            }
            if hisob == 2 {
                break 'hisoblash;
            }
            qolgan -= 1;
        }

        hisob += 1;
    }
    println!("Yakuniy hisob = {hisob}");
}

Tashqi loopda 'hisoblash labeli bor va u 0 dan 2 gacha hisoblanadi. Labelsiz ichki loop 10 dan 9 gacha hisoblanadi. Label ko'rsatilmagan birinchi break faqat ichki sikldan chiqadi. break 'hisoblash; statementi tashqi sikldan chiqadi. Keling kodni run qilib ko'ramiz:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
hisob = 0
qolgan = 10
qolgan = 9
hisob = 1
qolgan = 10
qolgan = 9
hisob = 2
qolgan = 10
Yakuniy hisob = 2

while bilan shartli looplar

Dastur ko'pincha loop ichidagi shartni evaluate qilishi kerak bo'ladi. Shart true bo'lsa-da, loop ishlaydi. Shart true bo'lishni to'xtatganda, dastur loopni to'xtatib, break ni chaqiradi. Bu kabi xatti-harakatlarni loop, if, else va break kombinatsiyasidan foydalanib amalga oshirish mumkin; Agar xohlasangiz, buni hozir dasturda sinab ko'rishingiz mumkin. Biroq, bu pattern shunchalik keng tarqalganki, Rustda buning uchun while sikli deb ataladigan o'rnatilgan til konstruktsiyasi mavjud. 3-3 ro'yxatda biz dasturni uch marta aylanish uchun while dan foydalanamiz, har safar sanab chiqamiz, so'ngra sikldan so'ng xabarni chop etamiz va chiqamiz.

Fayl nomi: src/main.rs

fn main() {
    let mut raqam = 3;

    while raqam != 0 {
        println!("{raqam}!");

        raqam -= 1;
    }

    println!("LIFTOFF!!!");
}

Ro'yxat 3-3: Shart to'g'ri bo'lganda kodni ishga tushirish uchun while siklidan foydalanish

Bu konstruksiya loop, if, else va break dan foydalansangiz, zarur bo'ladigan ko'plab joylashtirishlarni yo'q qiladi va bu aniqroq bo'ladi. Shart true deb baholansa, kod ishlaydi; aks holda, u loopdan chiqadi.

for bilan to'plam bo'ylab aylanish

Siz while konstruksiyasidan array kabi to‘plam elementlari ustidan aylanishni tanlashingiz mumkin. Masalan, 3-4 ro'yxatdagi sikl a arrayidagi har bir elementni chop etadi.

Fayl nomi: src/main.rs

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("qiymati: {}", a[index]);

        index += 1;
    }
}

Ro'yxat 3-4: while sikli yordamida to‘plamning har bir elementi bo‘ylab aylanish

Bu erda kod arraydagi elementlar orqali hisoblanadi. U 0 indeksidan boshlanadi va keyin arraydagi yakuniy indeksga yetguncha (ya'ni, index < 5 endi true bo`lmaganda) sikl davom etadi. Ushbu kodni ishga tushirish arraydagi har bir elementni chop etadi:

$ cargo run
   Compiling looplar v0.1.0 (file:///projects/looplar)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/looplar`
qiymati: 10
qiymati: 20
qiymati: 30
qiymati: 40
qiymati: 50

Barcha besh array qiymatlari kutilganidek terminalda paydo bo'ladi. Garchi index bir nuqtada 5 qiymatiga yetsa ham, arraydan oltinchi qiymatni olishga urinishdan oldin sikl ishlashni to‘xtatadi.

Biroq, bu yondashuv xatoga moyil; Agar indeks qiymati yoki test holati noto'g'ri bo'lsa, biz dasturni panic qo'yishimiz mumkin. Misol uchun, agar siz a arrayining ta'rifini to'rtta elementga o'zgartirsangiz, lekin shartni while index < 4 bo'lganda yangilashni unutgan bo'lsangiz, kod panic qo'zg'atadi. Bu ham sekin, chunki kompilyator sikl orqali har bir iteratsiyada indeks array chegaralarida ekanligini shartli tekshirish uchun runtime kodini qo‘shadi.

Aniqroq variant sifatida, siz for siklidan foydalanishingiz va to'plamdagi har bir element uchun ba'zi kodlarni bajarishingiz mumkin. for sikli 3-5-ro'yxatdagi kodga o'xshaydi.

Fayl nomi: src/main.rs

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("qiymati: {element}");
    }
}

Ro'yxat 3-5: for `sikli yordamida to'plamning har bir elementi bo'ylab aylanish

Ushbu kodni ishga tushirganimizda, biz 3-4 ro'yxatdagi kabi natijani ko'ramiz. Eng muhimi, biz kodning xavfsizligini oshirdik va arrayning oxiridan tashqariga chiqish yoki yetarlicha uzoqqa bormaslik va ba'zi elementlarni yetishmayotganligi sababli paydo bo'lishi mumkin bo'lgan xatolar ehtimolini yo'q qildik.

for siklidan foydalanib, agar siz 3-4 roʻyxatda qoʻllanilgan metodda boʻlgani kabi arraydagi qiymatlar sonini oʻzgartirsangiz, boshqa kodni oʻzgartirishni eslab qolishingiz shart emas.

for looplarining xavfsizligi va ixchamligi ularni Rustda eng ko‘p ishlatiladigan loop konstruksiyasiga aylantiradi. 3-3 ro'yxatdagi while siklidan foydalanilgan ortga hisoblash misolida bo'lgani kabi, ma'lum bir necha marta kodni ishlatmoqchi bo'lgan vaziyatlarda ham ko'pchilik Rustaceanlar for siklidan foydalanadilar. Buning yo'li standart kutubxona tomonidan taqdim etilgan Range dan foydalanish bo'lib, bir raqamdan boshlanib, boshqa raqamdan oldin tugaydigan barcha raqamlarni ketma-ketlikda hosil qiladi.

Ortga hisoblash for sikli va biz hali u to‘g‘risida gapirmagan boshqa metod – rev yordamida diapazonni teskari tomonga o‘zgartirishga o‘xshaydi:

Fayl nomi: src/main.rs

fn main() {
    for raqam in (1..4).rev() {
        println!("{raqam}!");
    }
    println!("LIFTOFF!!!");
}

Bu kod biroz chiroyliroq, shunday emasmi?

Xulosa

Siz erishdingiz! Bu juda katta bob bo'ldi: siz o'zgaruvchilar, skalyar va compound ma'lumotlar turlari, funksiyalar, izohlar, if expressionlari va sikllar haqida bilib oldingiz! Ushbu bobda muhokama qilingan tushunchalar bilan mashq qilish uchun quyidagilarni amalga oshirish uchun dasturlar yaratishga harakat qiling:

• Haroratni Farengeyt va Selsiy o'rtasida o'zgartiring.
• nta Fibonachchi raqamini yarating.
• Qo'shiqning takrorlanishidan foydalanib, “Rojdestvoning o'n ikki kuni“ Rojdestvo qo'shig'ining so'zlarini chop eting.

Davom etishga tayyor bo'lganingizda, Rustda boshqa dasturlash tillarida odatda mavjud bo'lmagan ownership(egalik) tushunchasi haqida gaplashamiz.

Ownershipni tushunish (Egalik)

Ownership Rustning eng noyob xususiyati bo'lib, tilning qolgan qismiga chuqur ta'sir ko'rsatadi. Bu Rust-ga garbage collectorga muhtoj bo'lmasdan xotira xavfsizligini kafolatlash imkonini beradi, shuning uchun ownership qanday ishlashini tushunish muhimdir. Ushbu bobda biz ownership huquqi, shuningdek, bir nechta tegishli xususiyatlar haqida gapiramiz: borrowing, slices va Rust ma'lumotlarni xotirada qanday joylashtirishi.

Ownership Nima?

Ownership(Egalik) bu Rust dasturi xotirani qanday boshqarishini boshqaradigan qoidalar to'plami. Barcha dasturlar ishlayotgan vaqtda kompyuter xotirasidan qanday foydalanishini boshqarishi kerak. Ba'zi tillarda axlat yig'ish(garbage collection) mavjud bo'lib, ular dastur ishlayotgan paytda ishlatilmaydigan xotirani muntazam ravishda qidiradi; boshqa tillarda dasturchi xotirani aniq ajratishi va bo'shatishi kerak. Rust uchinchi yondashuvdan foydalanadi: xotira kompilyator tekshiradigan qoidalar to'plamiga ownership tizimi orqali boshqariladi. Agar biron bir qoidalar buzilgan bo'lsa, dastur kompilatsiya qilinmaydi. Ownership xususiyatlarining hech biri dasturingiz ishlayotgan vaqtda sekinlashtirmaydi.

Ownership ko'plab dasturchilar uchun yangi tushuncha bo'lganligi sababli, unga ko'nikish uchun biroz vaqt kerak bo'ladi. Yaxshi xabar shundaki, siz Rust va ownership tizimi qoidalari bilan qanchalik tajribali bo'lsangiz, xavfsiz va samarali kodni tabiiy ravishda ishlab chiqish osonroq bo'ladi. Unda davom etamiz!

Ownershipni tushunganingizda, Rustni noyob qiladigan xususiyatlarni tushunish uchun mustahkam asosga ega bo'lasiz. Ushbu bobda, siz juda keng tarqalgan ma'lumotlar tuzilishiga qaratilgan ba'zi misollarni orqali ownershipni ishlashini o'rganasiz: string.

Stack va Heap

Ko'pgina dasturlash tillari stack va heap haqida tez-tez o'ylashingizni talab qilmaydi. Ammo Rust kabi tizim dasturlash tilida qiymat stackda yoki heapda bo'ladimi, til o'zini qanday tutishiga ta'sir qiladi va nima uchun siz ma'lum qarorlar qabul qilishingiz kerak. Ownershipning qismlari stack va heapga nisbatan keyinchalik ushbu bobda tasvirlanadi, shuning uchun bu yerda tayyorgarlik jarayonida qisqacha tushuntirish berilgan.

Stack ham, heap ham runtimeda foydalanish uchun kodingiz uchun mavjud bo'lgan xotira qismlaridir, lekin ular turli yo'llar bilan tuzilgan. Stack qiymatlarni ularni olgan tartibda saqlaydi va qiymatlarni teskari tartibda o'chiradi Bu oxirgi kelgan, birinchi chiqqan deb ataladi. Plitalar stackini o'ylab ko'ring: ko'proq plastinka qo'shsangiz, ularni qoziqning ustiga qo'yasiz va plastinka kerak bo'lganda, siz yuqoridan birini olib qo'yasiz. Plitalarni o'rtadan yoki pastdan qo'shish yoki olib tashlash ham ishlamaydi! Ma'lumotlarni qo'shish stackga qo'shish, ma'lumotlarni olib tashlash esa stackdan o'chirish deb ataladi. Stackda saqlangan barcha ma'lumotlar ma'lum, qat'iy belgilangan hajmga ega bo'lishi kerak. Kompilyatsiya vaqtida noma'lum o'lchamli yoki o'zgarishi mumkin bo'lgan o'lchamdagi ma'lumotlar esa heapda saqlanishi kerak.

heap kamroq tartibga solingan: ma'lumotlarni heapga qo'yganingizda, ma'lum miqdorda bo'sh joy talab qilasiz. Xotira ajratuvchisi(memory allocator) heapda yetarlicha katta bo'lgan bo'sh joyni topadi, uni ishlatilayotgan deb belgilaydi va o'sha joyning manzili bo'lgan pointerni ni qaytaradi. Bu jarayon heap allocating deb ataladi va ba'zan faqat allocating deb qisqartiriladi (qiymatlarni stackga qo'shish ajratish hisoblanmaydi). Heapga pointer ma'lum, qat'iy o'lcham bo'lgani uchun siz pointerni stackda saqlashingiz mumkin, lekin yaroqli ma'lumotlarni olishni istasangiz, pointergaga amal qilishingiz kerak. Restoranda o'tirganingizni o'ylab ko'ring. Kirish paytida siz guruhingizdagi odamlar sonini bildirasiz va uy egasi hammaga mos keladigan bo'sh stol topadi va sizni u yerga olib boradi. Agar guruhingizdagi kimdir kechikib kelsa, sizni topish uchun qayerda o'tirganingizni so'rashi mumkin.

stackga qo'shish heapda allocating qilishdan tezroq bo'ladi, chunki allacator hech qachon yangi ma'lumotlarni saqlash uchun joy izlamasligi kerak; bu joy har doim stackning yuqori qismida joylashgan. Nisbatan, heapda bo'sh joy ajratish ko'proq mehnat talab qiladi, chunki allacator avval ma'lumotlarni saqlash uchun yetarlicha katta joy topishi va keyingi allocatinga tayyorgarlik ko'rish uchun buxgalteriya hisobini amalga oshirishi kerak.

Heapdagi ma'lumotlarga kirish stackdagi ma'lumotlarga kirishdan ko'ra sekinroq, chunki u yerga borish uchun pointerga amal qilishingiz kerak. Zamonaviy protsessorlar xotirada kamroq o'tishsa, tezroq ishlaydi. O'xshashlikni davom ettirib, ko'plab jadvallardan buyurtmalarni qabul qiladigan restoran serverini ko'rib chiqing. Keyingi stolga o'tishdan oldin barcha buyurtmalarni bitta stolda olish eng samarali hisoblanadi. A jadvalidan buyurtma olish, keyin B jadvalidan buyurtma olish, keyin yana A dan va yana B dan bitta buyurtma olish ancha sekinroq jarayon bo'ladi. Xuddi shu qoidaga ko'ra, protsessor uzoqroqda emas (u heapda bo'lishi mumkin) emas, balki boshqa ma'lumotlarga yaqin (stackdagi kabi) ma'lumotlarda ishlasa, o'z ishini yaxshiroq bajarishi mumkin.

Sizning kodingiz funksiyani chaqirganda, funksiyaga o'tgan qiymatlar (shu jumladan, potentsial, heapdagi ma'lumotlarga pointerlar) va funksiyaning mahalliy o'zgaruvchilari stackga qo'shiladi. Funktsiya tugagach, bu qiymatlar stackdan chiqariladi.

Kodning qaysi qismlari heapda qaysi ma'lumotlardan foydalanayotganini kuzatib borish, heapdagi takroriy ma'lumotlar miqdorini minimallashtirish va bo'sh joy qolmasligi uchun heapdagi foydalanilmagan ma'lumotlarni tozalash - bularning barchasi ownership hal qiladigan muammolardir. Ownershipni tushunganingizdan so'ng, stack va heap haqida tez-tez o'ylashingiz shart emas, lekin ownership qilishning asosiy maqsadi heap ma'lumotlarni boshqarish ekanligini bilish uning nima uchun shunday ishlashini tushuntirishga yordam beradi.

Ownership qoidalari

Birinchidan, ownership qoidalarini ko'rib chiqaylik.Biz ularni ko'rsatadigan misollar bilan ishlashda ushbu qoidalarni yodda tuting:

• Rust-dagi har bir qiymat ownerga ega.
• Bir vaqtning o'zida faqat bitta owneri bo'lishi mumkin.
• Owneri amaldan tashqariga chiqsa, qiymat o'chiriladi.

O'zgaruvchan Scope

Endi biz Rustning asosiy sintaksisidan o‘tganimiz uchun, biz barcha fn main() { kodini misollarga kiritmaymiz, shuning uchun agar kuzatib boradigan bo‘lsangiz, quyidagi misollarni main funksiyasiga qo‘lda kiritganingizga ishonch hosil qiling. Natijada, bizning misollarimiz biroz ixchamroq bo'ladi, bu bizga boilerplate kodiga emas, balki haqiqiy tafsilotlarga e'tibor berishga imkon beradi.

Ownershipning birinchi misoli sifatida biz ba'zi o'zgaruvchilarning scopeni ko'rib chiqamiz. Scope - dastur doirasidagi element amal qiladigan diapazon. Quyidagi o'zgaruvchini oling:

#![allow(unused)]
fn main() {
let s = "salom";
}

s o'zgaruvchisi satr literaliga ishora qiladi, bu yerda satr qiymati dasturimiz matniga qattiq kodlangan. O'zgaruvchi e'lon qilingan paytdan boshlab joriy scopning oxirigacha amal qiladi. 4-1 ro'yxatida s o'zgaruvchisi qayerda to'g'ri bo'lishini izohlovchi izohlar bilan dastur ko'rsatilgan.

fn main() {
    {                      // s bu erda haqiqiy emas, u hali e'lon qilinmagan
        let s = "salom";   // s shu nuqtadan boshlab amal qiladi

        // s bilan ish bajaring
    }                      // bu scope endi tugadi va s endi haqiqiy emas
}

Ro'yxat 4-1: O'zgaruvchi va uning amal qiladigan doirasi

Boshqacha qilib aytganda, bu yerda ikkita muhim nuqta bor:

• Qachonki s scopega kirsa, u amal qiladi.
• U scopedan tashqariga chiqmaguncha amal qiladi.

Ushbu nuqtada, scopelar va o'zgaruvchilarning yaroqliligi o'rtasidagi munosabatlar boshqa dasturlash tillaridagiga o'xshaydi. Endi biz String turini joriy qilish orqali ushbu tushunchaga asoslanamiz.

String turi

Ownership qoidalarini tasvirlash uchun bizga 3-bobning ”Ma'lumotlar turlari” bo'limida ko'rib chiqilganlarga qaraganda murakkabroq ma'lumotlar turi kerak. Oldin ko'rib chiqilgan turlar ma'lum o'lchamga ega bo'lib, ular stackda saqlanishi va qo'llanilish doirasi tugagach, stackdan o'chirilishi mumkin va agar kodning boshqa qismi foydalanishi kerak bo'lsa yangi, mustaqil misol yaratish uchun tez va ahamiyatsiz nusxa ko'chirilishi mumkin kodning boshqa qismi bir xil qiymatni boshqa doirada ishlatishi kerak. Ammo biz heapda saqlangan ma'lumotlarni ko'rib chiqmoqchimiz va Rust bu ma'lumotlarni qachon tozalashni bilishini o'rganmoqchimiz va String turi ajoyib misoldir.

Biz String ning ownership bilan bog'liq qismlariga e'tibor qaratamiz. Ushbu jihatlar standart kutubxona tomonidan taqdim etilganmi yoki siz yaratganmi, boshqa murakkab ma'lumotlar turlariga ham tegishli. Biz 8-bobda Stringni chuqurroq muhokama qilamiz.

Biz allaqachon string literallarini ko'rdik, bu yerda string qiymati bizning dasturimizga qattiq kodlangan. String literallari qulay, ammo ular biz matndan foydalanmoqchi bo'lgan har qanday vaziyatga mos kelmaydi. Buning sabablaridan biri shundaki, ular o'zgarmasdir. Yana bir narsa shundaki, biz kodni yozganimizda har bir satr qiymatini bilish mumkin emas: masalan, agar biz foydalanuvchi ma'lumotlarini olib, uni saqlamoqchi bo'lsak-chi? Bunday holatlar uchun Rust ikkinchi string turiga ega, String. Bu tur heapda ajratilgan ma'lumotlarni boshqaradi va shuning uchun kompilyatsiya vaqtida bizga noma'lum bo'lgan matn miqdorini saqlashi mumkin. Siz from funksiyasidan foydalanib satr literalidan String yaratishingiz mumkin, masalan:

#![allow(unused)]
fn main() {
let s = String::from("salom");
}

Ikki nuqtali :: operatori bizga string_from kabi qandaydir nomdan foydalanish o'rniga String turi ostida ushbu from funksiyasini nom maydoniga qo`yish imkonini beradi. Biz ushbu sintaksisni 5-bobning ”Metod sintaksisi” bo'limida ko'proq muhokama qilamiz va 7-bobdagi ”Modul treedagi elementga murojaat qilish yo'llari” da modullar bilan nomlar oralig'i haqida gapiramiz.

Ushbu turdagi string mutatsiyaga uchragan bo'lishi mumkin:

fn main() {
    let mut s = String::from("salom");

    s.push_str(", dunyo!"); // push_str() satrga literal qo'shadi

    println!("{}", s); // Bu “salom, dunyo!” deb chop etiladi
}

Xo'sh, bu yerda qanday farq bor? Nima uchun String ni mutatsiyaga solish mumkin, lekin harflarni o'zgartirish mumkin emas? Farqi bu ikki turning xotira bilan qanday munosabatda bo'lishida.

Xotira va Taqsimlash(Allocation)

String literalida biz kompilyatsiya vaqtida tarkibni bilamiz, shuning uchun matn to'g'ridan-to'g'ri yakuniy bajariladigan faylga qattiq kodlangan.Shuning uchun string literallari tez va samarali. Ammo bu xususiyatlar faqat satr literalining o'zgarmasligidan kelib chiqadi. Afsuski, kompilyatsiya vaqtida hajmi noma'lum bo'lgan va dasturni ishga tushirishda hajmi o'zgarishi mumkin bo'lgan har bir matn bo'lagi uchun biz binary faylga bir bo'lak xotira qo'ya olmaymiz.

String turida o'zgaruvchan, o'sib boradigan matn qismini qo'llab-quvvatlash uchun tarkibni saqlash uchun kompilyatsiya vaqtida noma'lum bo'lgan xotira hajmini yig'ishda ajratishimiz kerak. Buning ma'nosi:

• Xotira runtimeda xotira allactoridan so'ralishi kerak.
• String bilan ishlashni tugatgandan so'ng, bizga ushbu xotirani allacatoriga qaytarish usuli kerak.

Bu birinchi qism biz tomonimizdan amalga oshiriladi: biz String::from deb chaqirganimizda, uni implementi kerakli xotirani talab qiladi. Bu dasturlash tillarida deyarli universaldir.

Biroq, ikkinchi qism boshqacha. Garbage Collector (GC) bo'lgan tillarda GC endi ishlatilmayotgan xotirani kuzatib boradi va tozalaydi va bu haqda o'ylashimiz shart emas. Ko'pgina tillarda GC bo'lmaganda, xotiradan qachon foydalanilmayotganini aniqlash va uni aniq bo'shatish uchun kodni chaqirish, xuddi biz so'raganimizdek, bizning burchimizdir. Buni to'g'ri bajarish tarixan qiyin dasturlash muammosi bo'lgan. Agar unutsak, xotirani behuda sarflaymiz. Agar biz buni juda erta qilsak, bizda noto'g'ri o'zgaruvchi bo'ladi. Agar buni ikki marta qilsak, bu ham xato. Aynan bitta allocateni bitta bo'sh bilan birlashtirishimiz kerak.

Rust boshqa yo'lni egallaydi: unga ega bo'lgan o'zgaruvchi amaldan tashqariga chiqqandan so'ng xotira avtomatik ravishda qaytariladi. Bu yerda 4-1 roʻyxatdagi misolimiz satr harfi oʻrniga String yordamida berilgan:

fn main() {
    {
        let s = String::from("salom"); // s shu nuqtadan boshlab amal qiladi

        // s bilan ish bajaring
    }                                  // bu scope endi tugadi va s yo'q
                                       // uzoqroq amal qiladi
}

Biz String kerak bo'lgan xotirani ajratuvchiga qaytarishimiz mumkin bo'lgan tabiiy nuqta bor: s scopedan chiqib ketganda. O'zgaruvchi scopedan chiqib ketganda, Rust biz uchun maxsus funksiyani chaqiradi.Ushbu funktsiya drop deb ataladi va u yerda String muallifi xotirani qaytarish uchun kodni qo'yishi mumkin. Rust yopilgan jingalak qavsda avtomatik ravishda drop ni chaqiradi.

Eslatma: C++ da, elementning ishlash muddati oxirida resurslarni taqsimlashning bunday sxemasi ba'zan Resource Acquisition Is Initialization (RAII)(Resurslarni yig'ish - ishga tushirish (RAII) deb ataladi. Agar siz RAII patternlaridan foydalangan bo'lsangiz, Rust-dagi drop funksiyasi sizga tanish bo'ladi.

Ushbu pattern Rust kodini yozish usuliga chuqur ta'sir qiladi. Bu hozir oddiy bo'lib tuyulishi mumkin, ammo biz bir nechta o'zgaruvchilar biz yig'ilgan ma'lumotlardan foydalanishni xohlayotganimizda, murakkabroq holatlarda kodning harakati kutilmagan bo'lishi mumkin. Keling, ushbu vaziyatlarning ba'zilarini ko'rib chiqaylik.

Move bilan o'zaro ta'sir qiluvchi o'zgaruvchilar va ma'lumotlar

Rustda bir nechta o'zgaruvchilar bir xil ma'lumotlar bilan turli yo'llar bilan o'zaro ta'sir qilishi mumkin. 4-2 ro'yxatda integer sondan foydalanish misolini ko'rib chiqaylik.

fn main() {
    let x = 5;
    let y = x;
}

4-2 roʻyxat: x oʻzgaruvchisining butun qiymatini y ga belgilash

Bu nima qilayotganini taxmin qilishimiz mumkin: 5 qiymatini x ga bog‘lang; keyin x dagi qiymatdan nusxa oling va uni y ga bog'lang. Endi bizda ikkita o'zgaruvchi bor, x va y va ikkalasi ham 5 ga teng. Bu haqiqatan ham sodir bo'lmoqda, chunki butun sonlar ma'lum, qat'iy o'lchamga ega oddiy qiymatlardir va bu ikkita 5 qiymat stackga qo'shiladi.

Endi String versiyasini ko'rib chiqamiz:

fn main() {
    let s1 = String::from("salom");
    let s2 = s1;
}

Bu juda o'xshash ko'rinadi, shuning uchun biz uning ishlash metodi bir xil bo'ladi deb taxmin qilishimiz mumkin: ya'ni ikkinchi qator s1 qiymatining nusxasini yaratadi va uni s2 bilan bog'laydi. Ammo bu sodir bo'ladigan narsa emas.

Qopqoq ostidagi String bilan nima sodir bo'layotganini ko'rish uchun 4-1-rasmga qarang. String chap tomonda ko'rsatilgan uchta qismdan iborat: satr tarkibini saqlaydigan xotiraga ko'rsatgich, uzunlik(len) va sig'im(capacity). Ushbu ma'lumotlar guruhi stackda saqlanadi. O'ng tomonda tarkibni saqlaydigan heap xotira joylashgan.

4-1-rasm: s1 ga bog‘langan salom qiymatiga ega String xotirasidagi tasvir

Uzunlik - String mazmuni hozirda qancha xotira, baytlarda foydalanayotganligi. Sig'im(capacity) - bu String allacatordan olgan xotiraning umumiy hajmi, baytlarda. Uzunlik va si'gimlar o'rtasidagi farq muhim, ammo bu kontekstda emas, shuning uchun hozircha si'gimlarni e'tiborsiz qoldirish yaxshi.

s1 ni s2 ga belgilaganimizda, String ma'lumotlari nusxalanadi, ya'ni biz stackdagi pointer, uzunlik va sig`imdan nusxa olamiz. Biz pointer(ko'rsatkich) ko'rsatgan to'plamdagi ma'lumotlarni ko'chirmaymiz. Boshqacha qilib aytganda, ma'lumotlarning xotirada ko'rinishi 4-2-rasmga o'xshaydi.

4-2-rasm: s1 pointeri, uzunligi va sigʻimi nusxasiga ega s2 oʻzgaruvchisi xotirasida koʻrsatilishi

Tasvir 4-3-rasmga o'xshamaydi, agar Rust o'rniga heap ma'lumotlarni ko'chirsa, xotira qanday ko'rinishga ega bo'lardi. Agar Rust buni amalga oshirgan bo'lsa, s2 = s1 operatsiyasi, agar heapdagi ma'lumotlar katta bo'lsa, runtimening ishlashi nuqtai nazaridan juda qimmat bo'lishi mumkin.

4-3-rasm: Rust heap ma'lumotlarni ham nusxalagan bo'lsa, s2 = s1 nima qilishi mumkin bo'lgan yana bir imkoniyat

Avvalroq biz aytgan edikki, o‘zgaruvchi qo‘llanish doirasidan chiqib ketganda, Rust avtomatik ravishda drop funksiyasini chaqiradi va bu o‘zgaruvchi uchun heap xotirani tozalaydi. Ammo 4-2-rasmda ikkala ma'lumot pointeri bir xil joyga ishora qiladi. Bu muammo: s2 va s1 scopedan chiqib ketganda, ikkalasi ham bir xil xotirani bo'shatishga harakat qiladi. Bu double free(ikki marta bo'sh)xato sifatida tanilgan va biz avval aytib o'tgan xotira xavfsizligi xatolaridan biridir. Xotirani ikki marta bo'shatish xotira buzilishiga olib kelishi mumkin, bu esa xavfsizlik zaifliklariga olib kelishi mumkin.

Xotira xavfsizligini ta'minlash uchun let s2 = s1; qatoridan keyin Rust s1 ni endi yaroqsiz deb hisoblaydi. Shuning uchun, s1 qo'llanilgandan tashqariga chiqqanda Rust hech narsani bo'shatishi shart emas. s2 yaratilgandan keyin s1 dan foydalanmoqchi bo'lganingizda nima sodir bo`lishini tekshiring; u ishlamaydi:

fn main() {
    let s1 = String::from("salom");
    let s2 = s1;

    println!("{}, dunyo!", s1);
}

Siz shunday xatoga yo'l qo'yasiz, chunki Rust bekor qilingan havoladan foydalanishga to'sqinlik qiladi:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:28
  |
2 |     let s1 = String::from("salom");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 | 
5 |     println!("{}, dunyo!", s1);
  |                            ^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let s2 = s1.clone();
  |                ++++++++

For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` due to previous error

Agar siz boshqa tillar bilan ishlashda shallow copy va deep copy so‘zlarini eshitgan bo‘lsangiz, pointerni nusxalash tushunchasi, ma'lumotlardan nusxa ko'chirmasdan uzunligi va sig'imi olish, ehtimol shallow copy kabi eshitiladi. Ammo Rust birinchi o'zgaruvchini ham bekor qilganligi sababli, shallow copy deb nomlanish o'rniga u move(ko'chirish) deb nomlanadi. Bu misolda s1 s2 ga ko'chirilgan deb aytamiz. Shunday qilib, aslida nima sodir bo'lishi 4-4-rasmda ko'rsatilgan.

4-4-rasm: s1 dan keyin xotiradagi ko`rinish bekor qilingan

Bu bizning muammomizni hal qiladi! Faqatgina s2 amal qilganda, u scopedan tashqariga chiqsa, u faqat xotirani bo'shatadi va biz tugatdik.

Bundan tashqari, dizayn tanlovi ham mavjud: Rust hech qachon avtomatik ravishda ma'lumotlaringizning "deep copyni" yaratmaydi. Shuning uchun, har qanday avtomatik nusxa ko'chirish runtimening ishlashi nuqtai nazaridan arzon deb taxmin qilish mumkin.

Clone bilan o'zaro ta'sir qiluvchi o'zgaruvchilar va ma'lumotlar

Agar biz faqat stack ma'lumotlarini emas, balki String ning heap ma'lumotlarini deeply copyni istasak, clone deb nomlangan umumiy metoddan foydalanishimiz mumkin. Metod sintaksisini 5-bobda muhokama qilamiz, lekin metodlar ko‘p dasturlash tillarida umumiy xususiyat bo‘lgani uchun siz ularni avval ko‘rgan bo‘lsangiz kerak.

Mana amaldagi clone metodiga misol:

fn main() {
    let s1 = String::from("salom");
    let s2 = s1.clone();

    println!("s1 = {}, s2 = {}", s1, s2);
}

Bu juda yaxshi ishlaydi va 4-3-rasmda ko'rsatilgan xatti-harakatni aniq ishlab chiqaradi, bu yerda heap ma'lumotlar nusxalanadi.

clone ga murojatni ko'rsangiz, ba'zi bir ixtiyoriy kod bajarilayotganini va bu kod qimmat bo'lishi mumkinligini bilasiz. Bu boshqa narsa sodir bo'layotganining vizual ko'rsatkichidir.

Faqat stack ma'lumotlari: nusxalash

Biz hali gapirmagan yana bir narsa bor. Integer sonlardan foydalanadigan ushbu kod - bir qismi 4-2 ro'yxatda ko'rsatilgan - ishlaydi va amal qiladi:

fn main() {
    let x = 5;
    let y = x;

    println!("x = {}, y = {}", x, y);
}

Ammo bu kod biz bilib olgan narsaga zid ko'rinadi: bizda clone uchun murojat yo'q, lekin x hali ham amal qiladi va y ga o'tkazilmagan.

Sababi, kompilyatsiya vaqtida ma'lum o'lchamga ega bo'lgan integer sonlar kabi turlar to'liq stackda saqlanadi, shuning uchun haqiqiy qiymatlarning nusxalari tezda tayyorlanadi. Bu shuni anglatadiki, biz y o'zgaruvchisini yaratganimizdan keyin x ning haqiqiy bo'lishiga to'sqinlik qilish uchun hech qanday sabab yo'q. Boshqacha qilib aytadigan bo'lsak, bu yerda deep va shallow nusxa ko'chirish o'rtasida farq yo'q, shuning uchun clone ni chaqirish odatdagi shallow copydan farq qilmaydi va biz uni tark etishimiz mumkin.

Rust Copy traiti deb nomlangan maxsus annotationga ega bo'lib, uni butun sonlar kabi stackda saqlanadigan turlarga joylashtirishimiz mumkin (biz 10-bobda traitlar haqida ko'proq gaplashamiz). Agar tur Copy traitini amalga oshirsa, undan foydalanadigan o‘zgaruvchilar harakatlanmaydi, aksincha, ahamiyatsiz tarzda ko‘chiriladi, bu esa boshqa o‘zgaruvchiga tayinlangandan keyin ham amal qiladi.

Rust turi yoki uning biron bir qismi Drop traitini qo‘llagan bo‘lsa, Copy bilan turga annotation qo‘yishimizga ruxsat bermaydi. Qiymat doirasidan chiqib ketganda turga maxsus biror narsa kerak bo'lsa va biz ushbu turga Copy annotationni qo'shsak, biz kompilyatsiya vaqtida xatolikni olamiz. Traitni amalga oshirish uchun turingizga Copy annotationni qanday qo‘shish haqida bilish uchun C ilovasidagi “Derivable Traitlar”ga qarang.

Xo'sh, Copy traitini qaysi turlar amalga oshiradi? Ishonch hosil qilish uchun berilgan tur uchun texnik hujjatlarni tekshirishingiz mumkin, lekin umumiy qoida sifatida har qanday oddiy skalyar qiymatlar guruhi Copy ni amalga oshirishi mumkin va ajratishni talab qiladigan yoki biron bir manba shakli bo‘lgan hech narsa Copy ni amalga oshira olmaydi. Copy ni amalga oshiradigan ba'zi turlar:

• u32 kabi barcha integer turlari.
• Boolean turi, bool, true va false qiymatlari bilan.
• Barcha floating-point turlari, masalan, f64.
• Belgi turi, char.
• Tuplelar, agar ular faqat Copy ni ham implement qiladigan turlarni o'z ichiga olsa. Masalan, (i32, i32) Copy ni implement qiladi, lekin (i32, String) bajarmaydi.

Ownership va Funksiyalar

Funksiyaga qiymat berish mexanikasi o'zgaruvchiga qiymat berish mexanikasiga o'xshaydi. O'zgaruvchini funksiyaga o'tkazish, xuddi assignment kabi ko'chiriladi yoki nusxalanadi. 4-3 ro'yxatda o'zgaruvchilarning qayerga kirishi va tashqariga chiqishini ko'rsatadigan ba'zi izohlar bilan misol mavjud.

Fayl nomi: src/main.rs

fn main() {
    let s = String::from("salom");  // s scopega kiradi

    ownershiplik_qiladi(s);             // s qiymati funksiyaga o'tadi ...
                                    // ... va shuning uchun bu yerda endi amal qilmaydi

    let x = 5;                      // x scopega kiradi

    nusxasini_yaratadi(x);                  // x funksiyaga o'tadi,
                                    // lekin i32 nusxa ko'chirish, shuning uchun tinch qo'yish yaxshidir
                                    // keyin x dan foydalaning

} // Bu erda x scopedan chiqib ketadi, keyin s. Lekin s qiymati ko'chirilganligi sababli, hech
  // qanday maxsus narsa sodir bo'lmaydi.

fn ownershiplik_qiladi(some_string: String) { // some_string scopega kiradi
    println!("{}", some_string);
} // Bu yerda some_string scopedan chiqib ketadi va `drop` deb ataladi. Qo'llab-quvvatlovchi
  // xotira bo'shatiladi.

fn nusxasini_yaratadi(some_integer: i32) { // some_integer scopega kiradi
    println!("{}", some_integer);
} // Bu erda some_integer scopedan tashqariga chiqadi. Hech qanday maxsus narsa bo'lmaydi.

Ro'yxat 4-3: ownership va scope izohlangan funksiyalar

Agar biz ownershiplik_qiladi chaqiruvidan keyin s dan foydalanmoqchi bo'lsak, Rust kompilyatsiya vaqtida xatolikka yo'l qo'yadi. Ushbu statik tekshiruvlar bizni xatolardan himoya qiladi. s va x dan foydalanadigan main ga kod qo‘shib ko‘ring va ulardan qayerda foydalanishingiz mumkinligini va ownership qoidalari bunga xalaqit beradigan joyni ko‘ring.

Return qiymatlari va Scope

Return qilingan qiymatlar ownershipni ham o'tkazishi mumkin. 4-4 ro'yxatda 4-3 ro'yxatdagi kabi izohlar bilan ba'zi qiymatlarni qaytaradigan funksiya misoli ko'rsatilgan.

Fayl nomi: src/main.rs

fn main() {
    let s1 = egalik_beradi();         // egalik_beradi o'zining return qiymatini
                                        // s1 ga o'tkazadi

    let s2 = String::from("salom");     // s2 scopega kiradi

    let s3 = oladi_va_qaytaradi(s2);  // s2 oladi_va_qaytaradi ichiga 
                                        // ko'chiriladi, u ham o'zining return
                                        // qiymatini s3 ga o'tkazadi
} // Bu erda s3 scopedan chiqib ketadi va o'chiriladi. s2 ko'chirildi, shuning uchun
  // hech narsa sodir bo'lmaydi. s1 scopedan chiqib ketadi va o'chiriladi.

fn egalik_beradi() -> String {             // egalik_beradi o'zining return
                                             // qiymatini uni chaqiradigan
                                             // funksiyaga o'tkazadi

    let some_string = String::from("rust"); // some_string scopea kiradi

    some_string                              // some_string return qilinadi va
                                             // chaqiruv funksiyasiga 
                                             // o'tadi
}

// Bu funksiya Stringni oladi va bittasini qaytaradi
fn oladi_va_qaytaradi(a_string: String) -> String { // a_string scopega 
                                                      // kiradi

    a_string  // a_string qaytariladi va chaqiruv funksiyasiga o'tadi
}

Ro'yxat 4-4: Return ownershipni o'tkazish qiymatlar

O'zgaruvchiga ownership har safar bir xil patternga amal qiladi: boshqa o'zgaruvchiga qiymat berish uni ko'chiradi. Heapdagi maʼlumotlarni oʻz ichiga olgan oʻzgaruvchi scopedan tashqariga chiqsa, agar maʼlumotlarga ownership boshqa oʻzgaruvchiga oʻtkazilmagan boʻlsa, qiymat drop orqali tozalanadi.

Bu ishlayotganda, ownership va keyin har bir funksiyaga ownershipini qaytarish biroz zerikarli. Agar funksiyaga qiymatdan foydalanishiga ruxsat bermoqchi bo'lsak, lekin ownershiplik qilmasak nima bo'ladi? Bu juda zerikarli, agar biz uni qayta ishlatmoqchi bo'lsak, biz kiritgan har qanday narsa, shuningdek, biz qaytarishni xohlashimiz mumkin bo'lgan funktsiya tanasidan kelib chiqadigan har qanday ma'lumotlarga qo'shimcha ravishda qaytarib berilishi kerak.

Rust 4-5 ro'yxatda ko'rsatilganidek, tuple yordamida bir nechta qiymatlarni return qilish imkon beradi.

Fayl nomi: src/main.rs

fn main() {
    let s1 = String::from("salom");

    let (s2, len) = uzunlikni_hisoblash(s1);

    println!("'{}' uzunligi {}.", s2, len);
}

fn uzunlikni_hisoblash(s: String) -> (String, usize) {
    let length = s.len(); // len() string uzunligini qaytaradi

    (s, length)
}

Ro'yxat 4-5: Parametrlarga ownershipni qaytarish

Ammo bu umumiy bo'lishi kerak bo'lgan kontseptsiya uchun juda ko'p funksiya va juda ko'p ish. Yaxshiyamki, Rustda qiymatni ownershipni o'tkazmasdan ishlatish xususiyati mavjud, uni reference deb atashadi.

Reference va Borrowing

Ro'yxat 4-5dagi tuple kodi bilan bog'liq muammo shundaki, biz String ni chaqiruvchi funksiyaga qaytarishimiz kerak, shunda biz uzunlikni_hisoblash ga chaqiruvdan keyin ham String dan foydalanishimiz mumkin, chunki String uzunlikni_hisoblash ga ko'chirildi. Buning o'rniga biz String qiymatiga reference(havola) berishimiz mumkin.

Reference pointerga o'xshaydi, chunki u biz ushbu manzilda saqlangan ma'lumotlarga kirish uchun amal qilishimiz mumkin bo'lgan manzildir; bu ma'lumotlar boshqa o'zgaruvchilarga tegishli. Pointerdan farqli o'laroq, reference ma'lumotnomaning amal qilish muddati davomida ma'lum turdagi yaroqli qiymatni ko'rsatishi kafolatlanadi.

Qiymatga egalik qilish o'rniga parametr sifatida obyektga referencega ega bo'lgan uzunlikni_hisoblash funksiyasini qanday aniqlash va ishlatishingiz mumkin:

Fayl nomi: src/main.rs

fn main() {
    let s1 = String::from("salom");

    let len = uzunlikni_hisoblash(&s1);

    println!("'{}' uzunligi {}.", s1, len);
}

fn uzunlikni_hisoblash(s: &String) -> usize {
    s.len()
}

Birinchidan, o'zgaruvchilar deklaratsiyasidagi barcha tuple kodi va funksiyani qaytarish qiymati yo'qolganiga e'tibor bering. Ikkinchidan, &s1 ni uzunlikni_hisoblash ga o'tkazamiz va uning definitionida biz String emas, &Stringni olamiz. Ushbu ampersandlar reference ni ifodalaydi va ular sizga biron bir qiymatga ownershiplik qilmasdan murojaat qilish imkonini beradi. 4-5-rasmda ushbu tushuncha tasvirlangan.

4-5-rasm: &String s chizmasi String s1ga ishora qiladi

Eslatma: & yordamida reference qilishning teskarisi dereferencing bo'lib, u * dereference operatori yordamida amalga oshiriladi. Biz 8-bobda dereference operatoridan baʼzi foydalanishni koʻrib chiqamiz va 15-bobda dereference tafsilotlarini muhokama qilamiz.

Keling, bu yerda funksiya chaqiruvini batafsil ko'rib chiqaylik:

fn main() {
    let s1 = String::from("salom");

    let len = uzunlikni_hisoblash(&s1);

    println!("'{}' uzunligi {}.", s1, len);
}

fn uzunlikni_hisoblash(s: &String) -> usize {
    s.len()
}

&s1 sintaksisi bizga s1 qiymatiga refers qiluvchi, lekin unga tegishli bo`lmagan reference yaratish imkonini beradi. Unga egalik qilmaganligi sababli, reference foydalanishni to'xtatganda, u ko'rsatgan qiymat o'chirilmaydi.

Xuddi shunday, funksiya imzosi s parametrining turi reference ekanligini ko'rsatish uchun & dan foydalanadi. Keling, ba'zi tushuntirish izohlarini qo'shamiz:

fn main() {
    let s1 = String::from("salom");

    let len = uzunlikni_hisoblash(&s1);

    println!("'{}' uzunligi {}.", s1, len);
}

fn uzunlikni_hisoblash(s: &String) -> usize { // s - Stringga reference(havola)
    s.len()
} // Bu yerda s scopedan chiqib ketadi. Lekin u nazarda tutgan itemga ownership qilmagani
  // uchun u tashlanmaydi.

s o'zgaruvchisi amal qiladigan doirasi har qanday funksiya parametrining qamrovi bilan bir xil bo'ladi, lekin s foydalanishni to'xtatganda reference ko'rsatilgan qiymat o'chirilmaydi, chunki s ownershipga ega emas. Funksiya referencelarni yaroqli qiymatlar o'rniga parametr sifatida ko'rsatsa, biz ownershipni qaytarish uchun qiymatlarni qaytarishimiz shart emas, chunki bizda hech qachon ownership bo'lmagan.

Malumot yaratish harakatini borrowing(qarz olish) deb ataymiz. Haqiqiy hayotda bo'lgani kabi, agar biror kishi biror narsaga ega bo'lsa, siz undan qarz olishingiz mumkin. Ishingiz tugagach, uni qaytarib berishingiz kerak. Siz unga egalik qilmaysiz.

Xo'sh, agar biz borrowing qilgan narsani o'zgartirishga harakat qilsak nima bo'ladi? 4-6 ro'yxatdagi kodni sinab ko'ring. Spoiler ogohlantirish: bu ishlamaydi!

Fayl nomi: src/main.rs

fn main() {
    let s = String::from("salom");

    almashtirish(&s);
}

fn almashtirish(some_string: &String) {
    some_string.push_str(", rust");
}

Ro'yxat 4-6: Borrow qilingan qiymatni o'zgartirishga urinish

Mana xato:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
7 | fn almashtirish(some_string: &String) {
  |                        ------- help: consider changing this to be a mutable reference: `&mut String`
8 |     some_string.push_str(", rust");
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` due to previous error

O'zgaruvchilar standart bo'yicha o'zgarmas bo'lganidek, referencelar ham shunday. Bizga reference biror narsani o'zgartirishga ruxsat berilmagan.

O'zgaruvchan Referencelar

Biz 4-6 ro'yxatdagi kodni tuzatishimiz mumkin, buning o'rniga o'zgaruvchan referencedan foydalanadigan bir nechta kichik sozlashlar bilan borrow qilingan qiymatni o'zgartirishimiz mumkin:

Fayl nomi: src/main.rs

fn main() {
    let mut s = String::from("salom");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", dunyo");
}

Avval s ni mut qilib o'zgartiramiz. Keyin biz &mut s bilan o'zgaruvchan reference yaratamiz, bu yerda biz change funksiyasini chaqiramiz va some_string: &mut String bilan o'zgaruvchan referencei qabul qilish uchun funksiya signatureni yangilaymiz. Bu change funksiyasi olingan qiymatni o'zgartirishini aniq ko'rsatadi.

O'zgaruvchan referencelar bitta katta cheklovga ega: agar sizda qiymatga o'zgaruvchan reference bo'lsa, sizda bu qiymatga boshqa referencelar bo'lishi mumkin emas. s ga ikkita o'zgaruvchan reference yaratishga urinayotgan ushbu kod muvaffaqiyatsiz bo'ladi:

Fayl nomi: src/main.rs

fn main() {
    let mut s = String::from("salom");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{}, {}", r1, r2);
}

Mana xato:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error

Bu xatolik bu kodning yaroqsiz ekanligini bildiradi, chunki biz bir vaqtning o'zida bir necha marta o'zgaruvchan s ni borrow qila ololmaymiz. Birinchi o'zgaruvchan borrow r1 da bo'lib, u println! da ishlatilgunga qadar davom etishi kerak, lekin bu o'zgaruvchan referenceni yaratish va undan foydalanish o'rtasida, biz r2 da r1 bilan bir xil ma'lumotlarni olgan boshqa o`zgaruvchan reference yaratishga harakat qildik.

Bir vaqtning o'zida bir xil ma'lumotlarga bir nechta o'zgaruvchan referencelarni oldini oluvchi cheklov mutatsiyaga imkon beradi, lekin juda nazorat ostida. Bu yangi Rustaceanlar bilan kurashadigan narsa, chunki aksariyat tillar xohlagan vaqtda mutatsiyaga o'tishga imkon beradi. Ushbu cheklovning afzalligi shundaki, Rust kompilyatsiya vaqtida data raceni oldini oladi. Data race poyga holatiga o'xshaydi va bu uchta xatti-harakatlar sodir bo'lganda sodir bo'ladi:

• Ikki yoki undan ortiq pointerlar bir vaqtning o'zida bir xil ma'lumotlarga kirishadi.
• Pointerlardan kamida bittasi ma'lumotlarga yozish uchun ishlatiladi.
• Ma'lumotlarga kirishni sinxronlashtirish uchun hech qanday mexanizm ishlatilmaydi.

Data race aniqlanmagan xatti-harakatlarga olib keladi va ularni runtimeda kuzatib borishga harakat qilayotganingizda tashxis qo'yish va tuzatish qiyin bo'lishi mumkin; Rust data racelari bilan kodni kompilyatsiya qilishni rad etish orqali bu muammoni oldini oladi!

Har doimgidek, biz bir vaqtning o'zida emas, balki bir nechta o'zgaruvchan referencelarga ruxsat beruvchi yangi scope yaratish uchun jingalak qavslardan foydalanishimiz mumkin:

fn main() {
    let mut s = String::from("salom");

    {
        let r1 = &mut s;
    } // r1 bu yerda scopedan chiqib ketadi, shuning uchun biz hech 
    //qanday muammosiz yangi reference qilishimiz mumkin.

    let r2 = &mut s;
}

Rust o'zgaruvchan va o'zgarmas referencelarni birlashtirish uchun shunga o'xshash qoidani qo'llaydi.

fn main() {
    let mut s = String::from("salom");

    let r1 = &s; // muammo yo'q
    let r2 = &s; // muammo yo'q
    let r3 = &mut s; // KATTA MUAMMO

    println!("{}, {}, va {}", r1, r2, r3);
}

Mana xato:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &s; // muammo yo'q
  |              -- immutable borrow occurs here
5 |     let r2 = &s; // muammo yo'q
6 |     let r3 = &mut s; // KATTA MUAMMO
  |              ^^^^^^ mutable borrow occurs here
7 |
8 |     println!("{}, {}, va {}", r1, r2, r3);
  |                                -- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error

Voy! Bizda shuningdek o'zgaruvchan referencelar bo'lishi mumkin emas, bizda bir xil qiymatga o'zgarmas reference mavjud.

O'zgarmas reference foydalanuvchilari qiymat birdaniga ularning ostidan o'zgarishini kutishmaydi! Biroq, bir nechta o'zgarmas referencelarga ruxsat beriladi, chunki faqat ma'lumotlarni o'qiyotgan hech kim boshqa hech kimning ma'lumotni o'qishiga ta'sir qilish qobiliyatiga ega emas.

E'tibor bering, referencening ko'lami u kiritilgan joydan boshlanadi va oxirgi ishlatilgan vaqtgacha davom etadi. Masalan, ushbu kod kompilyatsiya qilinadi, chunki o'zgarmas referencelarning oxirgi ishlatilishi, println!, o'zgaruvchan reference kiritilishidan oldin sodir bo'ladi:

fn main() {
    let mut s = String::from("salom");

    let r1 = &s; // muammo yo'q
    let r2 = &s; // muammo yo'q
    println!("{} va {}", r1, r2);
    // r1 va r2 o'zgaruvchilari bu nuqtadan keyin ishlatilmaydi

    let r3 = &mut s; // muammo yo'q
    println!("{}", r3);
}

r1 va r2 o'zgarmas referencelar doirasi println dan keyin tugaydi! ular oxirgi marta ishlatiladigan joy, ya'ni o'zgaruvchan referencelar r3 yaratilishidan oldin. Ushbu doiralar bir-biriga mos kelmaydi, shuning uchun bu kodga ruxsat beriladi: kompilyator reference doirasi tugashidan bir nuqtada endi foydalanilmayotganini aytishi mumkin.

Borrowingdagi xatolar ba'zida asabiylashsa ham, Rust kompilyatori potentsial xatoni erta (runtimeda emas, balki kompilyatsiya vaqtida) ko'rsatib beradi va muammo qayerda ekanligini aniq ko'rsatadi. Keyin nima uchun ma'lumotlaringiz siz o'ylagandek emasligini kuzatishingiz shart emas.

Dangling Referencelar

Pointerlari bo'lgan tillarda, dangling pointerni - xotiradagi boshqa birovga berilgan bo'lishi mumkin bo'lgan joyga reference qiluvchi pointerni - bu xotiraga pointerni saqlab qolgan holda, xotirani biroz bo'shatish orqali yaratish oson. Rust-da, aksincha, kompilyator referencelar hech qachon dangling referencelar bo'lmasligini kafolatlaydi: agar sizda ba'zi ma'lumotlarga reference bo'lsa, kompilyator ma'lumotlarga referencedan oldin ma'lumotlar doirasi tashqariga chiqmasligini ta'minlaydi.

Keling, Rust ularni kompilyatsiya vaqtida xatosi bilan qanday oldini olishini ko'rish uchun dangling reference yaratishga harakat qilaylik:

Fayl nomi: src/main.rs

fn main() {
    let dangle_reference = dangle();
}

fn dangle() -> &String {
    let s = String::from("salom");

    &s
}

Mana xato:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
  |
5 | fn dangle() -> &'static String {
  |                 +++++++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error

Ushbu xato xabari biz hali ko'rib chiqmagan xususiyatga ishora qiladi: lifetime. Biz 10-bobda lifetime batafsil muhokama qilamiz. Ammo, agar siz lifetime haqidagi qismlarga e'tibor bermasangiz, xabarda ushbu kod nima uchun muammo ekanligining kaliti mavjud:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from

Keling, dangle kodimizning har bir bosqichida nima sodir bo'layotganini batafsil ko'rib chiqaylik:

Fayl nomi: src/main.rs

fn main() {
    let dangle_reference = dangle();
}

fn dangle() -> &String { // dangle Stringga referencei qaytaradi

    let s = String::from("salom"); // s - yangi String

    &s // biz Stringga referenceni return qilamiz, s
} // Bu yerda s scopedan chiqib ketadi va drop qilinadi. Uning xotirasi yo'qoladi.
  // Xavf!

s dangle ichida yaratilganligi sababli, dangle kodi tugagach, s ajratiladi. Ammo biz unga referenceni qaytarishga harakat qildik. Bu shuni anglatadiki, bu reference yaroqsiz Stringga ishora qiladi. Bu yaxshi emas! Rust bizga buni qilishga ruxsat bermaydi.

Bu yerda yechim to'g'ridan-to'g'ri String ni return qilishdir:

fn main() {
    let string = dangle_yoq();
}

fn dangle_yoq() -> String {
    let s = String::from("salom");

    s
}

Bu hech qanday muammosiz ishlaydi. Ownership boshqa joyga ko'chiriladi va hech narsa ajratilmaydi.

Reference Qoidalari

Keling, referencelar haqida nimalarni muhokama qilganimizni takrorlaymiz:

• Istalgan vaqtda siz yoki bitta oʻzgaruvchan referencega yoki istalgan miqdordagi oʻzgarmas referencelarga ega boʻlishingiz mumkin.
• Referencelar har doim yaroqli bo'lishi kerak.

Keyinchalik, biz boshqa turdagi referenceni ko'rib chiqamiz: slicelar.

Slice turi

Slicelar butun to'plamga emas, balki to'plamdagi elementlarning qo'shni ketma-ketligiga murojaat qilish imkonini beradi. Slice bir xil referencedir, shuning uchun u ownershipga ega emas.

Bu erda kichik dasturlash muammosi: bo'shliqlar bilan ajratilgan so'zlar qatorini oladigan va shu qatorda topilgan birinchi so'zni qaytaradigan funksiya yozing. Agar funksiya satrda bo'sh joy topmasa, butun satr bitta so'zdan iborat bo'lishi kerak, shuning uchun butun satr qaytarilishi kerak.

Keling, slicelar hal qiladigan muammoni tushunish uchun ushbu funksiyaning imzosini slicelardan foydalanmasdan qanday yozishni ko'rib chiqaylik:

fn birinchi_soz(s: &String) -> ?

birinchi_soz funksiyasi parametr sifatida &String ga ega. Biz ownershiplik qilishni xohlamaymiz, shuning uchun bu yaxshi. Ammo biz nimani return qilishimiz kerak? Bizda satrning qismi haqida gapirishning metodi yo'q. Biroq, biz bo'sh joy bilan ko'rsatilgan so'z oxiri indeksini qaytarishimiz mumkin. 4-7 ro'yxatda ko'rsatilganidek, buni sinab ko'raylik.

Fayl nomi: src/main.rs

fn birinchi_soz(s: &String) -> usize {
    let bayt = s.as_bytes();

    for (i, &item) in bayt.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Ro'yxat 4-7: String parametriga bayt indeks qiymatini qaytaradigan birinchi_soz funksiyasi

Biz String elementini element bo'yicha ko'rib chiqishimiz va qiymat bo'sh joy yoki yo'qligini tekshirishimiz kerakligi sababli, as_bytes metodi yordamida Stringni baytlar arrayiga aylantiramiz.

fn birinchi_soz(s: &String) -> usize {
    let bayt = s.as_bytes();

    for (i, &item) in bayt.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Keyinchalik, iter metodi yordamida baytlar arrayida iterator yaratamiz:

fn birinchi_soz(s: &String) -> usize {
    let bayt = s.as_bytes();

    for (i, &item) in bayt.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Biz iteratorlarni 13-bobda batafsilroq muhokama qilamiz. Hozircha bilingki, iter to‘plamdagi har bir elementni return qiladigan va enumerate iter natijasini o‘rab, har bir elementni tuplening bir qismi sifatida return qiladigan metoddir. enumerate dan qaytarilgan tuplening birinchi elementi indeks, ikkinchi element esa elementga referencedir. Bu indeksni o'zimiz hisoblashdan ko'ra biroz qulayroqdir.

enumerate metodi tupleni qaytarganligi sababli, biz ushbu tupleni destructure qilish uchun patternlardan foydalanishimiz mumkin. Biz 6-bobda patternlarni ko'proq muhokama qilamiz. for siklida biz tupledagi indeks uchun i va bitta bayt uchun &element ga ega bo‘lgan patternni belgilaymiz. Biz .iter().enumerate() dan elementga referenceni olganimiz uchun biz patternda & dan foydalanamiz.

for sikli ichida biz bayt literal sintaksisidan foydalanib, bo'sh joyni ifodalovchi baytni qidiramiz. Agar bo'sh joy topsak, biz pozitsiyani return qilamiz. Aks holda, s.len() yordamida satr uzunligini qaytaramiz.

fn birinchi_soz(s: &String) -> usize {
    let bayt = s.as_bytes();

    for (i, &item) in bayt.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Endi bizda satrdagi birinchi so'zning oxirgi indeksini aniqlashning metodi bor, ammo muammo bor. Biz usize ni o'z-o'zidan qaytarmoqdamiz, lekin bu &String kontekstida faqat meaningful raqam. Boshqacha qilib aytadigan bo'lsak, bu String dan alohida qiymat bo'lganligi sababli, uning kelajakda ham amal qilishiga kafolat yo'q. Ro'yxat 4-8da 4-7 ro'yxatdagi birinchi_soz funksiyasidan foydalanadigan dasturni ko'rib chiqing.

Fayl nomi: src/main.rs

fn birinchi_soz(s: &String) -> usize {
    let baytlar = s.as_bytes();

    for (i, &item) in baytlar.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {
    let mut s = String::from("hello world");

    let soz = birinchi_soz(&s); // soz 5 qiymatini oladi

    s.clear(); // bu Stringni bo'shatib, uni "" ga tenglashtiradi

    // soz hali ham bu erda 5 qiymatiga ega, ammo biz 5 qiymatini meaningfull ishlatishimiz
    // mumkin bo'lgan boshqa qator yo'q. soz endi mutlaqo yaroqsiz!
}

Ro'yxat 4-8: birinchi_soz funksiyasini chaqirish natijasida olingan natijani saqlash va keyin String tarkibini o'zgartirish

Bu dastur hech qanday xatosiz kompilyatsiya qiladi va agar biz s.clear() ga murojat qilgandan keyin soz ishlatgan bo'lsak ham shunday bo'lardi. Chunki soz s holatiga umuman bog‘lanmagan, soz hali ham 5 qiymatini o‘z ichiga oladi. Birinchi so‘zni chiqarish uchun biz ushbu 5 qiymatini s o‘zgaruvchisi bilan ishlatishimiz mumkin, ammo bu xato bo‘lishi mumkin, chunki sozda 5 ni saqlaganimizdan so‘ng s tarkibi o‘zgargan.

Having to worry about the index in word getting out of sync with the data in s is tedious and error prone! Agar biz ikkinchi_soz funksiyasini yozsak, bu indekslarni boshqarish yanada mo'rt bo'ladi. Uning signaturesi quyidagicha ko'rinishi kerak:

fn ikkinchi_soz(s: &String) -> (usize, usize) {

Endi biz boshlang'ich va tugash indeksini kuzatmoqdamiz va bizda ma'lum bir holatdagi ma'lumotlardan hisoblangan, ammo bu holatga umuman bog'liq bo'lmagan ko'proq qiymatlar mavjud. Bizda bir-biriga bog'liq bo'lmagan uchta o'zgaruvchi mavjud bo'lib, ular sinxronlashtirilishi kerak.

Yaxshiyamki, Rust bu muammoni hal qildi: string slicelar.

String Slicelar

string slice String qismiga reference boʻlib, u quyidagicha koʻrinadi:

fn main() {
    let s = String::from("salom duno");

    let salom = &s[0..5];
    let dunyo = &s[6..11];
}

Butun Stringga reference oʻrniga salom qoʻshimcha [0..5] bitida koʻrsatilgan String qismiga referencedir. Biz [starting_index..ending_index] ni belgilash orqali qavslar ichidagi diapazondan foydalangan holda slicelarni yaratamiz, bu yerda starting_index bo'limdagi birinchi pozitsiyadir va ending_index slicedagi oxirgi pozitsiyadan bittaga ko'p. Ichkarida, slice ma'lumotlar tuzilmasi ending_index minus starting_index ga mos keladigan boshlang'ich pozitsiyasini va slice uzunligini saqlaydi. Demak, let dunyo = &s[6..11]; holatida dunyo so'zi s ning 6 indeksidagi baytga ko‘rsatgichni o‘z ichiga olgan bo‘lak bo‘lib, uzunligi 5 ga teng bo‘ladi.

4-6-rasmda bu diagrammada ko'rsatilgan.

4-6-rasm: Stringning bir qismiga referal qiluvchi String slice

Rustning .. diapazoni sintaksisi bilan, agar siz 0 indeksidan boshlamoqchi bo'lsangiz, qiymatni ikki davr oldidan tushirishingiz mumkin. Boshqacha qilib aytganda, ular tengdir:

#![allow(unused)]
fn main() {
let s = String::from("salom");

let slice = &s[0..2];
let slice = &s[..2];
}

Xuddi shu qoidaga ko'ra, agar sizning slicesingiz String ning oxirgi baytini o'z ichiga olgan bo'lsa, siz keyingi raqamni qo'yishingiz mumkin. Bu shuni anglatadiki, ular tengdir:

#![allow(unused)]
fn main() {
let s = String::from("salom");

let uzunlik = s.len();

let slice = &s[3..uzunlik];
let slice = &s[3..];
}

Shuningdek, butun satrning bir qismini olish uchun ikkala qiymatni ham tashlab qo'yishingiz mumkin. Shunday qilib, ular teng:

#![allow(unused)]
fn main() {
let s = String::from("salom");

let uzunlik = s.len();

let slice = &s[0..uzunlik];
let slice = &s[..];
}

Eslatma: String diapazoni indekslari yaroqli UTF-8 belgilar chegaralarida bo'lishi kerak. Agar siz ko'p baytli belgi o'rtasida string slice yaratishga harakat qilsangiz, dasturingiz xato bilan chiqadi. String slicelarini kiritish uchun biz faqat ushbu bo'limda ASCII ni qabul qilamiz; UTF-8 bilan ishlash bo'yicha batafsilroq muhokama 8-bobning ”UTF-8 kodlangan matnni satrlar bilan saqlash” bo'limida keltirilgan.

Ushbu ma'lumotlarning barchasini hisobga olgan holda, sliceni qaytarish uchun birinchi_soz ni qayta yozamiz. “String slice”ni bildiruvchi tur &str sifatida yoziladi:

Fayl nomi: src/main.rs

fn birinchi_soz(s: &String) -> &str {
    let baytlar = s.as_bytes();

    for (i, &item) in baytlar.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {}

Biz so'z oxiri indeksini 4-7 ro'yxatdagi kabi bo'shliqning birinchi marta paydo bo'lishini qidirib olamiz. Bo'shliqni topganimizda, satrning boshi va bo'sh joy indeksidan boshlang'ich va yakuniy indekslar sifatida foydalanib, satr bo'lagini qaytaramiz.

Endi biz birinchi_soz ni chaqirganimizda, biz asosiy ma'lumotlarga bog'langan bitta qiymatni olamiz. Qiymat slicening boshlang'ich nuqtasiga va bo'limdagi elementlar soniga referencedan iborat.

Sliceni return qilish ikkinchi_soz funksiyasi uchun ham ishlaydi:

fn ikkinchi_soz(s: &String) -> &str {

Endi bizda oddiy API mavjud, uni buzish ancha qiyin, chunki kompilyator String ga referencelar haqiqiyligini ta'minlaydi. 4-8 ro'yxatdagi dasturdagi xatoni eslaysizmi, biz indeksni birinchi so'zning oxirigacha olib, keyin qatorni o'chirib tashlaganimizda, indeksimiz yaroqsiz edi? Bu kod mantiqan noto'g'ri edi, lekin darhol xatoliklarni ko'rsatmadi. Agar biz birinchi so'z indeksini bo'shatilgan qator bilan ishlatishga harakat qilsak, muammolar keyinroq paydo bo'ladi. Slicelar bu xatoni imkonsiz qiladi va kodimiz bilan bog'liq muammo borligini bizga tezroq bildiradi. birinchi_soz slice versiyasidan foydalanish kompilyatsiya vaqtida xatolikka olib keladi:

Fayl nomi: src/main.rs

fn birinchi_soz(s: &String) -> &str {
    let baytlar = s.as_bytes();

    for (i, &item) in baytlar.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("salom dunyo");

    let soz = birinchi_soz(&s);

    s.clear(); // error!

    println!("birinchi so'z: {}", soz);
}

Mana kompilyator xatosi:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:18:5
   |
16 |     let soz = birinchi_soz(&s);
   |                           -- immutable borrow occurs here
17 |
18 |     s.clear(); // error!
   |     ^^^^^^^^^ mutable borrow occurs here
19 |
20 |     println!("birinchi so'z: {}", soz);
   |                                   ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error

Borrowing qoidalarini eslang, agar bizda biror narsaga o'zgarmas reference bo'lsa, biz o'zgaruvchan referenceni ham qabul qila olmaymiz. Chunki clear Stringni qisqartirishi kerak, u o'zgaruvchan referenceni olishi kerak. clear chaqiruvidan keyingi println! soz dagi referencedan foydalanadi, shuning uchun o‘zgarmas reference shu nuqtada faol bo‘lishi kerak. Rust bir vaqtning o'zida clear va soz dagi o'zgarmas referenceni bir vaqtning o'zida mavjud bo'lishiga yo'l qo'ymaydi va kompilyatsiya bajarilmaydi. Rust nafaqat API-dan foydalanishni osonlashtirdi, balki kompilyatsiya vaqtidagi xatolarning butun sinfini ham yo'q qildi!

String literallar Slice sifatida

Eslatib o'tamiz, biz binary tizimda saqlanadigan string literallari haqida gapirgan edik. Endi biz slicelar haqida bilganimizdan so'ng, biz string literallarini to'g'ri tushunishimiz mumkin:

#![allow(unused)]
fn main() {
let s = "Hello, world!";
}

Bu erda s turi &str: bu binary faylning o'ziga xos nuqtasiga ishora qiluvchi slice. Shu sababli ham string literallari o'zgarmasdir; &str - o'zgarmas reference.

Parametrlar sifatida String Slicelar

Siz literal va String qiymatlarini olish mumkinligini bilish bizni birinchi_sozni yana bir takomillashtirishga olib keladi va bu uning signaturesi:

fn birinchi_soz(s: &String) -> &str {

Tajribali Rustacean buni o'rniga 4-9 ro'yxatda ko'rsatilgan signatureni yozadi, chunki bu bizga &String qiymatlari va &str qiymatlarida bir xil funksiyadan foydalanishga imkon beradi.

fn birinchi_soz(s: &str) -> &str {
    let baytlar = s.as_bytes();

    for (i, &item) in baytlar.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mening_stringim = String::from("hello world");

    // `birinchi_soz` `String` ning qisman yoki to'liq slicelarida ishlaydi
    let soz = birinchi_soz(&mening_stringim[0..6]);
    let soz = birinchi_soz(&mening_stringim[..]);
    // `birinchi_soz`, shuningdek, `String` ning butun slicelariga ekvivalent bo`lgan
    // `String`-ga referencelar ustida ham ishlaydi.
    let soz = birinchi_soz(&mening_stringim);

    let mening_literal_stringim = "hello world";

    // `birinchi_soz` qisman yoki to'liq bo'lgan string literallari slicelarida ishlaydi
    let soz = birinchi_soz(&mening_literal_stringim [0..6]);
    let soz = birinchi_soz(&mening_literal_stringim [..]);

    // String literallari  allaqachon string slicelari bo'lganligi sababli,
    // bu slice sintaksisisiz ham ishlaydi!
    let soz = birinchi_soz(mening_literal_stringim );
}

Ro'yxat 4-9: birinchi_soz funksiyasini s parametri turi uchun string slicedan foydalanish orqali yaxshilash

Agar bizda string slice bo'lsa, biz uni to'g'ridan-to'g'ri o'tkazishimiz mumkin. Agar bizda String bo'lsa, biz String slicesini yoki String ga referenceni o'tkazishimiz mumkin. Ushbu moslashuvchanlik deref coercionlari dan foydalanadi, bu xususiyatni biz 15-bobning “Funktsiyalar va metodlar bilan Implicit Deref Coercionlari” da ko‘rib chiqamiz.

String ga reference o‘rniga string sliceni olish funksiyasini belgilash bizning API’ni hech qanday funksionallikni yo‘qotmasdan umumiyroq va foydali qiladi:

Fayl nomi: src/main.rs

fn birinchi_soz(s: &str) -> &str {
    let baytlar = s.as_bytes();

    for (i, &item) in baytlar.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mening_stringim = String::from("hello world");

    // `birinchi_soz` `String` ning qisman yoki to'liq slicelarida ishlaydi
    let soz = birinchi_soz(&mening_stringim[0..6]);
    let soz = birinchi_soz(&mening_stringim[..]);
    // `birinchi_soz`, shuningdek, `String` ning butun slicelariga ekvivalent bo`lgan
    // `String`-ga referencelar ustida ham ishlaydi.
    let soz = birinchi_soz(&mening_stringim);

    let mening_literal_stringim = "hello world";

    // `birinchi_soz` qisman yoki to'liq bo'lgan string literallari slicelarida ishlaydi
    let soz = birinchi_soz(&mening_literal_stringim [0..6]);
    let soz = birinchi_soz(&mening_literal_stringim [..]);

    // String literallari  allaqachon string slicelari bo'lganligi sababli,
    // bu slice sintaksisisiz ham ishlaydi!
    let soz = birinchi_soz(mening_literal_stringim );
}

Boshqa Slicelar

String slicelari, siz tasavvur qilganingizdek, stringlarga xosdir. Ammo yana umumiy slice turi ham bor. Ushbu arrayni ko'rib chiqing:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
}

Xuddi biz satrning bir qismiga murojaat qilishni xohlaganimizdek, arrayning bir qismiga murojaat qilishni xohlashimiz mumkin. Biz shunday qilamiz:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

Ushbu slice &[i32] turiga ega. U birinchi element va uzunlikka referenceni saqlash orqali string slicelari kabi ishlaydi. Siz boshqa barcha turdagi to'plamlar uchun bunday slicedan foydalanasiz. 8-bobda vektorlar haqida gapirganda, biz ushbu to'plamlarni batafsil muhokama qilamiz.

Xulosa

Ownership, borrowing va slicelar tushunchalari kompilyatsiya vaqtida Rust dasturlarida xotira xavfsizligini ta'minlaydi. Rust tili sizga boshqa tizim dasturlash tillari kabi xotiradan foydalanishni boshqarish imkonini beradi, lekin egasi amal qilish doirasidan chiqib ketganda maʼlumotlar egasi avtomatik ravishda ushbu maʼlumotlarni tozalaydi, bu boshqaruvni olish uchun qoʻshimcha kod yozish va debug qilish shart emasligini anglatadi.

Ownership Rustning boshqa ko'plab qismlari qanday ishlashiga ta'sir qiladi, shuning uchun biz bu tushunchalar haqida kitobning qolgan qismida batafsilroq gaplashamiz. Keling, 5-bobga o'tamiz va ma'lumotlar bo'laklarini structda birga guruhlashni ko'rib chiqamiz.

Tegishli ma'lumotlarni tuzish uchun Structlardan foydalanish

struct - foydalanuvchi tomonidan belgilangan ma'lumotlar turi bo'lib, u sizga mantiqiy va mantiqiy guruhni tashkil etuvchi bir nechta tegishli qiymatlarni nomlash va to'plash imkonini beradi. Agar siz obyektga yo'naltirilgan til bilan tanish bo'lsangiz, struct obyektning ma'lumotlar atributlariga o'xshaydi. Ushbu bobda biz tuplelarni structlar bilan solishtiramiz va o'zingiz bilgan narsalarga asoslaymiz va qachon structlar ma'lumotlarni guruhlashning eng yaxshi usuli ekanligini ko'rsatamiz.

Biz structlarni qanday aniqlash va yaratishni ko'rsatamiz. Struct turi bilan bog'liq xatti-harakatni belgilash uchun bog'langan funksiyalarni, ayniqsa methodlar deb ataladigan bog'langan funksiyalarni qanday aniqlashni muhokama qilamiz. Structlar va enumlar (6-bobda muhokama qilingan) dastur domenida yangi turlarni yaratish uchun building block hisoblanadi. Ular sizga Rustning kompilyatsiya vaqti turini tekshirish imkoniyatlaridan to'liq foydalanish imkonini beradi.

Structlarni aniqlash va yaratish

Structlar “Tuple turi“ bo'limida muhokama qilingan tuplelarga o'xshaydi, chunki ikkalasi ham bir-biriga bog'liq bo'lgan bir nechta qiymatlarga ega. Tuplelar singari, structning qismlari ham har xil turdagi bo'lishi mumkin. Tuplelardan farqli o'laroq, structda siz har bir ma'lumot qismini nomlaysiz, shunda qiymatlar nimani anglatishini tushunasiz. Ushbu nomlarni qo'shish structlar tuplelardan ko'ra moslashuvchanroq ekanligini anglatadi: misol qiymatlarini belgilash yoki ularga kirish uchun ma'lumotlar tartibiga ishonishingiz shart emas.

Structni aniqlash uchun biz struct kalit so`zini kiritamiz va butun tuzilishga nom beramiz. Struct nomi birgalikda guruhlangan ma'lumotlar bo'laklarining ahamiyatini tavsiflashi kerak. Keyin, jingalak qavslar ichida biz maydonlar deb ataydigan ma'lumotlar qismlarining nomlari va turlarini aniqlaymiz. Masalan, 5-1 ro'yxati foydalanuvchi hisobi haqidagi ma'lumotlarni saqlaydigan structni ko'rsatadi.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}

fn main() {}

Ro'yxat 5-1: Foydalanuvchi structi ta'rifi

Struct aniqlangandan so'ng, tegishli ma'lumotlar turiga ega bo'lgan har bir maydonga ma'lum bir qiymat berish orqali uni yaratish mumkin. Biz structning nomini ko'rsatish orqali misol yaratamiz va keyin kalit: qiymat(key: value) juftlarini o'z ichiga olgan jingalak qavslarni qo'shamiz, bu erda kalitlar maydonlarning nomlari va qiymatlar biz o'sha maydonlarda saqlamoqchi bo'lgan ma'lumotlardir.Biz maydonlarni structda e'lon qilgan tartibda ko'rsatishimiz shart emas. Boshqacha qilib aytganda, structning ta'rifi tur uchun umumiy shablonga o'xshaydi va misollar tur qiymatlarini yaratish uchun ushbu shablonni ma'lum ma'lumotlar bilan to'ldiradi. Misol uchun, biz 5-2 ro'yxatda ko'rsatilganidek, ma'lum bir foydalanuvchini e'lon qilishimiz mumkin.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}

fn main() {
    let foydalanuvchi1 = Foydalanuvchi {
        faollik: true,
        foydalanuvchi: String::from("ismoilovdev"),
        email: String::from("ismoilovdev@example.com"),
        kirish_hisobi: 1,
    };
}

Ro'yxat 5-2: Foydalanuvchi nusxasini yaratish structi

Structdan ma'lum bir qiymat olish uchun biz nuqta belgilaridan foydalanamiz. Masalan, ushbu foydalanuvchining elektron pochta manziliga kirish uchun biz foydalanuvchi1.email dan foydalanamiz. Agar misol o'zgaruvchan bo'lsa, biz nuqta belgisi yordamida qiymatni o'zgartirishimiz va ma'lum bir maydonga belgilashimiz mumkin. 5-3 ro'yxatda o'zgaruvchan Foydalanuvchi misolining email maydonidagi qiymatni qanday o'zgartirish mumkinligi ko'rsatilgan.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}

fn main() {
    let foydalanuvchi1 = Foydalanuvchi {
        faollik: true,
        foydalanuvchi: String::from("ismoilovdev"),
        email: String::from("ismoilovdev@example.com"),
        kirish_hisobi: 1,
    };

    foydalanuvchi1.email = String::from("asilbek@example.com");
}

Ro'yxat 5-3: Foydalanuvchi misolining email maydonidagi qiymatni o'zgartirish

E'tibor bering, butun misol o'zgaruvchan bo'lishi kerak; Rust bizga faqat ma'lum maydonlarni o'zgaruvchan deb belgilashga ruxsat bermaydi. Har qanday ifodada bo'lgani kabi, biz ushbu yangi misolni bilvosita qaytarish uchun funksiya tanasidagi oxirgi ifoda sifatida structning yangi nusxasini qurishimiz mumkin.

5-4 roʻyxatda berilgan email va foydalanuvchi nomi bilan Foydalanuvchi misolini qaytaruvchi foydalanuvchi_yaratish funksiyasi koʻrsatilgan. faollik maydoni true qiymatini, kirish_hisobi esa 1 qiymatini oladi.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}

fn foydalanuvchi_yaratish(email: String, foydalanuvchi: String) -> Foydalanuvchi {
    Foydalanuvchi {
        faollik: true,
        foydalanuvchi: foydalanuvchi,
        email: email,
        kirish_hisobi: 1,
    }
}

fn main() {
    let foydalanuvchi1 = foydalanuvchi_yaratish(
        String::from("ismoilovdev@example.com"),
        String::from("ismoilovdev"),
    );
}

Roʻyxat 5-4: foydalanuvchi_yaratish funksiyasi email va foydalanuvchi nomini oladi va Foydalanuvchi misolini qaytaradi

Funksiya parametrlarini struct maydonlari bilan bir xil nom bilan nomlash mantiqan to‘g‘ri keladi, lekin email va foydalanuvchi maydon nomlari va o‘zgaruvchilarini takrorlash biroz zerikarli. Agar structda ko'proq maydonlar bo'lsa, har bir nomni takrorlash yanada zerikarli bo'ladi. Yaxshiyamki, qulay Shorthand bor!

Field Init Shorthandan foydalanish

Parametr nomlari va struct maydonlarining nomlari 5-4 ro'yxatda aynan bir xil bo'lgani uchun, foydalanuvchi_yaratishni qayta yozish uchun init shorthand sintaksisidan foydalanishimiz mumkin, shuning uchun u xuddi shunday ishlaydi, lekin foydalanuvchi va emailni takrorlamaydi, 5-5 ro'yxatda ko'rsatilganidek.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}

fn foydalanuvchi_yaratish(email: String, foydalanuvchi: String) -> Foydalanuvchi {
    Foydalanuvchi {
        faollik: true,
        foydalanuvchi,
        email,
        kirish_hisobi: 1,
    }
}

fn main() {
    let foydalanuvchi1 = foydalanuvchi_yaratish(
        String::from("ismoilovdev@example.com"),
        String::from("ismoilovdev"),
    );
}

Roʻyxat 5-5: foydalanuvchi va email parametrlari struct maydonlari bilan bir xil nomga ega boʻlgani uchun init shorthanddan foydalanadigan foydalanuvchi_yaratish funksiyasi

Bu yerda biz Foydalanuvchi structining yangi nusxasini yaratmoqdamiz, unda email deb nomlangan maydon mavjud. Biz email maydonining qiymatini foydalanuvchi_yaratish funksiyasining email parametridagi qiymatga o‘rnatmoqchimiz. email maydoni va email parametri bir xil nomga ega bo'lgani uchun biz email: email emas, balki email yozishimiz kerak.

Structni update sintaksisidan foydalanib, boshqa tuzilma nusxasidan tuzilma namunasini yaratish

Ko'pincha boshqa namunadagi qiymatlarning ko'pini o'z ichiga olgan, lekin ularning ba'zilarini o'zgartiradigan structning yangi nusxasini yaratish foydali bo'ladi. Buni struct update sintaksisi yordamida amalga oshirishingiz mumkin.

Birinchidan, 5-6 ro'yxatda biz yangilanish sintaksisisiz muntazam ravishda foydalanuvchi2 da yangi Foydalanuvchi misolini qanday yaratishni ko'rsatamiz. Biz email uchun yangi qiymat o‘rnatdik, lekin aks holda 5-2 ro‘yxatda yaratgan foydalanuvchi1 qiymatidan foydalanamiz.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}


fn main() {
    // --snip--

    let foydalanuvchi1 = Foydalanuvchi {
        email: String::from("ismoilovdev@example.com"),
        foydalanuvchi: String::from("ismoilovdev"),
        faollik: true,
        kirish_hisobi: 1,
    };

    let foydalanuvchi2 = Foydalanuvchi {
        faollik: foydalanuvchi1.faollik,
        foydalanuvchi: foydalanuvchi1.foydalanuvchi,
        email: String::from("asilbek@example.com"),
        kirish_hisobi: foydalanuvchi1.kirish_hisobi,
    };
}

Roʻyxat 5-6: foydalanuvchi1 qiymatlaridan biri yordamida yangi Foydalanuvchi namunasini yaratish

Strukturani yangilash sintaksisidan foydalanib, biz 5-7 ro'yxatda ko'rsatilganidek, kamroq kod bilan bir xil effektga erishishimiz mumkin. .. sintaksisi qolgan maydonlar aniq o'rnatilganligini va belgilangan namunadagi qiymatlarga ega bo'lishi kerakligini ko'rsatadi.

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: String,
    email: String,
    kirish_hisobi: u64,
}

fn main() {
    // --snip--

    let foydalanuvchi1 = Foydalanuvchi {
        email: String::from("ismoilovdev@example.com"),
        foydalanuvchi: String::from("ismoilovdev"),
        faollik: true,
        kirish_hisobi: 1,
    };

    let foydalanuvchi2 = Foydalanuvchi {
        email: String::from("asilbek@example.com"),
        ..foydalanuvchi1
    };
}

Ro'yxat 5-7: Foydalanuvchi misoli uchun yangi email qiymatini o'rnatish, lekin foydalanuvchi1 dagi qolgan qiymatlardan foydalanish uchun structni yangilash sintaksisidan foydalanish

5-7 roʻyxatdagi kod foydalanuvchi2 da email uchun boshqa qiymatga ega, lekin foydalanuvchi1 dan foydalanuvchi, faollik va kirish_hisobi maydonlari uchun bir xil qiymatlarga ega boʻlgan misol yaratadi. ..foydalanuvchi1 qolgan maydonlar o‘z qiymatlarini foydalanuvchi1 dagi tegishli maydonlardan olishi kerakligini ko‘rsatish uchun oxirgi o‘rinda turishi kerak, lekin biz istalgan tartibda xohlagancha ko'p maydonlar uchun qiymatlarni belgilashni tanlashimiz mumkin, strukturaning ta'rifidagi maydonlar tartibidan qat'i nazar.

E'tibor bering, strukturani yangilash sintaksisi topshiriq kabi = dan foydalanadi; Buning sababi, biz ”O'zgaruvchilar va ma'lumotlarni ko'chirish bilan o'zaro ta'sir qilish” bo'limida ko'rganimizdek, u ma'lumotlarni harakatlantiradi. Ushbu misolda biz foydalanuvchi2 ni yaratganimizdan keyin foydalanuvchi1 dan bir butun sifatida foydalana olmaymiz, chunki foydalanuvchi1ning foydalanuvchi maydonidagi String foydalanuvchi2 ga koʻchirilgan. Agar biz foydalanuvchi2 ga email va foydalanuvchi uchun yangi String qiymatlarini bergan bo‘lsak va shuning uchun foydalanuvchi1dan faqat faollik va kirish_hisobi qiymatlarini ishlatgan bo‘lsak, keyin foydalanuvchi1 foydalanuvchi2 yaratilgandan keyin ham amal qiladi. faollik va kirish_hisobi turlari nusxa ko'chirish xususiyatini amalga oshiradigan turlardir, shuning uchun biz ”Stek ma'lumotlari: Nusxalash” bo'limida muhokama qilgan xatti-harakatlar qo'llaniladi.

Har xil turlarni yaratish uchun nomli maydonlarsiz tuplelardan foydalanish

Rust shuningdek, tuple structlar deb ataladigan tuplelarga o'xshash structlarni qo'llab-quvvatlaydi. Tuple structlari struct nomi taqdim etadigan qo'shimcha ma'noga ega, ammo ularning maydonlari bilan bog'langan nomlari yo'q; aksincha, ular faqat maydonlarning turlariga ega. Tuple structlari butun tuplega nom berish va tupleni boshqa tuplelardan farqli turga aylantirish zarur bo‘lganda foydali bo‘ladi va har bir maydonni oddiy structdagi kabi nomlashda batafsil yoki ortiqcha bo‘ladi.

Tuple structini aniqlash uchun struct kalit so‘zi va struct nomidan keyin tupledagi turlardan boshlang. Masalan, bu yerda biz Rang va Nuqta nomli ikkita tuple structini aniqlaymiz va foydalanamiz:

Fayl nomi: src/main.rs

struct Rang(i32, i32, i32);
struct Nuqta(i32, i32, i32);

fn main() {
    let qora = Rang(0, 0, 0);
    let kelib_chiqishi = Nuqta(0, 0, 0);
}

Esda tutingki, qora va kelib_chiqishi qiymatlari har xil turdagi, chunki ular turli xil tuple structlarining namunalaridir. Structdagi maydonlar bir xil turlarga ega bo'lishi mumkin bo'lsa ham, siz belgilagan har bir struct o'z turiga ega. Masalan, Rang turidagi parametrni qabul qiladigan funksiya, har ikkala tur ham uchta i32 qiymatidan iborat bo‘lsa ham, Nuqtani argument sifatida qabul qila olmaydi. Aks holda, tuple structi namunalari tupelarga o'xshaydi, chunki siz ularni alohida qismlarga ajratishingiz mumkin va individual qiymatga kirish uchun . va keyin indeksdan foydalanishingiz mumkin.

Hech qanday maydonsiz unit kabi structlar

Shuningdek, siz hech qanday maydonga ega bo'lmagan structlarni belgilashingiz mumkin! Ular unita o'xshash structlar deb ataladi, chunki ular biz ”Tuple turi” bo'limida aytib o'tgan unit turiga () o'xshash harakat qiladilar. Unitga o'xshash structlar qaysidir turdagi traitni qo'llash kerak bo'lganda foydali bo'lishi mumkin, ammo sizda turning o'zida saqlash uchun ma'lumotlaringiz yo'q. Traitlarni 10-bobda muhokama qilamiz. Mana AlwaysEqual nomli unit structini e’lon qilish va instantsiyalash misoli:

Fayl nomi: src/main.rs

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

AlwaysEqual ni aniqlash uchun biz struct kalit so'zidan, kerakli nomdan va keyin nuqta-verguldan foydalanamiz. Jingalak qavslar yoki qavslar kerak emas! Shunda biz subject o'zgaruvchisida AlwaysEqual misolini xuddi shunday tarzda olishimiz mumkin: biz belgilagan nomdan foydalanib, hech qanday jingalak qavs yoki qavslarsiz. Tasavvur qiling-a, keyinchalik biz ushbu turdagi xatti-harakatlarni shunday amalga oshiramizki, AlwaysEqual ning har bir nusxasi har doim boshqa turdagi har bir misolga teng bo'ladi, ehtimol sinov uchun ma'lum natijaga ega bo'lishi mumkin. Ushbu xatti-harakatni amalga oshirish uchun bizga hech qanday ma'lumot kerak emas! Traitlarni qanday aniqlash va ularni har qanday turdagi, shu jumladan unitga o'xshash structlarda amalga oshirishni 10-bobda ko'rasiz.

Strukturaviy ma'lumotlarga ownershiplik qilish

5-1 roʻyxatdagi Foydalanuvchi structi taʼrifida biz &str string slice turidan koʻra tegishli String turidan foydalandik. Bu ataylab qilingan tanlov, chunki biz ushbu structning har bir nusxasi uning barcha maʼlumotlariga ega boʻlishini va bu maʼlumotlar butun struct amalda boʻlgunga qadar amal qilishini istaymiz.

Structlar boshqa narsaga tegishli maʼlumotlarga referencelarni saqlashi ham mumkin, ammo buning uchun biz 10-bobda muhokama qiladigan Rust xususiyatidan lifetimelar foydalanishni talab qiladi. Lifetime struct tomonidan reference qilingan ma'lumotlar struct mavjud bo'lgunga qadar amal qilishini ta'minlaydi. Aytaylik, siz ma'lumotnomani lifetimeni ko'rsatmasdan structda saqlashga harakat qildingiz, quyidagi kabi; bu ishlamaydi:

Fayl nomi: src/main.rs

struct Foydalanuvchi {
    faollik: bool,
    foydalanuvchi: &str,
    email: &str,
    kirish_hisobi: u64,
}

fn main() {
    let foydalanuvchi1 = Foydalanuvchi {
        faollik: true,
        foydalanuvchi: "ismoilovdev",
        email: "ismoilovdev@example.com",
        kirish_hisobi: 1,
    };
}

Kompilyator referencelarning lifetimeni aniqlash zarurati haqida shikoyat qiladi:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:15
  |
3 |     foydalanuvchi: &str,
  |               ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct Foydalanuvchi<'a> {
2 |     faollik: bool,
3 ~     foydalanuvchi: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct Foydalanuvchi<'a> {
2 |     faollik: bool,
3 |     foydalanuvchi: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` due to 2 previous errors

10-bobda biz ushbu xatolarni qanday tuzatishni muhokama qilamiz, shunda siz referencelarni structlarda saqlashingiz mumkin, ammo hozircha biz bu kabi xatolarni &str kabi referencelar oʻrniga String kabi tegishli turlardan foydalanib tuzatamiz.

Structlar yordamida namunaviy dastur

Structlarni qachon ishlatishimiz mumkinligini tushunish uchun to'rtburchakning maydonini hisoblaydigan dastur yozaylik. Biz bitta o'zgaruvchilardan foydalanishni boshlaymiz, so'ngra uning o'rniga structlardan foydalanmagunimizcha dasturni qayta yaxshilab boramiz.

Keling, cargo bilan kvadratlar deb nomlangan yangi binary loyihani yarataylik, u piksellarda ko'rsatilgan to'rtburchakning kengligi va balandligini oladi va to'rtburchakning maydonini hisoblaydi. 5-8 ro'yxatda loyihaning src/main.rs faylida nima qilishimiz kerakligini aniq bajarishga imkon beradigan bitta qisqa kod ko'rsatilgan.

Fayl nomi: src/main.rs

fn main() {
    let kenglik1 = 30;
    let balandlik1 = 50;

    println!(
        "To'rtburchakning maydoni {} kvadrat piksel.",
        area(kenglik1, balandlik1)
    );
}

fn area(kenglik: u32, balandlik: u32) -> u32 {
    kenglik * balandlik
}

Ro'yxat 5-8: Alohida kenglik va balandlik o'zgaruvchilari bilan belgilangan to'rtburchaklar maydonini hisoblash

Endi ushbu dasturni cargo run yordamida ishga tushiring:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/rectangles`
To'rtburchakning maydoni 1500 kvadrat piksel.

Ushbu kod har bir o'lcham bilan area funksiyasini chaqirish orqali to'rtburchakning maydonini aniqlashga muvaffaq bo'ladi, ammo biz ushbu kodni aniq va o'qilishi uchun ko'proq narsani qilishimiz mumkin.

Ushbu kod bilan bog'liq muammo area signaturesida aniq ko'rinadi:

fn main() {
    let kenglik1 = 30;
    let balandlik1 = 50;

    println!(
        "To'rtburchakning maydoni {} kvadrat piksel.",
        area(kenglik1, balandlik1)
    );
}

fn area(kenglik: u32, balandlik: u32) -> u32 {
    kenglik * balandlik
}

area funksiyasi bitta to'rtburchakning maydonini hisoblashi kerak, lekin biz yozgan funksiya ikkita parametrga ega va bizning dasturimizning hech bir joyida parametrlar o'zaro bog'liqligi aniq emas. Kenglik va balandlikni birgalikda guruhlash yanada o'qilishi va boshqarilishi oson bo'lishi mumkin edi.3-bobning ”Tuple Turi” bo'limida biz buni amalga oshirishning bir usulini, ya'ni tuplelardan foydalanishni muhokama qildik.

Tuplelar yordamida Refaktoring

5-9 ro'yxatda tuplelardan foydalanadigan dasturimizning boshqa versiyasi ko'rsatilgan.

Fayl nomi: src/main.rs

fn main() {
    let kvadrat1 = (30, 50);

    println!(
        "To'rtburchakning maydoni {} kvadrat pikselga teng.",
        area(kvadrat1)
    );
}

fn area(olchamlari: (u32, u32)) -> u32 {
    olchamlari.0 * olchamlari.1
}

Ro'yxat 5-9: To'rtburchakning kengligi va balandligini tuple yordamida aniqlash

Bir tomondan, bu dastur yaxshiroq. Tuplar bizga biroz struct qo'shishga imkon beradi va biz hozir faqat bitta argumentni keltiramiz. Ammo boshqa yo'l bilan, bu versiya unchalik aniq emas: tuplelar o'z elementlarini nomlamaydi, shuning uchun biz hisob-kitobimizni kamroq aniq qilib, tuple qismlariga indeks qilishimiz kerak.

Kenglik va balandlikni aralashtirish maydonni hisoblash uchun muhim emas, lekin agar biz ekranda to'rtburchak chizmoqchi bo'lsak, bu muhim bo'ladi! Shuni yodda tutishimiz kerakki, kenglik indeks 0 da, balandlik esa 1 indeksda. Agar kimdir bizning kodimizdan foydalansa, buni tushunish va yodda tutish qiyinroq bo'ladi. Kodimizda ma'lumotlarimizning ma'nosini etkazmaganimiz sababli, endi xatolarni kiritish osonroq.

Struktuctlar bilan Refaktoring: ko'proq ma'no qo'shish

Biz ma'lumotlarni etiketlash orqali ma'no qo'shish uchun structlardan foydalanamiz. Biz foydalanayotgan tupleni 5-10 ro'yxatda ko'rsatilganidek, butun nomi bilan bir qatorda qismlar nomlari bilan tuzilishga aylantirishimiz mumkin.

Fayl nomi: src/main.rs

struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}

fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };

    println!(
        "To'rtburchakning maydoni {} kvadrat pikselga teng.",
        area(&kvadrat1)
    );
}

fn area(kvadrat: &Kvadrat) -> u32 {
    kvadrat.kenglik * kvadrat.balandlik
}

Ro'yxat 5-10: Kvadrat strukturasini aniqlash

Bu yerda biz structni aniqladik va uni Kvadrat deb nomladik. Jingalak qavslar ichida biz maydonlarni kenglik va balandlik sifatida belgiladik, ularning ikkalasi ham u32 turiga ega. Keyin, main da biz Kvadrat ning ma'lum bir misolini yaratdik, uning kengligi 30 va balandligi 50.

Bizning area funksiyamiz endi biz kvadrat deb nomlagan bitta parametr bilan aniqlanadi, uning turi Kvadrat structi misolining o‘zgarmas borrowidir. 4-bobda aytib o'tilganidek, biz unga ownershiplik qilishdan ko'ra, structi borrow qilishni xohlaymiz. Shunday qilib, main o'z ownershipini saqlab qoladi va kvadrat1 dan foydalanishni davom ettirishi mumkin, shuning uchun biz funktsiya signaturesida & dan foydalanamiz va biz funktiyani chaqiramiz.

area funksiyasi Kvadrat misolining kenglik va balandlik maydonlariga kiradi (esda tutingki, borrow qilingan struct misolining maydonlariga kirish maydon qiymatlarini ko'chirmaydi, shuning uchun siz ko'pincha structlarning borrowlarini ko'rasiz). Endi area funksiyasi signaturesi biz nimani nazarda tutayotganimizni aniq aytadi: Kvadrat maydonini uning kenglik va balandlik maydonlaridan foydalanib hisoblang. Bu kenglik va balandlik bir-biri bilan bog'liqligini bildiradi va 0 va 1 qator indeks qiymatlarini ishlatishdan ko'ra, qiymatlarga tavsiflovchi nomlar beradi. Bu aniqlik uchun g'alaba.

Olingan Traitlar bilan foydali funksionallikni qo'shish

Dasturimizni debug qilish va uning barcha maydonlari uchun qiymatlarni ko'rish paytida Kvadrat misolini chop etish foydali bo'lar edi. 5-11 ro'yxatda biz avvalgi boblarda foydalanganimizdek println! makrosidan foydalanishga harakat qiladi. Biroq, bu ishlamaydi.

Fayl nomi: src/main.rs

struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}
fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };

    println!("kvadrat1 - {}", kvadrat1);
}

Ro'yxat 5-11: Kvadratni chop etishga urinish misoli

Ushbu kodni kompilyatsiya qilishda, biz ushbu asosiy xabar bilan xatoga duch kelamiz:

error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`

println! makrosi ko'plab formatlash turlarini amalga oshirishi mumkin va standart bo'yicha jingalak qavslar println!ga Display deb nomlanuvchi formatlashdan foydalanishni bildiradi: to'g'ridan-to'g'ri oxirgi foydalanuvchi iste'moli uchun mo'ljallangan chiqish. Biz hozirgacha ko'rgan primitiv turlar standart bo'yicha Display ni qo'llaydi, chunki foydalanuvchiga 1 yoki boshqa primitiv turni ko'rsatishning faqat bitta usuli bor. Lekin structlar bilan println! ning chiqishni formatlash metodi unchalik aniq emas, chunki koʻproq koʻrsatish imkoniyatlari mavjud: vergul qoʻyishni xohlaysizmi yoki yoʻqmi? Jingalak qavslarni chop qilmoqchimisiz? Barcha maydonlar ko'rsatilishi kerakmi? Ushbu noaniqlik tufayli Rust biz xohlagan narsani taxmin qilishga urinmaydi va structlarda println! va {} to'ldiruvchisi bilan foydalanish uchun Display ning taqdim etilgan ilovasi yo'q.

Agar xatolarni o'qishda davom etsak, biz ushbu foydali eslatmani topamiz:

   = help: the trait `std::fmt::Display` is not implemented for `Kvadrat`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

Keling, sinab ko'raylik! println! macro chaqiruvi endi println!("kvadrat1 bu {}", kvadrat1); kabi ko'rinadi. :? spetsifikatsiyasini jingalak qavslar ichiga qo'yish println! biz Debug deb nomlangan chiqish formatidan foydalanmoqchi ekanligimizni bildiradi. Debug traiti bizga sturctni ishlab chiquvchilar uchun foydali bo'lgan tarzda chop etish imkonini beradi, shuning uchun biz kodimizni tuzatish paytida uning qiymatini ko'rishimiz mumkin.

Keling, ushbu o'zgarishlar bilan kodni kompilyatsiya qilaylik. Ehh! Biz hali ham xatoni olamiz:

error[E0277]: `Rectangle` doesn't implement `Debug`

Ammo yana, kompilyator bizga foydali eslatma beradi:

   = help: the trait `Debug` is not implemented for `Rectangle`
   = note: add `#[derive(Debug)]` to `Rectangle` or manually `impl Debug for Rectangle`

Rust debug ma'lumotlarini chop etish funksiyasini o'z ichiga oladi, lekin biz ushbu funksiyani structimiz uchun mavjud qilish uchun ochiqdan-ochiq rozi bo'lishimiz kerak. Buni amalga oshirish uchun 5-12 ro'yxatda ko'rsatilganidek, struct ta'rifidan oldin #[derive(Debug)] tashqi atributini qo'shamiz.

Fayl nomi: src/main.rs

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}
fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };

    println!("kvadrat1 - {}", kvadrat1);
}

Ro'yxat 5-12: Debug traitini olish uchun atribut qo‘shish va debug formatlash yordamida Kvadrat misolini chop etish

Endi dasturni ishga tushirganimizda, biz hech qanday xatolikka yo'l qo'ymaymiz va biz quyidagi natijani ko'ramiz:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
kvadrat1 - Kvadrat { kenglik: 30, balandlik: 50 }

Yaxshi! Bu eng yaxshi natija emas, lekin u ushbu misol uchun barcha maydonlarning qiymatlarini ko'rsatadi, bu disk raskadrovka paytida albatta yordam beradi. Kattaroq structlarga ega bo'lsak, o'qishni biroz osonlashtiradigan chiqishga ega bo'lish foydalidir; bunday hollarda println! qatoridagi {:?} o'rniga {:#?} dan foydalanishimiz mumkin. Ushbu misolda {:#?} uslubidan foydalanish quyidagi natijalarni beradi:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
kvadrat1 - Kvadrat {
    kenglik: 30,
    balandlik: 50
}

Debug formati yordamida qiymatni chop etishning yana bir usuli dbg! macro Ifodaga egalik qiluvchi macro (mos referencelar oladigan println! dan farqli o'laroq) o'sha dbg! qayerda fayl va satr raqamini chop etadi! macro murojati sizning kodingizda ushbu ifodaning natijaviy qiymati bilan birga sodir bo'ladi va qiymatga egalik huquqini qaytaradi.

Eslatma: dbg! makrosini chaqirish standart chiqish konsoli stremiga (stdout) chop qiluvchi println!dan farqli ravishda standart xato konsoli stremiga (stderr) chop etadi. Biz 12-bobdagi ”Xato xabarlarini standart chiqish o‘rniga standart xatoga yozish” bo‘limida stderr va stdout haqida ko‘proq gaplashamiz.

Mana bizni kenglik maydoniga tayinlanadigan qiymat, shuningdek kvadrat1dagi butun structning qiymati qiziqtiradigan misol:

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}
fn main() {
    let masshtab = 2;
    let kvadrat1 = Kvadrat {
        kenglik: dbg!(30 * masshtab),
        balandlik: 50,
    };

    dbg!(&kvadrat1);
}

Biz 30 * masshtab iborasi atrofida dbg! qo'yishimiz mumkin va dbg! ifoda qiymatiga egalik huquqini qaytargani uchun, kenglik maydoni bizda dbg! chaqiruvi bo'lmagani kabi bir xil qiymatga ega bo'ladi. Biz dbg! kvadrat1ga egalik qilishini istamaymiz, shuning uchun keyingi chaqiruvda kvadrat1 ga referencedan foydalanamiz. Ushbu misolning natijasi quyidagicha ko'rinadi:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10] 30 * masshtab = 60
[src/main.rs:14] &kvadrat1 = Kvadrat {
    kenglik: 30,
    balandlik: 50
}

Biz birinchi debuggingda src/main.rs ning 10-qatoridan kelganini ko'rishimiz mumkin, bu erda biz 30 * masshtab ifodani debugging qilamiz va uning natijaviy qiymati 60 (butun sonlar uchun Debug formati faqat ularning qiymatini chop etish uchun ishlatiladi). src/main.rs ning 14-qatoridagi dbg! chaqiruvi &kvadrat1 qiymatini chiqaradi, bu Kvadrat structidir. Ushbu chiqishda Kvadrat turidagi chiroyli Debug formatlash qo'llaniladi. dbg! makrosi sizning kodingiz nima qilayotganini aniqlashga harakat qilayotganingizda juda foydali bo'lishi mumkin!

Rust Debug traitiga qo‘shimcha ravishda derive atributi bilan foydalanishimiz uchun bir qancha taritlarni taqdim etdi, ular bizning odatiy turlarimizga foydali xatti-harakatlar qo‘shishi mumkin.Ushbu traitlar va ularning xatti-harakatlari C ilovasida keltirilgan. Biz 10-bobda ushbu traittlarni odatiy xatti-harakatlar bilan qanday implement qilishni, shuningdek, o'z traitlaringizni qanday yaratishni ko'rib chiqamiz.Bundan tashqari, 'derive' dan boshqa ko'plab atributlar mavjud; qo'shimcha ma'lumot olish uchun Rust Referencening "Atributlar" bo'limiga qarang.

Bizning area funksiyamiz juda aniq: u faqat to'rtburchaklar maydonini hisoblaydi. Ushbu xatti-harakatni Kvadrat structimiz bilan yaqinroq bog'lash foydali bo'ladi, chunki u boshqa turlar bilan ishlamaydi. Keling, ushbu kodni qanday qilib qayta ishlashni davom ettirishimiz mumkinligini ko'rib chiqaylik, bu area funksiyasini Kvadrat turida aniqlangan area metod ga aylantiradi.

Metod Sintaksisi

Metodlar funksiyalarga oʻxshaydi: biz ularni fn kalit soʻzi va nomi bilan eʼlon qilamiz, ular parametrlari va qaytish qiymatiga ega boʻlishi mumkin va ular boshqa joydan metod chaqirilganda ishga tushadigan kodni oʻz ichiga oladi. Funktsiyalardan farqli o'laroq, metodlar struct (yoki biz mos ravishda 6-bob va 17-bobda ko'rib chiqiladigan enum yoki trait obyekti) kontekstida aniqlanadi va ularning birinchi parametri har doim self dir metod chaqirilayotgan structning namunasini ifodalaydi.

Metodlarni aniqlash

Parametr sifatida Kvadrat misoliga ega bo‘lgan area funksiyasini o‘zgartiramiz va uning o‘rniga 5-13 ro‘yxatda ko'rsatilganidek, Kvadrat structida belgilangan area metodini yaratamiz.

Fayl nomi: src/main.rs

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}

impl Kvadrat {
    fn area(&self) -> u32 {
        self.kenglik * self.balandlik
    }
}

fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };

    println!(
        "To'rtburchakning maydoni {} kvadrat pikselga teng.",
        kvadrat1.area()
    );
}

Ro'yxat 5-13: Kvadrat structida area metodini aniqlash

Kvadrat kontekstida funksiyani aniqlash uchun Kvadrat uchun impl (implementation) blokini ishga tushiramiz. Ushbu impl blokidagi hamma narsa Kvadrat turi bilan bog'lanadi. Keyin biz area funksiyasini impl jingalak qavslar ichida harakatlantiramiz va birinchi (va bu holda, faqat) parametrni signatureda va tananing hamma joyida self o‘zgartiramiz. main da, biz area funksiyasini chaqirib, argument sifatida kvadrat1 ni topshirgan bo‘lsak, o‘rniga Kvadrat misolida area metodini chaqirish uchun metod sintaksisi dan foydalanishimiz mumkin. Metod sintaksisi misoldan keyin keladi: biz nuqta qo'shamiz, undan keyin metod nomi, qavslar va har qanday argumentlar qo'shiladi.

area uchun signatureda kvadrat: &Kvadrat o‘rniga &self dan foydalanamiz. &self aslida self: &Self ning qisqartmasi. impl blokida Self turi impl bloki uchun bo'lgan turdagi taxallusdir. Metodlar birinchi parametri uchun Self turidagi self deb nomlangan parametrga ega bo'lishi kerak, shuning uchun Rust birinchi parametr joyida faqat self nomi bilan qisqartirish imkonini beradi. Esda tutingki, biz hali ham kvadrat: &Kvadrat da qilganimizdek, bu metod Self misolini olishini koʻrsatish uchun Self stenografiyasi oldida & dan foydalanishimiz kerak. Boshqa har qanday parametr singari, metodlar self egallashi, o'zgarmas self borrow qilishi mumkin, xuddi biz bu yerda qilganimizdek yoki o'zgaruvchan selfni borrow qilishi mumkin.

Biz bu yerda funksiya versiyasida &Kvadrat dan foydalanganimiz uchun xuddi shu sababga ko‘ra &self tanladik: biz ownershiplik qilishni istamaymiz va faqat structdagi ma’lumotlarni o‘qishni istaymiz, unga yozishni emas. Agar biz ushbu metodning bir qismi sifatida chaqirgan misolni o'zgartirmoqchi bo'lsak, birinchi parametr sifatida &mut self dan foydalanamiz. Birinchi parametr sifatida faqat selfni ishlatib, misolga ownershiplik qiladigan metod kamdan-kam uchraydi; bu metod odatda selfni boshqa narsaga aylantirganda va siz murojat qiluvchiga transformatsiyadan keyin asl nusxadan foydalanishiga yo'l qo'ymaslikni istasangiz ishlatiladi.

Funktsiyalar o'rniga metodlardan foydalanishning asosiy sababi, har bir metod signaturesida selfturini takrorlashning hojati bo'lmagan metod sintaksisidan tashqari, kodni tashkil qilishdir. Biz kelajakdagi kod foydalanuvchilarini biz taqdim etayotgan kutubxonaning turli joylarida Kvadrat imkoniyatlarini izlashga majburlashdan ko‘ra, biz tur namunasi bilan qila oladigan barcha narsalarni bitta impl blokiga joylashtirdik.

E'tibor bering, biz metodga structning maydonlaridan biri bilan bir xil nom berishni tanlashimiz mumkin. Misol uchun, biz Kvadrat da kenglik deb nomlangan metodni belgilashimiz mumkin:

Fayl nomi: src/main.rs

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}

impl Kvadrat {
    fn kenglik(&self) -> bool {
        self.kenglik > 0
    }
}

fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };

    if kvadrat1.kenglik() {
        println!("To'rtburchakning kengligi nolga teng bo'lmagan; bu {}", kvadrat1.kenglik);
    }
}

Bu yerda, agar misolning kenglik maydonidagi qiymat 0 dan katta bo‘lsa, kenglik metodi true qiymatini qaytaradi, agar qiymat 0 bo'lsa, false bo‘lishini tanlaymiz: biz bir xil nomdagi metod ichidagi maydonni istalgan maqsadda ishlatishimiz mumkin. main da, biz qavslar bilan kvadrat1.kenglik ga amal qilsak, Rust kenglik metodini nazarda tutayotganimizni biladi. Qavslardan foydalanmasak, Rust kenglik maydonini nazarda tutayotganimizni biladi.

Ko'pincha, lekin har doim emas, biz metodga maydon bilan bir xil nom berganimizda, biz u faqat maydondagi qiymatni qaytarishini va boshqa hech narsa qilmasligini xohlaymiz. Shunga o'xshash metodlar getters deb ataladi va Rust ularni boshqa tillarda bo'lgani kabi tizim maydonlari uchun avtomatik ravishda amalga oshirmaydi. Getterslar foydalidir, chunki siz maydonni shaxsiy(private), lekin metodni hammaga ochiq(public) qilib qo'yishingiz mumkin va shu tariqa ushbu maydonga umumiy API ning bir qismi sifatida faqat o'qish uchun ruxsatni yoqishingiz mumkin. Biz 7-bobda public va private nima ekanligini va qanday qilib maydon yoki metodni public yoki private deb belgilashni muhokama qilamiz.

-> operatori qayerda ishlatiladi?

C va C++ tillarida metodlarni chaqirish uchun ikki xil operator qo'llaniladi: obyektdagi metodni to'g'ridan-to'g'ri chaqirayotgan bo'lsangiz . va agar siz ko'rsatgichdagi metodni obyektga chaqirayotgan bo'lsangiz va avval ko'rsatgichni yo'qotishingiz kerak bo'lsa -> dan foydalanasiz. Boshqacha qilib aytganda, agar object havola bo'lsa, u holda object->something() va (*object).something() metodi chaqiruvlari bir xil bo'ladi.

Rust -> operatoriga ekvivalentga ega emas; Buning o'rniga Rustda avtomatik reference va dereferencing deb nomlangan xususiyat mavjud. Metodni chaqirish Rustda bunday xatti-harakatlarga ega bo'lgan kam sonli joylardan biridir.

Bu shunday ishlaydi: object.something() bilan metodni chaqirganingizda, Rust avtomatik ravishda &, &mut yoki * ni qo'shadi, shuning uchun object metod signaturega mos keladi. Boshqacha qilib aytganda, quyidagilar bir xil:

#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
   fn masofa(&self, other: &Point) -> f64 {
       let x_kvadrat = f64::powi(other.x - self.x, 2);
       let y_kvadrat = f64::powi(other.y - self.y, 2);

       f64::sqrt(x_kvadrat + y_kvadrat)
   }
}
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 5.0, y: 6.5 };
p1.masofa(&p2);
(&p1).masofa(&p2);
}

Birinchisi ancha toza ko'rinadi. Ushbu avtomatik reference qilish harakati, metodlar aniq qabul qiluvchiga ega bo'lganligi sababli ishlaydi - self turi. Qabul qiluvchi va metod nomini hisobga olgan holda, Rust ma'lum bir holatda kod nima qilayotganini aniq aniqlashi mumkin: o'qish (&self), o'zgartirish (&mut self) yoki iste'mol qilish (self). Rust metodi qabul qiluvchilar uchun borrow qilishni yashirin qilib qo'yganligi amalda ownershipni ergonomik qilishning katta qismidir.

Ko'proq parametrlarga ega metodlar

Kvadrat structida ikkinchi metodni implement qilish orqali metodlardan foydalanishni mashq qilaylik. Bu safar biz Kvadrat misoli Kvadrat ning boshqa nusxasini olishini va agar ikkinchi Kvadrat to'liq o'ziga (birinchi Kvadrat) sig'ishi mumkin bo'lsa, true qiymatini qaytarishini istaymiz; aks holda u falseni qaytarishi kerak. Ya'ni, ushlab_tur metodini aniqlaganimizdan so'ng, biz 5-14 ro'yxatda ko'rsatilgan dasturni yozish imkoniyatiga ega bo'lishni xohlaymiz.

Fayl nomi: src/main.rs

fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };
    let kvadrat2 = Kvadrat {
        kenglik: 10,
        balandlik: 40,
    };
    let kvadrat3 = Kvadrat {
        kenglik: 60,
        balandlik: 45,
    };

    println!("kvadrat1 kvadrat2ni ushlab turadimi? {}", kvadrat1.ushlab_tur(&kvadrat2));
    println!("kvadrat1 kvadrat3ni ushlab turadimi? {}", kvadrat1.ushlab_tur(&kvadrat3));
}

Ro'yxat 5-14: Hali yozilmagan ushlab_tur dan foydalanish metodi

Kutilgan natija quyidagicha ko‘rinadi, chunki kvadrat2 ning ikkala o‘lchami kvadrat1 o‘lchamidan kichikroq, lekin kvadrat3 kvadrat1 dan kengroq:

kvadrat1 kvadrat2ni ushlab turadimi? true
kvadrat1 kvadrat3ni ushlab turadimi? false

Biz metodni aniqlamoqchi ekanligimizni bilamiz, shuning uchun u impl Kvadrat blokida bo'ladi. Metod nomi ushlab_tur bo'ladi va u parametr sifatida boshqa Kvadrat ning o'zgarmas borrowini oladi. Parametrning turi qanday bo'lishini metodni chaqiruvchi kodga qarab aniqlashimiz mumkin: kvadrat1.ushlab_tur(&kvadrat2) &kvadrat2 da o'tadi, bu kvadrat2 ga o'zgarmas borrow, Kvadrat misoli. Bu mantiqqa to'g'ri keladi, chunki biz faqat kvadrat2 ni o'qishimiz kerak (yozishdan ko'ra, bu bizga o'zgaruvchan borrow kerak degan ma'noni anglatadi), va biz main kvadrat2 ownershipligini saqlab qolishini istaymiz, shuning uchun ushlab_tur metodini chaqirganimizdan keyin uni qayta ishlatishimiz mumkin. ushlab_tur ning return qiymati mantiqiy qiymat bo'ladi va implement self ning kengligi va balandligi mos ravishda boshqa Kvadrat ning kengligi va balandligidan katta ekanligini tekshiradi. Keling, 5-15 ro'yxatda ko'rsatilgan 5-13 ro'yxatdagi impl blokiga yangi ushlab_tur metodini qo'shamiz.

Fayl nomi: src/main.rs

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}

impl Kvadrat {
    fn area(&self) -> u32 {
        self.kenglik * self.balandlik
    }

    fn ushlab_tur(&self, other: &Kvadrat) -> bool {
        self.kenglik > other.kenglik && self.balandlik > other.balandlik
    }
}

fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };
    let kvadrat2 = Kvadrat {
        kenglik: 10,
        balandlik: 40,
    };
    let kvadrat3 = Kvadrat {
        kenglik: 60,
        balandlik: 45,
    };

    println!("kvadrat1 kvadrat2ni ushlab turadimi? {}", kvadrat1.ushlab_tur(&kvadrat2));
    println!("kvadrat1 kvadrat3ni ushlab turadimi? {}", kvadrat1.ushlab_tur(&kvadrat3));
}

Ro'yxat 5-15: Parametr sifatida boshqa Kvadrat misolini oladigan ushlab_tur metodini Kvadratda qo'llash

Ushbu kodni 5-14 ro'yxatdagi main funksiya bilan ishga tushirganimizda, biz kerakli natijani olamiz. Metodlar biz signaturega self parametridan keyin qo'shadigan bir nechta parametrlarni olishi mumkin va bu parametrlar funksiyalardagi parametrlar kabi ishlaydi.

Associate Funksiyalar

Associate Funksiyalar (Bog'langan Funktsiyalar).impl blokida aniqlangan barcha funksiyalar associated funksiyalar deb ataladi, chunki ular impl nomi bilan atalgan tur bilan bog‘langan. Biz birinchi parametr sifatida self ega bo'lmagan associated funksiyalarni belgilashimiz mumkin (va shuning uchun metodlar emas), chunki ular bilan ishlash uchun turdagi namuna kerak emas. Biz allaqachon shunday funksiyadan foydalanganmiz: String turida aniqlangan String::from funksiyasi.

Metod bo'lmagan associated funktsiyalar ko'pincha structning yangi nusxasini qaytaradigan konstruktorlar uchun ishlatiladi. Ular ko'pincha new deb ataladi, ammo new maxsus nom emas va tilga kiritilmagan. Masalan, biz bir o‘lchamli parametrga ega bo‘lgan kvadrat nomli associated funksiyani taqdim etishimiz va undan kenglik va balandlik sifatida foydalanishimiz mumkin, bu esa bir xil qiymatni ikki marta belgilashdan ko‘ra Kvadrat kvadratini yaratishni osonlashtiradi. :

Fayl nomi: src/main.rs

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}

impl Kvadrat {
    fn kvadrat(size: u32) -> Self {
        Self {
            kenglik: size,
            balandlik: size,
        }
    }
}

fn main() {
    let kv = Kvadrat::kvadrat(3);
}

Return turidagi va funksiya tanasidagi Self kalit so'zlari impl kalit so'zidan keyin paydo bo'ladigan turning taxalluslari bo'lib, bu holda Kvadrat bo'ladi.We’ll discuss modules in Chapter 7.

Ushbu associated funktsiyani chaqirish uchun biz struct nomi bilan :: sintaksisidan foydalanamiz; let kv = Kvadrat::kvadrat(3); misol bo'la oladi. Bu funksiya struct tomonidan nom maydoniga ega: :: sintaksisi ham associated funksiyalar, ham modullar tomonidan yaratilgan nomlar bo'shliqlari uchun ishlatiladi. Biz modullarni 7-bobda muhokama qilamiz.

Bir nechta impl bloklari

Har bir structga bir nechta impl bloklari ruxsat etiladi. Masalan, 5-15 ro'yxati 5-16 ro'yxatida ko'rsatilgan kodga ekvivalent bo'lib, har bir metod o'zining impl blokiga ega yani har bir metod o'z impl blokida.

#[derive(Debug)]
struct Kvadrat {
    kenglik: u32,
    balandlik: u32,
}

impl Kvadrat {
    fn area(&self) -> u32 {
        self.kenglik * self.balandlik
    }
}

impl Kvadrat {
    fn ushlab_tur(&self, other: &Kvadrat) -> bool {
        self.kenglik > other.kenglik && self.balandlik > other.balandlik
    }
}

fn main() {
    let kvadrat1 = Kvadrat {
        kenglik: 30,
        balandlik: 50,
    };
    let kvadrat2 = Kvadrat {
        kenglik: 10,
        balandlik: 40,
    };
    let kvadrat3 = Kvadrat {
        kenglik: 60,
        balandlik: 45,
    };

    println!("kvadrat1 kvadrat2ni ushlab turadimi? {}", kvadrat1.ushlab_tur(&kvadrat2));
    println!("kvadrat1 kvadrat3ni ushlab turadimi? {}", kvadrat1.ushlab_tur(&kvadrat3));
}

Ro'yxat 5-16: Bir nechta impl bloklari yordamida 5-15 ro'yxatini qayta yozish

Bu metodlarni bir nechta impl bloklariga ajratish uchun hech qanday sabab yo'q, lekin bu to'g'ri sintaksis. Biz 10-bobda bir nechta impl bloklari foydali bo'lgan holatni ko'rib chiqamiz, bu yerda biz umumiy turlar va taritlarni muhokama qilamiz.

Xulosa

Structlar sizning domeningiz uchun mazmunli bo'lgan maxsus turlarni yaratishga imkon beradi. Structlardan foydalanib, siz bog'langan ma'lumotlar qismlarini bir-biriga bog'lab qo'yishingiz va kodingizni aniq qilish uchun har bir qismga nom berishingiz mumkin. impl bloklarida siz o'zingizning turingiz bilan bog'liq bo'lgan funksiyalarni belgilashingiz mumkin va metodlar - bu sizning structlaringiz misollarining xatti-harakatlarini belgilashga imkon beruvchi associated funksiyaning bir turi.

Ammo structlar maxsus turlarni yaratishning yagona usuli emas: toolboxga boshqa toolni qo'shish uchun Rust enum xususiyatiga murojaat qilaylik.

Enumlar va Pattern Match

Ushbu bobda biz enumlar deb ham ataladigan enumerationsni ko'rib chiqamiz. Enumlar sizga turni uning mumkin bo'lgan variantlarini sanab aniqlash imkonini beradi. Avval enum ma'lumotarni qanday birlashtirishi mumkinligini ko'rsatish uchun enumni aniqlaymiz va ishlatamiz. Keyinchalik, qiymatning biror narsa yoki hech narsa bo'lishi mumkinligini ifodalovchi Option deb nomlangan juda foydali enumni o'rganamiz. Keyin biz match iborasida pattern matching enumning turli qiymatlari uchun turli kodlarni ishga tushirishni qanday osonlashtirishini ko'rib chiqamiz. Nihoyat, if let konstruksiyasi sizning kodingizdagi enumlar bilan ishlash uchun qanday qulay va ixcham idioma ekanligini ko'rib chiqamiz.

Enumni aniqlash

Structlar sizga tegishli maydonlar va ma'lumotlarni, masalan, kenglik va balandlik bilan Kvadrat ni guruhlash usulini beradigan bo'lsa, enumlar qiymatni mumkin bo'lgan qiymatlar to'plamidan biri deb aytish metodini beradi. Masalan, Kvadrat bu mumkin bo‘lgan shakllar to‘plamidan biri bo‘lib, Doira va Uchburchakni ham o‘z ichiga oladi, demoqchimiz. Buning uchun Rust bizga ushbu imkoniyatlarni enum sifatida kodlash imkonini beradi.

Keling, kodda ifodalashni xohlashimiz mumkin bo'lgan vaziyatni ko'rib chiqaylik va bu holda nima uchun enumlar foydali va structlardan ko'ra mosroq ekanligini bilib olaylik. Aytaylik, biz IP manzillar bilan ishlashimiz kerak. Hozirgi vaqtda IP manzillar uchun ikkita asosiy standart qo'llaniladi: to'rtinchi versiya va oltinchi versiya. Bular bizning dasturimiz duch keladigan IP-manzilning yagona imkoniyatlari bo'lgani uchun biz barcha mumkin bo'lgan variantlarni enumerate qilishimiz mumkin, bu yerda enumeration o'z nomini oladi.

Har qanday IP manzil to'rtinchi versiya yoki oltinchi versiya manzili bo'lishi mumkin, lekin ikkalasi bir vaqtning o'zida emas. IP-manzillarning bu xususiyati enum ma'lumotlar structini mos qiladi, chunki enum qiymati faqat uning variantlaridan biri bo'lishi mumkin. To'rtinchi versiya va oltinchi versiya manzillari hali ham IP-manzillardir, shuning uchun kod har qanday IP-manzilga tegishli vaziyatlarni ko'rib chiqayotganda ular bir xil turdagi sifatida ko'rib chiqilishi kerak.

Biz ushbu kontseptsiyani kodda IpAddrKind ro'yxatini belgilash va IP-manzil bo'lishi mumkin bo'lgan V4 va V6 turlarini enumeration qilish orqali ifodalashimiz mumkin. Bular enumning variantlari:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let tort = IpAddrKind::V4;
    let olti = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_turi: IpAddrKind) {}

IpAddrKind endi biz kodimizning boshqa joylarida foydalanishimiz mumkin bo'lgan maxsus ma'lumotlar turidir.

Enum qiymatlari

Biz IpAddrKind ning ikkita variantining har birining misollarini quyidagicha yaratishimiz mumkin:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let tort = IpAddrKind::V4;
    let olti = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_turi: IpAddrKind) {}

E'tibor bering, enumning variantlari uning identifikatori ostida nom maydonida joylashgan va biz ikkalasini ajratish uchun qo'sh nuqtadan foydalanamiz. Bu foydali, chunki endi ikkala IpAddrKind::V4 va IpAddrKind::V6 qiymatlari bir xil turdagi: IpAddrKind. Masalan, biz har qanday IpAddrKind ni qabul qiladigan funksiyani aniqlashimiz mumkin:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let tort = IpAddrKind::V4;
    let olti = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_turi: IpAddrKind) {}

Va biz bu funktsiyani ikkala variant bilan chaqirishimiz mumkin:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let tort = IpAddrKind::V4;
    let olti = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_turi: IpAddrKind) {}

Enumlardan foydalanish yanada ko'proq afzalliklarga ega. Bizning IP manzilimiz turi haqida ko'proq o'ylab ko'rsak, hozirda bizda haqiqiy IP-manzilni ma'lumotlarni saqlash imkoni yo'q; biz faqat qanday turdagi ekanligini bilamiz. 5-bobda structlar haqida hozirgina bilib olganingizni hisobga olsak, 6-1 ro'yxatda ko'rsatilganidek, bu muammoni structlar yordamida hal qilish istagi paydo bo'lishi mumkin.

fn main() {
    enum IpAddrKind {
        V4,
        V6,
    }

    struct IpAddr {
        tur: IpAddrKind,
        manzil: String,
    }

    let asosiy = IpAddr {
        tur: IpAddrKind::V4,
        manzil: String::from("127.0.0.1"),
    };

    let orqaga_qaytish = IpAddr {
        tur: IpAddrKind::V6,
        manzil: String::from("::1"),
    };
}

Ro'yxat 6-1: struct yordamida IP manzilining ma'lumotlarini va IpAddrKind variantini saqlash

Bu yerda biz ikkita maydonga ega boʻlgan IpAddr structini aniqladik: IpAddrKind turidagi tur maydoni (biz avvalroq belgilagan raqam) va String tipidagi manzil maydoni. Bizda bu structning ikkita misoli bor. Birinchisi asosiy boʻlib, u 127.0.0.1 bogʻlangan manzil maʼlumotlari bilan tur sifatida IpAddrKind::V4 qiymatiga ega. Ikkinchi misol - orqaga_qaytish. U tur qiymati sifatida IpAddrKind ning boshqa variantiga ega, V6 va u bilan bog'langan ::1 manzili mavjud. Biz tur va manzil qiymatlarini birlashtirish uchun structdan foydalanganmiz, shuning uchun endi variant qiymat bilan bog'langan.

Shu bilan birga, bir xil kontseptsiyani faqat enum yordamida ifodalash yanada ixchamroqdir: struct ichidagi enum o'rniga, biz ma'lumotlarni to'g'ridan-to'g'ri har bir enum variantiga qo'yishimiz mumkin. IpAddr enumining ushbu yangi ta'rifida aytilishicha, V4 va V6 variantlari ham associated String qiymatlariga ega bo'ladi:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let asosiy = IpAddr::V4(String::from("127.0.0.1"));

    let orqaga_qaytish = IpAddr::V6(String::from("::1"));
}

Biz to'g'ridan-to'g'ri enumning har bir variantiga ma'lumotlarni biriktiramiz, shuning uchun qo'shimcha structga ehtiyoj qolmaydi. Bu yerda, shuningdek, enumlar qanday ishlashining yana bir tafsilotini ko'rish osonroq bo'ladi: biz belgilagan har bir enum variantining nomi, shuningdek, enum nusxasini yaratuvchi funktsiyaga aylanadi. Ya'ni, IpAddr::V4() funksiya chaqiruvi bo'lib, u String argumentini oladi va IpAddr tipidagi misolni qaytaradi. Enumni aniqlash natijasida aniqlangan ushbu konstruktor funksiyasini avtomatik ravishda olamiz.

Structdan ko'ra enumdan foydalanishning yana bir afzalligi bor: har bir variantda bog'langan ma'lumotlarning har xil turlari va miqdori bo'lishi mumkin. To'rtinchi versiyada IP-manzillar har doim 0 dan 255 gacha bo'lgan qiymatlarga ega bo'lgan to'rtta raqamli komponentga ega bo'ladi. Agar biz V4 manzillarini to‘rtta u8 qiymati sifatida saqlamoqchi bo‘lsak-da, V6 manzillarini bitta String qiymati sifatida ifodalasak, biz struct bilan buni qila olmaymiz. Enumlar bu ishni osonlik bilan hal qiladi:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let asosiy = IpAddr::V4(127, 0, 0, 1);

    let orqaga_qaytish = IpAddr::V6(String::from("::1"));
}

Biz to'rtinchi versiya va oltinchi versiya IP manzillarini saqlash uchun ma'lumotlar tuzilmalarini aniqlashning bir necha xil usullarini ko'rsatdik. Biroq, ma'lum bo'lishicha, IP-manzillarni saqlash va ularning qaysi turini kodlash istagi shunchalik keng tarqalganki, standart kutubxonada biz foydalanishimiz mumkin bo'lgan defination mavjud! . Keling, standart kutubxona IpAddr ni qanday aniqlashini ko'rib chiqaylik: u biz aniqlagan va ishlatgan aniq enum va variantlarga ega, lekin u manzil ma'lumotlarini variantlar ichida ikki xil struct shaklida joylashtiradi, har bir variant uchun turlicha belgilanadi:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

Ushbu kod har qanday turdagi ma'lumotlarni enum variantiga qo'yish mumkinligini ko'rsatadi: masalan, stringlar, raqamli turlar yoki structlar. Siz hatto boshqa raqamni ham qo'shishingiz mumkin! Bundan tashqari, standart kutubxona turlari ko'pincha siz o'ylab topganingizdan ancha murakkab emas.

E'tibor bering, standart kutubxonada IpAddr uchun definition mavjud bo'lsa ham, biz o'z definitionimizni ziddiyatli holda yaratishimiz va foydalanishimiz mumkin, chunki biz standart kutubxonaning definitionini o'z doiramizga kiritmaganmiz. Biz 7-bobda turlarni qamrab olish haqida ko'proq gaplashamiz.

Keling, 6-2 ro'yxatdagi enumning yana bir misolini ko'rib chiqaylik: bu o'z variantlarida ko'p turdagi turlarga ega.

enum Xabar {
    Chiqish,
    Kochirish { x: i32, y: i32 },
    Yozish(String),
    RangTanlash(i32, i32, i32),
}

fn main() {}

Ro'yxat 6-2: Xabar enumi, uning variantlari har xil miqdor va qiymat turlarini saqlaydi

Ushbu enum har xil turdagi to'rtta variantga ega:

• Chiqishda u bilan bogʻliq hech qanday maʼlumot yoʻq.
• Kochirish da struct kabi maydonlarni nomlagan.
• Yozish bitta String ni o'z ichiga oladi.
• RangTanla uchta i32 qiymatini o'z ichiga oladi.

Enumni 6-2-roʻyxatdagi kabi variantlar bilan belgilash strukturaviy definitionlarning har xil turlarini aniqlashga oʻxshaydi, faqat enum struct kalit soʻzidan foydalanmaydi va barcha variantlar Xabar turi ostida birlashtiriladi. Quyidagi structlar oldingi enum variantlari bilan bir xil ma'lumotlarni saqlashi mumkin:

struct ChiqishXabar; // unit struct
struct KochirishXabar {
    x: i32,
    y: i32,
}
struct YozishXabar(String); // tuple struct
struct RangTanshlaXabar(i32, i32, i32); // tuple struct

fn main() {}

Lekin biz o'z turlariga ega bo'lgan turli structlardan foydalanganimizda, biz har qanday xabar turini qabul qiladigan funksiyalarni osonlikcha aniqlay olmadik, buni bitta tur bo'lgan 6-2 ro'yxatda e'lon qilingan Xabar turini enum bilan amalga oshirish mumkin.

Enumlar va structlar o'rtasida yana bir o'xshashlik bor: biz impl yordamida structlarda metodlarni aniqlay olganimizdek, enumlarda ham metodlarni belgilashimiz mumkin. Bu yerda biz Xabar enumimizda aniqlashimiz mumkin bo'lgan chaqiruv deb nomlangan metod:

fn main() {
    enum Xabar {
        Chiqish,
        Kochirish { x: i32, y: i32 },
        Yozish(String),
        RangTanlash(i32, i32, i32),
    }

    impl Xabar {
        fn chaqiruv(&self) {
            // metod tanasi bu yerda aniqlanadi
        }
    }

    let m = Xabar::Yozish(String::from("salom"));
    m.chaqiruv();
}

Metod tanasi biz metod deb atagan qiymatni olish uchun self ishlatadi. Ushbu misolda biz Xabar::Yozish(String::from("salom")) qiymatini o'z ichiga olgan m o'zgaruvchisini yaratdik va m.chaqiruv() ishga tushganda chaqiruv metodining tanasida aynan shunday boladi. Keling, standart kutubxonadagi juda keng tarqalgan va foydali bo'lgan yana bir enumni ko'rib chiqaylik: Option`.

Option Enum va uning null qiymatlardan ustunligi

Ushbu bo'lim standart kutubxona tomonidan aniqlangan yana bir enum bo'lgan Option ning misolini o'rganadi.Option turi qiymat nimadir yoki hech narsa bo'lmasligi mumkin bo'lgan juda keng tarqalgan senariyni kodlaydi.

Misol uchun, agar siz bo'sh bo'lmagan ro'yxatdagi birinchi elementni so'rasangiz, qiymat olasiz. Agar siz bo'sh ro'yxatdagi birinchi elementni so'rasangiz, hech narsa olmaysiz. Ushbu kontseptsiyani turdagi tizim nuqtai nazaridan ifodalash kompilyator siz ko'rib chiqishingiz kerak bo'lgan barcha ishlarni ko'rib chiqqaningizni tekshirishi mumkinligini anglatadi; bu funksiya boshqa dasturlash tillarida juda keng tarqalgan xatolarni oldini oladi.

Dasturlash tilining dizayni ko'pincha siz qaysi xususiyatlarni o'z ichiga olganligingiz nuqtai nazaridan o'ylanadi, ammo siz chiqarib tashlagan xususiyatlar ham muhimdir. Rust ko'plab boshqa tillarda mavjud bo'lgan null xususiyatiga ega emas. Null - bu qiymat yo'qligini bildiradi. Null bo'lgan tillarda o'zgaruvchilar har doim ikkita holatdan birida bo'lishi mumkin: null yoki null emas.

2009 yilgi "Null References: The Million Dollar Mistake" taqdimotida null ixtirochisi Tony Hoare shunday deydi:

Men buni milliard dollarlik xatoyim deb atayman. O'sha paytda men object-oriented language referencelar uchun birinchi keng qamrovli turdagi tizimni loyihalashtirgan edim. Mening maqsadim referencelardan foydalanishning mutlaqo xavfsiz bo'lishini ta'minlash edi, tekshirish kompilyator tomonidan avtomatik ravishda amalga oshiriladi. Lekin men null reference qo'yish vasvasasiga qarshi tura olmadim, chunki uni amalga oshirish juda oson edi. Bu so'nggi qirq yil ichida bir milliard dollar og'riq va zarar keltirgan son-sanoqsiz xatolar, zaifliklar va tizimning ishdan chiqishiga olib keldi.

Null qiymatlari bilan bog'liq muammo shundaki, agar siz null qiymatdan a sifatida foydalanishga harakat qilsangiz no-null qiymat bo'lsa, siz qandaydir xatoga duch kelasiz. Ushbu null yoki not-null xususiyat keng tarqalganligi sababli, bunday xatoga yo'l qo'yish juda oson.

Biroq, null ifodalamoqchi bo'lgan kontseptsiya hali ham foydalidir: null hozirda yaroqsiz yoki biron sababga ko'ra mavjud bo'lmagan qiymatdir.

Muammo aslida kontseptsiyada emas, balki muayyan amalga oshirishda. Shunday qilib, Rust nulllarga ega emas, lekin u mavjud yoki yo'q qiymat tushunchasini kodlay oladigan enumga ega. Bu enum Option<T> bo'lib, u standart kutubxona tomonidan quyidagicha aniqlanadi:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Option<T> enumi shunchalik foydaliki, u hatto muqaddimaga ham kiritilgan; uni aniq doiraga kiritishingiz shart emas. Uning variantlari ham muqaddima tarkibiga kiritilgan: Some va None dan Option:: prefiksisiz bevosita foydalanishingiz mumkin. Option<T> enum hali ham oddiy enum bo'lib, Some(T) va None hali ham Option<T> turidagi variantlardir.

<T> sintaksisi Rustning oʻziga xos xususiyati boʻlib, biz hali gaplashmaganmiz. Bu umumiy turdagi parametr va biz 10-bobda genericlarni batafsil ko'rib chiqamiz. Hozircha siz bilishingiz kerak bo'lgan narsa shuki, <T> Option enumining Some varianti har qanday turdagi ma'lumotlarning bir qismini saqlashi mumkinligini va o'rniga qo'llaniladigan har bir konkret turni bildiradi. T umumiy Option<T> turini boshqa turga aylantiradi. Raqam turlari va qator turlarini saqlash uchun Option qiymatlaridan foydalanishga misollar keltiramiz:

fn main() {
    let raqam = Some(5);
    let belgi = Some('e');

    let yoq_raqam: Option<i32> = None;
}

raqam turi - Option<i32>. belgi turi Option<char> bo'lib, u boshqa tur. Rust bu turlarni aniqlashi mumkin, chunki biz Some variantida qiymat belgilaganmiz. yoq_raqam uchun Rust bizdan umumiy Option turiga izoh berishimizni talab qiladi: kompilyator faqat None qiymatiga qarab mos keladigan Some varianti qanday turga ega bo'lishini aniqlay olmaydi. Bu yerda biz Rustga aytamizki, biz yoq_raqam Option<i32> turida bo'lishini nazarda tutamiz.

Agar bizda Some qiymati bo'lsa, biz qiymat mavjud ekanligini va qiymat Some ichida saqlanishini bilamiz. Agar bizda None qiymati bo'lsa, u qaysidir ma'noda null bilan bir xil narsani anglatadi: bizda haqiqiy qiymat yo'q. Xo'sh, nega Option<T> nullga ega bo'lishdan yaxshiroq?

Xulosa qilib aytganda, Option<T> va T (bu erda T har qanday tur bo'lishi mumkin) har xil turdagi, chunki kompilyator bizga Option<T> qiymatidan foydalanishga ruxsat bermaydi, go'yo bu haqiqiy qiymat. Masalan, bu kod kompilyatsiya qilinmaydi, chunki u Option<i8>ga i8 qo`shishga harakat qilmoqda:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let natija = x + y;
}

Agar biz ushbu kodni ishlatsak, biz quyidagi kabi xato xabarini olamiz:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let natija = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
  = help: the following other types implement trait `Add<Rhs>`:
            <&'a i8 as Add<i8>>
            <&i8 as Add<&i8>>
            <i8 as Add<&i8>>
            <i8 as Add>

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` due to previous error

Kuchli! Aslida, bu xato xabari Rust i8 va Option<i8> ni qanday qo'shishni tushunmasligini anglatadi, chunki ular turli xil. Rustda i8 kabi turdagi qiymatga ega bo'lsak, kompilyator bizda har doim haqiqiy qiymatga ega bo'lishini ta'minlaydi. Ushbu qiymatdan foydalanishdan oldin nullni tekshirmasdan ishonch bilan davom etishimiz mumkin. Faqat bizda Option<i8> (yoki qanday turdagi qiymat bilan ishlayotgan bo'lishimizdan qat'iy nazar) mavjud bo'lganda, biz qiymatga ega bo'lmasligimizdan xavotirlanishimiz kerak va kompilyator qiymatdan foydalanishdan oldin bu holatni hal qilishimizga ishonch hosil qiladi.

Boshqacha qilib aytganda, T amallarini bajarishdan oldin Option<T>ni T ga aylantirishingiz kerak. Umuman olganda, bu null bilan bog'liq eng keng tarqalgan muammolardan birini hal qilishga yordam beradi: agar biror narsa bo'lsa, u null emas deb taxmin qilish.

Null bo'lmagan qiymatni noto'g'ri qabul qilish xavfini yo'q qilish kodingizga ko'proq ishonch hosil qilishingizga yordam beradi. Null bo'lishi mumkin bo'lgan qiymatga ega bo'lish uchun, siz ushbu qiymatning turini Option<T> qilib aniq belgilashingiz kerak. Keyin, ushbu qiymatdan foydalanganda, qiymat null bo'lsa, ishni aniq ko'rib chiqishingiz talab qilinadi. Qiymat Option<T> bo'lmagan turga ega bo'lgan har bir joyda, qiymat null emas deb ishonch bilan taxmin qilishingiz mumkin. Bu Rust uchun nullning tarqalishini cheklash va Rust kodining xavfsizligini oshirish uchun ataylab qilingan dizayn qarori edi.

Xo'sh, Option<T> turidagi qiymatga ega bo'lganingizda, Some variantidan T qiymatini qanday qilib olish mumkin, shunda siz ushbu qiymatdan foydalanishingiz mumkin? Option<T> enumi turli vaziyatlarda foydali boʻlgan koʻp sonli usullarga ega; siz ularni uning hujjatlarida tekshirishingiz mumkin. Option<T> dagi metodlar bilan tanishish Rust bilan sayohatingizda juda foydali bo`ladi.

Umuman olganda, Option<T> qiymatidan foydalanish uchun siz har bir variantni boshqaradigan kodga ega bo'lishni xohlaysiz. Siz faqat Some(T) qiymatiga ega bo'lganingizda ishlaydigan ba'zi kodni xohlaysiz va bu kod ichki T dan foydalanishga ruxsat etiladi. Agar sizda None qiymati bo'lsa va bu kodda T qiymati bo'lmasa, ishlaydigan boshqa kod ham kerak bo'ladi. match ifodasi control flow konstruksiyasi bo‘lib, u enumlar bilan foydalanilganda aynan shunday qiladi: u enumning qaysi variantiga ega bo‘lishiga qarab turli xil kodlarni ishga tushiradi va bu kod mos keladigan qiymat ichidagi ma’lumotlardan foydalanishi mumkin.

match Control Flow konstruksiyasi

Rust match deb nomlangan juda kuchli control flow konstruksiyasiga ega, bu sizga qiymatni bir qator patternlar bilan solishtirish va keyin qaysi pattern mos kelishiga qarab kodni bajarish imkonini beradi. Patternlar literal qiymatlar, o'zgaruvchilar nomlari, wildcardlar va boshqa ko'plab narsalardan iborat bo'lishi mumkin; 18-bobda har xil turdagi patternlar va ular bajaradigan ishlar yoritilgan. matchning kuchi patternlarning ifodaliligidan va kompilyator barcha mumkin bo'lgan holatlar ko'rib chiqilishini tasdiqlashidan kelib chiqadi.

match iborasini tanga saralash mashinasiga o'xshatib tasavvur qiling: tangalar bo'ylab turli o'lchamdagi teshiklari bo'lgan yo'ldan pastga siljiydi va har bir tanga o'zi mos keladigan birinchi teshikdan tushadi. Xuddi shu tarzda, qiymatlar match dagi har bir patterndan o'tadi va birinchi patternda qiymat “fits,”, qiymat bajarish paytida ishlatiladigan tegishli kod blokiga tushadi.

Tangalar haqida gap ketganda, keling, ularni match yordamida misol qilib olaylik! Biz noma'lum AQSH tangasini oladigan funksiyani yozishimiz mumkin va xuddi sanash mashinasiga o'xshab uning qaysi tanga ekanligini aniqlaydi va 6-3 ro'yxatda ko'rsatilganidek, uning qiymatini sentlarda qaytaradi.

enum Tanga {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn sentdagi_qiymat(tanga: Tanga) -> u8 {
    match tanga {
        Tanga::Penny => 1,
        Tanga::Nickel => 5,
        Tanga::Dime => 10,
        Tanga::Quarter => 25,
    }
}

fn main() {}

Ro'yxat 6-3: Enum va match ifodasi, uning namunalari sifatida enumning variantlari mavjud

Keling, sentdagi_qiymat funksiyasidagi match ni ajratamiz. Avval biz match kalit so'zidan keyin ifodani keltiramiz, bu holda bu qiymat tanga bo'ladi. Bu if bilan ishlatiladigan shartli ifodaga juda o'xshaydi, lekin katta farq bor: if bilan shart mantiqiy qiymatga baholanishi kerak, ammo bu yerda u har qanday turdagi bo'lishi mumkin. Ushbu misoldagi tanga turi biz birinchi qatorda belgilagan Tanga enumidir.

Keyingi match armlari. Arm ikki qismdan iborat: pattern va ba'zi kod. Bu yerdagi birinchi arm Tanga::Penny qiymati boʻlgan patternga ega, soʻngra ishlash uchun pattern va kodni ajratuvchi => operatori. Bu holatda kod faqat 1 qiymatidan iborat. Har bir arm keyingisidan vergul bilan ajratiladi.

match ifodasi bajarilganda, natijaviy qiymatni har bir armning patterniga solishtiradi. Agar pattern qiymatga mos kelsa, ushbu pattern bilan bog'langan kod bajariladi. Agar bu pattern qiymatga mos kelmasa, ijro tanga saralash mashinasida bo'lgani kabi keyingi armda davom etadi. Bizda qancha arm kerak bo'lsa, shuncha arm bo'lishi mumkin: 6-3 ro'yxatda bizning matchimizda to'rtta arm bor.

Har bir arm bilan bog'langan kod ifodadir va mos keladigan qismdagi ifodaning natijaviy qiymati butun match ifodasi uchun qaytariladigan qiymatdir.

Agar mos keladigan arm kodi qisqa bo'lsa, biz odatda jingalak qavslardan foydalanmaymiz, chunki bu ro'yxat 6-3da bo'lgani kabi, har bir arm shunchaki qiymat qaytaradi. Agar siz mos keladigan chiziqda bir nechta kod qatorlarini ishlatmoqchi bo'lsangiz, jingalak qavslardan foydalaning va armdan keyingi vergul ixtiyoriy bo'ladi. Masalan, quyidagi kodda Omadli tanga! metod har safar Tanga::Penny bilan chaqirilganda, lekin baribir blokning oxirgi qiymatini qaytaradi, 1:

enum Tanga {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn sentdagi_qiymat(tanga: Tanga) -> u8 {
    match tanga {
        Tanga::Penny => {
            println!("Omadli tanga!");
            1
        }
        Tanga::Nickel => 5,
        Tanga::Dime => 10,
        Tanga::Quarter => 25,
    }
}

fn main() {}

Qiymatlarni bog'laydigan patternlar

match armlarining yana bir foydali xususiyati shundaki, ular patternga mos keladigan qiymatlarning qismlarini bog'lashlari mumkin. Enum variantlaridan qiymatlarni shunday chiqarishimiz mumkin.

Misol tariqasida, uning ichida ma'lumotlarni saqlash uchun enum variantlarimizdan birini o'zgartiraylik. 1999 yildan 2008 yilgacha Qo'shma Shtatlar bir tomondan 50 shtatning har biri uchun turli dizayndagi tangalarni bosib chiqardi. Boshqa hech qanday tangalar davlat dizayniga ega emas, shuning uchun faqat quarterlarda bunday qo'shimcha qiymat mavjud. Biz ushbu maʼlumotni Quarter variantini uning ichida saqlangan UsState qiymatini kiritish uchun oʻzgartirish orqali enumga qoʻshishimiz mumkin, biz buni 6-4 roʻyxatda qilganmiz.

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Tanga {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {}

Roʻyxat 6-4: Quarter varianti ham UsState qiymatiga ega boʻlgan Tanga enumi

Tasavvur qiling-a, sizning do'stingiz barcha 50 shtatdan quarter yig'ishga harakat qilmoqda. Biz tangalar turi bo'yicha saralashimiz bilan birga, agar do'stimizda yo'q bo'lsa, ular uni o'z kollektsiyasiga qo'shishlari uchun har quarter bilan bog'liq shtat nomini ham chaqiramiz.

Ushbu kod uchun match ifodasida biz Tanga::Quarter varianti qiymatlariga mos keladigan patternga shtat deb nomlangan o'zgaruvchini qo‘shamiz. Tanga::Quarter mos kelganda, shtat o'zgaruvchisi o'sha quarter holati qiymatiga bog'lanadi. Keyin biz ushbu arm uchun kodda shtat dan foydalanishimiz mumkin, masalan:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Tanga {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn sentdagi_qiymat(tanga: Tanga) -> u8 {
    match tanga {
        Tanga::Penny => 1,
        Tanga::Nickel => 5,
        Tanga::Dime => 10,
        Tanga::Quarter(shtat) => {
            println!("{:?} dan shtat quarter!", shtat);
            25
        }
    }
}

fn main() {
    sentdagi_qiymat(Tanga::Quarter(UsState::Alaska));
}

Agar biz sentdagi_qiymat(Tanga::Quarter(UsState::Alaska)) deb ataydigan bo'lsak, tanga Tanga::Quarter(UsState::Alaska) bo'ladi. Ushbu qiymatni har bir match armi bilan solishtirganda, biz Tanga::Quarter(shtat) ga yetguncha ularning hech biri mos kelmaydi. O'sha paytda shtat uchun majburiy UsState::Alaska qiymati bo'ladi. Keyin biz bu bog'lanishni println! ifodasida qo'llashimiz mumkin, shu bilan Quarter uchun Tanga enum variantidan ichki holat qiymatini olamiz.

Option<T> uchun Match

Oldingi bo'limda biz Option<T> dan foydalanilganda Some holatidan ichki T qiymatini olishni xohladik; Biz, shuningdek, Tanga enum bilan qilganimizdek, match yordamida Option<T>ni boshqarishimiz mumkin! Tangalarni solishtirish o'rniga, biz Option<T> variantlarini solishtiramiz, lekin match ifodasining ishlash usuli bir xil bo'lib qoladi.

Aytaylik, biz Option<i32> ni oladigan funksiya yozmoqchimiz va agar ichida qiymat bo'lsa, bu qiymatga 1 qo'shiladi. Agar ichida qiymat bo'lmasa, funktsiya None qiymatini qaytarishi va hech qanday operatsiyani bajarishga urinmasligi kerak.

Ushbu funktsiyani yozish juda oson, match tufayli va 6-5-Ro'yxatga o'xshaydi.

fn main() {
    fn bir_qoshish(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let besh = Some(5);
    let olti = bir_qoshish(besh);
    let yoq = bir_qoshish(None);
}

Roʻyxat 6-5: Optionda match ifodasidan foydalanadigan funksiya`

Keling, bir_qoshish ning birinchi bajarilishini batafsilroq ko'rib chiqamiz. Biz bir_qoshish(besh) ni chaqirganimizda, bir_qoshish tanasidagi x o'zgaruvchisi Some(5) qiymatiga ega bo'ladi. Keyin biz buni har bir matchning armi bilan taqqoslaymiz:

fn main() {
    fn bir_qoshish(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let besh = Some(5);
    let olti = bir_qoshish(besh);
    let yoq = bir_qoshish(None);
}

Some(5) qiymati None patterniga mos kelmaydi, shuning uchun keyingi armga o'tamiz:

fn main() {
    fn bir_qoshish(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let besh = Some(5);
    let olti = bir_qoshish(besh);
    let yoq = bir_qoshish(None);
}

Some(5) ga Some(i) pattern mos keladimi? Ha bu shunday! Bizda ham xuddi shunday variant bor. Keyin i o'zgaruvchisi Some ichidagi qiymatga bog'lanadi, shuning uchun i 5 qiymatini oladi. Shundan so'ng match armidagi kod bajariladi, shuning uchun biz i qiymatiga 1 qo'shamiz va ichida jami 6 bo'lgan yangi Some qiymatini yaratamiz.

Keling, 6-5-Ro'yxatdagi bir_qoshish ning ikkinchi chaqiruvini ko'rib chiqaylik, bunda x None. Biz match ga kiramiz va birinchi arm bilan taqqoslaymiz:

fn main() {
    fn bir_qoshish(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let besh = Some(5);
    let olti = bir_qoshish(besh);
    let yoq = bir_qoshish(None);
}

Bu mos keladi! Qo'shiladigan qiymat yo'q, shuning uchun dastur to'xtaydi va => o'ng tomonidagi None qiymatini qaytaradi. Birinchi arm mos kelganligi sababli, boshqa armlar taqqoslanmaydi.

match va enumlarni birlashtirish ko'p holatlarda foydalidir. Rust kodida siz ushbu patterni juda ko'p ko'rasiz: enum bilan match, o'zgaruvchini ichidagi ma'lumotlarga bog'lang va keyin unga asoslangan kodni bajaring. Avvaliga bu biroz qiyin, lekin ko'nikkaningizdan so'ng uni barcha tillarda bo'lishini xohlaysiz. Bu har doim foydalanuvchilarning sevimli texnikasi.

Match barcha qiymat variantlarini qamrab oladi

Biz muhokama qilishimiz kerak bo'lgan match ning yana bir jihati bor: arm patterlari barcha imkoniyatlarni qamrab olishi kerak. Xatoga ega va kompilyatsiya qilinmaydigan bir_qoshish funksiyamizning ushbu versiyasini ko'rib chiqing:

fn main() {
    fn bir_qoshish(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let besh = Some(5);
    let olti = bir_qoshish(besh);
    let yoq = bir_qoshish(None);
}

Biz None holatini ko‘rib chiqmadik, shuning uchun bu kod xatolikka olib keladi. Yaxshiyamki, bu xato Rust qanday tutishni biladi. Agar biz ushbu kodni kompilyatsiya qilishga harakat qilsak, biz ushbu xatoni olamiz:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
 --> src/main.rs:3:15
  |
3 |         match x {
  |               ^ pattern `None` not covered
  |
note: `Option<i32>` defined here
 --> /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/option.rs:518:1
  |
  = note:
/rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/option.rs:522:5: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~             Some(i) => Some(i + 1),
5 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` due to previous error

Rust biz barcha mumkin bo'lgan holatlarni qamrab olmaganimizni biladi va hatto qaysi patterni unutganimizni biladi! Rust-da matchlar to'liq: kod to'g'ri bo'lishi uchun biz barcha mumkin bo'lgan holatlarni qamrab olishimiz kerak. Ayniqsa, Option<T> holatida, Rust bizni None holatini aniq ko'rib chiqishni unutib qo'yishimizga to'sqinlik qilsa, bizni null bo'lishi mumkin bo'lgan qiymatga ega bo`lishimizdan himoya qiladi, shunday qilib, ilgari muhokama qilingan milliard dollarlik xatoni imkonsiz qiladi.

Hammasini ushlash patternlari va _ placeholder

Enumlardan foydalanib, biz bir nechta ma'lum qiymatlar uchun maxsus harakatlarni amalga oshirishimiz mumkin, ammo boshqa barcha qiymatlar uchun bitta standart amalni bajaramiz. Tasavvur qiling-a, biz o'yinni amalga oshirmoqdamiz, unda 3 ta o'yinda o'yinchi qimirlamaydi, aksincha, chiroyli yangi shlyapa oladi. Agar siz 7 ni aylantirsangiz, o'yinchingiz chiroyli shlyapasini yo'qotadi. Boshqa barcha qiymatlar uchun o'yinchi o'yin taxtasida shuncha bo'sh joyni siljitadi. Mana, bu mantiqni amalga oshiradigan match, bu erda narda toshlarni o'rash natijasi tasodifiy qiymat emas, balki qattiq kodlangan va mantiqning qolgan qismi jismlarsiz funktsiyalar bilan ifodalanadi, chunki ularni amalga oshirish ushbu doiradan tashqarida. misol:

fn main() {
    let narda_toshi = 9;
    match narda_toshi {
        3 => chiroyli_shlyapa_qoshish(),
        7 => chiroyli_shlyapani_ochirish(),
        boshqa => player_harakati(boshqa),
    }

    fn chiroyli_shlyapa_qoshish() {}
    fn chiroyli_shlyapani_ochirish() {}
    fn player_harakati(bosh_joylar: u8) {}
}

Dastlabki ikkita arm uchun patternlar 3 va 7 harfli qiymatlardir. Boshqa barcha mumkin bo'lgan qiymatlarni qamrab oladigan oxirgi arm uchun pattern biz boshqa deb nomlash uchun tanlagan o'zgaruvchidir. boshqa arm uchun ishlaydigan kod o'zgaruvchini player_harakati funksiyasiga o'tkazish orqali ishlatadi.

Ushbu kod kompilatsiya qilinadi, garchi biz u8 ga ega bo'lishi mumkin bo'lgan barcha qiymatlarni sanab o'tmagan bo'lsak ham, chunki oxirgi pattern maxsus sanab o'tilmagan barcha qiymatlarga mos keladi. Bu match toʻliq boʻlishi kerakligi haqidagi talabga javob beradi. E'tibor bering, biz armni eng oxirgi qo'yishimiz kerak, chunki patternlar tartibda baholanadi. Agar biz ushlovchi armni oldinroq qo'ysak, boshqa armlar hech qachon run bo'lmaydi, shuning uchun biz hammamizni tutgandan keyin arm qo'shsak, Rust bizni ogohlantiradi!

Rustda umumiy patterda qiymatdan foydalanishni istamaganimizda foydalanish mumkin bo'lgan pattern ham mavjud: _ - har qanday qiymatga mos keladigan va bu qiymatga bog'lanmaydigan maxsus pattern. Bu Rustga biz qiymatdan foydalanmasligimizni bildiradi, shuning uchun Rust bizni foydalanilmagan o'zgaruvchi haqida ogohlantirmaydi.

Keling, o'yin qoidalarini shunday o'zgartiraylik: agar 3 yoki 7 dan boshqa narda toshi paydo bo'lsa, siz yana boshqatdan aylantirib tashlashingiz kerak. Biz endi catch-all qiymatidan foydalanishimiz shart emas, shuning uchun biz kodimizni boshqa deb nomlangan o‘zgaruvchi o‘rniga _ ishlatish uchun o‘zgartirishimiz mumkin:

fn main() {
    let narda_toshi = 9;
    match narda_toshi {
        3 => chiroyli_shlyapa_qoshish(),
        7 => chiroyli_shlyapani_ochirish(),
        _ => qaytadan(),
    }

    fn chiroyli_shlyapa_qoshish() {}
    fn chiroyli_shlyapani_ochirish() {}
    fn qaytadan() {}
}

Bu misol, shuningdek, to'liqlik talabiga javob beradi, chunki biz oxirgi qismdagi barcha boshqa qiymatlarni e'tiborsiz qoldiramiz; biz hech narsani unutmadik.

Nihoyat, biz o'yin qoidalarini yana bir bor o'zgartiramiz, shunda siz 3 yoki 7 ni o'tkazmaguningizcha sizning navbatingizda hech narsa sodir bo'lmaydi. Biz buni birlik qiymatidan (biz "Tuple turi" section da aytib o'tgan bo'sh tuple turi) _ armi bilan birga keladigan kod sifatida ifodalashimiz mumkin:

fn main() {
    let narda_toshi = 9;
    match narda_toshi {
        3 => chiroyli_shlyapa_qoshish(),
        7 => chiroyli_shlyapani_ochirish(),
        _ => (),
    }

    fn chiroyli_shlyapa_qoshish() {}
    fn chiroyli_shlyapani_ochirish() {}
}

Bu yerda biz Rustga aniq aytamizki, biz avvalgi armdagi patternga mos kelmaydigan boshqa qiymatdan foydalanmaymiz va bu holda hech qanday kodni ishga tushirishni xohlamaymiz.

18-bobda biz ko'rib chiqadigan patternlar va match haqida ko'proq ma'lumot bor. Hozircha biz if let sintaksisiga o‘tamiz, bu match ifodasi juda batafsil bo'lgan holatlarda foydali bo'lishi mumkin.

if let bilan Control Flow

if let sintaksisi sizga if va let ni birlashtirib, qolganlarini e'tiborsiz qoldirib, bitta patternga mos keladigan qiymatlarni boshqarishning kamroq batafsil metodiga imkon beradi. 6-6 ro'yxatdagi dasturni ko'rib chiqaylik, u max_sozlama o'zgaruvchisidagi Variant<u8> qiymatiga mos keladigan, lekin Some varianti boʻlsagina kodni bajarishni xohlaydigan dasturni koʻrib chiqamiz.

fn main() {
    let max_sozlama = Some(3u8);
    match max_sozlama {
        Some(max) => println!("Maksimal {} qilib sozlangan", max),
        _ => (),
    }
}

Ro'yxat 6-6. Qiymat Some bo'lsagina kodni bajaradigan match ifoda

Agar qiymat Some bo'lsa, biz qiymatni patterndagi max o'zgaruvchisiga bog'lash orqali Some variantidagi qiymatni chop qilamiz. Biz None qiymati bilan hech narsa qilishni xohlamaymiz. match ifodasini qondirish uchun faqat bitta variantni qayta ishlagandan so‘ng _ => () qo‘shishimiz kerak, bu esa qo‘shish uchun zerikarli boilerplate koddir.

Buning o'rniga, biz buni qisqaroq qilib if let yordamida yozishimiz mumkin. Quyidagi kod 6-6 ro'yxatdagi match bilan bir xil ishlaydi:

fn main() {
    let max_sozlama = Some(3u8);
    if let Some(max) = max_sozlama {
        println!("Maksimal {} qilib sozlangan", max);
    }
}

if let sintaksisi teng belgisi bilan ajratilgan pattern va ifodani oladi. U xuddi match bilan ishlaydi, bunda ifoda matchga beriladi va pattern uning birinchi armi hisoblanadi. Bunday holda, pattern Some(max) bo'lib, max Some ichidagi qiymatga bog'lanadi. Shundan so'ng biz if let blokining tanasida max dan xuddi mos keladigan match armida max dan foydalanganimiz kabi foydalanishimiz mumkin. Qiymat patternga mos kelmasa, if let blokidagi kod ishga tushmaydi.

if let dan foydalanish kamroq yozish, kamroq chekinish va kamroq kodli kodni bildiradi. Biroq, siz match amal qiladigan to'liq tekshirishni yo'qotasiz. match va if let o‘rtasida tanlov qilish sizning muayyan vaziyatingizda nima qilayotganingizga va ixchamlikka ega bo‘lish to‘liq tekshirishni yo‘qotish uchun to‘g‘ri kelishilganligiga bog‘liq.

Boshqacha qilib aytganda, siz if let konstruktsiyasini match uchun sintaktik shakar sifatida o'ylab ko'rishingiz mumkin, agar kiritilgan qiymat bitta patterga mos kelsa va boshqa barcha qiymatlarga e'tibor bermasa, kodni bajaradi.

Biz elseni if let bilan kiritishimiz mumkin. else bilan birlashtirilgan kod bloki if let va elsega ekvivalent bo‘lgan match ifodasidagi _ registriga mos keladigan kod bloki bilan bir xil. 6-4 roʻyxatdagi Tanga definitionni eslang, bunda Quarter varianti ham UsState qiymatiga ega edi. Agar biz quarterlarning holatini e'lon qilishda ko'rgan barcha quarter bo'lmagan tangalarni sanashni istasak, buni quyidagi kabi match ifodasi bilan qilishimiz mumkin:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Tanga {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let tanga = Tanga::Penny;
    let mut hisobchi = 0;
    match tanga {
        Tanga::Quarter(shtat) => println!("{:?} dan shtat kvartal!", shtat),
        _ => hisobchi += 1,
    }
}

Yoki if let va else ifodalaridan foydalanishimiz mumkin, masalan:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Tanga {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let tanga = Tanga::Penny;
    let mut hisobchi = 0;
    if let Tanga::Quarter(shtat) = tanga {
        println!("{:?} dan shtat kvartal!", shtat);
    } else {
        hisobchi += 1;
    }
}

Agar dasturingizda match yordamida ifodalash uchun juda batafsil mantiq mavjud bo'lsa, Rust toolboxda if let ham mavjudligini unutmang.

Xulosa

Endi biz sanab o'tilgan qiymatlar to'plamidan biri bo'lishi mumkin bo'lgan maxsus turlarni yaratish uchun enumlardan qanday foydalanishni ko'rib chiqdik. Biz standart kutubxonaning Option<T> turi xatolarni oldini olish uchun type tizimidan qanday foydalanishni ko'rsatdik. Enum qiymatlari ichida ma'lumotlar mavjud bo'lsa, siz qancha holatlarni ko'rib chiqishingiz kerakligiga qarab, ushbu qiymatlarni ajratib olish va ishlatish uchun match yoki if let dan foydalanishingiz mumkin.

Rust dasturlaringiz endi structlar va enumlar yordamida domeningizdagi tushunchalarni ifodalashi mumkin. API-da foydalanish uchun maxsus turlarni yaratish turdagi xavfsizligini ta'minlaydi: kompilyator sizning funksiyalaringiz faqat har bir funktsiya kutgan turdagi qiymatlarni olishiga ishonch hosil qiladi.

Foydalanuvchilaringizga foydalanish uchun qulay va faqat sizning foydalanuvchilarga nima kerakligini aniq ko'rsatadigan yaxshi tashkil etilgan API taqdim etish uchun endi Rust modullariga murojaat qilaylik.

O'sib borayotgan loyihalarni paketlar, cratelar va modullar bilan boshqarish

Katta dasturlarni yozganingizda, kodingizni tartibga solish tobora muhim ahamiyat kasb etadi. Tegishli funksiyalarni guruhlash va kodni alohida xususiyatlar bilan ajratish orqali siz ma'lum bir xususiyatni amalga oshiradigan kodni qayerdan topish va funksiya qanday ishlashini o'zgartirish uchun qayerga borish kerakligini aniqlaysiz.

Biz hozirgacha yozgan dasturlar bitta faylda bitta modulda bo'lgan. Loyiha o'sib borishi bilan siz kodni bir nechta modullarga va keyin bir nechta fayllarga bo'lish orqali tartibga solishingiz kerak. Paketda bir nechta binary cratelar va ixtiyoriy ravishda bitta kutubxona cratesi bo'lishi mumkin. Paket o'sishi bilan siz qismlarni alohida cratelarga ajratib olishingiz mumkin, ular tashqi bog'liqlikka aylanadi. Ushbu bo'lim ushbu texnikaning barchasini o'z ichiga oladi. Birgalikda rivojlanadigan o'zaro bog'liq paketlar to'plamini o'z ichiga olgan juda katta loyihalar uchun Cargo workspacelarni taqdim etadi, biz ularni 14-bobdagi "Cargo Workspacelari" bo'limida ko'rib chiqamiz.

Shuningdek, biz kodni yuqoriroq darajada qayta ishlatish imkonini beruvchi implement tafsilotlarini muhokama qilamiz: operatsiyani amalga oshirganingizdan so'ng, boshqa kod dastur qanday ishlashini bilmasdan kodingizni umumiy interfeysi orqali chaqirishi mumkin. Kodni yozish usuli qaysi qismlar boshqa koddan foydalanishi uchun public ekanligini va qaysi qismlar o'zgartirish huquqiga ega bo'lgan private implement tafsilotlarini belgilaydi. Bu yodda tutish kerak bo'lgan tafsilotlar miqdorini cheklashning yana bir usuli.

Tegishli tushuncha - bu scope: kod yoziladigan ichki kontekstda "scope" deb belgilangan nomlar to'plami mavjud. Kodni o'qish, yozish va kompilyatsiya qilishda dasturchilar va kompilyatorlar ma'lum bir nuqtadagi ma'lum bir nom o'zgaruvchiga, funksiyaga, structga, enumga, modulga, constantaga yoki boshqa elementga tegishli ekanligini va bu element nimani anglatishini bilishlari kerak. Siz scopelarni yaratishingiz va qaysi nomlar doirasida yoki tashqarida ekanligini o'zgartirishingiz mumkin. Bir xil nomdagi ikkita elementni bir xil scopeda bo'lishi mumkin emas; nom ziddiyatlarini hal qilish uchun tollar mavjud.

Rust sizga kodingizning tuzilishini boshqarish imkonini beruvchi bir qator xususiyatlarga ega, jumladan, qaysi tafsilotlar oshkor bo'lishi, qaysi tafsilotlar shaxsiy va dasturlaringizdagi har bir sohada qanday nomlar mavjudligi. Ba'zan birgalikda modul tizimi deb ataladigan bu xususiyatlar quyidagilarni o'z ichiga oladi:

• Paketlar: Cratelarni qurish, sinab ko'rish va almashish imkonini beruvchi cargo xususiyati
• Cratelar: Kutubxona yoki bajariladigan faylni yaratuvchi modullar daraxti
• Modullar va use: Fayl yoʻllarning tashkil etilishi, koʻlami va maxfiyligini nazorat qilish imkonini beradi
• Pathlar: Struct, funksiya yoki modul kabi elementni nomlash usuli

Ushbu bobda biz ushbu xususiyatlarning barchasini ko'rib chiqamiz, ularning qanday o'zaro ta'sirini muhokama qilamiz va qamrovni boshqarish uchun ulardan qanday foydalanishni tushuntiramiz. Oxir-oqibat, siz modul tizimi haqida yaxshi tushunchaga ega bo'lishingiz va professional kabi sohalar bilan ishlashingiz kerak!

Paketlar va Cratelar

Biz qamrab oladigan modul tizimining birinchi qismlari paketlar va cratelardir.

Crate - bu Rust kompilyatori bir vaqtning o'zida ko'rib chiqadigan eng kichik kod miqdori. Agar siz cargo o'rniga rustc ni ishga tushirsangiz va bitta manba faylga o'tsangiz ham (biz 1-bob, "Rust dasturini yozish va ishga tushirish"da qilganimiz kabi), kompilyator bu faylni crate sifatida ko'radi. Cratelar modullarni o'z ichiga olishi mumkin va modullar crate bilan tuzilgan boshqa fayllarda aniqlanishi mumkin, buni keyingi bo'limlarda ko'rib chiqamiz.

Crate ikkita shakldan birida bo'lishi mumkin: binary crate yoki kutubxona cratesi. Binary cratelar - bu buyruq qatori dasturi yoki server kabi ishga tushirishingiz mumkin bo'lgan bajariladigan faylga kompilyatsiya qilishingiz mumkin bo'lgan dasturlar. Har birida bajariladigan fayl ishga tushganda nima sodir bo'lishini belgilaydigan main funksiyasi bo'lishi kerak. Biz hozirgacha yaratgan barcha cratelar binary cratelar edi.

Kutubxona cratelari main funksiyaga ega emas va ular bajariladigan faylga kompilyatsiya qilinmaydi. Buning o'rniga, ular bir nechta loyihalar bilan bo'lishish uchun mo'ljallangan funksionallikni belgilaydi. Misol uchun, biz 2-bobda ishlatgan rand cratesi tasodifiy sonlarni yaratuvchi funksionallikni taʼminlaydi. Ko'pincha Rustaceanlar “crate” deganda, ular kutubxona crateni anglatadi va ular "kutubxona" ning umumiy dasturlash tushunchasi bilan "crate" dan foydalanadilar.

Crate root bu Rust kompilyatori cratengizning ildiz modulini yaratishni boshlaydigan manba fayldir (biz modullarni “Qo'llanish doirasi va maxfiylikni nazorat qilish uchun modullarni aniqlash” bo‘limida chuqur tushuntiramiz).

Paket - bu bir yoki bir nechta cratelar to'plami bo'lib, u funksiyalar to'plamini ta'minlaydi. Paketda ushbu cratelarni qanday build qilishni tavsiflovchi Cargo.toml fayli mavjud. Cargo - bu sizning kodingizni yaratishda foydalanayotgan buyruq qatori vositasi uchun binary crateni o'z ichiga olgan paket. Cargo paketida binary crate bog'liq bo'lgan kutubxona cratesi ham mavjud. Boshqa loyihalar Cargo buyruq qatori vositasi ishlatadigan mantiqdan foydalanish uchun cargo kutubxonasi cratesiga bog'liq bo'lishi mumkin.

Paket siz xohlagancha ko'p ikkilik binary cratelarni o'z ichiga olishi mumkin, lekin bitta kutubxona cratesidan ko'p bo'lmasligi kerak. Paketda kamida bitta crate bo'lishi kerak, u kutubxona yoki binary crate bo'lishi kerak.

Keling, paketni yaratganimizda nima sodir bo'lishini ko'rib chiqaylik. Birinchidan, biz cargo new buyrug'ini kiritamiz:

$ cargo new mening-paketim
     Created binary (application) `mening-paketim` package
$ ls mening-paketim
Cargo.toml
src
$ ls mening-paketim/src
main.rs

Biz cargo new ni ishga tushirgandan so'ng, biz cargo nima yaratganini ko'rish uchun ls dan foydalanamiz. mening-paketim jildida bizga paketni taqdim qiluvchi Cargo.toml fayli mavjud. Shuningdek, main.rs ni o'z ichiga olgan src jildi ham mavjud. Matn muharririda Cargo.toml ni oching va src/main.rs haqida hech qanday eslatma yo‘qligiga e'tibor bering. Cargo, src/main.rs paket bilan bir xil nomga ega binary cratening crate ildizi ekanligi haqidagi konventsiyaga amal qiladi. Xuddi shunday, Cargo ham biladiki, agar paket jildida src/lib.rs bo'lsa, paketda paket bilan bir xil nomdagi kutubxona cratesi mavjud va src/lib.rs uning crate ildizi hisoblanadi. Cargo kutubxona yoki binaryni yaratish uchun cratening ildiz fayllarini rustc ga o'tkazadi.

Bu yerda bizda faqat src/main.rs ni o'z ichiga olgan paket bor, ya'ni u faqat mening-paketim nomli binary crateni o'z ichiga oladi. Agar paketda src/main.rs va src/lib.rs bo'lsa, unda ikkita crate, binary crate va kutubxona cratesi mavjud bo'lib, ikkalasi ham paket bilan bir xil nomga ega. Paketda fayllarni src/bin jildiga joylashtirish orqali bir nechta binary cratelar bo'lishi mumkin: har bir fayl alohida binary crate bo'ladi.

Qo'llanish doirasi va maxfiylikni nazorat qilish uchun modullarni aniqlash

Ushbu bo'limda biz modullar va modul tizimining boshqa qismlari haqida gapiramiz, ya'ni elementlarni nomlash imkonini beruvchi pathlar(yo'llar); pathni qamrab oluvchi use kalit so'zi; va obyektlarni hammaga ochiq qilish(public) uchun pub kalit so'zi. Shuningdek, biz as kalit so'zini, tashqi paketlarni va glob operatorini muhokama qilamiz.

Birinchidan, kelajakda kodingizni tartibga solishda qulay foydalanish uchun qoidalar ro'yxatidan boshlaymiz. Keyin har bir qoidalarni batafsil tushuntiramiz.

Modullar qo'llanmasi

Bu yerda biz modullar, pathlar, use kalit soʻzi va pub kalit soʻzining kompilyatorda qanday ishlashi va koʻpchilik ishlab chiquvchilar oʻz kodlarini qanday tashkil qilishlari haqida qisqacha maʼlumot beramiz. Ushbu bobda biz ushbu qoidalarning har biriga misollarni ko'rib chiqamiz va modullar qanday ishlashini takrorlash uchun yaxshi vaqt. work.

• Cratening ildizidan boshlang: Crateni kompilyatsiya qilishda kompilyator kodni kompilyatsiya qilish uchun avval cratening ildiz fayliga (odatda kutubxona cratesi uchun src/lib.rs yoki binary crate uchun src/main.rs) qaraydi.
• Modullarni e'lon qilish: Cratening ildiz faylida siz yangi modullarni e'lon qilishingiz mumkin; aytaylik, siz mod poliz bilan poliz modulini e'lon qilasiz; Kompilyator modul kodini quyidagi joylarda qidiradi:
  • Inline, jingalak qavs ichida mod poliz dan keyingi nuqta-vergul o'rnini egallaydi
  • src/poliz.rs faylida
  • src/poliz/mod.rs faylida
• Submodullarni e'lon qilish: Crate ildizidan boshqa har qanday faylda siz submodullarni e'lon qilishingiz mumkin. Masalan, src/poliz.rs da mod sabzavotlar; deb e`lon qilishingiz mumkin. Kompilyator quyi modul kodini quyidagi joylarda ota-modul uchun nomlangan jilddan qidiradi:
  • Inline, to'g'ridan-to'g'ri mod sabzavotlar dan keyin, nuqta-vergul o'rniga jingalak qavslar ichida
  • src/poliz/sabzavotlar.rs faylida
  • src/poliz/sabzavotlar/mod.rs faylida
• Modullarda kodlash yo'llari: Modul sizning cratengizning bir qismi bo'lgandan so'ng, maxfiylik qoidalari ruxsat bergan bo'lsa, kod yo'lidan foydalanib, xuddi shu cratening istalgan joyidan ushbu moduldagi kodga murojaat qilishingiz mumkin. Misol uchun, poliz sabzavotlari modulidagi Pomidor turi Crate::poliz::sabzavotlar::Pomidor da topiladi.
• Private va Public: Modul ichidagi kod standart bo'yicha uning ota-modullaridan maxfiydir. Modulni public qilish uchun uni mod o'rniga pub mod bilan e’lon qiling. Public moduldagi elementlarni ham hammaga ochiq qilish uchun ularni e'lon qilishdan oldin pub dan foydalaning.
• use kalit so'zi: Bir doirada use kalit so'zidan foydalanish uzoq yo'llarning takrorlanishini kamaytirish uchun elementlar uchun taxalluslarni yaratadi. Crate::poliz::sabzavotlar::Pomidor ga murojaat qilishi mumkin bo'lgan har qanday sohada siz use crate::poliz::sabzavotlar::Pomidor; bilan taxallus yaratishingiz mumkin va shundan so'ng siz ushbu turdagi ushbu doirada foydalanish uchun Pomidor deb yozishingiz kerak.

Bu erda biz ushbu qoidalarni aks ettiruvchi orqa_hovli nomli binary crate yaratamiz. Crate jildi, shuningdek, orqa_hovli deb nomlangan, quyidagi fayllar va jildlarni o'z ichiga oladi:

orqa_hovli
├── Cargo.lock
├── Cargo.toml
└── src
    ├── poliz
    │   └── sabzavotlar.rs
    ├── poliz.rs
    └── main.rs

Bu holda cratening ildiz fayli src/main.rs bo'lib, u quyidagilarni o'z ichiga oladi:

Fayl nomi: src/main.rs

use crate::poliz::sabzavotlar::Pomidor;

pub mod poliz;

fn main() {
    let ekin = Pomidor {};
    println!("Men {:?} o'stiryapman!", ekin);
}

pub mod poliz; qatori kompilyatorga src/poliz.rs da topilgan kodni kiritishni aytadi, ya'ni:

Fayl nomi: src/poliz.rs

pub mod sabzavotlar;

Bu yerda pub mod sabzavotlar; src/poliz/sabzavotlar.rs dagi kod ham kiritilganligini bildiradi. That code is:

#[derive(Debug)]
pub struct Pomidor {}

Keling, ushbu qoidalarning tafsilotlari bilan tanishamiz va ularni amalda ko'rsatamiz!

Modullarda tegishli kodlarni guruhlash

Modullar kodni o'qish va qayta foydalanishni osonlashtirish uchun crate ichida tartibga solish imkonini beradi. Modullar bizga elementlarning maxfiyligini boshqarishga ham imkon beradi, chunki modul ichidagi kod standart boʻyicha shaxsiy(private) hisoblanadi. Private elementlar tashqi foydalanish uchun mavjud bo'lmagan ichki dastur tafsilotlari. Biz modullar va ulardagi elementlarni hammaga ochiq qilishni tanlashimiz mumkin, bu esa ularni tashqi koddan foydalanish va ularga bog'liq bo'lishiga imkon beradi.

Misol tariqasida, restoranning funksionalligini ta'minlaydigan kutubxona cratesini yozamiz. Biz funksiyalarning signaturelarini aniqlaymiz, lekin restoranni implement qilishga emas, balki kodni tashkil etishga e'tibor qaratish uchun ularning tanasini bo'sh qoldiramiz.

Restoran sanoatida restoranning ba'zi qismlari uyning old tomoni va boshqalari uyning orqa tomoni deb ataladi. Uyning old tomoni mijozlar joylashgan joy; Bu mezbonlar mijozlarni joylashtiradigan, serverlar buyurtma va to'lovlarni qabul qiladigan va barmenlar ichimliklar tayyorlaydigan joyni o'z ichiga oladi. Uyning orqa tomonida oshpazlar va oshpazlar oshxonada ishlaydi, idishlarni yuvish mashinalari tozalaydi va menejerlar ma'muriy ishlarni bajaradilar.

Cratemizni shu tarzda tuzish uchun biz uning funksiyalarini ichki modullarga ajratishimiz mumkin. cargo new restoran --lib ishga tushirish orqali restoran nomli yangi kutubxona yarating; keyin ba'zi modullar va funksiya signaturelarini aniqlash uchun 7-1 ro'yxatidagi kodni src/lib.rs ichiga kiriting. Mana, uyning old qismi: Fayl nomi: src/lib.rs

mod uyning_oldi {
    mod xizmat {
        fn navbat_listiga_qoshish() {}

        fn stolga_otirish() {}
    }

    mod serving {
        fn buyurtma_olish() {}

        fn buyurtma_berish() {}

        fn tolovni_qabul_qilish() {}
    }
}

Roʻyxat 7-1: uyning_oldi moduli, keyin funksiyalarni oʻz ichiga olgan boshqa modullarni oʻz ichiga oladi.

Biz modulni mod kalit so'zidan keyin modul nomi bilan belgilaymiz (bu holda uyning_oldi). Keyin modul tanasi jingalak qavslar ichiga kiradi. Modullar ichida biz boshqa modullarni joylashtirishimiz mumkin, masalan, xizmat va xizmat_korsatish modullari. Modullar, shuningdek, structlar, enumlar, konstantalar, belgilar va 7-1 ro'yxatdagi kabi boshqa elementlar uchun ta'riflarga ega bo'lishi mumkin.

Modullardan foydalanib, biz bir-biriga bog'liq definitionlarni guruhlashimiz va ular nima uchun bog'liqligini nomlashimiz mumkin. Ushbu koddan foydalanadigan dasturchilar barcha definitionlarni o'qib chiqmasdan, guruhlarga asoslangan kodni boshqarishi mumkin, bu ularga tegishli definitionlarni topishni osonlashtiradi. Ushbu kodga yangi funksiya qo'shadigan dasturchilar dasturni tartibli saqlash uchun kodni qayerga joylashtirishni bilishadi.

Yuqorida aytib o'tganimizdek, src/main.rs va src/lib.rs fayllari crate ildiz modullari deb ataladi. Ularning nomlanishining sababi shundaki, bu ikki faylning birortasining mazmuni modul daraxti deb nomlanuvchi crate modul strukturasining ildizida joylashgan crate nomli modulni tashkil qiladi.

7-2 ro'yxatda 7-1 ro'yxatdagi strukturaning modul daraxti ko'rsatilgan.

crate
 └── uyning_oldi
     ├── xizmat
     │   ├── navbat_listiga_qoshish
     │   └── stolga_otirish
     └── xizmat_korsatish
         ├── buyurtma_olish
         ├── buyurtma_berish
         └── tolov_qilish

7-2 ro'yxat: 7-1 ro'yxatdagi kod uchun modul daraxti

Bu daraxt ba'zi modullar bir-birining ichida qanday joylashishini ko'rsatadi; masalan, xizmat uyasi uyning_oldi ichida. Daraxt shuningdek, ba'zi modullar bir-birining aka-uka ekanligini, ya'ni ular bir modulda aniqlanganligini ko'rsatadi; xizmat va xizmat_korsatish uyning_oldi ichida belgilangan aka-ukalardir. Agar A moduli B modulida joylashgan bo'lsa, biz A moduli B modulining bolasi va B moduli A modulining otasi deb aytamiz. E'tibor bering, butun modul daraxti Crate nomli yashirin modul ostida joylashgan.

Modul daraxti sizga kompyuteringizdagi fayl tizimining jildlar daraxtini eslatishi mumkin; bu juda to'g'ri taqqoslash! Fayl tizimidagi jildlar singari, siz kodingizni tartibga solish uchun modullardan foydalanasiz. Va xuddi jilddagi fayllar singari, bizga modullarimizni topish usuli kerak.

Modul daraxtidagi elementga murojaat qilish yo'llari

Rust-ga modul daraxtidagi elementni qayerdan topish mumkinligini ko'rsatish uchun biz fayl tizimida harakat qilishda qanday yo'l(path) ishlatgan bo'lsak, xuddi shunday yo'ldan foydalanamiz. Funksiyani chaqirish uchun biz uning yo'lini bilishimiz kerak.

Yo'l ikki shaklda bo'lishi mumkin:

• Absolyut yo'l - bu crate ildizidan boshlanadigan to'liq yo'l; tashqi cretedagi kod uchun mutlaq yo'l crate nomidan boshlanadi va joriy cratedagi kod uchun esa crate bilan boshlanadi..
• N isbiy yo‘l joriy moduldan boshlanadi va joriy modulda self, super yoki identifikatordan foydalanadi.

Mutlaq va nisbiy yo‘llardan keyin ikki nuqta (::) bilan ajratilgan bir yoki bir nechta identifikatorlar keladi.

7-1 ro'yxatiga qaytsak, biz navbat_listiga_qoshish funksiyasini chaqirmoqchimiz deylik. Bu so'rash bilan bir xil: navbat_listiga_qoshish funksiyasining yo'li nima? 7-3 ro'yxatda 7-1 ro'yxati mavjud bo'lib, ba'zi modullar va funksiyalar olib tashlangan.

Biz crate ildizida belgilangan yangi restoranda_ovqatlanish funksiyasidan navbat_listiga_qoshish funksiyasini chaqirishning ikkita usulini ko‘rsatamiz. Bu yoʻllar toʻgʻri, ammo bu misolni avvalgidek tuzishga toʻsqinlik qiladigan yana bir muammo bor. Sababini birozdan keyin tushuntiramiz.

restoranda_ovqatlanish funksiyasi kutubxonamizning public API-ning bir qismidir, shuning uchun biz uni pub kalit so'zi bilan belgilaymiz. “pub kalit so'zi bilan yo'llarni ochish” bo‘limida biz pub haqida batafsilroq to‘xtalib o'tamiz.

Fayl nomi: src/lib.rs

mod uyning_oldi {
    mod xizmat {
        fn navbat_listiga_qoshish() {}
    }
}

pub fn restoranda_ovqatlanish() {
    // Mutlaq yo'l (Absolute path)
    crate::uyning_oldi::xizmat::navbat_listiga_qoshish();

    // Nisbiy yo'l (Relative path)
    uyning_oldi::xizmat::navbat_listiga_qoshish();
}

Ro'yxat 7-3: navbat_listiga_qoshish funksiyasini mutlaq va nisbiy yo'llar yordamida chaqirish

Biz birinchi marta restoranda_ovqatlanish ichida navbat_listiga_qoshish funksiyasini chaqirganimizda mutlaq yo'ldan foydalanamiz. navbat_listiga_qoshish funksiyasi restoranda_ovqatlanish bilan bir xil crateda belgilangan, ya'ni mutlaq yoʻlni boshlash uchun crate kalit soʻzidan foydalanishimiz mumkin. Keyin biz navbat_listiga_qoshish ga o'tgunimizcha ketma-ket modullarning har birini o'z ichiga olamiz. Siz bir xil strukturaga ega fayl tizimini tasavvur qilishingiz mumkin: biz navbat_listiga_qoshish dasturini ishga tushirish uchun /uyning_oldi/xizmat/navbat_listiga_qoshish yo'lini belgilaymiz; crate ildizidan boshlash uchun crate nomidan foydalanish shelldagi fayl tizimi ildizidan boshlash uchun / dan foydalanishga o'xshaydi.

Biz restoranda_ovqatlanish ichida navbat_listiga_qoshish ni ikkinchi marta chaqirganimizda nisbiy yo'ldan foydalanamiz. Yo'l uyning_oldi bilan boshlanadi, modul nomi restoranda_ovqatlanish bilan bir xil modul daraxti darajasida belgilangan. Bu yerda fayl tizimi ekvivalenti uyning_oldi/xizmat/navbat_listiga_qoshish yo'lidan foydalaniladi. Modul nomi bilan boshlash yo'l nisbiy ekanligini bildiradi.

Nisbiy yoki mutlaq yo‘ldan foydalanishni tanlash loyihangiz asosida qabul qilinadigan qaror bo‘lib, element definitioni kodini elementdan foydalanadigan koddan alohida yoki birga ko‘chirish ehtimoli ko‘proq ekanligiga bog‘liq. Masalan, uyning_oldi moduli va restoranda_ovqatlanish funksiyasini mijoz_tajribasi nomli modulga o‘tkazsak, mutlaq yo‘lni navbat_listiga_qoshishga yangilashimiz kerak bo‘ladi, lekin nisbiy yo‘l baribir amal qiladi. Biroq, agar biz restoranda_ovqatlanish funksiyasini ovqatlanish nomli modulga alohida ko'chirsak, restoranda_ovqatlanish chaqiruvining mutlaq yo'li bir xil bo'lib qoladi, lekin nisbiy yo'l yangilanishi kerak bo'ladi. Umuman olganda, bizning afzal ko'rganimiz mutlaq yo'llarni belgilashdir, chunki biz kod definitionlari va element chaqiruvlarini bir-biridan mustaqil ravishda ko'chirishni xohlaymiz.

Keling, 7-3 ro'yxatini kompilatsiya qilishga harakat qilaylik va nima uchun u hali kompilatsiya bo'lmaganligini bilib olaylik! Biz olgan xato 7-4 ro'yxatda ko'rsatilgan.

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: module `xizmat` is private
 --> src/lib.rs:9:28
  |
9 |     crate::uyning_oldi::xizmat::navbat_listiga_qoshish();
  |                            ^^^^^^^ private module
  |
note: the module `xizmat` is defined here
 --> src/lib.rs:2:5
  |
2 |     mod xizmat {
  |     ^^^^^^^^^^^

error[E0603]: module `xizmat` is private
  --> src/lib.rs:12:21
   |
12 |     uyning_oldi::xizmat::navbat_listiga_qoshish();
   |                     ^^^^^^^ private module
   |
note: the module `xizmat` is defined here
  --> src/lib.rs:2:5
   |
2  |     mod xizmat {
   |     ^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` due to 2 previous errors

Ro'yxat 7-4: 7-3 ro'yxatdagi kodni kompilyatsiya qilishda kompilyator xatolari

Xato xabarlari xizmat moduli private ekanligini aytadi. Boshqacha qilib aytadigan bo'lsak, bizda xizmat moduli va navbat_listiga_qoshish funksiyasi uchun to'g'ri yo'llar mavjud, ammo Rust ulardan foydalanishimizga ruxsat bermaydi, chunki u private bo'limlarga kirish imkoniga ega emas. Rust-da barcha elementlar (funktsiyalar, metodlar, structlar, enumlar, modullar va konstantalar) standart bo'yicha ota-modullar uchun privatedir. Agar siz funksiya yoki struktura kabi elementni yaratmoqchi bo'lsangiz, uni modulga joylashtirasiz.

Ota-moduldagi elementlar ichki modullar ichidagi private elementlardan foydalana olmaydi, lekin bolalar modullaridagi elementlar o'zlarining ota-modullaridagi elementlardan foydalanishi mumkin. Buning sababi shundaki, bolalar modullari o'zlarining amalga oshirish tafsilotlarini o'rab oladi va yashiradi, lekin bolalar modullari ular aniqlangan kontekstni ko'rishlari mumkin. Bizning metaforamizni davom ettirish uchun, maxfiylik qoidalarini restoranning orqa ofisi kabi tasavvur qiling: u erda nima sodir bo'layotgani restoran mijozlari uchun private, ammo ofis menejerlari o'zlari ishlayotgan restoranda hamma narsani ko'rishlari va qilishlari mumkin.

Rust modul tizimining shu tarzda ishlashini tanladi, shuning uchun ichki dastur tafsilotlarini yashirish standart bo'yichadir. Shunday qilib, siz ichki kodning qaysi qismlarini tashqi kodni buzmasdan o'zgartirishingiz mumkinligini bilasiz. Biroq, Rust sizga obyektni hammaga ochiq qilish uchun pub kalit so'zidan foydalanib, tashqi ajdod modullariga ichki modullar kodining ichki qismlarini ochish imkoniyatini beradi.

pub kalit so'zi bilan yo'llarni ochish

Keling, 7-4 ro'yxatdagi xatoga qaytaylik, bu bizga xizmat moduli private ekanligini aytdi. Biz ota-moduldagi restoranda_ovqatlanish funksiyasi bolalar modulidagi navbat_listiga_qoshish funksiyasiga kirishini xohlaymiz, shuning uchun biz xizmat modulini pub kalit so'zi bilan belgilaymiz, ro'yxat 7-5da ko`rsatilganidek.

Fayl nomi: src/lib.rs

mod uyning_oldi {
    pub mod xizmat {
        fn navbat_listiga_qoshish() {}
    }
}

pub fn restoranda_ovqatlanish() {
    // Mutlaq yo'l (Absolute path)
    crate::uyning_oldi::xizmat::navbat_listiga_qoshish();

    // Nisbiy yo'l (Relative path)
    uyning_oldi::xizmat::navbat_listiga_qoshish();
}

Ro'yxat 7-5: xizmat modulini restoranda_ovqatlanish dan foydalanish uchun pub deb e'lon qilish

Afsuski, 7-5 ro'yxatdagi kod hali ham 7-6 ro'yxatda ko'rsatilganidek xatolikka olib keladi.

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: function `navbat_listiga_qoshish` is private
 --> src/lib.rs:9:37
  |
9 |     crate::uyning_oldi::xizmat::navbat_listiga_qoshish();
  |                                     ^^^^^^^^^^^^^^^ private function
  |
note: the function `navbat_listiga_qoshish` is defined here
 --> src/lib.rs:3:9
  |
3 |         fn navbat_listiga_qoshish() {}
  |         ^^^^^^^^^^^^^^^^^^^^

error[E0603]: function `navbat_listiga_qoshish` is private
  --> src/lib.rs:12:30
   |
12 |     uyning_oldi::xizmat::navbat_listiga_qoshish();
   |                              ^^^^^^^^^^^^^^^ private function
   |
note: the function `navbat_listiga_qoshish` is defined here
  --> src/lib.rs:3:9
   |
3  |         fn navbat_listiga_qoshish() {}
   |         ^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` due to 2 previous errors

Ro'yxat 7-6: 7-5 ro'yxatdagi kodni build qilishda kompilyator xatolari

Nima bo'ldi? mod xizmat oldiga pub kalit so‘zini qo‘shish modulni hammaga ochiq qiladi. Ushbu o'zgarish bilan, agar biz uyning_oldi ga kira olsak, biz xizmat ga kira olamiz. Lekin xizmat ning tarkibi hamon private; modulni public qilish uning mazmunini ochiq qilmaydi. Moduldagi pub kalit so‘zi faqat uning ota-modullaridagi kodni unga murojaat qilish imkonini beradi, uning ichki kodiga kirishga ruxsat bermaydi. Modullar konteyner bo'lgani uchun modulni faqat public qilish orqali biz ko'p narsa qila olmaymiz; biz oldinga borishimiz va modul ichidagi bir yoki bir nechta narsalarni ham hammaga ochiq qilishni tanlashimiz kerak.

7-6 roʻyxatdagi xatolar navbat_listiga_qoshish funksiyasi private ekanligini bildiradi. Maxfiylik qoidalari structlar, enumlar, funksiyalar va metodlar hamda modullarga nisbatan qo'llaniladi.

7-7 ro'yxatda ko'rsatilganidek, definitiondan oldin pub kalit so'zini qo'shish orqali navbat_listiga_qoshish funksiyasini ham hammaga ochiq qilaylik.

Fayl nomi: src/lib.rs

mod uyning_oldi {
    pub mod xizmat {
        pub fn navbat_listiga_qoshish() {}
    }
}

pub fn restoranda_ovqatlanish() {
    // Mutlaq yo'l (Absolute path)
    crate::uyning_oldi::xizmat::navbat_listiga_qoshish();

    // Nisbiy yo'l (Relative path)
    uyning_oldi::xizmat::navbat_listiga_qoshish();
}

Ro'yxat 7-7: mod xizmat va fn navbat_listiga_qoshish ga pub kalit so'zini qo'shish bizga restoranda_ovqatlanish funksiyasini chaqirish imkonini beradi.

Endi kod kompilyatsiya qilinadi! Nima uchunpub kalit soʻzini qoʻshish ushbu yoʻllardan navbat_listiga_qoshish da maxfiylik qoidalariga nisbatan foydalanish imkonini berishini bilish uchun mutlaq va nisbiy yoʻllarni koʻrib chiqamiz.

Mutlaq yo'lda biz crate modul daraxtining ildizi bo'lgan crate dan boshlaymiz. uyning_oldi moduli crate ildizida belgilangan. uyning_oldi ochiq boʻlmasa-da, restoranda_ovqatlanish funksiyasi uyning_oldi bilan bir xil modulda aniqlanganligi sababli (yaʼni, restoranda_ovqatlanish va uyning_oldi siblingdir ya'ni aka-uka), biz restoranda_ovqatlanish dan uyning_oldiga murojaat qilishimiz mumkin. Keyingi o'rinda pub bilan belgilangan xizmat moduli. Biz xizmat ning ota-moduliga kira olamiz, shuning uchun biz xizmat ga kira olamiz. Nihoyat, navbat_listiga_qoshish funksiyasi pub bilan belgilangan va biz uning asosiy moduliga kira olamiz, shuning uchun bu funksiya chaqiruvi ishlaydi!

Nisbiy yo'lda mantiq birinchi qadamdan tashqari mutlaq yo'l bilan bir xil bo'ladi: yo'l crate ildizidan emas, uyning_oldidan boshlanadi. uyning_oldi moduli restoranda_ovqatlanish bilan bir xil modul ichida aniqlanadi, shuning uchun restoranda_ovqatlanish belgilangan moduldan boshlanadigan nisbiy yo‘l ishlaydi. Keyin, xizmat va navbat_listiga_qoshish pub bilan belgilanganligi sababli, qolgan yo‘l ishlaydi va bu funksiya chaqiruvi amal qiladi!

Agar siz kutubxona crateyingizni boshqa loyihalar sizning kodingizdan foydalanishi uchun baham ko'rishni rejalashtirmoqchi bo'lsangiz, public API sizning crateyingiz foydalanuvchilari bilan tuzilgan shartnoma bo'lib, ular sizning kodingiz bilan qanday aloqada bo'lishini belgilaydi. Odamlar sizning crateyingizga bog'liq bo'lishini osonlashtirish uchun public API-ga o'zgartirishlarni boshqarish bo'yicha ko'plab fikrlar mavjud. Bu mulohazalar ushbu kitob doirasidan tashqarida; agar sizni ushbu mavzu qiziqtirsa, Rust API ko'rsatmalariga qarang.

Binary va kutubxonaga ega paketlar uchun eng yaxshi amaliyotlar

Paketda src/main.rs binary crate ildizi ham, src/lib.rs kutubxona cratesi ildizi ham bo‘lishi mumkinligini aytib o'tdik va ikkala crate ham standart bo‘yicha paket nomiga ega bo‘ladi. Odatda, kutubxona va binary crateni o'z ichiga olgan ushbu patternli paketlar kutubxona cratesi bilan kod chaqiradigan bajariladigan faylni ishga tushirish uchun binary crateda yetarli kodga ega bo'ladi. Bu boshqa loyihalarga paket taqdim etadigan eng ko'p funksiyalardan foydalanish imkonini beradi, chunki kutubxona cratesi kodi public bo'lishi mumkin.

Modul daraxti src/lib.rs da aniqlanishi kerak. Keyin har qanday public obyektlar binary crateda paket nomi bilan yo'llarni boshlash orqali ishlatilishi mumkin. Binary crate kutubxona cratesidan foydalanuvchiga aylanadi, xuddi butunlay tashqi crate kutubxona cratesidan foydalanadi: u faqat pulic APIdan foydalanishi mumkin. Bu sizga yaxshi API yaratishga yordam beradi; Siz nafaqat muallif, balki mijoz hamsiz!

12-bobda biz ushbu tashkiliy amaliyotni binary crate va kutubxona cratesini o'z ichiga olgan buyruq qatori dasturi bilan ko'rsatamiz.

Nisbiy yo'llarni super bilan boshlash

Yo'l boshida super dan foydalanib, joriy modul yoki crate ildizi emas, balki ota-modulda boshlanadigan nisbiy yo'llarni qurishimiz mumkin. Bu fayl tizimi yoʻlini .. sintaksisi bilan boshlashga oʻxshaydi. super dan foydalanish bizga ota-modulda ekanligini biladigan elementga murojaat qilish imkonini beradi, bu modul ota-ona bilan chambarchas bog'liq bo'lsa, modul daraxtini qayta tartibga solishni osonlashtiradi, lekin ota-ona bir kun kelib modul daraxtining boshqa joyiga ko'chirilishi mumkin.

7-8 ro'yxatdagi kodni ko'rib chiqing, unda oshpaz noto'g'ri buyurtmani tuzatgan va uni mijozga shaxsan yetkazgan vaziyatni modellashtiradi. uyning_orqasi modulida aniqlangan buyurtmani_tuzatish funksiyasi super bilan boshlanadigan yetkazib_berish yo‘lini belgilash orqali asosiy modulda belgilangan yetkazib_berish funksiyasini chaqiradi:

Fayl nomi: src/lib.rs

fn yetkazib_berish() {}

mod uyning_orqasi {
    fn buyurtmani_tuzatish() {
        oshpaz();
        super::yetkazib_berish();
    }

    fn oshpaz() {}
}

Ro'yxat 7-8: super bilan boshlanadigan nisbiy yo'l yordamida funksiyani chaqirish

buyurtmani_tuzatish funksiyasi uyning_orqasi modulida joylashgan, shuning uchun biz super dan uyning_orqasi ota-moduliga o'tishimiz mumkin. U yerdan yetkazib_berish ni qidiramiz va uni topamiz. Muvaffaqiyat! Bizning fikrimizcha, uyning_orqasi moduli va yetkazib_berish funksiyasi bir-biri bilan bir xil munosabatda bo'lib qoladi va agar biz cratening modul daraxtini qayta tashkil etishga qaror qilsak, birgalikda harakatlanadi. Shu sababli, biz super dan foydalandik, shuning uchun kelajakda bu kod boshqa modulga ko‘chirilsa, kodni yangilash uchun kamroq joylarga ega bo‘lamiz.

Structlar va Enumlarni public qilish

Shuningdek, structlar va enumlarni public sifatida belgilash uchun pub dan foydalanishimiz mumkin, ammo pub dan structlar va enumlar bilan foydalanish uchun qo'shimcha tafsilotlar mavjud. Agar struct definitiondan oldin pub dan foydalansak, biz structni hammaga public qilamiz, lekin structning maydonlari hali ham private bo'lib qoladi. Biz har bir sohani alohida-alohida public qilishimiz yoki qilmasligimiz mumkin. 7-9 roʻyxatda biz public qizdirilgan_non maydoni, lekin private mavsumiy_meva maydoni bilan public uyning_orqasi:: nonushta structini belgilab oldik. Bu restoranda mijoz ovqat bilan birga keladigan non turini tanlashi mumkin bo'lgan holatni modellashtiradi, ammo oshpaz qaysi meva mavsumda va omborda borligiga qarab ovqatga hamroh bo'lishini hal qiladi. Mavjud mevalar tezda o'zgaradi, shuning uchun mijozlar mevani tanlay olmaydi yoki hatto qaysi mevani olishini ko'ra olmaydi.

Fayl nomi: src/lib.rs

mod uyning_orqasi {
    pub struct Nonushta {
        pub yopilgan_non: String,
        mavsumiy_meva: String,
    }

    impl Nonushta {
        pub fn yoz(yopilgan_non: &str) -> Nonushta {
            Nonushta {
                yopilgan_non: String::from(yopilgan_non),
                mavsumiy_meva: String::from("shaftoli"),
            }
        }
    }
}

pub fn restoranda_ovqatlanish() {
    // Yozda javdar yopilgan noni bilan nonushta buyurtma qiling
    let mut ovqat = uyning_orqasi::Nonushta::yoz("Javdar");
    // Qaysi nonni xohlashimiz haqidagi fikrimizni o'zgartiring
    ovqat.yopilgan_non = String::from("Bug'doy");
    println!("Iltimos, {}li yopilgan nonni istayman", ovqat.yopilgan_non);

    // Agar izohni olib tashlasak, keyingi qator kompilyatsiya qilinmaydi;
    // ovqat bilan birga keladigan mavsumiy mevalarni ko'rish yoki 
    // o'zgartirishga ruxsat berilmagan
    // ovqat.mavsumiy_meva = String::from("ko'katlar");
}

Ro'yxat 7-9: Ba'zi public maydonlari va ba'zilari bo'lgan struct xususiy maydonlar

uyning_orqasi::Nonushta structdagi yopilgan_non maydoni public bo'lgani uchun restoranda_ovqatlanish da biz yopilgan_non maydoniga nuqta belgisi yordamida yozishimiz va o'qishimiz mumkin. Esda tutingki, biz mavsumiy_meva maydonidan restoranda_ovqatlanishda foydalana olmaymiz, chunki mavsumiy_meva privatedir. Qaysi xatoga yo'l qo'yganingizni bilish uchun mavsumiy_meva maydoni qiymatini o'zgartiruvchi qatorni izohdan chiqarib ko'ring!

Shuni ham yodda tutingki, uyning_orqasi::Nonushta private maydonga ega bo'lgani uchun struct Nonushta misolini yaratuvchi public bog'langan funksiyani ta'minlashi kerak (biz uni bu yerda yoz deb nomladik).Agar Nonushta bunday funksiyaga ega boʻlmagan boʻlsa, biz restoranda_ovqatlanishda Nonushta misolini yarata olmadik, chunki biz restoranda_ovqatlanishda private mavsumiy_meva maydonining qiymatini oʻrnata olmadik.

Aksincha, agar biz enumni public qilsak, uning barcha variantlari public bo'ladi. 7 10 roʻyxatda koʻrsatilganidek, bizga faqat enum kalit soʻzidan oldin pub kerak boʻladi.

Fayl nomi: src/lib.rs

mod uyning_orqasi {
    pub enum Taom {
        Palov,
        Salat,
    }
}

pub fn restoranda_ovqatlanish() {
    let buyurtma1 = uyning_orqasi::Taom::Palov;
    let buyurtma2 = uyning_orqasi::Taom::Salat;
}

Ro'yxat 7-10: Enumni public deb belgilash uning barcha variantlarini hammaga ochiq qiladi

Biz Taom ro‘yxatini hammaga public qilganimiz uchun restoranda_ovqatlanishda Palov va Salat variantlaridan foydalanishimiz mumkin.

Enumlar, agar ularning variantlari public bo'lmasa, unchalik foydali emas; Har bir holatda pub bilan barcha enum variantlariga izoh qo'yish zerikarli bo'lar edi, shuning uchun enum variantlari uchun standart umumiy bo'lishi kerak. Structlar ko'pincha maydonlari public bo'lmasdan foydali bo'ladi, shuning uchun struct maydonlari, agar pub bilan izohlanmagan bo'lsa, standart bo'yicha hamma narsa private bo'lishining umumiy qoidasiga amal qiladi.

pub bilan bog'liq yana bir holat bor, biz uni ko'rib chiqmaganmiz va bu bizning modul tizimining oxirgi xususiyati: use kalit so'zi. Biz avval use ni o'z ichiga olamiz, so'ngra pub va use ni qanday birlashtirishni ko'rsatamiz.

use kalit so'zi bilan yo'llarni doiraga kiritish

Funksiyalarni chaqirish yo'llarini yozishga to'g'ri kelishi noqulay va takroriy tuyulishi mumkin. 7-7-Ro'yxatda navbat_listiga_qoshish funksiyasiga mutlaq yoki nisbiy yoʻlni tanladikmi, har safar navbat_listiga_qoshish funksiyasiga murojat qilmoqchi boʻlganimizda, uyning_oldi va xizmatni ham belgilashimiz kerak edi. Yaxshiyamki, bu jarayonni soddalashtirishning bir usuli bor: biz bir marta use kalit so‘zi bilan yo‘lga nom yaratishimiz mumkin, so‘ngra boshqa hamma joyda qisqaroq nomdan foydalanishimiz mumkin.

7-11 ro'yxatda biz crate::uyning_oldi::xizmat modulini restoranda_ovqatlanish funksiyasi doirasiga kiritamiz, shuning uchun restoranda_ovqatlanishdagi navbat_listiga_qoshish funksiyasini chaqirish uchun faqat xizmat::navbat_listiga_qoshish ni belgilashimiz kerak.

Fayl nomi: src/lib.rs

mod uyning_oldi {
    pub mod xizmat {
        pub fn navbat_listiga_qoshish() {}
    }
}

use crate::uyning_oldi::xizmat;

pub fn restoranda_ovqatlanish() {
    xizmat::navbat_listiga_qoshish();
}

Ro'yxat 7-11: Modulni use bilan qamrab olish

use va sohaga yo'lni qo'shish fayl tizimida ramziy havola yaratishga o'xshaydi. Crate ildiziga use crate::uyning_oldi::xizmat ni qo‘shish orqali xizmat endi bu doirada haqiqiy nom bo‘lib qoladi, xuddi xizmat moduli crate ildizida aniqlangandek. use doirasiga kiritilgan yo'llar boshqa yo'llar kabi maxfiylikni ham tekshiradi.

E'tibor bering, use faqat use ishlaydigan aniq doira uchun yorliqni yaratadi. 7-12 roʻyxat restoranda_ovqatlanish funksiyasini mijoz nomli yangi bolalar moduliga oʻtkazadi, bu keyinchalik use statementidan farq qiladi, shuning uchun funksiyaning tanasi kompilyatsiya qilinmaydi:

Fayl nomi: src/lib.rs

mod uyning_oldi {
    pub mod xizmat {
        pub fn navbat_listiga_qoshish() {}
    }
}

use crate::uyning_oldi::xizmat;

mod mijoz {
    pub fn restoranda_ovqatlanish() {
        xizmat::navbat_listiga_qoshish();
    }
}

Ro'yxat 7-12: use statementi faqat u joylashgan doirada qo'llaniladi

Kompilyator xatosi yorliq endi mijoz modulida qo'llanilmasligini ko'rsatadi:

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
warning: unused import: `crate::uyning_oldi::xizmat`
 --> src/lib.rs:7:5
  |
7 | use crate::uyning_oldi::xizmat;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

error[E0433]: failed to resolve: use of undeclared crate or module `xizmat`
  --> src/lib.rs:11:9
   |
11 |         xizmat::navbat_listiga_qoshish();
   |         ^^^^^^ use of undeclared crate or module `xizmat`

For more information about this error, try `rustc --explain E0433`.
warning: `restaurant` (lib) generated 1 warning
error: could not compile `restaurant` due to previous error; 1 warning emitted

E'tibor bering, use endi uning doirasida qo'llanilmasligi haqida ogohlantirish ham bor! Bu muammoni hal qilish uchun use ni mijoz moduliga ham o‘tkazing yoki mijoz modulidagi super::xizmat bilan ota-moduldagi yorliqlarga murojaat qiling.

use bilan idiomatik yo'llarni yaratish

7-11 ro'yxatda siz shunday deb hayron bo'lishingiz mumkin,Nima uchun biz bir xil natijaga erishish uchun navbat_listiga_qoshish funksiyasigacha toʻliq yoʻlni ishlatish oʻrniga, crate::uyning_oldi::xizmat ni ishlatishni belgilab qoʻydik va keyin restoranda_ovqatlanish ichidagi xizmat::navbat_listiga_qoshish ga murojat qildik, 7-13 ro'yxatdagi kabi.

Fayl nomi: src/lib.rs

mod uyning_oldi {
    pub mod xizmat {
        pub fn navbat_listiga_qoshish() {}
    }
}

use crate::uyning_oldi::xizmat::navbat_listiga_qoshish;

pub fn restoranda_ovqatlanish() {
    navbat_listiga_qoshish();
}

Ro'yxat 7-13: navbat_listiga_qoshish funksiyasini use bilan qamrab olish, bu unidiomatikdir

Garchi 7-11 va 7-13 ro'yxatlari bir xil vazifani bajarsa-da, 7-11 ro'yxat funksiyani use bilan qamrab olishning idiomatik usulidir. Funksiyaning ota-modulini use bilan qamrab olish funksiyani chaqirishda ota-modulni belgilashimiz kerakligini anglatadi. Funksiyani chaqirishda ota-modulni ko'rsatish, to'liq yo'lning takrorlanishini minimallashtirish bilan birga, funksiya mahalliy sifatida aniqlanmaganligini aniq ko'rsatadi. 7-13 ro'yxatda navbat_listiga_qoshish qayerda aniqlangani aniq emas.

Boshqa tomondan, use bilan structlar, enumlar va boshqa elementlarni keltirishda to'liq yo'lni ko'rsatish idiomatikdir. 7-14 ro'yxat standart kutubxonaning HashMap structini binary crate doirasiga olib kirishning idiomatik usulini ko'rsatadi.

Fayl nomi: src/main.rs

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

Ro'yxat 7-14: HashMap ni idiomatik tarzda qamrab olish

Bu idioma ortida hech qanday yaxshi sabab yo'q: Bu shunchaki konventsiya paydo bo'ldi va odamlar Rust kodini shu tarzda o'qish va yozishga o'rganib qolgan.

Bu idiomadan istisno shundaki, biz bir xil nomdagi ikkita elementni use statementi yordamida doiraga kiritganimizda - Rust bunga yo'l qo'ymaydi. 7-15 ro'yxatda bir xil nomga ega, ammo har xil ota-modullarga ega bo'lgan ikkita Result turini qanday ko'rinishga kiritish va ularga qanday murojaat qilish kerakligi ko'rsatilgan.

Fayl nomi: src/lib.rs

use std::fmt;
use std::io;

fn funksiya1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn funksiya2() -> io::Result<()> {
    // --snip--
    Ok(())
}

Ro'yxat 7-15: Bir xil nomdagi ikkita turni bir xil doiraga kiritish uchun ularning ota-modullaridan foydalanish talab etiladi.

Ko'rib turganingizdek, ota-modullardan foydalanish ikkita Result turini ajratib turadi. Buning o'rniga use std::fmt::Result va us std::io::Result ni belgilagan bo'lsak, bizda bir xil miqyosda ikkita Result turi bo'lar edi va Rust Result dan foydalanganda qaysi birini nazarda tutganimizni bilmas edi.

as kalit so'zi bilan yangi nomlarni taqdim etish

Bir xil nomdagi ikkita turni use bilan bir xil doiraga olib kirish muammosining yana bir yechimi bor: yoʻldan soʻng biz as va yangi mahalliy nom yoki tur uchun taxallus belgilashimiz mumkin. 7-16 ro'yxatda ikkita Result turidan birini as yordamida qayta nomlash orqali 7-15 ro'yxatdagi kodni yozishning yana bir usuli ko'rsatilgan.

Fayl nomi: src/lib.rs

use std::fmt::Result;
use std::io::Result as IoResult;

fn funksiya1() -> Result {
    // --snip--
    Ok(())
}

fn funksiya2() -> IoResult<()> {
    // --snip--
    Ok(())
}

Ro'yxat 7-16: as kalit so'zi bilan qamrovga kiritilgan tur nomini o'zgartirish

Ikkinchi use statementida biz std::io::Result turi uchun yangi IoResult nomini tanladik, bu endi std::fmt dan Result turiga zid kelmaydi, u ham doiraga kiradi. 7-15 va 7-16 ro'yxatlar idiomatik hisoblanadi, shuning uchun tanlov sizga bog'liq!

pub use bilan nomlarni qayta eksport(re-eksport) qilish

use kalit so'zidan foydalanib, nomni qamrovga kiritganimizda, yangi doirada mavjud bo'lgan nom private bo'ladi. Bizning kodimizni chaqiradigan kodni xuddi shu kod doirasida aniqlangandek ushbu nomga murojaat qilishini yoqish uchun biz pub va use ni birlashtira olamiz. Bu usul re-eksport deb nomlanadi, chunki biz obyektni qamrovga kiritmoqdamiz, lekin elementni boshqa qamrovlarga kiritish uchun ham mavjud qilamiz.

7-17 ro'yxatda 7-11 ro'yxatdagi kod ko'rsatilgan, ildiz modulidagi use pub use ga o'zgartirilgan.

Fayl nomi: src/lib.rs

mod uyning_oldi {
    pub mod xizmat {
        pub fn navbat_listiga_qoshish() {}
    }
}

pub use crate::uyning_oldi::xizmat;

pub fn restoranda_ovqatlanish() {
    xizmat::navbat_listiga_qoshish();
}

Ro'yxat 7-17. pub use bilan yangi doiradagi istalgan kod tomonidan foydalanish uchun nom berish

Ushbu o'zgarishdan oldin tashqi kod restoran::uyning_oldi::xizmat::navbat_listiga_qoshish() yo'lidan foydalanib, navbat_listiga_qoshish funksiyasini chaqirishi kerak bo'ladi. Endi bu pub use xizmat modulini ildiz modulidan qayta eksport qilgan bo‘lsa, tashqi kod endi restoran::xizmat::navbat_listiga_qoshish() yo‘lidan foydalanishi mumkin..

Qayta eksport qilish sizning kodingizning ichki tuzilishi sizning kodingizni chaqirayotgan dasturchilarning domen haqida o'ylashlaridan farq qilganda foydali bo'ladi. Misol uchun, ushbu restoran metaforasida restoranni boshqaradigan odamlar "uyning old tomoni" va "uyning orqasi" haqida o'ylashadi. Ammo restoranga tashrif buyurgan mijozlar, ehtimol, restoranning qismlari haqida o'ylamaydilar. pub use bilan biz kodimizni bitta struct bilan yozishimiz mumkin, lekin boshqa structni ko'rsatamiz. Bu bizning kutubxonamizni kutubxonada ishlaydigan dasturchilar va kutubxonaga murojat qilayotgan dasturchilar uchun uchun yaxshi tashkil etilgan holda saqlaydi. Biz 14-bobning “pub use bilan qulay umumiy APIni eksport qilish” bo‘limida pub usening yana bir misolini va uning cratengiz hujjatlariga qanday ta’sir qilishini ko‘rib chiqamiz.

Tashqi paketlardan foydalanish

2-bobda biz tasodifiy raqamlarni olish uchun rand deb nomlangan tashqi paketdan foydalangan holda taxminiy o'yin loyihasini dasturlashtirdik. Loyihamizda rand dan foydalanish uchun biz ushbu qatorni Cargo.toml ga qo'shdik:

Fayl nomi: Cargo.toml

rand = "0.8.5"

Cargo.toml-ga randni dependency sifatida qo'shish Cargo-ga crates.io-dan rand paketini va har qanday bog'liqliklarni yuklab olishni va randni loyihamiz uchun ishlatishni aytadi.

Keyin, rand ta'riflarini paketimiz doirasiga kiritish uchun biz crate nomidan boshlanadigan use qatorini qo'shdik, rand va biz qamrab olmoqchi bo'lgan elementlarni sanab o'tdik. Eslatib o‘tamiz, 2-bobdagi “Tasodifiy raqamni yaratish” bo‘limida biz Rng traitini qamrab oldik va rand::thread_rng funksiyasini chaqirdik:

use std::io;
use rand::Rng;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o‘qib bo‘lmadi");

    println!("Sizning taxminingiz: {taxmin}");
}

Rust hamjamiyatining a'zolari crates.io saytida ko'plab paketlarni taqdim etishdi va ulardan birini o'z paketingizga olish xuddi shu bosqichlarni o'z ichiga oladi: ularni paketingizning Cargo.toml faylida roʻyxatga kiriting va use dan foydalanib, ularni cratelaridagi elementlarni qamrab oling.

E'tibor bering, standart std kutubxonasi bizning paketimizdan tashqarida joylashgan cratedir. Standart kutubxona Rust tili bilan birga kelganligi sababli, biz Cargo.toml ni std qo'shish uchun o'zgartirishimiz shart emas. Ammo biz u yerdan elementlarni paketimiz doirasiga olib kirish uchun use bilan murojaat qilishimiz kerak. Masalan, HashMap bilan biz ushbu qatordan foydalanamiz:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

Bu standart kutubxona cratesining nomi bo'lgan std bilan boshlanadigan mutlaq yo'ldir.

Uzun use ro'yxatini qisqartirish uchun ichki yo'llardan foydalanish

Agar biz bir xil crate yoki bir xil modulda belgilangan bir nechta elementlardan foydalansak, har bir elementni o'z qatoriga qo'yish bizning fayllarimizda juda ko'p vertikal joy egallashi mumkin. Masalan, 2-4 roʻyxatdagi raqamlarni taxmin qilish dasturida mavjud boʻlgan ushbu ikkita use statementi std dagi elementlarni qamrab oladi:

Filename: src/main.rs

use rand::Rng;
// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o'qib bo'lmadi");

    println!("Sizning taxminingiz: {taxmin}");

    match taxmin.cmp(&yashirin_raqam) {
        Ordering::Less => println!("Raqam Kichik!"),
        Ordering::Greater => println!("Raqam katta!"),
        Ordering::Equal => println!("Siz yutdingiz!"),
    }
}

Buning o'rniga, biz bir xil elementlarni bir qatorga kiritish uchun ichki yo'llardan foydalanishimiz mumkin. Buni 7-18 roʻyxatda koʻrsatilganidek, yoʻlning umumiy qismini, keyin ikkita nuqta qoʻyib, soʻngra yoʻllarning bir-biridan farq qiladigan qismlari roʻyxati atrofida jingalak qavslarni belgilash orqali qilamiz.

Fayl nomi: src/main.rs

use rand::Rng;
// --snip--
use std::{cmp::Ordering, io};
// --snip--

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    println!("Yashirin raqam: {yashirin_raqam}");

    println!("Iltimos, taxminingizni kiriting.");

    let mut taxmin = String::new();

    io::stdin()
        .read_line(&mut taxmin)
        .expect("Satrni o'qib bo'lmadi");

    let taxmin: u32 = taxmin.trim().parse().expect("Iltimos, raqam yozing!");

    println!("Sizning taxminingiz: {taxmin}");

    match taxmin.cmp(&yashirin_raqam) {
        Ordering::Less => println!("Raqam Kichik!"),
        Ordering::Greater => println!("Raqam katta!"),
        Ordering::Equal => println!("Siz yutdingiz!"),
    }
}

Ro'yxat 7-18. Qo'llash sohasiga bir xil prefiksli bir nechta elementlarni qo'shish uchun ichki yo'lni belgilash

Kattaroq dasturlarda bir xil crate yoki moduldan ko'plab elementlarni o'rnatilgan yo'llar yordamida qamrab olish juda ko'p talab qilinadigan alohida use statementlari sonini kamaytirishi mumkin!

Siz har qanday darajadagi ichki yo'ldan foydalanishingiz mumkin, bu yo'l qismini ulashuvchi ikkita use statementini birlashtirishda foydalidir. Masalan, 7-19 ro'yxat ikkita use statementini ko'rsatadi: biri std::io ni qamrab oladi va ikkinchisi std::io::Write ni qamrab oladi.

Fayl nomi: src/lib.rs

use std::io;
use std::io::Write;

Ro'yxat 7-19: biri ikkinchisining bir qismi bo'lgan ikkita use statementi

Ushbu ikkita yo'lning umumiy qismi std::io va to'liq birinchi yo'ldir. Ushbu ikkita yo'lni bitta use statementiga birlashtirish uchun biz 7-20 ro'yxatda ko'rsatilganidek, ichki yo'lda self dan foydalanishimiz mumkin.

Fayl nomi: src/lib.rs

use std::io::{self, Write};

Ro'yxat 7-20: Ro'yxat 7-19dagi yo'llarni bitta use statementiga birlashtirish

Bu satr std::io va std::io::Write ni qamrab oladi.

Glob operatori

Agar biz yo'lda belgilangan barcha umumiy elementlarni qamrovga kiritmoqchi bo'lsak, biz * glob operatori tomonidan keyingi yo'lni belgilashimiz mumkin:

#![allow(unused)]
fn main() {
use std::collections::*;
}

Ushbu use statementi std::collections da aniqlangan barcha public elementlarni joriy doiraga olib keladi. Glob operatoridan foydalanganda ehtiyot bo'ling! Glob qaysi nomlar qamrovda ekanligini va dasturingizda ishlatiladigan nom qayerda aniqlanganligini aniqlashni qiyinlashtirishi mumkin.

Glob operatori ko'pincha sinovdan o'tgan hamma narsani tests moduliga kiritish uchun test paytida ishlatiladi; biz bu haqda 11-bobdagi "Testlarni qanday yozish kerak" bo'limida gaplashamiz. Glob operatori ba'zan prelude patterning bir qismi sifatida ham qo'llaniladi: ushbu pattern haqida qo'shimcha ma'lumot olish uchun standart kutubxona texnik hujjatlariga qarang.

Modullarni turli fayllarga ajratish

Hozirgacha ushbu bobdagi barcha misollar bitta faylda bir nechta modullarni aniqladi. Modullar kattalashganda, kodni boshqarishni osonlashtirish uchun ularning definitionlarini alohida faylga ko'chirishingiz mumkin.

Masalan, 7-17 ro'yxatdagi bir nechta restoran moduliga ega bo'lgan koddan boshlaylik. Biz cratening ildiz modulidagi barcha modullarni aniqlash o'rniga modullarni fayllarga ajratamiz. Bunday holda, cratening ildiz fayli src/lib.rs bo'ladi, lekin bu protsedura crate ildiz fayli src/main.rs bo'lgan binary cratelar bilan ham ishlaydi.

Birinchidan, biz uyning_oldi modulini o'z fayliga chiqaramiz. uyning_oldi moduli uchun jingalak qavslar ichidagi kodni olib tashlang va faqat mod uyning_oldi deklaratsiyasini qoldiring, shunda src/lib.rs ro'yxat 7-21da ko'rsatilgan kodni o`z ichiga oladi. E'tibor bering, biz 7-22 ro'yxatda src/uyning_oldi.rs faylini yaratmagunimizcha, bu kompilyatsiya qilinmaydi.

Fayl nomi: src/lib.rs

mod uyning_oldi;

pub use crate::uyning_oldi::xizmat;

pub fn restoranda_ovqatlanish() {
    xizmat::navbat_listiga_qoshish();
}

Ro'yxat 7-21. Tarkibi src/uyning_oldi.rs da joylashgan uyning_oldi modulini e'lon qilish

Keyin, jingalak qavslardagi kodni yangi faylga joylashtiring 7-22 ro'yxatda ko'rsatilganidek src/uyning_oldi.rs deb nomlangan. Kompilyator bu faylda nimani izlash kerakligini biladi, chunki u uyning_oldi deb nomlangan cratening ildiz modulida modul deklaratsiyasiga duch keldi.

Fayl nomi: src/uyning_oldi.rs

{{#rustdoc_include ../listings/ch07-managing-growing-projects/listing-07-21-and-22/src/front_of_house.rs}}

Ro'yxat 7-22. src/uyning_oldi.rs faylida uyning_oldi modulining mazmunini aniqlash

Esda tutingki, modul daraxtida bir marta mod deklaratsiyasidan foydalanib faylni yuklashingiz kerak. Kompilyator fayl loyihaning bir qismi ekanligini bilgandan so'ng (va mod statementi qo'ygan joyingiz tufayli kod modul daraxtining qayerida joylashganligini biladi), loyihangizdagi boshqa fayllar yuklangan fayl kodiga u e'lon qilingan joyga yo'l orqali murojaat qilishi kerak, bu "Modul daraxtidagi elementga murojaat qilish yo'llari" bo'limida yoritilgan. Boshqacha qilib aytganda, mod boshqa dasturlash tillarida ko'rishingiz mumkin bo'lgan “include” operatsiyasi emas.

Keyinchalik, biz xizmat modulini o'z fayliga chiqaramiz. Jarayon biroz boshqacha, chunki xizmat ildiz modulining emas, balki uyning_oldi ichki modulidir.Biz xizmat faylini modul daraxtidagi ajdodlari nomi bilan ataladigan yangi jildga joylashtiramiz, bu holda src/uyning_oldi/.

xizmatni ko‘chirishni boshlash uchun biz src/uyning_oldi.rs ni faqat xizmat moduli deklaratsiyasini o‘z ichiga olgan holda o‘zgartiramiz:

Fayl nomi: src/uyning_oldi.rs

{{#rustdoc_include ../listings/ch07-managing-growing-projects/no-listing-02-extracting-hosting/src/front_of_house.rs}}

Keyin biz src/uyning_oldi jildini va xizmat modulida berilgan definitionlarni o'z ichiga olgan xizmat.rs faylini yaratamiz:

Fayl nomi: src/uyning_oldi/xizmat.rs

{{#rustdoc_include ../listings/ch07-managing-growing-projects/no-listing-02-extracting-hosting/src/front_of_house/hosting.rs}}

Agar biz src jildiga xizmat.rs ni qo'ysak, kompilyator xizmat.rs kodi crate ildizida e'lon qilingan va uyning_oldi modulining yordamchisi sifatida e'lon qilinmagan xizmat modulida bo'lishini kutadi. Kompilyator qoidalari qaysi modullarning kodini o'z ichiga olgan fayllarni tekshirish uchun jildlar va fayllar modul daraxtiga to'liq mos kelishini taxmin qiladi.

Muqobil fayl yo'llari

Hozirgacha biz Rust kompilyatori foydalanadigan eng idiomatik fayl yo'llarini ko'rib chiqdik, lekin Rust fayl yo'lining eski uslubini ham qo'llab-quvvatlaydi. Crate ildizida e'lon qilingan uyning_oldi nomli modul uchun kompilyator modul kodini quyidagilardan qidiradi: module’s code in:

• src/uyning_oldi.rs (biz nimani qamrab oldik)
• src/uyning_oldi/mod.rs (eski uslub, hali ham qo'llab-quvvatlanadigan yo'l)

uyning_oldi submodul bo'lgan xizmat nomli modul uchun kompilyator modul kodini qidiradi:

• src/uyning_oldi/xizmat.rs (biz nimani qamrab oldik)
• src/uyning_oldi/xizmat/mod.rs (eski uslub, hali ham qo'llab-quvvatlanadigan yo'l)

Agar bir xil modul uchun ikkala uslubdan foydalansangiz, kompilyator xatosi paydo bo'ladi. Bitta loyihada turli modullar uchun ikkala uslubning aralashmasidan foydalanishga ruxsat beriladi, lekin loyihangizni boshqarayotgan odamlar uchun chalkash bo'lishi mumkin.

mod.rs nomli fayllardan foydalanadigan uslubning asosiy kamchiligi shundaki, sizning loyihangiz mod.rs nomli ko‘plab fayllar bilan tugashi mumkin, ular bir vaqtning o‘zida muharriringizda ochilganda chalkash bo‘lishi mumkin.

Biz har bir modul kodini alohida faylga ko'chirdik va modul daraxti o'zgarishsiz qoldi. restoranda_ovqatlanish funksiyasi chaqiruvlari, definitionlar turli fayllarda bo'lsa ham, hech qanday o'zgartirishlarsiz ishlaydi. Ushbu texnika modullarni hajmi oshgani sayin yangi fayllarga ko'chirish imkonini beradi.

Esda tutingki, src/lib.rs dagi pub use crate::uyning_oldi::xizmat statementi ham o'zgarmagan va use qaysi fayllar cratening bir qismi sifatida tuzilganiga ta'sir qilmaydi. mod kalit so'zi modullarni e'lon qiladi va Rust ushbu modulga kiradigan kod moduli bilan bir xil nomdagi faylga qaraydi.

Xulosa

Rust sizga paketni bir nechta cratelarga va crateni modullarga bo'lish imkonini beradi, shunda siz bir modulda belgilangan elementlarga boshqa moduldan murojaat qilishingiz mumkin. Buni mutlaq yoki nisbiy yo'llarni belgilash orqali amalga oshirishingiz mumkin. Ushbu yo'llar use statementi bilan qamrab olinishi mumkin, shuning uchun siz ushbu doiradagi elementdan bir nechta foydalanish uchun qisqaroq yo'ldan foydalanishingiz mumkin. Modul kodi standart boʻyicha maxfiydir, lekin pub kalit soʻzini qoʻshish orqali definitionlarni hammaga public qilishingiz mumkin.

Keyingi bobda biz standart kutubxonadagi ma'lumotlar tuzilmalarining ba'zi to'plamlarini ko'rib chiqamiz, ulardan siz o'zingizning aniq tartiblangan kodingizda foydalanishingiz mumkin.

Umumiy to'plamlar

Rustning standart kutubxonasi kolleksiyalar deb nomlangan juda foydali ma'lumotlar tuzilmalarini o'z ichiga oladi. Ko'pgina boshqa ma'lumotlar turlari bitta ma'lum qiymatni ifodalaydi, lekin to'plamlar bir nechta qiymatlarni o'z ichiga olishi mumkin. O'rnatilgan array va tuple turlaridan farqli o'laroq, ushbu to'plamlar ko'rsatadigan ma'lumotlar heapda saqlanadi, ya'ni ma'lumotlar miqdori kompilyatsiya vaqtida ma'lum bo'lishi shart emas va dastur ishga tushganda o'sishi yoki qisqarishi mumkin. To'plamning har bir turi o'z imkoniyatlariga ega va ishlash jihatidan farq qiladi, shuning uchun ma'lum bir to'plamni tanlash vaziyatga bog'liq va vaqt o'tishi bilan ishlab chiquvchining mahoratidir. Ushbu bobda biz Rust dasturlarida tez-tez ishlatiladigan uchta to'plamni muhokama qilamiz:

• vector o'zgaruvchan sonli qiymatlarni bir-birining yonida saqlashga imkon beradi.
• string - bu belgilar to'plami. Biz String turini avval aytib o'tgan edik, ammo bu bobda biz bu haqda chuqurroq gaplashamiz.
• hash map ma'lum bir kalit bilan qiymatni bog'lash imkonini beradi.Bu map deb nomlangan umumiy ma'lumotlar strukturasining o'ziga xos tatbiqidir.

Standart kutubxona tomonidan taqdim etilgan boshqa turdagi to'plamlar haqida bilish uchun texnik hujjatlarga qarang.

Biz vectorlarni, stringlarni va hash-maplarni qanday yaratish va yangilashni, shuningdek, har birining o'ziga xosligini muhokama qilamiz.

Vectorlar bilan qiymatlar ro'yxatini saqlash

Biz ko'rib chiqadigan birinchi to'plam turi Vec<T> bo'lib, u vector sifatida ham tanilgan. Vectorlar xotirada barcha qiymatlarni yonma-yon joylashtirgan yagona ma'lumotlar strukturasida bir nechta qiymatlarni saqlash imkonini beradi. Vectorlar faqat bir xil turdagi qiymatlarni saqlashi mumkin. Ular sizda fayldagi matn satrlari yoki xarid qilish savatidagi narsalarning narxlari kabi elementlar ro'yxatiga ega bo'lsangiz foydali bo'ladi.

Yangi vector yaratish

Yangi bo'sh vector yaratish uchun biz 8-1 ro'yxatda ko'rsatilganidek, Vec::new funksiyasini chaqiramiz.

fn main() {
    let v: Vec<i32> = Vec::new();
}

Roʻyxat 8-1: i32 turidagi qiymatlarni saqlash uchun yangi, boʻsh vector yaratish

E'tibor bering, biz bu erda annation tur qo'shdik. Biz ushbu vectorga hech qanday qiymat kiritmayotganimiz sababli, Rust biz qanday elementlarni saqlashni xohlayotganimizni bilmaydi. Bu muhim nuqta. Vectorlar generiklar yordamida amalga oshiriladi; Biz 10-bobda o'zingizning turlaringiz bilan generiklardan qanday foydalanishni ko'rib chiqamiz. Hozircha shuni bilingki, standart kutubxona tomonidan taqdim etilgan Vec<T> turi har qanday turni sig'dira oladi. Muayyan turni ushlab turish uchun vector yaratganimizda, burchakli qavslar([]) ichida turni belgilashimiz mumkin. 8-1 roʻyxatida biz Rustga vdagi Vec<T> i32 turidagi elementlarni saqlashini aytdik.

Ko'pincha siz boshlang'ich qiymatlari bilan Vec<T> ni yaratasiz va Rust siz saqlamoqchi bo'lgan qiymat turini aniqlaydi, shuning uchun kamdan-kam hollarda bu turdagi annotionni bajarishingiz kerak bo'ladi. Rust qulay tarzda vec! makrosini taqdim etadi, bu esa siz bergan qiymatlarni saqlaydigan yangi vectorni yaratadi. 8-2 roʻyxati 1, 2 va 3 qiymatlariga ega boʻlgan yangi Vec<i32>ni yaratadi. Butun son turi i32 dir, chunki bu standart butun son turi, biz 3-bobning "Ma'lumotlar turlari" bo'limida muhokama qilganimizdek.

fn main() {
    let v = vec![1, 2, 3];
}

Ro'yxat 8-2: qiymatlarni o'z ichiga olgan yangi vector yaratish

Biz boshlang‘ich i32 qiymatlarini berganimiz sababli, Rust v turi Vec<i32> ekanligini va tur izohi shart emas degan xulosaga kelishi mumkin. Keyinchalik vectorni qanday o'zgartirishni ko'rib chiqamiz.

Vectorni yangilash

Vector yaratish va unga elementlar qo'shish uchun biz 8-3 ro'yxatda ko'rsatilganidek, push metodidan foydalanishimiz mumkin.

fn main() {
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
}

Ro'yxat 8-3: vectorga qiymatlar qo'shish uchun push metodidan foydalanish

Har qanday o'zgaruvchida bo'lgani kabi, agar biz uning qiymatini o'zgartirish imkoniyatiga ega bo'lishni istasak, 3-bobda muhokama qilinganimizdek, mut kalit so'zidan foydalanib, uni o'zgaruvchan qilishimiz kerak. Biz joylashtirgan raqamlarning barchasi i32 turiga kiradi va Rust buni maʼlumotlardan chiqaradi, shuning uchun bizga Vec<i32> annotationi kerak emas.

Vector elementlarini o'qish

Vectorda saqlangan qiymatga murojaat qilishning ikki yo'li mavjud: indekslash yoki get metodi yordamida. Quyidagi misollarda biz qo'shimcha aniqlik uchun ushbu funksiyalardan qaytariladigan qiymatlar turlarini izohladik.

8-4 ro'yxatda indekslash sintaksisi va get metodi bilan vectordagi qiymatga kirishning ikkala usuli ko'rsatilgan.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let uchinchi: &i32 = &v[2];
    println!("Uchinchi element {uchinchi}");

    let uchinchi: Option<&i32> = v.get(2);
    match uchinchi {
        Some(uchinchi) => println!("Uchinchi element {uchinchi}"),
        None => println!("Uchinchi element yo'q."),
    }
}

Ro'yxat 8-4: Vectordagi elementga kirish uchun indekslash sintaksisi yoki get metodidan foydalanish

Bu erda bir nechta detallarga e'tibor bering. Uchinchi elementni olish uchun 2 indeks qiymatidan foydalanamiz, chunki vectorlar noldan boshlab raqamlar boʻyicha indekslanadi. & va [] dan foydalanish bizga indeks qiymatidagi elementga reference beradi. Argument sifatida berilgan indeks bilan get metodidan foydalansak, biz match bilan foydalanishimiz mumkin bo'lgan Option<&T>ni olamiz.

Rust elementga reference qilishning ushbu ikki usulini taqdim etishining sababi shundaki, siz mavjud elementlar doirasidan tashqarida indeks qiymatidan foydalanmoqchi bo'lganingizda dastur qanday harakat qilishini tanlashingiz mumkin. Misol sifatida, keling, besh elementli vectorga ega bo'lganimizda nima sodir bo'lishini ko'rib chiqamiz va keyin 8-5 ro'yxatda ko'rsatilganidek, har bir texnikada 100 indeksidagi elementga kirishga harakat qilamiz.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let mavjud_emas = &v[100];
    let mavjud_emas = v.get(100);
}

Ro'yxat 8-5: besh elementni o'z ichiga olgan vectorda 100 indeksidagi elementga kirishga urinish

Ushbu kodni ishga tushirganimizda, birinchi [] metodi dasturda panic chiqaradi, chunki u mavjud bo'lmagan elementga murojaat qiladi. Ushbu usul vector oxiridan o'tgan elementga kirishga urinish bo'lsa, dasturingiz ishdan chiqishini xohlasangiz yaxshi qo'llaniladi.

get metodi vectordan tashqaridagi indeksdan o'tganda, panic qo'ymasdan Noneni qaytaradi. Vector doirasidan tashqaridagi elementga kirish vaqti-vaqti bilan oddiy sharoitlarda sodir bo'lishi mumkin bo'lsa, siz ushbu usuldan foydalanasiz. Keyin sizning kodingiz 6-bobda muhokama qilinganidek, Some(&element) yoki Nonega ega bo'lish mantiqiga ega bo'ladi.Misol uchun, indeks raqamni kiritgan odamdan kelib chiqishi mumkin. Agar ular tasodifan juda katta raqamni kiritsa va dastur None qiymatiga ega bo'lsa, siz foydalanuvchiga joriy vectorda nechta element borligini aytishingiz va ularga to'g'ri qiymat kiritish uchun yana bir imkoniyat berishingiz mumkin.Bu imlo xatosi tufayli dasturni buzishdan ko'ra foydalanuvchilar uchun qulayroq bo'lar edi!

Dasturda tegishli reference mavjud bo'lsa, borrow tekshiruvi ushbu reference va vector mazmuniga boshqa har qanday referencelar haqiqiyligini ta'minlash uchun ownership va borrowing qoidalarini (4-bobda ko'rsatilgan) amalga oshiradi. Bir xil doirada o'zgaruvchan va o'zgarmas referencelarga ega bo'lolmaysiz degan qoidani eslang. Ushbu qoida 8-6 ro'yxatda qo'llaniladi, bu yerda biz vectordagi birinchi elementga o'zgarmas referenceni ushlab turamiz va elementni oxiriga qo'shishga harakat qilamiz. Agar biz ushbu elementga keyinroq funksiyada murojaat qilsak, bu dastur ishlamaydi:

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let birinchi = &v[0];

    v.push(6);

    println!("Birinchi element: {birinchi}");
}

Ro'yxat 8-6. Vector elementiga reference mavjud bo'lganda vectorga biron bir element qo'shishga urinish

Ushbu kodni kompilyatsiya qilish ushbu xatoga olib keladi:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:5
  |
4 |     let birinchi = &v[0];
  |                  - immutable borrow occurs here
5 |
6 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
7 |
8 |     println!("Birinchi element: {birinchi}");
  |                                 ----------- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` due to previous error

8-6 ro'yxatdagi kod ishlashi kerakdek ko'rinishi mumkin: nima uchun birinchi elementga reference vector oxiridagi o'zgarishlar haqida qayg'urishi kerak? Bu xato vectorlarning ishlash usuli bilan bog'liq: vectorlar qiymatlarni xotirada bir-birining yoniga qo'yganligi sababli vector oxiriga yangi element qo'shish yangi xotira ajratishni va eski elementlarni yangi bo'sh joyga ko'chirishni talab qilishi mumkin. Hozirda vector saqlanadigan barcha elementlarni bir-birining yoniga qo'yish uchun joy etarli emas. Bunday holda, birinchi elementga reference ajratilgan xotiraga ishora qiladi. Borrowing qoidalari dasturlarning bunday vaziyatga tushishiga yo'l qo'ymaydi.

Eslatma: Vec<T> turini implement qilish haqida ko'proq ma'lumot olish uchun "Rustonomikon" ga qarang.

Vectordagi qiymatlarni takrorlash

Vectordagi har bir elementga navbatma-navbat kirish uchun biz indekslarni birma-bir kirish uchun ishlatmasdan, barcha elementlarni takrorlaymiz. 8-7 ro'yxatda i32 qiymatlari vectoridagi har bir elementga o'zgarmas referencelarni olish va ularni chop etish uchun for siklidan qanday foydalanish ko'rsatilgan.

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{i}");
    }
}

Ro'yxat 8-7: for sikli yordamida elementlarni takrorlash orqali vectordagi har bir elementni chop etish

Shuningdek, biz barcha elementlarga o'zgartirish kiritish uchun o'zgaruvchan vectordagi har bir elementga o'zgaruvchan referencelarni takrorlashimiz mumkin. 8-8 ro'yxatdagi for sikli har bir elementga 50 qo'shadi.

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

Ro'yxat 8-8: Vectordagi elementlarga o'zgaruvchan referencelarni takrorlash

O'zgaruvchan reference nazarda tutilgan qiymatni o'zgartirish uchun biz += operatoridan foydalanishimizdan oldin i qiymatiga o'tish uchun * dereference operatoridan foydalanishimiz kerak. Biz 15-bobning "Dereference operatori bilan ko'rsatgichni qiymatga kuzatib borish" bo'limida dereference operatori haqida ko'proq gaplashamiz.

O'zgarmas yoki o'zgaruvchan bo'lsin, vector bo'yicha takrorlash, borrow tekshiruvi qoidalari tufayli xavfsizdir. Agar biz 8-7 va 8-8 ro'yxatlardagi for siklining tanasiga elementlarni qo'shishga yoki olib tashlashga harakat qilsak, biz 8-6 ro'yxatdagi kodga o'xshash kompilyator xatosiga duch kelamiz. for siklidagi vectorga murojaat qilish butun vectorni bir vaqtning o'zida o'zgartirishni oldini oladi.

Bir nechta turlarni saqlash uchun enumdan foydalanish

Vectorlar faqat bir xil turdagi qiymatlarni saqlashi mumkin. Bu noqulay bo'lishi mumkin; Har xil turdagi elementlar ro'yxatini saqlash zarurati uchun, albatta, foydalanish holatlari mavjud. Yaxshiyamki, enumlashning variantlari bir xil enum turi ostida aniqlanadi, shuning uchun bizga har xil turdagi elementlarni ko'rsatish uchun bitta tur kerak bo'lganda, enumni aniqlashimiz va ishlatishimiz mumkin!

Misol uchun, biz elektron jadvalning bir qator ustunlarida integer sonlar, ba'zi float raqamlar va ba'zi stringlar mavjud bo'lgan satrdan qiymatlarni olishni xohlaymiz. Variantlari turli qiymat turlariga ega bo'lgan enumni aniqlashimiz mumkin va barcha enum variantlari bir xil turdagi hisoblanadi: enum. Keyin biz ushbu enumni ushlab turish uchun vectorni yaratishimiz mumkin va natijada har xil turlarni ushlab turadi. Biz buni 8-9 ro'yxatda ko'rsatdik.

fn main() {
    enum ElektronJadval {
        Int(i32),
        Float(f64),
        Text(String),
    }

    let qator = vec![
        ElektronJadval::Int(3),
        ElektronJadval::Text(String::from("ko'k")),
        ElektronJadval::Float(10.12),
    ];
}

Ro'yxat 8-9: Har xil turdagi qiymatlarni bitta vectorda saqlash uchun enumni aniqlash

Rust kompilyatsiya vaqtida vectorda qanday turlar bo'lishini bilishi kerak, shuning uchun u har bir elementni saqlash uchun heapda qancha xotira kerakligini aniq biladi. Shuningdek, ushbu vectorda qanday turlarga ruxsat berilganligini aniq bilishimiz kerak. Agar Rust vectorga har qanday turni ushlab turishga ruxsat bergan bo'lsa, bir yoki bir nechta tur vector elementlari ustida bajarilgan operatsiyalarda xatoliklarni keltirib chiqarishi mumkin edi. Enum va match ifodasidan foydalanish Rust kompilyatsiya vaqtida 6-bobda muhokama qilinganidek, barcha mumkin bo'lgan holatlar ko'rib chiqilishini ta'minlaydi.

Agar siz vectorda saqlash uchun dastur runtimeda oladigan turlarning to'liq to'plamini bilmasangiz, enum texnikasi ishlamaydi. Buning o'rniga, biz 17-bobda ko'rib chiqiladigan trait obyektidan foydalanishingiz mumkin.

Endi biz vectorlardan foydalanishning eng keng tarqalgan usullarini ko'rib chiqdik, standart kutubxona tomonidan Vec<T> da belgilangan barcha foydali usullar uchun API texnik hujjatlarini ko'rib chiqishni unutmang. Masalan, push dan tashqari, pop usuli oxirgi elementni olib tashlaydi va qaytaradi.

Vectordan elementlarni olib tashlash

structlar singari, vector ham 8-10 ro'yxatda ko'rsatilganidek, amal qilish doirasidan tashqariga chiqqanda xotirasini bo'shatadi.

fn main() {
    {
        let v = vec![1, 2, 3, 4];

        // v bilan ish
    } // <- v doiradan chiqib ketadi va bu erda bo'shatiladi
}

Ro'yxat 8-10. Vector va uning elementlarini qanday o'chirishni ko'rsatadi

Vector o'chirilganda, uning barcha tarkibi ham o'chiriladi: vectorni o'chirish uning tarkibidagi qiymatlarni o'chirishni anglatadi. Borrow tekshiruvi vector mazmuniga har qanday referencelar faqat vectorning o'zi haqiqiy bo'lganda ishlatilishini ta'minlaydi.

Keling, keyingi to'plam turiga o'tamiz: String!

UTF-8 kodlangan matnni String bilan saqlash

Biz 4-bobda stringlar haqida gapirgan edik, ammo hozir ularni batafsil ko'rib chiqamiz. Yangi Rustaceanlar odatda uchta sababning kombinatsiyasiga ko'ra stringlarga yopishib qolishadi: Rustning mumkin bo'lgan xatolarni ochishga moyilligi, stringlar ko'plab dasturchilar tushunganidan ko'ra murakkabroq ma'lumotlar tuzilishi va UTF-8. Bu omillar shunday birlashadiki, agar siz boshqa dasturlash tillaridan kelgan bo'lsangiz, mavzu murakkab ko'rinishi mumkin.

To'plamlar kontekstida stringlarni muhokama qilish foydalidir, chunki stringlar baytlar to'plami sifatida amalga oshiriladi, shuningdek, bu baytlar matn sifatida talqin qilinganda foydali funksiyalarni ta'minlashning ba'zi usullari. Ushbu bo'limda biz String bo'yicha har bir to'plam turiga ega bo'lgan yaratish, yangilash va o'qish kabi operatsiyalar haqida gapiramiz. Shuningdek, biz String ning boshqa to'plamlardan qanday farq qilishini, ya'ni String ga indekslash odamlar va kompyuterlarning String ma'lumotlarini qanday talqin qilishlari o'rtasidagi farqlar tufayli qanday murakkablashishini muhokama qilamiz.

String nima?

Biz birinchi navbatda string atamasi bilan nimani nazarda tutayotganimizni aniqlaymiz. Rust asosiy tilda faqat bitta string turiga ega, bu str qator slice boʻlib, odatda uning &str shaklida koʻrinadi. 4-bobda biz boshqa joyda saqlangan ba'zi UTF-8 kodlangan string ma'lumotlariga referencelar bo'lgan string slicelar haqida gaplashdik. Masalan, satr literallari dasturning binary tizimida saqlanadi va shuning uchun satr slicedir.

Rust standart kutubxonasi tomonidan taqdim etilgan String turi asosiy tilga o'rnatilmagan va kengaytiriladigan, o'zgaruvchan, ega bo'lgan, UTF-8 kodlangan string turidir. Rustaceanlar Rust tilidagi "stringlar" ga murojaat qilganda, ular bu turlardan birini emas, balki String yoki string slice &str turlarini nazarda tutishi mumkin. Garchi bu bo'lim asosan String haqida bo'lsa-da, ikkala tur ham Rust standart kutubxonasida ko'p qo'llaniladi, String va string slicelari UTF-8 da kodlangan.

Yangi String yaratish

Vec<T> bilan mavjud bo'lgan bir xil amallarning ko'pchiligi String bilan ham mavjud, chunki String aslida qo'shimcha kafolatlar, cheklovlar va imkoniyatlarga ega baytlar vectori atrofida o'rash sifatida amalga oshiriladi. Vec<T> va String bilan bir xil ishlaydigan funksiyaga misol qilib, 8-11 ro'yxatda ko'rsatilgan yangi turdagi misolni yaratuvchi new funksiyadir.

fn main() {
    let mut s = String::new();
}

Ro'yxat 8-11: Yangi, bo'sh String yaratish

Ushbu satr s deb nomlangan yangi bo'sh qatorni yaratadi, biz keyin unga ma'lumotlarni yuklashimiz mumkin. Ko'pincha, biz stringni boshlamoqchi bo'lgan dastlabki ma'lumotlarga ega bo'lamiz. Buning uchun biz string literallari kabi Display traittini amalga oshiradigan har qanday turda mavjud bo'lgan to_string metotidan foydalanamiz. Ro'yxat 8-12 ikkita misolni ko'rsatadi.

fn main() {
    let malumot = "dastlabki tarkib";

    let s = malumot.to_string();

    // the method also works on a literal directly:
    let s = "dastlabki tarkib".to_string();
}

Ro'yxat 8-12: string literalidan String yaratish uchun to_string metodidan foydalanish

Bu kod dastlabki tarkibni o‘z ichiga olgan stringni yaratadi.

Satr literalidan String yaratish uchun String::from funksiyasidan ham foydalanishimiz mumkin. 8-13 ro'yxatdagi kod to_string funksiyasidan foydalanadigan 8-12 ro'yxatdagi kodga teng:

fn main() {
    let s = String::from("dastlabki tarkib");
}

Ro'yxat 8-13: string literalidan String yaratish uchun String::from funksiyasidan foydalanish

Stringlar juda ko'p narsalar uchun ishlatilganligi sababli, biz stringlar uchun juda ko'p turli xil umumiy API'lardan foydalanishimiz mumkin, bu bizga juda ko'p imkoniyatlarni taqdim etadi. Ulardan ba'zilari ortiqcha bo'lib tuyulishi mumkin, ammo ularning barchasi o'z joylariga ega! Bunday holda, String::from va to_string bir xil ishni bajaradi, shuning uchun tanlov sizga eng yoqqan uslubga bog'liq.

Yodda tutingki, stringlar UTF-8 bilan kodlangan, shuning uchun 8-14 ro'yxatda ko'rsatilganidek, biz ularga har qanday to'g'ri kodlangan ma'lumotlarni kiritishimiz mumkin.

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Salom");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

Ro'yxat 8-14: Salom so'zini turli tillarda stringlarda saqlash

Bularning barchasi yaroqli String qiymatlari.

Stringni yangilash

Agar siz unga ko'proq ma'lumot kiritsangiz, String hajmi kattalashishi mumkin va uning tarkibi Vec<T> tarkibidagi kabi o'zgarishi mumkin. Bundan tashqari, String qiymatlarini birlashtirish uchun + operatori yoki format! makrosidan qulay foydalanish mumkin.

push_str va push yordamida stringga biriktirish

Biz 8-15 roʻyxatda koʻrsatilganidek, string boʻlagini qoʻshish uchun push_str metodidan foydalanib Stringni kengaytirishimiz mumkin.

fn main() {
    let mut s = String::from("dastur");
    s.push_str("chi");
}

Roʻyxat 8-15: push_str metodi yordamida String ga satr boʻlagini qoʻshish

Ushbu ikki qatordan keyin s tarkibida dasturchi bo'ladi. push_str metodi string bo'lagini oladi, chunki biz parametrga egalik qilishni xohlamaymiz. Masalan, 8-16 roʻyxatdagi kodda biz uning mazmunini s1 ga qoʻshgandan soʻng s2 dan foydalanish imkoniyatiga ega boʻlishni xohlaymiz.

fn main() {
    let mut s1 = String::from("dastur");
    let s2 = "chi";
    s1.push_str(s2);
    println!("s2 - {s2}");
}

Ro'yxat 8-16: Tarkibni String ga qo'shgandan so'ng, string bo'lagidan foydalanish

Agar push_str metodi s2 ga egalik qilgan bo‘lsa, biz uning qiymatini oxirgi satrda chop eta olmaymiz. Biroq, bu kod biz kutgandek ishlaydi!

push metodi parametr sifatida bitta belgini oladi va uni String ga qo'shadi. 8-17 ro'yxatda push metodi yordamida String ga v harfi qo'shiladi.

fn main() {
    let mut s = String::from("su");
    s.push('v');
}

Roʻyxat 8-17: push yordamida String qiymatiga bitta belgi qoʻshish

Natijada, s tarkibida suv bo'ladi.

+ operatori yoki format! makrosidan foydalanib satrlarni birlashtirish

Ko'pincha siz ikkita mavjud satrni birlashtirishni xohlaysiz. Buning usullaridan biri 8-18 ro'yxatda ko'rsatilganidek, + operatoridan foydalanishdir.

fn main() {
    let s1 = String::from("Salom, ");
    let s2 = String::from("Rust!");
    let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used
}

Roʻyxat 8-18: Ikkita String qiymatini yangi String qiymatiga birlashtirish uchun + operatoridan foydalanish

s3 qatorida Salom, Rust! bo'ladi. Qo‘shishdan keyin s1 ning endi haqiqiy emasligi va s2ga referenceni qo‘llaganimiz sababi + operatoridan foydalanganda chaqirilayotgan metodning imzosi bilan bog‘liq. + operatori add metodidan foydalanadi, uning imzosi quyidagicha ko'rinadi:

fn add(self, s: &str) -> String {

Standart kutubxonada siz umumiy va tegishli turlar yordamida aniqlangan addni ko'rasiz. Bu erda biz aniq turlarni almashtirdik, bu metodni String qiymatlari bilan chaqirganimizda sodir bo'ladi. Biz 10-bobda generiklarni muhokama qilamiz. Ushbu imzo bizga + operatorining murakkab bitlarini tushunishimiz kerak bo'lgan maslahatlarni beradi.

Birinchidan, s2 & belgisiga ega, ya'ni biz birinchi satrga ikkinchi satrning referenceni qo'shmoqdamiz. Buning sababi add funksiyasidagi s parametri: biz faqat Stringga &str qo'shishimiz mumkin; biz ikkita String qiymatini qo'sha olmaymiz. Lekin kuting – &s2 turi add uchun ikkinchi parametrda ko‘rsatilganidek, &str emas, &Stringdir. Xo'sh, nima uchun 8-18 ro'yxatdagi kod kompilyatsiya bo'ladi?

add chaqiruvida &s2 dan foydalanishimiz sababi shundaki, kompilyator &String argumentini &str ga majburlashi(coerce) mumkin. Biz add metodini chaqirganimizda Rust deref coercion dan foydalanadi, bu erda &s2 ni &s2[..] ga aylantiradi. Biz 15-bobda coercion haqida batafsilroq gaplashamiz. add s parametriga egalik qilmaganligi sababli, s2 bu amaldan keyin ham haqiqiy String bo'lib qoladi.

Ikkinchidan, imzoda add self egalik qilishini ko'rishimiz mumkin, chunki selfda & yo'q. Bu shuni anglatadiki, 8-18-sonli ro'yxatdagi s1 add chaqiruviga o'tkaziladi va bundan keyin endi yaroqsiz bo'ladi. Shunday qilib, let s3 = s1 + &s2; har ikkala satrdan nusxa ko'chiradigan va yangisini yaratadiganga o'xshasa-da, bu statement aslida s1ga egalik qiladi va s2 mazmunining nusxasini qo'shadi, va keyin natijaga egalik huquqini qaytaradi. Boshqacha qilib aytganda, u juda ko'p nusxa ko'chirayotganga o'xshaydi, lekin unday emas; implement qilish nusxalashdan ko'ra samaraliroq.

Agar biz bir nechta satrlarni birlashtirishimiz kerak bo'lsa, + operatorining xatti-harakati noqulay bo'ladi:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

Bu vaqtda s tic-tac-toe bo'ladi. Barcha + va " belgilar bilan nima sodir bo'layotganini ko'rish qiyin. Murakkab qatorlarni birlashtirish uchun biz format! makrosidan foydalanishimiz mumkin:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

Ushbu kod s ni tic-tac-toe ga ham o'rnatadi. format! makrosi println! kabi ishlaydi, lekin natijani ekranga chop etish o'rniga mazmuni bilan Stringni qaytaradi. Kodning format! dan foydalanilgan versiyasini o‘qish ancha oson va format! makrosi tomonidan yaratilgan kod bu chaqiruv uning parametrlaridan birortasiga egalik qilmasligi uchun havolalardan foydalanadi.

Stringlarni indekslash

Ko'pgina boshqa dasturlash tillarida stringdagi alohida belgilarga indeks bo'yicha murojaat qilish orqali kirish to'g'ri va keng tarqalgan operatsiya hisoblanadi. Biroq, agar siz Rust-da indekslash sintaksisidan foydalanib, String qismlariga kirishga harakat qilsangiz, xatoga duch kelasiz. 8-19 ro'yxatdagi noto'g'ri kodni ko'rib chiqing.

fn main() {
    let s1 = String::from("salom");
    let h = s1[0];
}

Ro'yxat 8-19: String bilan indekslash sintaksisidan foydalanishga urinish

Ushbu kod quyidagi xatoga olib keladi:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `String` cannot be indexed by `{integer}`
 --> src/main.rs:3:13
  |
3 |     let h = s1[0];
  |             ^^^^^ `String` cannot be indexed by `{integer}`
  |
  = help: the trait `Index<{integer}>` is not implemented for `String`
  = help: the following other types implement trait `Index<Idx>`:
            <String as Index<RangeFrom<usize>>>
            <String as Index<RangeFull>>
            <String as Index<RangeInclusive<usize>>>
            <String as Index<RangeTo<usize>>>
            <String as Index<RangeToInclusive<usize>>>
            <String as Index<std::ops::Range<usize>>>

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` due to previous error

Xato va eslatma Rust indekslashni qo'llab-quvvatlamasligini aytadi. Lekin nega yo'q? Bu savolga javob berish uchun Rust stringlarni xotirada qanday saqlashini muhokama qilishimiz kerak.

Ichki vakillik

String turi - bu Vec<u8> turidagi wrapper. Keling, 8-14 ro'yxatdagi to'g'ri kodlangan UTF-8 misol stringlarini ko'rib chiqaylik. Birinchidan, bu:

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Salom");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

Bunday holda, len 4 bo'ladi, ya'ni "Hola" qatorini saqlaydigan vektor 4 bayt uzunlikda. Bu harflarning har biri UTF-8 da kodlanganda 1 baytni oladi. Biroq, keyingi qator sizni hayratda qoldirishi mumkin. (E'tibor bering, bu qator arabcha 3 raqami emas, kirill alifbosining bosh harfi Ze bilan boshlanadi.)

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Salom");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

String uzunligi so'ralganda, siz 12 deb aytishingiz mumkin. Aslida, Rustning javobi 24: bu UTF 8 da “Здравствуйте” ni kodlash uchun zarur bo'lgan baytlar soni, chunki bu satrdagi har bir Unicode skalyar qiymati 2 bayt xotirani oladi. Shuning uchun, satr baytlaridagi indeks har doim ham haqiqiy Unicode skalyar qiymatiga mos kelmaydi. Namoyish qilish uchun ushbu yaroqsiz Rust kodini ko'rib chiqing:

let salom = "Здравствуйте";
let javob = &salom[0];

Siz allaqachon bilasizki, javob birinchi harf bo'lgan З bo'lmaydi. UTF-8 da kodlanganda, З birinchi bayti 208, ikkinchisi esa 151, shuning uchun javob aslida 208 bo'lishi kerakdek tuyuladi, lekin 208 o'z-o'zidan haqiqiy belgi emas. Agar foydalanuvchi ushbu qatorning birinchi harfini so'ragan bo'lsa, 208 ni qaytarish, ehtimol bu emas; ammo, bu Rust bayt indeksi 0 bo'lgan yagona ma'lumotdir. Foydalanuvchilar odatda bayt qiymatini qaytarishni xohlamaydilar, hatto satrda faqat lotin harflari bo‘lsa ham: agar &“hello”[0] bayt qiymatini qaytaruvchi yaroqli kod bo‘lsa, u h emas, 104ni qaytaradi. .

Javob shundaki, kutilmagan qiymatni qaytarmaslik va darhol topilmasligi mumkin bo'lgan xatolarni keltirib chiqarmaslik uchun Rust ushbu kodni umuman kompilyatsiya qilmaydi va ishlab chiqish jarayonida tushunmovchiliklarning oldini oladi.

Baytlar va skalyar qiymatlar va grafema klasterlari!

UTF-8 bilan bog'liq yana bir nuqta shundaki, Rust nuqtai nazaridan satrlarga qarashning uchta mos usuli mavjud: baytlar, skalyar qiymatlar va grafema klasterlari (biz harflar deb ataydigan narsaga eng yaqin narsa).

Devanagari skriptida yozilgan hindcha “नमस्ते” so'ziga qarasak, u u8 qiymatlari vektori sifatida saqlanadi, bu quyidagicha ko'rinadi:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

Bu 18 bayt va kompyuterlar oxir-oqibat bu ma'lumotlarni qanday saqlaydi. Agar biz ularni Rustning char turiga ega bo'lgan Unicode skalyar qiymatlari sifatida qarasak, bu baytlar quyidagicha ko'rinadi:

['न', 'म', 'स', '्', 'त', 'े']

Bu yerda oltita char qiymati bor, lekin to'rtinchi va oltinchi harflar emas: ular o'z-o'zidan ma'noga ega bo'lmagan diakritikdir. Nihoyat, agar baytlarni grafema klasterlari sifatida ko'rib chiqsak, inson to'rt harfli hindcha so'z deb ataydigan narsani olamiz:

["न", "म", "स्", "ते"]

Rust kompyuterlar saqlaydigan ma'lumotlar qatorini talqin qilishning turli usullarini taqdim etadi, shunda ma'lumotlar qaysi inson tilida bo'lishidan qat'i nazar, har bir dastur kerakli talqinni tanlashi mumkin.

Rust bizga belgini olish uchun String ga indekslashga ruxsat bermasligining yakuniy sababi shundaki, indekslash operatsiyalari doimo konstanta(doimiy) vaqtni oladi (O(1)). Ammo String bilan ishlashni kafolatlab bo‘lmaydi, chunki Rust qancha to‘g‘ri belgilar mavjudligini aniqlash uchun tarkibni boshidan indeksgacha bosib o‘tishi kerak edi.

String bo'laklari

Satrni indekslash ko'pincha noto'g'ri fikrdir, chunki satrni indekslash operatsiyasining qaytish turi qanday bo'lishi kerakligi aniq emas: bayt qiymati, belgi, grafema klasteri yoki satr bo'lagi. Agar chindan ham string bo'laklarini yaratish uchun indekslardan foydalanish kerak bo'lsa, Rust sizdan aniqroq bo'lishingizni so'raydi.

Bitta raqam bilan [] yordamida indeksatsiya qilish o'rniga, muayyan baytlarni o'z ichiga olgan string bo'laklarini yaratish uchun diapazon bilan [] dan foydalanishingiz mumkin:

#![allow(unused)]
fn main() {
let salom = "Здравствуйте";

let s = &salom[0..4];
}

Bu erda s qatorning dastlabki 4 baytini o'z ichiga olgan &str bo'ladi. Avvalroq, biz ushbu belgilarning har biri 2 baytdan iborat bo'lganligini aytib o'tgan edik, ya'ni s Зд bo'ladi.

Agar biz &salom[0..1] kabi belgi baytlarining faqat bir qismini kesishga harakat qilsak, Rust ish runtimeda xuddi vektordagi yaroqsiz indeksga kirish kabi panic qo'yadi:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`
thread 'main' panicked at 'byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`', src/main.rs:4:14
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Ehtiyotkorlik bilan string bo'laklarni yaratish uchun diapazonlardan foydalanishingiz kerak, chunki bu dasturni buzishi mumkin.

Stringlarni takrorlash usullari

String bo'laklari bilan ishlashning eng yaxshi usuli - belgilar yoki baytlarni xohlaysizmi, aniq bo'lishdir. Unicode skalyar qiymatlari uchun chars metodidan foydalaning. “Зд” da charsni chaqirish char turidagi ikkita qiymatni ajratib turadi va qaytaradi va har bir elementga kirish uchun natijani takrorlashingiz mumkin:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

Ushbu kod quyidagilarni chop etadi:

З
д

Shu bilan bir qatorda, bytes metodi boshqa domenga mos kelishi mumkin bo'lgan har bir baytni qaytaradi:

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

Ushbu kod ushbu satrni tashkil etuvchi to'rt baytni chop etadi:

208
151
208
180

Lekin esda tutingki, joriy Unicode skalyar qiymatlari 1 baytdan ortiq bo'lishi mumkin.

Devanagari skriptidagi kabi satrlardan grafema klasterlarini olish juda murakkab, shuning uchun bu funksiya standart kutubxona tomonidan ta'minlanmagan. Agar sizga ushbu funksiya kerak bo'lsa, crates.io saytida cratelar mavjud.

Stringlar unchalik oddiy emas

Xulosa qilib aytganda, satrlar murakkab. Turli xil dasturlash tillari ushbu murakkablikni dasturchiga qanday taqdim etish bo'yicha turli xil tanlovlar qiladi. Rust String ma'lumotlarini to'g'ri ishlashni barcha Rust dasturlari uchun standart xatti-harakatga aylantirishni tanladi, bu esa dasturchilar UTF-8 ma'lumotlari bilan ishlash haqida oldindan ko'proq o'ylashlari kerakligini anglatadi. Ushbu o'zaro kelishuv boshqa dasturlash tillarida ko'rinadiganidan ko'ra ko'proq stringlarning murakkabligini ochib beradi, lekin keyinchalik ishlab chiqish jarayonida paydo bo'lishi mumkin bo'lgan ASCII bo'lmagan belgilar xatolarini qayta ishlash zaruratini oldini oladi.

Yaxshi xabar shundaki, standart kutubxona ushbu murakkab vaziyatlarni to'g'ri hal qilishga yordam beradigan String va &str turlaridan iborat ko'plab funksiyalarni taklif etadi. Satrda qidirish uchun contains va qator qismlarini boshqa satr bilan almashtirish uchun replace kabi foydali metodlar uchun texnik hujjatlarni ko'rib chiqing.

Keling, biroz murakkabroq narsaga o'taylik: HashMap!

Hash Maplarda bog'langan qiymatlarga ega kalitlarni saqlash

Umumiy to'plamlarimizning oxirgisi hash map. HashMap<K, V> turi K turidagi kalitlarning V turidagi qiymatlarga xaritasini xeshlash funksiyasi yordamida saqlaydi, bu kalit va qiymatlarni xotiraga qanday joylashtirishini belgilaydi. Ko'pgina dasturlash tillari bunday ma'lumotlar strukturasini qo'llab-quvvatlaydi, lekin ular ko'pincha bir nechtasini nomlash uchun hash, map, object, hash table, dictionary, yoki associative array kabi boshqa nomlardan foydalanadilar.

Hash maplar ma'lumotlarni vectorlar bilan bo'lgani kabi indeks yordamida emas, balki har qanday turdagi kalit yordamida qidirmoqchi bo'lsangiz foydali bo'ladi. Misol uchun, o'yinda siz har bir jamoaning balini hesh-mapda kuzatib borishingiz mumkin, unda har bir kalit jamoaning nomi va qiymatlar har bir jamoaning ballidir. Jamoa nomi berilgan bo'lsa, siz uning ballini olishingiz mumkin.

Ushbu bo'limda biz hesh-mapllarining asosiy API-ni ko'rib chiqamiz, ammo yana ko'plab foydali funksiyalar standart kutubxona tomonidan HashMap<K, V> da belgilangan funksiyalarda yashiringan. Har doimgidek, qo'shimcha ma'lumot olish uchun standart kutubxona texnik hujjatlarini tekshiring.

Yangi Hash Map yaratish

Bo'sh hesh mapni yaratishning bir usuli - new dan foydalanish va insert bilan elementlarni qo'shish. 8-20 ro'yxatda biz nomlari Yashil va Sariq bo'lgan ikkita jamoaning ballarini kuzatib boramiz. Yashil jamoa 10 ball bilan, Sariq jamoa esa 50 ball bilan boshlanadi.

fn main() {
    use std::collections::HashMap;

    let mut ballar = HashMap::new();

    ballar.insert(String::from("Yashil"), 10);
    ballar.insert(String::from("Sariq"), 50);
}

Ro'yxat 8-20: Yangi hesh mapni yaratish va ba'zi kalitlar va qiymatlarni kiritish

E'tibor bering, biz birinchi navbatda standart kutubxonaning to'plamlar qismidagi HashMap dan foydalanishimiz kerak. Bu quyidagicha bo'ladi use std::collections::HashMap;. Bizning uchta keng tarqalgan to'plamlarimiz orasida bu eng kam qo'llaniladi, shuning uchun u muqaddimada avtomatik ravishda kiritilgan funtsiyalarga kiritilmagan. Hash Maplar standart kutubxonadan ham kamroq qo'llab-quvvatlanadi; masalan, ularni yaratish uchun o'rnatilgan makros mavjud emas.

Vectorlar singari, hash maplar ham o'z ma'lumotlarini heapda saqlaydi. Ushbu HashMapda String turidagi kalitlar va i32 turidagi qiymatlar mavjud. Vectorlar singari, hash maplar ham bir xildir: barcha kalitlar bir-biri bilan bir xil turdagi va barcha qiymatlar bir xil turga ega bo'lishi kerak.

HashMap-dagi ma'lumotlarga kirish

Biz 8-21 ro'yxatda ko'rsatilganidek, get metodiga kalitni taqdim etish orqali hash mapdan qiymat olishimiz mumkin.

fn main() {
    use std::collections::HashMap;

    let mut ballar = HashMap::new();

    ballar.insert(String::from("Yashil"), 10);
    ballar.insert(String::from("Sariq"), 50);

    let jamoa_nomi = String::from("Yashil");
    let ball = ballar.get(&jamoa_nomi).copied().unwrap_or(0);
}

Ro'yxat 8-21: Hesh-Mapda saqlangan Yashil jamoa hisobiga kirish

Bu yerda ball Yashil jamoa bilan bog'liq qiymatga ega bo'ladi va natija 10 bo'ladi. get metodi Option<&V>ni qaytaradi; agar hesh-mapda ushbu kalit uchun qiymat bo'lmasa, get None ni qaytaradi. Bu dastur Option<&i32> emas, Option<i32> olish uchun copied ga murojaat qilib Optionni boshqaradi, so'ngra unwrap_or ballar da ushbu kalit uchun ma'lumotlar bo'lmasa, ballni nolga o'rnatish uchun.

Biz hesh-mapdagi har bir kalit/qiymat juftligini vectorlar bilan bo'lgani kabi, for siklidan foydalangan holda takrorlashimiz mumkin:

fn main() {
    use std::collections::HashMap;

    let mut ballar = HashMap::new();

    ballar.insert(String::from("Yashil"), 10);
    ballar.insert(String::from("Sariq"), 50);

    for (key, value) in &scores {
        println!("{key}: {value}");
    }
}

Ushbu kod har bir juftlikni tasodifiy tartibda chop etadi:

Sariq: 50
Yashil: 10

Hash Maplar va Ownership(Egalik)

Copy traitini amalga oshiradigan turlar uchun, masalan, i32, qiymatlar hesh-mapiga ko'chiriladi. String kabi tegishli qiymatlar uchun qiymatlar boshqa joyga koʻchiriladi va 8-22 roʻyxatda koʻrsatilganidek, hesh-map ushbu qiymatlarning egasi boʻladi.

fn main() {
    use std::collections::HashMap;

    let maydon_nomi = String::from("Sevimli rang");
    let maydon_qiymati = String::from("Yashil");

    let mut map = HashMap::new();
    map.insert(maydon_nomi, maydon_qiymati);
    // maydon_nomi va maydon_qiymati hozirda yaroqsiz, ulardan foydalanib ko'ring va qanday
    // kompilyator xatosiga yo'l qo'yganingizni ko'ring!
}

Ro'yxat 8-22: kalitlar va qiymatlar kiritilgandan so'ng ular hesh-mapda tegishli ekanligini ko'rsatish

maydon_nomi va maydon_qiymati o'zgaruvchilari qiymatlari insert metodini chaqirish orqali HashMap-ga ko'chirilgandan keyin foydalana olmaymiz.

Agar biz HashMap-ga qiymatlarga referencelar kiritsak, ular HashMap-ga ko'chirilmaydi. Murojaatlar ko'rsatadigan qiymatlar hech bo'lmaganda hesh-mapda amal qiladigan vaqt davomida amal qilishi kerak. Biz ushbu muammolar haqida 10-bobning "Lifetime bilan referencelarni tekshirish" bo'limida ko'proq gaplashamiz.

Hash Mapni yangilash

Kalit va qiymat juftlarining soni o'sishi mumkin bo'lsa-da, har bir noyob kalit bir vaqtning o'zida u bilan bog'langan faqat bitta qiymatga ega bo'lishi mumkin (lekin aksincha emas: masalan, Yashil jamoa ham, Sariq jamoa ham ballar hash-mapida saqlangan 10 qiymatiga ega bo'lishi mumkin).

Hash-mapdagi ma'lumotlarni o'zgartirmoqchi bo'lganingizda, kalit allaqachon tayinlangan qiymatga ega bo'lgan holatda qanday ishlashni hal qilishingiz kerak. Eski qiymatni butunlay e'tiborsiz qoldirib, eski qiymatni yangi qiymat bilan almashtirishingiz mumkin. Eski qiymatni saqlab qolishingiz va yangi qiymatni e'tiborsiz qoldirishingiz mumkin, faqat kalitda qiymat bo'lmasa, yangi qiymat qo'shishingiz mumkin. Yoki eski qiymat va yangi qiymatni birlashtira olasiz. Keling, bularning har birini qanday qilishni ko'rib chiqaylik!

Qiymatni qayta yozish

Agar biz kalit va qiymatni hash-mapga kiritsak va keyin boshqa qiymat bilan bir xil kalitni kiritsak, bu kalit bilan bog'langan qiymat almashtiriladi. Ro'yxat 8-23dagi kod ikki marta insert ni chaqirsa ham, hash-mapda faqat bitta kalit/qiymat juftligi bo'ladi, chunki biz har ikki marta Yashil jamoa kaliti qiymatini kiritamiz.

fn main() {
    use std::collections::HashMap;

    let mut ballar = HashMap::new();

    ballar.insert(String::from("Yashil"), 10);
    ballar.insert(String::from("Yashil"), 25);

    println!("{:?}", ballar);
}

Ro'yxat 8-23: Saqlangan qiymatni ma'lum bir kalit bilan almashtirish

Bu kod {"Yashil": 25}ni chop etadi. 10ning asl qiymati ustiga yozildi.

Kalit va qiymatni faqat kalit mavjud bo'lmaganda qo'shish

Hash Mapda ma'lum bir kalit allaqachon qiymatga ega yoki yo'qligini tekshirish odatiy holdir, keyin quyidagi amallarni bajaring: agar kalit hash-mapda mavjud bo'lsa, mavjud qiymat avvalgidek qolishi kerak. Agar kalit mavjud bo'lmasa, insert va uning qiymatini kiriting.

Hash Mapda buning uchun entry deb nomlangan maxsus API mavjud bo'lib, siz tekshirmoqchi bo'lgan kalitni parametr sifatida qabul qiladi. entry metodining qaytish qiymati Entry nomli enum bo‘lib, u mavjud yoki bo‘lmasligi mumkin bo‘lgan qiymatni ifodalaydi. Aytaylik, biz Sariq jamoa uchun kalitning u bilan bog'liq qiymati bor-yo'qligini tekshirmoqchimiz. Agar shunday bo'lmasa, biz 50 qiymatini qo'shishni xohlaymiz va Yashil jamoa uchun ham xuddi shunday. Entry API-dan foydalanib, kod Ro'yxat 8-24 kabi ko'rinadi.

fn main() {
    use std::collections::HashMap;

    let mut ballar = HashMap::new();
    ballar.insert(String::from("Yashil"), 10);

    ballar.entry(String::from("Sariq")).or_insert(50);
    ballar.entry(String::from("Yashil")).or_insert(50);

    println!("{:?}", ballar);
}

Ro'yxat 8-24: entry metodidan faqat kalitda qiymat mavjud bo'lmasa, kiritish uchun foydalanish

Entry da or_insert metodi mos keladigan Entry kaliti qiymatiga o'zgaruvchan referenceni qaytarish uchun belgilangan, agar bu kalit mavjud bo'lsa, parametrni ushbu kalit uchun yangi qiymat sifatida kiritadi va yangi qiymatga o'zgaruvchan referenceni qaytaradi. Ushbu metod mantiqni o'zingiz yozishdan ko'ra ancha toza va u xavfsizroq va borrowing qoidalariga mos keladi.

8-24-raqamdagi kodni ishga tushirish {"Sariq": 50, "Yashil": 10} chop etiladi. entry ga birinchi chaqiruv 50 qiymatiga ega Sariq jamoa uchun kalitni kiritadi, chunki sariq jamoada allaqachon qiymat yo'q. entry ga ikkinchi chaqiruv hash-mapni o'zgartirmaydi, chunki Yashil jamoa allaqachon 10 qiymatiga ega.

Eski qiymat asosida yangi qiymatni yangilash

Hash-Maplar uchun yana bir keng tarqalgan foydalanish holati kalit qiymatini izlash va keyin uni eski qiymat asosida yangilashdir. Misol uchun, 8-25 ro'yxatda har bir so'z ba'zi matnda necha marta takrorlanganini hisoblaydigan kodni ko'rsatadi. Biz kalit sifatida so'zlar bilan hash-mapdan foydalanamiz va bu so'zni necha marta ko'rganimizni kuzatib borish uchun qiymatni oshiramiz. Agar so'zni birinchi marta ko'rayotgan bo'lsak, avval 0 qiymatini kiritamiz.

fn main() {
    use std::collections::HashMap;

    let matn = "salom rust qiziqarli rust";

    let mut map = HashMap::new();

    for soz in matn.split_whitespace() {
        let hisoblash = map.entry(soz).or_insert(0);
        *hisoblash += 1;
    }

    println!("{:?}", map);
}

Ro'yxat 8-25: So'zlar va hisoblarni saqlaydigan hash-mapi yordamida so'zlarning necha marta takrorlanganini hisoblash

Bu kod {"qiziqarli": 1, "salom": 1, "rust": 2}ni chop etadi. Siz boshqa tartibda chop etilgan bir xil kalit/qiymat juftliklarini ko'rishingiz mumkin: “Hash-Mapdagi qiymatlarga kirish” bo'limidan hash-mapni takrorlash ixtiyoriy tartibda sodir bo'lishini eslang.

split_whitespace metodi matn qiymatining bo'sh joy bilan ajratilgan pastki bo'limlari ustidan iteratorni qaytaradi.or_insert metodi belgilangan kalit qiymatiga o'zgaruvchan havolani (&mut V) qaytaradi. Bu yerda biz o'zgaruvchan referenceni hisoblash o'zgaruvchisida saqlaymiz, shuning uchun bu qiymatni belgilash uchun avval yulduzcha (*) yordamida hisoblash ga murojaat qilishimiz kerak. O'zgaruvchan reference for siklining oxirida ko'lamdan chiqib ketadi, shuning uchun bu o'zgarishlarning barchasi xavfsiz va borrowing qoidalari bilan ruxsat etiladi.

Hashing funksiyalari

Odatda, HashMap SipHash nomli hashlash funksiyasidan foydalanadi, u ¹ hash-jadvallari ishtirokidagi Xizmatni rad etish (DoS) hujumlariga qarshilik ko'rsatishi mumkin. Bu mavjud bo'lgan eng tezkor hashlash algoritmi emas, lekin ishlashning pasayishi bilan birga keladigan yaxshi xavfsizlik uchun kelishuv bunga arziydi. Agar siz kodingizni profilga kiritsangiz va standart hash funksiyasi sizning maqsadlaringiz uchun juda sekin ekanligini aniqlasangiz, boshqa hasherni belgilash orqali boshqa funksiyaga o'tishingiz mumkin. hasher bu BuildHasher traitini amalga oshiradigan tur. Traitlar va ularni qanday implement qilish haqida 10-bobda gaplashamiz. Siz o'zingizning hasheringizni noldan implement qilishingiz shart emas; crates.io-da boshqa Rust foydalanuvchilari tomonidan baham ko'rilgan kutubxonalar mavjud bo'lib, ular ko'plab umumiy hashlash algoritmlarini implement qiladigan hasherlarni ta'minlaydi.

Xulosa

Vectorlar, stringlar va hash-maplar ma'lumotlarni saqlash, kirish va o'zgartirish kerak bo'lganda dasturlarda zarur bo'lgan katta hajmdagi funksionallikni ta'minlaydi. Mana endi hal qilish uchun tayyorlanishingiz kerak bo'lgan ba'zi mashqlar:

• Butun sonlar roʻyxati berilgan boʻlsa, vectordan foydalaning va roʻyxatning medianasini (tartiblanganda, oʻrtadagi qiymat) va rejimni (koʻpincha sodir boʻladigan qiymat; bu yerda hash-map foydali boʻladi) qaytaring.

• Satrlarni pig lotin tiliga aylantiring. Har bir so'zning birinchi undoshi so'z oxiriga ko'chiriladi va "ay" qo'shiladi, shuning uchun "birinchi" "birinchi-ay" bo'ladi. Unli tovush bilan boshlangan so‘zlarning oxiriga “hay” qo‘shiladi (“olma” “olma-hay”ga aylanadi). UTF-8 kodlash haqidagi tafsilotlarni yodda tuting!

• Hash Map va vectorlardan foydalanib, foydalanuvchiga kompaniyadagi bo'limga xodimlarning ismlarini qo'shishga ruxsat berish uchun matn interfeysini yarating. Masalan, "Asilbekni muhandislikka qo'shish" yoki "Sardorni savdoga qo'shish". Keyin foydalanuvchi bo'limdagi barcha odamlar yoki kompaniyadagi barcha odamlar ro'yxatini bo'limlar bo'yicha, alifbo tartibida tartiblangan holda olishiga ruxsat bering.

Standart kutubxona API texnik hujjatlari vectorlar, stringlar va hash-maplarda ushbu mashqlar uchun foydali bo'lgan usullarni tavsiflaydi!

Biz operatsiyalar muvaffaqiyatsiz bo'lishi mumkin bo'lgan yanada murakkab dasturlarga kirishmoqdamiz, shuning uchun xatolarni hal qilishni muhokama qilish uchun ajoyib vaqt. Qani kettik.

Xatolar bilan ishlash

Xatolar dasturiy ta'minotdagi hayot haqiqatidir, shuning uchun Rust nimadir noto'g'ri bo'lgan vaziyatlarni hal qilish uchun bir qator xususiyatlarga ega. Ko'p hollarda Rust sizdan xatolik ehtimolini tan olishingizni va kodingizni kompilyatsiya qilishdan oldin ba'zi choralarni ko'rishingizni talab qiladi. Ushbu talab sizning kodingizni ishlab chiqarishga joylashtirishdan oldin xatolarni aniqlashingiz va ularni to'g'ri hal qilishingizni ta'minlash orqali dasturingizni yanada mustahkam qiladi!

Rust xatolarni ikkita asosiy toifaga ajratadi: tiklash mumkin va tiklab bo‘lmaydigan xatolar. file not found (fayl topilmadi) xatosi kabi tiklanadigan xatolik uchun biz muammo haqida foydalanuvchiga xabar berishni va operatsiyani qaytadan urinib ko'rishni xohlaymiz. Qayta tiklanmaydigan xatolar har doim xato belgilaridir, masalan, array oxiridan tashqaridagi joyga kirishga urinish va shuning uchun biz dasturni darhol to'xtatmoqchimiz.

Aksariyat tillar bu ikki turdagi xatolarni farqlamaydi va istisnolar(exceptions) kabi mexanizmlardan foydalangan holda ikkalasini ham xuddi shunday hal qiladi. Rustda istisnolar yo'q. Buning o'rniga, u tiklanadigan xatolar uchun Result<T, E> turiga va dastur tuzatib bo'lmaydigan xatolikka duch kelganda jarayonni to'xtatuvchi panic! makrosiga ega. Bu bob avval panic! chaqirish haqida so'z boradi, soʻngra Result<T, E> qiymatlarini qaytarish haqida so'z boradi. Bundan tashqari, biz xatolikdan xalos bo'lish yoki bajarishni to'xtatish haqida qaror qabul qilishda fikrlarni o'rganamiz.

panic! bilan tuzatib bo'lmaydigan xatolar

Ba'zida sizning kodingizda yomon narsalar sodir bo'ladi va siz bu haqda hech narsa qila olmaysiz. Bunday hollarda Rustda panic! makrosi mavjud. Amalda panic chaqirishning ikki yo'li mavjud: kodimizni panic chiqaradigan harakatni amalga oshirish (masalan, arrayning oxiridan o'tib kirish) yoki aniq panic! makrosini chaqirish. Ikkala holatda ham biz dasturimizda panicni keltirib chiqaramiz. Odatiy bo'lib, bu panic muvaffaqiyatsizlik xabarini chop etadi, dasturni bajarish paytida ajratilgan resurslarni tozalaydi, stackni tozalaydi va ishdan chiqadi. Atrof-muhit o'zgaruvchisi orqali siz panic paydo bo'lganda panic manbasini kuzatishni osonlashtirish uchun Rust chaqiruvlar srackini ko'rsatishi ham mumkin.

panicga javoban stackni bo'shatish yoki bekor qilish

Odatiy bo'lib, panic paydo bo'lganda, dastur o'chiriladi, ya'ni Rust stekni zaxiraga olib chiqadi va duch kelgan har bir funksiyadan ma'lumotlarni tozalaydi. Biroq, bu orqaga qaytish va tozalash juda ko'p ishdir. Rust, shuning uchun dasturni tozalamasdan tugatadigan darhol bekor qilishning muqobilini tanlashga imkon beradi.

Dastur ishlatgan xotira keyinchalik operatsion tizim tomonidan tozalanishi kerak bo'ladi. Agar loyihangizda natijada olingan binary faylni iloji boricha kichikroq qilishingiz kerak bo'lsa, Cargo.toml faylingizdagi tegishli [profile] bo'limlariga panic = 'abort' qo'shish orqali panic bo'yicha bo'shatishdan bekor qilishga o'tishingiz mumkin. Misol uchun, agar siz bo'shatish rejimida panic holatini to'xtatmoqchi bo'lsangiz, quyidagilarni qo'shing:

[profile.release]
panic = 'abort'

Keling, oddiy dasturda panic! deb chaqirib ko'raylik:

Fayl nomi: src/main.rs

fn main() {
    panic!("halokatli xato");
}

Dasturni ishga tushirganingizda, siz shunga o'xshash narsani ko'rasiz:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished dev [unoptimized + debuginfo] target(s) in 0.25s
     Running `target/debug/panic`
thread 'main' panicked at 'halokatli xato', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

panic! chaqiruvi oxirgi ikki qatordagi xato xabarini keltirib chiqaradi. Birinchi qatorda panic haqidagi xabarimiz va manba kodimizdagi panic sodir bo'lgan joy ko'rsatilgan: src/main.rs:2:5 bu bizning src/main.rs faylimizning ikkinchi qatori, beshinchi belgisi ekanligini bildiradi.

Bunday holda, ko'rsatilgan qator bizning kodimizning bir qismidir va agar biz ushbu qatorga o'tsak, biz panic! makro chaqiruvini ko'ramiz. Boshqa hollarda, panic! chaqiruvi bizning kodimiz chaqiradigan kodda bo'lishi mumkin, va xato xabari tomonidan bildirilgan fayl nomi va satr raqami boshqa birovning kodi bo'ladi, bu yerda panic! makro chaqiriladi, kodimizning oxir-oqibat panic! chaqiruviga olib kelgan qatori emas. Kodimizning muammoga sabab bo'lgan qismini aniqlash uchun panic! chaqiruvidan kelgan funksiyalarning backtracedan foydalanishimiz mumkin. Keyinchalik orqaga qaytish(backtraces) haqida batafsilroq gaplashamiz.

panic! Backtracedan foydalanish

Yana bir misolni ko‘rib chiqaylik, panic! chaqiruvi to‘g‘ridan-to‘g‘ri makroni chaqiruvchi kodimizdan emas, balki kodimizdagi xato tufayli kutubxonadan kelganida qanday bo‘lishini ko‘raylik. 9-1 ro'yxatida joriy indekslar doirasidan tashqarida vectordagi indeksga kirishga harakat qiladigan ba'zi kodlar mavjud.

Fayl nomi: src/main.rs

fn main() {
    let v = vec![1, 2, 3];

    v[99];
}

Roʻyxat 9-1: Vector oxiridan tashqaridagi elementga kirishga urinish, bu esa panic! chaqiruviga sabab boʻladi.

Bu erda biz vectorimizning 100-elementiga kirishga harakat qilyapmiz (bu indeks 99-da, chunki indekslash noldan boshlanadi), lekin vectorda faqat 3 ta element mavjud. Bunday vaziyatda Rust panic qo'yadi. [] dan foydalanish elementni qaytarishi kerak, lekin siz noto'g'ri indeksni o'tkazyapsiz: Rust qaytara oladigan element yo'q.

C tilida ma'lumotlar strukturasining oxiridan tashqarida o'qishga urinish aniqlanmagan xatti-harakatlardir. Siz xotirada ma'lumotlar strukturasidagi ushbu elementga mos keladigan har qanday joyni olishingiz mumkin, garchi xotira ushbu tuzilishga tegishli bo'lmasa ham. Bu buffer overread deb ataladi va agar tajovuzkor indeksni ma'lumotlar tuzilmasidan keyin saqlanadigan ma'lumotlarni o'qishga ruxsat etilmasligi kerak bo'lgan tarzda o'zgartira olsa, xavfsizlik zaifliklariga olib kelishi mumkin.

Dasturingizni bunday zaiflikdan himoya qilish uchun, agar siz mavjud bo'lmagan indeksdagi elementni o'qishga harakat qilsangiz, Rust ishlashni to'xtatadi va davom etishni rad etadi. Keling, sinab ko'raylik va ko'ramiz:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished dev [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/panic`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Bu xatolik main.rs ning 4-qatoriga ishora qiladi, bu yerda biz 99 indeksiga kirishga harakat qilamiz. Keyingi eslatma satrida biz xatoga nima sabab bo'lganligining backtraceni olish uchun RUST_BACKTRACE muhit o'zgaruvchisini o'rnatishimiz mumkinligini aytadi. backtrace - bu dastur bajarilishining ma'lum bir nuqtasiga qadar chaqirilgan barcha funktsiyalar ro'yxatini. Backtrace boshqa tillarda bo'lgani kabi Rust tilida ham xuddi shunday ishlaydi. Shuning uchun, biz boshqa joylarda bo'lgani kabi, backtrace ma'lumotlarini o'qishni tavsiya qilamiz - siz yozgan fayllar haqidagi ma'lumotlarni ko'rmaguningizcha yuqoridan pastga o'qing. Bu muammo paydo bo'lgan joy. Yuqoridagi satrlar sizning kodingiz chaqirgan koddir; Quyidagi satrlar sizning kodingiz deb ataladigan koddir. Ushbu oldingi va keyingi qatorlar asosiy Rust kodini, standart kutubxona kodi yoki siz foydalanayotgan cratelarni o'z ichiga olishi mumkin. RUST_BACKTRACE muhit oʻzgaruvchisini 0 dan tashqari istalgan qiymatga oʻrnatish orqali backtraceni olishga harakat qilaylik. 9-2 ro'yxati siz ko'rgan narsaga o'xshash natijani ko'rsatadi.

$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
stack backtrace:
   0: rust_begin_unwind
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/std/src/panicking.rs:584:5
   1: core::panicking::panic_fmt
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:142:14
   2: core::panicking::panic_bounds_check
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:84:5
   3: <usize as core::slice::index::SliceIndex<[T]>>::index
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:242:10
   4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:18:9
   5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/alloc/src/vec/mod.rs:2591:9
   6: panic::main
             at ./src/main.rs:4:5
   7: core::ops::function::FnOnce::call_once
             at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/ops/function.rs:248:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

Roʻyxat 9-2: RUST_BACKTRACE muhit oʻzgaruvchisi oʻrnatilganda koʻrsatiladigan panic! chaqiruvi tomonidan yaratilgan backtrace

Bu juda ko'p natija! Siz ko'rgan aniq chiqish operatsion tizimingiz va Rust versiyasiga qarab farq qilishi mumkin. Ushbu ma'lumotlar bilan backtrace uchun debug symbollari yoqilgan bo'lishi kerak. Nosozliklarni tuzatish belgilari standart boʻyicha --release opsiyasiz cargo build yoki cargo run funksiyalaridan foydalanilganda yoqilgan.

9-2 ro'yxatdagi chiqishda backtracening 6-qatori muammoni keltirib chiqarayotgan loyihamizdagi chiziqqa ishora qiladi: src/main.rs ning 4-qatori. Agar dasturimiz panic bo'lishini istamasak, biz yozgan faylni eslatib o'tgan birinchi qatorda ko'rsatilgan joydan tekshirishni boshlashimiz kerak. 9-1 ro'yxatida biz panic qo'yadigan kodni ataylab yozganmiz. panicni tuzatish usuli vector indekslari doirasidan tashqarida elementni so'ramaslikdir. Kelajakda sizning kodingiz panic qo'zg'atganda, siz panic qo'zg'ash uchun kod qanday harakatlarni amalga oshirayotganini va buning o'rniga kod nima qilishi kerakligini aniqlashingiz kerak bo'ladi.

Biz panic! makrosi va qachon panic! qo'llashimiz kerak va qachon foydalanmaslik kerakligi haqidagi muhokamaga qaytamiz! Ushbu bobning keyingi qismida “panic! qo'yish yoki panic! qo'ymaslik” haqida gapalashamiz.

Keyinchalik, Result yordamida xatoni qanday tiklashni ko'rib chiqamiz.

Result bilan tiklanadigan xatolar

Ko'pgina xatolar dasturni butunlay to'xtatishni talab qiladigan darajada jiddiy emas. Ba'zan, funksiya bajarilmasa, bu siz osongina talqin qilishingiz va javob berishingiz mumkin bo'lgan sababdir. Misol uchun, agar siz faylni ochishga urinib ko'rsangiz va fayl mavjud bo'lmagani uchun bu operatsiya bajarilmasa, jarayonni tugatish o'rniga faylni yaratishni xohlashingiz mumkin.

2-bobdagi “Potentsial muvaffaqiyatsizlikni Result bilan hal qilish” bo'limini eslang: biz u yerda muvaffaqiyatsizliklarni hal qilish uchun ikkita variantga ega bo'lgan Ok va Err varianti bo'lgan Result enumidan foydalanganmiz. Enumning o'zi quyidagicha aniqlanadi:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

T va E umumiy turdagi parametrlardir: biz generiklarni 10-bobda batafsilroq muhokama qilamiz. Siz hozir bilishingiz kerak bo'lgan narsa shundaki, T Ok variantida muvaffaqiyatli holatda qaytariladigan qiymat turini bildiradi, va E Err(Xato) variantida xatolik holatida qaytariladigan xato turini ifodalaydi. Resultda ushbu umumiy turdagi parametrlar mavjud bo'lganligi sababli, biz qaytarmoqchi bo'lgan muvaffaqiyatli qiymat va xato qiymati har xil bo'lishi mumkin bo'lgan turli vaziyatlarda Result turidan va unda belgilangan funksiyalardan foydalanishimiz mumkin.

Keling, Result qiymatini qaytaruvchi funksiyani chaqiraylik, chunki funksiya bajarilmasligi mumkin. 9-3 ro'yxatda biz faylni ochishga harakat qilamiz.

Fayl nomi: src/main.rs

use std::fs::File;

fn main() {
    let fayl_ochish = File::open("olma.txt");
}

Ro'yxat 9-3: Faylni ochish

File::open return(qaytish) turi Result<T, E>dir. File::openni amalga oshirishdagi umumiy T turi muvaffaqiyatli qabul qilingan qiymat turiga, std::fs::Filega, ya'ni fayl deskriptoriga mos keladi. Xato qiymatida ishlatiladigan E turi std::io::Error. Qaytish(return) turi File::open ga chaqiruv muvaffaqiyatli bo'lishi va biz o'qishimiz yoki yozishimiz mumkin bo'lgan fayl handleni qaytarishi mumkinligini anglatadi. Funksiya chaqiruvi ham muvaffaqiyatsiz bo'lishi mumkin: masalan, fayl mavjud bo'lmasligi yoki faylga kirish uchun ruxsatimiz bo'lmasligi mumkin. File::open funksiyasi muvaffaqiyatli yoki muvaffaqiyatsiz bo'lganligini va bir vaqtning o'zida bizga fayl identifikatori yoki xato haqida ma'lumot beradigan metodga ega bo'lishi kerak. Ushbu ma'lumot aynan Result enumini bildiradi.

Agar File::open muvaffaqiyatli bo'lsa, fayl_ochish qiymati fayl identifikatorini o'z ichiga olgan Ok misoli bo'ladi. Muvaffaqiyatsiz bo'lgan taqdirda, fayl_ochish dagi qiymat Err misoli bo'lib, sodir bo'lgan xato turi haqida qo'shimcha ma'lumotni o'z ichiga oladi.

File::open qiymatiga qarab turli amallarni bajarish uchun 9-3-Ro'yxatdagi kodga o'zgartirishimiz kerak. 9-4 ro'yxatda biz 6-bobda muhokama qilgan asosiy tool - match ifodasi yordamida Result ni boshqarishning bir usuli ko'rsatilgan.

Fayl nomi: src/main.rs

use std::fs::File;

fn main() {
    let fayl_ochish = File::open("olma.txt");

    let fayl = match fayl_ochish {
        Ok(file) => file,
        Err(error) => panic!("Faylni ochishda muammo: {:?}", error),
    };
}

Roʻyxat 9-4: Qaytarilishi mumkin boʻlgan Result variantlarini boshqarish uchun match ifodasidan foydalanish

E'tibor bering, Option enumi kabi, Result enumi va uning variantlari avtomatik import (prelude) orqali kiritilgan, shuning uchun biz match qatoridagi Ok va Err variantlaridan oldin Result:: ni belgilashimiz shart emas.

Natija Ok bo'lsa, bu kod Ok variantidan ichki file qiymatini qaytaradi va biz ushbu faylni ishlov berish qiymatini fayl_ochish o'zgaruvchisiga tayinlaymiz. matchdan so'ng biz o'qish yoki yozish uchun fayl boshqaruvidan foydalanishimiz mumkin.

matchning boshqa qismi File::open dan Err qiymatini oladigan holatni boshqaradi. Ushbu misolda biz panic! makrosini tanladik. Agar joriy jildimizda olma.txt nomli fayl bo‘lmasa va biz ushbu kodni ishga tushirsak, biz panic! makrosidan quyidagi natijani ko‘ramiz:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
    Finished dev [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/error-handling`
thread 'main' panicked at 'Problem opening the file: Os { code: 2, kind: NotFound, message: "No such file or directory" }', src/main.rs:8:23
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Odatdagidek, bu chiqish bizga nima noto'g'ri ketganligini aniq aytadi.

Turli xil xatolarga moslashish

9-4 roʻyxatdagi kod nima uchun File::open muvaffaqiyatsiz boʻlishidan qatʼiy nazar panic! qoʻyadi. Biroq, biz turli sabablarga ko'ra turli xil harakatlarni amalga oshirishni xohlaymiz: agar fayl mavjud bo'lmagani uchun File::open muvaffaqiyatsiz bo'lsa, biz faylni yaratmoqchimiz va fayl boshqaruvini yangi faylga qaytaramiz. Agar File::open boshqa sabablarga ko'ra, masalan, faylni ochishga ruxsatimiz yo'qligi sababli muvaffaqiyatsiz bo'lsa, biz hali ham kodga 9-4 ro'yxatdagi kabi panic! qo'yishini xohlaymiz. Buning uchun biz 9-5 ro'yxatda ko'rsatilgan ichki match ifodasini qo'shamiz.

Fayl nomi: src/main.rs

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let fayl_ochish = File::open("olma.txt");

    let fayl = match fayl_ochish {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("olma.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Fayl yaratishda muammo: {:?}", e),
            },
            boshqa_xato => {
                panic!("Faylni ochishda muammo: {:?}", boshqa_xato);
            }
        },
    };
}

Ro'yxat 9-5: Har xil turdagi xatolarni turli yo'llar bilan hal qilish

File::open Err variantida qaytaradigan qiymat turi io::Error bo'lib, bu standart kutubxona tomonidan taqdim etilgan strukturadir. Ushbu strukturada io::ErrorKind qiymatini olish uchun chaqirishimiz mumkin bo'lgan kind metodi mavjud. io::ErrorKind enumi standart kutubxona tomonidan taqdim etilgan va io operatsiyasi natijasida yuzaga kelishi mumkin bo'lgan turli xil xatolarni ifodalovchi variantlarga ega. Biz foydalanmoqchi boʻlgan variant ErrorKind::NotFound boʻlib, biz ochmoqchi boʻlgan fayl hali mavjud emasligini bildiradi. Shunday qilib, biz fayl_ochish bo'yicha mos kelamiz, lekin bizda error.kind() da ichki match ham bor.

Biz ichki matchni tekshirmoqchi bo'lgan shart - error.kind() tomonidan qaytarilgan qiymat ErrorKind enumining NotFound variantidir. Agar shunday bo'lsa, biz faylni File::create yordamida yaratishga harakat qilamiz. Biroq, File::create ham muvaffaqiyatsiz bo'lishi mumkinligi sababli, bizga ichki match ifodasida ikkinchi arm kerak. Faylni yaratib bo'lmaganda, boshqa xato xabari chop etiladi. Tashqi match ning ikkinchi armi bir xil bo'lib qoladi, shuning uchun dastur yetishmayotgan fayl xatosidan tashqari har qanday xato haqida panic qo'yadi.

Result<T, E> bilan match dan foydalanishning muqobillari

Bu juda ko'p match! match ifodasi juda foydali, lekin ayni paytda juda primitivdir. 13-bobda siz Result<T, E> da belgilangan koʻplab metodlarda qoʻllaniladigan yopilishlar(closures) haqida bilib olasiz. Ushbu metodlar kodingizdagi Result<T, E> qiymatlari bilan ishlashda match dan foydalanishdan ko'ra qisqaroq bo'lishi mumkin.

Misol uchun, 9-5 ro'yxatda ko'rsatilgan mantiqni yozishning yana bir usuli, bu safar closures va unwrap_or_else metodi yordamida:

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let fayl_ochish = File::open("olma.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("olma.txt").unwrap_or_else(|error| {
                panic!("Fayl yaratishda muammo: {:?}", error);
            })
        } else {
            panic!("Faylni ochishda muammo: {:?}", error);
        }
    });
}

Garchi bu kod 9-5 roʻyxatdagi kabi harakatga ega boʻlsa-da, unda match iboralari mavjud emas va oʻqish uchun qulayroq. 13-bobni o‘qib bo‘lgach, ushbu misolga qayting va standart kutubxona hujjatlarida unwrap_or_else metodini qidiring. Ushbu metodlarning ko'pchiligi xatolar bilan shug'ullanayotganda katta o'rinli match iboralarni tozalashi mumkin.

Xatoda panic uchun yorliqlar: unwrap va expect

match dan foydalanish yetarlicha yaxshi ishlaydi, lekin u biroz batafsil bo'lishi mumkin va har doim ham maqsadni yaxshi bildirmaydi. Result<T, E> turida turli, aniqroq vazifalarni bajarish uchun belgilangan koʻplab yordamchi metodlar mavjud. unwrap metodi biz 9-4 ro'yxatda yozgan match iborasi kabi implemen qilinadigan yorliq metodidir. Agar Result qiymati Ok varianti bo'lsa, unwrap qiymati Ok ichidagi qiymatni qaytaradi. Agar Result Err varianti bo‘lsa, unwrap biz uchun panic! makrosini chaqiradi. Mana amaldagi unwrap misoli:

Fayl nomi: src/main.rs

use std::fs::File;

fn main() {
    let fayl_ochish = File::open("olma.txt").unwrap();
}

Agar biz ushbu kodni olma.txt faylisiz ishga tushiradigan bo‘lsak, biz panic! chaqiruvidan xato xabarini ko‘ramiz.

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Os {
code: 2, kind: NotFound, message: "No such file or directory" }',
src/main.rs:4:49

Xuddi shunday, expect metodi bizga panic! xato xabarini tanlash imkonini beradi. unwrap o'rniga expect dan foydalanish va yaxshi xato xabarlarini taqdim etish niyatingizni bildirishi va panic manbasini kuzatishni osonlashtirishi mumkin. expect sintaksisi quyidagicha ko'rinadi:

Fayl nomi: src/main.rs

use std::fs::File;

fn main() {
    let fayl_ochish = File::open("olma.txt")
        .expect("olma.txt ushbu loyihaga kiritilishi kerak");
}

Biz expect dan xuddi unwrap kabi foydalanamiz: fayl boshqaruvini qaytarish yoki panic! makrosini chaqirish uchun.panic! chaqiruvida expect tomonidan foydalanilgan xato xabari unwrap ishlatadigan standart panic! xabari emas, balki expect parametriga o‘tadigan parametr bo‘ladi. Bu qanday ko'rinishga ega:

thread 'main' panicked at 'olma.txt should be included in this project: Os {
code: 2, kind: NotFound, message: "No such file or directory" }',
src/main.rs:5:10

Ishlab chiqarish sifati kodida ko'pchilik Rustaceanlar unwrap o'rniga expect ni tanlaydilar va nima uchun operatsiya har doim muvaffaqiyatli bo'lishi kutilayotgani haqida ko'proq kontekst beradi. Shunday qilib, agar sizning taxminlaringiz noto'g'ri ekanligi isbotlangan bo'lsa, debuggingda foydalanish uchun ko'proq ma'lumotga ega bo'lasiz.

Xatoni yo'naltirish - Propagating

Funksiyani amalga oshirish muvaffaqiyatsiz bo'lishi mumkin bo'lgan narsani chaqirganda, xatoni funksiyaning o'zida hal qilish o'rniga, nima qilish kerakligini hal qilish uchun xatoni chaqiruvchi kodga qaytarishingiz mumkin. Bu xatoni propagating deb nomlanadi va chaqiruv kodini ko'proq nazorat qiladi, bu yerda kodingiz kontekstida mavjud bo'lgan narsadan ko'ra xatoni qanday hal qilish kerakligini ko'rsatadigan ko'proq ma'lumot yoki mantiq bo'lishi mumkin.

Misol uchun, 9-6 ro'yxati fayldan foydalanuvchi nomini o'qiydigan funksiyani ko'rsatadi. Agar fayl mavjud bo'lmasa yoki o'qib bo'lmasa, bu funksiya ushbu xatolarni funksiya chaqirgan kodga qaytaradi.

Fayl nomi: src/main.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn fayldan_foydalanuvchi_nomini_olish() -> Result<String, io::Error> {
    let foydalanuvchi_fayli_natijasi = File::open("olma.txt");

    let mut foydalanuvchi_fayli = match foydalanuvchi_fayli_natijasi {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut foydalanuvchi = String::new();

    match foydalanuvchi_fayli.read_to_string(&mut foydalanuvchi) {
        Ok(_) => Ok(foydalanuvchi),
        Err(e) => Err(e),
    }
}
}

Ro'yxat 9-6: match yordamida chaqiruv kodiga xatoliklarni qaytaruvchi funksiya

Bu funksiyani ancha qisqaroq tarzda yozish mumkin, lekin biz xatolarni qayta ishlashni o'rganish uchun uning ko'p qismini qo'lda qilishdan boshlaymiz; oxirida biz qisqaroq yo'lni ko'rsatamiz. Avval funksiyaning qaytish turini ko'rib chiqamiz: Result<String, io::Error>. Bu funksiya Result<T, E> turidagi qiymatni qaytarayotganini bildiradi, bunda parametr T aniq turdagi String bilan to'ldirilgan, va E umumiy turi aniq turdagi io::Error bilan to`ldirilgan.

Agar bu funksiya hech qanday muammosiz muvaffaqiyatli bajarilsa, ushbu funksiyani chaqiruvchi kod String ga ega boʻlgan Ok qiymatini oladi – bu funksiya fayldan o'qigan foydalanuvchi nomi. Agar bu funksiya biron bir muammoga duch kelsa, murojaat qiluvchi kod io::Error misolini o'z ichiga olgan Err qiymatini oladi, unda muammolar nima bo'lganligi haqida qo'shimcha ma'lumot mavjud. Biz ushbu funktsiyaning qaytish turi sifatida io::Error ni tanladik, chunki bu funksiyaning tanasida bajarilmay qolishi mumkin bo‘lgan ikkala operatsiyadan qaytarilgan xato qiymatining turi: File::open funksiyasi va read_to_string metodi.

Funksiyaning asosiy qismi File::open funksiyasini chaqirish orqali boshlanadi. Keyin biz Result qiymatini 9-4 ro'yxatdagi matchga o'xshash match bilan ishlaymiz. Agar File::open muvaffaqiyatli bajarilsa, file pattern o'zgaruvchisidagi fayl ishlovi foydalanuvchi_fayli o'zgaruvchan o'zgaruvchisidagi qiymatga aylanadi va funksiya davom etadi. Err holatida, panic! deb chaqirish o‘rniga, biz return kalit so‘zidan funksiyadan to‘liq chiqib ketish uchun foydalanamiz va xato qiymatini File::open dan, endi e pattern o‘zgaruvchisiga o‘tkazamiz, bu funksiya xato qiymati sifatida chaqiruvchi kodga qaytaradi.

Shunday qilib, agar bizda foydalanuvchi_fayli da fayl boshqaruvi mavjud bo'lsa, keyin funksiya foydalanuvchi o'zgaruvchisida yangi String yaratadi va fayl mazmunini foydalanuvchi ni o'qish uchun foydalanuvchi_fayli da fayl boshqaruvidagi read_to_string metodini chaqiradi. read_to_string metodi ham Resultni qaytaradi, chunki u File::open muvaffaqiyatli bo'lishi ham mumkin, muvaffaqiyatsiz bo'lishi ham mumkin. Demak, ushbu Result bilan ishlash uchun bizga yana bir match kerak bo'ladi: agar read_to_string muvaffaqiyatli bo'lsa, demak, bizning funksiyamiz muvaffaqiyatli bo'ldi va biz foydalanuvchi nomini hozirda Ok bilan o'ralgan foydalanuvchi faylidan qaytaramiz. Agar read_to_string bajarilmasa, biz xato qiymatini xuddi File::open qiymatini qayta ishlagan match da xato qiymatini qaytarganimizdek qaytaramiz. Biroq, biz return ni aniq aytishimiz shart emas, chunki bu funksiyadagi oxirgi ifoda.

Ushbu kodni chaqiruvchi kod foydalanuvchi nomini o'z ichiga olgan Ok qiymatini yoki io::Error ni o'z ichiga olgan Err qiymatini olishni boshqaradi. Ushbu qiymatlar bilan nima qilishni hal qilish chaqiruv kodiga bog'liq. Agar chaqiruv kodi Err qiymatini olsa, u panic! deb chaqirishi va dasturni buzishi mumkin, standart foydalanuvchi nomidan foydalaning yoki foydalanuvchi nomini fayldan boshqa joydan qidiring, masalan. Bizda chaqiruv kodi aslida nima qilmoqchi ekanligi haqida yetarli ma'lumot yo'q, shuning uchun biz barcha muvaffaqiyat yoki xato ma'lumotlarini to'g'ri ishlashi uchun xatolarni propagate qilamiz.

Xatolarni propagating qilish namunasi Rustda shu qadar keng tarqalganki, Rust buni osonlashtirish uchun savol belgisi operatori ? beradi.

Propagating xatolar uchun qisqa kod: ? operatori

9-7 ro'yxatda 9-6 ro'yxatdagi kabi funksiyaga ega bo'lgan foydalanuvchi_fayli ilovasi ko'rsatilgan, ammo bu dastur ? operatoridan foydalanadi.

Fayl nomi: src/main.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn fayldan_foydalanuvchi_nomini_olish() -> Result<String, io::Error> {
    let mut foydalanuvchi_fayli = File::open("olma.txt")?;
    let mut foydalanuvchi = String::new();
    foydalanuvchi_fayli.read_to_string(&mut foydalanuvchi)?;
    Ok(foydalanuvchi)
}
}

Ro'yxat 9-7: ? operatori yordamida chaqiruvchi kodga xatoliklarni qaytaruvchi funksiya

Result qiymatidan keyin qoʻyilgan ? 9-6 roʻyxatdagi Result qiymatlarini boshqarish uchun biz belgilagan match iboralari bilan deyarli bir xil ishlaydi. Agar Result qiymati Ok bo'lsa, Ok ichidagi qiymat ushbu ifodadan qaytariladi va dastur davom etadi. Agar qiymat Err bo'lsa, Err butun funktsiyadan qaytariladi, xuddi biz return kalit so'zidan foydalanganimizdek, xato qiymati chaqiruvchi kodga propagate qiladi.

9-6 roʻyxatdagi match ifodasi va ? operatori nima qilishi oʻrtasida farq bor: ? operatori chaqirilgan xato qiymatlari from funksiyasidan oʻtadi, qiymatlarni bir turdan ikkinchi turga aylantirish uchun foydalaniladigan standart kutubxonadagi From traitida aniqlanadi. ? operatori from funksiyasini chaqirganda, qabul qilingan xato turi joriy funksiyaning qaytish turida aniqlangan xato turiga aylanadi. Bu funksiya muvaffaqiyatsiz bo'lishi mumkin bo'lgan barcha usullarni ifodalash uchun bitta xato turini qaytarganda foydalidir, agar qismlar turli sabablarga ko'ra ishlamay qolsa ham.

Misol uchun, biz 9-7 ro'yxatdagi fayldan_foydalanuvchi_nomini_olish funksiyasini o'zgartirishimiz mumkin, bu biz aniqlagan OurError nomli maxsus xato turini qaytarishimiz mumkin. Agar io::Error dan OurError misolini yaratish uchun OurError uchun impl From<io::Error> for OurError ni ham aniqlasak, keyin fayldan_foydalanuvchi_nomini_olish asosiy qismidagi ? operatori chaqiruvlari fromga murojaat qiladi va funksiyaga boshqa kod qo'shmasdan xato turlarini o'zgartiradi. foydalanuvchi_fayli o'zgaruvchisiga qaytaradi.Agar xatolik yuzaga kelsa, ? operatori butun funksiyadan erta qaytadi va chaqiruvchi kodga istalgan Err qiymatini beradi. Xuddi shu narsa read_to_string chaqiruvi oxiridagi ? uchun ham amal qiladi.

? operatori ko'plab nosozliklarni bartaraf qiladi va bu funksiyani amalga oshirishni soddalashtiradi. 9-8 ro'yxatda ko'rsatilganidek, biz ushbu kodni ? dan keyin metod chaqiruvlar zanjiridan foydalansak, bu kodni yanada qisqartirishimiz mumkin.

Fayl nomi: src/main.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn fayldan_foydalanuvchi_nomini_olish() -> Result<String, io::Error> {
    let mut foydalanuvchi = String::new();

    File::open("olma.txt")?.read_to_string(&mut foydalanuvchi)?;

    Ok(foydalanuvchi)
}
}

Ro'yxat 9-8: ? operatoridan keyin zanjirlash(chaining) metodi chaqiruvlari

Biz foydalanuvchi da yangi String yaratishni funksiya boshiga o‘tkazdik; bu qism o'zgarmagan. foydalanuvchi_fayli oʻzgaruvchisini yaratish oʻrniga, File::open("olma.txt")? natijasiga toʻgʻridan-toʻgʻri read_to_string chaqiruvlarini bogʻladik. Bizda read_to_string chaqiruvi oxirida hali ham ? bor va biz xatoliklarni qaytarish oʻrniga File::open va read_to_string muvaffaqiyatli boʻlganda ham foydalanuvchini oʻz ichiga olgan OK qiymatini qaytaramiz. Funksionallik yana 9-6 va 9-7 ro'yxatdagi kabi; Bu uni yozishning boshqacha, ergonomik usuli.

9-9 ro'yxati fs::read_to_string yordamida buni yanada qisqartirish yo'lini ko'rsatadi.

Fayl nomi: src/main.rs

#![allow(unused)]
fn main() {
use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}
}

Roʻyxat 9-9: faylni ochish va keyin oʻqish oʻrniga fs::read_to_string dan foydalanish

Faylni stringda o'qish juda keng tarqalgan operatsiya, shuning uchun standart kutubxona faylni ochadigan, yangi String yaratadigan qulay fs::read_to_string funksiyasini ta'minlaydi fayl mazmunini o'qiydi, mazmunini o'sha String ga qo'yadi va uni qaytaradi. Albatta, fs::read_to_string dan foydalanish bizga xatolarni qanday hal qilishni tushuntirishga imkon bermaydi, shuning uchun biz birinchi navbatda uzoq yo'lni o'rgandik.

? Operatoridan qayerda foydalanish mumkin

? operatori faqat qaytarish turi ? ishlatiladigan qiymatga mos keladigan funksiyalarda ishlatilishi mumkin. Buning sababi, ? operatori biz 9-6 ro'yxatda belgilagan match ifodasi kabi funksiyadan tashqari qiymatni erta qaytarish uchun belgilangan. 9-6 roʻyxatda match Result qiymatidan foydalanilgan va erta qaytish armi Err(e) qiymatini qaytargan. Funksiyaning qaytish turi Result bo'lishi kerak, shunda u ushbu return bilan mos keladi.

9-10 ro'yxatda, agar biz ? dan foydalanadigan qiymat turiga mos kelmaydigan qaytish turi bilan main funksiyada ? operatoridan foydalansak, qanday xatoga duch kelamiz:

Fayl nomi: src/main.rs

use std::fs::File;

fn main() {
    let fayl_ochish = File::open("olma.txt")?;
}

Roʻyxat 9-10: () qaytaradigan main funksiyadagi ? dan foydalanishga urinish kompilyatsiya qilinmaydi.

Ushbu kod faylni ochadi, bu muvaffaqiyatsiz bo'lishi mumkin. ? operatori File::open tomonidan qaytarilgan Result qiymatiga amal qiladi, lekin bu main funksiya Result emas, () qaytish turiga ega. Ushbu kodni kompilyatsiya qilganimizda, biz quyidagi xato xabarini olamiz:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> src/main.rs:4:48
  |
3 | fn main() {
  | --------- this function should return `Result` or `Option` to accept `?`
4 |     let fayl_ochish = File::open("olma.txt")?;
  |                                                ^ cannot use the `?` operator in a function that returns `()`
  |
  = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `error-handling` due to previous error

Bu xato bizga ? operatoridan faqat Result, Option yoki FromResidualni qo'llaydigan boshqa turdagi qaytaruvchi funksiyada foydalanishga ruxsat berilganligini ko`rsatadi.

Xatoni tuzatish uchun sizda ikkita variant bor. Tanlovlardan biri, funksiyangizning qaytish turini ? operatoridan foydalanayotgan qiymatga mos keladigan qilib o'zgartirish, agar bunga hech qanday cheklovlar bo'lmasa. Boshqa usul esa, Result<T, E> ni mos keladigan usulda boshqarish uchun match yoki Result<T, E> metodlaridan birini qo`llashdir.

Xato xabarida, shuningdek, ? ni Option<T> qiymatlari bilan ham foydalanish mumkinligi aytilgan. Resultda ? dan foydalanish kabi, siz ? dan faqat Option ni qaytaradigan funksiyada foydalanishingiz mumkin. ? operatorining Option<T> bo'yicha chaqirilgandagi xatti-harakati Result<T, E> da chaqirilgandagi xatti-harakatiga o'xshaydi: agar qiymat None bo'lsa None bo'ladi o'sha paytda funksiyadan erta qaytariladi. Agar qiymat Some bo'lsa, Some ichidagi qiymat ifodaning natijaviy qiymati bo`lib, funksiya davom etadi. 9-11 ro'yxatda berilgan matndagi birinchi qatorning oxirgi belgisini topadigan funksiya misoli mavjud:

fn birinchi_satrning_oxirgi_belgisi(matn: &str) -> Option<char> {
    matn.lines().next()?.chars().last()
}

fn main() {
    assert_eq!(
        birinchi_satrning_oxirgi_belgisi("Salom Do'stim\n Ahvollaring qanday?"),
        Some('m')
    );

    assert_eq!(birinchi_satrning_oxirgi_belgisi(""), None);
    assert_eq!(birinchi_satrning_oxirgi_belgisi("\nhi"), None);
}

Roʻyxat 9-11: Optionda ? operatoridan foydalanish` value

Bu funksiya Option<char>ni qaytaradi, chunki u yerda belgi(character) boʻlishi mumkin, lekin yoʻq boʻlishi ham mumkin. Bu kod matn string argumentini oladi va undagi lines metodini chaqiradi, bu esa satrdagi satrlar ustidan iteratorni qaytaradi. Ushbu funksiya birinchi qatorni tekshirmoqchi bo'lganligi sababli, iteratordan birinchi qiymatni olish uchun iteratorda next ni chaqiradi. Agar matn boʻsh qator boʻlsa, next ga murojat qilish Noneni qaytaradi, bu holda biz birinchi_satrning_oxirgi_belgisidan Noneni toʻxtatish va qaytarish uchun ? operatoridan foydalanamiz. Agar matn bo'sh qator bo'lmasa, next matndagi birinchi qatorning string sliceni o'z ichiga olgan Some qiymatini qaytaradi.

? operatori satr bo'lagini chiqaradi va biz uning belgilarining iteratorini olish uchun ushbu qator bo'limidagi charslarni chaqirishimiz mumkin. Bizni ushbu birinchi qatordagi oxirgi belgi qiziqtiradi, shuning uchun biz iteratordagi oxirgi elementni qaytarish uchun last deb chaqiramiz. Bu Optiondir, chunki birinchi qator boʻsh satr boʻlishi mumkin, masalan, matn boʻsh satr bilan boshlansa, lekin "\nhi"dagi kabi boshqa qatorlarda belgilar boʻlsa. Biroq, agar birinchi qatorda oxirgi belgi bo'lsa, u Some variantida qaytariladi. O'rtadagi ? operatori bu mantiqni ifodalashning ixcham usulini beradi, bu funksiyani bir qatorda amalga oshirish imkonini beradi. Agar biz Option da? operatoridan foydalana olmasak, biz bu mantiqni ko'proq metod chaqiruvlari yoki match ifodasi yordamida amalga oshirishimiz kerak edi.

Esda tutingki, ? operatoridan Result qaytaruvchi funksiyada Resultda foydalanishingiz mumkin, va ? operatoridan Option qaytaradigan funksiyada Optionda foydalanishingiz mumkin, lekin siz aralashtirib, moslashtira olmaysiz. ? operatori Resultni avtomatik ravishda Optionga yoki aksincha o'zgartirmaydi; Bunday hollarda konvertatsiyani aniq amalga oshirish uchun Resultdagi ok metodi yoki Optiondagi ok_or kabi metodlardan foydalanishingiz mumkin.

Hozirgacha biz ishlatgan barcha main funksiyalar () ni qaytaradi. main funksiya maxsus, chunki u bajariladigan dasturlarning kirish va chiqish nuqtasi bo'lib, dasturlar kutilgandek harakat qilishi uchun uning qaytish(return) turi qanday bo'lishi mumkinligiga cheklovlar mavjud.

Yaxshiyamki, main Result<(), E>ni ham qaytarishi mumkin. 9-12 ro'yxatda 9-10 ro'yxatdagi kod mavjud, biroq biz main ning qaytish turini Result<(), Box<dyn Error>> qilib o'zgartirdik va oxiriga Ok(()) qaytish qiymatini qo'shdik. Ushbu kod endi kompilyatsiya qilinadi:

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let fayl_ochish = File::open("olma.txt")?;

    Ok(())
}

Roʻyxat 9-12: mainni Result<(), E> qaytarishga oʻzgartirish Result qiymatlarida ? operatoridan foydalanish imkonini beradi.

Box<dyn Error> turi bu trait ob'ekti bo'lib, biz 17-bobning "Turli turdagi qiymatlarga ruxsat beruvchi trait ob'ektlaridan foydalanish" bo'limida gaplashamiz. Hozircha siz Box<dyn Error>ni “har qanday xato” degan ma'noni anglatadi deb o'ylashingiz mumkin. Box<dyn Error> xato turi bilan main funksiyadagi Result qiymatida ? dan foydalanishga ruxsat beriladi, chunki bu har qanday Err qiymatini erta qaytarish imkonini beradi. Garchi bu main funksiyaning tanasi faqat std::io::Error turidagi xatolarni qaytarsa ham, Box<dyn Error> ni belgilab, main funksiyaga boshqa xatolarni qaytaruvchi ko'proq kod qo'shilsa ham, bu kod to'g'ri bo'lib qoladi.

main funksiya Result<(), E>ni qaytarsa, bajariladigan fayl(executable file) 0 qiymati bilan chiqadi, agar main Ok(()) qaytarsa va main Err qiymatini qaytarsa nolga teng bo'lmagan qiymat bilan chiqadi. C tilida yozilgan bajariladigan fayllar(executable file) chiqqanda butun sonlarni qaytaradi: muvaffaqiyatli chiqqan dasturlar 0 butun sonini qaytaradi, xatoga yo'l qo'ygan dasturlar esa 0 dan boshqa butun sonni qaytaradi. Rust shuningdek, ushbu konventsiyaga mos kelishi uchun bajariladigan fayllardan butun(integer) sonlarni qaytaradi.

main funksiya std::process::Termination traitini amalga oshiradigan har qanday turlarni qaytarishi mumkin, bunda ExitCode qaytaruvchi report funksiyasi mavjud. O'zingizning turlaringiz uchun Termination traitini qo'llash bo'yicha qo'shimcha ma'lumot olish uchun standart kutubxona texnik hujjatlariga murojaat qiling.

Endi biz panic! chaqirish yoki Resultni qaytarish tafsilotlarini muhokama qilganimizdan so‘ng, keling, qaysi hollarda qaysi biri to‘g‘ri kelishini hal qilish mavzusiga qaytaylik.

panic! yoki panic! qo'ymaslik

Xo'sh, qachon panic! deb murojat qilish va qachon Resultni qaytarish kerakligini qanday hal qilasiz? Kodda panic paydo bo'lganda, uni tiklashning iloji yo'q. Qayta tiklashning mumkin bo'lgan yo'li bormi yoki yo'qmi, har qanday xatolik uchun panic! deb chaiqruv qilishingiz mumkin, lekin siz chaqiruv kodi nomidan vaziyatni tuzatib bo'lmaydi degan qarorga kelasiz. Result qiymatini qaytarishni tanlaganingizda, siz chaqiruv kodini tanlash imkoniyatini berasiz. Chaqiruv kodi vaziyatga mos keladigan tarzda tiklashga urinishi mumkin yoki Errdagi xatoni qayta tiklab bo'lmaydi, deb qaror qilishi va panic! qo'yishi mumkin, bu sizning tiklanadigan xatongizni tuzatib bo'lmaydiganga aylantiradi. Shuning uchun, muvaffaqiyatsiz bo'lishi mumkin bo'lgan funksiyani belgilashda Result ni qaytarish yaxshi standart tanlovdir.

Misollar, prototip kodi va testlar kabi holatlarda Resultni qaytarish o'rniga panic qo'yadigan kodni yozish maqsadga muvofiqdir. Keling, nima uchun ekanligini ko'rib chiqaylik, keyin kompilyator muvaffaqiyatsizlik mumkin emasligini ayta olmaydigan vaziyatlarni muhokama qilaylik, lekin siz inson sifatida buni qila olasiz. Bob kutubxona kodida panic qo'yish yoki yo'qligini hal qilish bo'yicha ba'zi umumiy ko'rsatmalar bilan yakunlanadi.

Misollar, Prototip Kodi va Testlar

Ba'zi bir kontseptsiyani tasvirlash uchun misol yozayotganingizda, shuningdek, xatolarni qayta ishlash kodini o'z ichiga olgan holda, misolni kamroq tushunarli qilish mumkin. Misollarda, panic qo'zg'atishi mumkin bo'lgan unwrap kabi metodga murojaat qilish sizning ilovangiz xatoliklarni qanday hal qilishini xohlayotganingiz uchun to'ldiruvchi sifatida tushuniladi, bu sizning kodingizning qolgan qismi nima qilayotganiga qarab farq qilishi mumkin.

Xuddi shunday, prototiplashda xatolarni qanday hal qilishni hal qilishdan oldin unwrap va expect metodllari juda qulaydir. Dasturingizni yanada mustahkamroq qilishga tayyor bo'lganingizda ular kodingizda aniq belgilar qoldiradilar.

Agar testda metod chaqiruvi muvaffaqiyatsiz bo'lsa, bu metod sinovdan o'tkazilayotgan funksiya bo'lmasa ham, butun test muvaffaqiyatsiz bo'lishini xohlaysiz. Chunki panic! – bu sinovning muvaffaqiyatsiz deb belgilanishi, unwrap yoki expect deb atalgan narsa aynan shunday bo'lishi kerak.

Siz kompilyatordan ko'ra ko'proq ma'lumotga ega bo'lgan holatlar

Agar sizda Result Ok qiymatiga ega bo'lishini ta'minlaydigan boshqa mantiqqa ega bo'lsangiz, unwrap yoki expect ni chaqirish ham o'rinli bo'lardi, ammo mantiq kompilyator tushunadigan narsa emas. Siz hali ham Result qiymatiga ega bo'lasiz, uni hal qilishingiz kerak: siz murojaat qilayotgan har qanday operatsiya sizning vaziyatingizda mantiqan imkonsiz bo'lsa ham, umuman muvaffaqiyatsiz bo'lish ehtimoli bor. Agar siz kodni qo‘lda tekshirish orqali sizda hech qachon Err varianti bo‘lmasligiga ishonch hosil qilsangiz, unwrap deb nomlash juda maqbuldir, va expect matnida hech qachon Err varianti bo'lmaydi deb o'ylagan sababni hujjatlash yaxshiroqdir. Mana bir misol:

fn main() {
    use std::net::IpAddr;

    let asosiy: IpAddr = "127.0.0.1"
        .parse()
        .expect("Qattiq kodlangan IP manzil haqiqiy bo'lishi kerak");
}

Qattiq kodlangan stringni tahlil qilish orqali IpAddr misolini yaratmoqdamiz. Biz 127.0.0.1 to‘g‘ri IP manzil ekanligini ko‘ramiz, shuning uchun bu yerda expect dan foydalanish mumkin. Biroq, qattiq kodlangan, yaroqli satrga ega bo'lish parse metodining qaytish turini o'zgartirmaydi: biz hali ham Result qiymatini olamiz va kompilyator bizni Result bilan ishlashga majbur qiladi, go‘yo Err varianti mumkin, chunki kompilyator bu satr har doim haqiqiy IP manzil ekanligini ko‘rish uchun yetarlicha aqlli emas. Agar IP-manzillar qatori dasturga qattiq kodlanganidan ko'ra foydalanuvchidan kelgan bo'lsa va shuning uchun muvaffaqiyatsizlikka uchragan bo'lsa, biz, albatta, Result ni yanada ishonchli tarzda boshqarishni xohlaymiz. Ushbu IP-manzil qattiq kodlangan degan taxminni eslatib o'tsak, agar kelajakda IP-manzilni boshqa manbadan olishimiz kerak bo'lsa, bizni expect ni xatolarni boshqarish kodini yaxshiroq o'zgartirishga undaydi.

Xatolarni bartaraf etish bo'yicha ko'rsatmalar

Agar kodingiz yomon holatda bo'lishi mumkin bo'lsa, kodingiz panic qo'yishi tavsiya etiladi. Shu nuqtai nazardan, yomon holat deganda baʼzi taxminlar(assumption), kafolatlar(guarantee), shartnomalar(contract,) yoki oʻzgarmasliklar buzilganda, masalan, notoʻgʻri qiymatlar, qarama-qarshi qiymatlar yoki yetishmayotgan qiymatlar kodingizga oʻtkazilganda, shuningdek quyidagilardan biri yoki bir nechtasi:

• Yomon holat - foydalanuvchi noto'g'ri formatda ma'lumotlarni kiritishi kabi vaqti-vaqti bilan sodir bo'lishi mumkin bo'lgan narsadan farqli o'laroq, kutilmagan narsa.
• Ushbu nuqtadan keyin sizning kodingiz har qadamda muammoni tekshirishdan ko'ra, bu yomon holatda bo'lmaslikka tayanishi kerak.
• Siz foydalanadigan turlarda ushbu ma'lumotni kodlashning yaxshi usuli yo'q. Biz 17-bobning "Turlar sifatida kodlash holatlari va behaviorlari" bo'limida nimani nazarda tutayotganimizni misol qilib ko'rib chiqamiz.

Agar kimdir sizning kodingizga chaqiruv qilsa va mantiqiy bo'lmagan qiymatlarni o'tkazsa, kutubxona foydalanuvchisi bu holatda nima qilishni xohlashini hal qilishi uchun xatolikni qaytarish yaxshidir. Biroq, davom etish xavfli yoki zararli bo'lishi mumkin bo'lgan hollarda, eng yaxshi tanlov panic! deb chaqiruv qilish va kutubxonangizdan foydalanuvchini kodidagi xatolik haqida ogohlantirish bo'lishi mumkin, shunda ular ishlab chiqish jarayonida uni tuzatishi mumkin. Xuddi shunday, panic!ko'pincha sizning nazoratingizdan tashqarida bo'lgan tashqi kodga chaqiruv qilsangiz va uni tuzatishning imkoni bo'lmagan yaroqsiz holatni qaytarsangiz mos keladi.

Biroq, muvaffaqiyatsizlik kutilganda, panic! chaqiruv qilishdan ko'ra, Resultni qaytarish maqsadga muvofiqdir. Misollar, tahlilchiga noto'g'ri tuzilgan ma'lumotlar yoki tarif chegarasiga yetganingizni bildiruvchi holatni qaytaruvchi HTTP so'rovini o'z ichiga oladi. Bunday hollarda, Result ni qaytarish, chaqiruv kodi qanday ishlov berishni hal qilishi kerak bo'lgan muvaffaqiyatsizlik kutilgan imkoniyat ekanligini ko'rsatadi.

Agar kodingiz noto'g'ri qiymatlar yordamida chaqirilgan bo'lsa, foydalanuvchini xavf ostiga qo'yishi mumkin bo'lgan operatsiyani bajarganda, kodingiz avval qiymatlarning haqiqiyligini tekshirishi va qiymatlar noto'g'ri bo'lsa panic qo'yishi kerak.Bu asosan xavfsizlik nuqtai nazaridan: noto'g'ri ma'lumotlar bilan ishlashga urinish kodingizni zaifliklarga olib kelishi mumkin. Agar siz chegaradan tashqari xotiraga kirishga harakat qilsangiz, standart kutubxona panic! deb chaqirishining asosiy sababi shu: joriy ma'lumotlar tuzilishiga tegishli bo'lmagan xotiraga kirishga urinish umumiy xavfsizlik muammosidir. Funksiyalarda ko'pincha shartnomalar(contracts) mavjud: agar kirish ma'lum talablarga javob bersa, ularning xatti-harakati kafolatlanadi. Shartnoma buzilganda panic qo'yish mantiqan to'g'ri keladi, chunki shartnoma buzilishi har doim chaqiruv qiluvchi tomonidagi xatolikni ko'rsatadi va bu siz chaqiruv kodini aniq ko'rib chiqishni xohlagan xatolik emas. Aslida, chaqiruv kodini tiklashning oqilona usuli yo'q; kodni chaqiruvchi dasturchilar kodni tuzatishi kerak. Funksiya uchun shartnomalar, ayniqsa buzilish panic keltirib chiqaradigan bo'lsa, funksiya uchun API texnik hujjatlarida tushuntirilishi kerak.

Biroq, barcha funksiyalaringizda ko'plab xatolarni tekshirish batafsil va zerikarli bo'ladi. Yaxshiyamki, siz Rustning turdagi tizimidan (va shunday qilib, kompilyator tomonidan amalga oshiriladigan turdagi tekshirish) siz uchun ko'plab tekshiruvlarni amalga oshiradi. Agar funksiyangiz parametr sifatida ma'lum bir turga ega bo'lsa, kompilyator sizda haqiqiy qiymatga ega ekanligiga ishonch hosil qilgan holda kodingiz mantig'ini davom ettirishingiz mumkin. Misol uchun, agar sizda Option emas, balki turingiz bo'lsa, dasturingiz nothing(hech narsa) emas, balki something(nimadir) bo'lishini kutadi. Sizning kodingiz Some va None variantlari uchun ikkita holatni ko'rib chiqishi shart emas: aniq qiymatga ega bo'lish uchun faqat bitta holat bo'ladi. Funksiyangizga hech narsa o'tkazmaslikka harakat qiladigan kodni kompilyatsiya qilinmaydi, shuning uchun funksiyangiz runtimeda bu holatni tekshirishi shart emas. Yana bir misol, parametr hech qachon manfiy bo'lmasligini ta'minlaydigan u32 kabi belgisiz butun son turidan foydalanishdir.

Tasdiqlash uchun maxsus turlarni yaratish

Keling, bir qadam oldin haqiqiy qiymatga ega ekanligimizga ishonch hosil qilish uchun Rust turi tizimidan foydalanish g'oyasini olaylik va tekshirish uchun maxsus turni yaratishni ko'rib chiqaylik. 2-bobdagi taxmin qilish o'yinini eslang, unda bizning kodimiz foydalanuvchidan 1 dan 100 gacha bo'lgan raqamni taxmin qilishni so'radi. Biz hech qachon foydalanuvchining taxmini o'sha raqamlar o'rtasida ekanligini tasdiqlaganimiz yo'q, uni bizning maxfiy raqamimizga nisbatan tekshirishdan oldin; biz faqat taxmin ijobiy ekanligini tasdiqladik. Bunday holda, natijalar unchalik dahshatli emas edi: bizning "Raqam katta!" yoki "Raqam Kichik!" chiqishimiz hali ham to'g'ri bo'lar edi. Lekin foydalanuvchini to'g'ri taxmin qilishga va foydalanuvchi diapazondan tashqaridagi raqamni taklif qilganda va foydalanuvchi, masalan, raqamlar o'rniga harflarni kiritganda, boshqacha xatti-harakatlarga ega bo'lishga undash yaxshi bo'lardi.

Buning usullaridan biri potentsial manfiy raqamlarga ruxsat berish uchun taxminni faqat u32 o‘rniga i32 sifatida tahlil qilish va keyin diapazondagi raqamni tekshirishni qo‘shishdir, masalan:

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Raqamni topish o'yini!");

    let yashirin_raqam = rand::thread_rng().gen_range(1..=100);

    loop {
        // --snip--

        println!("Iltimos, taxminingizni kiriting.");

        let mut taxmin = String::new();

        io::stdin()
            .read_line(&mut taxmin)
            .expect("Satrni o‘qib bo‘lmadi");

        let taxmin: i32 = match taxmin.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        if taxmin < 1 || taxmin > 100 {
            println!("Yashirin raqam 1 dan 100 gacha bo'ladi.");
            continue;
        }

        match taxmin.cmp(&yashirin_raqam) {
            // --snip--
            Ordering::Less => println!("Raqam Kichik!"),
            Ordering::Greater => println!("Raqam katta!"),
            Ordering::Equal => {
                println!("Siz yutdingiz!");
                break;
            }
        }
    }
}

If ifodasi bizning qiymatimiz diapazondan tashqarida yoki yo‘qligini tekshiradi, foydalanuvchiga muammo haqida xabar beradi va siklning keyingi iteratsiyasini boshlash uchun continue ni chaqiradi va yana bir taxminni so‘raydi. if ifodasidan keyin taxmin 1 dan 100 gacha ekanligini bilgan holda taxmin va maxfiy raqam o‘rtasidagi taqqoslashni davom ettirishimiz mumkin.

Biroq, bu ideal echim emas: agar dastur faqat 1 dan 100 gacha bo'lgan qiymatlarda ishlaganligi juda muhim bo'lsa va bu talab bilan ko'plab funksiyalarga ega bo'lsa, har bir funksiyada bunday tekshiruvga ega bo'lish zerikarli bo'ladi (va ishlashga ta'sir qilishi mumkin).

Buning o'rniga, biz yangi turni yaratishimiz va tekshirishlarni hamma joyda takrorlashdan ko'ra, turdagi namunani yaratish uchun funksiyaga qo'yishimiz mumkin. Shunday qilib, funksiyalar o'zlarining imzolarida yangi turdan foydalanishlari va ular olgan qiymatlardan ishonchli foydalanishlari xavfsiz bo'ladi. 9-13 roʻyxatda Taxmin turini aniqlashning bir usuli koʻrsatilgan, bu new funksiya 1 dan 100 gacha boʻlgan qiymatni qabul qilsagina Taxmin misolini yaratadi.

#![allow(unused)]
fn main() {
pub struct Taxmin {
    qiymat: i32,
}

impl Taxmin {
    pub fn new(qiymat: i32) -> Taxmin {
        if qiymat < 1 || qiymat > 100 {
            panic!("Taxmin qilingan qiymat 1 dan 100 gacha bo'lishi kerak, {} qabul qilnmaydi.", qiymat);
        }

        Taxmin { qiymat }
    }

    pub fn qiymat(&self) -> i32 {
        self.qiymat
    }
}
}

Roʻyxat 9-13: Taxmin turi, u faqat 1 dan 100 gacha qiymatlar bilan davom etadi

Birinchidan, biz i32 ga ega qiymat nomli maydonga ega Taxmin nomli structni aniqlaymiz. Bu yerda raqam saqlanadi.

Keyin biz Taxmin da new nomli bog'langan funktsiyani amalga oshiramiz, u Taxmin qiymatlari misollarini yaratadi. new funksiya i32 turidagi qiymat nomli bitta parametrga ega bo‘lishi va Taxminni qaytarishi uchun belgilangan. new funksiyaning asosiy qismidagi kod qiymatni 1 dan 100 gacha ekanligiga ishonch hosil qilish uchun tekshiradi. Agar qiymat bu sinovdan o‘tmasa, biz panic! chaqiruvini qilamiz, bu chaqiruv kodini yozayotgan dasturchini tuzatishi kerak bo‘lgan xatolik haqida ogohlantiradi, chunki bu diapazondan tashqarida qiymat bilan Taxmin yaratish Taxmin::new tayanadigan qoidani buzadi. Taxmin::new panic qo'zg'atishi mumkin bo'lgan shartlar uning API texnik hujjatlarida muhokama qilinishi kerak; biz 14-bobda yaratgan API texnik hujjatlarida panic! ehtimolini ko‘rsatuvchi hujjatlar konventsiyalarini qamrab olamiz. Agar qiymat testdan o'tgan bo'lsa, biz uning qiymat maydoni qiymat parametriga o'rnatilgan yangi Taxmin yaratamiz va Taxminni qaytaramiz.

Keyinchalik, biz self ni oladigan, boshqa parametrlarga ega bo'lmagan va i32 ni qaytaradigan qiymat nomli metodni qo'llaymiz. Bunday usul ba'zan getter(oluvchi) deb ataladi, chunki uning maqsadi o'z maydonlaridan ba'zi ma'lumotlarni olish va uni qaytarishdir. Ushbu umumiy metod zarur, chunki Taxmin strukturasining qiymat maydoni shaxsiydir(private). qiymat maydoni shaxsiy(private) bo'lishi juda muhim, shuning uchun Taxmin strukturasi yordamida kod to'g'ridan-to'g'ri qiymat ni o'rnatishga ruxsat berilmaydi: moduldan tashqaridagi kod Taxmin::new funksiyasidan Taxmin misolini yaratish uchun foydalanishi kerak, shunday qilib, Taxmin ning Taxmin::new funksiyasidagi shartlar bo‘yicha tekshirilmagan qiymatga ega bo‘lishining imkoni yo‘qligini ta’minlaydi.

Parametrga ega bo'lgan yoki faqat 1 dan 100 gacha bo'lgan raqamlarni qaytaradigan funksiya o'z imzosida i32 emas, Taxmin ni olishi yoki qaytarishi va uning tanasida qo'shimcha tekshiruvlar o'tkazishga hojat qolmasligini e'lon qilishi mumkin.

Xulosa

Rust-ning xatolarni boshqarish xususiyatlari sizga yanada mustahkam kod yozishga yordam berish uchun mo'ljallangan. panic! makrosi dasturingiz u bardosh bera olmaydigan holatda ekanligini bildiradi va noto‘g‘ri yoki noto‘g‘ri qiymatlar bilan davom etish o‘rniga jarayonni to‘xtatishni aytish imkonini beradi. Result enumi operatsiyalar muvaffaqiyatsiz bo'lishi va kodingiz tiklanishi mumkinligini bildirish uchun Rust turdagi tizimdan foydalanadi. Kodingizga chaqiruv qiladigan kod potentsial muvaffaqiyat yoki muvaffaqiyatsizlikni hal qilishi kerakligini aytish uchun Result dan foydalanishingiz mumkin. Tegishli vaziyatlarda panic! va Result dan foydalanish muqarrar muammolar oldida kodingizni yanada ishonchli qiladi.

Endi siz standart kutubxonada Option va Result enumlari bilan generiklardan foydalanishning foydali usullarini ko'rganingizdan so'ng, biz generiklar qanday ishlashi va ularni kodingizda qanday ishlatishingiz haqida gaplashamiz.

Generik turlar, Traitlar va Lifetimelar

Har bir dasturlash tilida kontseptsiyalarning takrorlanishini samarali boshqarish vositalari mavjud. Rustda bunday vositalardan biri generiklar: concrete turlari yoki boshqa xususiyatlar uchun mavhum stendlar. Kodni kompilyatsiya qilish va ishga tushirishda ularning o'rnida nima bo'lishini bilmasdan, biz generiklarning xatti-harakatlarini yoki ularning boshqa generiklar bilan qanday bog'liqligini ifodalashimiz mumkin.

Funktsiyalar i32 yoki String kabi aniq turdagi o'rniga ba'zi umumiy turdagi parametrlarni olishi mumkin, xuddi shu tarzda funksiya bir xil kodni bir nechta aniq qiymatlarda ishlatish uchun noma'lum qiymatlarga ega parametrlarni oladi. Aslida, biz 6-bobda Option<T>, 8-bobda Vec<T> va HashMap<K, V> va 9-bobda Result<T, E> bilan generiklardan allaqachon foydalanganmiz. Ushbu bobda siz o'zingizning turlaringizni, funksiyalaringizni va metodlaringizni generiklar bilan qanday aniqlashni o'rganasiz!

Birinchidan, kodning takrorlanishini kamaytirish uchun funksiyani qanday chiqarishni ko'rib chiqamiz. Keyin biz bir xil texnikadan faqat parametrlari turida farq qiladigan ikkita funksiyadan umumiy funksiyani yaratamiz. Shuningdek, biz struct va enum ta'riflarida generik turlardan qanday foydalanishni tushuntiramiz.

Keyin xulq-atvorni umumiy tarzda aniqlash uchun traitlar dan qanday foydalanishni o'rganasiz. Har qanday turdan farqli o'laroq, faqat ma'lum bir xatti-harakatga ega bo'lgan turlarni qabul qilish uchun umumiy turni cheklash uchun traitlarni umumiy turlar bilan birlashtira olasiz.

Va nihoyat, biz lifetimelar haqida gaplashamiz: kompilyatorga referencelar bir-biriga qanday bog'liqligi haqida ma'lumot beradigan turli xil generiklar. Lifetimelar kompilyatorga olingan qiymatlar haqida yetarli ma'lumot berishga imkon beradi, shunda u murojaatlar bizning yordamimizsiz ko'proq holatlarda haqiqiy bo'lishini ta'minlaydi.

Funksiyani ajratib olish orqali takrorlanishni olib tashlash

Generiklar bizga kodning takrorlanishini olib tashlash uchun bir nechta turlarni ifodalovchi maxsus turlarni to'ldiruvchi bilan almashtirishga imkon beradi. Generik sintaksisga kirishdan oldin, keling, birinchi navbatda, ma'lum qiymatlarni bir nechta qiymatlarni ifodalovchi to'ldiruvchi bilan almashtiradigan funksiyani chiqarib, generik turlarni o'z ichiga olmaydigan tarzda takrorlashni qanday olib tashlashni ko'rib chiqaylik. Keyin generik funksiyani chiqarish uchun xuddi shu texnikani qo'llaymiz! Funksiyaga chiqarishingiz mumkin bo'lgan takrorlangan kodni qanday tanib olishni ko'rib chiqsangiz, generiklardan foydalanishi mumkin bo'lgan takrorlangan kodni taniy boshlaysiz.

Biz ro'yxatdagi eng katta raqamni topadigan 10-1 ro'yxatidagi qisqa dasturdan boshlaymiz.

Fayl nomi: src/main.rs

fn main() {
    let raqamlar_listi = vec![34, 50, 25, 100, 65];

    let mut eng_katta = &raqamlar_listi[0];

    for raqam in &raqamlar_listi {
        if raqam > eng_katta {
            eng_katta = raqam;
        }
    }

    println!("Eng katta raqam {}", eng_katta);
    assert_eq!(*eng_katta, 100);
}

Ro'yxat 10-1: Raqamlar ro'yxatidagi eng katta raqamni topish

Biz butun sonlar roʻyxatini raqamlar_listi oʻzgaruvchisida saqlaymiz va roʻyxatdagi birinchi raqamga referenceni eng_katta nomli oʻzgaruvchiga joylashtiramiz. Keyin biz roʻyxatdagi barcha raqamlarni takrorlaymiz va agar joriy raqam eng_kattada saqlangan raqamdan katta boʻlsa, ushbu oʻzgaruvchidagi referenceni almashtiramiz. Biroq, agar joriy raqam hozirgacha ko'rilgan eng katta raqamdan kichik yoki unga teng bo'lsa, o'zgaruvchi o'zgarmaydi va kod ro'yxatdagi keyingi raqamga o'tadi. Ro'yxatdagi barcha raqamlarni ko'rib chiqqandan so'ng, eng_katta eng katta raqamga ishora qilishi kerak, bu holda bu 100 ga teng.

Bizga endi ikki xil raqamlar ro‘yxatidagi eng katta raqamni topish vazifasi qo‘yildi. Buning uchun biz 10-1 roʻyxatdagi kodni takrorlashni tanlashimiz va 10-2 roʻyxatda koʻrsatilganidek, dasturning ikki xil joyida bir xil mantiqdan foydalanishimiz mumkin.

Fayl nomi: src/main.rs

fn main() {
    let raqamlar_listi = vec![34, 50, 25, 100, 65];

    let mut eng_katta = &raqamlar_listi[0];

    for raqam in &raqamlar_listi {
        if raqam > eng_katta {
            eng_katta = raqam;
        }
    }

    println!("Eng katta raqam {}", eng_katta);

    let raqamlar_listi = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let mut eng_katta = &raqamlar_listi[0];

    for raqam in &raqamlar_listi {
        if raqam > eng_katta {
            eng_katta = raqam;
        }
    }

    println!("Eng katta raqam {}", eng_katta);
}

Ro'yxat 10-2: ikkita raqamlar roʻyxatidagi eng katta raqamni topish uchun kod

Ushbu kod ishlayotgan bo'lsa-da, kodni takrorlash zerikarli va xatolarga moyil. Shuningdek, biz kodni o'zgartirmoqchi bo'lganimizda uni bir nechta joyda yangilashni unutmasligimiz kerak.

Ushbu takrorlanishni bartaraf qilish uchun biz parametrda berilgan butun sonlar ro'yxatida ishlaydigan funktsiyani aniqlash orqali abstraksiya yaratamiz. Ushbu yechim bizning kodimizni aniqroq qiladi va bizga ro'yxatdagi eng katta raqamni topish tushunchasini mavhum tarzda ifodalash imkonini beradi.

10-3 ro'yxatda biz eng katta raqamni topadigan kodni eng_katta deb nomlangan funksiyaga chiqaramiz. Keyin biz 10-2 ro'yxatdagi ikkita ro'yxatdagi eng katta raqamni topish uchun funksiyani chaqiramiz. Bundan tashqari, biz kelajakda ega bo'lishi mumkin bo'lgan i32 qiymatlarining boshqa ro'yxatida ham funksiyadan foydalanishimiz mumkin.

Fayl nomi: src/main.rs

fn eng_katta(list: &[i32]) -> &i32 {
    let mut eng_katta = &list[0];

    for element in list {
        if element > eng_katta {
            eng_katta = element;
        }
    }

    eng_katta
}

fn main() {
    let raqamlar_listi = vec![34, 50, 25, 100, 65];

    let natija = eng_katta(&raqamlar_listi);
    println!("Eng katta raqam {}", natija);
    assert_eq!(*natija, 100);

    let raqamlar_listi = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let natija = eng_katta(&raqamlar_listi);
    println!("Eng katta raqam {}", natija);
    assert_eq!(*natija, 6000);
}

Ro'yxat 10-3: Ikkita roʻyxatdagi eng katta raqamni topish uchun abstrakt kod

eng_katta funksiya list deb nomlangan parametrga ega bo'lib, biz funktsiyaga o'tkazishimiz mumkin bo'lgan i32 qiymatlarining har qanday aniq qismini ifodalaydi. Natijada, biz funksiyani chaqirganimizda, kod biz kiritadigan maxsus qiymatlarda ishlaydi.

Xulosa qilib aytganda, biz kodni kodni 10-2-ro'yxadan 10-3-ro'yxaga oʻzgartirish uchun qilgan qadamlarimiz:

1. Ikki nusxadagi kodni aniqlang.
2. Ikki nusxadagi kodni funktsiya tanasiga chiqarib oling va ushbu kodning kirish va qaytish qiymatlarini funktsiya imzosida belgilang.
3. Buning o'rniga funktsiyani chaqirish uchun ikki nusxadagi kodning ikkita nusxasini yangilang.

Keyinchalik, kodning takrorlanishini kamaytirish uchun generiklar bilan bir xil qadamlardan foydalanamiz. Xuddi shu tarzda, funksiya tanasi ma'lum qiymatlar o'rniga mavhum list bo'yicha ishlay oladi, generiklar kodni mavhum turlarda ishlashga imkon beradi.

Misol uchun, bizda ikkita funksiya bor edi deylik: biri i32 qiymatlari bo‘limidagi eng katta elementni topadigan va ikkinchisi char qiymatlari bo‘limidagi eng katta elementni topadigan. Bu takroriylikni qanday yo'q qilamiz? Keling, bilib olaylik!

Generik ma'lumotlar turlari

Funksiya imzolari yoki structlar kabi elementlar uchun definitionlarni yaratish uchun biz generik(umumiy) ma'lumotlardan foydalanamiz, keyin ularni turli xil aniq ma'lumotlar turlari bilan ishlatishimiz mumkin. Keling, avval generiklar yordamida funksiyalar, structlar, enumlar va metodlarni qanday aniqlashni ko'rib chiqaylik. Keyin biz generiklar kod ishlashiga qanday ta'sir qilishini muhokama qilamiz.

Funksiya ta'riflarida

Generiklardan foydalanadigan funksiyani belgilashda biz generiklarni funksiya imzosiga joylashtiramiz, u yerda biz odatda parametrlarning ma'lumotlar turlarini va qiymatni qaytaramiz. Bu bizning kodimizni yanada moslashuvchan qiladi va kodning takrorlanishining oldini olish bilan birga funksiyamizni chaqiruvchilarga ko'proq funksionallik beradi.

eng_katta funksiyamizni davom ettirsak, 10-4 roʻyxatda ikkalasi ham boʻlakdagi eng katta qiymatni topadigan ikkita funksiya koʻrsatilgan. Keyin biz ularni generiklardan foydalanadigan yagona funksiyaga birlashtiramiz.

Fayl nomi: src/main.rs

fn eng_katta_i32(list: &[i32]) -> &i32 {
    let mut eng_katta = &list[0];

    for element in list {
        if element > eng_katta {
            eng_katta = element;
        }
    }

    eng_katta
}

fn eng_katta_char(list: &[char]) -> &char {
    let mut eng_katta = &list[0];

    for element in list {
        if element > eng_katta {
            eng_katta = element;
        }
    }

    eng_katta
}

fn main() {
    let raqamlar_listi = vec![34, 50, 25, 100, 65];

    let natija = eng_katta_i32(&raqamlar_listi);
    println!("Eng katta raqam {}", natija);
    assert_eq!(*natija, 100);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let natija = eng_katta_char(&char_list);
    println!("Eng katta belgi {}", natija);
    assert_eq!(*natija, 'y');
}

Roʻyxat 10-4: Ikki funksiya faqat nomlari va imzolaridagi turlari bilan farqlanadi

eng_katta_i32 funksiyasi biz 10-3 roʻyxatda ajratib olingan funksiya boʻlib, u boʻlakdagi eng katta i32ni topadi. eng_katta_char funksiyasi bo‘lakdagi eng katta charni topadi. Funksiya organlari bir xil kodga ega, shuning uchun bitta funksiyaga generik turdagi parametrni kiritish orqali takrorlanishni bartaraf qilaylik.

Yangi bitta funksiyada turlarni parametrlash uchun, biz funksiyaning qiymat parametrlari uchun qilganimiz kabi, tur parametrini nomlashimiz kerak. Tur parametri nomi sifatida istalgan identifikatordan foydalanishingiz mumkin. Lekin biz T dan foydalanamiz, chunki Rust-dagi parametr nomlari odatda qisqa, koʻpincha harfdan iborat boʻladi va Rustning tur nomlash konventsiyasi UpperCamelCase hisoblanadi. “type(tur)” so'zining qisqartmasi T, Rust dasturchilarining ko'pchiligining standart tanlovidir.

Funksiya tanasida parametrdan foydalanganda, biz imzoda parametr nomini e'lon qilishimiz kerak, shunda kompilyator bu nom nimani anglatishini biladi. Xuddi shunday, biz funktsiya imzosida tup parametri nomini ishlatganimizda, uni ishlatishdan oldin parametr nomini e'lon qilishimiz kerak. Generik eng_katta funksiyani aniqlash uchun burchakli qavslar ichida <> nomi deklaratsiyasini funksiya nomi va parametrlar ro'yxati orasiga qo'ying, masalan:

fn eng_katta<T>(list: &[T]) -> &T {

Biz bu taʼrifni shunday oʻqiymiz: eng_katta funksiyasi T turiga nisbatan umumiydir. Bu funksiya list nomli bitta parametrga ega, bu T turidagi qiymatlar bo'lagidir. eng_katta funksiya bir xil turdagi T qiymatiga referenceni qaytaradi.

10-5 ro'yxatda imzodagi umumiy ma'lumotlar turidan foydalangan holda birlashtirilgan eng_katta funksiya ta'rifi ko'rsatilgan. list shuningdek, funktsiyani i32 yoki char qiymatlari bilan qanday chaqirishimiz mumkinligini ko'rsatadi. E'tibor bering, bu kod hali kompilyatsiya qilinmaydi, ammo biz uni ushbu bobda keyinroq tuzatamiz.

Fayl nomi: src/main.rs

fn eng_katta<T>(list: &[T]) -> &T {
    let mut eng_katta = &list[0];

    for element in list {
        if element > eng_katta {
            eng_katta = element;
        }
    }

    eng_katta
}

fn main() {
    let raqamlar_listi = vec![34, 50, 25, 100, 65];

    let natija = eng_katta(&raqamlar_listi);
    println!("Eng katta raqam {}", natija);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let natija = eng_katta(&char_list);
    println!("Eng katta belgi {}", natija);
}

Ro'yxat 10-5: Generik turdagi parametrlardan foydalangan holda eng_katta funksiya; bu hali kompilyatsiya qilinmagan

Agar dasturni hozir kompilyatsiya qilsak, biz quyidagi xatolikni olamiz:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `&T`
 --> src/main.rs:5:17
  |
5 |         if element > eng_katta {
  |            ------- ^ ------- &T
  |            |
  |            &T
  |
help: consider restricting type parameter `T`
  |
1 | fn eng_katta<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
  |             +++++++++++++++++++++

For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` due to previous error

Yordam matnida std::cmp::PartialOrd qayd etilgan, bu trait va biz keyingi bo'limda traitlar haqida gaplashamiz. Hozircha shuni bilingki, bu xato eng_katta tanasi T bo'lishi mumkin bo'lgan barcha mumkin bo'lgan turlar uchun ishlamasligini bildiradi. Kod tanasidagi T turidagi qiymatlarni solishtirmoqchi bo'lganimiz uchun biz faqat qiymatlari ordere qilinadigan turlardan foydalanishimiz mumkin. Taqqoslashni yoqish uchun standart kutubxona std::cmp::PartialOrd traitiga ega bo'lib, uni turlarga tatbiq etishingiz mumkin (bu trait haqida batafsil ma'lumot uchun C ilovasiga qarang). Yordam matnining taklifiga amal qilib, biz T uchun amal qiladigan turlarni faqat PartialOrd-ni qo'llaydiganlar bilan cheklaymiz va bu misol kompilyatsiya qilinadi, chunki standart kutubxona PartialOrdni ham i32 va char da qo'llaydi.

Struktura Definitionlarida

Shuningdek, biz <> sintaksisi yordamida bir yoki bir nechta maydonlarda generik turdagi parametrlardan foydalanish uchun structlarni belgilashimiz mumkin. Ro'yxat 10-6 har qanday turdagi x va y koordinata qiymatlarini saqlash uchun Point<T> structni belgilaydi.

Fayl nomi: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

10-6 roʻyxat: T turidagi x va y qiymatlarini oʻz ichiga olgan Point<T> structi

Struktura ta'riflarida generiklardan foydalanish sintaksisi funksiya ta'riflarida qo'llaniladigan sintaksisiga juda oʻxshaydi. Birinchidan, burchakli qavslar ichida strukturaning nomidan keyin tur parametrining nomini e'lon qilamiz. Keyin biz aniq ma'lumotlar turlarini ko'rsatadigan struct ta'rifida generik turdan foydalanamiz.

Esda tutingki, biz Point<T>ni aniqlash uchun faqat bitta generik turdan foydalanganmiz, bu taʼrifda aytilishicha, Point<T> structi ba'zi bir T turiga nisbatan umumiy boʻlib, x va y maydonlari qaysi turdagi boʻlishidan qatʼi nazar bir xil turdagi dir. Agar biz 10-7 ro'yxatdagi kabi har xil turdagi qiymatlarga ega bo'lgan Point<T> nusxasini yaratsak, bizning kodimiz kompilyatsiya qilinmaydi.

Fayl nomi: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let ishlamaydi = Point { x: 5, y: 4.0 };
}

Roʻyxat 10-7: x va y maydonlari bir xil turdagi boʻlishi kerak, chunki ikkalasi ham bir xil umumiy maʼlumotlar turi Tga ega.

Ushbu misolda, biz x ga 5 butun qiymatini belgilaganimizda, kompilyatorga T generik turi Point<T> misoli uchun butun son bo'lishini bildiramiz. Keyin biz x bilan bir xil turga ega ekanligini aniqlagan y uchun 4.0 ni belgilaganimizda, biz quyidagi turdagi nomuvofiqlik xatosini olamiz:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
 --> src/main.rs:7:38
  |
7 |     let ishlamaydi = Point { x: 5, y: 4.0 };
  |                                       ^^^ expected integer, found floating-point number

For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` due to previous error

x va y ikkalasi ham generik bo'lgan, lekin har xil turlarga ega bo'lishi mumkin bo'lgan Point strukturasini aniqlash uchun biz bir nechta generik turdagi parametrlardan foydalanishimiz mumkin. Masalan, 10-8 roʻyxatda biz Point taʼrifini T va U turlari boʻyicha umumiy qilib oʻzgartiramiz, bunda x T turiga, y esa U turiga tegishli.

Fayl nomi: src/main.rs

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let ikkita_integer = Point { x: 5, y: 10 };
    let ikkita_float = Point { x: 1.0, y: 4.0 };
    let integer_va_float = Point { x: 5, y: 4.0 };
}

Roʻyxat 10-8: x va y har xil turdagi qiymatlar boʻlishi uchun ikki turdagi umumiy Point<T, U>.

Endi ko'rsatilgan Point ning barcha misollariga ruxsat berilgan! Ta'rifda siz xohlagancha turdagi parametrlardan generik foydalanishingiz mumkin, lekin bir nechtadan ko'proq foydalanish kodingizni o'qishni qiyinlashtiradi. Agar siz kodingizda ko'plab generik turlar kerakligini aniqlasangiz, bu sizning kodingizni kichikroq qismlarga qayta qurish kerakligini ko'rsatishi mumkin.

Enum Definitionlarida

Structlar bilan qilganimizdek, ularning variantlarida generik ma'lumotlar turlarini saqlash uchun enumlarni belgilashimiz mumkin. Biz 6-bobda foydalanilgan standart kutubxona taqdim etadigan Option<T> enumini yana bir ko'rib chiqamiz:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

Bu ta'rif endi siz uchun yanada ma'noli bo'lishi kerak. Ko'rib turganingizdek, Option<T> enum T turiga nisbatan generik va ikkita variantga ega: T turidagi bitta qiymatga ega Some va hech qanday qiymatga ega bo'lmagan None varianti. Option<T> enum yordamida biz ixtiyoriy qiymatning mavhum kontseptsiyasini ifodalashimiz mumkin va Option<T> umumiy bo'lgani uchun biz ixtiyoriy qiymatning turi qanday bo'lishidan qat`i nazar, bu abstraktsiyadan foydalanishimiz mumkin.

Enumlar bir nechta generik turlardan ham foydalanishi mumkin. Biz 9-bobda aytib o'tgan Result enumining ta'rifi ushbu foydalanishga misoldir:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

Result enumlari ikki xil, T va E uchun generikdir va ikkita variantga ega: T turidagi qiymatga ega OK va E turidagi qiymatga ega bo'lgan Err. Bu taʼrif Result enumidan bizda muvaffaqiyatli boʻlishi mumkin boʻlgan (T turidagi qiymatni qaytarish) yoki muvaffaqiyatsiz boʻlishi mumkin boʻlgan (E turidagi xatolikni qaytarish) istalgan joyda foydalanishni qulay qiladi. Aslida, biz 9-3 ro'yxatdagi faylni shunday ochar edik, bu yerda fayl muvaffaqiyatli ochilganda T std::fs::File turi bilan to'ldirilgan va faylni ochishda muammolar yuzaga kelganda E std::io::Error turi bilan to`ldirilgan.

Kodingizdagi vaziyatlarni faqat ular ega bo'lgan qiymatlar turlarida farq qiluvchi bir nechta struct yoki enum ta'riflari bilan tanib olganingizda, uning o'rniga generik turlardan foydalanish orqali takrorlanishdan qochishingiz mumkin.

Metod Definitionlarida

Biz structlar va enumlar bo'yicha metodlarni qo'llashimiz mumkin (5-bobda qilganimiz kabi) va ularning ta'riflarida generik turlardan ham foydalanishimiz mumkin. 10-9 ro'yxatda biz 10-6 ro'yxatda belgilagan Point<T> structi ko'rsatilgan va unda x nomli metod qo'llaniladi.

Fayl nomi: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Roʻyxat 10-9: Point<T> structida x nomli metodni qo'llash, bu T turidagi x maydoniga referenceni qaytaradi

Bu yerda biz Point<T> da x nomli metodni belgilab oldik, u x maydonidagi ma`lumotlarga referenceni qaytaradi.

Esda tutingki, biz impl dan keyin T ni e'lon qilishimiz kerak, shuning uchun biz Point<T> turidagi metodlarni amalga oshirayotganimizni aniqlash uchun T dan foydalanishimiz mumkin. T ni impl dan keyin generik tur sifatida e'lon qilish orqali Rust Point dagi burchak qavslaridagi tur aniq tur emas, balki generik tur ekanligini aniqlay oladi. Biz ushbu umumiy parametr uchun struct taʼrifida eʼlon qilingan generik parametrdan boshqa nom tanlashimiz mumkin edi, lekin bir xil nomdan foydalanish odatiy hisoblanadi. Generik turni e'lon qiladigan impl ichida yozilgan metodlar, generik turdagi o'rnini bosadigan aniq turdagi qanday bo'lishidan qat'i nazar, har qanday turdagi namunada aniqlanadi.

Tur bo'yicha metodlarni belgilashda generik turlarga cheklovlarni ham belgilashimiz mumkin. Biz, masalan, har qanday generik turdagi Point<T> misollarida emas, balki faqat Point<f32> misollarida metodlarni amalga oshirishimiz mumkin. 10-10 ro'yxatda biz f32 aniq turidan foydalanamiz, ya'ni impl dan keyin hech qanday turni e'lon qilmaymiz.

Fayl nomi: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

impl Point<f32> {
    fn kelib_chiqishidan_masofa(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Roʻyxat 10-10: impl bloki, faqat T generik tur parametri uchun ma`lum bir aniq turdagi strukturaga tegishli.

Bu kod Point<f32> turi kelib_chiqishidan_masofa metodiga ega bo'lishini bildiradi; T f32 turiga tegishli bo'lmagan Point<T> ning boshqa misollarida bu metod aniqlanmaydi. Metod bizning pointimizning koordinatadagi nuqtadan qanchalik uzoqligini o'lchaydi (0,0, 0,0) va faqat floating point turlari uchun mavjud bo'lgan matematik operatsiyalardan foydalanadi.

Struct taʼrifidagi generik turdagi parametrlar har doim ham oʻsha structning metod imzolarida foydalanadigan parametrlar bilan bir xil boʻlavermaydi. 10-11 roʻyxatda misolni aniqroq qilish uchun Point structsi uchun X1 va Y1 va aralashtirish metodi imzosi uchun X2 Y2 generik turlari qoʻllaniladi. Metod yangi Point misolini yaratadi self Point (X1 turidagi) x qiymati va o'tkazilgan Point (Y2 turidagi) y qiymati.

Fayl nomi: src/main.rs

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn aralashtirish<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Salom", y: 'c' };

    let p3 = p1.aralashtirish(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

Ro'yxat 10-11: O'zining strukturasi ta'rifidan farqli generik turlardan foydalanadigan metod

mainda biz x uchun i32 (5 qiymati bilan) va y uchun f64 (10,4 qiymati bilan) bo'lgan Point ni aniqladik. p2 o'zgaruvchisi bu Point structi bo'lib, x (Salom qiymati bilan) va y (c qiymati bilan) uchun char bo'lagiga ega. p1 da aralashtirishni p2 argumenti bilan chaqirish bizga p3ni beradi, bunda x uchun i32 bo‘ladi, chunki x p1 dan kelgan. p3 o‘zgaruvchisi y uchun charga ega bo‘ladi, chunki y p2 dan kelgan. println! makro chaqiruvi p3.x = 5, p3.y = c ni chop etadi.

Ushbu misolning maqsadi ba'zi generik parametrlar impl bilan e'lon qilingan va ba'zilari metod ta'rifi bilan e'lon qilingan vaziyatni ko'rsatishdir. Bu erda X1 va Y1 generik parametrlari impl dan keyin e'lon qilinadi, chunki ular struct ta'rifiga mos keladi. X2 va Y2 generik parametrlari fn aralashtirish dan keyin e'lon qilinadi, chunki ular faqat metodga tegishli.

Generiklar yordamida kodning ishlashi

Generik turdagi parametrlardan foydalanganda ish vaqti narxi bor yoki yo'qligini sizni qiziqtirgan bo'lishi mumkin. Yaxshi xabar shundaki, generik turlardan foydalanish dasturingizning aniq turlariga qaraganda sekinroq ishlashiga olib kelmaydi.

Rust buni kompilyatsiya vaqtida generiklar yordamida kodni monomorfizatsiya qilish orqali amalga oshiradi. Monomorfizatsiya - bu kompilyatsiya paytida ishlatiladigan aniq turlarni to'ldirish orqali generik kodni maxsus kodga aylantirish jarayoni. Ushbu jarayonda kompilyator biz 10-5 ro'yxatdagi generik funksiyani yaratishda qo'llagan qadamlarning teskarisini bajaradi: kompilyator generik kod chaqiriladigan barcha joylarni ko'rib chiqadi va generik kod chaqirilgan aniq turlar uchun kod ishlab chiqaradi.

Keling, bu standart kutubxonaning umumiy Option<T> enum yordamida qanday ishlashini ko'rib chiqaylik:

#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}

Rust ushbu kodni kompilyatsiya qilganda, u monomorfizatsiyani amalga oshiradi. Ushbu jarayon davomida kompilyator Option<T> misollarida ishlatilgan qiymatlarni o'qiydi va ikki xil Option<T>ni aniqlaydi: biri i32, ikkinchisi esa f64. Shunday qilib, u Option<T> ning umumiy ta'rifini i32 va f64 uchun ixtisoslashgan ikkita ta'rifga kengaytiradi va shu bilan umumiy ta'rifni o'ziga xos ta'riflar bilan almashtiradi.

Kodning monomorflashtirilgan versiyasi quyidagiga o'xshaydi (kompilyator biz tasvirlash uchun ishlatayotganimizdan boshqa nomlardan foydalanadi):

Fayl nomi: src/main.rs

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

Generik Option<T> kompilyator tomonidan yaratilgan maxsus ta`riflar bilan almashtiriladi. Rust generik kodni har bir misolda turni belgilaydigan kodga kompilyatsiya qilganligi sababli, biz generiklardan foydalanish uchun hech qanday ish vaqti to'lamaymiz. Kod ishga tushganda, agar biz har bir ta'rifni qo'lda takrorlagan bo'lsak, xuddi shunday ishlaydi. Monomorfizatsiya jarayoni Rust generiklarini runtimeda juda samarali qiladi.

Traitlar: umumiy xatti-harakatni aniqlash

trait ma'lum bir turga ega bo'lgan va boshqa turlar bilan bo'lishishi mumkin bo'lgan funksionallikni belgilaydi. Biz umumiy xatti-harakatni mavhum tarzda aniqlash uchun traitlardan foydalanishimiz mumkin. Generik tur ma'lum xatti-harakatlarga ega bo'lgan har qanday tur bo'lishi mumkinligini aniqlash uchun trait (bound)chegaralari dan foydalanishimiz mumkin.

Eslatma: Traitlar ba'zi farqlarga ega bo'lsa-da, ko'pincha boshqa tillarda interfeyslar deb ataladigan xususiyatga o'xshaydi.

Traitni aniqlash

Turning xatti-harakati biz ushbu turga murojaat qilishimiz mumkin bo'lgan metodlardan iborat. Agar biz ushbu turlarning barchasida bir xil metodlarni chaqira olsak, har xil turlar bir xil xatti-harakatlarga ega. Trait ta'riflari - bu qandaydir maqsadga erishish uchun zarur bo'lgan xatti-harakatlar to'plamini aniqlash uchun metod imzolarini birgalikda guruhlash usuli.

Misol uchun, bizda turli xil va hajmdagi matnlarni o'z ichiga olgan bir nechta structlar mavjud deylik: ma'lum bir joyda joylashtirilgan yangiliklarni o'z ichiga olgan YangiMaqola structi va eng ko'pi 280 belgidan iborat bo'lishi mumkin bo'lgan Maqola yangi post, retpost yoki boshqa postga javob ekanligini ko'rsatadigan metama'lumotlar.

Biz YangiMaqola yoki Maqola misolida saqlanishi mumkin bo‘lgan ma’lumotlarning qisqacha mazmunini ko‘rsata oladigan aggregator nomli media agregator kutubxonasini yaratmoqchimiz. Buni amalga oshirish uchun bizga har bir tur bo'yicha xulosa kerak bo'ladi va biz ushbu xulosani misolda umumiy_xulosa metodini chaqirish orqali so'raymiz. 10-12 ro'yxatda ushbu xatti-harakatni ifodalovchi umumiy Xulosa traitining ta'rifi ko'rsatilgan.

Fayl nomi: src/lib.rs

pub trait Xulosa {
    fn umumiy_xulosa(&self) -> String;
}

Roʻyxat 10-12: umumiy_xulosa metodi bilan taʼminlangan xatti-harakatlardan iborat Xulosa traiti

Bu yerda biz trait kalit so'zidan foydalanib traitni e'lon qilamiz, so'ngra belgi nomi, bu holda Xulosa. Shuningdek, biz ushbu traitni pub deb e’lon qildik, shunda bu cratega bog‘liq bo‘lgan cratelar ham bu traitdan foydalanishi mumkin, buni bir necha misollarda ko‘ramiz. Jingalak qavslar ichida biz ushbu traitni amalga oshiradigan turlarning xatti-harakatlarini tavsiflovchi metod imzolarini e'lon qilamiz, bu holda fn umumiy_xulosa(&self) -> String.

Metod imzosidan so'ng, jingalak qavslar ichida amalga oshirish o'rniga, biz nuqta-verguldan foydalanamiz. Ushbu traitni amalga oshiradigan har bir tur metod tanasi uchun o'ziga xos xatti-harakatni ta'minlashi kerak. Kompilyator Xulosa traitiga ega boʻlgan har qanday turda aynan shu imzo bilan aniqlangan umumiy_xulosa metodi boʻlishini talab qiladi.

Traitining tanasida bir nechta metodlar bo'lishi mumkin: metod imzolari har bir satrda bittadan ko'rsatilgan va har bir satr nuqtali vergul bilan tugaydi.

Turga xos traitni amalga oshirish

Endi biz Xulosa traiti metodlarining kerakli imzolarini aniqlaganimizdan so‘ng, uni media agregatorimizdagi turlarga qo‘llashimiz mumkin. 10-13 roʻyxat sarlavhadan foydalanadigan YangiMaqola structidagi Xulosa traitining amalga oshirilishini koʻrsatadi, muallif va umumiy_xulosa qaytish qiymatini yaratish uchun joy. Maqola structi uchun biz umumiy_xulosani foydalanuvchi nomi va undan keyin maqolaning butun matni sifatida belgilaymiz, maqola mazmuni allaqachon 280 belgi bilan cheklangan deb hisoblaymiz.

Fayl nomi: src/lib.rs

pub trait Xulosa {
    fn umumiy_xulosa(&self) -> String;
}

pub struct YangiMaqola {
    pub sarlavha: String,
    pub manzil: String,
    pub muallif: String,
    pub mazmuni: String,
}

impl Xulosa for YangiMaqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}, by {} ({})", self.sarlavha, self.muallif, self.manzil)
    }
}

pub struct Maqola {
    pub foydalanuvchi: String,
    pub mazmuni: String,
    pub javob_berish: bool,
    pub repost: bool,
}

impl Xulosa for Maqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}: {}", self.foydalanuvchi, self.mazmuni)
    }
}

Roʻyxat 10-13: Xulosa traitini YangiMaqola va Maqola turlariga joriy qilish

Traitni turga tatbiq etish odatiy usullarni amalga oshirishga o'xshaydi. Farqi shundaki, impl dan so'ng biz amalga oshirmoqchi bo'lgan trait nomini qo'yamiz, so'ng for kalit so'zidan foydalanamiz va keyin traitni amalga oshirmoqchi bo'lgan tur nomini belgilaymiz. impl blokida biz trait ta'rifi belgilagan metod imzolarini qo'yamiz. Har bir imzodan keyin nuqta-vergul qo'yish o'rniga, biz jingalak qavslardan foydalanamiz va metod tanasini o'ziga xos xatti-harakat bilan to'ldiramiz, biz traitning metodlari ma'lum bir turga ega bo'lishini xohlaymiz.

Kutubxona YangiMaqola va Maqolada Xulosa traitini joriy qilganligi sababli, crate foydalanuvchilari YangiMaqola va Maqola misollaridagi xususiyat metodlarini biz odatdagi metodlar deb ataganimizdek chaqirishlari mumkin. Yagona farq shundaki, foydalanuvchi o'ziga xos traitni turlari bilan bir qatorda qamrab olishi kerak. Binary crate bizning aggregator kutubxonamiz cratesidan qanday foydalanishi mumkinligiga misol:

use aggregator::{Xulosa, Maqola};

fn main() {
    let maqola = Maqola {
        foydalanuvchi: String::from("ismoilovdev"),
        mazmuni: String::from(
            "Rust kitobi juda foydali ekan, men juda ko'p bilimlarni o'zlashtirdim",
        ),
        javob_berish: false,
        repost: false,
    };

    println!("1 ta yangi xabar: {}", maqola.umumiy_xulosa());
}

Bu kod 1 ta yangi xabar: ismoilovdev: Rust kitobi juda foydali ekan, men juda ko'p bilimlarni o'zlashtirdim chop etadi.

aggregator cratesiga bog'liq bo'lgan boshqa cratelar ham Xulosa traitini o'z turlari bo'yicha Xulosani amalga oshirish uchun qamrab olishi mumkin. E'tiborga olish kerak bo'lgan cheklashlardan biri shundaki, biz trait yoki turning hech bo'lmaganda bittasi bizning cratemiz uchun mahalliy(local) bo'lsa, biz traitni turga qo'llashimiz mumkin. Misol uchun, biz Maqola kabi maxsus turdagi Display kabi standart kutubxona traitlarini aggregator crate funksiyamizning bir qismi sifatida amalga oshirishimiz mumkin, chunki Maqola turi aggregator cratemiz uchun mahalliydir. Shuningdek, biz Vec<T> da Xulosani aggregator cratemizda ham qo‘llashimiz mumkin, chunki Xulosa traiti aggregator cratemiz uchun mahalliydir.

Ammo biz tashqi turlarga tashqi traitlarni amalga oshira olmaymiz. Masalan, biz aggregator cratemiz ichida Vec<T> da Display traitini amalga oshira olmaymiz, chunki Display va Vec<T> ikkalasi ham standart kutubxonada belgilangan va bizning aggregator cratemiz uchun mahalliy emas. Bu cheklash kogerentlik(coherence) deb nomlangan xususiyatning bir qismi va aniqrog'i yetim qoidasi(orphan rule), chunki ota-ona turi mavjud emasligi sababli shunday nomlangan. Bu qoida boshqa odamlarning kodi sizning kodingizni buzmasligini ta'minlaydi va aksincha. Qoidalarsiz ikkita crate bir xil turdagi bir xil traitni amalga oshirishi mumkin edi va Rust qaysi dasturdan foydalanishni bilmaydi.

Standart ilovalar

Ba'zan har bir turdagi barcha metodlarni amalga oshirishni talab qilish o'rniga, traitdagi ba'zi yoki barcha metodlar uchun standart xatti-harakatlarga ega bo'lish foydali bo'ladi. Keyin, biz traitni ma'lum bir turga qo'llaganimizda, har bir metodning standart xatti-harakatlarini saqlab qolishimiz yoki bekor qilishimiz mumkin.

Roʻyxat 10-14da biz 10-12 ro'yxatda bo'lgani kabi faqat metod imzosini belgilash o'rniga Xulosa traitining umumiy_xulosa metodi uchun standart qatorni belgilaymiz.

Fayl nomi: src/lib.rs

pub trait Xulosa {
    fn umumiy_xulosa(&self) -> String {
        String::from("(Batafsil...)")
    }
}

pub struct YangiMaqola {
    pub sarlavha: String,
    pub manzil: String,
    pub muallif: String,
    pub mazmuni: String,
}

impl Xulosa for YangiMaqola {}

pub struct Maqola {
    pub foydalanuvchi: String,
    pub mazmuni: String,
    pub javob_berish: bool,
    pub repost: bool,
}

impl Xulosa for Maqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}: {}", self.foydalanuvchi, self.mazmuni)
    }
}

Roʻyxat 10-14: Xulosa traitini umumiy_xulosa metodini standart boʻyicha amalga oshirish bilan aniqlash

YangiMaqola misollarini umumlashtirish uchun standart ilovadan foydalanish uchun biz bo'sh impl blokini impl Xulosa for YangiMaqola {} bilan belgilaymiz.

Biz YangiMaqolada to‘g‘ridan-to‘g‘ri umumiy_xulosa metodini endi aniqlamasak ham, biz standart bo‘yicha dasturni taqdim etdik va YangiMaqola Xulosa traitini amalga oshirishini belgilab oldik. Natijada, biz hali ham YangiMaqola misolida umumiy_xulosa metodini quyidagicha chaqirishimiz mumkin:

use aggregator::{self, YangiMaqola, Xulosa};

fn main() {
    let maqola = YangiMaqola {
        sarlavha: String::from("Tesla yangi elektromobil ustida ishlayapti"),
        manzil: String::from("USA"),
        muallif: String::from("Elon Musk"),
        mazmuni: String::from(
            "Hozirgi kunda Tesla yangi innovatsion elektromobil\
             ustida ishlamoqda.",
        ),
    };

    println!("Yangi maqola mavjud! {}", maqola.umumiy_xulosa());
}

Bu kod Yangi maqola mavjud! (Batafsil...)ni chop etadi.

Standart dasturni yaratish bizdan 10-13 roʻyxatdagi Maqoladagi Xulosani amalga oshirish haqida biror narsani oʻzgartirishimizni talab qilmaydi. Buning sababi, standart dasturni bekor qilish sintaksisi standart dasturga ega bo'lmagan trait metodini amalga oshirish sintaksisi bilan bir xil.

Standart ilovalar bir xil traitga ega bo'lgan boshqa metodlarni chaqirishi mumkin, hatto bu boshqa metodlarda standart dastur bo'lmasa ham. Shunday qilib, trait juda ko'p foydali funksiyalarni taqdim etishi mumkin va amalga oshiruvchilardan faqat uning kichik qismini ko'rsatishni talab qiladi. Misol uchun, biz Xulosa traitini amalga oshirish zarur bo'lgan muallif_haqida metodiga ega bo'lish uchun belgilashimiz va keyin muallif_haqida metodini chaqiradigan standart amalga oshirishga ega bo'lgan umumiy_xulosa metodini belgilashimiz mumkin:

pub trait Xulosa {
    fn muallif_haqida(&self) -> String;

    fn umumiy_xulosa(&self) -> String {
        format!("(Batafsil: {}...)", self.muallif_haqida())
    }
}

pub struct Maqola {
    pub foydalanuvchi: String,
    pub mazmuni: String,
    pub javob_berish: bool,
    pub repost: bool,
}

impl Xulosa for Maqola {
    fn muallif_haqida(&self) -> String {
        format!("@{}", self.foydalanuvchi)
    }
}

Xulosa ning ushbu versiyasidan foydalanish uchun biz faqat bir turdagi traitni amalga oshirganimizda muallif_haqida ni aniqlashimiz kerak:

pub trait Xulosa {
    fn muallif_haqida(&self) -> String;

    fn umumiy_xulosa(&self) -> String {
        format!("(Batafsil: {}...)", self.muallif_haqida())
    }
}

pub struct Maqola {
    pub foydalanuvchi: String,
    pub mazmuni: String,
    pub javob_berish: bool,
    pub repost: bool,
}

impl Xulosa for Maqola {
    fn muallif_haqida(&self) -> String {
        format!("@{}", self.foydalanuvchi)
    }
}

muallif_haqida ni aniqlaganimizdan so'ng, biz Maqola structi misollarida umumiy_xulosa deb atashimiz mumkin va umumiy_xulosa standart bajarilishi biz taqdim etgan muallif_haqida ta'rifini chaqiradi. Biz muallif_haqida ni qo'llaganimiz sababli, Xulosa traiti bizga boshqa kod yozishni talab qilmasdan umumiy_xulosa metodining harakatini berdi.

use aggregator::{self, Xulosa, Maqola};

fn main() {
    let maqola = Maqola {
        foydalanuvchi: String::from("ismoilovdev"),
        mazmuni: String::from(
            "Rust kitobi juda foydali ekan, men juda ko'p bilimlarni o'zlashtirdim",
        ),
        javob_berish: false,
        repost: false,
    };

    println!("1 ta yangi xabar: {}", maqola.umumiy_xulosa());
}

Bu kod 1 ta yangi xabar: (Batafsil: @ismoilovdev...) ni chop etadi.

Shuni esda tutingki, xuddi shu metodni bekor qilish orqali standart dasturni chaqirish mumkin emas.

Traitlar parametr sifatida

Endi siz traitlarni qanday aniqlash va amalga oshirishni bilganingizdan so'ng, biz ko'plab turlarni qabul qiladigan funksiyalarni aniqlash uchun traitlardan qanday foydalanishni o'rganishimiz mumkin. Biz 10-13 roʻyxatdagi YangiMaqola va Maqola turlari uchun joriy qilingan Xulosa traitidan foydalanamiz, uning element parametri boʻyicha umumlashtirish metodlini chaqiradigan xabar_berish funksiyasini belgilaymiz, u Xulosa traitini amalga oshiradi. Buning uchun biz impl Trait sintaksisidan foydalanamiz, masalan:

pub trait Xulosa {
    fn umumiy_xulosa(&self) -> String;
}

pub struct YangiMaqola {
    pub sarlavha: String,
    pub manzil: String,
    pub muallif: String,
    pub mazmuni: String,
}

impl Xulosa for YangiMaqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}, by {} ({})", self.sarlavha, self.muallif, self.manzil)
    }
}

pub struct Maqola {
    pub foydalanuvchi: String,
    pub mazmuni: String,
    pub javob_berish: bool,
    pub repost: bool,
}

impl Xulosa for Maqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}: {}", self.foydalanuvchi, self.mazmuni)
    }
}

pub fn xabar_berish(element: &impl Xulosa) {
    println!("Tezkor xabarlar! {}", element.umumiy_xulosa());
}

element parametri uchun aniq tur o'rniga biz impl kalit so'zini va trait nomini belgilaymiz. Ushbu parametr belgilangan traitni amalga oshiradigan har qanday turni qabul qiladi. xabar_berish qismida biz Xulosa traitidan kelib chiqadigan element bo‘yicha har qanday metodlarni chaqirishimiz mumkin, masalan, umumiy_xulosa. Biz xabar_berish ga chaiqruv qilishimiz va YangiMaqola yoki Maqola ning istalgan misolida o'tishimiz mumkin. Funksiyani String yoki i32 kabi boshqa har qanday turdagi chaqiruvchi kod kompilyatsiya qilinmaydi, chunki bu turlar Xulosa ni amalga oshirmaydi.

Traitlarni cheklash sintaksisi

impl Trait sintaksisi oddiy holatlar uchun ishlaydi, lekin aslida trait bound deb nomlanuvchi uzunroq shakl uchun sintaksis shakaridir; bu shunday ko'rinadi:

pub fn xabar_berish<T: Xulosa>(element: &T) {
    println!("Tezkor xabarlar! {}", element.umumiy_xulosa());
}

Ushbu uzunroq shakl oldingi bo'limdagi misolga teng, ammo batafsilroq. Trait chegaralarini ikki nuqta va ichki burchakli qavslardan keyin umumiy tur parametri e'lon qilingan holda joylashtiramiz.

impl Trait sintaksisi qulay va oddiy holatlarda ixchamroq kodni yaratadi, to'liqroq traitlar bilan bog'langan sintaksisi esa boshqa holatlarda ko'proq murakkablikni ifodalashi mumkin. Misol uchun, bizda Xulosa ni amalga oshiradigan ikkita parametr bo'lishi mumkin. Buni impl Trait sintaksisi bilan bajarish quyidagicha ko'rinadi:

pub fn xabar_berish(element1: &impl Xulosa, element2: &impl Xulosa) {

Agar biz ushbu funksiya element1 va element2 turli xil turlarga ega bo'lishini istasak, impl Trait dan foydalanish maqsadga muvofiqdir (agar ikkala tur ham Xulosani qo'llasa). Agar biz ikkala parametrni bir xil turga ega bo'lishga majburlamoqchi bo'lsak, quyidagi kabi trait bounddan foydalanishimiz kerak:

pub fn xabar_berish<T: Xulosa>(element1: &T, element2: &T) {

element1 va element2 parametrlarining turi sifatida belgilangan umumiy T turi funksiyani shunday cheklaydiki, element1 va element2 uchun argument sifatida berilgan qiymatning aniq turi bir xil bo`lishi kerak.

+ sintaksisi bilan bir nechta trait chegaralarini belgilash

Bundan tashqari, biz bir nechta traitlarni belgilashimiz mumkin. Aytaylik, biz xabar_berish funksiyasidan display formatlash hamda element bo‘yicha umumiy_xulosadan foydalanishni xohladik: biz xabar_berish ta'rifida element Display va Xulosa ni ham amalga oshirishi kerakligini belgilaymiz. Buni + sintaksisi yordamida amalga oshirishimiz mumkin:

pub fn xabar_berish(element: &(impl Xulosa + Display)) {

+ sintaksisi generik turdagi belgilar chegaralari bilan ham amal qiladi:

pub fn xabar_berish<T: Xulosa+ Display>(element: &T) {

Belgilangan ikkita trait chegarasi bilan xabar_berish asosiy qismi umumiy_xulosa deb chaqirishi va elementni formatlash uchun {} dan foydalanishi mumkin.

where bandlari bilan aniqroq trait bounds(chegaralari)

Haddan tashqari ko'p belgilar boundlaridan foydalanish o'zining salbiy tomonlariga ega. Har bir generikning o'ziga xos trait boundlari bor, shuning uchun bir nechta umumiy turdagi parametrlarga ega funksiyalar funksiya nomi va uning parametrlar ro'yxati o'rtasida ko'plab belgilar bilan bog'liq ma'lumotlarni o'z ichiga olishi mumkin, bu funksiya imzosini o'qishni qiyinlashtiradi. Shu sababli, Rust funksiya imzosidan keyin where bandida trait boundlarini belgilash uchun muqobil sintaksisga ega.

fn boshqa_funksiya<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

biz where bandidan foydalanishimiz mumkin, masalan:

fn boshqa_funksiya<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    unimplemented!()
}

Bu funksiya imzosi kamroq chalkash: funksiya nomi, parametrlar ro'yxati va qaytish turi bir-biriga yaqin bo'lib, ko'p trait boundlari bo'lmagan funksiyaga o'xshaydi.

Traitlarni amalga oshiradigan Return(qaytaruvchi) turlar

Bu yerda ko'rsatilganidek, traitni amalga oshiradigan ba'zi turdagi qiymatni qaytarish(return) uchun impl Trait sintaksisini return holatida ham ishlatishimiz mumkin:

pub trait Xulosa {
    fn umumiy_xulosa(&self) -> String;
}

pub struct YangiMaqola {
    pub sarlavha: String,
    pub manzil: String,
    pub muallif: String,
    pub mazmuni: String,
}

impl Xulosa for YangiMaqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}, by {} ({})", self.sarlavha, self.muallif, self.manzil)
    }
}

pub struct Maqola {
    pub foydalanuvchi: String,
    pub mazmuni: String,
    pub javob_berish: bool,
    pub repost: bool,
}

impl Xulosa for Maqola {
    fn umumiy_xulosa(&self) -> String {
        format!("{}: {}", self.foydalanuvchi, self.mazmuni)
    }
}

fn return_xulosa() -> impl Xulosa {
    Maqola {
        foydalanuvchi: String::from("ismoilovdev"),
        mazmuni: String::from(
            "Rust kitobi juda foydali ekan, men juda ko'p bilimlarni o'zlashtirdim",
        ),
        javob_berish: false,
        repost: false,
    }
}

Qaytish(return) turi uchun impl Xulosa dan foydalanib, biz return_xulosa funksiyasi aniq turga nom bermasdan Xulosa traitini amalga oshiradigan ba'zi turlarni qaytarishini aniqlaymiz. Bunday holda, return_xulosa Maqola ni qaytaradi, lekin bu funksiyani chaqiruvchi kod buni bilishi shart emas.

Qaytish turini faqat u amalga oshiradigan traitga ko'ra belgilash qobiliyati, ayniqsa, biz 13-bobda ko'rib chiqiladigan closurelar va iteratorlar kontekstida foydalidir. Closures va iteratorlar faqat kompilyator biladigan turlarni yoki belgilash uchun juda uzoq turlarni yaratadi. impl Trait sintaksisi sizga funksiya juda uzun turni yozishga hojat qoldirmasdan Iterator traitini amalga oshiradigan ba'zi turlarni qaytarishini qisqacha belgilash imkonini beradi.

Biroq, faqat bitta turni qaytarayotgan bo'lsangiz, impl Trait dan foydalanishingiz mumkin. Masalan, YangiMaqola yoki Maqolani qaytaruvchi impl Xulosa sifatida ko‘rsatilgan qaytarish turiga ega bo‘lgan bu kod ishlamaydi:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn returns_summarizable(switch: bool) -> impl Summary {
    if switch {
        NewsArticle {
            headline: String::from(
                "Penguins win the Stanley Cup Championship!",
            ),
            location: String::from("Pittsburgh, PA, USA"),
            author: String::from("Iceburgh"),
            content: String::from(
                "The Pittsburgh Penguins once again are the best \
                 hockey team in the NHL.",
            ),
        }
    } else {
        Tweet {
            username: String::from("horse_ebooks"),
            content: String::from(
                "of course, as you probably already know, people",
            ),
            reply: false,
            retweet: false,
        }
    }
}

YangiMaqola yoki Maqolani qaytarishga impl Trait sintaksisi kompilyatorda qanday amalga oshirilishi bilan bog‘liq cheklovlar tufayli ruxsat berilmaydi. Ushbu xatti-harakat bilan funksiyani qanday yozishni biz 17-bobning "Turli turdagi qiymatlarga ruxsat beruvchi trait ob'ektlaridan foydalanish" bo'limida ko'rib chiqamiz.

Metodlarni shartli ravishda amalga oshirish uchun Trait Boundlardan foydalanish

Umumiy turdagi parametrlardan foydalanadigan impl bloki bilan trait bounddan foydalanib, biz belgilangan traitlarni amalga oshiradigan turlar uchun metodlarni shartli ravishda amalga oshirishimiz mumkin. Masalan, 10-15-ro'yxatdagi Pair<T> turi har doim yangi Pair<T> nusxasini qaytarish uchun new funksiyasini amalga oshiradi (5-bobning “Metodlarni aniqlash” boʻlimidan eslaylikki, Self bu impl bloki turiga tegishli turdagi taxallus(alias) boʻlib, bu holda Pair<T> boʻladi). Ammo keyingi impl blokida Pair<T> faqat cmp_display metodini qo'llaydi, uning ichki turi(inner type) T taqqoslash imkonini beruvchi PartialOrd traitini va chop etish imkonini beruvchi Display traittini amalga oshiradi.

Fayl nomi: src/lib.rs

use std::fmt::Display;

struct Pair<T> {
    x: T,
    y: T,
}

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("Eng katta a'zo x = {}", self.x);
        } else {
            println!("Eng katta a'zo y = {}", self.y);
        }
    }
}

Ro'yxat 10-15: Trait boundga qarab generik tur bo'yicha shartli ravishda qo'llash metodlari

Biz shartli ravishda boshqa traitni amalga oshiradigan har qanday tur uchun traitni amalga oshirishimiz mumkin. Trait boundlarni qondiradigan har qanday turdagi tarittni amalga oshirish blanket implementations deb nomlanadi va Rust standart kutubxonasida keng qo'llaniladi. Masalan, standart kutubxona Display traitini amalga oshiradigan har qanday turdagi ToString traitini amalga oshiradi. Standart kutubxonadagi impl bloki ushbu kodga o'xshaydi:

impl<T: Display> ToString for T {
    // --snip--
}

Standart kutubxonada bu keng qamrovli dastur mavjud bo'lganligi sababli, biz Display traitini amalga oshiradigan har qanday turdagi ToString traiti bilan aniqlangan to_string metodini chaqirishimiz mumkin. Masalan, biz butun sonlarni mos keladigan String qiymatlariga shunday aylantirishimiz mumkin, chunki butun sonlar Displayni amalga oshiradi:

#![allow(unused)]
fn main() {
let s = 3.to_string();
}

Blanket implementationlari "Implementors" bo'limidagi trait uchun texnik hujjatlarda ko'rinadi.

Traitlar va trait boundlar takrorlanishni kamaytirish uchun generik turdagi parametrlardan foydalanadigan kod yozishga imkon beradi, shuningdek, generik turning o'ziga xos xatti-harakatlariga ega bo'lishini kompilyatorga ko'rsatishga imkon beradi. Keyin kompilyator trait bilan bog'langan ma'lumotlardan bizning kodimiz bilan qo'llaniladigan barcha aniq turlar to'g'ri xatti-harakatni ta'minlaydiganligini tekshirish uchun foydalanishi mumkin. Dinamik ravishda tuzilgan tillarda, agar biz metodni aniqlamagan turdagi metodni chaqirsak, runtimeda xatoga yo'l qo'yamiz. Ammo Rust bu xatolarni vaqtni kompilyatsiya qilish uchun ko'chiradi, shuning uchun biz kodimiz ishga tushgunga qadar muammolarni hal qilishga majbur bo'lamiz. Bundan tashqari, biz runtimeda xatti-harakatni tekshiradigan kod yozishimiz shart emas, chunki biz kompilyatsiya vaqtida allaqachon tekshirganmiz. Bu generiklarning moslashuvchanligidan voz kechmasdan ishlashni yaxshilaydi.

Referencelarni lifetime bilan tekshirish

Lifetimelar - biz allaqachon uchratgan generiklarning yana bir turi. Turning biz xohlagan xatti-harakatga ega bo'lishini ta'minlash o'rniga, lifetime referencelar biz uchun kerak bo'lganda haqiqiyligini ta'minlaydi.

4-bobdagi [“Referencelar va Borrowing”](references-and-borrowing) bo‘limida biz muhokama qilmagan bir tafsilot shundan iboratki, Rust-dagi har bir referenceda o‘sha referencening amal qilish doirasi lifetime bo‘ladi. Ko'pincha, lifetimelar yashirin va inferred bo'ladi, ko'p hollarda bo'lgani kabi, turlar ham inferred qilinadi.Biz faqat bir nechta tur mumkin bo'lganda turlarga izoh berishimiz kerak. Shunga o'xshab, biz referencelarning lifetime bir necha xil yo'llar bilan bog'lanishi mumkin bo'lgan lifetimelarini izohlashimiz kerak. Rust bizdan runtimeda ishlatiladigan haqiqiy referencelar haqiqiy bo'lishini ta'minlash uchun generik lifetime parametrlaridan foydalangan holda munosabatlarga izoh berishimizni talab qiladi.

Lifetimeni izohlash boshqa dasturlash tillarining ko'pchiligida mavjud bo'lgan tushuncha ham emas, shuning uchun bu notanish tuyuladi. Garchi biz ushbu bobda lifetimeni to'liq qamrab olmasak ham, kontseptsiyadan qulay bo'lishingiz uchun lifetime sintaksisga duch kelishingiz mumkin bo'lgan umumiy usullarni muhokama qilamiz.

Lifetimeda dangling referencelarni oldini olish

Lifetimening asosiy maqsadi dasturga reference qilish uchun mo'ljallangan ma'lumotlardan boshqa ma'lumotlarga reference qilishiga olib keladigan dangling referencelar ning oldini olishdir. 10-16 ro'yxatdagi dasturni ko'rib chiqing, uning tashqi va ichki ko'lami(tashqi va ichki ishlash doirasi) bor.

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {}", r);
}

Ro'yxat 10-16: Qiymati ishlash doiradan chiqib ketgan referencedan foydalanishga urinish

Eslatma: 10-16, 10-17 va 10-23 ro'yxatlardagi misollar o'zgaruvchilarni ularga boshlang'ich qiymat bermasdan e'lon qiladi, shuning uchun o'zgaruvchi nomi tashqi doirada mavjud. Bir qarashda, bu Rustning null qiymatlari yo'qligiga zid bo'lib tuyulishi mumkin. Biroq, agar biz o'zgaruvchiga qiymat berishdan oldin foydalanmoqchi bo'lsak, biz kompilyatsiya vaqtida xatoga duch kelamiz, bu Rust haqiqatan ham null qiymatlarga ruxsat bermasligini ko'rsatadi.

Tashqi qamrov boshlang‘ich qiymati bo‘lmagan r nomli o‘zgaruvchini, ichki qamrov esa boshlang‘ich qiymati 5 bo‘lgan x nomli o‘zgaruvchini e’lon qiladi. Ichki doirada(qamrov) biz x ga reference sifatida r qiymatini belgilashga harakat qilamiz. Keyin ichki qamrov tugaydi va biz qiymatni r da chop etishga harakat qilamiz. Ushbu kod kompilyatsiya qilinmaydi, chunki biz undan foydalanishga urinishdan oldin r qiymati ko'rib chiqilmaydi. Mana xato xabari:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
 --> src/main.rs:6:13
  |
6 |         r = &x;
  |             ^^ borrowed value does not live long enough
7 |     }
  |     - `x` dropped here while still borrowed
8 |
9 |     println!("r: {}", r);
  |                       - borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` due to previous error

x o'zgaruvchisi "yetarlicha uzoq umr ko'rmaydi". Sababi, 7-qatorda ichki qamrov tugashi bilan x amaldan tashqarida bo'ladi. Lekin r tashqi doira uchun hamon amal qiladi; uning qamrovi kengroq bo'lgani uchun biz uni "uzoq yashaydi" deymiz. Agar Rust ushbu kodning ishlashiga ruxsat bergan bo'lsa, r x doiradan chiqib ketganda ajratilgan xotiraga reference bo'ladi va biz r bilan qilishga uringan har qanday narsa to'g'ri ishlamaydi. Xo'sh, Rust bu kodning yaroqsizligini qanday aniqlaydi? Bu borrow(qarz) tekshiruvidan foydalanadi.

Borrow tekshiruvchisi

Rust kompilyatorida barcha borrowlar to'g'ri yoki yo'qligini aniqlash uchun ko'lamlarni taqqoslaydigan borrow tekshiruvi(borrow checker) mavjud. 10-17 ro'yxat 10-16 ro'yxati bilan bir xil kodni ko'rsatadi, ammo o'zgaruvchilarning lifetime(ishlash muddatini) ko'rsatadigan izohlar bilan.

fn main() {
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {}", r); //          |
}                         // ---------+