JavaScript એરેમાંથી ડુપ્લિકેટ્સ દૂર કરી રહ્યા છીએ

JavaScript માં એરેની વિશિષ્ટતાને સમજવી

JavaScript માં, ખાતરી કરવી કે એરેમાં માત્ર અનન્ય મૂલ્યો છે તે વિવિધ એપ્લિકેશનો માટે નિર્ણાયક બની શકે છે. જ્યારે આ હાંસલ કરવાની બહુવિધ રીતો છે, ત્યારે અમુક પદ્ધતિઓ ચોક્કસ પરિસ્થિતિઓમાં નિષ્ફળ થઈ શકે છે, જેમ કે શૂન્યની હાજરી.

આ લેખમાં, અમે એરેમાંથી ડુપ્લિકેટ્સ દૂર કરવા માટે પ્રોટોટાઇપ સ્ક્રિપ્ટનું પરીક્ષણ કરીશું. અમે શૂન્ય મૂલ્યો સાથે તેની સમસ્યાઓને ઓળખીશું અને વધુ વિશ્વસનીય ઉકેલ સાથે તેની તુલના કરીશું. આ તફાવતોને સમજીને, તમે JavaScriptમાં એરેની વિશિષ્ટતાને વધુ અસરકારક રીતે કેવી રીતે હેન્ડલ કરવી તે શીખી શકશો.

JavaScript એરેમાં ડુપ્લિકેટ્સ કેવી રીતે દૂર કરવી

અમે પ્રસ્તુત કરેલી પ્રથમ સ્ક્રિપ્ટનો ઉપયોગ કરે છે new Set() એરે વિશિષ્ટતાની ખાતરી કરવા માટે JavaScript માં ઑબ્જેક્ટ. એ Set મૂલ્યોનો સંગ્રહ છે જ્યાં દરેક મૂલ્ય અનન્ય હોવું જોઈએ. a માં એરે પસાર કરીને 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), તમે ડુપ્લિકેટ મૂલ્યોને ફિલ્ટર કરી શકો છો. વર્તમાન તત્વની અનુક્રમણિકા તે તત્વની પ્રથમ ઘટના અનુક્રમણિકા સમાન છે કે કેમ તે તપાસીને આ અભિગમ કાર્ય કરે છે. જો તે છે, તો તત્વ અનન્ય છે અને નવા એરેમાં શામેલ છે.