ఇక్మాస్క్రిప్ట్ రిఫరెన్స్ టైప్స్

రిఫరెన్స్ టైప్లను సాధారణంగా క్లాస్ అని పిలుస్తారు.

ఈ ట్యూటోరియల్ ఎక్మాస్క్రిప్ట్ ప్రి-డిఫైన్డ్ రిఫరెన్స్ టైప్లను చాలా చర్చిస్తుంది.

రిఫరెన్స్ టైప్

రిఫరెన్స్ టైప్లను సాధారణంగా క్లాస్ అని పిలుస్తారు, అంటే, రిఫరెన్స్ విలువను పొందినప్పుడు, అది ప్రాసెస్ చేసేది ఆబ్జెక్ట్.

ఈ ట్యూటోరియల్ ఎక్మాస్క్రిప్ట్ ప్రి-డిఫైన్డ్ రిఫరెన్స్ టైప్లను చాలా చర్చిస్తుంది.

ఇప్పటి నుండి, మాట్లాడే సారాంశ ప్రకారం సంభందించిన రిఫరెన్స్ టైప్లను ముఖ్యంగా చర్చించాలి.

గమనిక:సాంప్రదాయక అర్థం లో, ECMAScript కు క్లాస్లు లేవు. వాస్తవానికి, క్లాస్ అనే పదాన్ని ఎక్మా-262 లో ఎటువంటి సందర్భంలో ఎలాంటి లేదు. ECMAScript కు విధించబడిన 'ఆబ్జెక్ట్ డిఫైనిషన్' అనేది, ఇతర ప్రోగ్రామింగ్ భాషలలో క్లాస్ అనేది సిద్ధాంతపరంగా సమానం.

అడ్వైజ్本教程将使用术语“对象”。

对象是由 new 运算符加上要实例化的对象的名字创建的。例如，下面的代码创建 Object 对象的实例：

var o = new Object();

这种语法与 Java 语言的相似，不过当有不止一个参数时，ECMAScript 要求使用括号。如果没有参数，如以下代码所示，括号可以省略：

var o = new Object;

గమనిక:బ్రేకట్ అవసరం లేదు, కానీ క్లిష్టతను నివారించడానికి ఉపయోగించడం ఉత్తమం.

అడ్వైజ్మేము పాఠ్యపుస్తకంలో ఆధారం మరియు దాని ప్రవర్తనను మరింత లోతుగా పరిశీలించాలి.

ఈ భాగంలో సమానమైన ప్రాథమిక రకాలను కలిగివున్న రకాలు ప్రధానం.

Object ఆధారం

Object ఆధారం స్వయంగా చాలా ఉపయోగం లేదు, కానీ ఇతర క్లాసులను తెలుసుకోవడానికి ముందు అది తెలుసుకోవాలి. ఎందుకంటే ECMAScript లోని Object ఆధారం java.lang.Object తో సమానంగా ఉంటుంది, ECMAScript లోని అన్ని ఆధారాలు ఈ ఆధారం నుండి ఉత్పత్తి అవుతాయి, Object ఆధారంలోని అన్ని అనునికిలు మరియు కార్యక్రమాలు ఇతర ఆధారాలలో కనిపిస్తాయి, కాబట్టి Object ఆధారం ను అర్థం చేసుకున్నప్పుడు, ఇతర ఆధారాలను బాగా అర్థం చేసుకోవచ్చు.

Object ఆధారంలో కొన్ని ప్రత్యేక అనునికిలు ఉన్నాయి:

constructor
ఈ ఆధారం సృష్టించిన ఫంక్షన్ యొక్క ప్రతిపాదనను సూచిస్తుంది. Object ఆధారానికి, ఈ సూచిక ప్రాథమిక Object() ఫంక్షన్ ను సూచిస్తుంది.
Prototype
ఈ ఆధారం యొక్క ఆధారపూర్వక ప్రాతిపదికన ప్రతిపాదించబడింది. అన్ని ఆధారాలకు, ఇది డిఫాల్ట్లీ Object ఆధారం యొక్క ప్రతిపాదనను తిరిగి ఇస్తుంది.

Object ఆధారంలో కొన్ని మరొక కార్యక్రమాలు ఉన్నాయి:

hasOwnProperty(property)
ఆధారంలో నిర్వచించిన ప్రత్యేక ఆధారంను తనిఖీ చేస్తుంది. ఆధారంలో ప్రత్యేక ఆధారం నిర్వచించబడాలి. (ఉదాహరణకు, o.hasOwnProperty("name"))
IsPrototypeOf(object)
ఈ ఆధారం మరొక ఆధారం యొక్క ప్రాతిపదికన తనిఖీ చేస్తుంది.
PropertyIsEnumerable
ఇచ్చిన ఆధారం నిర్వచించిన ఆధారంలో పోల్చి చూస్తుంది దానికి కోసం for...in స్ట్రింగ్ వినియోగించబడగలదా అని.
ToString()
దాని ఆధారానికి ఆధారపూర్వక స్ట్రింగ్ ప్రాతిపదికన తిరిగి ఇస్తుంది. Object ఆధారానికి, ECMA-262 ఈ విలువను నిర్వచించలేదు, కాబట్టి వివిధ ECMAScript అమలులు వివిధ విలువలను తిరిగి ఇస్తాయి.
ValueOf()
ఈ కార్యక్రమం దానికి సరిపోయే ప్రాథమిక విలువను తిరిగి ఇస్తుంది. అనేక ఆధారాలకు, ఈ కార్యక్రమం తిరిగి ఇచ్చే విలువ �ToString() యొక్క తిరిగి ఇచ్చే విలువతో సమానంగా ఉంటుంది.

ప్రత్యామ్నాయంగా:పైన జాబితాభుక్తమైన ప్రతి అట్రిబ్యూట్ మరియు పద్ధతి ఇతర ఆబ్జెక్టులచే కవర్ చేయబడతాయి.

Boolean ఆబ్జెక్ట్

Boolean ఆబ్జెక్ట్ బౌలీన్ ప్రామాణిక రకము యొక్క రిఫరెన్స్ టైప్.

Boolean ఆబ్జెక్ట్ సృష్టించడానికి, Boolean విలువను పరామర్శించాలి:

var oBooleanObject = new Boolean(true);

Boolean ఆబ్జెక్ట్ Object ఆబ్జెక్ట్ యొక్క ValueOf() పద్ధతిని పూర్తిగా కవర్ చేస్తుంది, అంటే ప్రామాణిక విలువను అందిస్తుంది, అనగా true మరియు false. ToString() పద్ధతిని కూడా కవర్ చేస్తుంది, "true" లేదా "false" స్ట్రింగ్ విలువను అందిస్తుంది.

దురదర్శనకరంగా, ECMAScript లో Boolean ఆబ్జెక్ట్ సాధారణంగా ఉపయోగించబడదు, మరియు ఉపయోగించినా అర్థం కాకుండా ఉంటుంది.

సమస్యలు సాధారణంగా Boolean ప్రకటనలో Boolean ఆబ్జెక్ట్ ఉపయోగించడంలో వచ్చాయి. ఉదాహరణకు:

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true;	//ఫలితం true

ఈ కోడ్లో, false విలువ తో Boolean ఆబ్జెక్ట్ సృష్టించబడింది. ఈ విలువను మరియు ప్రామాణిక true విలువను AND ఆపరేషన్ చేయబడింది. Boolean కాలక్రమణ లో, false మరియు true యొక్క AND ఆపరేషన్ ఫలితం false. కానీ, ఈ కోడ్లో పరిగణించబడినది oFalseObject కాదు వల్ల దాని విలువ false.

ముందు చర్చించిన ప్రకారం, Boolean ప్రకటనలో, అన్ని ఆబ్జెక్ట్లు స్వయంచాలకంగా true పరివర్తించబడతాయి, కాబట్టి oFalseObject యొక్క విలువ true. అప్పుడు true యొక్క AND ఆపరేషన్ జరిగి ఫలితం true.

గమనిక:మీరు Boolean ఆబ్జెక్ట్ యొక్క లభ్యతను తెలుసుకున్నారు ఉంటే కూడా, ఈ సెక్షన్లో పేర్కొన్న సమస్యలను ఎదుర్కోడానికి Boolean ప్రామాణిక విలువను ఉపయోగించడం మంచిది.

సందర్శించండి

Boolean ఆబ్జెక్ట్ గురించి మరింత సమాచారం కోరి ఉంటే, ఈ లింక్ ను సందర్శించండి: JavaScript Boolean ఆధారిత పుస్తకం.

Number ఆబ్జెక్ట్

