sexta-feira, 19 de fevereiro de 2021

Conceitos comuns de Programação

Este capítulo cobre os conceitos que aparecem em quase todas as linguagens de programação e como eles funcionam no Rust. Muitas linguagens de programação têm muito em comum em seu núcleo. Nenhum dos conceitos apresentados neste capítulo é exclusivo do Rust, mas vamos discuti-los no contexto do Rust e explicar as convenções sobre o uso desses conceitos.

Especificamente, você aprenderá sobre variáveis, tipos básicos, funções, comentários e fluxo de controle. Essas bases estarão em todos os programas Rust, e aprendê-las desde cedo lhe dará um núcleo forte para começar.

Palavras-chave

A linguagem Rust possui um conjunto de palavras-chave que são reservadas para uso apenas pela linguagem, assim como em outras linguagens. Lembre-se de que você não pode usar essas palavras como nomes de variáveis ou funções. A maioria das palavras-chave tem significados especiais e você as usará para realizar várias tarefas em seus programas Rust; alguns não têm nenhuma funcionalidade atual associada a eles, mas foram reservados para funcionalidades que podem ser adicionadas ao Rust no futuro. Você pode encontrar uma lista de palavras-chave em Apêndice A.

Variáveis e Mutabilidade

Conforme mencionado no Capítulo 2, por padrão, as variáveis são imutáveis. Este é um dos muitos incentivos que o Rust lhe dá para escrever seu código de uma forma que aproveite a segurança e a facilidade de simultaneidade que o Rust oferece. No entanto, você ainda tem a opção de tornar suas variáveis mutáveis. Vamos explorar como e por que Rust o incentiva a favorecer a imutabilidade e por que às vezes você pode querer a mutabilidade.

Quando uma variável é imutável, uma vez que um valor está vinculado a um nome, você não pode alterar esse valor. Para ilustrar isso, vamos gerar um novo projeto chamado variables no diretório de seus projetos usando cargo new variables.

Em seguida, em seu novo diretório variables, abra src/main.rs e substitua seu código pelo seguinte código que ainda não compilou:

Nome do arquivo: src/main.rs

Esse código não compila Esse código não compila. 

fn main() {
    let x = 5;
    println!("O valor de x é: {}", x);
    x = 6;
    println!("O valor de x é: {}", x);
}

Salve e execute o programa usando cargo run. Você deve receber uma mensagem de erro, conforme mostrado nesta saída: 

