An Overview of Rust’s Built-In Data Types
Rust is a statically-typed modern programming language designed for performance, reliability, and security. As in other statically-typed languages, you declare Rust data types at compile time. This makes it easier to catch type errors before you run your code.
Rust offers scalar, compound, reference types, structs, enums, and strings. Its type inference provides functionality for writing concise code while maintaining the safety of a statically-typed language.
Integers in Rust
Rust provides signed and unsigned integer types classified based on the number of bits. The signed integer types arei8,i16,i32, andi64representing 8-bit, 16-bit, 32-bit, and 64-bit signed integers, respectively. It also supports unsigned integer types areu8,u16,u32, andu64, representing 8-bit, 16-bit, 32-bit, and 64-bit unsigned integers.
Rust uses thei32type for integer literals by default.
Rust Floating Point Types
Rust providesf32andf64as floating point types that represent single-precision and double-precision floating point numbers. Thef32type uses 32 bits to store values, and thef64type uses 64 bits.
Floating-point numbers in Rust follow the IEEE 754 standard for floating-point arithmetic.
Using Rust Booleans
Rust provides abooltype to representtrueorfalsevalues. Booleans are often used in conditional and control flow statements for program decision-making.
You can compare boolean values with the equality operator,==, and the inequality operator,!=. Rust does not define the comparison operators,<, >,<=,and>=, forboolvalues.
The Char Type
The Rustchartype represents a single Unicode scalar value that can represent any character inthe Unicode standard. You can specify acharvalue using single quotes.
Thechartype is helpful for working with emojis in Rust.
Tuples in Rust
The tuple data structure lets you group more than one value into a single compound value. These values can have the same type or different types. you may declare tuples by writing them as a comma-separated list of values surrounded by parentheses.
Here’s how you can declare a tuple with 32-bit integers, strings, and float64 values.
Tuples have a fixed length, and you can use them to return multiple values from a function or pass multiple values to functions as a single argument.
you could access individual elements of a tuple by destructuring it using pattern matching or directly accessing individual elements using dot (.) syntax and an index.
Here’s how you’re able to access individual elements of a struct using pattern matching:
Here’s how you can access individual elements using dot notation:
Tuples are very useful when grouping related data into a single value. They can also improve the readability of your code if you use them sparingly.
Arrays in Rust
An array is a collection of elements of the same type with a fixed length. You write Rust arrays as a square-bracketed list of values, separated by commas.
Here’s how you can declare arrays in Rust:
you could’t change the number of elements in an array once you have declared it, but you can access, modify, and manipulate individual elements of an array using indexing.
Rust Arrays arestored on the stackand have a contiguous memory allocation, so accessing elements of an array is fast and efficient. This makes arrays suitable for situations where you need to store and process many elements.
Working With Rust Slices
A slice is a data structure that allows referencing a contiguous sequence of elements in a collection. Slices are represented by the&[T]type, where T is the type of elements stored in the slice.
Notice how the range syntax,.., extracts a slice from an array using the starting index and an index one greater than the end:
Slices are dynamic, so Rust can determine their length at runtime. you could also pass slices as arguments to functions without needing heap allocation.
You’ll commonly use slices for string operations and to pass subsets of data to functions. They are a powerful and efficient tool for managing collections in Rust, providing a more flexible alternative to arrays.
You Can Build WebAssembly-Powered Frontend Web Apps in Rust
Knowledge of data types is pivotal to your Rust journey since you’ll use them for most operations while building applications.
WebAssembly is a low-level binary format that runs on modern web browsers, with near-native performance. It lets you write code in many different languages and transpiling it to WebAssembly.
WebAssembly is gaining adoption through Rust. There are many frameworks like Yew, Sycamore, and Seed that you can use to build WebAssembly-powered frontends with Rust.
Discover how to use the power and speed of WebAssembly from your Rust applications.
When your rival has to bail out your assistant.
Turn these settings on, and your iPhone will be so much better than before.
One casual AI chat exposed how vulnerable I was.
check that you don’t miss these movies and shows before Netflix removes them.
Tor spoiled me forever.
