---
title: 'Tipli Diziler'
source: 'https://academia.sh/tr/kurslar/javascript-nesne-modeli/tipli-diziler'
course: "JavaScript'te Nesneler ve Fonksiyonlar"
language: tr
updated: '2026-08-17T18:09:49+00:00'
license: 'CC BY-SA 4.0'
---

# Tipli Diziler

Sabit boyutlu ikili arabellekler ve üzerlerindeki tipli görünümler, taşma ile kırpma davranışı, bayt sırasının açıkça belirtilmesi ve tipli dizilerin sıradan dizilerden farkları.

Bu konudaki koleksiyonların hepsi keyfi JavaScript değerleri tuttu. Bir ölçüm akışını
dosyaya yazmak ya da ağ üzerinden aktarmak gerektiğinde ise veri, belirli sayıda bayta
oturan sabit bir düzende temsil edilmelidir.

**Tipli diziler (typed arrays)** bu iş için vardır. İkisi bir arada çalışır: ham baytları
tutan `ArrayBuffer` ve o baytları belirli bir sayı türü olarak yorumlayan **görünüm**.
Bilgisayarlar Nasıl Çalışır kursundaki İşaretli Tam Sayılar, Kayan Noktalı Sayılar ve
Bayt Sırası derslerinde kurulan temsiller, burada doğrudan gözlemlenebilir hâle gelir.

## Arabellek ve Görünüm

`ArrayBuffer` yalnızca bayt tutar; içeriğine doğrudan erişilmez. Erişim için üzerine bir
görünüm kurulur ve görünümün türü, aynı baytların nasıl okunacağını belirler.

```js
const arabellek = new ArrayBuffer(16);

console.log(arabellek.byteLength);

const baytGorunumu = new Uint8Array(arabellek);
const ondalikGorunum = new Float64Array(arabellek);

console.log(baytGorunumu.length);
console.log(ondalikGorunum.length);
console.log(Uint8Array.BYTES_PER_ELEMENT);
console.log(Float64Array.BYTES_PER_ELEMENT);

ondalikGorunum[0] = 21.4;
console.log(ondalikGorunum[0]);
console.log([...baytGorunumu.slice(0, 8)].join(","));

baytGorunumu[0] = 0;
console.log(ondalikGorunum[0]);
console.log(baytGorunumu.buffer === ondalikGorunum.buffer);

const bagimsiz = new Float64Array(2);
console.log(bagimsiz.buffer === arabellek);
console.log(bagimsiz[0]);
```

```
16
16
2
1
8
21.4
102,102,102,102,102,102,53,64
21.399999999999636
true
false
0
```

Aynı on altı bayt, bir görünümde on altı tam sayı, diğerinde iki ondalık sayıdır. İki
görünüm de aynı belleğe bakar: ondalık görünüme yazılan değerin baytları bayt görünümünde
okunur, bayt görünümünde yapılan tek bir değişiklik ondalık değeri bozar. Sekizinci
satırdaki sapma, en düşük anlamlı baytın sıfırlanmasının kayan noktalı gösterimdeki
karşılığıdır.

Bayt dizilişi platformun **yerel bayt sırasına** bağlıdır; yukarıdaki çıktı küçük uçlu bir
makinede üretilmiştir. Büyük uçlu bir makinede aynı program farklı bir dizilim gösterir.
Taşınabilirliğin nasıl sağlanacağı bu dersin üçüncü bölümünün konusudur.

Bir arabellek verilmeden kurulan görünüm, kendi arabelleğini yaratır ve sıfırlarla
başlar.

## Taşma ve Kırpma

Tipli dizinin bir gözü, türünün izin verdiği aralığın dışında bir değer alamaz. Aralık
dışı değerlerin ne olacağı türe göre değişir.

```js
const sarma = new Uint8Array(4);
const kirpma = new Uint8ClampedArray(4);
const isaretli = new Int8Array(4);

const denemeler = [300, -1, 255.9, 128];

denemeler.forEach((deger, sira) => {
  sarma[sira] = deger;
  kirpma[sira] = deger;
  isaretli[sira] = deger;
});

console.log([...sarma].join(","));
console.log([...kirpma].join(","));
console.log([...isaretli].join(","));

const tamsayi = new Int32Array(1);
tamsayi[0] = 21.9;
console.log(tamsayi[0]);

const ondalik = new Float32Array(1);
ondalik[0] = 21.4;
console.log(ondalik[0]);
console.log(ondalik[0] === 21.4);

const cifteDuyarlik = new Float64Array(1);
cifteDuyarlik[0] = 21.4;
console.log(cifteDuyarlik[0] === 21.4);
```

```
44,255,255,128
255,0,255,128
44,-1,-1,-128
21
21.399999618530273
false
true
```

`Uint8Array` değeri 256'ya göre sarar: 300 değeri 44 olur, -1 değeri 255. `Uint8ClampedArray`
ise aralığa **kırpar**: 300 değeri 255'te, -1 değeri 0'da durur. `Int8Array` aynı baytları
işaretli yorumlar; 128 değeri -128 olarak okunur — ikiye tümleyen gösteriminin doğrudan
sonucudur.

