DEV Community: João Gugel

Closures no Javascript

João Gugel — Tue, 27 May 2025 01:41:49 +0000

Closure é uma função que “lembra” do escopo onde foi criada, mantendo o acesso às variáveis desse escopo mesmo depois da função externa terminar. Assim, ela pode guardar e atualizar valores ao longo do tempo.

Exemplo de closure:

const completeUsername = () => {
    const username = "João Vitor Gugel";

    const formatName = () => {
        const names = username.split(" ");
        return `${names[0]} ${names[names.length - 1]}`;
    };

    return formatName;
};

const myClosure = completeUsername();

console.log(myClosure());

Perceba que a função formatName tem acesso a variável username, mas a variável username não fica exposta fora da função, ela está protegida e apenas o que está dentro da função externa (completeUsername) tem acesso a esses dados.

No Javascript, as funções aninhadas tem acesso às variáveis declaradas no seu escopo externo.

Como uma closure guarda os valores

Ao escrever e executar uma função em Javascript, espera-se que o comportamento normal seja limpar os dados que pertencem apenas ao escopo dessa função quando ela terminar de ser executada, então os dados armazenados durante o processamento da função são removidos da memória, certo?

Com uma closure fica um pouco diferente. Ao declarar uma closure (uma função dentro de outra) a função interna mantém acesso às variáveis da função externa, mesmo que ela já tenha sido executada, então os dados continuam válidos sempre que a closure for chamada.

Como funciona? Veja um exemplo.

const contador = (numero: number) => {
    return () => {
        numero++;
        console.log(numero);
    };
};

const contador1 = contador(5); // Começa em 5

contador1() // Vira 6 
contador1() // Vira 7

Criamos uma função contador que retorna uma closure responsável por incrementar o valor da variável numero, que está em seu escopo léxico.

Essa função é iniciada com o valor 5 e, ao chamarmos a função retornada (a closure), ela mantém o acesso ao valor original passado para contador. Assim, toda vez que executamos contador1(), incrementamos o número anterior, que continua salvo na memória graças à closure. O valor não é perdido entre as chamadas, mesmo que a função contador já tenha terminado sua execução.

Aplicando uma closure mais complexa

Vamos criar uma função que retorna uma closure para verificar se um usuário tem permissão para executar uma determinada ação.

const criarSistemaDePermissao = (cargo: "administrador" | "leitor") => {
    return (acao: string) => {
        const permissoes = {
            administrador: ["criar", "editar", "ler", "remover"],
            leitor: ["ler"],
        };
        return permissoes[cargo].includes(acao);
    };
};

const administrador = criarSistemaDePermissao("administrador");
const leitor = criarSistemaDePermissao("leitor");

const leitorPodeCriar = leitor("criar"); // false
const administradorPodeRemover = administrador("remover"); // true

Nesse exemplo criamos um cenário mais próximo do mundo real, como um sistema de permissões de uma aplicação com diferentes tipos de usuários.

Usamos a closure para criar uma função fábrica para administradores e leitores, assim criamos um sistema personalizado para cada tipo de usuário.

Como estamos usando uma closure, essa closure vai manter o estado, isso é, continua tendo acesso ao tipo de cargo definido quando a função foi executada pela primeira vez, assim, conseguimos usar a nossa closure para checar se o usuário que ela mantém armazenado possuí permissão para executar X ação.

Encapsulamento com closures

Assim como na orientação objetos, podemos usar closures para encapsular dados dentro de funções e restringir o acesso direto a eles, isso nos permite proteger o estado interno da nossa função e expor apenas o que for necessário utilizando funções com controle.

Veja o exemplo:

const meuCarrinhoDeCompras = () => {
    let itens: string[] = [];

    const adicionarItem = (item: string) => {
        itens.push(item);
    };

    const removerUltimoItem = () => {
        itens.pop();
    };

    const pegarItens = () => {
        return itens;
    };

    return { adicionarItem, removerUltimoItem, pegarItens };
};

const carrinho1 = meuCarrinhoDeCompras();

carrinho1.adicionarItem("maçã"); // [maçã]
carrinho1.adicionarItem("pera"); // [maçã, pera]
carrinho1.pegarItens(); // [maça, pera]
carrinho1.removerUltimoItem(); // [maçã]

Criamos uma closure para manter o acesso aos dados de um carrinho de compras. Isso nos permite proteger a variável interna itens, impedindo que ela seja acessada ou modificada diretamente

Quando usar uma closure?

Espero que os exemplos que dei tenham ajudado a entender as utilidades das closures. Elas podem ser muito úteis em várias situações do dia a dia, como:

Manter o estado entre chamadas de uma função.
Encapsular dados para restringir acessos/modificações não controladas.
Manter o contexto de uma função, mesmo após ter sido executada.
Criar funções fábrica, como no exemplo do sistema de permissões, que cria configurações distintas para administrador e leitor.

