# Table of Contents - [Geliştirme Ortamı | JavaScript Eğitimi](#geli-tirme-ortam-javascript-e-itimi) - [H.N. ÇETİNKAYA Kitapları](#h-n-eti-nkaya-kitaplar-) - [JavaScript'i HTML ile Bütünleştirme | JavaScript Eğitimi](#javascript-i-html-ile-b-t-nle-tirme-javascript-e-itimi) - [Katı Mod Kullanımı | JavaScript Eğitimi](#kat-mod-kullan-m-javascript-e-itimi) - [JavaScript Giriş | JavaScript Eğitimi](#javascript-giri-javascript-e-itimi) - [Kurulum | JavaScript Eğitimi](#kurulum-javascript-e-itimi) - [Javascript'te İfadeler | JavaScript Eğitimi](#javascript-te-i-fadeler-javascript-e-itimi) - [Koşullu İfadeler | JavaScript Eğitimi](#ko-ullu-i-fadeler-javascript-e-itimi) - [İlkel (Primitive) Veri Tipleri | JavaScript Eğitimi](#i-lkel-primitive-veri-tipleri-javascript-e-itimi) - [DOM - Belge Nesnesi Modeli | JavaScript Eğitimi](#dom-belge-nesnesi-modeli-javascript-e-itimi) - [Operatörler | JavaScript Eğitimi](#operat-rler-javascript-e-itimi) - [Kapsamlar ve Geçerlilikler | JavaScript Eğitimi](#kapsamlar-ve-ge-erlilikler-javascript-e-itimi) - [Değişkenler (Variables) | JavaScript Eğitimi](#de-i-kenler-variables-javascript-e-itimi) - [Uyarı, Bilgi, Onay Fonksiyonları | JavaScript Eğitimi](#uyar-bilgi-onay-fonksiyonlar-javascript-e-itimi) - [JSON - Javascript Nesne Gösterimi | JavaScript Eğitimi](#json-javascript-nesne-g-sterimi-javascript-e-itimi) - [BOM - Tarayıcı Nesnesi Modeli | JavaScript Eğitimi](#bom-taray-c-nesnesi-modeli-javascript-e-itimi) - [Düzenli İfadeler (Regular Expressions) | JavaScript Eğitimi](#d-zenli-i-fadeler-regular-expressions-javascript-e-itimi) - [HTML ve CSS Eğitimi](#html-ve-css-e-itimi) - [Fonksiyonlar (İleri) | JavaScript Eğitimi](#fonksiyonlar-i-leri-javascript-e-itimi) - [Fonksiyonlar (Temel) | JavaScript Eğitimi](#fonksiyonlar-temel-javascript-e-itimi) - [İyi Bir Yazım ve Okunurluk İçin | JavaScript Eğitimi](#i-yi-bir-yaz-m-ve-okunurluk-i-in-javascript-e-itimi) - [Semboller (Symbol) | JavaScript Eğitimi](#semboller-symbol-javascript-e-itimi) - [Döngüler | JavaScript Eğitimi](#d-ng-ler-javascript-e-itimi) - [Referans (Reference) Veri Tipleri | JavaScript Eğitimi](#referans-reference-veri-tipleri-javascript-e-itimi) - [String - Karakter Dizisi | JavaScript Eğitimi](#string-karakter-dizisi-javascript-e-itimi) - [Number - Sayı | JavaScript Eğitimi](#number-say-javascript-e-itimi) - [if - else - else if | JavaScript Eğitimi](#if-else-else-if-javascript-e-itimi) - [Boolean - Mantıksal | JavaScript Eğitimi](#boolean-mant-ksal-javascript-e-itimi) - [Tip Dönüşümleri | JavaScript Eğitimi](#tip-d-n-mleri-javascript-e-itimi) - [switch - case - break | JavaScript Eğitimi](#switch-case-break-javascript-e-itimi) - [Bir Değişkenin Ömrü (Bellekte Tutulma Süresi) | JavaScript Eğitimi](#bir-de-i-kenin-mr-bellekte-tutulma-s-resi-javascript-e-itimi) - [Bitsel Operatörler | JavaScript Eğitimi](#bitsel-operat-rler-javascript-e-itimi) - [Koşullu (Ternary) Operatör | JavaScript Eğitimi](#ko-ullu-ternary-operat-r-javascript-e-itimi) - [Mantıksal Operatörler | JavaScript Eğitimi](#mant-ksal-operat-rler-javascript-e-itimi) - [Atama Operatörleri | JavaScript Eğitimi](#atama-operat-rleri-javascript-e-itimi) - [Blok Kapsam | JavaScript Eğitimi](#blok-kapsam-javascript-e-itimi) - [Karşılaştırma Operatörleri | JavaScript Eğitimi](#kar-la-t-rma-operat-rleri-javascript-e-itimi) - [Deklare Edilmeden Kullanılan Değişkenler | JavaScript Eğitimi](#deklare-edilmeden-kullan-lan-de-i-kenler-javascript-e-itimi) - [BigInt - Büyük Sayı | JavaScript Eğitimi](#bigint-b-y-k-say-javascript-e-itimi) - [Virgül Operatörü | JavaScript Eğitimi](#virg-l-operat-r-javascript-e-itimi) - [Matematiksel (Aritmetik) Operatörler | JavaScript Eğitimi](#matematiksel-aritmetik-operat-rler-javascript-e-itimi) - [Undefined - Tipi ve Değeri | JavaScript Eğitimi](#undefined-tipi-ve-de-eri-javascript-e-itimi) - [var ile Değişken Deklare Etme - Eski Yöntem | JavaScript Eğitimi](#var-ile-de-i-ken-deklare-etme-eski-y-ntem-javascript-e-itimi) - [let ile Değişken Deklare Etme | JavaScript Eğitimi](#let-ile-de-i-ken-deklare-etme-javascript-e-itimi) - [Fonksiyon Kapsam | JavaScript Eğitimi](#fonksiyon-kapsam-javascript-e-itimi) - [Değişken İsimlendirme Kuralları ve Gelenekler | JavaScript Eğitimi](#de-i-ken-i-simlendirme-kurallar-ve-gelenekler-javascript-e-itimi) - [const ile Değişken Deklare Etme | JavaScript Eğitimi](#const-ile-de-i-ken-deklare-etme-javascript-e-itimi) - [Global Kapsam | JavaScript Eğitimi](#global-kapsam-javascript-e-itimi) - [Page 1 | HTML ve CSS Eğitimi](#page-1-html-ve-css-e-itimi) - [Fonksiyon İfadesi | JavaScript Eğitimi](#fonksiyon-i-fadesi-javascript-e-itimi) - [break - continue - label: | JavaScript Eğitimi](#break-continue-label-javascript-e-itimi) - [Değer Döndüren Fonksiyonlar | JavaScript Eğitimi](#de-er-d-nd-ren-fonksiyonlar-javascript-e-itimi) - [for Döngüsü | JavaScript Eğitimi](#for-d-ng-s-javascript-e-itimi) - [Geri Çağırma (Callback) | JavaScript Eğitimi](#geri-a-rma-callback-javascript-e-itimi) - [Set - Küme Nesnesi | JavaScript Eğitimi](#set-k-me-nesnesi-javascript-e-itimi) - [Parametreli Fonksiyonlar | JavaScript Eğitimi](#parametreli-fonksiyonlar-javascript-e-itimi) - [Koleksiyonlar (Map, Set) | JavaScript Eğitimi](#koleksiyonlar-map-set-javascript-e-itimi) - [Object - Nesne | JavaScript Eğitimi](#object-nesne-javascript-e-itimi) - [Ok (Arrow) Fonksiyonlar | JavaScript Eğitimi](#ok-arrow-fonksiyonlar-javascript-e-itimi) - [new Yapıcı Operatörü | JavaScript Eğitimi](#new-yap-c-operat-r-javascript-e-itimi) - [while - do while Döngüsü | JavaScript Eğitimi](#while-do-while-d-ng-s-javascript-e-itimi) - [Array - Dizi | JavaScript Eğitimi](#array-dizi-javascript-e-itimi) - [String Metotları | JavaScript Eğitimi](#string-metotlar-javascript-e-itimi) - [Number Metotları | JavaScript Eğitimi](#number-metotlar-javascript-e-itimi) - [Math Kütüphanesi | JavaScript Eğitimi](#math-k-t-phanesi-javascript-e-itimi) - [Map - Eşlem Nesnesi | JavaScript Eğitimi](#map-e-lem-nesnesi-javascript-e-itimi) - [Object.assign() ile Nesne Birleştirme ve Klonlama | JavaScript Eğitimi](#object-assign-ile-nesne-birle-tirme-ve-klonlama-javascript-e-itimi) - [Nesnelerde Üç Nokta (Spread) Operatörü | JavaScript Eğitimi](#nesnelerde-nokta-spread-operat-r-javascript-e-itimi) - [const ile Nesne Deklare Etme | JavaScript Eğitimi](#const-ile-nesne-deklare-etme-javascript-e-itimi) - [for .. in ile Nesnenin Özellikleri | JavaScript Eğitimi](#for-in-ile-nesnenin-zellikleri-javascript-e-itimi) - [Array Metotlar | JavaScript Eğitimi](#array-metotlar-javascript-e-itimi) - [this Deyimi ile Nesnenin Kendini Referans Etmesi | JavaScript Eğitimi](#this-deyimi-ile-nesnenin-kendini-referans-etmesi-javascript-e-itimi) - [Nesnelerde Fonksiyon Kullanımı ve Callback | JavaScript Eğitimi](#nesnelerde-fonksiyon-kullan-m-ve-callback-javascript-e-itimi) - [Nesne Erişimcileri (Getter & Setter) | JavaScript Eğitimi](#nesne-eri-imcileri-getter-setter-javascript-e-itimi) - [for .. of ile Dizilerin Yinelenmesi | JavaScript Eğitimi](#for-of-ile-dizilerin-yinelenmesi-javascript-e-itimi) - [Üç Nokta (Spread) Operatörü | JavaScript Eğitimi](#-nokta-spread-operat-r-javascript-e-itimi) --- # Geliştirme Ortamı | JavaScript Eğitimi Geliştiricilerin kod yazmak için tercih ettikleri iki seçenek vardır. 1. Tümleşik Geliştirici Ortamı (IDE - Integrated Development Environment) * Visual Studio Community * IntelliJ Idea * Eclipse * Android Studio * Arduino IDE * PyCharm * WebStorm * ... 2. Kaynak Kod Düzenleyiciler (Hafif Düzenleyiciler) (Code Editor) 1. Visual Studio Code 2. Sublime Text 3. Notepad++ 4. Atom 5. CodePen 6. ... Tümleşik geliştirme ortamları (IDE) size bir geliştirme esnasında test etme, ön izleme, derleme, hata ayıklama, kod tamamlama, kod vurgulama vb. baştan sona bir geliştiricinin tüm ihtiyacını karşılarken kod düzenleyiciler kod tamamlama, vurgulama ve hata ayıklama v.b. gibi bazı temel işlemleri yapabilir. Bu sebeple kod düzenleyiciler tümleşik geliştirme ortamlarına göre daha hafif ve hızlılardır fakat sadece kod düzenleme işini yapabilirler. Her geliştirici kendi sistemine, ortamına ve geliştirmek istediği projeye göre 'IDE' veya 'Kod Düzenleyici' seçebilir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/gelistirme-ortami#gelistirici-konsolu) Geliştirici Konsolu ---------------------------------------------------------------------------------------------------------------------- Yazdığımız JavaScript kodlarındaki hatalar için tarayıcımızın '**Geliştirici Araçları**' menüsünden '**Console**' sekmesini kullanacağız. Geliştirici araçları çoğu tarayıcıda **F12** kısayolu ile açılmaktadır. [PreviousKurulumchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kurulum) [NextJavaScript'i HTML ile Bütünleştirmechevron-right](https://hanuce.gitbook.io/javascript-egitimi/javascripti-html-ile-butunlestirme) Last updated 2 years ago --- # H.N. ÇETİNKAYA Kitapları [HTML ve CSS Eğitimi (2023)](https://hanuce.gitbook.io/html-ve-css-egitimi/) [JavaScript Eğitimi (2023)](https://hanuce.gitbook.io/javascript-egitimi/) Last updated 2 years ago --- # JavaScript'i HTML ile Bütünleştirme | JavaScript Eğitimi JavaScript kodları HTML ile **dahili** ve **harici** olarak bütünleştirilebilir. Dahili olarak satır içinde (inline) yazılabilir. Örnek olarak. Copy JavaScript Dersleri circle-info ' `alert()` ' fonksiyonu internet tarayıcımızın penceresinde bir uyarı kutusu göstermemizi sağlayan JavaScript fonksiyonudur. Uzun kodlar yazmak için elverişli olmayan bu yöntemi genellikle fonksiyonlarımızı çalıştırmak için kullanırız. JavaScript kodlarımızı dahili olarak doküman içerisinde '`****`' etiketi ile de yazabiliriz. Basit ve uzun olmayan kodlarımızı bu yöntemle bütünleştirmemiz önerilir. Örnek olarak. Copy gitbook.io Bu örnekte HTML elementimize tıklanınca çalıştırmak istediğimiz fonksiyonu satır içinde yazdık. Bu örnekteki "`****`" etiketini dokümanın "`** **`" etiketleri arasında istediğimiz yerde yazabiliriz. Genellikle kullanılan yöntem de harici olarak bütünleştirmektir. Uzun ve karmaşık işler için yazdığımız kodları bu yöntemle bütünleştirmemiz önerilir. Örnek olarak. Copy gitbook.io Bu yöntemde `**script**` etiketinin "`**src**`" niteliğini kullanırsak, etiket içinde yazdığımız kodlar yürütülmez. Yani 'bir' `**script**` etiketiyle aynı anda hem harici hem de dahili bütünleştirme yapamazsınız. Farklı script etiketleriyle bunu yapabilirsiniz. Bir HTML dokümanında sadece bir tane script etiketi olmasıyla ilgili bir zorunluluk yoktur. Örnek olarak. Copy Bu yöntemlerden birinin bir HTML dokümanında kullanılması diğer yöntemi geçersiz kılmaz. HTML dokümanında bütünleştirmeler birlikte kullanılabilir. [PreviousGeliştirme Ortamıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/gelistirme-ortami) [NextJavascript'te İfadelerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/javascriptte-ifadeler) Last updated 1 year ago --- # Katı Mod Kullanımı | JavaScript Eğitimi JavaScript varsayılan olarak ifadelerimizdeki semantik '_**bazı hataları**_' 'hata' olarak fırlatmaz, bunları tolere eder. ES5 ile 2009'da gelen yeniliklerden biri olan '_**katı mod**_'u kullandığımızda yazdığımız kodlardaki bu semantik hatalar tolere edilmez, kod yürütülmez ve hata olarak fırlatılır. Bu modun gelmesi ile birlikte eski mod 'özensiz mod (sloppy mode) - normal mod (normal mode)' yeni mod ise 'katı mod (strict mode)' olarak ifade edilmiştir. JavaScript'i katı mod ile kullanmak için `**"use strict" ;**` ifadesini kullanırız. 'Normal Mod' ile 'Katı Mod' arasındaki farklardan birini şu şekilde örnekleyebiliriz. Copy // normal mod dil = 'Javascript'; // hata vermez alert(dil); Copy // katı mod "use strict" ; dil = 'Javascript'; // hata fırlatır alert(dil); Yukarıdaki ilk kod bloğu çalışır, ikincisi çalışmaz. Katı mod hataları fırlatır çünkü katı modda değişkeni deklare etmeden kullanmak hata fırlatır. circle-info _'Değişken' ve_ '_Deklare Etme'_ kavramlarını bir sonraki ders işleyeceğiz. circle-info İnternet tarayıcımızda F12 kısayol tuşu ile açılan 'Diğer araçlar -> Geliştirici araçları -> Console (Konsol)' menüsündeki _**konsol**_ sekmesine kayıt (log) düşer ve bu şekilde orada bir çıktı görürüz. Örnekteki hata çıktısını konsoldan görüntüleyebilirsiniz. JavaScript geriye dönük uyumlu olarak geliştirildiği için önceki betiklerin çalışması açısından katı mod varsayılan olarak çalışmaz, normal moda göre çalışan motor katı moda biz belirttiğimiz takdirde geçer. Katı mod için yazdığımız ' `**"use strict";**` ' ifadesini **kesinlikle kodlarımızın ilk satırına yazmamız gerekir.** Aksi halde geçerli olmaz. Ayrıca katı modun _**bloklar (kapsamlar)**_ içinde de geçerli olmasını istiyorsanız blokların da ilk satırında yazmalısınız. Copy let isim; isim = 'Javascript' ; "use strict" ; // yanlış kullanım. alert(isim) { let dil; dil = 'Javascript' ; "use strict" ; // yanlış kullanım } circle-info _**{ Her süslü parantez arası bir blok (kapsam) anlamına gelir. }**_ Kapsamlar konusuna değişkenlerden sonra değineceğiz. Copy "use strict" ; // doğru kullanım. let isim; isim = 'Javascript' ; alert(isim) { "use strict" ; // doğru kullanım let dil; dil = 'Javascript' ; } [PreviousJavascript'te İfadelerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/javascriptte-ifadeler) [NextDeğişkenler (Variables)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables) Last updated 2 years ago --- # JavaScript Giriş | JavaScript Eğitimi * **JavaScript** 1995 yılında 'Brendan Eich' tarafından geliştirilmiştir. * 1997'den itibaren ECMA (European Computer Manufacturers Association) standartları altında geliştirilmeye devam edilmiştir. **ECMAScript** olarak da bilinir. * **JavaScript** dili geriye dönük uyumlu olarak geliştirilmeye devam ettiği için 1995 yılında yazılan JavaScript kodları halen günümüzde çalışabilmektedir. Bu yönü yaygınlaşmasında önemli rol oynamıştır. * **JavaScript** yorumlanan (interpreted) yüksek seviyeli bir dildir. * **JavaScript**'in yaygın şekilde kullanılması sebebiyle tüm tarayıcılar JavaScript kodlarını doğrudan çalıştırabilir şekilde tasarlanmaktadır. Herhangi bir kurulum gerektirmez. Yıllar içinde farklı geliştiriciler tarafından JavaScript'in üzerinde çalışan üst diller geliştirilmiştir. Typescript, Node.js, Dart gibi bu diller yaygın olarak kullanılmaktadır. Bu dillerde yazılan kodlar JavaScript'e çevrilerek yürütülmektedir. JavaScript ile istemci (client) tarafı için kod yazılabilirken, Typescript ve Node.js ile sunucu (server) taraflı kodlar da yazılabilmektedir. JavaScript: * Komut (script: '_betik_') dilidir. * Yorumlanan yüksek seviyeli bir dildir. * Fonksiyonel veya nesne yönelimli programlama yapabilirsiniz. (Çoklu Yaklaşım) * Tek iş parçacığı yürütür. (Single thread) * 'Çöp Toplama' özelliği vardır. (Başvurulmayan hafızayı boşaltır. Bellekte yer açar.) [NextKurulumchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kurulum) Last updated 2 years ago --- # Kurulum | JavaScript Eğitimi Herhangi bir sistemde JavaScript kodlarının yürütülmesi için herhangi bir kurulum, önyükleme vb. işlemler yapmaya gerek yoktur. JavaScript internet tarayıcılarının içinde çalışırlar. Mozilla, Chrome, Edge, Safari, vb. modern tarayıcıların hepsinde tümleşik ve etkin olarak bir '**JavaScript Motoru**' vardır. Buna 'JavaScript Sanal Makinesi' de denilmektedir. Bu motorlardan bazıları şunlardır: * V8 (Chrome, Opera) * SpiderMonkey (Mozilla) * ChakraCore (Edge) * Nitro (Safari) Bu motorlar yazılan JavaScript kodlarını makine diline çevirirler. Her motorun kendine ait özellikleri, metotları mevcuttur. JavaScript kodları (betikler) sistemimizdeki işlemci, bellek, disk vb. kaynaklara doğrudan erişemezler. Kodlar internet tarayıcısı aracılığıyla yürütülürler. İşlemin bu şekilde olması JavaScript kodlarının hızlı çalışmasını sağlamaktadır. Bir internet tarayıcısı ile bütünleşik çalışmanın artı ve eksi yönleri vardır. ARTILAR EKSİLER Kodlar her sistemde çalışır. Kodlarınız tarayıcıdan tarayıcıya farklı sonuçlar verebilir, geçerli olmayabilir. Kodlar istemci (client) tarafında yürütüldüğü için hızlıdır. Kodlar istemci tarafından görülebildiği için açıktır. Güvenlik ve gizlilik sorunlarına yol açabilir. Ağ üzerinden talepler gönderebilme. (Dosya yükleme, indirme vb.) Hata ayıklaması zordur. Hatalarda doğrudan uyarı vermez. Yürütme durdurulur. Sadece çerez (cookie) ile yerel dosya işlemleri yapmanıza olanak sağlar. İşletim sisteminin fonksiyonlarına (donanıma erişme, dosyalarınızı yazma, silme vb.) doğrudan erişemez. HTML ve CSS ile ön uçta zengin bir arayüz seçeneği sunar. [PreviousJavaScript Girişchevron-left](https://hanuce.gitbook.io/javascript-egitimi) [NextGeliştirme Ortamıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/gelistirme-ortami) Last updated 2 years ago --- # Javascript'te İfadeler | JavaScript Eğitimi Her programlama dilinin sözdizimi (syntax) yani yazım kuralları vardır. JavaScript kodlarını tarayıcı motorları okurken dile ait yazımlarda boşlukları dikkate almaz. Örneğin. Copy alert('Merhaba'); alert('Dünya'); alert( 'Merhaba Dünya' ) ; circle-info ' `**alert()**` ' fonksiyonu internet tarayıcımızda bir uyarı kutusu ile mesajımızı gösteren JavaScript fonksiyonudur. Yukarıdaki kod çalışır ve tarayıcıdan üç sefer uyarı metni alınır. Fakat kodun okunurluğunu artırmak için uygun şekilde yazmak önemlidir. Copy alert('Merhaba'); alert('Dünya'); Bir satırdaki ifade sözdizimi olarak birkaç satıra bölünebilir. Copy //Aşağıdaki yazımlar yürütülür. (Geleneksel olmayan yazım) alert('Merhaba' ); alert('Merhaba'+ 'Dünya'); alert(6*5- 30); alert(6 *5 -30); //Aşağıdaki yazım yürütülmez! Dile ait sembollerden sonra bölünebilir. alert('Merhaba Dünya'); Kod yazımı dile ait sembollerden bölünerek alt satırdan devam edebilir. Fakat bu işlemi kendi kurallarınıza göre değil yaygın kurallara göre yapmak gerekir. Eğer bir satırda seksen (80) karakterden fazla uzunlukta bir ifade var ise bölerek alt satırdan devam etmeniz önerilir. Kodun okunurluğu ve performans açısından önemlidir. Örnek olarak: Copy // 'const' ifadesine takılmayın ileride göreceğiz. const AYLAR = [\ 'Ocak', 'Şubat', 'Mart',\ 'Nisan', 'Mayıs', 'Haziran',\ 'Temmuz', 'Ağustos', 'Eylül',\ 'Ekim', 'Kasım', 'Aralık'\ ]; Ayrıca ifade sonunda noktalı virgül koymak zorunlu değildir. Bir satırdaki ifadeyi _**genellikle satır**_ sonunda noktalı virgül varmış gibi değerlendirir. Örnek olarak: Copy //Aşağıdaki ifadeler yürütülür alert('Merhaba') alert('Dünya') Birkaç ifade aynı satırda başlıyorsa ve noktalı virgül koymazsak hata alırız. Copy ///Aşağıdaki ifade hata verir! Yürütülemez! alert('Merhaba') alert('Dünya') //Doğrusu (yaygın olmayan yazım!) alert('Merhaba'); alert('Dünya'); //Aşağıdaki ifade hata verir! Yürütülemez! alert('Merhaba') alert ('Dünya') //Doğrusu (yaygın olmayan yazım!) alert('Merhaba'); alert ('Dünya') Noktalı virgül koymamak '_**genellikle'**_ hata oluşturmaz. Fakat bazı yürütmelerde hataya sebep olabilir. Bu sebeple yaygın kullanımda yazılırlar. Hataya bir örnek olarak. Copy //Hata veren yazım, 4.satırdaki ifade yürütülmez. // 'forEach'e takılmayın ileride göreceğiz. alert('Merhaba') ['Java','Script'].forEach(alert) Bu sebeple noktalı virgül ile ifadeleri bitirmek **uyulması gereken önemli bir gelenektir.** [PreviousJavaScript'i HTML ile Bütünleştirmechevron-left](https://hanuce.gitbook.io/javascript-egitimi/javascripti-html-ile-butunlestirme) [NextKatı Mod Kullanımıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kati-mod-kullanimi) Last updated 2 years ago --- # Koşullu İfadeler | JavaScript Eğitimi Koşullu ifadeler koşul olarak belirlenen şartın sağlandığı veya sağlanmadığı durumlara göre işlemler yapmamızı sağlayan ifadelerdir. Javascript'te bu ifadeler: * `**if**` - `**else**` - `**else if**` * `**switch**` - `**case**` - `**break**` Bu ifadelerden `**if**` - `**else**` - `**else if**` yapısı hemen hemen tüm programlama dillerinde mevcuttur. Koşullu operatörde gördüğümüz yapıyla aynı şekilde çalışır. Fakat ifade gücü ve okunurluğu daha fazladır. [PreviousUyarı, Bilgi, Onay Fonksiyonlarıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/uyari-bilgi-onay-fonksiyonlari) [Nextif - else - else ifchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/if-else-else-if) Last updated 2 years ago --- # İlkel (Primitive) Veri Tipleri | JavaScript Eğitimi JavaScript'te programlama yaparken oluşturduğumuz değişkenlerin değerleri bir veri tipinde olur. **Belirli bir değerin doğrudan erişilebilir şekilde saklandığı** tiplere ilkel veri tipleri (**değer tipler**) denir. Genellikle her programlama dilinde mevcuttur. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri#bir-veri-tipinin-ilkel-primitive-olarak-nitelendirilmesi) Bir Veri Tipinin İlkel (Primitive) Olarak Nitelendirilmesi ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Değişkenlerin tutulduğu hafıza RAM bellektir. Hafıza birimlerinin bellekteki konumu "0x2c53df20350" gibi **adreslerle** matematiksel olarak ifade edilirler. İlkel veri tiplerindeki değişkenler, belleğin "**çağrılan yığın (call stack)**" olarak ifade edilen bölümündeki bir adreste **doğrudan değerleri** tutarlar. Değerler **stack** olarak ifade edilen bu bölümde; parçalanmadan, doğrusal konumda (bitişik), sabit boyutlu ve doğrudan erişilebilir halde tutulurlar. ![Drawing](https://hanuce.gitbook.io/javascript-egitimi/~gitbook/image?url=https%3A%2F%2F1783608288-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FtkAky55y3oAsmbswePAh%252Fuploads%252FIsK0MjKcqtkzjPSMwv3o%252Ffile.excalidraw.svg%3Falt%3Dmedia%26token%3D18fea4bc-5adb-4454-9341-91dc83464f8b&width=768&dpr=3&quality=100&sign=6e8f769b&sv=2) İLKEL DEĞİŞKENLER VE HAFIZA **Stack** bölümü işletim sistemi tarafından yönetilir ve verilere hızlı erişilir. Fakat bir programda çok fazla ilkel veri tipinin kullanılması işletim sisteminde hafıza yetersizliğine yol açabilir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri#ilkel-veri-tipleri) İlkel Veri Tipleri ------------------------------------------------------------------------------------------------------------------------------- 1. **String - Karakter Dizisi** * Klavyeden girilen harf, rakam, nokta, virgül, boşluk vb. özel karakterle oluşan metin tipindeki veriler _**string**_ tipidir. 2. **Number - Sayı** * Nümerik olan ve üzerinde matematiksel işlemler yapabileceğimiz veri tipidir. Tamsayı, ondalıklı sayı, sonsuz sayı, sayısal değer olmayan gibi değerlerin hepsi _**number**_ tipinde veridir. 3. **Bigint - Büyüksayı** * 64-Bit uzunluğundaki sayısal veri tipidir. Sadece tamsayı olabilir ve teorik olarak _**number**_ tipinin alabileceği en fazla değerden daha büyük bir değeriniz varsa kullanılabilir. Çoğu programlama dilinde mevcut değildir ama ilkeldir. 4. **Boolean - Mantıksal** * Sadece True (Doğru) ve False (Yanlış) değerini tutan veri tipidir. 5. **Symbol - Sembol** * Benzersiz tanımlayıcıdır. İlkel bir tiptir fakat bu tipe referans veri tiplerinden sonra değineceğiz. Bir değişkenin tipini `**typeof degiskenAdi**` veya `**typeof(degiskenAdi)**` fonksiyonu ile öğrenebiliriz. Örnek. Copy let karakterDizisi = 'Javascript'; let sayi = 2023; let buyukSayi = 1n; let mantiksal = true; alert(typeof karakterDizisi); // 'string' çıktısı verir. alert( typeof(sayi) ); // 'number' çıktısı verir. alert(typeof buyukSayi); // 'bigint' çıktısı verir. alert( typeof(mantiksal) ); // 'boolean' çıktısı verir. [PreviousBir Değişkenin Ömrü (Bellekte Tutulma Süresi)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/bir-degiskenin-omru-bellekte-tutulma-suresi) [NextString - Karakter Dizisichevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi) Last updated 2 years ago --- # DOM - Belge Nesnesi Modeli | JavaScript Eğitimi [Previousİyi Bir Yazım ve Okunurluk İçinchevron-left](https://hanuce.gitbook.io/javascript-egitimi/iyi-bir-yazim-ve-okunurluk-icin) [NextBOM - Tarayıcı Nesnesi Modelichevron-right](https://hanuce.gitbook.io/javascript-egitimi/bom-tarayici-nesnesi-modeli) Last updated 2 years ago --- # Operatörler | JavaScript Eğitimi Programlama dillerinde '_**operatör**_' genellikle matematiksel veya mantıksal bir işlemi veya süreci temsil eden bir sembol veya deyimdir. Operatörler genellikle beş türde ifade edilir. 1. **Matematiksel (Aritmetik) Operatörler** * Toplama, çıkarma, çarpma vb. işlemler için kullandığımız sembollerdir. 2. **Atama Operatörleri** * Bir değişkenin değerini belirlerken (atarken) kullandığımız operatördür. 3. **Karşılaştırma Operatörleri** * İki öğe arasındaki büyüktür, küçüktür vb. ilişkiyi elde etmek için kullandığımız sembollerdir. 4. **Mantıksal Operatörler** * İfadeleri birbirine bağlamak için kullanılan '**ve (**`**&&**`**)**', '**veya (**`**||**`**)**' gibi sembollerdir. 5. **Bitsel Operatörler** * İki öğe arasındaki karşılaştırmayı öğelerin bit değerleri üzerinden yapmak için kullanılan sembollerdir. 6. **Koşullu (Ternary) Operatör** * Standart `**Boolean**` çıktısı olan `**true-false**` sonuçlarını kontrol etmek için kullanılan semboldür. 7. **Virgül Operatörü** * İfadeleri ardı ardına yazarak yürütmemizi sağlayan operatördür. [PreviousTip Dönüşümlerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/tip-donusumleri) [NextMatematiksel (Aritmetik) Operatörlerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler) Last updated 2 years ago --- # Kapsamlar ve Geçerlilikler | JavaScript Eğitimi Kapsam; değişkenlerin veya ifadelerin geçerli olduğu, başvurulduğunda erişilebildiği kod birimidir. Hiyerarşiktir. Alt kapsamlardan üst kapsamlardaki değişkenlere veya ifadelere erişebilir. Fakat tam tersi mümkün değildir. JavaScript'te üç çeşit kapsam vardır. * Global Kapsam (Ana Kapsam) * Blok Kapsamı (Alt Kapsam) * Fonksiyon Kapsamı (Alt Kapsam) [PreviousDeğişken İsimlendirme Kuralları ve Geleneklerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/degisken-isimlendirme-kurallari-ve-gelenekler) [NextGlobal Kapsamchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/global-kapsam) Last updated 2 years ago --- # Değişkenler (Variables) | JavaScript Eğitimi **Değişken (variable):** Programlama dilinde değerleri tuttuğumuz hafıza birimleridir. Verileri bir anahtar sözcüğe temsil ettiririz. Örneğin '`_x = 3_`_'_ ifadesinde '_**x**_' anahtar sözcüğünde '_3_' değerini tutarız. Bize " _**x**_ kadar elma al." denilirse "3 tane elma" alacağımızı biliriz. Yani x'in '3' değerini temsil ettiğini biliriz. Başka bir örnekle: ![Drawing](https://hanuce.gitbook.io/javascript-egitimi/~gitbook/image?url=https%3A%2F%2F1783608288-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FtkAky55y3oAsmbswePAh%252Fuploads%252Fj2Ri9akZYGf4FiVgiAC7%252Ffile.excalidraw.svg%3Falt%3Dmedia%26token%3Db7c4bdbb-9cf4-4880-be72-f47ba44f6a20&width=768&dpr=3&quality=100&sign=f6651c9d&sv=2) Değişken Başka bir örnekle, '`_metin = 'JavaScript'_`_'_ ifadesinde 'metin' anahtar sözcüğünde 'JavaScript' değerini tutarız. Bize "metin'in son harfi nedir?" sorusu sorulursa "t" harfi olduğunu söyleriz. JavaScript'te bir **değişkeni kullanmadan önce bildirmek esastır.** Buna '**deklare etme**' yani bildirim denir. Bir değişkeni deklare ederken JavaScript'e ait deklaratif bir sözcük kullanırız. **Deklare edilen değişkene bellekte bir yer ayrılır ve değerini bellekteki saklar.** JavaScript'te üç tane deklaratif sözcük vardır. * `**let**` * `**var**` * `**const**` [PreviousKatı Mod Kullanımıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kati-mod-kullanimi) [Nextlet ile Değişken Deklare Etmechevron-right](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/let-ile-degisken-deklare-etme) Last updated 2 years ago --- # Uyarı, Bilgi, Onay Fonksiyonları | JavaScript Eğitimi circle-info `**alert()**` | `**prompt()**` | `**confirm()**` `**alert()**` fonksiyonunu hali hazırda pek çok kez kullandık. Pencerede bir uyarı gösterir ve 'Tamam' tuşuna bastıktan sonra kodun geri kalanı çalışır. Copy alert('Bu bir uyarı mesajıdır'); `**prompt()**` fonksiyonu kullanıcıdan bilgi almaya yarar. Pencerede açılan bir kutuda metin alanı ile kullanıcıdan veri bekler. Girilen veri `**string**` tipinde tanımlanır. Örnek Copy let isim = prompt('İsminizi Giriniz:'); alert(`Merhaba ${isim}, hoşgeldiniz.`); Eğer iptal ederseniz `**null**` tipinde veri elde edilmiş olur. Deneyiniz. Copy let isim = prompt('İsminizi Giriniz:'); alert(`Merhaba ${isim}, hoşgeldiniz.`); Eğer iptal ederseniz `**null**` tipinde veri elde edilmiş olur. Deneyiniz. Copy let isim = prompt('İsminizi Giriniz:'); alert(`Merhaba ${isim}, hoşgeldiniz.`); `**prompt()**` kullanımında varsayılan cevap oluşturmanız önemlidir. Örnek. Copy let isim = prompt('İsminizi Giriniz:','Bilinmeyen'); alert(`Merhaba ${isim}, hoşgeldiniz.`); Copy let sifre = '1234'; let girilenSifre = prompt('Şifrenizi Giriniz.','Şife'); alert( sifre === girilenSifre ? 'Giriş Başarılı' : 'Yanlış Şifre' ); `**confirm()**` fonksiyonu kullanıcıya bir mesaj gösterip cevabını `**true**` (OK) veya `**false**` (CANCEL) olarak almanızı sağlar. Örnek. Copy let kabul = confirm('Çerezleri Onayla'); alert(kabul); Copy let onay = confirm('Değişiklikleri Kaydetmeden Kapatmak İstiyor musunuz?'); alert(onay === true ? 'Pencere Kapatılıyor' : 'Pencere Kapatılmadı'); [PreviousVirgül Operatörüchevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/virgul-operatoru) [NextKoşullu İfadelerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler) Last updated 2 years ago --- # JSON - Javascript Nesne Gösterimi | JavaScript Eğitimi [PreviousFonksiyonlar (İleri)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-ileri) [NextDüzenli İfadeler (Regular Expressions)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/duzenli-ifadeler-regular-expressions) Last updated 2 years ago --- # BOM - Tarayıcı Nesnesi Modeli | JavaScript Eğitimi [PreviousDOM - Belge Nesnesi Modelichevron-left](https://hanuce.gitbook.io/javascript-egitimi/dom-belge-nesnesi-modeli) Last updated 2 years ago --- # Düzenli İfadeler (Regular Expressions) | JavaScript Eğitimi adas [PreviousJSON - Javascript Nesne Gösterimichevron-left](https://hanuce.gitbook.io/javascript-egitimi/json-javascript-nesne-gosterimi) [Nextİyi Bir Yazım ve Okunurluk İçinchevron-right](https://hanuce.gitbook.io/javascript-egitimi/iyi-bir-yazim-ve-okunurluk-icin) Last updated 2 years ago --- # HTML ve CSS Eğitimi HTML ve CSS Eğitimi [NextPage 1chevron-right](https://hanuce.gitbook.io/html-ve-css-egitimi/page-1) Last updated 2 years ago --- # Fonksiyonlar (İleri) | JavaScript Eğitimi Fonksiyon argümanlarının iterasyonu fonksiyonların arguments'leri [PreviousSemboller (Symbol)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/semboller-symbol) [NextJSON - Javascript Nesne Gösterimichevron-right](https://hanuce.gitbook.io/javascript-egitimi/json-javascript-nesne-gosterimi) Last updated 2 years ago --- # Fonksiyonlar (Temel) | JavaScript Eğitimi Programlama dilinde fonksiyonlar belirli bir işlemi yerine getiren kod birimidir. Yapmak istediğimiz işlemleri `**function**` bloğu içinde ifade ederek oluştururuz. * Fonksiyonlar bir yazılımın yapıtaşlarını oluşturur. * Hemen hemen her görev fonksiyonlarla yazılır. * Fonksiyonlar programımızı modüler hale getirmeye yarar. * Programımızı fonksiyonlarla parçalar halinde yazmak okunurluk, sonradan bakım yapma, performans açısından çok kıymetlidir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel#fonksiyon-tanimlama-ve-cagirma) Fonksiyon Tanımlama ve Çağırma --------------------------------------------------------------------------------------------------------------------------------------------- Bir fonksiyon `**function**` deyimi ile **tanımlanır**. Her fonksiyonun bir ismi vardır. Fonksiyonları bu isim ile **çağırarak** çalıştırırız. Örnek. Copy function selamVer () { //fonksiyon tanımlama ve isim verme //Kod gövdesi alert('Merhaba Fonksiyonlar'); } selamVer(); // Fonksiyonu çalışması için çağırdık. En yalın haliyle bir fonksiyon bu şekilde yazılır. Bir fonksiyonun çağırdığınız satırdan önce yazılmış olmasına gerek yoktur. Aynı kapsamda tanımlanmış olması yeterlidir. Örnek. Copy selamVer(); // aynı kapsamda herhangi bir yerden çağrıabilir. function selamVer () { //fonksiyon tanımlama ve isim verme //Kod gövdesi alert('Merhaba Fonksiyonlar'); } Global kapsamda bildirilen değişkenler (global değişken) fonksiyon kapsamın içinde doğrudan kullanılabilirler. Fakat fonksiyon içinde bildirilen değişkenler (yerel değişken) fonksiyon kapsamın dışında kullanılamazlar. Örnek. Copy let ders = 'Fonksiyonlar'; function selamVer () { alert('Merhaba ' + ders ); let yerelDegisken = 'Merhaba JavaScript'; } selamVer(); // fonksiyonu çağırdık alert(yerelDegisken); // hata verir. Bu yapı global değişkenlerin fonksiyon içinden manipüle edilmesine de olanak sağlar. Örnek. Copy let ders = 'Global Değişken'; function degerDegistir() { ders = 'Yerel Değişken'; } degerDegistir(); // ders değişkenini değişmesi için degistir fonk. çağırdık. alert(ders); // global değişken yerelden değişti: 'Yerel Değişken'; Bu kullanım global değişkenin değerini değiştirdiği için sıkıntılara yol açabilir. Bu sebeple fonksiyon içinde kullanılacak değerler **parametre** ile içeri alınır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel#undefined) ---------------------------------------------------------------------------------------- [hashtag](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel#undefined-1) ------------------------------------------------------------------------------------------ [hashtag](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel#undefined-2) ------------------------------------------------------------------------------------------ [hashtag](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel#undefined-3) ------------------------------------------------------------------------------------------ [Previousbreak - continue - label:chevron-left](https://hanuce.gitbook.io/javascript-egitimi/donguler/break-continue-label) [NextParametreli Fonksiyonlarchevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/parametreli-fonksiyonlar) Last updated 2 years ago --- # İyi Bir Yazım ve Okunurluk İçin | JavaScript Eğitimi Programcılar, kodun okunabilir ve düzenli olmasını sağlamak için çok sayıda taktik kullanır. Bunlar şunlardır. 1. ### [hashtag](https://hanuce.gitbook.io/javascript-egitimi/iyi-bir-yazim-ve-okunurluk-icin#degisken-isimlendirme) Değişken İsimlendirme * **Pascal Tipi (PascalCase):** Değişkenin her kelimesi büyük harfle başlar, diğerleri küçük yazılır. Örnek: `PascalYazimGelenegi = 'Pascal tipi yazım geleneği';` * **Deve Tipi (CamelCase):** Değişkenin ilk kelimesi küçük yazılır, diğerleri büyük harfle başlar ve küçük yazılır. Örnek: `deveYazimGelenegi = 'Deve tipi yazım geleneği';` * **Yılan Tipi:** Değişkenin her kelimesinin arasına alt tire konur ve küçük yazılır. Sabitler büyük yazılır. Örnek: `yilan_yazim_gelenegi = 'Yılan tipi yazım geleneği';` * **Macar Gösterimi:** Değişken isimlendirmeye ilk başta veri tipi kısaltması ile başlanır ondan sonrası Pascal Tipi olarak devam eder. Sabitler büyük yazılır. Örnek: `sMacarGosterimGelenegi = 'Macar gösterimi yazım geleneği';` 2. ### [hashtag](https://hanuce.gitbook.io/javascript-egitimi/iyi-bir-yazim-ve-okunurluk-icin#yazim-bosluk-sekme) Yazım, Boşluk, Sekme * İfadelerin sonunda noktalı virgül kullan, * Satırları uzun tutma (En fazla 80-120 karakter), * Süslü parantezlerden önce bir boşluk bırak, * Deyimlerden sonra (`if`, `else`, `for` vb.) bir boşluk bırak, * Operatörlerin (=, +, -, <, >, vb.) sağında ve solunda boşluklar bırakarak okunur yap, * İç içe yapılarda girinti (Indentation) yap (İki boşluk veya Tab), * Satır içindeki iç içe ifadelerde parantezlerden önce ve sonra boşluk bırak, * Mantıksal ifadelerden önce boş bir satır bırak, * 'Değilse (`Else`)' deyimini boşluk bırakmadan süslü parantezle aynı satırda yaz, * Fonksiyon-parantez-ilk parametre arasında boşluk bırakma, * Parametreler ve argümanlar arasında bir boşluk bırak. 3. ### [hashtag](https://hanuce.gitbook.io/javascript-egitimi/iyi-bir-yazim-ve-okunurluk-icin#yorum-ekleme) Yorum Ekleme * Yorumlar, derleyicinin yok saydığı, kodu etiketlemek için yararlı olan kod bölümleridir. * Kodun bakımı veya güncellenmesi için en önemli ayrıntıdır. * Kodu bölümlere ayırmak için yorumlar eklenir. * Kritik olduğu düşünülen yerlerde (döngüler, fonksiyonlar, bloklar vb.) kodun neye yaradığı, kapsamı, beklenen sonuçları yorum olarak eklenir. [PreviousDüzenli İfadeler (Regular Expressions)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/duzenli-ifadeler-regular-expressions) [NextDOM - Belge Nesnesi Modelichevron-right](https://hanuce.gitbook.io/javascript-egitimi/dom-belge-nesnesi-modeli) Last updated 2 years ago --- # Semboller (Symbol) | JavaScript Eğitimi [PreviousSet - Küme Nesnesichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/koleksiyonlar-map-set/set-kume-nesnesi) [NextFonksiyonlar (İleri)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-ileri) Last updated 2 years ago --- # Döngüler | JavaScript Eğitimi Programlama dillerinde döngü (**loop**); bir dizi işlemi belirli bir sayıda veya bir koşul gerçekleşene kadar yinelemektir. Döngüler yineleme açısından iki türden olur. * Sayaçlı Döngüler: Belirli bir sayıda tekrar eden, teorik olarak işlemin tekrarlama sayısı belli olan döngüler. * Koşullu Döngüler: Belirlenen koşul gerçekleşene kadar tekrar eden, teorik olarak işlemin tekrarlanma sayısı belli olmayan döngüler. Esasında 'Sayaçlı Döngüler' de sayacın _**belirli**_ bir sayıya ulaşma _**koşuluna**_ göre çalışmaktadır. Fakat döngü sayısının _**belirli**_ olması ayrımı vardır. Javascript'te kullanılan üç tane döngü deyimi vardır. * **for** Döngüsü ( Sayaçlı Döngü ) * **while - do while** Döngüsü ( Koşullu Döngü ) Döngülerle birlikte şu kavramları da şimdiden öğrenmeniz faydalıdır. * **Sıralanmış (Ordered) Veriler**: Öğelerine belirli bir sıra ile erişilebilen veri yapısı. Örnek olarak: Copy let str = 'Javascript'; `**string**` tipinin veri yapısı sıralanmış (**ordered**) olduğu için `**str**` değişkeninin her bir öğesine (karakterine) teker teker ulaşabiliriz. Örnek. Copy alert( str[2] ); //v harfi çıktısı verir. * **Sıralanmamış (Unordered) Veriler**: Öğelerine belirli bir sıra ile erişilemeyen veri yapısı. Örnek olarak: Copy let sayi = 123; alert( sayi[0] ); //'undefined' çıktısı verir. Sırası ile erişilemez. * **Değiştirilebilir (Mutable) Veriler**: Değiştirilebilmesi mümkün veri birimi. Örnek olarak: Copy let str = 'Programlama Dili'; str = 'JavaScript'; // str mutable, değiştirilebilir. let sayi = 123; sayi = 0; * **Değiştirilemez (Immutable) Veriler**: Değiştirilebilmesi mümkün olmayan veri birimi. Örnek olarak: Copy let str = 'TUR'; str[1] = 'I'; // İşlem yapılmaz. Değiştirilemez (immutable) alert(str); * **Yinelenebilir (Iterable) Veriler**: Öğeleriyle yinelenebilir özellikte olan veri yapısı. * **Yineleyici (Iterator)**: Bir veri yapısının yinelettirilebilen her bir birimi. Örnek olarak `**string**` veri tipini ele alalım. `**String**` türünde oluşturulmuş bir değişkenimiz olsun: Copy let karakterDizisi = 'Javascript'; `**string**` tipinin veri yapısı sıralanmış (**ordered**) olduğu için `**karakterDizisi**` değişkeninin her bir öğesine (karakterine) teker teker ulaşabiliriz. Örnek. Copy alert( karakterDizisi[2] ); //v harfi çıktısı verir. `**string**` veri yapısı değiştirilebilir (**mutable**) olduğu için `**karakterDizisi**` değişkeninin tuttuğu veriyi değiştirebiliriz. Örnek. Copy karakterDizisi = 'Programlama Dili'; Fakat `**karakterDizisi**` değişkeninin eriştiğimiz (dilimlediğimiz) herhangi bir öğesi değiştirilemez (**immutable**) yapıdadır. Değiştiremeyiz. Örnek. Copy karakterDizisi[0] = 'T'; // İşlem yapılmaz. Değiştirilemez (immutable) alert(karakterDizisi); Her bir karakteri ekrana uyarı olarak verme işlemini bir döngü (**loop**) veya yineleyici (**iterator**) sayesinde yapabiliriz. Döngü ve yineleme farklı terimlerdir. `**string**` veri yapısı yinelenebilir (**iterable**) olduğu için `**karakterDizisi**` değişkeninin tuttuğu verinin her bir birimi (**iterator)** ile tekerrür ettirebiliriz. [Previousswitch - case - breakchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/switch-case-break) [Nextfor Döngüsüchevron-right](https://hanuce.gitbook.io/javascript-egitimi/donguler/for-dongusu) Last updated 2 years ago --- # Referans (Reference) Veri Tipleri | JavaScript Eğitimi Bir değişkende bir veya birçok **değeri referans eden (adresini tutan)** veri tipine referans (reference) veri tipi denir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri#bir-veri-tipinin-referans-reference-olarak-nitelendirilmesi) Bir Veri Tipinin Referans (Reference) Olarak Nitelendirilmesi ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- İlkel değişkenlerin **doğrudan değerlerinin** tutulduğu bölümün **call stack** olduğunu ifade etmiştik. Referans veri tiplerindeki değişkenler, belleğin "**bellek yığını (heap)**" olarak ifade edilen bölümündeki bir adreste **başka bir adresi (referansı)** tutarlar. Değişkenler **heap** olarak ifade edilen bu bölümde; parçalar halinde, rasgele konumlarda (hiyerarşik olarak), dinamik boyutlu ve referans ile erişilebilir halde tutulurlar. ![Drawing](https://hanuce.gitbook.io/javascript-egitimi/~gitbook/image?url=https%3A%2F%2F1783608288-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FtkAky55y3oAsmbswePAh%252Fuploads%252FDiX4KmbZ5BwT6oEnft0h%252Ffile.excalidraw.svg%3Falt%3Dmedia%26token%3D2c985442-bab3-46f8-bcbd-a5bfa030d33f&width=768&dpr=3&quality=100&sign=f619c18b&sv=2) REFERANS DEĞİŞKENLER VE HAFIZA **Heap** bölümü program tarafından yönetilir. Heap bölümünde değerler referans ettirildiği için bu bölüm dinamik (sabit olmayan) boyutludur. Veriler parçalı tutulduğu için ilkel tiplere göre erişim ve yürütme daha yavaştır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri#referans-veri-turleri) Referans Veri Türleri ---------------------------------------------------------------------------------------------------------------------------------------- * `**Array**` **- Dizi Nesnesi** * Köşeli parantezler ( `**[]**` ) arasında yazılan **değerler (value)** ile oluşan listeler `**array**` türündedir. **Anahtar (key)** kısmı doğal olarak **artan sıralı tamsayı** şeklindedir ve değiştirilemez. Döngüleneblirler. * `**Object**` **- Nesne** * **Anahtar (key)** kısmı sadece `**string**` veri tipinde olan '**anahtar:değer**' ikililerinden oluşan _**veri türüdür**_. Süslü parantezler arasında ( `**{ }**` ) yazılırlar. Döngüleneblirler. Bu bölümde ayrıca `**new**` operatörü ile `**Map**` ve `**Set**` türleri de işlenecektir. [PreviousOk (Arrow) Fonksiyonlarchevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/ok-arrow-fonksiyonlar) [NextArray - Dizichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi) Last updated 2 years ago --- # String - Karakter Dizisi | JavaScript Eğitimi circle-exclamation Javascript UTF-16 karakter setini kullanır. Bir değişkenin değeri _**tırnak arasında yazılmış ise**_ veri tipi string-karakter dizisi olur. Karakter dizisi klavyeden girilebilecek boşluk, nokta, virgül, kuyruklu a, rakamlar vb. basılabilen tüm karakterleri içerir. Örnek: Copy let karakterDizisi = '1. Basitlik güvenirlik için önkoşuldur. @Dijkstra'; Üç tip tırnak işareti vardır. Bunlar: * Çift Tırnak (Double Quote) (Basit) * Tek Tırnak (Single Quote) (Basit) * Ters (Garip) Tırnak (Backtick) (Genişletilmiş Fonksiyonlu) Yazacağınız metinde basit tırnaklardan biri varsa dışardaki tırnakları tersine kullanmalısınız. Örnek: Copy // Dışardaki tırnaklar ile metin içindekiler tersine kullanılır. let metin = "Javascript bir 'Java' dili değildir."; // veya let misra = 'Bastığın yerleri "toprak!" diyerek geçme, tanı!'; Bunu kontrol etmenin başka bir yolu da _basit tırnak işaretinden önce_ kaçış işareti '\\' eklemektir. Bu işaret çıktılarda görünmez. Deneyiniz. Copy let misra1 = "\"Gömelim gel seni târîhe\" desem, sığmazsın"; let misra2 = 'Doğacaktır sana va\'ettiği günler Hakk\'ın…'; alert(misra1); alert(misra2); Peki biz ekrana '\\' işaret yazdırmak istiyorsak ne yapmalıyız? İki kere kullanmalıyız. Deneyiniz. Copy let konum = 'C:\\Windows\\Users\\'; alert(konum); Bu kaçış işaretlerinden birkaçı şunlardır. Kaçış İşareti İşlevi \\ Basit tırnak işaretlerinin dıştakilerle çakışmasını engeller. \\\\ '\\' karakterinin basılmasını sağlar. \\n Sonrasında yazılanları bir alt satırdan başlatır. \\u Unicode karakteri yazmak için önek. (Örnek: \\u00A9) \\t Bir sekme boşluk bırakır. Dört tane boşluk. Örnekleri deneyiniz. Copy let satirBasi = "Birinci satır\nİkinci satır\nÜçüncü Satır"; alert(satirBasi); let telifSembolu = '\u00A9'; alert('Her Hakkı Saklıdır. ' + telifSembolu); **Ters** tırnak genişletilmiş fonksiyonları olan bir tırnak işaretidir. Ters tırnak ile yazılan karakter dizisinin içinde `**${ }**` ile kod yazımına geçebilirsiniz. Örnek: circle-info Ters tırnak işareti Alt Gr ile Virgül ( alt gr + , ) tuşlarına birlikte basılarak yapılır. Copy let dil = "Javascript"; //Basit tırnak kullandık. let mesaj = `Öğrendiğimiz dil: ${dil} dilidir.`; // Ters tırnak kullandık. alert(mesaj); Çok satırlı bir metni tanımlamak istiyorsak yine **ters** tırnak ile yapabiliriz. Deneyiniz. Copy let dortluk = `Kim bu cennet vatanın uğruna olmaz ki fedâ? Şühedâ fışkıracak, toprağı sıksan şühedâ! Cânı, cânânı, bütün varımı alsın da Hudâ, Etmesin tek vatanımdan beni dünyâda cüdâ.`; //Ters tırnak kullandık. alert(dortluk); [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi#stringe-ait-ozellikler-property) String'e Ait Özellikler (Property) ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Bir programlama dilinde bir deyimin normal parantez () ile bitmesi onun bir fonksiyon olduğunun işaretidir. Örnek olarak `**alert()**` gibi. Buna '`_alert_` _fonksiyonu_' deriz. Fonksiyonlar bir dizi işlem silsilesidir. Eğer fonksiyon `**.**` işareti ile bir öğeye bağlıysa buna **metot** (alt fonksiyon) denir. Örnek olarak `**console.log()**` gibi. Buna '`_console_` _öğesinin_ `_log_` _metodu_' deriz. **Özellik** (property) ise bir niteliktir. Bir değer ifade eder. Örnek olarak: Bir video dosyasını düşünün. Video dosyasının adı, uzunluğu, uzantısı bir niteliktir. Fakat videonun yürütülerek çalıştırılması fonksiyonlar veya metotlar ile olur. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi#uzunluk) Uzunluk -------------------------------------------------------------------------------------------------------------------------------- > ### > > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi#length) > > `.length` Bir string değerin uzunluğu `**.length**` ile elde edilir. Örnek: Copy let dortluk = 'Arkadaş! Yurduma alçakları uğratma sakın;'; alert(dortluk.length); // Başka bir örnek alert('Benim makinemde çalışıyor.'.length); `**.length**` bir özelliktir. Bir karakter dizisinin ilk karakterinin pozisyonu her zaman 0 (sıfır) değeridir. Örnek olarak 'Script' kelimesinin ilk karakteri olan S'nin pozisyonu 0, son karakter olan t'nin pozisyonu ise 5'tir. Dolayısıyla `**.length**` özelliği karakter dizisinin son karakterinin pozisyonu+1 değerini taşır. [Previousİlkel (Primitive) Veri Tiplerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri) [NextString Metotlarıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari) Last updated 2 years ago --- # Number - Sayı | JavaScript Eğitimi circle-exclamation Javascript sayıları 64-Bit uzunluğunda 'Çift Duyarlı Kayan Nokta' olarak IEEE-754 standartlarında tutar. IEEE-754 standardından daha büyük sayılar kullanılırsa hata vermez, 'sonsuz' olarak değerlenir. Bir sayısal büyüklük **tırnak içerisine alınmadan** doğrudan yazılırsa `**number**` tipinde olur. Bu şekilde matematiksel işlemlerde (toplama, çıkarma vb.) kullanılabilirler. Tırnak içerisinde yazılırsa `**string**` olur ve matematiksel işlemlerde **kullanılamazlar**. Örnek. Copy let tamSayi = 2023; let ondalikliSayi = 20.23; Javascript tamsayılar ve ondalıklı sayılar için number değişkenini kullanır. Farklı tipler olarak ele almaz. `**Number**` veri tipi _**güvenli olarak**_ −(253−1)\-(2^{53}-1)−(253−1) ile (253−1)(2^{53}-1)(253−1) arasında değerler alabilir. Daha büyük veya küçük değerler de alabilir fakat karşılaştırmalarda yanlış sonuçlar üretir. Örneğin 255+12^{55}+1255+1 ile 255+22^{55}+2255+2 birbirlerine eşit mi sorusuna _**doğru**_ cevabını alırsınız. Değer aralıklarını `**.MAX_VALUE**` ve `**.MIN_VALUE**` özellikleri ile görüntüleyin. > `**.MAX_VALUE**` | `**.MIN_VALUE**` | `**.MAX_SAFE_INTEGER**` | `**.MIN_SAFE_INTEGER**` Copy alert('Number max değeri: ' + Number.MAX_VALUE); alert('Number min değeri: ' + Number.MIN_VALUE); Güvenli **tamsayı** değer aralıklarını `**.MAX_SAFE_INTEGER**` ve `**.MIN_SAFE_INTEGER**` özellikleri ile görüntüleyin. Copy alert(Number.MAX_SAFE_INTEGER); // 9007199254740991 alert(Number.MIN_SAFE_INTEGER); // -9007199254740991 Javascript HexaDecimal (16'lı), Octal (8'li) ve Binary (2'li) sayı sistemlerini kabul eder. * **HexaDecimal - 16'lı Sayı Sistemi** * Sayılar 0-9 arasındaki rakamlar ve A-F arasındaki harflerle temsil edilir. * 0-9 arası rakamlar kendileri olarak, 10:A, 11:B, 12:C, 13:D, 14:E, 15:F olarak temsil edilir. * HexaDecimal sayılar '0x' ile başlayarak yazılır. Örnek: 0xFF * HTML Renk kodları bu sistemi kullanır ve gösterimi hashtag sembolü ile başlar. Örnek: #FFFFF * **Octal - 8'li Sayı Sistemi** * Sayılar 0-7 arasındaki rakamlarla temsil edilir. * Octal sayılar '0o' ile başlayarak yazılır. Örnek: 0o377 * **Binary - 2'li Sayı Sistemi** * Sayılar 0 ve 1 ile temsil edilir. * Binary sayılar '0b' ile başlayarak yazılır. Örnek: 0b11111111 Javascript'te çok sıfırlı sayıları yazarken 'e' harfi kullanılabilir. Örnek olarak: Copy let nBin = 3e+3; // Üç Bin sayısı e'nin sağında 3 rakamı 3 sıfır anlamına gelir. let nMilyon = 5e+6; //5 Milyon let nMilyar = 9.45e+10; //94 Milyar 500 Milyon let ondaN = 1e-1; //Sağdaki sayı negatif olursa ondalıklara geçer: Onda 1 let milyondaN = 1e-6; //Milyonda 1 let milyardaN = 4.56e-7; // Milyarda 456 `**Number**` tipinde iki tane _**özel değer**_ vardır. Bunlar **Infinity** ve **NaN**'dır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi#infinity-degeri) Infinity Değeri ------------------------------------------------------------------------------------------------------------------------------------- Sonsuz sayıları temsil eder. En büyük sayıdır. Javascript'in standardından daha büyük bir sayı yazarsanız veya bir sayıyı sıfıra bölerseniz `**Infinity**` değerini elde edersiniz. Hata almazsınız. Örnek. Copy let sayi1 = 1/0; // Sıfıra böldük: Infinity let sayi2 = 1e309; // Max değeri aştık: Infinity alert(sayi1); alert(sayi2); `**Infinity**` değeri bir **veri tipi değildir.** `**Number**` veri tipinin _**özel**_ bir değeridir. Şunları deneyip sonucu görünüz. Copy let sonsuz = Infinity; alert(25/sonsuz); // Sonuç: 0 alert(sonsuz/sonsuz); // Sonuç: NaN alert(sonsuz-sonsuz); // Sonuç: Infinity alert(sonsuz+sonsuz); // Sonuç: Infinity alert(sonsuz*sonsuz); // Sonuç: Infinity [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi#nan-degeri-not-a-number) NaN Değeri (Not a Number) ------------------------------------------------------------------------------------------------------------------------------------------------------- Matematiksel işlemi hatalı olan değişkenlerin değeridir. Örneğin bir harf rakama bölünemez. Bu durumda değeri `**NaN**` olur. Örnek. Copy let sayi1 = 'Karakter Dizisi' / 'Başka bir Karakter Dizisi'; alert(sayi1); // NaN let sayi2 = 'Karakter Dizisi' - 15; alert(sayi2); // NaN let sayi3 = 'Karakter Dizisi' * 3; alert(sayi3); // NaN Bazı `**NaN**` değeri üreten işlemler. Deneyiniz. Copy let sonsuz = Infinity; let sifir = 0; alert(sonsuz/sonsuz); // NaN alert(sifir/sifir); //NaN alert(sonsuz*sifir); //NaN [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi#ieee-754-sayi-hatalari) IEEE-754 Sayı Hataları --------------------------------------------------------------------------------------------------------------------------------------------------- Birçok dilde kullanılan IEEE-754 standardı sayıları bellekte binary olarak tutar. Bunun sonucunda bazı yuvarlamaları otomatik olarak yapar ve hatalı sonuç döndürür. Örnek. Copy let sayi1 = 0.1; let sayi2 = 0.2; alert(sayi1+sayi2); // Sonuç: 0.30000000000000004 IEEE-754 standardı ondalık kısmı en fazla 16 basamağa kadar doğru verir. Ondalığın 17. basamağında yukarı doğru yuvarlamalar yapar. IEEE-754 varsayılan olarak 1 işaret digit'i, 52 tamsayı basamak digit'i ve 11 ondalık basamak digit'i tutar. Dolayısıyla binary olarak 52 basamaktan daha fazla olan bir tamsayı yazarsanız bunda da _**belirli bir düzende**_ yukarı doğru yuvarlamalar yapar. > Aşağıda büyük bir tamsayının 2'lik tabandaki binary karşılığı verilmiştir. Sayı binary olarak 54 digit'tir. Yani 54 basamak uzunluğundadır. > > 9999999999999999\=(100011100001101111001001101111110000001111111111111111)29999999999999999 = (100011100001101111001001101111110000001111111111111111)\_29999999999999999\=(100011100001101111001001101111110000001111111111111111)2​ Copy let sayi = 9999999999999999; alert(sayi); // Çıktı: 10000000000000000 sayısıdr. Bu standardın 1 digit'i işaret olarak tuttuğunu ifade etmiştik. Bu durum sıfır (0) sayısı için de geçerlidir. Yani sıfır -0 ve +0 olarak iki sayı vardır. Sıfır sayısı iki türlü de binary olarak tamamen sıfırlardan oluştuğu için bu durum bir hataya sebep olmaz. Fakat -0 ve +0 standart olarak kullanılabilir. Aynı durum `**Infinity**` için de geçerlidir. Yani `**-Infinity**` ve `**+Infinity**` olarak kullanılabilir. [PreviousString Metotlarıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari) [NextNumber Metotlarıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi/number-metotlari) Last updated 2 years ago --- # if - else - else if | JavaScript Eğitimi Javascript'te bu ifadeleri yazarken küçük harflerle yazdığınıza emin olunuz. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/if-else-else-if#if-deyimi) `if` Deyimi ------------------------------------------------------------------------------------------------------------------- `**if**` deyimini bir koşul ile ifade haline getirip koşul doğru olduğunda yapılacak işlemleri bir kod bloğu olarak ifade ederiz. Örnek. Copy let yas = prompt('Yaşınızı Giriniz', 20) ; if ( +yas >= 15) { alert('Kimlik kartınızda fotoğraf olmak zorundadır.'); } Eğer yukarıdaki `**yas**` değişkeni için 15'ten daha küçük bir sayı girerseniz herhangi bir uyarı almazsınız. Çünkü koşul doğrulanmaz ise (`**true**`) `**if**` bloğundaki kodlar yürütülmez. `**if**` bloğunun çalışma mantığı şu şekildedir. Copy let kosul; if (true) { kosul = 'truthy'; } if (false) { kosul = 'falsy'; } alert(kosul); `**if (kosul)**` bloğundaki kodlar koşul gerçekleşirse (`**true**`) yürütülür, gerçekleşmezse (`**false**`) yürütülmez. Bunu `**true**` ve `**false**` değerlerinin matematiksel karışıkları ile de yapabiliriz. Copy let kosul; if (1) { kosul = 'truthy'; } if (0) { kosul = 'falsy'; } alert(kosul); Koşul ifadesini `**if (kosul)**` satırında yazmak yerine bir değişken değeri olarak ele almak daha yaygın bir kullanımdır. Copy let kosul = ( yas = prompt('Yaşınızı Giriniz', 20), +yas >= 15 ); if (kosul) { alert('Kimlik kartınızda fotoğraf olmak zorundadır.'); } Bir değişkenin tipini kontrol edip değiştirelim. Örnek. Copy let telefon = prompt('Telefon No Giriniz', 5554443322) ; if (typeof telefon == 'string') { telefon = Number(telefon); //veya telefon = +telefon alert(typeof telefon); } `**if**` blokları iç içe kullanılabilir. '**nested**' olarak adlandırılan bu yapılarda unutulmaması gereken dıştaki `**if**` bloğundaki koşul **gerçekleşmezse** içerideki `**if**` bloklarındaki koşulların bir öneminin olmadığıdır. Copy let saat = prompt('Saati örneğe uygun olarak giriniz.', '17.00'); let onay = confirm("12'lik Düzene Çevrilsin mi?"); if (onay) { if (saat.slice(0.2) >= 12) { saat = saat.slice(0,2) - 12 + saat.slice(2) + ' Ö.S.' } if (saat.slice(0.2) < 12) { saat = saat + ' Ö.Ö' } } alert(saat); Aynı ifade şu şekilde de kodlanabilir. Copy let saat = prompt('Saati örneğe uygun olarak giriniz.', '17.00'); let onay = confirm("12'lik Düzene Çevrilsin mi?"); if (onay) { saat.slice(0,2) >= 12 ? saat = saat.slice(0,2) - 12 + saat.slice(2) + ' Ö.S.' : saat = saat + ' Ö.Ö'; } alert(saat); Kodun okunurluğu açısından iki yazımı da değerlendiriniz. Yukarıdaki iç içe `**if**` örneğinde gördüğünüz içteki ikinci `**if**` deyimi esasında gereksizdir. Koşulun gerçekleşmediği durumu yeni bir `**if**` bloğu ile kontrol etmeye gerek yoktur. Bunun için `**else**` deyimini kullanırız. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/if-else-else-if#else-deyimi) `else` Deyimi ----------------------------------------------------------------------------------------------------------------------- `**if**` deyimi ile ifade ettiğimiz koşulun gerçekleşmediği durumlarda yapılacak işlemleri bir kod bloğu ile gerçekleştirmek için `**else**` deyimini kullanırız. Örnek. Copy let yas = prompt('Yaşınızı Giriniz', 20) ; if (yas >= 15) { alert('Kimlik kartınızda fotoğraf olmak zorundadır.'); } else { alert('Kimlik kartınızda fotoğraf olmak zorunda değildir.'); } Eğer yukarıdaki `**yas**` değişkeni için 15'ten daha küçük bir sayı girerseniz `**else**` bloğu yürütülür. Çünkü koşul doğrulanmaz ise (`**false**`) `**else**` bloğundaki kodlar yürütülür. `**else**` bloğunun çalışma mantığı şu şekildedir. Copy let kosul = false; if (kosul) { kosul = 'truthy'; } else { kosul = 'falsy'; } alert(kosul); İç içe `**if**` örneğini yeniden yazacak olursak. Copy let saat = prompt('Saati örneğe uygun olarak giriniz.', '17.00'); let onay = confirm("12'lik Düzene Çevrilsin mi?"); if (onay) { if (saat.slice(0.2) >= 12 { saat = saat.slice(0,2) - 12 + saat.slice(2) + ' Ö.S.' } else { //yeni koşula gerek yok. saat = saat + ' Ö.Ö' } } alert(saat); `**else**` deyimi koşulun gerçekleştiği durum haricindeki **her şeydir**. Bu sebeple `**else**` deyiminin sadece iki ihtimalin olduğu veya son ihtimalin kaldığı durumlarda kullanılmasına dikkat edilmelidir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/if-else-else-if#else-if-deyimi) `**else if**` Deyimi --------------------------------------------------------------------------------------------------------------------------------- `**else if**` deyimi koşulları birbirine bağlayıp sıralı şekilde işlemleri yaptırmak için kullanılır. Şu örneğe bir göz atalım. Copy let kanSayimi = prompt('Tam kan sayımı sonucunu giriniz', 310); let degerlendirme; if (kanSayimi <= 112) { degerlendirme = 'Düşük'; } if (kanSayimi >= 112 && kanSayimi <= 508) { degerlendirme = 'Normal'; } if (kanSayimi >= 508) { degerlendirme = 'Yüksek'; } alert(degerlendirme); Yukarıda birbirinden bağımsız `**if**` bloklarının hepsi yürütülür. Her blokta `**kanSayimi**` ile başlayan koşulu kontrol eder. Bu hem performansı etkileyen hem de yazımı zorlaştıran bir durumdur. Bunun yerine `**else if**` ile koşulları birbirine bağlayıp sadece koşulun sağlandığı bloğu yürütmek daha kullanışlıdır. Deneyiniz. Copy let kanSayimi = prompt('Tam kan sayımı sonucunu giriniz', 310); let degerlendirme; if (kanSayimi <= 112) { degerlendirme = 'Düşük'; } else if (kanSayimi <= 508){ degerlendirme = 'Normal'; } else { degerlendirme = 'Yüksek'; } alert(degerlendirme); Eğer `**else if**` bloğu kullandıysanız sonunda kesinlikle `**else**` bloğu olmalıdır. Hiçbir koşulun sağlanmadığı durumu da `**else**` bloğu ile kesinlikle kontrol etmek zorundasınız. Bu sebeple en az üç ihtimalin olduğu durumlarda kullanmalısınız. Copy let cevap = prompt("Türkiye AB'ye girmeyi hangi yıl reddetmiştir?",''); if (cevap > 1978) { alert('Daha geçmiş yıllarda..'); } else if (cevap < 1978) { alert('Daha sonraki yıllarda..'); } else { alert('Doğru'); } Yukarıdaki örnek `**if else**` ile de yapılabilir fakat cevaba göre yürütülecek kodları farklılaştıramazsınız, tekil olur. Bu sebeple `**if-else-else if**` yapısı koşulların gerçekleşmediği durumlara göre kod yürütmek için oldukça elverişlidir. circle-info `**if**` deyiminin satırındaki koşullar `**()**` arasına yazılmasa da çalışır fakat kodun okunurluğu açısından kullanmanız önerilir. Eğer `**if-else-else if**` bloklarında tek satırlık kodlarınız var ise blok açmanıza gerek kalmadan tek satırda da yazabilirsiniz. Örnek. Copy let cevap = prompt("Türkiye AB'ye girmeyi hangi yıl reddetmiştir?",''); if (cevap > 1978) alert('Daha geçmiş yıllarda..'); else if (cevap < 1978) alert('Daha sonraki yıllarda..'); else alert('Doğru'); [PreviousKoşullu İfadelerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler) [Nextswitch - case - breakchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/switch-case-break) Last updated 2 years ago --- # Boolean - Mantıksal | JavaScript Eğitimi `**Boolean**` veri tipi sadece `**true**` veya `**false**` olarak iki değer tutar. Örnek. Copy let dogru = true; let yanlis = false; alert(dogru); alert(yanlis); alert(typeof dogru); alert(typeof yanlis); `**Boolean**` veri tipinin genel kullanımı tabii ki bu şekilde değildir. Genellikle karşılaştırma, üyelik veya değer kontrolü sonucu olarak elde edilir. [Operatörler](https://hanuce.gitbook.io/javascript-egitimi/operatorler) konusunda `**boolean**` tipini daha detaylı işleyeceğiz. Örnek bir karşılaştırma ifade etmek gerekirse; `**2 > 3;**` ifadesi sonucunda `**false**` değeri elde edilir. Copy alert(2 > 3); // false çıktısı verir. Yine aynı şekilde eşitlik karşılaştırması da yapılabilir. Örnek. Copy alert(2023 == 2023); // true çıktısı verir. Matematiksel olarak `**true**` 1 (bir) `**false**` 0 (sıfır) değerine eşittir. Karakter dizilerinde ise herhangi bir karakter içeren `**string**` `**true**`, boş `**string**` değeri `**false**` olur. [PreviousBigInt - Büyük Sayıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/bigint-buyuk-sayi) [NextUndefined - Tipi ve Değerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/undefined-tipi-ve-degeri) Last updated 1 year ago --- # Tip Dönüşümleri | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/tip-donusumleri#string-tipine-donusturme) `String` Tipine Dönüştürme ------------------------------------------------------------------------------------------------------------------------------------------------------------- Bir değeri `**string**` tipine çevirmek için `**String()**` fonksiyonu veya `**.toString()**` metodu kullanılır. Örnek. Copy let sayi = 1923; sayi = String(sayi); alert(typeof sayi); `**String()**` fonksiyonu `**NaN**`, `**Null**` ve `**Undefined**` değerini de `**string**` olarak çevirebilir. Öte yandan `**.toString()**` metodu daha sıkıdır. `**NaN**` değeri için çevrim yaparken diğer özel değerler için hata verir. Copy let tanimsiz; let sayiOlmayan = NaN; let bos = null; tanimsiz = String(tanimsiz); alert(typeof tanimsiz); sayiOlmayan = String(sayiOlmayan); alert(typeof sayiOlmayan); bos = String(bos); alert(typeof bos); Yukarıdaki değerlerin hepsi `**string**` tipine dönüştürülür. Diğer yöntemde ise: Copy let tanimsiz; let sayiOlmayan = NaN; let bos = null; let sayi = 1923; sayiOlmayan = sayiOlmayan.toString(); // Çalışır. alert(typeof sayiOlmayan); sayiOlmayan = sayi.toString(); // Çalışır alert(typeof sayi); tanimsiz = tanimsiz.toString(); //hata verir alert(typeof tanimsiz); bos = bos.toString(); //hata verir alert(typeof bos); [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/tip-donusumleri#number-tipine-donusturme) `Number` Tipine Dönüştürme ------------------------------------------------------------------------------------------------------------------------------------------------------------- > `**Number()**` | `**+**` | `**parseInt()**` | `**parseFloat()**` Bir değeri `**number**` tipine dönüştürmek için **sayı tipine dönüştürülebilir bir değere sahip olması gerekir.** `**Numbe**`r tipinde olmayan bir değişkeni **number** tipine dönüştürmek için birkaç yöntem var. İlk yöntem değişkenin önüne + işareti koymak. Copy let st1 = "18.3"; let st2 = "12"; let toplam = +st1 + +st2; // ortadaki + toplama işareti, diğerleri dönüştürme. alert(toplam); Diğer yöntemlerden biri de `**Number()**` fonksiyonudur. Copy let st1 = "18.3"; let st2 = "12"; let fark = Number(st1) - Number(st2); alert(fark); Bu yöntemler katı yöntem olup eğer değişken içinde sayısal olmayan bir karakter var ise `**NaN**` değeri verir. Copy let uzunluk = "27cm"; alert( Number(uzunluk) ); // NaN Bu sebeple `**parseInt()**` veya `**parseFloat()**` fonksiyonları daha işlevsel olabilir. `**parseInt()**` ile tamsayıları, `**parseFloat()**` ile ondalıklı sayıları dönüştürebiliriz. Copy let uzunluk = "27cm"; let genislik = "22.4cm"; alert( parseInt(uzunluk) ); alert( parseFloat(genislik) ); Bu fonksiyonlar baştan ve sondan boşlukları kırpar ve ardından sol baştaki rakamlardan başlar. Sağa doğru rakamların bittiği yerde rakamı sonlandırır. `**parseInt()**` fonksiyonu isteğe bağlı bir parametre daha alır. Bu da taban bilgisidir. Örnek. Copy let renk = "0xFF"; alert( parseInt(renk,16) ); //255 sonucunu döndürür. renk = "FF"; alert( parseInt(renk,16) ); // Başına 0x yazılmasa da 16 tabanını verince çevirir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/tip-donusumleri#boolean-tipine-donusturme) `Boolean` Tipine Dönüştürme --------------------------------------------------------------------------------------------------------------------------------------------------------------- > `**Boolean()**` | `**!!**` Bir değeri `**boolean**` tipine çevirmek için `**Boolean()**` fonksiyonu veya `**!!**` operatörü kullanılır. `**Boolean**` tipine çevirmek için `**Boolean()**` fonksiyonu kullanılır. Örnek. Copy let bir = 1; let sifir = 0; alert( Boolean(bir) ); // true alert( Boolean(sifir) ); // false Matematiksel olarak `**true**` değer 1 `**false**` değer 0'dır. Tersten deneyelim. Copy let dogru = true; let yanlis = false; alert( Number(dogru) ); // 1 alert( Number(yanlis) ); // 0 Karakter dizilerinde ise boş string değeri `**false**` herhangi bir karakter içeren string `**true**` olur. Copy let bos = ''; let dolu = ' '; alert( Boolean(bos) ); //false alert( Boolean(dolu) ); //true Bir değeri `**boolean**` tipine çevirmek için `**!!**` operatörü de kullanılır. Örnek. Copy let bos = ''; let dolu = ' '; let bir = 1; let sifir = 0; alert( !!bos ); //false alert( !!dolu ); //true alert( !!sifir ); //false alert( !!bir ); //true [PreviousUndefined - Tipi ve Değerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/undefined-tipi-ve-degeri) [NextOperatörlerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler) Last updated 2 years ago --- # switch - case - break | JavaScript Eğitimi Javascript'te bu ifadeleri yazarken küçük harflerle yazdığınıza emin olunuz. `**switch**` ile `**if**` benzer işlemler için kullanılır. `**if**` _**koşula**_ göre `**switch**` _**duruma**_ göre çalışır. Örnek. Copy let gun = prompt('Lütfen 1-7 arasında bir sayı giriniz','1'); switch (gun) { case '1': alert('Pazartesi'); break; case '2': alert('Salı'); break; case '3': alert('Çarşamba'); break; case '4': alert('Perşembe'); break; case '5': alert('Cuma'); break; case '6': alert('Cumartesi'); break; case '7': alert('Pazar'); break; } `**switch - case**` ile tiplerin önemi vardır. Sıkı eşitlik kullanır. `**prompt**` ile aldığımız her verinin `**string**` tipinde olduğunu biliyoruz. O halde deneyelim. Copy let gun = prompt('Lütfen 1-7 arasında bir sayı giriniz','1'); switch (gun) { case 1: alert('Pazartesi'); break; case 2: alert('Salı'); break; case 3: alert('Çarşamba'); break; case 4: alert('Perşembe'); break; case 5: alert('Cuma'); break; case 6: alert('Cumartesi'); break; case 7: alert('Pazar'); break; } //hiçbir uyarı vermez. Yukarıdaki örnekten hiçbir uyarı alamazsınız çünkü `**gun**` değişkeninin veri tipi `**string**` ve biz `**number**` tipinde karşılaştırmalar yaptık. `**switch**` deyimi sıkı eşitlik kullandığı için hiçbir durum gerçekleşmedi. `**switch - case**` yapısında bir durumun gerçekleşmesi ile yürütme başlar ve ilk `**break**` komutuna kadar kodlar yürütülür. Bu sebeple **her duruma** `**break**` **komutu koymak gereklidir.** Örnek. Copy let trafikLambasi = 'Sarı'; switch (trafikLambasi) { case 'Kırmızı': alert('BEKLE'); case 'Sarı': alert('HAZIR OL'); case 'Yeşil': alert('İLERLE'); } Yukarıdaki örneği 'Yeşil' yaparak denerseniz sadece 'İLERLE' uyarısı alırsınız. 'Kırmızı' yaparsanız tüm durumlardaki uyarılar çalışır. Deneyebilirsiniz. `**switch**` yapısında `**case**` ile ifade ettiğiniz hiçbir durum gerçekleşmez ise `**default**` deyimi ile durum gerçekleşmesine bağlı olmadan kodlar yürütebilirsiniz. En sonda yazılması gereklidir. Örnek. Copy let httpRes = '301'; switch (httpRes) { case '200': alert('BAĞLANTI BAŞARILI'); break; case '404': alert('SAYFA BULUNAMADI!'); break; case '500': alert('SUNUCU HATASI'); break; default: // hiçbir case ile uyuşmadığı için burası çalışır. alert('Bilinen bir http durumu belirtilmedi.'); } [hashtag](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/switch-case-break#case-gruplama) `case` Gruplama ----------------------------------------------------------------------------------------------------------------------------- Bazı durumlarda aynı şeyleri yapmak gerekiyorsa kodları tekrar etmeye gerek kalmadan `**case**` deyimlerini alt alta yazarak gruplayabilirsiniz. Örnek. Copy let ay = prompt('Küçük harflerle bir ay ismi giriniz:', ''); switch (ay) { case 'aralık': case 'ocak': case 'şubat': alert('Kış mevsimindesiniz.'); break; case 'mart': case 'nisan': case 'mayıs': alert('İlkbahar mevsimindesiniz.'); break; case 'haziran': case 'temmuz': case 'ağustos': alert('Yaz mevsimindesiniz.'); break; case 'eylül': case 'ekim': case 'kasım': alert('Sonbahar mevsimindesiniz.'); break; default: alert('Doğru bir şekilde giriş yapmadınız.'); } `**switch**` ile `**if**` kullanımının bazı farkları aşağıda verilmiştir. if switch _**Koşula**_ göre çalışır. Koşul her zaman `**Boolean**` tipindedir. _**Duruma**_ göre çalışır. Durum herhangi bir tipte olabilir. Yürütülecek kodları _**koşula**_ göre `**if - else - else if**` ile farklılaştırırız. Yürütülecek kodları _**duruma**_ göre `**case - default**` ile farklılaştırırız. Değişken tipleri önemsizdir. Koşuldaki ifadeye göre `**Boolean**` sonuç üzerinden kodlar yürütülür. Değişken tipleri önemlidir. Durumdaki değer ve tip üzerinden kodlar yürütülür. Gerçekleşen koşul ile ilgili blok yürütülür. Gerçekleşen durumla birlikte ilk `**break**` komutuna kadar kodlar yürütülür. Koşullarda `**<=**`, `**>=**`, `**!=**`, `**!==**`, `**==**` veya `**===**` ile karşılaştırmalar yapabiliriz. Durumlarda her zaman sıkı karşılaştırma (`**===**`) yapılır. Koşullar mantıksal operatörler ile birbirine bağlanır. Durumlar gruplanarak birbirine bağlanır. Hiçbir koşul gerçekleşmez ise `**else**` deyimi ile kod bloğu yürütebiliriz. Hiçbir durum gerçekleşmez ise `**default**` deyimi ile kodlarımızı yürütebiliriz. [Previousif - else - else ifchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kosullu-ifadeler/if-else-else-if) [NextDöngülerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/donguler) Last updated 2 years ago --- # Bir Değişkenin Ömrü (Bellekte Tutulma Süresi) | JavaScript Eğitimi Bir değişken deklare edildiğinde bellekte yer tutmaya başlar. * `**let**` veya `**const**` ile deklare edilen değişkenler kapsam sonunda bellekten kaldırılırlar. Global kapsamda deklare edilirse programın çalışma süresince bellekte yer kaplar. * `**var**` ile deklare edilen değişkenler kapsam tanımadığı için global kapsamda deklare edilmiş gibi programın çalışma süresince bellekte yer kaplar. Bu özellik performans ve güvenlik açısından önemli bir ayrıntıdır. Global kapsam internet tarayıcımızın açık olan pencere veya sekmenin alt kapsamındadır. Bu sebeple pencere-sekme dışında bir kapsama erişemez. Pencere-sekme kapatılınca da bu değişkenler bellekten kaldırılırlar. circle-info JavaScript'te oluşturulan bir değişken, nesne veya fonksiyon silinemez. [PreviousDeklare Edilmeden Kullanılan Değişkenlerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/deklare-edilmeden-kullanilan-degiskenler) [Nextİlkel (Primitive) Veri Tiplerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri) Last updated 2 years ago --- # Bitsel Operatörler | JavaScript Eğitimi Bitsel operatörler ifadeleri **32-Bitlik** tamsayıya çevirir ve bunlar üzerinde ve, veya, _özel_ veya , değil, sola kaydırma, sağa kaydırma operatörlerini binary olarak yapar. Gerçekten ihtiyacınız olduğunda başvurunuz. Operatörler şu sembollerle ifade edilir. Operatör Sembol İfade 8-Bit İfade Bit Sonuç Sonuç Bitsel VE & 156 & 52 1 0 0 1 1 1 0 0 & 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 0 20 Bitsel VEYA | 156 | 52 1 0 0 1 1 1 0 0 | 0 0 1 1 0 1 0 0 1 0 1 1 1 1 0 0 188 Bitsel _ÖZEL_ VEYA ^ 156 ^ 52 1 0 0 1 1 1 0 0 ^ 0 0 1 1 0 1 0 0 1 0 1 0 1 0 0 0 168 Bitsel DEĞİL ~ ~ 203 ~ 1 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 52 Sola kaydırma << 9 << 2 0 0 0 0 1 0 0 1 << 10 0 0 1 0 0 1 0 0 36 Sağa kaydırma \>> 9 >> 2 0 0 0 0 1 0 0 1 \>> 10 0 0 0 0 0 0 1 0 2 circle-exclamation Yukarıdaki örnekler 8-Bit olarak verilmiştir fakat javascript 32-Bit olarak yapar. [PreviousMantıksal Operatörlerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler) [NextKoşullu (Ternary) Operatörchevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/kosullu-ternary-operator) Last updated 2 years ago --- # Koşullu (Ternary) Operatör | JavaScript Eğitimi `**?**` sembolü ile kullanılır. Standart operatörlerdeki `**true**` veya `**false**` çıktısını kontrol eder. Koşuldan soran `**?**` sembolü getirilir ve `**true**` olması durumunda atanacak değer yazılır ardından : sembolü konur ve `**false**` olduğu durumda atanacak değer yazılır. Örnek. Copy let ortalama = 45; alert(ortalama >= 45 ? 'Geçti' : 'Kaldı'); Birkaç tane koşullu operatör birbirine bağlanabilir. Örnek. Copy let ortalama = 70; let durum = ortalama < 0 ? 'Değerlendirme Dışı' : ortalama < 45 ? 'Zayıf' : ortalama < 55 ? 'Geçer' : ortalama < 70 ? 'Orta' : ortalama < 85 ? 'İyi' : ortalama <= 100 ? 'Pekiyi' : 'Değerlendirme Dışı'; alert(durum); Şeklinde de kullanılabilir. Kodun okunurluğunu azalttığı için kullanımı önerilmez. [PreviousBitsel Operatörlerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/bitsel-operatorler) [NextVirgül Operatörüchevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/virgul-operatoru) Last updated 2 years ago --- # Mantıksal Operatörler | JavaScript Eğitimi Mantıksal operatörler, ifade ettiğimiz önermeleri birbirine bağlamak için kullandığımız ve (`**&&**`), veya (`**||**`), değil (`**!**`) sembolleridir. Önermeleri genellikle karşılaştırma operatörleri ile ifade ederiz. Tipten bağımsız olarak kullanılabilir. circle-info Önerme: Mantıksal olarak doğrulanabilir veya yanlışlanabilir ifadelerdir. Örneğin: _'15 sayısı 12 sayısından büyüktür.'_ ifadesi önermedir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler#ve-operatoru-and-and) VE Operatörü ( `&&` ) ----------------------------------------------------------------------------------------------------------------------------------------- `**&&**` sembolü ile kullanılır. İfadeler arasındaki yanlış (`**false**`) sonucunu arar. Sondan bir önceki ifadeye kadar `**false**` sonucunu arar ve `**false**` sonucunu bulduğu ifadeyi döndürür. Eğer sondan bir önceki ifadeye kadar `**false**` bulamaz ise sonuncu ifadeyi döndürür. Örnek. Copy let harf = 'A'; let sayi = '65'; alert(harf === 'A' && sayi === '65'); //true && true : true alert(harf === 'A' && sayi === 65); //true && false : false alert(harf === 'A' && sayi == 65); //true && true : true Bu operatörün çalışma mantığı şöyledir. Copy //sondan bir önceki ifadeye kadar false yok ise son ifadeyi döndürür. alert( true && true && true && true ); //true alert( true && true && true && false ); //false //sondan bir önceki ifadeyi kadar bulduğu ilk false ifadesini döndürür. alert( true && true && false && true ); //false: 3.ifade ile kontrolü bıraktı. alert( false && false && false && false ); //false: 1.ifade kontrolü bıraktı. Bunu şu şekilde daha güzel örnekleyebiliriz. Daha önce anlattığımız üzere `**number**` tipi ele alındığında `**false**` 0 `**true**` 1 idi. Fakat 0 harici tüm değerler de yine `**true**` değeri almaktaydı. Aynı şekilde `**string**` olanlar için de hiçbir karakter içermeyen değer ('') `**false**` herhangi bir karakter içeren değer ise `**true**` idi. Copy alert( 5 && 4 && 3 && 2 ); // sonuç son ifade yani 2 alert( 5 && 0 && 3 && 2 ); // sonuç 2.ifade yani 0 alert( 'Ahmet' && 'Mehmet' && 'Ayşe' && 'Fatma' ); //sonuç son ifade yani Fatma alert( 'Ahmet' && '' && 'Ayşe' && 'Fatma' ); //sonuç 2.ifade yani '' [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler#veya-operatoru-or-or) VEYA Operatörü ( `||` ) ------------------------------------------------------------------------------------------------------------------------------------------- `**||**` sembolü ile kullanılır. İfadeler arasındaki doğru (`**true**`) sonucunu arar. Sondan bir önceki ifadeye kadar `**true**` sonucunun arar ve `**true**` sonucunu bulduğu ifadeyi döndürür. Eğer sondan bir önceki ifadeye kadar `**true**` bulamaz ise sonuncu ifadeyi döndürür. Örnek. circle-info `**|**` sembolü "_Alt-Gr + <_" kombinasyonu ile elde edilir. İki sefer yapılırsa `**||**` elde edilir. Copy let harf = 'A'; let sayi = '65'; alert (harf === 'B' || sayi === '65'); //false && true : true alert (harf === 'A' || sayi === 65); //true && false : true alert (harf === 'B' || sayi === 65); //false && true : false Bu operatörün çalışma mantığı şöyledir. Copy //sondan bir önceki ifadeye kadar true yok ise son ifadeyi döndürür. alert( false || false || false || true ); //true alert( false || false || false || false ); //false //sondan bir önceki ifadeye kadar bulduğu ilk true ifadesini döndürür. alert( false || false || true || false ); //true: 3.önerme ile kontrolü bıraktı. alert( true || false || false || false ); //true: 1.önermede kontrolü bıraktı. Daha iyi örnekle. Copy alert( 5 || 0 || 4 || 3 ); //sonuç ilk ifade yani 5 alert( 0 || 0 || 3 || 2 ); // sonuç sondan bir önceki ifade yani 3 alert( 'Ahmet' || 'Mehmet' || 'Ayşe' || 'Fatma' ); //sonuç ilk ifade yani Ahmet alert( '' || '' || 'Ayşe' || 'Fatma' ); //sonuç sondan bir önceki ifade yani Ayşe [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler#degil-operatoru) DEĞİL Operatörü ( `!` ) -------------------------------------------------------------------------------------------------------------------------------------- `**!**` sembolü ile kullanılır. Bir ifadenin başında kullanıldığında, ifadenin kendi değerini **ilk başta boolean tipine çevirir** ve bu değerin tersini döndürür. `**false**` ise `**true**`, `**true**` ise `**false**` olarak sonuç döndürür. Copy let harf = 'A'; let bos = ''; let sayi = 12; let sifir = 0; alert( !harf ); //harf'in boolean değeri true, değili false alert( !bos ); //bos'un boolean değeri false, değili true alert( !sayi ); //sayi'nin boolean değeri true, değili false alert( !sifir ); //sifir'ın boolean değeri false, değili true Bu operatörün çalışma mantığı şöyledir. Copy alert( !false ); //true alert( !true ); //false [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler#ozel-degerlerin-mantiksal-karsilastirmalari) Özel Değerlerin Mantıksal Karşılaştırmaları -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Özel değerlerin `**&&**` operatörü ile kullanımına bakalım. Sondan bir önceki ifadeye kadar `**undefined**`, `**NaN**` veya `**null**` ile karşılaşırsa kontrolü bırakır karşılaştığı değeri döndürür. Copy alert( true && undefined && false ); //undefined alert( false && undefined && true ); //false (ilk bulduğu false değerini döndürür) alert( true && null && false ); //null alert( false && null && true ); //false (ilk bulduğu false değerini döndürür) alert( true && NaN && false ); //NaN alert( false && NaN && true ); //false (ilk bulduğu false değerini döndürür) alert( null && undefined && NaN ); //null alert( undefined && NaN && null ); //undefined alert( NaN && null && undefined ); //NaN Fakat **veya** operatörü bu değerleri **görmezden gelir.** Copy alert( true || undefined || false ); //true alert( false || undefined || false ); //false alert( true || null || false ); //true alert( false || null || false ); //false alert( true || NaN || false ); //true alert( false || NaN || false ); //false alert( null || undefined || NaN ); //null alert( undefined || NaN || null ); //undefined alert( NaN || null || undefined ); //NaN Değil `**!**` operatörü hepsi için `**true**` değeri döndürür. Copy alert( !undefined ); //true alert( !null ); //true alert( !NaN); //true Bu şu anlama **gelmemektedir**: `_**undefined**_`_,_ `_**NaN**_` _ve_ `_**null**_` _değerleri boolean olarak_ `_**false**_` _değerindedir_. Bu önerme yanlıştır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler#operatorlerin-oncelikleri) Operatörlerin Öncelikleri -------------------------------------------------------------------------------------------------------------------------------------------------- Karşılaştırma yaparken farklı operatörleri bir arada kullanabilirsiniz. Bu durumda _**ve**_ ile _**veya**_ arasında öncelik nasıl olur ? Öncelik _**ve**_ operatöründedir. _**ve**_ operatör işlemlerinden sonra _**veya**_ operatörüne geçilir. Örnek. Copy alert( 0 || 5 && 3 ); // 3 // ilk 5 && 3 operatörü çalışır: 3 //sonra 0 || 3 operatörü çalışır: 3 Copy alert( '' || 'Kırmızı' && 'Beyaz' ); // 'Beyaz' // ilk 'Kırmızı' && 'Beyaz' operatörü çalışır: 'Beyaz' //sonra '' || 'Beyaz' operatörü çalışır: 'Beyaz' [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler#kisa-devre) Kısa Devre -------------------------------------------------------------------------------------------------------------------- Mantıksal operatörlerde kısa devre; operatörlerin çalışma sırasında son ifadeyi döndüreceği durumda sondaki ifadeyi kod için kullanmaktır. Bu durum okunurluğu artıracak bir kapıdır. Şöyle ki: Copy let kullanici = 'admin'; let sifre = '1234'; kullanici === 'admin' && sifre === '1234' && alert('Giriş Başarılı') //normalde mantıksal ifadelerim 2 tane idi fakat 3.ye kod ifadesi yazdım. // 've' operatörü 2 ifadeyi test edip doğru ise son ifadeyi döndüreceği için: // kod otomatik olarak çalışır. `**&&**` operatörü `**false**` değeri arar. Son ifadeye kadar bulamazsa son ifadeyi döndürür. Yukarıdaki örneğe bakarsak ilk iki ifade `**true**` olduğu için doğrudan son ifadeyi döndürür. Dolayısıyla değişkenleri manipüle etmek için de kullanılabilir. Başka bir örnekle: Copy let sistem = 'Android'; let cihaz = null; cihaz = sistem !== 'Windows' || sistem !== 'Linux' && 'mobil'; alert(cihaz); //mobil `**&&**` operatörü ilk `**false**` değeri döndürür. `**sistem**` değişkeninin değeri '`**Android**`' olduğu için ilk ifade `**true**` sonuç verir dolayısıyla `**&&**` operatörü son ifadeyi döndürür. Son ifade de '`**mobil**`' olduğu için `**cihaz**` değişkeni '`**mobil**`' olarak atanır. Aynısını ilk `**true**` değerini döndüren `**||**` operatörü ile yapalım. Copy let sistem = 'Android'; let cihaz = null; cihaz = sistem === 'Windows' || sistem === 'Linux' || 'mobil'; alert(cihaz); //mobil `**||**` operatörü ilk `**true**` değeri döndürür. `**sistem**` değişkeninin değeri '`**Android**`' olduğu için `**false**` sonuçlar verir dolayısıyla `**||**` operatörü son ifadeyi döndürür. Son ifade de '`**mobil**`' olduğu için `**cihaz**` değişkeni '`**mobil**`' olarak atanır. [PreviousKarşılaştırma Operatörlerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/karsilastirma-operatorleri) [NextBitsel Operatörlerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/bitsel-operatorler) Last updated 2 years ago --- # Atama Operatörleri | JavaScript Eğitimi Bir öğenin _**değerini**_ belirlemek için kullanılan `**=**` sembolüdür. Bu operatörü şimdiye kadar birçok kez kullandık zaten. Örnek. Copy let degisken = 'Javascript'; [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri#toplama-atamasi) Toplama Ataması ( `+=` ) ------------------------------------------------------------------------------------------------------------------------------------ Bir öğenin _**değerinin**_ üzerine eklenecek değerleri işleyip atamak için kullanılan `**+=**` sembolüdür. Örnek. Copy let sayi = 1923; sayi += 100; // sayi değerinin varolan değerinin üzerine 100 ekledik ve atadık. // Bunun daha uzun yöntemi de şudur: sayi = sayi + 100; alert(sayi); // 2023 Copy let str = 'Java'; str += 'script'; // str değerinin varolan değerini 'script' ile birleştirdik ve atadık. alert(str); // 'Javascript' [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri#cikarma-atamasi) Çıkarma Ataması ( `-=` ) ------------------------------------------------------------------------------------------------------------------------------------ Bir öğenin _**değerini**_ üzerinden çıkarılacak değerleri işleyip atamak için kullanılan `**-=**` sembolüdür. Örnek. Copy let sayi = 2023; sayi -= 100; // sayi değerinin varolan değerinin üzerinden 100 çıkardık ve atadık. // Bunun daha uzun yöntemi de şudur: sayi = sayi - 100; alert(sayi); // 1923 [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri#carpma-atamasi) Çarpma Ataması ( `*=` ) ---------------------------------------------------------------------------------------------------------------------------------- Bir öğenin _**değeri**_ ile çarpılacak değerleri işleyip atamak için kullanılan `***=**` sembolüdür. Örnek. Copy let sayi = 20; sayi *= 5; // sayi değerini 5 ile çarptık ve atadık. // Bunun daha uzun yöntemi de şudur: sayi = sayi * 5; alert(sayi); // 100 [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri#bolme-atamasi) Bölme Ataması ( `/=` ) -------------------------------------------------------------------------------------------------------------------------------- Bir öğenin _**değeri**_ ile bölünecek değerleri işleyip atamak için kullanılan `**/=**` sembolüdür. Örnek. Copy let sayi = 100; sayi /= 5; // sayi değerini 5 ile böldük ve atadık. // Bunun daha uzun yöntemi de şudur: sayi = sayi / 5; alert(sayi); // 20 [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri#ussune-atama) Üssüne Atama ( `**=` ) ------------------------------------------------------------------------------------------------------------------------------- Bir öğenin _**değeri**_ ile üssü alınacak değer işleyip atamak için kullanılan `****=**` sembolüdür. Örnek. Copy let sayi = 10; sayi **= 2; // sayi değerinin 2.üssünü aldık ve atadık. // Bunun daha uzun yöntemi de şudur: sayi = sayi ** 2; alert(sayi); // 100 [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri#kalanina-atama) Kalanına Atama ( `%=` ) ---------------------------------------------------------------------------------------------------------------------------------- Bir öğenin _**değeri**_ ile bölünecek değeri işleyip kalanı atamak için kullanılan `**%=**` sembolüdür. Örnek. Copy let sayi = 10; sayi %= 3; // sayi değerini 3'e böldük ve kalanına atadık. // Bunun daha uzun yöntemi de şudur: sayi = sayi ** 2; alert(sayi); // 100 [PreviousMatematiksel (Aritmetik) Operatörlerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler) [NextKarşılaştırma Operatörlerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/karsilastirma-operatorleri) Last updated 2 years ago --- # Blok Kapsam | JavaScript Eğitimi Javascript'te **her süslü parantez (** `**{ }**` **)arası bir bloktur.** Blok kapsamda (alt kapsam) deklare edilen değişkenler 'yerel değişken' (local) olarak adlandırılır ve sadece kendi kapsamında geçerlidir. Copy // Bu örnekte hata fırlatılır. Çalışmaz. { let yerelDegisken = 'Yerel Değişken'; } alert(yerelDegisken); // Global kapsamda böyle bir değişken bildirilmedi. Blok kapsamda deklare edilenler blok kapsamın tamamında geçerli olur. Yani kapsamın altındaki diğer kapsamlarda da geçerlidir. Deneyiniz. Copy // Kapsam içinde kapsam { let yerelDegisken = 'Yerel Değişken'; { alert(yerelDegisken); } } Burada da gördüğünüz gibi _**her kapsam bir alt kapsamın 'global' kapsamı sayılır**_**.** Bloklar iç içe uzayıp gidebilirler. Bir kapsamın herhangi bir satırında `**var**` ile yaptığınız bildirimler **kapsamdaki kodların yürütülmesinden önce ele alınır**. Buna yukarı kaldırma (**hoisted**) denir. Örnek yürütme: Copy // Yazılan Kod let dil = 'JS'; const ulke = 'TR'; alert('Uyarı!'); var isim = 'Asya'; function foo() { alert('FOO Fobnksiyonu'); } var soyisim = 'GÜN'; Copy // Yukarı Kaldırılan Kod var isim = undefined; var soyisim = undefined; function foo() { alert('FOO Fobnksiyonu'); } // yukarı kaldırma bitti let dil = 'JS'; const ulke = 'TR'; alert('Uyarı!'); var isim = 'Asya'; var soyisim = 'GÜN'; Kullanıcı tarafından oluşturulan fonksiyonlar da yine yukarı kaldırılır. [PreviousGlobal Kapsamchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/global-kapsam) [NextFonksiyon Kapsamchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/fonksiyon-kapsam) Last updated 2 years ago --- # Karşılaştırma Operatörleri | JavaScript Eğitimi Karşılaştırma operatörlerinden büyüktür, küçüktür vb. matematiksel olanları zaten biliyorsunuzdur. Programlama dillerindeki karşılaştırma işlemlerinin hepsinin sonucu `**true**` veya `**false**` olarak döner. Yani `**Boolean**` tipindedir. Şimdi karşılaştırmaları ele alalım. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/karsilastirma-operatorleri#iliskisel-karsilastirmalar-less-than-greater-than) İlişkisel Karşılaştırmalar ( `<`, `>`, `=`, `!` ) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Bu karşılaştırmalarda `**<**`, `**>**`, `**=**`, `**!**` sembolleri kullanılır. Büyüktür, küçüktür, eşittir gibi karşılaştırmalardır. Örnek. Copy let sayi1 = 12; let sayi2 = -12; alert(sayi1 > sayi2); // true alert(sayi1 < sayi2); //false alert(sayi1 > sayi1); //false alert(sayi1 < sayi1); //false alert(sayi1 >= sayi1); //true alert(sayi1 <= sayi1); //true Değerlerin sayı tipinde olmasına gerek yoktur. **Sayısal değerler farklı tipte olsalar da değerleri üzerinden karşılaştırılırlar.** Copy alert('15' > '25'); // false alert(25 > '15'); // true alert('15' > '25'); // false alert(true > false); //true (Boolean true=1 false=0) alert(false > true); //false (Boolean true=1 false=0) Javascript'te karakterler Unicode Karakter Kodlaması'na göre bit değerleri üzerinden karşılaştırılır. Örneğin: Harf Unicode UTF-16 a U+0061 0x0061 A U+0041 0x0041 Karakter dizisi sırayla ilk karakterden başlanarak karşılaştırılır. Bu tabloya göre karşılaştırmalar yapalım. Copy alert('a' > 'A'); // true alert('TRa' > 'TRA'); //true alert('TRK' > 'TRKS'); //false Aynı sonuç çünkü 'TR' karakterleri ikisinde de aynı olduğu için sonuç çıkana kadar karakterleri kontrol etmeye devam eder. Sayısal olmayan değerler ile sayısal olanları karşılaştırıldığında sayısal olmayanlar `**NaN**` değerine çevrildiği için tüm karşılaştırmalar `**false**` olarak çıkar. Copy alert('a' > 1); // false alert('a' < 1); // false Eşitlik karşılaştırmaları iki veya üç `**=**` sembolü ile yapılır. `**==**` sembolü ile sadece değer, `**===**` sembolü ile hem tip hem de değer karşılaştırması yapılır. Üç `**=**` sembolü ile yapılan karşılaştırmalar sıkı karşılaştırmalardır. Tek `**=**` sembolü atama operatörüdür karşılaştırma yapmaz. Örnek. circle-info `**==**` _**Değerler Eşit mi?**_ | `**===**` _**Tipler ve Değerler Eşit mi?**_ Copy alert(0 == '0'); //true - Eşit mi? Evet değerler eşit. alert(0 == 0); //true - Eşit mi? Evet değerler eşit. alert(0 == false); //true - Eşit mi? Evet değerler eşit. alert(0 == ''); //true - Eşit mi? Evet değerler eşit. alert(0 === '0'); //false - Eşit mi? Hayır tipler eşit değil. alert(0 === 0); //true - Eşit mi? Evet tipler ve değerler eşit. alert(0 === false); //false - Eşit mi? Hayır tipler eşit değil. alert(0 === ''); //false - Eşit mi? Hayır tipler eşit değil. Eşitsizlik (Eşit Değil mi?) karşılaştırmaları da iki şekilde yapılır. `**!=**` sembolü ile sadece değer `**!==**` sembolü ile hem tip hem de değer karşılaştırması yapılır. Örnek. Copy alert(0 != 0 ); //false - Eşit değil mi? Hayır değerler eşit. alert(0 != '0'); //false - Eşit değil mi? Hayır değerler eşit. alert(0 !== '0'); //true - Eşit değil mi? Evet tipler eşit değil. alert(0 !== 0); //false - Eşit değil mi? Hayır tipler ve değerler eşit. `**Undefined**`**,** `**Null**` **ve** `**NaN**` **değerlerinin karşılaştırmaları** beklenmeyen sonuçlar verebilir. `**Undefined**` değeri karşılaştırmalarda `**NaN**` değerine döner, `**Null**` değeri ise `**0**` değerine döner. `**NaN**` ile yapılan **bütün karşılaştırmaların** `**false**` **sonucunu vereceğini unutmayınız.** Copy alert(null == '0'); //false (true vermesi beklenebilirdi.) alert(null == 0); //false (true vermesi beklenebilirdi.) alert(null >= 0); //true (false vermesi beklenebilirdi.) alert(NaN === NaN); //false (true vermesi beklenmez.) alert(undefined === NaN); //false (true vermesi beklenmez.) Bu sebeple sıkı karşılaştırma olan `**===**` operatörünü kullanmanız önerilir. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/karsilastirma-operatorleri#dahili-karsilastirmalar) Dahili Karşılaştırmalar --------------------------------------------------------------------------------------------------------------------------------------------------- circle-info Copy Number.isNaN() | isNaN() | Number.isFinite() Number.isInteger() | Number.isSafeInteger() Dahili karşılaştırmalar dilde fonksiyon veya metotlarla yaptığımız karşılaştırmadır. Örneğin `**NaN**`, `**Infinity**`, `**Integer**` vb. değerlerini kontrol etmemizi sağlayan metot veya fonksiyonlar vardır. Örnek. Copy let sayiOlmayan = NaN; let sonsuz = Infinity; let tamSayi = 10000000000000000; // //isNaN kullanımları alert( Number.isNaN(sayiOlmayan) ); // true (metot) alert( isNaN(sayiOlmayan) ); // true (fonksiyon) //isFinite alert( Number.isFinite(sonsuz) ); // false //isInteger alert( Number.isInteger(tamSayi) ); // true //isSafeInteger alert( Number.isSafeInteger(tamSayi) ); // false - maxSafeInteger: 9007199254740991 circle-info .includes() | .endsWith() | .startsWith() Bu karşılaştırmalar daha önce [string](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi) konusunda işlenmiştir. Karşılaştırma sonucu olarak `**true**` `**false**` vermektedir. Copy let misra = 'Ben ezelden beridir hür yaşadım, hür yaşarım.'; alert( misra.includes('hür'); //true alert( misra.endsWith('.'); //true alert( misra.startsWith('Ben'); //true circle-info Array.isArray() | instanceof Bu karşılaştırmalar yine `**true**` `**false**` sonuç veren dahili karşılaştırmalardır. Referans Veri Tipleri konusu ile işlenecektir. [PreviousAtama Operatörlerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri) [NextMantıksal Operatörlerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler) Last updated 2 years ago --- # Deklare Edilmeden Kullanılan Değişkenler | JavaScript Eğitimi JavaScript'te bir değişkeni deklare etmeden de kullanabilirsiniz. Fakat burada katı mod ve normal mod farkı vardır. Örnek. Copy //Aşağıdaki kodlar katı mod ('use strict';) aktif değilse çalışır. degisken = 'Deklare Edilmemiş Değişken'; alert(degisken); { alert(degisken); } Copy //Katı mod açıksa bildirilmeyen değişken alt kapsamlarda çalışmaz. 'use strict'; degisken = 'Deklare Edilmemiş Değişken'; { alert(degisken); // Hata fırlatır. } Eğer katı mod kapalı ise deklare edilmeyen değişken hangi kapsamda tanımlanırsa tanımlansın global değişken olarak tüm kapsamlarda çalışır. Eğer katı mod açık ise deklare edilmeyen değişken sadece tanımlandığı kapsamda çalışır ve **alt kapsamlarında çalışmaz.** [PreviousFonksiyon Kapsamchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/fonksiyon-kapsam) [NextBir Değişkenin Ömrü (Bellekte Tutulma Süresi)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/bir-degiskenin-omru-bellekte-tutulma-suresi) Last updated 2 years ago --- # BigInt - Büyük Sayı | JavaScript Eğitimi `**BigInt**` veri tipi bir tamsayının sonuna `**n**` koyarak elde edilen değişkenlerin tipidir. Bu tip tamamen tamsayılardan oluşup genellikle `**number**` tipinin alabileceği `**Number.MAX_SAFE_INTEGER**` sayısı olan 253−12^{53}-1253−1 'den pozitif olarak büyük, negatif olarak küçük tam sayıları ifade etmek için kullanılır. Copy let buyukSayi1 = 1n; let buyukSayi2 = -1n; alert(buyukSayi1); // 1 olarak çıktı verir. alert(buyukSayi2); // -1 olarak çıktı verir. alert(typeof buyukSayi1); //bigint olarak çıktı verir. alert(typeof buyukSayi2); //bigint olarak çıktı verir. `**BigInt**` veri tipinde değişkenler `**number**` tipinde değişkenlerle **matematiksel işlemlere sokulamazlar.** Sadece kendi aralarında işleme girerler. Bir `**number**` tipindeki değişkeni `**bigInt**` tipine çevirmek için `**BigInt()**` fonksiyonu kullanılır. Copy let maxTamSayi = BigInt( Number.MAX_SAFE_INTEGER ); let minTamSayi = BigInt( Number.MIN_SAFE_INTEGER ); alert(maxTamSayi + minTamSayi); // 0 çıktısı alınır. alert(typeof (maxTamSayi + minTamSayi) ); //bigint çıktısı alınır. `**BigInt**` veri tipiyle `**Math**` kütüphanesini kullanamazsınız. Bu kütüphane sadece `**number**` tipi içindir. `**BigInt**` sadece kendi aralarında matematiksel işlemlere sokulur. Bu sebeple bir `**bigInt**` veri tipini `**number**` tipine çevirerek işleme sokmak mümkün ama güvenli değildir. Çünkü tam olarak istediğiniz sayıya dönüşeceğinden emin olamazsınız. Copy let bigN = BigInt( Number.MAX_SAFE_INTEGER ); bigN = bigN * bigN * bigN; //kendisini küpüne eşitledik. alert(bigN); // 730750818665451215712927172538123444058715062271 alert( Number(bigN) ); //7.307508186654512e+47 `**BigInt**` veri tipi tamsayı olduğu için bölümlerde ondalıklı sonuç bekleyemezsiniz. Copy alert( 5n / 2n ); //Sonuç 2n olarak çıkar ve 2 olarak çıktı verir. Bu tip kriptolama işlemlerinde kullanılmazlar. Çünkü güvenli değildirler ve işlemcide eş zamanlı oluşturulmazlar. [PreviousMath Kütüphanesichevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi/math-kutuphanesi) [NextBoolean - Mantıksalchevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/boolean-mantiksal) Last updated 2 years ago --- # Virgül Operatörü | JavaScript Eğitimi Farklı bir operatördür. Aralarına virgüller koyarak yazdığımız ifadeleri yürütür fakat değeri en son yazdığımız ifadedir. Okunurluğu azaltsa da kullanımı yaygındır. Parantez içinde kullanmayı unutmayınız. Örnek. Copy let cevre = (a = 3, b = 4, c = 5, a + b + c); alert(cevre); //12 Değerin sondaki ifade olduğuna dikkat ediniz. Copy let a = 3, b = 4, c = 5; let deger = (a, b, c); alert(deger); //5 Copy let durum = (a = 3, b = 4, c = 5, 'Değişken oluşturma başarılı'); alert(durum); alert(a, b, c); //'Değişken oluşturma başarılı' [PreviousKoşullu (Ternary) Operatörchevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler/kosullu-ternary-operator) [NextUyarı, Bilgi, Onay Fonksiyonlarıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/uyari-bilgi-onay-fonksiyonlari) Last updated 2 years ago --- # Matematiksel (Aritmetik) Operatörler | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#toplama) Toplama ( `+` ) ----------------------------------------------------------------------------------------------------------------------------------- İki _**değeri**_ birbiriyle toplamak veya birleştirmek için kullanılan `**+**` sembolüdür. Bu operatör ile sayısal değerler toplanır. Eğer değerler arasında en az bir tane `**string**` var ise `**string**` olarak birleştirilir. Örnek. Copy alert(19 + 23); // sonuç number: 42 alert(19 + '23'); // sonuç string: '1923' alert(19 + '23 TR'); // sonuç string: '1923 TR' alert('19' + '23'); // sonuç string: '1923' `**+**` operatörü değişkeni sayıya dönüştürmek için de kullanılır. Sayısal olamayacak verileri dönüştürüp `**NaN**` değeri üretir. Örnek. Copy let sayi1 = '2023'; let sayi2 = '1923'; let fark = +sayi1 + +sayi2; //2023 + 1923 alert(fark); // Number tipinde 3946 değeri. alert( +('Bindokuzyüzyirmiüç') ); // Number tipinde NaN değeri. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#cikarma) Çıkarma ( `-` ) ----------------------------------------------------------------------------------------------------------------------------------- İki _**değeri**_ birbirinden çıkarmak için kullanılan `**-**` sembolüdür. Eğer öğeler sayısal olabilecek değer içeriyorsa dönüştürüp işlemi yapar. Eğer öğelerden en az biri sayısal olamayacak değer içeriyorsa `**NaN**` değeri üretir. Örnek. Copy alert(2023 - 1923); // sonuç number: 100 alert(19 - '23'); // sonuç number: -4 alert(19 - '23 TR'); // sonuç number: NaN `**String**` tipini negatif olarak `**number**` tipine dönüştürmek için de `**-**` operatörü kullanılabilir. Örnek. Copy let sayi1 = '2023'; let sayi2 = '1923'; let fark = -sayi1 - -sayi2; // -2023 - (-1923) alert(fark); // Number tipinde -100 değeri. alert( -('Bindokuzyüzyirmiüç') ); // Number tipinde NaN değeri. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#carpma) Çarpma ( `*` ) --------------------------------------------------------------------------------------------------------------------------------- İki _**değeri**_ çarpmak için kullanılan `*****` sembolüdür. Eğer öğeler sayısal olabilecek değer içeriyorsa dönüştürüp işlemi yapar. Eğer öğelerden en az biri sayısal olamayacak değer içeriyorsa `**NaN**` değeri üretir. Örnek. Copy alert(12 * 12); // sonuç number: 144 alert(12 * '12'); // sonuç number: 144 alert(12 * '12 TR'); // sonuç number: NaN [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#bolme) Bölme ( `/` ) ------------------------------------------------------------------------------------------------------------------------------- İki _**değeri**_ bölmek için kullanılan `**/**` sembolüdür. Eğer öğeler sayısal olabilecek değer içeriyorsa dönüştürüp işlemi yapar. Eğer öğelerden en az biri sayısal olamayacak değer içeriyorsa `**NaN**` değeri üretir. Örnek. Copy alert(100 / 10); // sonuç number: 10 alert(100 / '10'); // sonuç number: 10 alert(100 / '10 TR'); // sonuç number: NaN [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#us-alma) Üs Alma ( `**` ) ------------------------------------------------------------------------------------------------------------------------------------ İlk _**değeri**_ taban ikinci _**değeri**_ üs olarak kullanan `******` sembolüdür. Eğer öğeler sayısal olabilecek değer içeriyorsa dönüştürüp işlemi yapar. Eğer öğelerden en az biri sayısal olamayacak değer içeriyorsa `**NaN**` değeri üretir. Örnek. Copy alert(10 ** 3); // sonuç number: 1000 alert(10 ** '3'); // sonuç number: 1000 alert(100 ** '3 TR'); // sonuç number: NaN [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#mod-alma-kalan) Mod Alma (Kalan) ( `%` ) --------------------------------------------------------------------------------------------------------------------------------------------------- İlk _**değeri**_ bölünen ikinci _**değeri**_ bölen olarak kullanan `**%**` sembolüdür. Eğer öğeler sayısal olabilecek değer içeriyorsa dönüştürüp işlemi yapar. Eğer öğelerden en az biri sayısal olamayacak değer içeriyorsa `**NaN**` değeri üretir. Örnek. Copy alert(10 % 3); // sonuç number: 1 alert(10 % '3'); // sonuç number: 1 alert(10 % '3 TR'); // sonuç number: NaN [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#artirma) Artırma ( `++` ) ------------------------------------------------------------------------------------------------------------------------------------ Sadece sayısal olabilecek _**değişkenleri**_ bir artırmak için kullanılan `**++**` sembolüdür. Sadece değişken isimleriyle kullanılabilir doğrudan değer ile kullanılamaz. Önden artırım ve sonradan artırım olarak iki türü mevcuttur. Sonradan artırım kullanımında **okunduktan sonra artırım yapar** ve bir sonraki okumada değeri artmış olur. Örnek. Copy // Sonradan artırım let sayi = 9; alert(sayi++); // Önce sayi:9 çıktısı verdi ardından artırım yaptı. alert(sayi); // Artık sayı 10 olarak çıktı verir. Önden artırım kullanımında **okunmadan hemen önce artırım yapar** ve ilk okumada değeri artmış olur. Örnek. Copy // Önden artırım let sayi = 9; alert(++sayi); // Önce artırım yaptı sonra okuma yaptı 10 olarak çıktı verdi. `**Number**` tipine dönüştürülebilecek diğer tipleri de dönüştürüp işlemi yapar. Örnek. Copy let sayi1 = '9'; // String let sayi2 = '19'; // String let toplam = ++sayi1 + sayi2++; // sayi1: 10, sayi2: 19 Sonuç:29 alert(toplam); // 29 çıktısı verir. alert(sayi2); // Sonradan artırım sonraki okumada değer artırır: 20 [hashtag](https://hanuce.gitbook.io/javascript-egitimi/operatorler/matematiksel-aritmetik-operatorler#azaltma) Azaltma ( `--` ) ------------------------------------------------------------------------------------------------------------------------------------ Sadece sayısal olabilecek _**değişkenleri**_ bir azaltmak için kullanılan `**--**` sembolüdür. Sadece değişken isimleriyle kullanılabilir doğrudan değer ile kullanılamaz. Önden azaltma ve sonradan azaltma olarak iki türü mevcuttur. Sonradan azaltma kullanımında **okunduktan sonra azaltma yapar** ve bir sonraki okumada değeri azaltmış olur. Örnek. Copy // Sonradan azaltma let sayi = 11; alert(sayi--); // Önce sayi:11 çıktısı verdi ardından azaltma yaptı. alert(sayi); // Artık sayı 10 olarak çıktı verir. Önden azaltma kullanımında **okunmadan hemen önce azaltma yapar** ve ilk okumada değeri azalmış olur. Örnek. Copy // Önden azaltma let sayi = 11; alert(--sayi); // Önce azaltma yaptı sonra 10 olarak çıktı verdi. `**Number**` tipine dönüştürülebilecek diğer tipleri de dönüştürüp işlemi yapar. Örnek. Copy let sayi1 = '11'; // String let sayi2 = '21'; // String let toplam = --sayi1 + sayi2--; // sayi1: 10, sayi2: 21 Sonuç:31 alert(toplam); // 31 çıktısı verir. alert(sayi2); // Sonradan azaltma sonraki okumada değer azaltır: 20 circle-info Javascript işlem önceliğine göre işlemleri yapar. Javascriptte matematiksel işlemler güvenlidir. Tip hatası olsa bile `**NaN**` değeri üretir. [PreviousOperatörlerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/operatorler) [NextAtama Operatörlerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/operatorler/atama-operatorleri) Last updated 2 years ago --- # Undefined - Tipi ve Değeri | JavaScript Eğitimi `**Undefined**` 'tanımlanmamış' demektir. Bir değişken değeri belirlenmeden tanımlanmışsa hem veri tipi hem de değeri `**undefined**` olarak bellekte yer tutar. Yani değeri atanmayan her değişken `**undefined**` tipinde ve değerindedir. **Esasında bir değerdir.** Tip kontrolü yapılırsa da `**undefined**` çıktısı alınır. Örnek. Copy let degisken; alert(degisken); // undefined çıktısı alert(typeof degisken); // undefined çıktısı Bir değişkenin değeri `**undefined**` olarak belirlenebilir. Fakat anlamsızdır. Çünkü genellikle değeri belirlenmeyen değişkenlerin kontrolünü yapmak için kullanılır. Copy let degisken; degisken = undefined; alert(degisken); // undefined çıktısı alert(typeof degisken); // undefined çıktısı `**undefined**` değeri özel bir değerdir. Bir değişkenin değerini `**undefined**` olarak belirlemek yerine `**null**` olarak belirlemek daha yaygındır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/undefined-tipi-ve-degeri#null-degeri) null Değeri ------------------------------------------------------------------------------------------------------------------------------------------ `**null**` değeri de özel bir değerdir. `**null**` 'boş' anlamına gelmektedir. Copy let degisken = null; alert(typeof degisken); // object çıktısı `**null**` değeri de ilkel veri tipidir ama `**object**` veri tipi çıktısı verir. Fakat `**object**`'e erişim sağlanamaz. `**object**` veri tipini ilerleyen konularda işleyeceğiz. circle-info Ne zaman `**null**` değeri kullanmalıyım? Bir değişkenin `**bir değeri referans etmesinin**` önemli olduğu durumlarda `**null**` değeri kullanılmalıdır. Çünkü `**null**` değeri değişkene **değerinin atandığını** ve 'boş' (null) değerde olduğunu referans eder. `**undefined**` ise (boş bile olsa) `**bir değer referans etmez.**` Değişkene değer atanmadığının, sadece değişkenin deklare edildiğini ifade eder. [PreviousBoolean - Mantıksalchevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/boolean-mantiksal) [NextTip Dönüşümlerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/tip-donusumleri) Last updated 2 years ago --- # var ile Değişken Deklare Etme - Eski Yöntem | JavaScript Eğitimi Eski kullanım olan `**var**` deklaratif sözcüğü ile de değişken bildirebilirsiniz. Fakat `**var**` ile `**let**`'in birbirinden bazı farkları olduğunu bilmek gerekir. `**var**` bildirimi blok ve kapsam tanımaz. Hangi kapsamda bildirildiğine bakılmaksızın ana kapsamda bildirilmiş gibi olur ve her kapsamda aynı bellek birimini temsil eder. Yukarıda `**let**` ile yaptığımız örneği `**var**` ile yaparsak farklardan birini anlamış oluruz. Copy var isim = 'Script'; { var isim = 'Java'; alert(isim); // İlk bu satır çalışır. 'Java' } alert(isim); // Sonra bu satır çalışır. Yine 'Java' `**var**` sözcüğünün blok ve kapsam hassasiyeti yoktur. Değişkenlerin kapsam fark etmeksizin aynı bellek birimindeki değeri temsil etmesi yapılan her değişikliği bir öncekinin üzerine yazacağı için yapmak istediğinizden farklı sonuçlar görebilirsiniz fakat hata fırlatılmaz. Çünkü çalışma mantığı bu şekildedir. `**var**` sözcüğünün `**let**` sözcüğünden bir farkı da `**var**` ile bildirilen bir değişkenin sonradan da **deklare** edilebilmesidir. Zaten kapsam tanımadığı için bütün bildirimler ana kapsam olarak ele alınır. Çok sayıda bildirim hata olarak fırlatılmaz. Dolayısıyla programcı aynı değişken ismini daha önce kullandığını fark edemez. Tekrar bildirince aynı bellek birimini kullanır ve eski değerin üzerine yazar. Copy var isim = 'Java'; // kodlar var isim = 'Script'; // kodlar { var isim = 'Programlama Dili'; // kodlar } alert(isim); // 'Programlama Dili' olarak görünür. `**var**` ile `**let**` arasındaki bir fark da şudur. `**let**` ile bildirdiğiniz bir değişkeni bildirimden önce kullanırsanız hata fırlatılır. Fakat `**var**` ile bildirdiğiniz bir değişkeni bildirimden önce kullanırsanız **hata fırlatılmaz**. Sadece '`**undefined**`' (tanımlanmamış) bir verisi olur. Deneyiniz. Copy alert(isim); //Hata fırlatılmaz. 'Undefined' değeri alınır. var isim = 'Javascript'; alert(isim); //'Javascript' değer alınır. var isim = 'Programlama Dili'; alert(isim); //'Programlama Dili' değer alınır. [Previouslet ile Değişken Deklare Etmechevron-left](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/let-ile-degisken-deklare-etme) [Nextconst ile Değişken Deklare Etmechevron-right](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/const-ile-degisken-deklare-etme) Last updated 2 years ago --- # let ile Değişken Deklare Etme | JavaScript Eğitimi İlk deklaratif sözcüğümüz '`**let**`' sözcüğüdür. Örnek: Copy // dil adında bir değişken oluşturalım "use strict" ; let dil; //bildiridik, bellekte yerini aldı. dil = 'JavaScript'; //bildirdikten sonra değer atadık. // uzanti adında bir değişken oluşturalım let uzanti = '.js'; //hem bildirdik, hem de değerini aynı satırda atadık. // kullanimAlani ve sonSurum adında bir değişken oluşturalım. let kullanimAlani = 'Web Geliştirme', sonSurum = 'ES13'; `**let**` ile bildirilen bir değişken **bildirimden sonra kullanılmalıdır**. Bildirimden önce kullanılırsa **hata fırlatılır.** Deneyiniz. Copy //Yanlış bildirim ve kullanım. Hata fırlatılır. "use strict" ; dil = 'Javascript'; let dil; Bir kapsamda `**let**` ile bildirilen bir değişken ismi aynı kapsamda yeniden bildirilemez. Javascript'te **her süslü parantezin başı ve sonu bir bloktur ve her blok bir kapsamı belirtir.** Bloklar ve kapsamlar bir sonraki konuda '[Kapsamlar ve Geçerlilik](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler) ' olarak işlenecektir. Şimdilik şunu bilmeniz yeterlidir. Örnek olarak. Copy // Burası ana kapsam // kodlar // kodlar { // Yeni blok başladı. Burası farklı bir kapsam //kodlar // Bir satır sonra bu blok ve kapsam bitiyor } // Burası tekrar ana kapsam { // Başka yeni bir blok başladı. Burası daha da farklı bir kapsam. //kodlar // Bir satır sonra bu blok ve kapsam da bitiyor. } // Burası da tekrar ana kapsam circle-info _Bundan sonraki kodlarda_ `**"use strict";**` _yazılmayacaktır. Bunun zaten kodun en başında belirtildiğini varsayıyorum._ Bir kapsamda aynı değişken ismi `**let**` ile birden fazla bildirilemez. Bir kez bildirdikten sonra bellekte yer alan değişkeni doğrudan değişken adı ile kullanabilirsiniz. Örnek. Copy let isim; isim = 'JavaScript'; let isim = 'Programlama Dili'; // bu satır hataya sebep olur { let tur; tur = 'Web Geliştirme'; let tur = 'Betik Dili'; // bu satır hataya sebep olur } Fakat farklı kapsamlarda aynı değişken ismini `**let**` ile deklare edip birbirinden farklı bellek birimi olarak kullanabilirsiniz. Her kapsam kendi bloğunda deklare edilen değişkenin değerini esas alır. Deneyiniz. Copy let isim = 'Script'; { let isim = 'Java'; alert(isim); // İlk bu satır çalışır. Alt kapsam için isim: 'Java' } alert(isim); // Sonra bu satır çalışır. Üst kapsam için isim: 'Script' Yukarıdaki örnekte farklı kapsamlarda fakat aynı isimde olan değişkenler, bellekte farklı birimlerde yer alır. Dolayısıyla her kapsam kendine ait olan değişkenin bellekteki değerini referans alır. Tek bildirimde birden fazla değişken bildirebilirsiniz. Bildirirken değerlerini de atayabilirsiniz. Örnekler: Copy let isim, soyisim; // Sadece bildirdik. let dogumYeri = 'Malatya', // bildirirken değer atadık. yas = 38, // Bildirirken değer atadık. kilo = 90, // Bildirirken değer atadık. boy = 180; // Bildirirken değer atadık. [PreviousDeğişkenler (Variables)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables) [Nextvar ile Değişken Deklare Etme - Eski Yöntemchevron-right](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/var-ile-degisken-deklare-etme-eski-yontem) Last updated 2 years ago --- # Fonksiyon Kapsam | JavaScript Eğitimi Fonksiyon kapsamlar da aynı blok kapsamlar gibidir. Bir üst kapsamındaki değişkenler alt kapsamda geçerlidir. Fakat alt kapsamda yeniden deklare edilirse farklı bir bellek birimi olarak yerel değişken haline gelir. Programlamada sık kullanılan fonksiyonlar erişim, güvenlik, performans vb. açılardan önemlidir. Fonksiyonları ileri konularda göreceğiz. Kısa bir örnek verelim. Copy let degisken = 'Global Değişken'; function fonksiyon1 () { alert('Fonksiyon-1 Kapsamı'); // Fonksiyon kapsamında aynı değişkeni deklare etmedik. alert(degisken); } fonksiyon1(); // fonksiyon1'i çalıştırdık. function fonksiyon2 () { alert('Fonksiyon-2 Kapsamı'); let degisken = 'Fonksiyon-2 Yerel Değişkeni'; //aynı değişkeni deklare ettik alert(degisken); } fonksiyon2(); // fonksiyon2'yi çalıştırdık. [PreviousBlok Kapsamchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/blok-kapsam) [NextDeklare Edilmeden Kullanılan Değişkenlerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/deklare-edilmeden-kullanilan-degiskenler) Last updated 2 years ago --- # Değişken İsimlendirme Kuralları ve Gelenekler | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/degisken-isimlendirme-kurallari-ve-gelenekler#degisken-isimlendirme-kurallari) Değişken İsimlendirme Kuralları ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Javascript'te bir değişkeni isimlendirirken sadece harfler (ingilizce karakterler) ve rakamlar ile '$' ve '\_' sembollerini kullanabilirsiniz. Fakat **değişken isminin ilk karakteri rakam ile başlayamaz.** Örnekler Copy //Doğru Örnekler let isim = 'Javascript'; let kisi1 = 'Öğrenci'; let yeniKullanici = 'FullStack'; let kullanici_turu = 'Çaylak'; let $ = 1985; let _ = 35.5; //Yanlış Örnekler let İSİM = 'Javascript'; //Türkçe karakter kullanılmaz. let 2kisi = 'Öğrenci'; // İlk karakter rakam olamaz. let yeni Kullanici = 'FullStack'; // '$' ve '_' hariç semboller kullanılamaz. let Kullanıcı-Türü = 'Çaylak'; // Türkçe karakter ve sembol hatası. Javascript'te değişken isimleri büyük-küçük karakter duyarlıdır. Yani '`kullanici`' değişkeni ile '`Kullanici`' değişkeni birbirinden farklı değişkenler olarak değerlendirilir. Aynı değişken değillerdir. Deneyiniz. Copy let adres = 'İstanbul'; let Adres = 'Ankara'; alert(adres); alert(Adres); Değişkenler değerlerini başka değişkenlerden alabilirler. Deneyiniz. Copy let kullanici1 = 'yönetici', kullanici2 = 'editör', kullanici3 = 'okuyucu'; let gecerliKullanici = kullanici2; alert(gecerliKullanici); // veya başka bir örnek let sayi1 = 5, sayi2 = 10, sayi3 = sayi1 + sayi2; alert(sayi3); [hashtag](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/degisken-isimlendirme-kurallari-ve-gelenekler#degisken-isimlendirme-gelenekleri) Değişken İsimlendirme Gelenekleri ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Programcılar değişkenleri isimlendirirken okunurluğu artırmak için bazı geleneklere uyarlar. Bunların bazıları şunlardır. 1. **Pascal Tipi (PascalCase):** Değişkenin her kelimesi büyük harfle başlar, diğerleri küçük yazılır. Örnek: `PascalYazimGelenegi = 'Pascal tipi yazım geleneği';` 2. **Deve Tipi (CamelCase):** Değişkenin ilk kelimesi küçük yazılır, diğerleri büyük harfle başlar ve küçük yazılır. Örnek: `deveYazimGelenegi = 'Deve tipi yazım geleneği';` 3. **Yılan Tipi:** Değişkenin her kelimesinin arasına alt tire konur ve küçük yazılır. Sabitler büyük yazılır. Örnek: `yilan_yazim_gelenegi = 'Yılan tipi yazım geleneği';` 4. **Macar Gösterimi:** Değişken isimlendirmeye ilk başta veri tipi kısaltması ile başlanır ondan sonrası Pascal Tipi olarak devam eder. Sabitler büyük yazılır. Örnek: `sMacarGosterimGelenegi = 'Macar gösterimi yazım geleneği';` Bu gelenekler okunurluğu artırmak, detayları kaçırmamak için programcıları tarafından tercih edilen stillerdir. Birini kullanmak zorunluluk olmayıp size uygun bir tarz ile birkaçını kullanarak da kodlayabilirsiniz. İleri konularda '[İyi Yazım Kuralları](https://hanuce.gitbook.io/javascript-egitimi/iyi-bir-yazim-ve-okunurluk-icin) ' olarak bu konunun önemine tekrar değineceğiz. [Previousconst ile Değişken Deklare Etmechevron-left](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/const-ile-degisken-deklare-etme) [NextKapsamlar ve Geçerliliklerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler) Last updated 2 years ago --- # const ile Değişken Deklare Etme | JavaScript Eğitimi `**const**` deklaratif sözcüğü `**let**` ile aynı özelliklere sahiptir. Blok hassasiyeti vardır, aynı kapsamda sadece bir kez bildirilebilir ve bildirilmeden kullanılamaz. Farkı şudur: `**const**` ile bildirdiğiniz bir değişkenin değerini **sonradan değiştiremezsiniz**. Yani **değeri sabittir**. Bu sebeple de bildirirken değerini atamak zorundasınız. Sonradan değer atayamaz veya değerini değiştiremezsiniz. Örnek: Copy const DOGUM_TARIHI = 1923; const ADI = 'TÜRKİYE'; `**const**` kelimesi İngilizce '_constant: sabit, daimi._' kelimesinden gelmektedir. Sonradan değerini değiştirmek veya tekrar deklare etmek hata olarak fırlatılır. Copy const DOGUM_TARIHI; // Değeri atanmadığı için bu satırda hata fırlatır. DOGUM_TARIHI = 1923; // Bu satıra sıra gelmez. // Farklı Örnek const PI_SAYISI = 3.14, E_SAYISI = 2.71828; PI_SAYISI = 3; // Bu satırda hata fırlatır. Değeri sonradan değişemez. const E_SAYISI = 2.71; // Bu satırda da hata fırlatır. Tekrar deklare edilemez. Gelenek olarak `**const**` ile bildirilen değişken isimleri büyük harflerle yazılır. Bu sayede programcı değişkeni sabit olarak deklare ettiğini bilir ve hata fırlatacak kod yazmaz. Büyük harflerle isim verirken okunaklı olması açısından kelimeler arasına alt tire (\_) koymak da bir gelenektir. [Previousvar ile Değişken Deklare Etme - Eski Yöntemchevron-left](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/var-ile-degisken-deklare-etme-eski-yontem) [NextDeğişken İsimlendirme Kuralları ve Geleneklerchevron-right](https://hanuce.gitbook.io/javascript-egitimi/degiskenler-variables/degisken-isimlendirme-kurallari-ve-gelenekler) Last updated 2 years ago --- # Global Kapsam | JavaScript Eğitimi JavaScript'te programın kodlarını yazdığımız ana kapsam '_**Global Kapsam**_'dır. Copy "use strict" ; // global kapsam // kodlar Global kapsamda tanımladığımız değişkenlere **programdaki bütün kapsamlardan erişilebilir.** Bunlara global değişken denir. Global değişkene her kapsamdan erişilebilmesi ve değiştirilebilmesi sorunlar yaratabilir. Bu sebeple güvenlik açısından genelde global kapsamda değişken belirlemekten kaçınılır. Deneyiniz. Copy let globalDegisken = 'Global Değişken'; alert('Şu an Global kapsamdayız.'); alert(globalDegisken); { // Blok Kapsamı alert('Şu an Blok kapsamdayız.'); alert(globalDegisken); } function ornek() { // Fonksiyon Kapsamı alert('Şu an Fonksiyon kapsamındayız.'); alert(globalDegisken); } ornek(); // Fonksiyonu çalışması için çağırdık. circle-info Örnekte gördüğünüz '`**function ornek() { }**` ' kısmını ileride işleyeceğiz. Şimdilik şunu bilmeniz yeterli; fonksiyonlar da süslü parantez içerdikleri için bir kapsam belirtirler. Örneği deneyince sırasıyla tüm uyarıları alırsınız. Yani global kapsamda deklare edilen bir değişkenin programın tüm alt kapsamlarında da geçerli olduğunu gördük. Şu an aklınıza `**let**` sözcüğünün blok hassasiyeti olduğu gelebilir. Neden alt blok kapsamında çalıştığını sorgulayabilirsiniz. Şöyle ki, global değişkeni alt blok kapsamında `**let**` ile **tekrar deklare ederseniz**, deklare ettiğiniz değişken global kapsamdakinden ayrı bir hafıza birimi olarak oluşturulur ve bu birime başvurulur. Global değişkeni **alt kapsamda yeniden deklare etmezseniz globaldeki ismi ve değeri ile doğrudan kullanabilirsiniz.** Deneyiniz. Copy let globalDegisken = 'Global Değişken'; { let globalDegisken = 'Artık Global Olmayan (Yerel) Değişken'; alert(globalDegisken); // 'Yerel' değişken uyarısı alırız. //'globalDeğisken' ile artık sadece yerel olan değişkene erişebiliriz. } [PreviousKapsamlar ve Geçerliliklerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler) [NextBlok Kapsamchevron-right](https://hanuce.gitbook.io/javascript-egitimi/kapsamlar-ve-gecerlilikler/blok-kapsam) Last updated 2 years ago --- # Page 1 | HTML ve CSS Eğitimi [PreviousHTML ve CSS Eğitimichevron-left](https://hanuce.gitbook.io/html-ve-css-egitimi) Last updated 2 years ago --- # Fonksiyon İfadesi | JavaScript Eğitimi Bir değişkene değer olarak fonksiyon atamaya **fonksiyon ifade etme** denir. Bu kullanımda fonksiyon sonuna zorunlu olmadığı halde okunurluğu artırmak için `**;**` konur. Bir değişkene değer olarak fonksiyon tanımlarsak fonksiyon nasıl yürütülecek ? Tabii ki de sonuna `**()**` sembolleri ekleyerek. Örnek. Copy let fonksiyon = function fx() { //kodlar return 'fx fonksiyonu'; }; alert( fonksiyon() ); // fonksiyon kodları stringmiş gibi görünür. İfade edilen (deklare edilen) fonksiyonlara isim vermeye gerek yoktur çünkü **ismi ile çağrılamaz**. İsimsiz bu fonksiyonlara **anonim fonksiyon** denir. Örnek. Copy let anonim = function () { // ismi yok. anonim fonksiyon. return 'Bu anonim bir fonksiyon ifadesidir.'; }; alert( anonim() ); // ifade edilen fonksiyonu yürüttük. Başka bir örnek. Copy let usAl = function (sayi, us) { // ismi yok. anonim fonksiyon. return sayi**us }; alert( usAl(3,4) ); // ifade edilen fonksiyonu yürüttük. Bu şekilde ifade ettiğimiz değişkenin tipi `**function**` olarak görünür. Bir fonksiyonu **ifade etmek** ile **tanımlamak** arasında da bazı farklar vardır. * **Tanımlaman Fonksiyon:** Kapsam yürütülmeden **önce yürütülerek bellekte oluşturulur.** Bu sayede bloktaki herhangi bir yerden fonksiyon ismi ile çağrılabilir. * **İfade Edilen Fonksiyon:** İfade edildiği (deklare edildiği) **satır yürütüldüğünde bellekte oluşturulur.** Bu sebeple satır yürütüldükten sonra değişken adı ile çağrılabilir. Copy alert( fx() ); // çalışır function fx() { //kodlar return 'fx fonksiyon tanımı'; } alert( fx() ); //çalışır Copy alert( foo() ); // hata verir. let foo = function () { //kodlar return 'foo fonksiyon ifadesi'; }; alert( foo() ); //çalışır ![Drawing](https://hanuce.gitbook.io/javascript-egitimi/~gitbook/image?url=https%3A%2F%2F1783608288-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FtkAky55y3oAsmbswePAh%252Fuploads%252F6dJBKX3WFCk92LEpeVTP%252Ffile.excalidraw.svg%3Falt%3Dmedia%26token%3D1bedc73b-4365-4c3d-acad-824857cdd666&width=768&dpr=3&quality=100&sign=e200454b&sv=2) Doğrusal olmayan bir yapıda işlem yapmamızı sağlayan fonksiyonlar çok önemlidir. Hangi kullanımı tercih edeceğiniz genellikle performans ve güvenlik ile ilgili olsa da fonksiyonlar genel olarak tanımlanarak kullanılır. [PreviousGeri Çağırma (Callback)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/geri-cagirma-callback) [NextOk (Arrow) Fonksiyonlarchevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/ok-arrow-fonksiyonlar) Last updated 2 years ago --- # break - continue - label: | JavaScript Eğitimi Standart kullanımda döngüler koşul kontrol edildiğinde `**true**` ise döngüye girer, kod bloklarını döngü bloğunun sonuna kadar yürütür ve tekrar koşulu kontrol eder. Bu böyle devam eder... Fakat sizler kod bloklarının herhangi bir noktasında döngüyü sonlandırmak, kodları atlayarak sonraki tekerrüre geçmek veya daha üst bloktaki döngüyü kontrol etmek isteyebilirsiniz. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/break-continue-label#break-komutu) `break` Komutu ---------------------------------------------------------------------------------------------------------------------- Bu komutu daha önce `**switch - case**` yapısında görmüştük. `**break**` komutu döngü bloklarını sonlandırmak için kullanılabilir. Buna döngüler de dahil. Örnek. Copy for (let i = 0; ; i++) { //normalde sonsuz döngü alert(i); if (i == 2) break; // i=2 olunca döngü kırılır. } Copy let i = 0; while (true) { //normalde sonsuz döngü i++; alert(i); if (i == 3) break; // i=3 olunca döngü kırılır. } `**if**` ile kullanmak şart değildir. Copy for (let i = 0; ; i++) { // normalde sonsuz döngü alert(i); break; alert('Bu uyarılar ekranda görülmeyecek'); alert('Çünkü döngü kırıldı'); } Copy let i = 0; while (true) { //normalde sonsuz döngü i++; alert(i); break; alert('Bu uyarılar ekranda görülmeyecek'); alert('Çünkü döngü kırıldı'); } `**break**` komutu sonsuz döngü yapılarıyla sık kullanılır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/break-continue-label#continue-komutu) `continue` Komutu ---------------------------------------------------------------------------------------------------------------------------- `**continue**` komutu bir döngünün doğrudan bir sonraki döngü adımına (tekerrüre) geçmesini sağlar. `**continue**` komutundan sonraki kodlar yürütülmez bir sonraki döngü adımı (tekerrür) başlar. Örnek. Copy for (let i = 1; i < 4 ; i++) { if (i == 2) continue; // 2.Döngü uyarısı continue sebebiyle alınamaz. alert(`${i}. Döngü`); } Copy for (let i = 1; i < 4 ; i++) { if (i < 3) continue; // 1.Döngü ve 2.Döngü uyarısı alınamaz. alert(`${i}. Döngü`); } Copy let i = 0; while (i < 3) { i++; if (i == 2) continue; alert(`${i}. Döngü`) } Bu komutlar virgül operatörleri ile kullanıldığında yazım hatası verir. Bu sebeple virgül veya koşullu operatör ile kullanılmaz. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/break-continue-label#etiket-label-tanimlayicisi) `:` Etiket (label) Tanımlayıcısı ------------------------------------------------------------------------------------------------------------------------------------------------------ `**break**` ve `**continue**` bulunduğunuz bloğu kontrol eder, peki ya daha üst blokta olan döngüleri alt bloktan nasıl kontrol ederiz. Bunun için `**:**` tanımlayıcısı kullanılır. Örnek. Copy ust_dongu: for (let i = 1; i < 4; i++) { for (let j = 1; j < 4; j++) { alert(`${i}. Döngünün içindeki ${j}. Döngü`); if (j == 3) break ust_dongu; } } // veya etkiketi bir satır yukarı tek başına da koyabilirsiniz. ust_dongu: for (let i = 1; i < 4; i++) { for (let j = 1; j < 4; j++) { if (i == 2) break ust_dongu; alert(`${i}. Döngünün içindeki ${j}. Döngü`); } } `**while**` döngüsü ile de kullanılabilir. Örnek. Copy let i = 0, j = 0; ust_dongu: while (i < 4) { i++; while (j < 4) { j++; alert(`${i}. Döngünün içindeki ${j}. Döngü`); if (j == 3) break ust_dongu; } } Aynı tanımlamalar `**continue**` ile de yapılabilir. Bu durumda sonraki döngü (tekerrür) için geçeceği yeri belirtmiş oluruz. Örnek. Copy ust_dongu: for (let i = 1; i < 4; i++) { for (let j = 1; j < 4; j++) { if (j == 2) continue ust_dongu; alert(`${i}. Döngünün içindeki ${j}. Döngü`); } } Farklı örnek olarak. Copy ust_dongu: for (let i = 1; i < 4; i++) { for (let j = 1; j < 4; j++) { alert(`${i}. Döngünün içindeki ${j}. Döngü`); if ( confirm('Döngüyü bitirmek istiyor musunuz?') ) break ust_dongu; } } Etiket tanımlayıcıları `**break**` ve `**continue**` komutları ile birlikte **döngüler** için kullanılabilirler. [Previouswhile - do while Döngüsüchevron-left](https://hanuce.gitbook.io/javascript-egitimi/donguler/while-do-while-dongusu) [NextFonksiyonlar (Temel)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel) Last updated 2 years ago --- # Değer Döndüren Fonksiyonlar | JavaScript Eğitimi Bir fonksiyon **sonunda** `**return**` ifadesi ile o fonksiyondan dışarı gönderilecek değer ifade edilir. Örnek. Copy function foo () { let mesaj = 'Merhaba Fonksiyon'; return mesaj; } alert( foo() ); // 'Merhaba Fonksiyon' çıktısı verir. `**return**` ifadesi sayesinde bir değişkenin değerini fonksiyon ile atayabiliriz. Örnek. Copy function kareleriTopla (a, b) { let sonuc; sonuc = a**2 + b**2; return sonuc; } let islem = kareleriTopla (12, 15); // fonksiyonun return ettiği değer oldu alert(islem); Copy // veya daha temiz ifade ile function kareleriTopla (a, b) { return a**2 + b**2; } let sonuc = kareleriTopla (12, 15); alert(sonuc); `**return**` ifadesinin temel işlevi fonksiyon bloktan çıkıştır, bitiştir. `**return**` ile değer döndürmek zorunlu değildir. Çıkış olarak da kullanılabilir. Örnekler. Copy function islemOnay () { if ( !confirm('İşleme Devam Edilecek Onaylıyor Musunuz?') ){ alert('İşlem Sonlandırıldı.'); return; //değer döndürmeden çıktık. } alert('İşleme devam ediliyor...'); return; } islemOnay(); Copy function incToCM(uzunluk) { return uzunluk /= 0.393; } alert( incToCM( prompt('İnç uzunluk değeri giriniz.',0)) ); Copy function aralikToplama(min,max) { alert(`${min} sayısından ${max} sayısına kadar olan sayılar toplanacak!`); let sonuc = 0; for (let i = Number(min); i < Number(max) + 1; i++) { sonuc += i; } return sonuc; } alert( aralikToplama( prompt('Başlangıç Sayısı',0), prompt('Bitiş Sayısı',0)) ); Copy function faktoriyel(n) { let sonuc = 1; for (let i = Number(n); i > 1; i--) { sonuc *= i; } return sonuc; } alert( faktoriyel( prompt('Faktöriyeli alınacak sayıyı giriniz.',0)) ); Bir fonksiyon genellikle karmaşık olmayan tek bir görevi yerine getirir. Uzun ve karmaşık görevler için fonksiyonları parçalamanız önerilir. circle-exclamation **Bir Fonksiyon = Bir Görev** Fonksiyon isimleri fonksiyonun görevini tanımlayan şekilde seçilmelidir. Copy function asalKontrol(sayi) { for (let i = 2; i < sayi) { if (sayi % i === 0) return 'Asal Değil'; } return 'Asal'; } alert( asalKontrol( prompt('Asallığı test edilecek sayıyı giriniz',0)) ); Fonksiyonu **çağırdığımızda** yürütülmesini sağlayan kritik sembol `**()**` parantezleridir. Peki bir fonksiyon ismini `**()**` ile çağırmadan kullanırsak? Deneyelim. Copy alert(foo); function foo() { //kodlar return 'foo fonksiyonu'; } Fonksiyonu oluşturan ifadeleri `_**string**_`'miş gibi ekrana basar. Yani **fonksiyonun ismi bir değişken ismi ve** **değeri de fonksiyonu oluşturan kodların** `**string**` **ifadesidir**. Bu şu anlama gelmektedir: circle-exclamation Fonksiyon tanımlarken kullandığınız ismi `**let**` ile değişken olarak deklare edemezsiniz, hata verir. `**var**` ile de deklare etmemeye de dikkat ediniz. Bu uyarıyı test edelim. Copy alert(foo); function foo() { //kodlar return 'foo fonksiyonu'; } let foo = 'Bir değişken'; //bu satırda hata verir. aşağıdaki uyarı çalışmaz. alert (foo); Copy alert(foo); function foo() { //kodlar return 'foo fonksiyonu'; } var foo = 'Artık bir fonksiyon değil'; alert(foo); //fonksiyonun üzerine yazdık.fonksiyon diye birşey kalmadı :) `**()**` olmadan da kullanabilme sayesinde bir fonksiyonu başka bir fonksiyona argüman yaparak **geri çağırabilir** veya bir değişkene değer olarak atayarak **ifade edebiliriz**. [PreviousParametreli Fonksiyonlarchevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/parametreli-fonksiyonlar) [NextGeri Çağırma (Callback)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/geri-cagirma-callback) Last updated 2 years ago --- # for Döngüsü | JavaScript Eğitimi İşlemlerin _**belirli bir sayıda**_ yinelendiği döngüdür. Bu döngü türünde bir sayaç olur ve bu sayacın _**başlama pozisyonu, bitiş pozisyonu ve artış/azalış miktarı**_ döngünün başında belirtilir. Kullanım: Copy for (baslamaPozisyonu; bitisPozisyonu; artisAzalisMiktari) { //döngü kod bloğu } Örnek olarak: Copy for (let i = 0; i < 5; i += 1) { alert(i); } `**for**` döngüsünde sayaç olarak daha önce bildirilmiş bir değişkeni kullanabiliriz. Copy let i; for (i = 0; i < 5; i += 1) { alert(i); } `**for**` döngüsünde sayaç başlama pozisyonunda da bildirilebilir. Diğerinden farkı değişkenin bellekte tutulma süresidir. Önceden bildirirseniz o kapsam süresince, `**for**` döngüsü başında bildirirseniz döngü bitene kadar bellekte yer kaplar. Copy for (let i = 0; i < 5; i += 1) { alert(i); } `**for**` döngüsünde sayaca ait bitiş pozisyonu `**true**` olursa döngü devam eder, `**false**` olursa döngüden çıkılır. Copy // bitiş pozisyonu ilk kullanımda true bir sonrakinde false, tek sefer döner. for (let i = 0; i == 0; i++) { alert('Merhaba'); } //i değişkeninin ömrü bitti bellekten kaldırıldı. Bu yapı sebebiyle genellikle `**<**` veya `**>**` ile bitiş pozisyonu verilir. `**==**` veya `**===**` ile verilen bitiş pozisyonları `**for**` döngüsü için mantıksız bir kullanımdır. Sonsuz döngü ve hiç dönmeyen bir döngü için şunu deneyebilirsiniz. Örnekler. Copy //Sonsuz Döngü for (let i = 0; true; i++) { alert(i); } //veya sayacın bitiş pozisyonunu hep true olacak şekilde ayarlayın for (let i = 0; i > -1; i++) { alert(i); } Copy //Hiç Dönmeyen Döngü for (let i = 0; false; i++) { alert(i); } //veya sayacın bitiş pozisyonunu ilk döngüde false olacak şekilde ayarlayın for (let i = 0; i == 2; i++) { alert(i); } //hiç döngüye girilmeden çıkıldı. i değişkeninin ömrü bitti kaldırıldı. `**for**` döngüsünde sayacın artış/azalış miktarı hep artış olma zorunluluğu yoktur. Azalış miktarı olacak şekilde de verilebilir. Örnek. Copy for (let i = 5; i > 0; i--) { alert(i); } `**for**` döngüsünde sayacın artış/azalış miktarı azalış olarak da verilebilir. Örnek. Copy for (let i = 5; i > 0; i--) { alert(i); } Arış/Azalış miktarı ifadesini sayacın başlama pozisyonundan bitiş pozisyonuna götürecek bir mantıkla ifade etmeniz gerekir. Aksi takdirde sonsuz döngü oluşturmuş olursunuz. `**for**` döngüsünde `**let**` ile deklare ettiğiniz değişken blok bittikten sonra bellekten kaldırıldığı için sonrasında tekrar deklare ederseniz herhangi bir hata almazsınız. Örnek. Copy for (let i = 5; i > 0; i -= 2) { alert(i); } let i = 'sayaç'; alert(i); Döngüler iç içe (nested) olarak da kullanılabilir. Örnek. Copy for (let i = 1; i < 4; i++) { for (let j = 1; j < 4; j++) { alert(`${i}. Döngünün içindeki ${j}. Döngü`); } } [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/for-dongusu#bazi-bolumleri-pas-gecme) Bazı Bölümleri Pas Geçme ----------------------------------------------------------------------------------------------------------------------------------- Sayaç olarak kullanılacak değişken daha önceden bildirilmiş ve değer atanmış ise bu kısım pas geçilebilir. Copy let i = 0; for ( ; i < 3; i++) { alert(i); } Aynı şekilde eğer artış/azalış miktarını döngü içinde duruma göre değiştirmek istiyorsanız bu kısmı da pas geçebilirsiniz. Fakat döngü içerisinde sayacı manipüle etmezseniz sonsuz bir döngü elde edersiniz. Örnek. Copy for (let i = 0; i <= 10; ) { alert(i); i += 5; } Bitiş pozisyonunu da pas geçebilirsiniz. Bu şekilde sürekli `**true**` ile sonsuz bir döngü elde edersiniz. Örnek. Copy for (let i = 0; ; i += 5) { alert(i); } Hepsini pas geçerek sayaçsız ve sonsuz bir döngü elde edebilirsiniz. Copy for (;;) { alert('Sonsuz döngü'); } Eğer `**for**` bloklarında tek satırlık kod yazacaksanız blok açmadan aynı satırda da yazabilirsiniz. Örnek. Copy for (let i = 0; i < 3; i++) alert(i); [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/for-dongusu#stringin-for-ile-yinelenmesi) `String`'in `for` ile Yinelenmesi ------------------------------------------------------------------------------------------------------------------------------------------------ `**String**` tipinin sıralanmış elemanlardan oluşması yinelenebilir bir yapı sunmaktadır. Döngülenebilir yapılar `**for**` deyiminin farklı şekilleriyle kullanılır. `**for ... of**` yinelemesi ile `**string**`'ler şu şekilde kullanılır. Örnek. Copy let str = 'Tekerrür'; for (let karakter of str) { alert(karakter); } `**String**`'ler ilkel (değer) tipler olduğu için **stack** bölümünde tutulurlar ve bu bölümdeki verilerin boyutu belirlidir. Bu sebeple bir parçası değiştirilemez, yani immutable'dir. Copy let str = 'Tekerrür'; for (let karakter of str) { if (karakter == 'k') { alert(karakter); // k harfi çıkar. karakter = 'ş'; // immutable, değiştirilemez. alert(str); // Tekerrür } } [PreviousDöngülerchevron-left](https://hanuce.gitbook.io/javascript-egitimi/donguler) [Nextwhile - do while Döngüsüchevron-right](https://hanuce.gitbook.io/javascript-egitimi/donguler/while-do-while-dongusu) Last updated 2 years ago --- # Geri Çağırma (Callback) | JavaScript Eğitimi Fonksiyonlar parantezi olmadan argüman olarak veya başka bir fonksiyon içinde kullanarak yürütülebilir. Buna **callback (geri çağırma)** denir. Örnek. Copy function sonucGoster(sonuc) { //bu fonksiyonu argüman yaparak geri çağıracağız. return alert(sonuc); } function topla(sayi1,sayi2,birFonksiyon) { let toplam = sayi1 + sayi2; birFonksiyon(toplam); //callback: geri çağırma } topla(20,20,sonucGoster); //geri çağrım için argüman verdik. Normalde sırayla (satır satır) yürütülen program akışında sırada olmayan bir kod birimini geri çağırma sayesinde yürütebiliyoruz. Copy function isimAl() { // bu fonksiyon geri çağrılacak. let isim = prompt('Kullanıcı Adınızı Giriniz','Kullanıcı'); return isim; } function fonk(foo) { let user = foo(); //callback: geri çağırma return alert(`Giriş Başarılı: ${user}`) } fonk(isimAl); // geri çağrılacak fonksiyon argüman olarak verildi. Fonksiyonların geri çağrılarak kodun akışında doğrusal olmayan başvurular yapması kıymetlidir. Örnek: Copy function fx() { return console.log(`F(x) fonksiyonu`); } function fy(p1) { p1(); // akışta sırada olmayan bir kod bloğunu çalıştırdık return console.log(`F(y) fonksiyonu`); } fy(fx); [PreviousDeğer Döndüren Fonksiyonlarchevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/deger-donduren-fonksiyonlar) [NextFonksiyon İfadesichevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/fonksiyon-ifadesi) Last updated 2 years ago --- # Set - Küme Nesnesi | JavaScript Eğitimi [PreviousMap - Eşlem Nesnesichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/koleksiyonlar-map-set/map-eslem-nesnesi) [NextSemboller (Symbol)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/semboller-symbol) Last updated 2 years ago --- # Parametreli Fonksiyonlar | JavaScript Eğitimi **Parametre**; fonksiyon **tanımlanırken** girdi olarak **alınan** öğelerdir. **Argüman**; fonksiyon **çağrılırken gönderilen** öğelerdir. Argüman olarak verilen öğenin kendisi işleme alınmaz, değerinin bir kopyası işleme alınır. Parametreli bir fonksiyon **tanımlayalım** ve argüman vererek fonksiyonu **çağıralım**. Örnek. Copy let ders = 'Argüman'; function parametreGoster(para1) { //'para1' bir parametredir. alert(para1); //para1'in değeri gönderilen argümanın değeridir. para1 = 'Parametre'; alert(para1); //parametrenin değeri değişir. } parametreGoster(ders); // 'ders' değişkenini fonksiyona argüman yaptık. alert(ders); //gönderilen argümanın esas değeri işlemlerden etkilenmez. Argüman olarak gönderilen öğenin bir kopyası fonksiyon içinde kullanılır bu sebeple üst kapsamdaki öğenin değeri değişmez. Parametreler için varsayılan değerler verilebilir. Örnek. Copy let arg1, arg2; // değeri undefined olan iki değişken parametreGoster(arg1, arg2); // arg1 = kapsam, arg2 = ders function parametreGoster(kapsam = 'Yerel Kapsam: ', ders = 'Fonksiyonlar') { alert(kapsam + ders); } Argümanlar gönderildikleri sıra ile parametrelerle eşleştirilirler. Bu sebeple argümanları parametrelere **uygun sırada vermeye dikkat ediniz.** Örnek. Copy let arg1 = 'Global Kapsam: ', arg2 = 'Parametreler '; parametreGoster(arg2, arg1); // arg2 = kapsam, arg1 = ders function parametreGoster(kapsam = 'Yerel Kapsam: ', ders = 'Fonksiyonlar') { alert(kapsam + ders); } Parametre ile tanımlanan bir fonksiyona argüman göndermezsek ne olur? Deneyelim. Copy degistir(); // argümansız çağırdık. function parametreGoster(para1, para2) { alert(para1 + ' ' + para2); } Yine çalışır. Bizler şimdiye kadar birçok çıktıyı elde etmek için fonksiyon içinde `**alert();**` kullandık. Peki bir fonksiyonu `**alert();**` fonksiyonuna argüman olarak göndersek ? Deneyelim. Copy function foo () { let mesaj = 'Fonksiyon'; } alert( foo() ); //undefined çıktısı verir. Sonuç `**undefined**` olduğuna göre demek ki fonksiyonlar bir değer döndürebilir. Fonksiyon bitiminde `**return**` ifadesi ile bu değeri kontrol edebiliriz. [PreviousFonksiyonlar (Temel)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel) [NextDeğer Döndüren Fonksiyonlarchevron-right](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/deger-donduren-fonksiyonlar) Last updated 2 years ago --- # Koleksiyonlar (Map, Set) | JavaScript Eğitimi * `**Map**` **- Eşlem Nesnesi** * **Anahtarları (key)** herhangi bir veri tipinde olabilen **sıralanmış** '**anahtar:değer**' ikililerinden oluşan _**veri türüdür.**_ Süslü parantezler arasında ( `**{ }**` ) yazılırlar. Döngülenebilirler. * `**Set**` **- Küme Nesnesi** * **Eşsiz değerlerden (value)** oluşan, **sıralanmış** '**anahtar:değer**' ikililerinden oluşan _**veri türüdür.**_ Süslü parantezler arasında ( `**{ }**` ) yazılırlar. Hiçbir **değer (value)** birbiriyle aynı değildir, tekildir. [Previousnew Yapıcı Operatörüchevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/new-yapici-operatoru) [NextMap - Eşlem Nesnesichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/koleksiyonlar-map-set/map-eslem-nesnesi) Last updated 2 years ago --- # Object - Nesne | JavaScript Eğitimi `**Object**` veri tipinin bölümleri: ![Drawing](https://hanuce.gitbook.io/javascript-egitimi/~gitbook/image?url=https%3A%2F%2F1783608288-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FtkAky55y3oAsmbswePAh%252Fuploads%252FkujxI5oIBcXhML9rvHqN%252Ffile.excalidraw.svg%3Falt%3Dmedia%26token%3D23c3d25b-5faa-4ebd-9f0f-1bbb1242af45&width=768&dpr=3&quality=100&sign=ac55ffa7&sv=2) `**Object**` 'ler süslü parantezler (`**{}**`) ile oluşturulurlar. Her obje "_**anahtar:değer**_" ikililerinden oluşur. `**Object**` türünde **anahtarlar sadece** `**string**` **tipinde** olabilirler. `**Object**`'lerin anahtarları özellik (property) veya nitelik (attribute) olarak da ifade edilmektedirler. Bir nesne oluşturalım. Copy let ogrenci = { //nesne adı 'ogrenci' no:2301, // anahtar adı 'no' değeri 2301 isim:'Asya', // anahtar adı 'isim' değeri 'Asya' soyisim:'KARA', // anahtar adı 'soyIsim' değeri 'KARA' sinif:7, // anahtar adı 'sinif' değeri 7 }; alert(ogrenci); //çıktı: [object Object] alert( typeof(ogrenci) ); // object circle-info `**Object**` türünde anahtarlar isimlendirilirken değişken isimlendirme kurallarında olduğu gibi dikkat edilir. Farklı olarak dile ait deyimler (let, const, if, for ... vb.) de anahtar olarak kullanılabilir. Hata vermez. Örnek. Copy let deyimler = { if:'if Deyimi', for:'for Deyimi', let:'let Deyimi', var:'var Deyimi', }; `**ogrenci**` nesnesi bir adres hiyerarşisini referans ettiği için `**alert(ogrenci);**` ile doğrudan değerlere erişilemez. Değerlere anahtarları üzerinden erişilebilir. Örnek. Copy alert(ogrenci.no); alert(ogrenci.isim); alert(ogrenci.soyisim); alert(ogrenci.sinif); Bu erişim köşeli parantez `**[]**` kullanılarak da yapılabilir. Örnek. Copy alert( ogrenci['no'] ); alert( ogrenci['isim'] ); alert( ogrenci['soyisim'] ); alert( ogrenci['sinif'] ); **Köşeli parantez kullanımı güçlüdür.** Değişkenler veya değerler ile erişmeye olanak sağlar. Örnek. Copy let ozellik = prompt('Göstermek istediğiniz özelliği giriniz',0); alert( ogrenci[ozellik] ); //veya alert( ogrenci['sinif'] ); // şeklinde de kullanılabilir Yukarıdaki örneğe bakarak "_**Öğrenci nesnesinin 4 özelliği vardır.**_" ifadesini kullanabiliriz. Nesnelerin anahtarları genellikle **özellik** olarak ifade edilir. Bir özelliği sabit bir `**string**` yerine değişken ile belirlemek istiyorsanız yine köşeli parantezler kullanmalısınız. Anahtar isminde köşeli parantez kullanınca yazdığınız ifade değerlendirilir. Buna '**Hesaplanmış Özellik**' denir. Örnek. Copy let ozellik = prompt('Eklemek istediğiniz özelliği giriniz',0); let deger = prompt('Eklemek istediğiniz değeri giriniz',0); let ogrenci = { no:2023, isim:'Asya', [ozellik]:deger }; alert( `${ozellik} : ${ogrenci[ozellik]}` ); Hesaplanmış özelliklerde `**string**` operatörler de kullanabilirsiniz. Örnek. Copy let ozellik = prompt('Eklemek istediğiniz özelliği giriniz',0); let deger = prompt('Eklemek istediğiniz değeri giriniz',0); let ogrenci = { no:2023, isim:'Asya', ['yeniOzellik_' + ozellik]:deger }; alert( `${'yeniOzellik_' + ozellik} : ${ogrenci['yeniOzellik_' + ozellik]}` ); Bir nesneye sonradan yeni özellikler eklenebilir veya var olan özellikler `**delete**` deyimi ile silinebilir. Örnek. Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, }; ogrenci.sube = 'A'; // sube özelliği ekledik ve değerini 'A' atadık. alert(ogrenci.sube); delete ogrenci.sinif; // sinif özellğini sildik. alert(ogrenci.sinif); // undefined çıktısı verir. Özellik eklemeyi köşeli parantezle de yapılabilirsiniz. Örnek. Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, }; ogrenci['sube'] = 'A'; // sube özellği ekledik ve değerini 'A' atadık. alert(ogrenci.sube); Nesneleri boş olarak oluşturup sonrasında anahtar (özellik) ekleyebilirsiniz. Örnek. Copy let nesne = {}; nesne.key1 = 'Özellik-1'; nesne.key2 = 'Özellik-2'; alert(nesne.key1); Nesnelerdeki anahtarların değerleri başka bir nesne olabilir. Örnek. Copy let nesneler = { nesne1:{ d1:'Nesne-1 Özellik-1', d2:'Nesne-1 Özellik-2' }, nesne2:{ d1:'Nesne-2 Özellik-1', d2:'Nesne-2 Özellik-2' }, }; alert(nesneler.nesne1); // [object Object] çıktısı alınır. alert(nesneler.nesne1.d1); // 'Nesne-1 Özellik-1' çıktısı alınır. [PreviousArray Metotlarchevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/array-metotlar) [NextObject.assign() ile Nesne Birleştirme ve Klonlamachevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/object.assign-ile-nesne-birlestirme-ve-klonlama) Last updated 2 years ago --- # Ok (Arrow) Fonksiyonlar | JavaScript Eğitimi **Anonim fonksiyonlar** ok fonksiyon şeklinde daha veciz, okunaklı ve **ilkel** bir şekilde ifade edilebilirler. Örnek. Copy //anonim fonksiyon ifadesi let uzunca = function () { return alert('Uzunca ifade edilmiş fonksiyon'); }; //ok fonksiyonlar ile ifade etme let veciz = () => alert('Veciz ifade edilmiş fonksiyon'); uzunca(); veciz(); Ok fonksiyonlara parametre de gönderebilirsiniz. Tek parametre gönderirseniz parantez kullanımına gerek de olmaz. Örnek. Copy let kareAl = n => n**2; let usAl = (a,n) => a**n; alert( kareAl(15) ); alert( usAl(15,3) ); Bu örnekler tek satırlı ok fonksiyonlar için örnekti. Eğer çok satırlı yazmak gerekirse yine süslü parantezler (`**{}**`) içerisinde kodlarınızı yazmalı ve sonucu döndürmek için `**return**` kullanmalısınız. Örnek. Copy let hipotenusBul = (a,b) => { let c; c = (a*a + b*b); // kareleri topla c = Math.sqrt(c); // kareköküne eşitle return c; }; alert( hipotenusBul(6,8) ); alert( hipotenusBul(5,12) ); veya daha veciz olarak: Koşullu operatör ile bir örneğini deneyelim. [PreviousFonksiyon İfadesichevron-left](https://hanuce.gitbook.io/javascript-egitimi/fonksiyonlar-temel/fonksiyon-ifadesi) [NextReferans (Reference) Veri Tiplerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri) Last updated 2 years ago sun-brightdesktopmoon Copy let hipotenusBul = (a,b) => Math.sqrt(a*a + b*b); alert( hipotenusBul(6,8) ); alert( hipotenusBul(5,12) ); Copy let tcNO = prompt("TC Numaranınızı Giriniz", 0); let tcKontrol = (tcNO.length == 11) ? () => alert('TC No basamak sayısı DOĞRU!') : () => alert("TC No basamak sayısı YANLIŞ!!"); tcKontrol(); sun-brightdesktopmoon --- # new Yapıcı Operatörü | JavaScript Eğitimi Bizler şu ana kadar değişkenleri özüne uygun (literal) bir şekilde oluşturduk. Yani: Copy let str = "Karakter", sayi = 123; alert( typeof(str) ); //string alert( typeof(sayi) ); //number Değişkenleri, tipinin özellik ve metotlarına sahip bir '_nesne_' olarak oluşturmak da mümkün. Bunu yapıcı bir fonksiyon olan `**new**` operatörü ile yaparız. Deneyelim. Copy let str = new String("new Operatörü"); // yeni bir 'String Nesnesi' alert(str); // Aynı string gibi ekrana basıldı. alert( str[1] ); // Aynı string gibi 'e' çıktısı verdi alert( str.slice(0,3) ); //// Aynı string gibi 'new' çıktısı verdi `**new**` operatörü ile oluşturulan tüm _numuneler_ `**object**` tipinde olur. Copy let str = new String("new Operatörü"); alert( typeof(str) ); // string değil 'object' Normalde ilkel tipler doğrudan değeri tutarlar fakat `**new**` ile deklare edilen değişkenler aksi yapılmamışsa belleğin [heap](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri) bölümünde referans (adres) tutarlar. `**new**` operatörüyle oluşturulan _numune_, örneklendirilen öğenin (`**string**`, `**number**`, vs.) boş bir modelinden (_**prototip**_) oluşturulur. Bu sebeple numuneler, örneklendirilen öğenin referansını tutmaz, heap bölümünde kendine ait bir referansı olur. Yani: Copy let str = new String("new Operatörü"); let str2 = str // veya 'new String(str);' olarak da deneyebilirsiniz. alert(str2); // 'new Operatörü' çıktısı str = 'Yeni değer'; alert(str2); // yine 'new Operatörü' çıktısı alınır. //str'nin değerinin değişmesinden etkilenmedi. Bağımısz bir kopya `**Object.assign()**` ile bir nesneden yeni bir nesne oluşturmak istediğimizde yaptığımız gibi fakat daha veciz bir şekilde. Örnek. Copy let isci = { tcNo:12345678900, isim:'Çetin KAYA', }; // Object.assign() ile boş bir örnekten (prototip) değil kendisinden bir kopya let yeniIsci = Object.assign( {}, isci ); alert(yeniIsci.tcNo); // oluşturulduğu nesne ile aynı değerlere sahip, boş değil. Bir _numune_ oluşturmak için bu işlemi `**new**` operatörü ile yapalım. Fakat öncesinde `**isci**` öğesini bir fonksiyon halinde yapılandıralım. Copy // isci öğesini bir fonksiyon haline getirerek yapılandıralım. function Isci(tcNo,isim) { this.tcNo = tcNo; this.isim = isim; this.kendiniTanit = function() { return alert(`TCNO: ${this.tcNo}, İSİM: ${this.isim}`); } } // new operatörü ile prototipten kopyalar yapalım let isci1 = new Isci('12345','Ahmet'); // her bir isci prototipten oluşur. let isci2 = new Isci('54321','Mehmet'); // her bir isci prototipten oluşur. isci1.kendiniTanit(); isci2.kendiniTanit(); alert( typeof(isci1) ); //tipi 'object' `**new**` operatörü ile oluşturulan _numunelerde_ oluşturulduğu öğenin ( `**string**`, `**number**`, `**function**` vb. ) tüm özellik ve metotları bulunur. circle-info Kendisinden `**new**` operatörü ile _numuneler_ üretilecek fonksiyon isimlerinin ilk harfi büyük yazılır. Bu prototipler için bir gelenektir, zorunluluk değil. Öğelerin bir prototipi (tüm özelliklerine haiz boş hali) vardır. Peki bir öğenin tüm _numunelerine_ sonradan bir özellik eklemek istersek ? Bunun için öğenin `**prototype**`'ini kullanacağız. Önceki koddan devam edersek. Copy isci1.kidem = '10'; // yeni özellik ekledik. alert(isci1.kidem); //10 çıktısı verir. alert(isci2.kidem); // 'undefined' çıktısı verir çünkü isci2 nesnesine eklemedik. // tüm isci örneklerine yeni bir özelliği prototip olarak ekleyelim. Isci.prototype.kidem = '0'; // tüm örnekler için varsayılan değer 0 atadık. alert(isci2.kidem); // 0 çıktısı verir. let isci3 = new Isci('98775', 'Veli'); alert(isci3.kidem); // 0 çıktısı verir. Bazı öğeler (sınıf, nesne veya fonksiyon) özüne uygun (literal) bir şekilde oluşturulabileceği gibi `**new**` operatörü ile de oluşturulabilir. Bunlar: * `**new Array()**` * `**new Object()**` * `**new String()**` * `**new Number()**` * `**new BigInt()**` * `**new Boolean()**` * `**new Function()**` Fakat bazı öğeleri oluşturmanın doğrudan bir yöntemi (literal) yoktur. Bunları sadece `**new**` operatörü ile oluşturabiliriz. Örnek: * `**new Map()**` * `**new Set()**` * `**new Symbol()**` * `**new Error()**` [Previousconst ile Nesne Deklare Etmechevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/const-ile-nesne-deklare-etme) [NextKoleksiyonlar (Map, Set)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/koleksiyonlar-map-set) Last updated 2 years ago --- # while - do while Döngüsü | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/while-do-while-dongusu#while-dongusu) `while` Döngüsü -------------------------------------------------------------------------------------------------------------------------- İşlemlerin _**belirli bir koşulun**_ `_**true**_` _**olduğu sürece**_ yinelendiği döngüdür. Bu döngü türünde belirli bir koşul olur ve koşulun geçerli olduğu sürece döner. Koşulun geçerli olmadığı durumda döngü başlamaz, biter. Kullanım. Copy while (kosul) { //döngü kod bloğu } //kodlar... `**while**` döngüsünde koşul `**true**` veya `**false**` olarak değer alır. Yani yapı şöyledir. Copy while (true) { // döngüye girilir ve tekrar buraya gelinir. //döngü kod bloğu } // kodlar... Copy while (false) { // döngüye girilmez. Çıkıştan devam eder. //döngü kod bloğu } //kodlar... Örnek olarak. Copy let ePosta; //eposta adresi bir değer alana kadar döngü devam eder. while (ePosta == undefined || ePosta == '') { ePosta = prompt('E-Posta Adresinizi Giriniz.') } Copy let toplam; alert('Toplamı 20 olmayan iki sayı girdiğiniz sürece sürekli uyarı alacaksınız!') while (toplam != '20') { //toplam 20 olmadığı sürece döngü döner. let sayi1 = prompt('1.Sayıyı Giriniz:'), sayi2 = prompt('2.Sayıyı Giriniz:'); toplam = Number(sayi1) + Number(sayi2); //toplamları 20 olan sayılar yazarsanız döngü sonlanır } alert('Döngü Bitti'); Copy let denemeSayisi = 1, pin = '1234'; alert('PIN Kodunu 3 kere deneme hakkınız var.'); while (denemeSayisi <= 3) { let girilenPin = prompt('Pin Kodunu Giriniz: '); if (pin === girilenPin) { denemeSayisi = 5; //3'ten büyük bir değer ile sonraki döngüyü engelledik. } else { denemeSayisi++; } if (denemeSayisi == 4) { //4'ile hakkını sonlandırdık. alert('Deneme hakkınız bitmiştir.') } if (denemeSayisi == 5) { //5 olduysa bilmiştir. DOĞRU uyarısını verelim. alert('DOĞRU. Giriş yapılıyor...') } } Bu döngü türüne elle oluşturulan bir sayaç koşul olarak verilirse sayaçlı döngü gibi çalışır. Fakat genel kanı sayaçsız olarak kullanım üzerinedir. Örnekler. Copy // Genel kullanım let tcNo = prompt('TC Numaraınızı Giriniz: '); while ( tcNo.length != 11) { //tcNo uzunluğu 11 olmadığı sürece döner tcNo = prompt('TC No 11 haneli olmak zorundadır. Tekrar Giriniz: ') } alert('TC NO Uzunluğu doğru!'); Copy // Sayaçlı örnek let i = 1; while (i <= 3) { //i küçük eşit 3 olduğu sürece alert(i); i++; } `**number**` tipinde `**true**` sıfır olmayan (**0**) bir değer, `**false**` ise sıfır (**0**) değeridir. Örnek. Copy let sayi = 5; while (sayi) { //baştan true alert(sayi); sayi--; // 0 olunca false olur. } `**string**` tipinde ise `**true**` boş olmayan herhangi bir değer, `**false**` ise boş ('') olan değerdir. Örnek. Copy let karakterDizisi = ' ', sayac = 1; while (karakterDizisi) { //baştan true if (sayac > 3) { karakterDizisi = ''; // sayac 3'ü geçerse boş değer ile false olur. } else { alert(`While Döngüsü Sayacı: ${sayac}`); } sayac++; } Eğer `**while**` bloklarında tek satırlık kod yazacaksanız blok açmadan aynı satırda da yazabilirsiniz. Örnek. Copy let i = 3; while (i) alert(i--); [hashtag](https://hanuce.gitbook.io/javascript-egitimi/donguler/while-do-while-dongusu#do-while-dongusu) `do while` Döngüsü -------------------------------------------------------------------------------------------------------------------------------- `**do while**` döngüsü ile döngüye ait kod blokları bir kez çalıştırılır ardından koşul kontrol edilir eğer koşul `**true**` ise tekrar başa dönerek döngüye devam eder kodları yeniden çalıştırır, `**false**` ise döngü olarak devam etmez. `**while**` döngüsünden farkı, koşul `**false**` bile olsa kod blokları en az bir sefer yürütülmüş olur. Örnek olarak. Copy let i = 0; do { i++; alert(i); } while(i == 0); // koşul doğru olmasa bile bir kez yürütülmüş olur. Başka bir örnek olarak. Copy let ePosta; // ePosta şu an false //eposta adresi bir değer alana kadar döngü devam eder. do { ePosta = prompt('E-Posta Adresinizi Giriniz.'); } while ( !ePosta ); // ePosta değer girilmezse false, değili (!) true alert(ePosta); Farklı bir örnek olarak. Copy let ePosta; // ePosta şu an false //eposta adresi bir değer ve doğrulaması olana kadar döngü devam eder. do { ePosta = prompt('E-Posta Adresinizi Giriniz.'); // ePosta için değer girilirse true olur boşsa false if ( ePosta && !confirm(`Eposta Adresinizi Onaylayın\n${ePosta}`) ) { ePosta = ''; } } while ( !ePosta ); alert(ePosta); [Previousfor Döngüsüchevron-left](https://hanuce.gitbook.io/javascript-egitimi/donguler/for-dongusu) [Nextbreak - continue - label:chevron-right](https://hanuce.gitbook.io/javascript-egitimi/donguler/break-continue-label) Last updated 2 years ago --- # Array - Dizi | JavaScript Eğitimi Bir `**array**` nesnesi tanımlamak için köşeli parantezler ( `**[]**` ) kullanılır ve her bir değerin (value) arasına virgül ( `**,**` ) konur. Örnek. Copy let gunler = ['Pazartesi','Salı','Çarşamba','Perşembe','Cuma','Cumartesi','Pazar']; alert ( typeof(gunler) ); //object çıktısı verir ve dizi nesnesidir. alert(gunler); `**Array**`'lerin içerisindeki değerler farklı veri tiplerinde olabilir. Doğrudan bir değer yerine bir değişkeni de tutabilirler. Örnek. Copy let str = 'Karakter Dizisi'; let veriTipleri = [str, 2023, true, ['Başka', 1, 'array']]; alert(veriTipleri); `**Array**`'in uzunluğu dizi nesnesinin `**.length**` anahtarı ile dizi uzunluğu ile elde edilir. Copy let gunler = ['Pazartesi','Salı','Çarşamba','Perşembe','Cuma','Cumartesi','Pazar']; alert ( gunler.length ); // 7 çıktısı verir. `**Array**`'deki değerler **tamsayı artan sıralıdır**. **İlk sıra 0. indisten başlar**. `**Array**`'lerin değerlerine sırayla şu şekilde erişilir. Copy let gunler = [\ 'Pazartesi', //0.indis\ 'Salı', //1.indis\ 'Çarşamba', //2.indis\ 'Perşembe', //3.indis\ 'Cuma', //4.indis\ 'Cumartesi', //5.indis\ 'Pazar' //6.indis\ ]; alert( gunler[0] ); // indisi değiştirerek kontrol ediniz. `**.at()**` metodu ile de değerlere erişilebilir. Copy let ulkeler = [\ ['Türkiye', 'Ankara',1923], // 0.indis\ ['KKTC', 'Lefkoşa',1983 ], // 1.indis\ ['Azerbaycan', 'Bakü',1991] // 2.indis\ ]; alert( ulkeler.at(0) ); // indisi değiştirerek kontrol ediniz. `**Array**`'de indisi ile eriştiğimiz bir değeri değiştirebiliriz. Örnek. Copy let dizi = ['Pazartesi', 'Salı', 'Çarşamba']; dizi[0] = 'Ocak'; //0.indisteki elemanı 'Ocak' ile değiştirdik. dizi[1] = 'Şubat'; //1.indisteki elemanı 'Şubat' ile değiştirdik. dizi[2] = 'Mart'; //2.indisteki elemanı 'Mart' ile değiştirdik. alert(dizi); `**Array**` nesnesinin boyutu dinamiktir bu sayede istediğimiz indise değer ekleyebiliriz. Örnek. Copy let dizi = ['Pazartesi', 'Salı', 'Çarşamba']; dizi[4] = 'Cuma'; //4.indise 'Cuma' değerini ekledik. dizi[5] = 'Cumartesi'; //5.indise 'Cumartesi' değerini ekledik. alert(dizi); Yukarıdaki örnekte 3.indisi atladık. Peki 3.indiste ne oluştu? Copy let dizi = ['Pazartesi', 'Salı', 'Çarşamba']; dizi[4] = 'Cuma'; //4.indise 'Cuma' değerini ekledik. dizi[5] = 'Cumartesi'; //5.indise 'Cumartesi' değerini ekledik. alert( dizi[3] ); // undefined çıktısı verir. alert(dizi); //Pazartesi,Salı,Çarşamba,,Cuma,Cumartesi //3.indis mevcuttur, yeri ayrılmıştır. Bu yöntemle değer eklemek için ekleyeceğimiz indisi bilmek gerekir. Aksi takdirde var olan bir değeri değiştirip üzerine yazabilir ve veriyi kaybedebiliriz. Bu sebeple zahmetlidir. Değerlere sırayla erişmeyi `**string**` tipinde de kullanmıştık. Fakat `**string**` tipinde indis ile eriştiğiniz değeri değiştiremez veya silemezsiniz. (İlkel tiplerin hafıza birimlerinin boyutu belirlidir.) Negatif bir indis verirseniz herhangi bir hata vermez fakat diziye de eklenmez. Copy let dizi = ['Pazartesi', 'Salı', 'Çarşamba']; dizi[-1] = 'Perşertesi'; //-1.indes yok, ekleyemez, hata vermez. alert(dizi); `**Array**`'lerden değer silmenin yöntemi `**delete**` komutu değildir. Bu yöntemle değer **silinemez** sadece değeri `**undefined**` olarak atanır. Örnek. Copy let gunler = ['Pazartesi', 'Salı', 'Çarşamba']; delete gunler[1]; alert(gunler); // 'Pazartesi,,Çarşamba' çift virgülü farkediniz. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi#dizi-kontrolu) Dizi Kontrolü ----------------------------------------------------------------------------------------------------------------------------------- > `**Array.isArray()**` Tüm `**object**` türlerinin tipinin `**object**` olduğunu ifade etmiştik. `**Object**` tipinde farklı türler bir arada olduğu için `**object**` bir değerin `**array**` dizisi olduğunu kontrol etmek için `**Array.isArray()**` fonksiyonu kullanılır. Örnek. Copy let harfler = ['A','B','C','D']; let str = 'ABCD'; alert( Array.isArray(harfler) ); // true alert( Array.isArray(str) ); // false [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi#dizi-turune-donusturme) Dizi Türüne Dönüştürme ----------------------------------------------------------------------------------------------------------------------------------------------------- > `**Array.from()**` | `**Array()**` `**String**` bir değer veya değişken `**array**` türüne `**Array.from()**` fonksiyonu ile dönüştürülebilir. Örnek. Copy let dizi = Array.from('JAVASCRIPT'); alert(dizi); // J,A,V,A,S,C,R,I,P,T alert( Array.isArray(dizi) ); Değerin tipinin `**string**` olması bir gerekliliktir. Örnek. Copy let sayi = 123, // nummber tipi array'a dönüşemez. dizi = Array.from(sayi); alert(dizi); // boş çıktı alınır, elemanları yoktur. alert( Array.isArray(dizi) ); // true verir fakat elemanları yoktur. Bununla birlikte bir `**string**`'i dilimlemeden tek bir eleman olarak `**array**` yapmak isterseniz `**Array()**` fonksiyonunu kullanabilirsiniz. Örnek. Copy let dizi = Array('JAVASCRIPT'); alert(dizi); // Tek eleman 'JAVASACRIPT' alert( Array.isArray(dizi) ); [PreviousReferans (Reference) Veri Tiplerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri) [NextÜç Nokta (Spread) Operatörüchevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/uc-nokta-spread-operatoru) Last updated 2 years ago --- # String Metotları | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#buyuk-kucuk-harf-cevrimi) Büyük-Küçük Harf Çevrimi ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#tolowercase-or-.touppercase) > > `.toLowerCase()` | `.toUpperCase()` > > > ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Bir karakter dizisinin karakterlerini (harflerini) büyük olarak `**.toUpperCase()**` metoduyla, küçük olarak `**.toLowerCase()**` metoduyla dönüştürebiliriz. Örnek: Copy let karakterDizisi = 'İstiklal Marşı'; alert( karakterDizisi.toUpperCase() ); // Büyük harf yaptık. alert( karakterDizisi.toLowerCase() ); // Küçük harf yaptık. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#karakterin-pozisyonunu-bulma) Karakterin Pozisyonunu Bulma ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > ### > > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#indexof-or-.lastindexof-or-.search) > > `.indexOf()` | `.lastIndexOf()` | `.search()` Bir karakter dizisinin içinde geçen alt karakter veya karakterleri arayarak ilk geçtiği pozisyonu `**.indexOf()**` metodu ile buluruz. `**.indexOf()**` metodu iki parametre alır, biri zorunlu diğeri isteğe bağlıdır. Kullanım: `**.indexOf(arananKarakter, aramayaBaslamaPozisyonu)**` şeklindedir ve aranan karakter zorunludur fakat aramaya başlama pozisyonu zorunlu değildir. Yazılmaz ise ilk karakterden yani 0. pozisyondan başlar. Örnek: Copy let deyim = 'Dediğimi yap, yaptığımı yapma'; alert( deyim.indexOf('Dedi') ); // İlk geçtiği poz. 0 sonucunu verir. alert( deyim.indexOf('yap') ); // İlk geçtiği poz. 9 sonucunu verir. alert( deyim.indexOf('Dedi',6) ); // Bulamaz -1 sonucunu verir. Aranan **karakter bulunamazsa -1 sonucunu verir.** Aranan karakterin birden fazla pozisyonu var ise hepsini bulmak için bir döngüye ihtiyaç vardır. Bunu ilerleyen konularda işleyeceğiz. Bir de sondan arama şekli olan `**.lastIndexOf()**` metodu vardır. Örnek. Copy let deyim = 'Dediğimi yap, yaptığımı yapma'; alert( deyim.lastIndexOf('yap') ); // Sondan başa ilk geçtiği poz. 24 sonucunu verir. `**.lastIndexOf()**` metodu `**.indexOf()**` metoduna göre daha az kullanılan bir metottur. Bir karakter dizisinin içinde geçen _**ifadeyi**_ ise `**.search()**` metodu ile buluruz. Örnek. Copy let deyim = 'Dediğimi yap, yaptığımı yapma'; alert( deyim.search('yap') ); // 'yap' ilk başladığı indisi verir. `**.search()**` metodu alt karakter aramaktan çok _ifade_ aramaya yöneliktir. Bu konuyu ileride [Düzenli İfadeler](https://hanuce.gitbook.io/javascript-egitimi/duzenli-ifadeler-regular-expressions) konusunda işleyeceğiz. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#karakter-kontrolu-iceriyor-mu-basliyor-mu-bitiyor-mu) Karakter Kontrolü ( İçeriyor mu? Başlıyor mu? Bitiyor mu? ) -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > ### > > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#includes-or-.startswith-or-.endswith) > > `.includes()` | `.startsWith()` | `.endsWith()` Bir karakter dizisinin içinde geçen alt karakter veya karakterlerin pozisyonu sizi ilgilendirmiyorsa sadece varlık/yokluk arıyorsanız bu metotları kullanmalısınız. * İçeriyor mu?: `**.includes(arananKarakter, aramayaBaslamaPozisyonu)**` * Başlıyor mu?: `**.startsWith(baslananKarakter)**` * Bitiyor mu?: `**.endsWith(baslananKarakter)**` Bu metotların sonucu **True (doğru)** veya **False (yanlış)** olarak döner. Örnek. Copy let tekerleme = 'Dal sarkar kartal kalkar, kartal kalkar dal sarkar'; alert( tekerleme.includes('kar') ); // True: Bulundu alert( tekerleme.includes('kartal', 45) ); //False: 45.Pozisyondan sonra bulunamadı alert( tekerleme.startsWith('Dal') ); //True: 'Dal' ile başlıyor. alert( tekerleme.startsWith('dal') ); //False: 'dal' ile başlamıyor. alert( tekerleme.endsWith('kar') ); //True: 'kar' ile bitiyor. alert( tekerleme.endsWith('.') ); //False '.' ile bitmiyor. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#karakteri-degistirme) Karakteri Değiştirme --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > ### > > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#replace-or-replaceall) > > `.replace()` | `replaceAll()` Bir karakter dizisinde geçen bir _ifadeyi_ başka bir _ifade_ ile değiştirmek için `**.replace()**` metodu kullanılır. İki tane zorunlu parametresi vardır ve `**.replace(arananIfade, yerineKonulacakIfade)**` olarak kullanılır. Örnek. Copy let ifade = 'JAVASCRIPT JAVASCRIPT'; alert ( ifade.replace('AVASCRIPT','avascript') ); Aranan ifade ilk bulunduğu yerde değişir ve metot sonlanır. Tüm eşleşmelerin değişmesi için `**.replaceAll()**` metodu kullanılır. Copy let ifade = 'JAVASCRIPT JAVASCRIPT'; alert ( ifade.replaceAll('AVASCRIPT','avascript') ); [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#karaktere-pozisyon-ile-erisme) Karaktere Pozisyon ile Erişme --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > ### > > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#at-or-.charat-or) > > `.at()` | `.charAt()` | `[ ]` Bir karakter dizisinin karakterlerine `**.at()**` ile erişebiliriz. Bir karakter dizisinin ilk karakteri her zaman 0.indisten (pozisyondan) başlar. Örnek Copy let kelime = 'Javascript'; alert( kelime.at(0) ); // 'J' harfi çıktısı alınır. alert( kelime.at(1) ); // 'J' harfi çıktısı alınır. alert( kelime.at(-1) ); // 't' harfi çıktısı alınır. alert( kelime.at(-2) ); // 'p' harfi çıktısı alınır. alert( kelime.at(100) ); // 'undefined' çıktısı alınır. `**.at()**` metodu ile negatif sayılar kullandığınızda sağ baştan başlayarak size karakterleri verir. Geçersiz başvuru yaptığınızda ise 'undefined' değerini alırsınız. Aynı işlemi `**.charAt()**` metodu ile de yapabilirsiniz. Örnek. Copy let kelime = 'Javascript'; alert( kelime.charAt(0) ); // 'J' çıktısı alınır. alert( kelime.charAt(1) ); // 'a' çıktısı alınır. alert( kelime.charAt(kelime.length-1) ); // 't' çıktısı alınır. alert( kelime.charAt(-1) ); // '' çıktısı alınır. alert( kelime.charAt(100) ); // '' çıktısı alınır. Fakat `**.charAt()**` metodu ile geçersiz veya negatif bir başvuru yaptığınızda boş değer elde edersiniz. Copy let kelime = 'Javascript'; alert( kelime.charAt(1000) ); // '' çıktısı. alert( kelime.charAt(-1) ); // '' çıktısı. Bir karakter dizisinin tüm karakterlerine `**[ ]**` ile de erişebiliriz. Örnek Copy let kelime = 'Javascript'; alert( kelime[0] ); // 'J' harfi çıktısı alınır. alert( kelime[1] ); // 'a' harfi çıktısı alınır. alert( kelime[kelime.length-1] ); // Son harf 't' harfi çıktısı alınır. alert( kelime[-1] ); // 'undefined' çıktısı alınır. alert( kelime[100] ); // 'undefined' çıktısı alınır. Köşeli parantez içinde negatif sayı veya geçersiz başvuru kullanıldığında '**undefined**' değeri verir. `**.charAt()**` metodu ile negatif veya geçersiz bir başvuru yaptığınızda boş değer elde edersiniz. Diğerleri ile arasındaki fark sadece budur. Copy let kelime = 'Javascript'; alert( kelime.charAt(100) ); // '' çıktısı. alert( kelime.at(100) ); // 'undefined' çıktısı. alert( kelime.[100] ); // 'undefined' çıktısı. Bir `**string**`'te eriştiğiniz karakterin değerini tekil olarak değiştiremezsiniz. Örnek. Copy let kelime = 'Javascript'; kelime.charAt(0) = 'H'; // hata fırlatır. kelime.at(0) = 'H'; // hata fırlatır. kelime.[0] = 'H'; // hata fırlatır. alert(kelime); // hatalar yüzünden çalışmaz. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#stringi-dilimleme) `String`'i Dilimleme ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ > ### > > [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#substring-or-.slice-or-.split) > > `.substring()` | `.slice()` | `.split()` Bir karakter dizisinin alt karakterlerini `**.substring()**` metodu ile dilimleyebilirsiniz. `**.substring(baslama, bitis)**` olarak pozisyonları verilerek dilimlenir. **Bitiş parametresine kadar olan karakterler** dilimlenmiş olur. Bitiş parametresinin olduğu karakter katılmaz. Ayrıca bitiş parametresi vermek zorunlu değildir. Verilmezse dizinin sonuna kadar (`**.length**`) dilimler. Örnek. Copy let kelime = 'Javascript Programalama Dili'; alert( kelime.substring(24) ); // Bitiş parametresi yok. Sona kadar gider: 'Dili' alert( kelime.substring(4,10) ); // 4'ten 10'a kadar gider (10 dahil değil):'script' `**.substring()**` metodu ile negatif parametreler verirseniz sıfır kabul eder. Ayrıca bitiş parametresini sıfır verirseniz parametreleri tersine çevirir. Copy let kelime = 'Javascript Programalama Dili'; alert( kelime.substring(-250,4) ); // (0,4) kabul eder: 'Java' çıktısı verir. alert( kelime.substring(4,0) ); // Parametreleri ters (0,4) çevirdi: 'Java' alert( kelime.substring(4,-250) ); // Ters çevirdi (0,4): 'Java' çıktısı verir. Bir karakter dizisinin alt karakterlerini `**.slice()**` metodu ile de dilimlenir. `**substring()**` ile farkı negatif sayılar da kabul etmesidir. Negatif sayılarda sağdan başlar fakat yine de soldan sağa doğru ilerleyerek dilimler. `**.slice(baslama, bitis)**` olarak parametreleri verilir. Copy let kelime = 'Javascript Programalama Dili'; alert( kelime.slice(0,4) ); //'Java' alert( kelime.slice(24) ); // 'Dili' alert( kelime.slice(-4,-1) ); // 'Dil' son karakteri dilemez. alert( kelime.slice(-28, -24) ); // Ters çevirdi (0,4): 'Java' çıktısı verir. `**.split()**` metodu ile bir karakter dizisini belirli karakterlerden ayırmamıza yarar. Fakat elde edilen **değişken tipi string olmaz.** Copy let kelime = 'Türkiye Büyük Millet Meclisi'; alert( kelime.split(' ') ); //Boşluklardan böldük. Çıktı: Türkiye,Büyük,Millet,Meclisi alert( kelime.split('i') ); //'i'lerden böldük. Çıktı: Türk,ye Büyük M,llet Mecl,s, Bir değişkene atarsak yeni değişken tipinin `**object**` (nesne) olduğunu görebiliriz. Copy let kelime = 'Türkiye Büyük Millet Meclisi', yeni = kelime.split(' '); alert( typeof(yeni) ); // 'object' çıktısı verir circle-info Yukarıdaki metotlar ile genel olarak karakter dizilerinin içindeki _**alt karakterler**_ üzerinden işlemler yapılır. Yani aradığınız karakterler aynen olduğu gibi karakter dizisinin içinde aranır ve sonuç birebir eşleşme üzerinden çıkar. Peki siz çeşitli şekillerdeki yazımı (büyük, küçük vb.) fark etmeksizin bir ifadeye erişip işlem yapmak istiyorsanız ? Bu durumda Düzenli İfadeler (Regular Expressions) ile işlemler yapmanız gerekir. İleri konularda [Düzenli İfadeler](https://hanuce.gitbook.io/javascript-egitimi/duzenli-ifadeler-regular-expressions) işlenecek. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi/string-metotlari#birlestirme-kirpma-tekrar-etme) Birleştirme, Kırpma, Tekrar Etme ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > `**.concat()**` | `**.trim()**` | `**.trimStart()**` | `**.trimEnd()**` | `**.repeat()**` Karakter dizilerini `**.concat()**` metodu ile birleştirebilirsiniz. Parametre olarak istediğiniz kadar string verebilirsiniz. Copy let str1 = 'Türkiye'; let str2 = 'Büyük'; let str3 = 'Millet'; let str4 = 'Meclisi'; let kelime = ''; //boş bir string tanımladık. kelime = kelime.concat(str1,' ',str2,' ',str3,' ',str4); alert(kelime); // Daha kısa ifadeyle //kelime = str1.concat(' ',str2,' ',str3,' ',str4); `**.concat()**` metodu yerine matematiksel toplama yöntemi de yapılabilir. Örnek. Copy let str1 = 'Türkiye'; let str2 = 'Büyük'; let str3 = 'Millet'; let str4 = 'Meclisi'; let kelime = str1 + ' ' + str2 + ' ' + str3 + ' ' + str4; alert(kelime); `**.trim()**` metodu ile bir karakter dizisinin başındaki ve sonundaki tüm boşlukları silebilirsiniz. Sadece baştakiler için `**.trimStart()**` sadece sondakiler için `**.trimEnd()**` metotlarını kullanabilirsiniz. Örnek. Copy let kelime = ' Merhaba Javascript '; alert( kelime.trim() ); // 'Merhaba Javascript' alert( kelime.trimStart() ); // 'Merhaba Javascript ' alert( kelime.trimEnd() ); // ' Merhaba Javascript' Bir karakter dizisini n kere tekrar ettirmek için `**.repeat()**` metodu kullanılır. Örnek. Copy let selam = 'Merhaba '; alert( selam.repeat(3) ); // 'Merhaba Merhaba Merhaba ' [PreviousString - Karakter Dizisichevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/string-karakter-dizisi) [NextNumber - Sayıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi) Last updated 2 years ago --- # Number Metotları | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi/number-metotlari#basamak-sinirlama) Basamak Sınırlama ---------------------------------------------------------------------------------------------------------------------------------------------------------- > `**.toFixed()**` | `**.toPrecision()**` Ondalık gösterimlerdeki hataları çözmek için `**.toFixed()**` metodu ile ondalık basamağı sınırlayabiliriz. Örnek. Copy let sayi1 = 0.1; let sayi2 = 0.2; let toplam = (sayi1 + sayi2).toFixed(2); alert(toplam); // 0.30 Çıktısı alınır. toplam = (sayi1 + sayi2).toFixed(4); alert(toplam); // 0.3000 Çıktısı alınır. Bu metot ile parametre olarak verdiğiniz sayı kadar ondalık basamak kadar sayı ele alınır. Eğer sayının olduğundan daha fazla basamak verirseniz 0 (sıfır) ekleyerek istediğiniz basamak sayısına sabitler. `**.toFixed()**` metodunun **string tipinde değer döndürdüğünü unutmayınız.** Genel olarak sayıların basamak sayısını sınırlamak için `**.toPrecision()**` metodu kullanılır. Copy let sayi1 = 1234.5678; alert( sayi1.toPrecision(6) ); //1234.57 çıktısı alınır. Son basamağı yuvarlar. alert( sayi1.toPrecision(4) ); //1234 çıktısı alınır. Son basamağı yuvarlar. sayi1 = 123456789; alert( sayi1.toPrecision(6) ); //1.23457e+8 çıktısı alınır. Son basamağı yuvarlar. alert( sayi1.toPrecision(4) ); //1.235e+8 çıktısı alınır. Son basamağı yuvarlar. `**.toPrecision()**` ile basamak sınırlarken soldan başlar ve verilen parametre kadar basamağı alır. Örneğin 1234'ün ilk iki basamağını alırsak 1200 olduğu için 1.2e+3 olarak yuvarlar. Tam sayılarda sayının birler basamağına kadar olan kısmını almıyorsanız genellikle _**e**_ (exponent) ile gösterim yapar. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi/number-metotlari#sayi-sistemlerini-cevirme) Sayı Sistemlerini Çevirme -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > `**.toString()**` Sayı sistemlerini (16-10-8-2 vb.) birbirine `**.toString()**` metodu ile çevirebiliriz. Örnek. Copy let sayi = 123456789; let binary = 1001000111; alert( sayi.toString(2) ); alert( binary.toString(10) ); alert( binary.toString(16) ); alert( sayi.toString(8) ); alert( sayi.toString(5) ); Bir sayı doğrudan da `**.toString()**` metodu ile çevrilebilir fakat ondalıklı sayılarda hata almamak için parantez içine almak veya çift nokta kullanmak gerekir. Copy alert( 1234.toString(2) ); alert( (1234.2).toString(2) ); alert( 1234.2..toString(2) ); `**.toString()**` metodu ile elde edilen veri tipi **string** olur. Dolayısıyla matematiksel işlemlerde kullanmak için **number tipine dönüştürülmesi gerekir.** [PreviousNumber - Sayıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi) [NextMath Kütüphanesichevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi/math-kutuphanesi) Last updated 2 years ago --- # Math Kütüphanesi | JavaScript Eğitimi Javascript'te dahili olarak `**Math**` kütüphanesi mevcuttur. Basit düzeyde birçok işlemi barındırır. Doğrudan `**Math.metot()**` şeklinde kullanılır. > `**Math.ceil()**` | `**Math.floor()**` | `**Math.round()**` Yukarı yuvarlamaları `**Math**` kütüphanesinin `**.ceil()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi1 = 5.0002; let sayi2 = -5.0002; alert( Math.ceil(sayi1) ); // 6 Çıktısını verir. alert( Math.ceil(sayi2) ); // -5 Çıktısını verir. Aşağı yuvarlamaları `**Math**` kütüphanesinin `**.floor()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi1 = 5.9999; let sayi2 = -5.9999; alert( Math.floor(sayi1) ); // 5 Çıktısını verir. alert( Math.floor(sayi2) ); // -6 Çıktısını verir. Standart yuvarlamaları `**Math**` kütüphanesinin `**.round()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi1 = 5.49999; let sayi2 = 5.50000; alert( Math.round(sayi1) ); // 5 Çıktısını verir. Çünkü 5.5'ten küçük. alert( Math.round(sayi2) ); // 6 Çıktısını verir. Çünkü 5.5 veya daha büyük. Standart yuvarlamaları `**Math**` kütüphanesinin `**.round()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi1 = 5.49999; let sayi2 = 5.50000; alert( Math.round(sayi1) ); // 5 Çıktısını verir. Çünkü 5.5'ten küçük. alert( Math.round(sayi2) ); // 6 Çıktı > `**Math.pow()**` | `**Math.sqrt()**` | `**Math.cbrt()**` Üs alma işlemini `**Math**` kütüphanesinin `**.pow()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi = 2; let us = 5; alert( Math.pow(sayi,us) ); // 32 Çıktısını verir. Karekök alma işlemini `**Math**` kütüphanesinin `**.sqrt()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi = 64; alert( Math.sqrt(sayi) ); // 8 Çıktısını verir. Küpkök alma işlemini `**Math**` kütüphanesinin `**.cbrt()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi = 125; alert( Math.cbrt(sayi) ); // 8 Çıktısını verir. > `**Math.abs()**` | `**Math.min()**` | `**Math.max()**` | `**Math.random()**` | `**Math.trunc()**` | Mutlak değer alma işlemini `**Math**` kütüphanesinin `**.abs()**` metodu ile yapabilirsiniz. Örnek. Copy let sayi = -256; alert( Math.abs(sayi) ); // 256 Çıktısını verir. Bir serideki en küçük değeri `**Math**` kütüphanesinin `**.min()**` metodu ile doğrudan elde edersiniz. Örnek. Copy let sayi1 = 12; let sayi2 = 6; let sayi3 = -25; let sayi4 = -5; alert( Math.min(sayi1,sayi2,sayi3,sayi4) ); // -25 Çıktısını verir. Bir serideki en büyük değeri `**Math**` kütüphanesinin `**.max()**` metodu ile doğrudan elde edersiniz. Örnek. Copy let sayi1 = 12; let sayi2 = 6; let sayi3 = -25; let sayi4 = -5; alert( Math.max(sayi1,sayi2,sayi3,sayi4) ); // 12 Çıktısını verir. Rasgele olarak 0-1 arasında bir sayıyı `**Math**` kütüphanesinin `**.random()**` metodu ile üretebilirsiniz. Örnek. Copy let sayi = Math.random(); alert( sayi ); // 0-1 arasında bir sayıyı çıktı olarak verir. alert( Number( (sayi*100).toFixed(0) ) ); // 1-100 arasına çevirdik. Yuvarlar. Ondalıklı bir sayının tamsayı kısmını yuvarlatmadan `**Math**` kütüphanesinin `**.trunc()**` metodu ile elde edebilirsiniz. Örnek. Copy let sayi = Math.random(); alert( sayi ); // 0-1 arasında bir sayıyı çıktı olarak verir. alert( Math.trunc( (sayi*100) ) ); // 1-100 arasına çevirdik. Yuvarlamaz. Bu işlemlerin haricinde `**Math**` kütüphanesinin `**.sin()**`, `**.cos()**`, .`**tan()**`, `**.cot()**`, `**.log()**`, `**.log10()**` gibi metotlar da mevcuttur. Ayrıca `**Math.PI**` olarak pi sayısı sabit olarak mevcuttur. Copy alert(Math.PI); // 3.141592653589793 çıktısı verir. [PreviousNumber Metotlarıchevron-left](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/number-sayi/number-metotlari) [NextBigInt - Büyük Sayıchevron-right](https://hanuce.gitbook.io/javascript-egitimi/ilkel-primitive-veri-tipleri/bigint-buyuk-sayi) Last updated 2 years ago --- # Map - Eşlem Nesnesi | JavaScript Eğitimi [PreviousKoleksiyonlar (Map, Set)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/koleksiyonlar-map-set) [NextSet - Küme Nesnesichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/koleksiyonlar-map-set/set-kume-nesnesi) Last updated 2 years ago --- # Object.assign() ile Nesne Birleştirme ve Klonlama | JavaScript Eğitimi Bir nesnenin özellikleri ve değerleri doğrudan atanabildiği gibi `**Object**` sınıfının `**.assign()**` metodu ile (`**Object.assign()**` ) de atanabilir. Örnek. Copy let isci = { sicilNo:2023, isim:'Ahmet', gorev:'Ustabaşı' }; //isci nesnesine kidem ve maas özelliklerini değerleriyle ekledik. Object.assign( isci, { kidem:15, maas:9000 } ); alert(isci.maas); //9000 çıktısı verir. İlk argüman nesnenin kendisi olurken gerisi de nesne tipinde 'anahtar:değer' ikilileridir. Yani `**Object.assign(object, Object)**` olarak argümanlar almaktadır. Var olan bir özelliği `**.assign()**` ile atarsanız var olanın **üzerine yazar**. Örnek. Copy let isci = { sicilNo:2023, isim:'Ahmet', gorev:'Ustabaşı' }; Object.assign( isci, { gorev:'İşçi', maas:9000 } ); alert(isci.gorev); //'İşçi' çıktısı verir. alert(isci.maas); //'9000' çıktısı verir. `**Object.assign()**` ile **farklı nesneler birleştirilebilir.** Örnek. Copy let isci = { tcNo:12345678900, isim:'Güneş Gün', }; let metrik = { kidem:15, maas:12000, }; Object.assign(isci, metrik); alert(isci.kidem); //'15' çıktısı verir. Bu fonksiyon klonlama için de kullanılır. **Klonlama orijinalden bağımsız bir kopya oluşturmaktır.** Referans tipler değeri değil adresi taşıdığı için yapılan değişikliklerden etkilenir. Daha iyi anlamak için şu örneğe bakınız. Copy //İLKEL (DEĞER) TİP let str = 'Değer'; let yeni = str; alert(yeni); // 'Değer' str = 'Yeni Değer'; //atanadığı değişkenin //değerinin değişmesinden //etkilenmez. alert(yeni); // 'Değer' Copy //REFERANS (ADRES) TİP let obj = { p1:'Değer'}; let yeni = obj; alert(yeni.p1); // 'Değer' obj.p1 = 'Yeni Değer'; //atanadığı nesnenin //değerinin değişmesinden //etkilenir. alert(yeni.p1); // 'Yeni Değer' Nesnelerin birbirini referans etmeyen **bağımsız kopyalarını** oluşturup üzerinde çalışmak için `**Object.assign()**` fonksiyonunun **ilk argümanını boş nesne** bırakarak oluşturabilirsiniz. Örnek. Copy let isci = { tcNo:12345678900, isim:'Çetin KAYA', kidem:15, maas:12000, }; let yeniIsci = Object.assign( {}, isci ); alert(yeniIsci.tcNo); //12345678900 isci.tcNo = 00000000000; alert(yeniIsci.tcNo); //12345678900 etkilenmedi, bağımsız bir kopya (klon) Fakat bu kolaylık değerlerde nesne kullanılmışsa işe yaramaz. Örnek. Copy let isci = { tcNo:12345678900, isim:'Çetin KAYA', metrik:{ kidem:15, maas:12000, } }; let yeniIsci = Object.assign( {}, isci ); alert(yeniIsci.metrik.kidem); // '15' isci.metrik.kidem = 5; alert(yeniIsci.metrik.kidem); // '5', etkilendi, değerdeki nesneler klon olamadı. Bu problem _**lodash.js**_ kitaplığındaki `**.cloneDeep()**` metodu ile çözülebilir. Daha fazlası için bakınız: [https://lodash.com/arrow-up-right](https://lodash.com/) [PreviousObject - Nesnechevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne) [NextNesnelerde Üç Nokta (Spread) Operatörüchevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/nesnelerde-uc-nokta-spread-operatoru) Last updated 2 years ago --- # Nesnelerde Üç Nokta (Spread) Operatörü | JavaScript Eğitimi `**Object.assign()**`'dan daha kullanışlı bir sözdizimidir. `**...**` operatörü ile nesnenin tüm özelliklerinden yayılacak şekilde bağımsız bir kopya (klon) oluşturulur. Örnek. Copy let isci = { tcNo:12345678900, isim:'Güneş Gün', }; let metrik = { kidem:15, maas:12000, }; // isci nesnesine metrik nesnesinin özelliklerini ekledik. isci = {...metrik}; alert(isci.kidem); //'15' çıktısı verir. //veya yeni bir nesnede birleştirebiliriz. let yeniIsci = {...isci,...metrik}; // yayılım yapılan nesnenin değerinin değişmesinden etkilenmez. isci.kidem = 25; alert(yeniIsci.kidem); //'15' çıktısı verir. Nesnelerde aynı özellikler var ise son sıradaki değer ilkinin üzerine yazılır. Örnek. Copy let isci = { tcNo:12345678900, isim:'Güneş Gün', }; let metrik = { tcNo: 0, kidem:15, maas:12000, }; isci = {...metrik}; // metrik'teki tcNo öncekinin üzerine yazılır. alert(isci.tcNo); //0 çıktısı verir. Üzerine yazmayı siz sonradan elle de yapabilirsiniz. Örnek. Copy let isci = { tcNo:12345678900, isim:'Güneş Gün', kidem:15, maas:12000, }; yeniIsci = { ...isci, tcNo:0, maas:9000, }; alert(yeniIsci.tcNo); //0 çıktısı verir. alert(yeniIsci.maas); //9000 çıktısı verir. //diğer özellikleri aynı kalır Eğer değerlerde nesne kullanılmışsa `**Object.assign()**` gibi onların bir klonunu oluşturamaz. `**...**` operatörü nesnelerde (`**object**`, `**array**` vb.) hepsinde kullanılabilir. Yukarıda `**...**` operatörünün yayılma özelliğini kullandık. Fakat tek işlevi yayılma (spread) değildir. Dilimlemeler ve birleştirmeler de yapılabilir. n sayıda elemanı (özelliği) olan bir nesneyi dilimleyebilir ve kalanı (rest) ile birlikte işleme alabilir. Bu kullanımına '**Rest (Geri Kalan) Parameter'** denir. Bunu ileri fonksiyonlarda göreceğiz. Basit bir örnek. Copy let matematik = { topla (...sayilar) { //n (belirsiz) sayıda argüman aldık let toplam = 0; for (let sayi of sayilar) { // for .. of döngüsünü array'lerde gördük. toplam += sayi; } return toplam; } }; alert( matematik.topla(1,2,3,4,5,6,7,8,9,10) ); [PreviousObject.assign() ile Nesne Birleştirme ve Klonlamachevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/object.assign-ile-nesne-birlestirme-ve-klonlama) [NextNesnelerde Fonksiyon Kullanımı ve Callbackchevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/nesnelerde-fonksiyon-kullanimi-ve-callback) Last updated 2 years ago --- # const ile Nesne Deklare Etme | JavaScript Eğitimi `**const**` ile değeri değişmeyen sabitler deklare ediliyordu. Fakat `**object**` veri tipi değeri değil adresi tuttuğu için `**const**` ile deklare edilen nesnelerin değeri nasıl sabit kalır? Değeri sabit kalmaz, adresi sabit kalır. Örnek. Copy const user = { takmaAd:'user', sifre:'1234', }; user.sifre = '0000'; // hata vermez alert(user.sifre); // şifre değişir: '0000' //veya delete user.sifre; // hata vermez alert('sifre' in user); // şifre silindi: false `**const**` ile deklare edilen nesneleri `**Object.assign()**` ile klonlayabilirsiniz. Bu durum size şunu hatırlatmalı: "_**Katı mod'da bir değişkeni, nesneyi veya fonksiyonu silemezsin.**_". Buradan dilin katı modda öğelerini nasıl ele aldığını fark edebilirsiniz. [Previousfor .. in ile Nesnenin Özelliklerichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/for-..-in-ile-nesnenin-ozellikleri) [Nextnew Yapıcı Operatörüchevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/new-yapici-operatoru) Last updated 2 years ago --- # for .. in ile Nesnenin Özellikleri | JavaScript Eğitimi Bir özelliğin bir nesne içindeki **varlığını** `**in**` deyimi ile sorgulayabiliriz. Örnek. Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, }; delete ogrenci.sinif; alert( 'isim' in ogrenci ); //true alert( 'notlar' in ogrenci ); //false alert( 'sinif' in ogrenci ); // 6.satırda sildiğimiz için: false Bu sorgulama `**.hasOwnProperty()**` veya `**Object.hasOwn()**` ile de yapılabilir. Örnek. Copy alert( ogrenci.hasOwnProperty('no') ); //true alert( Object.hasOwn(ogrenci,'isim') ); //true alert( Object.hasOwn(ogrenci,'okul') ); //false Nesnelerin anahtarları döngülenebilirler. Döngülenebilir yapılar `**for**`'un farklı kullanımlarıyla döngülenebilirler. Nesneler `**for ... in**` kullanımıyla döngülenebilirler. Örnek. Copy let user = { takmaAd:'user', sifre:'1234', dil:'TR', }; for (let ozellik in user) { alert(ozellik); } Eğer size değerler lazımsa şu şekilde kombinleyebilirsiniz. Copy let user = { takmaAd:'user', sifre:'1234', dil:'TR', }; for (let ozellik in user) { alert( user[ozellik] ); } `**for ... in**` kullanımı özelliklerin eklenme sırasına göre çalıştırır fakat anahtarlar `**string**` tipinde nümerik değerlerle belirtilmişse işler değişir. Copy let numerics = { '44':'kırkdört', '1':'bir', '34':'otuzdört', }; for (let anahtar in numerics) { alert(anahtar); } Anahtarlar eklenme sırasına göre değil de sayısal olarak artan sırada gelir. Bu durum anahtarların `**for ... in**` kullanımında bellekte nümerik olarak çevriminden kaynaklanır. Önüne geçmek için `**string'**`in önüne '+' vb. semboller konularak tip saflaştırılır. Copy let numerics = { '+44':'kırkdört', '+1':'bir', '+34':'otuzdört', }; for (let anahtar in numerics) { alert(anahtar); } Metotlar da yine `**for ... in**` döngüsü anahtar olarak gösterilir. Örnek. Copy let user = { takmaAd:'user', sifre:'1234', dil:'TR', ozellikGoster() { for (let ozellik in this) { alert(ozellik); } } }; user.ozellikGoster(); // en sonda ozellikGoster anahtarı görünecektir. [PreviousNesne Erişimcileri (Getter & Setter)chevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/nesne-erisimcileri-getter-and-setter) [Nextconst ile Nesne Deklare Etmechevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/const-ile-nesne-deklare-etme) Last updated 2 years ago --- # Array Metotlar | JavaScript Eğitimi [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/array-metotlar#eleman-ekleme-ve-cikarma) Eleman Ekleme ve Çıkarma ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ > `**.push()**` | `**.pop()**` | `**.unshift()**` | `**.shift()**` Bir `**array**`'in **sonuna** değer **eklemek** için `**.push()**` metodu kullanılır. Örnek. Copy let gunler = ['Pazartesi', 'Salı', 'Çarşamba']; gunler.push('Perşembe'); // Eklenecek değer parantez içinde verilir. alert(gunler); `**.push()**` metodu ile birden fazla değer aynı anda eklenebilir. Örnek. Copy let gunler = ['Pazartesi', 'Salı', 'Çarşamba']; gunler.push('Perşembe','Cuma','Cumartesi','Pazar'); // Eklenecek değerler verilir. alert(gunler); Bir `**array**`'in **sonundan** değer **silmek** için `**.pop()**` metodu kullanılır. Örnek. Copy let gunler = ['Pazartesi', 'Salı', 'Çarşamba']; gunler.pop(); // Sonuncuyu doğrudan siler. Herhangi bir değer verilmez. alert(gunler); Bir `**array**`'in **başına** değer **eklemek** için `**.unshift()**` metodu kullanılır. Örnek. Copy let gunler = ['Salı', 'Çarşamba', 'Perşembe']; gunler.unshift('Pazartesi'); // Eklenecek değer parantez içinde verilir. alert(gunler); `**.unshift()**` metodu ile birden fazla değer aynı anda eklenebilir. Örnek. Copy let gunler = ['Çarşamba', 'Perşembe','Cuma']; gunler.unshift('Pazartesi','Salı'); // Eklenecek değerler verilir. alert(gunler); Bir `**array**`'in **başından** değer **silmek** için `**.shift()**` metodu kullanılır. Örnek. Copy let gunler = ['Pazartesi', 'Salı', 'Çarşamba']; gunler.shift(); // Birinciyi doğrudan siler. Herhangi bir değer verilmez. alert(gunler); `**Array**`'in başından yapılan işlemler ( `**.shift()**` ve `**.unshift()**` ) donanım üzerinde çok işlem gerektirdiği için genellikle kullanılmazlar. Performansı kötü etkiler. Sonundan yapılan işlemler oldukça verimlidir ve genelde bunlar ( `**.push()**` ve `**.pop()**` ) kullanılır. [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/array-metotlar#dilimleme-birlestirme-siralama) Dilimleme, Birleştirme, Sıralama -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > `**.slice()**` | `**.concat()**` | `**.join()**` | `**.splice()**` | `**.sort()**` | `**.reverse()**` `**.slice()**` ile diziyi indislere göre sıralı şekilde dilimleyebiliriz. Örnek. Copy let evcilHayvanlar = ['kedi','köpek','kuş','balık','kaplumbağa']; alert( evcilHayvanlar.slice(2) ); // ilk indisten (0'dan) 2.indise kadar alert( evcilHayvanlar.slice(1,4) ); // 1.indisten 4.indise kadar alert( evcilHayvanlar.slice(-2) ); // son-2 indisten ilk indise kadar alert( evcilHayvanlar.slice(-3,-1) ); // son-3 indisten son indise kadar alert( evcilHayvanlar.slice(3,2) ); // boş çıktı: 3.indisten 2.indise gidemez. alert( evcilHayvanlar.slice(3,3) ); // boş çıktı: 3.indisten 3.indise gidemez. alert( evcilHayvanlar); // orijinal dizimizde hiçbir değişiklik yok. let yeniEvciller = evcilHayvanlar.slice(1,3); // bir dilimi yeni değişken atadık. alert(yeniEvciller); `**.slice()**` metodu orijinal dizi üzerinde bir değişiklik yapmaz, bir kopyasını oluşturur. Bu sebeple güvenlidir, dilimlenen değer yeni bir değişken olarak ifade edilebilir. Örnek. Copy let evcilHayvanlar = ['kedi','köpek','kuş','balık','kaplumbağa']; let yeniEvciller = evcilHayvanlar.slice(1,3); // bir dilimi değişken atadık. alert(yeniEvciller); `**.concat()**` ile dizilerin sonuna başka bir dizinin değerlerini toplu olarak ekleyebiliriz. Örnek. Copy let sehirC = ['çanakkale','çankırı','çorum']; let sehirD = ['denizli','diyarbakır','düzce']; let sehirE = ['edirne','elazığ','erzurum','eskişehir']; alert( sehirC.concat(sehirD) ); // dizi değerlerini ekledik. alert( sehirC.concat(sehirD,sehirE) ); // birkaç dizi de aynı anda kullanılabilir. `**.concat()**` metodu orijinal dizi üzerinde bir değişiklik yapmaz, bir kopyasını oluşturur. Bu sebeple güvenlidir, birleştirilmiş dizi yeni bir değişken olarak ifade edilebilir. Örnek. Copy let sehirC = ['çanakkale','çankırı','çorum']; let sehirD = ['denizli','diyarbakır','düzce']; let sehirE = ['edirne','elazığ','erzurum','eskişehir']; let sehirCED = sehirC.concat(sehirD,sehirE); alert(sehirC); alert(sehirCED); `**.join()**` ile dizi değerlerini `**string**` olarak birleştirebiliriz. Örnek. Copy let dil = ['J','A','V','A','S','C','R','I','P','T']; alert( dil.join() ); // parametresiz kullanılabilir. alert( dil.join('') ); //Değerlerin arasına konacak ifade parametre olarak yazılır. alert( dil.join('-') ); // J-A-V-A-S-C-R-I-P-T alert( typeof( dil.join('*') ) ); // string `**.join()**` metodu orijinal dizi üzerinde bir değişiklik yapmaz, bir kopyasını oluşturur. Bu sebeple güvenlidir, birleştirilmiş dizi yeni bir değişken olarak ifade edilebilir. Örnek. Copy let dil = ['J','A','V','A','S','C','R','I','P','T']; let seperator = '_'; let yeniDil = dil.join(seperator); alert(yeniDil); `**.splice()**` ile dizide ekleme, çıkarma, değiştirme işlemlerini yapabilirsiniz. İsveç çakısı gibidir. Kullanımı `**.splice(indis, cikarilacakAdet, ekle1, ekle2,..., ekleN)**` . `**.splice()**` ile ekleme örnekleri: Copy //ekleme örnekleri let futbolTakimlari = ['Trabzonspor','Beşiktaş','Galatasaray','Fenerbahçe']; //2.indise git, imleçten itibaren 0 tane değer sil, 'Malatyaspor' ekle futbolTakimlari.splice(2,0,'Malatyaspor'); alert(futbolTakimlari); //son-1. indise git, 0 değer sil, 'Sivasspor','Antalyaspor' ve 'Samsunspor' ekle futbolTakimlari.splice(-1,0,'Sivasspor','Antalyaspor','Samsunspor'); alert(futbolTakimlari); `**.splice()**` ile çıkarma örnekleri Copy //çıkarma örnekleri let futbolTakimlari = ['Trabzonspor','Beşiktaş','Galatasaray','Fenerbahçe']; //2.indise git, imleçten itibaren 2 tane değer sil futbolTakimlari.splice(2,2); alert(futbolTakimlari); //son-1.indise git, imleçten itibaren 1 değer sil futbolTakimlari.splice(-1,1); alert(futbolTakimlari); `**.splice()**` ile değiştirme örnekleri Copy //değiştirme örnekleri let futbolTakimlari = ['Trabzonspor','Beşiktaş','Galatasaray','Fenerbahçe']; //1.indise git, imleçten itibaren 1 değeri 'Malatyaspor' ile değiştir. futbolTakimlari.splice(1,1,'Malatyaspor'); alert(futbolTakimlari); //1.indise git, imleçten itibaren 2 değeri 'Ankaragücü' ve 'Adana Demir Spor' ile değiş. futbolTakimlari.splice(1,2,'Ankaragücü','Adana Demir Spor'); alert(futbolTakimlari); `**.splice()**` metodu **orijinal dizi üzerinde değişiklik yapar.** Bu sebeple **güvenli değildir.** Güvenli olarak işlem yapabilmek için aynı şekilde kullanılabilen `**.toSpliced()**` metodu kullanılmalıdır. `**.toSpliced()**` metodu orijinal dizi üzerinde işlem yapmaz. Örnek. Copy //.toSpliced() kullanımı let futbolTakimlari = ['Trabzonspor','Beşiktaş','Galatasaray','Fenerbahçe']; //0.indise git, imleçten itibaren 1 değeri 'Malatyaspor' ile değiştir. alert( futbolTakimlari.toSpliced(0,1,'Malatyaspor') ); alert(futbolTakimlari); // orijinal dizi değişmedi. `**.sort()**` ile dizinin elemanlarını **alfabetik** olarak sıralayabiliriz. Örnek. Copy let isimler = ['Alparslan','Yusuf','Göktuğ','Zeynep','Defne','Asel']; let yaslar = [1,12,22,39,3,101]; isimler.sort(); alert(isimler); // Alparslan,Asel,Defne,Göktuğ,Yusuf,Zeynep yaslar.sort(); alert(yaslar); // 1,101,12,22,3,39 (!! Alfabetik olarak sıralar) `**.sort()**` metodu **orijinal dizi üzerinde değişiklik yapar.** Bu sebeple **güvenli değildir.** Güvenli olarak işlem yapabilmek için aynı şekilde kullanılabilen `**.toSorted()**` metodu kullanılmalıdır. `**.toSorted()**` metodu orijinal dizi üzerinde işlem yapmaz. Örnek. Copy let dizi = ['Alparslan','Zeynep',1,101]; alert( dizi.toSorted() ); // 1,101,Alparslan,Zeynep alert(dizi); // orijinal dizi değişmedi. `**.reverse()**` metodu ile diziyi tersine çevirebiliriz. Örnek. Copy let dizi = ['T','R',1,9,2,3]; dizi.reverse(); alert(dizi); // 3,2,9,1,R,T `**.reverse()**` metodu **orijinal dizi üzerinde değişiklik yapar.** Bu sebeple **güvenli değildir.** Güvenli olarak işlem yapabilmek için aynı şekilde kullanılabilen `**.toReversed()**` metodu kullanılmalıdır. `**.toReversed()**` metodu orijinal dizi üzerinde işlem yapmaz. Örnek. Copy let dizi = ['T','R',1,9,2,3]; alert( dizi.toReversed() ); // 3,2,9,1,R,T alert(dizi); // T,R,1,9,2,3 [hashtag](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/array-metotlar#arama-ve-pozisyon-bulma) Arama ve Pozisyon Bulma ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- > `**.indexOf()**` | `**.lastIndexOf()**` | `**.includes()**` `**Array**`'lerin arama metotları `**string**`'lere oldukça benzerdir. `**.indexOf()**` metodu ile değeri bilinen bir değerin baştan (soldan sağa) ilk indisini bulabiliriz. Değer yoksa -1 döner. Örnek. Copy let harfler = ['A','B','C','D']; alert( harfler.indexOf('A') ); // 0 alert( harfler.indexOf('C') ); // 2 alert( harfler.indexOf('F') ); // -1 `**.lastIndexOf()**` metodu ile değeri bilinen bir değerin sondan (sağdan sola) ilk indisini bulabiliriz. Değer yoksa -1 döner. Örnek. Copy let harfler = ['A','B','C','D','C','B','A']; alert( harfler.lastIndexOf('A') ); // 6 alert( harfler.lastIndexOf('C') ); // 4 alert( harfler.lastIndexOf('F') ); // -1 `**.includes()**` metodu ile bir değerin dizideki varlığı sorgulanır, varsa `**true**` yoksa `**false**` döner. Örnek. Copy let harfler = ['A','B','C','D']; alert( harfler.includes('A') ); // true alert( harfler.includes('AA') ); // false [Previousfor .. of ile Dizilerin Yinelenmesichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/for-..-of-ile-dizilerin-yinelenmesi) [NextObject - Nesnechevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne) Last updated 2 years ago --- # this Deyimi ile Nesnenin Kendini Referans Etmesi | JavaScript Eğitimi Nesnelerin metotlarını işlevsel hale getirmek için nesnenin kendini referans etmesi çok kıymetlidir. Önceki örneklerden dönüştürelim. Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, kendiniTanit() { return `Ben ${this.isim}, numaram ${this.no}, sinifim ${this.sinif}`; } }; alert( ogrenci.kendiniTanit() ); // Asya öğrencisinin bilgileri let yeniOgrenci = Object.assign( {}, ogrenci ); yeniOgrenci.no = 1491; yeniOgrenci.isim = 'Ali'; yeniOgrenci.sinif = 8; alert( yeniOgrenci.kendiniTanit() ); // Ali öğrencisinin bilgileri Nesnenin adı yerine `**this**` deyimi ile nesnenin kendisini referans ettik. Metotları haricen oluşturup nesneye değer olarak da atayabiliriz. Yukarıdaki metodu harici bir fonksiyon ile de dönüştürebiliriz. (Çok kullanışlı olmasa da). Copy function kendiniTanit (obj) { return `Ben ${obj.isim}, numaram ${obj.no}, sinifim ${obj.sinif}`; } let ogrenci = { no:2301, isim:'Asya', sinif:7, kendiniTanit:kendiniTanit(this) } }; alert( ogrenci.kendiniTanit() ); Boş nesneleri fonksiyon olarak "_**anahtar:değer**_" ikilileri ile değer döndürerek oluşturmak daha kullanışlıdır. Bu da ES6 ile gelen bir yeniliktir. Örnek. Copy function isciOlustur (isim,gorev,maas) { return { isim, //isim:isim yazmaya gerek yok gorev, //gorev:gorevyazmaya gerek yok maas //maas:maas yazmaya gerek yok }; } let birIsci = isciOlustur('Ahmet','Usta','10.000') alert( birIsci.isim ); alert( birIsci.maas); Bunu yapabilmemizi sağlayan olay JavaScript dilinde **fonksiyonların bir nesne olarak tasarlanmış olması**dır. `**this**` deyimi sadece nesneleri referans etmez. Referans ettiği öğe, yürütülme esnasında `**.**` işaretinden önce olması gereken öğedir. `**this**` deyiminin sadece nesne ile sınırlı olmadığını bilmeniz gerekir. Şu örneklere bakınız. Copy //Sıkı mod "use strict"; function isci() { return this; } alert( isci() ); // undefined Copy // Normal mod function isci() { return this; } alert( isci() ); //[object Window] Pencere nesnesi Copy // Sıkı mod "use strict"; let x = this; alert(x); //[object Window] alert(x.length) // 0 'Pencere nesnesinin uzunluğu' alert(x.location) // bir adres 'Pencere nesnesinin adresi' `**this**` deyimi, koşullu operatör veya ok fonksiyonlarıyla kullanılırsa `**this**` **kaybolur**, nesneyi referans edemez. Örnek. Copy //Koşullu operatörlerde let nesne = { isim : 'Kaya', sifre : '1234', izinsiz: 'İzniniz yok!', sifreGoster: this.isim, sifreGizle: this.izinsiz, }; alert( nesne.isim == 'Kaya' ? nesne.sifreGoster : nesne.sifreGizle); //undefined Copy //Ok Fonksiyonlarda let nesne = { isim : 'Kaya', izinsiz: 'İzniniz yok!', kendiniTanit: let tanit = () => this.isim, kendiniGizle: let gizle = () => this.izinsiz, }; alert( nesne.kendiniTanit() ); //undefined `**this**` dile ait bir deyimdir (`**for**`, `**if**` ... gibi) referans ettiği öğeyi biz kontrol edemeyiz. [PreviousNesnelerde Fonksiyon Kullanımı ve Callbackchevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/nesnelerde-fonksiyon-kullanimi-ve-callback) [NextNesne Erişimcileri (Getter & Setter)chevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/nesne-erisimcileri-getter-and-setter) Last updated 2 years ago --- # Nesnelerde Fonksiyon Kullanımı ve Callback | JavaScript Eğitimi Nesnelerdeki anahtarların değerleri anonim bir fonksiyon olabilir. Örnek. Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, kendiniTanit:function () { return `Ben ${ogrenci.isim}, numaram ${ogrenci.no}, sinifim ${ogrenci.sinif}`; } }; alert(ogrenci.kendiniTanit); Fonksiyonu olduğu gibi `**string**` olarak gördük. O zaman bu fonksiyonu **callback** yapabiliriz. Hadi sonuna `**()**` koyarak deneyiniz. Copy alert( ogrenci.kendiniTanit() ); //callback Değeri fonksiyon olan özelliklere "**nesnenin metodu**" diyoruz. Bu metotları da **callback** ile yürütebiliyoruz. Nesnelerde değer olarak kullandığımız fonksiyonlar (yani nesnenin metodu) değer döndürmek zorunda değildir. **Değersiz fonksiyonlar** kullanarak 'yerinde' işlemler de yapabiliriz. Örnek. Copy let isci = { tcNo:12345678900, isim:'Güneş Gün', kidem:15, maas:12000, maasArtir: function () { let miktar = prompt("Yeni maaşı giriniz:",isci.maas); isci.maas = miktar; } // return kullanmadık (değersiz fonksiyon) }; alert(isci.maas); // 120000 isci.maasArtir(); //callback alert(isci.maas); // girdiğiniz miktar ES6 ile gelen yeniliklerden biri de bir nesne içinde bir fonksiyon (metot) yazarken anahtar tanımlamaya ve `**function**` deyimi yazmaya gerek olmamasıdır. Yani örnek olarak. Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, kendiniTanit() { // 'function' deyimi olmadan doğrudan yazdık. return `Ben ${ogrenci.isim}, numaram ${ogrenci.no}, sinifim ${ogrenci.sinif}`; } }; alert( ogrenci.kendiniTanit() ); Bu kullanımda fonksiyon adı doğrudan özellik (anahtar) olur. Ayrıca `**function**` deyimi kullanmanıza da gerek kalmaz. Bu sebeple daha okunaklı ve kısadır. Klon nesnelerin içindeki metotlar (fonksiyonlar), nesne isimleri değişeceği için (isci1, isci2 vb.) metotlar çalışmaz. Yani: Copy let ogrenci = { no:2301, isim:'Asya', sinif:7, kendiniTanit() { return `Ben ${ogrenci.isim}, numaram ${ogrenci.no}, sinifim ${ogrenci.sinif}`; } }; let yeniOgrenci = Object.assign( {}, ogrenci ); yeniOgrenci.no = 1491; yeniOgrenci.isim = 'Ali'; yeniOgrenci.sinif = 8; alert( yeniOgrenci.kendiniTanit() ); // kopyalandığı öğrencinin bilgilerini verir Dolayısıyla her nesnede aynı metodu nesne ismi ile yeniden yazmak gerekir mi? Hayır. Bunu yapmak saçmadır. Bu problemi `**this**` deyimi ile çözeriz. [PreviousNesnelerde Üç Nokta (Spread) Operatörüchevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/nesnelerde-uc-nokta-spread-operatoru) [Nextthis Deyimi ile Nesnenin Kendini Referans Etmesichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/this-deyimi-ile-nesnenin-kendini-referans-etmesi) Last updated 2 years ago --- # Nesne Erişimcileri (Getter & Setter) | JavaScript Eğitimi Bir nesnenin metotlarını oluştururken özellik adı vermeden doğrudan fonksiyon olarak yazabildiğimizi ifade etmiştik. Örnek. Copy let ogrenci = { isim:'Asya', soyisim:'GÜN', no:2301, bilgi() { return this.isim + ' ' + this.soyisim; }, }; alert( ogrenci.bilgi() ); Metotların başında `**get**` kullanımı ile bir metodu özellikmiş gibi `**()**` koymaya gerek kalmadan erişerek metodun döndürdüğü değeri elde edebiliriz. Güzel yanı ise `**get**` ile hesaplanan değerin haricen (nesne dışından) manipüle edilememesidir. Örnek. Copy let ogrenci = { isim:'Asya', soyisim:'GÜN', no:2301, get bilgi() { // get ekledik return this.isim + ' ' + this.soyisim; }, }; alert( ogrenci.bilgi ); // paranteze gerek kalmadı. ogrenci.bilgi = 'JavaScript'; // haricen manipüle ettik alert( ogrenci.bilgi ); // dışarıdan manipüle edilemez. Metotların başında `**set**` kullanımı ile nesne dışından bir değeri atama (`**=**`) ile alabilir ve parametre gibi nesnede işleyebiliriz. Örnek. Copy let ogrenci = { isim:'Asya', soyisim:'GÜN', dogumYili:2010, yabanciDil: '', set yabanciDilDegis(dil) { // set ekledik this.yabanciDil = dil; }, }; ogrenci.yabanciDilDegis = 'en'; //parametre yerine atama ile değeri aldık. alert(ogrenci.yabanciDil); `**set**` kullanarak bir metoda parametre göndermek yerine atama ile parametre işledik. `**set**` kullanmadan örnek şöyle olur. Copy let ogrenci = { isim:'Asya', soyisim:'GÜN', dogumYili:2010, yabanciDil: '', yabanciDilDegis(dil) { this.yabanciDil = dil; }, }; ogrenci.yabanciDilDegis('en'); // atama değil parametre olarak vermek gerekti. alert(ogrenci.yabanciDil); [Previousthis Deyimi ile Nesnenin Kendini Referans Etmesichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/this-deyimi-ile-nesnenin-kendini-referans-etmesi) [Nextfor .. in ile Nesnenin Özelliklerichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/object-nesne/for-..-in-ile-nesnenin-ozellikleri) Last updated 2 years ago --- # for .. of ile Dizilerin Yinelenmesi | JavaScript Eğitimi `**Array**` tipinin sıralanmış elemanlardan oluşması yinelenebilir bir yapı sunmaktadır. `**for .. of**` yinelemesi şu şekilde kullanılır. Örnek. Copy let dizi = ['T','R',1,9,2,3]; for (let eleman of dizi) { alert(eleman); } `**Array**`'lerin `**.keys()**`, `**.values()**` ve `**.entries()**` metotlarını kullanarak `**for**` ile yinelemek `**array**`'lerin `**object**` temellerini anlamaya yardımcı olur. Örnek. Copy let dizi = ['T','Ü','R','K','İ','Y','E']; let anahtarlar = dizi.keys(); //indisleri aldık. for (let anahtar of anahtarlar) { alert(`Anahtar: ${anahtar}`); } let degerler = dizi.values(); //değerleri aldık. for (let deger of degerler) { alert(`Değer: ${deger}`); } let elemanlar = dizi.entries(); //indis ve değeri aldık. for (let eleman of elemanlar) { alert(`Eleman: ${eleman}`); } [PreviousÜç Nokta (Spread) Operatörüchevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/uc-nokta-spread-operatoru) [NextArray Metotlarchevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/array-metotlar) Last updated 2 years ago --- # Üç Nokta (Spread) Operatörü | JavaScript Eğitimi `**Array.from()**` ve `**Array.concat()**`'dan daha kullanışlı bir sözdizimidir. `**...**` operatörü ile bir `**string**` veya `**array**`'in tüm elemanlarından oluşan bağımsız bir kopya yapılabilir. Örnek. Copy let dizi = [1,2,3]; str = 'Örnek'; let yeniDizi = [...dizi]; alert(yeniDizi); yeniDizi = [...str]; alert(yeniDizi); yeniDizi = [...'JavasScript'] alert(yeniDizi); Sayılar için denenirse **hata verir**. Kod yürütülmesi durur. Copy let nmbr = 123; let dizi = [...nmbr]; // 'nmbr is not iterable' alert(dizi); Farklı iki dizi için kullanılırsa dilimleme yapmadan birleştirir. Örnek. Copy let dil = ['JAVASCRIPT']; let site = ['hanuce.io']; let materyal = [...dil,...site] alert(materyal); // 'JAVASCRIPT,hanuce.io' çıktısı alınır Mesela `**Math**` kütüphanesinin metotlarını kullanırken dizileri argüman yapamazsınız. Hata verir. Örnek. Copy let sayilar = [1,2,3,4,5]; alert( Math.max(sayilar) ); // 'NaN' çıktısı alınır. Fakat `**...**` operatörü dilimleme yaptığı için bu sorunu çözer. Copy let sayilar = [1,2,3,4,5]; alert( Math.max(...sayilar) ); // '5' çıktısı alınır. [PreviousArray - Dizichevron-left](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi) [Nextfor .. of ile Dizilerin Yinelenmesichevron-right](https://hanuce.gitbook.io/javascript-egitimi/referans-reference-veri-tipleri/array-dizi/for-..-of-ile-dizilerin-yinelenmesi) Last updated 2 years ago ---