javascript-objects - كيف أقوم بإزالة خاصية من كائن JavaScript؟




object-properties (25)

قل أن أقوم بإنشاء كائن على النحو التالي:

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

ما هي أفضل طريقة لإزالة الخاصية regex حتى ينتهي بـ myObject الجديد كما يلي؟

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};

Answers

في developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… هو أفضل طريقة للقيام بذلك.

مثال حي لإظهاره:

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.

جاء ECMAScript 2015 (أو ES6) مع كائن Reflect المضمنة . من الممكن حذف خاصية الكائن عن طريق استدعاء Reflect.deleteProperty() مع الكائن الهدف ومفتاح الخاصية كمعلمات:

Reflect.deleteProperty(myJSONObject, 'regex');

وهو ما يعادل:

delete myJSONObject['regex'];

ولكن إذا لم تكن خاصية الكائن قابلة للتكوين ، فلا يمكن حذفها لا باستخدام وظيفة deleteProperty ولا حذف المشغل:

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

Object.freeze()يجعل Object.freeze() كافة خصائص الكائن غير قابلة للتكوين (بالإضافة إلى أشياء أخرى). deletePropertyالدالة (وكذلك developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ) falseعند محاولة حذف أي من خصائصه. إذا كانت الخاصية قابلة للتكوين ، فإنها تعود true، حتى إذا كانت الخاصية غير موجودة.

الفرق بين deleteو deletePropertyوعند استخدام طريقة صارم:

"use strict";

let obj = Object.freeze({ prop: "value" });
Reflect.deleteProperty(obj, "prop"); // false
delete obj["prop"];
// TypeError: property "prop" is non-configurable and can't be deleted

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

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

var obj = {"property":"value", "property2":"value"};

if (obj && obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}

نظرًا للطبيعة الديناميكية لجافا سكريبت ، غالبًا ما تكون هناك حالات لا تعرف فيها ببساطة ما إذا كان العقار موجودًا أم لا. التحقق من وجود obj قبل && & يضمن أيضا عدم رمي خطأ بسبب استدعاء الدالة hasOwProperty () على كائن غير معرف.

عذرًا إذا لم يضف ذلك إلى حالة الاستخدام المحددة الخاصة بك ولكنني أعتقد أن هذا التصميم جيد للتكيف عند إدارة الكائنات وخصائصها.


جرب الطريقة التالية. قم بتعيين Objectقيمة الخاصية إلى undefined. ثم stringifyالكائن و parse.

 var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);


باستخدام ramda#dissoc ستحصل على كائن جديد بدون السمة regex:

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

يمكنك أيضا استخدام وظائف أخرى لتحقيق نفس التأثير - حذف ، اختيار ، ...


بديل آخر هو استخدام المكتبة Underscore.js .

لاحظ أن _.pick() و _.omit() بإرجاع نسخة من الكائن وعدم تعديل الكائن الأصلي مباشرة. يجب أن يؤدي تعيين النتيجة إلى الكائن الأصلي إلى الحيلة (غير معروض).

المرجع: link _.pick (الكائن ، * المفاتيح)

قم بإرجاع نسخة من الكائن ، تمت تصفيته بحيث لا يحتوي إلا على قيم لمفاتيح القائمة البيضاء (أو مجموعة من المفاتيح الصالحة).

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

المرجع: link _.omit (الكائن ، * المفاتيح)

قم بإرجاع نسخة من الكائن ، تمت تصفيتها لإلغاء مفاتيح القائمة السوداء (أو مجموعة من المفاتيح).

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

للصفائف ، يمكن استخدام _.filter() و _.reject() بطريقة مماثلة.


باستخدام ES6:

(مشغل Destructuring + Spread)

    const myObject = {
      regex: "^http://.*",
      b: 2,
      c: 3
    };
    const { regex, ...noRegex } = myObject;
    console.log(noRegex); // => { b: 2, c: 3 }

يمكنك ببساطة حذف أي خاصية كائن باستخدام deleteالكلمة الأساسية.

فمثلا:

var obj = {key1:"val1",key2:"val2",key3:"val3"}

لإزالة أي موقع ، قل key1، استخدم deleteالكلمة الرئيسية مثل هذا:

delete obj.key1

أو يمكنك أيضًا استخدام الترميز الشبيه بالمصفوفة:

delete obj[key1]

المرجع: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .


يعد استخدام طريقة الحذف أفضل طريقة للقيام بذلك ، وفقًا لوصف MDN ، يقوم عامل الحذف بإزالة خاصية من كائن. لذا يمكنك ببساطة أن تكتب:

