Vamos pular para o Rust trabalhando juntos em um projeto prático! Este capítulo apresenta alguns conceitos comuns do Rust, mostrando como usá-los em um programa real. Você aprenderá sobre let, match, métodos, funções associadas, uso de crates externos e muito mais! Os capítulos seguintes explorarão essas idéias com mais detalhes. Neste capítulo, você praticará os fundamentos.
Implementaremos um problema clássico de programação para iniciantes: um jogo de adivinhação. Funciona assim: o programa irá gerar um número inteiro aleatório entre 1 e 100. Em seguida, ele solicitará que o jogador insira uma estimativa. Depois de inserir uma estimativa, o programa indicará se a estimativa é muito baixa ou muito alta. Se o palpite estiver correto, o jogo irá imprimir uma mensagem de parabéns e sair.
Configurando um Novo Projeto
Para configurar um novo projeto, vá para o diretório de projetos que você criou no Capítulo 1 e faça um novo projeto usando Cargo, assim:
$ cargo new guessing_game
$ cd guessing_game
O primeiro comando, cargo new leva o nome do projeto (guessing_game) como o primeiro argumento. O segundo comando muda para o diretório do novo projeto.
Veja o arquivo Cargo.toml gerado:
Nome do arquivo: Cargo.toml
[package]
name = "guessing_game"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]Se as informações do autor que o Cargo obteve do seu ambiente não estiverem corretas, corrija-as no arquivo e salve-o novamente.
Como você viu no Capítulo 1, cargo new gera um programa "Hello, world!" para você. Verifique o arquivo src/main.rs:
Nome do arquivo: src/main.rs
fn main() {
println!("Hello, world!");
}
Agora vamos compilar este programa Hello, world! e executa-lo na mesma etapa usando o comando cargo run:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
Running `target/debug/guessing_game`
Hello, world!
O comando run é útil quando você precisa iterar rapidamente em um projeto, como faremos neste jogo, testando rapidamente cada iteração antes de passar para a próxima.
Reabra o arquivo src/main.rs. Você escreverá todo o código neste arquivo.
Processando um palpite
A primeira parte do programa jogo de adivinhação solicitará a entrada do usuário, processará essa entrada e verificará se a entrada está na forma esperada. Para começar, vamos permitir que o jogador dê um palpite. Digite o código na Listagem 2-1 em src/main.rs.
Nome do arquivo: src/main.rs
use std::io;
fn main() {
println!("Adivinhe o número!");
println!("Por favor entre com o seu palpite.");
let mut palpite = String::new();
io::stdin()
.read_line(&mut palpite)
.expect("Falha ao ler a linha.");
println!("Seu palpite: {}", palpite);
}Listagem 2-1: Código que obtém um palpite do usuário e a imprime
Este código contém muitas informações, então vamos examiná-lo linha por linha. Para obter a entrada do usuário e, em seguida, imprimir o resultado como saída, precisamos trazer a biblioteca io (entrada/saída) para o escopo. A biblioteca io vem da biblioteca padrão (conhecida como std):
use std::io;
Por padrão, Rust traz apenas alguns tipos no âmbito de cada programa no prelúdio. Se um tipo que você deseja usar não está no prelúdio, você deve trazer esse tipo para o escopo explicitamente com uma declaração use. O uso da biblioteca std::io fornece vários recursos úteis, incluindo a capacidade de aceitar entradas do usuário.
Como você viu no Capítulo 1, a função main é o ponto de entrada para o programa:
fn main() {
A sintaxe fn declara uma nova função, os parênteses, (), indicam que não há parâmetros, e a chave, {, inicia o corpo da função.
Como você também aprendeu no Capítulo 1, println! é uma macro que imprime uma string na tela:
println!("Adivinhe o número!");
println!("Por favor entre com o seu palpite.");
Este código está imprimindo um prompt informando o que é o jogo e solicitando a entrada do usuário.
Armazenamento de valores com variáveis
A seguir, criaremos um local para armazenar a entrada do usuário, como este:
let mut palpite = String::new();
Agora o programa está ficando interessante! Há muita coisa acontecendo nesta pequena linha. Observe que esta é uma instrução let, que é usada para criar uma variável. Aqui está outro exemplo:
let foo = bar;
Esta linha cria uma nova variável chamada foo e a vincula ao valor da variável bar. No Rust, as variáveis são imutáveis por padrão. Discutiremos esse conceito em detalhes na seção “Variáveis e mutabilidade” no Capítulo 3. O exemplo a seguir mostra como usar mut antes do nome da variável para tornar uma variável mutável:
let foo = 5; // imutável
let mut bar = 5; // mutávelNota:
//inicia um comentário que continua até o final da linha. Rust ignora tudo nos comentários, que são discutidos com mais detalhes no Capítulo 3.
Voltemos ao programa de jogo de adivinhação. Agora você sabe que let mut palpite introduzirá uma variável mutável chamada palpite. Do outro lado do sinal de igual (=) está o valor vinculado a palpite, que é o resultado da chamada String::new, uma função que retorna uma nova instância de String. String é um tipo de string fornecido pela biblioteca padrão que é um bit de texto codificado em UTF-8 que pode ser ampliado.
A sintaxe :: na linha ::new indica que new é uma função associada do tipo String. Uma função associada é implementada em um tipo, neste caso String, ao invés de em uma instância particular de String. Algumas linguagens chamam isso de método estático.
Esta função new cria uma nova string vazia. Você encontrará uma função new em muitos tipos, porque é um nome comum para uma função que cria um novo valor de algum tipo.
Para resumir, a linha let mut palpite = String::new(); criou uma variável mutável que está atualmente associada a uma nova instância vazia de String. Uau!
Lembre-se de que incluímos a funcionalidade de entrada/saída da biblioteca padrão use std::io; na primeira linha do programa. Agora vamos chamar a função stdin do módulo io:
io::stdin()
.read_line(&mut palpite)
Se não tivéssemos colocado a linha use std::io no início do programa, poderíamos ter escrito essa chamada de função como std::io::stdin. A função stdin retorna uma instância de std::io::Stdin, que é um tipo que representa um identificador para a entrada padrão do seu terminal.
A próxima parte do código, .read_line(&mut palpite) chama o método read_line no identificador de entrada padrão para obter a entrada do usuário. Também estamos passando um argumento para read_line: &mut palpite.
O trabalho de read_line é pegar tudo o que o usuário digitar na entrada padrão e colocá-lo em uma string, de modo que essa string seja um argumento. O argumento da string precisa ser mutável para que o método possa alterar o conteúdo da string adicionando a entrada do usuário.
& indica que esse argumento é uma referência, o que fornece uma maneira de permitir que várias partes do seu código acessem um dado sem a necessidade de copiar esses dados para a memória várias vezes. As referências são um recurso complexo e uma das principais vantagens do Rust é o quão seguro e fácil é usar as referências. Você não precisa saber muitos desses detalhes para terminar este programa. Por enquanto, tudo que você precisa saber é que, como as variáveis, as referências são imutáveis por padrão. Portanto, você precisa escrever &mut palpite em vez de &palpite para torná-lo mutável. (O Capítulo 4 explicará as referências mais detalhadamente.)
Lidando com a falha potencial com o tipo Result
Ainda estamos trabalhando nesta linha de código. Embora agora estejamos discutindo uma terceira linha de texto, ela ainda faz parte de uma única linha lógica de código. A próxima parte é este método:
.expect("Falha ao ler a linha.");
Quando você chama um método com a sintaxe .foo(), geralmente é aconselhável introduzir uma nova linha e outro espaço em branco para ajudar a quebrar as linhas longas. Poderíamos ter escrito este código como:
io::stdin().read_line(&mut palpite).expect("Falha ao ler a linha.");No entanto, uma linha longa é difícil de ler, por isso é melhor dividi-la. Agora vamos discutir o que esta linha faz.
Conforme mencionado anteriormente, read_line coloca o que o usuário digitar na string que estamos passando como parametro para a função, mas também retorna um valor - neste caso, um io::Result. Rust tem vários tipos nomeados Result em sua biblioteca padrão Result versões genéricas e específicas para submódulos, como io::Result.
Os tipos Result são enumerações, geralmente chamadas de enums. Uma enumeração é um tipo que pode ter um conjunto fixo de valores, e esses valores são chamados de variantes enum. O Capítulo 6 abordará enums com mais detalhes.
Pois Result, as variantes são Ok ou Err. A variante Ok indica que a operação foi bem-sucedida e dentro de Ok está o valor gerado com sucesso. A variante Err significa que a operação falhou e Err contém informações sobre como ou por que a operação falhou.
O objetivo desses tipos Result é codificar informações de tratamento de erros. Valores do tipo Result, como valores de qualquer tipo, têm métodos definidos neles. Uma instância de io::Result possui um método expect que você pode chamar. Se esta instância de io::Result for um valor Err, expect fará com que o programa trave e exiba a mensagem que você transmitiu como argumento expect. Se o método read_line retornar um Err, provavelmente será o resultado de um erro proveniente do sistema operacional subjacente. Se esta instância de io::Result for um valor Ok, expect assumirá o valor de retorno que Ok está mantendo e retorna apenas esse valor para que você possa usá-lo. Nesse caso, esse valor é o número de bytes em que o usuário inseriu na entrada padrão.
Se você não chamar expect, o programa será compilado, mas você receberá um aviso:
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
warning: unused `std::result::Result` that must be used
--> src/main.rs:10:5
|
10 | io::stdin().read_line(&mut palpite);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: this `Result` may be an `Err` variant, which should be handled
warning: 1 warning emitted
Finished dev [unoptimized + debuginfo] target(s) in 0.59s
Rust avisa que você não usou o valor Result retornado pelo método read_line, indicando que o programa não tratou um possível erro.
A maneira correta de suprimir o aviso é escrever o tratamento de erros, mas como você deseja apenas travar este programa quando ocorrer um problema, você pode usar expect. Você aprenderá a se recuperar de erros no Capítulo 9.
Impressão de valores com marcadores de posição println!
Além da chave de fechamento, há apenas mais uma linha para discutir no código adicionado até agora, que é o seguinte:
println!("Seu palpite: {}", palpite);
Esta linha imprime a string em que salvamos a entrada do usuário. O conjunto de chaves, {}, é um espaço reservado: pense em pequenas pinças de caranguejo que mantêm um valor no lugar. Você pode imprimir mais de um valor usando chaves: o primeiro conjunto de chaves contém o primeiro valor listado após a string de formato, o segundo conjunto contém o segundo valor e assim por diante. Imprimir vários valores em uma chamada para println! ficaria assim:
let x = 5;
let y = 10;
println!("x = {} e y = {}", x, y);
Este código vai imprimir x = 5 e y = 10.
Testando a Primeira Parte
Vamos testar a primeira parte do jogo de adivinhação. Execute-o usando cargo run:
C:\Users\user\projetos\guessing_game>cargo run
Compiling guessing_game v0.1.0 (C:\Users\user\projetos\guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 22.74s
Running `target\debug\guessing_game.exe`
Adivinhe o número!
Por favor entre com o seu palpite.
9
Seu palpite: 9
Neste ponto, a primeira parte do jogo está concluída: estamos recebendo dados do teclado e depois imprimindo.
Gerando um Número Secreto
Em seguida, precisamos gerar um número secreto que o usuário tentará adivinhar. O número secreto deve ser diferente a cada vez, para que seja divertido jogar mais de uma vez. Vamos usar um número aleatório entre 1 e 100 para que o jogo não seja muito difícil. Rust ainda não inclui a funcionalidade de número aleatório em sua biblioteca padrão. No entanto, a equipe Rust fornece o crate rand.
Usando um crate para obter mais funcionalidade
Lembre-se de que um crate é uma coleção de arquivos de código-fonte do Rust. O projeto que estamos construindo é um crate binário, que é um executável. O crate rand é uma crate de biblioteca, que contém código destinado a ser usado em outros programas.
O uso de crates externos pelo cargo é onde ele realmente brilha. Antes que possamos escrever o código que usa rand, precisamos modificar o arquivo Cargo.toml para incluir o crate rand como uma dependência. Abra esse arquivo agora e adicione a seguinte linha na parte inferior, abaixo do cabeçalho [dependencies] da seção que o Cargo criou para você:
Nome do arquivo: Cargo.toml
[dependencies]
rand = "0.5.5"
No arquivo Cargo.toml, tudo o que segue um cabeçalho é parte de uma seção que continua até que outra seção seja iniciada. A seção [dependencies] é onde você diz ao Cargo de quais crates externos seu projeto depende e de quais versões desses crates você precisa. Nesse caso, especificaremos o crate rand com o especificador de versão semântica 0.5.5. Cargo entende o Controle de Versão Semântico (às vezes chamado de SemVer), que é um padrão para escrever números de versão. O número 0.5.5 é, na verdade, uma abreviação de ^0.5.5, o que significa qualquer versão que esteja no mínimo 0.5.5 abaixo de 0.6.0. Cargo considera que essas versões têm APIs públicas compatíveis com a versão 0.5.5.
Agora, sem alterar nenhum código, vamos construir o projeto, conforme mostrado na Listagem 2-2.
C:\Users\user\projetos\guessing_game>cargo build
Updating crates.io index
Downloaded rand v0.5.6
Downloaded rand_core v0.3.1
Downloaded rand_core v0.4.2
Downloaded winapi v0.3.9
Downloaded 4 crates (1.4 MB) in 4.38s (largest was `winapi` at 1.2 MB)
Compiling winapi v0.3.9
Compiling rand_core v0.4.2
Compiling rand_core v0.3.1
Compiling rand v0.5.6
Compiling guessing_game v0.1.0 (C:\Users\user\projetos\guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2m 18s
Listagem 2-2: A saída da execução cargo build após adicionar o crate rand como uma dependência
Você pode ver números de versão diferentes (mas todos eles serão compatíveis com o código, graças ao SemVer!), Linhas diferentes (dependendo do sistema operacional) e as linhas podem estar em uma ordem diferente.
Agora que temos uma dependência externa, o Cargo busca as versões mais recentes de tudo no registro, que é uma cópia dos dados de Crates.io. Crates.io é onde as pessoas no ecossistema Rust publicam seus projetos Rust de código aberto para outros usarem.
Depois de atualizar o registro, o Cargo verifica a seção [dependencies] e baixa todos os crates que você ainda não tiver. Neste caso, apesar de listarmos apenas rand como dependência, Cargo também baixou libc e rand_core, porque rand depende deles para funcionar. Depois de baixar os crates, Rust os compila e então compila o projeto com as dependências disponíveis.
Se você executar imediatamente cargo build novamente sem fazer nenhuma alteração, não obterá nenhuma saída além da linha Finished. O Cargo sabe que já baixou e compilou as dependências e você não alterou nada sobre elas no arquivo Cargo.toml. O Cargo também sabe que você não mudou nada em seu código, então também não o recompila. Sem nada para fazer, ele simplesmente sai.
Se você abrir o arquivo src/main.rs, fizer uma alteração trivial, salvá-lo e compilá-lo novamente, verá apenas duas linhas de saída:
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs
Essas linhas mostram que o Cargo atualiza apenas a construção com sua pequena alteração no arquivo src/main.rs. Suas dependências não mudaram, então Cargo sabe que pode reutilizar o que já baixou e compilou para elas. Ele apenas reconstrói sua parte do código.
Garantindo construções reproduzíveis com o arquivo Cargo.lock
O Cargo tem um mecanismo que garante que você possa reconstruir o mesmo artefato sempre que você ou qualquer outra pessoa criar seu código: o Cargo usará apenas as versões das dependências especificadas até que você indique o contrário. Por exemplo, o que acontecerá se na próxima semana a versão 0.5.6 do crate rand for lançada e contiver uma correção de bug importante, mas também contiver uma regressão que quebrará seu código?
A resposta para esse problema é o arquivo Cargo.lock, que foi criado na primeira vez que você executou cargo builde em seu diretório guessing_game. Quando você constrói um projeto pela primeira vez, o Cargo descobre todas as versões das dependências que atendem aos critérios e as grava no arquivo Cargo.lock. Quando você construir seu projeto no futuro, Cargo verá que o arquivo Cargo.lock existe e usará as versões especificadas lá em vez de fazer todo o trabalho de descobrir as versões novamente. Isso permite que você tenha uma construção reproduzível automaticamente. Em outras palavras, seu projeto permanecerá em 0.5.5 até que você atualize explicitamente, graças ao arquivo Cargo.lock.
Atualizando um crate para obter uma nova versão
Quando você não deseja atualizar um crate, cargo fornece outro comando, update que irá ignorar o arquivo Cargo.lock e descobrir todas as últimas versões que atendem às suas especificações em Cargo.toml. Se funcionar, o Cargo gravará essas versões no arquivo Cargo.lock.
Mas por padrão, o Cargo procurará apenas versões maiores que 0.5.5 e menores que 0.6.0. Se o crate rand lançou duas novas versões 0.5.6 e 0.6.0, você veria o seguinte se executasse cargo update:
$ cargo update
Updating crates.io index
Updating rand v0.5.5 -> v0.5.6
Neste ponto, você também notaria uma mudança em seu arquivo Cargo.lock, observando que a versão do crate rand que você está usando agora é 0.5.6.
Se você quiser usar a versão do rand 0.6.0 ou qualquer versão da série 0.6.x, terá que atualizar o arquivo Cargo.toml para ficar assim:
[dependencies]
rand = "0.6.0"
Na próxima vez que você executar cargo build, o Cargo atualizará o registro de crates disponíveis e reavaliará seus requisitos rand de acordo com a nova versão que você especificou.
Há muito mais a dizer sobre Cargo e seu ecossistema, que discutiremos no Capítulo 14, mas por enquanto, isso é tudo que você precisa saber. O Cargo facilita a reutilização de bibliotecas, de modo que os Rustáceos são capazes de escrever projetos menores que são montados a partir de vários pacotes.
Gerando um Número Aleatório
Agora que você adicionou crate rand ao arquivo Cargo.toml, vamos começar a usar rand. A próxima etapa é atualizar src/main.rs, conforme mostrado na Listagem 2-3.
Nome do arquivo: src/main.rs
use std::io;
use rand::Rng;
fn main() {
println!("Adivinhe o número!");
let numero_secreto = rand::thread_rng().gen_range(1, 101);
println!("O número secreto é: {}", numero_secreto);
println!("Por favor entre com o seu palpite.");
let mut palpite = String::new();
io::stdin()
.read_line(&mut palpite)
.expect("Falha ao ler a linha.");
println!("Seu palpite: {}", palpite);
}Listagem 2-3: Adicionando código para gerar um número aleatório
Primeiro, adicione uma linha use: use rand::Rng. A característica Rng define métodos que os geradores de números aleatórios implementam, e essa característica deve estar no escopo para que possamos usar esses métodos. O Capítulo 10 abordará as características em detalhes.
Em seguida, estamos adicionando duas linhas no meio. A função rand::thread_rng nos dará o gerador de número aleatório específico que vamos usar: um que é local para o thread atual de execução e propagado pelo sistema operacional. Em seguida, chamamos o método gen_range no gerador de números aleatórios. Esse método é definido pela característica Rng que colocamos no escopo com a instrução use rand::Rng. O método gen_range recebe dois números como argumentos e gera um número aleatório entre eles. É inclusivo no limite inferior, mas exclusivo no limite superior, portanto, precisamos especificar 1 e 101 para solicitar um número entre 1 e 100.
Nota: Você não saberá apenas quais características usar e quais métodos e funções chamar de uma crate. As instruções para usar uma crate estão na documentação de cada crate. Outro recurso interessante do Cargo é que você pode executar o comando
cargo doc --open, que criará a documentação fornecida por todas as suas dependências localmente e abri-la em seu navegador. Se você estiver interessado em outras funcionalidades da craterand, por exemplo, executecargo doc --opene cliquerandna barra lateral à esquerda.
A segunda linha que adicionamos no meio do código imprime o número secreto. Isso é útil enquanto estamos desenvolvendo o programa para poder testá-lo, mas vamos excluí-lo da versão final. Não será um grande jogo se o programa imprimir a resposta assim que for iniciado!
Tente executar o programa algumas vezes:
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `target/debug/guessing_game`
Adivinhe o número!
O número secreto é: 75
Por favor entre com o seu palpite.
9
Seu palpite: 9
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/guessing_game`
Adivinhe o número!
O número secreto é: 46
Por favor entre com o seu palpite.
2
Seu palpite: 2
Você deve obter diferentes números aleatórios, e todos devem ser números entre 1 e 100. Ótimo trabalho!
Comparando o palpite com o número secreto
Agora que temos a entrada do usuário e um número aleatório, podemos compará-los. Essa etapa é mostrada na Listagem 2-4. Observe que este código ainda não compilará, como explicaremos.
Nome do arquivo: src/main.rs
Esse código não compila.
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
// --recorte--
println!("Seu palpite: {}", palpite);
match guess.cmp(&numero_secreto) {
Ordering::Less => println!("Muito baixo!"),
Ordering::Greater => println!("Muito alto!"),
Ordering::Equal => println!("Você ganhou!"),
}
}
Listagem 2-4: Lidando com os possíveis valores de retorno da comparação de dois números
O primeiro novo pedaço aqui é outra instrução use, trazendo um tipo chamado std::cmp::Ordering para o escopo da biblioteca padrão. Como Result, Ordering é outro enum, mas as variantes de Ordering são Less (menor), Greater (maior) e Equal (igual). Esses são os três resultados possíveis quando você compara dois valores.
Em seguida, adicionamos cinco novas linhas na parte inferior que usam o tipo Ordering. O método cmp compara dois valores e pode ser chamado em qualquer coisa que possa ser comparada. Ele faz referência a tudo o que você deseja comparar: aqui está comparando o palpite com o numero_secreto. Em seguida, ele retorna uma variante enum do Ordering que incluímos no escopo com a instrução use. Usamos uma expressão match para decidir o que fazer a seguir com base em qual variante de Ordering foi retornada da chamada de cmp com os valores em palpite e numero_secreto.
Uma expressão match é feita de ramificações. Uma ramificação consiste em um padrão e no código que deve ser executado se o valor dado ao início da expressão match se ajustar ao padrão dessa ramificação. Rust pega o valor dado a match e examina o padrão de cada ramificação sucessivamente. A construção match e os padrões são recursos poderosos no Rust que permitem expressar uma variedade de situações que seu código pode encontrar e certificar-se de lidar com todas elas. Esses recursos serão abordados em detalhes no Capítulo 6 e Capítulo 18, respectivamente.
Vamos examinar um exemplo do que aconteceria com a expressão match usada aqui. Digamos que o usuário digitou 50 e o número secreto gerado aleatoriamente é 38. Quando o código comparar 50 com 38, o método cmp retornará Ordering::Greater, porque 50 é maior que 38. A expressão match obtém o valor Ordering::Greater e começa a verificar o padrão de cada ramificação. Ele examina o padrão da primeira ramificação Ordering::Less, e vê que o valor Ordering::Greater não corresponde a Ordering::Less, então ele ignora o código naquela ramificação e passa para a próxima ramificação. O padrão da próxima ramificação Ordering::Greater, corresponde a Ordering::Greater! O código associado naquela ramificação será executado e impresso Muito alto! na tela. A expressão match termina porque não há necessidade de olhar para a última ramificação neste cenário.
No entanto, o código na Listagem 2-4 ainda não será compilado. Vamos tentar:
$ cargo run
Compiling guessing_game v0.1.0 (/home/thor/Documentos/Rust/guessing_game)
error[E0308]: mismatched types
--> src/main.rs:22:23
|
22 | match palpite.cmp(&numero_secreto) {
| ^^^^^^^^^^^^^^^ expected struct `String`, found integer
|
= note: expected reference `&String`
found reference `&{integer}`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
error: could not compile `guessing_game`
To learn more, run the command again with --verbose.
O núcleo do erro afirma que existem tipos incompatíveis. Rust tem um sistema de tipo estático forte. No entanto, ele também possui inferência de tipo. Quando escrevemos let mut palpite = String::new(), Rust foi capaz de inferir que palpite deveria ser uma String e não nos fez escrever o tipo. O numero_secreto, por outro lado, é um tipo de número. Alguns tipos de número podem ter um valor entre 1 e 100: i32, um número de 32 bits; u32, um número de 32 bits sem sinal; i64, um número de 64 bits; assim como outros. O padrão de Rust é um i32, que é o tipo de numero_secreto, a menos que você adicione informações de tipo em outro lugar que façam Rust inferir um tipo numérico diferente. O motivo do erro é que Rust não pode comparar uma string e um tipo de número.
Em última análise, queremos converter a String inserida no programa como entrada em um tipo de número real para que possamos compará-lo numericamente ao número secreto. Podemos fazer isso adicionando outra linha ao corpo da função main:
Nome do arquivo: src/main.rs
use std::io;
use rand::Rng;
use std::cmp::Ordering;
fn main() {
println!("Adivinhe o número!");
let numero_secreto = rand::thread_rng().gen_range(1, 101);
println!("O número secreto é: {}", numero_secreto);
println!("Por favor entre com o seu palpite.");
let mut palpite = String::new();
io::stdin()
.read_line(&mut palpite)
.expect("Falha ao ler a linha.");
let palpite: u32 = palpite.trim().parse().expect("Por favor entre com um número!");
println!("Seu palpite: {}", palpite);
match palpite.cmp(&numero_secreto) {
Ordering::Less => println!("Muito baixo!"),
Ordering::Greater => println!("Muito alto!"),
Ordering::Equal => println!("Você ganhou!"),
}
}A linha é:
let palpite: u32 = palpite.trim().parse().expect("Por favor entre com um número!");
Criamos uma variável chamada palpite. Mas espere, o programa já não tem uma variável chamada palpite? Sim, mas Rust nos permite obscurecer o valor anterior de palpite com um novo. Este recurso é frequentemente usado em situações nas quais você deseja converter um valor de um tipo para outro. O sombreamento nos permite reutilizar o nome palpite da variável em vez de nos forçar a criar duas variáveis exclusivas, como palpite_str e palpite por exemplo. (O Capítulo 3 cobre o sombreamento com mais detalhes.)
Nos ligamos palpite à expressão palpite.trim().parse(). O palpite na expressão refere-se variável original palpite que foi uma String que recebemos como entrada. O método trim em uma instância String eliminará qualquer espaço em branco no início e no final. Embora u32 possa conter apenas caracteres numéricos, o usuário deve pressionar enter para satisfazer read_line. Quando o usuário pressiona enter, um caractere de nova linha é adicionado à string. Por exemplo, se o usuário digita 5 e presionar enter para entrar, palpite se parece com isso: 5\n. O \n representa “nova linha”, o resultado de pressionar enter. O método trim elimina \n, resultando em apenas 5.
O método parse em strings converte uma string em algum tipo de número. Como esse método podemos converter uma variedade de tipos de número, precisamos informar a Rust o tipo de número exato que queremos usar let palpite: u32. Os dois pontos (:) depois de palpite informar a Rust que anotaremos o tipo da variável. Rust tem alguns tipos de números integrados; o u32 visto aqui é um inteiro sem sinal de 32 bits. É uma boa escolha padrão para um pequeno número positivo. Você aprenderá sobre outros tipos de número no Capítulo 3. Além disso, a anotação u32 neste programa de exemplo e a comparação com numero_secreto significa que Rust inferirá que numero_secreto também deve ser um u32. Portanto, agora a comparação será entre dois valores do mesmo tipo!
A chamada para parse pode facilmente causar um erro. Se, por exemplo, a string continha A👍%, não haveria como convertê-la em um número. Como pode falhar, o método parse retorna um tipo Result, da mesma forma que o método read_line (discutido anteriormente em “Lidando com a falha potencial com o tipo Result”). Vamos tratar Result da mesma maneira, usando o método expect novamente. Se parse retornar um variante Err Result porque não foi possível criar um número a partir da string, a chamada expect travará o jogo e imprimirá a mensagem que fornecemos. Se parse puder converter com sucesso a string em um número, ele retornará a variante Ok de Result e expect o número que desejamos do valor Ok.
Vamos rodar o programa agora!
$ cargo run
Compiling guessing_game v0.1.0 (/home/thor/Documentos/Rust/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 0.67s
Running `target/debug/guessing_game`
Adivinhe o número!
O número secreto é: 9
Por favor entre com o seu palpite.
8
Seu palpite: 8
Muito baixo!
Legal! Mesmo que espaços tenham sido adicionados antes da estimativa, o programa ainda descobriu que o usuário adivinhou 76. Execute o programa algumas vezes para verificar o comportamento diferente com diferentes tipos de entrada: adivinhe o número corretamente, adivinhe um número muito alto, e adivinhe um número muito baixo.
Temos a maior parte do jogo funcionando agora, mas o usuário só pode tentar adivinhar o número uma vez. Vamos mudar isso adicionando um loop!
Permitindo várias tentativas com Looping
A palavra-chave loop cria um loop infinito. Vamos adicionar isso agora para dar aos usuários mais chances de adivinhar o número:
Nome do arquivo: src/main.rs
use std::io;
use rand::Rng;
use std::cmp::Ordering;
fn main() {
println!("Adivinhe o número!");
let numero_secreto = rand::thread_rng().gen_range(1, 101);
println!("O número secreto é: {}", numero_secreto);
loop {
println!("Por favor entre com o seu palpite.");
let mut palpite = String::new();
io::stdin()
.read_line(&mut palpite)
.expect("Falha ao ler a linha.");
let palpite: u32 = palpite.trim().parse().expect("Por favor entre com um número!");
println!("Seu palpite: {}", palpite);
match palpite.cmp(&numero_secreto) {
Ordering::Less => println!("Muito baixo!"),
Ordering::Greater => println!("Muito alto!"),
Ordering::Equal => println!("Você ganhou!"),
}
}
}
Como você pode ver, movemos tudo do prompt de entrada de adivinhação em diante para dentro de loop. Certifique-se de recuar as linhas dentro do loop mais quatro espaços cada e execute o programa novamente. Observe que há um novo problema porque o programa está fazendo exatamente o que dissemos para ele fazer: peça outro palpite para sempre! Não parece que o usuário pode sair!
O usuário sempre pode interromper o programa usando o atalho de teclado ctrl-c. Mas há outra maneira de escapar desse monstro insaciável, conforme mencionado na discussão parse em “Comparando a Suposição com o Número Secreto”: se o usuário digitar uma resposta não numérica, o programa irá travar. O usuário pode tirar vantagem disso para sair, conforme mostrado aqui:
>cargo run
Compiling guessing_game v0.1.0 (C:\Users\user\projetos\guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 27.11s
Running `target\debug\guessing_game.exe`
Adivinhe o número!
O número secreto é: 91
Por favor entre com o seu palpite.
76
Seu palpite: 76
Muito baixo!
Por favor entre com o seu palpite.
100
Seu palpite: 100
Muito alto!
Por favor entre com o seu palpite.
91
Seu palpite: 91
Você ganhou!
Por favor entre com o seu palpite.
sair
thread 'main' panicked at 'Por favor entre com um número!: ParseIntError { kind: InvalidDigit }', src\main.rs:22:51
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: process didn't exit successfully: `target\debug\guessing_game.exe` (exit code: 101)
Digitando sair realmente fecha o jogo, mas o mesmo acontecerá com qualquer outra entrada não numérica. No entanto, isso não é ideal para dizer o mínimo. Queremos que o jogo pare automaticamente quando o número correto for adivinhado.
Sair após um palpite correto
Vamos programar o jogo para encerrar quando o usuário vencer, adicionando uma declaração break:
Nome do arquivo: src/main.rs
match palpite.cmp(&numero_secreto) {
Ordering::Less => println!("Muito baixo!"),
Ordering::Greater => println!("Muito alto!"),
Ordering::Equal => {
println!("Você ganhou!");
break;
}
}
Adicionar a linha break após Você ganhou! faz com que o programa saia do loop quando o usuário adivinhar o número secreto corretamente. Sair do loop também significa sair do programa, porque o loop é a última parte da função main.
Tratamento de entrada inválida
Para refinar ainda mais o comportamento do jogo, em vez de travar o programa quando o usuário insere um não-número, vamos fazer o jogo ignorar um não-número para que o usuário possa continuar adivinhando. Podemos fazer isso alterando a linha onde palpite é convertida de String para um u32, conforme mostrado na Listagem 2-5.
Nome do arquivo: src/main.rs
use std::io;
use rand::Rng;
use std::cmp::Ordering;
fn main() {
println!("Adivinhe o número!");
let numero_secreto = rand::thread_rng().gen_range(1, 101);
println!("O número secreto é: {}", numero_secreto);
loop {
println!("Por favor entre com o seu palpite.");
let mut palpite = String::new();
io::stdin()
.read_line(&mut palpite)
.expect("Falha ao ler a linha.");
let palpite: u32 = match palpite.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("Seu palpite: {}", palpite);
match palpite.cmp(&numero_secreto) {
Ordering::Less => println!("Muito baixo!"),
Ordering::Greater => println!("Muito alto!"),
Ordering::Equal => {
println!("Você ganhou!");
break;
}
}
}
}Listagem 2-5: Ignorando um palpite não numérico e pedindo outro palpite em vez de travar o programa.
Mudar de uma chamada expect para uma expressão match é como você geralmente muda de um erro para lidar com o erro. Lembre-se de que parse retorna um tipo Result e Result é um enum que possui as variantes Ok ou Err. Estamos usando uma expressão match aqui, como fizemos com o resultado Ordering do método cmp.
Se parse for capaz de transformar a string em um número com sucesso, ele retornará o valor Ok que contém o número resultante. Esse valor Ok corresponderá ao padrão da primeira ramificação e a expressão match apenas retornará o valor num que parse produziu e colocou dentro do valor Ok. Esse número vai acabar exatamente onde o queremos na nova variável palpite que estamos criando.
Se parse não for capaz de transformar a string em um número, ele retornará um valor que contém mais informações sobre o erro. O valor não corresponde ao padrão na primeira ramificação, mas corresponde ao padrão na segunda ramificação. O sublinhado, _, é um valor genérico; neste exemplo, estamos dizendo que queremos combinar todos os valores, não importa quais informações eles tenham dentro deles. Portanto, o programa executará o código da segunda ramificação, que diz ao programa para ir para a próxima iteração e solicitar outro palpite. Portanto, efetivamente, o programa ignora todos os erros que possa encontrar!
Agora, tudo no programa deve funcionar conforme o esperado. Vamos tentar:
>cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.18s
Running `target\debug\guessing_game.exe`
Adivinhe o número!
O número secreto é: 17
Por favor entre com o seu palpite.
5
Seu palpite: 5
Muito baixo!
Por favor entre com o seu palpite.
56
Seu palpite: 56
Muito alto!
Por favor entre com o seu palpite.
sair
Por favor entre com o seu palpite.
17
Seu palpite: 17
Você ganhou!
Impressionante! Com um pequeno ajuste final, terminaremos o jogo de adivinhação. Lembre-se de que o programa ainda está imprimindo o número secreto. Funcionou bem para o teste, mas estragou o jogo. Vamos deletar o println! que mostra o número secreto. A Listagem 2-6 mostra o código final.
Nome do arquivo: src/main.rs
use std::io;
use rand::Rng;
use std::cmp::Ordering;
fn main() {
println!("Adivinhe o número!");
let numero_secreto = rand::thread_rng().gen_range(1, 101);
loop {
println!("Por favor entre com o seu palpite.");
let mut palpite = String::new();
io::stdin()
.read_line(&mut palpite)
.expect("Falha ao ler a linha.");
let palpite: u32 = match palpite.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("Seu palpite: {}", palpite);
match palpite.cmp(&numero_secreto) {
Ordering::Less => println!("Muito baixo!"),
Ordering::Greater => println!("Muito alto!"),
Ordering::Equal => {
println!("Você ganhou!");
break;
}
}
}
}Listagem 2-6: Código completo do jogo de adivinhação
Resumo
Neste ponto, você construiu com sucesso o jogo de adivinhação. Parabéns!
Este projeto foi uma maneira "mãos à obra" de apresentá-lo a muitos conceitos novos do Rust: let, match, métodos, funções associadas, o uso de crates externos, e muito mais. Nos próximos capítulos, você aprenderá sobre esses conceitos com mais detalhes. O Capítulo 3 cobre os conceitos que a maioria das linguagens de programação tem, como variáveis, tipos de dados e funções, e mostra como usá-los no Rust. O Capítulo 4 explora a propriedade, um recurso que torna o Rust diferente de outras linguagens. O Capítulo 5 discute estruturas e sintaxe de método, e o Capítulo 6 explica como funcionam os enums.
Traduzido por Acervo Lima. O original pode ser acessado aqui.
