Operator delete secara tak terduga lambat!

Lihatlah patokan.

Hapus adalah satu-satunya cara yang benar untuk menghapus properti objek tanpa sisa, tetapi itu berhasil ~ 100 kali lebih lambat, dibandingkan dengan pengaturan "alternatif" nya object[key] = undefined.

Alternatif ini bukanlah jawaban yang benar untuk pertanyaan ini! Tetapi, jika Anda menggunakannya dengan hati-hati, Anda dapat mempercepat secara dramatis beberapa algoritme. Jika Anda menggunakan delete dalam putaran dan Anda memiliki masalah dengan kinerja, baca penjelasan verbose.

Kapan sebaiknya digunakan delete dan ketika menetapkan nilai ke undefined ?

Suatu objek dapat dilihat sebagai satu set pasangan kunci-nilai. Apa yang saya sebut 'nilai' adalah primitif atau referensi ke objek lain, terhubung ke 'kunci' itu.

Menggunakan delete, ketika Anda mengirimkan objek hasil ke kode di mana Anda tidak memiliki kontrol (atau ketika Anda tidak yakin tentang tim Anda atau diri Anda sendiri).

Saya t menghapus kunci dari hashmap.

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

Gunakan pengaturan untuk undefined, ketika Anda peduli tentang kinerja. Ini dapat memberi dorongan serius pada kode Anda.

Itu kunci tetap pada tempatnya di hashmap, hanya nilainya diganti dengan undefined. Pahamilah itu for..in pengulangan akan tetap beriterasi di atas kunci itu.

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

Menggunakan metode ini, tidak semua cara menentukan keberadaan properti akan berfungsi seperti yang diharapkan.

Namun, kode ini:

object.field === undefined

akan berperilaku sama untuk kedua metode.

Tes

Untuk meringkas, perbedaan adalah tentang cara menentukan keberadaan properti, dan tentang for..in lingkaran.

 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. *');

Waspadai Kebocoran Memori!

Saat menggunakan obj[prop] = undefined lebih cepat daripada melakukan delete obj[prop], pertimbangan penting lainnya adalah itu obj[prop] = undefined mungkin tidak selalu tepat. delete obj[prop] menghapus prop dari obj dan menghapusnya dari memori sedangkan obj[prop] = undefined cukup atur nilainya prop untuk undefined yang pergi prop masih dalam memori. Oleh karena itu, dalam keadaan di mana ada banyak kunci yang dibuat dan dihapus, gunakan obj[prop] = undefined dapat memaksa rekonsiliasi memori mahal (menyebabkan halaman untuk membeku) dan berpotensi kesalahan out-of-memory. Periksa kode berikut.

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

Dalam kode di atas, cukup lakukan nodeRecords[i][lastTime] = undefined; akan menyebabkan kebocoran memori besar-besaran karena setiap frame animasi. Setiap frame, semua 65536 elemen DOM akan mengambil 65536 slot lainnya, tetapi 65536 slot sebelumnya hanya akan diatur ke tidak terdefinisi yang membuat mereka menggantung di memori. Silakan, coba jalankan kode di atas di konsol dan lihat sendiri. Setelah memalsukan kesalahan di luar memori, coba jalankan lagi kecuali dengan versi kode berikut yang menggunakan deleteoperator saja.

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

Seperti yang terlihat pada cuplikan kode di atas, ada beberapa kasus penggunaan yang tepat untuk delete operator. Namun, jangan khawatir tentang masalah ini terlalu banyak. Ini hanya akan menjadi masalah dengan objek jangka panjang yang mendapatkan kunci baru secara konstan ditambahkan ke mereka. Dalam kasus lain (yang hampir setiap kasus dalam pemrograman dunia nyata), itu paling tepat untuk digunakan obj[prop] = undefined. Tujuan utama dari bagian ini adalah hanya untuk memberikan perhatian Anda sehingga dalam kesempatan langka ini menjadi masalah dalam kode Anda, maka Anda dapat lebih mudah memahami masalah dan dengan demikian tidak perlu membuang waktu membedah kode Anda untuk mencari dan memahami masalah ini.

Jangan Selalu Diatur undefined

