JS基础笔记(二)7.函数以及作用域_js 为什么instanceof判断对象都是true-CSDN博客

本文链接：https://blog.csdn.net/weixin_44488397/article/details/104231912

函数的简介

函数function

函数是一个对象
函数中可以封装一些功能(代码),在需要的时可以执行这些功能(代码)
函数中可以保存一些代码在需要的时候调用
使用typeof检查一下对象时，会返回function

// 我们在实际开发中很少使用构造函数来创建一个函数对象
// 创建一个函数对象
// 可以将要封装的代码以字符串的形式传递给构造函数
 var fun = new Function("console.log('Hello');");
 console.log(typeof fun);
//封装的代码不会立即执行
//函数中的代码会在函数调用的时候执行
//调用函数语法:函数对象()
//当调用函数时，函数中封装的代码会按照顺序执行
 fun();

使用函数声明来创建一个函数
语法:
function 函数名([形参1,形参2,…,形参N]){
语句…
}
()里加上[]代表形参可传可不传

function fun2(){
			console.log("函数");
		}
fun2();
console.log(fun2);

使用函数表达式来创建一个函数

语法：var 函数名 = function([形参1,形参2,....,形参N]){
		语句...
	 }
var fun3 = function(){
    console.log("匿名函数赋值变量函数");
};
fun3();

函数的参数

1.函数的参数是：
定义一个用来求两个数和的函数，
可以在函数的()中来指定一个或多个形参(形式参数)，
多个形参之间使用逗号隔开，声明形参就相当于在函数内部声明了对应的变量，但是并不赋值。

function sum(a,b){
		console.log(a+b);
}

在调用函数时，可以在()中指定实参(实际参数)，实参将会赋值给函数中对应的形参。

sum(1,2);

调用函数时解析器不会检查实参的类型，所以要注意,是否有可能会接收到非法的参数，如果有可能则需要对参数进行类型的检查，函数的实参可以是任意的数据类型。

// sum(123,"hello");
sum(true,false);

调用函数时，解析器也不会检查实参的数量，多余实参不会被赋值，
如果实参的数量少于形参的数量，则没有对应实参的形参将是undefined。

函数的返回值

创建一个函数，用来计算三个数的和
可以使用return来设置函数的返回值
语法：
return 值;
return后的值将会会作为函数的执行结果返回，
可以定义一个变量来接收结果
在函数中return后的语句都不会被执行
如果return语句后不跟任何值就相当于返回一个undefined
如果函数不写return，则也会返回undefined
return后可以跟任意类型的值。

function sum(a, b, c){
			var d = a+b+c;
			// console.log(d);
			return d;
}

调用函数
变量result的值就是函数的执行结果
函数返回什么result的值就是什么

var result = sum(1,2,3);
console.log(result);

实参可以是任何值

实参可以是任意的数据类型，也可以是一个对象，当我们的参数过多时，可以将参数封装到一个对象中，然后通过对象传递。

function sayHello(o){
	console.log(o);
}
var obj = {
	name:"s",
	age:18,
	gender:"n",
	address:"tt"
};
sayHello(obj);
/* 
实参也可以是函数
*/
function fun(a){
	console.log("a="+a);
}
fun(sayHello);

sayHello();
-调用函数
-相当使用函数的返回值
sayHello
-函数对象
-相当于使用函数对象

返回值的类型

返回值可以是任意数据类型
也可以是一个对象，也可以是一个函数

function fun(){
			alert("函数要执行~~~");
			for (var i=0; i<5;i++) {
				console.log(i);
				if (i == 2) {
					//使用return结束整个函数
					return;
				}		
			}
		alert("函数执行完了~~~");

}
fun();

立即执行函数

立即执行函数
函数定义完，立即被调用，这种函数被称为立即执行函数
立即执行函数往往只会执行一次

(function(){
	console.log("一个匿名函数");
})();
		
(function(a,b){
	console.log(a+b);
})(10,20);

