---
title: Nesneler
source: 'https://academia.sh/tr/kurslar/javascript-temelleri/nesneler'
course: 'JavaScript Temelleri'
language: tr
updated: '2026-08-17T18:09:46+00:00'
license: 'CC BY-SA 4.0'
---

# Nesneler

Özellik erişiminin iki biçimi, anahtar dizgileştirme, kısaltmalı ve hesaplanmış yazım, varlık denetimi, yapıbozum, yayma ve referans anlambilimi.

Önceki derste ölçüm kayıtları nesne olarak kullanıldı ama sözdizimi tanımlanmadı. Bu ders
nesneleri ele alıyor: oluşturma, erişim, ayırma ve birleştirme.

Nesne, anahtar–değer çiftlerinin sırasız olmayan bir kümesidir. Anahtarlar dizgi veya
semboldür; değerler herhangi bir tipte olabilir. Prototip zinciri, özellik tanımlayıcıları
ve sınıf sözdizimi bir sonraki kursun konusudur; bu ders yalın veri nesnelerini kapsar.

## Oluşturma ve Erişim

```js
const alan = "sicaklik";
const istasyon = "A1";
const sicaklik = 21.5;

const kayit = {
  istasyon,
  sicaklik,
  [alan + "Birimi"]: "C",
  ozet() {
    return `${this.istasyon}: ${this.sicaklik}`;
  },
};

console.log(kayit);
console.log(kayit.istasyon, kayit["sicaklik"], kayit[alan]);
console.log(kayit.ozet());
```

```
{
  istasyon: 'A1',
  sicaklik: 21.5,
  sicaklikBirimi: 'C',
  ozet: [Function: ozet]
}
A1 21.5 21.5
A1: 21.5
```

Üç yazım kısayolu birlikte kullanıldı. **Kısaltmalı özellik** (`istasyon`), aynı adlı bir
değişkenden değer alır. **Hesaplanmış anahtar** (`[alan + "Birimi"]`), anahtarı çalışma
anında üretir. **Kısaltmalı yöntem** (`ozet()`), fonksiyon özelliğini `function`
sözcüğü olmadan yazar; Ok Fonksiyonları dersindeki kural gereği yöntemler ok biçiminde
yazılmaz.

Erişimin iki biçimi vardır. **Nokta biçimi** sabit ve geçerli bir ad gerektirir.
**Köşeli ayraç biçimi** herhangi bir ifade kabul eder; anahtar çalışma anında
belirleniyorsa zorunludur. Çıktının ikinci satırında üç erişim biçimi de aynı değeri
verdi.

Nesnenin çok satırlı yazılması çalışma zamanının inceleme biçimidir; nesne belirli bir
uzunluğu aştığında satırlara bölünür ve fonksiyon özellikleri `[Function: ad]` biçiminde
gösterilir. Bu gösterim standartta tanımlı değildir.

## Anahtarlar Dizgidir

Sembol dışındaki her anahtar dizgiye çevrilir:

```js
const nesne = {};
nesne[1] = "sayi bir";
nesne["1"] = "metin bir";
nesne[true] = "mantiksal";
console.log(nesne);
console.log(Object.keys(nesne));
console.log(typeof Object.keys(nesne)[0]);
```

```
{ '1': 'metin bir', true: 'mantiksal' }
[ '1', 'true' ]
string
```

`1` ve `"1"` aynı anahtardır; ikinci atama birinciyi ezdi. Döngüler dersinde `for...in`
ile gelen dizinlerin dizgi olmasının nedeni budur — dizi de bir nesnedir ve dizinleri
anahtar olarak taşır.

Sayısal anahtarlı bir eşleme gerekiyorsa `Map` yapısı ayrımı korur; bu kursun kapsamı
dışındadır.

## Varlık Denetimi

Bir alanın **bulunmaması** ile **`undefined` değeri taşıması** farklı durumlardır:

```js
const kayit = { istasyon: "A1", nem: undefined };
console.log(kayit.nem, "nem" in kayit, Object.hasOwn(kayit, "nem"));
console.log(kayit.basinc, "basinc" in kayit, Object.hasOwn(kayit, "basinc"));
delete kayit.nem;
console.log("silme sonrasi:", "nem" in kayit, kayit);
```

