Rust é uma linguagem de programação moderna de tipagem estática projetada para desempenho, confiabilidade e segurança. Como em outras linguagens de tipagem estática, você declara os tipos de dados Rust em tempo de compilação. Isso torna mais fácil detectar erros de tipo antes de executar seu código.
Rust oferece escalar, composto, tipos de referência, structs, enums e strings. Sua inferência de tipo fornece funcionalidade para escrever código conciso enquanto mantém a segurança de uma linguagem de tipagem estática.
Números inteiros em Rust
Rust fornece tipos inteiros assinados e não assinados classificados com base no número de bits. Os tipos inteiros assinados são i8, i16, i32, e i64 representando inteiros assinados de 8 bits, 16 bits, 32 bits e 64 bits, respectivamente. Ele também suporta tipos inteiros não assinados são u8, u16, u32, e u64, representando inteiros sem sinal de 8 bits, 16 bits, 32 bits e 64 bits.
// inteiros assinados
deixar a: i8 = -10;
deixar b: i16 = -2048;
deixar c: i32 = -2147483648;
deixar d: i64 = -9223372036854775808;
// inteiros sem sinal
deixar e: u8 = 255;
deixar f: u16 = 65535;
deixar g: u32 = 4294967295;
deixar h: u64 = 18446744073709551615;
Rust usa o i32 type para literais inteiros por padrão.
Tipos de ponto flutuante de ferrugem
A ferrugem fornece f32 e f64 como tipos de ponto flutuante que representam números de ponto flutuante de precisão simples e precisão dupla. O f32 tipo usa 32 bits para armazenar valores, e o f64 tipo usa 64 bits.
Os números de ponto flutuante em Rust seguem o padrão IEEE 754 para aritmética de ponto flutuante.
deixar um = 3.14159265358979323_f32;
deixar b = 2.718281828459045235_f64;
Usando Rust Booleanos
A ferrugem fornece um bool digite para representar verdadeiro ou falso valores. Os booleanos são freqüentemente usados em declarações de fluxo de controle e condicionais para a tomada de decisões do programa.
deixar variável_1: bool = verdadeiro;
deixar variável_2: bool = falso;
Você pode comparar valores booleanos com o operador de igualdade, ==, e o operador de desigualdade, !=. Rust não define os operadores de comparação, , <=, e >=, para bool valores.
deixar variável_1: bool = verdadeiro;
deixar variável_2: bool = falso;
se variável_1 == variável_2 {
println!("variável_1 é igual a variável_2");
} outrose variável_1 != variável_2 {
println!("variável_1 não é igual a variável_2");
}
O Tipo de Caráter
a ferrugem Caracteres type representa um único valor escalar Unicode que pode representar qualquer caractere em o padrão Unicode. Você pode especificar um Caracteres valor usando aspas simples.
// Declarando um valor char
deixar c = 'a';
O Caracteres type é útil para trabalhar com emojis no Rust.
Tuplas em Rust
A estrutura de dados da tupla permite agrupar mais de um valor em um único valor composto. Esses valores podem ter o mesmo tipo ou tipos diferentes. Você pode declarar tuplas escrevendo-as como uma lista de valores separados por vírgulas entre parênteses.
Veja como você pode declarar uma tupla com inteiros de 32 bits, strings e valores float64.
deixar tup: (i32, &str, f64) = (500, "Olá", 3.14);
As tuplas têm um comprimento fixo e você pode usá-las para retornar vários valores de uma função ou passar vários valores para funções como um único argumento.
Você pode acessar elementos individuais de uma tupla desestruturando-a usando correspondência de padrões ou acessando diretamente elementos individuais usando a sintaxe de ponto (.) e um índice.
Veja como você pode acessar elementos individuais de uma estrutura usando correspondência de padrões:
deixar minha_tupla = (10, "Olá Mundo!", falso);deixar (x, y, z) = minha_tupla;
println!("O primeiro elemento é: {}", x);
println!("O segundo elemento é: {}", y);
println!("O terceiro elemento é: {}", z);
Veja como você pode acessar elementos individuais usando a notação de ponto:
deixar minha_tupla = (10, "Olá Mundo!", falso);
println!("Oprimeiroelementoé: {}", minha_tupla.0);
println!("Osegundoelementoé: {}", minha_tupla.1);
println!("Oterceiroelementoé: {}", minha_tupla.2);
As tuplas são muito úteis ao agrupar dados relacionados em um único valor. Eles também podem melhorar a legibilidade do seu código se você usá-los com moderação.
Matrizes em Rust
Uma matriz é uma coleção de elementos do mesmo tipo com um comprimento fixo. Você escreve matrizes Rust como uma lista de valores entre colchetes, separados por vírgulas.
Veja como você pode declarar arrays em Rust:
deixar arr = [1, 2, 3, 4, 5];
Você não pode alterar o número de elementos em uma matriz depois de declará-la, mas pode acessar, modificar e manipular elementos individuais de uma matriz usando a indexação.
deixar mut minha_array = [1, 2, 3, 4, 5];// Acessando elementos
println!("Oprimeiroelementoé: {}", my_array[0]);// Modificando elementos
minha_array[0] = 100;
println!("Oprimeiroelementodepoismodificaçãoé: {}", my_array[0]);// Percorrendo um array e manipulando elementos
paraeuem 0..my_array.len() {
minha_array[i] *= 2;
}
// imprimindo o array
println!("A matriz após a manipulação: {:?}", meu_array);
Matrizes de ferrugem são armazenado na pilha e têm uma alocação de memória contígua, portanto, acessar elementos de uma matriz é rápido e eficiente. Isso torna os arrays adequados para situações em que você precisa armazenar e processar muitos elementos.
Trabalhando com fatias de ferrugem
Uma fatia é uma estrutura de dados que permite referenciar uma sequência contígua de elementos em uma coleção. As fatias são representadas pelo &[T] type, onde T é o tipo de elementos armazenados na fatia.
fn principal(){
// declara um array
deixar minha_matriz = [1, 2, 3, 4, 5];// cria uma fatia do array
deixar minha_fatia = &minha_array[1..3];
// imprime a fatia
println!("Fatiar: {:?}", minha_fatia);
}
Observe como a sintaxe de intervalo, .., extrai uma fatia de uma matriz usando o índice inicial e um índice maior que o final:
As fatias são dinâmicas, portanto, o Rust pode determinar seu comprimento em tempo de execução. Você também pode passar fatias como argumentos para funções sem precisar de alocação de heap.
Você normalmente usará fatias para operações de string e para passar subconjuntos de dados para funções. Eles são uma ferramenta poderosa e eficiente para gerenciar coleções em Rust, fornecendo uma alternativa mais flexível aos arrays.
Você pode criar aplicativos da Web front-end baseados em WebAssembly em Rust
O conhecimento dos tipos de dados é fundamental para sua jornada no Rust, pois você os usará para a maioria das operações durante a criação de aplicativos.
WebAssembly é um formato binário de baixo nível executado em navegadores da Web modernos, com desempenho quase nativo. Ele permite escrever código em vários idiomas diferentes e transpilá-lo para o WebAssembly.
O WebAssembly está sendo adotado por meio do Rust. Existem muitos frameworks como Yew, Sycamore e Seed que você pode usar para construir frontends baseados em WebAssembly com Rust.