>cargo run
   Compiling variables v0.1.0 (C:\Users\user\projetos\variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src\main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: make this binding mutable: `mut x`
3 |     println!("O valor de x é: {}", x);
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

error: aborting due to previous error

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables`

To learn more, run the command again with --verbose.

Este exemplo mostra como o compilador o ajuda a encontrar erros em seus programas. Mesmo que os erros do compilador possam ser frustrantes, eles apenas significam que seu programa ainda não está fazendo o que você deseja com segurança; eles não significam que você não seja um bom programador! Rustáceos experientes ainda obtêm erros do compilador.

A mensagem de erro indica que a causa do erro é que você cannot assign twice to immutable variable x (não pode atribuir duas vezes à variável imutável x), porque tentou atribuir um segundo valor à variável x que é imutável.

É importante obtermos erros em tempo de compilação quando tentamos alterar um valor que designamos anteriormente como imutável, porque essa mesma situação pode levar a bugs. Se uma parte de nosso código opera na suposição de que um valor nunca mudará e outra parte de nosso código muda esse valor, é possível que a primeira parte do código não faça o que foi projetado para fazer. A causa desse tipo de bug pode ser difícil de rastrear após o fato, especialmente quando a segunda parte do código altera o valor apenas algumas vezes.

No Rust, o compilador garante que, quando você afirma que um valor não muda, ele realmente não muda. Isso significa que, ao ler e escrever código, você não precisa controlar como e onde um valor pode mudar. Seu código é, portanto, mais fácil de raciocinar.

Mas a mutabilidade pode ser muito útil. As variáveis são imutáveis apenas por padrão; como você fez no Capítulo 2, você pode torná-los mutáveis adicionando mut antes do nome da variável. Além de permitir que esse valor seja alterado, mut transmite a intenção a futuros leitores do código, indicando que outras partes do código irão alterar o valor desta variável.

Por exemplo, vamos alterar src/main.rs para o seguinte:

Nome do arquivo: src/main.rs 

fn main() {
    let mut x = 5;
    println!("O valor de x é: {}", x);
    x = 6;
    println!("O valor de x é: {}", x);
}

Quando executamos o programa agora, obtemos o seguinte: 

>cargo run
   Compiling variables v0.1.0 (C:\Users\user\projetos\variables)
    Finished dev [unoptimized + debuginfo] target(s) in 8.95s
     Running `target\debug\variables.exe`
O valor de x é: 5
O valor de x é: 6

Podemos alterar o valor vinculado a x de 5 para 6 quando mut é usado. Em alguns casos, você desejará tornar uma variável mutável porque torna o código mais conveniente de escrever do que se ele tivesse apenas variáveis imutáveis.

Existem várias opções a serem consideradas, além da prevenção de bugs. Por exemplo, nos casos em que você está usando grandes estruturas de dados, transformar uma instância no local pode ser mais rápido do que copiar e retornar instâncias recém-alocadas. Com estruturas de dados menores, criar novas instâncias e escrever em um estilo de programação mais funcional pode ser mais fácil de pensar, portanto, um desempenho inferior pode ser uma penalidade valiosa para obter essa clareza.

Diferenças entre variáveis e constantes

Ser incapaz de alterar o valor de uma variável pode ter lembrado você de outro conceito de programação que a maioria das outras linguagens têm: constantes. Como variáveis imutáveis, constantes são valores vinculados a um nome e não podem ser alterados, mas existem algumas diferenças entre constantes e variáveis.

Primeiro, você não tem permissão para usar mut com constantes. Constantes não são apenas imutáveis por padrão - elas são sempre imutáveis.

Você declara constantes usando a palavra-chave const em vez da palavra-chave let, e o tipo do valor deve ser anotado. Estamos prestes a cobrir os tipos e anotações de tipo na próxima seção, “Tipos de dados”, então não se preocupe com os detalhes agora. Apenas saiba que você deve sempre anotar o tipo.

As constantes podem ser declaradas em qualquer escopo, incluindo o escopo global, o que as torna úteis para valores que muitas partes do código precisam conhecer.

A última diferença é que as constantes podem ser definidas apenas para uma expressão constante, não o resultado de uma chamada de função ou qualquer outro valor que só poderia ser calculado em tempo de execução.

Aqui está um exemplo de declaração de constante onde o nome da constante é MAX_POINTS e seu valor é definido como 100.000. (A convenção de nomenclatura de Rust para constantes é usar todas as letras maiúsculas com sublinhados entre as palavras, e sublinhados podem ser inseridos em literais numéricos para melhorar a legibilidade): 

const MAX_POINTS: u32 = 100_000;

As constantes são válidas durante todo o tempo que um programa é executado, dentro do escopo em que foram declaradas, tornando-as uma escolha útil para valores em seu domínio de aplicativo que várias partes do programa podem precisar saber, como o número máximo de pontos que qualquer jogador de um jogo pode ganhar ou a velocidade da luz.

Nomear valores codificados permanentemente usados ​​em todo o seu programa como constantes é útil para transmitir o significado desse valor para futuros mantenedores do código. Também ajuda ter apenas um local em seu código que você precisaria alterar se o valor codificado permanentemente precisasse ser atualizado no futuro.

Como você viu no tutorial do jogo de adivinhação na seção “Comparando a estimativa com o número secreto” no Capítulo 2, você pode declarar uma nova variável com o mesmo nome de uma variável anterior e a nova variável sombreia a variável anterior. Rustáceos dizem que a primeira variável é sombreada pela segunda, o que significa que o valor da segunda variável é o que aparece quando a variável é usada. Podemos sombrear uma variável usando o nome da mesma variável e repetindo o uso da palavra-chave let da seguinte maneira:

Nome do arquivo: src/main.rs 

fn main() {
    let x = 5;

    let x = x + 1;

    let x = x * 2;

    println!("O valor de x é: {}", x);
}

Este programa primeiro associa x ao valor 5. Em seguida, ele sombreia x repetindo let x =, tomando o valor original e adicionan do 1 de forma que o valor de x é 6. A terceira declaração let também sombreia x, multiplicando o valor anterior de x por 2 para obter um valor final de 12. Quando executamos este programa, ele irá gerar o seguinte: 

>cargo run
   Compiling variables v0.1.0 (C:\Users\user\projetos\variables)
    Finished dev [unoptimized + debuginfo] target(s) in 1.81s
     Running `target\debug\variables.exe`
O valor de x é: 12

Sombreamento é diferente de marcar uma variável como mut, porque obteremos um erro em tempo de compilação se tentarmos acidentalmente reatribuir um valor a esta variável sem usar a palavra-chave let. Ao usar let, podemos realizar algumas transformações em um valor, mas ter a variável imutável depois que essas transformações forem concluídas.

A outra diferença entre mut e sombreamento é que, como estamos efetivamente criando uma nova variável quando usamos a palavra-chave let novamente, podemos alterar o tipo do valor, mas reutilizar o mesmo nome. Por exemplo, digamos que nosso programa peça a um usuário para mostrar quantos espaços ele deseja entre algum texto inserindo caracteres de espaço, mas realmente queremos armazenar essa entrada como um número: 

let espacos = "   ";
let espacos = espacos.len();

Essa construção é permitida porque a primeira variável espacos é um tipo de string e a segunda variável espacos, que é uma variável totalmente nova que por acaso tem o mesmo nome da primeira, é um tipo de número. O sombreamento, portanto, nos poupa de ter que inventar nomes diferentes, como espacos_str e espacos_num; em vez disso, podemos reutilizar o nome espacos mais vezes. No entanto, se tentarmos usar mut para isso, conforme mostrado aqui, obteremos um erro em tempo de compilação:

Esse código não compila Esse código não compila. 

let mut espacos = "   ";
        espacos = espacos.len();

O erro diz que não podemos alterar o tipo de uma variável: 

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
3 |     espacos = espacos.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables`

To learn more, run the command again with --verbose.

Agora que exploramos como as variáveis funcionam, vamos examinar mais tipos de dados que elas podem ter.

Tipos de dados

Cada valor em Rust é de um determinado tipo de dados, o que informa ao Rust que tipo de dados está sendo especificado para que ele saiba como trabalhar com esses dados. Veremos dois subconjuntos de tipo de dados: escalar e composto.

Lembre-se de que Rust é uma linguagem de tipo estático, o que significa que ela deve conhecer os tipos de todas as variáveis ​​em tempo de compilação. O compilador geralmente pode inferir que tipo queremos usar com base no valor e como o usamos. Nos casos em que muitos tipos são possíveis, como quando convertemos a String em um tipo numérico usando o método parse na seção “Comparando o palpite com o número secreto” no Capítulo 2, devemos adicionar uma anotação de tipo, como esta: 

let palpite: u32 = "42".parse().expect("Não é um número!");

Se não adicionarmos a anotação de qual tipo queremos, Rust exibirá o seguinte erro, o que significa que o compilador precisa de mais informações para saber qual tipo queremos usar: 

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let palpite = "42".parse().expect("Not a number!");
  |         ^^^^^^^ consider giving `guess` a type

error: aborting due to previous error

For more information about this error, try `rustc --explain E0282`.
error: could not compile `no_type_annotations`

To learn more, run the command again with --verbose.

Você verá anotações de tipo diferente para outros tipos de dados.

Tipos escalares

Um tipo escalar representa um único valor. Rust tem quatro tipos escalares primários: inteiros, números de ponto flutuante, booleanos e caracteres. Você pode reconhecê-los de outras linguagens de programação. Vamos ver como eles funcionam no Rust.

Tipos inteiros

Um inteiro é um número sem um componente fracionário. Usamos um tipo inteiro no Capítulo 2, o tipo u32. Esta declaração de tipo indica que o valor ao qual está associado deve ser um inteiro não assinado (tipos inteiros assinados começam com i, em vez de u) que ocupa 32 bits de espaço. A Tabela 3-1 mostra os tipos de inteiros integrados em Rust. Cada variante nas colunas Som sinal e Sem sinal (por exemplo, i16) pode ser usada para declarar o tipo de um valor inteiro.

Tabela 3-1: Tipos inteiros em Rust

Tamanho Com sinal Sem sinal
8 bits i8 u8
16 bits i16 u16
32 bits i32 u32
64 bits i64 u64
128 bits i128 u128
arcos isize usize

Cada variante pode ser com sinal ou não e tem um tamanho explícito. Com sinal e sem sinal referem-se à possibilidade do número ser negativo - em outras palavras, se o número precisa ter um sinal com ele (com sinal) ou se será apenas positivo e, portanto, pode ser representado sem um sinal (Sem sinal). É como escrever números no papel: quando o sinal importa, um número é mostrado com um sinal de mais ou um sinal de menos; entretanto, quando é seguro presumir que o número é positivo, ele é mostrado sem nenhum sinal. Os números com sinal são armazenados usando a representação de complemento de dois.

Cada variante com sinal pode armazenar números de -(2 n - 1 ) a 2 n - 1 - 1 inclusive, onde n é o número de bits que a variante usa. Portanto, um i8 pode armazenar números de -(2 7 ) a 27 - 1, que é igual a -128 a 127. Variantes sem sinal podem armazenar números de 0 a 2 n - 1, então u8 pode armazenar números de 0 a 28 - 1, que é igual a 0 até 255.

Além disso, os tipos isize e usize dependem do tipo de computador em que seu programa está sendo executado: 64 bits se você estiver em uma arquitetura de 64 bits e 32 bits se estiver em uma arquitetura de 32 bits.

Você pode escrever literais inteiros em qualquer uma das formas mostradas na Tabela 3-2. Observe que todos os literais de número, exceto o literal de byte, permitem um sufixo de tipo, como 57u8, e _ como um separador visual, como 1_000.

Tabela 3-2: Literais inteiros em Rust

Literais de número Exemplo
Decimal 98_222
Hexadecimal 0xff
Octal 0o77
Binário 0b1111_0000
Byte (apenas u8) b'A'

Então, como você sabe que tipo de número inteiro usar? Se você não tiver certeza, os padrões do Rust são geralmente boas escolhas, e os tipos inteiros são i32: este tipo é geralmente o mais rápido, mesmo em sistemas de 64 bits. A situação primária em que você usaria isize ou usize é ao indexar algum tipo de coleção.

Estouro de inteiro

Digamos que você tenha uma variável do tipo u8 que pode conter valores entre 0 e 255. Se você tentar alterar a variável para um valor fora desse intervalo, como 256, ocorrerá um estouro de inteiro. Rust tem algumas regras interessantes envolvendo esse comportamento. Quando você está compilando no modo de depuração, o Rust inclui verificações de estouro de inteiros que fazem seu programa entrar em pânico no tempo de execução se esse comportamento ocorrer. Rust usa o termo pânico quando um programa é encerrado com um erro; discutiremos os pânicos com mais detalhes na seção “Erros irrecuperáveis com pânico!” no Capítulo 9.

Quando você está compilando no modo de liberação com a flag --release, o Rust não inclui verificações de estouro de inteiros que causam pânico. Em vez disso, se ocorrer estouro, Rust executa o empacotamento de complemento de dois. Resumindo, valores maiores do que o valor máximo que o tipo pode conter “envolvem” ao mínimo dos valores que o tipo pode conter. No caso de u8, 256 torna-se 0, 257 torna-se 1 e assim por diante. O programa não entrará em pânico, mas a variável terá um valor que provavelmente não é o que você esperava. Depender do comportamento de agrupamento do estouro de inteiro é considerado um erro.

Para lidar explicitamente com a possibilidade de estouro, você pode usar estas famílias de métodos que a biblioteca padrão fornece em tipos numéricos primitivos:

  • Envolva em todos os modos com os métodos wrapping_*, como wrapping_add.
  • Retorne o valor None se houver estouro com os métodos checked_*.
  • Retorna o valor e um booleano indicando se houve estouro com os métodos overflowing_*.
  • Sature nos valores mínimo ou máximo do valor com métodos saturating_*.

Tipos de ponto flutuante

Rust também possui dois tipos primitivos para números de ponto flutuante, que são números com casas decimais. Os tipos de ponto flutuante do Rust são f32 e f64, que têm 32 bits e 64 bits, respectivamente. O tipo padrão é f64 porque em CPUs modernas é quase a mesma velocidade que f32, mas pode ter mais precisão.

Aqui está um exemplo que mostra números de ponto flutuante em ação:

Nome do arquivo: src/main.rs 

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Os números de ponto flutuante são representados de acordo com o padrão IEEE-754. O tipo f32 é um float de precisão simples e f64 tem precisão dupla.

Operações Numéricas

Rust suporta as operações matemáticas básicas que você esperaria para todos os tipos de número: adição, subtração, multiplicação, divisão e resto. O código a seguir mostra como você usaria cada uma com uma declaração let:

Nome do arquivo: src/main.rs 

fn main() {
    // adição
    let sum = 5 + 10;

    // subtração
    let difference = 95.5 - 4.3;

    // multiplicação
    let product = 4 * 30;

    // divisão
    let quotient = 56.7 / 32.2;

    // resto
    let remainder = 43 % 5;
}

Cada expressão nessas instruções usa um operador matemático e é avaliada como um único valor, que é então vinculado a uma variável. O Apêndice B contém uma lista de todos os operadores fornecidos pelo Rust.

O tipo booleano

Como na maioria das outras linguagens de programação, um tipo booleano em Rust tem dois valores possíveis: true e false. Os booleanos têm um byte de tamanho. O tipo booleano em Rust é especificado usando bool. Por exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    let t = true;

    let f: bool = false; // Com anotação de tipo explicita
}