枚举对象中的属性

	var obj = {
			name:"大圣",
			age:18,
			gender:"男",
			address:"花果山"
		};
		// 枚举对象中的属性
		/* 
			使用for...in 语句
				语法：
					for(var 变量 in 对象){
						
					}
			for..in语句 对象中有几个属性，循环体就会执行几次
			 每次执行时，会将对象中的一个属性的名字赋值给变量
		 */
		for (var n in obj) {
			console.log("属性名"+n);
			console.log("属性值"+obj[n]);
		}

全局作用域

作用域：

作用域指一个变量的作用范围
在JS中一共有俩种作用域
1.全局作用域
直接编写在script标签中的代码,都在全局作用域。
全局作用域在页面打开时创建，在页面关闭时销毁。
在全局作用域中有一个全局对象window，它代表浏览器的一个窗口，它由浏览器创建我们可以直接使用。
在全局作用域中，创建的变量都会作为window对象的属性保存，创建的函数都会作为window对象的方法保存。
全局作用域中的变量都是全局变量，在页面任意的部分都可以访问的到。

2.变量的声明提前

使用var关键字声明的变量，会在所有代码执行前被声明(但是不会赋值)
但是如果声明变量时不适用var关键字，则变量不会被声明提前

3.函数的声明提前

使用函数声明形式创建的函数function 函数(){}
它会在所有代码执行之前就被创建，所以我们可以在函数声明前来调用函数
使用函数表达式创建的函数，不会被声明提前，所以不能在声明前调用

	console.log(a);
	//提前声明变量
	var a = 123;
	fun();
	// fun2();
	
	function fun(){
		console.log("我是一个fun函数");
	};
	//提前声明函数
	var fun2 = function(){
		console.log("我是fun2函数")
	};

在函数作用域也有声明提前的特性，使用var关键字声明的变量，会在函数中所有的代码执行之前被声明，在函数中，不使用var声明的变量都会成为全局变量，定义形参就相当于在函数作用域中声明了变量。

构造函数

构造函数就是一个普通的函数，创建方式和普通函数没有区别，
不同的是构造函数习惯上首字母大写，
构造函数和普通函数的区别就是调用方式不同，
通函数就是直接调用，而构造函数需要使用new关键字来调用。
构造函数的执行流程
1.立刻创建一个新的对象
2.将新建的对象设置为函数中的this
3.逐行执行函数中的代码
4.将新建的对象作为返回值返回
使用同一个构造函数创建的对象，我们称为一类对象
我们将通过一个构造函数创建的对象，称为是该类的实例
this的实例
1.当以构造函数的形式调用时，this就是window
2.当以方法形式调用时，谁调用this就是谁
3.当以构造函数调用时，this就是新创建的那个对象

function Person(name,age){
		this.name = name;
		this.age = age;
		this.sayName = function(){
		console.log(this.name);
	};
}
// 普通函数调用
var per = Person();
console.log(per);
// 构造函数调用
var per2 = new Person();
console.log(per2);
var p = new Person("jia",12);
console.log(p);

使用instanceof可以检查一个对象是否是一个类的实例
语法：
对象 instanceof 构造函数
如果是返回true 不是返回false

console.log(p instanceof Person);

所有对象都是Object的后代，
所以任何对象和Object在instanceof检查时都会返回true。

练习例子：
创建一个Person构造函数

在Person构造函数中，为每一个对象都添加一个sayName方法,
目前我们的方法就是在构造函数内部创建的，
也就是构造函数每执行一次就会创建一个新的sayName方法
也就是所有实例的sayName都是唯一的。
这样就会导致构造函数执行一次就会创建一个新的方法，
执行10000次就会创建10000个新的方法，而10000个方法都是一模一样的，
这完全没有必要，完全可以使所有都对象共享同一个方法。

function Person(name,age){
			this.name = name;
			this.age = age;
			//向对象中添加一个方法
			this.sayName = fun;
		}
		//将sayName方法定义在全局作用域中定义
		/* 
			将函数定义在全局作用域，污染了全局作用域的命名空间
			 而且定义在全局作用域中也很不安全
		 */
		function fun(){
			console.log(this.name);
		}
		var p1 = new Person("jia",13);
		p1.sayName();