ECMAScript రకాల మార్పు

అన్ని ప్రోగ్రామింగ్ భాషలకు అత్యంత ముఖ్యమైన లక్షణాలలో ఒకటి రకాల మార్పిడి చేయగలిగిన సామర్థ్యం ఉంటుంది.

ECMAScript కుడివాడికి ప్రధాన మెథడ్లు అనేవి చాలా మంది మెథడ్లు ఉన్నాయి.

అన్ని రకాల రకాలు సాధారణ మార్పిడి మెథడ్లు కలిగి ఉన్నాయి, మరియు కొన్ని సమగ్ర మార్పిడికి ఉపయోగపడే గ్లౌబల్ మెథడ్లు కూడా ఉన్నాయి. సరిగ్గా, ECMAScript లో రకాల మార్పిడి సాధారణమైన ఒక చర్య ఉంది.

స్ట్రింగ్గా మార్చడం

ECMAScript ప్రాథమిక విలువలు బౌలియన్ విలువలు, సంఖ్యలు మరియు స్ట్రింగ్లు అనేవి ఫలితాబ్జెక్ట్లు అని, అనగా వాటికి అంశాలు మరియు మెథడ్లు ఉన్నాయి.

ఉదాహరణకు, స్ట్రింగ్ పరిమాణాన్ని పొందడానికి, క్రింది కోడ్ ను ఉపయోగించవచ్చు:

var sColor = "red";

అయితే,

మొత్తంగా, మూడు ప్రధాన ప్రాథమిక రకాలు బౌలియన్ విలువలు, సంఖ్యలు మరియు స్ట్రింగ్లు టోస్ట్రింగ్() మెథడ్ కలిగి ఉన్నాయి, వాటి విలువలను స్ట్రింగ్లుగా మార్చవచ్చు.

సూచన:మీరు చెప్పే విధంగా,

Boolean రకం యొక్క toString() పద్ధతి మాత్రమే "true" లేదా "false" అవుట్‌పుట్ చేస్తుంది, ఫలితం సంబంధించిన విలువ ఆధారంగా ఉంటుంది:

var bFound = false;
alert(bFound.toString());	//అవుట్‌పుట్ "false"

Number రకం యొక్క toString() పద్ధతి యొక్క ప్రత్యేకత అనేది రెండు మోడ్లు కలిగి ఉంటుంది:డిఫాల్ట్ మోడ్మరియుబేస్ మోడ్డిఫాల్ట్ మోడ్లో, toString() పద్ధతి సంఖ్యల విలువను అనుసరించి అనుసరించే విధంగా అవుట్‌పుట్ చేస్తుంది (ఇంటిజర్, ఫ్లోటింగ్ లేదా సైన్స్ నామెల్ ఫార్మాట్ లో ఉండవచ్చు):

var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString());	//అవుట్‌పుట్ "10"
alert(iNum2.toString());	//అవుట్‌పుట్ "10"

పరిశీలన:డిఫాల్ట్ మోడ్లో, సంఖ్యలను ప్రారంభంలో ఏ రీతిలో ప్రకటించినా, Number రకం యొక్క toString() పద్ధతి అవుట్‌పుట్ చేసేది సంఖ్యల దశమ ఫలితం అని ఉంటుంది. అందువల్ల, ఆక్సీల్ లేదా హెక్సడెసిమల్ లాక్స్ లో ప్రకటించబడిన సంఖ్యలు అవుట్‌పుట్ చేయబడినా దశమ ఫలితంగా ఉంటాయి.

Number రకం యొక్క toString() పద్ధతి యొక్క బేస్ మోడల్ను వినియోగించి, వివిధబేస్సంఖ్యలను అవుట్‌పుట్ చేయండి, ఉదాహరణకు బైనరీ బేస్ అనేది 2, ఆక్సీల్ బేస్ అనేది 8, హెక్సడెసిమల్ బేస్ అనేది 16.

బేస్మాత్రమే మార్పిడి చేయవలసిన బేస్ సంఖ్య మరియు toString() పద్ధతి పరామితి అని పరిగణించవచ్చు:

var iNum = 10;
alert(iNum.toString(2));	//అవుట్‌పుట్ "1010"
alert(iNum.toString(8));	//అవుట్‌పుట్ "12"
alert(iNum.toString(16));	//అవుట్‌పుట్ "A"

ముంది ఉదాహరణలో, సంఖ్య 10 ను మూడు విధాలుగా అవుట్‌పుట్‌చేశాము: బైనరీ ఫార్మాట్, ఆక్సీల్ ఫార్మాట్ మరియు హెక్సడెసిమల్ ఫార్మాట్. HTML రంగులను హెక్సడెసిమల్ ఫార్మాట్ లో ప్రస్తుతీకరించడానికి ఈ ఫంక్షన్ చాలా ఉపయోగపడుతుంది.