delete myObject.regex;
// OR
delete myObject['regex'];

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

  • إذا كانت الخاصية التي تحاول حذفها غير موجودة ، فلن يكون للحذف أي تأثير وسيعود إلى true

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

  • لا يمكن حذف أي خاصية تم التصريح عنها بالقيمة var من النطاق العالمي أو من نطاق الدالة.

  • على هذا النحو ، لا يمكن حذف حذف أي وظائف في النطاق العالمي (سواء كان ذلك جزءًا من تعريف دالة أو دالة (تعبير).


  • يمكن حذف الوظائف التي تعد جزءًا من كائن ما (بخلاف النطاق العالمي) بحذف.

  • لا يمكن حذف أي خاصية يتم الإعلان عنها باستخدام السماح أو const من النطاق الذي تم تعريفها فيه. لا يمكن إزالة الخصائص غير القابلة للتكوين. يتضمن هذا خصائص كائنات مضمنة مثل Math و Array و Object وخصائص تم إنشاؤها على أنها غير قابلة للتكوين باستخدام أساليب مثل Object.defineProperty ().

المقتطف التالي يعطي مثالًا بسيطًا آخر:

var Employee = {
      age: 28,
      name: 'abc',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // returns true
    console.log(delete Employee.age);    // returns true
    
    // When trying to delete a property that does 
    // not exist, true is returned 
    console.log(delete Employee.salary); // returns true

لمزيد من المعلومات حول المزيد من الأمثلة ورؤيتها ، تفضل بزيارة الرابط أدناه:

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…


لنفترض أن لديك كائنًا يبدو كالتالي:

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
        ...
    ],
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',
        ...
    ]
};

حذف خاصية كائن

إذا كنت ترغب في استخدام staffالمصفوفة بأكملها ، فستكون الطريقة الصحيحة للقيام بذلك هي:

delete Hogwarts.staff;

بدلاً من ذلك ، يمكنك أيضًا القيام بذلك:

delete Hogwarts['staff'];

وبالمثل ، سيتم إزالة مجموعة الطلاب بأكملها عن طريق الاتصال delete Hogwarts.students;أو delete Hogwarts['students'];.

حذف فهرس مجموعة

الآن ، إذا كنت ترغب في إزالة موظف واحد أو طالب واحد ، يكون الإجراء مختلفًا بعض الشيء ، نظرًا لأن كلا الصفحتين هما صفيفتان نفسيتان.

إذا كنت تعرف فهرس موظفك ، يمكنك ببساطة القيام بذلك:

Hogwarts.staff.splice(3, 1);

إذا كنت لا تعرف الفهرس ، فستحتاج أيضًا إلى إجراء البحث عن الفهرس:

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);

ملحوظة

في حين يمكنك استخدام deleteصفيف تقنيًا ، فإن استخدامه يؤدي إلى الحصول على نتائج غير صحيحة عند الاتصال على سبيل المثال في Hogwarts.staff.lengthوقت لاحق. بعبارة أخرى ، deleteقد يؤدي إلى إزالة العنصر ، ولكنه لن يؤدي إلى تحديث قيمة lengthالموقع. استخدام من deleteشأنه أيضا خبط الفهرسة الخاصة بك.

لذا ، عند حذف قيم من كائن ، فكر دائمًا أولاً في ما إذا كنت تتعامل مع خصائص الكائن أو إذا كنت تتعامل مع قيم الصفيف ، واختر الاستراتيجية المناسبة بناءً على ذلك.

إذا كنت ترغب في تجربة هذا ، يمكنك استخدام هذا كمنطلق كنقطة بداية.


تحديث 2018-07-21: لوقت طويل ، شعرت بالحرج من هذه الإجابة ، لذا أعتقد أن الوقت قد حان لمسها قليلاً. مجرد القليل من التعليق والتوضيح والتنسيق للمساعدة في الإسراع في قراءة الأجزاء الطويلة المعقدة من هذه الإجابة بلا داع.

النسخة القصيرة

الجواب الفعلي على السؤال

كما قال الآخرون ، يمكنك استخدام delete .

obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined

صفيف معادل

لا delete من صفيف. استخدم Array.prototype.splice بدلاً من ذلك.

arr // [1,2,3,4,5]
arr.splice(3,1); // 4
arr // [1,2,3,5]

نسخة طويلة

JavaScript هي لغة OOP ، لذلك كل شيء كائن ، بما في ذلك المصفوفات . وبالتالي ، أشعر أنه من الضروري الإشارة إلى تحذير معين.

في المصفوفات ، على عكس الأشياء القديمة البسيطة ، يؤدي استخدام delete ترك القمامة في شكل null ، وإنشاء "ثقب" في الصفيف.

var array = [1, 2, 3, 4];
delete array[2];
/* Expected result --> [1, 2, 4]
 * Actual result   --> [1, 2, null, 4]
 */

كما ترى ، لا يعمل delete دائمًا كما قد يتوقع المرء. يتم الكتابة فوق القيمة ، ولكن لا يتم إعادة تخصيص الذاكرة. وهذا يعني أن array[4] لا يتم نقله إلى array[3] . والذي هو على النقيض من Array.prototype.unshift ، الذي يقوم بإدراج عنصر في بداية المصفوفة Array.prototype.unshift كل شيء ( array[0] يصبح array[1] ، إلخ.)

بصراحة ، وبغض النظر عن الإعداد للظهور بدلاً من عدم التحديد - وهو أمر غريب بشكل غريب - فإن هذا السلوك لا ينبغي أن يكون مفاجئًا ، لأن delete مشغّل وحيد ، مثل typeof ، الذي يغلي في اللغة وليس من المفترض أن يهتم حول نوع الكائن الذي يتم استخدامه عليه ، في حين أن Array هو فئة فرعية من Object بالطرق المصممة خصيصًا للعمل مع المصفوفات. لذلك لا يوجد سبب وجيه delete حتى يكون لديك حالة خاصة تم طهيها لإعادة تحويل المصفوفة ، لأن ذلك سيؤدي إلى إبطاء العمل مع العمل غير الضروري. في الماضي ، كانت توقعاتي غير واقعية.

