Başlangıç Seviyesi

Bu bölümde JavaScript veri tiplerini adım adım öğreneceksiniz. Başlangıç seviyesi içeriklerle, karmaşık terimlerden uzak durarak mantığı kavrayacağınız örneklerle ilerleyeceğiz.

Ana Başlık

Kod Örneği

~18

Dakika

JavaScript Veri Tipleri - Başlangıç Seviyesi

JavaScript Veri Tipleri: Bilginin Kimlik Kartları Temel Kavramlar

Değişkenlerin birer "kutu" olduğunu öğrendik. Ancak bu kutuların içine koyduğumuz her bilgi aynı doğaya sahip değildir.

JavaScript, bilgileri işleyebilmek için onlara belirli kimlikler atar. Bu kimliklere Veri Tipleri diyoruz.

Bilgisayarın bir yazıyla bir sayıyı birbirinden ayırması, web sitenizin doğru çalışmasının temelidir.

Temel Yapı Taşları

İlkel (Primitive) Veri Tipleri: Temel Yapı Taşları

İlkel tipler, bellekte tek bir değer tutan en basit veri türleridir. Bu türler değiştirilemez; yani bellekte bir değer oluşturulduğunda o değerin kendisi sabittir.

String (Metinler): Karakter dizileridir. İster tek tırnak (' '), ister çift tırnak (" ") içinde yazılırlar. Kelimeler, cümleler ve hatta rakam gibi görünen ama matematiksel işlem görmeyen "123" gibi yapılar bu gruba girer.
Number (Sayılar): JavaScript'te tam sayılar ve ondalıklı sayılar ayrımı yoktur; her ikisi de Number tipindedir. 5, -10, 3.14 gibi değerlerle toplama, çıkarma ve bölme işlemlerini bu kimlik sayesinde yaparız.
Boolean (Mantıksal Değerler): Yazılımın en temel karar mekanizmasıdır. Sadece iki seçenek sunar: true (Doğru) veya false (Yanlış). Bir kullanıcının giriş yapıp yapmadığını veya bir ışığın açık olup olmadığını bu değerle kontrol ederiz.
Null (Boş): Bilinçli bir boşluktur. Bir değişkenin içinin boş olduğunu yazılımcı olarak biz belirtmek istediğimizde bu tipi kullanırız.

</>

Temel Veri Tiplerini Tanıyalım ()

Mühendislik Laboratuvarına Geç

// 1. String: Karakter Zinciri
let mesaj = "JavaScript Öğreniyorum";

// 2. Number: Matematiksel Değerler
let sayi = 42;
let ondalikli = 10.5;

// 3. Boolean: Mantıksal Karar
let ogrenciMi = true;

// 4. Undefined ve Null
let henuzAtanmadi; // Tanımsız (Undefined)
let kutuBos = null; // Bilinçli Boşluk (Null)

console.log(typeof mesaj); // "string"
console.log(typeof sayi);  // "number"
console.log(typeof ogrenciMi); // "boolean"

Kod Açıklamaları

Metin ve Sayı Tipleri

let mesaj = "JavaScript Öğreniyorum";
let sayi = 42;

String (Metin) tipindeki verileri her zaman tırnak içinde yazarız. Bilgisayar bu tırnakları gördüğünde "Tamam, bu sadece bir yazı, matematiksel bir değeri yok" der.

Number (Sayı) tipinde ise tırnak kullanmayız. Böylece bilgisayar bu veriyle toplama veya çarpma gibi işlemler yapabileceğini bilir.

Mantıksal Kararlar ve Boşluk

let ogrenciMi = true;
let henuzAtanmadi;
let kutuBos = null;

Boolean tipi (true/false) yazılımın anahtarıdır. Ya doğrudur ya yanlıştır; arası yoktur.

Undefined, bir kutu var ama içine henüz hiçbir şey konulmamış demektir. Null ise "Bu kutu şu an bilinçli olarak boş" demektir.

Kimlik Sorgulama (typeof)

console.log(typeof mesaj);

Bilgisayara "Bu kutudaki verinin tipi nedir?" diye sormak için typeof komutunu kullanırız. Konsolda karşımıza "string", "number" veya "boolean" gibi cevaplar çıkar.

Bellek Yönetimi

Verinin Doğasını Anlamak: Bellekte Ne Oluyor?

Neden her bilginin tipini bilmeliyiz? Çünkü JavaScript belleği (RAM) bir kütüphane gibidir.

Bir sayı için ayrılan alanla, binlerce kelimelik bir metin için ayrılan alan aynı değildir.

Siz bir veri tipi seçtiğinizde, aslında bilgisayara "Hafızanda benim için şu kadarlık bir yer ayır" demiş olursunuz.

Tip Dönüşümü

Tip Dönüşümü (Type Conversion): Esnekliğin Gücü

JavaScript bazen çok esnektir ve farklı tipleri birbirine dönüştürmenize izin verir. Ancak bu esneklik, bazen beklenmedik sonuçlara yol açabilir:

Otomatik Dönüşüm: Eğer bir sayıyla (5) bir metni ("10") toplamaya çalışırsanız, JavaScript sayıyı metne çevirip yan yana yazarak size "510" sonucunu verebilir.
Zorunlu Dönüşüm: Yazılımcı olarak biz, Number() veya String() gibi komutlarla verinin tipini manuel olarak değiştirebiliriz. Bu, veriyi kontrol altında tutmanın en güvenli yoludur.

</>

Tip Dönüşümü: Sayı mı Metin mi? ()

Mühendislik Laboratuvarına Geç

let sayiInput = "10"; // Kullanıcıdan metin olarak geldi
let bonus = 5;

// Yanlış: Metinle sayıyı toplarsak yan yana yazar
let hataliSonuc = sayiInput + bonus; 
console.log("Hatalı Toplam: " + hataliSonuc); // "105"

// Doğru: Metni sayıya çeviriyoruz
let dogruSonuc = Number(sayiInput) + bonus;
console.log("Doğru Toplam: " + dogruSonuc); // 15

Kod Açıklamaları

Beklenmedik Toplama (Hatalı Sonuç)

let hataliSonuc = sayiInput + bonus; // "105"

Burada sayiInput bir tırnak içinde ("10") olduğu için bilgisayar onu bir sayı olarak değil, bir yazı olarak görüyor.

JavaScript'te bir metinle bir sayıyı toplamaya çalışırsanız, bilgisayar "bunları yan yana yapıştırmalıyım" der. Sonuçta 10 ile 5'i toplamak yerine, onları birleştirip "105" yapar.

Güvenli Dönüşüm (Doğru Sonuç)

let dogruSonuc = Number(sayiInput) + bonus;

Number() komutu burada sihirli bir değnek görevi görür. Tırnak içindeki metni alıp gerçek bir sayıya dönüştürür.

Bilgisayar artık her iki değerin de sayı olduğunu bildiği için matematiksel toplama yapar ve bize gerçek sonuç olan 15 değerini verir.

Tip Kontrolü

Verinin Kimliğini Sorgulamak

Yazılım geliştirirken bazen elimizdeki verinin ne olduğunu biz bile karıştırabiliriz ( özellikle kullanıcıdan bir bilgi aldığımızda ). JavaScript bize bu belirsizliği çözmek için sihirli bir büyü sunar:

Dedektif Gibi Çalışır: Bir değişkenin önüne typeof yazdığınızda, bilgisayar size o kutunun içindeki verinin kimliğini (tipini) metin olarak söyler.
Hata Önleyicidir: Bir sayıyla metni yanlışlıkla toplamadan önce, verilerin tipini kontrol ederek olası "bug"ların önüne geçmenizi sağlar.

</>

Typeof ile Veri Tipini Kontrol Etme ()

Mühendislik Laboratuvarına Geç

// Farklı veri tiplerini kontrol edelim
let isim = "Softyla";
let yas = 25;
let aktifMi = true;
let bos = null;
let tanimsiz;

