ਇੱਕ JavaScript ਐਰੇ ਤੋਂ ਡੁਪਲੀਕੇਟਸ ਨੂੰ ਹਟਾਉਣਾ

JavaScript ਵਿੱਚ ਐਰੇ ਦੀ ਵਿਲੱਖਣਤਾ ਨੂੰ ਸਮਝਣਾ

JavaScript ਵਿੱਚ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨਾ ਕਿ ਇੱਕ ਐਰੇ ਵਿੱਚ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲ ਸ਼ਾਮਲ ਹਨ ਵੱਖ-ਵੱਖ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੋ ਸਕਦੇ ਹਨ। ਹਾਲਾਂਕਿ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ, ਕੁਝ ਖਾਸ ਸ਼ਰਤਾਂ, ਜਿਵੇਂ ਕਿ ਜ਼ੀਰੋ ਦੀ ਮੌਜੂਦਗੀ ਦੇ ਅਧੀਨ ਕੁਝ ਢੰਗ ਅਸਫਲ ਹੋ ਸਕਦੇ ਹਨ।

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

ਹੁਕਮ	ਵਰਣਨ
new Set()	ਇੱਕ ਸੈੱਟ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੇ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦਿੰਦਾ ਹੈ।
[...new Set(array)]	ਇੱਕ ਸੈੱਟ ਨੂੰ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਦੀ ਇੱਕ ਐਰੇ ਵਿੱਚ ਬਦਲਣ ਲਈ ਸਪ੍ਰੈਡ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।
Array.prototype.getUnique	ਐਰੇ ਤੋਂ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਲਈ ਐਰੇ ਪ੍ਰੋਟੋਟਾਈਪ 'ਤੇ ਇੱਕ ਨਵੀਂ ਵਿਧੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।
uniqueElements[this[i]] = this[i]	ਵਿਲੱਖਣਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਹਰੇਕ ਤੱਤ ਨੂੰ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਇੱਕ ਕੁੰਜੀ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ।
for (let key in uniqueElements)	ਨਤੀਜਾ ਐਰੇ ਬਣਾਉਣ ਲਈ ਵਿਲੱਖਣ ਐਲੀਮੈਂਟਸ ਆਬਜੈਕਟ ਦੀਆਂ ਕੁੰਜੀਆਂ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ।
const uniqueElements = {}	ਵਿਲੱਖਣ ਤੱਤਾਂ ਨੂੰ ਕੁੰਜੀਆਂ ਵਜੋਂ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਖਾਲੀ ਵਸਤੂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।

JavaScript ਐਰੇ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਨੂੰ ਕਿਵੇਂ ਹਟਾਉਣਾ ਹੈ

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

ਉਦਾਹਰਨ ਲਈ, ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਡੁਪਲੀਕੇਟ ਨੰਬਰਾਂ ਵਾਲਾ ਐਰੇ ਹੈ, ਜਿਸ ਵਿੱਚ ਜ਼ੀਰੋ ਸ਼ਾਮਲ ਹਨ, ਜਿਵੇਂ ਕਿ , ਫੰਕਸ਼ਨ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਨਾਲ ਇੱਕ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ: . ਇਹ ਵਿਧੀ ਸਿੱਧੀ ਹੈ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਮੁੱਦੇ ਦੇ ਜ਼ੀਰੋ ਸਮੇਤ ਸਾਰੇ ਕਿਸਮ ਦੇ ਤੱਤਾਂ ਨੂੰ ਹੈਂਡਲ ਕਰਦੀ ਹੈ।

ਵਿਲੱਖਣ ਐਰੇ ਮੁੱਲਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇੱਕ ਕਸਟਮ ਢੰਗ

ਦੂਜੀ ਸਕ੍ਰਿਪਟ 'ਤੇ ਇੱਕ ਕਸਟਮ ਵਿਧੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਬੁਲਾਇਆ . ਇਹ ਵਿਧੀ ਵਿਲੱਖਣ ਤੱਤਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਇੱਕ ਵਸਤੂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਵਿਧੀ ਦੇ ਅੰਦਰ, ਅਸੀਂ ਪਹਿਲਾਂ ਇੱਕ ਖਾਲੀ ਵਸਤੂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਖਾਲੀ ਐਰੇ const resultArray = []. ਅਸੀਂ ਫਿਰ a ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਰੇ ਉੱਤੇ ਦੁਹਰਾਉਂਦੇ ਹਾਂ ਲੂਪ, ਹਰੇਕ ਤੱਤ ਨੂੰ ਇੱਕ ਕੁੰਜੀ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕਰਨਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਸਾਰੀਆਂ ਕੁੰਜੀਆਂ ਵਿਲੱਖਣ ਹਨ।

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

function getUniqueValues(array) {
  return [...new Set(array)];
}

// Example usage:
const numbers = [1, 2, 2, 3, 4, 4, 5, 0, 0];
const uniqueNumbers = getUniqueValues(numbers);
console.log(uniqueNumbers);

