ECMAScript 引用类型

ਹਵਾਲਾ ਪ੍ਰਕਾਰਾਂ ਨੂੰ ਸਧਾਰਨ ਤੌਰ 'ਤੇ ਕਲਾਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ

ਇਹ ਟਿੱਪਣੀ ਵਿੱਚ ECMAScript ਦੇ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰਿਮੀਟਿਵ ਹਵਾਲਾ ਪ੍ਰਕਾਰਾਂ ਨੂੰ ਚਰਚਾ ਕੀਤਾ ਜਾਵੇਗਾ。

ਹਵਾਲਾ ਪ੍ਰਕਾਰਾਂ

ਹਵਾਲਾ ਪ੍ਰਕਾਰਾਂ ਨੂੰ ਸਧਾਰਨ ਤੌਰ 'ਤੇ ਕਲਾਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਹਵਾਲਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਉਸ ਨੂੰ ਹਵਾਲਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਹ ਆਬਜ਼ਦਗੀ ਹੈ।

ਇਹ ਟਿੱਪਣੀ ਵਿੱਚ ECMAScript ਦੇ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰਿਮੀਟਿਵ ਹਵਾਲਾ ਪ੍ਰਕਾਰਾਂ ਨੂੰ ਚਰਚਾ ਕੀਤਾ ਜਾਵੇਗਾ。

ਹੁਣ ਤੋਂ ਅਸੀਂ ਜਿਸ ਨਾਲ ਚਰਚਾ ਕਰ ਰਹੇ ਹਾਂ, ਉਸ ਨਾਲ ਸਬੰਧਤ ਮੂਲ ਪ੍ਰਕਾਰਾਂ ਦੇ ਹਵਾਲਾ ਪ੍ਰਕਾਰਾਂ ਬਾਰੇ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਚਰਚਾ ਕਰਾਂਗੇ।

ਧਿਆਨ:ਰਵਾਇਤੀ ਅਰਥ ਵਿੱਚ, ECMAScript ਨੂੰ ਇੱਕ ਕਲਾਸ ਵਾਲਾ ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ECMA-262 ਵਿੱਚ 'ਕਲਾਸ' ਇਸਲਈ ਨਹੀਂ ਮੌਜੂਦ ਹੈ ਕਿਉਂਕਿ ਕਲਾਸ ਨਹੀਂ ਹੈ। ECMAScript 'ਆਬਜ਼ਦਗੀ ਵਿਸ਼ੇਸ਼ਕਰਣ' ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਜੋ ਕਿ ਅਦਾਰਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕਲਾਸ ਦੇ ਬਰਾਬਰ ਹੈ।

提示：本教程将使用术语“对象”。

ਆਬਜੈਕਟ ਨਵੇਂ ਆਬਜੈਕਟ ਨੂੰ ਨਿਰਮਾਣ ਕਰਨ ਲਈ new ਆਪਰੇਟਰ ਅਤੇ ਨਿਰਮਾਣ ਕਰਨ ਵਾਲੇ ਆਬਜੈਕਟ ਦਾ ਨਾਮ ਵਰਤ ਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਣ ਵਜੋਂ ਹੇਠ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਕਿ ਇਹ ਕੋਡ Object ਆਬਜੈਕਟ ਦਾ ਇੱਕ ਪ੍ਰਯੋਗ ਬਣਾਉਂਦਾ ਹੈ:

var o = new Object();

ਇਹ ਸ਼ਾਬਦਿਕਤਾ ਜਾਵਾ ਭਾਸ਼ਾ ਦੇ ਵਰਗ ਵਾਂਗ ਹੈ ਪਰ ਜਦੋਂ ਬਹੁਤ ਸਾਰੇ ਪੈਰਾਮੀਟਰ ਹਨ ਤਾਂ 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()
ਆਬਜੈਕਟ ਦਾ ਮੁੱਢਲਾ ਸਟਰਿੰਗ ਪ੍ਰਦਰਸ਼ਨ ਵਾਪਸ ਦਿੰਦਾ ਹੈ। ਆਬਜੈਕਟ ਆਬਜੈਕਟ ਲਈ ਇਹ ਮੁੱਲ ECMA-262 ਵਿੱਚ ਨਾਪਦਾ ਨਹੀਂ ਹੈ ਇਸ ਲਈ ਵੱਖ-ਵੱਖ ECMAScript ਲਾਗੂਕਰਨਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮੁੱਲ ਹੁੰਦੇ ਹਨ。
ValueOf()
ਇਹ ਮੁੱਢਲਾ ਮੁੱਲ ਵਾਪਸ ਦਿੰਦਾ ਹੈ ਜੋ ਇਸ ਆਬਜੈਕਟ ਨੂੰ ਬਹੁਤ ਹੀ ਉਚਿਤ ਹੈ। ਕਈ ਆਬਜੈਕਟਾਂ ਲਈ ਇਹ ਮੱਥਦਾ ਮੁੱਲ ToString() ਦਾ ਮੁੱਲ ਹੀ ਹੈ。

