जावास्क्रिप्ट में सरणी से तत्व कैसे निकालें?

Question

var arr = [1,2,3,5,6];

पहला तत्व निकालें

मैं सरणी का पहला तत्व निकालना चाहता हूं ताकि यह बन जाए:

var arr = [2,3,5,6];

दूसरा तत्व निकालें

इस प्रश्न का विस्तार करने के लिए, क्या होगा अगर मैं सरणी के दूसरे तत्व को निकालना चाहता हूं ताकि यह बन जाए:

var arr = [1,3,5,6];

Comments

slice(start, end)नहीं 'how_many_to_remove'

— seanjacob

@Ped arr.unshift () does not REMOVE, लेकिन "सरणी के आरंभ में एक या एक से अधिक तत्व जोड़ता है"

— साइको brm

@seanjacob यह मुझे spliceनहीं sliceलगता है।

— अनिमेश सिंह

Answer 1

अधिक लचीले समाधान के लिए, splice()फ़ंक्शन का उपयोग करें । यह आपको इंडेक्स वैल्यू के आधार पर किसी ऐरे में किसी भी आइटम को हटाने की अनुमति देता है:

var indexToRemove = 0;
var numberToRemove = 1;

arr.splice(indexToRemove, numberToRemove);

Comments

और अनुवर्ती प्रश्न: arr.splice(1,1)दूसरे तत्व के लिए।

— स्लीपबेटमैन

मैं splice()अधिक पसंद करता हूं shift()क्योंकि यह अधिक लचीला है। मैं भविष्य में कुछ अलग करना चाहता हूं, और हमेशा नहीं कि मैं केवल एक तत्व, या यहां तक ​​कि पहला तत्व निकालना चाहता हूं।

— गैब्रियल मैकएडम्स

यदि आप Google से यहां आते हैं: गेब्रियल इस उत्तर को पसंद करता है, लेकिन आपको पता होना चाहिए कि शिफ्ट () भी है, जोसेफ का जवाब देखें।

— SHernandez

Answer 2

shift()आपकी स्थिति के लिए आदर्श है। shift()किसी सरणी से पहला तत्व निकालता है और उस तत्व को वापस करता है। यह विधि सरणी की लंबाई बदलती है।

array = [1, 2, 3, 4, 5];

array.shift(); // 1

array // [2, 3, 4, 5]

Comments

यह काम करता है, लेकिन केवल सरणी में पहले तत्व को हटा देगा।

— गेब्रियल मैकएडम्स

@ गैब्रिएल: बिल्कुल ऐसा सवाल नहीं था? मैं पसंद shift()करता हूं splice(..., ...)क्योंकि यह अधिक स्पष्ट, प्रत्यक्ष है।

— ब्रूनो रीस

सुधार: यह पहला तत्व देता है, न कि एक नया सरणी पहला तत्व, जो आपके द्वारा दिए गए लिंक के अनुसार है :)

— DanH

हालांकि कोड उदाहरण सही है, विवरण भ्रामक है: (ए) जैसा कि @DHH बताते हैं, यह पहला तत्व है जो वापस आ गया है , और (बी) इनपुट सरणी को संशोधित करने वाले तथ्य को स्पष्ट नहीं किया गया है। इसलिए, पेड का जवाब बेहतर है।

— mklement0

shiftजब तक आप बड़ी सूचियाँ jsperf.com/splice-vs-shift3 और jsperf.com/splice-vs-shift2

— kcathode

Answer 3

Array.prototype.shiftविधि एक सरणी से पहले तत्व निकाल देता है, और यह देता है। यह मूल सरणी को संशोधित करता है।

var a = [1,2,3]
// [1,2,3]
a.shift()
// 1
a
//[2,3]

Comments

यूसुफ सिल्वाशी के उत्तर पर एक महान सुधार - विवरण और कोड के बीच कोई असंगति नहीं।

— mklement0

Answer 4

arr.slice(begin[,end])