```
undefined true true
undefined false false
silme sonrasi: false { istasyon: 'A1' }
```

Okuma her iki durumda da `undefined` verdi; ayrımı yalnızca varlık denetimi gösterdi.
`in` işleci kalıtılan özellikleri de sayar; `Object.hasOwn` yalnızca nesnenin kendi
özelliklerine bakar. Kursta ikincisi kullanılacaktır.

`delete` özelliği tümüyle kaldırır. `undefined` atamak ise özelliği bırakır ve yalnızca
değerini değiştirir.

## Anahtar–Değer Çevrimleri

Nesne ile dizi arasında gidip gelmek, dönüşüm yazmanın temelidir:

```js
const kayit = { istasyon: "A1", sicaklik: 21.5, nem: 48 };
console.log(Object.keys(kayit));
console.log(Object.values(kayit));
console.log(Object.entries(kayit));

const ciftler = [["istasyon", "B1"], ["sicaklik", 23]];
console.log(Object.fromEntries(ciftler));
```

```
[ 'istasyon', 'sicaklik', 'nem' ]
[ 'A1', 21.5, 48 ]
[ [ 'istasyon', 'A1' ], [ 'sicaklik', 21.5 ], [ 'nem', 48 ] ]
{ istasyon: 'B1', sicaklik: 23 }
```

`Object.entries` ile `Object.fromEntries` birbirinin tersidir. Bu çift, nesne üzerinde
dizi yöntemleri kullanmayı mümkün kılar: nesne diziye çevrilir, süzülür veya eşlenir,
sonra nesneye geri çevrilir.

## Yapıbozum

**Yapıbozum (destructuring)**, bir nesnenin veya dizinin alanlarını ayrı adlara ayırır:

```js
const kayit = { istasyon: "A1", sicaklik: 21.5, konum: { yukseklik: 120 } };

const { istasyon, sicaklik: derece, nem = null } = kayit;
console.log(istasyon, derece, nem);

const { konum: { yukseklik } } = kayit;
console.log(yukseklik);

const { istasyon: ad, ...digerleri } = kayit;
console.log(ad, digerleri);

const [ilk, , ucuncu = 0] = [21.5, 19.75];
console.log(ilk, ucuncu);
```

```
A1 21.5 null
120
A1 { sicaklik: 21.5, konum: { yukseklik: 120 } }
21.5 0
```

Dört yetenek kullanıldı: **yeniden adlandırma** (`sicaklik: derece`), **varsayılan**
(`nem = null`), **iç içe ayırma** ve **kalan alanların toplanması**. Varsayılanın ölçütü
Parametreler dersindekiyle aynıdır: yalnızca değer `undefined` ise devreye girer.

Dizi yapıbozumunda sıra konuma göredir; atlanacak eleman boş bırakılır. Döngüler
dersinde `entries` ile kullanılan `[dizin, deger]` yazımı budur.

## Yayma ve Birleştirme

Yayma sözdizimi, bir nesnenin kendi sayılabilir özelliklerini başka bir nesne
sözdiziminin içine kopyalar:

```js
const temel = { istasyon: "A1", sicaklik: 21.5, birim: "C" };
const guncel = { sicaklik: 22.75 };

console.log({ ...temel, ...guncel });
console.log({ ...guncel, ...temel });
console.log(temel);
```

```
{ istasyon: 'A1', sicaklik: 22.75, birim: 'C' }
{ sicaklik: 21.5, istasyon: 'A1', birim: 'C' }
{ istasyon: 'A1', sicaklik: 21.5, birim: 'C' }
```

**Sıra sonucu belirler:** sonra yazılan aynı adlı özellik öncekini ezer. İkinci satırda
sıra tersine çevrildiği için güncelleme kaybolmuştur. Üçüncü satır, özgün nesnenin
değişmediğini gösteriyor — yayma yeni bir nesne üretir.

Kopya **sığdır**:

```js
const derin = { istasyon: "A1", konum: { yukseklik: 120 } };
const kopya = { ...derin };
kopya.konum.yukseklik = 999;
console.log(derin.konum.yukseklik);
```

```
999
```

