ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਅਸਿੰਕ/ਉਡੀਕ ਨੂੰ ਸਮਝਣਾ: ਆਉਟਪੁੱਟ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਡੂੰਘੀ ਡੁਬਕੀ

ਸਮੇਂ ਵਿੱਚ JavaScript ਅਸਿੰਕ/ਉਡੀਕ ਵਿਵਹਾਰ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨਾ

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

ਜਿਸ ਸਮੱਸਿਆ 'ਤੇ ਤੁਸੀਂ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਉਹ ਦੋ ਅਸਿੰਕਰੋਨਸ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪ੍ਰਤੀਤ ਹੁੰਦਾ ਹੈ ਸਮਾਨ ਵਿਵਹਾਰ ਦੇ ਨਾਲ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਪਰ ਸਮੇਂ ਦੇ ਰੂਪ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਨਤੀਜੇ ਹਨ। ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ, ਫੰਕਸ਼ਨ ਦੋਵਾਂ ਨੂੰ 10 ਸਕਿੰਟ ਲੱਗ ਸਕਦੇ ਹਨ, ਪਰ ਅਸਲ ਜਵਾਬ ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਹੈਰਾਨ ਕਰ ਦਿੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਵਾਅਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੇ ਤਰੀਕੇ ਦੀ ਡੂੰਘੀ ਸਮਝ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ।

ਇਸ ਲੇਖ ਦਾ ਉਦੇਸ਼ ਤੁਹਾਨੂੰ ਕੋਡ ਰਾਹੀਂ ਜਾਣਨਾ ਹੈ, ਇਸ ਨੂੰ ਤੋੜਨਾ ਕਿ ਕਿਵੇਂ async ਅਤੇ ਉਡੀਕ ਕਰੋ ਮਕੈਨਿਕਸ ਕੰਮ ਕਰਦਾ ਹੈ, ਨਾਲ ਹੀ ਵਾਅਦਾ ਰੈਜ਼ੋਲੂਸ਼ਨ ਦਾ ਕ੍ਰਮ ਅੰਤਮ ਨਤੀਜੇ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਇਸਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ ਇਸ ਗੱਲ ਦੀ ਸਪਸ਼ਟ ਸਮਝ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਕਿ ਅਸਿੰਕ੍ਰੋਨਸ JavaScript ਵਿੱਚ ਸਮਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

ਆਉ ਇਹ ਸਮਝਣ ਲਈ ਕੋਡ ਵਿੱਚ ਡੁਬਕੀ ਕਰੀਏ ਕਿ ਪਹਿਲਾ ਫੰਕਸ਼ਨ ਆਉਟਪੁੱਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ 24 5 ਸਕਿੰਟਾਂ ਬਾਅਦ, ਅਤੇ ਦੂਜਾ ਫੰਕਸ਼ਨ ਵੀ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ 24 ਪਰ ਇੱਕ ਵੱਖਰੇ ਵਾਅਦੇ ਢਾਂਚੇ ਦੇ ਨਾਲ। ਇਸ ਗਿਆਨ ਨਾਲ, ਤੁਸੀਂ ਆਪਣੇ ਆਉਣ ਵਾਲੇ ਇੰਟਰਵਿਊ ਦੇ ਮੁਲਾਂਕਣਾਂ ਲਈ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਲੈਸ ਹੋਵੋਗੇ।

JavaScript ਵਿੱਚ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਵਿੱਚ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਸ਼ਕਤੀ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੀ ਹੈ async ਅਤੇ ਉਡੀਕ ਕਰੋ ਕੀਵਰਡਸ. ਮੁੱਖ ਵਿਚਾਰ ਅਸਿੰਕ੍ਰੋਨਸ ਕਾਰਜਾਂ ਜਿਵੇਂ ਕਿ ਦੇਰੀ ਵਾਲੇ ਕਾਰਜਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲਣਾ ਹੈ। ਦੋਵਾਂ ਉਦਾਹਰਨਾਂ ਵਿੱਚ, ਫੰਕਸ਼ਨ 5s(x) ਤੋਂ ਬਾਅਦ ਮੁੱਲ ਦੇ ਨਾਲ ਹੱਲ ਕਰਨ ਵਾਲੇ ਵਾਅਦੇ ਨੂੰ ਵਾਪਸ ਕਰਕੇ 5 ਸਕਿੰਟਾਂ ਦੀ ਦੇਰੀ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ x. ਇਹ ਦੇਰੀ ਓਪਰੇਸ਼ਨਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸਮਝਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਅਤੇ ਕਿਵੇਂ ਵਾਅਦੇ ਫੰਕਸ਼ਨ ਦੇ ਪ੍ਰਵਾਹ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾਉਂਦੇ ਹਨ।

