javascript - समझ - मैं जावास्क्रिप्ट में एक सरणी कैसे खाली करूं?




प्रपत्र एचटीएमएल (12)

आप अपने सरणी को "साफ़" होने की अनुमति देने के लिए इसे अपनी जावास्क्रिप्ट फ़ाइल में जोड़ सकते हैं:

Array.prototype.clear = function() {
    this.splice(0, this.length);
};

फिर आप इसे इस तरह इस्तेमाल कर सकते हैं:

var list = [1, 2, 3];
list.clear();

या यदि आप यह सुनिश्चित करना चाहते हैं कि आप कुछ नष्ट नहीं करते हैं:

if (!Array.prototype.clear) {
    Array.prototype.clear = function() {
       this.splice(0, this.length);
    };
}

बहुत से लोग सोचते हैं कि आपको मूल वस्तुओं (जैसे ऐरे) को संशोधित नहीं करना चाहिए, और मैं सहमत हूं। कृपया इसे संभालने का निर्णय लेने में सावधानी बरतें।

क्या सरणी खाली करने का कोई तरीका है और यदि संभवतः .remove() ?

उदाहरण के लिए,

A = [1,2,3,4];

मैं इसे कैसे खाली कर सकता हूं?


आप आसानी से ऐसा करने के लिए एक फ़ंक्शन बना सकते हैं, लंबाई बदल सकते हैं या इसे मूल ऐरे में भी पुन: उपयोग के लिए remove() फ़ंक्शन के रूप में जोड़ सकते हैं।

कल्पना करें कि आपके पास यह सरणी है:

var arr = [1, 2, 3, 4, 5]; //the array

ठीक है, बस इसे चलाएं:

arr.length = 0; //change the length

और नतीजा यह है:

[] //result

एक सरणी खाली करने के लिए आसान तरीका ...

लूप का भी उपयोग करना जरूरी नहीं है, लेकिन ऐसा करने का एक और तरीका है:

/* could be arr.pop() or arr.splice(0)
don't need to return as main array get changed */

function remove(arr) {
  while(arr.length) {
    arr.shift(); 
  }
}

ऐसे कठिन तरीके भी हैं जिनके बारे में आप सोच सकते हैं, उदाहरण के लिए ऐसा कुछ:

arr.splice(0, arr.length); //[]

तो यदि एआर में 5 आइटम हैं, तो यह 0 से 5 आइटमों को विभाजित करेगा, जिसका अर्थ है कि सरणी में कुछ भी नहीं रहेगा।

उदाहरण के लिए सरणी को फिर से असाइन करने जैसे अन्य तरीकों:

arr = []; //[]

यदि आप ऐरे फ़ंक्शंस को देखते हैं, तो ऐसा करने के कई अन्य तरीके हैं, लेकिन सबसे अधिक अनुशंसित लंबाई लंबाई बदल सकती है।

जैसा कि मैंने पहले स्थान पर कहा था, आप प्रोटोटाइप को भी हटा सकते हैं () क्योंकि यह आपके प्रश्न का उत्तर है। आप उपरोक्त विधियों में से एक को चुन सकते हैं और इसे जावास्क्रिप्ट में ऐरे ऑब्जेक्ट पर प्रोटोटाइप कर सकते हैं, जैसे कुछ:

Array.prototype.remove = Array.prototype.remove || function() {
  this.splice(0, this.length);
};

और आप इसे अपने जावास्क्रिप्ट एप्लिकेशन में किसी भी सरणी को खाली करने के लिए बस इसे इस तरह कॉल कर सकते हैं:

arr.remove(); //[]

थोड़ी देर के बारे में बहुत भ्रम और गलतफहमी है; उत्तर और टिप्पणियों दोनों में पॉप / शिफ्ट प्रदर्शन। जबकि / पॉप समाधान (जैसा कि अपेक्षित) सबसे खराब प्रदर्शन है । वास्तव में क्या हो रहा है कि सेटअप प्रत्येक नमूने के लिए केवल एक बार चलता है जो एक लूप में स्निपेट चलाता है। उदाहरण के लिए:

var arr = [];

for (var i = 0; i < 100; i++) { 
    arr.push(Math.random()); 
}

for (var j = 0; j < 1000; j++) {
    while (arr.length > 0) {
        arr.pop(); // this executes 100 times, not 100000
    }
}

मैंने एक नया परीक्षण बनाया है जो सही तरीके से काम करता है:

http://jsperf.com/empty-javascript-array-redux

चेतावनी: यहां तक ​​कि परीक्षण के इस संस्करण में आप वास्तव में वास्तविक अंतर नहीं देख सकते हैं क्योंकि सरणी क्लोनिंग अधिकांश परीक्षण समय लेती है। यह अभी भी दिखाता है कि splice सरणी को साफ़ करने का सबसे तेज़ तरीका है ( [] को ध्यान में नहीं ले रहा है क्योंकि यह सबसे तेज़ है जबकि यह वास्तव में मौजूदा सरणी को साफ़ नहीं कर रहा है)।