మీరు ఆశించిన ప్రకారం, Number ఆబ్జెక్ట్ నంబర్ ప్రామాణిక రకము యొక్క రిఫరెన్స్ టైప్. Number ఆబ్జెక్ట్ సృష్టించడానికి, ఈ కోడ్ని ఉపయోగించండి:

var oNumberObject = new Number(68);

మీరు ఈ చాప్టర్ ముందును చదివిన సెక్షన్ల్లో ప్రత్యేక విలువలు (ఉదాహరణకు Number.MAX_VALUE) పై చర్చించిన Number ఆబ్జెక్ట్ ను గుర్తించారా. అన్ని ప్రత్యేక విలువలు Number ఆబ్జెక్ట్ స్టాటిక్ అట్రిబ్యూట్లు.

నంబర్ ఆబ్జెక్ట్ యొక్క నంబర్ ప్రామాణిక విలువను పొందడానికి, వాల్యూ ఆఫ్() పద్ధతిని ఉపయోగించాలి:

var iNumber = oNumberObject.valueOf();

当然，Number 类也有 toString() 方法，在讨论类型转换的小节中已经详细讨论过该方法。

除了从 Object 对象继承的标准方法外，Number 对象还有几个处理数值的专用方法。

toFixed() 方法

toFixed() 方法返回的是具有指定位数小数的数字的字符串表示。例如：

var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  //输出 "68.00"

在这里，toFixed() 方法的参数是 2，说明应该显示两位小数。该方法返回 "68.00"，空的字符串位由 0 来补充。对于处理货币的应用程序，该方法非常有用。toFixed() 方法能表示具有 0 到 20 位小数的数字，超过这个范围的值会引发错误。

toExponential() 方法

与格式化数字相关的另一个方法是 toExponential()，它返回的是用科学计数法表示的数字的字符串形式。

与 toFixed() 方法相似，toExponential() 方法也有一个参数，指定要输出的小数的位数。例如：

var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  //输出 "6.8e+1"

这段代码的结果是 "6.8e+1"，前面解释过，它表示 6.8x101。问题是，如果不知道要用哪种形式（预定形式或指数形式）表示数字怎么办？可以用 toPrecision() 方法。

toPrecision() 方法

toPrecision() 方法根据最有意义的形式来返回数字的预定形式或指数形式。它有一个参数，即用于表示数的数字总数（不包括指数）。例如，

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  // అవుట్పుట్ "7e+1"

ఈ కోడ్ యొక్క పని అనగారా 68 నంబర్ ను ఒక సంఖ్య అక్షరం ద్వారా ప్రదర్శించడం, ఫలితం "7e+1" అని ఉంటుంది, మరొక రీతిలో అనగారా 70. నిజంగా, toPrecision() మెథడ్ అనగారా ను కుటుంబకంగా ప్రదర్శిస్తుంది. కానీ, అనగారాను 2 సంఖ్యల స్థాయిలో ప్రదర్శించడం చాలా సులభం అవుతుంది:

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  // అవుట్పుట్ "68"

అయితే, "68" అనేది అనగారా, అది అనగారా అనే సంఖ్య యొక్క ఖచ్చితమైన ప్రాతిపదిక. కానీ, అవసరమైన స్థానాలను అధికంగా ప్రకటించినప్పుడు ఏమి జరుగుతుంది అని నాకు తెలుసు కాదు.

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  // ప్రసారం చేయుము "68.0"

ఈ పరిస్థితిలో, toPrecision(3) అనేది toFixed(1) తో సమానం, "68.0" ప్రసారం అవుతుంది.

toFixed(), toExponential() మరియు toPrecision() పద్ధతులు చుట్టూ పరిగణనలు చేయడం ద్వారా సరైన అంచనా ప్రకారం సరైన పద్ధతిలో ఒక సంఖ్యను ప్రసారం చేయడానికి ఉపయోగిస్తాయి.

అడ్వైజ్Boolean ఆబ్జెక్ట్ పోలి, Number ఆబ్జెక్ట్ కూడా ముఖ్యం కాని, దీనిని అధికంగా ఉపయోగించకుండా ఉండండి ఎందుకంటే అసలు ప్రకారం ప్రసారం చేయడం ద్వారా ప్రసంగాలు ఉంటాయి. అయితే అవసరమైనప్పుడు సంఖ్యల అసలు ప్రకారం ఉపయోగించండి.

సందర్శించండి