పరిశీలన:సంఖ్యలపై toString(10) కాల్లా మరియు toString() కాల్లా అదే విధంగా కాల్లా, వాటివాటి అన్ని సంఖ్యల దశమ ఫలితంగా ఉంటాయి.

పరిశీలించండి:

చూడండి: JavaScript సందర్శనా పుస్తకంఈ సమాచారం లో toString() పద్ధతి కి సంబంధించిన వివరాలు అందిస్తుంది:

సంఖ్యగా మార్చడం

ECMAScript పైబడిన సంఖ్యలను అసంఖ్యాక విలువలను పరివర్తించడానికి రెండు పద్ధతులు అందిస్తుంది, అవి parseInt() మరియు parseFloat().

మీరు ఆశించినట్లు ఉండవచ్చు, మొదటి ఒకటి విలువను సంఖ్యగా మార్చుతుంది, మరొకటి విలువను ఫ్లోటింగ్ పదార్థకంగా మార్చుతుంది. ఈ పద్ధతులు మాత్రమే స్ట్రింగ్ రకంపై పని చేస్తాయి; ఇతర రకాలపై తిరిగి NaN అవుతాయి.

parseInt()

parseInt() మరియు parseFloat() పద్ధతులు స్ట్రింగ్ సంక్లిష్టమైన విలువను పరిశీలించడానికి ముందు సరైన పద్ధతిలో ఉన్నాయి.

parseInt() పద్ధతి మొదటి స్థానంలో ఉన్న అక్షరాన్ని పరిశీలిస్తుంది, అక్షరం ఒక వాస్తవ సంఖ్య కాదేమో నిర్ణయిస్తుంది; కానీ అది ఒక వాస్తవ సంఖ్య కాదేమో ఉంటే, అది రెండవ స్థానంలో ఉన్న అక్షరాన్ని పరిశీలిస్తుంది, అలాగే పరిశీలన ప్రక్రియను చేస్తుంది. ఈ ప్రక్రియ అక్షరం అక్షరం అక్షరం వరకు కొనసాగుతుంది, అప్పుడు parseInt() పద్ధతి అక్షరానికి ముందున్న సరిహద్దులో ఉన్న సంఖ్యను సంఖ్యగా మార్చుతుంది.

ఉదాహరణకు, "12345red" సంక్లిష్టమైన సంఖ్యను పదార్థకంగా మార్చడానికి, parseInt() పద్ధతి "r" అక్షరాన్ని చూసినప్పుడు పరిశీలన ప్రక్రియను ఆగిస్తుంది, అప్పుడు 12345 అవుతుంది.

సరిహద్దులో ఉన్న సంఖ్య లాక్షణికమైన సంఖ్యను సరిగ్గా మార్చబడుతుంది, ఉదాహరణకు "0xA" సరిగ్గా 10 సంఖ్యగా మార్చబడుతుంది. కానీ, "22.5" సరిగ్గా 22 గా మార్చబడుతుంది, ఎందుకంటే పదార్థక సంఖ్యకు వాస్తవమైన పద్ధతి క్షుధ్ధాకారం కాదు.

కొన్ని ఉదాహరణలు ఇలా ఉన్నాయి:

var iNum1 = parseInt("12345red");	//తిరిగి 12345 అవుతుంది
var iNum1 = parseInt("0xA");	//తిరిగి 10 అవుతుంది
var iNum1 = parseInt("56.9");	//తిరిగి 56 అవుతుంది
var iNum1 = parseInt("red");	//తిరిగి NaN అవుతుంది

parseInt() పద్ధతికి అనేక బేస్ మోడ్లు ఉన్నాయి, బైనరీ, ఆక్టల్, హెక్సడ్కేస్ లేదా ఇతర పదార్థక పద్ధతులను సంఖ్య లో మార్చవచ్చు. బేస్ పద్ధతి parseInt() పద్ధతికి రెండవ పారామిటర్ ద్వారా నిర్దేశించబడుతుంది, కాబట్టి హెక్సడ్కేస్ విలువను పరిశీలించడానికి parseInt() పద్ధతిని అలాగే ఉపయోగించాలి:

var iNum1 = parseInt("AF", 16);	//తిరిగి 175 అవుతుంది

అలాగే, బైనరీ, ఆక్టల్ లేదా పదార్థక పద్ధతి (డిఫాల్ట్ మోడ్), parseInt() పద్ధతిని అలాగే ఉపయోగించవచ్చు:

var iNum1 = parseInt("10", 2);	//తిరిగి 2 అవుతుంది
var iNum2 = parseInt("10", 8);	//返回 8
var iNum3 = parseInt("10", 10);	//返回 10

如果十进制数包含前导 0，那么最好采用基数 10，这样才不会意外地得到八进制的值。例如：

