Convertisseur JSON vers .env

Qu'est-ce qu'un fichier .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"

Fonctionnalités clés

Exemples

{
  "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\"]"

Comment utiliser

1. 1

   Collez votre objet JSON

   Saisissez ou collez un objet JSON plat dans le champ de saisie ci-dessus. Vous pouvez aussi cliquer sur « Charger un exemple » pour essayer un objet de config, des valeurs nécessitant des guillemets ou un objet imbriqué.

2. 2

   Voir la sortie .env en direct

   Le fichier .env apparaît instantanément dans le panneau de sortie. Activez « Normaliser les clés » pour des noms en UPPER_SNAKE_CASE, ou « Ajouter le préfixe export » si le fichier sera sourcé dans un shell.

3. 3

   Copier ou télécharger

   Cliquez sur Copier pour récupérer le .env dans votre presse-papiers, ou Télécharger pour l'enregistrer en fichier .env — prêt à déposer dans votre projet et à charger avec dotenv.

Pièges courants du 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"}

Cas d'usage courants

Générer un .env à partir d'un export de config

Prenez un export de configuration JSON depuis une API, un tableau de bord de réglages ou un gestionnaire de secrets et transformez-le en fichier .env prêt à l'emploi pour le développement local ou un conteneur.

Échafauder des modèles .env

Construisez un objet JSON décrivant les variables dont un nouveau service a besoin, convertissez-le en .env, et validez un .env.example pour que vos coéquipiers sachent exactement quelles clés renseigner.

Relier les outils configurés en JSON à dotenv

Certains outils émettent leur configuration en JSON alors que votre runtime attend un .env. Convertissez la sortie JSON au format dotenv pour que les deux moitiés du pipeline s'accordent sur les mêmes variables.

Produire des fichiers env shell sourçables

Activez le préfixe export pour générer un fichier que vous pouvez sourcer directement dans un shell ou une étape CI, transformant un blob de config JSON en variables d'environnement exportées en un seul collage.

Aller-retour de configuration

Associez ceci au Convertisseur .env vers JSON pour éditer la configuration en JSON structuré et la réécrire en .env — les guillemets sûrs pour l'aller-retour garantissent que les valeurs survivent dans les deux sens.

Normaliser des clés à casse mixte

Convertissez un objet JSON avec des clés en camelCase ou kebab-case en un .env avec des noms de variable cohérents en UPPER_SNAKE_CASE grâce à l'option Normaliser les clés, suivant les conventions des variables d'environnement.

Détails techniques

Entrée objet uniquement avec sérialisation typée

L'entrée est analysée avec le JSON.parse() natif du navigateur et doit être un objet de premier niveau ; les tableaux et scalaires sont rejetés avec une erreur claire. Chaque propriété de premier niveau est sérialisée par type : les nombres et booléens sont écrits nus, null devient une valeur vide (KEY=), et les chaînes sont écrites directement sauf si elles contiennent un espace, un saut de ligne, un # ou un guillemet, auquel cas elles sont entourées de guillemets doubles et échappées pour la sécurité de l'aller-retour.

Valeurs imbriquées et normalisation des clés

Les objets et tableaux imbriqués sont sérialisés avec un JSON.stringify compact, mis entre guillemets doubles et échappés, avec un avertissement nommant les clés aplaties. L'étape optionnelle Normaliser les clés convertit les clés en UPPER_SNAKE_CASE, résolvant la plupart des noms invalides ; quand les clés sont conservées telles quelles, toute clé qui ne correspond pas à [A-Za-z_][A-Za-z0-9_]* déclenche un avertissement de nom invalide. Un préfixe export optionnel peut être ajouté à chaque ligne.

Côté navigateur — aucun envoi, aucun serveur

Tout le traitement se déroule entièrement dans le moteur JavaScript de votre navigateur ; aucune donnée JSON n'est transmise sur le réseau à aucun moment. Le sérialiseur est écrit en interne sans dépendance externe, car la bibliothèque Node dotenv n'est pas sûre côté navigateur. Les entrées de plus de 200 Ko passent du mode direct au mode manuel (un clic explicite sur Convertir) pour garder le navigateur réactif.

Bonnes pratiques

Conserver les clés telles quelles sauf besoin des conventions env

Laissez Normaliser les clés désactivé quand l'application consommatrice attend déjà les noms de clé exacts de votre JSON, pour que rien ne soit renommé de façon inattendue. Activez-le uniquement quand vous voulez spécifiquement la convention UPPER_SNAKE_CASE qu'utilisent conventionnellement les variables d'environnement.

Aplatir l'imbrication intentionnellement, pas accidentellement

Une valeur imbriquée devient une chaîne JSON opaque dans le .env, que la plupart des applications ne peuvent pas réanalyser automatiquement. Quand vous voyez l'avertissement d'aplatissement, préférez remodeler le JSON en clés plates et préfixées (DB_HOST, DB_PORT) avant de convertir, ou choisissez un format structuré comme YAML.

Faire confiance à la mise entre guillemets automatique pour les aller-retours

Laissez l'outil décider quand mettre entre guillemets — il n'entoure de guillemets doubles et n'échappe que les valeurs qui en ont besoin. Cela garde le .env lisible tout en garantissant que les valeurs avec espaces, sauts de ligne ou # survivent inchangées à un aller-retour via le Convertisseur .env vers JSON.

Générer des secrets uniquement dans un outil côté navigateur

Le JSON que vous convertissez ici est de fait un ensemble d'identifiants. Ne générez un .env que dans un outil qui s'exécute entièrement dans le navigateur ; vérifiez zéro requête réseau dans les DevTools. Ce convertisseur remplit cette condition, contrairement aux générateurs côté serveur ou adossés à une API.

Valider d'abord l'entrée JSON

Si le JSON est écrit à la main ou assemblé par un script, validez-le d'abord avec le Formateur JSON pour détecter les virgules finales ou les clés non entre guillemets, afin d'obtenir un .env propre plutôt qu'une erreur d'analyse déroutante.

Questions fréquentes