मैं टाइपस्क्रिप्ट में एक सरणी आइटम कैसे निकालूं?

404

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

arrays typescript collections

— टिम बादाम
स्रोत

639

जैसा कि आप जावास्क्रिप्ट में होगा।

delete myArray[key];

ध्यान दें कि यह तत्व को सेट करता है undefined।

Array.prototype.spliceसमारोह का उपयोग करने के लिए बेहतर :

const index = myArray.indexOf(key, 0);
if (index > -1) {
   myArray.splice(index, 1);
}

— blorkfish
स्रोत

8

आप इसमें एक प्रकार जोड़ सकते हैं! var index: number = myArray.indexOf(key, 0);

— कोरेथन

17

@CorayThan निश्चित रूप से इसे indexOfरिटर्न के रूप में अनुमानित रूप से टाइप किया जाएगा number?

— क्रिस

5

@ क्रिस इस सरल मामले में स्पष्ट होने के बावजूद, यदि आप स्पष्ट रूप से प्रत्येक चर के लिए एक प्रकार को परिभाषित करते हैं, तो यह आपको तेजी से कीड़े का निदान करने में मदद कर सकता है। आप indexपहले से ही एक से अधिक बार उपयोग कर रहे हैं और उन स्थानों में से एक ( splice) एक नंबर देखना चाहते हैं या आपको एक त्रुटि मिलेगी। वर्तमान में कंपाइलर आपको वहां गलतियाँ करने से नहीं रोक सकता।

— जोकेम कूइजपर्स

33

@blorkfish यह उल्लेख करना अच्छा है कि यदि आपके पास वस्तुओं की सूची है, तो आप उपयोग कर सकते हैं var index = myArray.findIndex(x => x.prop==key.prop);।

— फ्रांसिस्को कैब्रल

6

@ Cirelli94 - आप एक पुराने धागे का जवाब दे रहे हैं, लेकिन आपके प्रश्न का उत्तर यह है कि किसी सरणी तत्व को हटाने से उसकी लंबाई या सरणी को पुनः अनुक्रमित नहीं किया जाता है। क्योंकि सरणियाँ जावास्क्रिप्ट में वस्तुएं हैं, delete myArr[2]वस्तुतः की संपत्ति 2 को हटा देती है myArr, जो इससे भिन्न भी है myArr[2] = undefined। इस कहानी का नैतिक सिर्फ spliceइस कार्य के लिए उपयोग करना है क्योंकि यह साइड इफेक्ट्स को भ्रमित किए बिना वांछित प्रभाव प्राप्त करने का एक सुरक्षित तरीका है।

— विंगलर २।

200

यदि सरणी वस्तुओं का प्रकार है, तो सबसे सरल तरीका है

let foo_object // Item to remove
this.foo_objects = this.foo_objects.filter(obj => obj !== foo_object);

— मलिक शहजाद
स्रोत

20

यह कुछ भी नहीं हटाता है यह बस फ़िल्टर करता है। यदि सूची को वास्तव में संशोधित करने की आवश्यकता है तो यह तरीका नहीं है।

— user573434

6

@ user573434 हाँ, आप सही हैं, जैसा कि नाम से संकेत मिलता है। लेकिन यह उस मामले में सरल दृष्टिकोण है जहां आप सफल डिलीट एप कॉल आदि पर किसी ऑब्जेक्ट को हटाना चाहते हैं

— मलिक शहजाद

3

यह एक अद्वितीय कुंजी संपत्ति के बिना वस्तुओं की एक सरणी पर मेरे लिए पूरी तरह से काम किया। @ user573434 फ़िल्टर विधि फ़िल्टर किए गए ऑब्जेक्ट के बिना एक नया सरणी देता है, इसलिए परिणामी सरणी में ऑब्जेक्ट हटा दिया गया है।

— जेसन

6

मुझे लगता है कि इसे एक वस्तु के रूप में वापस करने के लिए आपको ऐसा करना होगाthis.foo_objects = this.foo_objects.filter(obj => obj !== foo_object)[0];

— Roel

1

यह काम। बस 2 पंक्ति को ध्यान से पढ़ें। वह obj के साथ एक फिल्टर करता है! = foo_object और इसे मूल चर पर नियत करता है, इस प्रकार मूल सरणी को एक शून्य से फ़िल्टर किए गए foo_object से बदल देता है। आईडी के साथ वस्तुओं के एक सरणी के साथ इसका इस्तेमाल किया deleteById(id: string) { this.data = this.data.filter(d => d.id !== id); }, चेतावनी का सिर्फ एक शब्द, अगर Ids अद्वितीय नहीं हैं तो आप सभी को समान रूप से हटा देंगेid

— मार्कस

74

ES6 के साथ आप इस कोड का उपयोग कर सकते हैं:

removeDocument(doc){
   this.documents.forEach( (item, index) => {
     if(item === doc) this.documents.splice(index,1);
   });
}

— Idak
स्रोत

1

सरणी के संदर्भ को बदले बिना और विशिष्ट समानता को लागू करने की संभावना के साथ हटाने के लिए सबसे अच्छा समाधान अल्गोरिथम

— सिड

1

सर्वश्रेष्ठ उत्तर मिला है

— Gvs अखिल

1

ईएस

— नाथन बेक

2

