JavaScript个人学习记录（四）

函数练习

求两个数的差

function getSub(x,y) {
	return x-y;
}
console.log(getSub(10,20));

求一组数字中的最大值

function getArrayMax(array){
	var max = array[0];
	for(var i = 0; i < array.length; i++) {
	if(max < array[i]) {
		max = array[i];
	}
	}
	return max;
}
var arr = [10,20,30,40];
var max = getArrayMax(arr);
console.log(max);

求一组数组的最小值

function getArrayMin(array) {
	var min = array[0];
	for(var i = 0; i<array.length; i++) {
		if(min > array[i]) {
			min = array[i];
		}
	}
	return min;
}
//测试
console.log(getArrayMin(10,20,30,40));

求一组数字的和

function getArraySum(array){
	var sum = 0;
	for(var i = 0; i < array.length; i++){
		sum += array[i];
	}
	return sum;
}
console.log(getArraySum([10,2,4,5,6,2]));

求一个数组中的最大值和最小值还有和

/*
给我一个数组，我返回一个数组（最大值，最小值，和）
@param array参数是一个数组
@returns {*[]}返回值是一个数组，第一个元素值是最大值，第二个元素值是最小值第三个元素值是和
*/

function getArrayMaxAndMinAndSum(array){
	var max = array[0];
	var min = array[0];
	var sum = 0;
	for (var i = 0; i < array.length; i++) {
	//最大值
		if(max < array[i]){
			max = array[i];
		}//end if
	//最小值
		if(min > array[i]) {
			min = array[i];
		}//end if
		sum += array[i];
	}//end for
	var arr = [max,min,sum];
	return arr;
}
//测试
var resultArray = getArrayMaxAndMinAndSum([10,20,30,4,3]);
console.log("最大值：" + resultArray[0]);
console.log("最小值：" + resultArray[1]);
console.log("和：" + resultArray[2]);

通过函数实现数组反转

function reverseArray(array) {

	for(var i = 0; i < array.length/2; i++) {
		var temp = array[i];
		array[i] = array[array.length-1-i];
		array[array.length-1-i] = temp;
	}
	return array;
}

通过函数实现冒泡排序

function sortArray(arr) {
	//控制比较轮数
	for(var i = 0; i < arr.length-1; i++){
	//控制每行比较次数
		for(var j = 0; j<arr.length-1-i; j++) { //注意  j < arr.length-1-i
			if(arr[j] > arr[j+1]) {
				var temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}//end if
		}//end for
	}//end for
	return arr;
}
console.log(sortArray([12,3,54,32,33]));

求一个数字的阶乘

function getJieCheng(num) {
	var result = 1;
	for(var i = 1; i <= num; i++){ //注意 i = 1
		result *= i;
	}
	return result;
}
console.log(getJieCheng(5));

求斐波那契数列 12–144
1，1，2，3，5，8，13，21，34，55，89，144

function getFib(num){
	var num1 = 1;
	var num2 = 1;
	var sum = 0;
	for(var i = 3; i<=num; i++) { //注意 i=3
		sum = num1 + num2;
		num1 = num2;
		num2 = sum;
	}
	return sum;
}

输入，年月日，获取这个日期是这一年的第多少天

//判断这个年份是不是闰年
function isLeapYear(year){
	return year%4==0&&year%100!=0||year%400==0;
}
//年---月---日：202年7月27日
function getDays(year,month,day){
	//定义变量存储对应的天数
	var days = day;
	//如果用户输入的是一月份，没必要向后算天数，直接返回天数
	if(month == 1) {
		return days;
	}
	//代码执行到这里---说明用户输入的不是1月份
	//用户输入的是7月份27日---1，2，3   +27
	//定义一个数组，存储每月的天数
	var months = [31,28,31,30,31,30,31,31,30,31,30,31];
	for(var i = 0; i<month-1, i++) {
		days += months[i];
	}
	//需要判断这个年份是不是闰年,是则+1
	if(isLeapYear(year)&&month>2){
	days++;
	}
	return days;
}
console.log(getDays(2020,7,27));

求一个数字的阶乘和

//求一个数的阶乘
function getJieCheng(num){
	var result = 1;
	for(var i = 0; i <= num; i++) {
		result *= i;
	}
	return result;
}
//求一个数的阶乘和
function getJieChengSum(num) {
	var sum = 0;
	for(var i = 0; i<=num; i++){
		sum += getJieCheng(i);
	}
	return sum;
}
console.log(getJieChengSum(5));

argument对象

计算n个数的和

function f1() {
//argument---->数组使用--->伪数组
	var sum = 0;
	for(var i = 0; i<argument.length; i++){
		sum += argument[i];
	}
	return sum;
}
console.log(f1(10,20,30,40));

函数的其他定义方式