A principal forma de usar valores booleanos é por meio de condicionais, como uma expressão if. Abordaremos como as expressões if funcionam no Rust na seção “Fluxo de controle”.

O tipo caractere

Até agora, trabalhamos apenas com números, mas Rust também aceita letras. O tipo char do Rust é o tipo alfabético mais primitivo da linguagem, e o código a seguir mostra uma maneira de usá-lo. (Observe que os literais char são especificados com aspas simples, ao contrário dos literais de string, que usam aspas duplas.)

Nome do arquivo: src/main.rs 

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
}

O tipo char do Rust tem quatro bytes de tamanho e representa um valor escalar Unicode, o que significa que pode representar muito mais do que apenas ASCII. Letras acentuadas; Caracteres chineses, japoneses e coreanos; emoji; e espaços de largura zero são todos valores char válidos em Rust. Os valores Unicode escalares vão desde U+0000a U+D7FFe U+E000para U+10FFFF inclusiva. No entanto, um caractere não é realmente um conceito em Unicode, então sua intuição humana sobre o que é um caractere pode não corresponder ao que char é em Rust. Discutiremos esse tópico em detalhes em “Armazenando Texto Codificado em UTF-8 com Strings” no Capítulo 8.

Tipos compostos

Os tipos compostos podem agrupar vários valores em um tipo. Rust tem dois tipos de compostos primitivos: tuplas e matrizes.

O tipo tupla

Uma tupla é uma maneira geral de agrupar vários valores com uma variedade de tipos em um tipo composto. As tuplas têm um comprimento fixo: uma vez declaradas, elas não podem aumentar ou diminuir de tamanho.