ਟਿੱਪਣੀ:ਉੱਪਰ ਦਿੱਤੇ ਹਰ ਪ੍ਰਕਾਰ ਦੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਮੈਥਡ ਹੋਰ ਆਬਜੈਕਟ ਦੁਆਰਾ ਓਵਰਰਾਇਡ ਕੀਤੇ ਜਾਣਗੇ।

Boolean ਆਬਜੈਕਟ

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 ਨਾਲ ਆਂਦਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Boolean ਗਣਨਾ ਵਿੱਚ false ਅਤੇ true ਨੂੰ ਆਂਦਰ ਕੀਤਾ ਜਾਣ ਦਾ ਨਤੀਜਾ false ਹੈ। ਫਿਰ ਵੀ ਇਸ ਕੋਡ ਵਿੱਚ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ oFalseObject, ਨਾ ਤਾਂ ਉਸ ਦਾ ਮੁੱਲ false。

ਜਿਵੇਂ ਪਹਿਲਾਂ ਚਰਚਾ ਕੀਤਾ ਗਿਆ ਹੈ, Boolean ਪ੍ਰਗਟਾਵਾਂ ਵਿੱਚ, ਸਾਰੇ ਆਬਜੈਕਟ ਆਪਣੇ ਆਪ ਵਿੱਚ true ਵਾਲੇ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ oFalseObject ਦਾ ਮੁੱਲ true ਹੈ। ਤਦ true ਨੂੰ ਇੱਕ ਨਾਲ ਆਂਦਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਦਾ ਨਤੀਜਾ true ਹੈ।

ਧਿਆਨ:ਭਾਵੇਂ ਤੁਸੀਂ Boolean ਆਬਜੈਕਟ ਦੀ ਉਪਲੱਬਧਤਾ ਨੂੰ ਜਾਣਦੇ ਹੋ, ਫਿਰ ਵੀ Boolean ਮੂਲ ਮੁੱਲ ਦਾ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ ਤਾਕਿ ਇਸ ਸੈਕਸ਼ਨ ਵਿੱਚ ਚਰਚਾ ਕੀਤੇ ਗਏ ਪ੍ਰਸ਼ਨਾਂ ਵਿੱਚੋਂ ਬਚਿਆ ਜਾ ਸਕੇ。

ਦੇਖੋ

Boolean ਆਬਜੈਕਟ ਬਾਰੇ ਹੋਰ ਸੂਚਨਾ ਲਈ ਇੱਥੇ ਜਾਵੋ: JavaScript Boolean ਦਾ ਮੁੱਦਾ ਮੰਜਲਾ。

Number ਆਬਜੈਕਟ

ਜਿਵੇਂ ਤੁਸੀਂ ਸੋਚਣ ਵਾਲੇ ਹਨ, Number ਆਬਜੈਕਟ Number ਮੂਲ ਟਾਈਪ ਦਾ ਰੈਫਰੈਂਸ ਟਾਈਪ ਹੈ। Number ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ ਨਿਮਨ ਕੋਡ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ:

var oNumberObject = new Number(68);

ਤੁਸੀਂ ਹੁਣ ਇਸ ਚੈਪਟਰ ਦੇ ਪਹਿਲੇ ਸੈਕਸ਼ਨ ਵਿੱਚ ਚਰਚਾ ਕੀਤੇ ਗਏ ਵਿਸ਼ੇਸ਼ ਮੁੱਲਾਂ (ਜਿਵੇਂ Number.MAX_VALUE) ਦੇ ਬਾਰੇ Number ਆਬਜੈਕਟ ਨੂੰ ਮਾਨਤਾ ਕਰਨ ਵਾਲੇ ਹੋਣੋਂ ਚਾਹੀਦੇ ਹਨ। ਸਾਰੇ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਨਮੂਨੇ ਵਾਲੇ Number ਆਬਜੈਕਟ ਦੀਆਂ ਸਟੈਟਿਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ。

