මට සංඛ්‍යා රාශියක් ඇති අතර .push()එයට මූලද්‍රව්‍ය එකතු කිරීමට මම ක්‍රමය භාවිතා කරමි .

අරාවකින් නිශ්චිත අංගයක් ඉවත් කිරීමට සරල ක්‍රමයක් තිබේද?

මම සොයන්නේ මෙවැනි දෙයකට සමාන ය:

array.remove(number);

මට මූලික ජාවාස්ක්‍රිප්ට් භාවිතා කළ යුතුයි . රාමු වලට අවසර නැත.

indexභාවිතයෙන් ඉවත් කිරීමට අවශ්‍ය අරාව මූලද්‍රව්‍යය සොයා ගන්න indexOf, ඉන්පසු එම දර්ශකය ඉවත් කරන්න splice.

විභේදන () ක්‍රමය මඟින් පවතින මූලද්‍රව්‍ය ඉවත් කිරීමෙන් සහ / හෝ නව මූලද්‍රව්‍ය එකතු කිරීමෙන් අරාවෙහි අන්තර්ගතය වෙනස් කරයි.

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

දෙවන පරාමිතිය spliceවන්නේ ඉවත් කළ යුතු මූලද්රව්ය සංඛ්යාවයි. spliceස්ථානයෙහි අරාව වෙනස් කරන අතර ඉවත් කළ මූලද්‍රව්‍ය අඩංගු නව අරාවක් නැවත ලබා දෙන බව සලකන්න .

සම්පූර්ණත්වය සඳහා, මෙහි කාර්යයන් ඇත. පළමු කාර්යය පමණක් තනි සිදුවීමක් (එනම් පළමු තරගය ඉවත් ඉවත් 5සිට [2,5,9,1,5,8,5]දෙවන කාර්යය සියලු සිදුවීම් ඉවත් කර ගන්නා විට,):

function removeItemOnce(arr, value) { 
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}

function removeItemAll(arr, value) {
    var i = 0;
    while (i < arr.length) {
        if(arr[i] === value) {
            arr.splice(i, 1);
        } else {
            ++i;
        }
    }
    return arr;
}

ඔබ array.remove(int)හැසිරීමට බලාපොරොත්තු වන්නේ කෙසේදැයි මම නොදනිමි . ඔබට අවශ්‍ය යැයි මට සිතිය හැකි අවස්ථා තුනක් තිබේ.

දර්ශකයක අරාවෙහි මූලද්‍රව්‍යයක් ඉවත් කිරීමට i:

array.splice(i, 1);

numberඅරාව වෙතින් වටිනාකමක් ඇති සෑම අංගයක්ම ඉවත් කිරීමට ඔබට අවශ්‍ය නම් :

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
        array.splice(i, 1);
    }
}

ඔබට අවශ්‍ය වන්නේ දර්ශකයේ ඇති මූලද්‍රව්‍යය iතවදුරටත් නොපවතින නමුත් අනෙක් මූලද්‍රව්‍යයන්ගේ දර්ශක වෙනස් වීමට ඔබට අවශ්‍ය නැත:

delete array[i];

සංස්කරණය කළේ 2016 ඔක්තෝබර්

• එය සරල, බුද්ධිමත් හා පැහැදිලිව කරන්න ( ඔකෑම්ගේ රේසරය )
• එය වෙනස් කළ නොහැකි ලෙස කරන්න (මුල් අරාව නොවෙනස්ව පවතී)
• සම්මත ජාවාස්ක්‍රිප්ට් කාර්යයන් සමඟ එය කරන්න, ඔබේ බ්‍රව්සරය ඒවාට සහය නොදක්වන්නේ නම් - පොලිෆිල් භාවිතා කරන්න

මෙම කේත උදාහරණයේ දී මම අරාවකින් අනවශ්‍ය අයිතම ඉවත් කිරීමට "array.filter (...)" ශ්‍රිතය භාවිතා කරමි . මෙම ශ්‍රිතය මුල් අරාව වෙනස් නොකරන අතර නව එකක් නිර්මාණය කරයි. ඔබගේ බ්‍රව්සරය මෙම ශ්‍රිතයට සහය නොදක්වන්නේ නම් (උදා: 9 වන අනුවාදයට පෙර ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හෝ 1.5 අනුවාදයට පෙර ෆයර්ෆොක්ස්), මොසිල්ලා වෙතින් පෙරහන් පොලිෆිල් භාවිතා කිරීම ගැන සලකා බලන්න .