Cuidado com a memória

Closures mantêm em memória todas as variáveis do escopo externo, mesmo quando não estão sendo usadas. Por isso, evite manter dados desnecessários dentro delas. Quando precisar, limpe referências que não são mais necessárias para evitar consumo excessivo de memória.

Convertendo números binários para decimais com RUST!

João Gugel — Sat, 06 Apr 2024 23:06:07 +0000

Ver Código Final

Como Funciona a Conversão de Binários Para Decimais?

Para converter um número na base 2 (binário) para um número na base 10 (decimal), multiplicamos cada digito do número binário pela potência de 2 relativa à posição que ele está ocupando:

Exemplo, no número binário 1010, pegamos as posições de trás pra frente começando do 0:

0: Posição 0
1: Posição 1
0: Posição 2
1: Posição 3

Agora o calculo ficaria assim: 0 * 2⁰ + 1 * 2¹ + 0 * 2² + 1 * 2³ = 10 no sistema decimal.

Mão na Massa

Pronto, sabendo como funciona a conversão dos sistemas numéricos vamos criar o nosso programa usando Rust. Se você preferir, sinta-se a vontade para fazer na sua linguagem de programação favorita.

Se quiser instalar o Rust, entre aqui: https://rust-book.cs.brown.edu/.

Criando Projeto

Em nosso terminal, vamos criar o projeto usando o comando cargo new binary_decimal, isso irá criar um novo programa em rust usando o gerenciador de pacotes do Rust, que nos facilita na hora de criar programas ou fazer a sua build.

Para rodar o programa, usamos cargo run dentro da pasta criada.

Após isso vamos acessar a nova pasta binary_decimal que ele criou e vamos começar a escrever o nosso código dentro do arquivo main.rs na pasta src.

Dentro do arquivo main.rs você vai ver o seguinte código:

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

O programa em Rust sempre vai procurar a função principal main para saber onde começa o seu código, tudo que fizermos vai começar dentro dela. Agora, no escopo da função main temos o código println!("Hello, world!");, um macro do Rust(não vamos nos aprofundar na diferença entre macros e funções.) que vai imprimir Hello, world! na tela assim que você executar o programa.

Escrevendo as Primeiras Linhas

Primeiro, no topo do nosso arquivo main.rs vamos importar um módulo da biblioteca padrão do Rust, que vai nos permitir ler entradas dos usuários:

use std::io;

fn main() {
    //.....
}

Agora, vamos escrever as nossas primeiras linhas do código:

use std::io;

fn main() {
    println!("Olá, escreva um número binário: ");

    let mut binary_number = String::new();
    let mut converted_numbers: Vec<u32> = Vec::new();

    io::stdin().read_line(&mut binary_number).unwrap();
}

Primeiro, chamamos o macro println! para imprimir "Olá, escreva um número binário:" no terminal, e em seguida com let mut binary_number = String::new(); criamos uma variável que poderá armazenar strings (textos) dinâmicas que podem crescer e diminuir de tamanho. Também usamos let mut converted_numbers: Vec<i32> = Vec::new(); para criar um vetor de tamanho dinâmico que armazena inteiros. Note que colocamos a palavra-chave mut antes do nome da variável, isso diz ao Rust que ela pode e vai ser modificada mais pra frente no nosso código, já que variáveis são imutáveis por padrão em Rust.

Na linha io::stdin().read_line(&mut binary_number).unwrap(); usamos método read_line dentro do módulo io para ler o que o usuário digitar no terminal, depois (&mut binary_number) diz ao Rust para pegar o valor digitado no terminal e armazenar esse valor no endereço que memória que a variável binary_number aponta, se o usuário digitar 10 então a variável binary_number estará apontando para um endereço na memória com o valor 10.

Convertendo e Armazenando Valores Binários para Decimais

Vamos adicionar mais algumas linhas:

use std::io;

fn main() {
    println!("Olá, escreva um número binário: ");

    let mut binary_number = String::new();
    let mut converted_numbers: Vec<u32> = Vec::new();

    io::stdin().read_line(&mut binary_number).unwrap();

    let mut pos = 0;

    for binary in binary_number.trim().chars().rev() {
    if binary == '1' {
            let result = 1 * 2_u32.pow(pos);
            converted_numbers.push(result);
        }
        pos += 1;
    }
}

Como aprendemos no começo, cada digito em um número binário possuí uma posição, que começa em 0 da esquerda para a direita, então criamos a variável pos que será iniciada em 0 e servirá como controle da posição em que estivermos olhando para fazer a multiplicação.

