From 4efeb74c723a788fb86390e7e281569e3a17d2b9 Mon Sep 17 00:00:00 2001 From: Andika Triwidada Date: Tue, 21 Nov 2023 09:51:20 +0000 Subject: [PATCH] Add ch03-01 translation --- src/ch03-01-variables-and-mutability.md | 247 +++++++++++++----------- 1 file changed, 131 insertions(+), 116 deletions(-) diff --git a/src/ch03-01-variables-and-mutability.md b/src/ch03-01-variables-and-mutability.md index 058f7bb5c4..9e921513ed 100644 --- a/src/ch03-01-variables-and-mutability.md +++ b/src/ch03-01-variables-and-mutability.md @@ -1,19 +1,21 @@ -## Variables and Mutability +## Variabel dan Mutabilitas -As mentioned in the [“Storing Values with -Variables”][storing-values-with-variables] section, by default, -variables are immutable. This is one of many nudges Rust gives you to write -your code in a way that takes advantage of the safety and easy concurrency that -Rust offers. However, you still have the option to make your variables mutable. -Let’s explore how and why Rust encourages you to favor immutability and why -sometimes you might want to opt out. +Sebagaimana disinggung di bagian ["Menyimpan Nilai dengan +Variabel"][storing-values-with-variables], secara baku, +variabel itu immutable. Ini adalah satu dari banyak dorongan yang Rust berikan +kepada Anda untuk menulis kode dengan cara yang memanfaatkan keamanan dan +konkurensi mudah yang ditawarkan oleh Rust. Namun Anda masih punya pilihan +untuk membuat variabel Anda mutable. Mari kita eksplorasi bagaimana dan +mengapa Rust mendorong Anda agar lebih suka atas imutabilitas dan mengapa +kadang Anda perlu untuk tidak memilihnya. -When a variable is immutable, once a value is bound to a name, you can’t change -that value. To illustrate this, generate a new project called *variables* in -your *projects* directory by using `cargo new variables`. +Ketika suatu variabel immutable, sekali suatu nilai diikat ke sebuah nama, +Anda tidak bisa mengubah nilai tersebut. Untuk mengilustrasikan ini, buatlah +sebuah proyek baru bernama *variables* dalam direktori *projects* Anda dengan +memakai `cargo new variables`. -Then, in your new *variables* directory, open *src/main.rs* and replace its -code with the following code, which won’t compile just yet: +Lalu, dalam direktori *variables* baru Anda, buka *src/main.rs* dan ganti +kodenya dengan kode berikut, yang kini belum bisa dikompilasi: Filename: src/main.rs @@ -21,40 +23,46 @@ code with the following code, which won’t compile just yet: {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-01-variables-are-immutable/src/main.rs}} ``` -Save and run the program using `cargo run`. You should receive an error message -regarding an immutability error, as shown in this output: +Simpan dan jalankan program memakai `cargo run`. Anda mestinya memperoleh +pesan kesalahan terkait kesalahan imutabilitas, seperti ditunjukkan dalam +keluaran ini: ```console {{#include ../listings/ch03-common-programming-concepts/no-listing-01-variables-are-immutable/output.txt}} ``` -This example shows how the compiler helps you find errors in your programs. -Compiler errors can be frustrating, but really they only mean your program -isn’t safely doing what you want it to do yet; they do *not* mean that you’re -not a good programmer! Experienced Rustaceans still get compiler errors. - -You received the error message `` cannot assign twice to immutable variable `x` -`` because you tried to assign a second value to the immutable `x` variable. - -It’s important that we get compile-time errors when we attempt to change a -value that’s designated as immutable because this very situation can lead to -bugs. If one part of our code operates on the assumption that a value will -never change and another part of our code changes that value, it’s possible -that the first part of the code won’t do what it was designed to do. The cause -of this kind of bug can be difficult to track down after the fact, especially -when the second piece of code changes the value only *sometimes*. The Rust -compiler guarantees that when you state that a value won’t change, it really -won’t change, so you don’t have to keep track of it yourself. Your code is thus -easier to reason through. - -But mutability can be very useful, and can make code more convenient to write. -Although variables are immutable by default, you can make them mutable by -adding `mut` in front of the variable name as you did in [Chapter -2][storing-values-with-variables]. Adding `mut` also conveys -intent to future readers of the code by indicating that other parts of the code -will be changing this variable’s value. - -For example, let’s change *src/main.rs* to the following: +Contoh ini menunjukkan bagaimana compiler membantu Anda menemukan kesalahan +dalam program Anda. Kesalahan compiler bisa membuat frustrasi, tetapi +sebenarnya mereka hanya berarti bahwa program Anda belum secara aman +melakukan apa yang Anda ingin dia lakukan; mereka *bukan* berarti bahwa Anda +bukanlah programmer yang baik! Rustacean yang berpengalaman masih mendapat +kesalahan compiler. + +Anda menerima pesan kesalahan `` cannot assign twice to immutable variable `x` +`` karena Anda mencoba menugaskan suatu nilai kedua ke variabel `x` yang +immutable. + +Penting bahwa kita mendapat kesalahan saat compile ketika kita mencoba +mengubah suatu nilai yang ditugaskan sebagai immutable karena situasi seperti +ini dapat mengarah ke bug. Bila satu bagian dari kode kita beroperasi pada +asumsi bahwa suatu nilai tidak akan pernah berubah dan bagian lain dari kode +kita mengubah nilai tersebut, mungkin bahwa bagian pertama kode tidak akan +melakukan apa yang itu dirancang untuk melakukannya. Penyebab bug jenis ini +bisa sulit dilacak setelah fakta, khususnya ketika penggalan kedua kode +hanya *kadang-kadang* mengubah nilai. Compiler Rust menjamin bahwa ketika +Anda menyatakan bahwa suatu nilai tidak akan berubah, itu benar-benar tidak +akan berubah, sehingga Anda tidak perlu melacaknya sendiri. Maka kode Anda +lebih mudah dipahami. + +Tapi mutabilitas bisa sangat berguna, dan dapat membuat kode lebih nyaman +ditulis. Walaupun variabel secara default immutable, Anda dapat membuat mereka +mutable dengan menambahkan `mut` di depan nama variabel seperti yang telah +Anda lakukan dalam [Bab 2][storing-values-with-variables]. +Menambahkan `mut` juga menyampaikan maksud ke pembaca kode di masa depan +dengan mengindikasikan bahwa bagian lain dari kode akan mengubah nilai +variabel ini. + +Sebagai contoh, mari kita ubah *src/main.rs* menjadi yang berikut: Filename: src/main.rs @@ -62,74 +70,77 @@ For example, let’s change *src/main.rs* to the following: {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-02-adding-mut/src/main.rs}} ``` -When we run the program now, we get this: +Saat kita sekarang menjalankan program, kita memperoleh ini: ```console {{#include ../listings/ch03-common-programming-concepts/no-listing-02-adding-mut/output.txt}} ``` -We’re allowed to change the value bound to `x` from `5` to `6` when `mut` is -used. Ultimately, deciding whether to use mutability or not is up to you and -depends on what you think is clearest in that particular situation. +Kita diizinkan mengubah nilai yang diikat ke `x` dari `5` ke `6` ketika +`mut` dipakai. Pada akhirnya, menentukan apakah memakai mutabilitas atau +tidak terserah padamu dan tergantung kepada apa yang Anda pikir paling +jelas dalam situasi tersebut. -### Constants +### Konstanta -Like immutable variables, *constants* are values that are bound to a name and -are not allowed to change, but there are a few differences between constants -and variables. +Seperti variable yang immutable, *konstanta* adalah nilai-nilai yang terikat +ke suatu nama dan tidak diizinkan berubah, tapi ada beberapa perbedaan +antara konstanta dan variabel. -First, you aren’t allowed to use `mut` with constants. Constants aren’t just -immutable by default—they’re always immutable. You declare constants using the -`const` keyword instead of the `let` keyword, and the type of the value *must* -be annotated. We’ll cover types and type annotations in the next section, -[“Data Types”][data-types], so don’t worry about the details -right now. Just know that you must always annotate the type. +Pertama, Anda tidak diizinkan memakai `mut` dengan konstanta. Konstanta tidak +hanya sekadar immutable secara baku — mereka selalu immutable. Anda +mendeklarasikan konstanta memakai kata kunci `const` bukan kata kunci `let`, +dan tipe nilai *harus* dianotasikan. Kita akan membahas tipe dan anotasi tipe +dalam bagian selanjutnya, ["Tipe Data,"][data-types], jadi +jangan khawatir tentang detilnya sekarang. Ketahui saja bahwa Anda mesti selalu +menganotasi tipe. -Constants can be declared in any scope, including the global scope, which makes -them useful for values that many parts of code need to know about. +Konstanta dapat dideklarasikan dalam sebarang skup, termasuk skup global, yang +membuat mereka berguna untuk nilai-nilai yang banyak bagian kode perlu tahu +tentangnya. -The last difference is that constants may be set only to a constant expression, -not the result of a value that could only be computed at runtime. +Perbedaan terakhir adalah konstanta dapat diatur hanya ke suatu ekspresi +konstan, bukan hasil dari suatu nilai yang hanya dapat dihitung saat runtime. -Here’s an example of a constant declaration: +Ini adalah sebuah contoh dari deklarasi konstanta: ```rust const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3; ``` -The constant’s name is `THREE_HOURS_IN_SECONDS` and its value is set to the -result of multiplying 60 (the number of seconds in a minute) by 60 (the number -of minutes in an hour) by 3 (the number of hours we want to count in this -program). Rust’s naming convention for constants is to use all uppercase with -underscores between words. The compiler is able to evaluate a limited set of -operations at compile time, which lets us choose to write out this value in a -way that’s easier to understand and verify, rather than setting this constant -to the value 10,800. See the [Rust Reference’s section on constant -evaluation][const-eval] for more information on what operations can be used -when declaring constants. - -Constants are valid for the entire time a program runs, within the scope in -which they were declared. This property makes constants useful for values in -your application domain that multiple parts of the program might need to know -about, such as the maximum number of points any player of a game is allowed to -earn, or the speed of light. - -Naming hardcoded values used throughout your program as constants is useful in -conveying the meaning of that value to future maintainers of the code. It also -helps to have only one place in your code you would need to change if the -hardcoded value needed to be updated in the future. +Nama konstantanya adalah `THREE_HOURS_IN_SECONDS` dan nilainya diatur ke +hasil perkalian 60 (banyaknya detik dalam satu menit) dengan 60 (banyaknya +menit dalam satu jam) dengan 3 (banyaknya jam yang ingin kita hitung dalam +program ini). Konvensi penamaan Rust bagi konstanta adalah memakai huruf besar +dengan garis bawah antara kata. Compiler dapat mengevaluasi set operasi +terbatas saat compile, yang memungkinkan kita memilih menulis nilai ini dalam +suatu cara yang lebih mudah dipahami dan diverifikasi, daripada menata +konstanta ini ke nilai 10.800. Lihat [Bagian Referensi Rust tentang evaluasi +konstanta][const-eval] untuk informasi lebih banyak tentang operasi apa yang +dapat dipakai saat mendeklarasikan konstanta. + +Konstanta valid bagi seluruh waktu suatu program dijalankan, dalam skup +tempat mereka dideklarasikan. Properti ini membuat konstanta berguna untuk +nilai-nilai dalam domain aplikasi Anda yang berbagai bagian dari program +mungkin perlu tahu, seperti banyaknya maksimum nilai yang diizinkan diperoleh +seorang pemain, atau kecepatan cahaya. + +Menamai nilai-nilai ter-*hardcode* yang dipakai dalam seluruh program Anda +sebagai konstanta berguna dalam menyampaikan makna nilai itu ke pemelihara +kode di masa mendatang. Itu juga membantu agar hanya satu tempat dalam kode +Anda yang perlu diubah bila nilai ter-*hardcode* perlu diperbarui nanti. ### Shadowing -As you saw in the guessing game tutorial in [Chapter -2][comparing-the-guess-to-the-secret-number], you can declare a -new variable with the same name as a previous variable. Rustaceans say that the -first variable is *shadowed* by the second, which means that the second -variable is what the compiler will see when you use the name of the variable. -In effect, the second variable overshadows the first, taking any uses of the -variable name to itself until either it itself is shadowed or the scope ends. -We can shadow a variable by using the same variable’s name and repeating the -use of the `let` keyword as follows: +Sebagaimana Anda lihat dalam tutorial permainan tebakan dalam +[Bab 2][comparing-the-guess-to-the-secret-number], Anda dapat +mendeklarasikan suatu variabel baru dengan nama sama seperti variabel +sebelumnya. Rustacean mengatakan bahwa variabel pertama *di-shadow* oleh yang +kedua, yang berarti bahwa variabel kedua adalah yang akan dilihat oleh +compiler ketika Anda memakai nama variabel tersebut. Efeknya, variabel +kedua menutupi yang pertama, mengambil sebarang penggunaan dari nama variabel +ke dirinya sendiri dengan memakai nama variabel yang sama dan mengulangi +penggunaan kata kunci `let` sebagai berikut: Filename: src/main.rs @@ -137,52 +148,56 @@ use of the `let` keyword as follows: {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-03-shadowing/src/main.rs}} ``` -This program first binds `x` to a value of `5`. Then it creates a new variable -`x` by repeating `let x =`, taking the original value and adding `1` so the -value of `x` is then `6`. Then, within an inner scope created with the curly -brackets, the third `let` statement also shadows `x` and creates a new -variable, multiplying the previous value by `2` to give `x` a value of `12`. -When that scope is over, the inner shadowing ends and `x` returns to being `6`. -When we run this program, it will output the following: +Program ini pertama mengikat `x` ke suatu nilai `5`. Lalu itu membuat +sebuah variabel baru `x` dengan mengulangi `let x =`, mengambil nilai asli +dan menambahkan `1` sehingga nilai `x` lalu menjadi `6`. Kemudian, di dalam +skup dalam yang dibuat dengan kurung kurawal, pernyataan `let` ketiga juga +membayang `x` dan membuat sebuah variabel baru, mengalikan nilai sebelumnya +dengan `2` untuk menghasilkan suatu nilai `12`. Ketika skup itu berakhir, +bayang dalam berakhir dan `x` kembali menjadi `6`. Ketika kita menjalankan +program ini, itu akan mengeluarkan yang berikut: ```console {{#include ../listings/ch03-common-programming-concepts/no-listing-03-shadowing/output.txt}} ``` -Shadowing is different from marking a variable as `mut` because we’ll get a -compile-time error if we accidentally try to reassign to this variable without -using the `let` keyword. By using `let`, we can perform a few transformations -on a value but have the variable be immutable after those transformations have -been completed. +Shadowing berbeda dari menandai suatu variabel sebagai `mut` karena kita akan +memperoleh suatu galat saat compile bila kita secara tidak sengaja mencoba +menugaskan ulang ke variabel ini tanpa memakai kata kunci `let`. Dengan +memakai `let`, kita bisa melakukan beberapa transformasi pada suatu nilai +tapi memiliki variabel yang immutable setelah transformasi itu selesai. -The other difference between `mut` and shadowing is that because we’re -effectively creating a new variable when we use the `let` keyword again, we can -change the type of the value but reuse the same name. For example, say our -program asks a user to show how many spaces they want between some text by -inputting space characters, and then we want to store that input as a number: +Perbedaan lain antara `mut` dan shadowing adalah karena kita secara efektif +membuat sebuah variabel baru ketika kita memakai kata kunci `let` lagi, kita +dapat mengubah tipe nilai tapi memakai ulang nama yang sama. Misalnya, +katakanlah program kita meminta pengguna untuk menunjukkan berapa banyak spasi +yang mereka inginkan antara beberapa teks dengan memasukkan karakter spasi, +lalu kita ingin menyimpan masukan itu sebagai suatu bilangan: ```rust {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-04-shadowing-can-change-types/src/main.rs:here}} ``` -The first `spaces` variable is a string type and the second `spaces` variable -is a number type. Shadowing thus spares us from having to come up with -different names, such as `spaces_str` and `spaces_num`; instead, we can reuse -the simpler `spaces` name. However, if we try to use `mut` for this, as shown -here, we’ll get a compile-time error: +Variabel `spaces` pertama bertipe string dan variabel `spaces` kedua bertipe +angka. Maka *shadowing* membebaskan kita dari mencari nama lain, seperti +misalnya `spaces_str` dan `spaces_num`; sebagai gantinya, kita dapat memakai +ulang nama `spaces` yang lebih sederhana. Namun, bila kita mencoba memakai +`mut` untuk ini, seperti yang ditunjukkan di sini, kita akan memperoleh +kesalahan waktu compile: ```rust,ignore,does_not_compile {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-05-mut-cant-change-types/src/main.rs:here}} ``` -The error says we’re not allowed to mutate a variable’s type: +Kesalahannya mengatakan bahwa kita tidak diizinkan untuk memutasi suatu +tipe variabel: ```console {{#include ../listings/ch03-common-programming-concepts/no-listing-05-mut-cant-change-types/output.txt}} ``` -Now that we’ve explored how variables work, let’s look at more data types they -can have. +Kini setelah kita mengeksplorasi bagaimana variabel bekerja, mari kita +melihat lebih banyak tipe data yang dapat mereka miliki. [comparing-the-guess-to-the-secret-number]: ch02-00-guessing-game-tutorial.html#comparing-the-guess-to-the-secret-number