Mga Uri ng Data sa JavaScript

Ipinaliliwanag ng artikulong ito ang mga uri ng data sa JavaScript.

YouTube Video

Mga Uri ng Data sa JavaScript

Ang JavaScript ay mayroong mga uri ng data upang mauri ang mga halaga, na maaaring mahati sa mga uri ng primitive at mga uri ng object. Ang mga uri ng data ay tumutukoy kung anong uri ng data ang nakaimbak sa isang variable at nakakaapekto kung paano ito maaaring manipulahin.

Mga Uri ng Primitive

Ang mga uri ng primitive ay simpleng mga uri ng data na kumakatawan sa isang solong halaga. Ang JavaScript ay may sumusunod na 7 na uri ng primitive.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• Ang number ay isang uri na ginagamit para sa paghawak ng mga numerical na halaga, kabilang ang mga integers at floating-point numbers (mga decimal). Ang paghawak ng mga halaga na lumampas sa ilang 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 JavaScript, ang mga numero ay kinakatawan bilang floating-point numbers. Dahil dito, ang ilang decimal (lalo na ang mga hindi maaaring maipakita nang eksakto sa binary) ay maaaring hindi maipahayag nang eksakto.
• Kapag kinakailangan ang eksaktong kalkulasyon, tulad ng para sa mga halaga ng pera, kailangang iwasan ang ganitong mga pagkakamali sa pag-round-off. Halimbawa, maaari mong gamitin ang BigInt o ayusin ang bilang ng decimal places gamit ang toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• Ang string ay isang uri ng data na ginagamit para sa paghawak ng teksto, na kumakatawan sa isang hanay ng mga karakter. Ito ay kinakatawan sa pamamagitan ng paglilista ng teksto sa single quotes (') o double quotes ("). Mula ES6 at pataas, pinapayagan ng template literals ang madaling pagsasama ng mga variable gamit ang backticks (). Upang maisama ang isang variable, gamitin ang syntax na ${}.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• Ang boolean ay kumakatawan sa isang lohikal na halaga at maaari lamang magkaroon ng dalawang halaga: true o false. Ginagamit ito bilang resulta ng mga kundisyunal na pagpapahayag o bilang isang flag.

null

1let result = null;
2
3console.log("Value of result:", result);

• Ang null ay isang uri ng data na tahasang nagpapahiwatig ng 'walang halaga.'. Ang null ay itinakda ng mga developer upang ipahiwatig ang sadyang kawalan.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• Ang undefined ay isang uri ng data na nangangahulugang 'hindi natukoy.'. Ang undefined ay awtomatikong itinalaga kapag ang isang variable ay naideklara ngunit hindi nabigyan ng halaga.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint ay isang uri ng data para sa paghawak ng malalaking buumbilang. bigint ay nagpapahintulot ng tumpak na representasyon ng malalaking buumbilang na hindi kayang i-representa ng uri na number. Ang mga literal ng bigint ay kinakatawan sa pamamagitan ng pagdaragdag ng n sa dulo ng isang numero.
• bigint ay isang uri para sa paghawak ng mga buumbilang ng kahit anong sukat, na walang limitasyon sa sakop. Gayunpaman, ang bigint at number ay hindi maaaring direktang operahin nang magkasama, kaya kinakailangan ng pag-iingat.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbol ay isang uri ng data na ginagamit upang lumikha ng natatanging mga identifier. Ito ay nilikha gamit ang Symbol() at maaaring gamitin bilang isang katangian ng isang object. Hindi tulad ng ibang mga primitive na uri, ang Symbol ay may mga natatanging halaga, kaya kahit pareho ang nilalaman, ito ay itinuturing na ibang Symbol.

Mga Uri ng Object

Ang mga uri ng object ay mga istraktura ng data na maaaring mag-imbak ng maraming halaga. Ang isang object ay isang koleksyon ng mga pares ng key-value at maaaring magkaroon ng mga property at mga method.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Ang Object ay isang koleksyon ng mga katangian (key-value pairs) na maaaring mag-imbak ng iba't ibang uri ng data. Ang mga object ay kinakatawan ng {} mga kulot na brace, at bawat property ay nakakonekta ng : sa pagitan ng key at value.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Ang Array ay isang listahan na naglalaman ng maraming halaga sa maayos na pagkakasunod-sunod. Ang mga array ay kinakatawan ng [ ] na mga square bracket, at ang mga halaga ay pinaghihiwalay ng mga kuwit ,. Ang bawat elemento ay ina-access gamit ang isang index na nagsisimula sa 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Ang Functions ay isang uri ng object at reusable na mga bloke ng code. Maaaring tukuyin ang mga function gamit ang keyword na function.

Iba Pang Uri ng Object

• Ang JavaScript ay mayroon ding mga built-in na uri ng object tulad ng Date, RegExp, Map, at Set. Ang mga ito ay ginagamit upang pamahalaan ang data batay sa partikular na mga kaso ng paggamit.

Pagpapalit ng Uri

Ang Implicit at explicit na pagpapalit ng uri ay madalas na ginagawa sa JavaScript.

Implicit na Pagpapalit ng Uri

• Maaaring awtomatikong i-convert ng JavaScript ang mga uri kapag nagsasagawa ng mga operasyon sa pagitan ng iba't ibang uri.

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

• Sa halimbawa na ito, ang bilang na 5 ay hindi tuwirang na-convert sa isang string, na nagresulta sa string na "55".

Explicit na Pagpapalit ng Uri

• Ang mga developer ay maaari ding magsagawa ng pagpapalit ng uri nang tahasan.

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

• Sa halimbawa na ito, ginamit ang function na Number() upang tahasang ma-convert ang string na "123" sa bilang na 123.

Pag-check ng Uri

Sa JavaScript, maaari mong gamitin ang operator na typeof upang matukoy 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 () {});

Konklusyon

• Ang Primitive na uri ay kinabibilangan ng number, string, boolean, null, undefined, at symbol.
• Ang Mga Uri ng Object ay kinabibilangan ng Object, Array, Function, at iba pa.
• Dahil parehong nangyayari ang awtomatiko at malinaw na pagbabago ng uri, mahalagang maunawaan ang wastong paggamit ng mga uri ng datos.

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