Após isso criamos um loop que passará por todos os caracteres armazenados na variável binary_number, como precisamos cuidar disso de trás pra frente usamos o método .rev() para inverter a string, também usamos o método .chars() para dizer que queremos lidar com os caracteres da string, e o método .trim() para remover os espaços em branco da string, que são adicionados quando clicamos enter para enviar, já que é um caractere válido de escape mas não queremos ele pois causaria mais problemas.

A cada caractere que passarmos no loop vamos verificar se ele é do valor 1, usando if binary == '1' e, caso seja, então vamos fazer o nosso calculo multiplicando 1 * 2 elevado a posição em que o número está, que é controlada pela variável pos, fazemos isso armazenando o resultado em uma variável result fazendo a elevação com o método pow() com

let result = 1 * 2_u32.pow(pos);`. Precisamos guardar os valores em algum lugar, já que no final de tudo precisamos somar todos os resultados para ter o nosso valor em decimal, então na linha `converted_numbers.push(result);`armazenamos o resultado da operação no nosso vetor`converted_numbers`, e, logo após, incrementamos a variável `pos`com`pos += 1;

para termos o valor da próxima posição, que aumenta de 1 em 1.

Exemplo:

Se o usuário digitar 1011, vamos fazer o loop de trás para frente. Na primeira iteração, o valor será 1 e a posição será 0. Assim, será multiplicado 1 por 2 elevado a 0, resultando em 1, que será armazenado. Em seguida, incrementamos o valor da posição em 1 e avançamos para a próxima iteração, onde o valor 1 será novamente 1 e a posição será 1, resultando em 1 multiplicado por 2 elevado a 1. Novamente, incrementamos a posição, chegando à terceira iteração, onde o valor é 0 e a posição é 2. Nessa etapa, teremos 0 multiplicado por 2 elevado a 2. Esse processo continua até percorrer todos os dígitos fornecidos pelo usuário, calculando o valor decimal correspondente à representação binária.

Somando os Valores Armazenados e Imprimindo na Tela

Escrevendo o resto do nosso código, a versão final ficará assim:

use std::io;

fn main() {
    println!("Olá, escreva um número binário: ");

    let mut binary_number = String::new();
    let mut converted_numbers: Vec<u32> = Vec::new();

    io::stdin().read_line(&mut binary_number).unwrap();

    let mut pos = 0;

    for binary in binary_number.trim().chars().rev() {
    if binary == '1' {
            let result = 1 * 2_u32.pow(pos);
            converted_numbers.push(result);
    }
    pos += 1;
    }

    let decimal_number = convert_to_decimal(&mut converted_numbers);

    println!(
    "O número binário {} em decimal é {}",
    binary_number, decimal_number
    );
}

fn convert_to_decimal(numbers: &mut Vec<u32>) -> u32 {
    let mut result = 0;

    for number in numbers {
        result += number.clone();
    }

    result
}

Primeiro, criamos fora da função main, uma nova função chamada convert_to_decimal que receberá um parâmetro chamado numbers que recebe uma referência a um vetor de inteiros.

Em (numbers: &mut Vec<u32>) dizemos o tipo do parâmetro e na parte -> u32 dizemos o que a função deverá retornar, no nosso caso, um inteiro.

Dentro da nova função criamos uma variável result que ficará responsável com o nosso calculo de todos os valores armazenados dentro do vetor que recebemos, para fazer isso iteramos sobre todos os números dentro de numbers com um loop, somando o valor da iteração atual com o valor de result, assim: result += number.clone();. O método .clone() faz com que o número seja copiado para result e não passe a sua referencia para o lugar em que está armazenado no valor, evitando bugs, e alterações indesejadas.

Por fim, criamos a variável decimal_number que recebe o resultado da função convert_to_decimal que recebe como argumento a referência do vetor que queremos iterar. let decimal_number = convert_to_decimal(&mut converted_numbers);.

Agora decimal_number tem o resultado do número convertido para decimal e imprimimos isso na tela com o macro println!:

println!(
        "O número binário {} em decimal é {}",
        binary_number, decimal_number
    );

Código Final Aqui está o código final do artigo de hoje!

FIM!

Esse é o primeiro artigo que eu faço, espero que tenham gostado e aprendido algo novo, estou sempre aberto para sugestões e dicas em que posso melhorar <3

Se curtiu, tenho alguns links que possam interessar:

The Rust Book PT-BR, essa é a versão traduzida do livro oficial de Rust, tento simplificar e traduzir pra poder aumentar um pouco do público que quer aprender essa linguagem.

tech4all Meu repositório onde pretendo guardar os códigos que escrevo nos artigos, como esse. Lá você pode encontrar esse conversor também!

Código Final Aqui está o código final do artigo de hoje!

Binário para Decimal Aqui foi onde peguei a explicação sobre como converter binários para decimal.

VALEU ❤️