आप यह भी उपयोग कर सकते हैं: this.documents.forEach ((आइटम, इंडेक्स, एरे) => {अगर (आइटम === डॉक) array.splice (इंडेक्स, 1);}); जो बहुत क्लीनर हो सकता है, खासकर जब नेस्टेड सरणियों के साथ काम कर रहा हो।

— CGundlach

20

यह उस के लिए मेरा समाधान है:

onDelete(id: number) {
    this.service.delete(id).then(() => {
        let index = this.documents.findIndex(d => d.id === id); //find index in your array
        this.documents.splice(index, 1);//remove element from array
    });

    event.stopPropagation();
}

— Butsaty
स्रोत

इस समाधान के बारे में क्या अच्छा है कि यह तब भी काम करेगा जब वस्तु समानता दो वस्तुओं को समान पहचानने में विफल हो।

— ब्रैड जॉनसन

18

आप spliceतत्वों को निकालने के लिए एक सरणी पर विधि का उपयोग कर सकते हैं ।

उदाहरण के लिए यदि आपके पास नाम के साथ एक सरणी है, arrतो निम्नलिखित का उपयोग करें:

arr.splice(2, 1);

इसलिए यहां इंडेक्स 2 वाला तत्व शुरुआती बिंदु होगा और तर्क 2 यह निर्धारित करेगा कि कितने तत्वों को हटाया जाना है।

यदि आप नाम के अंतिम तत्व को हटाना चाहते हैं arrतो ऐसा करें:

arr.splice(arr.length-1, 1);

यह हटाए गए अंतिम तत्व के साथ गिरफ्तार वापस आ जाएगा।

उदाहरण:

var arr = ["orange", "mango", "banana", "sugar", "tea"];
arr.splice(arr.length-1, 1)
console.log(arr); // return ["orange", "mango", "banana", "sugar"]

— आकाश विषगोपाल
स्रोत

1

केवल FYI करें, ब्याह विधि सरणी को संशोधित करता है (इसलिए इस मामले में अंतिम आइटम को हटाता है) और हटाए गए आइटम (ओं) को वापस लौटाता है, न कि सरणी को।

— CGundlach

2

अंतिम तत्व को हटाने के लिए इसे वास्तव में गिरफ्तार किया जाना चाहिए ।plice (arr.length-1,1)।

— स्टीव इन सीओ

15

चलो विभागों एक सरणी है। आप इस सरणी से कोई आइटम निकालना चाहते हैं।

departments: string[] = [];

 removeDepartment(name: string): void {
    this.departments = this.departments.filter(item => item != name);
  }

— अब्दुस सलाम आज़ाद
स्रोत

8

यहाँ वस्तुओं के एक सरणी से संपत्ति द्वारा एक वस्तु को हटाने के लिए एक सरल एक लाइनर है।

delete this.items[this.items.findIndex(item => item.item_id == item_id)];

या

this.items = this.items.filter(item => item.item_id !== item.item_id);

— जेमी कवच
स्रोत

1

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

— क्रिस्चियन

यह बात बताने के लिए धन्यवाद। मुझे लगता है कि मेरे उपयोग के मामले में मैंने अभी तक इसकी खोज नहीं की थी। अच्छी तरह से मनाया :)

— जेमी कवच

5

टाइपस्क्रिप्ट स्प्रेड ऑपरेटर (...) का उपयोग करके उत्तर दें

// Your key
const key = 'two';

// Your array
const arr = [
    'one',
    'two',
    'three'
];

// Get either the index or -1
const index = arr.indexOf(key); // returns 0


// Despite a real index, or -1, use spread operator and Array.prototype.slice()    
const newArray = (index > -1) ? [
    ...arr.slice(0, index),
    ...arr.slice(index + 1)
] : arr;

— जोशुआ माइकल वैगनर
स्रोत

5

टाइपस्क्रिप्ट का उपयोग कर एक और समाधान:

let updatedArray = [];
for (let el of this.oldArray) {
    if (el !== elementToRemove) {
        updated.push(el);
    }
}
this.oldArray = updated;

— श्री। पावेल
स्रोत

हालांकि यह पूछे जाने वाली समस्या को हल करता है, लेकिन नए सरणी के निर्माण और मूल पर लूपिंग के कारण निष्पादित करना महंगा है। एक विशाल सरणी पर इस तरह के ऑपरेशन को करने से अवांछनीय साइड इफेक्ट्स उत्पन्न हो सकते हैं, जैसे कि मोबाइल बैटरी पर कठिन, लंबे समय तक इंतजार करना, jank, आदि

— Jessy

1

इसका उपयोग करें, यदि आपको किसी दिए गए ऑब्जेक्ट को किसी सरणी से निकालने की आवश्यकता है और आप निम्नलिखित के बारे में सुनिश्चित होना चाहते हैं:

सूची पुनर्निवेशित नहीं है
सरणी की लंबाई ठीक से अपडेट की गई है

    const objWithIdToRemove;
    const objIndex = this.objectsArray.findIndex(obj => obj.id === objWithIdToRemove);
    if (objIndex > -1) {
      this.objectsArray.splice(objIndex, 1);
    }

— रादु लीनु
स्रोत

0

बस एक सरणी के लिए एक्सटेंशन विधि जोड़ना चाहते थे।

interface Array<T> {
      remove(element: T): Array<T>;
    }

    Array.prototype.remove = function (element) {
      const index = this.indexOf(element, 0);
      if (index > -1) {
        return this.splice(index, 1);
      }
      return this;
    };

— supernerd
स्रोत