జావాస్క్రిప్ట్ నంబర్

జావాస్క్రిప్ట్లో ఒక మాత్రమే నమ్మబడిన విలువ రకం ఉంది.

నమ్మబడిన విలువలను రాయడంలో చివరి ముద్రలు ఉండకూడదు.

జావాస్క్రిప్ట్ నమ్మబడిన విలువలు

JavaScript విలువలను చివరకు పంక్తి ఉన్నా లేదా లేనా రాయవచ్చు:

ఇన్స్టాన్స్

var x = 3.14;    // పంక్తి ఉన్న సంఖ్య
var y = 3;       // చివరకు పంక్తి లేని సంఖ్య

స్వయంగా ప్రయత్నించండి

అత్యంత పెద్ద లేదా చిన్న సంఖ్యలను శాస్త్రాత్మక పంక్తి ద్వారా రాయవచ్చు:

ఇన్స్టాన్స్

var x = 123e5;    // 12300000
var y = 123e-5;   // 0.00123

స్వయంగా ప్రయత్నించండి

JavaScript విలువలు ఎప్పటికీ 64 బిట్స్ ఫ్లోటింగ్ పంక్తి ఉంటాయి

పలు ఇతర ప్రోగ్రామింగ్ భాషలకు విరుద్ధంగా, JavaScript విలువలను వివిధ రకాలుగా నిర్వచించదు, అవి కాకుండా పంక్తి ప్రకారం, చిన్నవి, పెద్దవి, ఫ్లోటింగ్ పంక్తి వివిధంగా ఉంటాయి.

JavaScript విలువలు ఎప్పటికీ డబుల్ ప్రకృతి ఫ్లోటింగ్ పంక్తిలో నిల్వ చేస్తాయి, అంతర్జాతీయ IEEE 754 ప్రమాణాలకు అనుగుణంగా.

ఈ ఫార్మాట్ 64 బిట్స్ తో విలువను నిల్వ చేస్తుంది, అక్కడ 0 నుండి 51 వరకు సంఖ్యలు (ఫ్రాగ్మెంట్), 52 నుండి 62 వరకు ప్రకారాలు మరియు 63 బిట్స్ సిగ్నేచర్ ఉంటాయి:

ఫార్మాట్ (అకా ఫ్రాక్షన్ / మాంటిసిస్) ప్రకారం సిగ్నేచర్
52 బిట్స్ (0 - 51) 11 బిట్స్ (52 - 62) 1 బిట్ (63)

ప్రకృతి

పంక్తి ప్రకారం వాడకం లేదా శాస్త్రాత్మక పంక్తి లేదా స్కూలర్ కంటే సంఖ్యలు పరిపూర్ణంగా 15 స్థానాలకు కనిపించబడతాయి.

ఇన్స్టాన్స్

var x = 999999999999999;   // x ఉంటుంది 999999999999999
var y = 9999999999999999;  // y ఉంటుంది 10000000000000000

స్వయంగా ప్రయత్నించండి

చిన్న సంఖ్యల అత్యంత సంఖ్యలు 17 నిమిషాలు ఉంటాయి, కానీ ఫ్లోటింగ్ పంక్తి అలబాత్రిక్స్ ఎప్పటికీ 100% పరిపూర్ణం కాదు:

ఇన్స్టాన్స్

var x = 0.2 + 0.1;         // x ఉంటుంది 0.30000000000000004

స్వయంగా ప్రయత్నించండి

పైన పేర్కొన్న సమస్యను పరిష్కరించడానికి జోడించడం మరియు భాగంగా వినియోగించడం వాడతారు:

ఇన్స్టాన్స్

var x = (0.2 * 10 + 0.1 * 10) / 10;       // x ఉంటుంది 0.3

స్వయంగా ప్రయత్నించండి

సంఖ్యలు మరియు స్ట్రింగ్లు జోడించడం

జాగ్రత్త గా !!

JavaScript జోడించడం మరియు కలయిక (concatenation) లకు అదే + ఆపరేటర్ వాడతారు.

సంఖ్యలను జోడించడం వాడతారు. స్ట్రింగ్లను కలయిక చేస్తారు.

మీరు రెండు సంఖ్యలను జోడించినప్పుడు, ఫలితం ఒక సంఖ్య ఉంటుంది:

ఇన్స్టాన్స్

var x = 10;
var y = 20;
var z = x + y;           // z ఉంటుంది 30 (ఒక సంఖ్య)

