Šajā apmācībā jūs uzzināsit par JavaScript numuru ar piemēru palīdzību.
JavaScript valodā skaitļi ir primitīvi datu tipi. Piemēram,
const a = 3; const b = 3.13;
Atšķirībā no dažām citām programmēšanas valodām, jums nav īpaši jādeklarē vesels skaitlis vai peldošās vērtības, izmantojot int , float utt.
Eksponenciālo apzīmējumu e var izmantot, lai iekļautu pārāk lielus vai pārāk mazus skaitļus. Piemēram,
const a1 = 5e9; console.log(a1); //5000000000 const a2 = 5e-5; console.log(a2); // 0.00005
Skaitļus var apzīmēt arī ar heksadecimālo apzīmējumu. Piemēram,
const a = 0xff; console.log(a); // 255 const b = 0x00 ; console.log(b); // 0
+ Operators ar numuriem
Ja +to lieto kopā ar skaitļiem, to izmanto skaitļu pievienošanai. Piemēram,
const a = 4 + 9; console.log(a); // 13
Ja +to lieto kopā ar skaitļiem un virknēm, to izmanto, lai tos savienotu. Piemēram,
const a = '4' + 9; console.log(a); // 49
Ja ciparu virkni izmanto kopā ar citām skaitliskām operācijām, ciparu virkne tiek pārveidota par skaitli. Piemēram,
const a = '4' - 2; console.log(a); // 2 const a = '4' / 2; console.log(a); // 2 const a = '4' * 2; console.log(a); // 8
JavaScript NaN
JavaScript valodā NaN(Not a Number) ir atslēgvārds, kas norāda, ka vērtība nav skaitlis.
Veicot aritmētiskās darbības (izņemot +) skaitliskajai vērtībai ar virknes rezultātiem NaN. Piemēram,
const a = 4 - 'hello'; console.log(a); // NaN
Iebūvēto funkciju isNaN()var izmantot, lai noteiktu, vai vērtība ir skaitlis. Piemēram,
const a = isNaN(9); console.log(a); // false const a = isNaN(4 - 'hello'); console.log(a); // true
Ja vērtību typeofizmanto operatoru NaN, tas dod skaitļa izvadi. Piemēram,
const a = 4 - 'hello'; console.log(a); // NaN console.log(typeof a); // "number"
JavaScript bezgalība
Jo JavaScript, kad aprēķins tiek veikts, kas pārsniedz lielāko (vai vismazāko) iespējamo numuru Infinity (vai -Infinity) tiek atgriezta. Piemēram,
const a = 2 / 0; console.log(a); // Infinity const a = -2 / 0; console.log(a); // -Infinity
JavaScript BigInt
JavaScript valodā ciparu tips var attēlot tikai skaitļus, kas mazāki par (2 53 - 1) un lielākus par - (2 53 - 1) . Tomēr, ja jums ir jāizmanto lielāks skaitlis, varat izmantot BigInt datu tipu.
BigInt numurs tiek izveidots, veselā skaitļa beigās pievienojot n . Piemēram,
// BigInt value const value = 900719925124740998n; // Adding two big integers const value1 = value + 1n; console.log(value1); // returns "900719925124740999n"
Piezīme: BigInt tika ieviests jaunākā JavaScript versijā, un daudzi pārlūki to neatbalsta. Apmeklējiet JavaScript BigInt atbalstu, lai uzzinātu vairāk.
JavaScript numuri tiek glabāti 64 bitu formātā
JavaScript valodā numuri tiek glabāti 64 bitu formātā IEEE-754, kurus sauc arī par "dubultprecīziem peldošā komata numuriem".
Skaitļi tiek saglabāti 64 bitos (skaitlis tiek saglabāts 0 līdz 51 bitu pozīcijās, eksponents 52 līdz 62 bitu pozīcijās un zīme 63 bitu pozīcijā).
| Skaitļi | Eksponents | Parakstieties |
|---|---|---|
| 52 biti (0 - 51) | 11 biti (52–62) | 1 bits (63) |
Precizitātes problēmas
Darbības ar peldošā komata skaitļiem rada dažus negaidītus rezultātus. Piemēram,
const a = 0.1 + 0.2; console.log(a); // 0.30000000000000004
Rezultātam jābūt 0,3, nevis 0,3000000000000000004 . Šī kļūda rodas tāpēc, ka JavaScript skaitļi tiek glabāti binārā formā, lai iekšēji attēlotu decimālzīmes. Un decimāldaļskaitļus nevar precīzi attēlot binārā formā.
Lai atrisinātu iepriekš minēto problēmu, varat rīkoties šādi:
const a = (0.1 * 10 + 0.2 * 10) / 10; console.log(a); // 0.3
Jūs varat arī izmantot toFixed()metodi.
const a = 0.1 + 0.2; console.log(a.toFixed(2)); // 0.30
toFixed(2) decimāldaļu noapaļo līdz divām decimāldaļām.
const a = 9999999999999999 console.log(a); // 10000000000000000
Piezīme . Veseli skaitļi ir precīzi līdz 15 cipariem.
Objektu skaits
Izmantojot newatslēgvārdu, varat izveidot arī skaitļus . Piemēram,
const a = 45; // creating a number object const b = new Number(45); console.log(a); // 45 console.log(b); // 45 console.log(typeof a); // "number" console.log(typeof b); // "object"
Piezīme . Ieteicams izvairīties no skaitļu objektu izmantošanas. Skaitļu objektu izmantošana palēnina programmu.
JavaScript numuru metodes
Šeit ir JavaScript iebūvēto skaitļu metožu saraksts.
| Metode | Apraksts |
|---|---|
| isNaN () | nosaka, vai nodotā vērtība ir NaN |
| isFinite () | nosaka, vai nodotā vērtība ir ierobežots skaitlis |
| isInteger () | nosaka, vai nodotā vērtība ir vesels skaitlis |
| isSafeInteger () | nosaka, vai nodotā vērtība ir drošs vesels skaitlis |
| parseFloat (virkne) | pārveido skaitlisko peldošo virkni par peldošā komata skaitli |
| parseInt (virkne, (radix)) | pārveido ciparu virkni par veselu skaitli |
| toExponential (frakcijaDigits) | returns a string value for a number in exponential notation |
| toFixed(digits) | returns a string value for a number in fixed-point notation |
| toPrecision() | returns a string value for a number to a specified precision |
| toString((radix)) | returns a string value in a specified radix(base) |
| valueof() | returns the numbers value |
| toLocaleString() | returns a string with a language sensitive representation of a number |
For example,
// check if a is integer const a = 12; console.log(Number.isInteger(a)); // true // check if b is NaN const b = NaN; console.log(Number.isNaN(b)); // true // display upto two decimal point const d = 5.1234; console.log(d.toFixed(2)); // 5.12
JavaScript Number Properties
Here is a list of Number properties in JavaScript.
| Property | Description |
|---|---|
| EPSILON | returns the smallest interval between two representable numbers |
| MAX_SAFE_INTEGER | returns the maximum safe integer |
| MAX_VALUE | returns the largest possible value |
| MIN_SAFE_INTEGER | returns the minimum safe integer |
| MIN_VALUE | returns the smallest possible value |
| NaN | represents 'Not-a-Number' value |
| NEGATIVE_INFINITY | represents negative infinity |
| POSITIVE_INFINITY | apzīmē pozitīvu bezgalību |
| prototips | ļauj objektam Numurs pievienot īpašības |
Piemēram,
// largest possible value const a = Number.MAX_VALUE; console.log(a); // 1.7976931348623157e+308 // maximum safe integer const a = Number.MAX_SAFE_INTEGER; console.log(a); // 9007199254740991
JavaScript numura () funkcija
Number()Funkcija tiek izmantota, lai pārvērstu dažādus datu tipus numuriem. Piemēram,
const a = '23'; // string const b = true; // boolean //converting to number const result1 = Number(a); const result2 = Number(b); console.log(result1); // 23 console.log(result2); // 1
Ja vēlaties uzzināt vairāk par skaitļu pārveidošanu, apmeklējiet vietni JavaScript tipa reklāmguvums.
