Basic Rust Interview Question

Question 1

What is Rust?

Answer 1

Rust is a general-purpose memory-safe high-performance systems programming language.

It enables developers to write correct and maintainable code.

Question 2

Why does Rust have high performance?

Answer 2

Rust has high performance because it compiles directly to native machine code.

Question 3

Why do Rust programs consume a small amount of memory?

Answer 3

Rust allocates the minimum amount of memory required for an operation and only does so when needed. Once the operation finishes, the memory is then deallocated.

Question 4

How can you use cargo to build and test Rust code?

Answer 4

To use cargo to build Rust code, the build command gets used:

Question 5

What kinds of programs can you write with Rust?

Answer 5

Using Rust, you can create web servers, command line programs, databases, audio plugins, text processors, operating systems, device drivers, and more.

Question 6

What is the difference between a Rust enum and struct?

Answer 6

While both enum and struct provide ways to encapsulate data, they do so in different ways:

A struct contains fields and every field in the struct is present at all times. This makes struct appropriate when you need to group data together and have access to all components of that data.

An enum contains variants in which a single variant gets represented at a time.

Question 7

Provide an example of an impl block in Rust

Answer 7

struct Number(i32);

impl Number {
pub fn new(n: i32) -> Self {
Self(n)
}
}

let five = Number::new(5);

Question 8

How do you create an infinite loop in Rust?

Answer 8

loop {
// …
}

Question 9

How can you mutate variables in Rust?

Answer 9

By default, all data in Rust is immutable and cannot get changed without being marked as mutable.

Using the mut keyword changes this behavior and allows changing (mutating) the data:

Question 10

What happens to borrowed data at the end of a Rust function?

Answer 10

When writing a function that borrows data, the borrowed data will remain available for use after the function ends.

This is because ownership of the data does not transfer when borrowed.

Question 11

What happens to owned data at the end of a Rust function?

Answer 11

When writing a function that takes ownership of data, the data gets dropped (deleted) at the end of a function.

Question 12

What does #[derive(Debug)] do in Rust?

Answer 12

Using #[derive(Debug)] allows a struct or enum to get printed with the debug formatting token {:?} in the println! and format! macros.

Question 13

What’s the difference between .unwrap() and .expect() in Rust?

Answer 13

Both .unwrap() and .expect() will trigger a panic if they execute.

.unwrap() triggers a thread panic and then displays the line number containing the call to .unwrap().

.expect() triggers a thread panic with a customized message, and then displays the line number containing the call to .expect().

Question 14

Why is the return keyword in Rust optional? Provide examples

Answer 14

The return keyword is optional in Rust because Rust is an expression-based language.

fn one() -> u32 {
1
}

Question 15

What is an example of a match expression in Rust?

Answer 15

This Rust match expression matches an Option.

When the Option contains Some, the data gets printed to the terminal. When the Option contains None, the message there is no number gets printed to the terminal.

let foo = Some(1);
match foo {
Some(n) => println!(“number is {n}”),
None => println!(“there is no number”),
}

Question 16

Can you assign the result of a Rust match expression to a variable binding?

Answer 16

Yes. Since match is an expression, assigning the result gets accomplished like this:

let t = true;
let one = match t {
true => 1,
false => 0,
};

Question 17

What happens if you add a new variant to a Rust enum without changing any other code?

Answer 17

Adding a new variant to an enum without changing any other code may trigger compiler errors elsewhere in the program.

Question 18

What Rust keyword will iterate through a collection?

Answer 18

Using the for will iterate through a collection:

let nums = vec![1, 2, 3];
for n in nums {
println!(“{n}”)
}

Question 19

. What Rust code would you write for printing information to the terminal?

Answer 19

println!(“hello world”);

Question 20

hat’s a Rust Vec and when would you use it?

Answer 20

A Vec is a linear collection of elements, with similarities to a dynamic array present in other languages.

You would use a Vec when you need to store elements in a defined order, or when you plan on iterating over the elements.