Vad är Buffers i Node.js?

Question

Accepted Answer

En **Buffer** är Node's sätt att hantera **raw binary data** — en sekvens av bytes med fast längd som lagras utanför V8-heapen. Eftersom JavaScript-strängar är för text (Unicode), finns Buffers för att arbeta med binär data: filinnehål, nätverkspaket, bilder, kryptering, osv.

## Varför Buffers finns

```text
JavaScript strings → text (UTF-16). Can't cleanly represent arbitrary bytes.
Buffers → raw bytes (0–255 each). For binary data that isn't text.
```

När du läser en fil eller tar emot nätverksdata anländer det som bytes — en Buffer — som du sedan kan avkoda till en sträng om det är text, eller bearbeta som binär om det inte är det.

## Skapa och använd Buffers

```js
const buf = Buffer.from("Hello");          // from a string → bytes
const buf2 = Buffer.from([72, 105]);       // from byte values → "Hi"
const buf3 = Buffer.alloc(10);             // 10 zero-filled bytes

buf.length;          // 5 (bytes, not characters)
buf.toString("utf8"); // "Hello" — decode back to text
buf.toString("hex");  // "48656c6c6f"
buf.toString("base64"); // "SGVsbG8="
buf[0];              // 72 — access individual bytes
```

## Var Buffers dyker upp

```js
// file reads without an encoding return a Buffer
const data = await fs.promises.readFile("image.png"); // Buffer (binary)
const text = await fs.promises.readFile("file.txt", "utf8"); // string (decoded)

// streams emit Buffer chunks
req.on("data", (chunk) => { /* chunk is a Buffer */ });

// crypto, compression, network protocols all work with Buffers
crypto.randomBytes(16); // a Buffer of 16 random bytes
```

Om du läser en fil *utan* att specificera en encoding får du en Buffer; specificera `"utf8"` så avkodar Node det till en sträng för dig.

## En subtil poäng: bytes vs tecken

```js
Buffer.from("café").length; // 5 (é is 2 bytes in UTF-8) — NOT 4 characters
```

Buffer-längd är i **bytes**, vilket kan skilja sig från antalet tecken för multi-byte (non-ASCII) text — relevant när man delar upp binär data.

## Varför det är viktigt

Buffers är hur Node hanterar all **binär data**, vilket är oundvikligt i serverarbete: läsning av icke-text-filer, bearbetning av streams, nätverksprotokoll, kryptering, bild-/filöverföringar och komprimering.

Att förstå att I/O fundamentalt arbetar med bytes (Buffers) — och hur man konverterar mellan Buffers och strängar med rätt encoding — är väsentligt när du går bortom vanlig text, och det ligger till grund för streams, filsystemet och crypto.