Salah satu aspek dari Javascript yang penting untuk dipertimbangkan adalah polimorfisme. Polimorfisme adalah ketika menetapkan variabel / slot-in-an-objek yang berbeda jenis yang sama seperti yang terlihat di bawah ini.

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

Namun, ada dua masalah besar yang tidak bisa diperbaiki dengan susunan polimorfik:

1. Mereka lambat & memori tidak efisien. Ketika mengakses indeks tertentu, alih-alih hanya mendapatkan tipe global untuk array, browser malah harus mendapatkan jenis pada basis per-indeks dimana setiap indeks menyimpan metadata tambahan dari jenisnya.
2. Sekali polimorfik, selalu polimorfik. Ketika sebuah array dibuat polimorfik, polimorfisme tidak dapat dibatalkan di browser WebKit. Jadi, bahkan jika Anda mengembalikan larik polimorfik menjadi non-polimorfik, ia akan tetap disimpan oleh peramban sebagai larik polimorfik.

Seseorang mungkin menyamakan polimorfisme dengan kecanduan narkoba. Pada pandangan pertama, tampaknya sangat menguntungkan: kode yang bagus dan halus. Kemudian, pembuat kode memperkenalkan susunannya ke obat polimorfisme. Seketika, susunan polimorfik menjadi kurang efisien, dan tidak pernah bisa seefisien seperti sebelumnya karena dibius. Untuk menghubungkan keadaan tersebut dengan kehidupan nyata, seseorang dengan kokain bahkan mungkin tidak mampu mengoperasikan pegangan pintu yang sederhana, apalagi dapat menghitung digit PI. Demikian juga, sebuah array pada obat polimorfisme tidak dapat seefisien array monomorfik.

Tapi, bagaimana analogi perjalanan obat berhubungan dengan delete operasi? Jawabannya mewarisi baris terakhir kode di cuplikan di atas. Dengan demikian biarlah dikaji ulang, kali ini dengan twist.

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

Mengamati. bar[1] = "" tidak memaksa polimorfisme sedangkan bar[1] = undefined tidak. Oleh karena itu, orang harus selalu, kapan saja mungkin menggunakan jenis yang sesuai untuk objek mereka sehingga tidak secara tidak sengaja menyebabkan polimorfisme. Satu orang seperti itu dapat menggunakan daftar berikut sebagai referensi umum untuk mewujudkannya. Namun, tolong jangan secara eksplisit menggunakan ide-ide di bawah ini. Sebagai gantinya, gunakan apa pun yang berfungsi dengan baik untuk kode Anda.

• Saat menggunakan array / variabel yang diketik ke primitif boolean, gunakan juga false atau undefined sebagai nilai kosong. Sementara menghindari polimorfisme yang tidak perlu adalah baik, menulis ulang semua kode Anda untuk secara eksplisit melarang itu kemungkinan akan benar-benar menghasilkan penurunan kinerja. Gunakan penilaian umum!
• Ketika menggunakan array / variabel yang diketik ke nomor primitif, gunakan 0 sebagai nilai kosong. Perhatikan bahwa secara internal, ada dua jenis angka: bilangan bulat cepat (2147483647 ke -2147483648 inklusif) dan titik ganda mengambang lambat (apa pun selain itu termasuk NaN dan Infinity). Ketika sebuah integer diturunkan ke ganda, itu tidak dapat dipromosikan kembali ke integer.
• Saat menggunakan array / variabel yang diketik ke string primitif, gunakan "" sebagai nilai kosong.
• Saat menggunakan Simbol, tunggu, mengapa Anda menggunakan Simbol?!?! Simbol adalah juju buruk untuk kinerja. Semua yang diprogram untuk menggunakan Simbol dapat diprogram ulang agar tidak menggunakan Simbol, menghasilkan kode yang lebih cepat tanpa Simbol. Simbol adalah benar-benar hanya meta-gula yang sangat tidak efisien.
• Saat menggunakan yang lain, gunakan null.

