Fitur TypeScript baru untuk meningkatkan kegunaan

TypeScript, dalam banyak hal, tidak lagi seperti bahasa pemrograman, tetapi alat yang ampuh untuk menyisir dan mendokumentasikan kode yang membantu Anda menulis program JavaScript yang lebih baik.

Salah satu kekuatan yang paling menonjol dari TypeScript adalah dukungannya untuk beberapa fitur terbaru yang dijelaskan dalam spesifikasi ECMAScript. Ketika seorang pengembang memutakhirkan ke versi baru dari TypeScript, itu berarti bahwa ia memiliki fitur JavaScript baru. Selain itu, penggunaan fitur-fitur ini tidak berarti potensi masalah kompatibilitas. TypeScript, di samping memperkenalkan fitur-fitur JavaScript terbaru, juga terkenal karena fakta bahwa pembuat bahasa terus-menerus menghadirkan sesuatu yang baru bagi komunitas programmer TS, yang dirancang untuk meningkatkan kegunaan. Ini termasuk, misalnya, alat bantu untuk refactoring kode, alat untuk mengganti nama entitas dan untuk menemukan tempat di mana mereka digunakan dalam program.



Materi, terjemahan yang kami terbitkan hari ini, akan membahas beberapa fitur segar yang menarik dari TypeScript. Untuk daftar lengkap inovasi TypeScript, lihat di sini .

Objek dan array tidak berubah


Untuk membuat array tetap yang digunakan dalam bentuk variabel biasa dan parameter fungsi selama kompilasi, dalam TypeScript, Anda bisa menggunakan tipe bantu Readonlydan ReadonlyArray. Namun, penggunaannya dapat menyebabkan perasaan heterogenitas dalam anotasi tipe, terutama ketika mendeklarasikan array menggunakan karakter []setelah menentukan tipe. TypeScript 3.4 memperkenalkan cara baru untuk memberi label parameter yang hanya baca array. Segera muncul cara baru untuk mendeklarasikan variabel yang seharusnya tidak berubah.

Meningkatkan kegunaan dengan parameter hanya baca


Saat mendeklarasikan parameter fungsi yang harus Anda gunakan sebagai array hanya-baca, kini Anda dapat menggunakan kata kunci readonly. Dalam contoh berikut, tanda tangan dari kedua metode ini identik:

function foo(s: ReadonlyArray<string>) { /* ... */ }
 
function foo(s: readonly string[]) { /* ... */ }

Dalam kedua kasus, setiap upaya untuk mengubah array (misalnya, menggunakan metodenya push) akan menghasilkan kesalahan. Inovasi ini menghilangkan kebutuhan untuk jenis generik tambahan, yang berarti bahwa kode lebih mudah dibaca. Jenis objek juga bisa diberi label sebagai entitas read-only, tetapi mereka masih membutuhkan tipe helper Readonly.

Meningkatkan kegunaan variabel tidak berubah menggunakan konstruk sebagai const


Jenis variabel yang dinyatakan menggunakan kata kunci consttidak dapat diubah. Konsep ini ada dalam JavaScript. Itu juga diadopsi dalam TypeScript demi mengorganisir lebih banyak pekerjaan yang ketat dengan jenis. Tetapi ketika bekerja dengan tipe data objek, seperti objek atau array, ternyata struktur seperti itu tidak benar-benar berubah. Menggunakan kata kunci constberarti bahwa instance spesifik objek atau array akan tetap tidak berubah ketika bekerja dengan konstanta, namun konten objek atau array ini dapat dengan mudah diubah. Misalnya, tanpa melanggar aturan untuk bekerja dengan entitas const, Anda bisa menambahkan nilai baru ke array menggunakan metode ini push, Anda bisa mengubah nilai properti objek.

Menggunakan ReadonlydanReadonlyArrayAnda dapat memberi tahu TypeScript bahwa sistem harus memperlakukan entitas seolah-olah mereka benar-benar tidak dapat diubah. Ini berarti bahwa setiap kali upaya dilakukan dalam kode untuk mengubah entitas seperti itu, pesan kesalahan akan dikeluarkan.

interface Person { 
  name: string; 
}
 
const person = { 
  name: 'Will' 
} as Readonly<Person>;
person.name = 'Diana'; // !

Dalam TypeScript 3.4, di antara inovasi-inovasi lain, konsep pernyataan konstan (statemen konstan), yang menyediakan penggunaan konstruk, muncul as const. Ini adalah metode yang disederhanakan untuk mendeklarasikan konstanta yang berisi objek dan array yang tidak dapat diubah. Deklarasi semacam itu dibangun dengan menambahkan as constkonstanta pada akhir deklarasi. Metode ini memiliki keuntungan tambahan, yaitu ketika Anda menggunakannya, Anda tidak perlu secara spesifik menentukan jenis dalam pernyataan as const.

const person = { 
        name: 'Will' 
} as const;
 
person.name = 'Diana'; // !
 
//      as const
const array = [1, 2, 3] as const
array.push(4); // !

Abaikan tipe pembantu


