حذف عناصر المصفوفة في JavaScript - حذف مقابل لصق

StackOverflow https://stackoverflow.com/questions/500606

سؤال

ما هو الفرق بين استخدام ال delete المشغل أو العامل على عنصر الصفيف بدلاً من الاستخدام ال Array.splice طريقة?

على سبيل المثال:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

لماذا حتى يكون لدي طريقة لصق إذا كان بإمكاني حذف عناصر المصفوفة كما أستطيع مع الكائنات؟

هل كانت مفيدة؟

المحلول

delete سيتم حذف خاصية الكائن، ولكن لن يتم إعادة فهرسة المصفوفة أو تحديث طولها.وهذا يجعلها تبدو وكأنها غير محددة:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

لاحظ أنه لم يتم تعيينه في الواقع على القيمة undefined, ، بل تتم إزالة الخاصية من المصفوفة، مما يجعلها يظهر غير معرف.توضح أدوات تطوير Chrome هذا التمييز من خلال الطباعة empty عند تسجيل المصفوفة.

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) في الواقع، يزيل العنصر، ويعيد فهرسة المصفوفة، ويغير طولها.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

نصائح أخرى

طريقة Array.remove()

جون ريسيج, ، أنشأ منشئ jQuery أداة سهلة الاستخدام للغاية Array.remove الطريقة التي أستخدمها دائمًا في مشاريعي.

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

وإليك بعض الأمثلة على كيفية استخدامها:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

موقع جون

نظرًا لأن الحذف يزيل فقط الكائن من العنصر الموجود في المصفوفة، فلن يتغير طول المصفوفة.يقوم Splice بإزالة الكائن وتقصير المصفوفة.

سيعرض الكود التالي "أ"، "ب"، "غير محدد"، "د"

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

حيث أن هذا سيعرض "أ" و"ب" و"د"

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

لقد عثرت على هذا السؤال أثناء محاولتي فهم كيفية إزالة كل تكرار لعنصر من المصفوفة. وهنا المقارنة ل splice و delete لإزالة كل 'c' من items مجموعة مصفوفة.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

من مرجع JavaScript 1.5 الأساسي > المشغلون > المشغلون الخاصون > حذف المشغل :

عند حذف عنصر صفيف ، لا يتأثر طول الصفيف.على سبيل المثال ، إذا قمت بحذف A [3] ، فإن A [4] لا يزال [4] و [3] غير محدد.هذا يحمل حتى لو قمت بحذف العنصر الأخير من الصفيف (حذف [A.Length-1]).

splice سوف تعمل مع المؤشرات الرقمية.

بينما delete يمكن استخدامها ضد نوع آخر من المؤشرات ..

مثال:

delete myArray['text1'];

ربما تجدر الإشارة أيضًا إلى أن splice يعمل فقط على المصفوفات.(لا يمكن الاعتماد على خصائص الكائن لاتباع ترتيب ثابت.)

لإزالة زوج المفتاح والقيمة من كائن ما، فإن الحذف هو في الواقع ما تريده: 

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

كما ذكرنا عدة مرات أعلاه، باستخدام splice() يبدو وكأنه مناسبا تماما. التوثيق في موزيلا:

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

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

بناء الجملة

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

حدود

يبدأ

الفهرس الذي يبدأ عنده تغيير المصفوفة.إذا كان أكبر من طول المصفوفة، فسيتم تعيين فهرس البداية الفعلي على طول المصفوفة.وإذا كان سلبيا، فسوف تبدأ عناصر كثيرة من النهاية.

deleteCount

عدد صحيح يشير إلى عدد عناصر المصفوفة القديمة المطلوب إزالتها.إذا كانت قيمةdeleteCount تساوي 0، فلن تتم إزالة أي عناصر.في هذه الحالة، يجب عليك تحديد عنصر جديد واحد على الأقل.إذا كانdeleteCount أكبر من عدد العناصر المتبقية في المصفوفة بدءًا من البداية، فسيتم حذف جميع العناصر حتى نهاية المصفوفة.

إذا تم حذفdeleteCount، فسيكونdeleteCount مساويًا لـ (arr.length - start).

البند 1، البند 2، ...

العناصر المراد إضافتها إلى المصفوفة، بدءًا من فهرس البداية.إذا لم تحدد أي عناصر، splice() سيؤدي فقط إلى إزالة العناصر من المصفوفة.

قيمة الإرجاع

مصفوفة تحتوي على العناصر المحذوفة.إذا تمت إزالة عنصر واحد فقط، فسيتم إرجاع مصفوفة من عنصر واحد.إذا لم تتم إزالة أي عناصر، فسيتم إرجاع مصفوفة فارغة.