Criamos uma tupla escrevendo uma lista de valores separados por vírgulas entre parênteses. Cada posição na tupla tem um tipo e os tipos dos diferentes valores na tupla não precisam ser os mesmos. Adicionamos anotações de tipo opcionais neste exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

A variável tup se liga a toda a tupla, porque uma tupla é considerada um único elemento composto. Para obter os valores individuais de uma tupla, podemos usar a correspondência de padrões para desestruturar um valor de tupla, como este:

Nome do arquivo: src/main.rs 

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("O valor de y é: {}", y);
}

Este programa primeiro cria uma tupla e a vincula à variável tup. Em seguida, usa um padrão com let para pegar tup e transformá-lo em três variáveis separadas, x, y, e z. Isso é chamado de desestruturação, porque divide a tupla única em três partes. Finalmente, o programa imprime o valor de y, que é 6.4.

Além da desestruturação por meio de correspondência de padrões, podemos acessar um elemento da tupla diretamente usando um ponto (.) seguido pelo índice do valor que queremos acessar. Por exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let quinhentos = x.0;

    let seis_ponto_quatro = x.1;

    let um = x.2;
}

Este programa cria uma tupla, x, e então cria novas variáveis ​​para cada elemento usando seus respectivos índices. Como acontece com a maioria das linguagens de programação, o primeiro índice em uma tupla é 0.

O tipo array (matriz)

Outra maneira de ter uma coleção de vários valores é com um array. Ao contrário de uma tupla, cada elemento de um array deve ter o mesmo tipo. Arrays em Rust são diferentes de arrays em algumas outras linguagens porque arrays em Rust têm um comprimento fixo, como tuplas.

Em Rust, os valores que entram em uma matriz são escritos como uma lista separada por vírgulas entre colchetes:

Nome do arquivo: src/main.rs 

fn main() {
    let a = [1, 2, 3, 4, 5];
}

Os arrays são úteis quando você deseja que seus dados sejam alocados na pilha em vez de no heap (discutiremos a pilha e o heap mais no Capítulo 4) ou quando deseja garantir que sempre tenha um número fixo de elementos. No entanto, uma matriz não é tão flexível quanto o tipo de vetor. Um vetor é um tipo de coleção semelhante fornecido pela biblioteca padrão que é deixada a crescer ou diminuir de tamanho. Se você não tiver certeza se deve usar uma matriz ou um vetor, provavelmente deve usar um vetor. O Capítulo 8 discute os vetores com mais detalhes.

Um exemplo de quando você pode querer usar uma matriz em vez de um vetor é em um programa que precisa saber os nomes dos meses do ano. É muito improvável que tal programa precise adicionar ou remover meses, então você pode usar uma matriz porque sabe que sempre conterá 12 elementos: 

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

Você escreveria o tipo de um array usando colchetes, e entre os colchetes incluiria o tipo de cada elemento, um ponto-e-vírgula e o número de elementos no array, assim: 

let a: [i32; 5] = [1, 2, 3, 4, 5];

Aqui i32 é o tipo de cada elemento. Após o ponto-e-vírgula, o número 5 indica que a matriz contém cinco elementos.

Escrever um tipo de array desta forma é semelhante a uma sintaxe alternativa para inicializar um array: se você deseja criar um array que contém o mesmo valor para cada elemento, você pode especificar o valor inicial, seguido por um ponto-e-vírgula e, em seguida, o comprimento do array entre colchetes, conforme mostrado aqui: 

let a = [3; 5];

O array nomeado a conterá 5 elementos que serão todos configurados com o valor inicialmente 3. Isso é o mesmo que escrever, let a = [3, 3, 3, 3, 3]; mas de uma forma mais concisa.

Acessando Elementos do array

Um array é um único pedaço de memória alocado na pilha. Você pode acessar elementos de um array usando indexação, como este:

Nome do arquivo: src/main.rs 

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

Neste exemplo, a variável nomeada first obterá o valor 1, porque esse é o valor no índice [0] do array. A variável nomeada second obterá o valor 2 que é o valor no índice [1] do array.

Acesso inválido de elemento de um array

O que acontece se você tentar acessar um elemento de uma matriz que já passou do final da matriz? Digamos que você altere o exemplo para o código a seguir, que será compilado, mas sairá com um erro ao ser executado:

Nome do arquivo: src/main.rs

Esse código não compila Esse código não compila. 

fn main() {
    let a = [1, 2, 3, 4, 5];
    let index = 10;

    let elemento = a[index];

    println!("O valor do elemento é: {}", elemento);
}

Executar este código usando cargo run produz o seguinte resultado: 

$ cargo run
   Compiling arrays v0.1.0 (file:///projects/arrays)
error: this operation will panic at runtime
 --> src/main.rs:5:19
  |
5 |     let elemento = a[index];
  |                    ^^^^^^^^ index out of bounds: the length is 5 but the index is 10
  |
  = note: `#[deny(unconditional_panic)]` on by default

error: aborting due to previous error

error: could not compile `arrays`

To learn more, run the command again with --verbose.

A compilação não produziu erros, mas o programa resultou em um erro de execução e não foi encerrado com êxito. Quando você tenta acessar um elemento usando indexação, Rust irá verificar se o índice que você especificou é menor que o comprimento do array. Se o índice for maior ou igual ao comprimento da matriz, Rust entrará em pânico.

Este é o primeiro exemplo dos princípios de segurança da Rust em ação. Em muitas linguagens de baixo nível, esse tipo de verificação não é feito e, quando você fornece um índice incorreto, a memória inválida pode ser acessada. Rust protege você contra esse tipo de erro, saindo imediatamente em vez de permitir o acesso à memória e continuar. O Capítulo 9 discute mais sobre o tratamento de erros do Rust.

Funções

As funções são difundidas no código Rust. Você já viu uma das funções mais importantes da linguagem: a função main, que é o ponto de entrada de muitos programas. Você também viu a palavra-chave fn, que permite declarar novas funções.

O código Rust usa o estilo convencional snake case para nomes de funções e variáveis. No caso do snake, todas as letras são minúsculas e sublinhados em palavras separadas. Aqui está um programa que contém uma definição de função de exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    println!("Hello, world!");

    outra_funcao();
}

fn outra_funcao() {
    println!("Outra função.");
}

As definições de funções em Rust começam com fn e têm um conjunto de parênteses após o nome da função. As chaves informam ao compilador onde o corpo da função começa e termina.

Podemos chamar qualquer função que definimos inserindo seu nome seguido por um conjunto de parênteses. Como outra_funcao está definido no programa, pode ser chamado de dentro da função main. Observe que definimos outra_funcao após a função main no código-fonte; poderíamos ter definido isso antes também. Rust não se importa onde você define suas funções, apenas se elas estão definidas em algum lugar.

Vamos começar um novo projeto binário denominado funcoes para explorar mais as funções. Coloque o exemplo outra_funcao em src/main.rs e execute-o. Você deve ver a seguinte saída: 

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 0.28s
     Running `target/debug/funcoes`
Hello, world!
Outra função.

As linhas são executadas na ordem em que aparecem na função main. Primeiro, a mensagem "Hello, world! é impressa e, em seguida, outra_funcao é chamada e sua mensagem é impressa.

Parâmetros de Funções

As funções também podem ser definidas para ter parâmetros, que são variáveis ​​especiais que fazem parte da assinatura de uma função. Quando uma função tem parâmetros, você pode fornecer valores concretos para esses parâmetros. Tecnicamente, os valores concretos são chamados de argumentos, mas na conversa casual, as pessoas tendem a usar as palavras parâmetro e argumento de forma intercambiável para as variáveis ​​na definição de uma função ou para os valores concretos passados ​​quando você chama uma função.

A seguinte versão reescrita de outra_funcao mostra a aparência dos parâmetros no Rust:

Nome do arquivo: src/main.rs 

fn main() {
    outra_funcao(5);
}

fn outra_funcao(x: i32) {
    println!("O valor de x é: {}", x);
}

Tente executar este programa; você deve obter a seguinte saída: 

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 1.21s
     Running `target/debug/funcoes`
Ovalor de x é: 5

A declaração de outra_funcao tem um parâmetro denominado x. O tipo de x é especificado como i32. Quando 5 é passado para outra_funcao, a macro println! coloca 5 onde o par de chaves estava na string de formato.

Em assinaturas de função, você deve declarar o tipo de cada parâmetro. Esta é uma decisão deliberada no design de Rust: exigir anotações de tipo nas definições de função significa que o compilador quase nunca precisa que você as use em outro lugar no código para descobrir o que você quer dizer.

Quando você quiser que uma função tenha vários parâmetros, separe as declarações dos parâmetros com vírgulas, assim:

Nome do arquivo: src/main.rs 

fn main() {
    outra_funcao(5, 6);
}

fn outra_funcao(x: i32, y: i32) {
    println!("O valor de x é: {}", x);
    println!("O valor de y é: {}", y);
}

Este exemplo cria uma função com dois parâmetros, sendo que ambos são do tipo i32. A função então imprime os valores em ambos os seus parâmetros. Observe que os parâmetros da função não precisam ser todos do mesmo tipo, eles apenas são neste exemplo.

Vamos tentar executar este código. Substitua o programa atualmente no arquivo src/main.rs do projeto de funções pelo exemplo anterior e execute-o usando: cargo run 

$ cargo run
   Compiling funcoes v0.1.0 (file:///projects/funcoes)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/funcoes`
O valor de x é: 5
O valor de y é: 6

Como chamamos a função com 5 como o valor de x e 6 é passada como o valor de y, as duas strings são impressas com esses valores.

O corpo das funções contêm declarações e expressões

O corpo das funções são compostos de uma série de declarações que terminam opcionalmente em uma expressão. Até agora, cobrimos apenas funções sem uma expressão final, mas você viu uma expressão como parte de uma instrução. Como Rust é uma linguagem baseada em expressões, essa é uma distinção importante a ser entendida. Outras linguagens não têm as mesmas distinções, então vamos ver o que são declarações e expressões e como suas diferenças afetam o corpo das funções.

Na verdade, já usamos declarações e expressões. Declarações são instruções que executam alguma ação e não retornam um valor. As expressões são avaliadas como um valor resultante. Vejamos alguns exemplos.

Criar uma variável e atribuir um valor a ela com a palavra-chave let é uma declaração. Na Listagem 3-1, let y = 6; está uma declaração.

Nome do arquivo: src/main.rs 

fn main() {
    let y = 6;
}

Listagem 3-1: Uma declaração de função main contendo uma instrução.

As definições de função também são instruções; todo o exemplo anterior é uma afirmação em si.

As instruções não retornam valores. Portanto, você não pode atribuir uma declaração let a outra variável, como o código a seguir tenta fazer; você obterá um erro:

Nome do arquivo: src/main.rs 

fn main() {
    let x = (let y = 6);
}

Ao executar este programa, o erro que você obterá se parecerá com este: 

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error[E0658]: `let` expressions in this position are experimental
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^^^^^^^
  |
  = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information

error: expected expression, found statement (`let`)
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^^^^^^^
  |
  = note: variable declaration using `let` is a statement

warning: unnecessary parentheses around assigned value
 --> src/main.rs:2:13
  |
2 |     let x = (let y = 6);
  |             ^^^^^^^^^^^ help: remove these parentheses
  |
  = note: `#[warn(unused_parens)]` on by default

error: aborting due to 2 previous errors; 1 warning emitted

For more information about this error, try `rustc --explain E0658`.
error: could not compile `functions`

To learn more, run the command again with --verbose.

A declaração let y = 6; não retorna um valor, então não há nada para ser vinculado a x. Isso é diferente do que acontece em outras linguagens, como C e Ruby, onde a atribuição retorna o valor da atribuição. Nessas linguagens, você pode escrever x = y = 6 e ambos x e y ter o valor 6; esse não é o caso em Rust.

As expressões são avaliadas como algo e constituem a maior parte do restante do código que você escreverá em Rust. Considere uma operação matemática simples, como 5 + 6, que é uma expressão que resulta no valor 11. As expressões podem fazer parte das declarações: na Listagem 3-1, o 6 na declaração let y = 6; é uma expressão que resulta no valor 6 atribuido a variavel y. Chamar uma função é uma expressão. Chamar uma macro é uma expressão. O bloco que usamos para criar novos escopos, {},é uma expressão, por exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("O valor de y é: {}", y);
}

Esta expressão: 

{
    let x = 3;
    x + 1
}

é um bloco que, neste caso, resulta no valor 4. Esse valor é vinculado a y como parte da declaração let. Observe a linha x + 1 sem ponto-e-vírgula no final, que é diferente da maioria das linhas que você viu até agora. As expressões não incluem ponto e vírgula final. Se você adicionar um ponto-e-vírgula ao final de uma expressão, você o transforma em uma declaração, que não retornará um valor. Lembre-se disso ao explorar os valores e expressões de retorno da função a seguir.

Funções com valores de retorno

