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

# Dizgiler

Şablon dizgileri, dilimleme ve arama yöntemleri, yerel ayara bağlı harf dönüşümü, kod birimi ile grafem ayrımı ve sayı biçimlendirme.

Çıktılar bu derse kadar `console.log` argümanlarıyla üretildi. Rapor metni yazmak,
dizgilerin kendi araçlarını gerektirir. Bu ders o araçları tanımlar ve İlkel Tipler
dersinde bırakılan bir konuyu — dizginin kod birimi dizisi olmasının pratik sonucunu —
tamamlar.

Dizgiler değiştirilemezdir; buradaki her yöntem yeni bir dizgi üretir, özgün değeri
değiştirmez.

## Şablon Dizgileri

Ters tırnakla yazılan dizgiler üç ek yetenek taşır: ifade yerleştirme, çok satırlılık ve
kaçış kurallarının farklılığı.

```js
const kayit = { istasyon: "A1", sicaklik: 21.5 };
const esik = 20;

const sablon = `${kayit.istasyon}: ${kayit.sicaklik} C (${kayit.sicaklik > esik ? "esik ustu" : "esik alti"})`;
console.log(sablon);

const cokSatir = `istasyon: ${kayit.istasyon}
sicaklik: ${kayit.sicaklik}`;
console.log(cokSatir);
console.log(`tirnak: "A1", ters tirnak: \`A1\`, dolar: \${kayit}`);
```

```
A1: 21.5 C (esik ustu)
istasyon: A1
sicaklik: 21.5
tirnak: "A1", ters tirnak: `A1`, dolar: ${kayit}
```

Yerleştirilen şey bir **ifadedir**; koşullar Koşullar ve Seçim dersindeki üçlü işleçle
yazılır. Her ifade metne çevrilir — Tip Dönüşümü ve Zorlama dersindeki metne çevirme
yordamı uygulanır, yani bir nesne yerleştirildiğinde `[object Object]` çıkar.

Satır sonu doğrudan yazılır; kaçış dizisi gerekmez. Ters tırnak ve dolar–süslü ayraç
ikilisi kaçırılmak istendiğinde ters bölü kullanılır.

Kursta metin birleştirme şablon dizgileriyle yazılır. Gerekçe, `+` işlecinin Tip
Dönüşümü ve Zorlama dersinde görülen iki yüzlü davranışından kaçınmaktır: şablonda
sonucun metin olduğu sözdiziminden bellidir.

## Dilimleme ve Bölme

```js
const satir = "A1;21.5;48";
console.log(satir.length, satir[0], satir.at(-1));
console.log(satir.slice(0, 2), satir.slice(-2));
console.log(satir.slice(4, 2), satir.substring(4, 2));
console.log(satir.split(";"));
console.log(satir.split(";", 2));
console.log(["A1", "21.5"].join(";"));
```

```
10 A 8
A1 48
 ;2