بالطبع ، لقد فاجأني. لأنني كتبت هذا لتبرير الحملة الصليبية ضد "القمامة الفارغة":

تجاهل المخاطر والمخاطر الكامنة في null ، والمساحة المهدرة ، وهذا يمكن أن يكون مشكلة إذا كانت مجموعة تحتاج إلى أن تكون دقيقة.

وهو مبرر رهيب للتخلص من null s-- null يكون خطيرًا فقط إذا تم استخدامه بشكل غير صحيح ، ولا علاقة له بـ "الدقة". السبب الحقيقي الذي لا يجب عليك delete من مصفوفة هو أن تكون بنية البيانات المليئة بالقمامة والفوضى الموجودة حولك غير ملائمة وقليلة.

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

... إنه لأمر غبي ، وأنا أعلم.

سيناريو PDP-11 المفتعل والمنتفخ

على سبيل المثال ، لنفترض أنك تقوم بإنشاء تطبيق ويب يستخدم JSON-serialization لتخزين صفيف مستخدَم لـ "علامات التبويب" في سلسلة (في هذه الحالة ، localStorage ). لنفترض أيضًا أن الشفرة تستخدم المؤشرات الرقمية لأعضاء الصفيف "لعنوان" لهم عند الرسم على الشاشة. لماذا تفعل هذا بدلاً من مجرد تخزين "العنوان" أيضًا؟ لأن ... الأسباب .

حسنًا ، لنفترض أنك تحاول حفظ الذاكرة بناءً على طلب هذا المستخدم الوحيد الذي يدير جهازًا صغيرًا يعمل بنظام التشغيل PDP-11 من نظام التشغيل UNIX في عام 1960 ، وكتب تطبيقًا خاصًا به متوافقًا مع جافا سكريبت ومتوافقًا مع جافا سكريبت المتصفح لأن X11 غير وارد .

سيناريو حالة حافة الغبية على نحو متزايد جانبا ، وسوف يؤدي استخدام delete على صفيف المذكور في تلويث الصفيف ، وربما يتسبب في الأخطاء في التطبيق في وقت لاحق. وإذا قمت بالبحث عن null ، فسيتم تخطي الأرقام مباشرة مما يؤدي إلى عرض علامات التبويب مثل [1] [2] [4] [5] ...

if (array[index] == null)
    continue;
else
    title = (index + 1).toString();
/* 0 -> "1"
 * 1 -> "2"
 * 2 -> (nothing)
 * 3 -> "4"
 */

نعم ، هذا بالتأكيد ليس ما تريده.

الآن ، يمكنك الاحتفاظ بمكرر آخر ، مثل j ، لزيادة فقط عندما تتم قراءة القيم الصالحة من الصفيف. ولكن ذلك لن يحل المشكلة null تمامًا ، ولا يزال عليك إرضاء مستخدم tpp PDP-11. للأسف ، جهاز الكمبيوتر الخاص به ليس لديه ذاكرة كافية لعقد هذا العدد الصحيح الأخير (لا تسأل كيف يتمكن من التعامل مع مصفوفة متغيرة العرض ...) .

لذلك ، يرسل لك رسالة إلكترونية في الغضب:

Hey, your webapp broke my browser! I checked my localStorage database after your stupid code made my browser segfault, and this is what I found:

>"tabs:['Hello World', 'foo bar baz', null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, ... ]"

After clearing my precious data, it segfaulted again, and I did a backtrace, and what do I find? WHAT DO I FIND!? YOU USE TOO MANY VARIABLES!

>var i = index;
>var j = 1;

Grr, I am angry now.
-Troll Davidson

حول الآن ، كنت في نهاية الذكاء الخاص بك. كان هذا الرجل يشكو بدون توقف حول تطبيقك ، وتريد أن تخبره بأن يصمت ويذهب للحصول على كمبيوتر أفضل.

الحل: Array.prototype.splice

لحسن الحظ ، تحتوي المصفوفات على طريقة متخصصة لحذف المؤشرات وإعادة تخصيص الذاكرة: Array.prototype.splice() . يمكنك كتابة شيء كهذا:

Array.prototype.remove = function(index){
  this.splice(index,1);
}
...
array = [1, 2, 3, 4];
array.remove(2);
// Result -> [1, 2, 4]

ومثل هذا ، لقد سررت بالسيد (PDP-11). الصيحة! (ما زلت أخبره ، على الرغم من ...)

Array.prototype.splice vs Array.prototype.slice

أشعر أنه من المهم أن نشير إلى الفرق بين هاتين الوظيفتين المتشابهتين ، لأنهما مفيدتان للغاية.

Array.prototype.splice (start، n)

.splice() الصفيف ، ويعيد الفهارس التي تمت إزالتها. يتم تقطيع الصفيف بدءًا من الفهرس ، start ، و يتم فصل العناصر n . إذا كان n غير محدد ، n = array.length - start الصفيف بأكمله بعد start ( n = array.length - start ).

let a = [5,4,3,2,1];
let chunk = a.splice(2,2);

// a     [5,4,3,2,1]
// start  0 1 2 - -
// n      - - 1 2 -

chunk; // [3,2]
a;     // [5,4,1]

Array.prototype.slice (البداية ، النهاية)

