Pertanyaan Bagaimana cara menghapus properti dari objek JavaScript?
Katakanlah saya membuat objek sebagai berikut:
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
Apa cara terbaik untuk menghapus properti regex
berakhir dengan yang baru myObject
sebagai berikut?
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI"
};
4893
2017-10-16 10:57
asal
Jawaban:
Seperti ini:
delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];
Demo
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
delete myObject.regex;
console.log(myObject);
Bagi siapa pun yang tertarik untuk membaca lebih banyak tentang hal itu, pengguna Stack Overflow kangax telah menulis posting blog yang sangat mendalam tentang delete
pernyataan di blog mereka, Memahami penghapusan. Sangat disarankan.
6817
2017-10-16 10:58
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 delete
operator 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:
- 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.
- 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.
700
2018-02-12 17:48
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.
192
2017-10-16 11:03
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 delete
untuk 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 null
s--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.
133
2017-09-18 00:56
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);
91
2017-11-08 18:02
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.
65
2018-05-24 18:53
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 ()
33
2018-02-12 06:29
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
28
2018-01-10 16:36
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.
28
2018-02-21 18:09
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.
22
2018-04-28 05:14