Tam sayı görünümlerinde ondalık kısım atılır, yuvarlama yapılmaz: 21.9 değeri 21 olur.
Kırpmalı türde ise en yakın tam sayıya yuvarlanır; 255.9 değeri 256 olur ve aralığa
kırpılarak 255'te kalır.

Son üç satır duyarlık farkını gösterir. `Float32Array` sayıyı tek duyarlıkta saklar ve
geri okunan değer aslından farklıdır; `Float64Array` ise JavaScript sayılarının kendi
gösterimini kullandığı için değeri aynen korur. İkili kayıt biçimlerinde alan genişliği
seçimi bu ödünleşimi doğrudan belirler.

## Bayt Sırasını Açıkça Belirtmek

Tipli dizi görünümleri yerel bayt sırasını kullanır; bu, verinin başka bir makinede
okunması gerektiğinde sorun çıkarır. `DataView`, her okuma ve yazmada bayt sırasının
açıkça belirtilmesini sağlar.

Ölçüm kayıtlarını on iki baytlık sabit bir düzene yerleştirelim: dört bayt sensör numarası,
sekiz bayt ölçüm değeri.

```js
const KAYIT_BOYU = 12;

function kayitlariYaz(kayitlar, kucukUclu) {
  const arabellek = new ArrayBuffer(KAYIT_BOYU * kayitlar.length);
  const gorunum = new DataView(arabellek);
  kayitlar.forEach((kayit, sira) => {
    const ofset = sira * KAYIT_BOYU;
    gorunum.setUint32(ofset, kayit.sensorNo, kucukUclu);
    gorunum.setFloat64(ofset + 4, kayit.deger, kucukUclu);
  });
  return arabellek;
}

function kayitlariOku(arabellek, kucukUclu) {
  const gorunum = new DataView(arabellek);
  const sonuc = [];
  for (let ofset = 0; ofset < arabellek.byteLength; ofset += KAYIT_BOYU) {
    sonuc.push({
      sensorNo: gorunum.getUint32(ofset, kucukUclu),
      deger: gorunum.getFloat64(ofset + 4, kucukUclu),
    });
  }
  return sonuc;
}

const kayitlar = [
  { sensorNo: 1, deger: 21.4 },
  { sensorNo: 2, deger: 19.8 },
];

const kucukUcluArabellek = kayitlariYaz(kayitlar, true);
const buyukUcluArabellek = kayitlariYaz(kayitlar, false);

console.log(kucukUcluArabellek.byteLength);
console.log([...new Uint8Array(kucukUcluArabellek).slice(0, 4)].join(","));
console.log([...new Uint8Array(buyukUcluArabellek).slice(0, 4)].join(","));

console.log(JSON.stringify(kayitlariOku(kucukUcluArabellek, true)));
console.log(JSON.stringify(kayitlariOku(buyukUcluArabellek, false)));
console.log(kayitlariOku(buyukUcluArabellek, true)[0].sensorNo);
```

```
24
1,0,0,0
0,0,0,1
[{"sensorNo":1,"deger":21.4},{"sensorNo":2,"deger":19.8}]
[{"sensorNo":1,"deger":21.4},{"sensorNo":2,"deger":19.8}]
16777216
```

İki arabellek aynı kayıtları taşır ama baytları ters sırada dizilidir. Bu çıktı platformdan
bağımsızdır: `DataView` yazımda ve okumada sırayı açıkça aldığı için makinenin yerel
sırasına bakmaz.

Son satır yanlış varsayımın bedelini gösterir. Büyük uçlu yazılmış veri küçük uçlu
okunduğunda `1` yerine `16777216` çıkar; hata yükselmez, yalnızca sayı anlamsızlaşır.
Bilgisayar Ağları müfredatındaki ağ bayt sırası tartışması aynı sorunun protokol
düzeyindeki karşılığıdır: ikili bir biçim tanımlanırken bayt sırası biçimin parçası olarak
yazılmalıdır.

## Sıradan Diziden Farkları

Tipli diziler `Array` türünün bir alt türü değildir. Prototip zincirleri ayrıdır ve dizi
davranışlarının bir kısmını taşımazlar.

```js
const tipli = new Float64Array([21.4, 19.8, 25.1]);
const siradan = [21.4, 19.8, 25.1];

console.log(Array.isArray(tipli));
console.log(Array.isArray(siradan));
console.log(typeof tipli.push);
console.log(typeof siradan.push);

tipli[5] = 99;
console.log(tipli.length);
console.log(tipli[5]);

const ustPrototip = Object.getPrototypeOf(Float64Array.prototype);
console.log(ustPrototip === Object.getPrototypeOf(Uint8Array.prototype));
console.log(ustPrototip === Array.prototype);
console.log(Object.getPrototypeOf(ustPrototip) === Object.prototype);

const esleme = tipli.map((d) => d * 2);
console.log(esleme.constructor === Float64Array);
console.log([...esleme].join(","));
console.log([...tipli].join(","));
console.log(JSON.stringify(tipli));
console.log(JSON.stringify(Array.from(tipli)));
```

```
false
true
undefined
function
3
undefined
true
false
true
true
42.8,39.6,50.2
21.4,19.8,25.1
{"0":21.4,"1":19.8,"2":25.1}
[21.4,19.8,25.1]
```

Uzunluk sabittir: sınır dışına yazma sessizce yok sayılır, `push` gibi büyüten yöntemler
bulunmaz. Bu, Veri Yapıları kursundaki Diziler ile Dinamik Diziler ayrımının dildeki
karşılığıdır — tipli dizi birincisi, sıradan dizi ikincisidir.

Zincir yapısı da ayrıdır. Tüm tipli dizi türleri ortak bir ara prototipi paylaşır; `map`,
`filter`, `reduce` gibi yöntemler orada tanımlıdır ve `Array.prototype` ile hiçbir bağları
yoktur. Ara prototipin prototipi doğrudan `Object.prototype` nesnesidir. `map` çağrısının
yine tipli dizi döndürmesi de bu ayrı gerçekleştirimin sonucudur.

Dizileştirmede fark belirgindir: `JSON.stringify` tipli diziyi sayısal anahtarlı bir nesne
olarak yazar, dizi olarak değil. İkili veriyi metin biçiminde taşımak gerekiyorsa önce
sıradan diziye çevrilmelidir.

## Görünüm mü, Kopya mı

Aynı arabellek üzerinde çalışan iki yöntem, bu kursun son dersine doğrudan bağlanan bir
ayrım kurar: `subarray` bir görünüm, `slice` bir kopya döndürür.

```js
const tumOlcumler = new Float64Array([21.4, 19.8, 25.1, 18.2, 30.0]);

const pencereGorunumu = tumOlcumler.subarray(1, 4);
const pencereKopyasi = tumOlcumler.slice(1, 4);

console.log([...pencereGorunumu].join(","));
console.log([...pencereKopyasi].join(","));
console.log(pencereGorunumu.buffer === tumOlcumler.buffer);
console.log(pencereKopyasi.buffer === tumOlcumler.buffer);

pencereGorunumu[0] = 0;
pencereKopyasi[1] = 0;

console.log([...tumOlcumler].join(","));
console.log([...pencereKopyasi].join(","));

console.log(pencereGorunumu.byteOffset);
console.log(pencereKopyasi.byteOffset);
console.log(tumOlcumler.byteLength);
```

```
19.8,25.1,18.2
19.8,25.1,18.2
true
false
21.4,0,25.1,18.2,30
19.8,0,18.2
8
0
40
```

İki pencere başlangıçta aynı değerleri gösterir. Görünüme yazmak asıl diziyi değiştirir,
kopyaya yazmak değiştirmez. Bellek açısından da farklıdırlar: görünüm yeni bayt ayırmaz ve
asıl arabellek içinde bir ofsetten başlar; kopya kendi arabelleğini yaratır.

Büyük ölçüm bloklarında pencere işlemleri için görünüm kullanmak, veriyi çoğaltmadan
çalışmayı sağlar. Buna karşılık görünüm asıl arabelleği erişilebilir tuttuğu için, küçük
bir pencere büyük bir arabelleği bellekte yaşatabilir — Zayıf Koleksiyonlar dersindeki
erişilebilirlik tartışmasının bir başka biçimi.

## Özet

- `ArrayBuffer` ham baytları tutar; erişim, baytları belirli bir sayı türü olarak
  yorumlayan görünümlerle yapılır.
- Aynı arabellek üzerinde birden çok görünüm kurulabilir ve hepsi aynı belleği paylaşır.
- Tam sayı görünümleri aralık dışı değerleri sarar, kırpmalı tür ise aralığa kırpar;
  ondalık kısım tam sayı türlerinde atılır.
- Tipli dizi görünümleri yerel bayt sırasını kullanır; taşınabilir ikili biçimler için
  `DataView` ile sıra açıkça belirtilir.
- Tipli diziler `Array` türünden ayrı bir zincire sahiptir: uzunlukları sabittir,
  büyütülemezler ve dizileştirmede nesne olarak yazılırlar.
- `subarray` aynı belleğe bakan bir görünüm, `slice` bağımsız bir kopya döndürür.

## Sonraki Adım

Bu derste kopya ile görünüm ayrımı bayt düzeyinde göründü; aynı soru nesneler için kursun
başından beri açıktı. Nesne yayma zinciri kaybetti, `Object.assign` erişimcileri düz
değere çevirdi, `JSON.stringify` yöntemleri ve `Map` içeriğini attı. Son ders bu ayrımı
toplu olarak ele alacak: bir nesneyi kopyalarken neyin taşındığını, neyin düştüğünü ve
derin kopyanın hangi yollarla — hangi kayıplarla — yapıldığını gösterecek.