प्रदर्शन का परीक्षण:

http://jsperf.com/array-clear-methods/3

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest

मौजूदा सरणी को साफ़ करने के तरीके A :

विधि 1

(यह सवाल का मेरा मूल जवाब था)

A = [];

यह कोड वैरिएबल A को एक नई खाली सरणी में सेट करेगा। यह सही है अगर आपके पास मूल सरणी के संदर्भ कहीं भी नहीं हैं क्योंकि यह वास्तव में एक ब्रांड नई (खाली) सरणी बनाता है। आपको इस विधि से सावधान रहना चाहिए क्योंकि यदि आपने इस सरणी को किसी अन्य चर या संपत्ति से संदर्भित किया है, तो मूल सरणी अपरिवर्तित रहेगी। केवल इसका उपयोग करें यदि आप केवल सरणी को इसके मूल चर A द्वारा संदर्भित करते हैं।

यह भी सबसे तेज़ समाधान है।

यह कोड नमूना इस विधि का उपयोग करते समय आप जिस समस्या का सामना कर सकते हैं उसे दिखाता है:

var arr1 = ['a','b','c','d','e','f'];
var arr2 = arr1;  // Reference arr1 by another variable 
arr1 = [];
console.log(arr2); // Output ['a','b','c','d','e','f']

विधि 2 (जैसा मैथ्यू क्रूमली द्वारा suggested गया है)

A.length = 0

यह मौजूदा सरणी को इसकी लंबाई 0 पर सेट करके साफ़ कर देगा। कुछ ने तर्क दिया है कि यह जावास्क्रिप्ट के सभी कार्यान्वयन में काम नहीं कर सकता है, लेकिन यह पता चला है कि यह मामला नहीं है। यह ईसीएमएस्क्रिप्ट 5 में "सख्त मोड" का उपयोग करते समय भी काम करता है क्योंकि सरणी की लंबाई संपत्ति एक पढ़ने / लिखने की संपत्ति है।

विधि 3 ( Anthony द्वारा suggested गए अनुसार)

A.splice(0,A.length)

.splice() का उपयोग पूरी तरह से काम करेगा, लेकिन चूंकि .splice() फ़ंक्शन सभी हटाए गए आइटमों के साथ एक सरणी लौटाएगा, यह वास्तव में मूल सरणी की एक प्रति वापस करेगा। बेंचमार्क सुझाव देते हैं कि इसका प्रदर्शन पर कोई प्रभाव नहीं पड़ता है।

विधि 4 (जैसा कि tanguy_k द्वारा tanguy_k )

while(A.length > 0) {
    A.pop();
}

यह समाधान बहुत संक्षिप्त नहीं है, और यह मूल उत्तर में संदर्भित पहले के बेंचमार्क के विपरीत, सबसे धीमा समाधान भी है।

प्रदर्शन

मौजूदा सरणी को साफ़ करने के सभी तरीकों में से, विधियों 2 और 3 प्रदर्शन में बहुत समान हैं और विधि 4 से बहुत तेज़ हैं। इस benchmark देखें।

जैसा कि नीचे दिए गए उनके answer में Diadistis द्वारा इंगित किया गया है, ऊपर वर्णित चार विधियों के प्रदर्शन को निर्धारित करने के लिए उपयोग किए जाने वाले मूल मानक त्रुटिपूर्ण थे। मूल बेंचमार्क ने साफ़ सरणी का पुन: उपयोग किया ताकि दूसरा पुनरावृत्ति एक सरणी को साफ़ कर दे जो पहले से खाली था।

निम्नलिखित बेंचमार्क इस दोष को हल करता है: benchmark । यह स्पष्ट रूप से दिखाता है कि विधियों # 2 (लंबाई संपत्ति) और # 3 (splice) सबसे तेज़ हैं (गिनती विधि # 1 नहीं जो मूल सरणी नहीं बदलती है)।

यह एक गर्म विषय और बहुत सारे विवाद का कारण रहा है। वास्तव में कई सही उत्तर हैं और क्योंकि इस उत्तर को बहुत लंबे समय तक स्वीकृत उत्तर के रूप में चिह्नित किया गया है, मैं यहां सभी विधियों को शामिल करूंगा। यदि आप इस उत्तर के लिए वोट देते हैं, तो कृपया उन अन्य उत्तरों को ऊपर उठाएं जिन्हें मैंने संदर्भित किया है।


यदि आप उपयोग कर रहे हैं

a = []; 

फिर आप किसी नए चर के संदर्भ में पहले से असाइन किए गए संदर्भ में नया सरणी संदर्भ निर्दिष्ट कर रहे हैं, तो यह उस सरणी को भी खाली नहीं करेगा और इसलिए कचरा कलेक्टर उस स्मृति को एकत्र नहीं करेगा।

पूर्व के लिए

var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];

या

a.length = 0;