Namun, berhati-hatilah! Jangan tiba-tiba mulai melakukan ini dengan semua kode yang sudah ada sekarang karena kemungkinan akan memecahkan kode yang sudah ada sebelumnya dan / atau memperkenalkan bug aneh. Sebaliknya, praktik yang efisien seperti itu perlu diimplementasikan sejak awal, dan ketika mengonversi kode yang sudah ada sebelumnya, Anda disarankan untuk menggandakan, melipatgandakan, empat kali lipat memeriksa semua baris yang terkait dengan itu ketika mencoba memperbarui kode lama ke praktik baru ini dapat seperti berisiko karena bermanfaat.

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

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

Ini berfungsi di Firefox dan Internet Explorer, dan saya rasa ini berfungsi di semua yang lain.

Perbarui 2018-07-21: Untuk waktu yang lama, saya merasa malu dengan jawaban ini, jadi saya pikir sudah waktunya saya menyentuhnya sedikit. Hanya sedikit komentar, klarifikasi, dan pemformatan untuk membantu mempercepat pembacaan bagian-bagian yang tidak perlu panjang dan berbelit-belit dari jawaban ini.

VERSI PENDEK

Jawaban sebenarnya untuk pertanyaan itu

Seperti yang orang lain katakan, Anda bisa menggunakannya delete.

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

Array setara

Jangan delete dari sebuah array. Menggunakan Array.prototype.splice sebagai gantinya.

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

VERSI PANJANG

JavaScript adalah Bahasa OOP, jadi semuanya adalah objek, termasuk array. Jadi, saya merasa perlu untuk menunjukkan peringatan tertentu.

Dalam array, tidak seperti benda lama biasa, menggunakan delete meninggalkan sampah dalam bentuk null, membuat "lubang" di larik.

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

Seperti yang Anda lihat, delete tidak selalu berfungsi seperti yang diharapkan. Nilai ditimpa, tetapi memori tidak dialokasikan kembali. Artinya, array[4] tidak dipindahkan ke array[3]. Yang berbeda dengan Array.prototype.unshift, yang memasukkan elemen di awal array dan menggeser semuanya ke atas (array[0] menjadi array[1], dll.)

Jujur, selain dari pengaturan ke null daripada undefined--yang sah aneh - perilaku ini seharusnya tidak menjadi mengejutkan, sejak delete adalah operator unary, seperti typeof, yang direbus keras ke dalam bahasa dan tidak seharusnya peduli dengan mengetik objek itu digunakan pada, sedangkan Array adalah subkelas dari Object dengan metode dirancang khusus untuk bekerja dengan array. Jadi tidak ada alasan yang bagus untuk itu deleteuntuk memiliki kotak khusus yang dimasak untuk menggeser ulang array, karena itu hanya akan memperlambat pekerjaan yang tidak perlu. Dalam retrospeksi, harapan saya tidak realistis.

Tentu saja melakukan mengejutkan saya. Karena saya menulis ini untuk membenarkan perang salib saya melawan "sampah nol":

Mengabaikan bahaya dan masalah yang melekat pada null, dan ruang yang terbuang, ini bisa menjadi masalah jika array harus tepat.

Yang merupakan pembenaran yang mengerikan untuk menyingkirkan nulls--null hanya berbahaya jika digunakan secara tidak benar, dan itu tidak ada hubungannya dengan "presisi". Alasan sebenarnya Anda tidak seharusnya delete dari array adalah karena meninggalkan struktur data yang dipenuhi sampah dan berantakan di sekitar ceroboh dan rentan bug.

Apa yang berikut adalah skenario yang dibuat yang cukup panjang, sehingga Anda dapat melompat ke bagian, Solusinya, jika kamu mau. Satu-satunya alasan saya meninggalkan bagian ini adalah karena saya pikir beberapa orang mungkin berpikir itu lucu, dan saya tidak ingin menjadi "orang itu" yang mengirimkan jawaban "lucu" dan kemudian menghapus semua "lucu" darinya nanti .

... Bodoh, aku tahu.

Skenario PDP-11 yang dibuat-buat dan bertele-tele

Misalnya, Anda membuat webapp yang menggunakan JSON-serialization untuk menyimpan larik yang digunakan untuk 'tab' dalam string (dalam hal ini, localStorage). Mari kita juga mengatakan bahwa kode menggunakan indeks numerik dari anggota array untuk "judul" mereka ketika menggambar ke layar. Kenapa kamu melakukan ini daripada hanya menyimpan "title" juga? Karena... alasan.