console.log(typeof isim);      // "string"
console.log(typeof yas);       // "number"
console.log(typeof aktifMi);  // "boolean"
console.log(typeof bos);       // "object" (JavaScript'in bilinen bir hatası)
console.log(typeof tanimsiz);  // "undefined"

// Kullanıcıdan gelen veriyi kontrol etme
let kullaniciGirdisi = prompt("Bir sayı girin:");
console.log("Girdi tipi: " + typeof kullaniciGirdisi); // Her zaman "string"!

// Tip kontrolü ile güvenli işlem
if (typeof kullaniciGirdisi === "string") {
    let sayi = Number(kullaniciGirdisi);
    console.log("Dönüştürülmüş sayı: " + sayi);}

Kod Açıklamaları

Veri Dedektifi: typeof

console.log(typeof isim); // "string"
console.log(typeof bos);  // "object"

typeof operatörü, kutunun içine bakıp verinin "kimlik kartını" okuyan bir dedektif gibidir.

Dikkat: null tipini sorguladığımızda "object" cevabını alırız. Bu, JavaScript'in ilk çıktığı günlerden kalan ünlü bir hatadır. ByteOmi'de bu hatanın neden düzeltilemediğini (geriye dönük uyumluluk) konuşacağız!

Prompt Tuzağı

let kullaniciGirdisi = prompt("Bir sayı girin:");
// Tip: "string"

Burası çok kritik! Kullanıcı kutuya 25 bile yazsa, prompt bunu her zaman tırnak içinde, yani bir metin ("25") olarak alır. Eğer tip kontrolü yapmazsanız, matematiksel işlemleriniz hatalı sonuç verebilir.

Savunmacı Kod Yazımı

if (typeof kullaniciGirdisi === "string") { ... }

Burada kodumuzu korumaya alıyoruz. "Eğer gelen veri gerçekten bir metinse, önce onu sayıya çevir, sonra işlem yap" diyoruz. Bu alışkanlık, sitemizin çökmesini veya yanlış hesap yapmasını önleyen profesyonel bir yaklaşımdır.

ByteOmi Köprüsü

Ek Köprü İçeriği: "Değişmezlik" (Immutability)

ByteOmi'ye geçtiğinde en çok duyacağın kelimelerden biri "Değişmezlik" olacak. İlkel tiplerin ( String, Number vb. ) neden değiştirilemez olduğunu şimdiden anlamak, ilerideki büyük mimari yapıları kavramanı sağlar:

İlkel Tipler Sabittir: Bir Number veya String oluşturduğunda, bilgisayar o değeri bellekte dondurur.
Kutuyu Değiştirmek vs. İçindekini Değiştirmek: Eğer puan = 5 iken puan = 10 yaparsan, aslında 5 sayısını 10'a dönüştürmezsin; bilgisayar gider yeni bir 10 sayısı oluşturur ve kutunun içine onu koyar. Eski 5 ise "Çöp Toplayıcı" (Garbage Collector) tarafından temizlenir.

</>

Değişmezlik (Immutability) Kanıtı ()

Mühendislik Laboratuvarına Geç

let kurs = "softla";
kurs.toUpperCase(); // Büyük harfe çevir komutu verdik

console.log(kurs); // Çıktı hala "softla"!
// Neden? Çünkü orijinal string asla değişmez. 

// Eğer değişmiş halini istiyorsak yeni bir değişkene atamalıyız:
let yeniKurs = kurs.toUpperCase();
console.log(yeniKurs); // "SOFTLA"

Kod Açıklamaları

Dondurulmuş Veriler

kurs.toUpperCase(); // Komut verildi ama...

JavaScript'te metinler (String) **ilkel** tiplerdir ve bellekte bir kez oluşturulduğunda asla değiştirilemezler. Sanki dondurulmuş bir kalıp gibidirler.

toUpperCase() komutunu kullandığında, JavaScript orijinal metni alıp büyük harfe çevirmez; bunun yerine büyük harflerden oluşan **tamamen yeni bir metin** üretir.