var iNum1 = parseInt("010");	//返回 8
var iNum2 = parseInt("010", 8);	//返回 8
var iNum3 = parseInt("010", 10);	//返回 10

在这段代码中，两行代码都把字符 "010" 解析成一个数字。第一行代码把这个字符串看作八进制的值，解析它的方式与第二行代码（声明基数为 8）相同。最后一行代码声明基数为 10，所以 iNum3 最后等于 10。

చూడండి:

చూడండి: JavaScript సందర్శనా పుస్తకంparseInt() పద్ధతి కు సంబంధించిన వివరాలు ఇక్కడ ఉన్నాయి:parseInt().

parseFloat()

parseFloat() పద్ధతి parseInt() పద్ధతితో సమానంగా పని చేస్తుంది, అక్షరం 0 నుండి ప్రతి అక్షరాన్ని పరిశీలిస్తుంది, వరకు అసత్వంగా ఉన్న అక్షరం వరకు, అక్షరం ముంది స్ట్రింగ్ ను సంఖ్యలుగా మారుస్తుంది.

అయితే, ఈ పద్ధతికి మొదటి కనిపించిన దశమాక్షరం అక్షరం వినియోగపడుతుంది. రెండు దశమాక్షరాలు ఉన్నప్పుడు, రెండవ దశమాక్షరం అక్షరం అసత్వంగా పరిగణించబడుతుంది. parseFloat() ఈ దశమాక్షరం ముంది అక్షరాలను సంఖ్యలుగా మారుస్తుంది. అంటే ఈ స్ట్రింగ్ "11.22.33" 11.22 గా పరిగణించబడుతుంది.

ఈ parseFloat() పద్ధతిని వాడటంలో మరొక వ్యత్యాసం ఏమిటంటే, స్ట్రింగ్ అక్షరం మొదటి అక్షరం మొదటి అక్షరం దశమాక్షరం లో ఫ్లోటింగ్ నంబర్ ప్రస్తావించాలి, ఆక్షరం లేదా కాలుక సంఖ్యలలో ప్రస్తావించకూడదు. ఈ పద్ధతి మొదటి అక్షరం త్రోవాలి, కాబట్టి ఆక్షరం 0102 కాబట్టి పరిగణించబడుతుంది 102. కాబట్టి 0xA కాబట్టి ఈ పద్ధతి 0xA నంబర్ తిరిగి చేయదు, కాబట్టి ఫ్లోటింగ్ నంబర్ లో x అక్షరం వినియోగించకూడదు。（పరిశీలన:పరీక్షలు చేసిన తర్వాత, ప్రత్యేకమైన బ్రౌజర్ అమలులు 0 తిరిగి చేయడం జరుగుతుంది, కాదు NaN。）

ఇక పద్ధతి parseFloat() కు బేస్ మోడల్ లేదు.

ఈ parseFloat() మాదిరి మాదిరి కొన్ని ఉదాహరణలు ఇక్కడ ఉన్నాయి:

var fNum1 = parseFloat("12345red");	//తిరిగి 12345 అవుతుంది
var fNum2 = parseFloat("0xA");	//తిరిగి NaN అవుతుంది
var fNum3 = parseFloat("11.2");	//తిరిగి 11.2 అవుతుంది
var fNum4 = parseFloat("11.22.33");	//తిరిగి 11.22 అవుతుంది
var fNum5 = parseFloat("0102");	//102 అన్నికి తిరిగి ఇస్తుంది
var fNum1 = parseFloat("red");	//NaN అన్నికి తిరిగి ఇస్తుంది

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

చూడండి:

చూడండి: JavaScript సందర్శనా పుస్తకంparseFloat() మెథడ్ గురించి సమాచారం మార్చండి:parseFloat().

మార్పిడి పద్ధతి

మీరు కూడా ఉపయోగించవచ్చు:మార్పిడి పద్ధతి (type casting)మార్చబడే విలువను ప్రకారం ప్రక్రియలో ప్రాసెస్ చేయడానికి. మార్పిడి పద్ధతిని ఉపయోగించడం ద్వారా మరొక రకం విలువను ప్రాప్తం చేయవచ్చు, అయితే అది మరొక రకం విలువ అయినప్పుడు.

రైటర్ నోట్:cast అనేది "తయారు చేయడ" అని అర్థం కలిగింది, ఇది "మార్పిడి" అని అర్థం కలిగింది.

ECMAScript లో లభించే 3 రకాల మార్పిడి పద్ధతులు కనబడతాయి:

  • Boolean(value) - దిగువ విలువను బౌలియన్ లో మార్చండి;
  • Number(value) - దిగువ విలువను సంఖ్యగా మార్చండి (ఇంటిజర్ లేదా ఫ్లోటింగ్ పాయింట్ సంఖ్యలు ఉంటాయి);
  • String(value) - దిగువ విలువను స్ట్రింగ్ లో మార్చండి;

