Bodoslama JavaScript

JavaScript dünyada en yaygın olarak kullanılan programlama dilidir çünkü web tarayıcıları sayfaları gösterirken sıklıkla bu dili kullanır. Tüm cep telefonları, tabletler, bilgisayarlar gibi internet sayfalarını görüntülediğiniz cihazlarda otomatik olarak yüklüdür ve sıklıkla JavaScript programları çalışır. Bundan dolayı bu dilin modasının hiç bir zaman geçmeyeceği gibi bir kanı vardır ve muhtemelen öyle olacak, yani bu dili öğrenmeniz size hiç bir şey kaybettirmez.

Her programlama dilinde olduğu gibi JavaScript kullanırken de değişkenler tanımlayıp bunlara değerler atarız, aşağıdaki kodlarda JavaScript söz dizimi ve en sık kullanılan değişken tiplerini gözlemleyebilirsiniz.

//Bu cift geri bolu isaretinden sonra gelen her sey yorum olarak kabul edilir

let x; // x adinda bir degisken tanimladik

//degiskenlere = operatoruyle değer atayabiliriz
x = 1; // simdi x degiskeninin degeri 1 oldu
x //=> 1: bu sekilde degiskenin degerini hesaplatabiliriz

// Asagida JavaScript'in destekledigi yaygin veri tipleri var
x=1; // sayilar.
x = 0.01; // float
x = "hello world"; // string
x = 'JavaScript'; // bu da string
x = true; // boolean
x = false; // boolean
x = null; // bu ozel bir veridir, degeri yok demektir
x = undefined; // bu da null gibi ozel bir veri tipidir

JavaScript'te en yaygın kullanılan nesneler object veri tipleridir, bunlar Python'daki dictionary veri tiplerine benzer. Yani bunlar aslında isimler ve karşılık gelen değerlerden oluşan bir çoklu veri deposudur.

//object: en onemli veri tipi
let book = { // bu nesneler tanimlanirken suslu parantez kullanilir
    topic: "JavaScript", // "topic" ozelliginin degeri "JavaScript"
    edition: 7 // "edition" ozelliginin degeri7
}; // object nesnesini tanimlamayi bitirdik

// . veya [] ile ozellik degerlerine ulasilabilir
book.topic // => "JavaScript"
book["edition"] // => 7
book.author = "Flanagan"; // yeni ozellik ve deger olusturulabilir
book.contents = {}; // {} ile bos bir object nesnesi yaratilir
// ?. ile sartli ozellik ulasimi
book.contents?.ch01?.sect1 // => undefined: cunku boyle bir ozellik yok

JavaScript programlarında sık kullanılan başka bir çoklu veri tipi de array veri tipleridir, bunlar indislenmiş nümerik verilerden oluşur, Python'daki list veri tipine benzer özellikleri vardır.

let primes = [2, 3, 5, 7]; // 4 elemanli bir array verisi
primes[0] // => 2: ilk eleman, indeksi 0
primes.length // => 4: eleman sayisi
primes[primes.length-1] // => 7: son eleman
primes[4] = 9; // yeni eleman ve deger ekleme
primes[4] = 11; // var olan bir elemani degistirme
let empty = []; // [] bos array olusturma
empty.length // => 0

//array nesneleri object veya diger veri tiplerini tasiyabilir
let points = [
    {x: 0, y: 0},
    {x:1,y:1}
];

let data = {
    trial1: [[1,2], [3,4]], // her ozelliginin degeri bir array olan bir object
    trial2: [[2,3], [4,5]] // arraylarin degerleri de array
};

Tüm dillerde olduğu gibi JavaScript ile de operatörler yardımıyla veriler üzerinde işlemler yaparız.

// Aritmetik operatorler
3+2 // => 5
3-2 // => 1
3*2 // => 6
3/2 // => 1.5
points[1].x - points[0].x // => 1
"3" + "2" // => "32": string toplama
 
// bazi kisa yollar
let count = 0; // tanimlama
count++; // arttirma
count--; // azaltma
count += 2; // iki arttirma
count *= 3; // 3 ile carpma
count // => 6:

// kiyaslama
let x =2,y=3; // These = signs are assignment, not equality tests
x === y // => false
x !== y // => true
x true
x<=y // => true
x>y // => false
x>=y // => false
"two" === "three" // => false
"two" > "three" // => true: alfabetik siralama
false === (x > y) // => true

// lojik operatorler
(x === 2) && (y === 3) // => true
(x > 3) || (y < 3) // => false
!(x === y) // => true

JavaScript ile fonksiyon tanımlama aşağıdaki işlemlerde görüldüğü gibi yapılır.

function plus1(x) { // degiskeni x olan bir fonksiyon
    return x + 1; // degisken degerini bir artirip donduruyor
} // susulu parantezle kapanir

plus1(y) // => 4

let square = function(x) { // fonksiyonlar degiskene atanabilir
    return x * x; // hesaplama adimi
}; // noktali virgul ile biter

square(plus1(y)) // => 16

// bazi kisa yollar
const plus1 = x => x + 1; 
const square = x => x * x;

plus1(y) // => 4
square(plus1(y)) // => 16

Object nesnelerinin özellikleri üzerinde tanımlanmış fonksiyonlara metod denir.

let a = []; // bos array olusturduk
a.push(1,2,3); // push() metotu arraya eleman ekler
a.reverse(); // bu metod sirayi ters cevirir

//kendi metotlarimizi olusturabiliriz
points.dist = function() { // iki nokta arasi mesafe hesaplayan bir metod
    let p1 = this[0];
    let p2 = this[1];
    let a = p2.x-p1.x;
    let b = p2.y-p1.y;
    return Math.sqrt(a*a + b*b);
};

points.dist() // => Math.sqrt(2)

JavaScript'in kontrol yapıları aşağıdaki örnekte özetlenmiştir.

function abs(x) { // mutlak deger hesaplayan bir fonksiyon
    if(x>=0){ // if yapisi
        return x; // mukayese true ise calisacak kod
    } else { // 
        return -x; // mukayese false ise
    } //if yapisi sonu
} // fonksiyon sonu

function sum(array) {
    letsum=0;
        for(let x of array) { // for dongusu
            sum += x; 
        } // dongu bitis
    return sum;
}

function factorial(n) {
    let product = 1;
    while(n > 1) { // while dongusu
        product *= n;
        n--;
    } // dongu bitis
    return product;
}

function factorial2(n) {
    let i, product = 1;
    for(i=2; i <= n; i++) // 2'den n'e kadar otomatik sayac arttirimi
        product *= i;
    }
    return product;
}

JavaScript bir nesne yönelimli programlama dilidir (OOP), aşağıdaki örneklerde sınıf yapısını gözlemleyebilirsiniz.

class Point { // sinif isimlerini buyuk harfle baslatmak adettir
    constructor(x, y) { // constructor ile instance olusturulur
        this.x = x; // this kelimesi ile yeni object olusturulur
        this.y = y; 
    }

    distance() { // metod tanimliyoruz
        return Math.sqrt( // kare hesaplama
            this.x * this.x + // Point nesnesinin x degeri
            this.y * this.y // y degeri
        );
    } 
}

// instance alma
let p = new Point(1, 1); // (1,1) noktasi

// simdi metodumuzu kullanalim
p.distance() // => Math.SQRT2