Diretório de artigos
Variáveis e Variabilidade
As variáveis são declaradas usando a palavra-chave let.Por padrão, as variáveis são imutáveis (Immutable). Ao declarar uma variável, adicione mut na frente da variável para torná-la mutável.
fn main() {
println!("Hello, world!");
let mut x = 5;
println!("The value of x is {}",x);
x = 6;
println!("The value of x is {}",x);
}
Variáveis e Constantes
Constante (constante), a constante também é imutável após vincular o valor, mas tem muitas diferenças em relação à variável imutável:
- mut não pode ser usado, as constantes são sempre imutáveis;
- A declaração de uma constante usa a palavra-chave const e seu tipo deve ser marcado;
- As constantes podem ser declaradas em qualquer escopo, incluindo o escopo global;
- As constantes só podem ser vinculadas a expressões constantes, não ao resultado de uma chamada de função ou a um valor que só pode ser calculado em tempo de execução.
As constantes permanecem válidas dentro do escopo em que são declaradas durante a execução do programa. Convenção de nomenclatura: Constantes em Rust usam todas as letras maiúsculas, cada letra é separada por um sublinhado, por exemplo: MAX_POINTS.
const MAX_POINTS:u32 = 100_000;
sombreamento
Você pode declarar uma nova variável com o mesmo nome, e a nova variável irá sombrear (ocultar) a variável declarada anteriormente com o mesmo nome.No código subseqüente, este nome de variável representa a nova variável.
Shadow não é o mesmo que marcar uma variável como mut: se a palavra-chave let não for usada, a reatribuição a uma variável não-mut causará um erro de tempo de compilação; e uma nova variável com o mesmo nome declarada usando let também é imutável. Use let para declarar uma nova variável com o mesmo nome, que pode ser de um tipo diferente do anterior.
let space= " ";
let space = space.len();
tipo de dados
Rust é uma linguagem compilada estaticamente e os tipos de todas as variáveis devem ser conhecidos em tempo de compilação. Com base no valor usado, o compilador geralmente é capaz de inferir seu tipo concreto. Mas se houver muitos tipos possíveis (como o método parse para converter String em inteiro), você deve adicionar anotações de tipo, caso contrário, um erro será relatado.
tipo escalar
Um tipo escalar representa um único valor.Rust tem quatro tipos escalares principais: tipos inteiros, tipos de ponto flutuante, tipos booleanos e tipos de caracteres.
1. Tipo inteiro
Tipos inteiros não possuem parte fracionária. Por exemplo, u32 é um tipo inteiro sem sinal, ocupando 32 bits de espaço. Inteiros sem sinal começam com u e inteiros com sinal começam com i. A lista de tipos inteiros de ferrugem é a seguinte:
Cada um é dividido em i e u, e um número fixo de dígitos. Faixa com sinal: -2 n-1 a 2 n-1 -1. Intervalo sem sinal: 0 a 2n - 1.
O número de bits dos tipos isize e usize é determinado pela arquitetura do computador no qual o programa está sendo executado: se for um computador de 64 bits, é de 64 bits. O cenário principal para usar isize ou usize é indexar algum tipo de coleção.
O valor literal de um inteiro é mostrado na figura:
Um sufixo de tipo é permitido para todos os literais numéricos, exceto o tipo de byte. Se você não tem certeza de qual tipo usar, pode usar o tipo padrão correspondente do Rust: o tipo padrão para inteiros é i32, que geralmente é rápido, mesmo em sistemas de 64 bits.
Estouro de número inteiro: Por exemplo, o intervalo de u8 é 0 a 255. Se você definir o valor de uma variável u8 como 256 e, em seguida, compilar no modo de depuração, o Rust verificará o estouro de número inteiro e o programa entrará em pânico durante a execução; no lançamento mode (–release ), o Rust não verificará o estouro de número inteiro que pode causar um pânico, se o estouro ocorrer, o Rust executará uma operação de contorno, 256 torna-se 0, 257 torna-se 1, mas o programa não entrará em pânico.
2. Tipo de ponto flutuante
Rust tem dois tipos básicos de ponto flutuante, ou seja, tipos com partes fracionárias.
- f32, 32 bits, precisão simples
- f64, 64 bits, precisão dupla
Os tipos de ponto flutuante de Rust são expressos usando o padrão IEEE-754, e f64 é o tipo padrão porque f64 tem aproximadamente a mesma velocidade que f32 em CPUs modernas e tem maior precisão.
3. Tipo booleano
O tipo booleano de Rust também possui dois valores: true e false. Tamanho de um byte, o símbolo é bool.
4. Tipo de personagem
O tipo char na linguagem Rust é usado para descrever o caractere único mais básico da linguagem. O valor literal do tipo de caractere usa aspas simples e ocupa 4 bytes. É um valor escalar Unicode e pode representar muito mais conteúdo de caracteres do que ASCII: Pinyin, chinês, japonês e coreano, caracteres em branco de comprimento zero, expressões emoji etc. . Os valores escalares Unicode variam de U+0000 a U+D7FF e de U+E000 a U+10FFFF. Mas não há conceito de caracteres em Unicode, então os caracteres intuitivos podem não corresponder ao conceito em Rust.
tipo composto
Os tipos compostos permitem que vários valores estejam contidos em um único tipo. Rust fornece dois tipos básicos de composição: tuplas e arrays.
1. Tupla
A tupla pode colocar vários valores de vários tipos em um tipo. O comprimento da tupla é fixo e não pode ser alterado depois de declarado. Você pode usar a correspondência de padrões para desestruturar uma Tupla para obter os valores de seus elementos.
let tup: (i32, f64, u8)=(100, 6.4, 1);
println!("{},{},{}", tup.0, tup.1, tup.2);
let (x, y, z) = tup;
println!("{},{},{}", x, y, z);
2. Matriz
Os arrays também podem armazenar vários valores em um tipo, e cada elemento do array deve ser do mesmo tipo. Se você deseja que seus dados sejam armazenados na pilha (stack) ao invés do heap (heap), ou se deseja garantir um número fixo de elementos, é mais vantajoso utilizar um array neste momento. Uma matriz é um único bloco de memória alocado na pilha e um índice pode ser usado para acessar os elementos da matriz. Se o índice acessado exceder o intervalo do array, a compilação passará e o runtime relatará um erro (o runtime entrará em pânico) e o Rust não permitirá que ele continue acessando a memória no endereço correspondente.
let a: [i32; 5]=[1, 2, 3, 4, 5];
println!("{},{},{}", a[1], a[2], a[3]);
função
Para declarar uma função, use a palavra-chave fn. Por convenção, para nomes de funções e variáveis, Rust usa a convenção de nomenclatura de maiúsculas e minúsculas. Todas as letras são minúsculas e as palavras são separadas por sublinhados.
fn main() {
another_function();
}
fn another_function() {
println!("Another function")
}
Se houver parâmetros, o tipo de cada parâmetro deve ser declarado.
fn main() {
another_function(5);
}
fn another_function(x:i32) {
println!("The value of x is:{}", x);
}
Uma função consiste em uma série de instruções, opcionalmente terminadas por uma expressão. Rust é uma linguagem baseada em expressões. Uma instrução é uma instrução para executar alguma ação e uma expressão é avaliada como um valor. A definição de uma função também é uma declaração e a declaração não retorna um valor, então você não pode usar let para atribuir uma declaração a uma variável.
fn main() {
let x = 5;
let y = {
let x = 1;
x + 3
};
println!("The value of y is {}",y);
}
Após o símbolo ->, declare o tipo do valor de retorno da função, mas você não pode nomear o valor de retorno. No Rust, o valor de retorno é o valor da última expressão no corpo da função.Se você quiser retornar antes, precisará usar a palavra-chave return e especificar um valor. A maioria das funções usa a última expressão como valor de retorno por padrão.
fn five()->i32{
5
}
fn plus_five(x: i32)->i32{
x + 5
}
fn main() {
let x = five();
println!("The value of x is {}",x);
let x = plus_five(5);
println!("The value of x is {}",x);
}
se-expressão
A expressão if permite executar diferentes ramificações de código com base em uma condição, que deve ser do tipo bool. Na expressão if, o bloco de código associado à condição é chamado de ramificação (braço). Opcionalmente, uma outra expressão pode ser adicionada depois.
fn main() {
let number = 3;
if number < 5 {
println!("condition was true");
} else {
println!("condition was false");
}
}
Se estiver usando vários else if. Então é melhor usar match para refatorar o código.
fn main() {
let number = 3;
match number < 5 {
true => println!("condition was true"),
false => println!("condition was false"),
}
}
Como if é uma expressão, pode ser colocado à direita do sinal de igual na instrução let.
fn main() {
let condition = true;
let number = if condition {
5 } else {
6 };
println!("The value of number is {}", number);
}
ciclo
1.loop
A palavra-chave loop diz ao Rust para executar um bloco de código repetidamente até que você diga para parar.
fn main() {
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2;
}
};
println!("The value of result is {}", result);
}
2.enquanto
Outro padrão de loop comum é avaliar a condição antes de cada execução do corpo do loop. O loop condicional while nasce para esse padrão.
fn main() {
let mut number = 3;
while number != 0 {
println!("{}!", number);
number = number - 1;
}
}
3.para
Use um loop for para percorrer a coleção. Você pode usar while ou loop para percorrer a coleção, mas é propenso a erros (o índice excede o tamanho da coleção) e ineficiente (cada loop julga se a condição é verdadeira). É mais conciso e compacto usar um loop for, que pode executar algum código para cada elemento da coleção. O loop for é o mais usado no Rust por causa de sua segurança e simplicidade.
fn main() {
let a = [10, 20, 30, 40, 50];
for element in a.iter() {
println!("The value is {}", element);
}
}
Use o loop for para implementar o conteúdo do loop while acima. A biblioteca padrão fornece intervalo, especifica um número inicial e um número final, intervalo pode gerar números entre eles (excluindo o final) e o método rev pode inverter o intervalo.
fn main() {
for number in (1..4).rev() {
println!("{}!", number);
}
}