Articles
Panimula sa JavaScript
Ang `Number` Class sa JavaScript

Ang `Number` Class sa JavaScript

Ipinaliwanag ng artikulong ito ang Number class sa JavaScript.

Maingat naming ipapaliwanag ang mga katangian ng Number, mga karaniwang pagkakamali, mga kapaki-pakinabang na API, at mga praktikal na halimbawa, hakbang-hakbang.

YouTube Video

Ang Number Class sa JavaScript

Ang Number ay ang pangunahing uri ng numeriko sa JavaScript at ito ay kinakatawan bilang isang IEEE-754 double-precision floating point (64-bit).

Pangunahing Kaalaman: Representasyon ng Numero at Pag-check ng Uri

Sa JavaScript, lahat ng numero ay kinakatawan bilang primitive na uri na number.

 1// Primitive numbers and Number object
 2const a = 42;                 // primitive number
 3const b = 3.14;               // primitive float
 4const c = Number(10);         // primitive via constructor call (function form)
 5const d = new Number(10);     // Number object (wrapper)
 6
 7console.log(typeof a);        // "number"
 8console.log(typeof d);        // "object"
 9console.log(c == d);          // true  (value coerces)
10console.log(c === d);         // false (different types)
  • Ipinapakita ng code na ito ang pagkakaiba sa pagitan ng primitive na number at ng Number wrapper object. Karaniwan, mga primitive ang ginagamit imbes na mga wrapper.

Espesyal na Mga Halaga: NaN, Infinity, at Mga Constant

Nagbibigay ang Number ng mga espesyal na halaga (NaN, Infinity) at mga constant.

 1// Special numeric values and constants
 2console.log(Number.NaN);                 // NaN
 3console.log(Number.POSITIVE_INFINITY);   // Infinity
 4console.log(Number.NEGATIVE_INFINITY);   // -Infinity
 5
 6console.log(Number.MAX_VALUE);           // largest positive representable
 7console.log(Number.MIN_VALUE);           // smallest positive representable (closest to 0)
 8console.log(Number.MAX_SAFE_INTEGER);    // 9007199254740991
 9console.log(Number.MIN_SAFE_INTEGER);    // -9007199254740991
10console.log(Number.EPSILON);             // smallest difference ~2.220446049250313e-16
  • Ang mga integer na mas malaki o katumbas ng MAX_SAFE_INTEGER ay maaaring hindi tamang maipakita. Isaalang-alang ang paggamit ng BigInt kung kinakailangan ang katumpakan. Ang EPSILON ay ginagamit sa paghahambing ng floating-point.

Pagko-convert ng Numero: Number(), parseInt, parseFloat, at ang + Operator

May ilang paraan upang ma-convert ang string sa numero, bawat isa ay may iba't ibang pag-uugali.

 1// Converting strings to numbers
 2console.log(Number("42"));        // 42
 3console.log(Number("  3.14 "));   // 3.14
 4console.log(+ "7");               // 7 (unary +)
 5
 6console.log(parseInt("42px"));    // 42
 7console.log(parseFloat("3.14abc"));// 3.14
 8
 9// Careful with parseInt and radix
10console.log(parseInt("08"));      // 8
11console.log(parseInt("08", 10));  // 8 (explicit radix is safer)
  • Ang Number() ay nagbabalik ng NaN maliban kung ang buong string ay striktong nasa numeric na format, samantalang ang parseInt at parseFloat ay kinukuha ang nababasang parte ng numero mula sa simula ng string. Mas ligtas na laging tukuying malinaw ang radix kapag gumagamit ng parseInt.

Pag-handle at Pag-check ng NaN: isNaN at Number.isNaN

Ang NaN (Not-A-Number) ay espesyal dahil NaN !== NaN. May pagkakaiba sa kanilang pag-check; ang global na isNaN ay gumagawa ng type conversion at maaaring magresulta sa maling positibo, kaya inirerekomenda ang Number.isNaN.

1// NaN detection differences
2console.log(NaN === NaN);             // false
3
4console.log(isNaN("foo"));            // true  -> because "foo" coerces to NaN
5console.log(Number.isNaN("foo"));     // false -> "foo" is not the numeric NaN
6
7console.log(Number.isNaN(NaN));       // true
  • Gamitin ang Number.isNaN para mag-check ng mga numero at mag-validate ng resulta ng kalkulasyon upang maiwasan ang hindi kailangang type conversion.

Mga Pagkakamali sa Floating-Point at Paghahambing Gamit ang Number.EPSILON

Dahil sa IEEE-754, may mga pagkakamaling tulad ng 0.1 + 0.2 !== 0.3. Para sa mas mahigpit na paghahambing, karaniwan nang gamitin ang diperensya at ang Number.EPSILON.

1// Floating point precision example and EPSILON comparison
2const sum = 0.1 + 0.2;
3console.log(sum === 0.3);             // false
4
5function nearlyEqual(a, b, epsilon = Number.EPSILON) {
6  return Math.abs(a - b) <= epsilon * Math.max(1, Math.abs(a), Math.abs(b));
7}
8
9console.log(nearlyEqual(sum, 0.3));   // true
  • Kapag pinapayagan ang maliit na pagkakaiba sa paghahambing, inirerekomenda ang matatag na implementasyon tulad ng nearlyEqual na gumagamit din ng scaling at absolute differences.

Pag-check ng Integers at Safe Integers (isInteger, isSafeInteger)

