Padam dan padam operator dalam kemahiran javascript_javascript

Jadi, mengapa kita boleh memadamkan atribut objek:

var x = { a: 1 };
delete x.a; // true
x.a; // undefined

Tetapi anda tidak boleh memadam pembolehubah:

var x = 1;
delete x; // false;
x; // 1

Anda tidak boleh memadam fungsi sama ada:

function x() {};
delete x; // false;
typeof x; // "function"

Nota: padam hanya mengembalikan palsu jika harta tidak boleh dipadamkan.

Setiap atribut mempunyai sifar kepada lebih banyak atribut dalaman - *ReadOnly, DontEnum, DontDelete dan Internal**. Anda boleh menganggapnya sebagai teg - harta mungkin mempunyai sifat dalaman khas atau tidak. Untuk perbincangan hari ini, kami berminat dengan DontDelete.

Apabila pembolehubah dan fungsi diisytiharkan, ia menjadi sifat objek Pembolehubah—sama ada objek pengaktifan (dalam kod fungsi) atau objek global (dalam kod global Sifat ini disertakan dengan Sifat dalaman DontDelete dijana). Walau bagaimanapun, sebarang sifat yang diperuntukkan secara eksplisit/implisit tidak menjana DontDelete. Dan ini pada asasnya mengapa kita boleh memadamkan beberapa sifat tetapi tidak yang lain.

var GLOBAL_OBJECT = this;

/* 'foo' ialah sifat objek global, yang dihasilkan melalui pengisytiharan berubah-ubah, jadi ia mempunyai sifat dalaman DontDelete

Itulah sebabnya ia tidak boleh dipadamkan*/

var foo = 1;
delete foo; // false
typeof foo; // "number"
/* 'bar

' ialah sifat objek global, yang dihasilkan melalui pengisytiharan berubah-ubah, jadi ia mempunyai anak DontDelete

Itulah sebabnya ia tidak boleh dipadam sama ada*/

function bar() {};
delete bar; // false
typeof bar; // "function"

/* 'baz' juga merupakan hak milik objek global,

Walau bagaimanapun, ia dijana melalui penetapan harta, jadi tiada DontDelete

Itulah sebabnya ia boleh dialih keluar*/

GLOBAL_OBJECT.baz = "baz";
delete GLOBAL_OBJECT.baz; // true
typeof GLOBAL_OBJECT.baz; // "undefined"

1.5, terbina dalam dan DontDelete | Jadi inilah sebabnya semua ini berlaku: harta dalaman khas sesuatu harta mengawal sama ada harta itu boleh dipadamkan atau tidak. Nota: Sesetengah sifat objek terbina dalam mempunyai sifat dalaman DontDelete dan oleh itu tidak boleh dipadamkan pembolehubah argumen khas (seperti yang kita ketahui, sifat objek yang diaktifkan) mempunyai sifat DontDelete (panjang parameter pulangan) bagi mana-mana contoh fungsi juga Jangan Padam:

(function() {
  //不能删除'arguments'，因为有DontDelete
  delete arguments; // false;
  typeof arguments; // "object"

  //也不能删除函数的length,因为有DontDelete
  function f() {};
  delete f.length; // false;
  typeof f.length; // "number"
}) ();

Sifat yang dikaitkan dengan argumen fungsi juga mempunyai DontDelete dan tidak boleh dipadamkan sama ada

(function(foo,bar) {
  delete foo; // false
  foo; // 1

  delete bar; // false
  bar; // "bah"
}) (1,"bah");

1.6 Tugasan pembolehubah tidak diisytiharkan |

Anda mungkin ingat bahawa tugasan pembolehubah yang tidak diisytiharkan menjadi sifat objek global melainkan sifat itu ditemui di tempat lain dalam rantaian skop. Dan kini kami memahami perbezaan antara penguntukan harta dan pengisytiharan berubah - yang kedua menjana DontDelete dan yang pertama tidak - itulah sebabnya tugasan pembolehubah yang tidak diisytiharkan boleh dipadamkan.

Nota: Atribut dalaman ditentukan apabila atribut dijana dan proses tugasan seterusnya tidak akan mengubah atribut dalaman atribut sedia ada. Adalah penting untuk memahami perbezaan ini.

var GLOBAL_OBJECT = this;

