- Prefácio
- Como surgiu o Rust
- Pilares do Rust
- Tipos primitivos:
- Inteiros
- Testando os tipos - ESCALARES
- Testando os tipos - COMPOSTOS
- Erros comuns em linguagem de baixo nível
- Rust Playground -> Para você pegar o código da documentação e rodar direto no navegador.
- Surgiu como alternativa ao C e C++
Ao longo do tempo ela se tornou uma linguagem multi propósito
- Desenvolvimento Web
- Desenvolvimento de aplicativos
- Desenvolvimento nos sistemas operacionais
- Segurança
- Performance
- Concorrência
Ultimamente o Rust tem atendimento muito bem no Backend e Frontend.
Vários desenvolvedores com bastantes criações de respeito para a comunidade diz que o Rust vai ser bastante usado no futuro.
Os tipos primitivos em Rust são divididos em 2 categorias: Escalares e Compostos
- Representam um único valor contido dentro de uma escala conhecida.
- Permitem a comparação direta entre valores.
- inteiro (integer) ex:
5 - flutuante (floating point) ex:
42.1 - booleano (bool) ex:
true,false - caractere (chat) ex:
'a',Ω≈,'😒'
- Servem para agregar múltiplos valores.
- tupla (tuple) ex:
(5, true, 42.1,, 'a') - matriz (array) ex:
[1, 2, 3, 4, 5, 6]
| bits | signed | unsigned |
|---|---|---|
| 8 | i8 | u8 |
| 16 | i16 | u16 |
| 32 | i32 | u32 |
| 64 | i64 | u64 |
| 128 | i128 | u128 |
| arch | isize | usize |
range: -(2^n-1) até ((2^n-1)-1) i8: -128 até 127 [-(2^7) até ((2^7)-1)]
range: 0 até ((2^n)-1) u8: 0 até 255 [0 até ((2ˆ8)-1)]
- Abaixo o Rust não vai deixar passar pelo problema de overflow, que seria colocar um valor onde ele não "cabe". O tipo u8 não suporta o valor de x * 200.
5 * 200 = 1000
fn main() {
let x: u8 = 5;
let y: u8 = x * 200;
}-
Rust facilita na hora de criar números para ficar visível. Com isso você consegue deixar visível qual o valor que esta ali. Método comum utilizado é você trocar o "." pelas "_".
- O "_" vai ser ignorado pelo Rust, é como se ele não existisse.
fn main() {
let x = 5;
let y = 1_193_123_000
}-
Rust nos permite colocar inteiros que estão em outras bases.
-
h = Hexadecimal
-
o = Octal
-
b = Binário
-
by = Byte
fn main() {
let h = 0xff;
let o = 0o77;
let b = 0b111_000;
let by = b'A';- Rust nos permite colocar os Floats.
fn main() {
let x:f64 = 42.11;
let y:f32 = 42.1;
}- Rust nos permite colocar os Booleans.
fn main() {
let x = true;
let y = false;
}- Rust nos permite colocas os character. Ele nos permite criar até 4 bytes dentro da tabela unicode. O Rust vai nos permitir utilizar símbolos, como por exemplo emojis. Observação importante no tipo character é necessário utilizar aspas simples
'🥲'.
fn main() {
let letra1: char = 'a';
let letra2 = 'b';
let emoji1 = '🥲';
}-
O mais importante tipo composto do Rusto é a
TUPLA. A Tupla é um tipo que tem um tamanho fixo de elementos dentro dela. Uma outra característica é que ela tem a tipagem Heterogênea, ela permite que tenhamos elementos de mais de um tipo misturados dentro de uma única tupla. -
Uma tupla assim criada com 3 valores, você não pode alterar o tamanho dela, ela sempre vai precisar ter a mesma estrutura.
fn main() {
let numbers = (1, 2, 3);
// durante a inferência o rust vai criar um tipo assim:
// let numbers: (i32, i32, i32) = (1, 2, 3)
println!("{:?}", numbers);
// pegando um elemento dentro da tupla
println!("{:?}", numbers.0);
println!("{:?}", numbers.2);
println!("{:?}", numbers.1);
}- Uma coisa interessante das tuplas é o fato delas poderem ser desestruturadas através do pattern match. Isso é bastante util quando o assunto é retorno de funções.
fn main() {
let numbers = (1, 2, 3);
let (a, b, c) = numbers;
// isso ficaria assim
// a = 1
// b = 2
// c = 3
println!("{:?}", a);
println!("{:?}", b);
println!("{:?}", c);
}- Apesar da tupla ser de tamanho e tipos fixos, ela pode ser mutável.
fn main() {
let mut numbers = (1, 2, 3);
numbers.0 = 50;
println!("{:?}", numbers);
// usando o pattern match podemos mudar a tupla inteira
// lembrando que precisa estar no mesmo tipo de
// dos elementos e a mesma quantidade
numbers = (45, 90, 100);
println!("{:?}", numbers);
}- A diferença no
arraypara atuplaé que noarraynão aceita tipos diferentes dentro do mesmo objeto.
fn main() {
let numbers = [1, 2, 3];
// a inferência que o Rust faz nesse let é assim
// let numbers: [i32;3] = [1, 2, 3]
// no tipo a gente passa o array com o tipo e a quantidade de elementos dentro dele
println!("{:?}", numbers);
// acessando o valor do array
println!("{}", numbers[0]);
println!("{}", numbers[1]);
println!("{}", numbers[2]);
}- Podemos fazer o array mutável
fn main() {
let mut numbers = [4, 5, 6];
println!("{:?}", numbers);
numbers = [10, 20, 30];
println!("{:?}", numbers);
numbers[0] = 50;
println!("{}", numbers[0]);
}- Estou tentando pegar um elemento na posição
3mas so temos as posições0,1,2. Assim tomamos oOut of Bound Error. Esse erro acontece na compilação e não na execução.
fn main() {
let numbers = [1.1, 2.0, 3.3];
println!("{:?}", numbers[3]);
}- Existe um comando que podemos rodar chamado slice para poder pegar apenas uma parte desse array.
fn main() {
let numbers = [1, 2, 3];
println!("{:?}", &numbers[1..3]); // output -> [2, 3]
}- Com o mesmo comando podemos omitir partes desse array passando apenas onde vai começar e ele vai até o final.
fn main() {
let numbers = [1, 2, 3];
println!("{:?}", &numbers[1..]); // output -> [2, 3]
}