面向對象 一、單例模式 1.1 對象數據類型的作用: 把描述一個對象的屬性和方法放在一個單獨的空間,與其他的對象分割開,即時出現屬性名相同的情況,也不會產生衝突 單例模式就好像上面對象數據類型一樣,使用分組編寫代碼思想。在單例模式中person1叫命名空間,只是存放空間的一個名字而已。 1.2 模塊 ...
面向對象
一、單例模式
1.1 對象數據類型的作用:
把描述一個對象的屬性和方法放在一個單獨的空間,與其他的對象分割開,即時出現屬性名相同的情況,也不會產生衝突
var name="xiao 1"
var age=12
var name="xiao 2"
var aeg=13
//單例模式
var person1={
name="xiao 1",
age=12
}
var person2={
name="xiao 2",
age=13
}
單例模式就好像上面對象數據類型一樣,使用分組編寫代碼思想。在單例模式中person1叫命名空間,只是存放空間的一個名字而已。
1.2 模塊化開發:
在項目中使用單例模式來開發一個大型項目,把當前的需求分成若幹個功能模塊,每個人負責一部分,同時開發,最後把所有人的代碼整合在一起。
// 公共模塊
var utils = {
select: function () {
}
}
// tab模塊
var tabRender = {
change: function () {
utils.select() //公共模塊方法調用
}
}
// search模塊
var searchRender = {
change: function () {
this.clickEvent() //自己命名空間下方法調用,this可以避免修改名字的麻煩
},
clickEvent: function () {
}
}
缺點:單例模式手工生產輸出單個個體,需要批量多個是就麻煩。
二、工廠模式
2.1 工廠模式:
用函數封裝實現同一件事相同的代碼,要實現該功能,只需要執行函數就可以了。
function creatTable(w,h) {
var obj = {};
obj.width = w;
obj.height = h;
obj.fn = function () {
console.log("the table width is "+this.width+" and height is "+this.height)
}
return obj;
}
var myTable=creatTable(200,100)
myTable.fn()
2.2 低耦合高內聚:
減少頁面中的冗餘代碼,提高代碼的重覆利用率
三、一些概念
- 繼承:子類繼承父類的屬性和方法
- 封裝:把相同的代碼放在一個函數裡面,以後要實現該功能執行函數就可以了。
- 多態:當前方法的多種形態。後臺語言中包括重載(傳入的參數不一樣,方法也不一樣,js沒有重載)和重寫(子類重寫父類的方法通過原型鏈)。
- 對象:js中萬物皆是對象。一個泛指
- 類:對象的具體細分
- 實例:一個類別中具體的一個個體
- 舉個例子 對象:大自然;類:動物、植物、人 實例:貓狗 你我他
+內置類:
Number,String,Boolean,Null,Undefined
Object、Array、RegExp、Date、Function...
四、構造函數模式
主要的目的創建一個自定義類,並創建這個類的實例。
構造函數和工廠模式區別
4.1 執行的時候
構造函數要在類(首字母一般大寫,不是函數和方法)(所有的類都是函數數據類型)前加new,返回的是類的實例
var a=creatTable(10,10)
var b=new CreatTable(10,12)
4.2 代碼執行
先創建一個私有的作用域,形參賦值,進行預解釋,代碼執行從上到下執行。
特別的地方,不用手動創建空的對象obj,瀏覽器會預設幫我們創建一個對象數據類型(這個對象是我們當前類的一個實例)(用this代表),代碼執行,把屬性名、屬性值賦予當前的實例,最後瀏覽器返回當前的實例。
function CreatTable(w,h) {
// 創建myTable實例 也就是this
this.width = w; // 賦值 myTable.width
this.height = h;
this.fn = function () {
console.log("the table width is "+this.width+" and height is "+this.height)
}
// 返回實例
}
var myTable=new CreatTable(200,100)
myTable.fn()
知識點:
1、js所有的類都是函數數據類型、所有的實例都是對象數據類型
2、類中this是類的一個實例
3、this.xxx=xxx都是私有屬性,不同實例私有屬性不相等
4.3 構造函數擴展
1、構造函數中new fn() 執行,如果沒有傳遞參數,後面的括弧可以省略new Fn。
2、this在類中出現指的是當前類的一個實例,在一個屬性值是方法時,要看執行的時候前面有".",有就是點前面的,沒有則是window
function Fn() {
this.a=50;
this.getA=function () {
console.log(this.a);
}
}
var F1=new Fn; // 類後面可以不加括弧
F1.getA() //50 this-->F1
var F2=F1.getA //F2 --> function(){console.log(this.a);}
F2() //undefined this-->window
3、在構造函數中,瀏覽器會預設的返回一個對象數據類型的值,如果我們手動的創建返回的值。返回的是基本數據類型的值,創建的實例對象沒有影響。返回的是引用數據類型的值,當前的實例會被返回值替換。
function Fn() {
this.x=1;
this.getX=function() {
console.log(this.x);
}
return {x:233} //基本數據類型沒有影響
}
var f1=new Fn;
console.log(f1) //{x: 233}
4.4 檢測類型
- 檢測某一個實例是否屬於這個類 instanceof
console.log(f1 instanceof Fn) true
- 檢測屬性屬於對象 in
console.log(x in f1) true
- 是否是私有屬性 hasOwnProperty
console.log(f1.hasOwnProperty("grtX")) true
- 是否是公有屬性
function hasPunProperty(obj,attr) {
retrun (attr in obj) && !obj.hasOwnProperty(attr);
}
console.log(hasPUnProperty(f1,"getX")) //flase
五、原型鏈模式
5.1 概述
構造函數模式有類和實例的概念,把兩者區分開,那如何識別每一個類,就需要原型鏈模式。
把實例上公有的屬性和方法放到類的原型上(xxxx.prototype)
function CreatTable(w, h) {
this.width = w;
this.height = h;
}
CreatTable.prototype.fn = function () {
console.log("the table width is " + this.width + " and height is " + this.height)
}
- 1、每一個函數數據類型(類)都有一個天生自帶的屬性(prototype),屬性值是對象數據類型。
- 2、在prototype上瀏覽器天生給他加上一個constructor屬性,屬性值是當前函數(類)本身。
- 3、每一個對象數據類型(實例,對象,prototype)天生自帶一個屬性_proto_,屬性值是當前實例所屬類的原型(prototype)
5.2 原型鏈
一個實例的方法在運行的時候,如果這個方法是自己私有的,那麼就直接用,如果不是私有的,那麼通過__proto__去所屬類的原型上去查找,如果還沒有就通過原型的__proto__一直查到基類的Object.如果還沒有報錯,如果有就直接用了。我們把這種通過__proto__查找的機制叫做原型鏈.
5.3 批量設置原型上的公有屬性和方法
1、起別名
function Fn() {
this.x = 100
}
var pro = Fn.prototype;
pro.getX = function () { }
pro.getY = function () { }
2、重構原型上的對象
重新開闢一個堆記憶體,存儲自定義公有的屬性和方法,原來瀏覽器開闢的堆記憶體會給替換掉(沒有constructor指向不是創建實例的類而是向上查找的Object,為了保持一致可以手動增加constructor的指向)瀏覽器在空閑的時候會銷毀回收記憶體。
function Fn() {
this.x = 100
}
Fn.prototype={
constructor: Fn,
getX: function () { },
getY: function () { }
}
用上面的方法給內置的類增加公有的方法,會把原來的屬性和方法替換,瀏覽器會屏蔽這種方法。
但是我們可以一個個去修改內置的方法,重覆修改沒有則增加(用特殊的命名標記自己的方法)
Array.prototype = {
constructor: Array,
unique: function() {}
};
console.dir(Array.prototype);
////
Array.prototype.sort1 = function () {
console.log("ok");//this->ary 我們當前要操作的這個數組
};
var ary = [1, 2, 2, 1, 2, 3, 4, 2, 1, 3];
var res=ary.sort1(); //把sort1 改成sort 就是修該內置的sort
console.log(ary);
console.log(res);
5.4 原型,模式中this指向問題。
數組去重
Array.prototype.unique = function () {
var obj = {}
for (var i = 0; i < this.length; i++) {
var cur = this[i]
if (obj.cur === cur) {
this[i] = this[this.length - 1]
this.length--
i--
continue
}
obj.cur = cur
}
obj = null
return this
}
ary = [2, 12, 121, 12, 1, 2, 2, 1, 3, 41, 1]
ary.unique()
鏈式寫法:執行完成數組的一個方法可以緊接著執行下一個方法
//數組從小到大,再倒序排列,去除最後的一個數,返回去除的數,原數組改變
Array.sort(function (a, b) {return a-b }).reverse().pop()
5.5 可枚舉和不可枚舉
Object.prototype.lol=function () { }
var obj={name:"小a",age=12}
for(var key in obj){
//for in預設的情況下只會遍歷到實例的私有屬性和我們在實例所屬類的原型上增加的方法屬性。
if(obj.propertyIsEnumerable(key)){
//原型上的方法和屬性都是不可枚舉的不管是內置還是增加的
console.log(key)
}
if(obj.hasOwnPerporty(key)) {
//另一種方法,只枚舉公有的方法
console.log(key)
}
}
5.6 原型繼承
子類和父類通過原型鏈有了關聯,也是通過查找原型鏈來實現,
function A() {
this.x = 100
}
A.prototype.getX = function () { }
function B() {
this.y = 200
}
//讓B繼承A的方法和私有屬性
B.prototype = new A;
//父類中公有和私有都會變成子類原型上的公有的屬性和方法