translated numbers section

gnwx · sumn2u · commit 7d8b113db83f · 2023-07-13T21:33:56.000-05:00
diff --git a/tr/numbers/README.md b/tr/numbers/README.md
@@ -0,0 +1,42 @@
+---
+layout: editorial
+chapter: 3
+pageNumber: 16
+---
+
+# Bölüm 3
+
+# Numbers (Sayılar)
+
+JavaScript **sadece tek bir sayı türüne** sahiptir - 64 bit float point. Java'daki `double` ile aynıdır.
+Diğer programlama dillerinin çoğundan farklı olarak, ayrı bir tamsayı türü yoktur, bu nedenle 1 ve 1.0 aynı değerdir. Bir sayı oluşturmak kolaydır, `var` anahtar sözcüğü kullanılarak diğer değişken türlerinde olduğu gibi yapılabilir.
+
+Sayılar sabit bir değerden oluşturulabilir:
+
+```javascript
+// This is a float:
+let a = 1.2;
+
+// This is an integer:
+let b = 10;
+```
+
+Veya başka bir değişkenin değerinden:
+
+```javascript
+let a = 2;
+let b = a;
+```
+
+Tam sayılar 15 basamağa kadar tam olarak doğru bir şekilde temsil edilebilir. Ancak, 16 veya daha fazla basamaklı bir tam sayı tanımlamaya çalıştığınızda, JavaScript bu sayıyı yakınsama (approximation) yöntemiyle temsil etmeye başlar.
+
+```javascript
+let x = 999999999999999; // x'in değeri 999999999999999 olacak.
+let y = 9999999999999999; // y'nin değeri 10000000000000000 olacak.
+```
+
+Sayıların önünde `0x` varsa **hexadecimal** formatta kullanılırlarr.
+
+```javascript
+let z = 0xff; // 255
+```
diff --git a/tr/numbers/advanced.md b/tr/numbers/advanced.md
@@ -0,0 +1,112 @@
+---
+chapter: 3
+pageNumber: 21
+---
+
+# Advanced Operators (İleri Düzey Operatörler)
+
+Operatörler parantez olmadan bir araya getirildiklerinde, uygulanma sıraları operatörlerin _önceliği_ tarafından belirlenir. Çarpma `(*)` ve bölme `(/)`, toplama `(+)` ve çıkarmadan `(-)` daha yüksek önceliğe sahiptir.
+
+```javascript
+// önce çarpma işlemi, daha sonra toplama işlemi yapılır
+let x = 100 + 50 * 3; // 250
+// parantez içindeki işlemler önce hesaplanır
+let y = (100 + 50) * 3; // 450
+// aynı önceliğe sahip işlemler soldan sağa doğru hesaplanır
+let z = (100 / 50) * 3;
+```
+
+Kod yazarken çeşitli gelişmiş matematik operatörleri kullanılabilir. İşte bazı ileri düzey matematik operatörlerinin bir listesi:
+
+- **Modulo (Kalan) operatörü (`%`)**: Modulo operatörü, bir bölme işleminin kalanını döndürür. Örneğin:
+
+```javascript
+console.log(10 % 3); // 1
+console.log(11 % 3); // 2
+console.log(12 % 3); // 0
+```
+
+- **Üs alma operatörü (\* \*)**: Üs alma operatörü bir sayıyı başka bir sayının kuvvetine yükseltir. Daha yeni bir operatördür ve tüm tarayıcılarda desteklenmez, bu nedenle bunun yerine `Math.pow` işlevini kullanmanız gerekebilir. Örneğin:
+
+```javascript
+console.log(2 ** 3); // 8
+console.log(3 ** 2); // 9
+console.log(4 ** 3); // 64
+```
+
+- **Arttırma operatörü (`++`)**: Arttırma operatörü bir sayıyı bir artırır. Kullanılacak elemanın önüne veya sonuna eklenebilir. Örneğin:
+
+```javascript
+let x = 1;
+x++; // x is now 2
+++x; // x is now 3
+```
+
+- **Azaltma operatörü (`--`)**: Azaltma operatörü bir sayıyı bir azaltır. Kullanılacak elemanın önüne veya sonuna eklenebilir. Örneğin:
+
+```javascript
+let y = 3;
+y--; // y is now 2
+--y; // y is now 1
+```
+
+- **Math objesi**: `Math` objesi, JavaScript'te matematiksel fonksiyonlar ve sabit değerler sağlayan hazır bir objedir. Bir sayının karekökünü bulmak, bir sayının sinüsünü hesaplamak veya rastgele bir sayı oluşturmak gibi ileri düzey matematik işlemleri gerçekleştirmek için `Math` objesinin fonksiyonlarını kullanabilirsiniz. Örneğin:
+
+```javascript
+console.log(Math.sqrt(9)); // 3
+console.log(Math.sin(0)); // 0
+console.log(Math.random()); //0 ile 1 arasında rastgele bir sayı
+```
+
+Bunlar JavaScript'te bulunan ileri düzey matematik operatörleri ve fonksiyonlarına sadece birkaç örnek. Program yazarken ileri düzey matematik işlemleri gerçekleştirmek için kullanabileceğiniz çok daha fazlası vardır.
+
+{% exercise %}
+`num1` ve `num2` üzerinde işlem yapmak için aşağıdaki ileri düzey operatörleri kullanın.
+
+{% initial %}
+let num1 = 10;
+let num2 = 5;
+
+// num1'in değerini artırmak için ++ operatörünü kullanın.
+const result1 =
+// num2'nin değerini azaltmak için -- operatörünü kullanın.
+const result2 =
+// num2'yi num1'e eklemek için += operatörünü kullanın.
+const result3 =
+// num2'yi num1'den çıkarmak için -= operatörünü kullanın.
+const result4 =
+
+{% solution %}
+let num1 = 10;
+let num2 = 5;
+
+// ++ operator to increment the value of num1.
+
+num1++;
+const result1 = num1; // 11
+// -- operator to decrement the value of num2.
+num2--;
+const result2 = num2; // 4
+// += operator to add num2 to num1.
+num1 += num2;
+const result3 = num1 // 15
+// -= operator to subtract num2 from num1.
+num1 -= num2;
+const result4 = num1 // 11
+
+{% validation %}
+assert(result1 === 11 && result2 === 4 && result3 === 15 && result4 === 11 );
+
+{% context %}
+{% endexercise %}
+
+## Nullish coalescing operator '??'
+
+`nullish coalescing operator`, `null/undefined` değilse ilk argümanı, `null/undefined` ise ikincisini döndürür. İki soru işareti `??` olarak yazılır. `x ?? y`'nin sonucu şudur:
+
+- eğer `x` tanımlanmışsa, o zaman `x`,
+- eğer `y` tanımlanmamışsa, o zaman `y`.
+
+{% hint style="info" %}
+Dile yeni eklenmiştir ve eski tarayıcıların desteklemesi için polyfills'e ihtiyaç duyabilir.
+{% endhint %}
diff --git a/tr/numbers/math.md b/tr/numbers/math.md
@@ -0,0 +1,72 @@
+---
+chapter: 3
+pageNumber: 17
+---
+
+# Math
+
+`Math` objesi JavaScript'te matematiksel işlemlerin gerçekleştirilmesini sağlar. Statiktir ve bir yapıcısı (**constructor**) yoktur. Math objesi oluşturmadan Math objesinin fonksiyonlarını kullanılabilirsiniz. Bazı matematik özellikleri aşağıda açıklanmıştır:
+
+```javascript
+Math.E; // Euler sayısını döndürür
+Math.PI; // PI değerini döndürür
+Math.SQRT2; // 2'nin karekökünü döndürür
+Math.SQRT1_2; // 1/2'nin karekökünü döndürür
+Math.LN2; // 2'nin doğal logaritmasını döndürür
+Math.LN10; // 10'un doğal logaritmasını döndürür
+Math.LOG2E; // E'nin 2 tabanında logaritmasını döndürür
+Math.LOG10E; // E'nin 10 tabanında logaritmasını döndürür
+```
+
+Bazı matematik yöntemlerine örnek olarak şunlar verilebilir:
+
+```javascript
+Math.pow(8, 2); // 64
+Math.round(4.6); // 5
+Math.ceil(4.9); // 5
+Math.floor(4.9); // 4
+Math.trunc(4.9); // 4
+Math.sign(-4); // -1
+Math.sqrt(64); // 8
+Math.abs(-4.7); // 4.7
+Math.sin((90 * Math.PI) / 180); // 1 (the sine of 90 degrees)
+Math.cos((0 * Math.PI) / 180); // 1 (the cos of 0 degrees)
+Math.min(0, 150, 30, 20, -8, -200); // -200
+Math.max(0, 150, 30, 20, -8, -200); // 150
+Math.random(); // 0.44763808380924375
+Math.log(2); // 0.6931471805599453
+Math.log2(8); // 3
+Math.log10(1000); // 3
+```
+
+Matematik metoduna erişmek için, gerektiğinde argümanlarla doğrudan metotları çağrılabilir.
+
+| Method             | Description                                                                        |
+| ------------------ | ---------------------------------------------------------------------------------- |
+| `abs(x)`           | `x`'in mutlak değerini döndürür                                                    |
+| `acos(x)`          | `x`'in arkkosinüs değerini radyan cinsinden döndürür                               |
+| `acosh(x)`         | `x`'in hiperbolik arkkosinüsünü döndürür                                           |
+| `asin(x)`          | `x`'in radyan cinsinden arksinüsünü döndürür                                       |
+| `asinh(x)`         | `x`'in hiperbolik arksinüsünü döndürür                                             |
+| `atan(x)`          | `x`'in arktanjantını `-PI/2` ile `PI/2` arasında sayısal bir değer olarak döndürür |
+| `atan2(y,x)`       | İki argümanın bölümünün arktanjantını döndürür                                     |
+| `atanh(x)`         | `x`'in hiperbolik arktanjantını döndürür                                           |
+| `crbt(x)`          | `x`'in küp kökünü döndürür                                                         |
+| `ceil(x)`          | `x`'in en yakın üst tam sayıya yuvarlanmış hâlini döndürür                         |
+| `cos(x)`           | `x`'in kosinüsünü radyan cinsinden döndürür                                        |
+| `cosh(x)`          | `x`'in hiperbolik kosinüsünü döndürür                                              |
+| `exp(x)`           | `x`'in üstel fonksiyonunu döndürür                                                 |
+| `floor(x)`         | `x`'in en yakın alt tam sayıya yuvarlanmış hâlini döndürür                         |
+| `log(x)`           | `x`'in doğal logaritmasını döndürür                                                |
+| `max(x,y,z,... n)` | En yüksek değere sahip olan sayıyı döndürür                                        |
+| `min(x,y,z,... n)` | En düşük değere sahip olan sayıyı döndürür                                         |
+| `pow(x,y)`         | x'in y. kuvvetini döndürür                                                         |
+| random()           | 0 ile 1 arasında bir sayı döndürür                                                 |
+| round(x)           | Sayıyı en yakın tam sayıya yuvarlar                                                |
+| sign(x)            | x negatifse -1, 0 ise null, pozitifse 1 döndürür                                   |
+| sin(x)             | x'in sinüsünü radyan cinsinden döndürür                                            |
+| sinh(x)            | x'in hiperbolik sinüsünü döndürür                                                  |
+| sqrt(x)            | x'in karekökünü döndürür                                                           |
+| tan(x)             | Bir açının tanjantını döndürür                                                     |
+| tanh(x)            | x'in hiperbolik tanjantını döndürür                                                |
+| trunc(x)           | Bir sayının tam kısmını döndürür                                                   |
diff --git a/tr/numbers/operators.md b/tr/numbers/operators.md
@@ -0,0 +1,114 @@
+---
+chapter: 3
+pageNumber: 19
+---
+
+# Basic Operators (Temel operatörler)
+
+Sayılar üzerinde matematiksel işlemler, aşağıdaki gibi bazı temel operatörler kullanılarak gerçekleştirilebilir:
+
+- **Toplama operatörü (`+`)**: Toplama operatörü iki sayıyı birbirine ekler. Örneğin:
+
+```javascript
+console.log(1 + 2); // 3
+console.log(1 + -2); // -1
+```
+
+- **Çıkarma operetörü (`-`)**: Çıkarma operatörü bir sayıyı diğerinden çıkarır. Örneğin:
+
+```javascript
+console.log(3 - 2); // 1
+console.log(3 - -2); // 5
+```
+
+- **Çarpma operatörü (`*`)**: Çarpma operatörü iki sayıyı çarpar. Örneğin:
+
+```javascript
+console.log(2 * 3); // 6
+console.log(2 * -3); // -6
+```
+
+- **Bölme operatörü (`/`)**: Bölme operatörü bir sayıyı diğerine böler. Örneğin:
+
+```javascript
+console.log(6 / 2); // 3
+console.log(6 / -2); // -3
+```
+
+- **Remainder (Kalan) operatörü (`%`)**: Kalan operatörü, bir bölme işleminin kalanını döndürür. Örneğin:
+
+```javascript
+console.log(10 % 3); // 1
+console.log(11 % 3); // 2
+console.log(12 % 3); // 0
+```
+
+JavaScript yorumlayıcısı soldan sağa doğru çalışır. İfadeleri ayırmak ve gruplamak için matematikte olduğu gibi parantezler kullanılabilir: `c = (a / b) + d`
+
+{% hint style="warning" %}
+JavaScript hem toplama hem de birleştirme için `+` operatörü kullanır. Sayılar eklenirken, dizeler (**string**) birleştirilir.
+{% endhint %}
+
+`NaN` terimi, bir sayının geçerli bir sayı olmadığını belirten ayrılmış bir sözcüktür; bu, sayısal olmayan bir dizeyle aritmetik yaptığımızda ortaya çıkar ve `NaN` (Not a Number) ile sonuçlanır.
+
+```javascript
+let x = 100 / "10";
+```
+
+`parseInt` fonksiyonu bir değeri bir dize olarak çözümleyip ilk tamsayıyı döndürür.
+
+```javascript
+parseInt("10"); // 10
+parseInt("10.00"); // 10
+parseInt("10.33"); // 10
+parseInt("34 45 66"); // 34
+parseInt(" 60 "); // 60
+parseInt("40 years"); //40
+parseInt("He was 40"); //NaN
+```
+
+JavaScript'te, mümkün olan en büyük sayının dışında bir sayı hesaplarsak `Infinity` döndürür.
+
+```javascript
+let x = 2 / 0; // Infinity
+let y = -2 / 0; // -Infinity
+```
+
+{% exercise %}
+Matematik operatörleri +, -, \*, / ve %'yi kullanarak `num1` ve `num2` üzerinde aşağıdaki işlemleri gerçekleştirin.
+{% initial %}
+
+let num1 = 10;
+let num2 = 5;
+
+// num1 ile num2'yi toplayın.
+let addResult =
+// num2'den, num1'i çıkartın.
+let subtractResult =
+// num1 ile num2'yi çarpın.
+let multiplyResult =
+// num1 ile num2'yi bölün.
+let divideResult =
+// Num1'in num2'ye bölümünden kalanı bulun.
+let reminderResult =
+
+{% solution %}
+let num1 = 10;
+let num2 = 5;
+
+// Add num1 and num2.
+let addResult = (num1 + num2);
+// Subtract num2 from num1.
+let subtractResult = (num1 - num2);
+// Multiply num1 and num2.
+let multiplyResult = (num1 \* num2);
+// Divide num1 by num2.
+let divideResult = (num1 / num2);
+// Find the remainder num1 is divided by num2.
+let reminderResult = (num1 % num2);
+
+{% validation %}
+assert(addResult === 15 && subtractResult === 5 && multiplyResult === 50 && divideResult === 2 && reminderResult === 0 );
+
+{% context %}
+{% endexercise %}