.slice() غير مدمر ويعيد مصفوفة جديدة تحتوي على المؤشرات المشار إليها من start إلى end . إذا تركت end غير محددة ، فإن السلوك هو نفسه .splice() ( end = array.length ). السلوك صعب بعض الشيء ، لسبب ما ، end الفهارس من 1 بدلاً من 0. لا أعرف لماذا يفعل هذا ، ولكن هذا كيف. أيضا ، إذا كانت end <= start ، فإن النتيجة هي مصفوفة فارغة.

let a = [5,4,3,2,1];
let chunks = [
    a.slice(2,0),
    a.slice(2,2),
    a.slice(2,3),
    a.slice(2,5) ];

// a             [5,4,3,2,1]
// start          0 1 2 - -
// end, for...    - - - - -
//   chunks[0]  0 - - - - -   
//   chunks[1]    1 2 - - -
//   chunks[2]    1 2 3 - -
//   chunks[3]    1 2 3 4 5

chunks; // [ [], [], [3], [3,2,1] ]
a;      // [5,4,3,2,1]

هذا في الواقع ليس ما يحدث ، ولكن من الأسهل التفكير بهذه الطريقة. وفقًا لـ MDN ، إليك ما يحدث بالفعل:

// a             [5,4,3,2,1]
// start          0 1 2 - - -
// end, for...    - - - - - -
//   chunks[0]    0 - - - - -
//   chunks[1]    0 1 2 - - -
//   chunks[2]    0 1(2)3 - -
//   chunks[3]    0 1(2 3 4)5

يتم ببساطة استبعاد المؤشر المحدد عن طريق end من الشريحة. تشير المؤشرات التي تم ترقيمها إلى ما يتم تقطيعه. وفي كلتا الحالتين ، فإن السلوك ليس بديهيًا ، ومن المحتم أن يتسبب في نصيبه العادل من الأخطاء .splice() ، لذا قد تجد أنه من المفيد أن تقوم بعمل دالة .splice() لمحاكاة سلوك .splice() :

function ez_slice(array, start = 0, n = null){
    if(!Array.isArray(array) || !is_number(start))
        return null;

    if(is_number(n))
        return array.slice(start, start + n);

    if(n === null)
        return array.slice(start);

    return null;
}

ez_slice([5,4,3,2,1], 2, 1) // [3]
ez_slice([5,4,3,2,1], 2)    // [3,2,1]

/* Fun fact: isNaN is unreliable.
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(isNaN)
 * [NaN, {}, undefined, "Hi"]
 *
 * What we want is...
 *
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(is_nan)
 * [NaN]
 */
function is_nan(num){
    return typeof num === "number"
        && num !== num;
}

function is_number(num){
    return !is_nan(num)
        && typeof num === "number"
        && isFinite(num);
}

لاحظ أن الدالة wrapper مصممة بحيث تكون صارمة للغاية حول الأنواع ، وستقوم بإرجاع null إذا تم إيقاف أي شيء. يتضمن ذلك وضع سلسلة مثل "3" . يتم ترك الأمر للمبرمج ليجعل من أجناسه. هذا هو تشجيع ممارسة البرمجة الجيدة.

تحديث بخصوص is_array()

هذا فيما يتعلق بهذا المقتطف (الذي تمت إزالته الآن):

function is_array(array){
    return array !== null
        && typeof array === "object"
        && typeof array.length !== "undefined"
        && array.__proto__ === Array.prototype;
}

وهكذا ، كما تبين ، هناك طريقة مدمجة لمعرفة ما إذا كانت الصفيف عبارة عن مصفوفة بالفعل ، وهذا هو Array.isArray() ، الذي تم تقديمه في ECMAScript 5 (ديسمبر 2009). لقد وجدت هذا في حين أن ننظر لمعرفة ما إذا كان هناك سؤال يسأل عن إخبار صفائف من الأشياء ، لمعرفة ما إذا كان هناك حل أفضل من الألغام ، أو إضافة لي إذا لم يكن هناك. لذلك ، إذا كنت تستخدم إصدارًا من جافا سكريبت أقدم من ECMA 5 ، فهناك polyfill الخاص بك. ومع ذلك ، أوصي بشدة بعدم استخدام وظيفة is_array() ، لأن الاستمرار في دعم إصدارات جافا سكريبت القديمة يعني الاستمرار في دعم المتصفحات القديمة التي تقوم بتطبيقها ، وهذا يعني التشجيع على استخدام البرامج غير الآمنة ووضع المستخدمين المعرضين لخطر البرامج الضارة. لذا من فضلك ، استخدم Array.isArray() . استخدم let و const . استخدم الميزات الجديدة التي تمت إضافتها إلى اللغة. لا تستخدم بادئات البائعين. احذف هذا IE polyfill حماقة من موقع الويب الخاص بك. احذف هذا XHTML <!CDATA[[... crap ، أيضًا - انتقلنا إلى HTML5 مرة أخرى في عام 2014. وكلما أسرع الجميع بسحب الدعم لتلك المتصفحات القديمة / الباطنية ، كلما أسرع بائعو المستعرضات في متابعة معيار الويب واحتضان التكنولوجيا الجديدة ، وكلما أسرعنا في الانتقال إلى شبكة أكثر أمانًا.


السؤال القديم ، والإجابة الحديثة. باستخدام كائن destructuring ، ميزة ECMAScript 6 ، انها بسيطة مثل:

const { a, ...rest } = { a: 1, b: 2, c: 3 };

أو مع عينة الأسئلة:

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);

يمكنك رؤيته في العمل في محرر بابل للتجربة.

تصحيح:

لإعادة تعيين نفس المتغير ، استخدم let :

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);

