Conversor de JSON para .env

O que é um arquivo .env?

// Generate .env lines from a JSON object in Node.js
const config = {
  DATABASE_URL: 'postgres://user:pass@localhost:5432/mydb',
  PORT: 8080,
  DEBUG: true,
  NOTE: 'value with spaces',
};

const needsQuotes = (s) => /[\s#"'\n]/.test(s);

const env = Object.entries(config)
  .map(([key, value]) => {
    if (typeof value === 'string') {
      return needsQuotes(value)
        ? `${key}=${JSON.stringify(value)}`
        : `${key}=${value}`;
    }
    return `${key}=${value ?? ''}`; // null -> empty value
  })
  .join('\n');

console.log(env);
// DATABASE_URL=postgres://user:pass@localhost:5432/mydb
// PORT=8080
// DEBUG=true
// NOTE="value with spaces"

Recursos principais

Exemplos

{
  "DATABASE_URL": "postgres://user:pass@localhost:5432/mydb",
  "PORT": 8080,
  "DEBUG": true,
  "LOG_LEVEL": "info",
  "API_KEY": "sk_live_abc123"
}

DATABASE_URL=postgres://user:pass@localhost:5432/mydb
PORT=8080
DEBUG=true
LOG_LEVEL=info
API_KEY=sk_live_abc123

{
  "GREETING": "Hello, World",
  "MOTD": "line one\nline two",
  "COLOR": "#ff0000",
  "NOTE": "value with # hash",
  "EMPTY": null
}

GREETING="Hello, World"
MOTD="line one\nline two"
COLOR="#ff0000"
NOTE="value with # hash"
EMPTY=

{
  "databaseUrl": "postgres://localhost/mydb",
  "poolSize": 10,
  "enable-signup": true
}

DATABASE_URL=postgres://localhost/mydb
POOL_SIZE=10
ENABLE_SIGNUP=true

{
  "APP_NAME": "my-app",
  "FEATURES": { "signup": true, "beta": false },
  "REGIONS": ["us-east-1", "eu-west-1"]
}

APP_NAME=my-app
FEATURES="{\"signup\":true,\"beta\":false}"
REGIONS="[\"us-east-1\",\"eu-west-1\"]"

Como usar

1. 1

   Cole seu objeto JSON

   Digite ou cole um objeto JSON plano no campo de entrada acima. Você também pode clicar em 'Carregar exemplo' para experimentar um objeto de configuração, valores que precisam de aspas ou um objeto aninhado.

2. 2

   Veja a saída .env ao vivo

   O arquivo .env aparece na hora no painel de saída. Alterne 'Normalizar chaves' para nomes em UPPER_SNAKE_CASE, ou 'Adicionar prefixo export' se o arquivo for carregado via source em um shell.

3. 3

   Copie ou baixe

   Clique em Copiar para pegar o .env na área de transferência, ou em Baixar para salvá-lo como um arquivo .env — pronto para colocar no seu projeto e carregar com o dotenv.

Armadilhas comuns do JSON

["a", "b", "c"]

{"ITEMS": "a,b,c"}

{'PORT': 8080,}

{"PORT": 8080}

{"DB": {"host": "localhost", "port": 5432}}

{"DB_HOST": "localhost", "DB_PORT": 5432}

{"2fa-enabled": true}

{"TWO_FA_ENABLED": true}

{"MSG": Hello World}

{"MSG": "Hello World"}

Casos de uso comuns

Gerar .env a partir de uma exportação de configuração

Pegue uma exportação de configuração JSON de uma API, de um painel de configurações ou de um gerenciador de segredos e transforme-a em um arquivo .env pronto para uso em desenvolvimento local ou em um contêiner.

Montar modelos de .env

Construa um objeto JSON descrevendo as variáveis que um novo serviço precisa, converta-o em um .env e confirme um .env.example para que os colegas saibam exatamente quais chaves preencher.

Conectar ferramentas configuradas em JSON ao dotenv

Algumas ferramentas emitem configuração como JSON enquanto seu runtime espera um .env. Converta a saída JSON para o formato dotenv para que as duas metades do pipeline concordem com as mesmas variáveis.

Produzir arquivos env de shell carregáveis via source

Ative o prefixo export para gerar um arquivo que você pode carregar diretamente via source em um shell ou etapa de CI, transformando um blob de configuração JSON em variáveis de ambiente exportadas em uma única colagem.

Configuração de ida e volta

Combine isto com o Conversor de .env para JSON para editar a configuração como JSON estruturado e gravá-la de volta no .env — as aspas seguras na ida e volta garantem que os valores sobrevivam nas duas direções.

Normalizar chaves de maiúsculas/minúsculas mistas

Converta um objeto JSON com chaves em camelCase ou kebab-case em um .env com nomes de variáveis consistentes em UPPER_SNAKE_CASE usando a opção Normalizar chaves, combinando com as convenções de variáveis de ambiente.

Detalhes técnicos

Entrada apenas de objetos com serialização tipada

A entrada é analisada com o JSON.parse() nativo do navegador e precisa ser um objeto de nível superior; arrays e escalares são rejeitados com um erro claro. Cada propriedade de nível superior é serializada por tipo: números e booleanos são escritos sem aspas, null vira um valor vazio (KEY=), e strings são escritas diretamente a menos que contenham um espaço, quebra de linha, # ou aspa, caso em que são envolvidas em aspas duplas e escapadas para segurança na ida e volta.

Valores aninhados e normalização de chaves

Objetos e arrays aninhados são serializados com um JSON.stringify compacto, envolvidos em aspas duplas e escapados, com um aviso nomeando as chaves achatadas. A etapa opcional Normalizar chaves converte as chaves para UPPER_SNAKE_CASE, resolvendo a maioria dos nomes inválidos; quando as chaves são mantidas literalmente, qualquer chave que não corresponda a [A-Za-z_][A-Za-z0-9_]* dispara um aviso de nome inválido. Um prefixo export opcional pode ser adicionado a cada linha.

Baseado no navegador — sem upload, sem servidor

Todo o processamento acontece inteiramente no motor JavaScript do seu navegador; nenhum dado JSON é transmitido pela rede em momento algum. O serializador é escrito internamente, sem dependências externas, já que a biblioteca Node dotenv não é segura no navegador. Entradas maiores que 200KB mudam do modo ao vivo para o modo manual (um clique explícito em Converter) para manter o navegador responsivo.

Boas práticas

Mantenha as chaves literais a menos que precise das convenções de env

Deixe Normalizar chaves desativado quando a aplicação consumidora já espera os nomes de chave exatos do seu JSON, para que nada seja renomeado inesperadamente. Ative-o apenas quando você quiser especificamente a convenção UPPER_SNAKE_CASE que as variáveis de ambiente usam por convenção.

Achate o aninhamento intencionalmente, não por acidente

Um valor aninhado vira uma string JSON opaca no .env, que a maioria das aplicações não consegue analisar de volta automaticamente. Quando você vir o aviso de achatamento, prefira remodelar o JSON em chaves planas e prefixadas (DB_HOST, DB_PORT) antes de converter, ou escolha um formato estruturado como YAML.

Confie nas aspas automáticas para idas e voltas

Deixe a ferramenta decidir quando colocar aspas — ela envolve em aspas duplas e escapa apenas os valores que precisam. Isso mantém o .env legível enquanto garante que valores com espaços, quebras de linha ou # sobrevivam inalterados a uma ida e volta de volta pelo Conversor de .env para JSON.

Gere segredos apenas em uma ferramenta exclusiva do navegador

O JSON que você converte aqui é efetivamente um conjunto de credenciais. Só gere um .env em uma ferramenta que roda inteiramente no navegador; verifique zero requisições de rede no DevTools. Este conversor se qualifica, ao contrário de geradores do lado do servidor ou baseados em API.

Valide a entrada JSON primeiro

Se o JSON é escrito à mão ou montado por um script, valide-o com o Formatador JSON primeiro para pegar vírgulas finais ou chaves sem aspas, para que você obtenha um .env limpo em vez de um erro de análise confuso.

Perguntas frequentes