ਪਹਿਲੇ ਸਮਾਗਮ ਵਿੱਚ ਸ. ਮਲਟੀ (ਇਨਪੁਟ), ਕੋਡ ਦੋ ਵਾਅਦਿਆਂ ਦੇ ਹੱਲ ਲਈ ਕ੍ਰਮਵਾਰ ਉਡੀਕ ਕਰਦਾ ਹੈ। ਦ ਉਡੀਕ ਕਰੋ ਕੀਵਰਡ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਉਦੋਂ ਤੱਕ ਰੋਕਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਵਾਅਦਾ ਵਾਪਸ ਨਹੀਂ ਹੋ ਜਾਂਦਾ after5s(3) ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਫਿਰ, ਪਹਿਲੇ ਵਾਅਦੇ ਦੇ ਹੱਲ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਕੋਡ ਦੂਜੇ ਵਾਅਦੇ ਲਈ ਹੋਰ 5 ਸਕਿੰਟ ਉਡੀਕ ਕਰਦਾ ਹੈ after5s(4) ਹੱਲ ਕਰਨ ਲਈ. ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਗਣਨਾ ਕੀਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਕੁੱਲ 10 ਸਕਿੰਟ ਉਡੀਕ ਸਮਾਂ ਹੁੰਦਾ ਹੈ। ਦੋਵੇਂ ਹੱਲ ਕੀਤੇ ਮੁੱਲਾਂ ਦੁਆਰਾ ਇਨਪੁਟ ਦਾ ਗੁਣਾ ਅੰਤਮ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ।

ਦੂਜਾ ਫੰਕਸ਼ਨ, second_mult(ਇਨਪੁਟ), ਦੋਵੇਂ ਵਾਅਦਿਆਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਸ਼ੁਰੂ ਕਰਕੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ। ਸੌਂਪ ਕੇ after5s(3) ਅਤੇ after5s(4) ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲਾਂ ਲਈ ਉਡੀਕ ਕਰੋ, ਦੋਵੇਂ ਵਾਅਦੇ ਸਮਾਨਾਂਤਰ ਚੱਲਦੇ ਹਨ। ਜਦੋਂ ਕੋਡ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ ਉਡੀਕ ਕਰੋ ਬਿਆਨ, ਇਹ ਦੋਵਾਂ ਵਾਅਦਿਆਂ ਦੇ ਹੱਲ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ, ਪਰ ਉਹ ਪਹਿਲਾਂ ਹੀ ਪ੍ਰਗਤੀ ਵਿੱਚ ਹਨ, ਕੁੱਲ ਉਡੀਕ ਸਮੇਂ ਨੂੰ ਘਟਾ ਕੇ ਸਿਰਫ 5 ਸਕਿੰਟ ਕਰ ਰਹੇ ਹਨ। ਇਹ ਸਮਕਾਲੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੇ ਮਹੱਤਵ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ।

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

function after5s(x) {
  return new Promise(res => {
    setTimeout(() => {
      res(x);
    }, 5000);
  });
}

// First approach using async/await with sequential waits
async function mult(input) {
  const f = await after5s(3);
  const g = await after5s(4);
  return input * f * g;
}

// Calling the function and handling the promise resolution
mult(2).then(value => {
  console.log(value); // Output: 24 after 10 seconds
});

function after5s(x) {
  return new Promise(res => {
    setTimeout(() => {
      res(x);
    }, 5000);
  });
}

// Second approach optimizing by starting both promises concurrently
async function second_mult(input) {
  const f = after5s(3); // Starts promise immediately
  const g = after5s(4); // Starts second promise concurrently
  return input * await f * await g;
}

// Calling the function and handling the promise resolution
second_mult(2).then(value => {
  console.log(value); // Output: 24 after 5 seconds
});

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਅਸਿੰਕਰੋਨਸ ਪੈਟਰਨਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ

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

ਅਸਿੰਕਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਵਿੱਚ ਇੱਕ ਅਕਸਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਗਿਆ ਤੱਤ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਹੈ। async/await ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਆਪਣੇ ਕੋਡ ਨੂੰ a ਵਿੱਚ ਲਪੇਟ ਸਕਦੇ ਹਨ ਕੋਸ਼ਿਸ਼ ਕਰੋ...ਫੜੋ ਵਾਅਦਾ ਅਸਵੀਕਾਰੀਆਂ ਅਤੇ ਹੋਰ ਗਲਤੀਆਂ ਨੂੰ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਬਲਾਕ ਕਰੋ। ਇਹ ਵਿਧੀ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਇੱਕ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨ ਵਿੱਚ ਹੋਣ ਵਾਲੀਆਂ ਕੋਈ ਵੀ ਤਰੁੱਟੀਆਂ ਨੂੰ ਪ੍ਰੋਗ੍ਰਾਮ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਤੋੜੇ ਬਿਨਾਂ ਫੜਿਆ ਅਤੇ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ। ਅਸਿੰਕ੍ਰੋਨਸ ਫੰਕਸ਼ਨ ਨਾ ਸਿਰਫ਼ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦੇ ਹਨ ਬਲਕਿ ਗੁੰਝਲਦਾਰ ਤਰੁੱਟੀ ਨੂੰ ਸੰਭਾਲਣ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਅਤੇ ਡੀਬੱਗ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ।

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