[...]

حذف مقابل لصق

عندما تقوم بحذف عنصر من مصفوفة

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

عند لصق

var arr = [1,2,3,4]; arr.splice(1,1); //result [1, 3, 4]
console.log(arr);

في حالة يمسح ال يتم حذف العنصر لكن ال يبقى الفهرس فارغا

بينما في حالة لصق او جمع يتم حذف العنصر و يتم تقليل مؤشر عناصر الراحة وفقًا لذلك

يمسح يتصرف مثل الوضع غير الحقيقي في العالم، إنه مجرد يزيل العنصر، لكن طول المصفوفة يظل كما هو:

مثال من محطة العقدة:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

فيما يلي دالة لإزالة عنصر من مصفوفة حسب الفهرس باستخدام شريحة(), ، فإنه يأخذ arr باعتباره الوسيط الأول، وفهرس العضو الذي تريد حذفه باعتباره الوسيط الثاني.كما ترون، فإنه في الواقع يحذف عضو المصفوفة، وسيقلل طول المصفوفة بمقدار 1

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

ما تفعله الوظيفة أعلاه هو أخذ جميع الأعضاء إلى الفهرس، وجميع الأعضاء بعد الفهرس، وربطهم معًا، وإرجاع النتيجة.

فيما يلي مثال لاستخدام الوظيفة أعلاه كوحدة عقدة، وستكون رؤية الوحدة الطرفية مفيدة:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

يرجى ملاحظة أن هذا لن يعمل على مصفوفة واحدة تحتوي على نسخ مكررة، لأن IndexOf("c") سيحصل فقط على أول ظهور، وسيقوم فقط بربط وإزالة أول "c" الذي يجده.

إذا كنت تريد تكرار مصفوفة كبيرة وحذف العناصر بشكل انتقائي، فسيكون من المكلف استدعاء splice() لكل عملية حذف لأن splice() سيتعين عليها إعادة فهرسة العناصر اللاحقة في كل مرة.نظرًا لأن المصفوفات ترابطية في Javascript، فسيكون حذف العناصر الفردية ثم إعادة فهرسة المصفوفة بعد ذلك أكثر فعالية.

يمكنك القيام بذلك عن طريق بناء مجموعة جديدة.على سبيل المثال

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

لكنني لا أعتقد أنه يمكنك تعديل القيم الأساسية في المصفوفة الأصلية، الأمر الذي سيكون أكثر كفاءة - يبدو أنك قد تضطر إلى إنشاء مصفوفة جديدة.

لاحظ أنك لا تحتاج إلى التحقق من الإدخالات "غير المحددة" لأنها غير موجودة بالفعل ولا تقوم حلقة for بإرجاعها.إنها قطعة أثرية من طباعة المصفوفة التي تعرضها على أنها غير محددة.لا يبدو أنهم موجودون في الذاكرة.

سيكون من الرائع أن تتمكن من استخدام شيء مثل Slice() والذي سيكون أسرع، لكنه لا يعيد الفهرسة.هل يعرف أحد طريقة أفضل؟

في الواقع، ربما يمكنك القيام بذلك على النحو التالي والذي ربما يكون أكثر كفاءة من حيث الأداء:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

يمكنك استخدام شيء من هذا القبيل

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]

لماذا لا يتم التصفية فقط؟أعتقد أن هذه هي الطريقة الأكثر وضوحًا للنظر في المصفوفات في JS.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

مثال:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

يتم حذف الموز وطول المصفوفة = 2

إنها أشياء مختلفة لها أغراض مختلفة.

splice خاص بالمصفوفة، وعند استخدامه للحذف، فإنه يزيل الإدخالات من المصفوفة و ينقل كافة الإدخالات السابقة لأعلى لملء الفجوة.(يمكن استخدامه أيضًا لإدراج الإدخالات، أو كليهما في نفس الوقت.) splice سوف يغير length من المصفوفة (بافتراض أنها ليست مكالمة no-op: theArray.splice(x, 0)).