/* 通过变量声明生成全局对象的属性，拥有DontDelete */
var foo = 1;

/* 通过未声明的变量赋值生成全局对象的属性，没有DontDelete */
bar = 2;
delete foo; // false
delete bar; // true

Ringkasan:

/* 'foo'创建的同时生成DontDelete */
function foo() {};
/* 之后的赋值过程不改变已有属性的内部属性，DontDelete仍然存在 */
foo = 1;
delete foo; // false;
typeof foo; // "number"
/* 但赋值一个不存在的属性时，创建了一个没有内部属性的属性，因此没有DontDelete */
this.bar = 1;
delete bar; // true;
typeof bar; // "undefined"

Pengisytiharan pembolehubah dan fungsi ialah sifat bagi objek global Pengaktifan.

Properti mempunyai sifat dalaman, salah satunya - DontDelete - bertanggungjawab untuk menentukan sama ada sesuatu harta boleh dipadamkan.

Pembolehubah dan pengisytiharan fungsi dalam kod global atau kod fungsi semuanya menjana atribut dengan DontDelete.

Parameter fungsi juga merupakan atribut objek pengaktifan dan juga mempunyai DontDelete.

Padam atribut dalam objek: padam object.member

Anda hanya boleh memadam ahli anda sendiri

Hanya pembolehubah global yang diisytiharkan dengan var tidak boleh dipadamkan

Ahli global yang ditambahkan menggunakan tetingkap atau tetingkap[""] boleh dipadamkan

ps: padam operator dalam Javascript

Padam ialah salah satu operasi yang kurang kerap digunakan dalam bahasa Javascript, tetapi kadangkala, apabila kita perlu melakukan tindakan padam atau jelas, kita memerlukan operasi padam. Dalam artikel ini, kami akan menyelami cara menggunakannya dan cara ia berfungsi. Tujuan pemadaman, seperti yang anda fikirkan, adalah untuk memadamkan sesuatu Secara lebih khusus, ia akan memadamkan atribut objek, seperti dalam contoh berikut:

Operator

padam tidak akan memadamkan pembolehubah biasa, seperti dalam contoh berikut:

var Benjamin = {
  "name": "zuojj",
  "url" : "http://www.zuojj.com"
};
delete Benjamin.name;
//Outputs: Object { url: "http://www.zuojj.com" }
console.log(Benjamin);

Walau bagaimanapun, ia boleh mengalih keluar "pembolehubah global" kerana ia sebenarnya sifat objek global (tetingkap dalam penyemak imbas).

var benjamin = "http://www.zuojj.com";
delete benjamin;
//Outputs: "http://www.zuojj.com"
console.log(benjamin);

Operator

padam juga mempunyai nilai pulangan Jika pemadaman atribut berjaya, ia mengembalikan benar Jika atribut tidak boleh dipadamkan kerana atribut tidak boleh ditulis, ia akan mengembalikan salah, atau ia akan membuang ralat jika dalam. mod ketat.

// Because var isn't used, this is a property of window
benjamin = "zuojj";
delete window.benjamin;
// ReferenceError: benjamin is not defined
console.log(benjamin);

你可能不知道在什么情况下使用删除运算符。答案是，只要你真的想从对象中删除一个属性。

有的时候，Javascript开发不是删除一个属性，而是把这个属性值设置为null.像下面这样：

var benjamin = {
  "name": "zuojj",
  "url" : "http://www.zuojj.com"
};
benjamin.name = null;

虽然这有效地切断从原来的值的属性，但该属性本身仍然存在的对象上，你可以看到如下：

// Outputs: Object { name: null, url: "http://www.zuojj.com" }
console.log(benjamin);

同时，像in和for in 循环运算将不会报告null属性的存在，如果你使用个对象，可能使用这些方法来检查一个对象，你可能想确保你真正删除任何不需要的属性。

最后，你应该记住，删除并没有破坏属性的值，仅仅属性本身，看下面的例子：

var name   = "zuojj",
    benjamin = {};
benjamin.name = name;
delete benjamin.name;
//Outputs: "zuojj"
console.log(name);

这里，name和benjamin.name映射到相同的值，真如你所看到的，删除benjamin.name并不会影响name.

以上，就是我对delete运算符的概述，不妥之处，欢迎大家批评指正。