JS 对象和函数

目录

一、对象

创建对象的四种方式

构造函数原型对象prototype和对象原型__proto__

二、函数

创建函数的3种方式

一、对象

创建对象的四种方式

第一种方式：字面量

var o1 = {name:"o1"}
var o2 = new Object({name:"o2"})

第二种方式：通过构造函数

//每个函数都会有一个prototype
var M = function(name){this.name=name};
//原型对象的constructor就等于函数
var o3 = new M("o3");


//其他（关于构造函数的静态成员和实例成员）
1.实例成员就是构造函数内部用this添加的成员，上面的name就是实例成员
2.静态成员就是在构造函数本身上添加的成员

M.age = 18;
console.log(M.age);//18,只能通过构造函数来访问静态成员
consloe.log(o3.age);//undefined,不可通过对象来访问静态成员

   第三种方式：Object.create           

var a = {name:"a"}
var o4 = Object.create(a);

   第四种:通过Class创建对象（ES6） 

class A {
	constructor(name) {
		this.name = name
	}
	say(){
		console.log("我是父类"+this.name);
	}
}

const a = new A("A")

构造函数原型对象prototype和对象原型__proto__

构造函数通过原型分配的函数是所有对象所共享的。
JavaScript规定，每一个函数都有一个prototype属性，指向另一个对象。 注意这个prototype就是一个对象，这个对象的所有属性和方法，都会被构造函数所拥有。
我们可以把那些不变的方法，直接定义在prototype对象上，这样所有对象的实例就可以共享这些方法。

 简单点说prototype的作用就是共享方法。

function func() {
}
func.prototype.sing = function() {
	console.log("我会唱歌");
}
var f1 = new func();
var f2 = new func();
f1.sing();//我会唱歌
f2.sing();//我会唱歌

//函数的原型对象里的构造函数就是它本身
console.log(func.prototype.constructor === func);//true

对象都会有一个属性__proto__指向构造函数的 prototype原型对象。

之所以我们对象可以使用构造函数
prototype原型对象的属性和方法。就是因为对象有__proto__原型的存在。
__proto__对象原型和原型对象prototype是等价的。

对象的对象原型就等于函数的原型对象
console.log(f1.__proto__ === func.prototype)//true;

除此之外，函数其实也是对象，所以也有对象原型__proto__,它的对象原型就指向Function的原型对象

console.log(func.__proto__ === Function.prototype);//true

二、函数（函数也是对象）

创建函数的3种方式

//1.命名函数
function func(){}

//2.匿名函数
var a = function(){}

//3.new Function('参数1','参数2','函数体')
//注意：Function中的参数都是字符串
var b = new Function('a','b','console.log(a+b);')
b(1,2)//3

函数的调用方式 

// 1.普通函数
function a(){}
a();
// 2.对象的方法
var o = {a:function(){}}
o.a()
//3.构造函数
function Star(){}
new Star();
// 4.绑定事件函数
btn.onclick = function(){}
// 5.定时器函数
setInterval(function(){},1000)
// 6.立即执行函数
(function b(){})()

 函数中的this指向问题

		// 1.普通函数
		//对于普通函数而言,this指向的是windows对象
		function a() {
			console.log("普通函数" + this);
		}
		a();
		this.a();
		window.a()
		// 2.对象的方法(this指向的是o)
		var o = {
			a: function() {
				console.log("对象方法的this" + this);
			}
		}
		o.a()
		//3.构造函数(构造函数this指向star这个实例对象，原型对象里面的this，指向的也是star)
		function Star(name) {this.name = name}
		Star.prototype.sing = function() {
			console.log("构造函数中的原型的this" + this.name);
		}
		var star = new Star("star");
		star.sing()
		// 4.绑定事件函数(this指向函数的调用者btn)
		btn.onclick = function() {}
		// 5.定时器函数(指向window)
		setInterval(function() {}, 1000)
		// 6.立即执行函数(指向window)
		(function b() {})()

 闭包函数

闭包(closure) 指有权访问另一个函数作用域中变量的函数。
闭包:我们fun这个函数作用域访问了另外一个函数fn里面的局部变量num
 

//这里foo函数访问另一个函数作用域的变量（也就是fn的局部变量num），所以fn就是一个闭包函数
function fn(){
	var num = 10;
	function foo(){
		console.log(num);
	}
	return foo;
}
var f = fn();
f();//10


//上面的函数等同于
function fn() {
	var num = 10;
    return function foo() {
		console.log(num);
	}
}
var f = fn();
f(); //10