I'm writing this while learning Rust, so everything I write here is the basic things someone starting to learn Rust should know. So let's start with some history.
Rust History
Graydon Hoare, a Research employee at Mozilla started Rust as a personal project in the year 2006. Then later, Mozilla began sponsoring the project in 2009 as a part of the ongoing development of an experimental browser engine called Servo, which was announced in 2010.
The first release was on May 15th, 2015.
List of Basic Rust Knowledge
- The main function is the beginning of every Rust program.
fn main(){
//Dont do this
let x = 5;
println!(x);
//This will throw an error.
//Do this instead.
println!("{}", 1);
// or
println!("{}", x);
//Output is 1 or 5 for the variables x.
}
- These
{}are calledplaceholdersin Rust.
- In Rust, Positional Arguments specify the position of a value in a string. In positional arguments, each value is assigned a number based on the order of occurrence. So in the example, the first value is assigned 0, and the next is 1, so in a case where we value a third value, we will put 3 inside the placeholder if we want to display that data. Note that this is not a Named Argument.
fn main(){
println!("Becoming the in the {0} is very important. So be {1}.", "industry", "patient");
//output
// Becoming the in the industry is very important. So be patient.
}
- Named Arguments take a name that stores a value. It is like declaring a variable to accumulate a value (string or numbers). So it works by specifying a name within the placeholder and assigning that name to a value to be inserted inside the string in the placeholder then displaying the output.
fn main(){
println!("{blog_name} provides {type} needed.", blog_name="devBox", type="informations");
//output
//devBox provides informations needed.
}
- Placeholders in Rust have different ways to print out data for the console or users. The placeholder used for converting values to binary, hexadecimal, and octal is called Placeholder Traits and is in these formats "Binary
{:b}, Hexadecimal{:x}, Octal{:o}. Then we have a placeholder format fordebugging, which is called Debug Trait. And with it, it is possible to display multiple values to the console using a placeholder with a colon followed by a question mark{:?}.
- Showing or printing a statement to the terminal in Rust is done using macros,
print! (), which prints strings to the console.println!(), prints strings to the console but appends a new line character at the end of the string.eprint!(), prints any string inside the parentheses as an error. And the last one,eprintln!(), prints string as errors but also appends a new line character at the end.
fn main(){
//---print!()---
//The following example prints “Rust Programming is fun, right?John is coding in Rust, cool right?” in one line.
print!("Rust Programming is fun, right?");
print!("John is coding in Rust, cool right?");
//output Rust Programming is fun, right?John is coding in Rust, cool right? -- same line
// ---println!()---
//The following example prints “Rust Programming is fun, right?” on one line and “"John is coding in Rust, cool right?” on the new line.
println!("Rust Programming is fun, right?");
println!("John is coding in Rust, cool right?");
/*
output:
Rust Programming is fun, right? --line
John is coding in Rust, cool right? --another line
*/
//---eprint!()---
//The following example prints “Rust Programming is fun, right?” and “John is coding in Rust, cool right?” on the same line but as an error.
eprint!("Rust Programming is fun, right?");
eprint!("John is coding in Rust, cool right?");
//output Rust Programming is fun, right?John is coding in Rust, cool right? -- same line
// ---eprintln!()---
//The following example prints “Rust Programming is fun, right?” as an error and appends a new line to it. Then prints “John is coding in Rust, cool right?” and appends a new line.
println!("Rust Programming is fun, right?");
println!("John is coding in Rust, cool right?");
/*
output as errors:
Rust Programming is fun, right? --line
John is coding in Rust, cool right? --another line
*/
}
- Comments are readable instructions that help explain codes. But note that the compiler ignores them. Rust has three types of comment; two are commonly used. These comments are the Line Comments
//, Block Comments/**/and Doc Comments. Now the Doc Comments has a sub-type called Outer Doc Comments///and Inner Doc Comments//!
/// Outer Doc Comment
fn main() {
// Line Comments
//Example:
//let mut x = 5;
/*
Block Comment
Example:
You can use the block comment when you want to disable a lengthy blocks of code
let mut x = 5;
*/
//! Inner Doc Comments
}
- The Character in Rust, known as
char, is used to store a single alphabet, emojis, or Korean characters. And The value assigned to a char variable is enclosed in a single quote''. But note that, unlike some other languages, a character in Rust takes up 4 bytes rather than a single byte. It does so because it can store a lot more than just an ASCII value like emojis, Korean, Chinese, and Japanese characters.
fn main(){
let char_letter = 'a';
println!("{}", char_letter)
// output: a
}
Concept to Know
Variables and Mutability:
- In Rust, variables are immutable by default, meaning their values cannot be changed once assigned. To create a mutable variable, you need to use the
mutkeyword.
fn main() {
let x = 5; // Immutable variable
let mut y = 10; // Mutable variable
y = 15; // Updating the value of a mutable variable
println!("x: {}, y: {}", x, y);
// output: x: 5, y: 15
}
Data Types:
- Rust is a statically-typed language, meaning you need to declare the type of each variable. Rust provides various built-in data types, including integers, floating-point numbers, booleans, characters, and more.
fn main() {
let number: i32 = 42; // Signed 32-bit integer
let pi: f64 = 3.14; // 64-bit floating-point number
let is_true: bool = true; // Boolean
let letter: char = 'A'; // Character
println!("Number: {}, Pi: {}, Is True: {}, Letter: {}", number, pi, is_true, letter);
// output: Number: 42, Pi: 3.14, Is True: true
}
Control Flow:
- Rust offers control flow structures like if-else, loops, and match expressions.
fn main() {
let number = 7;
// if/ if else/ else
if number < 5 {
println!("Number is less than 5");
} else if number == 5 {
println!("Number is equal to 5");
} else {
println!("Number is greater than 5");
}
// Loop
let mut counter = 0;
loop {
println!("Counter: {}", counter);
counter += 1;
if counter >= 5 {
break;
}
}
//
// match @desc this is Unqiue to Rust.
let day = 3;
match day {
1 => println!("Monday"),
2 => println!("Tuesday"),
3 => println!("Wednesday"),
_ => println!("Other day"),
}
}
Match:
- The
matchexpression in Rust is a powerful construct that allows you to compare the value of an expression against a series of patterns and execute different codes based on the pattern that matches. It's similar to a switch statement in other programming languages but provides more flexibility and exhaustive pattern matching.
fn main() {
let number = 5;
match number {
1 => println!("Number is 1"),
2 | 3 | 4 => println!("Number is 2, 3, or 4"),
5..=10 => println!("Number is between 5 and 10 (inclusive)"),
_ => println!("Number doesn't match any pattern"),
}
}
Functions:
- Functions in Rust are defined using the
fnkeyword. You can specify the function's parameters and return type.
fn add_numbers(a: i32, b: i32) -> i32 {
return a + b;
}
fn main() {
let result = add_numbers(3, 4);
println!("Result: {}", result);
// output: Result: 7
}
Ownership and Borrowing:
- Rust's ownership system ensures memory safety without the need for a garbage collector. It prevents issues like data races and dangling pointers. Rust follows the ownership, borrowing, and lifetimes concepts to manage memory.
fn main() {
let s1 = String::from("hello"); // s1 owns the string "hello"
let s2 = s1; // s2 takes ownership of the string, s1 is invalidated
println!("{}", s2); // s2 can be used
// output: hello
let s3 = String::from("world");
let s4 = &s3; // s4 borrows a reference to s3 and s3 is not invalidated
println!("{}", s4); // s4 can be used, but s3 is still valid
// output: world
}
Conclusion
These are just a few basic concepts in Rust to get you started. Rust is a rich language with many more features and concepts to explore. Happy learning!