1 files changed, 186 insertions, 0 deletions
diff --git a/files/id/web/javascript/reference/global_objects/isnan/index.html b/files/id/web/javascript/reference/global_objects/isnan/index.html
new file mode 100644
index 0000000000..b7a6774528
--- /dev/null
+++ b/files/id/web/javascript/reference/global_objects/isnan/index.html
@@ -0,0 +1,186 @@
+---
+title: isNaN()
+slug: Web/JavaScript/Reference/Global_Objects/isNaN
+translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>Fungsi <code><strong>isNaN()</strong></code> menentukan apakah nilai adalah sebuah {{jsxref("NaN")}} atau bukan. Catatan: pemaksaan pada fungsi <code>isNaN</code> memiliki aturan yang <a href="#Description">menarik</a>. Anda mungkin ingin menggunakan {{jsxref("Number.isNaN()")}}, <span id="result_box" lang="id"><span>seperti yang didefinisikan dalam ECMAScript 2015.</span></span></p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>isNaN(v<em>alue</em>)</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>Nilai yang akan di uji.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p><strong><code>true</code></strong> Jika nilai yang di uji adalah {{jsxref("NaN")}}; jika tidak, <strong><code>false</code></strong>.</p>
+
+<h2 id="Deskripsi">Deskripsi</h2>
+
+<h3 id="Kebutuhan_akan_fungsi_isNaN">Kebutuhan akan fungsi <code>isNaN</code></h3>
+
+<p>Mungkin tidak seperti nilai lainnya dalam javascript, Ini tidak memungkinkan untuk mengandalkan operator persamaan (== dan ===) untuk menentukan bahwa nilai adalah {{jsxref("NaN")}} atau bukan, karena <code>NaN == NaN</code> dan <code>NaN === NaN</code> mengevaluasi ke <code>false</code>. Oleh karena itu, diperlukan adanya fungsi <code>isNaN</code>.</p>
+
+<h3 id="Asal_Mula_Nilai_NaN">Asal Mula Nilai <code>NaN</code></h3>
+
+<p>Nilai<code>NaN</code> <span id="result_box" lang="id"><span>dihasilkan saat operasi aritmatika menghasilkan nilai <em>undefined</em> atau <em>unrepresentable</em></span></span>. <span id="result_box" lang="id"><span>Nilai tersebut tidak harus mewakili kondisi overflow</span></span>.  <code>NaN</code> juga dihasilkan dari percobaan pemaksaan ke nilai numerik dari nilai non-numerik <span id="result_box" lang="id"><span>yang tidak memiliki nilai numerik primitif yang tersedia.</span></span></p>
+
+<p><span class="short_text" id="result_box" lang="id"><span>Misalnya, membagi nol dengan nol menghasilkan sebuah</span></span> <code>NaN</code> — namun <span class="short_text" id="result_box" lang="id"><span>membagi angka lain dengan nol tidak menghasilkan sebuah <code>NaN</code>.</span></span></p>
+
+<h3 id="Perilaku_Khusus_yang_membingungkan">Perilaku Khusus yang membingungkan</h3>
+
+<p><span id="result_box" lang="id"><span>Karena versi paling awal dari spesifikasi fungsi</span></span> <code>isNaN</code> , perilaku untuk argumen non-numerik menjadi membingungkan. Ketika<span id="result_box" lang="id"><span> argumen ke fungsi</span></span> <code>isNaN</code> bukan bertipe <a href="http://es5.github.com/#x8.5" title="http://es5.github.com/#x8.5">Number</a>, Nilainya akan dipaksakan terlebih dahulu ke tipe <a href="http://es5.github.com/#x8.5" title="http://es5.github.com/#x8.5">Number</a>. <span id="result_box" lang="id"><span>Nilai yang dihasilkan kemudian diuji untuk menentukan apakah itu</span></span> {{jsxref("NaN")}}. Jadi untuk non-angka <span id="result_box" lang="id"><span>yang jika dipaksakan pada hasil numerik menghasilkan nilai numerik</span></span> non-NaN (<span id="result_box" lang="id"><span>terutama string kosong dan primitif boolean, yang jika dipaksakan memberi nilai numerik nol atau satu</span></span>), nilai pengembalian "false" mungkin tidak terduga; <span id="result_box" lang="id"><span>String kosong, misalnya, pastinya "not a number"</span></span>. <span id="result_box" lang="id"><span>Kebingungan itu berawal dari kenyataan bahwa istilah</span></span> "not a number", <span id="result_box" lang="id"><span>memiliki arti khusus untuk angka yang diwakili sebagai nilai floating-point IEEE-754</span></span>. <span id="result_box" lang="id"><span>Fungsi harus diinterpretasikan sebagai penjawab pertanyaan, "apakah nilai ini, jika dipaksakan pada nilai numerik, nilai IEEE-754 'Not A Number'?"</span></span></p>
+
+<p><span class="short_text" id="result_box" lang="id"><span class="alt-edited">Versi terbaru dari ECMAScript (ES2015) berisi fungsi </span></span>{{jsxref("Number.isNaN()")}}. <code>Number.isNaN(x)</code> <span class="short_text" id="result_box" lang="id"><span>akan menjadi cara yang andal untuk menguji apakah</span></span> <code>x</code> adalah <code>NaN</code> atau bukan. Bahkan dengan <code>Number.isNaN</code>, <span id="result_box" lang="id"><span>namun arti <code>NaN</code> tetap merupakan makna numerik yang tepat, dan bukan sekadar,</span></span> "not a number". Sebagai alternatif, untuk ketidakhadiran <code>Number.isNaN</code>, ekspresi <code>(x != x)</code> <span id="result_box" lang="id"><span>adalah cara yang lebih dapat diandalkan untuk menguji apakah variabel x adalah <code>NaN</code></span></span> <span id="result_box" lang="id"><span>atau bukan, karena hasilnya tidak sesuai dengan false positive yang membuat</span></span> <code>isNaN</code> <span id="result_box" lang="id"><span>tidak dapat diandalkan</span></span>.</p>
+
+<p><span class="short_text" id="result_box" lang="id"><span>Anda bisa memikirkan isNaN sebagai:</span></span></p>
+
+<pre class="brush: js">var isNaN = function(value) {
+    return Number.isNaN(Number(value));
+}</pre>
+
+<h2 id="Contoh">Contoh</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" <span class="short_text" id="result_box" lang="id"><span>dikonversi ke nomor</span></span> 37 yang mana bukan NaN
+isNaN('37.37');   // false: "37.37" <span class="short_text" id="result_box" lang="id"><span>dikonversi ke nomor</span></span> 37.37 yang mana bukan NaN
+isNaN('123ABC');  // true:  parseInt("123ABC") adalah 123 namun Number("123ABC") adalah NaN
+isNaN('');        // false: string kosing dikonversi ke 0 yang mana bukan NaN
+isNaN(' ');       // false: string dengan spasi dikonversi ke 0 yang mana bukan NaN
+
+// dates
+isNaN(new Date());                // false
+isNaN(new Date().toString());     // true
+
+// <span id="result_box" lang="id"><span>Ini adalah false positif dan alasan mengapa NaN tidak sepenuhnya dapat diandalkan</span></span>
+isNaN('blabla');   // true: "blabla" dikonversi ke nomor.
+                   // <span id="result_box" lang="id"><span>Parsing ini sebagai nomor gagal dan mengembalikan NaN</span></span>
+</pre>
+
+<h3 id="Berguna_dalam_perilaku_khusus">Berguna dalam perilaku khusus</h3>
+
+<p><span id="result_box" lang="id"><span>Ada cara penggunaan </span></span><span lang="id"><span>yang lebih berorientasi untuk memikirkan <code>isNaN</code></span></span> <code>isNaN()</code>: Jika <code>isNaN(x)</code> mengembalikan <code>false</code>, anda bisa menggunakan <code>x</code> <span id="result_box" lang="id"><span>dalam ekspresi aritmatika tidak membuat ekspresi mengembalikan</span></span> <code>NaN</code>. Jika itu mengembalikan<code>true</code>, <code>x</code> <span class="short_text" id="result_box" lang="id"><span>akan membuat setiap ekspresi aritmatika</span></span> mengembalikan <code>NaN</code>. <span class="short_text" id="result_box" lang="id"><span>Ini berarti bahwa dalam JavaScript,</span></span> <code>isNaN(x) == true</code> <span class="short_text" id="result_box" lang="id"><span>setara dengan</span></span> <code>x - 0</code> mengembalikan <code>NaN</code> (<span class="short_text" id="result_box" lang="id"><span>meskipun di JavaScript</span></span> <code>x - 0 == NaN</code> selalu mengembalikan false, <span id="result_box" lang="id"><span>jadi anda tidak bisa mengujinya).</span> <span>Sebenarnya, </span></span><code>isNaN(x)</code>, <code>isNaN(x - 0)</code>, <code>isNaN(Number(x))</code>, <code>Number.isNaN(x - 0)</code>, dan <code>Number.isNaN(Number(x))</code> <span class="short_text" id="result_box" lang="id"><span>selalu kembali sama dan di JavaScript</span></span><code>isNaN(x)</code> <span id="result_box" lang="id"><span>hanya bentuk sesingkat mungkin untuk mengungkapkan masing-masing istilah ini.</span></span></p>
+
+<p><span id="result_box" lang="id"><span>Anda dapat menggunakan ini, misalnya, untuk menguji apakah sebuah argumen terhadap suatu fungsi secara aritmatika dapat diolah (dapat digunakan "seperti" angka), atau jika tidak dan Anda harus memberikan nilai default atau yang lainnya.</span> <span>Dengan cara ini Anda dapat memiliki fungsi yang memanfaatkan fleksibilitas penuh JavaScript yang disediakan oleh nilai konversi secara implisit bergantung pada konteks.</span></span></p>
+
+<h2 id="Contoh_2">Contoh</h2>
+
+<pre class="brush: js">function increment(x) {
+  if (isNaN(x)) x = 0;
+  return x + 1;
+}
+
+// <span class="short_text" id="result_box" lang="id"><span>Efek yang sama dengan</span></span> Number.isNaN():
+function increment(x) {
+  if (Number.isNaN(Number(x))) x = 0;
+  return x + 1;
+}
+
+// <span class="short_text" id="result_box" lang="id"><span>Dalam kasus berikut untuk argumen fungsi x,</span></span>
+// isNaN(x)<span class="short_text" id="result_box" lang="id"><span>selalu salah, meski x memang bukan sebuah</span></span>
+// nomor, <span class="short_text" id="result_box" lang="id"><span>namun bisa digunakan seperti itu dalam ekspresi
+// aritmatika</span></span>
+increment('');            // 1: "" dikonversi ke 0
+increment(new String());  // 1: <span id="result_box" lang="id"><span>Objek String yang mewakili string kosong dikonversi menjadi 0</span></span>
+increment([]);            // 1: [] dikonversi ke 0
+increment(new Array());   // 1: <span id="result_box" lang="id"><span>Objek array yang mewakili sebuah array kosong dikonversi menjadi 0</span></span>
+increment('0');           // 1: "0" dikonversi ke 0
+increment('1');           // 2: "1" dikonversi ke 1
+increment('0.1');         // 1.1: "0.1" dikonversi ke 0.1
+increment('Infinity');    // Infinity: "Infinity" dikonversi ke Infinity
+increment(null);          // 1: null dikonversi ke 0
+increment(false);         // 1: false dikonversi ke 0
+increment(true);          // 2: true dikonversi ke 1
+increment(new Date());    // <span id="result_box" lang="id"><span>mengembalikan tanggal/waktu sekarang dalam milidetik ditambah 1</span></span>
+
+// <span class="short_text" id="result_box" lang="id"><span>Dalam kasus berikut untuk argumen fungsi x,</span></span>
+// isNaN(x) <span class="short_text" id="result_box" lang="id"><span>selalu false dan x memang angka</span></span>
+increment(-1);            // 0
+increment(-0.1);          // 0.9
+increment(0);             // 1
+increment(1);             // 2
+increment(2);             // 3
+// ... <span class="short_text" id="result_box" lang="id"><span>dan seterusnya</span></span> ...
+increment(Infinity);      // Infinity
+
+// <span class="short_text" id="result_box" lang="id"><span>Dalam kasus berikut untuk argumen fungsi x,</span></span>
+// isNaN(x) <span class="short_text" id="result_box" lang="id"><span>selalu true dan x benar-benar bukan angka,</span></span>
+// <span id="result_box" lang="id"><span>sehingga fungsi tersebut menggantikannya dengan 0 dan mengembalikan 1</span></span>
+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) <span class="short_text" id="result_box" lang="id"><span>selalu sama dengan</span></span> isNaN(Number(x)),
+// <span class="short_text" id="result_box" lang="id"><span>namun kehadirannya</span></span> x <span class="short_text" id="result_box" lang="id"><span>adalah wajib disini</span></span>!
+isNaN(x) == isNaN(Number(x)); // true <span class="short_text" id="result_box" lang="id"><span>untuk setiap nilai</span></span> x, termasuk x == undefined,
+                              // karena isNaN(undefined) == true dan Number(undefined) mengembalikan NaN,
+                              // namun ...
+isNaN() == isNaN(Number());   // false, karena isNaN() == true dan Number() == 0
+</pre>
+
+<h2 id="Spesifikasi">Spesifikasi</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.2.4', 'isNaN')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-isnan-number', 'isNaN')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.isNaN")}}</p>
+
+<h2 id="Lihat_Juga">Lihat Juga</h2>
+
+<ul>
+ <li>{{jsxref("NaN")}}</li>
+ <li>{{jsxref("Number.isNaN()")}}</li>
+</ul>