අයිතමය ඉවත් කිරීම (ECMA-262 Edition 5 code aka oldstyle JavaScript)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) {
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

අයිතමය ඉවත් කිරීම (ECMAScript 6 කේතය)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

වැදගත් ECMAScript 6 "() => {}" ඊතල ක්‍රියාකාරී සින්ටැක්ස් ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්, ක්‍රෝම් 45 ට පෙර, ෆයර්ෆොක්ස් 22 අනුවාදයට පෙර සහ සෆාරි 10 අනුවාදයට සහය නොදක්වයි. පැරණි බ්‍රව්සර්වල ECMAScript 6 සින්ටැක්ස් භාවිතා කිරීමට ඔබට බාබෙල් ජේඑස් භාවිතා කළ හැකිය .

බහු අයිතම ඉවත් කිරීම (ECMAScript 7 කේතය)

මෙම ක්‍රමයේ අමතර වාසියක් නම් ඔබට බහුවිධ අයිතම ඉවත් කළ හැකිය

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

වැදගත් "array.includes (...)" ශ්‍රිතයට ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්, 47 අනුවාදයට පෙර ක්‍රෝම්, 43 අනුවාදයට පෙර ෆයර්ෆොක්ස්, 9 අනුවාදයට පෙර සෆාරි, සහ 14 අනුවාදයට පෙර එජ් වැනි ක්‍රියාකාරකම් සඳහා සහය නොදක්වයි .

බහු අයිතම ඉවත් කිරීම (අනාගතයේදී, සමහර විට)

නම් "මෙම-බඳින්නන් වාග් රීතිය" යෝජනාවක් මෙතෙක් පිළිගෙන ඇත, ඔබට මේ දේවල් කිරීමට හැකි වනු ඇත:

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

බාබල් ජේඑස් හි එය ඔබම උත්සාහ කරන්න :)

යොමුව

• Array.prototype.includes
• ක්‍රියාකාරී සංයුතිය

එය ඔබට හිස් ස්ථානයක් තබා ගැනීමට අවශ්‍යද නැද්ද යන්න මත රඳා පවතී.

ඔබට හිස් තව් අවශ්‍ය නම්, මකා දැමීම හොඳයි:

delete array[index];

ඔබ එසේ නොකරන්නේ නම්, ඔබ ස්ප්ලයිස් ක්‍රමය භාවිතා කළ යුතුය :

array.splice(index, 1);

ඔබට එම අයිතමයේ වටිනාකම අවශ්‍ය නම්, ඔබට ආපසු ලබා දුන් අරාවෙහි මූලද්‍රව්‍යය ගබඩා කළ හැකිය:

var value = array.splice(index, 1)[0];

ඔබට එය යම් අනුපිළිවෙලකට කිරීමට අවශ්‍ය නම්, ඔබට array.pop()අවසාන එක array.shift()සඳහා හෝ පළමු එක සඳහා භාවිතා කළ හැකිය (දෙකම අයිතමයේ වටිනාකම ද ආපසු ලබා දෙයි).

තවද ඔබ අයිතමයේ දර්ශකය නොදන්නේ නම්, ඔබට array.indexOf(item)එය ලබා ගැනීමට භාවිතා කළ හැකිය ( if()එක් අයිතමයක් ලබා ගැනීමට හෝ while()ඒ සියල්ල ලබා ගැනීමට). array.indexOf(item)දර්ශකය හෝ -1 සොයාගත නොහැකි නම් ආපසු එවයි. 

