Jenis Data dalam TypeScript

Articles

Artikel ini menerangkan jenis data dalam TypeScript.

YouTube Video

Jenis Data dalam TypeScript

TypeScript menyediakan pelbagai jenis data. Ini membolehkan anda menetapkan jenis yang ketat untuk pembolehubah, hujah fungsi, dan nilai pulangan. Berikut adalah jenis data utama dan kegunaannya.

Jenis Asas

Jenis number

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

number adalah jenis yang digunakan untuk mengendalikan nilai numerik, termasuk integer dan nombor perpuluhan (nombor terapung). Mengendalikan nilai yang melebihi had tertentu menghasilkan Infinity atau NaN (Bukan Nombor).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

Dalam TypeScript, nombor diwakili sebagai nombor terapung. Ini mungkin menghasilkan ketidaktepatan kecil dalam keputusan pengiraan.
Apabila pengiraan yang tepat diperlukan, seperti jumlah kewangan, adalah perlu untuk mengelakkan kesilapan pembundaran seperti ini. Sebagai contoh, anda boleh menggunakan BigInt atau toFixed(), atau menyesuaikan tempat perpuluhan menggunakan perpustakaan seperti decimal.js.

Jenis string

Jenis string mengendalikan data teks.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

boolean (Jenis Logik)

Jenis boolean mempunyai dua nilai: true atau false.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null dan undefined

null mewakili 'nilai yang tidak wujud', dan undefined mewakili 'nilai yang tidak ditakrifkan'.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

Dalam TypeScript, anda boleh menetapkan jenis elemen dalam array. number[] ialah array nombor, dan string[] ialah array teks.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Tuple

Tuple ialah array dengan elemen-elemen yang mempunyai jenis berbeza.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Enum

enum mentakrifkan satu set pemalar yang dinamakan.

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

Jenis any boleh memegang sebarang jenis nilai dan digunakan apabila anda mahu mematikan pemeriksaan jenis.

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Jenis Union

Dengan menggunakan jenis Union, anda boleh menetapkan pembolehubah yang boleh memegang salah satu daripada pelbagai jenis.

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Ringkasan

number, string, boolean: Jenis Primitif.
null, undefined: Nilai Khas.
Array: Satu array dengan anotasi jenis.
Tuple: Array dengan elemen daripada jenis yang berbeza.
enum: Jenis yang diperhitungkan.
any: Sebarang jenis.
Union: Satu pemboleh ubah yang boleh mengambil salah satu daripada berbilang jenis.

Dengan menggunakan jenis data ini, TypeScript meningkatkan keselamatan jenis, menjadikannya lebih mudah untuk mencegah kesilapan semasa pembangunan.

Objek Pembungkus

Wrapper Objects dalam TypeScript adalah objek yang dicipta secara automatik untuk mengendalikan jenis data primitif sebagai objek. Jenis primitif membolehkan operasi yang ringan dan pantas, manakala jenis objek mempunyai kaedah dan sifat, membolehkan operasi yang lebih kaya.

Dalam JavaScript (dan TypeScript), terdapat objek pembungkus yang sepadan dengan jenis primitif seperti string, number, dan boolean. Ia diciptakan menggunakan fungsi konstruktor yang dipanggil String, Number, dan Boolean secara masing-masing.

Berikut adalah contoh objek pembungkus.

Objek String

Objek String menyediakan sifat dan kaedah untuk string.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Ciri-ciri:

Tidak seperti string primitif, objek String dianggap sebagai object oleh typeof.
Objek pembungkus berguna semasa memanipulasikan string atau memanggil kaedah padanya.

Objek Number

Objek Number menyediakan sifat dan kaedah untuk nombor.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Ciri-ciri:

Objek Number, sebagai pembungkus untuk nombor, termasuk kaedah untuk operasi angka (contohnya, toFixed).

Objek Boolean

Objek Boolean menyediakan sifat dan kaedah untuk nilai boolean.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Ciri-ciri:

Objek Boolean adalah pembungkus untuk jenis boolean primitif dan dianggap sebagai object.

Perbezaan antara Objek Pembungkus dan Jenis Primitif

Kerana objek pembungkus dianggap sebagai objek, terdapat sedikit penurunan prestasi, tetapi operasi yang lebih berfungsi boleh dilakukan kerana sifat dan kaedah yang ditambah. Selain itu, terdapat perbezaan dalam perbandingan menggunakan == dan ===.

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Ciri-ciri:

== membandingkan nilai, manakala === membandingkan dengan ketat termasuk jenis. === mengembalikan false apabila membandingkan objek pembungkus dengan jenis primitif.

Penukaran Jenis

Dalam TypeScript, adalah penting untuk menguruskan penukaran jenis tersirat dan tersurat dengan betul.

Penukaran Jenis Tersirat

Dalam TypeScript, penukaran jenis tersirat harus dielakkan sebanyak mungkin untuk memastikan keselamatan jenis.

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

Dalam contoh ini, nombor 5 secara tersirat ditukar kepada string, menghasilkan string "55".

Penukaran Jenis Tersurat

Dalam TypeScript, gunakan anotasi jenis atau fungsi penukaran jenis untuk melaksanakan penukaran jenis dengan selamat.

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

Dalam contoh ini, fungsi Number() digunakan untuk secara tersurat menukar string "123" kepada nombor 123.

Pemeriksaan Jenis

Dalam TypeScript, anda boleh menggunakan operator typeof untuk memeriksa jenis data sesuatu pemboleh ubah.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Dalam TypeScript, anda boleh menggunakan typeof untuk memeriksa jenis, tetapi untuk pemeriksaan jenis yang lebih tepat, disarankan juga untuk menggunakan operator instanceof atau is.

Ringkasan

Objek Pembungkus dianggap sebagai objek kerana mereka menyediakan kaedah tambahan dan sifat untuk jenis primitif.
String, Number, dan Boolean adalah contoh representatif objek pembungkus.
Tidak seperti jenis primitif, objek pembungkus dikenalpasti sebagai object oleh typeof.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video

Asas-asas TypeScript Operator dalam TypeScript