May mga API upang i-check kung ang value ay isang integer at kung ito ay nasa loob ng ligtas na range ng integer.

1// Integer and safe integer checks
2console.log(Number.isInteger(3));                 // true
3console.log(Number.isInteger(3.0));               // true
4console.log(Number.isInteger(3.1));               // false
5
6console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER)); // true
7console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)); // false
  • Kapag kinakailangan ang katumpakan para sa malalaking integer, gamitin ang Number.isSafeInteger para mag-check, at isaalang-alang ang paggamit ng BigInt sa mga numerong lumalagpas sa saklaw na iyon.

Display at Format: toFixed, toPrecision, toString

May mga paraan para makontrol ang paraan ng pagpapakita ng mga numero. Ang toFixed ay nagbabalik ng string na may tinukoy na bilang ng decimal places, ngunit mag-ingat sa pag-round.

1// Formatting numbers for display
2const x = 1.23456;
3console.log(x.toFixed(2));         // "1.23"   (string)
4console.log(x.toPrecision(3));     // "1.23"   (string with total significant digits)
5console.log((255).toString(16));   // "ff"     (hexadecimal string)
  • Ang toFixed ay nagbabalik ng string, kaya dapat maging maingat sa mga value kapag kino-convert muli para kalkulahin.

Mga Paalala ukol sa String Concatenation at + Operator

Ang + operator ay ginagamit para sa parehong pagdagdag ng numero at pagkakabit ng string, kaya maaaring magdulot ng hindi inaasahang resulta depende sa mga uri ng datos.

1// Pitfall with + operator and type coercion
2console.log(1 + 2 + "px");    // "3px"
3console.log("px" + 1 + 2);    // "px12"
4console.log(1 + "2" - 0);     // 3  (string coerced to number for subtraction)
  • Kapag nahahalo ang string at numero, mas ligtas na gumamit ng String(), Number(), o template literals upang maiwasan ang implicit type conversion.

Mga Advanced na Gamit: Number.parseInt / Number.parseFloat, valueOf

Ang Number.parseInt at Number.parseFloat ay mga alias ng mga global function. Ang valueOf ay ginagamit para kunin ang primitive value mula sa isang Number object, ngunit bihira itong kailanganin sa aktwal na paggamit.

1// Number.parseInt/parseFloat aliases and valueOf example
2console.log(Number.parseInt("100", 10));   // 100
3console.log(Number.parseFloat("3.14"));    // 3.14
4
5const nObj = new Number(5);
6console.log(nObj.valueOf());               // 5
7console.log(nObj + 1);                     // 6  (object coerced to primitive)
  • Kapag gumagamit ng Number.parseInt at Number.parseFloat, maging maingat sa radix at sa pag-trim ng input. Karaniwan, iniiwasan ang paggamit ng wrapper objects.

Referencia: Maliit na Utility na Halimbawa - Mga Function para sa Number Validation

Narito ang maliliit na utility function na kinokolekta ang mga karaniwang ginagamit na pagsusuri. Pinadadali nito ang mga gawain tulad ng input validation.

 1// Small number utility functions
 2function toNumberStrict(value) {
 3  // Return a Number or throw for invalid numeric strings
 4  const n = Number(value);
 5  if (typeof value === "string" && value.trim() === "") {
 6    throw new Error("Empty string is not a valid number");
 7  }
 8  if (Number.isNaN(n)) {
 9    throw new Error(`Invalid number: ${value}`);
10  }
11  return n;
12}
13
14function almostEqual(a, b, eps = Number.EPSILON) {
15  // Robust relative comparison
16  return Math.abs(a - b) <= eps * Math.max(1, Math.abs(a), Math.abs(b));
17}
  • Ito ay mga versatile na function na maaaring gamitin nang paulit-ulit sa input processing at paghahambing. Ang mga implementasyon na nagtatapon ng error ay kapaki-pakinabang para sa validation.

Buod ng Performance at Mga Pinakamainam na Paraan

Ang mga sumusunod ay mga praktikal na puntos kapag gumagamit ng Number.

  • Sa pangkalahatan, gamitin ang primitive na number at iwasan ang new Number().
  • Pumili sa pagitan ng Number() (mahigpit) o parseInt/parseFloat (bahaging bunot) para sa string-to-number conversion depende sa iyong kaso.
  • Gamitin ang Number.isNaN at Number.isFinite para sa ligtas na pag-check.
  • Para sa floating-point na paghahambing, gumamit ng Number.EPSILON o gumawa ng sariling comparison function.
  • Kapag kinakailangan ng katumpakan sa integer, gamitin ang Number.isSafeInteger; kung lumagpas, gumamit ng BigInt.
  • Maaari mong gamitin ang toFixed o toPrecision para mag-round sa pagpapakita, ngunit tandaan na ang return value ay isang string.

Buod

Ang Number ay ang pangunahing uri para sa lahat ng numero sa JavaScript, kabilang ang integer, decimal, at mga espesyal na halaga (NaN at Infinity). Mahalagang maging maingat sa type conversion at floating-point na mga pagkakamali, at tama ang paggamit ng mga pamamaraan tulad ng Number.isNaN at Number.EPSILON. Kung lumagpas sa safe integer range, gumamit ng BigInt, at gamitin ang toFixed o toPrecision para sa pag-round at pagpapakita.

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

Ang klase na `JSON` sa JavaScript