[ 'A1', '21.5', '48' ]
[ 'A1', '21.5' ]
A1;21.5
```

Üçüncü satır iki dilimleme yönteminin ayrımını gösteriyor. `slice` negatif dizin kabul
eder ve başlangıç bitişten büyükse **boş dizgi** verir. `substring` negatif dizinleri
sıfır sayar ve argümanları gerekirse **yer değiştirir**; bu yüzden `;2` üretti. İki
sonucun aynı satırda boşlukla ayrılmış yazılması, ilkinin boş olduğunu gösteriyor. Kursta
`slice` kullanılacaktır: davranışı dizilerdeki `slice` ile aynıdır ve sürpriz üretmez.

`split` bir ayırıcıya göre böler ve ikinci argümanla sonuç sayısını sınırlar. Sınırlama
kalan metni son parçaya eklemez, atar — dosya ayrıştırırken beklenmedik veri kaybının
kaynağıdır.

## Arama ve Değiştirme

```js
const satir = "istasyon=A1;alan=sicaklik;alan=nem";
console.log(satir.includes("alan"), satir.indexOf("alan"), satir.lastIndexOf("alan"));
console.log(satir.startsWith("istasyon"), satir.endsWith("nem"));
console.log(satir.replace("alan", "ALAN"));
console.log(satir.replaceAll("alan", "ALAN"));
console.log("  A1  ".trim() + "|", "  A1  ".trimStart() + "|");
console.log("A1".padStart(5, "0"), "A1".padEnd(5, "."), "-".repeat(10));
```

```
true 12 26
true true
istasyon=A1;ALAN=sicaklik;alan=nem
istasyon=A1;ALAN=sicaklik;ALAN=nem
A1| A1  |
000A1 A1... ----------
```

`replace` metin argümanıyla çağrıldığında **yalnızca ilk eşleşmeyi** değiştirir;
tümü için `replaceAll` kullanılır. Bu, sessiz hata üreten bir ayrımdır.

Doldurma yöntemleri hizalı çıktı üretmenin temelidir ve dolgu karakteri verilebilir.
Kırpma yöntemleri baştaki ve sondaki boşlukları atar; hangi karakterlerin boşluk sayıldığı
standartta tanımlıdır.

## Yerel Ayara Bağlı Harf Dönüşümü

Büyük–küçük harf dönüşümü dile bağlıdır ve öntanımlı yöntemler dilden bağımsız kuralı
uygular:

```js
const ad = "istasyon";
console.log(ad.toUpperCase());
console.log(ad.toLocaleUpperCase("tr"));
console.log("ISTANBUL".toLowerCase());
console.log("ISTANBUL".toLocaleLowerCase("tr"));
```

```
ISTASYON
İSTASYON
istanbul
ıstanbul
```

Fark, noktalı ve noktasız i harflerinin ayrı harfler olduğu dillerde ortaya çıkar.
Öntanımlı dönüşüm `i` harfini noktasız büyük harfe çevirir; yerel ayarlı dönüşüm noktalı
harfi üretir.

Buradan iki kural çıkar. Kullanıcıya gösterilecek metin dönüştürülüyorsa yerel ayar
belirtilmelidir. Buna karşılık **karşılaştırma amacıyla** yapılan dönüşümde yerel ayarlı
biçim kullanılmamalıdır: aynı metin farklı yerel ayarlarda farklı sonuç verir ve
karşılaştırma tutarsızlaşır. Anahtar karşılaştırmaları dilden bağımsız biçimle yapılır.

## Kod Birimi ve Grafem

İlkel Tipler dersinde dizginin kod birimi dizisi olduğu söylenmişti. Sonucu dilimlemede
görünür:

```js
const metin = "A1😀";
console.log(metin.length);
console.log([...metin].length);
console.log([...metin]);
console.log(Array.from(metin).length);
```

```
4
3
[ 'A', '1', '😀' ]
3
```

`length` dört verdi çünkü son karakter iki kod biriminden oluşur — Bilgisayarlar Nasıl
Çalışır kursundaki vekil çift. Yayma ve `Array.from`, dizgiyi **kod noktalarına** göre
dolaşır ve üç eleman verir.

Kod birimi sınırında kesmek metni bozar:

```js
const metin = "A1😀";
console.log(metin.slice(0, 3).length);
console.log([...metin].slice(0, 3).join(""));
```

```
3
A1😀
```

İlk dilimleme, çift kod biriminin yalnızca ilkini aldı; ortaya tek başına anlamı olmayan
bir kod birimi çıktı ve gösterildiğinde bozuk görünür. İkinci yol kod noktası dizisi
üzerinde çalıştığı için karakteri bölmedi.

Grafem — kullanıcının tek karakter saydığı birim — kod noktasından da büyük olabilir;
birleştirici işaretler bunun örneğidir:

```js
const birlesik = "é";
const tek = "é";
console.log(birlesik.length, tek.length, birlesik === tek);
console.log(birlesik.normalize("NFC") === tek);
```

```
2 1 false
true
```

İki dizgi aynı görünür ama farklı kod noktası dizileridir; karşılaştırma yanlış verir.
Normalleştirme ikisini ortak biçime getirir. Metin karşılaştırması yapan kod, girdileri
önce normalleştirmelidir.

## Sayı Biçimlendirme

```js
console.log((21.456).toFixed(2));
console.log((0.1 + 0.2).toFixed(2));
console.log((1.005).toFixed(2));
console.log((21.5).toString(2));
console.log(String(1e21), String(1e-7));
```

```
21.46
0.30
1.00
10101.1
1e+21 1e-7
```

`toFixed` belirtilen basamak sayısına yuvarlar ve **metin** döndürür. Üçüncü satır
sürpriz gibi görünür ama İlkel Tipler dersindeki modelin sonucudur: `1.005` değeri kayan
noktalı gösterimde tam olarak temsil edilemez ve saklanan değer `1.005`'ten biraz
küçüktür, bu yüzden aşağı yuvarlanır. Yuvarlama hatası biçimlendirmede değil, sayının
kendisindedir.

`toString` taban argümanı alır; Bilgisayarlar Nasıl Çalışır kursundaki İkilik Sayı
Sistemi dersindeki gösterim böyle üretilir. Son satır, çok büyük ve çok küçük sayıların
üstel gösterime geçtiğini gösteriyor; sınırlar standartta tanımlıdır.

## Ölçüm Raporunu Yazmak

Bu dersin araçları birleştiğinde hizalı bir rapor çıkar:

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

const baslik = `${"istasyon".padEnd(10)}${"sicaklik".padStart(9)}${"nem".padStart(6)}`;
const cizgi = "-".repeat(baslik.length);

const satirlar = kayitlar.map((k) => {
  const nemMetni = k.nem == null ? "-" : String(k.nem);
  return `${k.istasyon.padEnd(10)}${k.sicaklik.toFixed(2).padStart(9)}${nemMetni.padStart(6)}`;
});

console.log([baslik, cizgi, ...satirlar].join("\n"));
```