İç nesne kopyalanmadı; iki nesne aynı `konum` nesnesini paylaşıyor. Derin kopya bu
kursun kapsamı dışındadır ve Değişmezlik Teknikleri dersinde ele alınacaktır.

## Referans Anlambilimi

Nesneler adlara referansla bağlanır. Programlama Temelleri kursundaki Değer ve Referans
ile Aktarım dersinde kurulan kural burada birebir geçerlidir:

```js
const kayit = { istasyon: "A1", sicaklik: 21.5 };
const ikinciAd = kayit;
ikinciAd.sicaklik = 22.75;
console.log(kayit.sicaklik);

function bozar(k) { k.sicaklik = 0; }
function bozmaz(k) { return { ...k, sicaklik: 0 }; }

bozar(kayit);
console.log(kayit.sicaklik);
console.log(bozmaz(kayit), kayit.sicaklik);
```

```
22.75
0
{ istasyon: 'A1', sicaklik: 0 } 0
```

`bozar` fonksiyonu çağıranın verisini değiştirdi. `bozmaz` ise yeni bir nesne üretti ve
özgün kaydı olduğu gibi bıraktı — son satırdaki `0` değeri, `bozar` çağrısından kalmadır.

Kursun kuralı: **dönüşüm fonksiyonları girdilerini değiştirmez, yeni nesne döndürür.**
Yan etkili bir güncelleme gerekiyorsa fonksiyonun adı bunu söylemelidir.

## Ölçüm Betiğine Uygulama

Kayıtları istasyona göre gruplamak, nesnenin eşleme olarak kullanımıdır:

```js
const kayitlar = [
  { istasyon: "A1", sicaklik: 21.5 },
  { istasyon: "A2", sicaklik: 19.75 },
  { istasyon: "A1", sicaklik: 22.75 },
  { istasyon: "B1", sicaklik: 23 },
];

const gruplar = {};
for (const kayit of kayitlar) {
  const anahtar = kayit.istasyon;
  if (!Object.hasOwn(gruplar, anahtar)) {
    gruplar[anahtar] = [];
  }
  gruplar[anahtar].push(kayit.sicaklik);
}
console.log(gruplar);

const ortalamalar = Object.fromEntries(
  Object.entries(gruplar).map(([ad, degerler]) => [
    ad,
    degerler.reduce((t, d) => t + d, 0) / degerler.length,
  ]),
);
console.log(ortalamalar);
```

```
{ A1: [ 21.5, 22.75 ], A2: [ 19.75 ], B1: [ 23 ] }
{ A1: 22.125, A2: 19.75, B1: 23 }
```

İki adım da bu dersin araçlarını kullanıyor. Gruplama, hesaplanmış anahtarla nesneye
yazıyor ve varlık denetimini `Object.hasOwn` ile yapıyor. Ortalama hesabı, nesneyi
çiftlere çevirip eşleme uyguluyor ve nesneye geri döndürüyor. Geri çağrının parametresi
`[ad, degerler]` yazımıyla yapıbozuma uğratıldı.

## Özet

- Kısaltmalı özellik, hesaplanmış anahtar ve kısaltmalı yöntem yazımları nesne
  sözdiziminin üç kısayoludur.
- Sembol dışındaki anahtarlar dizgiye çevrilir; `1` ile `"1"` aynı anahtardır.
- Alanın bulunmaması ile `undefined` taşıması ayrı durumlardır; ayrım `Object.hasOwn` ile
  görülür.
- `Object.entries` ve `Object.fromEntries` birbirinin tersidir ve nesne üzerinde dizi
  yöntemleri kullanmayı sağlar.
- Yapıbozum yeniden adlandırma, varsayılan, iç içe ayırma ve kalan alan toplama sunar.
- Yaymada sonra yazılan özellik önceki aynı adlıyı ezer; kopya sığdır ve nesneler adlara
  referansla bağlanır.

## Sonraki Adım

Çıktılar bu derse kadar `console.log` argümanlarıyla veya birleştirmeyle üretildi.
Sonraki ders dizgileri ele alacak: şablon dizgileriyle biçimlendirme, arama ve bölme
yöntemleri, kod birimi ile grafem ayrımının pratik sonuçları ve sayı biçimlendirme.
Ölçüm raporunun okunabilir metni orada yazılacak.