స్వయంగా ప్రయత్నించండి

రెండు స్ట్రింగ్లను జోడించినప్పుడు, ఫలితం ఒక స్ట్రింగ్ కలయిక ఉంటుంది:

ఇన్స్టాన్స్

var x = "10";
var y = "20";
var z = x + y;           // z అని 1020 (పదం) అవుతుంది

స్వయంగా ప్రయత్నించండి

మీరు ఒక సంఖ్యను మరియు ఒక స్ట్రింగ్ ను జోడించినప్పుడు, ఫలితం కూడా స్ట్రింగ్ కలయిక ఉంటుంది:

ఇన్స్టాన్స్

var x = 10;
var y = "20";
var z = x + y;           // z ఉంటుంది 1020 (ఒక స్ట్రింగ్)

స్వయంగా ప్రయత్నించండి

ఒక పదాన్ని మరియు సంఖ్యను కలపడంలో ఫలితం పదం జతచేయబడుతుంది:

ఇన్స్టాన్స్

var x = "10";
var y = 20;
var z = x + y;           // z అని 1020 (పదం) అవుతుంది

స్వయంగా ప్రయత్నించండి

సాధారణంగా ఫలితం 30 అని భావిస్తారు:

ఇన్స్టాన్స్

var x = 10;
var y = 20;
var z = "The result is: " + x + y;

స్వయంగా ప్రయత్నించండి

సాధారణంగా ఫలితం 102030 అని భావిస్తారు:

ఇన్స్టాన్స్

var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;

స్వయంగా ప్రయత్నించండి

జావాస్క్రిప్ట్ ఎడమ నుండి కుడికి సంకేతింపులను చేస్తుంది.

ఇక్కడ x మరియు y సంఖ్యలు అని ఉన్నందున, 10 + 20 జతచేయబడుతుంది.

ఇక్కడ z పదం అని ఉన్నందున, 30 + "30" జతచేయబడుతుంది.

సంఖ్య పదం

జావాస్క్రిప్ట్ పదాలు సంఖ్యలను కలిగి ఉండవచ్చు:

var x = 100;         // x అని సంఖ్య
var y = "100";       // y అని పదం

అన్ని సంఖ్య కలిగిన కాలకలిగిన ఆపరేషన్లలో, జావాస్క్రిప్ట్ పదాన్ని సంఖ్యగా మారుస్తుంది:

ఈ ఉదాహరణ ఈ విధంగా పనిచేస్తుంది:

var x = "100";
var y = "10";
var z = x / y;       // z అని 10 అవుతుంది

స్వయంగా ప్రయత్నించండి

ఈ ఉదాహరణ ఈ విధంగా పనిచేస్తుంది:

var x = "100";
var y = "10";
var z = x * y;       // z అని 1000 అవుతుంది

స్వయంగా ప్రయత్నించండి

ఈ ఉదాహరణ ఈ విధంగా పనిచేస్తుంది:

var x = "100";
var y = "10";
var z = x - y;      // z అని 90 అవుతుంది

స్వయంగా ప్రయత్నించండి

ఈ ఉదాహరణ అలాగే పనిచేయదు:

var x = "100";
var y = "10";
var z = x + y;       // z అని 110 కాదు (10010 అవుతుంది)

స్వయంగా ప్రయత్నించండి

చివరి ఉదాహరణలో, జావాస్క్రిప్ట్ + ఆపరేటర్ ను పదాలను జతచేస్తుంది.

NaN - అసంఖ్యాకం

NaN జావాస్క్రిప్ట్ అన్యంకం పదం, ఒక సంఖ్య అని సూచిస్తుంది.

ఒక అసంఖ్యాక పదాన్ని విభజించడంలో ఉంటే NaN (Not a Number) అవుతుంది:

ఇన్స్టాన్స్

var x = 100 / "Apple";  // x అని NaN (Not a Number) అవుతుంది

స్వయంగా ప్రయత్నించండి

కానీ, ఇక్కడ పదం సంఖ్యగా ఉన్నట్లయితే ఫలితం సంఖ్యగా ఉంటుంది:

ఇన్స్టాన్స్

var x = 100 / "10";     // x అని 10 అవుతుంది

స్వయంగా ప్రయత్నించండి

మీరు సమగ్ర జావాస్క్రిప్ట్ ఫంక్షన్ ను ఉపయోగించవచ్చు: isNaN() ఒక విలువను సంఖ్యగా నిర్ణయించడానికి:

ఇన్స్టాన్స్

var x = 100 / "Apple";
isNaN(x);               // సంఖ్య కాదు అని తిరిగిస్తుంది

స్వయంగా ప్రయత్నించండి

要小心 NaN。假如您在数学运算中使用了 NaN，则结果也将是 NaN：

ఇన్స్టాన్స్

var x = NaN;
var y = 5;
var z = x + y;         // z 将是 NaN

స్వయంగా ప్రయత్నించండి

结果也许是串连接：

ఇన్స్టాన్స్

var x = NaN;
var y = "5";
var z = x + y;         // z 将是 NaN5

స్వయంగా ప్రయత్నించండి

NaN 是数，typeof NaN 返回 number：

ఇన్స్టాన్స్

typeof NaN;             // 返回 "number"

స్వయంగా ప్రయత్నించండి

Infinity

Infinity （或 -Infinity）是 JavaScript 在计算数时超出最大可能数范围时返回的值。

ఇన్స్టాన్స్

var myNumber = 2;
while (myNumber != Infinity) {          // 执行直到 Infinity
    myNumber = myNumber * myNumber;
}

స్వయంగా ప్రయత్నించండి

除以 0（零）也会生成 Infinity：

ఇన్స్టాన్స్

var x =  2 / 0;          // x 将是 Infinity
var y = -2 / 0;          // y 将是 -Infinity

స్వయంగా ప్రయత్నించండి

Infinity 是数：typeOf Infinity 返回 number。

ఇన్స్టాన్స్

typeof Infinity;        // 返回 "number"

స్వయంగా ప్రయత్నించండి

十六进制

JavaScript 会把前缀为 0x 的数值常量解释为十六进制。

ఇన్స్టాన్స్

var x = 0xFF;             // x 将是 255。

స్వయంగా ప్రయత్నించండి

绝不要用前导零写数字（比如 07）。

一些 JavaScript 版本会把带有前导零的数解释为八进制。

默认地，Javascript 把数显示为十进制小数。

但是您能够使用 toString() 方法把数输出为十六进制、八进制或二进制。

ఇన్స్టాన్స్

var myNumber = 128;
myNumber.toString(16);     // బయటపడు 80
myNumber.toString(8);      // బయటపడు 200
myNumber.toString(2);      // బయటపడు 10000000

స్వయంగా ప్రయత్నించండి

నంబర్లు కూడా ఆబ్జెక్ట్లు కావచ్చు

సాధారణంగా జావాస్క్రిప్ట్ నంబర్లు లాక్షణిక విలువల ద్వారా సృష్టించబడతాయి: var x = 123

但是也可以通过关键词 new 定义为对象：var y = new Number(123)

ఇన్స్టాన్స్

var x = 123;
var y = new Number(123);
// typeof x 返回 number
// typeof y 返回 object

స్వయంగా ప్రయత్నించండి

请不要创建数值对象。这样会拖慢执行速度。

new 关键词使代码复杂化，并产生某些无法预料的结果：

ఉపయోగించినప్పుడు == 相等运算符时，相等的数看上去相等：

ఇన్స్టాన్స్

var x = 500;             
var y = new Number(500);
// (x == y) 为 true，因为 x 和 y 有相等的值

స్వయంగా ప్రయత్నించండి

ఉపయోగించినప్పుడు === సమానత్వ ఆపరేటర్ తర్వాత, సమానంగా ఉన్న సంఖ్యలు సమానంగా కనిపించవు ఎందుకంటే === ఆపరేటర్స్ రకం మరియు విలువలను ఒకేసారి సమానంగా చేయాలి.

ఇన్స్టాన్స్

var x = 500;             
var y = new Number(500);
// (x === y) కాల్స్ట్ ఫాల్స్, ఎందుకంటే x మరియు y యొక్క రకాలు వ్యత్యాసపడినవి

స్వయంగా ప్రయత్నించండి

కాక కూడా చాలా చెడు. ఓబ్జెక్ట్స్ పోలింగ్ చేయలేదు:

ఇన్స్టాన్స్

var x = new Number(500);             
var y = new Number(500);
// (x == y) కాల్స్ట్ ఫాల్స్, ఎందుకంటే ఓబ్జెక్ట్స్ పోలింగ్ చేయలేదు

స్వయంగా ప్రయత్నించండి

జావాస్క్రిప్ట్ ఆబ్జెక్ట్స్ పోలింగ్ చేయలేదు.