يمكن تفسير المصطلح الذي استخدمته في عنوان السؤال الخاص بك ، Remove a property from a JavaScript object ، بطرق مختلفة. واحد هو إزالته لكامل الذاكرة وقائمة مفاتيح الكائن أو الآخر هو فقط لإزالته من الكائن الخاص بك. كما ذكر في بعض الإجابات الأخرى ، فإن الكلمة الرئيسية delete هي الجزء الرئيسي. لنفترض أن لديك كائنًا مثل:

myJSONObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

اذا فعلت:

console.log(Object.keys(myJSONObject));

ستكون النتيجة:

["ircEvent", "method", "regex"]

يمكنك حذف هذا المفتاح المحدد من مفاتيح الكائن مثل:

delete myJSONObject["regex"];

ثم سيكون مفتاح الكائنات الخاص بك باستخدام Object.keys(myJSONObject) :

["ircEvent", "method"]

لكن الهدف هو إذا كنت تهتم بالذاكرة وترغب في إزالة الكائن من الذاكرة ، فمن المستحسن تعيينه إلى الصفر قبل حذف المفتاح:

myJSONObject["regex"] = null;
delete myJSONObject["regex"];

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

var regex = myJSONObject["regex"];

أو إضافته كمؤشر جديد إلى كائن آخر مثل:

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

ثم حتى إذا قمت بإزالته من myJSONObject الكائن الخاص بك ، فلن يتم حذف هذا الكائن المحدد من الذاكرة ، حيث أن متغير regex و myOtherObject["regex"] لا يزال لديهم قيمهم. ثم كيف يمكننا إزالة الكائن من الذاكرة بالتأكيد؟

ستكون الإجابة هي حذف جميع المراجع الموجودة في شفرتك ، والإشارة إلى ذلك الكائن ذاته وعدم استخدام عبارات var لإنشاء مراجع جديدة لهذا الكائن . هذه النقطة الأخيرة بخصوص العبارات var ، هي واحدة من أهم القضايا التي نواجهها عادة ، لأن استخدام العبارات var سيمنع الكائن الذي تم إنشاؤه من إزالته.

مما يعني أنه في هذه الحالة لن تتمكن من إزالة هذا الكائن لأنك قمت بإنشاء متغير regex عبر عبارة var ، وإذا قمت بذلك:

delete regex; //False

ستكون النتيجة false ، مما يعني أن بيان الحذف الخاص بك لم يتم تنفيذه كما هو متوقع. ولكن إذا لم تكن قد قمت بإنشاء هذا المتغير من قبل ، وكان لديك فقط myOtherObject["regex"] كمرجع آخر موجود لديك ، فقد كان بإمكانك فعل ذلك فقط عن طريق إزالته مثل:

myOtherObject["regex"] = null;
delete myOtherObject["regex"];

وبعبارة أخرى ، يتم قتل كائن جافا سكريبت بمجرد عدم وجود مرجع يسار في التعليمة البرمجية الخاصة بك إلى هذا الكائن.

تحديث: شكرًا علىAgentME:

لا يؤدي تعيين خاصية إلى null قبل حذفها إلى إنجاز أي شيء (ما لم يتم إغلاق الكائن بواسطة Object.seal ويفشل الحذف. لا يحدث ذلك عادة إلا إذا حاولت ذلك تحديدًا).

للحصول على مزيد من المعلومات حول Object.seal: Object.seal()


جرب هذا

delete myObject['key'];

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

console.log ( myObject.regex); // logs: undefined

هذا يعمل في فايرفوكس وإنترنت إكسبلورر ، وأعتقد أنه يعمل في جميع الآخرين.


إزالة الممتلكات في جافا سكريبت

هناك العديد من الخيارات المختلفة المعروضة في هذه الصفحة ، ليس لأن معظم الخيارات خاطئة — أو لأن الإجابات هي نسخ مكررة — ولكن لأن التقنية المناسبة تعتمد على الحالة التي أنت فيها وأهداف المهام التي أنت و / أو أنت يحاول الفريق تحقيقها. للإجابة على السؤال بشكل لا لبس فيه ، يحتاج المرء إلى معرفة:

  1. إصدار ECMAScript الذي تستهدفه
  2. نطاق أنواع الكائنات التي تريد إزالة خصائصها ونوع أسماء الخصائص التي تحتاج إلى حذفها (سلاسل فقط؟ رموز؟ المراجع الضعيفة التي تم تعيينها من كائنات عشوائية؟ هذه كلها أنواع من مؤشرات الخاصية في JavaScript لسنوات حتى الآن )
  3. روح / أنماط البرمجة التي تستخدمها أنت وفريقك. هل تؤيد النهج الوظيفية ويتم تحقير الطفرات على فريقك ، أو هل تستخدم أساليب التمويه الكائن في الغرب المتوحش؟
  4. هل تتطلع إلى تحقيق ذلك في جافا سكريبت خالص أم هل أنت مستعد وقادر على استخدام مكتبة تابعة لجهة خارجية؟

بعد الإجابة على هذه الاستعلامات الأربعة ، هناك أربع فئات أساسية من "إزالة الموقع" في جافا سكريبت لتختار منها من أجل تحقيق أهدافك. هم انهم:

حذف خاصية كائن mutative غير آمنة

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

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws

هذه الفئة هي الفئة الأقدم والأكثر وضوحًا وأكثرها تأييدا من إزالة الملكية. وهو يدعم Symbolمجموعة الفهارس بالإضافة إلى سلاسل ويعمل في كل نسخة من JavaScript باستثناء الإصدار الأول. ومع ذلك ، فإنه يعد تحديًا ينتهك بعض مبادئ البرمجة وله تأثيرات على الأداء. كما يمكن أن يؤدي إلى استثناءات غير معلمة عند استخدامها على developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .

استبعاد خاصية سلسلة الاستناد

هذه الفئة هي للتشغيل على كائن بسيط أو حالات صفيف في النكهات الأحدث ECMAScript عند الرغبة في اتباع نهج غير متحولة ولا تحتاج إلى حساب مفاتيح الرمز:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

حذف خاصية كائن mutative ، آمنة

هذه الفئة مخصصة للتشغيل على قيم العناصر الحرفية أو مثيلات الكائن عندما تريد الاحتفاظ / متابعة استخدام المرجع الأصلي أثناء الحماية من الاستثناءات التي يتم طرحها على الخصائص غير القابلة للتعديل:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
Reflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
Reflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false

بالإضافة إلى ذلك ، في حين أن تحوير الكائنات في المكان ليس عديمًا ، يمكنك استخدام الطبيعة الوظيفية Reflect.deletePropertyللقيام بالتطبيق الجزئي والتقنيات الوظيفية الأخرى غير الممكنة مع deleteالبيانات.

بناء الجملة على أساس جملة الجمل

هذه الفئة هي للتشغيل على كائن بسيط أو حالات صفيف في النكهات الأحدث ECMAScript عند الرغبة في اتباع نهج غير متحولة ولا تحتاج إلى حساب مفاتيح الرمز:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

حذف الممتلكات في المكتبة

تسمح هذه الفئة بشكل عام بمرونة وظيفية أكبر ، بما في ذلك حساب الرموز وإلغاء أكثر من خاصية واحدة في بيان واحد:

const o = require("lodash.omit")
const foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }
const bar = o(foo, 'a') // "'a' undefined"
const baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, "Symbol.for('a') undefined"

بسيط جدا:

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

delete myObject.regex;

const myObject = {
        "ircEvent": "PRIVMSG",
        "method": "newURI",
        "regex": "^http://.*"
    };

const { regex, ...other } = myObject;

console.log(myObject)
console.log(regex)
console.log(other)


ضع في اعتبارك إنشاء كائن جديد بدون "regex"الخاصية لأنه يمكن دائمًا الإشارة إلى الكائن الأصلي بواسطة أجزاء أخرى من البرنامج. وبالتالي يجب تجنب التلاعب بها.

const myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

const { regex, ...newMyObject } = myObject;

console.log(newMyObject);


هذه المشاركة قديمة جدًا وأجدها مفيدة جدًا لذا قررت مشاركة وظيفة غير محددة كتبت في حالة رؤية شخص آخر لهذه المشاركة والتفكير في سبب أنها ليست بهذه البساطة كما هو الحال في وظيفة PHP.

سبب كتابة هذه unsetالوظيفة الجديدة هو الاحتفاظ بفهرس جميع المتغيرات الأخرى في هذا hash_map. انظر إلى المثال التالي ، وشاهد كيف أن مؤشر "test2" لم يتغير بعد إزالة قيمة من hash_map.

function unset(unsetKey, unsetArr, resort){
  var tempArr = unsetArr;
  var unsetArr = {};
  delete tempArr[unsetKey];
  if(resort){
    j = -1;
  }
  for(i in tempArr){
    if(typeof(tempArr[i]) !== 'undefined'){
      if(resort){
        j++;
      }else{
        j = i;
      }
      unsetArr[j] = tempArr[i];
    }
  }
  return unsetArr;
}

var unsetArr = ['test','deletedString','test2'];

console.log(unset('1',unsetArr,true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1',unsetArr,false)); // output Object {0: "test", 2: "test2"}

2 المنتشرة (ES6)

لمن يحتاجها ...

لإكمالKoen الإجابة في هذا الموضوع ، إذا كنت تريد إزالة متغير ديناميكي باستخدام صيغة الانتشار ، فيمكنك القيام بذلك كما يلي:

const key = 'a';

const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(rest); // { b: 2, c: 3 }

* fooسيكون متغيرًا جديدًا بقيمة a(وهو 1).


استكمال :
هناك عدد قليل من الطرق الشائعة لإزالة خاصية من كائن.
كل واحد لديه إيجابيات وسلبيات خاصة به ( تحقق من مقارنة الأداء هذه ):

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
قراءته وقصره ، ومع ذلك قد لا يكون الخيار الأفضل إذا كنت تعمل على عدد كبير من الكائنات حيث لم يتم تحسين أدائه.

delete obj[key];


Reassignment
أكثر من 2X أسرع منdelete، ومع ذلكلايتمحذفالخاصيةويمكن تكرارها.

obj[key] = null;
obj[key] = false;
obj[key] = undefined;


Spread Operator يتيح لنا
هذاES6المشغل إعادة كائن جديد تمامًا ، باستثناء أي خصائص ، دون تحور الكائن الموجود. الجانب السلبي هو أنه يحتوي على أداء أسوأ من أعلاه وليس مقترحا لاستخدامه عندما تحتاج إلى إزالة العديد من الخصائص في كل مرة.

{ [key]: val, ...rest } = obj;

حل آخر ، وذلك باستخدام Array#reduce.

var myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

myObject = Object.keys(myObject).reduce(function(obj, key) {
  if (key != "regex") {           //key you want to remove
    obj[key] = myObject[key];
  }
  return obj;
}, {});

console.log(myObject);

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

(ES6)

const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',
};

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);