මිතුරෙකුට ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8 හි ගැටළු ඇති අතර ඔහු කළ දේ මට පෙන්නුවා. මම ඔහුට කිව්වා ඒක වැරදියි, ඔහු මට කිව්වා මෙතන උත්තරය ලැබුණා කියලා. වර්තමාන ඉහළ පිළිතුර සියලුම බ්‍රව්සර් වල ක්‍රියා නොකරනු ඇත (උදාහරණයක් ලෙස ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8), එය ඉවත් කරන්නේ අයිතමයේ පළමු සිදුවීම පමණි.

අරාවකින් සියලු අවස්ථා ඉවත් කරන්න

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

එය අරාව හරහා පසුපසට විහිදේ (අයිතම ඉවත් කරන විට දර්ශක සහ දිග වෙනස් වන බැවින්) සහ අයිතමය සොයාගත හොත් එය ඉවත් කරයි. එය සියලුම බ්‍රව්සර් වල ක්‍රියා කරයි.

ප්‍රධාන ප්‍රවේශයන් දෙකක් තිබේ:

1. භේදය () :anArray.splice(index, 1);

2. මකන්න :delete anArray[index];

ඔබ අරාව සඳහා මකන්න භාවිතා කරන විට ප්‍රවේශම් වන්න. වස්තූන්ගේ ගුණාංග මකා දැමීම සඳහා එය හොඳ ය, නමුත් අරා සඳහා එතරම් හොඳ නැත. spliceඅරා සඳහා භාවිතා කිරීම වඩා හොඳය .

ඔබ deleteඅරාව සඳහා භාවිතා කරන විට ඔබට වැරදි ප්‍රති results ල ලබා ගත හැකි බව මතක තබා ගන්න anArray.length. වෙනත් වචන වලින් කිවහොත්, deleteමූලද්‍රව්‍යය ඉවත් කරනු ඇත, නමුත් එය දිග දේපලවල වටිනාකම යාවත්කාලීන නොකරයි.

මකාදැමීම භාවිතා කිරීමෙන් පසු ඔබට දර්ශක අංකවල සිදුරු ඇති බව අපේක්ෂා කළ හැකිය, උදා: ඔබට 1, 3, 4, 8, 9, සහ 11 දර්ශක තිබීම හා මකාදැමීමට පෙර තිබූ දිග මෙන් විය හැකිය. එවැනි අවස්ථාවකදී, සුචිගත forකිරීම් තවදුරටත් අනුක්‍රමික නොවන බැවින් සියලු සුචිගත ලූප බිඳ වැටෙනු ඇත.

deleteකිසියම් හේතුවක් නිසා භාවිතා කිරීමට ඔබට බල කෙරෙන්නේ නම්, ඔබට for eachඅරා හරහා ලූප කිරීමට අවශ්‍ය වූ විට ඔබ ලූප භාවිතා කළ යුතුය . ඇත්ත වශයෙන්ම, forහැකි නම්, සුචිගත කළ ලූප භාවිතා කිරීමෙන් වළකින්න . එමගින් කේතය වඩාත් ශක්තිමත් වන අතර දර්ශක සමඟ ඇති ගැටළු වලට ගොදුරු වේ.

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

එහි භාවිතා කිරීමට අවශ්ය නැත indexOfහෝ splice. කෙසේ වෙතත්, ඔබට අවශ්‍ය වන්නේ මූලද්‍රව්‍යයක එක් සිදුවීමක් ඉවත් කිරීමට පමණි.

සොයාගෙන ගෙන යන්න (ගෙනයන්න):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

භාවිතා කිරීම indexOfසහ splice(සුචිගත කිරීම):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

පමණක් භාවිතා කරන්න splice(භේදය):

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

මූලද්රව්ය 1000 ක් සහිත අරාව සඳහා නෝඩ්ජ් මත ධාවනය වන වේලාවන් (සාමාන්ය ලකුණු 10000 ට වඩා වැඩි):

දර්ශකය චලනය වීමට වඩා දළ වශයෙන් 10x මන්දගාමී වේ . වන ලෙස ඉල්ලා ඉවත් කිරීමෙන් වැඩි දියුණු වුවද indexOfදී පිරිද්දුමෙන් වඩා බෙහෙවින් නරක අතට සිදු පියවර .

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

මෙය අගයක් වෙනුවට පුරෝකථනයක් සපයයි.

