Esses são valores booleanos comuns que podem ser verdadeiros ou falsos.

personagem

Este tipo é caracterizado pela largura de bits. O comprimento máximo suportado pelo Rust é 128 bits.

Um inteiro assinado de tamanho variável (o tamanho depende do tamanho do ponteiro subjacente).

Inteiro não assinado de tamanho variável (o tamanho depende do tamanho do ponteiro subjacente).

tipo de ponto flutuante f32 bits

tipo de ponto flutuante f64 bits

Uma matriz de tamanho fixo, T representa o tipo de elemento, N representa o número de elementos e é uma constante não negativa em tempo de compilação.

Uma visualização dimensionada dinamicamente de uma sequência contígua, T representando qualquer tipo.

Fatiamento de strings, usado principalmente como referência, ou seja, &str

Sequências finitas, T e U podem ser de tipos diferentes.

Uma função que recebe um parâmetro de tipo i32 e retorna um parâmetro de tipo i32. As funções também possuem um tipo.

fn adicionar (a: u64, b: u64) -> u64 { um b } fn principal() { seja a: u64 = 17; seja b = 3; deixe resultado = adicionar (a, b); println!("Resultado {}", resultado); }

fn principal() { deixe duplicador = |x| deixe valor = 5; deixe duas vezes = doubler(valor); println!("{} dobrado é {}", valor, duas vezes); deixe big_closure = |b, c| seja z = b c; z * duas vezes }; deixe algum_número = big_closure(1, 2); println!("Resultado do fechamento: {}", some_number); }

fn principal() { deixe pergunta = "Como você está?"; deixe pessoa: String = "Bob".to_string(); deixe namaste = String::from("zd"); println!("{}! {} {}", nome, pergunta, pessoa); }

No código acima, o tipo de pessoa e namaste é String, e o tipo de pergunta é &str. Existem muitas maneiras de criar dados do tipo String. Os dados do tipo string são alocados no heap. Os dados do tipo &str geralmente são um ponteiro para uma string existente. Essas strings estão na pilha e no heap ou podem ser strings no segmento de dados do código do objeto compilado.

fn principal() { deixe ferrugem_is_awesome = verdadeiro; se ferrugem_é_incrível { println!("De fato"); } outro { println!("Bem, você deveria tentar Rust!"); } }

fn principal() { deixe resultado = se 1 == 2 { "Espere o que?" } outro { "A ferrugem faz sentido" }; println!("Quer saber? {}.", resultado); }

Quando o valor a ser atribuído é retornado da expressão if else, precisamos usar um ponto e vírgula como marca final. Por exemplo, if é uma expressão, então let é uma instrução que espera que tenhamos um ponto e vírgula no final.

fn req_status() -> u32 { 200 } fn principal() { deixe status = req_status(); status da correspondência { 200 => println!("Sucesso"), 404 => println!("Não encontrado"), outro => { println!("Solicitação falhou com código: {}", outro); } } }

fn principal() { seja mut x = 1024; laço { se x < 0 { quebrar; } println!("{} mais corridas pela frente", x); x-= 1; } }

fn bobo_sub(a: i32, b: i32) -> i32 { deixe mut resultado = 0; 'incremento: loop { se resultado == a { deixe mut dec = b; 'decremento: loop { ifdec==0{ quebrar 'incremento; } outro { resultado -= 1; dezembro -= 1; } } } outro { resultado = 1; } } resultado } fn principal() { seja a = 10; seja b = 4; deixe resultado = bobo_sub(a, b); println!("{} menos {} é {}", a, b, resultado); }

fn principal() { print!("Intervalo normal: "); para eu em 0..10 { imprimir!("{},", eu); } imprimir!(); print!("Intervalo inclusivo: "); para eu em 0..=10 { imprimir!("(),", eu); } }

No Rust, existem três formas de declaração de estrutura. A mais simples delas é a unit struct, que é declarada usando a palavra-chave struct, seguida de seu nome e terminando com ponto e vírgula.

A segunda forma de estrutura é a estrutura de tupla, que possui dados associados. Cada um desses campos não é nomeado, mas é referenciado com base na sua posição na definição.

As estruturas de tupla são ideais para modelar dados com menos de 5 atributos. Qualquer escolha diferente dessa prejudicará a legibilidade e o raciocínio do código. Para tipos de dados com mais de 3 campos, construa estruturas usando linguagem semelhante a C. Esta é a terceira forma e a mais comumente usada.

As enumerações são uma boa maneira de fazer isso quando você precisa modelar diferentes tipos de coisas. Ele é criado usando a palavra-chave enum, seguida pelo nome da enumeração e um par de chaves. Dentro das chaves podemos escrever todos os tipos possíveis, ou seja, variantes. Essas variantes podem ser definidas com ou sem dados, e os dados contidos podem ser de qualquer tipo, estrutura, estrutura de tupla ou até mesmo um tipo de enumeração.

Podemos adicionar comportamento a uma estrutura definida usando dois mecanismos: funções semelhantes a construtores e métodos getter e setter.

As enumerações são amplamente utilizadas em máquinas de estado e, quando usadas com expressões de correspondência, podem tornar o código de transição de estado muito conciso. Eles também podem ser usados ​​para modelagem de tipos de erros personalizados.

Todo programa Rust requer um módulo raiz. Para arquivos executáveis, geralmente é o arquivo main.rs, e para bibliotecas, geralmente é o arquivo lib.rs.

Os módulos podem ser declarados dentro de outros módulos ou organizados em arquivos e diretórios.

Para que o compilador reconheça nosso módulo, precisamos usar a palavra-chave mod declaração. Em nosso módulo raiz, precisamos usar a palavra-chave use antes do nome do módulo, o que significa trazer o elemento para o escopo.

Os elementos definidos em um módulo são privados por padrão e precisam ser expostos aos chamadores usando a palavra-chave pub.

Os arrays têm comprimento fixo e podem armazenar elementos do mesmo tipo. Eles são representados por [T, N], onde T representa qualquer tipo e N representa o número de elementos do array. O tamanho do array não pode ser representado por uma variável e deve ser um valor literal de usize.

sub tópico