Fahami secara ringkas ciri pengkapsulan dan pewarisan dalam pengetahuan JavaScript_Basic

Pengenkapsulan dalam JavaScript
Encapsulation hanya bermaksud bahawa dunia luar hanya boleh mengakses pembolehubah dan fungsi biasa objek, menyembunyikan butiran dan data.
Terdapat tiga cara untuk mencipta objek dalam js, iaitu membuka pintu, menggunakan konvensyen penamaan untuk membezakan pembolehubah persendirian, dan penutupan untuk mencipta pembolehubah persendirian sebenar.
1. Pintu terbuka adalah kaedah paling asas untuk merealisasikan objek Semua kaedah dan pembolehubah adalah biasa dan boleh diakses oleh dunia luar.

var Book = function(name){ 
  if(this.check(name)){ 
    console.log("error"); 
    throw new Error("name null"); 
  } 
  this.name = name; 
} 
Book.prototype = { 
  check:function(name){ 
    if(!name){ 
      return true; 
    } 
  }, 
  getName:function(){ 
    return this.name; 
  } 
} 
 
var book = new Book("哈哈"); 
//output:哈哈 哈哈 
console.log(book.name,book.getName()); 

Contoh ini ialah contoh tipikal pintu terbuka, di mana dunia luar boleh terus mengakses sifat dan kaedah objek. Anda boleh melihat bahawa sifat dan pembolehubah dicipta dengan "ini".

2. Gunakan konvensyen penamaan untuk membezakan pembolehubah persendirian Kaedah ini adalah versi optimum kaedah pintu terbuka Ia hanya dibezakan dengan "_" di hadapan pembolehubah persendirian atau kaedah Jika pengaturcara bercadang untuk menggunakan kaedah _getName(). untuk memanggil kaedah, masih tidak boleh dihalang, ia tidak benar-benar menyembunyikan pembolehubah.

3. Penutupan mewujudkan pembolehubah persendirian sebenar Kaedah ini mengambil kesempatan daripada fakta bahawa hanya fungsi dalam js mempunyai skop dan mentakrifkan pembolehubah yang berkaitan dalam skop pembina.

var Book2 = function(name){ 
  if(check(name)){ 
    console.log("error"); 
    throw new Error("name null"); 
  } 
  name = name; 
  function check(name){ 
    if(!name){ 
      return true; 
    } 
  } 
  this.getName = function(){ 
    return name; 
  } 
} 
Book2.prototype = { 
  display:function(){ 
    //无法直接访问name 
    return "display:"+this.getName(); 
  } 
} 
var book2 = new Book2("哈哈"); 
//output:undefined "哈哈" "display:哈哈" 
console.log(book2.name,book2.getName(),book2.display()); 

Seperti yang anda lihat, dalam contoh ini, mengakses nama secara langsung akan mengembalikan hasil yang tidak ditentukan. Anda boleh melihat perbezaan antara contoh ini dan jenis pintu terbuka Pembolehubah dalam jenis pintu terbuka dibuat menggunakan "ini", manakala dalam contoh ini var digunakan untuk menciptanya. supaya nama dan fungsi semak hanya boleh dibuat dalam pembina Ia diakses dalam skop fungsi dan tidak boleh diakses secara langsung oleh dunia luar.
Kaedah ini menyelesaikan masalah dua kaedah pertama, tetapi ia juga mempunyai kelemahan tertentu. Dalam mod penciptaan objek pintu terbuka, semua kaedah dicipta dalam objek prototaip, jadi tidak kira berapa banyak contoh objek dijana, hanya satu salinan kaedah ini wujud dalam memori Dengan kaedah ini, setiap objek baharu yang dihasilkan akan Cipta salinan baharu pembolehubah dan kaedah persendirian, yang menggunakan lebih banyak memori.

Warisan dalam JavaScript
Kelas asas buku:

var Book = function(name){ 
  if(this.check(name)){ 
    console.log("error"); 
    throw new Error("name null"); 
  } 
  this.name = name; 
} 
Book.prototype = { 
  check:function(name){ 
    if(!name){ 
      return true; 
    } 
  }, 
  getName:function(){ 
    return this.name; 
  } 
} 

Kaedah yang diwarisi:

function extend(subClz,superClz){ 
var F = function(){} 
F.prototype = superClz.prototype; 
subClz.prototype = new F(); 
subClz.prototype.constructor = subClz; 
subClz.superClass = superClz.prototype; 
if(superClz.prototype.constructor == Object.prototype.constructor){ 
  superClz.prototype.constructor = superClz; 
} 

Menggunakan fungsi kosong F sebagai jambatan boleh mengelakkan overhed tambahan untuk memanggil pembina kelas induk apabila secara langsung kelas induk Selain itu, apabila pembina kelas induk mempunyai parameter, anda ingin melaksanakannya secara langsung melalui subClass.prototype = new superClass() ; Memanggil pembina kelas induk dan warisan melalui rantaian prototaip tidak dibenarkan.

subClz.superClass = superClz.prototype; 
if(superClz.prototype.constructor == Object.prototype.constructor){ 
  superClz.prototype.constructor = superClz; 
} 

Menambah tiga ayat ini boleh menghalang subkelas daripada mewarisi kelas induk dan menulis Book.call(nama ini, sebaliknya, tulis ArtBook.superClass.Constructor.call(ini, nama).
Dan apabila subkelas mengatasi kaedah kelas induk, ia boleh memanggil kaedah kelas induk:

ArtBook.prototype.getName = functiion(){ 
  return ArtBook.superClass.getName.call(this) + "!!!"; 
} 

Subkelas ArtBook:

var ArtBook = function(name,price){ 
  ArtBook.superClass.Constructor.call(this,name); 
  this.price = price; 
} 
extend(ArtBook,Book); 
ArtBook.prototype.getPrice = function(){ 
    return this.price; 
} 
ArtBook.prototype.getName = function(){ 
   return ArtBook.superClass.getName.call(this)+"!!!"; 
 }