-
JavaScript学习笔记——JS基础6
61this
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
/*
解析器在调用函数每次都会向函数内部传递一个隐含的参数
这个隐含的参数就是this,this指向的是一个对象
这个对象我们称为函数执行的上下文对象
根据我们的函数调用方式不同，this会执行不同的对象
1.以函数的形式调用时，this永远是window
2.以方法的形式调用时，this就是调用方法那个对象
*/
// name="sss";
function fun(){
console.log(this.name);
//alert("美好");
}
fun();
var name="全局的name属性";
name="sss";
//fun(1,2);
/* var obj={
name:"xm",
sayname:fun
};
var obj2={
name:"ssxm",
sayname:fun
}; */
//console.log(obj.sayname==fun)
// obj.sayname();
//obj.sayname();、
//以函数形式调用，this永远是window
// var name="全局的name属性";
// fun();//全局的name属性
//以方法的形式调用时，this就是调用方法那个对象
/* obj.sayname();//xm
obj2.sayname();//ssxm */
</script>
</head>
<body>
</body>
</html>62this补充
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
/*
创建一个name变量
*/
var name="全局";
//创建一个fun（）函数
function fun(){
console.log(this.name);
}
//创建俩个对象
var obj={
name:"a",
sayname:fun
}
var obj2={
name:"b",
sayname:fun
}
//我们希望调用obj.sayname();时可以输出obj的名字
obj.sayname();
obj2.sayname();
//fun();
</script>
</head>
<body>
</body>
</html>63使用工厂方法创建对象
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
// 创建一个对象
var obj={
name:"小明",
age:18,
gender:"男",
sayname:function(){
alert(this.name);
}
}
//console.log(obj.sayname);
// 使用工厂方法创建对象
/*
通过该方法可以大批量的创建对象
*/
function creatperson(name,age){
var obj=new Object();
obj.name=name;
obj.age=age;
//将新的对象返回
return obj;
}
var obj2=creatperson("ss",23);
var obj3=creatperson("fd",12);
console.log(obj2);
console.log(obj3);
</script>
</head>
<body>
</body>
</html>64构造函数
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
// function crateDog(name,age){
/*
使用工厂方法创建的对象，使用的构造函数都是object
所有创建的对象都是object这个类型
就导致我们无法区分出多种不同类型的对象
*/
// var obj=new Object();
// obj.name=window.name;
// obj.age=age;
// obj.sayhello=function(){
// alert("问问");
// };
// return obj;
// }
// var obj=crateDog("sss",12);
// console.log(obj);
/*
创建一个构造函数，专门用来创建person对象的
构造函数就是一个普通的函数，创建方式和普通函数没有区别，
不同的是构造函数习惯上首字母大写
构造函数和普通函数的区别就是调用的方式的不同
普通函数是直接调用，而构造函数需要使用new关键字来调用
构造函数的执行流程：
1。立刻创建一个新的对象
2.将新建的对象设置为函数中的this,在构造函数中可以使用this来引用新建的对象
3.逐行执行函数中的代码
4.将新建的对象作为返回值返回
使用同一个构造函数创建的对象，我们称为一类对象，也将一个构造函数称为一个类
我们将通过一个构造函数创建的对象，称为是该类的实例
*/
function Person(name){
// alert(this);//就是per
this.name="hello";
this.sayhello=function(){
alert(this.name);
}
}
function Dog(){
}
// var per=new Person();这是一个普通的函数
var per=new Person("sss");
var per2=new Person();
// console.log(per);
// console.log(per2.sayhello())
var obj2=new Dog();
/* 使用instanceof可以检查一个对象是否是一个类的实例
语法
对象 instanceof 构造函数
如果是就返回true，否则就是false
所有对象都是object的后代
所以任何对象和object在instanceof检查中都会返回true
this的情况
1.当以函数的形式调用，this就是Windows
2.当以方法的形式调用时，谁调用方法this就是谁
当以构造函数的形式调用时，this就是新创建的那个对象
*/
console.log(per instanceof Person);
console.log(per instanceof Object);
</script>
</head>
<body>
</body>
</html>65构造函数修改
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
/*
在person构造函数中，为每一个对象都添加一个sayhello方法
目前我们的方法是在构造函数内部创建的，也就是构造函数没执行一次就会创建一次新的sayhello方法
也是所有实例的sayname都是唯一的
这样就导致构造函数执行一次就会创建一个新的方法
执行1000次就会创建10000个新的方法，而1000个新的方法都是一模一样
这是完全没有必要的，完全可以使所有的对象共享同一个方法
*/
function Person(name,age){
this.name=name;
this.age=age;
// this.sayname=fun;
}
//将sayname方法在全局作用域中定义
/*
将函数定义在全局作用域，污染了全局作用域的命名空间
而且定义在全局作用域中也不是很安全
*/
// function fun(){
// alert("hello"+this.name)
// };
//向原型中添加sayname方法
Person.prototype.sayname=function(){
alert("我是"+this.name);
}
var a=new Person("小明",19);
var b=new Person("小是",23);
a.sayname();
b.sayname();
console.log(a.sayname==b.sayname);
</script>
</head>
<body>
</body>
</html>66原型对象
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
/*
原型prototype
我们所创建的每一个函数，解析器都会向函数中添加一个属性prototype
这个属性对应着一个对象，这个对象就是我们所谓的原型对象
如果函数作为普通函数调用prototype没有任何作用
当函数以构造函数的形式调用时，他所调用的对象中都会有一个隐含的属性
指向该构造函数的原型对象，我们可以通过__proto__来访问该属性
原型对象就相当于一个公共的区域，所有同一个类的实例都可以访问到这个原型对象
我们可以将对象中公共的内容，统一设置到原型对象中
当我们访问对象的一个属性或方法时，它会先在对象自身中寻找，如果有则直接使用
如果没有则会在原型对象中寻找，如果找到就则直接使用
以后我们创建构造函数时，可以将这些对象共有的属性和方法，统一添加到构造函数的原型对象中
这样不用分别为每一个对象添加，也不会影响到全局作用域，就可以使每个对象都具备这些属性和方法了
*/
// function Person(){
// }
function Myclass(){
}
//向Myclass的原型中添加属性a
Myclass.prototype.a=123;
//向Myclass的原型中添加一个方法
Myclass.prototype.sayhello=function(){
alert("hello");
}
var mc=new Myclass();
var mc2=new Myclass();
// console.log(Myclass.prototype);
// console.log(Person.prototype)
// console.log(mc2.__proto__==Myclass.prototype);
//向mc中添加a属性
mc.a="我是mc中的a"
console.log(mc.a)
// mc.sayhello=function(){
// alert("ssss");
// }
mc.sayhello();
</script>
</head>
<body>
</body>
</html>67原型对象
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
//创建一个构造函数
function Myclass(){
}
// 向Myclass的原型中添加一个name属性
Myclass.prototype.name="我是原型中的名字";
var mc=new Myclass();
mc.age=18;
//console.log(mc.name);
//使用in检查对象中是否含有某个属性时，如果对象中没有但是原型中有，也会返回true
//console.log("name" in mc);//返回true
// 可以使用对象的hasOwnProperty()来检查对象自身中是否含有该属性
// 使用该方法只有当对象自身含有属性时，才会返回true
// console.log(mc.hasOwnProperty("name"));
// console.log(mc.hasOwnProperty("age"));
// console.log(mc.hasOwnProperty("hasOwnProperty"));//false
// console.log(mc.__proto__.hasOwnProperty("hasOwnProperty"));//false
/*
原型对象也是对象，所以它也有原型
当我们使用一个对象的属性或方法时，会先在自身中寻找，
自身中如果有，则直接使用，
如果没有则去原型对象中寻找，如果原型对象中有，则使用
如果没有则去原型的原型中寻找,直到找到object对象的原型
object对象的原型没有原型，如果在object中依然没有找到，就返回undefined
*/
console.log(mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty"))
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
function Person(name,age){
this.name=name;
this.age=age;
}
// 修改原型的tostring
Person.prototype.toString=function(){
return this.name+this.age;
}
var per=new Person("搜索",19);
// 当我们直接在页面打印一个对象时，事件上是输出的对象的tostring()方法的返回值
// 如果我们希望在输出对象时不输出[object Object]，可以为对象添加一个tostring方法
var result=per.toString();
console.log(result);
</script>
</head>
<body>
</body>
</html>
69垃圾回收<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
// 垃圾回收（GC）
// 就像人生活的时间长了一样会产生垃圾，程序运行的过程也会产生垃圾
// 这些垃圾记载过多，会导致程序速度过慢
// 所以我们需要一个垃圾回收的机制，来处理程序运行过程中产生垃圾
// 当一个对象没有任何的变量或属性对它进行引用，此时我们将·永远无法操作对象，
// 此时这种对象就是一个垃圾，这种对象过多会占用我们大量的空间，使我们的程序变慢
// 在JS中有自动的垃圾回收机制，会自动将这些垃圾对象从内存中销毁
// 我们只需啊要将这些不需要的设置为null
var obj=new Object;
obj=null;
</script>
</head>
<body>
</body>
</html> -
相关阅读:
笔记1.5：计算机网络体系结构
【CSS布局】实现中间自适应，左右宽度固定的三栏布局
【软考】6.1 信息安全及技术
CMD使用不完全指南
Java项目：ssm课程在线学习与测试系统
金仓数据库KingbaseES物理备份恢复最佳实践（概述）
Webpack和Vite
每日一结(11.8)
什么蓝牙耳机好用？音质好佩戴舒适蓝牙耳机推荐
网络安全（黑客技术）—小白自学
- 原文地址：https://blog.csdn.net/weixin_64612659/article/details/125051666