Array.prototype.getUnique = function() {
  const uniqueElements = {};
  const resultArray = [];
  for (let i = 0; i < this.length; i++) {
    uniqueElements[this[i]] = this[i];
  }
  for (let key in uniqueElements) {
    resultArray.push(uniqueElements[key]);
  }
  return resultArray;
};

// Example usage:
const numbers = [1, 2, 2, 3, 4, 4, 5, 0, 0];
const uniqueNumbers = numbers.getUnique();
console.log(uniqueNumbers);

ਐਰੇ ਡੀਡੁਪਲੀਕੇਸ਼ਨ ਤਕਨੀਕਾਂ ਵਿੱਚ ਡੂੰਘੀ ਡੁਬਕੀ ਕਰੋ

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

ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਐਰੇ 'ਤੇ ਵਿਚਾਰ ਕਰੋ . ਵਰਤ ਕੇ , ਤੁਸੀਂ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਪਹੁੰਚ ਇਸ ਗੱਲ ਦੀ ਜਾਂਚ ਕਰਕੇ ਕੰਮ ਕਰਦੀ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਤੱਤ ਦਾ ਸੂਚਕਾਂਕ ਉਸ ਤੱਤ ਦੇ ਪਹਿਲੇ ਮੌਜੂਦਗੀ ਸੂਚਕਾਂਕ ਦੇ ਸਮਾਨ ਹੈ। ਜੇਕਰ ਇਹ ਹੈ, ਤਾਂ ਤੱਤ ਵਿਲੱਖਣ ਹੈ ਅਤੇ ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ।

1. ਇੱਕ ਐਰੇ ਤੋਂ ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਉਣ ਦਾ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕਾ ਕੀ ਹੈ?
2. ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਏ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਤਰੀਕਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ O(n) ਦੀ ਸਮੇਂ ਦੀ ਗੁੰਝਲਤਾ ਹੈ।
3. ਕੀ ਮੈਂ ਵਰਤ ਸਕਦਾ ਹਾਂ ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਉਣ ਲਈ ਢੰਗ?
4. ਹਾਂ, ਜੋੜਨਾ ਨਾਲ ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਉਣ ਲਈ ਇੱਕ ਆਮ ਪਹੁੰਚ ਹੈ.
5. ਕਿਉਂ ਕਰਦਾ ਹੈ ਵਿਧੀ ਜ਼ੀਰੋ ਨਾਲ ਫੇਲ?
6. ਅਸਲੀ ਸਕ੍ਰਿਪਟ ਜ਼ੀਰੋ ਨਾਲ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਜ਼ੀਰੋ 'ਤੇ ਰੁਕਦਾ ਹੈ, ਇਸਨੂੰ ਗਲਤ ਸਮਝਦਾ ਹੈ।
7. ਮੈਂ ਵਿਲੱਖਣਤਾ ਲਈ ਇੱਕ ਐਰੇ ਵਿੱਚ ਵੱਖ ਵੱਖ ਡੇਟਾ ਕਿਸਮਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲ ਸਕਦਾ ਹਾਂ?
8. ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਏ ਹਰੇਕ ਮੁੱਲ ਵਿਲੱਖਣ ਹੋਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਕੇ ਵੱਖ-ਵੱਖ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ।
9. ਵਰਤਣ ਦਾ ਕੀ ਫਾਇਦਾ ਹੈ ਹੋਰ ਢੰਗ ਵੱਧ?
10. ਸੰਖੇਪ ਹੈ ਅਤੇ ਵਾਧੂ ਤਰਕ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।
11. ਕੀ ਮੈਂ ਸਾਰੀਆਂ ਐਰੇਆਂ ਵਿੱਚ ਵਿਲੱਖਣ ਵਿਧੀ ਸ਼ਾਮਲ ਕਰ ਸਕਦਾ ਹਾਂ?
12. ਹਾਂ, ਵਿੱਚ ਇੱਕ ਵਿਧੀ ਜੋੜ ਕੇ , ਤੁਸੀਂ ਇਸਨੂੰ ਸਾਰੀਆਂ ਐਰੇ ਲਈ ਉਪਲਬਧ ਕਰਵਾ ਸਕਦੇ ਹੋ।
13. ਸੋਧਣ ਦਾ ਨੁਕਸਾਨ ਕੀ ਹੈ ?
14. ਸੋਧਿਆ ਜਾ ਰਿਹਾ ਹੈ ਜੇਕਰ ਹੋਰ ਸਕ੍ਰਿਪਟਾਂ ਵੀ ਇਸਨੂੰ ਸੋਧਦੀਆਂ ਹਨ ਤਾਂ ਵਿਵਾਦ ਪੈਦਾ ਹੋ ਸਕਦਾ ਹੈ।
15. ਕੀ ਅਸਲੀ ਐਰੇ ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ ਵਿਲੱਖਣਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਦਾ ਕੋਈ ਤਰੀਕਾ ਹੈ?
16. ਹਾਂ, ਤਰੀਕੇ ਜਿਵੇਂ ਅਤੇ ਅਸਲੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹੋਏ, ਇੱਕ ਨਵੀਂ ਐਰੇ ਬਣਾਓ।

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