Você está aqui: Rust ::: Fundamentos da Linguagem ::: Ferramenta Cargo

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta Cargo

Quantidade de visualizações: 478 vezes

Em outra dica do site nós vimos como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc, ou seja, a ferramenta de compilação do Rust. No entanto, o acesso direto a essa ferramenta só é recomendado quando estamos desenvolvendo aplicações simples, sem dependências.

Nesta dica mostrarei o processo mais comum de desenvolvimento em Rust, que é usando a ferramenta Cargo. O Cargo é o sistema de build e gerenciamento de pacotes. Ele é o responsável por, dentre várias tarefas, construir o nosso código, baixar as bibliotecas das quais dependemos e anexá-las ao resultado final do nosso programa.

Sendo assim, o primeiro passo é verificar se a ferramenta Cargo está devidamente instalada e configurada em nossa máquina. Para isso, abra uma janela de terminal e dispare o seguinte comando:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

cargo --version

A execução deste comando deverá trazer um resultado parecido com:

C:\Users\Osmar>cargo --version
cargo 1.64.0 (387270bc7 2022-09-16)

Obteve um resultado parecido? Então já podemos prosseguir.

Como criar um projeto Rust usando Cargo

Agora as coisas começam a ficar interessantes. Crie um novo diretório no seu sistema, algo como "C:\estudos_rust". Então, via janela de terminal, entre nesse diretório e dispare o seguinte comando:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

c:\estudos_rust>cargo new hello_world --bin

Pressione Enter, aguarde uns dois segundos e teremos o seguinte resultado:

Created binary (application) `hello_world` package

Vá até o diretório "C:\estudos_rust\hello_world\src" e localize o arquivo chamado main.rs. Abra-o em seu editor favorito e altere o seu conteúdo para:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

Agora, dentro do diretório "C:\estudos_rust\hello_world", dispare o seguinte comando em uma janela de terminal:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

c:\estudos_rust\hello_world>cargo build

Aguarde alguns segundos e teremos o seguinte resultado:

Compiling hello_world v0.1.0 (C:\estudos_rust\hello_world)
Finished dev [unoptimized + debuginfo] target(s) in 6.23s

Se tudo correr bem, dentro do diretório "C:\estudos_rust\hello_world\target\debug" você encontrará um arquivo chamado "hello_world.exe". Basta executá-lo com o comando abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

c:\estudos_rust\hello_world>cd target\debug
c:\estudos_rust\hello_world\target\debug>hello_world

O resultado dessa execução será algo como:

Hello, world usando Cargo

Existe uma forma de compilar o código Rust e já executá-lo de imediato. Para isso basta usarmos o comando "cargo run". Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

c:\estudos_rust\hello_world>cargo run

Agora o resultado será:

Compiling hello_world v0.1.0 (C:\estudos_rust\hello_world)
Finished dev [unoptimized + debuginfo] target(s) in 1.75s
Running `target\debug\hello_world.exe`
Hello, world usando Cargo run

Agora é só aprofundar os seus conhecimentos com nossas dicas, truque e exercícios resolvidos de Rust. Bons estudos.

Link para compartilhar na Internet ou com seus amigos:

Rust ::: Dicas & Truques ::: Strings e Caracteres

Como testar se uma string é um valor numérico em Rust usando a função is_numeric()

Quantidade de visualizações: 522 vezes

Nesta dica mostrarei como podemos verificar se uma string possui um valor numérico válido, ou seja, é composta apenas pelos dígitos de 0 a 9. Note que criei uma função validar_string_numerica() que recebe a string e retorna um valor bool, indicando se a string é um valor númerico válido ou não.

Note também o uso do método is_numeric() do tipo char para testar os caracteres individuais da string.

Veja o código Rust completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// função principal do programa Rust
fn main() {
  // vamos declarar uma string
  let numero = "3a2221";
  
  // vamos testar se a string é numérica
  if validar_string_numerica(numero.to_string()){
    println!("A string {} é numérica", numero);  
  }
  else{
    println!("A string {} não é numérica", numero);  
  }
}

// função quer permite verificar se uma string
// possui um valor numérico válido
fn validar_string_numerica(str: String) -> bool {
  // vamos varrer os caracteres da string
  for c in str.chars() {
    // o caractere atual não é numérico?
    if !c.is_numeric() {
      return false;
    }
  }
  
  // se chegou até aqui, a string é numérica
  return true;
}

Rust ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como retornar o tamanho de um array em Rust usando a função len()

Quantidade de visualizações: 541 vezes

Em várias situações nós precisamos obter e retornar a quantidade de elementos em um vetor Rust, ou seja, um array. Para isso nós podemos usar a função len() do objeto Array.