As funções podem retornar valores para o código que as chama. Não nomeamos os valores de retorno, mas declaramos seu tipo após uma seta (->). Em Rust, o valor de retorno da função é sinônimo do valor da expressão final no bloco do corpo de uma função. Você pode retornar antecipadamente de uma função usando a palavra-chave return e especificando um valor, mas a maioria das funções retorna a última expressão implicitamente. Aqui está um exemplo de função que retorna um valor:

Nome do arquivo: src/main.rs 

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("O valor de x é: {}", x);
}

Não há chamadas de função, macros ou mesmo declarações let na função five - apenas o número 5 em si. Essa é uma função perfeitamente válida no Rust. Observe que o tipo de retorno da função também é especificado, como -> i32. Tente executar este código; a saída deve ser semelhante a esta: 

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/functions`
O valor de x é: 5

O 5 em five é o valor de retorno da função, e é por isso que o tipo de retorno é i32. Vamos examinar isso com mais detalhes. Existem dois trechos importantes: primeiro, a linha let x = five(); mostra que estamos usando o valor de retorno de uma função para inicializar uma variável. Como a função five retorna um 5, essa linha é igual à seguinte: 

let x = 5;

Em segundo lugar, a fivefunção não tem parâmetros e define o tipo do valor de retorno, mas o corpo da função é solitário, 5sem ponto-e-vírgula porque é uma expressão cujo valor queremos retornar.

Vejamos outro exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    let x = mais_um(5);

    println!("O valor de x é: {}", x);
}

fn mais_um(x: i32) -> i32 {
    x + 1
}

Executar este código irá imprimir O valor de x é: 6. Mas se colocarmos um ponto-e-vírgula no final da linha que contém x + 1, mudando de uma expressão para uma declaração, obteremos um erro.

Nome do arquivo: src/main.rs

Esse código não compila Esse código não compila. 

fn main() {
    let x = mais_um(5);

    println!("O valor de x é: {}", x);
}

fn mais_um(x: i32) -> i32 {
    x + 1;
}

Compilar este código produz um erro, da seguinte maneira: 

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
 --> src/main.rs:7:24
  |
7 | fn mais_um(x: i32) -> i32 {
  |    -------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: consider removing this semicolon

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions`

To learn more, run the command again with --verbose.

A mensagem de erro principal, mismatched types (“tipos incompatíveis”), revela o problema principal com este código. A definição da função mais_um diz que ela retornará um i32, mas as declarações não são avaliadas como um valor, que é expresso por uma tupla vazia (). Portanto, nada é retornado, o que contradiz a definição da função e resulta em um erro. Nesta saída, Rust fornece uma mensagem para possivelmente ajudar a retificar esse problema: ele sugere a remoção do ponto-e-vírgula, o que corrigiria o erro.

Comentários

Todos os programadores se esforçam para tornar seu código fácil de entender, mas às vezes uma explicação extra é necessária. Nesses casos, os programadores deixam notas ou comentários em seu código-fonte que o compilador irá ignorar, mas as pessoas que estão lendo o código-fonte podem achar útil.

Aqui está um comentário simples: 

// hello, world

Em Rust, o estilo de comentário idiomático começa um comentário com duas barras, e o comentário continua até o final da linha. Para comentários que vão além de uma única linha, você precisará incluir // em cada linha, assim: 

// Então, estamos fazendo algo complicado aqui, longo o suficiente para
// precisarmos de várias linhas de comentários para fazer isso! Uau!
// Esperançosamente, este comentário explicará o que está acontecendo.

Os comentários também podem ser colocados no final das linhas que contêm o código:

Nome do arquivo: src/main.rs 

fn main() {
        let numero_da_sorte = 7; // Estou com sorte hoje
    }

Mas você os verá com mais frequência usados neste formato, com o comentário em uma linha separada acima do código que está anotando:

Nome do arquivo: src/main.rs 

fn main() {
    // Estou com sorte hoje
    let numero_da_sorte = 7;
}

Rust também tem outro tipo de comentário, comentários de documentação, que discutiremos na seção “Publicando um crate em Crates.io” do Capítulo 14.

Controle de fluxo

Decidir se deve ou não executar algum código dependendo se uma condição é verdadeira e decidir executar algum código repetidamente enquanto uma condição é verdadeira são blocos de construção básicos na maioria das linguagens de programação. As construções mais comuns que permitem controlar o fluxo de execução do código Rust são expressões if e loops.

Expressões if

Uma expressão if permite que você ramifique seu código dependendo das condições. Você fornece uma condição e afirma: “Se esta condição for atendida, execute este bloco de código. Se a condição não for atendida, não execute este bloco de código.”

Crie um novo projeto chamado branches no diretório de seus projetos para explorar a expressão if. No arquivo src/main.rs , insira o seguinte:

Nome do arquivo: src/main.rs 

fn main() {
    let numero = 3;

    if numero < 5 {
        println!("A condição era verdadeira");
    } else {
        println!("A condiração era falsa");
    }
}

Todas as expressões if começam com a palavra-chave if, que é seguida por uma condição. Nesse caso, a condição verifica se a variável numero tem ou não um valor menor que 5. O bloco de código que queremos executar se a condição for verdadeira é colocado imediatamente após a condição entre chaves. Os blocos de código associados às condições nas expressões if às vezes são chamados de ramificações, assim como as ramificações nas expressões match que discutimos na seção “Comparando a estimativa com o número secreto” do Capítulo 2.

Opcionalmente, também podemos incluir uma expressão else, que escolhemos fazer aqui, para dar ao programa um bloco alternativo de código para executar caso a condição seja avaliada como falsa. Se você não fornecer uma expressão else e a condição for falsa, o programa irá simplesmente pular o bloco if e passar para o próximo trecho de código.

Tente executar este código; você deve ver a seguinte saída: 

> cargo run
   Compiling branches v0.1.0 (C:\Users\user\projetos\branches)
    Finished dev [unoptimized + debuginfo] target(s) in 19.91s
     Running `target\debug\branches.exe`
A condição era verdadeira

Vamos tentar alterar o valor de numero para um valor que crie a condição false para ver o que acontece: 

let number = 7;

Execute o programa novamente e observe o resultado: 

> cargo run
   Compiling branches v0.1.0 (C:\Users\user\projetos\branches)
    Finished dev [unoptimized + debuginfo] target(s) in 1.85s
     Running `target\debug\branches.exe`
A condiração era falsa

Também é importante notar que a condição neste código deve ser a bool. Se a condição não for bool, obteremos um erro. Por exemplo, tente executar o seguinte código:

Nome do arquivo: src/main.rs

Esse código não compila Esse código não compila. 

fn main() {
    let number = 3;

    if number {
        println!("O número era três.");
    }
}

A condição if é avaliada como um valor 3 deste vez, e Rust gera um erro: 

> cargo run
   Compiling branches v0.1.0 (C:\Users\user\projetos\branches)
error[E0308]: mismatched types
 --> src\main.rs:4:8
  |
4 |     if number {
  |        ^^^^^^ expected `bool`, found integer

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches`

To learn more, run the command again with --verbose.

O erro indica que Rust esperava um, bool mas obteve um inteiro. Ao contrário de linguagens como Ruby e JavaScript, o Rust não tentará converter automaticamente tipos não booleanos em booleanos. Você deve ser explícito e sempre fornecer um booleano como condição if. Se quisermos que o bloco de código if seja executado apenas quando um número não for igual a 0, por exemplo, podemos alterar a expressão if para o seguinte:

Nome do arquivo: src/main.rs 

fn main() {
    let number = 3;

    if number != 0 {
        println!("Número era algo diferente de zero.");
    }
}

Executar este código irá imprimir Número era algo diferente de zero..

Lidando com várias condições com else if

Você pode ter várias condições combinando if e else em uma expressão else if. Por exemplo:

Nome do arquivo: src/main.rs 

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("O número é divisivel por 4");
    } else if number % 3 == 0 {
        println!("O número é divisivel por 3");
    } else if number % 2 == 0 {
        println!("O número é divisivel por 2");
    } else {
        println!("O número não é divisivel por 4, 3, ou 2");
    }
}

Este programa tem quatro caminhos possíveis que pode seguir. Depois de executá-lo, você verá a seguinte saída: 

> cargo run
   Compiling branches v0.1.0 (C:\Users\user\projetos\branches)
    Finished dev [unoptimized + debuginfo] target(s) in 27.78s
     Running `target\debug\branches.exe`
O número é divisivel por 3

Quando este programa é executado, ele verifica cada expressão if por vez e executa o primeiro corpo para o qual a condição é verdadeira. Observe que, embora 6 seja divisível por 2, não vemos a saída O número é divisivel por 2, nem vemos o texto O número não é divisivel por 4, 3, ou 2 do bloco else. Isso porque Rust só executa o bloco para a primeira condição verdadeira e, uma vez que encontra uma, nem verifica o resto.

Usar muitas expressões else if pode confundir seu código, portanto, se você tiver mais de uma, talvez queira refatorá-lo. O Capítulo 6 descreve uma poderosa construção de ramificação do Rust chamada match para esses casos.

Usando if em uma declaração let

Por ser uma expressão if, podemos usá-la no lado direito de uma declaração let, como na Listagem 3-2.

Nome do arquivo: src/main.rs 

fn main() {
    let condition = true;
    let numero = if condition { 5 } else { 6 };

    println!("O valor da variável 'numero' é: {}", numero);
}

Listagem 3-2: Atribuindo o resultado de uma expressão if a uma variável

A variável numero será associada a um valor baseado no resultado da expressão if. Execute este código para ver o que acontece: 

> cargo run
   Compiling branches v0.1.0 (C:\Users\user\projetos\branches)
    Finished dev [unoptimized + debuginfo] target(s) in 8.51s
     Running `target\debug\branches.exe`
O valor da variável 'numero' é: 5

Lembre-se de que os blocos de código avaliam a última expressão neles, e os números por si só também são expressões. Nesse caso, o valor de toda a expressão depende de qual bloco de código é executado. Isso significa que os valores que têm o potencial de ser resultados de cada ramificação do if devem ser do mesmo tipo; na Listagem 3-2, os resultados da ramificação if e da ramificação else eram inteiros i32. Se os tipos forem incompatíveis, como no exemplo a seguir, obteremos um erro:

Nome do arquivo: src/main.rs

Esse código não compila Esse código não compila. 

fn main() {
    let condicao = true;

    let numero = if condicao { 5 } else { "seis" };

    println!("O valor da variável 'numero' é: {}", numero);
}

Quando tentarmos compilar este código, obteremos um erro. As ramificações if e else têm valor de tipos incompatíveis e Rust indica exatamente onde encontrar o problema no programa: 

> cargo run
   Compiling branches v0.1.0 (C:\Users\user\projetos\branches)
error[E0308]: `if` and `else` have incompatible types
 --> src\main.rs:4:43
  |
4 |     let numero = if condicao { 5 } else { "seis" };
  |                                -          ^^^^^^ expected integer, found `&str`
  |                                |
  |                                expected because of this

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches`

To learn more, run the command again with --verbose.

A expressão no bloco if é avaliada como um inteiro e a expressão no bloco else é avaliada como uma string. Isso não funcionará porque as variáveis devem ter um único tipo. Rust precisa saber em tempo de compilação qual é o tipo da variável numero, definitivamente, para que possa verificar em tempo de compilação se seu tipo é válido em todos os lugares que usamos numero. Rust não seria capaz de fazer isso se o tipo de numero só fosse determinado em tempo de execução; o compilador seria mais complexo e ofereceria menos garantias sobre o código se tivesse que controlar vários tipos hipotéticos para qualquer variável.

Repetição com loops

Geralmente, é útil executar um bloco de código mais de uma vez. Para esta tarefa, o Rust fornece vários loops. Um loop percorre o código dentro do corpo do loop até o fim e então começa imediatamente de volta ao início. Para experimentar loops, vamos fazer um novo projeto chamado loops.

Rust tem três tipos de loops: loop, while, e for. Vamos experimentar cada um.

Repetindo código com loop

A palavra-chave loop diz ao Rust para executar um bloco de código indefinidamente ou até que você diga explicitamente para parar.

Por exemplo, altere o arquivo src/main.rs em seu diretório loops para ficar assim:

Nome do arquivo: src/main.rs 

fn main() {
    loop {
        println!("De novo!");
    }
}

Quando executamos este programa, veremos a impressão De novo! continuamente até interrompermos o programa manualmente. A maioria dos terminais oferece suporte a um atalho de teclado, ctrl-c, para interromper um programa que está travado em um loop contínuo. De uma chance: 

> cargo run
   Compiling loops v0.1.0 (C:\Users\user\projetos\loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.84s
     Running `target\debug\loops.exe`
De novo!
De novo!
De novo!
De novo!
error: process didn't exit successfully: `target\debug\loops.exe` (exit code: 0xc000013a, STATUS_CONTROL_C_EXIT)

Felizmente, o Rust fornece outra maneira mais confiável de quebrar um loop. Você pode colocar a palavra-chave break dentro do loop para informar ao programa quando interromper a execução do loop. Lembre-se de que fizemos isso no jogo de adivinhação na seção “Encerrando após uma estimativa correta” do Capítulo 2 para sair do programa quando o usuário venceu o jogo adivinhando o número correto.

Retornando valores de Loops

Um dos usos da declaração loop é tentar novamente uma operação que você sabe que pode falhar, como verificar se um encadeamento concluiu seu trabalho. No entanto, pode ser necessário passar o resultado dessa operação para o resto do código. Para fazer isso, você pode adicionar o valor que deseja retornar após a expressão break usada para interromper o loop; esse valor será retornado para fora do loop para que você possa usá-lo, conforme mostrado aqui: 

fn main() {
    let mut contador_de_loop = 0;

    let resultado = loop {
        contador_de_loop += 1;

        if contador_de_loop == 10 {
            break contador_de_loop * 2;
        }
    };

    println!("O resultado é {}", resultado);
}

Antes do loop, declaramos uma variável chamada contador_de_loop e a inicializamos com 0. Em seguida, declaramos uma variável chamada resultado para conter o valor retornado do loop. Em cada iteração do loop, adicionamos 1 à variável contador_de_loop e verificamos se o contador é igual a 10. Quando for, usamos a palavra-chave break com o valor contador_de_loop * 2. Após o loop, usamos um ponto e vírgula para encerrar a instrução que atribui o valor a resultado. Finalmente, imprimimos o valor em resultado, que neste caso é 20.

Loops condicionais com while

Geralmente, é útil para um programa avaliar uma condição dentro de um loop. Enquanto a condição for verdadeira, o loop é executado. Quando a condição deixa de ser verdadeira, o programa chama break, interrompendo o loop. Este tipo de circuito pode ser implementado utilizando uma combinação de loop, if, else, e break; você pode tentar isso agora em um programa, se quiser.

No entanto, esse padrão é tão comum que Rust tem uma construção de linguagem embutida para ele, chamada de loop while. A Listagem 3-3 usa while: o programa faz um loop três vezes, contando cada vez, e então, após o loop, ele imprime outra mensagem e sai.

Nome do arquivo: src/main.rs 

fn main() {
    let mut numero = 3;

    while numero != 0 {
        println!("{}!", numero);

        numero -= 1;
    }

    println!("SAINDO!!!");
}

Listagem 3-3: Usando um loop while para executar código enquanto uma condição for verdadeira

Esta construção elimina um monte de nidificação que seria necessário se você usou loop, if, else, e break, e é mais clara. Embora uma condição seja verdadeira, o código é executado; caso contrário, ele sai do loop.

Loop por meio de uma coleção com for

Você pode usar a construção while para percorrer os elementos de uma coleção, como um array. Por exemplo, vamos dar uma olhada na Listagem 3-4.

Nome do arquivo: src/main.rs 

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("O valor é: {}", a[index]);

        index += 1;
    }
}