命名函数：函数如果有名字，就是命名函数
匿名函数：函数如果没有名字，就是匿名函数

函数的另一种定义方式：
函数定义：

1. 函数声明-函数定义

function 函数名() {
	函数体;
}

2. 函数表达式
   把一个函数给一个变量，此时形成了函数表达式
   注意：函数表达式后面，赋值结束后，要加分号

var 变量 = 匿名函数;
//例子:
var f1 = function(){

};
f1();

如果是函数表达式，那么此时前面的变量中存储的就是一个函数，而这个变量就相当于是一个函数，就可以直接加小括号调用

//函数表达式
var f2 = function(){
	console.log("123");
};
f2(); //123
f2 = function(){
	console.log("1234");
};
f2();//1234

3. 函数的自调用，没有名字，调用—声明的同时，直接调用
   一次性的

(function(){console.log("哈哈哈");})();

• 函数也是一种数据类型
  如何获取某个变量的类型？ typeof

function f1() {
	console.log("我是函数");
}
console.log(typeof f1);
//函数是有数据类型，数据类型：是function类型的

函数作为参数使用

函数可以作为参数使用，如果一个函数作为参数，那么我们说这个参数（函数）可以叫回调函数
只要看到一个函数作为参数使用了，那就是回调函数

//函数声明，fn是变量，fn是参数
function f1(fn){
fn();
}
function f2(){
console.log("12345");
}
f1(f2);

function sayHi(fn){
	console.log("你好");
	fn(); //fn此时是一个函数
}
function suSay(){
	console.log("hello");
}
sayHi(suSay);

函数作为返回值使用

函数可以作为返回值使用

function f1(){
	console.log("f1函数调用了");
	return function(){
		console.log("这是一个函数");
	}
}
var ff = f1();//调用
//ff就是一个函数了
ff();

作用域

作用域：使用范围

全局变量：声明的变量是使用var声明的，那么这个变量就是全局变量，全局变量可以在页面的任何位置使用
除了函数以外，其他的任何位置定义的变量都是全局变量
局部变量：在函数内部定义的变量，是局部变量，外面不能使用
全局变量，如果页面不关闭，那么就不会释放，就会占空间，消耗内存

全局作用域：全局变量的使用范围
局部作用域：局部变量的使用范围

块级作用域：一对大括号就可以看成是一块，在这块区域中定义的变量，只能在这个区域中使用，但是在js中在这个块级作用域中定义的变量，外面也能使用
说明：js没有块级作用域，只有函数除外
隐式全局变量：声明的变量没有var ，就叫隐式全局变量

function f1(){
	number = 1000; //是隐式全局变量
}
f1();
console.log(number); //1000

全局变量是不能被删除的，隐式全局变量是可以被删除的
定义变量使用var不可以被删除，没有var可以删除

var num1 = 10;
num2 = 20;
delete num1;
delete num2;
console.log(typeof num1);//number
console.log(typeof num2);//undefined
console.log(num1+10);//20

作用域链

在当作用域里找，找不到去上一级

预解析

预解析：提前解析代码

预解析：就是在解析代码之前
预解析做什么事？
把变量的声明提前了----提前到当前所在的作用域的最上面
函数的声明也会被提前----提前到当前所在的作用域的最上面

把变量的声明提前了

console.log(num); //没有报错,为undefined
var num = 10;
//预解析
var num;
console.log(num);//undefined
num = 10;

函数的声明也会被提前

f1(); //没有报错，正常调用
function f1(){
console.log("这是一个函数");
}
//预解析 函数声明提前

• 练习

//1---
var a = 25;
function abc(){
	alert(a);//undefined
	var a = 10;
}
abc();

//2---
console.log(a); //不是undefined，也不是报错，是函数代码
function a() {
console.log('aaaa');
}
var a = 1;
console.log(a); //1
//预解析
var a;
function a(){
console.log('aaaa');
}
console.log(a); //a 函数的代码
a = 1;
console.log(a);//1

//3---
var a = 18;
f1();
function f1(){
var b = 9;
console.log(a); //undefined
console.log(b);//9
var a = '123';
}
//预解析
var a;
a = 18;
function f1(){
var b;
var a;
b = 9;
console.log(a);//undefined
console.log(b);//9
a = '123';
}
f1();

//4---
f1();
console.log(c); //9
console.log(b); //9
console.log(a); //报错
function f1(){
	var a = b = c = 9;
	console.log(a); //9
	console.log(b); //9
	console.log(c); //9
}
//预解析
function f1(){
var a;
a = 9;
//隐式全局变量
b = 9;
c = 9;
}

//5---
f1();//报错，不能调用,f1是变量
var f1 = function () {
	console.log(a);
	var a = 10;
};
//预解析
var f1;
f1();
f1 = function () {
	....
}