delete مشغل بطيئة بشكل غير متوقع!

انظر إلى benchmark .

الحذف هو الطريقة الوحيدة الحقيقية لإزالة خصائص الكائن دون أي بقايا ، لكنه يعمل ~ 100 مرة أبطأ ، مقارنة بـ "البديل" ، إعداد object[key] = undefined .

هذا البديل ليس الجواب الصحيح لهذا السؤال! ولكن ، إذا استخدمته بعناية ، يمكنك تسريع بعض الخوارزميات بشكل كبير. إذا كنت تستخدم delete في حلقات ولديك مشكلات في الأداء ، فاقرأ الشرح المطول.

متى يجب استخدام delete وعند تعيين القيمة على undefined ؟

قد يتم اعتبار الكائن كمجموعة من أزواج القيم الرئيسية. ما أسميه "قيمة" هو بدائي أو إشارة إلى كائن آخر ، متصل بهذا "المفتاح".

استخدم delete ، عندما تمرر كائن النتيجة إلى الرمز الذي لا تتحكم فيه (أو عندما تكون غير متأكد من فريقك أو نفسك).

يحذف المفتاح من hashmap .

 var obj = {
     field: 1     
 };
 delete obj.field;

استخدم الإعداد إلى undefined ، عندما تهتم بالأداء. يمكن أن يعطي دفعة قوية لشفائك.

يبقى المفتاح على مكانه في hashmap ، يتم استبدال القيمة فقط مع undefined . نفهم ، أن ل for..in حلقة لا تزال تتكرر على هذا المفتاح.

 var obj = {
     field: 1     
 };
 obj.field = undefined;

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

ومع ذلك ، فإن هذا الرمز:

object.field === undefined

سوف تتصرف على قدم المساواة لكلا الطريقتين.

اختبارات

لتلخيص ، الاختلافات كلها عن طرق لتحديد وجود خاصية ، وحول ل for..in حلقة.

 console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');

 console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');

 console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');

 console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');

 console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');

 console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
 //Object.keys().indexOf() is an overkill that runs much slower :)

 var counter = 0,
     key;
 for (key in obj) {
     counter++;
 }
 console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');

حذار من تسرب الذاكرة!