Oke, anggap saja Anda mencoba untuk menghemat memori atas permintaan ini satu pengguna yang menjalankan komputer mini PDP-11 dari dasawarsa 1960-an yang menjalankan UNIX, dan menulis peramban ramah-garis-nya sendiri yang sesuai dengan Alinks, JavaScript-compliant, dan ramah-printer karena X11 adalah keluar dari pertanyaan.

Skenario sampingan semakin bodoh, menggunakan delete pada kata array akan menghasilkan null mencemari array, dan mungkin menyebabkan bug di app nanti. Dan jika Anda memeriksa null, itu akan langsung melewati nomor yang menghasilkan tab yang diberikan seperti [1] [2] [4] [5] ....

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

Ya, itu jelas bukan yang kau inginkan.

Kamu sekarang bisa simpan iterator kedua, seperti j, untuk kenaikan hanya ketika nilai yang valid dibaca dari array. Tapi itu tidak akan memecahkan masalah null masalah, dan Anda masih harus menyenangkan itu troll Pengguna PDP-11. Sial, komputernya saja tidak memiliki cukup memori untuk menyimpan integer terakhir itu _{(jangan tanya bagaimana dia menangani berbagai variabel-lebar ...)}.

Jadi, dia mengirimi Anda email dalam kemarahan:

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

Tentang sekarang, kau ada di ujung kepalamu. Orang ini telah mengeluh tanpa henti tentang aplikasi Anda, dan Anda ingin mengatakan kepadanya untuk tutup mulut dan pergi mendapatkan komputer yang lebih baik.

Solusinya: Array.prototype.splice

Untungnya, array melakukan memiliki metode khusus untuk menghapus indeks dan merealokasi memori: Array.prototype.splice(). Anda dapat menulis sesuatu seperti ini:

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

Dan seperti itu, Anda sudah senang Mr. PDP-11. Hore! _{(Aku masih akan menyuruhnya pergi, meskipun ...)}

Array.prototype.splice vs Array.prototype.slice

Saya merasa penting untuk menunjukkan perbedaan antara dua fungsi yang dinamai serupa ini, karena keduanya sangat berguna.

Array.prototype.splice (mulai, n)

.splice() bermutasi array, dan mengembalikan indeks yang dihapus. Array diiris mulai dari indeks, start, dan n elemen diiris. Jika n tidak ditentukan, seluruh larik sesudahnya start diiris keluar (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 (awal, akhir)

.slice() tidak merusak dan mengembalikan array baru yang berisi indeks yang ditunjukkan start untuk end. Jika end tidak ditentukan, perilaku sama dengan .splice() (end = array.length). Perilaku agak sulit karena, untuk beberapa alasan, end indeks dari 1 bukannya 0. Saya tidak tahu mengapa ini melakukan ini, tapi begitulah. Juga, jika end <= start, hasilnya adalah array kosong.

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]

Itu sebenarnya bukan apa yang terjadi, tetapi lebih mudah untuk berpikir seperti itu. Menurut MDN, inilah yang sebenarnya terjadi:

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

Indeks yang ditentukan oleh end hanya dikecualikan dari irisan. Indeks yang disisipkan menunjukkan apa yang akan diiris. Either way, perilaku tidak intuitif dan itu pasti menyebabkan adil dari kesalahan off-by-one, sehingga Anda mungkin merasa berguna untuk membuat fungsi wrapper untuk lebih menyamai perilaku .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);
}

Perhatikan bahwa fungsi pembungkus dirancang untuk sangat ketat tentang jenis, dan akan kembali null jika ada yang tidak aktif. Itu termasuk memasukkan string seperti "3". Itu diserahkan kepada programmer untuk rajin tentang tipenya. Ini untuk mendorong praktik pemrograman yang baik.

Perbarui terkait is_array()

Ini terkait dengan cuplikan ini (yang sekarang dihapus):

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

