Merge pull request #1112 from Namchee/id-3.7-syntax

docs(translation): Add Indonesian translation for TS 3.7 Syntax and Messaging section

Author: github-actions[bot]

packages/playground-examples/copy/id/3-7/Syntax And Messaging/Flattened Error Reporting.ts

@@ -0,0 +1,66 @@
+//// { compiler: {  }, order: 3 }
+
+// Pesan kesalahan yang ditampilkan TypeScript terkadang berlebihan.
+// Dengan TypeScript 3.7, kami telah mengambil beberapa kasus dimana
+// pesan kesalahan yang ditampilkan oleh TypeScript sangat buruk.
+
+// Properti bersarang
+
+let a = { b: { c: { d: { e: "string" } } } };
+let b = { b: { c: { d: { e: 12 } } } };
+
+a = b;
+
+// Sebelumnya, terdapat 2 baris kode untuk satu properti bersarang,
+// dimana orang-orang akan belajar untuk membaca pesan kesalahan
+// dengan membaca baris pertama terlebih dahulu dan kemudian
+// membaca baris terakhir.
+
+// Sekarang pesan kesalahan tersebut ditampilkan dalam satu baris. :tada:
+
+// Sebelumnya pada versi 3.6:
+//
+// Type '{ b: { c: { d: { e: number; }; }; }; }' is not assignable to type '{ b: { c: { d: { e: string; }; }; }; }'.
+//   Types of property 'b' are incompatible.
+//     Type '{ c: { d: { e: number; }; }; }' is not assignable to type '{ c: { d: { e: string; }; }; }'.
+//       Types of property 'c' are incompatible.
+//         Type '{ d: { e: number; }; }' is not assignable to type '{ d: { e: string; }; }'.
+//           Types of property 'd' are incompatible.
+//             Type '{ e: number; }' is not assignable to type '{ e: string; }'.
+//               Types of property 'e' are incompatible.
+//                 Type 'number' is not assignable to type 'string'
+
+// Cara ini dapat menampilkan pesan kesalahan pada berbagai
+// tipe objek, namun tetap mampu untuk menampilkan
+// pesan kesalahan yang jelas dan berguna.
+
+class ContohKelas {
+    state = "ok";
+}
+
+class KelasLain {
+    state = 12;
+}
+
+let x = { a: { b: { c: { d: { e: { f: ContohKelas } } } } } };
+let y = { a: { b: { c: { d: { e: { f: KelasLain } } } } } };
+x = y;
+
+// Sebelumnya pada versi 3.6:
+//
+// Type '{ a: { b: { c: { d: { e: { f: typeof KelasLain; }; }; }; }; }; }' is not assignable to type '{ a: { b: { c: { d: { e: { f: typeof ContohKelas; }; }; }; }; }; }'.
+//   Types of property 'a' are incompatible.
+//     Type '{ b: { c: { d: { e: { f: typeof KelasLain; }; }; }; }; }' is not assignable to type '{ b: { c: { d: { e: { f: typeof ContohKelas; }; }; }; }; }'.
+//       Types of property 'b' are incompatible.
+//         Type '{ c: { d: { e: { f: typeof KelasLain; }; }; }; }' is not assignable to type '{ c: { d: { e: { f: typeof ContohKelas; }; }; }; }'.
+//           Types of property 'c' are incompatible.
+//             Type '{ d: { e: { f: typeof KelasLain; }; }; }' is not assignable to type '{ d: { e: { f: typeof ContohKelas; }; }; }'.
+//               Types of property 'd' are incompatible.
+//                 Type '{ e: { f: typeof KelasLain; }; }' is not assignable to type '{ e: { f: typeof ContohKelas; }; }'.
+//                   Types of property 'e' are incompatible.
+//                     Type '{ f: typeof KelasLain; }' is not assignable to type '{ f: typeof ContohKelas; }'.
+//                       Types of property 'f' are incompatible.
+//                         Type 'typeof KelasLain' is not assignable to type 'typeof ContohKelas'.
+//                           Type 'KelasLain' is not assignable to type 'ContohKelas'.
+//                             Types of property 'state' are incompatible.
+//                               Type 'number' is not assignable to type 'string'

packages/playground-examples/copy/id/3-7/Syntax And Messaging/Nullish Coalescing.ts