```
istasyon   sicaklik   nem
-------------------------
A1            21.50    48
A2            19.75    55
B1            23.00     -
```

Eksik nem alanı `-` ile gösterildi; `== null` denetimi Eşitlik Karşılaştırmaları
dersindeki istisnadır. `toFixed(2)` tüm sıcaklıkları aynı basamak sayısına getirdi —
`23` değeri `23.00` olarak yazıldı. Satırlar `join` ile tek bir metne bağlandı ve tek
çağrıda yazıldı.

Hizalama kod birimi sayısına dayanır. Rapor Latin harfleri dışında karakterler
içeriyorsa, doldurma yöntemleri görsel genişliği değil kod birimi sayısını
dengeleyeceği için sütunlar kayabilir.

## Özet

- Şablon dizgileri ifade yerleştirir, çok satırlıdır ve kursta metin birleştirmenin
  tek biçimidir.
- `slice` negatif dizin kabul eder ve ters aralıkta boş dizgi verir; `substring`
  argümanları yer değiştirir.
- `replace` yalnızca ilk eşleşmeyi değiştirir; tümü için `replaceAll` gerekir.
- Harf dönüşümü yerel ayara bağlıdır; gösterim için yerel ayarlı, karşılaştırma için
  dilden bağımsız biçim kullanılır.
- `length` kod birimi sayar; kod noktası bazlı işlem için yayma veya `Array.from`
  kullanılır ve karşılaştırmadan önce normalleştirme gerekir.
- `toFixed` metin döndürür ve yuvarlama, sayının kayan noktalı temsilinden etkilenir.

## Sonraki Adım

Rapor okunabilir bir metin üretti, ama makinenin geri okuyabileceği bir biçim değil.
Sonraki ders JSON'u ele alacak: dizileştirme ve ayrıştırma, biçimin desteklemediği
değerler, döngüsel başvurunun ürettiği hata ve dönüşümü uyarlayan geri çağrılar. Büyük
Tam Sayılar dersinde bırakılan dizileştirme sorunu da orada tamamlanacak.
