js基础知识点补充（4）

版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/ygj0727/article/details/98957985

面向对象
概念：是一种编程思想，在程序里面用对象来描述现实中一个具体的事务
对象：封装了一个事务的属性和功能的程序结构
why oop：和现实中人的想法非常接近，便于大程序的维护

创建一个自定义对象（封装）
var obj ={
属性名:属性值,
… : …,
方法名:function(){
…
this.属性名…
this.方法名()…
},
… : …,
创建一个叫 mafei：mafei 11岁 自我介绍 写信
var mafei = {
sname:“Mafei”,
sage:11,
intr:function(){
console.log(

My name is ${this.sname} ,I'm ${this.age}

);
// this关键字也可以在方法中调用对象的其他方法
this.wri();
},
wri:function(){
console.log(‘写信’);
},
}
console.log(mafei.sname);
//如果此时我要改变mafei的属性
mafei.sage++;
console.log(mafei.sname)
}
有一个关键字this
（1）this代表着对象自己的方法，要访问自己的属性，必须用this.属性名
（2）this 就是引用正在调用函数对象的关键词，就是点前面的对象
（3）方法中不加this的变量，默认仅在作用域链中找，不会去对象中查找
（4）只要对象的方法想要用自己的属性，必须加this

使用new时注意 在创建对象时，暂时不知道对象的成员
var obj = new Object();//创建一个新对象，可以简写成new Object或者Object()
向空对象中添加属性和方法
obj.属性名= 属性值
obj.方法名=function(){…this.属性名…}
var mafei = Object();
mafei.name = “Mafei”;
mafei.age = 11;
mafei.intr = function(){
console.log('My name is '+this.name+",I’am "+this.age);
}
mafei.age ++;
mafei.intr();
对象的本质是
js中的一切对象的底层都是关联数组
每个属性/方法 都是关联数组中的元素value
每个方法名/属性名，都是关联数组中的key

构造函数：专门用来描述一类对象统一结构的函数，它们有共有的属性和方法
开始定义构造函数，其中类型名的首字母大写（人为规范）
function 类型名(属性参数列表）{
this.属性名 = 属性参数值;
…;
this.方法名 = function(){
…this.属性名…
}
}
用new调用构造函数，传入具体对象的属性值
var obj = new 类型名(属性值列表); 创建一个指定类型的对象；用new调用指定"类型"
function Student(sname,sage){
this.sname = sname;
this.sage = sage;
this.intr = function(){
console.log(

My name is ${this.sname},I'am ${this.sage}

);
}
}
var mafei = new Student(“Mafei”,11);
var pdd = new Student(“Pdd”,11);
console.dir(mafei);
lilei.intr();
console.dir(pdd);
lihua.intr();

继承：父对象的成员，子对象不用重复创建，也可以直接使用
好处是可以节约内存
什么时候用：只要一类子对象，都需要相同的苏醒或功能时，都要将相同的属性和功能仅在父对象中定义一次即可。

function Student(sname,sage){
this.sname = sname;
this.sage = sage;

}
// prototype 是构造函数的一个属性
Student.prototype.intr=function(){//在原型对象中添加方法
console.log(`My name is ${this.sname},I'am ${this.sage}`);
}
// 在原型对象中添加属性
Student.prototype.className = '初一2班';
var lilei = new Student("Li Lei",11);
var lihua = new Student("Li Hua",11);
console.dir(lilei);
console.dir(lihua);
// 关于原型对象中的方法和属性的访问   --和构造函数的方法一样使用
lilei.intr();
console.log(lilei.className);
// 如果修改原型对象中的方法或属性？  不会去修改原型对象中的属性值，而是在子对象中自己添加一个新的属性
lihua.className = "初一3班";//七年级2班
console.log(lihua.className,lilei.className);

// 正确的修改原型中的属性
Student.prototype.className = "七年级2班";
console.log(lilei.className,lihua.className);

自有属性：直接保存在对象本地的属性
共有属性：保存在原型对象中，被所有子对象共享的属性
使用方式都是 创建的类型名。属性/方法
赋值：自有属性：对象名.属性 = 值
共有属性： 构造函数.prototype.属性名 = 值
鉴别自有 var bool = obj.hasOwnProperty(“属性名”)
接下来来判断属性名是否是obj的自有属性
true：自有属性
false：不是自有属性 共有属性，一种不存在的属性

var isOwn = lilei.hasOwnProperty(“teacher”);
console.log(isOwn);//
console.log(lilei.teacher);//
console.log(lilei.className);//
// 是否为共有属性 ：不是自有属性 && obj.属性名 != undefined

function checkProperty(obj,pname){
console.dir(obj)
console.log(pname in obj);
// 是否为自有属性
if(obj.hasOwnProperty(pname)){
console.log('自有');
}else{
// 共有
// if(obj[pname] !== undefined){
if(pname in obj){// 检测pname中存储的属性名是否在obj对象中存在，存在返回true，否则返回false
console.log('共有');
}else{// 没有
console.log('没有');
}

}
}

checkProperty(lihua,"sname");//自有
checkProperty(lilei,"className");//共有
checkProperty(lihua,"teacher");//没有

// 删除属性 可以使用delete关键字删除对象的属性
function Emp(ename,salary){
this.ename = ename;
this.salary = salary;
this.toString = function(){
console.log(

${this.ename}的工资是：${this.salary}元

)
}
}
var emp1 = new Emp(“jack”,5000);
var emp2 = new Emp(“张三丰”,10000);
Emp.prototype.partName = “研发部门”;
emp1.toString();
emp2.toString();

// 删除的自有属性（存储在 emp1对象当中的属性）
delete emp1.ename;
console.log(emp1.ename);
console.log(emp2.ename);
// 通过原型对象删除共有属性
delete Emp.prototype.partName;
console.log(emp1.partName);
console.log(emp2.partName);

删除对象的属性以及删除原型中的属性的操作是非常危险的，谨慎使用