ای سی ایم اسکریپت آئی اینٹی تبدیل

ECMAScript ਦੀ ਵਰਤੋਂ ਨਾਲ ਨਾ ਕੇਵਲ ਆਬਜੈਕਟ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਸਗੋਂ ਮੌਜੂਦਾ ਆਬਜੈਕਟ ਦਾ ਵਿਵਹਾਰ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ。

prototype ਪ੍ਰਤੀਯੋਗੀ ਨਾਲ ਨਾ ਕੇਵਲ ਬਣਾਉਣ ਵਾਲੇ ਫੰਕਸ਼ਨ ਦੇ ਪੈਰਾਮੀਟਰ ਅਤੇ ਮੈਥਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦਾ ਹੈ, ਸਗੋਂ ਸਥਾਨਕ ਆਬਜੈਕਟ ਨੂੰ ਪੈਰਾਮੀਟਰ ਅਤੇ ਮੈਥਡ ਜੋੜ ਸਕਦਾ ਹੈ。

ਨਵੇਂ ਮੇਥਡ ਬਣਾਉਣਾ

ਪੁਰਾਣੇ ਮੇਥਡ ਰਾਹੀਂ ਨਵੇਂ ਮੇਥਡ ਬਣਾਉਣਾ

ਪ੍ਰੋਟੋਟਾਈਪ ਪ੍ਰਾਪਰਟੀ ਰਾਹੀਂ ਕਿਸੇ ਵੀ ਪੁਰਾਣੇ ਕਲਾਸ ਲਈ ਨਵੇਂ ਮੇਥਡ ਨਿਰਮਿਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ ਆਪਣੀ ਕਲਾਸ ਦੇ ਤਰ੍ਹਾਂ ਹੀ। ਉਦਾਹਰਣ ਵਜੋਂ, ਯਾਦ ਕਰੋ ਕਿ ਨੰਬਰ ਕਲਾਸ ਦਾ toString() ਮੇਥਡ ਹੈ? ਜੇਕਰ ਇਸ ਨੂੰ 16 ਦਾ ਪੈਰਾਮੀਟਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਹੈਕਸਾਡੈਸਿਮਲ ਚਿਨਹਾਂ ਵਾਲੀ ਸਟਰਿੰਗ ਲਿਖ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਪੈਰਾਮੀਟਰ 2 ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਬਾਇਨਰੀ ਚਿਨਹਾਂ ਵਾਲੀ ਸਟਰਿੰਗ ਲਿਖ ਦਿੰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਮੇਥਡ ਬਣਾਉਣਾ ਬਹੁਤ ਸਹਿਜ ਹੈ:

Number.prototype.toHexString = function() {
  return this.toString(16);
};

ਇਸ ਮਾਹੌਲ ਵਿੱਚ, ਕੀਵਾਰਡ this ਨੂੰ ਨੰਬਰ ਦੇ ਇੱਕ ਇੰਸਟੈਂਸ ਨੂੰ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਨੰਬਰ ਦੇ ਸਾਰੇ ਮੇਥਡਾਂ ਤੱਕ ਪਹੁੰਚ ਸਕਦਾ ਹੈ। ਇਸ ਕੋਡ ਨਾਲ, ਹੇਠ ਲਿਖੇ ਕੰਮ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ:

var iNum = 15;
alert(iNum.toHexString());		//ਪ੍ਰਦਰਸ਼ਿਤ "F"

TIY

ਅੰਕ 15 ਹੈਕਸਾਡੈਸਿਮਲ ਵਿੱਚ F ਹੈ, ਇਸ ਲਈ ਚਿਤਾਵਨੀ "F" ਦਿਖਾਈ ਦੇਵੇਗੀ。

ਪੁਰਾਣੇ ਮੇਥਡ ਦਾ ਨਾਮ ਬਦਲਣਾ