ਨੰਬਰ ਆਬਜੈਕਟ ਦਾ ਮੂਲ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਸਿਰਫ valueOf() ਮੈਥਡ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ:

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.8x10 ਦਾ ਅਰਥ ਹੈ1ਸਮੱਸਿਆ ਹੈ, ਜੇਕਰ ਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਹੈ ਕਿ ਨੂੰ ਕਿਸ ਰੂਪ ਵਿੱਚ (ਮੁੱਢਲਾ ਪ੍ਰਕਾਰ ਜਾਂ ਅਨੁਮਾਨਿਕ ਪ੍ਰਕਾਰ) ਨੰਬਰ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਹੈ ਤਾਂ ਇਹ toPrecision() ਮੈਥਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ।

toPrecision() ਮੈਥਡ

toPrecision() ਮੈਥਡ ਨੂੰ ਨੰਬਰ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਮੁੱਢਲਾ ਪ੍ਰਕਾਰ ਜਾਂ ਅਨੁਮਾਨਿਕ ਪ੍ਰਕਾਰ ਵਾਪਸ ਦਿੰਦਾ ਹੈ। ਇਸ ਕੋਲ ਇੱਕ ਪੈਰਾਮੀਟਰ ਹੈ, ਜੋ ਨੰਬਰ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਨੰਬਰਾਂ ਦੀ ਸੰਖਿਆ ਹੈ (ਅਨੁਮਾਨਿਕ ਪ੍ਰਕਾਰ ਨਹੀਂ ਸ਼ਾਮਲ)। ਉਦਾਹਰਣ ਵਜੋਂ:

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  //ਆਉਟਪੁਟ "7e+1"

ਇਸ ਕੋਡ ਦੀ ਕਾਰਵਾਈ ਨੂੰ ਸੰਖਿਆ 68 ਨੂੰ ਇੱਕ ਨੰਬਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਹੈ, ਨਤੀਜਾ "7e+1" ਹੈ, ਇੱਕ ਹੋਰ ਰੂਪ ਵਿੱਚ ਇਹ 70 ਹੈ। ਨਿਸ਼ਚਿਤ ਤੌਰ 'ਤੇ, toPrecision() ਮੈਥਡ ਨੂੰ ਨੰਬਰਾਂ ਨੂੰ ਰਾਸ਼ਟਰੀ ਪ੍ਰਕਾਰ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਪਰ ਜੇਕਰ 2 ਨੰਬਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ 68 ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਹੈ, ਤਾਂ ਇਹ ਹੋਰ ਆਸਾਨ ਹੁੰਦਾ ਹੈ:

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 ਵਿੱਚ ਕਿਤੇ ਵੀ ਕਾਫੀ ਜ਼ਿਆਦਾ ਜਟਿਲ ਟਿੱਪਣੀਆਂ ਵਾਲਾ ਆਬਜੈਕਟ ਹੈ। ਇਸ ਚਿੱਤਰ ਵਿੱਚ ਸਿਰਫ String ਵਰਗ ਦੀਆਂ ਬੁਨਿਆਦੀ ਸਮਰੱਥਾਵਾਂ ਦਾ ਧਿਆਨ ਰੱਖਿਆ ਗਿਆ ਹੈ। ਹੋਰ ਸੁਪਰੀਮ ਸਮਰੱਥਾਵਾਂ ਦੀ ਜਾਣਕਾਰੀ ਲਈ ਇਸ ਟੂਰੀਜ਼ ਦੇ ਸਬੰਧਤ ਚੈਪਟਰਾਂ ਨੂੰ ਪੜ੍ਹੋ, ਜਾਂ ਇਹ ਪੜ੍ਹੋ: 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"

ਸਟ੍ਰਿੰਗ "hello world" ਵਿੱਚ ਸਥਾਨ 1 ਵਿੱਚ ਚਿੱਤਰ "e" ਹੈ।"ECMAScript ਮੂਲ ਟਾਈਪ" ਸੈਕਸ਼ਨ ਵਿੱਚ ਅਸੀਂ ਗੱਲ ਕੀਤੀ ਹੈ ਕਿ ਪਹਿਲਾ ਚਿੱਤਰ ਦਾ ਸਥਾਨ 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("hello ");
var sResult = oStringObject.concat("world");
alert(sResult);		//ਆਉਟਪੁਟ "hello world"
alert(oStringObject);	//ਆਉਟਪੁਟ "hello "

ਇਸ ਕੋਡ ਵਿੱਚ concat() ਮੈਥਡ ਦਾ ਆਉਟਪੁਟ "hello world" ਹੈ, ਪਰ String ਆਬਜੈਕਟ ਵਿੱਚ ਹੁਣ ਵੀ "hello " ਹੈ।ਇਸ ਕਾਰਣ, ਸਟ੍ਰਿੰਗ ਨੂੰ ਜੋੜਣ ਲਈ ਜ਼ਿਆਦਾ ਤੋਂ ਜ਼ਿਆਦਾ ਜੋਡਨੀ ਹੁੰਦੀ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਰੂਪ ਵਿੱਚ ਸਹੀ ਵਿਵਹਾਰ ਦਿਖਾਉਂਦਾ ਹੈ:

