ਰੈਂਡਮਾਈਜ਼ੇਸ਼ਨ ਸਮੱਸਿਆ ਦੀ ਵਿਆਖਿਆ ਜੋ ਦੂਜੀ ਜਾਵਾਸਕ੍ਰਿਪਟ ਲੂਪ ਨੂੰ ਉਹੀ ਨੰਬਰ ਦੁਹਰਾਉਣ ਦਾ ਕਾਰਨ ਬਣ ਰਹੀ ਹੈ

JavaScript ਲੂਪਸ ਵਿੱਚ ਬੇਤਰਤੀਬੇ ਨੰਬਰਾਂ ਨਾਲ ਅਚਾਨਕ ਵਿਵਹਾਰ

ਪੈਦਾ ਕਰ ਰਿਹਾ ਹੈ JavaScript ਵਿੱਚ ਬੇਤਰਤੀਬ ਨੰਬਰ ਐਰੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਆਮ ਕੰਮ ਹੁੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਅਜਿਹੇ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਲੂਪਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਕਈ ਵਾਰ ਅਚਾਨਕ ਨਤੀਜੇ ਆ ਸਕਦੇ ਹਨ। ਇੱਕ ਧਿਆਨ ਦੇਣ ਯੋਗ ਮੁੱਦਾ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਤੋਂ ਵੱਧ ਦੁਹਰਾਓ ਇੱਕੋ ਜਿਹੇ ਜਾਂ ਅਨੁਮਾਨਤ ਮੁੱਲ ਪੈਦਾ ਕਰਦੇ ਹਨ।

ਇਹ ਲੇਖ ਇੱਕ ਆਮ ਸਮੱਸਿਆ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਦੋ ਫਾਰ-ਲੂਪਸ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਐਰੇ ਤੋਂ ਬੇਤਰਤੀਬ ਸੰਖਿਆਵਾਂ ਬਣਾਉਣ ਲਈ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਕਿ ਪਹਿਲਾ ਲੂਪ ਸਹੀ ਢੰਗ ਨਾਲ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ, ਦੂਜਾ ਲੂਪ ਹਰ ਵਾਰ ਮੁੱਲਾਂ ਦਾ ਉਹੀ ਕ੍ਰਮ ਵਾਪਸ ਕਰਦਾ ਜਾਪਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ 30, 29, 28, 27 ਅਤੇ 26 ਨੰਬਰ।

ਅਸੀਂ ਇਸ ਸਮੱਸਿਆ ਦੇ ਮੂਲ ਕਾਰਨ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਅਤੇ ਸਮਝਾਂਗੇ ਕਿ ਕਿਉਂ ਦੂਜੀ ਲਈ-ਲੂਪ ਸੱਚੀ ਬੇਤਰਤੀਬੀ ਪੈਦਾ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਰਹਿੰਦੀ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਲੇਖ ਕੋਡ ਨੂੰ ਠੀਕ ਕਰਨ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਕਿ ਹਰੇਕ ਲੂਪ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ।

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

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਐਰੇ ਰੈਂਡਮਾਈਜ਼ੇਸ਼ਨ ਦੇ ਪਿੱਛੇ ਤਰਕ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ

ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹੱਲ ਇੱਕ ਆਮ ਮੁੱਦੇ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਦੇ ਹਨ ਜਿੱਥੇ ਦੋ ਲੂਪਸ ਵੱਖ-ਵੱਖ ਐਰੇ ਤੋਂ ਬੇਤਰਤੀਬ ਸੰਖਿਆਵਾਂ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ, ਪਰ ਇੱਕ ਲੂਪ ਸੱਚਮੁੱਚ ਬੇਤਰਤੀਬ ਨਤੀਜੇ ਪ੍ਰਦਾਨ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੁੰਦਾ ਹੈ। ਇਸ ਸਮੱਸਿਆ ਦਾ ਮੁੱਖ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਕਿਵੇਂ Math.random() ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ. ਮੂਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਬੇਤਰਤੀਬ ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਸਮੇਂ ਗਣਨਾ ਵਿੱਚ +1 ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਇਸ ਸੂਖਮ ਗਲਤੀ ਕਾਰਨ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਈ ਵਾਰ ਇੱਕ ਅਵੈਧ ਸੂਚਕਾਂਕ ਦੀ ਚੋਣ ਕਰਨੀ ਪੈਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਦੂਜਾ ਲੂਪ 30 ਤੋਂ 26 ਤੱਕ ਕਾਊਂਟਡਾਊਨ ਵਾਂਗ ਗੈਰ-ਰੈਂਡਮ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ।

