---
title: 'Süreç Nesnesi'
source: 'https://academia.sh/tr/kurslar/nodejs/surec-nesnesi'
course: 'Node.js Çalışma Zamanı'
language: tr
updated: '2026-08-17T18:09:52+00:00'
license: 'CC BY-SA 4.0'
---

# Süreç Nesnesi

Argüman dizisi, ortam değişkenleri, standart akışların nesne karşılığı, çıkış kodu belirlemenin iki yolu ve çıkış kancası.

Önceki ders döngünün turlarını inceledi. Turların içinde çalışan program, dış dünyayla
yalnızca dosya ve ağ üzerinden değil, kendisini başlatan ortamla da konuşur: hangi
argümanlarla çağrıldı, hangi ortam değişkenlerini devraldı, çıktısı nereye bağlı ve
sonlandığında çağırana ne bildirecek?

Bu bilgilerin tamamı tek bir genel nesnede toplanır. Kabuk Programlama kursunda bir
betiğin `$1`, `$?` ve `$HOME` ile yaptığı şeylerin karşılığı burada bu nesnenin
alanlarıdır.

## Argümanlar ve Ortam

`process.argv`, sürecin başlatıldığı komut satırını bir dizgi dizisi olarak taşır.
Dizinin ilk iki öğesi sabittir: çalıştırılabilir dosyanın yolu ve çalıştırılan ana
modülün yolu. Kullanıcının yazdığı argümanlar üçüncü öğeden başlar.

```js
// surec.mjs
console.log('argv[0] son parca:', process.argv[0].split('/').pop());
console.log('argv[1] son parca:', process.argv[1].split('/').pop());
console.log('kalan argumanlar :', process.argv.slice(2));
console.log('platform         :', process.platform);
console.log('calisma dizini   :', process.cwd().split('/').pop());
console.log('OLCUM_DIZINI     :', process.env.OLCUM_DIZINI ?? '(tanimsiz)');
```

```sh
node surec.mjs --dugum kenar-01 --bicim ozet
```

```
argv[0] son parca: node
argv[1] son parca: surec.mjs
kalan argumanlar : [ '--dugum', 'kenar-01', '--bicim', 'ozet' ]
platform         : darwin
calisma dizini   : lab
OLCUM_DIZINI     : (tanimsiz)
```

İlk iki satırdaki tam yollar makineye göre değişir; bu yüzden örnekte yalnızca son
parçaları yazdırılıyor. `platform` alanı çalıştığınız işletim sistemine göre farklı
bir değer verir; `calisma dizini` ise komutu hangi dizinden çağırdığınıza bağlıdır.
Yolları sabitlemenin doğru yolu bir sonraki konuda ele alınacak.

Ortam değişkenleri `process.env` üzerinden okunur. Bu nesnenin bütün değerleri
dizgidir; sayı bekliyorsanız dönüştürmek ve doğrulamak size düşer.

```sh
OLCUM_DIZINI=/veri/olcum node surec.mjs
```

```
argv[0] son parca: node
argv[1] son parca: surec.mjs
kalan argumanlar : []
platform         : darwin
calisma dizini   : lab
OLCUM_DIZINI     : /veri/olcum
```

Değişkenin komuttan önce yazılması, onu yalnızca o çağrı için tanımlar; kabuk oturumu
etkilenmez. Bu, Kabuk Programlama kursunda kurulan ortam devri kuralının aynısıdır.

## Standart Akışların Nesne Karşılığı

Kabuk Programlama kursunda üç standart akış birer numarayla anılmıştı: 0 girdi,
1 çıktı, 2 hata. Çalışma zamanı bu üç tanıtıcıyı birer nesne olarak sunar:
`process.stdin`, `process.stdout` ve `process.stderr`. Bunlar sıradan
nesneler değil, ilerleyen derslerde ayrıntılandırılacak akış nesneleridir; şimdilik
`write` yöntemleri yeterlidir.

Akış ayrımı kuralı burada da geçerlidir: verinin kendisi standart çıktıya, veriyle
ilgili her açıklama standart hataya yazılır. Aşağıdaki araç ölçüm dosyasını okuyup
sekmeyle ayrılmış iki sütun yazar; sayaç ve hata iletileri ikinci akışa gider.

```js
// akis-ayrimi.mjs
import { readFileSync } from 'node:fs';

const dosya = process.argv[2] ?? 'olcumler.ndjson';

let metin;
try {
  metin = readFileSync(dosya, 'utf8');
} catch (hata) {
  process.stderr.write(`hata: ${dosya} okunamadi (${hata.code})\n`);
  process.exitCode = 66;                    // veri girdisi yok
  metin = '';
}

let sayac = 0;
for (const satir of metin.split('\n')) {
  if (satir.trim() === '') continue;
  const { dugum, deger } = JSON.parse(satir);
  process.stdout.write(`${dugum}\t${deger}\n`);
  sayac += 1;
}

process.stderr.write(`${sayac} kayit islendi\n`);

process.on('exit', (kod) => {
  process.stderr.write(`surec ${kod} koduyla sonlaniyor\n`);
});
```

Yalnızca veriyi görmek için ikinci akış ıskartaya çıkarılır:

```sh
node akis-ayrimi.mjs 2>/dev/null | head -3
```

```
kenar-01	21.4
kenar-01	48
kenar-02	19.8
```

Yalnızca tanı iletilerini görmek için birinci akış:

```sh
node akis-ayrimi.mjs 1>/dev/null
```

```
12 kayit islendi
surec 0 koduyla sonlaniyor
```