Listagem 3-4: Loop através de cada elemento de uma coleção usando o loop while

Aqui, o código faz a contagem progressiva dos elementos do array. Ele começa no índice 0 e depois faz um loop até atingir o índice final na matriz (ou seja, quando a expressão index < 5 não é mais verdadeira). Executar este código imprimirá todos os elementos da matriz: 

> cargo run
   Compiling loops v0.1.0 (C:\Users\user\projetos\loops)
    Finished dev [unoptimized + debuginfo] target(s) in 1.52s
     Running `target\debug\loops.exe`
O valor é: 10
O valor é: 20
O valor é: 30
O valor é: 40
O valor é: 50

Todos os cinco valores da matriz aparecem no terminal, conforme o esperado. Mesmo que index atinja o valor 5 em algum ponto, a execução do loop é interrompida antes de tentar obter um sexto valor da matriz.

Mas essa abordagem está sujeita a erros; podemos fazer com que o programa entre em pânico se o comprimento do índice estiver incorreto. Também é lento, porque o compilador adiciona código de tempo de execução para realizar a verificação condicional em cada elemento em cada iteração através do loop.

Como alternativa mais concisa, você pode usar um loop for e executar alguns códigos para cada item em uma coleção. Um loop for se parece com o código da Listagem 3-5.

Nome do arquivo: src/main.rs 

fn main() {
    let a = [10, 20, 30, 40, 50];

    for elemento in a.iter() {
        println!("O valor é: {}", elemento);
    }
}

Listagem 3-5: Loop através de cada elemento de uma coleção usando um loop for

Quando executamos esse código, veremos a mesma saída da Listagem 3-4. Mais importante, agora aumentamos a segurança do código e eliminamos a chance de bugs que podem resultar de ir além do final do array ou não ir longe o suficiente e perder alguns itens.

Por exemplo, no código da Listagem 3-4, se você alterasse a definição da a array para ter quatro elementos, mas se esquecesse de atualizar a condição para while index < 4, o código entraria em pânico. Usando o loop for, você não precisaria se lembrar de alterar nenhum outro código se alterasse o número de valores na matriz.

A segurança e a concisão dos loops for os tornam a construção de loop mais comumente usada no Rust. Mesmo em situações em que você deseja executar algum código um certo número de vezes, como no exemplo de contagem regressiva que usou um loop while na Listagem 3-3, a maioria dos Rustáceos usaria um loop for. A maneira de fazer isso seria usar um Range, que é um tipo fornecido pela biblioteca padrão que gera todos os números em sequência começando de um número e terminando antes de outro.

Esta é a aparência da contagem regressiva usando um loop for e outro método sobre o qual ainda não falamos, rev, para inverter o intervalo:

Nome do arquivo: src/main.rs 

fn main() {
    for numero in (1..4).rev() {
        println!("{}!", numero);
    }
    println!("SAINDO!!!");
}

Este código é um pouco melhor, não é?

Resumo

Você conseguiu! Esse foi um capítulo considerável: você aprendeu sobre variáveis, tipos de dados escalares e compostos, funções, comentários, expressões if e loops! Se você quiser praticar com os conceitos discutidos neste capítulo, tente construir programas para fazer o seguinte:

  • Converta temperaturas entre Fahrenheit e Celsius.
  • Gere o enésimo número de Fibonacci.
  • Imprima a letra da canção natalina “The Twelve Days of Christmas”, aproveitando a repetição da música.

Quando você estiver pronto para seguir em frente, falaremos sobre um conceito no Rust que normalmente não existe em outras linguagens de programação: propriedade.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Licença

0 comentários:

Postar um comentário

Assinar: Postar comentários (Atom)