ਠੀਕ ਕੀਤੇ ਹੱਲ ਵਰਤਦੇ ਹਨ Math.floor(Math.random() * array.length) ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਤਿਆਰ ਸੂਚਕਾਂਕ ਵੈਧ ਹਨ। ਇਸ ਫਾਰਮੂਲੇ ਦੇ ਪਿੱਛੇ ਤਰਕ ਦਾ ਨਤੀਜਾ ਗੁਣਾ ਕਰਨਾ ਹੈ Math.random() (ਜੋ 0 ਅਤੇ 1 ਦੇ ਵਿਚਕਾਰ ਹੈ) ਐਰੇ ਦੀ ਲੰਬਾਈ ਦੁਆਰਾ। ਦ Math.floor() ਵਿਧੀ ਨਤੀਜੇ ਨੂੰ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਪੂਰਨ ਅੰਕ ਤੱਕ ਲੈਂਦੀ ਹੈ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸੂਚਕਾਂਕ ਹਮੇਸ਼ਾ ਸੀਮਾ ਦੇ ਅੰਦਰ ਹੋਵੇ। ਇਹ ਪਰਿਵਰਤਨ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਲੂਪ ਦੀ ਹਰੇਕ ਦੁਹਰਾਓ ਬੇਤਰਤੀਬੇ ਇੱਕ ਵੱਖਰੇ ਤੱਤ ਦੀ ਚੋਣ ਕਰਦੀ ਹੈ।

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

ਇੱਕ ਹੋਰ ਮੁੱਖ ਸੁਧਾਰ ਵਿੱਚ ਬੇਤਰਤੀਬ ਤੱਤਾਂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਫੰਕਸ਼ਨ ਬਣਾਉਣਾ ਸ਼ਾਮਲ ਹੈ। getRandomFromArray ਫੰਕਸ਼ਨ ਤਰਕ ਨੂੰ ਇੱਕ ਸਿੰਗਲ, ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਬਲਾਕ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਕੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਕੋਡ ਨੂੰ ਹੋਰ ਸੰਭਾਲਣਯੋਗ ਅਤੇ ਸਮਝਣ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਫੰਕਸ਼ਨ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਸਨ। ਦੀ ਵਰਤੋਂ ਦਾਅਵਾ ਸਟੇਟਮੈਂਟਸ ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ ਕਿ ਵਾਪਸ ਕੀਤੇ ਐਰੇ ਦੀ ਲੰਬਾਈ ਉਮੀਦਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ ਅਤੇ ਸਾਰੇ ਚੁਣੇ ਹੋਏ ਤੱਤ ਵਿਲੱਖਣ ਹਨ। ਕੋਡ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਢਾਂਚਾ ਬਣਾ ਕੇ, ਹੱਲ ਨਾ ਸਿਰਫ਼ ਕਾਰਜਸ਼ੀਲ ਹੁੰਦੇ ਹਨ, ਸਗੋਂ ਮਜ਼ਬੂਤ ​​ਅਤੇ ਵੱਖ-ਵੱਖ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਆਸਾਨੀ ਨਾਲ ਅਨੁਕੂਲ ਹੁੰਦੇ ਹਨ।

// Solution 1: Correcting the Random Selection Logic
let col1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
let col2 = [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30];

for (let i = 0; i < 5; i++) {
  const random = Math.floor(Math.random() * col1.length);
  const number = col1.splice(random, 1)[0];
  console.log(number);
}

for (let i = 0; i < 5; i++) {
  const random = Math.floor(Math.random() * col2.length);
  const number = col2.splice(random, 1)[0];
  console.log(number);
}

