arrays - كيف أقوم بإزالة عنصر معين من صفيف في JavaScript؟




(25)

لدي مجموعة من الأعداد الصحيحة ، وأنا أستخدم طريقة .push() لإضافة عناصر إليها.

هل هناك طريقة بسيطة لإزالة عنصر معين من صفيف؟ أي ما يعادل شيئًا مثل array.remove(int); .

لا بد لي من استخدام جافا سكريبت الأساسية - لا يسمح أطر العمل.


Answers

ES6 وبدون طفرة: (أكتوبر 2016)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

ثم :

removeByIndex([33,22,11,44],1) //=> [33,11,44]

يجب عليك أبدا تحور صفيف صفيف الخاص بك. لأن هذا ضد نمط البرمجة الوظيفية. ما يمكنك القيام به هو إنشاء مصفوفة جديدة دون الإشارة إلى المصفوفة التي تريد تغيير بيانات استخدام filter أسلوب es6؛

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

لنفترض أنك تريد إزالة 5 من المصفوفة ، يمكنك القيام بذلك ببساطة.

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

سيعطيك هذا صفيفًا جديدًا بدون القيمة التي تريد إزالتها. لذلك ستكون النتيجة

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

لمزيد من الفهم ، يمكنك قراءة وثائق MDN على Array.filter filter


يمكن استخدام Underscore.js لحل المشكلات مع متصفحات متعددة. ويستخدم أساليب متصفح البناء في حالة وجودها. إذا كانوا غائبين مثل في حالة إصدارات Internet Explorer القديمة ، فإنه يستخدم أساليب مخصصة خاصة به.

مثال بسيط لإزالة العناصر من الصفيف (من موقع الويب):

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

قديم جدًا للرد ، ولكن قد يساعد شخصًا ما ، من خلال تقديم قيمة مساوية بدلاً من القيمة.

ملاحظة: سيتم تحديث الصفيف المحدد وإرجاع الصفوف المتأثرة

استعمال

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;
    }
};

استنادًا إلى جميع الإجابات التي كانت صحيحة بشكل أساسي ومراعاة أفضل الممارسات المقترحة (لا سيما استخدام Array.prototype مباشرةً) ، توصلت إلى الشفرة التالية:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

مراجعة الوظيفة المذكورة أعلاه ، على الرغم من حقيقة أنه يعمل بشكل جيد ، أدركت أنه يمكن أن يكون هناك بعض التحسن في الأداء. أيضا استخدام ES6 بدلا من ES5 هو نهج أفضل بكثير. تحقيقا لهذه الغاية ، هذه هي الكود المحسن:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

كيف تستعمل:

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

أقوم حاليًا بكتابة مشاركة مدونة قمت فيها بمقارنة عدة حلول لـ Array بدون مشكلة وقارنت الوقت المستغرق لتشغيله. سأقوم بتحديث هذه الإجابة بالرابط بمجرد أن أنتهي من هذه المشاركة. فقط لإعلامك ، لقد قارنت ما سبق من دون lodash وفي حالة دعم المستعرض Map، فإنه يدق lodash! لاحظ أني لا أستخدم Array.prototype.indexOfأو Array.prototype.includesألصق exlcudeValues ​​في Mapأو Objectيجعل الاستعلام أسرع! ( https://jsperf.com/array-without-benchmark-against-lodash )


ابحث عن index عنصر الصفيف الذي تريد إزالته ، ثم أزل هذا الفهرس مع splice .

تقوم طريقة splice () بتغيير محتويات الصفيف عن طريق إزالة العناصر الموجودة و / أو إضافة عناصر جديدة.

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

المعلمة الثانية من splice هو عدد العناصر المراد إزالتها. لاحظ أن splice يعدل الصفيف في المكان ويعيد مصفوفة جديدة تحتوي على العناصر التي تمت إزالتها.

ملاحظة : دعم المتصفح لـ indexOf محدود ؛ غير معتمد في Internet Explorer 7 و 8.

إذا كنت بحاجة إلى indexOf في متصفح غير مدعوم ، فجرّب polyfill التالي. العثور على مزيد من المعلومات حول هذا polyfill هنا .

Array.prototype.indexOf || (Array.prototype.indexOf = function(d, e) {
    var a;
    if (null == this) throw new TypeError('"this" is null or not defined');
    var c = Object(this),
        b = c.length >>> 0;
    if (0 === b) return -1;
    a = +e || 0;
    Infinity === Math.abs(a) && (a = 0);
    if (a >= b) return -1;
    for (a = Math.max(0 <= a ? a : b - Math.abs(a), 0); a < b;) {
        if (a in c && c[a] === d) return a;
        a++
    }
    return -1
});

يمكنك استخدام ES6.

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

انتاج :

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

يمكنك استخدام lodash _.pull (صفيف _.pullAt ) أو _.without (صفيف _.without ) أو _.without (لا يتم تحويل صفيف) ،

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']

ليست هناك حاجة لاستخدام 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 (indexof):

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);
    }
  }
}