Veja um exemplo Rust no qual nós criamos um array com cinco elementos do tipo inteiro e em seguida usando a função len() para retornar o seu tamanho:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// função principal do programa Rust
fn main() {
  // vamos criar um array com 5 elementos
  let valores = [7, 3, 4, 9, 1];
  
  // agora vamos obter o tamanho do array
  let tamanho = valores.len();
  
  // e mostramos o resultado
  println!("O array possui {} elementos", tamanho);
}

Ao executar este código Rust nós teremos o seguinte resultado:

O array possui 5 elementos

Rust ::: Fundamentos da Linguagem ::: Compilador rustc

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc

Quantidade de visualizações: 520 vezes

Então você já fez a instalação do Rust, testou o seu funcionamento disparando "rustc --version" em uma janela de terminal e agora quer começar a aprender mais sobre a linguagem? Que tal começar escrevendo o famoso "Hello, World!" ("Olá, Mundo!")?

Nesta dica mostrarei como essa tarefa é fácil, principalmente se optarmos pelo uso da ferramenta rustc. Lembre-se, no entanto, que rustc é usado diretamente quando estamos escrevendo aplicações simples, provas de conceito, protótipos e coisas assim. Para aplicações mais complexas, é sempre recomendado o uso do Cargo, que é um sistema de build e gerenciador de pacotes do Rust.

Então vamos começar. Abra o seu editor de códigos favorito (tal como o Notepad++) e digite a seguinte listagem:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

fn main() {
  println!("Hello, world! Aqui é Rust na veia.");
}

Salve este arquivo como "estudos.rs" no diretório de sua preferência. Aqui eu optei por salvá-lo em um diretório chamado "C:\estudos_rust".

Agora vamos compilar nosso programa Rust. Abra uma janela de terminal e navegue até o diretório que você salvou o arquivo "estudos.rs" e dispare o comando abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

C:\Users\Osmar>cd c:\estudos_rust
c:\estudos_rust>rustc estudos.rs

Se tudo correr bem, você verá a criação de um arquivo "estudos.exe". Para executá-lo pela linha de comando nós só precisamos disparar:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

c:\estudos_rust>estudos
Hello, world! Aqui é Rust na veia.

Simples, né? No entanto, se dermos duplo-clique em cima do executável gerado, ele abre e fecha automaticamente. Não seria bom exibir uma mensagem do tipo "Pressione uma tecla para fechar..."? Basta modificar seu código para a versão abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// importamos a biblioteca io
use std::io;
use std::io::Write;

fn main() {
  println!("Hello, world! Aqui é Rust na veia.");
  
  // procedimento para pausar o programa
  let mut resposta = String::new();
  print!("\nPressione Enter para sair...");
  io::stdout().flush().unwrap();
  io::stdin().read_line(&mut resposta)
    .expect("Erro ao ler a entrada do usuário");
}

Sim, eu sei que agora nós adicionamos código demais para alcançar um detalhe tão simples. Mas, à medida que a linguagem Rust evolui, talvez os desenvolvedores resolvam simplificar esta parte. Compile o programa novamente e experimente abrir o executável com duplo-clique. Você verá que agora o programa fica aguardando o pressionamento da tecla Enter para fechar.

Vamos testar seus conhecimentos em JavaScript

Qual o resultado da execução do seguinte código JavaScript?

document.write(0.1 + 0.2 == 0.3);

A) Um erro de execução

B) true

C) 0.6

D) false

Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em JavaScript

Analise o seguinte código JavaScript

var a = new Array("teste", 1, 2, -1, -2, 0xFFFFF);
a.sort();
document.write(a);

Qual é o resultado de sua execução?

A) teste,1,2,-1,-2,1048575

B) -1,-2,1,1048575,2,teste

C) Um erro na criação do array

D) teste,-2,-1,1,2,1048575

Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em

Dimensionamento de lajes maciças à flexão

As lajes de concreto armado são elementos planos e horizontais, submetidos a carregamentos perpendiculares ao plano. Esses carregamentos promovem o desenvolvimento de esforços internos de flexão.

Analise as afirmativas a seguir referentes aos tipos de flexão:

I. A flexão normal ocorre em uma seção transversal em que atuam apenas momento fletor e esforço normal de tração ou compressão.

II. A flexão reta ocorre quando os momentos fletores atuam em planos ortogonais aos eixos principais de inércia da seção transversal.

III. Diz-se que a seção transversal de uma laje está submetida à flexão pura quando sobre ela atuam somente momentos fletores.

IV. A seção transversal de uma laje está submetida à flexão composta quando, sobre esta, atuam momentos de flexão e forças normais.

Assinale a alternativa correta:

A) Apenas a afirmativa I está correta.

B) Apenas a afirmativa III está correta.

C) As afirmativas I, II e IV estão corretas.

D) As afirmativas II, III e IV estão corretas.

E) As afirmativas I, II, III e IV estão corretas.

Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Fundações

Fundações profundas

A ABNT reconhece a execução dos seguintes tipos de estaca: madeira, aço, concreto pré-moldado, concreto moldado in loco, argamassa, calda de cimento ou qualquer combinação deles.

Com base no exposto, assinale a alternativa que define estaca metálica ou de aço.

A) Estaca armada e preenchida com argamassa de cimento e areia, moldada in loco e executada por perfuração rotativa ou rotopercussiva, revestida integralmente, no trecho em solo, por um conjunto de tubos metálicos recuperáveis.

B) Estaca executada por perfuração do solo com uma sonda ou piteira e revestimento total com camisa metálica, realizando-se gradativamente o lançamento e apiloamento do concreto, com retirada simultânea do revestimento.

C) Estaca cravada, constituída de elemento estrutural metálico produzido industrialmente, podendo ser de perfis laminados ou soldados, simples ou múltiplos, tubos de chapa dobrada ou calandrada, tubos com ou sem costura e trilhos.

D) Estaca moldada in loco, armada, executada por perfuração rotativa ou rotopercussiva e injetada com calda de cimento por um tubo com válvulas.

E) Estaca executada por perfuração do solo por trado mecânico, construída totalmente sem o emprego de revestimento ou de um fluido estabilizante.

Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em JavaScript

Qual é a forma correta de se escrever uma laço WHILE em JavaScript?

A) while (a < 10) {}

B) while a = 1 to 10

C) while (a < 10):

D) while (a < 10; a++) {}

Verificar Resposta Estudar Cards Todas as Questões

Veja mais Dicas e truques de Rust

Como somar os elementos de um array em Rust

Como testar se uma substring está contida em uma string em Rust usando a função find()

Como usar o laço while da linguagem Rust

Como inverter uma string em Rust usando os métodos chars(), rev() e collect()

Como retornar o tamanho de um array em Rust usando a função len()

Como inverter o conteúdo de uma string em Rust usando um laço loop e um vetor de chars

Como encontrar o menor elemento em um array em Rust

Como retornar a versão do Rust usando rustc --version

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc

Como acessar os caracteres individuais de uma string em Rust usando as funções chars() e nth()

Dicas e truques de outras linguagens

Java - Curso de Java - Como usar a classe String da linguagem Java

C - Como elevar uma base a um determinado expoente usando a função pow() da linguagem C

Python - Como converter Coordenadas Cartesianas para Coordenadas Polares usando Python

Java - Exercício Resolvido de Java - Usando um laço for para contar de 0 até 10 e somar todos os valores

Ruby - Como testar o tipo de uma variável em Ruby usando a função class

Delphi - Como retornar a data e hora atual em Delphi usando as funções Now() e DateTimeToStr()

Python - Como repetir os elementos de um vetor ou matriz usando a função repeat() da NumPy do Python

C - Exercício Resolvido de C - Ler três números inteiros e indicar se eles estão em ordem crescente ou decrescente

Python - Exercícios Resolvidos de Python - Ler os lados de um triângulo e informar se ele é isósceles, escaleno ou equilátero

Java - Java Swing - Como evitar a barra de rolagem horizontal em um JScrollPane

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e Fornecedores

Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais

Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby

Você está aqui: Rust ::: Fundamentos da Linguagem ::: Ferramenta Cargo

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta Cargo

Rust ::: Dicas & Truques ::: Strings e Caracteres

Como testar se uma string é um valor numérico em Rust usando a função is_numeric()

Rust ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como retornar o tamanho de um array em Rust usando a função len()

Rust ::: Fundamentos da Linguagem ::: Compilador rustc

Como escrever um "Hello, World!" na linguagem Rust usando a ferramenta rustc

Vamos testar seus conhecimentos em JavaScript

Vamos testar seus conhecimentos em JavaScript

Vamos testar seus conhecimentos em

Vamos testar seus conhecimentos em Fundações

Vamos testar seus conhecimentos em JavaScript

Questões de Concurso para Engenharia Civil

Exercícios Resolvidos

Bancos de Dados

Questões de Concurso

Frameworks

Projetos e Códigos Fonte

Especializações

Calculadoras

Ferramentas

Todas as Linguagens, Frameworks, Biliotecas e Bancos de Dados

Compre pelo WhatsApp: +55 (062) 98553-6711

E-Book 650 Dicas e Truques de Python - Com comentários em Português

PDF COM 1.200 PÁGINAS

Apenas R$ 32,90