गैर विनाशकारी है, ब्याह और बदलाव आपके मूल सरणी को संशोधित करेगा

Comments

गैर उत्परिवर्तन के लिए हाँ। यह अधिक दिखाई देना चाहिए।

— यूजर

Answer 5

जावास्क्रिप्ट एररेज़ में मनमाने पदों पर तत्वों को सम्मिलित करने और हटाने के बारे में एक छोटा लेख लिखा।

यहां किसी भी स्थिति से एक तत्व को निकालने के लिए छोटा स्निपेट है। यह जावास्क्रिप्ट में ऐरे क्लास को बढ़ाता है और रिमूव (इंडेक्स) मेथड जोड़ता है।

// Remove element at the given index
Array.prototype.remove = function(index) {
    this.splice(index, 1);
}

तो अपने उदाहरण में पहला आइटम निकालने के लिए, arr.remove () कॉल करें:

var arr = [1,2,3,5,6];
arr.remove(0);

दूसरा आइटम निकालने के लिए,

arr.remove(1);

यहां ऐरे क्लास के लिए सम्मिलित और हटाने के तरीकों के साथ एक छोटा लेख है ।

अनिवार्य रूप से यह ब्याह का उपयोग करने वाले अन्य उत्तरों से अलग नहीं है, लेकिन नाम spliceगैर-सहज ज्ञान युक्त है, और यदि आपके पास आपके आवेदन में सभी कॉल हैं, तो यह कोड को पढ़ने के लिए कठिन बना देता है।

Answer 6

शायद कुछ इस तरह:

arr=arr.slice(1);

Answer 7

दूसरों के जवाब महान हैं, मैं सिर्फ ES6ऐरे फ़ंक्शन के साथ एक वैकल्पिक समाधान जोड़ना चाहता था filter:।

filter() उन तत्वों के साथ एक नया सरणी बनाता है जो किसी मौजूदा सरणी से दिए गए मापदंड के अंतर्गत आते हैं।

तो आप आसानी से इसका उपयोग उन वस्तुओं को हटाने के लिए कर सकते हैं जो मानदंड पारित नहीं करते हैं। इस फ़ंक्शन का लाभ यह है कि आप इसे जटिल सरणी पर उपयोग कर सकते हैं न कि केवल स्ट्रिंग और संख्या।

कुछ उदाहरण :

पहला तत्व निकालें :

// Not very useful but it works
function removeFirst(element, index) {
  return index > 0;
}
var arr = [1,2,3,5,6].filter(removeFirst); // [2,3,4,5,6]

दूसरा तत्व निकालें :

function removeSecond(element, index) {
  return index != 1;
}
var arr = [1,2,3,5,6].filter(removeSecond); // [1,3,4,5,6]

विषम तत्व निकालें :

function removeOdd(element, index) {
  return !(element % 2);
}
var arr = [1,2,3,5,6].filter(removeOdd); [2,4,6]

आइटम नहीं स्टॉक में निकालें

const inventory = [
  {name: 'Apple', qty: 2},
  {name: 'Banana', qty: 0},
  {name: 'Orange', qty: 5}
];

const res = inventory.find( product => product.qty > 0);

Answer 8

आप आराम ऑपरेटर के साथ ईएस 6 डिस्ट्रक्ट्यूरिंग असाइनमेंट सुविधा का उपयोग कर सकते हैं। एक अल्पविराम इंगित करता है कि आप तत्व और शेष (... गिरफ्तार) ऑपरेटर को कैसे हटाना चाहते हैं जो आपको सरणी के शेष तत्वों को देने के लिए है।

const source = [1,2,3,5,6];

function removeFirst(list) {
   var  [, ...arr] = list;
   return arr;
}
const arr = removeFirst(source);
console.log(arr); // [2, 3, 5, 6]
console.log(source); // [1, 2, 3, 5, 6]

Answer 9