Bu ayrım, aracın bir boru hattına takılabilmesinin ön koşuludur. Sayaç satırı standart
çıktıya yazılsaydı, çıktıyı okuyan bir sonraki komut onu veri satırı sanardı.

`console.log` çağrısı standart çıktıya, `console.error` standart hataya yazar. Bunlar
`write` üzerine kurulmuş kolaylık fonksiyonlarıdır; nesneleri okunabilir biçimde
düzenlemeleri yararlıdır, ancak çıktısı başka bir programa girdi olacak yerlerde
biçimi doğrudan denetlemek için `write` yeğlenir.

## Çıkış Kodu

Bir sürecin çağırana bildirdiği tek sayısal sonuç çıkış kodudur. Kabuk Programlama
kursundaki kural burada da geçerlidir: sıfır başarı, sıfırdan farklı her değer bir
başarısızlık türüdür.

Kodu belirlemenin iki yolu vardır ve aralarındaki fark önemlidir.

```js
// cikis-sert.mjs
setTimeout(() => console.log('bekleyen is'), 0);
console.log('cikis oncesi');
process.exit(3);
```

```sh
node cikis-sert.mjs; echo "cikis kodu: $?"
```

```
cikis oncesi
cikis kodu: 3
```

```js
// cikis-yumusak.mjs
setTimeout(() => console.log('bekleyen is'), 0);
console.log('cikis oncesi');
process.exitCode = 3;
```

```sh
node cikis-yumusak.mjs; echo "cikis kodu: $?"
```

```
cikis oncesi
bekleyen is
cikis kodu: 3
```

`process.exit`, olay döngüsünü o anda durdurur; kuyrukta bekleyen geri çağrılar
çalışmaz. Yukarıdaki ilk çıktıda `bekleyen is` satırının olmaması bunun sonucudur.
Aynı kesme, henüz aktarılmamış çıktı için de geçerli olabilir: çıktısı bir dosyaya
veya boruya bağlı bir süreçte yazma işlemi eşzamansız yürütülebilir ve sert çıkış
onu yarıda bırakabilir.

`process.exitCode` alanına yazmak ise yalnızca sonucu kaydeder. Döngü işini bitirip
doğal olarak boşaldığında süreç bu kodla sonlanır. Bekleyen yazma, kapanmakta olan
bağlantı ve süren dosya işlemi tamamlanır.

Kural: **sert çıkış yalnızca sürecin durumunun bozulduğuna karar verildiğinde
kullanılır.** Olağan hata yollarında kod alana yazılır ve süreç kendiliğinden biter.

Yukarıdaki araç bu kuralı izler. Dosya bulunamadığında sürece 66 kodu verilir, ama
süreç kesilmez; sayaç satırı ve çıkış kancası yine çalışır:

```sh
node akis-ayrimi.mjs yok.ndjson; echo "cikis kodu: $?"
```

```
hata: yok.ndjson okunamadi (ENOENT)
0 kayit islendi
surec 66 koduyla sonlaniyor
cikis kodu: 66
```

## Çıkış Kancası

`process.on('exit', ...)` ile kurulan geri çağrı, süreç sonlanmadan hemen önce
çalışır ve çıkış kodunu argüman olarak alır. Yukarıdaki her iki çalıştırmada son
satırı yazan budur.

Bu kancanın tek katı kuralı vardır: içinde **eşzamansız iş başlatılamaz.** Süreç
kapanmak üzeredir; kancadan sonra olay döngüsüne dönülmez, bu yüzden kancada kurulan
bir zamanlayıcı veya dosya yazımı hiçbir zaman çalışmaz. Kanca yalnızca eşzamanlı,
kısa işler içindir — bir sayaç yazmak, bir kilidi eşzamanlı olarak kaldırmak gibi.

Gerçek temizlik işleri, kapanma **sinyali** alındığında yapılır; sinyaller ve zarif
kapanma Süreç Yönetimi ve Sağlamlık dersinin konusudur.

Sürecin kendini tanıtan iki alanı daha vardır. `process.pid`, işletim sisteminin
sürece verdiği kimliktir ve her çalıştırmada farklıdır; kütük satırlarında birden
çok süreci ayırt etmek için kullanılır. `process.uptime()`, sürecin başlamasından
bu yana geçen saniyeyi verir ve sağlık uçlarında yaş bilgisi olarak yazılır.

## Özet

- `process.argv` dizisinin ilk iki öğesi çalıştırılabilir dosya ve ana modül yoludur;
  kullanıcı argümanları üçüncü öğeden başlar.
- `process.env` değerleri her zaman dizgidir; sayısal veya mantıksal yorum, okuyan
  kodun sorumluluğundadır.
- Üç standart akış birer nesne olarak sunulur; veri standart çıktıya, tanı iletisi
  standart hataya yazıldığında araç bir boru hattına takılabilir hâle gelir.
- `process.exit` döngüyü o anda keser ve bekleyen işleri düşürür; `process.exitCode`
  yalnızca sonucu kaydeder ve sürecin doğal olarak bitmesine izin verir.
- `exit` kancası yalnızca eşzamanlı iş için uygundur; kancadan sonra olay döngüsüne
  dönülmediğinden eşzamansız temizlik burada yapılamaz.

## Sonraki Adım

Bu derste dosya adı `olcumler.ndjson` biçiminde, çalışma dizinine göre verildi;
program başka bir dizinden çağrıldığında dosyayı bulamaz. Sonraki ders bu bağımlılığı
ortadan kaldıran düzeneği ele alır: bir ad yazıldığında çalışma zamanının hangi
dosyayı yükleyeceğine hangi kurallarla karar verdiğini — yerleşik modül, dosya yolu ve
paket adı arasındaki ayrımı — inceler.
