# Node.js miljövariabler – Guide till .env och process.env

*Annette Härröd*
*26 juni 2026*

> Node.js miljövariabler är nyckeln till säker applikationskonfiguration. I denna guide lär du dig hur du använder .env-filer och process.env för att hantera hemliga nycklar och känslig konfiguration på ett säkert sätt.

Node.js miljövariabler är en kritisk del av säker applikationsutveckling. De låter dig lagra känslig information som databaskonfiguration, API-nycklar och andra hemliga värden utanför din källkod. I denna steg-för-steg guide lär du dig hur du implementerar miljövariabler med .env-filer och process.env för att skydda dina applikationer mot säkerhetshot.

## Varför är Node.js miljövariabler viktiga?

Att hålla hemligheter och känslig konfiguration i din kod är en dålig idé. Om du begår din källkod till ett publikt repository hamnar API-nycklar och databasadresser där alla kan se dem. Node.js miljövariabler löser detta genom att separera konfiguration från kod. Med process.env kan du komma åt dessa värden vid körtid, och dotenv-paketet gör det enkelt att ladda in variabler från en .env-fil under utveckling.

## Hur hanterar du Node.js miljövariabler? – En steg-för-steg guide

### Steg 1: Installera dotenv-paketet

Det första steget är att installera dotenv, ett npm-paket som automatiskt laddar miljövariablerna från din .env-fil:

```
npm install dotenv
```

Dotenv är en liten och lätt modul som läser en .env-fil och gör dess innehål tillgängligt via process.env. Det är det mest populära sättet att hantera miljövariabler i Node.js-projekt.

### Steg 2: Skapa en .env-fil

Skapa en fil med namnet `.env` i roten av ditt projekt. Denna fil innehåller dina miljövariabler i formatet `NYCKEL=värde`:

```
DATABASE_URL=mongodb://localhost:27017/myapp
API_KEY=ditt_hemliga_api_nyckel_här
JWT_SECRET=denna_ska_vara_slumpmässig_och_långt_hemlig
NODE_ENV=development
PORT=3000
```

Använd stora bokstäver för variabelnamn efter konvention. Säkerhet är kritisk här – lagra bara variabler du behöver, aldrig hemliga nycklar som redan är i kod.

### Steg 3: Ladda miljövariablerna i din app

I din applikations huvudfil (ofta `index.js` eller `server.js`), importera och initiera dotenv längst upp:

```javascript
require('dotenv').config();

const express = require('express');
const app = express();

// Nu är alla variabler från .env tillgängliga
const dbUrl = process.env.DATABASE_URL;
const apiKey = process.env.API_KEY;
```

Det är viktigt att anropa `.config()` innan du använder någon annan modul som kan behöva dessa variabler.

### Steg 4: Använd process.env för att läsa värdena

Nu kan du komma åt dina miljövariabler via det globala `process.env`-objektet:

```javascript
const jwtSecret = process.env.JWT_SECRET;
const port = process.env.PORT || 3000;

app.listen(port, () => {
  console.log(`Server körs på port ${port}`);
});
```

Notera att `process.env` alltid returnerar strängar. Om du behöver ett tal, konvertera det manuellt med `parseInt()`.

### Steg 5: Skydda din .env-fil

Lägg aldrig din .env-fil i versionskontroll. Lägg till den i din `.gitignore`:

```
.env
.env.local
.env.*.local
```

Detta säkerställer att hemliga nycklar inte läcker ut när du pushar din kod till GitHub eller andra repositories. För produktion använder du istället miljövariabler som sätts av din hosting-provider (som Vercel, Heroku, eller AWS).

### Steg 6: Hantera olika miljöer

I utveckling kan du behöva olika inställningar än i produktion. Du kan skapa flera .env-filer:

- `.env` – standard för utveckling
- `.env.local` – lokala åsidosättningar (lägg till i .gitignore)
- `.env.production` – inställningar för produktion

Sedan kan du ladda rätt fil baserat på NODE_ENV:

```javascript
const env = process.env.NODE_ENV || 'development';
require('dotenv').config({ path: `.env.${env}` });
```

Många projekt använder en .env.example-fil utan känsliga värden för att dokumentera vilka variabler som krävs.

## Sammanfattning

Node.js miljövariabler är essentiellt för säker applikationskonfiguration. Genom att använda .env-filer tillsammans med process.env och dotenv-paketet kan du hålla hemligheter och känslig data säkra och separerade från din källkod. Kom ihåg att aldrig committa .env-filer till ditt repository, och använd istället miljövariabler för att hantera hemliga nycklar i produktion.

### Vad är skillnaden mellan .env och process.env?

.env är en textfil som innehåller dina miljövariabler. process.env är ett globalt Node.js-objekt som innehåller alla miljövariabler (både från .env-filen, som dotenv laddade in, och från systemet). Dotenv läser .env-filen och skriver värdena in i process.env så att du kan komma åt dem i din kod.

### Hur håller jag hemligheter säkra i Node.js?

Det viktigaste är att aldrig lagra hemligheter i din källkod eller committa .env-filer. Använd istället miljövariabler som ställs in av din hosting-provider vid deployment. För lokal utveckling, använd .env-filer med dotenv. Rotera dina hemliga nycklar regelbundet och övervaka dem mot exponeringar.

### Kan jag använda miljövariabler utan dotenv?

Ja, på många hosting-plattformar kan du ställa in miljövariabler direkt i gränssnittet utan dotenv. Men för lokal utveckling är dotenv mycket praktisk. Du kan också manuellt ställa in variabler när du kör Node.js: `PORT=3000 node server.js`. För de flesta projekt är dotenv-paketet dock det lättaste sättet.