Tudo o que você precisa saber para começar a escrever Rust

Desde seu lançamento em 2015, Rust ganhou popularidade como uma das linguagens de programação favoritas dos desenvolvedores. Rust oferece excelente desempenho e recursos de segurança com sintaxe intuitiva e concisa que tornam a linguagem desejável.

O Rust é adequado para criar vários programas, incluindo aplicativos da Web, ferramentas de linha de comando e serviços de rede. Rust inclui muitos recursos que você espera de uma linguagem de programação moderna, como simultaneidade, inferência de tipos e muito mais.

Começando com ferrugem

Rust é uma linguagem de programação multiplataforma que roda na maioria dos sistemas operacionais. Para começar com o Rust, acesse o site oficial site enferrujado e instale a versão preferida para o seu sistema operacional.

Depois de instalar o Rust, você pode começar a escrever programas em arquivos Rust com um

.rs extensão. Rust é versátil e fácil de aprender. Você achará isso simples se tiver experiência anterior em programação.

Variáveis ​​e Constantes em Rust

Rust é altamente expressivo e há várias maneiras de declarar variáveis. Você pode usar o deixar palavra-chave para declarar variáveis.

Veja como você pode declarar variáveis ​​em Rust:

deixar a: Corda;
deixar b: i32;
deixar c: () = ();

O a e b variáveis ​​são uma string e um inteiro, respectivamente. O c variável é um tipo de unidade Rust que atua como um espaço reservado para funções e expressões.

Após a declaração de tipo de dados opcional, você pode declarar e inicializar variáveis ​​com valores usando um sinal de igual.

fnprincipal(){
deixar idade: Corda = Corda::de("cinco anos de idade");
deixar idade = 5; // equivalente a deixar idade: i32 = 5;
println!("{}", idade);
}

O programa declara dois idade variáveis ​​antes de imprimir com o println! macro. O primeiro idade variável especifica o tipo de dados e a segunda não.

Você não precisa especificar o tipo de dados de uma variável ao declará-la. O compilador Rust infere o tipo do tipo de dados do valor em tempo de compilação.

Você também pode declarar constantes em Rust com o const palavra-chave de maneira semelhante à declaração de variáveis:

const idade: &str = "cinco anos de idade";

Você não pode modificar o valor de uma variável declarada como uma constante.

