Kapsamı Kontrol Etmek için Modülleri Tanımlama
Bu bölümde, modüller ve modül sisteminin diğer parçaları olan yollar hakkında ve bir yolu kapsam içine alma imkanı veren use
anahtar kelimesi hakkında konuşacağız.
Öncelikle, kodunuzu gelecekte organize ederken kolay referans için bir kural listesiyle başlayacağız. Sonra bu kuralların her birini detaylı bir şekilde açıklayacağız.
Modüller Hile Sayfası
Burada, modüllerin, yolların ve use
anahtar kelimesinin derleyicide nasıl çalıştığına ve çoğu geliştiricinin kodlarını nasıl organize ettiğine dair hızlı bir referans sunuyoruz.
-
Kutu kökünden başlayın: Bir kutuyu derlerken, derleyici önce kodu derlemek için kutu kök dosyasında (src/lib.cairo) arar.
-
Modülleri bildirmek: Kutu kök dosyasında,
mod garden;
diyerek yeni modüller bildirebilirsiniz. Derleyici, modülün kodunu şu yerlerde arayacaktır:-
Inline, within curly brackets that replace the semicolon following
mod garden
.// crate root file (src/lib.cairo) mod garden { // code defining the garden module goes here }
-
In the file src/garden.cairo.
-
-
Alt modülleri bildirmek: Kutu kök dosyası dışındaki herhangi bir dosyada, alt modüller bildirebilirsiniz.
-
Doğrudan
mod vegetables
'ı takip eden ve noktalı virgülün yerine geçen kıvırcık parantezler içinde.// src/garden.cairo file mod vegetables { // code defining the vegetables submodule goes here }
-
In the file src/garden/vegetables.cairo.
-
-
Paths to code in modules: Once a module is part of your crate, you can refer to code in that module from anywhere else in that same crate, using the path to the code. For example, an
Asparagus
type in thevegetables
submodule would be found atcrate::garden::vegetables::Asparagus
. -
Private vs public: Code within a module is private from its parent modules by default. This means that it may only be accessed by the current module and its descendants. To make a module public, declare it with
pub mod
instead ofmod
. To make items within a public module public as well, usepub
before their declarations. Cairo also provides thepub(crate)
keyword, allowing an item or module to be only visible within the crate in which the definition is included. -
The
use
keyword: Within a scope, theuse
keyword creates shortcuts to items to reduce repetition of long paths. In any scope that can refer tocrate::garden::vegetables::Asparagus
, you can create a shortcut withuse crate::garden::vegetables::Asparagus;
and from then on you only need to writeAsparagus
to make use of that type in the scope.
Bu bölümde, backyard
adında bu kuralları örneklendiren bir kutu oluşturuyoruz. Kutunun dizini, aynı zamanda backyard
olarak adlandırılmış, bu dosya ve dizinleri içerir:
backyard/
├── Scarb.toml
└── src
├── garden
│ └── vegetables.cairo
├── garden.cairo
└── lib.cairo
Bu durumda kutu kök dosyası src/lib.cairo'dır ve içerdiği:
Filename: src/lib.cairo
pub mod garden;
use crate::garden::vegetables::Asparagus;
fn main() {
let plant = Asparagus {};
println!("I'm growing {:?}!", plant);
}
The pub mod garden;
line imports the garden
module. Using pub
to make garden
publicly accessible, or pub(crate)
if you really want to make garden
only available for your crate, is optional to run our program here, as the main
function resides in the same module as pub mod garden;
declaration. Nevertheless, not declaring garden
as pub
will make it not accessible from any other package. This line tells the compiler to include the code it finds in src/garden.cairo, which is:
Filename: src/garden.cairo
pub mod vegetables;
Here, pub mod vegetables;
means the code in src/garden/vegetables.cairo is included too. That code is:
#[derive(Drop, Debug)]
pub struct Asparagus {}
The line use crate::garden::vegetables::Asparagus;
lets us bring the Asparagus
type into scope, so we can use it in the main
function.
Şimdi bu kuralların detaylarına dalalım ve onları eylemde gösterelim!
Modüllerde İlgili Kodları Gruplama
Modules let us organize code within a crate for readability and easy reuse. Modules also allow us to control the privacy of items, because code within a module is private by default. Private items are internal implementation details not available for outside use. We can choose to make modules and the items within them public, which exposes them to allow external code to use and depend on them.
As an example, let’s write a library crate that provides the functionality of a restaurant. We’ll define the signatures of functions but leave their bodies empty to concentrate on the organization of the code, rather than the implementation of a restaurant.
Restoran endüstrisinde, bir restoranın bazı kısımlarına ön ev ve diğerlerine arka ev denir. Ön ev, müşterilerin olduğu yerdir; bu, hostların müşterileri oturttuğu, garsonların sipariş ve ödemeleri aldığı ve barmenlerin içki yaptığı yerleri kapsar. Arka ev, şeflerin ve aşçıların mutfakta çalıştığı, bulaşıkçıların temizlik yaptığı ve yöneticilerin idari işleri yürüttüğü yerdir.
To structure our crate in this way, we can organize its functions into nested modules. Create a new package named restaurant by running scarb new restaurant
; then enter the code in Listing 7-1 into src/lib.cairo to define some modules and function signatures. Here’s the front of house section:
Filename: src/lib.cairo
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
fn seat_at_table() {}
}
mod serving {
fn take_order() {}
fn serve_order() {}
fn take_payment() {}
}
}
Listing 7-1: A front_of_house
module containing other modules that then contain functions
We define a module with the mod
keyword followed by the name of the module (in this case, front_of_house
). The body of the module then goes inside curly brackets. Inside modules, we can place other modules, as in this case with the modules hosting
and serving
. Modules can also hold definitions for other items, such as structs, enums, constants, traits, and functions.
Modülleri kullanarak, ilgili tanımlamaları bir araya gruplayabilir ve neden ilişkili olduklarını adlandırabiliriz. Bu kodu kullanan programcılar, tüm tanımları okumak zorunda kalmadan gruplara dayanarak kodu gezinebilir, bu da onlara ilgili tanımlamaları daha kolay bulmalarını sağlar. Bu koda yeni işlevsellik ekleyen programcılar, programı düzenli tutmak için kodu nereye yerleştireceklerini bilecektir.
Earlier, we mentioned that src/lib.cairo is called the crate root. The reason for this name is that the content of this file forms a module named after the crate name at the root of the crate’s module structure, known as the module tree.
Listeleme 7-2, Listeleme 7-1'deki yapı için modül ağacını gösterir.
restaurant
└── front_of_house
├── hosting
│ ├── add_to_waitlist
│ └── seat_at_table
└── serving
├── take_order
├── serve_order
└── take_payment
Listing 7-2: The module tree for the code in Listing 7-1
This tree shows how some of the modules nest inside one another; for example, hosting
nests inside front_of_house
. The tree also shows that some modules are siblings to each other, meaning they’re defined in the same module; hosting
and serving
are siblings defined within front_of_house
. If module A is contained inside module B, we say that module A is the child of module B and that module B is the parent of module A. Notice that the entire module tree is rooted under the explicit name of the crate restaurant.
Modül ağacı, bilgisayarınızdaki dosya sisteminin dizin ağacını hatırlatabilir; bu çok uygun bir karşılaştırmadır! Dosya sistemindeki dizinler gibi, kodunuzu düzenlemek için modülleri kullanırsınız. Ve bir dizindeki dosyalar gibi, modüllerimizi bulmanın bir yoluna ihtiyacımız var.