Ada beberapa tipe pembantu dalam TypeScript yang membuatnya mudah untuk memetakan tipe yang sudah ada ke yang baru, atau menetapkan jenis berdasarkan kondisi pada tipe lain.

Tipe bantu Partialmemungkinkan menandai semua properti objek sebagai opsional. Sebelum rilis TypeScript 3.5, ternyata, saya terus menggunakan satu mekanisme menarik dalam proyek saya. Ini sama dengan penggunaan tipe bantu yang sekarang memungkinkan untuk dicapai Omit. Jenis ini, seperti namanya, memungkinkan Anda untuk mengecualikan sesuatu dari jenis lain. Omitmenerima jenis dan kombinasi tombol, dan kemudian mengembalikan tipe baru dari mana properti yang dijelaskan oleh kunci dikecualikan. Lewatlah sudah hari-hari ketika saya harus menggunakan Pickitu Excludeuntuk pelaksanaan independen fungsiOmit.

//     TypeScript 3.5
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
interface A { 
    propA?: string; 
    propB?: string; 
    propC?: string; 
}
 
type B = Omit<A, 'propA' | 'propC'>; 
const b: B = { propA: 'hi' }; // ;

Fitur JavaScript Baru Didukung oleh TypeScript


Ketika saran untuk fitur JavaScript baru mencapai 4 tahap koordinasi, saran tersebut dianggap sebagai bagian dari versi bahasa berikutnya. Benar, ini tidak berarti bahwa kemampuan tersebut dapat segera digunakan dalam JavaScript, karena dukungan mereka harus diimplementasikan di lingkungan yang sesuai. Aplikasi harus memiliki akses ke peluang tersebut di mana pun operasi normalnya diharapkan.

Dukungan untuk fitur JavaScript baru ditambahkan secara teratur ke kompiler TypeScript. Biasanya, kode yang mengimplementasikan fitur-fitur ini dapat dikonversi ke kode JavaScript yang kompatibel dengan semua browser yang mendukung tujuan pembangunan proyek yang ditentukan dalam tsconfig.json.

▍ Periksa null dan tidak terdefinisi


Pengembang JavaScript akrab dengan konsep kebenaran dan kepalsuan. Ketika memeriksa kebenaran dapat diidentifikasi 6 nilai-nilai, yang selalu salah: 0, null, undefined, «», NaN, dan, tentu saja, false. Paling sering, pengembang hanya perlu mencari tahu apakah nilainya benar atau salah, tetapi dalam beberapa kasus Anda hanya perlu mencari tahu apakah nilai yang diselidiki adalah nilai nyata nullatau undefined. Misalnya, dalam kasus ini jika perlu untuk membedakan antara kode 0dan undefined:

//  ||     ,  index  0
const getValueOrOne = (x?: number) => index || 1
getValueOrOne(0); // 1 <-- 

Kode ini akan bekerja dengan mengatur xke nilai yang ditulis index, dalam semua kasus kecuali yang ketika nilainya indexsama 0. Agar kode ini berfungsi dengan benar dalam situasi apa pun, kode ini harus ditulis ulang menggunakan skema pengujian yang lebih kompleks untuk mengetahui jenis nilai sebenarnya.

//   ,    
const getValueOrOne = (x?: number) => index !== null && index !== undefined ? : 1
getValueOrOne(0); // 0

Sekarang kodenya berfungsi, tetapi membutuhkan penggunaan pemeriksaan yang lebih kompleks. Operator baru untuk memeriksa nilai pada nulldan undefined(sepertinya dua tanda tanya - ??) menyederhanakan pemeriksaan tersebut dengan mengembalikan nilai yang terletak di bagian kirinya, jika tidak sama dengan nulldan undefined. Kalau tidak, ia mengembalikan apa yang ada di sisi kanannya.

// !
const getValueOrOne = (x?: number) => index ?? 1
getValueOrOne(0); // 0
getValueOrOne(2); // 2
getValueOrOne(); // 1

▍ Urutan opsional


Fitur JavaScript baru lainnya yang tersedia di TypeScript 3.7 adalah operator untuk mengatur urutan opsional ( ?.). Saya pertama kali bertemu operator seperti itu dalam bahasa pemrograman Groovy. Sejak itu, saya ingin itu muncul di JavaScript juga. Operator ini memungkinkan Anda untuk mengatur akses ke properti yang tertanam dari objek tanpa perlu memeriksa keberadaannya secara konstan. Jika, ketika mengakses properti, operator ini menemukan nilai undefined, itu hanya akan mengembalikan nilai ini tanpa menimbulkan kesalahan TypeError.

//    
const value = foo && foo.bar && foo.bar.baz;
 
//    
const value = foo?.bar?.baz;

Operator urutan opsional dikombinasikan dengan operator yang memeriksa nilai-nilai pada nulldan undefinedmemberikan pengembang lebih banyak kemungkinan, memungkinkan, misalnya, untuk menulis ke variabel baik nilai beberapa properti bersarang objek, atau, jika properti seperti itu tidak ada, beberapa nilai standar. Begini tampilannya:

const value = foo?.bar?.baz ?? 'default value';