Number ఆబ్జెక్ట్ గురించి మరింత సమాచారం తెలుసుకోవాలంటే ఈ లింక్ను సందర్శించండి: JavaScript Number ఆధారిత పుస్తకం.

String ఆబ్జెక్ట్

String ఆబ్జెక్ట్ అనేది String రకం యొక్క ఆబ్జెక్ట్ ప్రాప్తి ఉంది, ఇది ఈ రీతిలో సృష్టించబడుతుంది:

var oStringObject = new String("hello world");

String ఆబ్జెక్ట్ యొక్క valueOf() మరియు toString() పద్ధతులు స్ట్రింగ్ క్లాస్ యొక్క అసలు విలువను పునఃప్రాప్తి చేస్తాయి:

alert(oStringObject.valueOf() == oStringObject.toString());	// ప్రసారం చేయుము "true"

ఈ కోడ్ నడిచినప్పుడు, "true" ప్రసారం అవుతుంది, అనగా ఈ విలువలు నిజంగా సమానం.

ప్రత్యామ్నాయంగా:String ఆబ్జెక్ట్ అనేది ECMAScript లో అత్యంత క్లిష్టమైన పరిచయ రకాలలో ఒకటి. ఈ భాగంలో మొత్తం స్ట్రింగ్ క్లాస్ యొక్క ప్రాథమిక సామర్థ్యాలు మాత్రమే ముఖ్యం. మరింత అధునాతన సామర్థ్యాలకు ఈ శిక్షణాలో సంబంధించిన చిప్పలను పరిశీలించండి, లేదా JavaScript String ఆధారిత పుస్తకం.

length లక్షణం

String ఆబ్జెక్ట్ యొక్క length అనే లక్షణం స్ట్రింగ్ లోని అక్షరాల సంఖ్య ఉంది:

var oStringObject = new String("hello world");
alert(oStringObject.length);	// ప్రసారం చేయుము "11"

ఈ ఉదాహరణ ప్రసారం చేసేది "11" అని, అది "hello world" స్ట్రింగ్ లోని అక్షరాల సంఖ్య. శ్రద్ధ వహించండి, స్ట్రింగ్ లో పారిశ్రామిక అక్షరాలు (ఎస్కి అక్షరాలకన్నా ఒక బెయిట్ చేస్తాయి) కలిగి ఉండినప్పటికీ, ప్రతి అక్షరం ఒక అక్షరంగా పరిగణించబడుతుంది.

charAt() మరియు charCodeAt() పద్ధతులు

String ఆబ్జెక్ట్ అనేది చాలా పద్ధతులను కలిగి ఉంటుంది.

మొదటిది, రెండు పద్ధతులు charAt() మరియు charCodeAt() స్ట్రింగ్ లోని ఒకే అక్షరాన్ని ప్రాప్తి చేస్తాయి. ఈ రెండు పద్ధతులు కూడా ఒక పరామితిని కలిగి ఉంటాయి, అది చర్యలు చేయాల్సిన అక్షరం యొక్క స్థానం.

charAt() పద్ధతి నిర్దేశిత స్థానంలో ఉన్న అక్షరాన్ని కలిగించే స్ట్రింగ్ను పునఃప్రాప్తి చేస్తుంది:

var oStringObject = new String("hello world");
alert(oStringObject.charAt(1));	// ప్రసారం చేయుము "e"

స్ట్రింగ్ "హలో వరల్డ్" లో, స్థానం 1 వద్ద యొక్క అక్షరం "e" ఉంది. "ఇసిఎమ్ఎస్క్రిప్ట్ ప్రాథమిక రకాల" విభాగంలో మేము చెప్పాము, మొదటి అక్షరం యొక్క స్థానం 0 ఉంది, రెండవ అక్షరం యొక్క స్థానం 1 ఉంది, ముందుకు కొనసాగుతుంది. అందువలన, charAt(1) నుండి తిరిగి ఇస్తుంది "e".

అక్షరం కాదు కానీ అక్షర కోడ్ కావాలి అనేకానేక సందర్భాల్లో, charCodeAt() పద్ధతిని కలిగించవచ్చు:

var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1));	//అవుట్పుట్ "101"

ఈ ఉదాహరణ "101" అవుట్పుట్ ఇస్తుంది, అది చిన్న అక్షర "e" యొక్క అక్షర కోడ్ ఉంది.

concat() పద్ధతి

