मैं जावास्क्रिप्ट में एक सरणी कैसे खाली कर सकता हूँ?
जवाबों:
मौजूदा सरणी को खाली करने के तरीके A:
विधि 1
(यह प्रश्न का मूल उत्तर था)
A = [];यह कोड चर 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 (as मैथ्यू क्रुमले द्वारा सुझाई गई )
A.length = 0यह इसकी लंबाई को 0. पर सेट करके मौजूदा सरणी को साफ कर देगा। कुछ ने तर्क दिया है कि यह जावास्क्रिप्ट के सभी कार्यान्वयन में काम नहीं कर सकता है, लेकिन यह पता चलता है कि यह मामला नहीं है। यह ECMAScript 5 में "सख्त मोड" का उपयोग करते समय भी काम करता है क्योंकि किसी सरणी की लंबाई गुण पढ़ने / लिखने की संपत्ति है।
विधि 3 (जैसा कि सुझाव दिया गया है कि एंथनी द्वारा गया है )
A.splice(0,A.length)का उपयोग करना .splice()पूरी तरह से काम करेगा, लेकिन चूंकि .splice()फ़ंक्शन सभी हटाए गए आइटमों के साथ एक सरणी लौटाएगा, यह वास्तव में मूल सरणी की एक प्रति वापस कर देगा। बेंचमार्क बताते हैं कि इससे प्रदर्शन पर कोई प्रभाव नहीं पड़ता है।
विधि 4 (जैसा कि सुझाव दिया गया है tanguy_k )
while(A.length > 0) {
A.pop();
}यह समाधान बहुत रसीला नहीं है, और यह सबसे धीमा समाधान भी है, जो मूल उत्तर में पहले के बेंचमार्क के विपरीत है।
प्रदर्शन
मौजूदा सरणी को साफ़ करने के सभी तरीकों में से , विधि 2 और 3, प्रदर्शन में बहुत समान हैं और विधि की तुलना में बहुत तेज़ हैं। यह बेंचमार्क देखें । ।
जैसा कि उनके उत्तर में डायडिस्टिस ने बताया है नीचे दिए गए , मूल बेंचमार्क जो ऊपर वर्णित चार तरीकों के प्रदर्शन को निर्धारित करने के लिए उपयोग किए गए थे। मूल बेंचमार्क ने साफ़ किए गए सरणी का पुन: उपयोग किया इसलिए दूसरा पुनरावृत्ति एक सरणी को साफ़ कर रहा था जो पहले से ही खाली था।
निम्नलिखित बेंचमार्क इस दोष को ठीक करता है: http://jsben.ch/#/hyj65 । यह स्पष्ट रूप से दिखाता है कि तरीके # 2 (लंबाई संपत्ति) और # 3 (ब्याह) सबसे तेज़ हैं (मतगणना विधि # 1 जो मूल सरणी को नहीं बदलता है)।
यह एक गर्म विषय रहा है और बहुत विवाद का कारण रहा है। वास्तव में कई सही उत्तर हैं और क्योंकि यह उत्तर बहुत लंबे समय के लिए स्वीकृत उत्तर के रूप में चिह्नित किया गया है, मैं यहां सभी विधियों को शामिल करूंगा। यदि आप इस उत्तर के लिए मतदान करते हैं, तो कृपया अन्य उत्तरों को भी देखें जिन्हें मैंने संदर्भित किया है।
while (A.length) { A.pop(); }, कोई ज़रूरत नहीं है> 0
> 0अधिक पठनीय IMHO है। और दोनों के बीच कोई प्रदर्शन अंतर नहीं है।
bजाने के बाद भी पुराने सरणी का संदर्भ रखता है a। cऔर dउसी सरणी को संदर्भित करना जारी रखें। इसलिए आउटपुट में अंतर अपेक्षित है।
while(A.pop())सरणी में कोई आइटम गलत है तो आप उपयोग नहीं कर सकते । उदाहरण के लिए A = [2, 1, 0, -1, -2] का परिणाम A के बराबर होगा [2, 1]। यहां तक कि while(A.pop() !== undefined)काम नहीं करता है क्योंकि आप मूल्यों में से एक के रूप में अपरिभाषित के साथ एक सरणी रख सकते हैं। शायद क्यों संकलक ने इसे अनुकूलित नहीं किया है।
यदि आपको मूल सारणी रखने की आवश्यकता है क्योंकि आपके पास इसके अन्य संदर्भ हैं जिन्हें अद्यतन भी किया जाना चाहिए, तो आप इसकी लंबाई शून्य पर सेट करके एक नया सरणी बनाए बिना इसे खाली कर सकते हैं:
A.length = 0;myarray.push(whatever)इसे कहते हैं तो यह लंबाई में एक जोड़ देता है। इसलिए लंबाई सेट करना सरणी को छोटा करता है, लेकिन यह स्थायी नहीं है।
lengthएक विशेष संपत्ति है, लेकिन केवल पढ़ा नहीं जाता है, इसलिए यह अभी भी काम करेगा।
यहाँ सबसे तेजी से काम कर रहा कार्यान्वयन , जबकि एक ही सरणी रखने ( "परिवर्तनशील"):
function clearArray(array) {
while (array.length) {
array.pop();
}
}FYI करें इसे सरल नहीं किया जा सकता है while (array.pop()) : परीक्षण विफल हो जाएंगे।
FYI करें मानचित्र और सेट परिभाषित clear(), यह Array केclear() लिए तार्किक प्रतीत होगा भी।
टाइपस्क्रिप्ट संस्करण:
function clearArray<T>(array: T[]) {
while (array.length) {
array.pop();
}
}इसी परीक्षण:
describe('clearArray()', () => {
test('clear regular array', () => {
const array = [1, 2, 3, 4, 5];
clearArray(array);
expect(array.length).toEqual(0);
expect(array[0]).toEqual(undefined);
expect(array[4]).toEqual(undefined);
});
test('clear array that contains undefined and null', () => {
const array = [1, undefined, 3, null, 5];
clearArray(array);
expect(array.length).toEqual(0);
expect(array[0]).toEqual(undefined);
expect(array[4]).toEqual(undefined);
});
});यहां अपडेट किए गए jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152
Array.prototypeऔर वह कुछ अलग कर रही है, तो आपके पूरे कोड [].clear()में कुछ गलत था। यह डिबग करने के लिए मजेदार नहीं होगा। तो, सामान्य संदेश है: ग्लोबल्स को संशोधित न करें।
function clear(arr) { while(arr.length) arr.pop(); }, फिर के clear(arr)बजाय के साथ स्पष्ट सरणियाँ arr.clear()।
.splice()और .length=0। बेंचमार्क सही नहीं थे। देखिये मेरा अपडेटेड जवाब।
एक अधिक क्रॉस-ब्राउज़र अनुकूल और अधिक इष्टतम समाधान नीचे spliceए के रूप में ए की सामग्री को खाली करने के लिए विधि का उपयोग करना होगा :
A.splice(0, A.length);
spliceकरता है, सरणी को संशोधित करता है और हटाए गए प्रविष्टियों को वापस करता है। डॉक्स पहले पढ़ें: developer.mozilla.org/en-US/docs/JavaScript/Reference/…
A.splice(0, A.length),0;। यह 0जैसा A.length = 0;होगा वैसा ही एक रिटर्न वैल्यू छोड़ देगा। परिणामी सरणी अभी भी बनाई गई है और स्क्रिप्ट को धीमा चलाने का कारण बनना चाहिए : ( jsperf ~ 56% धीमी)। ब्राउज़र कार्यान्वयन इसे प्रभावित करेगा, हालांकि मुझे कोई कारण नहीं दिखता कि spliceसेटिंग से अधिक तेज़ क्यों होगा length।
A.splice(0)काम भी करता है।
जिन उत्तरों का कोई कम नहीं है, जो अब तक 2739 अपवित्र हैं, वे भ्रामक और गलत हैं।
सवाल यह है: "आप अपने मौजूदा सरणी को कैसे खाली करते हैं?" जैसे के लिए A = [1,2,3,4]।
"
A = []उत्तर है" कहना अज्ञानी और बिल्कुल गलत है।[] == []है झूठी ।इसका कारण यह है कि ये दो सरणियाँ दो अलग-अलग हैं, अलग-अलग वस्तुएं, अपनी स्वयं की दो पहचानों के साथ, डिजिटल दुनिया में अपना स्थान, प्रत्येक अपने दम पर।
मान लीजिए कि आपकी मां आपसे कचरा खाली करने के लिए कहती है।
- आप एक नए रूप में नहीं लाते हैं जैसे कि आपने वही किया है जो आपसे मांगा गया है।
- इसके बजाय, आप कचरा खाली कर सकते हैं।
- आप भरे हुए को नए खाली डिब्बे से बदल नहीं सकते हैं, और आप भरे हुए कैन से "A" का लेबल नहीं लगाते हैं और इसे नए आकार में चिपका सकते हैं।
A = [1,2,3,4]; A = [];
किसी सरणी वस्तु को खाली करना सबसे आसान काम है:
A.length = 0;इस तरह, "ए" के तहत न केवल खाली है, बल्कि नए रूप में भी साफ है!
इसके अलावा, जब तक कैन खाली न हो, आपको हाथ से कचरा हटाने की आवश्यकता नहीं है! आपको मौजूदा एक को पूरी तरह से खाली करने के लिए कहा गया था, पूरी तरह से, एक मोड़ में, कचरा उठाने के लिए नहीं जब तक कि खाली नहीं हो सकता, जैसे कि:
while(A.length > 0) { A.pop(); }न ही, अपने बाएं हाथ को कूड़े के तल पर रखने के लिए, अपनी सामग्री को ऊपर खींचने में सक्षम होने के लिए शीर्ष पर अपने दाहिने हाथ से पकड़ना:
A.splice(0, A.length);
नहीं, आपको इसे खाली करने के लिए कहा गया था:
A.length = 0;यह एकमात्र कोड है जो किसी दिए गए जावास्क्रिप्ट सरणी की सामग्री को सही ढंग से खाली करता है।
A(n) = A.splice( 0, A.length );स्थिति में है जब आपको अपनी पिछली सामग्री का बैकअप लेना होगा। पीएस Array.lengthएक पढ़ा-लिखा संपत्ति \ विधि है, अगर आपने उस मूल तथ्य को याद नहीं किया है। मतलब, आप इसे एक नई लंबाई तक विस्तारित कर सकते हैं, आप इसे अपनी इच्छित लंबाई के हिसाब से ट्रिम कर सकते हैं, और दूसरों के बीच आप इसकी लंबाई को छोटा करके सभी सदस्यों को त्याग सकते हैं। यह सरणी का स्विस-चाकू है।
प्रदर्शन का परीक्षण:
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आप इसे अपनी जावास्क्रिप्ट फ़ाइल में जोड़ सकते हैं ताकि आपके सरणियों को "साफ़" किया जा सके:
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);
};
}बहुत से लोग सोचते हैं कि आपको देशी वस्तुओं (जैसे ऐरे) को संशोधित नहीं करना चाहिए, और मैं सहमत होने के लिए इच्छुक हूं। कृपया यह तय करने में सावधानी बरतें कि इसे कैसे संभालना है।
clearकुंजी सहित शुरू होगा ?
कुछ समय के बारे में बहुत भ्रम और गलत सूचना है, उत्तर और टिप्पणियों दोनों में पॉप / शिफ्ट प्रदर्शन। जबकि / पॉप समाधान में सबसे खराब प्रदर्शन होता है । वास्तव में क्या हो रहा है कि सेटअप केवल एक बार प्रत्येक नमूने के लिए चलता है जो स्निपेट को लूप में चलाता है। उदाहरण के लिए:
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सरणी को साफ़ करने का सबसे तेज़ तरीका है (ध्यान []में नहीं लेने के कारण, जबकि यह सबसे तेज़ है, यह वास्तव में मौजूदा सरणी को साफ़ नहीं कर रहा है)।
यदि आप मेमोरी आवंटन में रुचि रखते हैं, तो आप क्रोम देव टूल्स के टाइमलाइन टैब के संयोजन में इस jsfiddle जैसी किसी चीज का उपयोग करके प्रत्येक दृष्टिकोण की तुलना कर सकते हैं । आप 'क्लियरिंग' एरे के बाद कचरा संग्रह को बाध्य करने के लिए नीचे कूड़ेदान के चिह्न का उपयोग करना चाहेंगे। यह आपको अपनी पसंद के ब्राउज़र के लिए अधिक निश्चित उत्तर देना चाहिए। यहाँ बहुत सारे उत्तर पुराने हैं और मैं उन पर भरोसा नहीं करता, बल्कि @ tanguy_k के उत्तर के रूप में परीक्षण करता हूँ।
(पूर्वोक्त टैब पर एक परिचय के लिए आप यहां देख सकते हैं )
Stackoverflow मुझे jsfiddle की नकल करने के लिए मजबूर करता है तो यहाँ है:
<html>
<script>
var size = 1000*100
window.onload = function() {
document.getElementById("quantifier").value = size
}
function scaffold()
{
console.log("processing Scaffold...");
a = new Array
}
function start()
{
size = document.getElementById("quantifier").value
console.log("Starting... quantifier is " + size);
console.log("starting test")
for (i=0; i<size; i++){
a[i]="something"
}
console.log("done...")
}
function tearDown()
{
console.log("processing teardown");
a.length=0
}
</script>
<body>
<span style="color:green;">Quantifier:</span>
<input id="quantifier" style="color:green;" type="text"></input>
<button onclick="scaffold()">Scaffold</button>
<button onclick="start()">Start</button>
<button onclick="tearDown()">Clean</button>
<br/>
</body>
</html>और आपको ध्यान रखना चाहिए कि यह सरणी तत्वों के प्रकार पर निर्भर हो सकता है, क्योंकि जावास्क्रिप्ट अन्य वस्तुओं की तुलना में अन्य आदिम प्रकारों की तुलना में अलग-अलग तार का प्रबंधन करता है। प्रकार प्रभावित हो सकता है कि क्या होता है।
आप आसानी से ऐसा करने के लिए एक फ़ंक्शन बना सकते हैं, लंबाई बदल सकते हैं या फिर इसे पुनः उपयोग के लिए फ़ंक्शन के रूप में मूल सरणी में जोड़ सकते हैं 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(); //[]Array.prototype.clear = function() {
this.length = 0;
};और इसे कॉल करें: array.clear();
A.splice(0);
मैंने अभी कुछ कोड पर काम किया है जिस पर मैं काम कर रहा हूं। इससे व्यूह साफ हो गया।
यदि आप उपयोग कर रहे हैं
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.splice(0,a.length)तथा
while(a.length > 0) {
a.pop();
}Kenshou.html द्वारा पिछले उत्तर के अनुसार, दूसरा तरीका तेज़ है।
a.length, मैं यह नहीं देखता कि यह नया उत्तर धागे में क्या जोड़ता है?
a.length=0;? उन इंजनों के लिए कार्य a.length=500;और कैसे होगा a.length=4;?
var a = [1]; var b = a; a.length = 0; console.log(b)प्रिंट Array [ ]करता है, इसलिए ऐसा नहीं लगता कि यह मेरे लिए एक नई सरणी बना रहा है।
यदि आप स्थिरांक का उपयोग करते हैं तो आपके पास कोई विकल्प नहीं है:
const numbers = [1, 2, 3]आप पुन: असाइन नहीं कर सकते:
numbers = []आप केवल काट सकते हैं:
numbers.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());
}
};new 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);
length = ?बजाय कहना चाहिए था length।
मुझे आश्चर्य है कि किसी ने भी अभी तक इसका सुझाव नहीं दिया है:
let xs = [1,2,3,4];
for (let i in xs)
delete xs[i];यह अन्य समाधानों से काफी भिन्न अवस्था में एक सरणी देता है। एक मायने में, सरणी को 'खाली' कर दिया गया है:
xs
=> Array [ <4 empty slots> ]
[...xs]
=> Array [ undefined, undefined, undefined, undefined ]
xs.length
=> 4
xs[0]
=> ReferenceError: reference to undefined property xs[0]आप के साथ [,,,,]या बराबर सरणी का उत्पादन कर सकते हैंArray(4)
यदि आपको कोणीय 2+ फॉर्मअरे को खाली करने की आवश्यकता है तो नीचे का उपयोग करें।
public emptyFormArray(formArray:FormArray) {
for (let i = formArray.controls.length - 1; i >= 0; i--) {
formArray.removeAt(i);
}
}