ఈ మూడు ఫంక్షన్లలో ఏదైనా ఒకదాని ద్వారా విలువను మార్చడం ద్వారా ఒక కొత్త విలువను సృష్టించడం జరుగుతుంది, దీనికి అసలు విలువ నుండి ప్రత్యక్షంగా మార్చబడే విలువ ఉంటుంది. ఈ పద్ధతి అనుమానాన్ని సృష్టించవచ్చు.

Boolean() ఫంక్షన్

మార్చవలసిన విలువ కనీసం ఒక అక్షరం కలిగిన స్ట్రింగ్, అసలు సంఖ్య లేదా ఆబ్జెక్ట్ అయితే, Boolean() ఫంక్షన్ ట్రూ ను తిరిగి ఇస్తుంది. ఈ విలువ ఖాళీ స్ట్రింగ్, సంఖ్య 0, undefined లేదా null అయితే, ఫాల్స్ ను తిరిగి ఇస్తుంది.

బౌలియన్ మార్పిడి పద్ధతిని పరీక్షించడానికి క్రింది కోడ్ ను ఉపయోగించవచ్చు:

var b1 = Boolean("");		//false - ఖాళీ స్ట్రింగ్
var b2 = Boolean("hello");		//true - అసలు స్ట్రింగ్
var b1 = Boolean(50);		//true - అసలు సంఖ్య
var b1 = Boolean(null);		//false - null
var b1 = Boolean(0);		//false - నలుపు
var b1 = Boolean(new object());	//true - ఆబ్జెక్ట్

Number() ఫంక్షన్

Number() ఫంక్షన్ మార్పిడి పద్ధతి parseInt() మరియు parseFloat() మెథడ్స్ పద్ధతితో సమానం, కానీ ఇది మొత్తం విలువను మార్చుతుంది, మాత్రమే భాగిక విలువను మార్చదు.

మీరు గుర్తించగలరు కాదా, parseInt() మరియు parseFloat() మెథడ్స్ మాత్రమే మొదటి అసలు అక్షరం ముందున కాల్చబడే స్ట్రింగ్ ను మార్చుతాయి, కాబట్టి "1.2.3" అనేది "1" మరియు "1.2" అని మార్చబడుతుంది.

Number() ద్వారా సింగిల్ రకంగా మార్చడం చేసినప్పుడు, "1.2.3" NaN ఉంటుంది, ఎందుకంటే మొత్తం పదబద్ధం విలువను పదబద్ధం చేయలేదు. పదబద్ధం విలువను మొత్తంగా పదబద్ధం చేయగలిగినప్పుడు, Number() ఈవిషయంలో parseInt() మరియు parseFloat() మాధ్యమాలను అనుకూలిస్తుంది.

ఈ పట్టిక వివరిస్తుంది వివిధ విలువలపై Number() మాధ్యమాన్ని కాల్ చేసినప్పుడు జరిగే పరిణామాలను:

ఉపయోగం ఫలితం
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("1.2") 1.2
Number("12") 12
Number("1.2.3") NaN
Number(new object()) NaN
Number(50) 50

String() ఫంక్షన్

చివరి రకం సింగిల్ రకంగా మార్చడం మాధ్యమం String() చాలా సులభం, ఎందుకంటే ఇది ఏ విలువనైనా పదబద్ధం చేయగలదు.

ఈ రకం సింగిల్ రకంగా మార్చడాన్ని చేపట్టడానికి, పరామితిగా పరిచయం చేసిన విలువల నుండి toString() మాధ్యమాన్ని కాల్ చేయాలి, అనగా 12 ను "12" గా, true ను "true" గా, false ను "false" గా మార్చడం మరియు అలా మరియు మరియు ఇలా చేయడం.

సింగిల్ రకంగా మార్చడం మరియు toString() మాధ్యమాన్ని కాల్ చేయడం మధ్య ఏకైక వ్యత్యాసం లేదు, కానీ null మరియు undefined విలువలను సింగిల్ రకంగా మార్చడం ద్వారా విలువలను పదబద్ధం చేయవచ్చు మరియు ప్రమాదాలు జరగకుండా ఉంటాయి:

var s1 = String(null);	//"null"
var oNull = null;
var s2 = oNull.toString();	//దోషపూరిత ప్రమాదం ఉంటుంది

బలహీన రకం భాషలు వంటి ECMAScript వంటి నిర్బంధిత రకం భాషలను నిర్వహించడంలో, విలువలను నిర్బంధిత రకంగా మార్చడం చాలా ఉపయోగపడుతుంది, కానీ విలువల నిజత్వాన్ని నిర్ధారించాలి.