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

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

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

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

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

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

ਉਦਾਹਰਨ ਲਈ, ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਡੁਪਲੀਕੇਟ ਨੰਬਰਾਂ ਵਾਲਾ ਐਰੇ ਹੈ, ਜਿਸ ਵਿੱਚ ਜ਼ੀਰੋ ਸ਼ਾਮਲ ਹਨ, ਜਿਵੇਂ ਕਿ [1, 2, 2, 3, 4, 4, 5, 0, 0], ਫੰਕਸ਼ਨ getUniqueValues(array) ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਨਾਲ ਇੱਕ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ: [1, 2, 3, 4, 5, 0]. ਇਹ ਵਿਧੀ ਸਿੱਧੀ ਹੈ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਮੁੱਦੇ ਦੇ ਜ਼ੀਰੋ ਸਮੇਤ ਸਾਰੇ ਕਿਸਮ ਦੇ ਤੱਤਾਂ ਨੂੰ ਹੈਂਡਲ ਕਰਦੀ ਹੈ।

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

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

ਆਬਾਦੀ ਦੇ ਬਾਅਦ uniqueElements ਵਸਤੂ, ਅਸੀਂ ਇੱਕ ਹੋਰ ਵਰਤਦੇ ਹਾਂ for...in ਆਬਜੈਕਟ ਦੀਆਂ ਕੁੰਜੀਆਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਲੂਪ ਕਰੋ ਅਤੇ ਹਰੇਕ ਵਿਲੱਖਣ ਕੁੰਜੀ ਨੂੰ ਵਿੱਚ ਧੱਕੋ resultArray. ਅੰਤ ਵਿੱਚ, ਵਿਧੀ ਵਾਪਸ ਆਉਂਦੀ ਹੈ 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 ਵਿੱਚ ਇੱਕ ਐਰੇ ਤੋਂ ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਉਣ ਲਈ ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਹੈ filter ਦੇ ਨਾਲ ਸੁਮੇਲ ਵਿੱਚ ਵਿਧੀ indexOf ਢੰਗ. ਇਸ ਵਿਧੀ ਵਿੱਚ ਐਰੇ ਉੱਤੇ ਦੁਹਰਾਉਣਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਅਤੇ ਸਿਰਫ਼ ਉਹ ਤੱਤ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਦੀ ਪਹਿਲੀ ਮੌਜੂਦਗੀ ਉਹਨਾਂ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਤੱਤ ਨੂੰ ਨਤੀਜੇ ਵਾਲੇ ਐਰੇ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਪ੍ਰਭਾਵੀ ਢੰਗ ਨਾਲ ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਇਆ ਗਿਆ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਐਰੇ 'ਤੇ ਵਿਚਾਰ ਕਰੋ [1, 2, 2, 3, 4, 4, 5, 0, 0]. ਵਰਤ ਕੇ array.filter((item, index) => array.indexOf(item) === index), ਤੁਸੀਂ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਪਹੁੰਚ ਇਸ ਗੱਲ ਦੀ ਜਾਂਚ ਕਰਕੇ ਕੰਮ ਕਰਦੀ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਤੱਤ ਦਾ ਸੂਚਕਾਂਕ ਉਸ ਤੱਤ ਦੇ ਪਹਿਲੇ ਮੌਜੂਦਗੀ ਸੂਚਕਾਂਕ ਦੇ ਸਮਾਨ ਹੈ। ਜੇਕਰ ਇਹ ਹੈ, ਤਾਂ ਤੱਤ ਵਿਲੱਖਣ ਹੈ ਅਤੇ ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ।