Rust

Install Rust

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

Update Rust

rustup update

Create new project

cargo new myappcd myappcargo run

Compile and run

rustc src/test.rscargo build

cargo run (will compile and run main.rs)

build release bin

cargo build --releaseremove libscargo cleanshow all installed libscargo --list

Conditionals

if / else

fn main() { let n = 5;
if n < 0 { print!("{} is negative", n); } else if n > 0 { print!("{} is positive", n); } else { print!("{} is zero", n); }}

AND, OR

if n < 10 && n > 10
if n < 10 || n > 5

IF NOT

if ! name = "Frank"
if name != "Frank"

User Input

pass value of user input to &mut guess = Reference object

use std::io;fn main {
let mut guess String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}

Dependencies

install cargo pkgs

vi Cargo.toml
[dependencies]
rand = "0.8.3"

cargo build

Update dependencies
cargo update

Strings

convert string literal to String object

let mut name = String::new()
let name = "joe".to_string()

remote whitespace

let mut name = String::from(" hello");
println!("{name}");
name = name.trim().to_string();
println!("{name}");>> hello
hello

print variables

println!("pattern: {:?}, path: {:?}", args.pattern, args.path);

Booleans

let t = true;

let f: bool = false;

Functions

func with return type

fn calculate_length(s: &String) -> i32 {
do stuff
return 10
}

Structs

declare new struct

struct User { active: bool, username: String, email: String, sign_in_count: u64,}

init the struct

fn main() { let user1 = User { active: true, username: String::from("someusername123"), email: String::from("someone@example.com"), sign_in_count: 1, };}println!("user email is {}", user1.email);

struct builder function

fn build_user(email: String, username: String) -> User { User { active: true, username, email, sign_in_count: 1, }}

Tuple Structs (no field names)

struct Color(i32, i32, i32);struct Point(i32, i32, i32);
fn main() { let black = Color(0, 0, 0); let origin = Point(0, 0, 0);}

add debug to Struct

#[derive(Debug)]struct Rectangle {    width: u32,    height: u32,}
fn main() {    let rect1 = Rectangle {        width: 30,        height: 50,    };
    println!("rect1 is {rect1:?}");}

Variables

new mutable string

let mut name = String::new();
name = "Joe";
name = "Frank";

Data Types

bool
char
f32,f64 // 32bit, 64bit float
i8,i16,i32,i64,i128 // signed int
i8 = -127 to 127
i16 =
u8,u16,u32,u64,u128 //unsigned 0 to 255, no negative

Object reference

let s1 = String::from("hello");let len = calculate_length(&s1);

len is reference to value of s1, no ownership

Integers

signed/unsigned integers (signed can be negative)

8 bit = i8 (-127 to 127), u8 (0 to 255)
16 bit = i16 (, u16 (-
32 bit = i32, u32
64 bit = i64, u64
128 bit = i128, u128
arch = isize, usize

floating point
f32, f64 (f64 is default)
let number = 2.0;

Tuple (can be mix of types, fixed length)

let tup: (i32, f64, u8) = (500, 6.4, 1);
access tuple value by indexlet x = (500, 32, 55, 100)println!("{:?}", x.0);
>> 500

Arrays (same type, fixed lenth)

faster than Vector, sits on stack not heap

declare type + size of arraylet a: [i32; 5] = [1, 2, 3, 4, 5];

access element of array

let a = [1,2,3,4,5];let idx = 3;println!("{}", a[idx]);

convert String to Int

let mut guess = String::new();
guess = "23"

Math operationsfn main() {

let sum = 5 + 10; // addition
let difference = 95.5 - 4.3;   // subtraction
let product = 4 * 30;   // multiplication
let quotient = 56.7 / 32.2;   // division
let floored = 2 / 3; // Results in 0
let remainder = 43 % 5;   // remainder
}
Generate random # from 1-100
use rand::Rng
let secret: i32 = rand::thread_rng().gen_range(1..=100);

Conditionals / For Loops

infinite loop

loop {
println!("stuff");
}

Page updated

Google Sites

Report abuse