▍ Bidang kelas pribadi


TypeScript, sejak munculnya bahasa ini, memiliki konsep sendiri bidang kelas privat yang dideklarasikan dengan pengubah akses private. Konsep ini muncul dalam TypeScript bahkan sebelum kelas dijelaskan dalam standar ECMAScript. Namun dalam TypeScript, konsep ini merujuk pada mekanisme yang bekerja selama kompilasi kode. Kompiler akan melempar kesalahan jika bidang pribadi kelas diakses bukan dari metode kelas sendiri. Sekarang di JavaScript ada peluang untuk mendeklarasikan properti dan metode pribadi kelas. Tetapi fitur ini berbeda secara semantik dan sintaksis dari apa yang masih ada dalam TypeScript.

Bidang pribadi dalam JavaScript tidak dideklarasikan menggunakan pengubah akses private. Sebaliknya, mereka dideklarasikan dengan meletakkan simbol di awal nama mereka #.

class Fan 
    #on = false
    private name = 'fan';
 
    turnOn() { 
        this.#on = true
    }
   isTurnedOn() { 
        return this.#on; 
    }
}
 
const fan = new Fan(); 
fan.isTurnedOn(); // false  
fan.turnOn(); 
fan.isTurnedOn(); // true
 
fan.on; //  
fan.#on; // 
fan.name; //   ,    JS

JavaScript sekarang mendukung bidang pribadi, proposal untuk metode pribadi sedang dalam tahap ketiga persetujuan. Saat ini, pengubah privatedan karakter #dalam nama bidang tidak dapat digunakan bersama. Kedua pendekatan dapat berguna selama pengembangan, dan mana yang harus dipilih tergantung pada programmer. Berikut podcast yang membahas sintaks baru untuk mendeklarasikan bidang pribadi.

▍Menggunakan kata kunci yang menunggu di tingkat atas kode


Mekanisme pemrograman asinkron sangat memperluas kemampuan JavaScript dan TypeScript. Mula-mula janji muncul di area ini, lalu - desain async/awaityang memungkinkan Anda menulis kode asinkron yang lebih bersih.

Salah satu kasus di mana janji digunakan, dan tidak, async/awaitadalah pemanggilan metode asinkron di luar fungsi asinkron. Misalnya, di tingkat atas modul atau kode aplikasi. Sebagai solusi dalam situasi ini, Anda dapat mengusulkan membuat ekspresi fungsi asinkron segera disebut (IIFE, Ekspresi Fungsi Segera Diminta) dan mengeksekusi kode asinkron di dalam ekspresi seperti itu.

(async () => { 
    const response = await fetch('https://api.github.com/users/sitepen'); 
    const data = await response.json(); 
    console.log(`Check out the blog at ${data.blog}`); 
})();

TypeScript sekarang mendukung kemampuan JavaScript untuk menggunakan kata kunci awaitdi tingkat atas kode. Ini berarti bahwa menunggu dapat digunakan di luar fungsi yang dideklarasikan dengan kata kunci async. Ini sangat bagus dalam menulis kode yang ringkas dan jelas. Benar, ekspresi awaitdi tingkat atas kode dikritik karena fakta bahwa mereka dapat memperlambat pemuatan modul dan membuat situasi di mana modul tertentu dapat memperlambat pemuatan seluruh aplikasi, karena sistem harus menunggu penyelesaian operasi asinkron, dan kemudian jalankan semua kode modul.

const response = await fetch('https://api.github.com/users/sitepen'); 
const data = await response.json();
 
export default { ...data };

Lingkungan eksperimen TypeScript yang disempurnakan


Ini tidak dapat disebut fitur TypeScript baru, tetapi mengingat bahwa kita berbicara tentang TypeScript sebagai alat, TypeScript Playground dapat disebut alat yang efektif untuk dengan cepat memeriksa konstruksi TypeScript dan melihat kode JavaScript di mana konstruksi ini berubah menjadi. Sebagian besar contoh di sini diuji secara khusus di TypeScript Playground. Sekarang lingkungan ini mendukung kemampuan untuk memilih versi tertentu dari TypeScript (termasuk dukungan untuk versi beta). Ini mencakup beberapa contoh yang akan membantu pemula memulai dengan TypeScript.

Ringkasan


TypeScript adalah alat yang membantu Anda menulis kode JavaScript yang lebih baik dan lebih ekspresif. Alat bantu TypeScript memudahkan untuk menyelesaikan tugas-tugas kompleks, seperti refactoring dan penggantian nama entitas, yang jauh lebih rumit dalam JavaScript biasa. TypeScript terus-menerus memperkenalkan mekanisme baru, seperti Omitdan as const. Dalam bahasa tersebut, orang dapat mengamati peningkatan berkelanjutan dalam mendukung tipe yang kompleks. TypeScript dengan cepat mengimplementasikan fitur-fitur JavaScript terbaru. Itulah sebabnya banyak orang memilih TypeScript, menganggapnya sebagai alat, bahasa, dan ekosistem.

Pembaca yang budiman! Apa fitur TypeScript baru yang menurut Anda paling menarik?


All Articles