أوقات التشغيل على nodejs للمصفوفة التي تحتوي على 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 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]


A أكثر حداثة ، ECMAScript 2015 (المعروف سابقا باسم الوئام أو ES 6) النهج. معطى:

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

ثم:

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

العائد:

[1, 2, 4]

يمكنك استخدام خدمة Babel و polyfill لضمان دعم هذا بشكل جيد عبر المتصفحات.


كان صديق يواجه مشاكل في Internet Explorer 8 ، وأظهر لي ما فعله. قلت له أنه كان خطأ ، وقال لي أنه حصل على الجواب هنا. لن تعمل الإجابة الأعلى الحالية في جميع المتصفحات (Internet Explorer 8 على سبيل المثال) ، وستقوم فقط بإزالة التواجد الأول للعنصر.

قم بإزالة كافة المثيلات من صفيف

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

يتدفق عبر الصفيف للخلف (بما أن الفهارس والطول سيتغيران عند إزالة العناصر) ويزيل العنصر إذا تم العثور عليه. يعمل في جميع المتصفحات.


تم تحريره في 2016 أكتوبر

  • افعل ذلك بطريقة بسيطة وبديهية وصريحة ( https://en.wikipedia.org/wiki/Occam%27s_razor )
  • هل هي غير قابلة للتغيير (تبقى المجموعة الأصلية دون تغيير)
  • افعل ذلك بوظائف JS القياسية ، إذا كان متصفحك لا يدعمها - استخدم polyfill

في هذا المثال ، استخدم وظيفة "array.filter (...)" لإزالة العناصر غير المرغوب فيها من المصفوفة ، وهذه الوظيفة لا تغير الصفيف الأصلي وتنشئ واحدة جديدة. إذا كان متصفحك لا يدعم هذه الوظيفة (على سبيل المثال ، IE قبل الإصدار 9 ، أو Firefox قبل الإصدار 1.5) ، فكر في استخدام مرشح الترشيح من Mozilla .

إزالة العنصر (ECMA-262 Edition 5 code aka oldstyle JS)

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 ]

إزالة عنصر (كود ES2015)

let value = 3

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

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

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

IMPORTANT ES2015 "() => {}" صيغة الدالة arrow arrow غير مدعومة في IE على الإطلاق ، Chrome قبل إصدار 45 ، Firefox قبل الإصدار 22 ، Safari قبل الإصدار 10. لاستخدام صيغة ES2015 في المتصفحات القديمة ، يمكنك استخدام BabelJS

إزالة عناصر متعددة (رمز ES2016)

ميزة إضافية من هذه الطريقة هي أنه يمكنك إزالة عناصر متعددة

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 (...)" وظيفة غير مدعومة في IE على الإطلاق ، Chrome قبل إصدار 47 ، و Firefox قبل الإصدار 43 ، و Safari قبل الإصدار 9 و Edge قبل الإصدار 14 ، لذلك ، هنا هو polyfill من Mozilla