සටහන: එය ලබා දී ඇති අරාව යාවත්කාලීන කර බලපෑමට ලක් වූ පේළි නැවත ලබා දෙනු ඇත.

භාවිතය

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

අර්ථ දැක්වීම

var helper = {

    // Remove and return the first occurrence

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }
            i++;
        }
        return removed;
    }
};

පෙරහන් ක්‍රමය මඟින් ඔබට එය පහසුවෙන් කළ හැකිය :

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log(remove([1, 2, 1, 0, 3, 1, 4], 1));

මෙම අරාව සියලු අංග ඉවත් කරන අතර ද වේගවත් සංකලනයක් වඩා වැඩ sliceහා indexOf.

ජෝන් රෙසිග් හොඳ ක්‍රියාත්මක කිරීමක් පළ කළේය :

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

ඔබට ගෝලීය වස්තුවක් දිගු කිරීමට අවශ්‍ය නැතිනම්, ඒ වෙනුවට ඔබට පහත සඳහන් දේ වැනි දෙයක් කළ හැකිය:

// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.push.apply(array, rest);
};

නමුත් මම මෙය පළ කිරීමට ප්‍රධාන හේතුව වන්නේ එම පිටුවෙහි අදහස් දැක්වීමේදී යෝජනා කර ඇති විකල්ප ක්‍රියාත්මක කිරීමට එරෙහිව පරිශීලකයින්ට අනතුරු ඇඟවීමයි (2007 දෙසැම්බර් 14):

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

මුලදී එය හොඳින් ක්‍රියාත්මක වන බව පෙනේ, නමුත් වේදනාකාරී ක්‍රියාවලියක් මගින් අරාවෙහි දෙවන සිට අන්තිම මූලද්‍රව්‍යය ඉවත් කිරීමට උත්සාහ කිරීමේදී එය අසාර්ථක වන බව මම සොයා ගතිමි. උදාහරණයක් ලෙස, ඔබට මූලද්‍රව්‍ය 10 ක අරාවක් තිබේ නම් සහ ඔබ මෙය සමඟ 9 වන මූලද්‍රව්‍යය ඉවත් කිරීමට උත්සාහ කරයි:

myArray.remove(8);

ඔබ අවසන් වන්නේ මූලද්‍රව්‍ය 8 කින් යුත් අරාවකින්. එයට හේතුව නොදන්නා නමුත් මම තහවුරු කළේ ජෝන් ගේ මුල් ක්‍රියාත්මක කිරීම මෙම ගැටලුවක් නොමැති බවයි.

බහුවිධ බ්‍රව්සර් සමඟ ඇති ගැටළු විසඳීමට Underscore.js භාවිතා කළ හැකිය. එය තිබේ නම් එය තුළ ඇති බ්‍රව්සර් ක්‍රම භාවිතා කරයි. පැරණි ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් අනුවාදවල මෙන් ඒවා නොමැති නම් එය ස්වකීය අභිරුචි ක්‍රම භාවිතා කරයි.

අරාවෙන් මූලද්‍රව්‍ය ඉවත් කිරීමට සරල උදාහරණයක් (වෙබ් අඩවියෙන්):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

ඔබට ES6 භාවිතා කළ හැකිය. උදාහරණයක් ලෙස මෙම අවස්ථාවේදී '3' අගය මකා දැමීමට:

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');
console.log(newArray);

ප්‍රතිදානය:

["1", "2", "4", "5", "6"]

මකාදැමූ ස්ථාන ඉවත් කර නව අරාවක් ඔබට අවශ්‍ය නම්, ඔබට සෑම විටම නිශ්චිත අංගය මකා දමා අරාව පෙරහන් කළ හැකිය. පෙරහන් ක්‍රමය ක්‍රියාත්මක නොකරන බ්‍රව්සර් සඳහා අරාව වස්තුවේ දිගුවක් අවශ්‍ය විය හැකි නමුත් දිගු කාලීනව එය පහසු බැවින් ඔබ කරන සියල්ල මෙයයි:

var my_array = [1, 2, 3, 4, 5, 6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

එය දර්ශනය විය යුතුය [1, 2, 3, 4, 6].

මෙම කේතය බලන්න. එය සෑම ප්‍රධාන බ්‍රව්සරයකම ක්‍රියාත්මක වේ.

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

මෙම ශ්‍රිතය අමතන්න

remove_item(array,value);

ඔබට lodash _.pull ( mutate array), _.pullAt ( mutate array) හෝ _.without (array විකෘති නොකරයි ),

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

ES6 සහ විකෘති නොමැතිව: (2016 ඔක්තෝබර්)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

අරාවකින් විශේෂිත මූලද්‍රව්‍යයක් / නූලක් ඉවත් කිරීම එක් ලයිනර් එකකින් කළ හැකිය:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

කොහේද:

theArray : ඔබට විශේෂිත යමක් ඉවත් කිරීමට අවශ්‍ය අරාව

stringToRemoveFromArray : ඔබට ඉවත් කිරීමට අවශ්‍ය නූල සහ 1 යනු ඔබට ඉවත් කිරීමට අවශ්‍ය මූලද්‍රව්‍ය ප්‍රමාණයයි.

සටහන : "stringToRemoveFromArray" ඔබේ අරාවෙහි පිහිටා නොමැති නම්, මෙය අරාවේ අවසාන අංගය ඉවත් කරයි.

එය ඉවත් කිරීමට පෙර, ඔබේ අරාවෙහි මූලද්‍රව්‍යය තිබේදැයි පරීක්ෂා කිරීම සැමවිටම හොඳ පුරුද්දකි.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

ඔබේ සේවාදායකයාගේ පරිගණකවල නවතම එක්ස්මාස්ක්‍රිප්ට් අනුවාද වලට ඔබට ප්‍රවේශය ඇත්නම් (අවවාදයයි, පැරණි ස්ථානවල ක්‍රියා නොකරනු ඇත):

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');

'3' යනු අරාවෙන් ඉවත් කිරීමට ඔබට අවශ්‍ය අගයයි. එවිට අරාව බවට පත්වේ:['1','2','4','5','6']

ජාවාස්ක්‍රිප්ට් භාවිතයෙන් අරාවකින් අයිතමයක් ඉවත් කිරීමට ක්‍රම කිහිපයක් මෙන්න .

විස්තර කර ඇති සියලුම ක්‍රම මඟින් මුල් අරාව විකෘති නොකරන අතර ඒ වෙනුවට නව එකක් සාදන්න.

අයිතමයක දර්ශකය ඔබ දන්නේ නම්

ඔබට අරාවක් තිබේ යැයි සිතමු, ඔබට අවශ්‍ය අයිතමයක් ඉවත් කිරීමට අවශ්‍යය i.

එක් ක්‍රමයක් වන්නේ slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

slice()එයට ලැබෙන දර්ශක සමඟ නව අරාවක් සාදයි. ආරම්භයේ සිට අපට ඉවත් කිරීමට අවශ්‍ය දර්ශකය දක්වා අපි නව අරාවක් සාදන්නෙමු, සහ අරාවෙහි අවසානය දක්වා අප ඉවත් කළ ස්ථානයට පසුව පළමු ස්ථානයේ සිට තවත් අරාවක් සංයුක්ත කරමු.

ඔබ වටිනාකම දන්නවා නම්

මෙම අවස්ථාවේ දී, එක් හොඳ විකල්පයක් භාවිතා කිරීම filter(), එය වඩාත් ප්‍රකාශන ප්‍රවේශයක් ඉදිරිපත් කරයි:

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(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

නැතහොත් ඔබට පැරණි බ්‍රව්සර් වලට වඩා ජීර්ණය කළ හැකි වන පරිදි බාබල් භාවිතා කර ES6 කේතය නැවත ES5 වෙත සම්ප්‍රේෂණය කළ හැකිය, නමුත් ඔබේ කේතයේ නවීන ජාවාස්ක්‍රිප්ට් ලියන්න.

බහු අයිතම ඉවත් කිරීම

තනි අයිතමයක් වෙනුවට, ඔබට බොහෝ අයිතම ඉවත් කිරීමට අවශ්‍ය නම් කුමක් කළ යුතුද?

අපි සරලම විසඳුම සොයා ගනිමු.

දර්ශකය අනුව

ඔබට ශ්‍රිතයක් සාදා ශ්‍රේණියේ අයිතම ඉවත් කළ හැකිය:

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(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

වටිනාකම අනුව

ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතය තුළට ඇතුළත් කිරීම සඳහා ඔබට සෙවිය හැකිය:

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()) මුල් අරාව විකෘති කරන අතර එය වළක්වා ගත යුතුය.

(මුලින් පළ කළේ https://flaviocopes.com/how-to-remove-item-from-array/ )

හරි, උදාහරණයක් ලෙස ඔබට පහත අරාව ඇත:

var num = [1, 2, 3, 4, 5];

අපට අංක 4 මකා දැමීමට අවශ්‍යයි. ඔබට පහත කේතය භාවිතා කළ හැකිය:

num.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];

ඔබ මෙම ශ්‍රිතය නැවත භාවිතා කරන්නේ නම්, ඔබ නැවත භාවිතා කළ හැකි ශ්‍රිතයක් ලියන අතර එය පහත දැක්වෙන පරිදි ස්වදේශීය අරාව ශ්‍රිතයට අමුණා ඇත:

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1)
      return;
  this.splice(i, 1); // num.remove(5) === [1, 2, 3];
}

නමුත් ඔබට අරාවෙහි [5] කිහිපයක් සමඟ පහත අරාව තිබේ නම් කෙසේද?

var num = [5, 6, 5, 4, 5, 1, 5];

ඒවා සියල්ලම පරික්ෂා කිරීමට අපට ලූපයක් අවශ්‍යය, නමුත් වඩා පහසු හා කාර්යක්ෂම ක්‍රමයක් වන්නේ ජාවාස්ක්‍රිප්ට් ශ්‍රිත භාවිතා කිරීමයි, එබැවින් අපි පහත දැක්වෙන ආකාරයට පෙරනයක් භාවිතා කරන ශ්‍රිතයක් ලියන්නෙමු:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]

ලොඩාෂ් හෝ අන්ඩර්ස්කෝර් වැනි තෙවන පාර්ශවීය පුස්තකාලද ඔබට මෙය කිරීමට උපකාරී වේ. වැඩි විස්තර සඳහා, lodash _.pull, _.pullAt හෝ _.without දෙස බලන්න.

මම ජාවාස්ක්‍රිප්ට් වලට අලුත් ය, මෙම ක්‍රියාකාරිත්වය අවශ්‍ය විය. මම මෙය ලිව්වේ:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

මට එය භාවිතා කිරීමට අවශ්‍ය වූ විට:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

ප්‍රතිදානය - අපේක්ෂා කළ පරිදි. ["item1", "item1"]

ඔබට මට වඩා වෙනස් අවශ්‍යතා තිබිය හැක, එබැවින් ඔබට පහසුවෙන් ඒවා ගැලපෙන පරිදි වෙනස් කළ හැකිය. මම හිතනවා මේක කෙනෙකුට උදව් කරයි කියලා.

ඔබට අරාවෙහි සංකීර්ණ වස්තු තිබේ නම් ඔබට පෙරහන් භාවිතා කළ හැකිද? In .inArray හෝ array.splice භාවිතා කිරීම පහසු නොවන අවස්ථාවන්හිදී. විශේෂයෙන් වස්තූන් අරාවෙහි නොගැඹුරු නම්.

උදා: ඔබට හැඳුනුම් ක්ෂේත්‍රයක් සහිත වස්තුවක් තිබේ නම් සහ වස්තුව අරාවකින් ඉවත් කිරීමට ඔබට අවශ්‍ය නම්:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

ECMAScript 6 මත පදනම්ව මට පිළිතුරු දීමට අවශ්‍යයි . උපකල්පනය කරන්න, ඔබට පහත දැක්වෙන අරා එකක් ඇත:

let arr = [1,2,3,4];

ඔබට විශේෂ දර්ශකයකින් මකා දැමීමට අවශ්‍ය නම් 2, පහත කේතය ලියන්න:

arr.splice(2, 1); //=> arr became [1,2,4]

නමුත් ඔබට විශේෂ අයිතමයක් මකා දැමීමට අවශ්‍ය නම් 3සහ එහි දර්ශකය ඔබ නොදන්නේ නම්, පහත පරිදි කරන්න:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

ඉඟිය : ඔබට හිස් අරාවක් නොලැබෙන්නේ නම් කරුණාකර පෙරහන් ඇමතුම් සඳහා ඊතල ශ්‍රිතයක් භාවිතා කරන්න.

යාවත්කාලීන කිරීම: මෙම ක්‍රමය නිර්දේශ කරනුයේ ඔබට ECMAScript 2015 (කලින් ES6 ලෙස හැඳින්වූ) භාවිතා කළ නොහැකි නම් පමණි. ඔබට එය භාවිතා කළ හැකි නම්, මෙහි ඇති වෙනත් පිළිතුරු බොහෝ පිළිවෙලට ක්‍රියාත්මක කරයි.

මෙහි ඇති මෙම සාරාංශය ඔබගේ ගැටළුව විසඳනු ඇති අතර තර්කයේ සියලු සිදුවීම් 1 වෙනුවට (හෝ නිශ්චිත අගයක්) මකා දමනු ඇත.

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

භාවිතය:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]

කාර්ය සාධනය

අද (2019-12-09) තෝරාගත් විසඳුම් සඳහා මම macOS v10.13.6 (High Sierra) හි කාර්ය සාධන පරීක්ෂණ පවත්වමි. මම delete(A) පෙන්වන නමුත් වෙනත් ක්‍රම සමඟ සැසඳීමේදී මම එය භාවිතා නොකරමි, මන්ද එය අරාවෙහි හිස් ඉඩක් ඉතිරි කර ඇති බැවිනි.

නිගමන

• වේගවත්ම විසඳුම වන්නේ array.splice(සී) (දෙවන වරට කුඩා අරා සඳහා සෆාරි හැර)
• විශාල අරා සඳහා, array.slice+splice(එච්) ෆයර්ෆොක්ස් සහ සෆාරි සඳහා වේගවත්ම වෙනස් කළ නොහැකි විසඳුමයි; Array.from(ආ) ක්‍රෝම් හි වේගවත්ම වේ
• විකෘති විසඳුම් සාමාන්‍යයෙන් වෙනස් කළ නොහැකි ප්‍රමාණයට වඩා 1.5x-6x වේගවත් වේ
• සෆාරි හි කුඩා වගු සඳහා, විකෘති ද්‍රාවණය (සී) වෙනස් කළ නොහැකි විසඳුමට (ජී) වඩා මන්දගාමී වේ.

විස්තර

පරීක්ෂණ වලදී මම විවිධාකාරයෙන් අරාව වෙතින් මැද මූලද්‍රව්‍යය ඉවත් කරමි. මෙම A, C විසඳුම්-ස්ථානය වේ. මෙම බී, ඩී, ඊ, එෆ්, ජී, H විසඳුම් හා අණුවල පැවැත්ම වේ.

මූලද්රව්ය 10 ක් සහිත අරාව සඳහා ප්රති Results ල

ක්‍රෝම් හි array.splice(සී) වේගවත්ම විසඳුම වේ. මෙම array.filter(D) වේගවත්ම හා අණුවල පැවැත්ම විසඳුම. මන්දගාමී වන්නේ array.slice(F) ය. ඔබේ යන්ත්‍රය මත ඔබට මෙහි පරීක්ෂණය සිදු කළ හැකිය .

මූලද්රව්ය 1.000.000 සමඟ අරාව සඳහා ප්රති Results ල

ක්‍රෝම් හි array.splice(සී) වේගවත්ම ස්ථානීය විසඳුමයි ( delete(සී) සමාන වේගවත් වේ - නමුත් එය අරාවෙහි හිස් තට්ටුවක් ඉතිරි කර ඇත (එබැවින් එය 'පූර්ණ ඉවත් කිරීමක්' සිදු නොකරයි)). මෙම array.slice-splice(H) වේගවත්ම හා අණුවල පැවැත්ම විසඳුම. මන්දගාමී වන්නේ array.filter(D සහ E) ය. ඔබේ යන්ත්‍රය මත ඔබට මෙහි පරීක්ෂණය සිදු කළ හැකිය .

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);