ਅਸੀਂ ਪੁਰਾਣੇ ਮੇਥਡ ਨੂੰ ਹੋਰ ਸਮਝਦਾਰ ਨਾਮ ਦੇ ਸਕਦੇ ਹਾਂ। ਉਦਾਹਰਣ ਵਜੋਂ, ਅਸੀਂ ਏਕ੍ਰੇਅਰ ਕਲਾਸ ਨੂੰ enqueue() ਅਤੇ dequeue() ਦੋ ਮੇਥਡ ਜੋੜ ਸਕਦੇ ਹਾਂ, ਜੋ ਸਿਰਫ ਪੁਰਾਣੇ push() ਅਤੇ shift() ਮੇਥਡਾਂ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਨ:

Array.prototype.enqueue = function(vItem) {
  this.push(vItem);
};
Array.prototype.dequeue = function() {
  return this.shift();
};

TIY

ਪੁਰਾਣੇ ਮੇਥਡ ਨਾਲ ਸਬੰਧ ਨਾ ਰੱਖਣ ਵਾਲਾ ਮੇਥਡ ਜੋੜ ਸਕਦੇ ਹਾਂ

ਕੋਈ ਵੀ ਪੁਰਾਣੇ ਮੇਥਡ ਨਾਲ ਸਬੰਧ ਨਾ ਰੱਖਣ ਵਾਲਾ ਮੇਥਡ ਜੋੜ ਸਕਦੇ ਹਾਂ। ਉਦਾਹਰਣ ਵਜੋਂ, ਇਹ ਮੰਨੋ ਜਾਵੇ ਕਿ ਇੱਕ ਵਸਤੂ ਨੂੰ ਮੰਡਲ ਵਿੱਚ ਸਥਾਨ ਤਲਾਸ਼ਣ ਲਈ ਕੋਈ ਸਥਾਨਕ ਮੇਥਡ ਨਹੀਂ ਹੈ। ਅਸੀਂ ਹੇਠ ਲਿਖੇ ਮੇਥਡ ਸਹਿਜੇ ਤੌਰ 'ਤੇ ਬਣਾ ਸਕਦੇ ਹਾਂ:

Array.prototype.indexOf = function (vItem) {
  for (var i=0; i<this.length; i++) {
    if (vItem == this[i]) {
	  return i;
	}
  }
  return -1;
}

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

var aColors = new Array("red","green","blue");
alert(aColors.indexOf("green"));	//ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ "1"

TIY

ਸਥਾਨਕ ਆਬਜਦ ਨੂੰ ਨਵੇਂ ਮੈਥਡ ਜੋੜਨਾ

ਅੰਤ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ECMAScript ਵਿੱਚ ਹਰ ਸਥਾਨਕ ਆਬਜਦ ਨੂੰ ਨਵੇਂ ਮੈਥਡ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਮੈਥਡ Object ਆਬਜਦ ਦੇ prototype ਪ੍ਰਤੀਯੋਗਿਤਾ ਉੱਤੇ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਹੋਵੇਗਾ। ਪਹਿਲਾਂ ਦੇ ਖੰਡ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਸਾਰੇ ਸਥਾਨਕ ਆਬਜਦ ਆਬਜਦ ਆਬਜਦ ਤੋਂ ਵਾਰਸਾ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ ਆਬਜਦ ਆਬਜਦ 'ਤੇ ਕੋਈ ਵੀ ਬਦਲਾਅ ਕਰੋ, ਤਾਂ ਇਹ ਸਾਰੇ ਆਬਜਦ 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰੇਗਾ। ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਤੁਸੀਂ ਆਬਜਦ ਦੇ ਮੌਜੂਦਾ ਮੁੱਲ ਨੂੰ ਚਿਤਾਵਨੀ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਨਿਮਨਲਿਖਤ ਕੋਡ ਵਰਤ ਸਕਦੇ ਹੋ:

Object.prototype.showValue = function () {
  alert(this.valueOf());
};
var str = "hello";
var iNum = 25;
str.showValue();		//ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ "hello"
iNum.showValue();		//ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ "25"

TIY

