RUST > RUST{PRINT!} > RUST{VARIÁVEIS!}

Rust {Variáveis!}

Variáveis são como pequenas caixas dentro de um programa onde você armazena dados. Pense nelas como etiqueta que você coloca em objetos para identificá-los e usa-los. Cada caixa contém um tipo específico de dado, como um número, uma palavra ou um valor lógico sendo eles verdadeiro ou falso. Em Rust, as variáveis são imutáveis por padrão, o que significa que seu valor não pode ser alterado após a inicialização. Essa característica promove a segurança e a previsibilidade do código. Novembro - 07/2024

Variáveis, mutabilidade, constante, sombreamento e escopo

a. Variáveis

let nome = valor;
let : deve ser usado antes de cada variável;
nome : deve ser usado para nomear;
= valor : você deve definir o valor.

Exemplo:

            
    fn main () {

      // Variaveis
      // let nome = "valor";

      let name = "Alice";
      println!("Qual o seu nome: {}", name);
      println!("------------------------------");
    
      let num = 24;
      println!("Qual número você escolheu? {}", num);
      println!("------------------------------");
    
      let letter = 'a';
      println!("Qual é a primeira letra que vem à sua mente? {}", letter);
      println!("------------------------------");
    
      let ok = true;
      println!("1 + 1 é igual a dois? {}", ok);
      println!("------------------------------");

    }

Rust Playground: Acesse

b. Mutabilidade

let mut name = valor;
Adicione 'mut' após 'let' para alterar o valor de uma variável.

Exemplo:

            
    fn main () {

        // Variaveis
        // let nome = "valor";
  
        let mut name = "Alice";
        println!("Qual o seu nome: {}", name);
        println!("------------------------------");
      
        name = "Carlos";
        println!("Qual o seu nome: {}", name);
        println!("------------------------------");
      

        let mut num = 24;
        println!("Qual número você escolheu? {}", num);
        println!("------------------------------");
      
        num = 12;
        println!("Qual número você escolheu? {}", num);
        println!("------------------------------");
      

        let mut letter = 'a';
        println!("Qual é a primeira letra que vem à sua mente? {}", letter);
        println!("------------------------------");
      
        letter = 'b';
        println!("Qual é a primeira letra que vem à sua mente? {}", letter);
        println!("------------------------------");
      

        let mut ok = true;
        println!("1 + 1 é igual a dois? {}", ok);
        println!("------------------------------");

        ok = false;
        println!("1 + 1 é igual a dois? {}", ok);
        println!("------------------------------");
        
    }

Rust Playground: Acesse

c. Constante

const NOME : tipo = valor;
Uma constante não pode ser alterada depois de receber um valor;
As constantes devem ser declaradas em maiúsculas e ter um tipo explícito.

Exemplo:

            
    fn main () {
  
        // const
        // const NOME : TIPO = valor;

        const NUM : u8 = 1;
        println!("{}", NUM);
        println!("------------------------------");
        
        // Erro
        let const NUM : u8 = 4;
        println!("{}", NUM);
        println!("------------------------------");
        
        // Erro
        const mut NUM : u8 = 5;
        println!("{}", NUM);
        println!("------------------------------");
        teste = 10;
        
    }

Rust Playground: Acesse

d. Sombreamento

let nome = "Alice";
let nome = "Carlos";
O sombreamento de uma variável é feito declarando uma nova com o mesmo nome.

Exemplo:

            
    fn main () {

        // shadowing
    
        let comida = "pão";
        println!("{}", comida);
        println!("------------------------------");
    
        let comida = "leite";
        println!("{}", comida);
        println!("------------------------------");
        
        let comida = "pizza";
        println!("{}", comida);
        println!("------------------------------");
        
    }

Rust Playground: Acesse

e. Escopo

Quando um bloco de código é colocado entre chaves {}, ele entra em um novo escopo, que é aninhado dentro do escopo do programa principal.

Exemplo:

            
    fn main () {

        // scope
        let x = 1;
        println!("{}", x);
        println!("------------------------------");
    
        {

          let x = 2;
          println!("{}", x);
          // resultado = 2
          println!("------------------------------");
        
        }
    
        println!("{}", x);
        println!("------------------------------");
        
    }

Rust Playground: Acesse

Rust {Variáveis!}

Variáveis, mutabilidade, constante, sombreamento e escopo

a. Variáveis

b. Mutabilidade

c. Constante

d. Sombreamento

e. Escopo

Post: