70 lines
1.6 KiB
Markdown
70 lines
1.6 KiB
Markdown
#Rust
|
|
|
|
The quick brown fox jumps over the lazy dog. The dog stays blissfully asleep. :)
|
|
|
|
# What is Chapter 3?
|
|
Chapter three is about common programming concepts that I would be familiar with
|
|
from other languages. This chapter covers variables, mutability, data types,
|
|
functions, comments, and control flow.
|
|
|
|
# 3.1 Variables and Mutability
|
|
## Variables
|
|
Rust defines variables kind of like C does:
|
|
```rust
|
|
let x = 7; // x is 7!
|
|
```
|
|
but Rust also allows explicit declaration of types when defining a variable:
|
|
|
|
```rust
|
|
let x: u32 = 7; // x is a 32 bit unsigned integer with value 7
|
|
let y: f32 = 7.0; // y is a 32 bit float with value of 7.0
|
|
```
|
|
|
|
Variables can be defined in specific scopes that do not escape the inner scope:
|
|
|
|
```rust
|
|
let x: u32 = 4;
|
|
{
|
|
let mut x = x;
|
|
x += 2;
|
|
}
|
|
|
|
println!("{x}")
|
|
>> 4 // NOT 6.
|
|
```
|
|
|
|
## Mutability
|
|
All variables in Rust are immutable unless specifically mentioned. This is
|
|
part of ensuring memory safety--you will not be able to overwrite variables
|
|
unless you declare that they can change over time. Here's an example:
|
|
|
|
```rust
|
|
let x: u32 = 2;
|
|
x += 2; // Will fail. x is not mutable
|
|
|
|
let mut y: u32 = 2;
|
|
y += 2; // Will work, since y is mutable
|
|
```
|
|
|
|
### Constants
|
|
Constants are a special case in Rust. They are immutable variables just like
|
|
`let`, but they have a special ability to be defined in the global scope,
|
|
where `let` may not be. Here's an example.
|
|
|
|
```rust
|
|
const TWO_PLUS_THREE: u32 = 2 + 3;
|
|
fn main() {
|
|
println!("{TWO_PLUS_THREE}");
|
|
}
|
|
>> 5
|
|
```
|
|
Constants are by convention written in UPPER_CAMEL_CASE.
|
|
|
|
# 3.2 Data Types
|
|
|
|
# 3.3 Functions
|
|
|
|
# 3.4 Comments
|
|
|
|
# 3.5 Control Flow
|