This snippet only presents code used in performance tests - it does not perform tests itself.

බ්‍රව්සර් සඳහා සංසන්දනය: ක්‍රෝම් v78.0.0, සෆාරි v13.0.4, සහ ෆයර්ෆොක්ස් v71.0.0

ඔබ කිසි විටෙකත් ඔබේ අරාව විකෘති නොකළ යුතුය. මෙය ක්‍රියාකාරී ක්‍රමලේඛ රටාවට පටහැනි බැවින්. ECMAScript 6 ක්‍රමය භාවිතා කිරීමේ දත්ත වෙනස් කිරීමට ඔබට අවශ්‍ය අරාව සඳහන් නොකර ඔබට නව අරාවක් සෑදිය හැකිය filter;

var myArray = [1, 2, 3, 4, 5, 6];

ඔබට 5අරාවෙන් ඉවත් කිරීමට අවශ්‍ය යැයි සිතමු , ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

myArray = myArray.filter(value => value !== 5);

ඔබට ඉවත් කිරීමට අවශ්‍ය අගය නොමැතිව මෙය නව අරාවක් ලබා දෙනු ඇත. එබැවින් ප්රති result ලය වනු ඇත්තේ:

 [1, 2, 3, 4, 6]; // 5 has been removed from this array

වැඩිදුර අවබෝධ කර ගැනීම සඳහා ඔබට Array.filter හි MDN ප්‍රලේඛනය කියවිය හැකිය .

වඩාත් නවීන, ECMAScript 2015 (කලින් හැඳින්වූයේ Harmony හෝ ES 6) ප්‍රවේශයකි. ලබා දී ඇත්තේ:

const items = [1, 2, 3, 4];
const index = 2;

ඉන්පසු:

items.filter((x, i) => i !== index);

අස්වැන්න:

[1, 2, 4]

බ්‍රව්සර් හරහා මෙය හොඳින් සහාය වන බව සහතික කිරීම සඳහා ඔබට බාබෙල් සහ පොලිෆිල් සේවාවක් භාවිතා කළ හැකිය .

ඔබට අරාවෙහි 1 සිට 9 දක්වා ඇති අතර ඔබට ඉවත් කිරීමට අවශ්‍ය 5. පහත කේතය භාවිතා කරන්න:

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

ඔබට බහු අගයන් අවශ්‍ය නම්. උදාහරණය: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 1,7 and 8 removed", newNumberArray);

ඔබට අරාවෙහි අරාව අගයක් ඉවත් කිරීමට අවශ්‍ය නම්. උදාහරණය: [3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

සහාය දක්වන බ්‍රව්සරය සබැඳිය ඇතුළත් වේ .

මේ වන විටත් පිළිතුරු රාශියක් ඇති බව මම දනිමි, නමුත් ඒවායින් බොහොමයක් ගැටලුව සංකීර්ණ කර ඇති බව පෙනේ. යතුරක සියලු අවස්ථා ඉවත් කිරීමේ සරල, පුනරාවර්තන ක්‍රමයක් මෙන්න - දර්ශකය සොයාගත නොහැකි වන තෙක් ස්වයං ඇමතුම්. ඔව්, එය ක්‍රියාත්මක වන්නේ බ්‍රව්සර් සමඟ පමණිindexOf , නමුත් එය සරල වන අතර පහසුවෙන් පොලිෆිල් කළ හැකිය.

තනිවම ක්‍රියා කිරීම

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

මූලාකෘති ක්‍රමය

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}

මූලද්‍රව්‍යයේ බහුවිධ අවස්ථා තිබේ නම්, දර්ශක ඉස්කුරුප්පු නොකිරීමට වග බලා ගැනීම සඳහා ඔබට පසුගාමී ලූපයක් කළ හැකිය.

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

සජීවී නිරූපණය