JavaScript, Brendan Eich tarafından 1995 yılında oluşturuldu. Başlangıçta, daha karmaşık web uygulamaları için Java'nın kullanıldığı siteler için daha basit bir betik dili olarak tasarlandı, ancak Web sayfalarıyla sıkı entegrasyonu ve tarayıcılardaki yerleşik desteği nedeniyle Java'dan daha yaygın hale geldi.
Ancak, JavaScript yalnızca web tarayıcılarıyla sınırlı değildir: Google Chrome'un V8 JavaScript motoru için bağımsız bir çalışma ortamı sağlayan Node.js giderek daha popüler hale gelmektedir.
JavaScript, C diline benzer bir sözdizimine sahiptir, bu nedenle C veya Java gibi dilleri kullandıysanız, temel sözdizimin büyük bir kısmını zaten biliyorsunuz. Bununla birlikte, isim benzerliğine rağmen, JavaScript'in nesne modeli Java'nınkinden önemli ölçüde farklıdır.
```js
// Tek satırlık yorumlar iki eğik çizgi ile başlar.
/* Çok satırlı yorumlar eğik çizgi-yıldız ile başlar,
ve yıldız-eğik çizgi ile biter */
// İfadeler ; ile sonlandırılabilir
birSeyYap();
// ... ancak sonlandırma yapmak zorunda değilsiniz, çünkü noktalı virgüller
// otomatik olarak yeni satırlarda yer alır, ancak bazı durumlar hariç.
birSeyYap()
// Bu durumlar beklenmeyen sonuçlara yol açabileceğinden, burada
// noktalı virgüller kullanmaya devam edeceğiz.
///////////////////////////////////
// 1. Sayılar, Dizeler ve Operatörler
// JavaScript'in bir sayı türü vardır (64 bitlik IEEE 754 double).
// Double'lar 52 bitlik bir mantisaya sahiptir, bu da tam sayıları
// yaklaşık olarak 9✕10¹⁵'e kadar kesin olarak depolamak için yeterlidir.
3; // = 3
1.5; // = 1.5
// Temel aritmetik işlemler beklediğiniz gibi çalışır.
1 + 1; // = 2
0.1 + 0.2; // = 0.30000000000000004
8 - 1; // = 7
10 * 2; // = 20
35 / 5; // = 7
// Hatta düzensiz bölme işlemi de yapılabilir.
5 / 2; // = 2.5
// Ve modülo bölmesi de yapılabilir.
10 % 2; // = 0
30 % 4; // = 2
18.5 % 7; // = 4.5
// Bit işlemleri de çalışır; bir bit işlemi yaptığınızda float'ınız
// *en fazla* 32 bitlik bir işaretleme tamsayıya dönüştürülür.
1 <<2;//=4
// Öncelik parantez ile sağlanır.
(1 + 3) * 2; // = 8
// Üç adet gerçek olmayan sayı değeri vardır:
Infinity; // örneğin 1/0'ın sonucu
-Infinity; // örneğin -1/0'ın sonucu
NaN; // örneğin 0/0'ın sonucu, 'Sayı Değil' anlamına gelir
// Ayrıca boolean türü vardır.
true;
false;
// Stringler ' veya " ile oluşturulur.
'abc';
"Merhaba, dünya";
// Olumsuzluk işareti ! sembolü ile yapılır.
!true; // = false
!false; // = true
// Eşitlik === ile kontrol edilir.
1 === 1; // = true
2 === 1; // = false
// Eşitsizlik !== ile kontrol edilir.
1 !== 1; // = false
2 !== 1; // = true
// Diğer karşılaştırmalar
1 <10;//=true
1 > 10; // = false
2 <= 2; // = true
2 >= 2; // = true
// Stringler + ile birleştirilir.
"Merhaba " + "dünya!"; // = "Merhaba dünya!"
// ... ve sadece stringlerle sınırlı olmayan bir şekilde çalışır
// JavaScript nesneleri, diğer dillerde "sözlük(dictionary)" veya "haritalar(maps)" ile eşdeğerdir: anahtar-değer çiftlerinin sırasız bir koleksiyonudur.
var benimNesnem = {anahtar1: "Merhaba", anahtar2: "Dünya"};
// Değerler herhangi bir tür olabilir.
var benimNesnem = {benimAnahtarim: "benimDegerim", "digerAnahtarim": 4};
// Nesne özelliklerine köşeli parantezlerle veya nokta sözdizimi kullanarak da erişilebilir,
benimNesnem["digerAnahtarim"]; // = 4
benimNesnem.benimAnahtarim; // = "benimDegerim"
// Nesneler değiştirilebilir; değerler değiştirilebilir ve yeni anahtarlar eklenir.
benimNesnem.benimUcuncuAnahtarim = true;
// Henüz tanımlanmamış bir değeri erişmeye çalışırsanız, undefined alırsınız.
// JavaScript fonksiyonları birinci sınıf nesnelerdir, bu nedenle farklı değişken adlarına
// yeniden atanabilir ve diğer fonksiyonlara argüman olarak geçilebilir - örneğin,
// bir olay işleyici sağlarken:
function fonksiyonum(){
// bu kod 5 saniye sonra çağrılacak
}
setTimeout(fonksiyonum, 5000);
// Not: setTimeout, JS dilinin bir parçası değildir, ancak tarayıcılar ve Node.js tarafından sağlanır.
// Tarayıcılar tarafından sağlanan başka bir fonksiyon da setInterval'dir
function fonksiyonum(){
// bu kod her 5 saniyede bir çağrılacak
}
setInterval(fonksiyonum, 5000);
// Fonksiyon nesnelerinin bile isimle tanımlanması gerekmez - başka bir argümana
// doğrudan anonim bir fonksiyon tanımı yazabilirsiniz.
setTimeout(function(){
// bu kod 5 saniye sonra çağrılacak
}, 5000);
// JavaScript, fonksiyon kapsamına sahiptir; fonksiyonlar kendi kapsamlarını alır,
// ancak diğer bloklar almaz.
if (true){
var i = 5;
}
i; // = 5 - blok kapsamı olan bir dilde beklendiği gibi undefined değil
// Bu, "hemen çalışan anonim fonksiyonlar"ın yaygın bir modeline yol açmıştır.
// Bu model, geçici değişkenlerin global kapsama sızmasını önler.
(function(){
var gecici = 5;
// Global kapsama `window` olarak atanarak global kapsama erişebiliriz.
// Web tarayıcısında global nesne her zaman `window`'dur. Node.js gibi tarayıcı dışı
// ortamlarda global nesnenin farklı bir adı olabilir.
window.kalici = 10;
})();
gecici; // Referans Hatası verir
kalici; // = 10
// JavaScript'in en güçlü özelliklerinden biri closure'lardır. Eğer bir fonksiyon başka bir fonksiyonun içinde tanımlanmışsa, iç fonksiyon dış fonksiyonun tüm değişkenlerine erişebilir, hatta dış fonksiyon sonlandıktan sonra bile.
function beşSaniyedeMerhabaDe(isim){
var mesaj = "Merhaba, " + isim + "!";
// İç fonksiyonlar varsayılan olarak yerel kapsama yerleştirilir, sanki `var` ile tanımlanmış gibi.
function içFonksiyon(){
alert(mesaj);
}
setTimeout(içFonksiyon, 5000);
// setTimeout asenkron bir işlem olduğu için beşSaniyedeMerhabaDe fonksiyonu hemen sonlanacak ve setTimeout daha sonra içFonksiyon'u çağıracak. Ancak içFonksiyon, beşSaniyedeMerhabaDe fonksiyonunun kapsamında olduğu için içFonksiyon sonunda çağrıldığında hala `mesaj` değişkenine erişebilecektir.
}
beşSaniyedeMerhabaDe("Kaan"); // 5 saniye sonra "Merhaba, Kaan!" içeren bir pencere açacak
///////////////////////////////////
// 5. Nesneler Hakkında Daha Fazla: Kurucular(Constructors) ve Prototipler(Prototypes)
// Nesneler fonksiyonlar içerebilir.
var myObj = {
myFunc: function(){
return "Merhaba dünya!";
}
};
myObj.myFunc(); // = "Merhaba dünya!"
// Nesneye bağlı olarak çağrılan fonksiyonlar, `this` anahtar kelimesini kullanarak kendilerine bağlı olan nesneye erişebilir.
myObj = {
myString: "Merhaba dünya!",
myFunc: function(){
return this.myString;
}
};
myObj.myFunc(); // = "Merhaba dünya!"
// `this` hangi bağlamda fonksiyonun çağrıldığıyla ilgilidir, tanımlandığı yerle değil. Bu nedenle, fonksiyonumuz nesnenin bağlamında çağrılmazsa çalışmaz.
var myFunc = myObj.myFunc;
myFunc(); // = undefined
// Tersine, bir fonksiyon, tanımlandığı sırada bağlı olmasa bile nesneye atanabilir ve `this` aracılığıyla nesneye erişebilir.
var myOtherFunc = function(){
return this.myString.toUpperCase();
};
myObj.myOtherFunc = myOtherFunc;
myObj.myOtherFunc(); // = "MERHABA DÜNYA!"
// Ayrıca, bir fonksiyonu çağırırken onu hangi bağlamda çalıştıracağımızı`call` veya `apply` kullanarak belirtebiliriz.
var anotherFunc = function(s){
return this.myString + s;
};
anotherFunc.call(myObj, " Ve Merhaba Ay!"); // = "Merhaba Dünya! Ve Merhaba Ay!"
// `apply` işlevi neredeyse aynıdır, ancak bir argüman listesi için bir dizi alır.
anotherFunc.apply(myObj, [" Ve Merhaba Güneş!"]); // = "Merhaba Dünya! Ve Merhaba Güneş!"
// Bu, bir dizi geçirmek istediğinizde bir argüman dizisini kabul eden bir işlevle çalışırken faydalıdır.
Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (Haydaaa)
Math.min.apply(Math, [42, 6, 27]); // = 6
// Ancak, `call` ve `apply` geçicidir. Kalıcı olmasını istediğimizde `bind` kullanabiliriz.
var birlestir = anotherFunc.bind(myObj);
birlestir(" Ve Merhaba Satürn!"); // = "Merhaba Dünya! Ve Merhaba Satürn!"
// `bind` ayrıca bir işlevi kısmen uygulamak (curry) için de kullanılabilir.
var product = function(a, b){ return a * b; };
var ikiylecarp = product.bind(this, 2);
ikiylecarp(8); // = 16
// `new` anahtar kelimesiyle bir işlevi çağırdığınızda, yeni bir nesne oluşturulur ve bu nesne `this` anahtar kelimesi aracılığıyla işleve ulaşır. Böyle çağrılmak üzere tasarlanmış işlevlere kurucular denir.
var MyConstructor = function(){
this.myNumber = 5;
};
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
// JavaScript, diğer popüler nesne tabanlı dillerin aksine, 'sınıf' taslaklarından oluşturulan 'örnekler' kavramına sahip değildir; bunun yerine, JavaScript, örnekleme ve kalıtımı tek bir kavramda birleştirir: 'prototype' (prototip).
// Her JavaScript nesnesinin bir 'prototype'u vardır. Bir nesnenin üzerinde mevcut olmayan bir özelliğe erişmeye çalıştığınızda, yorumlayıcı prototipine bakar.
// Bazı JS uygulamaları, nesnenin prototipine `__proto__` sihirli özelliği üzerinden erişmenizi sağlar. Bu, prototipleri açıklamak için faydalı olsa da, bunun standart bir parçası değildir; prototipleri kullanmanın standart yollarına daha sonra geleceğiz.
var myObj = {
myString: "Merhaba dünya!"
};
var prototipim = {
hayatinAnlami: 42,
myFunc: function(){
return this.myString.toLowerCase();
}
};
myObj.__proto__ = prototipim;
myObj.hayatinAnlami; // = 42
// Bu, işlevler için de çalışır.
myObj.myFunc(); // = "merhaba dünya!"
// Elbette, özelliğiniz prototipte değilse, prototipin prototipi aranır ve böyle devam eder.
prototipim.__proto__ = {
myBoolean: true
};
myObj.myBoolean; // = true
// Burada herhangi bir kopyalama işlemi yoktur; her nesne, prototipine bir referans tutar. Bu, prototipi değiştirebileceğimiz ve değişikliklerimizin her yerde yansıyacağı anlamına gelir.
prototipim.hayatinAnlami = 43;
myObj.hayatinAnlami; // = 43
// for/in ifadesi bir nesnenin özellikleri üzerinde yinelemeye izin verir,
// bir null prototipi görünceye kadar prototip zinciri üzerinde yürür.
for (var x in myObj){
console.log(myObj[x]);
}
///çıktı:
// Merhaba dünya!
// 43
// [Fonksiyon: myFunc]
// true
// Yalnızca nesneye kendisi tarafından eklenen özellikleri düşünmek için
// ve prototiplerini değil, `hasOwnProperty()` kontrolünü kullanın.
for (var x in myObj){
if (myObj.hasOwnProperty(x)){
console.log(myObj[x]);
}
}
///çıktı:
// Merhaba dünya!
// `__proto__`'nun standart olmadığını ve mevcut bir nesnenin prototipini
// değiştirmenin standart bir yolunun olmadığını belirttik. Bununla birlikte, verilen bir prototiple
// yeni bir nesne oluşturmanın iki yolu vardır.
// İlk yöntem:
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
// İkinci yol, yapıcılarla(constructors) ilgilidir.
// Yapıcıların prototype adında bir özelliği vardır. Bu, yapıcı işlevinin kendisinin prototipi değildir;
// bunun yerine, yeni nesnelerin, o yapıcı ve new anahtar kelimesiyle oluşturulduklarında verilen
// prototiptir.
MyConstructor.prototype = {
myNumber: 5,
getMyNumber: function(){
return this.myNumber;
}
};
var myNewObj2 = new MyConstructor();
myNewObj2.getMyNumber(); // = 5
myNewObj2.myNumber = 6;
myNewObj2.getMyNumber(); // = 6
// Dize ve sayı gibi yerleşik tiplerin ayrıca denk gelen sarma nesnelerini oluşturan yapıcıları vardır.
var myNumber = 12;
var myNumberObj = new Number(12);
myNumber == myNumberObj; // = true
// Ancak, tam olarak eşdeğer değiller.
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
if (0){
// Bu kod çalışmayacak, çünkü 0 yanlış değerlidir.
}
if (new Number(0)){
// Bu kod çalışacak, çünkü sarmalanan sayılar nesnelerdir ve nesneler
// her zaman doğru değerlidir.
}
// Bununla birlikte, sarma nesneleri ve düzenli yerleşik tipler bir prototipi paylaşırlar, bu yüzden
// aslında bir dizeye işlevsellik ekleyebilirsiniz, örneğin.
String.prototype.firstCharacter = function(){
return this.charAt(0);
};
"abc".firstCharacter(); // = "a"
// Bu genellikle "polyfilling" olarak adlandırılan bir yöntemde kullanılır.
// Örneğin, Object.create bazı uygulamalarda mevcut değil,
// ancak aşağıdaki polyfill ile yine de kullanabiliriz:
if (Object.create === undefined){ // mevcut ise üzerine yazma
Object.create = function(proto){
// doğru prototipe sahip geçici bir yapıcı oluştur
var Constructor = function(){};
Constructor.prototype = proto;
// ardından onu kullanarak yeni, uygun prototipli bir nesne oluştur
return new Constructor();
};
}
// ES6
// "let" anahtar kelimesi, değişkenleri bir fonksiyon kapsamı yerine
// bir leksikal kapsamda tanımlamanıza olanak tanır, var anahtar kelimesi gibi.
let name = "Billy";
// let ile tanımlanan değişkenlere yeni değerler atanabilir.
name = "William";
// "const" anahtar kelimesi, let ile aynı şekilde bir leksikal kapsamda bir değişken tanımlamanıza olanak tanır,
// ancak bir değer atandıktan sonra tekrar değer atanamaz.
const pi = 3.14;
pi = 4.13; // Bunu yapamazsınız.
// ES6'da "lambda sözdizimi" olarak bilinen bir fonksiyon için farklı bir sözdizimi vardır.
// Bu, sabit ve let ile tanımlanan değişkenler gibi bir leksikal kapsamda fonksiyonların tanımlanmasına olanak tanır.
const isEven = (number) => {
return number % 2 === 0;
};
isEven(7); // false
// Geleneksel sözdizimde bu fonksiyonun "eşdeğeri" şu şekilde görünür:
function isEven(number) {
return number % 2 === 0;
};
// "eşdeğer" kelimesini çift tırnak içine koydum çünkü lambda sözdizisi kullanılarak tanımlanan bir fonksiyon, tanımdan önce çağrılamaz.
// Aşağıdaki, geçersiz bir kullanım örneğidir:
add(1, 8);
const add = (firstNumber, secondNumber) => {
return firstNumber + secondNumber;
};
```
## Daha Fazlası İçin
[Mozilla Developer Network][1] tarayıcılarda kullanılan JavaScript için mükemmel bir dokümantasyon sunar. Ayrıca, bir wiki olduğu için daha fazla bilgi edindikçe kendi bilginizi paylaşarak diğer insanlara yardımcı olabilirsiniz.
MDN'nin [A re-introduction to JavaScript(JavaScript'e Yeniden Giriş)][2] başlıklı kaynağı, burada ele alınan kavramların daha detaylı bir şekilde ele alınmış halini içerir. Bu rehber, bilinçli bir şekilde sadece JavaScript dilini ele almıştır. Eğer JavaScript'i web sayfalarında nasıl kullanacağınız hakkında daha fazla bilgi edinmek isterseniz, [Belge Nesne Modeli (Document Object Model)][3] hakkında öğrenmeye başlayabilirsiniz.
[Patika - JavaScript][4]Hakan Yalçınkaya'nın eğitmen olduğu bu kaynak, JavaScript'i baştan sonra öğrenmenizi ve öğrendiklerinizi çeşitli test, proje ve coding challenge'lar ile pekiştirmenizi sağlar.
