https://www.bilibili.com/video/BV1YW411T7GX?p=47
这里写目录标题
1.1 Object 对象
- 对象的分类:
- 1.内建对象
-由ES标准中定义的对象,在任何的ES的实现中都可以使用
-比如:Math String Number Boolean Function Object……… - 2.宿主对象
由JS的运行环境提供的对象,目前来讲主要指由浏览器提供的对象
-比如BOM DOM - 3.自定义对象
-由开发人员自己创建的对象
- 1.内建对象
1.2 对象增删改查(new Object)
*使用new关键字调用的函数,是构造函数constructor
*构造函数是专门用来创建对象的画数
*使用typeof检查一个对象时,会返回object
1.创建
var obj=new Object();
2.增 //*向对象添加属性 语法:对象.属性名=属性值;
obj.name="孙悟空";
obj.gender="男";
obj.age=18;
3. 删
delete obj.name;
4. 改
obj.name="tom";
5. 查
console.1og(obj); // Object{name="孙悟空",gender="男”,age=18}
console.1og(obj.name); //Object{name="孙悟空"}
=================使用[]可以传变量==================
ps:增obj["123"]=789; 查console.1og(obj["123"]);
套娃
//创建一个对象
var obj=new Object();
var obj2=new Object();
obj2.name=“猪八戒”;
obj.test=obj2;
console.log(obj.test.name); //猪八戒
检查obj中是否含有test属性,有true,无false
console.log("test2"in obj);
console.log("test"in obj)
其他创建对象方法
var obj = {};
obj.name = "猪八戒"
var obj2 = {
name:“猪八戒”,
age:28,
gender:“男”,
test:{name:"沙和尚"}
};
1.2 对象存放位置
- 基本数据类型String Number Boolean Null Undefined
引用数据类型Object - JS中的变量都是保存到堆内存中的,
- 基本数据类型的值直接在栈内存中存储,值与值之间是独立存在,修改一个变量不会影响其他的变量
- 对象是保存到堆内存中的,每创建一个新的对象,就会在堆内存中开辟出一个新的空间,而变量保存的是对象的内存地址(对象的引用),如果两个变量保存的是同一个对象引用,当一个通过一个变量修改属性时,另一个也会受到影响
2 Function 函数
在函数中封装、存储代码和功能
2.1 构造函数来创建一个函数对象
1.创建一个函数对象
var fun=new Function();
var fun=new Function("console.1og('Hel1o 这是我的第一个函数');");
2.封装到函数中的代码不会立即执行,函数中的代码会在函数调用的时候执行
//调用函数语法:函数对象()
fun(); //当调用函数时,函数中封装的代码会按照顺序执行
2.2 使用函数声明来创建一个函数
function sum(a,b,c){
var d=a+b+c;
return d;
}
var result=sum(4,7,8);
- sum()
-调用函蒙
-相当于使用的函数的返回值
sum
-函数对象
-相当于直接使用函数对象
2.3 使用函数表达式来创建一个函数
function(){
console.1og("我是匿名函数中封装的代码")}
赋值给以个变量,最后要加;
var a = function(){
console.1og("我是匿名函数中封装的代码");
};
2.4立即执行函数
(function(){
alert(“我是一个匿名函数~~~");
})();
(function(a,b){
console.log("a="+a);console.1og("b="+b);
})(123,456);
3 method (构造)方法
var obj=new object();
obj.name="孙悟空";
obj.age=18;
---对象的属性值可以是任何的数据类型,也可以是个函数,该属性称之为方法
obj.sayName=function(){
console.1og(obj.name);
};
4 (对象和)初见this
- 解析器在调用函数每次都会向函数内部传递进一个隐含的参数,
这个隐含的参数就是this,this指向的是一个对象,这个对象我们称为函数执行的上下文对象 - 根据函数的调用方式的不同,this会指向不同的对象
1.以函数的形式调用时,this永远都是window
2.以方法的形式调用时,this就是调用方法的那个对象
function fun(a,b){
console. log(this);
}
var obj={
name:"沙和尚",
sayName:fun
};
fun(); 等同于:window.fun();
结果:"[object window]"
obj.sayName();
结果:"[object Object ]"
补充
var name="全局";
function fun(){
console.1og(this.name); -->同时调用obj和obj2时,可以输出对应的name,孙悟空or沙和尚!
console.1og(obj.name); -->同时调用obj和obj2时,只能输出obj的name孙悟空
console.1og(obj2.name); -->同时调用obj和obj2时,只能输出obj2的name沙和尚
var obj={
name:“孙悟空",
sayName:fun
};
var obj2={
name:“沙和尚",
sayName:fun
};
//我们希望调用obj.sayName()时可以输出obj的名字
我们希望调用obj2.sayName()时可以输出obj2的名字
obj.sayName();
obj2.sayName();
此处obj是对象,该对象内的this会根据调用对象指向相应的对象
4.1 批量 创建对象-工厂方法
------->>>麻烦的创建对象方法--------------------------
var obj={
name:"孙悟空",
age:18,
gender:"男",
sayName:function(){
alert(this.name);
}
};
var obj2={
name:"猪八戒”,
age:28
gender:"男",
sayName:function(){
alert(this.name);
}
};
var obj3={
name:"沙和尚”,
age:38,
gender:"男",
sayName:function(){
alert(this.name);
}
};
--------------------工厂方法--------------------
/*
*使用工厂方法创建对象
*通过该方法可以大批量的创建对象
*/
function createPerson(name,age,gender){
//创建一个新的对象
var obj=new Object();
//向对象中添加属性
obj.name=name;
obj.age=age;
obj.gender=gender;
obj.sayName=function(){
alert(this.name);
};
return obj;
}
var obj2=createPerson("猪八戒",28,“男");
var obj3=createPerson("白骨精”,16,“女");
var obj4=createPerson(“蜘蛛精”,18,“女");
obj3.sayName();
- 使用工厂方法创建的对象,使用的构造函数都是Object所以创建的对象都是Object这个类型,就导致我们无法区分出多种不同类型的对象|
4.2 批量 创建对象-构造方法
-
创建一个构造函数,专门用来创建Person对象的
-
构造函数就是一个普通的函数,创建方式和普通函数没有区别,不同的是构造函数习惯上首字母大写
构造函数和普通函数的区别就是调用方式的不同
普通函数是直接调用,而构造函数需要使用new关键字来调用 -
构造函数的执行流程:
1.立刻创建一个新的对象
2.将新建的对象设置为函数中this,在构造函数中可以使用this来引用新建的对象
3.逐行执行函数中的代码
4.将新建的对象作为返回值返回 -
使用同一个构造函数创建的对象,我们称为一类对象,也将一个构造函数称为一个类。
-我们将通过一个构造函数创建的对象,称为是该类的实例。
function Person(name,age,gender){
this.name=name;
this.age=age;
this.gender=gender;
this.sayName=function(){
alert(this.name);
};
}
function Dog(){}
var per=new Person("孙悟空",18,“男");
var per2=new Person("玉兔精”,16,"女”);
var per3=new Person("奔波霸",38,“男");
var dog=new Dog();
-------使用instanceof可以检查一个对象是否是一个类的实例,如果是,则返回true,否则返回false
console.log(per instanceof Person);
console.log(dog instanceof Person);
-------所有的对象都是Object的后代,所以任何对象和Object左instanceof检查时都会返回true
改进上述代码:
在sayName处,改为如下
{
this.sayName = fun();
}
在外部添加全局函数:
function fun(){
alert(this.name);
};
this的情况:
1.当以函数的形式调用时,this是window 【fun()】
2.当以方法的形式调用时,谁调用方法this就是谁 【obj.fun()】
3.当以构造函数的形式调用时,this就是新创建的那个对象 【var per = new Person】
5 原型prototype
- 我们所创建的每一个函数,解析器都会向函数中添加一个属性prototype这个属性对应着一个对象,这个对象就是我们所谓的原型对象
- 如果函数作为普通函数调用prototype没有任何作用
- 当函数以构造函数的形式调用时,它所创建的对象中都会有一个隐含的属性,指向该构造函数的原型对象,我们可以通过__proto__来访问该属性。
- 原型对象就相当于一个公共的区域,所有同一个类的实例都可以访问到这个原型对象,我们可以将对象中共有的内容,统一设置到原型对象中。
- 当我们访间对象的一个属性或方法时,它会先在对象自身中寻找,如果有则直接使用,如果没有则会去原型对象中寻找,如果找到则直接使用
- 以后我们创建构造函数时,可以将这些对象共有的属性和方法,统一添加到构造函数的原型对象中,这样不用分别为每一个对象添加,也不会影响到全局作用域,就可以使每个对象都具有这些属性和方法了
function MyClass(){}
var mc= new MyClass();
console. log(mc. proto_==MyClass. prototype); !!!!!
var mc2=new MyClass();
console. log(mc2. proto_==MyClass. prototype);
--------->>>>>>将对象中共有的内容,统一设置到原型对象中--------------------
MyClass.prototype.a=123; ---向MyClass的原型中添加一个方法
console.1og(mc.a);
Person.prototype.sayName=function(){ ----向原型中添加sayName方法
alert("Hello大家好,我是:"+this.hame);
};
var per=new Person("孙悟空",18,“男");
var per2=new Person("猪八戒”,28,“男”);
per.sayName();
per2.sayName();
5.1 原型的原型
function MyClass(){
MyClass.prototype.name="我是原型中的名字";
var mc=new MyClass();
mc.age=18;
//console.1og(mc.name); 我是原型中的名字
-----使用in检查对象中是否含有某个属性时,如果对象中没有但是原型中有,也会返回true
//console.log("name"in mc); ture
-----可以使用对象的hasOwnProperty()来检查对象自身中是否含有该属性
-----使用该方法只有当对象自身中含有属性时,才会返回true
//console.1og(mc.hasOwnProperty("name")); false
//console.1og(mc.hasOwnProperty("age")); true
----原型对象也是对象,所以它也有原型
----当我们使用一个对象的属性或方法时,会现在自身中寻找,
-------自身中如果有,则直接使用,
-------如果没有则去原型对象中寻找,如果原型对象中有,则使用,
-------如果没有则去原型的原型中寻找,直到找到Object对象的原型,
-------Object对象的原型没有原型,如果在Object中依然没有找到,则返回undefined
//console.1og(mc. hasownProperty("hasownProperty")); false
//console. log(mc.__proto__.hasownProperty("hasownProperty")); false
//console. log(mc.__proto__.__proto__.hasownProperty("hasownProperty")); true
//console. log(mc.__proto__.__proto__.__proto__) null
5.2 初见垃圾回收
obj = null