Rust by Example | страница 9
or by default. Integers default to i32 and floats to f64. Note that Rust can also infer types from context.
>fn main() {
>// Variables can be type annotated.
>let logical: bool = true;
>let a_float: f64 = 1.0; // Regular annotation
>let an_integer = 5i32; // Suffix annotation
>// Or a default will be used.
>let default_float = 3.0; // `f64`
>let default_integer = 7; // `i32`
>// A type can also be inferred from context
>let mut inferred_type = 12; // Type i64 is inferred from another line
>inferred_type = 4294967296i64;
>// A mutable variable's value can be changed.
>let mut mutable = 12; // Mutable `i32`
>mutable = 21;
>// Error! The type of a variable can't be changed.
>mutable = true;
>// Variables can be overwritten with shadowing.
>let mutable = true;
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Integers 1, floats 1.2, characters 'a', strings "abc", booleans true and the unit type () can be expressed using literals.
Integers can, alternatively, be expressed using hexadecimal, octal or binary notation using these prefixes respectively: 0x, 0o or 0b.
Underscores can be inserted in numeric literals to improve readability, e.g. 1_000 is the same as 1000, and 0.000_001 is the same as 0.000001.
We need to tell the compiler the type of the literals we use. For now, we'll use the u32 suffix to indicate that the literal is an unsigned 32-bit integer, and the i32 suffix to indicate that it's a signed 32-bit integer.
The operators available and their precedence in Rust are similar to other C-like languages.
>fn main() {
>// Integer addition
>println!("1 + 2 = {}", 1u32 + 2);
>// Integer subtraction
>println!("1 - 2 = {}", 1i32 - 2);
>// TODO ^ Try changing `1i32` to `1u32` to see why the type is important
>// Short-circuiting boolean logic
>println!("true AND false is {}", true && false);
>println!("true OR false is {}", true || false);
>println!("NOT true is {}", !true);
>// Bitwise operations