Jadi ternyata, ada IS IS built-in cara untuk mengetahui apakah array benar-benar sebuah array, dan itu Array.isArray(), diperkenalkan di ECMAScript 5 (Desember 2009). Saya menemukan ini sambil mencari untuk melihat apakah ada pertanyaan yang bertanya tentang menceritakan array dari objek, untuk melihat apakah ada solusi yang lebih baik daripada saya, atau menambahkan milik saya jika tidak ada. Jadi, jika Anda menggunakan versi JavaScript yang lebih awal dari ECMA 5, ada polyfill Anda. Namun, saya sangat menyarankan untuk tidak menggunakan saya is_array() berfungsi, karena terus mendukung versi lama JavaScript berarti terus mendukung browser lama yang menerapkannya, yang berarti mendorong penggunaan perangkat lunak tidak aman dan menempatkan pengguna pada risiko malware. Jadi tolong, gunakan Array.isArray(). Menggunakan let dan const. Gunakan fitur-fitur baru yang ditambahkan ke bahasa. Jangan gunakan awalan vendor. Menghapus omong kosong polyfill IE dari situs web Anda. Hapus XHTML itu <!CDATA[[... juga - kami pindah ke HTML5 kembali pada tahun 2014. Semakin cepat semua orang menarik dukungan untuk browser lama / esoterik, semakin cepat vendor peramban akan benar-benar mengikuti standar web dan merangkul teknologi baru, dan semakin cepat kita dapat beralih ke web yang lebih aman.

Pertanyaan lama, jawaban modern. Menggunakan perusakan objek, sebuah ECMAScript 6 fitur, itu sesederhana:

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

Atau dengan contoh pertanyaan:

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

Anda dapat melihatnya beraksi di editor uji coba Babel.

Edit:

Untuk menetapkan kembali ke variabel yang sama, gunakan a let:

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

Alternatif lain adalah menggunakan Underscore.js Perpustakaan.

Perhatikan itu _.pick() dan _.omit() keduanya mengembalikan salinan objek dan tidak langsung mengubah objek asli. Menetapkan hasil ke objek asli harus melakukan trik (tidak ditampilkan).

Referensi: link  _.pick (objek, * kunci)

Kembalikan salinan objek, difilter agar hanya memiliki nilai untuk kunci yang masuk daftar putih (atau larik kunci yang valid).

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

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

Referensi: link  _.omit (objek, * kunci)

Kembalikan salinan objek, difilter untuk menghilangkan kunci daftar hitam (atau susunan kunci).

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

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

Untuk array, _.filter() dan _.reject() dapat digunakan dengan cara yang sama.

Istilah yang Anda gunakan dalam judul pertanyaan Anda Remove a property from a JavaScript object, dapat ditafsirkan dalam beberapa cara berbeda. Yang satu adalah menghapusnya untuk seluruh memori dan daftar kunci objek atau yang lain hanya untuk menghapusnya dari objek Anda. Seperti yang telah disebutkan dalam beberapa jawaban lainnya, delete kata kunci adalah bagian utama. Katakanlah Anda memiliki objek seperti:

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

Jika kamu melakukan:

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

hasilnya adalah:

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

Anda dapat menghapus kunci spesifik tersebut dari kunci objek Anda seperti:

delete myJSONObject["regex"];

Lalu gunakan kunci objek Anda Object.keys(myJSONObject) akan menjadi:

["ircEvent", "method"]

Tetapi intinya adalah jika Anda peduli dengan memori dan Anda ingin seluruh objek dihapus dari memori, disarankan untuk mengaturnya ke null sebelum Anda menghapus kunci:

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

Poin penting lainnya di sini adalah berhati-hati tentang referensi Anda yang lain ke objek yang sama. Misalnya, jika Anda membuat variabel seperti:

var regex = myJSONObject["regex"];

Atau tambahkan sebagai penunjuk baru ke objek lain seperti:

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

Kemudian bahkan jika Anda menghapusnya dari objek Anda myJSONObject, objek tertentu tidak akan terhapus dari memori, karena regex variabel dan myOtherObject["regex"] masih memiliki nilai-nilai mereka. Lalu bagaimana kita bisa menghapus objek dari memori dengan pasti?

Jawabannya adalah hapus semua referensi yang ada di kode Anda, menunjuk ke objek itu dan juga tidak digunakan var pernyataan untuk membuat referensi baru ke objek itu. Poin terakhir tentang ini var pernyataan, adalah salah satu masalah paling penting yang biasanya kita hadapi, karena menggunakan var pernyataan akan mencegah objek yang dibuat agar tidak dihapus.

Yang berarti dalam hal ini Anda tidak akan dapat menghapus objek itu karena Anda telah membuat regex variabel melalui var pernyataan, dan jika Anda melakukannya:

delete regex; //False

Hasilnya pasti false, artinya pernyataan penghapusan Anda belum dijalankan seperti yang Anda harapkan. Tetapi jika Anda belum membuat variabel itu sebelumnya, dan Anda hanya punya myOtherObject["regex"] sebagai referensi terakhir Anda, Anda bisa melakukan ini hanya dengan menghapusnya seperti:

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

Dengan kata lain, objek JavaScript akan mati segera setelah tidak ada referensi yang tersisa di kode Anda yang mengarah ke objek itu.

Memperbarui: Terima kasih kepada @AgentME:

Menetapkan properti ke null sebelum menghapusnya tidak tercapai   apa pun (kecuali objek telah disegel oleh Object.seal dan   hapus gagal. Itu tidak biasanya terjadi kecuali Anda secara khusus   mencoba).

Untuk mendapatkan info lebih lanjut Object.seal: Object.seal ()

ECMAScript 2015 (atau ES6) hadir dengan built-in Mencerminkan obyek. Adalah mungkin untuk menghapus properti objek dengan menelepon Reflect.deleteProperty () berfungsi dengan objek target dan kunci properti sebagai parameter:

Reflect.deleteProperty(myJSONObject, 'regex');

yang setara dengan:

delete myJSONObject['regex'];

Tetapi jika properti objek tidak dapat dikonfigurasi, tidak dapat dihapus baik dengan fungsi deleteProperty maupun menghapus operator:

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

Object.freeze () membuat semua properti objek tidak dapat dikonfigurasi (selain hal-hal lain). deleteProperty fungsi (serta hapus operator) kembali false ketika mencoba untuk menghapus semua properti itu. Jika properti dikonfigurasi, ia akan kembali true, bahkan jika properti tidak ada.

Perbedaan antara delete dan deleteProperty adalah ketika menggunakan mode ketat:

"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

Misalkan Anda memiliki objek yang terlihat seperti ini:

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

Menghapus properti objek

Jika Anda ingin menggunakan keseluruhan staff array, cara yang tepat untuk melakukan ini, akan melakukan ini:

delete Hogwarts.staff;

Atau, Anda juga bisa melakukan ini:

delete Hogwarts['staff'];

Demikian pula, menghapus seluruh array siswa akan dilakukan dengan menelepon delete Hogwarts.students; atau delete Hogwarts['students'];.

Menghapus indeks larik

Sekarang, jika Anda ingin menghapus satu anggota staf atau siswa, prosedurnya sedikit berbeda, karena kedua properti tersebut merupakan array sendiri.

Jika Anda tahu indeks anggota staf Anda, Anda dapat melakukan ini:

Hogwarts.staff.splice(3, 1);

Jika Anda tidak tahu indeks, Anda juga harus melakukan pencarian indeks:

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

Catatan

Sementara Anda bisa menggunakannya secara teknis delete untuk array, menggunakannya akan menghasilkan hasil yang salah saat memanggil contoh Hogwarts.staff.length kemudian. Dengan kata lain, delete akan menghapus elemen, tetapi tidak akan memperbarui nilai length milik. Menggunakan delete juga akan mengacaukan pengindeksan Anda.

Jadi, ketika menghapus nilai dari objek, pertama-tama selalu pertimbangkan apakah Anda berurusan dengan properti objek atau apakah Anda berurusan dengan nilai-nilai larik, dan pilih strategi yang tepat berdasarkan itu.

Jika Anda ingin bereksperimen dengan ini, Anda bisa menggunakannya Fiddle ini sebagai titik awal.

Itu hapus operator adalah cara terbaik untuk melakukannya.

Contoh nyata untuk ditampilkan:

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