var oStringObject = new String("hello ");
var sResult = oStringObject + "world";
alert(sResult);		//ਆਉਟਪੁਟ "hello world"
alert(oStringObject);	//ਆਉਟਪੁਟ "hello "

indexOf() ਅਤੇ lastIndexOf() ਮੈਥਡ

ਹੁਣ ਤੱਕ, ਸਾਨੂੰ ਸਟ੍ਰਿੰਗ ਨੂੰ ਜੋੜਣ ਵਾਲੇ ਮੈਥਡ, ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਸਿੱਧੇ ਚਿੱਤਰ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਮੈਥਡ ਬਾਰੇ ਚਰਚਾ ਕੀਤੀ ਹੈ, ਪਰ ਜੇਕਰ ਇਹ ਨਹੀਂ ਪਤਾ ਹੈ ਕਿ ਕਿਸੇ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਕੀ ਚਿੱਤਰ ਹੈ, ਤਾਂ ਇਸ ਸਮੇਂ indexOf() ਅਤੇ lastIndexOf() ਮੈਥਡ ਨੂੰ ਕਿਉਂ ਬੁਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ? ਇਸ ਸਮੇਂ indexOf() ਅਤੇ lastIndexOf() ਮੈਥਡ ਨੂੰ ਬੁਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ。

indexOf() ਅਤੇ lastIndexOf() ਮੈਥਡ ਦੋਵੇਂ ਵੀ ਸ਼ੁਰੂ ਵਿੱਚ ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਉਸ ਉੱਚਾਰਨ ਦਾ ਸਥਾਨ ਨੂੰ ਦਿੰਦੇ ਹਨ, ਜੇਕਰ ਉਸ ਉੱਚਾਰਨ ਨੂੰ ਨਹੀਂ ਲੱਭਿਆ ਤਾਂ -1 ਦਿੰਦੇ ਹਨ。

ਇਨ੍ਹਾਂ ਦੋ ਮੈਥਡਾਂ ਦਾ ਅੰਤਰ ਇਹ ਹੈ ਕਿ indexOf() ਮੈਥਡ ਹੈਲੋ ਵਰਲਡ! ਸਟ੍ਰਿੰਗ ਦੇ ਸ਼ੁਰੂ (ਸਥਾਨ 0) ਤੋਂ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਉਸ ਉੱਚਾਰਨ ਨੂੰ ਲੱਭਣ ਲਈ ਹੈ, ਜਦਕਿ lastIndexOf() ਮੈਥਡ ਸਟ੍ਰਿੰਗ ਦੇ ਸਮਾਪਤ ਤੋਂ ਸ਼ੁਰੂ ਕਰਕੇ ਉਸ ਉੱਚਾਰਨ ਨੂੰ ਲੱਭਣ ਲਈ ਹੈ。

var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o"));		ਆਉਟਪੁਟ "4"
alert(oStringObject.lastIndexOf("o"));	ਆਉਟਪੁਟ "7"

ਇੱਥੇ, ਪਹਿਲਾ "o" ਸਟਰਿੰਗ 4 ਵਿੱਚ ਹੈ, ਜਿਵੇਂ ਕਿ "hello" ਵਿੱਚ ਦੇ "o"; ਆਖਰੀ "o" 7 ਵਿੱਚ ਹੈ, ਜਿਵੇਂ ਕਿ "world" ਵਿੱਚ ਦੇ "o"। ਜੇਕਰ ਇਸ ਸਟਰਿੰਗ ਵਿੱਚ ਇੱਕ ਹੀ "o" ਸਟਰਿੰਗ ਹੈ, ਤਾਂ indexOf() ਅਤੇ lastIndexOf() ਮੈਥਡ ਵਾਪਸ ਦਿੱਤੇ ਗਏ ਸਥਾਨ ਬਰਾਬਰ ਹੋਣਗੇ。

localeCompare() ਮੈਥਡ