// Solution 2: Functional Approach with Reusable Functions
const getRandomFromArray = (array, count) => {
  const result = [];
  for (let i = 0; i < count; i++) {
    const random = Math.floor(Math.random() * array.length);
    result.push(array.splice(random, 1)[0]);
  }
  return result;
};

const col1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const col2 = [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30];

console.log(getRandomFromArray(col1, 5));
console.log(getRandomFromArray(col2, 5));

// Solution 3: Simple Unit Test to Verify Random Output
const assert = (condition, message) => {
  if (!condition) {
    throw new Error(message || "Assertion failed");
  }
};

const testRandomFunction = () => {
  const array = [1, 2, 3, 4, 5];
  const result = getRandomFromArray([...array], 5);
  assert(result.length === 5, "Result length should be 5");
  assert(new Set(result).size === 5, "All numbers should be unique");
};

testRandomFunction();
console.log("All tests passed!");

ਉੱਨਤ ਧਾਰਨਾਵਾਂ: ਬੇਤਰਤੀਬੇ ਐਰੇ ਚੋਣ ਵਿੱਚ ਆਮ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣਾ

JavaScript ਵਿੱਚ, ਵਰਤ ਕੇ ਬੇਤਰਤੀਬ ਨੰਬਰ ਪੈਦਾ ਕਰਨਾ ਲੂਪਸ ਦੇ ਅੰਦਰ ਆਮ ਖਰਾਬੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਧਿਆਨ ਨਾਲ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ ਨਾਜ਼ੁਕ ਮੁੱਦਾ ਉਦੋਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ ਗਲਤ ਸੂਚਕਾਂਕ ਗਣਨਾ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਅਣਇੱਛਤ ਜਾਂ ਦੁਹਰਾਉਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਚੋਣ ਹੁੰਦੀ ਹੈ। ਬੇਤਰਤੀਬ ਸੰਖਿਆਵਾਂ ਪੈਦਾ ਕਰਦੇ ਸਮੇਂ, ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਸੂਚਕਾਂਕ ਐਰੇ ਦੀ ਵੈਧ ਸੀਮਾ ਦੇ ਅੰਦਰ ਹੀ ਰਹਿਣ। ਮੂਲ ਕੋਡ ਵਿੱਚ, ਜੋੜਨਾ +1 ਬੇਤਰਤੀਬ ਫਾਰਮੂਲੇ ਵਿੱਚ ਲੰਬਾਈ ਗਲਤੀ ਨਾਲ ਐਰੇ ਦੀਆਂ ਸੀਮਾਵਾਂ ਨੂੰ ਪਾਰ ਕਰ ਗਈ, ਜਿਸ ਨਾਲ ਦੂਜੇ ਲੂਪ ਵਿੱਚ ਅਣ-ਅਨੁਮਾਨਿਤ ਵਿਵਹਾਰ ਹੋਇਆ।

ਇੱਕ ਹੋਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਮੁੱਦਾ ਐਰੇ ਹੇਰਾਫੇਰੀ ਵਿਧੀਆਂ ਦੀ ਚੋਣ ਹੈ। ਜਦਕਿ splice() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਪਾੜੇ ਨੂੰ ਛੱਡੇ ਬਿਨਾਂ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ indexOf() ਗਲਤ ਤਰਕ ਨੂੰ ਤੋੜ ਸਕਦਾ ਹੈ. ਜੇਕਰ ਐਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤਾ ਮੁੱਲ ਨਹੀਂ ਮਿਲਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਵਾਪਸ ਆ ਜਾਵੇਗਾ -1, ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਗਲਤੀਆਂ ਵੱਲ ਅਗਵਾਈ ਕਰਦਾ ਹੈ। ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਸੂਚਕਾਂਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸਪਲੀਸਿੰਗ ਕਰਕੇ Math.floor(), ਕੋਡ ਇਸ ਮੁੱਦੇ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਟਾਲਦਾ ਹੈ, ਕਿਉਂਕਿ ਸਿਰਫ਼ ਵੈਧ ਸੂਚਕਾਂਕ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

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