initial commit

1 files changed, 170 insertions, 0 deletions

diff --git a/files/tr/web/javascript/reference/global_objects/isnan/index.html b/files/tr/web/javascript/reference/global_objects/isnan/index.html
new file mode 100644
index 0000000000..7a098629e6
--- /dev/null
+++ b/files/tr/web/javascript/reference/global_objects/isnan/index.html
@@ -0,0 +1,170 @@
+---
+title: isNaN()
+slug: Web/JavaScript/Reference/Global_Objects/isNaN
+translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p><code>isNaN()</code> bir değerin <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN </a>olup olmadığını belirler. Not: <code>isNaN</code> işlevi içindeki zorlamanın <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN#Description">ilginç</a> kuralları vardır; alternatif olarak ECMAScript 2015'te tanımlandığı gibi <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN">Number.isNaN()</a> yöntemini kullanmak isteyebilirsiniz.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}</div>
+
+<h2 id="Sözdizimi">Sözdizimi</h2>
+
+<pre class="syntaxbox"><code>isNaN(deger)</code></pre>
+
+<h3 id="Parametreler">Parametre(ler)</h3>
+
+<dl>
+ <dt><code>değer</code></dt>
+ <dd>Test edilecek değer.</dd>
+</dl>
+
+<h3 id="Verilecek_değer">Verilecek değer</h3>
+
+<p>Verilen değer {{jsxref("NaN")}} ise<strong> <code>true</code></strong>; değilse <strong><code>false</code></strong>.</p>
+
+<h2 id="Açıklama">Açıklama</h2>
+
+<h3 id="isNaN_işlevi_gerekliliği"><code>isNaN</code> işlevi gerekliliği</h3>
+
+<p>JavaScript'teki diğer tüm olası değerlerden farklı olarak, bir değerin {{jsxref ("NaN")}} olup olmadığını belirlemek için eşitlik operatörlerine (== ve ===) güvenmek mümkün değildir, çünkü NaN == NaN ve NaN === NaN <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">false</span></font> olarak değerlendirilir. BU yüzden <code>isNaN</code> işlevi.</p>
+
+<h3 id="NaN_değerlerinin_kaynağı"><code>NaN</code> değerlerinin kaynağı</h3>
+
+<p>NaN değerleri, aritmetik işlemler <em>tanımsız (undefined)</em> veya <em>tekrarlanamayan</em> değerlerle sonuçlandığında üretilir. Bu tür değerler mutlaka taşma koşullarını temsil etmez. <code>NaN</code> ayrıca, ilkel sayısal değerin bulunmadığı sayısal olmayan değerlerin sayısal değerlerine zorlama girişiminden de kaynaklanır.</p>
+
+<p>Örneğin, sıfıra sıfıra bölmek bir <code>NaN</code> ile sonuçlanır - ancak diğer sayıları sıfıra bölmek olmaz.</p>
+
+<h3 id="Özel_durum_davranışlarını_karıştırmak">Özel durum davranışlarını karıştırmak</h3>
+
+<p><code>İsNaN</code> işlev belirtiminin en eski sürümleri olduğundan, sayısal olmayan bağımsız değişkenler için davranışı kafa karıştırıcı olur. İsNaN işlevinin bağımsız değişkeni <a href="http://es5.github.com/#x8.5">Number</a> türünde değilse, değer önce bir Number öğesine zorlanır. Dağa sonra elde edilen değer daha sonra {{jsxref ("NaN")}} olup olmadığını belirlemek için test edilir. Bu nedenle, sayısal tipe zorlandığında, geçerli bir <code>NaN</code> olmayan sayısal değerle sonuçlanan sayılar için (özellikle boş dize ve boolean ilkelleri, zorlandığında sayısal değerler sıfır veya bir verir), <code>"false"</code> döndürülen değer beklenmedik olabilir; örneğin, boş dize mutlaka "bir sayı değildir". Karışıklık, "sayı değil" teriminin IEEE-754 kayan nokta değerleri olarak gösterilen sayılar için özel bir anlamı olduğu gerçeğinden kaynaklanmaktadır. İşlev, "bu değer, sayısal değere zorlandığında IEEE-754 'Sayı Değil' değeri mi?" Sorusunu yanıtlıyor olarak yorumlanmalıdır.</p>
+
+<p>ECMAScript 2015, {{jsxref ("Number.isNaN ()")}} işlevini içerir. <code>Number.isNaN(x)</code>, x'in <code>NaN</code> olup olmadığını test etmenin güvenilir bir yoludur. Bununla birlikte, <code>Number.isNaN</code> ile bile, <code>NaN</code>'nin anlamı, basitçe "bir sayı değil", kesin sayısal anlam olarak kalır. Alternatif olarak, <code>Number.isNaN</code> yokluğunda, <code>(x != x)</code> ifadesi, <code>x</code> değişkeninin <code>NaN</code> olup olmadığını test etmenin daha güvenilir bir yoludur, çünkü sonuç <code>isNaN</code>'yi güvenilir olmayan sahte pozitiflere tabi değildir.</p>
+
+<p><code>isNaN</code> için bir çoklu dolgu (çoklu dolgu, <code>NaN</code>'nin kendine özgü asla eşit olmayan özelliğini kullanır):</p>
+
+<pre class="brush: js">var isNaN = function(deger) {
+    var n = Number(deger);
+    return n !== n;
+};</pre>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush: js">isNaN(NaN);       // true
+isNaN(undefined); // true
+isNaN({});        // true
+
+isNaN(true);      // false
+isNaN(null);      // false
+isNaN(37);        // false
+
+// strings
+isNaN('37');      // false: "37", NaN olmayan 37 sayısına dönüştürülür
+isNaN('37.37');   // false: "37.37", NaN olmayan 37.37 sayısına dönüştürülür
+isNaN("37,5");    // true
+isNaN('123ABC');  // true:  parseInt("123ABC") 123, ancak Number("123ABC")
+isNaN('');        // false: boş dize, NaN olmayan 0'a dönüştürülür
+isNaN(' ');       // false: boşluklu bir dize, NaN olmayan 0'a dönüştürülür
+
+// tarihler
+isNaN(new Date());                // false
+isNaN(new Date().toString());     // true
+
+// Bu yanlış bir pozitiftir ve isNaN'ın tamamen güvenilir olmamasının nedenidir
+isNaN('blabla');   // true: "blabla" bir sayıya dönüştürülür.
+                   // Bunu bir sayı olarak ayrıştırma başarısız olur ve NaN döndürür</pre>
+
+<h3 id="Faydalı_özel_durum_davranışı">Faydalı özel durum davranışı</h3>
+
+<p><code>İsNaN()</code> yöntemini düşünmek için daha çok kullanıma yönelik bir yol vardır: <code>isNaN(x)</code> <code>false</code> değerini döndürürse, ifadeyi <code>NaN</code> döndürmeyen bir aritmetik ifadede <code>x</code> kullanabilirsiniz. <code>true</code> değerini döndürürse, <code>x</code> her aritmetik ifadeyi <code>NaN</code> döndürür. Bu, JavaScript'te,<code> isNaN(x) == true</code> değerinin, <code>NaN</code> döndüren <code>x - 0</code>'a eşdeğer olduğu anlamına gelir (JavaScript <code>x - 0 == NaN</code>'de her zaman <code>false</code> döndürür, bu nedenle test edemezsiniz). Aslında, <code>isNaN(x)</code>, <code>isNaN(x - 0)</code>, <code>isNaN(Number(x))</code>, <code>Number.isNaN(x - 0)</code> ve <code>Number.isNaN(Number(x))</code> her zaman aynı döndürür ve JavaScript <code>isNaN(x)</code> bu terimlerin her birini ifade etmek için mümkün olan en kısa biçimdir.</p>
+
+<p>Örneğin, bir işleve ait bir argümanın aritmetik olarak işlenebilir (bir sayı gibi "kullanılabilir") veya değilse ve varsayılan bir değer veya başka bir şey sağlamanız gerekip gerekmediğini test etmek için kullanabilirsiniz. Bu şekilde, içeriğe bağlı olarak değerleri dolaylı olarak dönüştürerek JavaScript'in sağladığı çok yönlülüğü kullanan bir işleve sahip olabilirsiniz.</p>
+
+<h2 id="Örnekler">Örnekler</h2>
+
+<pre class="brush: js">function artım(x) {
+  if (isNaN(x)) x = 0;
+  return x + 1;
+}
+
+// Number.isNaN() ile aynı etki:
+function artım(x) {
+  if (Number.isNaN(Number(x))) x = 0;
+  return x + 1;
+}
+
+// Aşağıdaki durumlarda işlevin x argümanı için,
+// isNaN(x) her zaman yanlıştır, ancak x gerçekten bir
+// ancak aritmetik olarak kullanılabilir
+// ifadeler
+increment('');            // 1: "", 0'a dönüştürülür
+increment(new String());  // 1: Boş bir dizeyi temsil eden dize nesnesi 0'a dönüştürülür
+increment([]);            // 1: [], 0'a dönüştürülür
+increment(new Array());   // 1: Boş bir diziyi temsil eden dizi nesnesi 0'a dönüştürülür
+increment('0');           // 1: "0", 0'a dönüştürülür
+increment('1');           // 2: "1", 1'e dönüştürülür
+increment('0.1');         // 1.1: "0.1", 0.1'a dönüştürülür.
+increment('Infinity');    // Infinity: "Infinity", Infinity dönüştürülür
+increment(null);          // 1: null değeri 0'a dönüştürülür
+increment(false);         // 1: false değeri 0'a dönüştürülür
+increment(true);          // 2: true değeri 1'e dönüştürülür
+increment(new Date());    // milisaniye cinsinden geçerli tarih/saati döndürür artı 1
+
+// Aşağıdaki durumlarda işlevin x argümanı için,
+// isNaN (x) her zaman falsetır ve x gerçekten bir sayıdır.
+increment(-1);            // 0
+increment(-0.1);          // 0.9
+increment(0);             // 1
+increment(1);             // 2
+increment(2);             // 3
+// ...ve bunun gibi...
+increment(Infinity);      // Infinity
+
+// Aşağıdaki durumlarda işlevin x argümanı için,
+// isNaN(x) her zaman doğrudur ve x gerçekten bir sayı değildir,
+// böylece fonksiyon 0 ile değiştirilir ve 1 döndürür
+increment(String);            // 1
+increment(Array);             // 1
+increment('blabla');          // 1
+increment('-blabla');         // 1
+increment(0 / 0);               // 1
+increment('0 / 0');             // 1
+increment(Infinity / Infinity); // 1
+increment(NaN);               // 1
+increment(undefined);         // 1
+increment();                  // 1
+
+// isNaN(x) her zaman isNaN(Number(x)) ile aynıdır,
+// ama x'in varlığı burada zorunludur!
+isNaN(x) == isNaN(Number(x)); // x == undefined dahil, x'in her değeri için true,
+                              // çünkü isNaN(undefined) == true ve Number(undefined) NaN değerini döndürür,
+                              // ama...
+isNaN() == isNaN(Number());   // false, çünküisNaN() == true ve Number() == 0
+</pre>
+
+<h2 id="Özellikler">Özellikler</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Şartname</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Tarayıcı_Uyumluluğu">Tarayıcı Uyumluluğu</h2>
+
+
+
+<p>{{Compat("javascript.builtins.isNaN")}}</p>
+
+<h2 id="Ayrıca_bakınız">Ayrıca bakınız</h2>
+
+<ul>
+ <li>{{jsxref("NaN")}}</li>
+ <li>{{jsxref("Number.isNaN()")}}</li>
+</ul>