Mga Uri ng Data sa TypeScript

Articles

Ipinaliwanag ng artikulong ito ang mga uri ng data sa TypeScript.

YouTube Video

Mga Uri ng Data sa TypeScript

Nag-aalok ang TypeScript ng iba't ibang uri ng data. Pinapahintulutan ka nitong tukuyin ang mahigpit na mga uri para sa mga variable, argumento ng mga function, at mga return value. Nasa ibaba ang pangunahing mga uri ng data at ang kanilang paggamit.

Mga Uri ng Primitive

Uri ng number

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

Ang number ay isang uri na ginagamit para sa paghawak ng mga numerikal na halaga, kabilang ang mga integer at floating-point numbers (mga desimal). Ang paghawak ng mga halagang lumalampas sa tiyak na limitasyon ay nagreresulta sa Infinity o NaN (Not-a-Number).

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

Sa TypeScript, ang mga numero ay kinakatawan bilang floating-point numbers. Maaari itong magresulta sa bahagyang mga pagkakamali sa mga resulta ng kalkulasyon.
Kapag kinakailangan ang tumpak na kalkulasyon, tulad ng mga halagang pampinansyal, mahalagang iwasan ang pag-ikot ng mga error tulad nito. Halimbawa, maaari mong gamitin ang BigInt o toFixed(), o ayusin ang mga lugar ng desimal gamit ang mga aklatan katulad ng decimal.js.

Uri ng string

Ang uri ng string ay humahawak ng mga tekstwal na datos.

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

boolean (Uri ng Lohikal)

Ang uri ng boolean ay may dalawang halaga: true o false.

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

null at undefined

Ang null ay kumakatawan sa 'hindi umiiral na halaga', at ang undefined ay kumakatawan sa 'hindi natukoy na halaga'.

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

Sa TypeScript, maaari mong tukuyin ang uri ng mga elemento ng array. Ang number[] ay isang array ng mga numero, at ang string[] ay isang array ng mga string.

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

Ang tuple ay isang array na may mga elemento ng magkakaibang uri.

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

Enum

Ang enum ay tumutukoy sa isang hanay ng mga pinangalanang constant.

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

Ang uri ng any ay maaaring maglaman ng anumang uri ng halaga at ginagamit kapag gusto mong i-disable ang pagsuri ng uri.

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

Uri ng Union

Sa paggamit ng mga uri ng Union, maaari kang tumukoy ng mga variable na maaaring maglaman ng isa sa maraming uri.

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

Buod

number, string, boolean: Mga pangunahing uri.
null, undefined: Mga espesyal na halaga.
Array: Isang array na may mga anotasyon ng uri.
Tuple: Isang array na may mga element na may iba't ibang uri.
enum: Isang enumeradong uri.
any: Anumang uri.
Union: Isang variable na maaaring tumanggap ng isa sa maraming uri.

Sa pamamagitan ng paggamit ng mga uri ng datos na ito, pinapalakas ng TypeScript ang kaligtasan sa uri, na nagpapadali upang maiwasan ang mga error sa panahon ng development.

Mga Wrapper Object

Ang Wrapper Objects sa TypeScript ay mga object na awtomatikong nilikha upang iproseso ang mga primitive na uri ng datos bilang mga object. Ang mga primitive na uri ay nagpapahintulot ng magaan at mabilis na operasyon, habang ang mga uri ng object ay may mga metodo at katangian, na nagbibigay-daan sa mas masaganang operasyon.

Sa JavaScript (at TypeScript), may mga wrapper object na tumutugma sa mga primitive na uri tulad ng string, number, at boolean. Ang mga ito ay nililikha gamit ang mga constructor na function na tinatawag na String, Number, at Boolean, ayon sa pagkakasunod.

Narito sa ibaba ang mga halimbawa ng wrapper objects.

String Object

Ang String na object ay naglalaman ng mga katangian at metodo para sa mga 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

Mga Tampok:

Hindi tulad ng primitive na string, ang String na object ay itinuturing bilang isang object ng typeof.
Ang mga wrapper object ay kapaki-pakinabang kapag nagpoproseso ng mga string o tumatawag ng mga metodo sa mga ito.

Number Object

Ang Number na object ay nagbibigay ng mga katangian at metodo para sa mga numero.

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

Mga Tampok:

Ang Number na object, bilang isang wrapper para sa mga numero, ay may mga metodo para sa mga numerikal na operasyon (hal., toFixed).

Boolean Object

Ang Boolean na object ay nagbibigay ng mga katangian at metodo para sa mga boolean na halaga.

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

Mga Tampok:

Ang Boolean na object ay isang wrapper para sa primitive na boolean na uri at itinuturing bilang object.

Mga Pagkakaiba sa Pagitan ng Wrapper Objects at Primitive Types

Dahil ang mga wrapper object ay itinuturing bilang mga object, may bahagyang pagbawas sa performance, ngunit mas maraming mga operasyon ang posibleng magawa dahil sa mga karagdagang katangian at metodo. Bukod dito, may mga pagkakaiba sa paghahambing gamit ang == at ===.

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)

Mga Tampok:

Ang == ay naghahambing ng mga halaga, samantalang ang === ay mahigpit na naghahambing kasama ang uri. === ay nagbabalik ng false kapag ikinumpara ang wrapper objects sa mga primitive na uri.

Pagkonbersyon ng Uri

Sa TypeScript, mahalaga na maayos na pamahalaan ang implicit at explicit na pagkonbersyon ng mga uri.

Implicit na Pagkonbersyon ng Uri

Sa TypeScript, ang implicit na pagkonbersyon ng mga uri ay dapat iwasan hangga't maaari upang matiyak ang kaligtasan ng uri.

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

Sa halimbawang ito, ang numero na 5 ay implicit na kinonvert sa isang string, na naging resulta sa string na "55".

Explicit na Pagkonbersyon ng Uri

Sa TypeScript, gumamit ng mga anotasyon ng uri o mga function sa pagkonbersyon ng uri upang ligtas na magawa ang pagkonbersyon ng mga uri.

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

Sa halimbawang ito, ang Number() na function ay ginamit upang explicit na ikonvert ang string na "123" sa numero na 123.

Pagcheck ng Uri

Sa TypeScript, maaari mong gamitin ang typeof operator para i-check ang uri ng data ng isang variable.

 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 () {});

Sa TypeScript, maaari mong gamitin ang typeof upang i-check ang mga uri, ngunit para sa mas tumpak na pagcheck ng uri, inirerekomenda rin ang paggamit ng mga instanceof o is operators.

Buod

Ang Wrapper Objects ay itinuturing bilang mga object dahil nagbibigay sila ng karagdagang mga pamamaraan at katangian para sa mga primitive na uri.
Ang String, Number, at Boolean ay mga kinatawang halimbawa ng wrapper objects.
Hindi tulad ng mga primitive na uri, ang mga wrapper objects ay kinikilala bilang object ng typeof.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video

Mga Pangunahing Kaalaman sa TypeScript Mga Operator sa TypeScript