Bun: O runtime JavaScript desafiando o Node.js e o Deno

Bun é um novo runtime JavaScript extremamente rápido que está causando muita discussão. Para entender por que Bun é tão importante, vamos primeiro revisar um pouco da história importante do JavaScript.

Tabela de conteúdo:

O que é um motor JavaScript?
Apresentando os runtimes do JavaScript
O que é o Bun?
Testando o Bun
Escrevendo e executando nosso primeiro script Bun
Escrevendo arquivos com Bun
Suporte integrado para SQLite3
Usando arquivos .env com Bun

O que é um motor JavaScript?

Quando o JavaScript foi criado, ele só podia ser executado em navegadores, originalmente no Netscape Navigator. No entanto, os desenvolvedores precisavam de um software que pudesse ler o código JavaScript e transformá-lo em algo que pudesse ser executado no computador. Essa tecnologia é conhecida como motor JavaScript. Até o momento existem três principais motores JavaScript que impulsionam seus navegadores favoritos:

V8: Criado pelo Google para o Chrome
SpiderMonkey: Criado pela Mozilla para o Firefox
JavaScriptCore: Criado pela Apple para o Safari

Cada motor JavaScript possui pequenas diferenças em seu suporte para a especificação do JavaScript, rapidez na adoção de novos recursos do JavaScript, facilidade de uso e desempenho.

Apresentando os runtimes do JavaScript

Eventualmente, em 2009, Ryan Dahl começou a desenvolver uma ferramenta que permitiria que o JavaScript fosse executado fora do navegador. Ao escolher um motor para construir essa ferramenta, ele escolheu o V8.

O que ele criou foi um runtime JavaScript, uma ferramenta para executar o JavaScript fora do navegador. Ele deu ao JavaScript acesso à sua rede de computadores mais ampla e aos sistemas de arquivos para criar servidores da web e qualquer tipo de aplicativo que você possa imaginar.

O Node.js desde então explodiu em popularidade, tornando-se uma ferramenta essencial no desenvolvimento web de frontend e backend. Quando o Node.js foi criado, muitos padrões modernos de JavaScript ainda não existiam, como a API Fetch, os módulos ES e outros.

Vendo o crescimento do TypeScript e a robustez dos padrões da web, Ryan Dahl criou um sucessor do Node.js usando Rust, chamado Deno. O Deno oferecia melhorias de velocidade, adoção dos padrões da web e suporte de primeira classe ao TypeScript e ao JSX.

O que é o Bun?

Em 2022, o desenvolvedor da Stripe Jared Sumner lançou o Bun. O Bun é um runtime desenvolvido na linguagem de programação Zig, que também adota os padrões da web, mas tem como objetivo a compatibilidade com as APIs do Node.js, para que os desenvolvedores possam migrar facilmente o código existente.

Uma das escolhas mais interessantes é que o Bun usa o JavaScriptCore como seu motor, ao contrário do Node.js e do Deno, que usam o V8. O resultado é um tempo de execução extremamente rápido que também oferece várias ferramentas úteis para os desenvolvedores de JavaScript.

O Bun também possui integração de primeira classe com TypeScript e JSX. Ele tem como objetivo fornecer muitos dos recursos de transpiladores, como Babel, e de empacotadores como Webpack, Rollup, Snowpack e Vite.

Testando o Bun

Para começar a usar o Bun, primeiro, precisamos instalá-lo. De acordo com a documentação do Bun, a instalação requer apenas o seguinte comando:

curl https://bun.sh/install | bash Lembre-se de que este comando funcionará apenas no Mac e no Linux. Portanto, se você estiver usando o Windows, precisará configurar o Subsistema Windows para Linux para instalar o Bun.

Depois que a instalação estiver concluída, certifique-se de ler a mensagem de confirmação com instruções para adicionar o Bun ao seu PATH. Isso exigirá que você adicione as seguintes linhas aos seus arquivos .bashrc ou .zshrc:

BUN_INSTALL="/home/<username>/.bun" PATH="$BUN_INSTALL/bin:$PATH" Agora, se você executar o comando "bun--version", deverá receber um número de versão impresso confirmando que o Bun foi instalado corretamente.

Escrevendo e executando nosso primeiro script Bun

Crie um arquivo chamado script.js e adicione o seguinte código dentro dele:

Bun.serve({
    fetch(request){
        return new Response("Hello World")
    }
})
console.log("Listening on Port 3000")

Bun.serve inicia o servidor e recebe um objeto com as configurações do servidor. Em cada solicitação, o objeto de solicitação é passado para uma função armazenada na propriedade fetch do objeto de configuração.

Podemos executar o Bun.serve usando o comando "bun run script.js" e depois acessar o endereço "localhost:3000" para ver a resposta à nossa solicitação. Se quisermos alterar a porta em que o servidor é executado, podemos adicionar uma propriedade de porta ao objeto passado para Bun.serve.

Escrevendo arquivos com Bun

Bun possui uma API bastante simples para escrita em arquivos. Vamos modificar nosso script para escrever em um arquivo toda vez que enviarmos uma solicitação:

let count = 1
Bun.serve({
    fetch(request){
        Bun.write(`${count}.txt`, request.url)
        count += 1
        return new Response("Hello World")
    },
})
console.log("Listening on Port 3000")

Execute o código acima e visite localhost:3000/cheese, e você verá dois novos arquivos criados, 1.txt e 2.txt. O primeiro argumento do Bun.write é o destino da escrita, como um arquivo ou stdout, e o segundo argumento é o que escrever.

Suporte integrado para SQLite3

Ao contrário de outros ambientes de execução JavaScript, você não precisa instalar o SQLite3 porque ele vem integrado por padrão. Vamos criar um novo arquivo chamado db.js com o seguinte código:

import { Database } from "bun:sqlite";
// Cria um novo arquivo de banco de dados
const db = new Database("db.sqlite3");
// Cria uma tabela no banco de dados
db.run("CREATE TABLE IF NOT EXISTS cheeses (name VARCHAR(100));")
// Insere alguns valores na tabela
db.run("INSERT INTO cheeses VALUES ('gouda'), ('munster'), ('brie');")
// Consulta a tabela
const result = db.query("SELECT * FROM cheeses;").all()
// Registra os resultados
console.log(result)

Execute o código com bun run db.js e você deverá ver os registros inseridos registrados no terminal.

Usando arquivos .env com Bun

Outra funcionalidade muito interessante é a capacidade de usar arquivos .env integrados. Você pode simplesmente acessá-los com process.env como em Node.js, sem precisar instalar bibliotecas adicionais. Crie um arquivo .env com o seguinte comando:

VARIABLE=cheddar

Agora, vamos atualizar nosso script.js com o seguinte código:

// let count = 1
Bun.serve({
    fetch(request){
        // Bun.write(`${count}.txt`, request.url)
        // count += 1
        return new Response(process.env.VARIABLE)
    },
})
console.log("Listening on Port 3000")

Agora, quando executamos bun run script.js e visitamos localhost:3000, devemos ver as informações do nosso arquivo .env sendo retornadas.

Conclusão

Além de ser extremamente rápido, Bun possui algumas funcionalidades muito interessantes que tornam muitas das tarefas mais mundanas, como escrever arquivos, gerenciar bancos de dados simples e usar variáveis ambientais, bastante fáceis.

Será que Bun irá superar Deno e desafiar Node.js por seu trono? Teremos que esperar para ver. Bun, assim como Deno, certamente apresentará muitas inovações que Node.js pode adotar enquanto esculpe seu próprio espaço.

De qualquer forma, é uma grande vitória para os desenvolvedores JavaScript terem mais um ambiente de execução no espaço. No momento em que este texto foi escrito, Bun ainda está em seus estágios iniciais de desenvolvimento, com muitas APIs e funcionalidades ainda não implementadas. No entanto, o que está disponível até agora é bastante impressionante, então vale a pena acompanhar.