మరియు concat() పద్ధతి, ఒక లేదా అనేక స్ట్రింగ్ లను String ఆబ్జెక్ట్ యొక్క ప్రారంభ విలువకు జత పెట్టడానికి ఉపయోగిస్తారు. ఈ పద్ధతి స్ట్రింగ్ ప్రారంభ విలువను తిరిగి ఇస్తుంది, మరియు ప్రారంభిక String ఆబ్జెక్ట్ ను మార్చదు:

var oStringObject = new String("హలో ");
var sResult = oStringObject.concat("వరల్డ్");
alert(sResult);		//అవుట్పుట్ "హలో వరల్డ్"
alert(oStringObject);	//అవుట్పుట్ "హలో వరల్డ్"

ఈ కోడ్ లో, concat() పద్ధతి అవుట్పుట్ "హలో వరల్డ్" ఇస్తుంది, కానీ String ఆబ్జెక్ట్ లో ఇప్పటికీ "హలో " ఉంటుంది. ఈ కారణంగా, సాధారణంగా జోడించడానికి కొత్తపదం (+) ఉపయోగిస్తారు, ఎందుకంటే ఇది వాస్తవ ప్రవర్తనను సూచిస్తుంది:

var oStringObject = new String("హలో ");
var sResult = oStringObject + "వరల్డ్";
alert(sResult);		//అవుట్పుట్ "హలో వరల్డ్"
alert(oStringObject);	//అవుట్పుట్ "హలో వరల్డ్"

indexOf() మరియు lastIndexOf() పద్ధతులు

ఇంతవరకు, స్ట్రింగ్ లను జత పెట్టే పద్ధతులు, స్ట్రింగ్ లోని వేరొక అక్షరాన్ని పొందే పద్ధతులను చర్చించాము. అయితే, కొన్ని సందర్భాల్లో ఒక స్ట్రింగ్ లో ఒక అక్షరం ఉన్నాలా ఎందుకు తెలియదో అనేకానేక పద్ధతులను కనుగొనవచ్చు. ఈ సందర్భంలో, indexOf() మరియు lastIndexOf() పద్ధతులను కలిగించవచ్చు.

indexOf() మరియు lastIndexOf() పద్ధతులు ప్రత్యేకంగా కనుగొనబడే ఉపస్ట్రింగ్ స్ట్రింగ్ లో స్థానాన్ని తిరిగి ఇస్తాయి, ఉపస్ట్రింగ్ కనుగొనబడలేకపోతే -1 తిరిగి ఇస్తాయి.

ఈ రెండు పద్ధతుల లో వ్యత్యాసం ఇందుకంటే, indexOf() పద్ధతి స్ట్రింగ్ ప్రారంభం నుండి (స్థానం 0) స్ట్రింగ్ లో కనుగొనబడే ఉపస్ట్రింగ్ ను కనుగొంటుంది, మరియు lastIndexOf() పద్ధతి స్ట్రింగ్ ముగింపు నుండి కనుగొంటుంది. ఉదాహరణకు:

var oStringObject = new String("హలో వరల్డ్!");
alert(oStringObject.indexOf("o"));		//అవుట్పుట్ "4"
alert(oStringObject.lastIndexOf("o"));		//అవుట్పుట్ "7"

ఇక్కడ, మొదటి "o" స్ట్రింగ్ స్థానం 4లో ఉంది, అది "hello" లోని "o"; చివరి "o" స్థానం 7లో ఉంది, అది "world" లోని "o". స్ట్రింగ్ లో ఒకే "o" ఉంటే, indexOf() మరియు lastIndexOf() మెట్హడ్‌డులు స్థానాలను తిరిగి చూపుతాయి.

localeCompare() మెట్హడ్‌డు

మరొక మెట్హడ్‌డు localeCompare() సరికొత్త మెట్హడ్‌డులో క్రమబద్ధీకరించడానికి ఉపయోగించబడుతుంది. ఇది ఒక పరామితిని కలిగి ఉంటుంది - పోల్చబడే స్ట్రింగ్, మరియు ముందుకు కనిపించే మూడు విలువలలో ఒకటిని తిరిగి చూపుతుంది:

  • స్ట్రింగ్ ఆబ్జెక్ట్ అక్షరవంతి క్రమంలో పరామితికి ముందు ఉంటే, అంతర్జాతీయ క్రమంలో ప్రత్యక్షంగా అవుతుంది.
  • స్ట్రింగ్ ఆబ్జెక్ట్ పరామితికి సమానం అయితే, అంతర్జాతీయ క్రమంలో 0 అవుతుంది
  • స్ట్రింగ్ ఆబ్జెక్ట్ అక్షరవంతి క్రమంలో పరామితికి వచ్చిన స్ట్రింగ్ కంటే తరువాత ఉంటే, అంతర్జాతీయ క్రమంలో ప్రత్యక్షంగా అవుతుంది.