Rust fornece funcionalidade para comentários de bloco e linha única. Você pode usar barras duplas (//) para comentários de linha única:

fnprincipal() {
// Este é um comentário de linha
deixar x = 5; // Este comentário explica o propósito da variável `x`
}

Para comentários de várias linhas (comentários em bloco), use uma barra seguida de um asterisco (/*) e feche o bloco com um asterisco seguido de uma barra (*/):

fnprincipal() {
/*
 Este é um comentário em bloco que abrange várias linhas.
 Geralmente é usado para descrever um bloco maior de código.
 */
deixar x = 5;
}

Seus comentários devem ser concisos e diretos.

Matrizes em Rust

Arrays são uma coleção de tamanho fixo de elementos do mesmo tipo de dados. Rust aloca arrays na pilha por padrão.

Veja como você pode declarar arrays em Rust:

fnprincipal() {
deixar números = [1, 2, 3, 4, 5];
}

O números array contém cinco itens. Você pode acessar o valor em um local em uma matriz usando seu índice:

fnprincipal() {
deixar números = [1, 2, 3, 4, 5];
deixar x = números[3];
println!("{}", x)
}

O principal função imprime o x variável que acessa o quarto elemento do array.

Vetores em Rust

Rust fornece vetores para encobrir as limitações do array. Os vetores são dimensionados dinamicamente; eles podem crescer e encolher conforme necessário.

Veja como você pode declarar vetores no Rust:

fnprincipal() {
deixar meu_vec: vec<i32> = você![1, 2, 3, 4, 5];
deixar x = meu_vec[3];
println!("{}", x)
}

O meu_vec vector é um vetor de inteiros de 32 bits. O x variável acessa o quarto elemento do vetor, e o principal A função imprime o valor no console.

Declarações condicionais de Rust

As declarações condicionais são uma das Estruturas de controle de Rust para tomada de decisão em programas. Você pode usar o se e outro palavras-chave para lidar com decisões em seus programas.

aqui está um se instrução que imprime uma string no console com base na igualdade de dois inteiros.

fnprincipal() {
deixar a: i32 = 12;
se um == 12 {
println!("um é igual a doze");
 }
}

O principal função imprime a string com o println! macro, pois a variável é igual a 12.

Você pode usar o outro palavra-chave para lidar com casos em que o se declaração avalia falso:

fnprincipal() {
deixar a: i32 = 12;
se um == 123 {
println!("um é igual a doze");
 } outro {
println!("a não é igual a doze");
 }
}

Neste exemplo, o outro A instrução é executada porque o valor de a não é igual a 123.

Você pode declarar declarações de correspondência com o corresponder palavra-chave para condicionais complexas:

fnprincipal() {
deixar idade: i32 = 7;
corresponder idade {
1 => println!("um"),
2 => println!("dois"),
3 => println!("três"),
 _ => println!("zero"),
 }
}

O principal função corresponde ao idade variável para casos no corresponder declaração e executa a expressão que corresponde ao valor. O sublinhado (_) é a instrução padrão executada se houver uma correspondência para o valor.

Loops em Rust

Rust fornece loops para tarefas repetitivas. Rust tem três tipos principais de loops: laço, enquanto, e para rotações.

O laço A palavra-chave cria um loop infinito que é executado até encontrar uma palavra-chave break:

fnprincipal() {
laço {
println!("impresso repetidamente até que a instrução break seja encontrada.");
quebrar;
 }
}

O enquanto loop é útil quando você deseja repetir um bloco de código, desde que uma condição seja avaliada como verdadeira:

fnprincipal() {
deixarmudo contagem = 0;
enquanto contar < 5 {
println!("A contagem é {}", contar);
 contar += 1;
 }
}

A para loop é bom para iterar sobre uma coleção de itens, como um array:

fnprincipal() {
deixar números = [1, 2, 3, 4, 5];
para item em números.iter() {
println!("O item atual é {}", item);
 }
}

Esse para loop itera através do números array e imprime cada item no console.

Declarando e Chamando Funções Rust

Use o fn palavra-chave para declarar uma função Rust, seguido pelo nome da função, uma lista de parâmetros e um tipo de retorno (se houver).

Veja como você pode declarar uma função com parâmetros e um tipo de retorno:

fnadicionar(a: i32, b: i32) -> i32 {
retornar a + b;
}

O adicionar A função recebe dois inteiros de 32 bits e retorna um inteiro de 32 bits, a soma dos dois parâmetros.

Para chamar uma função de outro lugar em seu código, simplesmente especifique o nome e os argumentos (se houver):

fnprincipal() {
deixar resultado = adicionar(2, 3);
println!("2 + 3 = {}", resultado);
}

O resultado variável contém o resultado da chamada do adicionar função. O principal A função imprime o resultado no console usando o println! macro.

Estruturas em ferrugem

Rust fornece structs para definir tipos de dados personalizados que agrupam valores relacionados. Estruturas são esquemas para criar objetos com propriedades específicas.

Veja como você pode declarar uma struct:

estruturaPessoa {
 nome: Corda,
 idade: u32,
 is_male: bool,
}

O Pessoa struct tem três campos: uma String, um inteiro de 32 bits sem sinal e um booleano.

Depois de definir uma struct, você pode criar instâncias dela em outras partes do seu programa:

fnprincipal() {
deixar pessoa1 = Pessoa {
 nome: Corda::de("Candace Flynn"),
 idade: 16,
 is_male: falso,
 };
}

O pessoa1 variável é uma instância do Pessoa struct. Na instanciação, você pode atribuir valores aos campos struct. Você pode criar quantas instâncias de uma estrutura quiser.

Você pode implementar conceitos OOP em Rust

O Rust é flexível e você pode implementar os conceitos OOP no Rust com estruturas de dados integradas, como structs.

Você usará structs como uma alternativa às classes. Com a struct do Rust, você pode definir um projeto para o tipo e implementar os diferentes conceitos OOP com as funcionalidades que o Rust fornece em structs.