├── J-Class ├── 5-Instanceof.md ├── 3-Static properties.md ├── 1-Class.md ├── 4-Private&Public Properties.md └── 2-Class Inheritence.md ├── C-Objects ├── 5-Object Destructuring.md ├── 7-Object Getters-Setters.md ├── 3-Symbol Veri Türü.md ├── 4-Object Fonksiyonları.md ├── 2-Objeleler ve Kopyalama.md ├── 6-Object Property Flags.md └── 1-Objects.md ├── B-Temeller ├── 8-İleri Fonksiyonlar │ ├── 3-IIFE.md │ ├── 4-NFE.md │ ├── 1-Function Destructuring.md │ ├── 2-Rest Parameter.md │ ├── 7-Function Borrowing.md │ └── 6-Call ve Apply.md ├── 5-Fonksiyonlar │ ├── 2-Return'de Boşluk.md │ ├── 5-Arrow Fonksiyonlar.md │ ├── 1-Parametre Kavramı.md │ ├── 4-Function Declartion-Expression farkı.md │ ├── 6-Clousers.md │ └── 3-Fonksiyonlar ve Clean Code.md ├── 2-Veri Türleri │ ├── 2-JavaScript ve Matematik.md │ ├── 5-Type Coversion - Coercion.md │ ├── 3-Tür Dönüşümleri.md │ ├── 1-Veri Türleri Giriş.md │ └── 4-İşlem Operatörler.md ├── 6-Kod Kalitesi │ ├── 2-Babel.md │ └── 1-Yorum Satırları.md ├── 3-Karşılaştırmalar ve Kontroller.md │ ├── 2-Kontroller.md │ ├── 1-Karşılaştırmalar.md │ ├── 3-Operatörler.md │ └── 4-Switch.md ├── 4-Döngüler │ ├── 2-Döngü İsimlendirme.md │ ├── 1-Döngüleri Tanıyalım.md │ └── 3-For-Foreach farkı.md ├── 7-Operatörler │ ├── 1-New Operatörü.md │ ├── 3-Optional Chaining.md │ └── 2-This.md └── 1-Değişkenler │ ├── 2-JavaScript Değişkenleri.md │ ├── 3-Değişken İsimlendirme.md │ ├── 4-Değişkenler ve Kod Okunabilirliği.md │ └── 1-Değişken Kavramı.md ├── L-Ekstralar ├── 2-Global Window.md ├── 3-Hoisting Detay.md ├── 4-Strict Mode.md ├── 1-Lexical Environment.md └── 5-Generator & Iterator.md ├── K-Memory └── 1-Garbage Collection.md ├── LICENSE ├── M-Modules ├── 3-CommonJS.md ├── 2-Export-Import.md └── 1-Modules.md ├── A-Hoşgeldiniz ├── 3- Söz Dizimi.md ├── 1-Giriş.md └── 2-Nasıl Çalışır.md ├── I-Network Requests ├── 2-XMLHttpRequest.md └── 1-Fetch.md ├── G-Exception Handling ├── 1- Try & Catch.md └── 2-Types of Errors.md ├── D- Veri Türleri ve Fonksiyonları ├── 7-WeakMap & WeakSet.md ├── 9-Typed Arrays.md ├── 8-Date & Time.md ├── 5-Veriler Üzerinde İterasyon.md ├── 6-Map & Set.md ├── 1-Numbers.md ├── 3-Arrays.md ├── 2-Strings.md └── 4-Sık Kullanılan Array Fonksiyonları.md ├── F-Scope ├── 2-Lexical Scope.md └── 1-Block Scope.md ├── H-Asynchronous ├── 4-Promises.md ├── 5-Async & Await.md ├── 2-Event Loop.md ├── 1-setTimeout & setInterval.md └── 3-Callbacks.md ├── E-Prototype Inheritence └── 1-Prototype Inheritence.md └── README.md /J-Class/5-Instanceof.md: -------------------------------------------------------------------------------- 1 | ## Instanceof 2 | 3 | `instanceof` ile bir objenin bir class'ın instance'ı olup olmadığını kontrol edebiliriz. 4 | 5 | ```js 6 | class Rabbit {} 7 | 8 | let rabbit = new Rabbit(); 9 | 10 | alert( rabbit instanceof Rabbit ); // true 11 | ``` -------------------------------------------------------------------------------- /C-Objects/5-Object Destructuring.md: -------------------------------------------------------------------------------- 1 | ## Object Destructuring 2 | 3 | Object Destructuring, bir objenin key'lerini değişkenlere atamak için kullanılır. 4 | 5 | ```js 6 | let user = { 7 | name: "John", 8 | age: 30 9 | }; 10 | 11 | // objenin key'lerini değişkenlere atıyoruz 12 | let {name, age} = user; 13 | 14 | alert(name); // John 15 | alert(age); // 30 16 | ``` -------------------------------------------------------------------------------- /B-Temeller/8-İleri Fonksiyonlar/3-IIFE.md: -------------------------------------------------------------------------------- 1 | ## IIFE 2 | 3 | IIFE yani Immediately Invoked Function Expression, fonksiyonun tanımlandığı yerde çalıştırılmasıdır. Bu fonksiyonlar genellikle bir kere kullanılmak üzere tanımlanır. 4 | 5 | ```js 6 | (function () { 7 | console.log('IIFE'); 8 | })(); 9 | ``` 10 | 11 | Günümüzde bunun kullanımından kaçınmalıyız, ancak eski kodlarda sıkça rastlanabilir veya gerçekten ihtiyaç duyulduğunda kullanılabilir. -------------------------------------------------------------------------------- /B-Temeller/5-Fonksiyonlar/2-Return'de Boşluk.md: -------------------------------------------------------------------------------- 1 | ## Return'de Boşluk Bırakmak 2 | 3 | Bir fonksiyondan bir değer return ederken arada boşluk bırakırsak JavaScript otomatik olarak `;` ekler. Bu yüzden return'de boşluk bırakmamaya özen göstermeliyiz. 4 | 5 | ```js 6 | return 7 | (some + long + expression + or + whatever * f(a) + f(b)) // bu ifade hata verecektir. 8 | ``` 9 | 10 | Doğrusu: 11 | 12 | ```js 13 | return ( 14 | some + long + expression 15 | + or + 16 | whatever * f(a) + f(b) 17 | ) 18 | ``` 19 | -------------------------------------------------------------------------------- /B-Temeller/5-Fonksiyonlar/5-Arrow Fonksiyonlar.md: -------------------------------------------------------------------------------- 1 | ## Arrow Fonksiyonlar 2 | 3 | Arrow fonksiyonlar, fonksiyonları daha kısa yazmamızı sağlayan bir fonksiyon yazım şeklidir. 4 | 5 | ```js 6 | const myFunction = () => { 7 | console.log("Hello World!"); 8 | }; 9 | ``` 10 | 11 | Bu fonksiyonların this keyword'ü yoktur. Bu yüzden this keyword'ünü kullanmak istediğimizde dikkatli olmamız gerekir. 12 | 13 | ```js 14 | const myObject = { 15 | myMethod: () => { 16 | console.log(this); // window 17 | } 18 | }; 19 | ``` 20 | -------------------------------------------------------------------------------- /B-Temeller/2-Veri Türleri/2-JavaScript ve Matematik.md: -------------------------------------------------------------------------------- 1 | ## JavaScript ve Matematik 2 | 3 | JavaScript'te matematiksel işlemlerin bütününü güvenle yapabilirsiniz. Sıfıra bölme gibi durumlarda kod direkt olarak çökmez ve `Infinity` veya `-Infinity` gibi özel değerler döndürür. Ayrıca, `NaN` (Not a Number) değeri de matematiksel işlemler sonucunda elde edilebilir. 4 | 5 | ```js 6 | alert( 1 / 0 ); // Infinity 7 | alert( "not a number" / 2 ); // NaN 8 | alert( NaN + 1 ); // NaN 9 | alert( 3 * NaN ); // NaN 10 | alert( "not a number" / 2 - 1 ); // NaN 11 | ``` -------------------------------------------------------------------------------- /B-Temeller/6-Kod Kalitesi/2-Babel.md: -------------------------------------------------------------------------------- 1 | ## Babel 2 | 3 | Babel, JavaScript kodunun eski tarayıcılar tarafından anlaşılabilir hale getirilmesini sağlayan bir JavaScript derleyicisidir. 4 | 5 | Örneğin nullish coalescing operatorü (??) gibi yeni bir özellik, eski tarayıcılar tarafından anlaşılamaz. Bu durumda Babel, bu özelliği eski tarayıcılar tarafından anlaşılabilir hale getirir. 6 | 7 | ```js 8 | // before running the transpiler 9 | height = height ?? 100; 10 | 11 | // after running the transpiler 12 | height = (height !== undefined && height !== null) ? height : 100; 13 | ``` -------------------------------------------------------------------------------- /B-Temeller/3-Karşılaştırmalar ve Kontroller.md/2-Kontroller.md: -------------------------------------------------------------------------------- 1 | ## Kontroller 2 | 3 | JavaScript'te diğer programlama dillerinde olduğu gibi basitçe `if`, `elseif` ve `else` kullanarak koşullu ifadeler oluşturabiliriz. 4 | 5 | Benzer şekilde ? operatörü ile de koşullu ifadeler oluşturabiliriz. 6 | 7 | Örneğin: 8 | 9 | ```js 10 | let result = condition ? value1 : value2; 11 | ``` 12 | 13 | Tek satırda bir değişken içerisinde de kontrol yapabiliriz: 14 | 15 | ```js 16 | let age = 19; 17 | let accessAllowed = age > 18; 18 | console.log(accessAllowed); // true 19 | ``` 20 | 21 | 22 | -------------------------------------------------------------------------------- /J-Class/3-Static properties.md: -------------------------------------------------------------------------------- 1 | ## Static Properties 2 | 3 | Static property'ler instance ile doğrudan ilişkili olmayan property'lerdir. 4 | 5 | ```js 6 | class User { 7 | static staticMethod() { 8 | alert(this === User); 9 | } 10 | } 11 | 12 | User.staticMethod(); // true 13 | ``` 14 | 15 | Burada this User class'ını gösterir. 16 | 17 | ## Static Properties and Inheritance 18 | 19 | Static property'ler kalıtımla aktarılabilir. 20 | 21 | ```js 22 | class Animal { 23 | static planet = "Earth"; 24 | } 25 | 26 | class User extends Animal {} 27 | 28 | alert(User.planet); // Earth 29 | ``` 30 | -------------------------------------------------------------------------------- /B-Temeller/4-Döngüler/2-Döngü İsimlendirme.md: -------------------------------------------------------------------------------- 1 | ## Döngü İsimlendirme (Tag'leme) 2 | 3 | JavaScript'te her döngüye bir etiket, isim verebiliriz ve bu isimleri break/continue ile kullanabiliriz. 4 | 5 | ```js 6 | outer: for (let i = 0; i < 3; i++) { 7 | 8 | for (let j = 0; j < 3; j++) { 9 | 10 | let input = prompt(`Value at coords (${i},${j})`, ''); 11 | 12 | 13 | if (!input) break outer; // <-- 14 | 15 | 16 | } 17 | } 18 | 19 | alert('Done!'); 20 | ``` 21 | 22 | Bu etiketler herhangi bir yere atlamaya izin vermezler. 23 | 24 | ```js 25 | break label; 26 | 27 | label: for (...) 28 | ``` 29 | -------------------------------------------------------------------------------- /B-Temeller/7-Operatörler/1-New Operatörü.md: -------------------------------------------------------------------------------- 1 | ## New Operatörü 2 | 3 | new keyword'ü ile bir yapının instance'ı oluşturulabilir. Örneğin bir fonksiyondan instance oluşturulabilir. 4 | 5 | ```js 6 | function User(name) { 7 | this.name = name; 8 | this.isAdmin = false; 9 | } 10 | 11 | let user = new User("Jack"); 12 | 13 | alert(user.name); // Jack 14 | alert(user.isAdmin); // false 15 | ``` 16 | 17 | Bu örnek için fonksiyonun instance'ı new ile oluşturulduğunda aşağıdaki işlemler gerçekleşir: 18 | 19 | - Yeni bir boş obje oluşturulur ve this bu objeyi referans eder. 20 | - Fonksiyon içeriği yürütülür, this genellikle yeni oluşturulan objeyi değiştirir. 21 | - this objesi otomatik olarak döndürülür. 22 | 23 | ```js 24 | -------------------------------------------------------------------------------- /B-Temeller/3-Karşılaştırmalar ve Kontroller.md/1-Karşılaştırmalar.md: -------------------------------------------------------------------------------- 1 | ## String Karşılaştırmaları 2 | 3 | ```js 4 | alert( 'Z' > 'A' ); // true 5 | alert( 'Glow' > 'Glee' ); // true 6 | alert( 'Bee' > 'Be' ); // true 7 | ``` 8 | 9 | ## Diğer Türler 10 | 11 | JavaScript, farklı türlerdeki değerleri karşılaştırırken değerleri sayılara dönüştürür. 12 | 13 | ```js 14 | alert( '2' > 1 ); // true, 15 | alert( '01' == 1 ); // true 16 | 17 | alert( true == 1 ); // true 18 | alert( false == 0 ); // true 19 | ``` 20 | 21 | ## Object.is() 22 | 23 | `Object.is(a, b)` yöntemi, `===` ile aynı şekilde çalışır, ancak iki özel durumda farklı davranır: 24 | 25 | - `NaN` ile `NaN`'yi karşılaştırırken `true` döndürür. 26 | 27 | - `0` ile `-0`'yı karşılaştırırken `false` döndürür. 28 | 29 | ```js 30 | alert( Object.is(NaN, NaN) ); // true 31 | alert( Object.is(0, -0) ); // false 32 | ``` 33 | -------------------------------------------------------------------------------- /L-Ekstralar/2-Global Window.md: -------------------------------------------------------------------------------- 1 | ## Window 2 | 3 | JavaScrip'te window global bir nesnedir. Bu nesne, JavaScript'te tanımlanan tüm değişken ve fonksiyonları içerir. Bu nedenle, window nesnesi, JavaScript'te tanımlanan tüm değişken ve fonksiyonlara erişmek için kullanılabilir. 4 | 5 | ```js 6 | console.log(window); // window nesnesini yazdırır 7 | ``` 8 | 9 | Örneğin tanımlanmış bir değişkene veya fonksiyona başka bir yerden erişmek istediğimizde, window'u kullanabiliriz: 10 | 11 | ```js 12 | // make current user information global, to let all scripts access it 13 | window.currentUser = { 14 | name: "John" 15 | }; 16 | 17 | // somewhere else in code 18 | alert(currentUser.name); // John 19 | 20 | // or, if we have a local variable with the name "currentUser" 21 | // get it from window explicitly (safe!) 22 | alert(window.currentUser.name); // John 23 | ``` 24 | 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /B-Temeller/8-İleri Fonksiyonlar/4-NFE.md: -------------------------------------------------------------------------------- 1 | ## NFE 2 | 3 | NFE yani Named Function Expression, fonksiyonları değişkenlere atamak için kullanılır. 4 | 5 | ```js 6 | 7 | let sayHi = function func(who) { 8 | if (who) { 9 | alert(`Merhaba, ${who}`); 10 | } else { 11 | func("Ziyaretçi"); // func, fonksiyonun kendisine referans verir. 12 | } 13 | }; 14 | 15 | sayHi(); // Merhaba, Ziyaretçi 16 | ``` 17 | 18 | JavaScript'te fonksiyonlar birer objedir. Bu yüzden objelerdeki gibi property'lerine erişebiliriz. 19 | 20 | ## name özelliği 21 | 22 | Fonksiyonun name özelliği fonksiyonun adını döndürür. 23 | 24 | ```js 25 | function sayHi() { 26 | alert("Merhaba"); 27 | } 28 | 29 | alert(sayHi.name); // sayHi 30 | ``` 31 | 32 | ## length özelliği 33 | 34 | Fonksiyonun length özelliği fonksiyonun parametre sayısını döndürür. 35 | 36 | ```js 37 | function f1(a) {} 38 | function f2(a, b) {} 39 | function many(a, b, ...more) {} 40 | 41 | alert(f1.length); // 1 42 | alert(f2.length); // 2 43 | alert(many.length); // 2 44 | ``` 45 | -------------------------------------------------------------------------------- /K-Memory/1-Garbage Collection.md: -------------------------------------------------------------------------------- 1 | ## Garbage Collection 2 | 3 | Oluşturulan bir obje kullanılmadığında bellekten silinir. Bu işleme garbage collection denir. Bazı durumlarda ise silinemeyen objeler olabilir. Bunlar: 4 | 5 | - Global scope'da tanımlanan objeler 6 | - Yürütülen fonksiyonlar ve onun local değişkenleri, parametreleri 7 | - Nested fonksiyonlar ve onun local değişkenleri, parametreleri 8 | 9 | 10 | Garbage Collection basitçe bir yapıya erişim devam ettiği sürece objeyi bellekte tutar. O yapının herhangi bir yerinde erişim sona erdiğinde obje bellekten silinir. 11 | 12 | ```js 13 | let user = { 14 | name: "John" 15 | }; 16 | 17 | user = null; // bu satırda obje bellekten silinir 18 | ``` 19 | 20 | Eğer bir yapı başka bir değişkene kopyalanırsa mevcut yapı bellekte saklanmaya devam eder: 21 | 22 | ```js 23 | let user = { 24 | name: "John" 25 | }; 26 | 27 | let admin = user; // referans kopyalandı 28 | 29 | user = null; // user null oldu ama admin hala objeye erişebilir 30 | 31 | alert(admin.name); // John 32 | ``` 33 | -------------------------------------------------------------------------------- /B-Temeller/8-İleri Fonksiyonlar/1-Function Destructuring.md: -------------------------------------------------------------------------------- 1 | ## Function Desturcturing 2 | 3 | Fonksiyona gelenecek olan parametrelerin içerisindeki değerleri değişkenlere atamak için kullanılır. Bu, uzun fonksiyon parametrelerini daha okunabilir hale getirmek için kullanışlıdır. 4 | 5 | Örneğin: 6 | 7 | ```js 8 | function showMenu(title = "Untitled", width = 200, height = 100, items = []) { 9 | // ... 10 | } 11 | ``` 12 | 13 | Bu fonksiyonu çağırmak istesek şöyle bir kullanım yapabiliriz: 14 | 15 | ```js 16 | showMenu("My Menu", undefined, undefined, ["Item1", "Item2"]) 17 | ``` 18 | 19 | Burada undefined vermek yerine function destructuring kullanarak daha okunabilir bir kullanım yapabiliriz: 20 | 21 | ```js 22 | function showMenu({title = "Untitled", width = 200, height = 100, items = []}) { 23 | // ... 24 | } 25 | 26 | showMenu({ 27 | title: "My Menu", 28 | items: ["Item1", "Item2"] 29 | }) 30 | ``` 31 | 32 | Eğer tüm parametreleri default değerleriyle çağırmak istersek: 33 | 34 | ```js 35 | showMenu({}) 36 | ``` 37 | 38 | 39 | -------------------------------------------------------------------------------- /L-Ekstralar/3-Hoisting Detay.md: -------------------------------------------------------------------------------- 1 | ## Hoisting 2 | 3 | JavaScript hoisting, Türkçe olarak "kaldırma" veya "yükseleme" anlamına gelir ve JavaScript'in çalışma zamanındaki bir davranışıdır. Hoisting, JavaScript motorunun kodu nasıl yürüttüğüyle ilgili bir kavramdır ve genellikle değişkenlerin ve fonksiyonların tanımlanma süreciyle ilişkilidir. 4 | 5 | Hoisting, iki şekilde etkisini gösterir: 6 | 7 | ## Değişken Hoisting 8 | 9 | Hoisting, değişkenin tanımlanmasını veya açıklamasını, kodun ilgili kısmından önce gerçekleştiği gibi algılar. Bu, değişkenin var ya da let ile tanımlanmış olsa bile, kodun başında bir yükseltilmiş (hoisted) değişken olduğu anlamına gelir. 10 | 11 | ```js 12 | console.log(x); // Çıktı: undefined 13 | var x = 5; 14 | console.log(x); // Çıktı: 5 15 | ``` 16 | 17 | ## Fonksiyon Hoisting 18 | 19 | Fonksiyon tanımları da değişken hoisting gibi yukarı taşınır. Yani, fonksiyonlar, kodun ilgili kısmından önce çağrılabilirler. 20 | 21 | ```js 22 | foo(); // Çıktı: "Merhaba dünya!" 23 | 24 | function foo() { 25 | console.log("Merhaba dünya!"); 26 | } 27 | ``` -------------------------------------------------------------------------------- /C-Objects/7-Object Getters-Setters.md: -------------------------------------------------------------------------------- 1 | ## Object Getters-Setters 2 | 3 | Accessor Properties olarak bilinen getter ve setter'lar, obje property'lerine erişimde kullanılır. Bu property'lerin değerleri fonksiyonlardır. Bu fonksiyonlar obje property'lerine erişimde kullanılır. 4 | 5 | ```js 6 | const user = { 7 | firstName: "John", 8 | lastName: "Doe", 9 | get fullName() { 10 | return `${this.firstName} ${this.lastName}`; 11 | }, 12 | set fullName(value) { 13 | [this.firstName, this.lastName] = value.split(" "); 14 | } 15 | }; 16 | ``` 17 | 18 | Burada getter objenin bir property'si okunurken, setter ise bir property'ye değer atanırken çalışır. 19 | 20 | Bir objeye daha sonrasında defineProperty ile getter ve setter ekleyebiliriz. 21 | 22 | ```js 23 | const user = { 24 | firstName: "John", 25 | lastName: "Doe" 26 | }; 27 | 28 | Object.defineProperty(user, "fullName", { 29 | get() { 30 | return `${this.firstName} ${this.lastName}`; 31 | }, 32 | set(value) { 33 | [this.firstName, this.lastName] = value.split(" "); 34 | } 35 | }); 36 | ``` 37 | 38 | 39 | -------------------------------------------------------------------------------- /B-Temeller/8-İleri Fonksiyonlar/2-Rest Parameter.md: -------------------------------------------------------------------------------- 1 | ## Rest Parameter 2 | 3 | Rest parameter, bir fonksiyona sınırsız sayıda argüman göndermek için kullanılır. Rest parameter, fonksiyonun son parametresi olmalıdır. Rest parameter, bir dizi olarak fonksiyona gönderilir. 4 | 5 | ```js 6 | function sum(...args) { 7 | let total = 0; 8 | for (let i of args) { 9 | total += i; 10 | } 11 | return total; 12 | } 13 | ``` 14 | 15 | Fonksiyonda birden fazla parametre varsa rest paramter en son parametre olmalıdır. 16 | 17 | ```js 18 | function sum(a, b, ...args) { 19 | let total = a + b; 20 | for (let i of args) { 21 | total += i; 22 | } 23 | return total; 24 | } 25 | ``` 26 | 27 | ## arguments 28 | 29 | `arguments` değişkeni, fonksiyona gönderilen tüm argümanları içeren bir dizidir. `arguments` değişkeni, fonksiyonun içinde tanımlanmıştır ve fonksiyonun her yerinden erişilebilir. 30 | 31 | ```js 32 | function sum() { 33 | let total = 0; 34 | for (let i of arguments) { 35 | total += i; 36 | } 37 | return total; 38 | } 39 | ``` 40 | Arrow fonksiyonlarında `arguments` değişkeni kullanılamaz. 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 DogukanSakin 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /B-Temeller/3-Karşılaştırmalar ve Kontroller.md/3-Operatörler.md: -------------------------------------------------------------------------------- 1 | ## && And Operatörü 2 | 3 | Soldan sağa doğru işler ve ilk bulduğu hatalı değeri döndürür. 4 | 5 | ```js 6 | alert( 1 && 0 ); // 0 7 | alert( 1 && 5 ); // 5 8 | alert( null && 5 ); // null 9 | alert( 0 && "hi" ); // 0 10 | ``` 11 | 12 | Tüm sonuçlar doğruysa en sonuncuyu döndürür: 13 | 14 | ```js 15 | alert( 1 && 2 && 3 ); // 3, the last one 16 | ``` 17 | ## !! Operatörü 18 | 19 | Bir değerin boolean değerini döndürür. 20 | 21 | ```js 22 | alert( !!"non-empty string" ); // true 23 | alert( !!null ); // false 24 | ``` 25 | 26 | ## ?? Operatörü 27 | 28 | Nullish coalescing operator olarakta bilinir. Eğer ilk değer null veya undefined ise ikinci değeri döndürür. Dile yeni eklenmiştir. 29 | 30 | ```js 31 | let firstName = null; 32 | let nickName = "Supercoder"; 33 | let currentName = firstName ?? nickName ?? "Anonymous"; // Supercoder 34 | ``` 35 | 36 | Bunu || operatörü ile de yapabiliriz. || Operatörü ilk true değere sahip olanı döndürür. ?? Operatörü ise ilk tanımlanmış değeri döndürür. 37 | 38 | Örneğin: 39 | 40 | ```js 41 | let height = 0; 42 | 43 | alert(height || 100); // 100 44 | alert(height ?? 100); // 0 45 | ``` -------------------------------------------------------------------------------- /M-Modules/3-CommonJS.md: -------------------------------------------------------------------------------- 1 | ## CommonJS 2 | 3 | CommonJS, JavaScript için bir modül sistemi olup, dildeki modüllerin yazılıp yüklenmesini standartlaştırmayı amaçlar. Başlıca olarak sunucu tarafı JavaScript uygulamaları için tasarlanmış olup, Node.js adlı açık kaynaklı sunucu tarafı JavaScript çalışma zamanında yaygın bir şekilde kullanılmıştır. 4 | 5 | CommonJS'in temel fikri, JavaScript kodunu küçük, tekrar kullanılabilir modüllere bölmek ve büyük kod tabanlarını yönetmek ve bakımını yapmayı kolaylaştırmaktır. Her bir modül kendi kapsamına sahip olabilir ve modülden belirli fonksiyonlar, nesneler veya değişkenler başka kısımlarda kullanılmak üzere dışa aktarılabilir (export). Diğer modüller de bu dışa aktarılan öğeleri içe aktararak (import) temiz bir sorumluluk ayrımı oluştururlar. 6 | 7 | ```js 8 | // math.js 9 | exports.topla = function(a, b) { 10 | return a + b; 11 | }; 12 | 13 | exports.cikar = function(a, b) { 14 | return a - b; 15 | }; 16 | ``` 17 | 18 | ```js 19 | // app.js - math.js modülünü içe aktaran ve kullanarak işlem yapan bir CommonJS modülü 20 | const matematik = require('./math'); 21 | 22 | console.log(matematik.topla(5, 3)); // Çıktı: 8 23 | console.log(matematik.cikar(10, 2)); // Çıktı: 8 24 | ``` 25 | -------------------------------------------------------------------------------- /B-Temeller/5-Fonksiyonlar/1-Parametre Kavramı.md: -------------------------------------------------------------------------------- 1 | ## Parametre Kapsamı 2 | 3 | Fonksiyonlara parametre gönderildiğinde fonksiyonun kapsamı içerisinde geçerli olur ve yerel değişkenlere kopyalanır. 4 | 5 | ```js 6 | function showMessage(from, text) { 7 | 8 | from = '*' + from + '*'; 9 | 10 | alert( from + ': ' + text ); 11 | } 12 | 13 | let from = "Ann"; 14 | 15 | showMessage(from, "Hello"); // *Ann*: Hello 16 | 17 | alert( from ); // Ann 18 | ``` 19 | 20 | ## Default Parametreler 21 | 22 | Modern JavaScript'te gönderilmeden parametreleri nullish ile veya diğer kontrol yapılarıyla kontrol edebiliriz. 23 | 24 | ```js 25 | function showCount(count) { 26 | alert(count ?? "unknown"); 27 | } 28 | 29 | showCount(0); // 0 30 | showCount(null); // unknown 31 | showCount(); // unknown 32 | ``` 33 | 34 | ## Higher-Order Functions 35 | 36 | Higher-Order Functions (HOF), fonksiyonları parametre olarak alan veya fonksiyon döndüren fonksiyonlardır. 37 | 38 | ```js 39 | function ask(question, yes, no) { 40 | if (confirm(question)) yes() 41 | else no(); 42 | } 43 | 44 | function showOk() { 45 | alert( "You agreed." ); 46 | } 47 | 48 | function showCancel() { 49 | alert( "You canceled the execution." ); 50 | } 51 | 52 | 53 | 54 | ask("Do you agree?", showOk, showCancel); 55 | ``` -------------------------------------------------------------------------------- /J-Class/1-Class.md: -------------------------------------------------------------------------------- 1 | ## Class 2 | 3 | Class, object orienter programming için sıkça kullanılan bir terimdir. Class'lar, birbirine benzeyen nesneleri oluşturmak için kullanılır. Örneğin, bir araba class'ı oluşturduğumuzda, bu class'ı kullanarak birçok araba nesnesi oluşturabiliriz. Class'lar, birçok özelliği ve fonksiyonu içinde barındırabilir. 4 | 5 | ```js 6 | class User { 7 | 8 | constructor(name) { 9 | this.name = name; 10 | } 11 | 12 | sayHi() { 13 | alert(this.name); 14 | } 15 | 16 | } 17 | 18 | // Usage: 19 | let user = new User("John"); 20 | user.sayHi(); 21 | ``` 22 | 23 | JavaScript'te her class bir fonksiyondur. 24 | 25 | ## Class getter/setter 26 | 27 | Class'lar, getter ve setter fonksiyonlarını da içerebilir. Bu fonksiyonlar, class'ın özelliklerine erişmek için kullanılır. 28 | 29 | ```js 30 | class User { 31 | 32 | constructor(name) { 33 | // invokes the setter 34 | this.name = name; 35 | } 36 | 37 | get name() { 38 | return this._name; 39 | } 40 | 41 | set name(value) { 42 | if (value.length < 4) { 43 | alert("Name is too short."); 44 | return; 45 | } 46 | this._name = value; 47 | } 48 | 49 | } 50 | 51 | let user = new User("John"); 52 | 53 | alert(user.name); // John 54 | 55 | user = new User(""); // Name is too short. 56 | ``` -------------------------------------------------------------------------------- /A-Hoşgeldiniz/3- Söz Dizimi.md: -------------------------------------------------------------------------------- 1 | ## JavaScript'in Söz Dizimi 2 | 3 | Belki daha önce bir programlama diliyle ilgilendiyseniz kod bloklarının sonuna noktalı virgül kullanımının zorunlu olduğuna şahit olmuşsunuzdur. Ancak JavaScript'te bu iş böyle değil dilerseniz koymayabilirsiniz. 4 | 5 | Ancak okunabilirlik açısından şunu incelediğimizde şu kullanım yerine: 6 | 7 | ```js 8 | alert('Hello'); alert('World'); 9 | ``` 10 | 11 | Bu kullanımın daha okunabilir olduğunu görmek mümkün: 12 | 13 | ```js 14 | alert('Hello'); 15 | alert('World'); 16 | ``` 17 | 18 | ## Noktalı Virgül 19 | 20 | Her ne kadar yukarıda noktalı virgülün kullanımının zorunlu olmadığını belirtsemde bazı durumlarda gerçekten zorunlu olabiliyor. Örneğin: 21 | 22 | ```js 23 | alert("Hello"); 24 | 25 | [1, 2].forEach(alert); 26 | ``` 27 | 28 | Şöyle bir kod önce Hello ardından sırasıyla 1 ve 2'yi gösterir. Ancak şunu inceleyelim: 29 | 30 | ```js 31 | alert("Hello") 32 | 33 | [1, 2].forEach(alert); 34 | ``` 35 | 36 | Burada tek fark alert'te noktalı virgül olmaması. JavaScript Bu kodu şu hale getirerek yorumlar: 37 | 38 | ```js 39 | alert("Hello")[1, 2].forEach(alert); 40 | ``` 41 | Bu ise beklediğimiz sonucu bize göstermez. alert("Hello")[1, 2] sözdizimi alert'ten dönen değerleri okumaya çalışmaktır. Ancak alert bir değer döndürmez. Dolayısıyla kod hata verir. 42 | 43 | -------------------------------------------------------------------------------- /A-Hoşgeldiniz/1-Giriş.md: -------------------------------------------------------------------------------- 1 | ## Neden JavaScript? 2 | 3 | JavaScript başlangıçta web sayfalarını "canlı" hale getirmek için oluşturuldu. Çıkış motivasyonu bu olsa da şuan günümüzde en popüler programlama dili niteliğini taşıyor. Sadece JavaScript ile web, mobil, backend ve masaüstü uygulamaları geliştirebilirsiniz. Kullanım alanlarının fazlalığı beraberinde dilin popülerliğini ve dile ait topluluğun büyümesine yardımcı oluyor. 4 | 5 | ## LiveScr.. pardon JavaScript? 6 | 7 | JavaScript'in başlangıçta isminin LiveScript olması düşünülüyormuş. Ancak çıkış yıllarında (4 Aralık 1995 (27 yıl önce)) Java oldukça popüler bir dil olduğu için Java'nın küçük kardeşi olarak konumlandırabilmek adına isminin başına Live yerine Java eklenmiş. Bu da böyle bir bilgi her zaman teknik konuşacağız diye bir şey yok. Genel kültürde lazım. 8 | 9 | 10 | 11 | ## Geliştirme Ortamının Önemi 12 | 13 | JavaScript'in yapabilecekleri yazıldığı ortama bağlı olarak değişir. Örneğin Node.JS JavaScript'e dosya okuma/yazma, bir sunucuya istek göndermeye ve istek almaya yarar. Eğer Node.JS haricinde örneğin yalnızca web sayfasında kullanmak dosya okuma/yazma işlemlerini yapmanız kullanıcıların güvenliği açısından oldukça kısıtlanmıştır. 14 | 15 | 16 | -------------------------------------------------------------------------------- /B-Temeller/7-Operatörler/3-Optional Chaining.md: -------------------------------------------------------------------------------- 1 | ## Optional Chainig 2 | 3 | JavaScript'te optional chaining, bir nesne zincirinde yer alan özelliklere ve yöntemlere erişirken, zincirin herhangi bir noktasında hata almaktan kaçınmayı sağlayan bir özelliktir. Bu, özellikle nesne zincirindeki bir veya daha fazla özelliğin veya alt nesnenin değeri null veya undefined olduğunda sık kullanılan bir yaklaşımdır. 4 | 5 | ```js 6 | const user = { 7 | name: 'John', 8 | age: 30, 9 | address: { 10 | street: 'Main Street', 11 | city: 'New York' 12 | } 13 | }; 14 | ``` 15 | 16 | Eğer bu nesneye erişirken herhangi bir optional chaining kullanmazsak ve olmayan bir özelliğe erişmeye çalışırsak, hata alırız: 17 | 18 | ```js 19 | console.log(user.address.country); // Uncaught TypeError: Cannot read property 'country' of undefined 20 | ``` 21 | 22 | Bu hatayı önlemek için, optional chaining kullanabiliriz: 23 | 24 | ```js 25 | const array = [1,2,3,4,5,6] 26 | console.log(array?.length) // 6 27 | console.log(array?.[0]) // 1 28 | console.log(array?.[10]) // undefined 29 | ``` 30 | 31 | 32 | Obje fonksiyonlarına da optional chaining uygulayabiliriz: 33 | 34 | ```js 35 | let userAdmin = { 36 | admin() { 37 | alert("I am admin"); 38 | } 39 | }; 40 | 41 | let userGuest = {}; 42 | 43 | userAdmin.admin?.(); // I am admin 44 | 45 | userGuest.admin?.(); // nothing happens (no such method) 46 | ``` 47 | -------------------------------------------------------------------------------- /I-Network Requests/2-XMLHttpRequest.md: -------------------------------------------------------------------------------- 1 | ## XMLHttpRequest 2 | 3 | XMLHttpRequest, tarayıcı tabanlı web uygulamalarında kullanılan bir JavaScript nesnesidir ve sunucuyla iletişim kurmak için kullanılır. Bu nesne, AJAX (Asenkron JavaScript ve XML) teknolojisinin temelini oluşturur ve web sayfalarının dinamik olarak veri alışverişi yapmasına ve sayfa yenileme olmaksızın içeriği güncellemesine izin verir. 4 | 5 | XMLHttpRequest nesnesi, sunucudan veri almak veya sunucuya veri göndermek için HTTP veya HTTPS protokollerini kullanır. Bu, veri alışverişi için özellikle uygun olan asenkron bir yapıya sahiptir, bu sayede sayfanın diğer işlemlerini bloke etmeden veri alışverişi yapabilir. 6 | 7 | Örnek kullanım: 8 | 9 | ```js 10 | const xhr = new XMLHttpRequest(); 11 | xhr.open('GET', 'https://api.example.com/data'); 12 | xhr.responseType = 'json'; 13 | xhr.onload = () => { 14 | console.log(xhr.response); 15 | }; 16 | 17 | xhr.send(); 18 | ``` 19 | 20 | Önemli Not: XMLHttpRequest nesnesi modern tarayıcılarda hala kullanılabilir olsa da, daha yeni ve gelişmiş bir alternatif olan "Fetch API" ve "axios" gibi kütüphaneler daha yaygın olarak tercih edilmektedir. Bu kütüphaneler, daha kolay kullanım ve daha güvenli işlem gibi avantajlar sağlar. 21 | 22 | XMLHttpRequest üç durumda kullanılabilir: 23 | 24 | - Eski browser'ları desteklemek için 25 | - Mevcut script'lerde XMLHttpRequest kullanıldığı için 26 | - XMLHttpRequest'in sağladığı özelliklerin Fetch API'de bulunmaması (örneğin upload progess tracking için) 27 | -------------------------------------------------------------------------------- /B-Temeller/2-Veri Türleri/5-Type Coversion - Coercion.md: -------------------------------------------------------------------------------- 1 | ## Type Conversion - Coercion 2 | 3 | JavaScript'te, "type conversion" (tür dönüşümü) ve "type coercion" (tür dönüşümü) terimleri, bir veri türünden başka bir veri türüne geçişi ifade etmek için kullanılır. Bu terimler sıklıkla karıştırılır, ancak farklı anlamlara gelirler. 4 | 5 | ## Type Conversion 6 | 7 | Type conversion, bir veri değerini bir başka veri türüne dönüştürme işlemidir ve genellikle açıkça belirtilir. Bu işlem, değerin asıl türünü değiştirmez, sadece geçici olarak başka bir türe dönüşür. JavaScript, çeşitli veri türleri arasında dönüşüm yapmak için bazı yöntemler ve fonksiyonlar sağlar. 8 | 9 | Örneğin: 10 | 11 | ```js 12 | let strNumber = "42"; 13 | let numNumber = Number(strNumber); 14 | 15 | let numValue = 42; 16 | let strValue = String(numValue); 17 | 18 | let boolValue = true; 19 | let strBool = String(boolValue); 20 | ``` 21 | 22 | ## Type Coercion 23 | 24 | Type coercion ise, JavaScript'in ifade değerlerini farklı veri türlerine otomatik olarak dönüştürme yeteneğini ifade eder. Bu, bazen beklenmedik sonuçlara veya istenmeyen davranışlara neden olabilir. JavaScript, ifadelerin içinde farklı veri türleri bulunduğunda otomatik olarak bazı tür dönüşümleri yapar. 25 | 26 | Örneğin: 27 | 28 | ```js 29 | console.log("42" == 42); // true, "42" otomatik olarak 42'ye dönüştürülür 30 | console.log("1" + 1); // "11", 1 sayısı stringe dönüştürülerek birleştirme işlemi yapılır 31 | console.log(true + 1); // 2, true boolean değeri sayıya dönüştürülerek toplama yapılır 32 | ``` -------------------------------------------------------------------------------- /G-Exception Handling/1- Try & Catch.md: -------------------------------------------------------------------------------- 1 | ## Try & Catch 2 | 3 | try-catch blokları, programın çalışması sırasında oluşabilecek hataların önüne geçmek için kullanılır. Bu bloklar sayesinde programın çalışması sırasında oluşabilecek hataların önüne geçilir ve programın çalışması durdurulmaz. 4 | 5 | ```js 6 | try { 7 | // Hata oluşabilecek kodlar 8 | } catch (error) { 9 | // Hata olduğunda çalışacak kodlar 10 | }finally { 11 | // Opsiyonel: Her durumda çalışmasını istediğiniz kod bloğu 12 | } 13 | ``` 14 | 15 | Örneğin: 16 | 17 | ```js 18 | try { 19 | // Kullanıcıdan bir sayı girmesini isteyelim 20 | const sayi = Number(prompt("Bir sayı girin:")); 21 | 22 | // Girdiği sayıyı 2'ye bölelim 23 | const sonuc = sayi / 2; 24 | 25 | // Eğer girdiği değer bir sayı değilse veya NaN (Not-a-Number) ise bir hata oluşacaktır 26 | if (isNaN(sonuc)) { 27 | throw new Error("Geçersiz sayı"); 28 | } 29 | 30 | console.log("Sonuç:", sonuc); 31 | } catch (hata) { 32 | // Hata durumunda bu blok çalışır 33 | console.error("Hata oluştu:", hata.message); 34 | } finally { 35 | // Her durumda çalışacak kodlar burada yer alır 36 | console.log("İşlem tamamlandı."); 37 | } 38 | ``` 39 | 40 | Try-catch yapısı, programların daha güvenli ve hataya dayanıklı olmasını sağlar. Ancak, her zaman hata yakalama bloklarını kullanmak yerine hataların oluşma olasılığını en aza indirmeye özen göstermek daha iyi bir uygulama geliştirmeye yardımcı olur. Çok fazla try-catch kullanmak, kodun okunabilirliğini azaltabilir ve performansı olumsuz etkileyebilir. 41 | -------------------------------------------------------------------------------- /B-Temeller/6-Kod Kalitesi/1-Yorum Satırları.md: -------------------------------------------------------------------------------- 1 | ## Yorum Satırları 2 | 3 | Yorum satırları, kodun anlaşılması, bakımı ve işbirliği için önemli bir araçtır. İyi bir clean code (temiz kod) pratiğiyle birlikte, yorum satırlarını aşağıdaki durumlarda eklemek veya eklememek genellikle önerilir: 4 | 5 | - Karmaşık Mantıksal İfadeler: Karmaşık bir kod parçası veya algoritma varsa, bu kısımları açıklayan yorum satırları eklemek faydalı olabilir. Bu şekilde, kodun nasıl çalıştığı hakkında daha fazla anlayış sağlanır. 6 | 7 | ```js 8 | // Dizi elemanlarını toplar 9 | // ve sonucu döndürür. 10 | function toplam(dizi) { 11 | let toplam = 0; 12 | for (let i = 0; i < dizi.length; i++) { 13 | toplam += dizi[i]; 14 | } 15 | return toplam; 16 | } 17 | ``` 18 | 19 | - Önemli Notlar veya Dikkat Edilmesi Gereken Durumlar: Bazı kod parçalarında, özellikle önemli veya dikkate değer notlar varsa, bunları yorum satırlarıyla belirtmek önemlidir. Örneğin, performans etkileri veya dış bağımlılıklar gibi konular bu kategoriye girer. 20 | 21 | ```js 22 | // Dikkat: Bu işlev dış bir API'yi çağırıyor 23 | // ve geri dönüş süresi uzun olabilir. 24 | function verileriCek() { 25 | // ... 26 | } 27 | ``` 28 | 29 | - Açıklayıcı İsimlendirme Kullanımı: İyi bir clean code pratiği, kodun kendisini açıklayıcı ve anlaşılır bir şekilde yazmaktır. Eğer kodunuzda açıklayıcı isimlendirme kullanıyorsanız, yorum satırı eklemek genellikle gerekli değildir. 30 | 31 | ```js 32 | // Yorum satırı gereksiz, işlevin amacı zaten isminden anlaşılıyor. 33 | function toplama(sayi1, sayi2) { 34 | return sayi1 + sayi2; 35 | } 36 | ``` 37 | 38 | - -------------------------------------------------------------------------------- /B-Temeller/4-Döngüler/1-Döngüleri Tanıyalım.md: -------------------------------------------------------------------------------- 1 | ## While Loop 2 | 3 | While döngüsü, belirli bir koşul sağlandığı sürece döngüyü çalıştırmaya devam eder. 4 | 5 | ```js 6 | let i = 0; 7 | while (i < 3) { // shows 0, then 1, then 2 8 | alert( i ); 9 | i++; 10 | } 11 | ``` 12 | 13 | Burada herhangi bir koşul olmazsa sonsuz döngü oluşacaktır. 14 | 15 | ## For Loop 16 | 17 | Benzer şekilde for döngüsü de belirli bir koşul sağlandığı sürece döngüyü çalıştırmaya devam eder. Başlangıç, ilerleyiş miktarı ve bitiş koşullarını tanımlama esnasında belirleyebiliriz. 18 | 19 | ```js 20 | for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2 21 | alert(i); 22 | } 23 | ``` 24 | 25 | Burada istediğimiz herhangi bir kısmı boş bırakabiliriz. Örneğin başlangıç noktasını belirlemeyebiliriz: 26 | 27 | ```js 28 | let i = 0; // we have i already declared and assigned 29 | 30 | for (; i < 3; i++) { // no need for "begin" 31 | alert( i ); // 0, 1, 2 32 | } 33 | ``` 34 | 35 | ## Break ve Continue 36 | 37 | Döngü içerisinde break ifadesiyle döngüyü sonlandırabiliriz. 38 | 39 | ```js 40 | 41 | let sum = 0; 42 | 43 | while (true) { 44 | 45 | let value = +prompt("Enter a number", ''); 46 | 47 | if (!value) break; // (*) 48 | 49 | sum += value; 50 | 51 | } 52 | alert( 'Sum: ' + sum ); 53 | ``` 54 | 55 | Benzer şekilde continue ifadesiyle döngüyü sonlandırmadan bir sonraki adıma geçebiliriz. 56 | 57 | ```js 58 | 59 | for (let i = 0; i < 10; i++) { 60 | 61 | // if true, skip the remaining part of the body 62 | if (i % 2 == 0) continue; 63 | 64 | alert(i); // 1, then 3, 5, 7, 9 65 | } 66 | ``` 67 | 68 | 69 | -------------------------------------------------------------------------------- /D- Veri Türleri ve Fonksiyonları/7-WeakMap & WeakSet.md: -------------------------------------------------------------------------------- 1 | Map ve Set'ten farklı olarak WeakMap ve WeakSet, WeakMap ve WeakSet nesneleri için özel bir bellek yönetimi sağlar. WeakMap ve WeakSet nesneleri, WeakMap ve WeakSet nesneleri dışında başka bir referans olmadığında bellekten silinir. 2 | 3 | ## WeakMap 4 | 5 | Map'ten farkı key'ler obje olmalıdır. Yani map'teki gibi string olamaz. WeakMap'te key'lerin referansı tutulur. Eğer key'in referansı başka bir yerde tutulmuyorsa, WeakMap'ten silinir. 6 | 7 | ```js 8 | let obj = { name: 'John' }; 9 | 10 | const map = new WeakMap(); 11 | map.set(obj, 'John Doe'); 12 | 13 | obj = null; 14 | ``` 15 | 16 | WeakMap'ler iterable değildir. Dolayısıyla yalnızca şu fonkisyonlara sahiptir: 17 | 18 | - `get(key)`: WeakMap içerisindeki bir key'in değerini döner. 19 | - `set(key, value)`: WeakMap içerisine yeni bir key-value çifti ekler. 20 | - `has(key)`: WeakMap içerisinde bir key'in bulunup bulunmadığını kontrol eder. Eğer key, WeakMap içerisinde bulunuyorsa, `true` değeri döner. Eğer key, WeakMap içerisinde bulunmuyorsa, `false` değeri döner. 21 | - `delete(key)`: WeakMap içerisinde bir key'i siler. Eğer key, WeakMap içerisinde bulunuyorsa, `true` değeri döner. Eğer key, WeakMap içerisinde bulunmuyorsa, `false` değeri döner. 22 | 23 | ## WeakSet 24 | 25 | Set'ten farkı elemanlar obje olmalıdır. Yani set'teki gibi string olamaz. WeakSet'te elemanların referansı tutulur. Eğer elemanın referansı başka bir yerde tutulmuyorsa, WeakSet'ten silinir. 26 | 27 | ```js 28 | let obj = { name: 'John' }; 29 | 30 | const set = new WeakSet(); 31 | set.add(obj); 32 | 33 | obj = null; 34 | ``` 35 | -------------------------------------------------------------------------------- /B-Temeller/8-İleri Fonksiyonlar/7-Function Borrowing.md: -------------------------------------------------------------------------------- 1 | ## Function Borrowing 2 | 3 | JavaScript'te "Function Borrowing", bir nesnenin diğer bir nesnenin metodunu kullanabilmesine olanak sağlayan bir programlama kavramıdır. Bu, nesneler arasında fonksiyonları paylaşma ve yeniden kullanma yeteneği sunar ve kod tekrarını azaltır. Function Borrowing, özellikle JavaScript'te nesne tabanlı programlama ve fonksiyonel programlama uygulamalarında sıkça kullanılan bir tekniktir. 4 | 5 | ```js 6 | const person1 = { 7 | name: "John", 8 | age: 30, 9 | sayHello: function() { 10 | console.log(`Hello, my name is ${this.name}.`); 11 | } 12 | }; 13 | 14 | const person2 = { 15 | name: "Alice", 16 | age: 25 17 | }; 18 | 19 | // person1 nesnesinin sayHello metodu, person2 nesnesi tarafından ödünç alınıyor 20 | person1.sayHello.call(person2); 21 | 22 | // Hello, my name is Alice. 23 | ``` 24 | 25 | Yukarıdaki örnekte, person1 ve person2 adında iki ayrı nesne tanımlanmıştır. person1 nesnesinde bir sayHello metodu bulunmaktadır. Ancak, person2 nesnesinde böyle bir metot yoktur. Bu durumda call metodunu kullanarak person1 nesnesinin sayHello metodunu person2 nesnesine ödünç veriyoruz. call metodu, bir fonksiyonu belirli bir bağlamda (this değeri) çalıştırmak için kullanılır. İlk argüman olarak geçtiğimiz nesne, this anahtar kelimesinin referansını oluşturacaktır. 26 | 27 | Sonuç olarak, person2 nesnesi, person1 nesnesinin sayHello metodunu kullanarak "Hello, my name is Alice." mesajını konsola yazdıracaktır. 28 | 29 | Bu şekilde, JavaScript'te Function Borrowing kullanarak bir nesnenin başka bir nesnenin metodlarını kullanabilmesi, kodun daha esnek ve tekrar kullanılabilir olmasını sağlar. -------------------------------------------------------------------------------- /F-Scope/2-Lexical Scope.md: -------------------------------------------------------------------------------- 1 | ## Lexical Scope 2 | 3 | JavaScript'teki "lexical scope" (lexical kapsam), bir değişkenin nereden erişilebileceğini belirleyen kapsam türüdür. Bu kapsam türü, değişkenin kodun hangi bölümünde tanımlandığına dayanır ve değişkenin kapsamı, tanımlandığı yeri çevreleyen kod yapısına göre belirlenir. Başka bir deyişle, lexical scope, değişkenin belirli bir kod bloğu veya fonksiyon içinde erişilebilir olacağı anlamına gelir. 4 | 5 | JavaScript'te lexical scope, programcının kodu yazarken doğal olarak oluşturduğu kapsamı ifade eder. Değişkenler, tanımlandıkları blok veya fonksiyonun "scope"u içinde erişilebilir ve dışında erişilemezler. 6 | 7 | ```js 8 | function outerFunction() { 9 | const outerVariable = 'Bu bir dış değişkendir'; 10 | 11 | function innerFunction() { 12 | const innerVariable = 'Bu bir iç değişkendir'; 13 | console.log(outerVariable); // Çıktı: "Bu bir dış değişkendir" 14 | console.log(innerVariable); // Çıktı: "Bu bir iç değişkendir" 15 | } 16 | 17 | innerFunction(); 18 | } 19 | 20 | outerFunction(); 21 | console.log(outerVariable); // Hata: outerVariable tanımsız 22 | console.log(innerVariable); // Hata: innerVariable tanımsız 23 | ``` 24 | 25 | Lexical scope, bir fonksiyonun tanımlandığı yeri baz alır ve o fonksiyon nerede çağrılırsa çağrılsın, o tanımlanan yere göre kapsam belirlenir. Bu da kapsamın tahmin edilebilir ve mantıklı bir şekilde oluşturulmasını sağlar. 26 | 27 | ES6 ile tanıtılan let ve const anahtar kelimeleri, block scope oluşturarak lexical scope konusunu daha da güçlendirmiştir. Böylece let ve const ile tanımlanan değişkenler sadece belirli bir kod bloğunda (blok kapsamında) geçerlidir ve dışarıdaki kod bu değişkenlere erişemez. Ancak var anahtar kelimesi function scope oluşturur ve lexical scope kurallarına uymaz. -------------------------------------------------------------------------------- /M-Modules/2-Export-Import.md: -------------------------------------------------------------------------------- 1 | ## Export - Import 2 | 3 | Tanımlamalardan önce export yapabiliriz: 4 | 5 | ```js 6 | export const pi = 3.14159265359; 7 | 8 | export function square(x) { 9 | return x * x; 10 | } 11 | ``` 12 | 13 | Burada noktali virgül kullanmak çoğu JavaScript style guids tarafından önerilmez. 14 | 15 | `import *` ile tüm fonksiyonları ve değişkenleri içeri aktarabiliriz: 16 | 17 | ```js 18 | import * as utils from './utils.js'; 19 | 20 | console.log(utils.square(5)); // Çıktı: 25 21 | 22 | console.log(utils.pi); // Çıktı: 3.14159265359 23 | ``` 24 | 25 | `import as` ile fonksiyonları ve değişkenleri yeniden adlandırabiliriz: 26 | 27 | ```js 28 | import { square as kare, pi as PI } from './utils.js'; 29 | 30 | console.log(kare(5)); // Çıktı: 25 31 | 32 | console.log(PI); // Çıktı: 3.14159265359 33 | ``` 34 | 35 | `export as ` ile fonksiyonları ve değişkenleri yeniden adlandırabiliriz: 36 | 37 | ```js 38 | function square(x) { 39 | return x * x; 40 | } 41 | 42 | const pi = 3.14159265359; 43 | 44 | export { square as kare, pi as PI }; 45 | ``` 46 | 47 | `export default` ile bir modülün varsayılan değerini dışa aktarabiliriz: 48 | 49 | ```js 50 | // utils.js 51 | 52 | export default function(x) { 53 | return x * x; 54 | } 55 | ``` 56 | 57 | ```js 58 | 59 | // main.js 60 | 61 | import square from './utils.js'; 62 | 63 | console.log(square(5)); // Çıktı: 25 64 | ``` 65 | 66 | Bir dosyanın yalnızca bir default export'u olabilir. 67 | 68 | 69 | ## Re-export 70 | 71 | re-export bir modülün içindeki belirli bir içeriği başka bir modülde tekrar kullanılabilir hale getirme işlemidir. 72 | 73 | Çeşitleri: 74 | 75 | - export [default] class/function/variable 76 | - export {x [as y], ...}. 77 | - export * from ... [as y]. 78 | - export {default [as y]} from "module" -------------------------------------------------------------------------------- /D- Veri Türleri ve Fonksiyonları/9-Typed Arrays.md: -------------------------------------------------------------------------------- 1 | ## Typed Arrays 2 | 3 | JavaScript'teki Typed Array, düşük seviyeli veri depolama ve manipülasyonu için kullanılan özel bir veri türüdür. Tipik JavaScript dizilerinden (Array) farklı olarak, Typed Array'ler belirli bir veri türünde (örneğin, sayılar veya baytlar) sabit uzunluğa sahip bir bellek alanıdır. Bu nedenle, Typed Array'ler daha az bellek tüketir ve veri işlemlerini daha hızlı hale getirir. Bu veri türleri, web tarayıcılarında ve Node.js gibi JavaScript çalıştırma ortamlarında bulunur. 4 | 5 | JavaScript'te beş farklı türde Typed Array bulunmaktadır: 6 | 7 | - Int8Array: 8-bit işaretli tam sayılar 8 | - Uint8Array: 8-bit işaretsiz tam sayılar 9 | - Int16Array: 16-bit işaretli tam sayılar 10 | - Uint16Array: 16-bit işaretsiz tam sayılar 11 | - Float32Array: 32-bit kayan noktalı sayılar 12 | 13 | Bunlar, sayılarla çalışmak için kullanışlıdır ancak özel durumlar için tek başına yeterli değillerdir. Dolayısıyla, ECMAScript 2015 (ES6) ile birlikte Typed Array'leri destekleyen ve daha fazla esneklik sunan bir diğer veri türü de eklenmiştir: 14 | 15 | - Uint8ClampedArray: 8-bit işaretsiz tam sayılar (0 ile 255 arasında) - Genellikle görüntü işleme ile ilgili kullanılır. 16 | Typed Array'lerin kullanımı, ArrayBuffer adı verilen bir bellek alanında verileri saklayarak gerçekleştirilir. ArrayBuffer, sabit uzunlukta bellek bloklarının temelini oluşturur ve Typed Array'ler bu bellek bloklarının üzerinde çalışır. Bu, veri kopyalamayı önleyerek ve bellek kullanımını optimize ederek veri işlemlerini hızlandırır. 17 | 18 | ```js 19 | const typedArray = new Uint8Array(10); 20 | 21 | for (let i = 0; i < typedArray.length; i++) { 22 | typedArray[i] = i * 2; 23 | } 24 | 25 | 26 | for (let i = 0; i < typedArray.length; i++) { 27 | console.log(typedArray[i]); 28 | } 29 | ``` 30 | -------------------------------------------------------------------------------- /C-Objects/3-Symbol Veri Türü.md: -------------------------------------------------------------------------------- 1 | ## Symbol 2 | 3 | Bir objenin key'i sadece string veya symbol olabilir. JavaScript'te Symbol, benzersiz ve değişmez bir veri türüdür. Symbol'ler, diğer JavaScript değerlerinden farklı olarak, her biri tamamen eşsiz olan bir anahtara sahiptir. Bu nedenle, Symbol'ler özellikle nesne özelliklerini tanımlamak için kullanılırken çakışma riskini en aza indirmek amacıyla tercih edilir. 4 | 5 | ```js 6 | const mySymbol = Symbol(); 7 | const myOtherSymbol = Symbol(); 8 | console.log(mySymbol === myOtherSymbol); // false 9 | ``` 10 | 11 | Symbol'ler genellikle nesne özellikleri olarak kullanılır. Bu, özelliklerin çakışma riskini azaltır çünkü Symbol'lerin anahtarları diğer özelliklerle karışmaz: 12 | 13 | ```js 14 | const mySymbol = Symbol("Açıklama"); 15 | const obj = {}; 16 | 17 | obj[mySymbol] = "Bu Symbol ile ilişkilendirilen bir değer"; 18 | console.log(obj[mySymbol]); // Bu Symbol ile ilişkilendirilen bir değer 19 | ``` 20 | 21 | Symbol'ler bir objenin içerisinde iterasyon esnasında görünmezler. Bu, Symbol'lerin özelliklerin çakışmasını önlemek için kullanıldığı anlamına gelir. 22 | 23 | ```js 24 | let id = Symbol("id"); 25 | let user = { 26 | name: "John", 27 | age: 30, 28 | [id]: 123 29 | }; 30 | 31 | for (let key in user) alert(key); // name, age (no symbols) 32 | 33 | // the direct access by the symbol works 34 | alert( "Direct: " + user[id] ); // Direct: 123 35 | ``` 36 | 37 | Symbol'ler, Object.getOwnPropertySymbols() veya Reflect.ownKeys() gibi özel yöntemler kullanılarak nesnelerdeki Symbol özelliklerini elde etmek için kullanılabilir. 38 | 39 | Symbol'ler, JavaScript dilinde bazı yerleşik sembol değerlerine de sahiptir. Örneğin, Symbol.iterator, Symbol.match, Symbol.species gibi semboller, belirli işlemleri gerçekleştirmek üzere kullanılır ve özellikle veri yapılarının davranışlarını tanımlamak için önemlidir. -------------------------------------------------------------------------------- /B-Temeller/4-Döngüler/3-For-Foreach farkı.md: -------------------------------------------------------------------------------- 1 | ## For - Foreach Farkı 2 | 3 | JavaScript'te for ve forEach döngü yapıları, farklı senaryolarda tercih edilir ve bazı farklara sahiptir. 4 | 5 | For: 6 | 7 | - Genel amaçlı bir döngü yapısıdır ve çeşitli durumlar için uygundur. 8 | - Döngünün her bir adımında, kontrol değişkeni üzerinden koşul kontrolü yapılır ve döngü bloğu çalıştırılır. 9 | - Kontrol değişkeni, başlangıç değeri, bitiş koşulu ve adım değeri belirtilerek kontrol edilir. 10 | - break ifadesiyle döngü erken sonlandırılabilir veya continue ifadesiyle bir adım atlanabilir. 11 | - Döngüdeki her bir elemana erişim sağlamak için indeks kullanılabilir. 12 | 13 | Örneğin: 14 | 15 | ```js 16 | for (let i = 0; i < array.length; i++) { 17 | console.log(array[i]); 18 | } 19 | ``` 20 | 21 | forEach: 22 | 23 | - Dizi üzerinde gezinmek için özel olarak tasarlanmış bir döngü yapısıdır. 24 | - Dizi elemanlarına erişim sağlamak için daha kolay ve okunabilir bir yol sunar. 25 | - Dizi üzerinde gezinirken her eleman için belirtilen bir fonksiyonu çalıştırır. 26 | - Dizi elemanlarının sırasını korur ve indekslere gerek duyulmadan erişim sağlar. 27 | - break veya continue ifadeleri kullanılamaz. 28 | 29 | Örneğin: 30 | 31 | ```js 32 | array.forEach(function(element) { 33 | console.log(element); 34 | }); 35 | ``` 36 | 37 | Farklılıklar: 38 | 39 | - for döngüsü, daha genel amaçlıdır ve her türlü döngü senaryosuna uygundur. forEach ise özellikle bir dizi üzerinde gezinmek için kullanılır. 40 | - for döngüsü, indeks tabanlı erişim sağlar ve indeksleri kontrol ederek dizi üzerinde gezinir. forEach ise her eleman için belirtilen bir fonksiyonu çalıştırarak diziye erişir. 41 | - for döngüsü, break veya continue ifadeleriyle kontrol akışını değiştirebilirken, forEach bu imkanı sağlamaz. 42 | - forEach, daha okunabilir bir sözdizimi sunar ve daha az kod yazmanızı sağlar, ancak bazı durumlarda performans açısından for döngüsü tercih edilebilir. -------------------------------------------------------------------------------- /B-Temeller/5-Fonksiyonlar/4-Function Declartion-Expression farkı.md: -------------------------------------------------------------------------------- 1 | ## Fonksiyon Declartion-Expression Farkı 2 | 3 | JavaScript'te "Function Declaration" ve "Function Expression" olmak üzere iki farklı fonksiyon tanımlama yöntemi vardır. Bu iki yöntem arasındaki farklar aşağıdaki gibi özetlenebilir: 4 | 5 | Function Declaration (Fonksiyon Bildirimi): 6 | 7 | - Fonksiyonlar, function anahtar kelimesiyle ve isimleriyle birlikte doğrudan tanımlanır. 8 | - Fonksiyon bildirimleri, tanımlandıkları kapsamın başına yükseltilir (hoisted). Bu nedenle, fonksiyon bildirimi, tanımlandığı yerden önce çağrılabilir. 9 | - Fonksiyon bildirimi, global kapsamda, başka bir fonksiyon içinde veya blok içinde tanımlanabilir. 10 | 11 | ```js 12 | function sayHello() { 13 | console.log("Merhaba!"); 14 | } 15 | 16 | sayHello(); // Fonksiyon bildirimi çağrısı 17 | ``` 18 | 19 | Function Expression (Fonksiyon İfadesi): 20 | 21 | - Fonksiyonlar, bir değişkene atanarak ifade edilir. 22 | - Fonksiyon ifadeleri, değişkenin tanımlandığı yerden sonra çağrılabilir. 23 | - Fonksiyon ifadeleri, değişkenin atanmasından sonra kullanılabilir. 24 | - Function Expression, genellikle anonim fonksiyonlar (isimsiz fonksiyonlar) veya IIFE'ler (Immediately Invoked Function Expressions) oluşturmak için kullanılır. 25 | 26 | ```js 27 | const sayHello = function() { 28 | console.log("Merhaba!"); 29 | }; 30 | ``` 31 | 32 | Fonksiyon bildirimleri ve fonksiyon ifadeleri arasındaki en önemli fark, hoisting (yükseltme) davranışıdır. Fonksiyon bildirimleri hoisted olduğu için, tanımlandıkları yerden önce çağrılabilirler. Fonksiyon ifadeleri ise değişkenler olarak tanımlanır ve hoisted olmazlar, bu nedenle tanımlandıkları yerden sonra çağrılmaları gerekmektedir. 33 | 34 | ```js 35 | sayHello(); // Fonksiyon bildirimi çağrısı 36 | function sayHello() { 37 | console.log("Merhaba!"); 38 | } 39 | 40 | sayHi(); // Hata: sayHi is not a function 41 | var sayHi = function() { 42 | console.log("Merhaba!"); 43 | }; 44 | ``` 45 | -------------------------------------------------------------------------------- /H-Asynchronous/4-Promises.md: -------------------------------------------------------------------------------- 1 | ## Promises 2 | 3 | JavaScript Promise, JavaScript dilinde asenkron işlemleri yönetmek ve daha okunabilir, düzenli kod yazmak için kullanılan bir yapıdır. Asenkron işlemler, genellikle ağ istekleri, dosya okuma/yazma, veritabanı sorguları gibi işlemlerdir ve bu tür işlemler genellikle zaman alabilirler. Promise'lar, bu tür asenkron işlemleri daha etkili bir şekilde yönetmeyi sağlar. 4 | 5 | Promise, gelecekte tamamlanacak bir işlemi temsil eden bir nesnedir. Bir işlem başlatıldığında, o işlemin sonucu henüz bilinmeyebilir, ancak Promise, işlemin başarılı bir şekilde tamamlandığından veya bir hata ile sonuçlandığından bağımsız olarak, sonuç hakkında bir bilgi sunar. Bu, callback işlevlerine göre daha düzenli ve anlaşılır bir kod yazmamıza olanak tanır. 6 | 7 | Promise'ın üç temel durumu vardır: 8 | 9 | - "pending" (Beklemede): Promise henüz tamamlanmamış durumda. 10 | - "fulfilled" (Gerçekleşmiş): Promise, başarıyla sonuçlandı ve sonuç değeri mevcut. 11 | - "rejected" (Reddedilmiş): Promise, bir hata nedeniyle başarısız oldu ve hata nedeni mevcut. 12 | 13 | Promise, iki argüman alan bir yapıya sahiptir: bir yürütme işlevi (executor) ve iki geri çağırma işlevi (resolve ve reject). Executor işlevi, Promise oluşturulduğunda otomatik olarak çalıştırılır ve genellikle asenkron bir işlemi başlatır. 14 | 15 | ```js 16 | // Basit bir asenkron işlemi temsil eden bir Promise oluşturma 17 | const myPromise = new Promise((resolve, reject) => { 18 | // Asenkron işlemi burada başlatırız 19 | setTimeout(() => { 20 | const randomNumber = Math.random(); 21 | if (randomNumber > 0.5) { 22 | resolve(randomNumber); // İşlem başarılı 23 | } else { 24 | reject(new Error("Bir hata oluştu")); // İşlem başarısız 25 | } 26 | }, 1000); 27 | }); 28 | 29 | // Promise sonuçlarını işleme 30 | myPromise 31 | .then(result => { 32 | console.log("Sonuç:", result); // İşlem başarılı olduğunda çalışır 33 | }) 34 | .catch(error => { 35 | console.error("Hata:", error.message); // İşlem başarısız olduğunda çalışır 36 | }); 37 | ``` -------------------------------------------------------------------------------- /L-Ekstralar/4-Strict Mode.md: -------------------------------------------------------------------------------- 1 | ## Strict Mode 2 | 3 | "strict mode" (katı kip) kod yazımında yapılan hataları yakalamayı ve bazı özellikleri devre dışı bırakarak daha güvenli bir kodlama deneyimi sunmayı amaçlayan bir özelliktir. "use strict" ifadesi ile etkinleştirilir ve aşağıdaki şekilde kodun başına eklenir: 4 | 5 | ```js 6 | "use strict"; 7 | 8 | // Kodunuz buraya gelecek 9 | ``` 10 | 11 | Artık bu ifadeyi kullanarak yazılan kod, katı kipin sağladığı kurallara uymak zorundadır. Peki, katı kipin sunduğu avantajlar ve uygulamaları nelerdir? İşte bazı temel konular: 12 | 13 | - Hata Yakalama: Katı kip, yazım hatalarını ve potansiyel sorunları daha erken aşamalarda tespit etmenize yardımcı olur. Örneğin, tanımlanmamış değişkenler kullanma veya değiştirilemez (const) olarak tanımlanan bir değişkene yeni bir değer atama gibi hatalar derleme sırasında fark edilir. 14 | 15 | - Deklarasyonları Zorunlu Kılma: Katı kip, değişkenlerin tanımlanmasını, fonksiyonların argümanlarını ve nesne özelliklerini oluşturmadan önce onları açıkça bildirme zorunluluğunu getirir. Bu, yanlışlıkla global değişkenler oluşturma riskini azaltır ve kodun daha anlaşılır olmasına yardımcı olur. 16 | 17 | - Global Kapsamda Güvenlik: Katı kip, kodun global kapsama düşmesini sınırlandırır ve güvenliğe katkıda bulunur. "use strict" ifadesi, kodun birden çok dosyada çalıştığı büyük projelerde, global kapsamda çakışmaları önlemek için kullanışlıdır. 18 | 19 | - Eval ve Arguments Kısıtlamaları: Katı kip, "eval" ve "arguments" gibi potansiyel güvenlik açıklarına sahip olan özellikleri sınırlar. Özellikle "eval" kullanımı güvenlik riskleri oluşturabilir, bu nedenle katı kip bu tür kullanımları engelleyerek güvenliğinizi artırır. 20 | 21 | - Silme Kısıtlamaları: Katı kipte, değişkenlerin veya fonksiyonların "delete" operatörü ile silinmesi engellenir. Bu, önemli verilerin yanlışlıkla silinmesini önler ve programın tutarlılığını artırır. 22 | 23 | - Octal Sayıların Kısıtlanması: Katı kip, oktal sayıları kullanmanın (örneğin, 010 veya 0o10) önüne geçer ve bu tür sayılar artık syntax hatası olarak kabul edilir. -------------------------------------------------------------------------------- /L-Ekstralar/1-Lexical Environment.md: -------------------------------------------------------------------------------- 1 | ## Lexical Environment 2 | 3 | Lexical Environment, kodun çalışma zamanında değişkenlerin ve fonksiyonların nasıl tanımlandığı ve erişildiği hakkında önemli bir kavramdır. Bu kavram, JavaScript dilinin çalışma mantığının temelini oluşturur ve kodun doğru bir şekilde çalışmasını sağlamak için oldukça önemlidir. 4 | 5 | Lexical Environment, bir kod bloğu (genellikle bir fonksiyon) içindeki değişkenlerin ve fonksiyonların tanımlandığı yerdir ve bu kod bloğu içindeki değişkenlere ve fonksiyonlara erişimi belirler. Bir fonksiyonun çalışma zamanında, bu fonksiyonun lexical environment'ı fonksiyonun tanımlandığı anın çevresi olarak kabul edilir. Bu, fonksiyonun dışarıdan veya içeriden nasıl erişebileceği ve hangi değişkenleri ve fonksiyonları görebileceği konusunda önemli bir rol oynar. 6 | 7 | Lexical Environment, iki bileşenden oluşur: 8 | 9 | - Environment Record: İçinde tanımlanan tüm değişkenlerin ve fonksiyonların gerçek değerlerinin ve referanslarının saklandığı bir kayıttır. Bir değişkenin değeri, environment record içinde ilgili isimle ilişkilendirilir ve kod çalıştırıldığında bu değerlere erişilebilir hale gelir. 10 | 11 | - Outer Environment Reference: Bu, bir fonksiyonun lexical enviroment'ına erişim sağlamak için başka bir lexical environment' referansı gösterir. Bir fonksiyon, kapsayıcı (üst) bir fonksiyon içinde tanımlandığında, içteki fonksiyonun lexical environment'i, dıştaki fonksiyonun lexical environment'ına referansla bağlanır. Bu şekilde, içteki fonksiyon, dıştaki fonksiyonun değişkenlerine ve fonksiyonlarına erişebilir. 12 | 13 | Örneğin: 14 | 15 | ```js 16 | function outerFunction() { 17 | let outerVariable = 'I am outside!'; 18 | 19 | function innerFunction() { 20 | let innerVariable = 'I am inside!'; 21 | console.log(outerVariable); // innerFunction, outerFunction'ın leksikal çevresine erişebilir 22 | } 23 | 24 | return innerFunction; 25 | } 26 | 27 | const closureFunction = outerFunction(); 28 | closureFunction(); // 'I am outside!' yazdırır, innerFunction outerFunction'ın leksikal çevresine erişebilir 29 | ``` -------------------------------------------------------------------------------- /D- Veri Türleri ve Fonksiyonları/8-Date & Time.md: -------------------------------------------------------------------------------- 1 | ## Date & Time 2 | 3 | JavaScript'te tarih ve saat, `Date` nesnesi kullanılarak temsil edilir. Date nesnesinde aylar sıfırdan başlar. Yani Ocak ayı 1 olarak değil 0 olarak temsil edilir. Günlerde benzer şekilde pazar gününden başlar ve pazar günü de 0 olarak temsil edilir. 4 | 5 | 6 | ```js 7 | const now = new Date(); 8 | console.log(now); // 2020-12-01T12:00:00.000Z 9 | ``` 10 | 11 | Date içerisinde yer alan fonksiyonlar ile tarih ve saat ile ilgili işlemler yapabiliriz. Bu fonksiyonlar: 12 | 13 | - `getFullYear()` - Yıl 14 | - `getMonth()` - Ay 15 | - `getDate()` - Gün 16 | - `getHours()` - Saat 17 | - `getMinutes()` - Dakika 18 | - `getSeconds()` - Saniye 19 | - `getMilliseconds()` - Milisaniye 20 | - `getTime()` - Zaman Damgası 21 | - `getDay()` - Haftanın Günü 22 | 23 | Benzer şekilde tüm bu fonkisyonların `set` ile başlayan karşılıkları da bulunmaktadır. 24 | 25 | Date nesnesini oluştururken autocorrect özelliği yanlış tarihlerin düzeltilmesini sağlar. Örneğin, 32 Aralık tarihi 1 Ocak'a dönüştürülür. 26 | 27 | ```js 28 | const date = new Date(2013, 0, 32); 29 | console.log(date); // 2013-01-01T12:00:00.000Z 30 | ``` 31 | 32 | ## İki Tarih Arasındaki Farkı Bulmak 33 | 34 | İki tarih arasındaki farkı bulmak için `getTime()` fonksiyonu kullanılır. Bu fonksiyon, 1970 yılından bu yana geçen milisaniye cinsinden zamanı döndürür. Bu sayede iki tarih arasındaki farkı bulabiliriz. 35 | 36 | ```js 37 | const now = new Date(); 38 | const past = new Date(2020, 0, 1); 39 | 40 | const diff = now.getTime() - past.getTime(); 41 | console.log(diff); // 31536000000 42 | ``` 43 | 44 | ## Date.parse() 45 | 46 | `Date.parse()` fonksiyonu, bir tarih dizesini milisaniye cinsinden zaman damgasına dönüştürür. 47 | 48 | ```js 49 | const msec = Date.parse("March 21, 2012"); 50 | console.log(msec); // 1332288000000 51 | ``` 52 | 53 | ## Tarih Formatlama 54 | 55 | `toLocaleDateString()` fonksiyonu, tarihi yerel tarih biçimine dönüştürür. 56 | 57 | ```js 58 | const date = new Date(); 59 | console.log(date.toLocaleDateString("tr-TR")); // 1.12.2020 60 | ``` 61 | 62 | -------------------------------------------------------------------------------- /B-Temeller/5-Fonksiyonlar/6-Clousers.md: -------------------------------------------------------------------------------- 1 | ## Clousers 2 | 3 | JavaScript'te "closure" (kapanım), bir fonksiyonun dışarıdan bağımsız bir şekilde kendi kapsamındaki değişkenlere erişebilmesi ve bu değişkenlerin yaşam döngüsünün fonksiyonunun çalışması süresince korunmasıdır. Bu, fonksiyonların içerisindeki değişkenleri, o fonksiyon çalıştıktan sonra bile hafızada tutmasını ve sonraki çağrılarda erişilebilir kılmasını sağlar. 4 | 5 | Closures, fonksiyonları daha güçlü ve esnek hale getiren önemli bir özelliktir ve iyi anlaşılması gereken bir konudur. Bir closure oluşması için şu koşulların sağlanması gereklidir: 6 | 7 | - Bir iç fonksiyonun, bir dış fonksiyonun içinde tanımlanması. 8 | - İç fonksiyonun, dış fonksiyonun bir değerini referans alması (yani yakalaması). 9 | 10 | ```js 11 | function outerFunction() { 12 | const outerVariable = 'Bu bir dış değişkendir'; 13 | 14 | function innerFunction() { 15 | console.log(outerVariable); // Closure: outerVariable'e erişiyor 16 | } 17 | 18 | return innerFunction; 19 | } 20 | 21 | const closureExample = outerFunction(); 22 | closureExample(); // Çıktı: "Bu bir dış değişkendir" 23 | ``` 24 | 25 | innerFunction, outerFunction içinde tanımlanmış ve outerVariable adlı değişkeni referans almıştır. innerFunction fonksiyonu, outerFunction fonksiyonunun çalışması tamamlandıktan sonra bile hala outerVariable değişkenine erişebilir ve değeri korunur. Bu durum, closure özelliği sayesinde gerçekleşir. 26 | 27 | Closure'lar, genellikle fonksiyon fabrikaları (function factory) oluşturmak veya özel durumları yönetmek gibi durumlarda kullanışlıdır. Özellikle event yönetimi ve asenkron işlemler gibi alanlarda sıkça rastlanır. 28 | 29 | Aşağıda closure kullanarak basit bir counter (sayaç) fonksiyonu örneği verilmiştir: 30 | 31 | ```js 32 | function createCounter() { 33 | let count = 0; 34 | 35 | function increment() { 36 | return ++count; 37 | } 38 | 39 | return increment; 40 | } 41 | 42 | const counter = createCounter(); 43 | 44 | console.log(counter()); // Çıktı: 1 45 | console.log(counter()); // Çıktı: 2 46 | console.log(counter()); // Çıktı: 3 47 | ``` -------------------------------------------------------------------------------- /A-Hoşgeldiniz/2-Nasıl Çalışır.md: -------------------------------------------------------------------------------- 1 | ## JavaScript Nasıl Çalışır? 2 | 3 | JavaScript'in kullanım alanlarının artmasıyla günümüzde yalnızca web tarayıcısı ile çalıştırılmakla kalmayıp bugün çeşitli ve modern JavaScript motorları yani JavaScript Engine'ler mevcuttur. Peki nedir bu JavaScript Engine? 4 | 5 | ## JavaScript Engine 6 | 7 | JavaScript motoru (JavaScript engine), JavaScript programlarını çalıştıran ve JavaScript dilinin kodlarını yorumlayan bir yazılım bileşenidir. JavaScript motorları, JavaScript kodunu alır ve bunu bilgisayarın anlayabileceği bir formata çevirir. Bu işlem genellikle iki aşamada gerçekleşir: yorumlama (interpretation) ve/veya derleme (compilation). Bazı JavaScript motorları yalnızca yorumlama yaparken, bazıları ise yorumlama ve derleme işlemlerini birleştirir. 8 | 9 | Birkaç JavaScript Engine'e göz atacak olursak: 10 | 11 | - V8: Google tarafından geliştirilen ve Chromium tabanlı tarayıcıların yanı sıra Node.js gibi ortamlarda da kullanılan bir JavaScript motorudur. 12 | 13 | - SpiderMonkey: Mozilla Firefox tarayıcısının JavaScript motorudur. Mozilla topluluğu tarafından geliştirilmektedir. 14 | 15 | - JavaScriptCore: Apple'ın Safari tarayıcısı için geliştirilen JavaScript motorudur. 16 | 17 | - Chakra: Microsoft Edge tarayıcısı için geliştirilen JavaScript motorudur. Daha sonra Chromium tabanlı Edge'e geçildi ve V8 kullanılmaya başlandı. 18 | 19 | ## Çalışma Adımları 20 | 21 | Bu başlık altında bir web tarayıcısı seneryosunda JavaScript kodunun çalışıtırması sürecinde gerçekleşen adımları inceleyelim: 22 | 23 | - HTML ile entegrasyon: JavaScript kodu, HTML belgesi içerisinde