जब हम a.length निर्दिष्ट a.length , हम केवल सरणी की सीमाओं को रीसेट कर रहे हैं और बाकी सरणी तत्वों के लिए स्मृति कचरा कलेक्टर द्वारा जोड़ा जाएगा।

इन दो समाधानों के बजाय बेहतर हैं।

a.splice(0,a.length)

तथा

while(a.length > 0) {
    a.pop();
}

Kenshou.html द्वारा पिछले उत्तर के अनुसार, दूसरी विधि तेज है।


यदि आप स्थिरांक का उपयोग करते हैं तो आपके पास कोई विकल्प नहीं है:

const numbers = [1, 2, 3]

आप फिर से हस्ताक्षर नहीं कर सकते:

numbers = []

आप केवल छेड़छाड़ कर सकते हैं:

numbers.length = 0

यदि आपको मूल सरणी रखने की आवश्यकता है क्योंकि आपके पास अन्य संदर्भ हैं जिन्हें अद्यतन भी किया जाना चाहिए, तो आप इसकी लंबाई शून्य पर सेट करके एक नई सरणी बनाये बिना इसे साफ़ कर सकते हैं:

A.length = 0;

किसी सरणी के वर्तमान स्मृति स्थान को रिक्त करने के लिए: 'myArray.length = 0' या 'myArray.pop() UN-till its length is 0'

  • length : आप किसी भी समय किसी सरणी को छोटा करने के लिए लंबाई की संपत्ति सेट कर सकते हैं। जब आप अपनी लंबाई संपत्ति को बदलकर एक सरणी का विस्तार करते हैं, तो वास्तविक तत्वों की संख्या बढ़ जाती है।
  • pop() : पॉप विधि एक सरणी से अंतिम तत्व को हटा देती है और लौटाती है जो हटाए गए मान को वापस लाती है।
  • shift() : शिफ्ट विधि तत्व को शून्य सूचकांक पर हटा देती है और मूल्यों को लगातार सूचकांक में बदल देती है, फिर हटाए गए मान को वापस कर देती है।

उदाहरण:

var arr = ['77'];
arr.length = 20;
console.log("Increasing : ", arr); // (20) ["77", empty × 19]
arr.length = 12;
console.log("Truncating : ", arr); // (12) ["77", empty × 11]

var mainArr = new Array();
mainArr = ['1', '2', '3', '4'];

var refArr = mainArr;
console.log('Current', mainArr, 'Refered', refArr);

refArr.length = 3;
console.log('Length: ~ Current', mainArr, 'Refered', refArr);

mainArr.push('0');
console.log('Push to the End of Current Array Memory Location \n~ Current', mainArr, 'Refered', refArr);

mainArr.poptill_length(0);
console.log('Empty Array \n~ Current', mainArr, 'Refered', refArr);

Array.prototype.poptill_length = function (e) {
  while (this.length) {
    if( this.length == e ) break;

    console.log('removed last element:', this.pop());
  }
};
  • Array Array Array constructor या array literal का उपयोग करके नई मेमोरी लोकेशन के साथ एक ऐरे बनाएं।

    mainArr = []; // a new empty array is addressed to mainArr.
    
    var arr = new Array('10'); // Array constructor
    arr.unshift('1'); // add to the front
    arr.push('15'); // add to the end
    console.log("After Adding : ", arr); // ["1", "10", "15"]
    
    arr.pop(); // remove from the end
    arr.shift(); // remove from the front
    console.log("After Removing : ", arr); // ["10"]
    
    var arrLit = ['14', '17'];
    console.log("array literal « ", indexedItem( arrLit ) ); // {0,14}{1,17}
    
    function indexedItem( arr ) {
        var indexedStr = "";
        arr.forEach(function(item, index, array) {
            indexedStr += "{"+index+","+item+"}";
            console.log(item, index);
        });
        return indexedStr;
    }
    
  • slice() : स्लाइस फ़ंक्शन का उपयोग करके हमें मूल मेमोरी के तत्वों की एक उथली प्रतिलिपि मिलती है, जिसमें नए मेमोरी एड्रेस होते हैं, ताकि क्लोनएआरआर पर कोई भी संशोधन वास्तविक | मूल सरणी को प्रभावित न करे।

    var shallowCopy = mainArr.slice(); // this is how to make a copy
    
    var cloneArr = mainArr.slice(0, 3); 
    console.log('Main', mainArr, '\tCloned', cloneArr);
    
    cloneArr.length = 0; // Clears current memory location of an array.
    console.log('Main', mainArr, '\tCloned', cloneArr);
    

A.splice(0);

मैंने बस कुछ कोड पर ऐसा किया है जिस पर मैं काम कर रहा हूं। यह सरणी को मंजूरी दे दी।


Jan के शुरुआती सुझाव के एक संशोधित संस्करण का प्रयोग करें:

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}

अगर आपको कोणीय 2+ फॉर्मएरे खाली करने की आवश्यकता है तो नीचे प्रयोग करें।

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}




arrays