Yeni Değeri Saklamak

let yeniKurs = kurs.toUpperCase();

Eğer o büyük harfli sonuca ihtiyacımız varsa, onu yeni bir kutuya (yeniKurs) koymalıyız.

Orijinal kurs kutusu hala "softla" olarak kalmaya devam eder. Bu durum, verinin güvenliğini sağlar ve kodun beklenmedik şekilde bozulmasını önler.

Sayıların Sırrı

Sayıların Sırrı: 0.1 + 0.2 Neden 0.3 Etmez?

Yeni başlayan bir yazılımcı için en şaşırtıcı anlardan biri budur. Bu bilgi, seni sıradan bir kod yazıcısından, sistemin nasıl çalıştığını bilen bir yazılım mimarına dönüştürür:

Bilgisayarlar sayıları bizim gibi 10'luk sistemde değil, 2'lik (Binary) sistemde saklar.
Tıpkı 10'u 3'e böldüğümüzde 3.333... diye sonsuza gitmesi gibi, bilgisayar da bazı ondalıklı sayıları tam olarak saklayamaz.
Bu yüzden JavaScript'te 0.1 + 0.2 işlemi tam olarak 0.3 değil, 0.30000000000000004 gibi bir sonuç verir.
Neden Önemli? byteomi'de finansal uygulamalar veya hassas hesaplamalar yaparken neden özel yöntemler kullanmamız gerektiğini bu temel bilgiyle anlayacağız.

</>

Hassas Hesaplama Testi (Mühendislik Notu) ()

Mühendislik Laboratuvarına Geç

let sonuc = 0.1 + 0.2;

console.log("0.1 + 0.2 işleminin sonucu:");
console.log(sonuc); 

if (sonuc === 0.3) {
    console.log("Matematiksel olarak doğru!");
} else {
    console.log("Bilgisayar mimarisi nedeniyle küçük bir fark oluştu!");
}

Kod Açıklamaları

İkili (Binary) Sistem Gerçeği

let sonuc = 0.1 + 0.2; // 0.30000000000000004

Matematiksel olarak 0.3 bekliyordun değil mi? Ancak bilgisayarlar sayıları bizim gibi 10'luk değil, 0 ve 1'lerden oluşan 2'lik sistemde saklar.

Tıpkı 10'u 3'e böldüğümüzde 3.333... diye sonsuza gitmesi gibi, bilgisayar da bazı ondalıklı sayıları (0.1 gibi) 2'lik sistemde tam olarak ifade edemez ve çok küçük bir yuvarlama farkı oluşur.

Karşılaştırma Tuzağı

if (sonuc === 0.3) { ... }

Bu fark o kadar küçüktür ki gözle fark edilemez ama if kontrolü yaparken bilgisayar "Bunlar tamamen aynı değil!" diyerek else bloğuna geçer.

ByteOmi Vizyonu: Profesyonel projelerde veya finansal uygulamalarda bu tip hataları önlemek için sayıları önce tam sayıya çevirip sonra işlem yapmayı veya özel kütüphaneler kullanmayı öğreneceğiz.

İleri Seviye Hazırlık

Bir Üst Seviye İçin Hazırlık

Şu ana kadar öğrendiğimiz bu basit (ilkel) tipler, aslında büyük bir sistemin parçalarıdır.

İlerleyen aşamalarda, bu basit kutuların bir araya gelerek devasa veri yapılarını (Nesneler ve Diziler) nasıl oluşturduğunu göreceğiz.

Mimariyi anlamak için önce tuğlaları (veri tiplerini) doğru tanımak gerekir. Bu sayfadaki temeller, profesyonel bir yazılım mimarı olma yolundaki en kritik adımlarınızdır.

Görsel Diyagram

Verinin Kimliği

Bellek Yönetimi

String

Harflerden oluşan bir zincir gibi görselleştirilir.

Number

Bir hesap makinesi ekranındaki sayı gibi gösterilir.

Boolean

Bir lamba anahtarı (açık/kapalı) şeklinde simgelenir.