ప్రత్యామ్నాయంగా:మినహాయించి, ప్రత్యక్షంగా అవుతుంది కాబట్టి, అంతర్జాతీయ క్రమంలో మినహాయించబడిన విలువలను తరచుగా -1 అవుతుంది. అలాగే, అంతర్జాతీయ క్రమంలో మినహాయించబడిన విలువలను తరచుగా 1 అవుతుంది. అయితే, వాస్తవంగా అవుతుంది కాబట్టి దానిని గమనించండి.

ఇది ఉదాహరణ:

var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick"));		//అవుట్పుట్ "1"
alert(oStringObject.localeCompare("yellow"));		//అవుట్పుట్ "0"
alert(oStringObject.localeCompare("zoo"));		//అవుట్పుట్ "-1"

ఈ కోడ్‌లో, స్ట్రింగ్ "yellow" కు 3 విలువలతో పోల్చబడింది, అవి "brick", "yellow", మరియు "zoo". అక్షరవంతి క్రమంలో పెరసరంగా, "yellow" "brick" కంటే తరువాత ఉంది కాబట్టి localeCompare() మెట్హడ్‌డు 1 అవుతుంది; "yellow" "yellow"కు సమానం కాబట్టి localeCompare() మెట్హడ్‌డు 0 అవుతుంది; "zoo" "yellow" కంటే తరువాత ఉంది కాబట్టి localeCompare() మెట్హడ్‌డు -1 అవుతుంది. మరోసారి మీరు localeCompare() మెట్హడ్‌డు ఈ విధంగా ఉపయోగించాలి:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " ముందు " + oStringObject2);
}
  alert(oStringObject1 + " తర్వాత " + oStringObject2);
}
  alert("రెండు స్ట్రింగ్లు సమానంగా ఉన్నాయి");
}

ఈ నిర్మాణం ద్వారా, ఈ కోడ్ అన్ని అమలుల్లో సరిగా పని చేస్తుంది అని నిర్ధారించవచ్చు.

localeCompare() మెట్హడ్స్ ప్రత్యేకత అనగా, అది అదే ప్రాంతం (locale, దేశ/ప్రాంతం మరియు భాష) నిర్వచించినప్పుడు ఈ మెట్హడ్స్ యొక్క పని పద్ధతిని తెలుపుతుంది. అమెరికాలో, అంగ్లేయం ఎక్మాస్క్రిప్ట్ అమలు యొక్క ప్రమాణ భాష, localeCompare() ప్రత్యేకించి క్రియాశీలంగా ఉంటుంది, ముఖ్యంగా ముఖ్యమైన అక్షరాలు చిన్న అక్షరాల తర్వాత ఉంటాయి. అయితే, ఇతర ప్రాంతాల్లో ఈ పరిస్థితి వివిధంగా ఉండవచ్చు.

slice() మరియు substring()

ECMAScript సబ్ స్ట్రింగ్ విలువలను సృష్టించడానికి రెండు మెట్హడ్స్ను అందిస్తుంది, అవి slice() మరియు substring(). ఈ రెండు మెట్హడ్స్ కూడా ప్రాసెస్ చేయవలసిన స్ట్రింగ్ యొక్క సబ్ స్ట్రింగ్ను తిరిగి ఇస్తాయి, ఒక లేదా రెండు పారామీటర్స్ ను అంగీకరిస్తాయి. మొదటి పారామీటర్ సబ్ స్ట్రింగ్ యొక్క ప్రారంభ స్థానం ఉంది, రెండవ పారామీటర్ (ఉపయోగించబడితే) సబ్ స్ట్రింగ్ యొక్క ముగింపు ముందు యొక్క స్థానం ఉంది (అంటే, తిరిగి ఇచ్చిన విలువలో ముగింపు స్థానం యొక్క అక్షరం చేరవు). రెండవ పారామీటర్ను ఉపయోగించకుండా వివరించితే, ముగింపు స్థానం స్ట్రింగ్ యొక్క పొడవు ఉంటుంది.