delete ليست خاصة بالصفيف؛إنه مصمم للاستخدام على الكائنات:يقوم بإزالة خاصية (زوج المفتاح/القيمة) من الكائن الذي تستخدمه عليه.ينطبق هذا فقط على المصفوفات لأن المصفوفات القياسية (على سبيل المثال، غير المكتوبة) في JavaScript ليست حقا صفائف على الإطلاق*، فهي كائنات ذات معالجة خاصة لخصائص معينة، مثل تلك التي تكون أسماؤها عبارة عن "فهارس المصفوفات" (وهي مُعرف كأسماء سلسلة "... قيمتها الرقمية i يقع في النطاق +0 ≤ i < 2^32-1") و length.عندما تستخدم delete لإزالة إدخال مصفوفة، كل ما يفعله هو إزالة الإدخال؛ولا يقوم بنقل الإدخالات الأخرى التي تتبعه لملء الفجوة، وبالتالي يصبح المصفوفة "متناثرة" (تفقد بعض الإدخالات بالكامل).ليس له أي تأثير على length.

تشير بعض الإجابات الحالية على هذا السؤال بشكل غير صحيح إلى أن الاستخدام delete "يحدد الإدخال إلى undefined".هذا غير صحيح.هو - هي يزيل دخول (الملكية) تماما، وترك فجوة.

دعونا نستخدم بعض التعليمات البرمجية لتوضيح الاختلافات:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

* (هذا منشور على مدونتي الصغيرة التي تعاني من فقر الدم)

حاليا هناك طريقتان للقيام بذلك

  1. باستخدام لصق ()

    arrayObject.splice(index, 1);

  2. باستخدام الحذف

    delete arrayObject[index];

لكنني أقترح دائمًا استخدام لصق لكائنات المصفوفة وحذف لسمات الكائن لأن الحذف لا يؤدي إلى تحديث طول المصفوفة.

يمكن ملاحظة الفرق من خلال تسجيل طول كل صفيف بعد delete المشغل و splice() يتم تطبيق الطريقة.على سبيل المثال:

حذف المشغل

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

ال delete يقوم عامل التشغيل بإزالة العنصر من المصفوفة، لكن "العنصر النائب" للعنصر لا يزال موجودًا. oak تمت إزالته ولكنه لا يزال يشغل مساحة في المصفوفة.وبسبب هذا، يبقى طول المصفوفة 5.

طريقة لصق ().

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

ال splice() الطريقة تزيل القيمة المستهدفة تمامًا و "العنصر النائب" أيضًا. oak تمت إزالته بالإضافة إلى المساحة التي كان يشغلها في المصفوفة.طول المصفوفة الآن 4.

حسنًا، تخيل أن لدينا هذه المصفوفة أدناه:

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

لنقم بالحذف أولاً:

delete arr[1];

وهذه هي النتيجة:

[1, empty, 3, 4, 5];

فارغ! ودعنا نحصل عليه:

arr[1]; //undefined

يعني ذلك فقط القيمة المحذوفة وهي غير معرف الآن، الطول هو نفسه، وسيعود أيضًا حقيقي...

دعونا نعيد ضبط مصفوفتنا ونقوم بذلك باستخدام الوصلة هذه المرة:

arr.splice(1, 1);

وهذه هي النتيجة هذه المرة:

[1, 3, 4, 5];

كما ترون تغير طول المصفوفة و arr[1] يكون 3 الآن...

سيؤدي هذا أيضًا إلى إرجاع العنصر المحذوف في صفيف وهو [3] في هذه الحالة...

أسهل طريقة هي على الأرجح 

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

أتمنى أن يساعدك هذا.مرجع: https://lodash.com/docs#compact

بالنسبة لأولئك الذين يريدون استخدام لوداش يمكن استخدام:myArray = _.without(myArray, itemToRemove)

أو كما أستخدم في Angular2

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

يمسح:سيقوم Delete بحذف خاصية الكائن ، ولكن لن يكرم الصفيف أو تحديث طوله.هذا يجعله يبدو كما لو أنه غير محدد:

لصق او جمع:في الواقع يزيل العنصر ، ويؤدي إلى صفيف ، ويغير طوله.

حذف العنصر من الأخير 

arrName.pop();

حذف العنصر من الأول 

arrName.shift();

حذف من الوسط

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

حذف عنصر واحد من الأخير

arrName.splice(-1);

الحذف باستخدام رقم فهرس الصفيف

 delete arrName[1];

إذا كان العنصر المطلوب حذفه موجودًا في المنتصف (على سبيل المثال، نريد حذف 'c'، والذي يكون فهرسه 1)، فيمكنك استخدام:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

IndexOf يقبل أيضًا نوعًا مرجعيًا.لنفترض السيناريو التالي:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

بشكل مختلف:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// نتيجة :myArray = ['b', 'c', 'd'];

مرخصة بموجب: CC-BY-SA مع الإسناد
لا تنتمي إلى StackOverflow
scroll top