ਅਗਲਾ ਮੈਥਡ localeCompare() ਹੈ, ਜੋ ਸਟਰਿੰਗ ਨੂੰ ਕਰਨ ਲਈ ਹੈ। ਇਸ ਮੈਥਡ ਦੇ ਇੱਕ ਪੈਰਾਮੀਟਰ ਹੈ - ਤੁਲਨਾ ਕਰਨ ਲਈ ਦਿੱਤਾ ਗਿਆ ਸਟਰਿੰਗ, ਜੋ ਹੇਠ ਲਿਖੇ ਤਿੰਨ ਵਿੱਚੋਂ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਦਿੰਦਾ ਹੈ:

  • ਜੇਕਰ String ਆਬਜੈਕਟ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਸਟਰਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਹੈ, ਤਾਂ ਨੇਗਟਿਵ ਵਾਪਸ ਦਿੰਦਾ ਹੈ。
  • ਜੇਕਰ String ਆਬਜੈਕਟ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਸਟਰਿੰਗ ਨਾਲ ਬਰਾਬਰ ਹੈ, ਤਾਂ 0 ਵਾਪਸ ਦਿੰਦਾ ਹੈ
  • ਜੇਕਰ String ਆਬਜੈਕਟ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਸਟਰਿੰਗ ਤੋਂ ਬਾਅਦ ਹੈ, ਤਾਂ ਪੋਜਿਟਿਵ ਵਾਪਸ ਦਿੰਦਾ ਹੈ。

ਟਿੱਪਣੀ:ਜੇਕਰ ਵਾਪਸ ਦਿੱਤਾ ਗਿਆ ਮੁੱਲ ਨੂੰ ਨੇਗਟਿਵ ਹੈ, ਤਾਂ ਸਭ ਤੋਂ ਆਮ ਮੌਕੇ 'ਚ -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 + " comes before " + oStringObject2);
} else if (iResult > 0) {
  alert(oStringObject1 + " comes after " + oStringObject2);
} else {
  alert("The two strings are equal");
}

ਇਸ ਢਾਂਚੇ ਨੂੰ ਅਪਣਾਉਣ ਨਾਲ, ਇਹ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਕੋਡ ਸਾਰੇ ਇਮਪਲੀਮੈਂਟੇਸ਼ਨਾਂ ਵਿੱਚ ਸਹੀ ਤਰ੍ਹਾਂ ਚਲੇਗਾ。

localeCompare() ਮੈਥਡ ਦੀ ਵਿਲੱਖਣਤਾ ਇਹ ਹੈ ਕਿ ਜਿਸ ਖੇਤਰ (locale) ਵਿੱਚ ਇਹ ਮੈਥਡ ਚਲਦਾ ਹੈ, ਉਹ ਇਸ ਮੈਥਡ ਦੇ ਚਲਣ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੈ (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() کی مدد سے، کوئی بھی لفظ کی لمبائی کو اضافہ کیا جائیگا، اور 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() 总把较小的数字作为起始位，较大的数字作为终止位。因此，substring("3, -4") 返回的是 "hel"。这里的最后一行代码用来说明如何使用这些方法。

toLowerCase()、toLocaleLowerCase()、toUpperCase() 和 toLocaleUpperCase()

最后一套要讨论的方法涉及大小写转换。有 4 种方法用于执行大小写转换，即

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

从名字上可以看出它们的用途，前两种方法用于把字符串转换成全小写的，后两种方法用于把字符串转换成全大写的。

toLowerCase() 和 toUpperCase() 方法是原始的，是以 java.lang.String 中相同方法为原型实现的。

toLocaleLowerCase() 和 toLocaleUpperCase() 方法是基于特定的区域实现的（与 localeCompare() 方法相同）。在许多区域中，区域特定的方法都与通用的方法完全相同。不过，有几种语言对 Unicode 大小写转换应用了特定的规则（例如土耳其语），因此必须使用区域特定的方法才能进行正确的转换。

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"

这代码中，toUpperCase() 和 toLocaleUpperCase() 输出的都是 "HELLO WORLD"，toLowerCase() 和 toLocaleLowerCase() 输出的都是 "hello world"。一般来说，如果不知道在以哪种编码运行一种语言，则使用区域特定的方法比较安全。

提示：记住，String 对象的所有属性和方法都可应用于 String 原始值上，因为它们是伪对象。

instanceof 运算符

在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 "object"。ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。

instanceof 运算符与 typeof 运算符相似，用于识别正在处理的对象的类型。与 typeof 方法不同的是，instanceof 方法要求开发者明确地确认对象为某特定类型。例如：

var oStringObject = new String("hello world");
alert(oStringObject instanceof String);	//输出 "true"

这代码问的是“变量 oStringObject 是否为 String 对象的实例？”oStringObject 的确是 String 对象的实例，因此结果是 "true"。尽管不像 typeof 方法那样灵活，但是在 typeof 方法返回 "object" 的情况下，instanceof 方法还是很有用的。