في حين أن استخدام obj[prop] = undefined هو أسرع من فعل delete obj[prop] ، فإن هناك اعتبارًا مهمًا آخر هو أن obj[prop] = undefined قد لا يكون مناسبًا دائمًا. delete obj[prop] يزيل prop من obj ويمحوها من الذاكرة في حين obj[prop] = undefined يضبط قيمة prop ببساطة إلى undefined الذي يترك prop في الذاكرة. لذلك ، في الحالات التي يوجد فيها العديد من المفاتيح التي يتم إنشاؤها وحذفها ، يمكن أن يؤدي استخدام obj[prop] = undefined إجبار الذاكرة على التوفيق (مما يؤدي إلى تجميد الصفحة) واحتمال حدوث خطأ خارج الذاكرة. افحص التعليمة البرمجية التالية.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /*************************************************/
            /****/ nodeRecords[i][lastTime] = undefined; /****/
            /*************************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

في التعليمة البرمجية المذكورة أعلاه ، ما nodeRecords[i][lastTime] = undefined; سوى إجراء nodeRecords[i][lastTime] = undefined; سوف يسبب تسرب ذاكرة هائلة بسبب كل إطار للرسوم المتحركة. كل إطار ، كل عناصر الـ 65536 DOM ستشغل 65536 فتحات فردية أخرى ، لكن الفتحات السابقة 65536 سيتم ضبطها فقط إلى غير محدد مما يتركها معلقة في الذاكرة. المضي قدما ، في محاولة لتشغيل التعليمات البرمجية أعلاه في وحدة التحكم ونرى بنفسك. بعد فرض خطأ خارج الذاكرة ، حاول تشغيله مرة أخرى باستثناء الإصدار التالي من التعليمات البرمجية التي تستخدم عامل delete بدلاً من ذلك.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /********************************************/
            /****/ delete nodeRecords[i][lastTime]; /****/
            /********************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

كما هو موضح في مقتطف الشفرة الموضح أعلاه ، توجد بعض حالات الاستخدام المناسبة النادرة لمشغل delete . ومع ذلك ، لا تقلق بشأن هذه المشكلة أكثر من اللازم. سيصبح هذا فقط مشكلة في الكائنات طويلة العمر التي تحصل على مفاتيح جديدة تضيفها باستمرار. في أي حالة أخرى (وهو ما يقرب من كل حالة في برمجة العالم الحقيقي) ، فمن الأنسب استخدام obj[prop] = undefined . الغرض الرئيسي من هذا القسم هو فقط لفت انتباهك إلى هذا الأمر ، بحيث أنه في فرصة نادرة أن تصبح هذه مشكلة في شفرتك ، عندها يمكنك فهم المشكلة بسهولة أكبر وبالتالي لا يجب أن تضيع ساعات تشريح شفرتك لتحديد مكانها. وفهم هذه المشكلة.

لا دائما تعيين undefined

أحد جوانب جافا سكريبت التي يجب أخذها بعين الاعتبار هو تعدد الأشكال. تعدد الأشكال هو عند تعيين نفس الأنواع المختلفة المتغيرة / فتحة في كائن كما هو موضح أدناه.

var foo = "str";
foo = 100;          // variable foo is now labeled polymorphic by the browser
var bar = ["Some", "example"];
bar[2] = "text";    // bar is a monomorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = undefined; // bar is now a polymorphic array

ومع ذلك ، هناك مشكلتين رئيسيتين غير قابلتين للإصلاح مع صفائف متعددة الأشكال:

  1. فهي بطيئة والذاكرة غير فعالة. عند الوصول إلى فهرس معين ، بدلاً من مجرد الحصول على النوع العام للمصفوفة ، يجب أن يحصل المستعرض بدلاً من ذلك على النوع على أساس كل فهرس ، حيث يخزن كل فهرس البيانات الأولية الإضافية من نوعها.
  2. مرة واحدة متعددة الأشكال ، دائما متعددة الأشكال. عندما يصنع صفيف متعدد الأشكال ، لا يمكن التراجع عن تعدد الأشكال في متصفحات Webkit. لذا ، حتى إذا قمت باستعادة مصفوفة متعددة الأشكال إلى أن تكون غير متعددة الأشكال ، فسيظل تخزينها من قبل المستعرض كمجموعة متعددة الأشكال.

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

ولكن ، كيف يرتبط قياس رحلة الدواء بعملية delete ؟ يكمن الحل في السطر الأخير من التعليمة البرمجية في المقتطف أعلاه. لذا دعنا نعيد فحصها ، هذه المرة مع تطور.

var bar = ["Some", "example"];
bar[2] = "text";    // bar is not a polymorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = "";        // bar is still a monomorphic array
bar[1] = undefined; // bar is now a polymorphic array

رصد. bar[1] = "" إجبار تعدد الأشكال في حين أن bar[1] = undefined . لذلك ، يجب دائمًا ، عند الإمكان ، استخدام النوع المطابق لأجسامها بحيث لا تسبب تعدد الأشكال بطريق الخطأ. قد يستخدم أحد هؤلاء الأشخاص القائمة التالية كمرجع عام لحملهم على الذهاب. ومع ذلك ، يرجى عدم استخدام الأفكار التالية بوضوح. بدلاً من ذلك ، استخدم كل ما يعمل جيدًا للشفرة.

  • عند استخدام صفيف / متغير مكتوب بلغة بدائية ، استخدم إما false أو undefined كقيمة فارغة. في حين أن تجنب تعدد الأشكال غير الضروري أمر جيد ، فإن إعادة كتابة جميع التعليمات البرمجية الخاصة بك لمنعها صراحةً من المحتمل أن يؤدي في الواقع إلى انخفاض في الأداء. استخدام الحكم المشترك!
  • عند استخدام صفيف / متغير مطبوع على الرقم البدائي ، استخدم 0 كقيمة فارغة. لاحظ أنه داخليًا ، هناك نوعان من الأرقام: الأعداد الصحيحة السريعة (2147483647 إلى -2147483648 شاملة) والنقاط العائمة المزدوجة البطيئة (أي شيء آخر غير ذلك بما في ذلك NaN و Infinity ). عندما يتم تخفيض عدد صحيح إلى مزدوج ، لا يمكن ترقيته مرة أخرى إلى عدد صحيح.
  • عند استخدام صفيف / متغير كتبته السلسلة الأولية ، استخدم "" كقيمة فارغة.
  • عند استخدام الرمز ، انتظر ، لماذا تستخدم الرمز؟!؟! الرموز هي juju سيئة للأداء. كل شيء مبرمج لاستخدام الرموز يمكن إعادة برمجته لعدم استخدام الرموز ، مما يؤدي إلى رمز أسرع بدون رموز. الرموز هي في الواقع مجرد سوبر ميتا سكر غير فعال.
  • عند استخدام أي شيء آخر ، استخدم القيمة null .

ومع ذلك ، يجب أن تضع في اعتبارها! لا تبدأ فجأة في القيام بذلك مع كل التعليمات البرمجية الموجودة لديك من قبل حيث أنه من المرجح كسر مثل هذه التعليمة البرمجية الموجودة و / أو إدخال أخطاء غريبة. بدلاً من ذلك ، يجب تنفيذ مثل هذه الممارسة الفعالة من البداية ، وعند تحويل الشفرة الموجودة مسبقًا ، يُنصح بأن تقوم بالتحقق من كل الأسطر المتعلقة بثلاثة أضعاف وثلاثة أضعاف هذه الخطوط ، حيث أن محاولة ترقية الرمز القديم إلى هذه الممارسة الجديدة يمكن أن تكون محفوفة بالمخاطر كما هو مجزي.


مرحبا يمكنك أن تجرب هذا النوع البسيط

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

بناء على الجواب المقبول.

إذا كان الكائن يحتوي على خصائص تريد الاتصال به .properties () حاول!

var keys = Object.keys(myJSONObject);

for (j=0; j < keys.length; j++) {
  Object[keys[i]].properties();
}




javascript javascript-objects object-properties