Articles
Panimula sa JavaScript
Mga Wrapper Object sa JavaScript

Mga Wrapper Object sa JavaScript

Ipinaliliwanag ng artikulong ito ang tungkol sa mga wrapper object sa JavaScript.

YouTube Video

Mga Wrapper Object

Ang JavaScript ay mayroong mga uri ng primitive at mga object upang pangasiwaan ang mga ito (mga wrapper object).

Mga Uri ng Primitive

Ang mga primitive na uri ay kumakatawan sa isang nag-iisang halaga at simple at magaan. Ang mga ito ay hindi nababago (hindi maaring baguhin) at walang direktang mga pamamaraan o katangian ng object, ngunit pansamantalang maaring gawing mga wrapper na object para sa mga operasyon.

Ang string at number ay mga halimbawa ng mga primitive na uri. Sa kabilang banda, ang mga wrapper na object ay nagsisimula sa malaking titik, tulad ng String at Number.

Mga Wrapper Object

Upang manipulahin ang mga primitive types, pansamantalang lumilikha ang JavaScript ng wrapper objects (Object wrappers). Ang mga Wrapper Objects ay naglalaman ng mga methods at properties para sa mga primitive types.

Number 

1let numObject = new Number(42);   // Wrapper object
2
3console.log(typeof numObject);    // object
4console.log(numObject.valueOf()); // 42
5
6let numValue = Number(42);        // Return primitive value
7
8console.log(typeof numValue);     // number
9console.log(numValue);            // 42
  • Ang Number ay isang object type na bumabalot sa isang pangunahing number. Sa pamamagitan ng sadyang paglikha ng isang Number object, maaari mong hawakan ang mga numero tulad ng number, ngunit karaniwang inirerekomenda ang paggamit ng pangunahing number type.

Ang typeof numObject ay "object", ngunit ang typeof 42 ay "number".

  • Pakakatandaan na ang paggamit ng new operator upang gumawa ng bagong wrapper object ay nagbibigay ng ibang resulta kaysa sa pagtawag sa Number bilang isang function. Kapag tinawag bilang isang function, isang primitive na number ang ibinabalik.

String 

1let strObject = new String("Hello"); // Wrapper object
2
3console.log(typeof strObject);    // object
4console.log(strObject.valueOf()); // Hello
  • Ito ay isang object type na bumabalot sa isang pangunahing string. Sa pamamagitan ng paggamit ng isang String object, maaari mong ma-access ang mga properties at methods ng string, ngunit karaniwang ginagamit ang pangunahing string.

Ang typeof strObject ay "object", ngunit ang typeof "Hello" ay "string".

  • Katulad ng Number, ang pagtawag sa String bilang isang function ay nagbabalik ng pangunahing string.

Boolean 

1let boolObject = new Boolean(true); // Wrapper object
2
3console.log(typeof boolObject);    // object
4console.log(boolObject.valueOf()); // true
  • Ito ay isang object type na bumabalot sa isang pangunahing boolean. Maaari ka ring sadyang lumikha ng isang Boolean object, ngunit karaniwang ginagamit ang pangunahing boolean type.

Ang typeof boolObject ay "object", ngunit ang typeof true ay "boolean".

  • Katulad ng Number, ang pagtawag sa Boolean bilang isang function ay nagbabalik ng pangunahing boolean.

BigInt 

 1let bigIntObject = Object(9007199254740991n); // Wrapper object
 2
 3console.log(typeof bigIntObject);    // object
 4console.log(bigIntObject.valueOf()); // 9007199254740991n
 5
 6let bigIntValue = BigInt(9007199254740991);   // Return primitive BigInt
 7
 8console.log(typeof bigIntValue);     // bigint
 9console.log(bigIntValue);            // 9007199254740991n
10
11// Error
12let bigIntObject2 = new BigInt(9007199254740991n);
  • Objectを使ってBigIntのラッパーオブジェクトを生成できますが、通常はプリミティブ型のbigintを直接使うのが一般的です。

typeof bigIntObjectは"object"であるのに対し、typeof 9007199254740991nは"bigint"です。

  • BigIntを関数として呼び出すとプリミティブなbigintを返しますが、new演算子をつけてBigIntのラッパーオブジェクトを生成することはできません。

Symbol 

1let symObject = Object(Symbol("id")); // Wrapper object for Symbol
2
3console.log(typeof symObject);    // object
4console.log(symObject.valueOf()); //
  • Maaari mong gamitin ang Object upang lumikha ng wrapper object para sa Symbol, ngunit kadalasan, direktang ginagamit ang pangunahing uri ng Symbol.

Ang Mga Pagkakaiba sa pagitan ng Primitive Types at Wrapper Objects

  • Ang mga Primitive Types ay magaan at matipid sa memorya, ngunit wala silang direktang mga properties o methods. Gayunpaman, sa JavaScript, kahit na sa mga primitive types, awtomatikong lumilikha ng pansamantalang wrapper objects kung kinakailangan upang magbigay ng methods at properties.
1let text = "Hello";
2
3// A temporary String object is created,
4// allowing access to the length property
5console.log(text.length);
  • Ang Wrapper Objects ay mga sadyang nilikhang object na maaaring makaapekto sa memorya at performance, kaya karaniwang inirerekomenda ang paggamit ng primitive types.

Konklusyon

  • Mga Uri ng Primitive: Mga magagaan na uri tulad ng number, string, boolean, null, undefined, at symbol na walang direktang mga pamamaraan.
  • Mga Wrapper Object: Mga object tulad ng Number, String, at Boolean na pansamantalang na-convert mula sa mga primitive na uri.

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 Uri ng Data sa JavaScriptMga Operator sa JavaScript