అలాగే concat() మాదిరిగా, slice() మరియు substring() మెట్హడ్స్ స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క విలువను మార్చవు. వాటివల్ల మాత్రమే ప్రాథమిక స్ట్రింగ్ విలువను తిరిగి ఇవ్వబడుతుంది, స్ట్రింగ్ ఆబ్జెక్ట్ అలాగే ఉంటుంది.

var oStringObject = new String("hello world");
alert(oStringObject.slice("3"));		//అవుట్పుట్ "lo world"
alert(oStringObject.substring("3"));		//అవుట్పుట్ "lo world"
alert(oStringObject.slice("3", "7"));		//అవుట్పుట్ "lo w"
alert(oStringObject.substring("3", "7"));	//అవుట్పుట్ "lo w"

ఈ ఉదాహరణలో, slice() మరియు substring() పద్ధతుల వాడుక మరియు తిరిగిస్తున్న విలువలు అదే ఉన్నాయి. మాత్రమే పారామీటర్ 3 ఉన్నప్పుడు, రెండు పద్ధతులు రెండుగా "lo world" అనే పదాన్ని తిరిగిస్తాయి, ఎందుకంటే "hello" అనే పదంలో రెండవ "l" స్థానం 3వ స్థానంలో ఉంది. పారామీటర్లు 3 మరియు 7వ స్థానాలు ఉన్నప్పుడు, రెండు పద్ధతులు రెండుగా "lo w" అనే పదాన్ని తిరిగిస్తాయి ("world" అనే పదంలో "o" అనే అక్షరం 7వ స్థానంలో ఉంది, కాబట్టి దానిని ఫలితంలో చేర్చబడదు).

ఎందుకు రెండు ప్రమాణాలు పూర్తిగా అదే పని చేసే పద్ధతులు ఉన్నాయి? వాస్తవానికి, ఈ రెండు పద్ధతులు పూర్తిగా అదే కాదు, కానీ పారామీటర్లు మానిటర్ అయినప్పుడు మాత్రమే వాటి పారామీటర్ల ప్రాసెసింగ్ విధానం కొంచెం వ్యత్యాసం ఉంటుంది.

మానిటర్ పారామీటర్లకు సంబంధించినప్పుడు, slice() పద్ధతి slice() పద్ధతి మాత్రమే ఉపయోగిస్తుంది, substring() పద్ధతి దానిని 0 అని పరిగణిస్తుంది (అంటే దానిని పరిగణించకుండా ఉంటుంది). ఉదాహరణకు:

var oStringObject = new String("hello world");
alert(oStringObject.slice("-3"));		//అవుట్పుట్ "rld"
alert(oStringObject.substring("-3"));	//అవుట్పుట్ "hello world"
alert(oStringObject.slice("3, -4"));		//అవుట్పుట్ "lo w"
alert(oStringObject.substring("3, -4"));	//అవుట్పుట్ "hel"

ఈ విధంగా slice() మరియు substring() పద్ధతుల ప్రధాన వ్యత్యాసాలను చూడగలరు.

మాత్రమే -3 పారామీటర్ ఉన్నప్పుడు, slice() "rld" అనే పదాన్ని తిరిగిస్తుంది, substring() "hello world" అనే పదాన్ని తిరిగిస్తుంది. ఈ కారణంగా, "hello world" అనే పదంలో, slice("-3") అనేది slice("8") అనేదిగా మారుస్తుంది, substring("-3") అనేది substring("0") అనేదిగా మారుస్తుంది.

అలాగే, పరామీతి 3 మరియు -4 ఉపయోగించినప్పుడు, వ్యత్యాసం కూడా పెద్దది. slice() ను slice(3, 7) గా మార్చబడుతుంది, మునుపటి ఉదాహరణలో అనికట్టబడింది, "lo w" అనేది వాటిలో ఉంది. substring() పద్ధతి అనేకసార్లు రెండు పరామీతులను substring(3, 0) గా పరిగణిస్తుంది, అది వాస్తవానికి substring(0, 3) అని. అందువలన, substring("3, -4") అనేది "hel" అనేది ప్రసారం అవుతుంది. చివరి వరుసలోని కోడ్ ఈ పద్ధతులను ఉపయోగించడానికి వివరిస్తుంది.

toLowerCase(), toLocaleLowerCase(), toUpperCase() మరియు toLocaleUpperCase()