Array.splice()दिलचस्प संपत्ति है कि कोई पहला तत्व निकालने के लिए इसका इस्तेमाल नहीं कर सकता है। इसलिए, हमें इसका सहारा लेना चाहिए

function removeAnElement( array, index ) {
    index--;

    if ( index === -1 ) {
        return array.shift();
    } else {
        return array.splice( index, 1 );
    }
}

Comments

Array.splice (0,1) पहला तत्व निकालता है। यहाँ हर दूसरे उत्तर के अनुसार, और developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… के अनुसार । इसके अलावा, कोई पहला तत्व निकालने के लिए -1 पास क्यों करेगा? वे 0 पास नहीं होगा?

— पत्थर का

@skypecakes मैं 0 वें इंडेक्स पर ब्याह की वैधता के बारे में बात नहीं कर सकता, लेकिन यहां उस चेक से पहले इंडेक्स घटाया जाता है, इसलिए इसे 0 में पास होने पर 0 हो जाता।

— जेक टी।

हाँ, यह निश्चित रूप से पहले तत्व को हटा सकता है। मैंने इसे यहाँ परीक्षण किया: jsfiddle.net/sijpkes/d87rcLob/2

— sijpkes

Answer 10

टाइपस्क्रिप्ट समाधान जो मूल सरणी को म्यूट नहीं करता है

function removeElementAtIndex<T>(input: T[], index: number) {
  return input.slice(0, index).concat(input.slice(index + 1));
}

Answer 11

एक ऐरे से एक तत्व को हटाने के कई तरीके हैं। मुझे सबसे नीचे इस्तेमाल किए गए विकल्पों को इंगित करने दें। मैं यह उत्तर इसलिए लिख रहा हूं क्योंकि मुझे इन सभी विकल्पों में से क्या उपयोग करना है, इसका उचित कारण नहीं मिल रहा है। प्रश्न का उत्तर विकल्प 3 ( ब्याह () ) है।

1) SHIFT () - मूल ऐरे से पहला तत्व निकालें और पहला तत्व लौटाएं

Array.prototype.shift () के लिए संदर्भ देखें । इसका उपयोग केवल तभी करें जब आप पहला तत्व निकालना चाहते हैं, और केवल तभी जब आप मूल सरणी को बदलने के साथ ठीक हों।

const array1 = [1, 2, 3];

const firstElement = array1.shift();

console.log(array1);
// expected output: Array [2, 3]

console.log(firstElement);
// expected output: 1

2) SLICE () - एरे की कॉपी लौटाता है, जो एक इंडेक्स इंडेक्स और एक एंड इंडेक्स द्वारा अलग किया जाता है

Array.prototype.slice () के लिए संदर्भ देखें । आप इस विकल्प से कोई विशिष्ट तत्व नहीं निकाल सकते। आप केवल मौजूदा सरणी का टुकड़ा ले सकते हैं और सरणी का एक निरंतर भाग प्राप्त कर सकते हैं। यह आपके द्वारा निर्दिष्ट अनुक्रमित से सरणी को काटने जैसा है। मूल सरणी प्रभावित नहीं होती है।

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

3) SPLICE () - विशिष्ट इंडेक्स पर तत्वों को हटाने या बदलने के द्वारा ऐरे की सामग्री बदलें।

Array.prototype.splice () के लिए संदर्भ देखें । ब्याह () विधि मौजूदा तत्वों को हटाने या बदलने और जगह में नए तत्वों को जोड़कर एक सरणी की सामग्री को बदल देती है। अद्यतन सरणी देता है। मूल सरणी अपडेट हो जाती है।

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]

Answer 12

आप इसे कम करने के साथ भी कर सकते हैं:

let arr = [1, 2, 3]

arr.reduce((xs, x, index) => {
        if (index == 0) {
            return xs
        } else {
            return xs.concat(x)
        }
    }, Array())

// Or if you like a oneliner
arr.reduce((xs, x, index) => index == 0 ? xs : xs.concat(x), Array())