إزالة عناصر متعددة (تجريبية JavaScript ES2018؟)

// 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 ]

جربه بنفسك في BabelJS :)

مرجع


يعتمد على ما إذا كنت تريد الاحتفاظ بمكان فارغ أم لا.

إذا كنت ترغب في الحصول على فتحة فارغة ، فستكون الحذف أمرًا جيدًا:

delete array[ index ];

إذا لم تقم بذلك ، يجب عليك استخدام طريقة splice :

array.splice( index, 1 );

وإذا كنت بحاجة إلى قيمة هذا العنصر ، فيمكنك فقط تخزين عنصر الصفيف المرتجع:

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

في حال كنت ترغب في القيام بذلك في بعض الترتيب ، يمكنك استخدام array.pop() لآخر واحد أو array.shift() لأول واحد (وكلاهما إرجاع قيمة العنصر أيضا).

وإذا كنت لا تعرف فهرس العنصر ، يمكنك استخدام array.indexOf( item ) للحصول عليه (في if() للحصول على عنصر واحد أو في while() للحصول على كل منهم). array.indexOf( item ) إما الفهرس أو -1 إذا لم يتم العثور على.


التحديث: ينصح بهذا الأسلوب فقط إذا لم تتمكن من استخدام ECMAScript 2015 (المعروف سابقًا باسم ES6). إذا كنت تستطيع استخدامها ، فإن الإجابات الأخرى هنا توفر عمليات تنفيذ أكثر دقة.

هذا gist هنا سوف تحل مشكلتك ، وأيضا يحذف جميع تكرارات الوسيطة بدلا من 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]

في ما يلي بعض الطرق لإزالة عنصر من صفيف باستخدام جافا سكريبت .

لا تقوم كافة الطرق الموضحة بتحويل الصفيف الأصلي ، وبدلاً من ذلك قم بإنشاء صفيف جديد.

إذا كنت تعرف فهرس عنصر

افترض أن لديك صفيف ، وتريد إزالة عنصر في الموضع i .

تتمثل إحدى الطرق في استخدام slice() :

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() بإنشاء صفيف جديد مع الفهارس التي يتلقاها. نقوم ببساطة بإنشاء مصفوفة جديدة ، بدءًا من البداية وحتى الفهرس الذي نريد إزالته ، وسَلسَلة صفيف آخر من الموضع الأول بعد الموضع الذي أزلناه إلى نهاية المصفوفة.

إذا كنت تعرف القيمة

في هذه الحالة ، يكون أحد الخيارات الجيدة هو استخدام 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 لجعلها أكثر قابلية للهضم إلى المتصفحات القديمة ، مع كتابة 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(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] s في المصفوفة؟

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 أو Underscore ، للحصول على مزيد من المعلومات ، انظر إلى 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"]

قد يكون لديك احتياجات مختلفة عني ، لذلك يمكنك بسهولة تعديلها لتناسبها. آمل أن يساعد هذا شخصًا ما.


لا أعرف كيف تتوقع أن تتصرف 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];

تحقق من هذا الرمز. وهو يعمل في كل متصفح رئيسي .

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);

يمكنك إجراء حلقة للخلف للتأكد من عدم فك مؤشر الفهارس ، إذا كانت هناك مثيلات متعددة للعنصر.

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);
}

عرض حي


يمكنك القيام بذلك بسهولة باستخدام طريقة filter :

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

هذا يزيل جميع العناصر من المصفوفة ويعمل أيضا أسرع ثم مزيج من شريحة و indexOf


لديك مجموعة من 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, 5 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);

يتضمن متصفح معتمد هو link


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)


باستخدام ES6 ، استخدم مشغل التوزيع ... :

DEMO

var arr = [23, 45, 12, 67];
arr = [34, ...arr]; // RESULT : [34,23, 45, 12, 67]

console.log(arr)





javascript arrays