చివరిగా చర్చించాల్సిన పద్ధతులు పరిమాణం మరియు మేజ్యూమెంట్ మార్పిడికి సంబంధించి ఉన్నాయి. మొత్తం 4 పద్ధతులు పరిమాణం మరియు మేజ్యూమెంట్ మార్పిడి చేయడానికి ఉపయోగిస్తాయి అని

  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

పేరు నుండి వాటి వినియోగాన్ని తెలుసుకోవచ్చు, మొదటి రెండు పద్ధతులు సరిహద్దు చెన్న రీతిలో మార్పిడి చేయడానికి ఉపయోగిస్తాయి, మరియు మిగిలిన రెండు పద్ధతులు సరిహద్దు పెద్ద రీతిలో మార్పిడి చేయడానికి ఉపయోగిస్తాయి.

toLowerCase() మరియు toUpperCase() పద్ధతులు మూలంగా ఉన్నాయి, వాటిని java.lang.String లోని అదే పద్ధతులపై ఆధారపడి ప్రతిపాదించబడినవి.

toLocaleLowerCase() మరియు toLocaleUpperCase() పద్ధతులు ప్రత్యేక ప్రాంతాలపై ఆధారపడి ఉన్నాయి (localeCompare() పద్ధతితో సమానంగా). అనేక ప్రాంతాలలో, ప్రత్యేక ప్రాంతపు పద్ధతులు సాధారణ పద్ధతులతో పూర్తిగా అనికట్టబడతాయి. అయితే, కొన్ని భాషలు (ఉదాహరణకు తుర్కీ భాష) యూనికోడ్ మేజ్యూమెంట్ మరియు క్యూమెంట్ మార్పిడికి ప్రత్యేక నియమాలను వాడుతాయి, కాబట్టి ప్రత్యేక ప్రాంతపు పద్ధతులను వాడినప్పుడు సరైన మార్పిడికి అవసరం.

var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());	// ప్రసారం "HELLO WORLD"
alert(oStringObject.toUpperCase());		// ప్రసారం "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase());	// ప్రసారం "hello world"
alert(oStringObject.toLowerCase());		//అవుట్పుట్ "hello world"

ఈ కోడ్ లో టుపేర్కేప్() మరియు టులోకేప్రేషన్ఎప్పుడు అవుట్పుట్ "HELLO WORLD" ఉంటాయి, టులోకేప్() మరియు టులోకేప్రేషన్ఎప్పుడు అవుట్పుట్ "hello world" ఉంటాయి. సాధారణంగా, ఇంకా రాష్ట్రంలో అంచనా కనుగొనబడలేదు అయితే రాష్ట్ర ప్రత్యేక పద్ధతులను ఉపయోగించడం సురక్షితం.

అడ్వైజ్గమనించండి, String ఆధారిత పదార్థం అన్ని గుణాత్మకాలు మరియు పద్ధతులు String అక్షరశృంఖలంపై అనువర్తించబడతాయి, ఎందుకంటే వాటివారు ఫలాలా పదార్థాలు.

instanceof ఆపరేటర్

typeof ఆపరేటర్లో సందర్భంలో ఆధారిత పదార్థాన్ని నిల్వ చేయడంలో సమస్య ఉంది, సందర్భంలో ఆధారిత పదార్థం ఏ రకం లేకుండా, అది "object" ఉంటుంది. ECMAScript మరొక Java ఆపరేటర్ instanceof సమస్యను పరిష్కరించింది.

instanceof ఆపరేటర్ typeof ఆపరేటర్ పోలికగా ఉంటుంది, దానిని ఉపయోగించి ప్రస్తుతం ప్రాప్తించుచున్న పదార్థం రకాన్ని గుర్తించడానికి ఉపయోగించబడుతుంది. ఉదాహరణకు typeof మాధ్యమంలో సందర్భంలో సందర్భంలో రకాన్ని గుర్తించడానికి ఉపయోగించబడుతుంది.

var oStringObject = new String("hello world");
alert(oStringObject instanceof String);	//అవుట్పుట్ "true"

ఈ కోడ్ ప్రశ్నలు "వెర్రి ఆధారిత ప్రతిపాదన అనుకొనుట విధంగా వాస్తవానికి వాస్తవంగా వాస్తవం వాస్తవం అని ఉంది. అయితే typeof మాధ్యమం మాత్రమే మన్నిస్తుంది కాదు, instanceof మాధ్యమం typeof మాధ్యమం "object" ఉంటే ఉపయోగపడుతుంది.