როგორ შემიძლია ამოვიღო კონკრეტული ელემენტი JavaScript-ის მასივიდან? (ოცი)
მე მაქვს მთელი რიცხვების მასივი და ვიყენებ .push () მეთოდს მასში ელემენტების დასამატებლად.
არის თუ არა მასივიდან კონკრეტული ელემენტის ამოღების მარტივი გზა? ექვივალენტური რაღაც array.remove (int); ,
უნდა გამოვიყენო ბაზა JavaScript - არცერთიარ არის დაშვებული ჩარჩოები.
ES6 და მუტაციის გარეშე: (2016 წლის ოქტომბერი)
const removeByIndex = (list, index) => [... list.slice (0, index), ... list.slice (index + 1)];RemoveByIndex (, 1) // =>
რედაქტირებულია 2016 წლის ოქტომბერში
- გახადეთ ის მარტივი, ინტუიციური და მკაფიო (https://en.wikipedia.org/wiki/Occam%27s_razor)
- გახადეთ ის უცვლელი (ორიგინალი მასივი უცვლელი დარჩება)
- გააკეთეთ ეს სტანდარტული JS ფუნქციებით, თუ თქვენი ბრაუზერი მათ არ უჭერს მხარს - გამოიყენეთ პოლიფილი
ამ მაგალითის კოდში მე ვიყენებ ფუნქციის მასივი.ფილტრი (...)"მასივიდან არასაჭირო ელემენტების მოსაშორებლად, ეს ფუნქცია არ ცვლის თავდაპირველ მასივს და ქმნის ახალს. თუ თქვენი ბრაუზერი არ უჭერს მხარს ამ ფუნქციას (მაგ. IE 9 ვერსიამდე ან Firefox 1.5 ვერსიამდე), განიხილეთ გამოყენება პოლიფილის ფილტრი Mozilla-სგან .
ელემენტის წაშლა (ECMA-262 Edition 5 კოდი, aka oldstyle JS)
var მნიშვნელობა = 3 var arr = arr = arr.ფილტრი (ფუნქცია (პუნქტი) (დაბრუნების ელემენტი! == მნიშვნელობა)) console.log (arr) // [1, 2, 4, 5]ელემენტის წაშლა (ES2015 კოდი)
let value = 3 let arr = arr = arr.filter (item => item! == value) console.log (arr) // [1, 2, 4, 5]ᲛᲜᲘᲨᲕᲜᲔᲚᲝᲕᲐᲜᲘ ES2015 "() => ()" ისრის ფუნქციის სინტაქსი საერთოდ არ არის მხარდაჭერილი IE-ში, Chrome 45 ვერსიამდე, Firefox 22 ვერსიამდე, Safari 10 ვერსიამდე. ძველ ბრაუზერებში ES2015 სინტაქსის გამოსაყენებლად შეგიძლიათ გამოიყენოთ BabelJS
რამდენიმე ელემენტის ამოღება (ES2016 კოდი)
ამ მეთოდის დამატებითი უპირატესობა ის არის, რომ შეგიძლიათ ამოიღოთ მრავალი ელემენტი
მოდით forDeletion = მოდით arr = arr = arr.filter (item =>! ForDeletion.includes (item)) // !!! წაიკითხეთ ქვემოთ array.includes (...) მხარდაჭერა !!! console.log (arr) // [1, 4]
ᲛᲜᲘᲨᲕᲜᲔᲚᲝᲕᲐᲜᲘ"array.includes (...)" საერთოდ არ არის მხარდაჭერილი IE-ში, Chrome 47 ვერსიამდე, Firefox 43 ვერსიამდე, Safari 9 ვერსიამდე და Edge 14 ვერსიამდე.
მიმდინარეობს მრავალი ელემენტის წაშლა (მოწინავე ექსპერიმენტული JavaScript ES2018?)
// array-lib.js ექსპორტის ფუნქცია წაშლა (... forDeletion) (დააბრუნე this.filter (item =>! forDeletion.includes (item))) // main.js import (remove) from "./array-lib .js "let arr = // :: This-Binding Syntax Proposal // გამოყენებით" ამოიღეთ "function as" ვირტუალური მეთოდი "// Array.prototype arr = arr :: წაშლა (2, 3, 5) console.log (arr) // [1, 4]აქ არის რამდენიმე გზა ამოიღეთ ელემენტი მასივიდან Javascript-ის გამოყენებით .
ყველა აღწერილი მეთოდი არ შეცვალოთ ორიგინალური მასივიდა ამის ნაცვლად შექმენით ახალი.
თუ იცით ელემენტის ინდექსი
დავუშვათ, რომ თქვენ გაქვთ მასივი და გსურთ ამოიღოთ ელემენტი i პოზიციაზე.
ერთი გზა არის ნაჭრის გამოყენება ():
const items = ["a", "b", "c", "d", "e", "f"] const i = 3 const filteredItems = items.slice (0, i-1) .concat (items. slice (i, items.length)) console.log (filteredItems)
slice () ქმნის ახალ მასივს მის მიერ მიღებული ინდექსებით. ჩვენ უბრალოდ ვქმნით ახალ მასივს - თავიდან იმ ინდექსამდე, რომლის ამოღებაც გვინდა, და ვაკავშირებთ სხვა მასივს პირველი პოზიციიდან, რაც მოვაშორეთ, მასივის ბოლომდე.
თუ იცი მნიშვნელობა
ამ შემთხვევაში, ერთი კარგი ვარიანტია გამოიყენოთ ფილტრი (), რომელიც უფრო მეტს გვთავაზობს დეკლარაციულიმიდგომა:
const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter (item => item! == valueToRemove) console.log (filteredItems)
ის იყენებს ES6 ისრის ფუნქციებს. თქვენ შეგიძლიათ გამოიყენოთ ტრადიციული ფუნქციები ძველი ბრაუზერების მხარდასაჭერად:
const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter (ფუნქცია (პუნქტი) (დაბრუნების ელემენტი! = = valueToRemove)) console.log (filteredItems)
ან შეგიძლიათ გამოიყენოთ Babel და დააბრუნოთ თქვენი ES6 კოდი ES5-ში, რათა ის უფრო მონელებული იყოს ძველი ბრაუზერებისთვის, მაგრამ ჩაწერეთ თანამედროვე JavaScript თქვენს კოდში.
მრავალი ელემენტის ამოღება
რა მოხდება, თუ გსურთ წაშალოთ მრავალი ელემენტი ერთი ელემენტის ნაცვლად?
მოდი ვიპოვოთ უმარტივესი გამოსავალი.
ინდექსით
თქვენ შეგიძლიათ უბრალოდ შექმნათ ფუნქცია და წაშალოთ ელემენტები თანმიმდევრულად:
const items = ["a", "b", "c", "d", "e", "f"] const removeItem = (items, i) => items.slice (0, i-1) .concat (items.slice (i, items.length)) let filteredItems = removeItem (item, 3) filteredItems = removeItem (filteredItems, 5) // ["a", "b", "c", "d"] კონსოლი. ჟურნალი (გაფილტრული ნივთები)
ღირებულებით
თქვენ შეგიძლიათ მოძებნოთ ჩართვა გამოძახების ფუნქციის შიგნით:
const items = ["a", "b", "c", "d", "e", "f"] const valuesToRemove = ["c", "d"] const filteredItems = items.filter (item => ! valuesToRemove.includes (item)) // ["a", "b", "e", "f"] console.log (filteredItems)
მოერიდეთ ორიგინალური მასივის მუტაციას
splice () (არ უნდა აგვერიოს slice-ში ()) ახდენს ორიგინალურ მასივის მუტაციას და თავიდან უნდა იქნას აცილებული.
შეგიძლიათ გამოიყენოთ ES6.
Var array = ["1", "2", "3", "4", "5", "6"] var index = array.filter ((მნიშვნელობა) => მნიშვნელობა! = "3");
["1", "2", "4", "5", "6"]
ამის გაკეთება მარტივად შეგიძლიათ ფილტრის მეთოდით:
ფუნქცია remove (arrOriginal, elementToRemove) (return arrOriginal.filter (function (el) (return el! == elementToRemove));) console.log (remove (, 1));
ეს შლის ყველა ელემენტს მასივიდან და ასევე უფრო სწრაფია ვიდრე slice და indexOf კომბინაცია
თქვენ არასოდეს არ უნდა მოახდინოთ მასივის მასივის მუტაცია. რადგან ეს ეწინააღმდეგება ფუნქციური პროგრამირების ნიმუშს. თქვენ შეგიძლიათ შექმნათ ახალი მასივი იმ მასივზე მითითების გარეშე, რომლის შეცვლაც გსურთ es6 მეთოდის ფილტრის გამოყენებით;
Var myArray =;
დავუშვათ, რომ გსურთ ამოიღოთ 5 მასივიდან, შეგიძლიათ უბრალოდ გააკეთოთ ეს ასე.
MyArray = myArray.filter (მნიშვნელობა => მნიშვნელობა! == 5);
ეს მოგცემთ ახალ მასივს იმ მნიშვნელობის გარეშე, რომლის წაშლა გსურთ. ასე რომ შედეგი იქნება
; // 5 ამოღებულია ამ მასივიდან
დამატებითი გაგებისთვის, შეგიძლიათ წაიკითხოთ MDN დოკუმენტაცია Array.filter ფილტრზე
თუ გსურთ ახალი მასივი წაშლილი პოზიციებით, ყოველთვის შეგიძლიათ ამოიღოთ კონკრეტული ელემენტი და გაფილტროთ მასივი. მას შეიძლება დასჭირდეს მასივის ობიექტის გაფართოება ბრაუზერებისთვის, რომლებიც არ ახორციელებენ ფილტრაციის მეთოდს, მაგრამ გრძელვადიან პერსპექტივაში ეს უფრო ადვილია, რადგან ყველაფერი რასაც აკეთებთ არის ეს:
ვარ ჩემი_მასივი =; წაშალე my_array; console.log (my_array.filter (ფუნქცია (a) (დაბრუნების ტიპი a! == "დაუზუსტებელი";)));
უნდა იყოს ნაჩვენები
თუ თქვენ გაქვთ რთული ობიექტები მასივში, შეგიძლიათ გამოიყენოთ ფილტრები? სიტუაციებისთვის, როდესაც $ .inArray ან array.splice არც ისე მარტივი გამოსაყენებელია. მით უმეტეს, თუ ობიექტები შესაძლოა მცირე იყოს მასივში.
მაგალითად, თუ თქვენ გაქვთ ობიექტი Id ველით და გსურთ ობიექტის ამოღება მასივიდან:
This.array = this.array.filter (ფუნქცია (ელემენტი, i) (return element.id! == idToRemove;));
იპოვეთ მასივის ელემენტის ინდექსი, რომლის წაშლაც გსურთ, შემდეგ ამოიღეთ ეს ინდექსი სპლაისით.
Splice () მეთოდი ცვლის მასივის შიგთავსს არსებული ელემენტების ამოღებით და/ან ახალი ელემენტების დამატებით.
var მასივი =; console.log (მასივი) var index = array.indexOf (5); if (index> -1) (array.splice (index, 1);) // array = console.log (მაივი);
მეორე შერწყმის პარამეტრი არის ამოღებული ელემენტების რაოდენობა. გაითვალისწინეთ, რომ splice ცვლის მასივს ადგილზე და აბრუნებს ახალ მასივს, რომელიც შეიცავს ამოღებულ ელემენტებს.
თქვენ გაქვთ 1-დან 9-მდე მასივი და გსურთ წაშალოთ 5 ქვემოთ მოცემული კოდის გამოყენებით.
var numberArray =; var newNumberArray = numberArray.filter (m => (დაბრუნება m! == 5;)); console.log ("ახალი მასივი, 5 ამოღებულია", newNumberArray);
თუ გსურთ გამოიყენოთ მრავალი ex მნიშვნელობები: - 1,7,8
var numberArray =; var newNumberArray = numberArray.filter (m => (დაბრუნება (m! == 1) && (m! == 7) && (m! == 8);)); console.log ("ახალი მასივი, 5 ამოღებულია", newNumberArray);
თუ გსურთ წაშალოთ მასივის მნიშვნელობა ex მასივში: -
var numberArray =; var removebleArray =; var newNumberArray = numberArray.filter (m => (დაბრუნება! removebleArray.includes (m);)); console.log ("ახალი მასივი, ამოღებული", newNumberArray);
მოიცავს მხარდაჭერილ ბრაუზერს - ბმულს
მე ვიცი, რომ უკვე ბევრი პასუხია, მაგრამ ბევრი მათგანი, როგორც ჩანს, ართულებს პრობლემას. აქ არის მარტივი, რეკურსიული გზა გასაღების ყველა ინსტანციის წასაშლელად - იძახებს საკუთარ თავს, სანამ ინდექსი არ მოიძებნება. დიახ, ის მუშაობს მხოლოდ indexOf ბრაუზერებში, მაგრამ მარტივია და ადვილად დასახლებულია.
დამოუკიდებელი ფუნქცია
ფუნქცია removeAll (მასივი, გასაღები) (var index = array.indexOf (გასაღები); if (index === -1) დააბრუნებს; array.splice (ინდექსი, 1); removeAll (მასივი, გასაღები);)
პროტოტიპის მეთოდი
Array.prototype.removeAll = ფუნქცია (გასაღები) (var index = this.indexOf (გასაღები); if (index === -1) დაბრუნება; this.splice (ინდექსი, 1); this.removeAll (გასაღები);)
Array.prototype.removeItem = ფუნქცია (a) (for (i = 0; i< this.length; i++) { if (this[i] == a) { for (i2 = i; i2 < this.length - 1; i2++) { this = this; } this.length = this.length - 1 return; } } } var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"]; recentMovies.removeItem("Superman");
როგორ ამოიღოთ ელემენტი მასივიდან მნიშვნელობის მიხედვით? (ოცი)
// რედაქტირებულია მადლობა MarcoCI-ს რჩევისთვის
სცადე ეს:
ფუნქცია wantDelete (item, arr) (for (var i = 0; i იმედია ეს დაგეხმარებათ არსებობს გზა, რომ ამოიღოთ ელემენტი JavaScript მასივიდან? მასივის გათვალისწინებით: Var ary = ["სამი", "შვიდი", "თერთმეტი"]; მე მინდა გავაკეთო მსგავსი რამ: RemoveItem ("შვიდი", ary); მე შევხედე splice-ს () მაგრამ ეს მხოლოდ აშორებს პოზიციის ნომერს, მაშინ როცა მე მჭირდება რაღაც ამოიღო ელემენტი მისი მნიშვნელობით. მოდით commentsWithoutDeletedArray = commentsArray.filter ((კომენტარი) =>! (Comment.Id === commentId)); აქ არის ვერსია, რომელიც იყენებს jQuery-ის inArray ფუნქციას: Var ინდექსი = $ .inArray (პუნქტი, მასივი); if (ინდექსი! = -1) (array.splice (ინდექსი, 1);) ამის მიღწევა შეგიძლიათ ფუნქციის გამოყენებით ლოდაშ _.მოხსნა. var array = ["სამი", "შვიდი", "თერთმეტი"]; var evens = _.remove (მაივი, ფუნქცია (e) (return e! == "შვიდი";)); console.log (თანაბრები); Const _ = მოითხოვს ("lodash"); _.გარეშე (, 2); // -> მართლაც, არ მესმის, რატომ არ შეიძლება ამის მოგვარება Arr = arr.filter (მნიშვნელობა => მნიშვნელობა! == "შვიდი"); ან იქნებ გსურთ გამოიყენოთ ვანილის JS Arr = arr.filter (ფუნქცია (მნიშვნელობა) (დაბრუნების მნიშვნელობა! == "შვიდი")); კიდევ ერთი ვარიანტი: If (! Array.prototype.removeArr) (Array.prototype.removeArr = ფუნქცია (arr) (if (! Array.isArray (arr)) arr =; // მოდით, კარგი იყოს ხალხის მიმართ, ვინც აყენებს არამასივნის მნიშვნელობას აქ .. ეს შეიძლება ვიყო მე! var that = ეს; თუ (arr.length) (var i = 0; ხოლო (i ეს არის indexOf () ისევ მარყუჟის შიგნით, მაგრამ ვივარაუდოთ, რომ წაშლილი მასივი მცირეა გასასუფთავებელ მასივთან შედარებით; თითოეული მოცილება ამცირებს while მარყუჟს. ეს საშუალებას მოგცემთ გააკეთოთ შემდეგი: Var ary = ["სამი", "შვიდი", "თერთმეტი"]; var aryWithoutSeven = ary.filter (ფუნქცია (მნიშვნელობა) (დაბრუნების მნიშვნელობა! = "შვიდი")); console.log (aryWithoutSeven); // აბრუნებს ["სამი", "თერთმეტი"] ეს ასევე აღინიშნა ამ თემაში სხვაგან: https: //.com/a/20827100/293492 არ გამოიყენოთ წაშლის ოფცია - ის ქმნის ხვრელს მასივში, რადგან არ ახდენს ელემენტების რეინდექსირებას წაშლილი ელემენტის შემდეგ. > Array.prototype.remove = ფუნქცია (v) (... წაშალე ეს ...); > var myarray = ["3", "24", "55", "2"]; undefined> myarray.remove ("55"); undefined> myarray ["3", "24", "2"] ერთი ლაინერი ამას გააკეთებს Var ary = ["სამი", "შვიდი", "თერთმეტი"]; // ამოიღეთ ელემენტი "შვიდი" მასივიდან var filteredAry = ary.filter (ფუნქცია (e) (return e! == "seven")) // => ["სამი", "თერთმეტი"] // ECMA6-ში (ისარი ფუნქციის სინტაქსი): var filteredAry = ary.filter (e => e! == "შვიდი") ეს იყენებს ფილტრის ფუნქციას JS-ში. ის მხარდაჭერილია IE9 და ზემოთ. filter () იძახებს მოწოდებულ გამოძახების ფუნქციას ერთხელ მასივის თითოეული ელემენტისთვის და ქმნის ახალ მასივს ყველა მნიშვნელობიდან, რომლისთვისაც გამოძახება აბრუნებს მნიშვნელობას, რომელიც ფასდება true. გამოძახება იწოდება მხოლოდ მასივის ინდექსებისთვის, რომლებსაც მინიჭებული აქვთ მნიშვნელობები; ის არ არის მოწოდებული იმ ინდექსებისთვის, რომლებიც ჩამოიშალა ან რომლებსაც არასოდეს მინიჭებული აქვთ მნიშვნელობები. მასივის ელემენტები, რომლებიც ვერ ახერხებენ გამოძახების ტესტს, უბრალოდ გამოტოვებულია და არ შედის ახალ მასივში. ასე რომ, ეს ძირითადად იგივეა, რაც ყველა სხვა (var key in ary) (...) გადაწყვეტილებისთვის, გარდა იმისა, რომ for in მხარდაჭერილია როგორც IE6. ძირითადად, ფილტრი არის მოსახერხებელი მეთოდი, რომელიც გამოიყურება ბევრად უკეთესი (და ჯაჭვურია) განსხვავებით for in კონსტრუქტორისგან (AFAIK). Შეამოწმე: For (var i მასივში) (if (მასივი [i] == "შვიდი") (array.splice (i, 1); break;)) და ფუნქციაში: ფუნქცია removeItem (მასივი, ელემენტი) (for (var i მასივში) (if (მაივი [i] == ელემენტი) (array.splice (i, 1); break;))) removeItem (მაივი, "შვიდი"); ყველა შესატყვისი ელემენტის ამოღება მასივიდან (არა მხოლოდ პირველი, როგორც ჩანს, აქ ყველაზე ზოგადი პასუხია): while ($ .inArray (item, array)> -1) (array.splice ($. InArray (item, array), 1);) მე გამოვიყენე jQuery გარკვეული შრომისმოყვარეობისთვის, მაგრამ თქვენ გესმით იდეა, თუ გსურთ თქვენს მშობლიურ ენაზე გადასვლა. ხრიკი არის მასივის ციკლის თავიდან დაწყებამდე, ასე რომ თქვენ არ გააფუჭოთ ინდექსები ელემენტების წაშლისას. Var deleteMe = ფუნქცია (arr, me) (var i = arr.length; ხოლო (i--) if (arr [i] === me) arr.splice (i, 1);) var arr = ["ნარინჯისფერი "," წითელი "," შავი "," ნარინჯისფერი "," თეთრი "," ნარინჯისფერი "]; deleteMe (arr, "ნარინჯისფერი"); arr ახლა არის ["წითელი", "შავი", "თეთრი"] ფუნქცია cleanArrayOfSpecificTerms (მასივი, unwantedTermsArray) ($ .each (unwantedTermsArray, ფუნქცია (ინდექსი, მნიშვნელობა) (var index = array.indexOf (მნიშვნელობა); if (index> -1) (array.splice (index, 1);)) დაბრუნების მასივი;) გამოსაყენებლად მიჰყევით ამ ნაბიჯებს: Var notInclude = ["არა", "არა", "პირველი", "ბოლო", "წინა", "შემდეგი", "ძაღლები", "კატები"]; var splitTerms = ["ზარი", "ლოგი", "ძაღლები", "კატები", "თემა", "ცვლილება", "ფასი"]; cleanArrayOfSpecificTerms (splitTerms, notInclude) მე ვცადე ფუნქციის მეთოდის გამოყენება ზემოთ jbaron-დან, მაგრამ აღმოვაჩინე, რომ მჭირდებოდა ორიგინალური მასივის უცვლელი შენარჩუნება შემდგომი გამოყენებისთვის და ახალი მასივის შექმნა: Var newArray = referenceArray; ფუნქცია newArrRemoveItem (მასივი, ელემენტი, newArray) (for (var i = 0; i< array.length; i++) {
if(array[i]!=item){
newArray.push(array[i]);
}
}
}
შემდეგ გამოვიყენებ შემდეგნაირად: Var გემის ID = record.get ("VesselID"); var otherVessels = ახალი მასივი (); newArrRemoveItem (vesselArr, გემის ID, სხვა გემები); ახლა shipArr ხელუხლებელი რჩება და ყოველ ჯერზე, როცა ზემოხსენებულ კოდს ვასრულებ, otherVessels მასივი მოიცავს ყველაფერს, გარდა ბოლო CAID ელემენტისა. indexOf არის ვარიანტი, მაგრამ მისი განხორციელება ძირითადად ეძებს მთელ მასივს მნიშვნელობას, ასე რომ, გაშვების დრო იზრდება მასივის ზომასთან ერთად. (ასე რომ ეს ყველა ბრაუზერშია, ვფიქრობ, მე მხოლოდ Firefox გამოვტესტე). მე არ მაქვს IE6 შესამოწმებლად, მაგრამ მე მას დავარქმევ უსაფრთხო ფსონს, რომ თქვენ შეგიძლიათ შეამოწმოთ მინიმუმ მილიონი მასივის ელემენტი წამში ამ გზით თითქმის ნებისმიერი კლიენტის აპარატზე. თუ [მასიის ზომა] * [ძიება წამში] შეიძლება გაიზარდოს მილიონზე მეტი, თქვენ უნდა განიხილოთ სხვა განხორციელება. ძირითადად შეგიძლიათ გამოიყენოთ ობიექტი თქვენი მასივის ინდექსის შესაქმნელად, მაგალითად: Var ინდექსი = ("სამი": 0, "შვიდი": 1, "თერთმეტი": 2); ნებისმიერი ნორმალური JavaScript ფრეიმვორკი შექმნის საძიებო ინდექსს ასეთი ობიექტებისთვის, ასე რომ თქვენ შეგიძლიათ სწრაფად თარგმნოთ გასაღები მნიშვნელობაზე, მიუხედავად იმისა, თუ რამდენი თვისება აქვს ობიექტს. ეს მხოლოდ ძირითადი მეთოდია, თქვენი საჭიროებიდან გამომდინარე, შეგიძლიათ დააკავშიროთ მრავალი ობიექტი და/ან მასივები, რათა იგივე მონაცემები სწრაფად მოძებნოთ სხვადასხვა თვისებებისთვის. თუ თქვენ მიაწვდით თქვენს კონკრეტულ საჭიროებებს, შემიძლია შემოგთავაზოთ მონაცემთა უფრო კონკრეტული სტრუქტურა. // ეს ფუნქცია საშუალებას გაძლევთ ამოიღოთ ლუწი მასივი მასივიდან var removeFromArr = ფუნქცია (arr, elem) (var i, len = arr.length, new_arr =, sort_fn = ფუნქცია (a, b) (დაბრუნება a - b;); i = 0; i< len; i += 1) {
if (typeof elem === "object" && typeof arr[i] === "object") {
if (arr[i].toString() === elem.toString()) {
continue;
} else {
if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) {
continue;
}
}
}
if (arr[i] !== elem) {
new_arr.push(arr[i]);
}
}
return new_arr;
}
გამოყენების მაგალითი Var arr =, "abc", 1, "1", 1]; removeFromArr (arr, 1); // ["2", "abc", "1"] var arr = [, 2, "a",,]; removeFromArr (arr,); //] მოდით arr =; console.log (arr); // შედეგი მოდით index = arr.indexOf (30); if (index> -1) (arr.splice (index, 1);) console.log (arr); // შედეგი Var index = array.indexOf ("item"); if (ინდექსი! = - 1) (array.splice (ინდექსი, 1);) გამოიყენეთ .shift მასივის პირველი ელემენტის მოსაშორებლად. Მაგალითად: Var მასივი =; მასივი.shift (); მასივი იწვევს: Მაგალითად: Var მასივი =; array.pop (); მასივი იწვევს: ორივე მეთოდი აბრუნებს ამოღებულ ნივთს; გამოიყენეთ.splice () მასივიდან ელემენტების სერიის მოსაშორებლად. .splice () იღებს ორ პარამეტრს, სასტარტო ინდექსს და არჩევით კარდინალობას. თუ მეორე პარამეტრი არ არის, splice () ამოიღებს ყველა ელემენტს საწყისი ინდექსიდან მასივის ბოლომდე. Მაგალითად: Var მასივი =; array.splice (1, 2); ტოვებს მასივს, რომელიც შეიცავს: array.splice ()-ის დაბრუნება არის ახალი მასივი, რომელიც შეიცავს ამოღებულ ელემენტებს. ზემოთ მოცემულ მაგალითში დაბრუნება იქნება: ამრიგად, მეორე პარამეტრის გამოტოვება ეფექტურად ყოფს მასივს ორ მასივად, ორიგინალი მთავრდება მითითებულ ინდექსამდე: Var მასივი =; მასივი.splice (2); ტოვებს მასივს, რომელიც შეიცავს და აბრუნებს. გამოიყენეთ delete, რათა ამოიღოთ ელემენტი მასივიდან მასივის სიგრძის შეცვლის გარეშე: Var მასივი =; console.log (მასივი.სიგრძე); // 5 წაშლა მასივი; console.log (მასივი); // console.log (მასივი.სიგრძე); // 5 მასივის სიგრძეზე მნიშვნელობის მინიჭება ცვლის სიგრძეს მითითებული მნიშვნელობით. თუ ახალი მნიშვნელობა ნაკლებია მასივის სიგრძეზე, ელემენტები წაიშლება მნიშვნელობის ბოლოდან. მასივი =; მასივი.სიგრძე = 2; console.log (მასივი); // მე აღვწერე მასივებთან მუშაობის მეთოდების მხოლოდ ნაწილი. აქ ვისაუბრებთ მასივის ელემენტების დამატებაზე, ამოღებაზე. მასივის ინვერსიისა და დახარისხების, ასევე მასივების დაჭრის, ჩანაცვლებისა და გაერთიანების შესახებ. თქვენ შეგიძლიათ გამოიყენოთ length თვისება მასივში ახალი ელემენტების დასამატებლად: Var myArray = ["Apple", "Microsoft", "Google", "Facebook"]; myArray = "Yahoo!"; console.log (myArray); // ["Apple", "Microsoft", "Google", "Facebook", "Yahoo!"] ეს იმუშავებს, რადგან მასივის ელემენტები დანომრილია ნულიდან და სიგრძეკიდევ ერთი. სიგრძეყოველთვის ექვივალენტი ინდექსი + 1ასე რომ, ძალიან ადვილია ახალი ელემენტის დამატება მასივის ბოლოს. უცნაურია, მაგრამ თქვენ შეგიძლიათ დაამატოთ ელემენტი იმ პოზიციაზე, რომელიც ბევრად აღემატება თავად მასივის სიგრძეს: Var myArray = ["ჯიმი ჰენდრიქსი", "ერიკ კლეპტონი", "ჯიმი პეიჯი", "კეიტ რიჩარდსი"]; myArray = "Lindsey Buckingham"; console.log (myArray); // ["ჯიმი ჰენდრიქსი", "ერიკ კლეპტონი", "ჯიმი პეიჯი", "კეიტ რიჩარდსი", განუსაზღვრელი × 95, "ლინდსი ბუკინგემი"] console.log (myArray.length); // 100 როგორც კომენტარებში ჩანს, 95 ცარიელი სლოტი და "Lindsey Buckingham" ელემენტი დაემატება მასივის ბოლოს. ამის შემდეგ მივიღებთ სიგრძეს 100. მასივში ახალი ელემენტის დამატების კიდევ ერთი გზაა მეთოდის გამოყენება. ბიძგი (): Var myArray = ["პოლ მაკარტნი", "ჯონ ლენონი", "ჯორჯ ჰარისონი"]; myArray.push ("რინგო სტარი", "ჯორჯ მარტინი"); console.log (myArray); // ["პოლ მაკარტნი", "ჯონ ლენონი", "ჯორჯ ჰარისონი", "რინგო სტარი", "ჯორჯ მარტინი"] მეთოდი ბიძგი ()ყოველთვის აბრუნებს მასივის ახალ სიგრძეს (ჩვენს შემთხვევაში 5). თქვენ შეგიძლიათ დაამატოთ ელემენტი გამოყენებით შერწყმა (): Var myArray = ["აკორნი", "წიფელი", "მონგონგო", "მაკადამია"]; myArray.splice (2, 0, "cashew"); // ამატებს "cashew"-ს index 2 console.log-ში (myArray); // ["აკორნი", "წიფელი", "კეშიუ", "მონგონგო", "მაკადამია"] როდესაც მეორე არგუმენტი არის 0, ეს ნიშნავს, რომ არცერთი ელემენტი არ წაიშლება და, შესაბამისად, ნებისმიერი შემდგომი არგუმენტი დაემატება მასივს პირველ არგუმენტში მითითებულ პოზიციაზე. ელემენტის ამოღება ცოტა უფრო რთულია, ვიდრე მისი დამატება. ელემენტის ამოსაღებად მასივის ბოლოდან, შეგიძლიათ გამოიყენოთ პოპ (): Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop (); console.log (myArray); // ["7-up", "Sprite", "Ginger Ale"] მეთოდი პოპი ()ყოველთვის აშორებს მასივის ბოლო ელემენტს და აბრუნებს მას. თქვენ ასევე შეგიძლიათ გამოიყენოთ შერწყმა ()მეთოდი: Var myArray = ["კასავა", "მუსკატის კაკალი", "ლუპინი", "რევანდი"]; myArray.splice (2, 1); // ელემენტის ამოღება index 2 console.log (myArray); // ["კასავა", "მუსკატი", "რევანდი"] მეთოდისგან განსხვავებით შეერთება (),რომელიც გამოიყენება ელემენტების დასამატებლად, აქ მეორე არგუმენტია 1, რომელიც ამბობს, რომ გვინდა ელემენტის ამოღება ინდექსით 2 (ან ზედიზედ მე-3). ამ შემთხვევაში "ლუპინის" ელემენტი ამოღებულია. თქვენ შეგიძლიათ ამოიღოთ ელემენტი მასივიდან ოპერატორის გამოყენებით წაშლა: Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log (myArray.length); // 4 წაშალე myArray; // ამოიღეთ Eliza console.log (myArray.length); // 4 console.log (myArray); // ["ბაიტი ბანდიტი", განუსაზღვრელი × 1, "ჯიფო", "მიქელანჯელო"] პირველი მნიშვნელოვანი შენიშვნა: წაშლა ()არ ცვლის მასივის სიგრძეს ელემენტის ამოღების შემდეგ (თუნდაც ეს იყოს მასივის ბოლო ელემენტი). მეორე: წაშლა ()ცვლის ამოღებული ელემენტის მნიშვნელობას განუსაზღვრელად, ასე რომ, როდესაც უკუგდება myArray = განუსაზღვრელი. მასივიდან ელემენტის ამოღების კარგი გზაა John Resig-ის Array.remove-ის გამოყენება. ქვემოთ მოცემულია მისი გვერდიდან აღებული გამოყენების მაგალითი: // Array Remove - ავტორი ჯონ რეზიგი (MIT ლიცენზირებული) Array.prototype.remove = ფუნქცია (from, to) (var rest = this.slice ((to || from) + 1 || this.length); this.length = დან< 0 ? this.length + from: from;
return this.push.apply(this, rest);
};
// Удаление 2 элемента из массива
array.remove(1);
// Удаление 2-ого элемента с конца массива
array.remove(-2);
// Удаление второго и третьего элемента
array.remove(1,2);
// Удаление последнего и предпоследнего элемента
array.remove(-2,-1);
შეიძლება დაგჭირდეთ გადახედოთ Viral Patel-ის გამოსავალს, ერთ-ერთ ფუნქციას Underscore.js-ში ან jQuery-ის grep (). დამატებით, in JavaScriptარსებობს მეთოდი ცვლა (),რომელიც შლის მასივის პირველ ელემენტს და აბრუნებს მის მნიშვნელობას. ვნახოთ კოდი: Var myArray = ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; console.log (myArray.length); // 4 var firstItem = myArray.shift (); console.log (firstItem); // Matt Kramer console.log (myArray.length); // 3 console.log (myArray); // ["ჯეისონ ბილერი", "ტომ დეფილე", "ფილ ვარონე"] მეთოდის გამოყენებით ცვლა ()ჩვენ წავშალეთ ელემენტი, მაგრამ შევინახეთ მისი მნიშვნელობა ჩვენს firstItem ცვლადში. მასივის სიგრძე შეიცვალა 4-დან 3-მდე. ეს მეთოდი შეიძლება სასარგებლო იყოს მეთოდთან ერთად ბიძგი ().მათი ერთად გამოყენებით, ჩვენ შეგვიძლია ეფექტურად დავაყენოთ ელემენტები მასივში. ჩვენ ვინარჩუნებთ მასივის სიგრძეს ელემენტის თავიდან ამოღებით და ბოლოს ახლის დამატებით. პირიქით, ჩვენ შეგვიძლია გამოვიყენოთ მეთოდი გადართვა ()მასივის დასაწყისში ელემენტის დასამატებლად: Var myArray = ["apito", "castanets", "maraca"]; console.log (myArray.length); // 3 myArray.unshift ("chime bar", "tan-tan"); console.log (myArray.length); // 5 console.log (myArray); // ["chime bar", "tan-tan", "apito", "castanets", "maraca"] მეთოდის გამოყენებით გადართვა ()მეთოდით პოპ (),შეგიძლიათ რიგს უკუ დააყენოთ ელემენტების დასაწყისში დამატებით და მასივის ბოლოდან ამოღებით. ელემენტების მასივში გადასაბრუნებლად შეგვიძლია გამოვიყენოთ საპირისპირო (): Var myArray = ["countdown", "final", "the"]; console.log (myArray); // ["countdown", "final", "the"] myArray = myArray.reverse (); console.log (myArray); // ["საბოლოო გადათვლა"] მასივის ელემენტების დალაგება ანბანური თანმიმდევრობაშესაძლებელია მეთოდის გამოყენებით დალაგება (): Var myArray = ["ქსილოფონები", "ზებრები", "ჯუჯები", "ავოკადო"]; console.log (myArray); // ["ქსილოფონები", "ზებრები", "ჯუჯები", "ავოკადო"] myArray = myArray.sort (); console.log (myArray); // ["ავოკადო", "ჯუჯერნავტები", "ქსილოფონები", "ზებრები"] მაგრამ ეს არ იმუშავებს ციფრებთან. Var myArray =; console.log (myArray); // myArray = myArray.sort (); console.log (myArray); // თუ ნომრების დალაგება გჭირდებათ, შეგიძლიათ გამოიყენოთ შემდეგი კოდი: ფუნქცია compareNumbers (a, b) (დაბრუნება a - b;) var myArray =; console.log (myArray); // myArray = myArray.sort (compareNumbers); console.log (myArray); // როგორც ზემოთ ნაჩვენებია მარტივი ფუნქციით ჩასმული დალაგება (),რიცხვების შემცველი მასივი სწორად დალაგდება. თქვენ შეგიძლიათ დააკავშიროთ 2 ან მეტი მასივი და მიიღოთ 1 მასივი, რომელიც შეიცავს შეკრული მასივების ელემენტებს. ამისათვის ჩვენ ვიყენებთ მეთოდს concat (): Var myArray = ["ჯეი ფერგიუსონი", "ენდრიუ სკოტი"]; var myArray2 = ["კრის მერფი", "პატრიკ პენტლენდი"]; var myNewArray = myArray.concat (myArray2); console.log (myNewArray); // ["ჯეი ფერგიუსონი", "ენდრიუ სკოტი", "კრის მერფი", "პატრიკ პენტლენდი"] Var myArray = ["ჯეი ფერგიუსონი", "ენდრიუ სკოტი"]; var myNewArray = myArray.concat ("კრის მერფი", "პატრიკ პენტლენდი"); console.log (myNewArray); // ["ჯეი ფერგიუსონი", "ენდრიუ სკოტი", "კრის მერფი", "პატრიკ პენტლენდი"] ფუნქციის გამოყენებით შეგიძლიათ შექმნათ ახალი მასივი, რომელიც შეიცავს 1 ან მეტ ელემენტს არსებული მასივიდან ნაჭერი (): Var myArray = ["ვოკალი", "ბასი", "გიტარა", "დრამი", "ვაშლი", "ფორთოხალი"]; var myNewArray = myArray.slice (4); console.log (myNewArray); // ["ვაშლი", "ფორთოხალი"] მეთოდი ნაჭერი ()იღებს 1 ან 2 არგუმენტს. თუ გადაეცემა 1 არგუმენტი (ინდექსი), მაშინ ახალი მასივი იქმნება ძველის ყველა ელემენტისგან, მოცემული ინდექსიდან დაწყებული. თუ გადაეცემა 2 არგუმენტი, მაშინ იქმნება ახალი მასივი ელემენტებიდან პირველი არგუმენტიდან დაწყებული და მეორე პარამეტრში გადაცემულ ინდექსის ელემენტამდე, ბოლო პარამეტრის გარეშე. უფრო გასაგებად, ვნახოთ ქვემოთ მოცემული კოდი: Var myArray = ["ვოკალი", "ბასი", "გიტარა", "დრამი", "ვაშლი", "ფორთოხალი"]; var myNewArray = myArray.slice (0, 4); console.log (myNewArray); // ["ვოკალი", "ბასი", "გიტარა", "დრამი"] Ჩვენ ვიყენებთ შერწყმა ()ამოიღონ ელემენტები მასივიდან, მაგრამ ჩვენ ასევე შეგვიძლია შევცვალოთ ელემენტი მასივში ახალი ელემენტებით: Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice (3, 1, "Scott Shriner"); // 1 ელემენტის შეცვლა index 3 console.log (myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"] მეთოდი შერწყმა ()ყოველთვის აბრუნებს მასივს, რომელიც შეიცავს ამოღებულ ელემენტებს. ხაზი 2 დააბრუნებს 1 პუნქტს "ბრაიან ბელი". ამ სტატიებში აღწერილია JavaScript-ში მასივებით მუშაობის მეთოდები. ზოგიერთი დამატებითი ელემენტის ნახვა შესაძლებელია MDN-ზე, რომლებიც მე არ ჩამიწერია ამ პოსტში. ისინი მხოლოდ IE9 +-ში მუშაობენ, ამიტომ შეიძლება არ იყოს სასარგებლო. რამე დასამატებელია? ან იცით რაიმე საინტერესო ბიბლიოთეკა, რომელიც დაგეხმარებათ მასივების მართვაში? გთხოვთ კომენტარი!ცვლა
შერწყმა
წაშლა
მასივი.პროტოტიპი.სიგრძე
ელემენტების დამატება მასივში.
ელემენტების ამოღება მასივიდან
მასივის ელემენტების შებრუნება და დახარისხება.
მასივების გაერთიანება.
მასივის გაყოფა.
ელემენტების ჩანაცვლება მასივში.
დასკვნა
