1、基本寫法和組成
var obj=new Object();//創建一個空的對象
obj.name='a'; //屬性
obj.showName=function(){ //方法
console.log(this.name);
}
obj.showName();
var obj2=new Object();
obj.name='b';
obj.showName=function(){
console.log(this.name);
}
obj2.showName();
2、工廠模式
面向對象中的封裝函數
function People(name){
//var obj={};//與new Object()相同
var obj=new Object();
obj.name=name;
obj.showName=function(){
console.log(this.name);
}
return obj;
}
var p1=People('a');
p1.showName();
var p2=People('b');
p1.showName();
new去調用一個函數的時候，這個函數中的this就是創建出來的對象，而且函數的返回值就是this（隱式返回）,創建出來的對象叫做實例對象 var p1=new People('a'); p1就是創建出來的實例對象
new后面調用的函數就是構造函數 new Arry() ,Arry()就是數組的構造函數
function People(name){
this.name=name;
this.showName=function(){
console.log(this.name);
}
}
var p1=new People('a');
p1.showName();
var p2=new People('b');
p2.showName();
//p1 p2的構造函數是People
3、對象的引用
基本類型：賦值的時候只是值得復制
對象類型：不僅是值得復制，而且也是引用的傳遞
var a=5,b=a;
b+=3;
alert(a); //5
alert(b); //8
var a=[1,2,3];
var b=a;
b.push(4);
alert(a); //[1,2,3,4]
alert(b); //[1,2,3,4]
var a=5, b=5;
alert(a==b);//true 基本類型，值相同就可以
var b=[1,2,3], c=[1,2,3];
alert(b==c);//false 對象類型，值和引用都相同才可以
4、prototype
原型：改寫對象下面公用的方法和屬性，讓公用的方法和屬性在內存中存在一份
prototype => class 普通方法 => style
普通方法的優先級高于prototype
var arr=[1,5,9];
Arry.prototype.sum= function () {
var result=0;
for(var i=0;i<this.length;i++){
result+=this[i];
}
returnresult;
};
alert(arr.sum());
arr.number=10;
Arry.prototype.number=20;
function People(name){
this.name=name;
}
People.prototype.showName=function(){
alert(this.name);
}
var p1=new People('a');
var p2=new People('b');
p1.showName==p1.showName; //true
具體寫法
function 構造函數(){
this.屬性
}
構造函數.prototype.方法=function(){}
面試題
function C1(name){
if(name){
this.name=name;
}
}
function C2(name){
this.name=name;
}
function C3(name){
this.name=name||'John';
}
C1.prototype.name='Tom';
C2.prototype.name='Tom';
C3.prototype.name='Tom';
alert(new C1().name);//Tom
alert(new C2().name);//undefined
alert(new C3().name);//John
JS是基于原型的程序
var arr=[1,2,3];
Array.prototype.push=function(){
for(var i=0;i<arguments.length;i++){
this[this.length]=this.arguments[i];
}
return this.length;
}
arr.push(4,5,6);
5、包裝對象
基本類型會找到對應的包裝對象類型，然后包裝對象把所有的方法和屬性給了基本類型，然后包裝對象消失
//var str=new String('hello');
//alert(typeof str);//object
//String.prototype.charAt= function () {};
var str='hello';//str.charAt(1);
String.prototype.lastValue=function(){
return this.charAt(this.length-1);
};
alert(str.lastValue());//o
/*var str='hello';
str.number=10;
alert(str.number);//undefined*/
6、面向對象中的一些屬性和方法
hasOwnProperty()看是不是對象自身下面的屬性
constructor()查看對象的構造函數，每個構造函數原型下都會有constructor屬性 Aaa.prototype.constructor=function(){}
var arr=[];
arr.num=10;
Array.prototype.num2=20;
console.log(arr.hasOwnProperty('num'));//true
console.log(arr.hasOwnProperty('num2'));//false
function Aaa(){}
Aaa.prototype.constructor=Aaa;//自動添加的屬性
var a1=new Aaa();
console.log(a1.constructor);//Aaa
arr.constructor//Array
arr.constructor==Array //true 判斷數組
var arr=[1,2,3];
arr.toString()// '1,2,3'
Array.prototype.toString=function(){
return this.join('');
}
var num=20;
num.toString(16)//轉化成16進制
//利用toString做類型的判斷
var arr=[];
var json={};
Object.prototype.toString.call(arr)// '[object Array]'
Object.prototype.toString.call(json)// '[object object]'
console.log(Object.prototype.toString.call(arr)=='[object Array]');//true
window.onload=function(){
var oF=document.createElement('iframe');
document.body.appendChild(oF);
var ifArray=window.frames[0].Array;
var arr=new ifArray();
console.log(Object.prototype.toString.call(arr)=='[object Array]');
//true
}
intanceof :運算符 對象與構造函數在原型鏈上是否有關系 可以做類型的判斷
function Aaa(){}
var a1=new Aaa();
console.log(a1 instanceof Aaa);//true
console.log(a1 instanceof Object);//true
console.log(a1 instanceof Array);//false
toString() 把對象轉成字符串 Object上的方法,系統對象下是自帶的，自己寫的對象都是通過原型鏈找的Object下面的
function Aaa(){}
var a1=new Aaa();
a1.toString==Object.prototype.toString//true
var arr=[];
arr.toString==Object.prototype.toString//false
7、繼承
繼承：子類不影響父類，子類可以繼承父類的一些功能（代碼復用）拷貝繼承:通用型 有new或無new都可以
類式繼承 new構造函數
原型繼承 無new的對象 {}等屬性的繼承：調用父類的構造函數，call/apply方法的繼承：for in 拷貝繼承