ਇੱਥੇ, String ਅਤੇ Number ਆਬਜਦ ਦਾ showValue() ਮੈਥਡ Object ਆਬਜਦ ਤੋਂ ਵਾਰਸਾ ਕਰਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਆਬਜਦ 'ਤੇ ਇਹ ਮੈਥਡ ਆਉਣ ਤੋਂ ਪਹਿਲਾਂ ਚਲਾਇਆ ਜਾਵੇਗਾ, ਜਿਸ ਨਾਲ "hello" ਅਤੇ "25" ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਣਗੇ。

ਪਹਿਲੇ ਦੇ ਮੈਥਡ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾਣਾ

ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦੇ ਖੰਡ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਹਿਲੇ ਦੇ ਕਲਾਸ ਦੇ ਨਵੇਂ ਮੈਥਡ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਕਲਾਸ ਦੇ ਨਾਮ ਫੰਕਸ਼ਨ ਦੇ ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਪਾਸੇ ਹੈ, ਇਸ ਲਈ ਇਹ ਆਸਾਨੀ ਨਾਲ ਹੋਰ ਫੰਕਸ਼ਨ ਨੂੰ ਨਿਰਦੇਸ਼ ਕਰ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਸਥਾਨਕ ਮੈਥਡ ਜਿਵੇਂ toString() ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰੋ, ਤਾਂ ਕੀ ਹੋਵੇਗਾ?

Function.prototype.toString = function() {
  return "Function code hidden";
}

ਪਹਿਲਾਂ ਦਾ ਕੋਡ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਾਨੂੰਨੀ ਹੈ, ਚਲਾਉਣ ਦਾ ਨਤੀਜਾ ਮੰਗਦੇ ਹੋਏ ਮੰਗਦਾ ਹੈ:

function sayHi() {
  alert("hi");
}
alert(sayHi.toString());	//ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ "Function code hidden"

TIY

ਤੁਸੀਂ ਯਾਦ ਕਰ ਸਕਦੇ ਹੋ, Function ਆਬਜਦ ਦੇ ਇਸ ਖੰਡ ਵਿੱਚ Function ਦੇ toString() ਮੈਥਡ ਦੀ ਜਾਣਕਾਰੀ ਦਿੱਤੀ ਗਈ ਸੀ ਕਿ ਇਹ ਮੈਥਡ ਸਾਧਾਰਨ ਤੌਰ 'ਤੇ ਫੰਕਸ਼ਨ ਦੇ ਸੋਰਸ ਕੋਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਮੈਥਡ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨ ਨਾਲ ਇੱਕ ਹੋਰ ਸਟਰਿੰਗ (ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, "Function code hidden") ਵਾਪਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਲੇਕਿਨ toString() ਦੇ ਪ੍ਰਾਚੀਨ ਫੰਕਸ਼ਨ ਨੂੰ ਕੀ ਹੋਇਆ? ਇਹ ਬੇਕਾਰ ਸਟੋਰੇਜ ਯੂਨਿਟ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਰਿਕਾਰਡ ਕੀਤਾ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਇਹ ਹੋਰ ਤੋਂ ਤਿਆਰ ਹੋ ਗਿਆ ਹੈ। ਪ੍ਰਾਚੀਨ ਫੰਕਸ਼ਨ ਨੂੰ ਬਹਾਲ ਕਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਪ੍ਰਾਚੀਨ ਮੈਥਡ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਇਸ ਦੀ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨਾ ਸਭ ਤੋਂ ਸੁਰੱਖਿਅਤ ਤਰੀਕਾ ਹੈ, ਤਾਕਿ ਭਵਿੱਖ ਵਿੱਚ ਇਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕੇ। ਕਦੇ-ਕਦੇ ਤੁਸੀਂ ਨਵੇਂ ਮੈਥਡ ਵਿੱਚ ਪ੍ਰਾਚੀਨ ਮੈਥਡ ਨੂੰ ਬੁਲਾਉਣ ਵੀ ਸਕਦੇ ਹੋ:

Function.prototype.originalToString = Function.prototype.toString;
Function.prototype.toString = function() {
  if (this.originalToString().length > 100) {
    return "Function too long to display.";
  }
    return this.originalToString();
  }
};

TIY