@@ -0,0 +1,45 @@
+//// { compiler: {  }, order: 2 }
+
+// Operator _nullish coalescing_ adalah sebuah alternatif
+// untuk operator || yang akan mengembalikan ekspresi sebelah kanan
+// apabila ekspresi sebelah kiri bernilai null atau undefined.
+
+// Sebaliknya, operator || menggunakan pemeriksaan _falsy_, yang berarti
+// sebuah string kosong atau bilangan yang bernilai akan dianggap false.
+
+// Sebuah contoh yang baik untuk fitur ini adalah ketika berurusan dengan
+// objek parsial yang memiliki nilai anggapan ketika sebuah pengidentifikasi
+// tidak dinyatakan.
+
+interface KonfigurasiAplikasi {
+    // Nilai anggapan: "(tidak bernama)"; string kosong merupakan nilai yang VALID
+    nama: string;
+
+    // Nilai anggapan: -1; 0 merupakan nilai yang valid
+    barang: number;
+
+    // Nilai anggapan: true
+    aktif: boolean;
+}
+
+function perbaruiAplikasi(konfigurasi: Partial<KonfigurasiAplikasi>) {
+    // Dengan operator _null-coalescing_
+    konfigurasi.nama = konfigurasi.nama ?? "(tidak bernama)";
+    konfigurasi.barang = konfigurasi.barang ?? -1;
+    konfigurasi.aktif = konfigurasi.aktif ?? true;
+
+    // Solusi saat ini
+    konfigurasi.nama = typeof konfigurasi.nama === "string" ? konfigurasi.nama : "(tidak bernama)";
+    konfigurasi.barang = typeof konfigurasi.barang === "number" ? konfigurasi.barang : -1;
+    konfigurasi.aktif = typeof konfigurasi.aktif === "boolean" ? konfigurasi.aktif : true;
+
+    // Menggunakan operator || yang dapat menghasilkan data yang buruk
+    konfigurasi.nama = konfigurasi.nama || "(tidak bernama)"; // tidak mengizinkan masukan bernilai ""
+    konfigurasi.barang = konfigurasi.barang || -1; // tidak mengizinkan masukan bernilai 0
+    konfigurasi.aktif = konfigurasi.aktif || true; // sangat buruk, karena selalu mengembalikan nilai true
+}
+
+  // Anda dapat membaca lebih lanjut tentang _nullish coalescing_ pada
+  // tulisan blog versi 3.7:
+  //
+  // https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/

packages/playground-examples/copy/id/3-7/Syntax And Messaging/Optional Chaining.ts

@@ -0,0 +1,75 @@
+//// { compiler: {  }, order: 1 }
+
+// _Optional Chaining_ mencapai konsesus TC39 Tahap 3 ketika
+// TypeScript 3.7 sedang dikembangkan. _Optional Chaining_
+// mengizinkan Anda untuk menulis kode yang akan langsung berhenti
+// menjalankan ekspresi ketika sebuah nilai null dan undefined
+// ditemukan.
+
+// Akses Properti
+
+// Coba bayangkan bahwa ada sebuah album dimana artis dan
+// biografinya mungkin tidak tertera pada data album tersebut.
+// Contohnya, sebuah album kompilasi bisa saja sama sekali
+// tidak memiliki seorang artis.
+
+type ResponAPIAlbum = {
+    judul: string;
+    artis?: {
+        nama: string;
+        biografi?: string;
+        albumSebelumnya?: string[];
+    };
+};
+
+declare const album: ResponAPIAlbum;
+
+// Dengan _optional chaining_, Anda dapat
+// menulis kode seperti berikut:
+
+const biografiArtis = album?.artis?.biografi;
+
+// Dibandingkan dengan:
+
+const mungkinBiografiArtis = album.artis && album.artis.biografi;
+
+// Pada kasus ini, operator ?. akan mengambil tindakan yang berbeda bila
+// dibandingkan dengan operator && karena operator && akan
+// bertindak berbeda pada nilai "falsy" (contoh: sebuah string kosong,
+// 0, NaN, dan false).
+
+// _Optional chaining_ hanya akan menganggap null atau undefined
+// sebagai sebuah sinyal untuk berhenti dan mengembalikan nilai undefined.
+
+// Akses Elemen Opsional
+
+// Properti dapat diakses melalui operator., _optional chaining_
+// juga dapat digunakan dengan operator [] ketika mengakses elemen
+
+const mungkinElemenBiografiArtis = album?.["artis"]?.["biografi"];
+
+const mungkinAlbumSebelumnyaYangPertama = album?.artis?.albumSebelumnya?.[0];
+
+// Pemanggilan Opsional
+
+// Ketika berurusan dengan fungsi yang mungkin tidak ada
+// pada saat program berjalan (runtime), _optional chaining_ mendukung
+// kasus-kasus dimana sebuah fungsi hanya akan dipanggil
+// jika fungsi tersebut ada. Hal tersebut dapat menggantikan kode yang
+// biasanya ditulis seperti: if (func) func()
+
+// Sebagai contoh, disini terdapat sebuah pemanggilan opsional
+// pada _callback_ dari sebuah permintaan API
+
+const panggilPembaruanMetadata = (metadata: any) => Promise.resolve(metadata); // Pemanggilan API palsu
+
+const perbaruiMetadataAlbum = async (metadata: any, callback?: () => void) => {
+    await panggilPembaruanMetadata(metadata);
+
+    callback?.();
+};
+
+  // Anda dapat membaca lebih lanjut tentang _optional chaining_
+  // pada tulisan blog TypeScript 3.7:
+  //
+  // https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/