ਇਸ ਕੋਡ ਵਿੱਚ, ਪਹਿਲੀ ਲਾਈਨ ਨਾਲ ਮੌਜੂਦਾ toString() ਮੇਥਡ ਦੀ ਰਿਫਰੈਂਸ ਨੂੰ ਪ੍ਰਾਇਮੋਰਲ ਟੋਸਟਰਿੰਗ () ਵਿੱਚ ਸੰਭਾਲਿਆ ਗਿਆ ਹੈ। ਫਿਰ ਇੱਕ ਸਰਕਾਰੀ ਮੇਥਡ ਨੂੰ toString() ਮੇਥਡ ਉੱਤੇ ਅਵਰੋਧ ਕੀਤਾ ਗਿਆ ਹੈ। ਨਵਾਂ ਮੇਥਡ ਫੰਕਸ਼ਨ ਸੋਰਸ ਕੋਡ ਦੀ ਲੰਬਾਈ ਨੂੰ ਜਾਂਚ ਕਰੇਗਾ; ਜੇਕਰ ਇਹ ਲੰਬਾਈ 100 ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਇੱਕ ਜਾਣਕਾਰੀ ਸੁਨੇਹਾ ਵਾਪਸ ਦੇਵੇਗਾ ਕਿ ਫੰਕਸ਼ਨ ਕੋਡ ਬਹੁਤ ਲੰਬਾ ਹੈ, ਅਤੇ ਨਾਲ ਹੀ originalToString() ਮੇਥਡ ਨੂੰ ਬੁਲਾਵੇਗਾ ਅਤੇ ਫੰਕਸ਼ਨ ਦੇ ਸੋਰਸ ਕੋਡ ਨੂੰ ਵਾਪਸ ਦੇਵੇਗਾ।

ਬਹੁਤ ਹੀ ਲੱਭਣ (Very Late Binding)

ਤਕਨੀਕੀ ਰੂਪ ਵਿੱਚ, ਬਹੁਤ ਹੀ ਲੱਭਣ ਨਹੀਂ ਹੈ। ਇਹ ਪੁਸਤਕ ਇਸ ਟੇਰਮ ਨੂੰ ECMAScript ਵਿੱਚ ਇੱਕ ਅਪਰੇਸ਼ਨ ਦੇਣ ਦੀ ਕਿਸਮ ਦੇ ਵਰਣਨ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਅਬਜੈਕਟ ਦੇ ਇੰਸਟੈਂਸੀਏਸ਼ਨ ਦੇ ਬਾਅਦ ਇਸ ਦੇ ਤੰਤਰ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਣ ਵਜੋਂ:

var o = new Object();
Object.prototype.sayHi = function () {
  alert("hi");
};
o.sayHi();

TIY

ਮੋਸਟ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ, ਅਬਜੈਕਟ ਦੇ ਇੰਸਟੈਂਸੀਏਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਅਬਜੈਕਟ ਦੇ ਤੰਤਰ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਹੁੰਦਾ ਹੈ। ਇੱਥੇ, ਮੇਥਡ ਸੇਅਹੀ() ਅਬਜੈਕਟ ਕਲਾਸ ਦੇ ਇੰਸਟੈਂਸ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ ਜੋੜੀ ਗਈ ਹੈ। ਰਵਾਇਤੀ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ, ਇਹ ਮੇਥਡ ਵੀ ਅਬਜੈਕਟ ਦੇ ਇੰਸਟੈਂਸ ਨੂੰ ਆਪਣੇ ਆਪ ਸਮੇਤ ਸਵੈਚਾਲਿਤ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਅਤੇ ਤੁਰੰਤ ਇਸਤੇਮਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ (ਅਗਲੇ ਲਾਈਨ ਵਿੱਚ)।

ਧਿਆਨ:ਅਤੇ ਹੁਣ ਲੱਭਣ ਅਤੇ ਰਿਕਾਰਡ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਿਲ ਹੁੰਦੀ ਹੈ, ਪਰ ਇਸ ਸੰਭਾਵਨਾ ਦੇ ਬਾਰੇ ਜਾਣਨਾ ਚਾਹੀਦਾ ਹੈ।