JavaScript05

函数
变量的作用域
函数的作用域
递归

1.函数

Number()/parseInt()/parseFloat()/alert()/prompt()…

函数分为系统函数和自定义函数
函数：是一个功能体，需要提供若干个数据，返回处理的结果；用于封装重复执行的代码

(1)创建普通函数

function 函数名称(){ 函数体 —— 要封装的重复执行的代码}
调用函数
函数名称() //执行函数体中封装的代码

/*
console.log('卖煎饼了，又香又脆的煎饼');
console.log('所有煎饼一律8折');
*/
//创建函数
function laba(){
  console.log('卖煎饼了，又香又脆的煎饼');
  console.log('所有煎饼一律12折');
}
//调用
//laba();
//laba();
//laba();
//练习：创建函数getSum，在函数体中封装计算1~100之间所有整数的和并打印结果；调用多次
function getSum(){
  //求和
  for(var i = 1,sum = 0;i <= 100;i++){
    sum += i;
  }
  console.log(sum);
}
getSum();
getSum();
getSum();

(2)创建带有参数的函数

function 函数名称(参数列表){ 函数体}
调用
函数名称(参数列表)
创建函数时的参数称作形参，调用函数时的参数称作实参，实参会赋值给形参，实参数量可以和形参的数量不匹配，如果形参未被赋值则为undefined。

//计算任意两个数字相加的和
function add(n1,n2){//形参，用于接收传递的数据
  //console.log(n1 + n2);
  console.log(n1,n2);
}
/*
add(2,3);//实参，传递的数据
add(1,6);
add(3,7);
add(5);
add();
add(1,2,3);
*/
//练习：创建函数getSum，计算1~任意数字之间所有整数的和，调用多次
function getSum(n){
  //计算1~n之间所有整数的和
  for(var i = 1,sum = 0;i <= n;i++){
    //i代表所有的整数
	sum += i;
  }
  console.log(sum);
}
//getSum(100);
//getSum(50);

//练习：创建函数getRun，传递任意两个年份，统计出两个年份之间所有闰年的个数，调用多次
function getRun(n1,n2){
  //循环产生n1~n2之间所有的年份
  for(var i = n1,count = 0;i <= n2;i++){
    //i代表所有年份
	//判断是否为闰年
	if(i % 4 ===0 && i % 100 !== 0 || i % 400 === 0){
	  count++;
	}
  }
  console.log(count);
}
getRun(2000,2100);
getRun(1949,2021);

(3)创建带有返回值的函数

function 函数名称(参数列表){ 函数体 return 值; //返回值，返回函数调用后的结果}
调用
函数名称(参数列表)

return用于返回函数调用后的结果，如果函数中没有return或者return后不加任何值则返回undefined，一旦return执行就会跳出函数，结束函数的执行。

function add(a,b){
  //函数体
  console.log(a + b);
  //return '大腰子';
  return a + b; //返回函数调用后得到的结果
  //return; //跳出函数
  console.log('执行完毕');
}
//保存函数调用后的结果
//var res = add(81,73);
//console.log('两个数字相加的结果：'+res);

//练习：创建函数getMax，传递任意两个数字返回最大值
function getMax(a,b){
  /*
  if(a > b){
    return a;
  }else{
    return b;
  }
  */
  return a > b ? a : b;

}
//var res = getMax(3,5);
//console.log(res);

//练习：创建函数getMax2，传递任意三个数字返回最大值
function getMax2(a,b,c){
  /*
  if(a > b && a > c){
    return a;
  }else if(b > c){
    return b;
  }else{
    return c;
  }
  */
  var max = a > b ? a : b;
  return max > c ? max : c;
}
//var res = getMax2(3,7,9);
//console.log(res);

//练习：创建函数getStatus，根据订单的状态码返回对应的汉字状态
function getStatus(n){
  switch(n){
    case 1:
	  return '等待付款';
	  //break;
	case 2:
	  return '等待发货';
	  //break;
	case 3:
	  return '运输中';
	  //break;
	case 4:
	  return '已签收';
	  //break;
	case 5:
	  return '已取消';
	  //break;
	default:
	  return '无法追踪';
  }
} 
//var res = getStatus(3);
//console.log(res);

//练习：创建函数isPrime，传递任意一个数字，检测是否为素数，返回布尔型的值。
function isPrime(n){
  //排除1
  if(n <= 1){
    return false;
  }
  //检测是否为素数
  //1~n之间是否含有能被整除的数字
  for(var i = 2;i < n;i++){
    //i代表之间所有的事数字
	//如果有能被整除的数字说明不是素数
	if(n % i === 0){
	  return false;
	}
  }
  //如果循环结束后，说明中间没有能被整数的数字
  return true;
}
/*
//var res = isPrime(1);
//console.log(res);
//循环打印1~100之间所有的素数
//产生1~100之间所有的整数
for(var i = 1;i <= 100;i++){
  //console.log(i);
  //查看之间所有的整数是否为素数，只需要把这些整数作为实参传递给isPrime
  var res = isPrime(i);
  //console.log(res);
  //判断结果res是否为true
  //如果是，打印对应的数字i
  if(res){
    console.log(i);
  }
}
*/
//练习：创建函数isRun，传递任意一个年份，检测是否为闰年，返回布尔型的值
function isRun(year){
  //判断year是否为闰年
  /*
  if(year % 4 === 0 && year % 100 !== 0 || year % 400 === 0){
    return true;
  }
  return false;
  */
  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
}
var res = isRun(2020);
console.log(res);

练习：创建函数getMax，传递任意两个数字返回最大值

练习：创建函数getMax2，传递任意三个数字返回最大值

练习：创建函数getStatus，根据订单的状态码返回对应的汉字状态

1-等待付款 2-等待发货 3-运输中 4-已签收 5-已取消 其它-无法追踪

练习：创建函数isPrime，传递任意一个数字，检测是否为素数，返回布尔型的值。

练习：创建函数isRun，传递人一个年份，检测是否为闰年，返回布尔型的值

使用switch-case判断

对比break和return
break用于循环和switch-case语句中，跳出所在的这组语句return用于函数中，跳出函数，结束函数的调用

2.变量的作用域

全局作用域 ： 在函数以外就是全局作用域
函数作用域 ： 在函数以内就是函数作用域
全局变量：在全局作用域下声明的变量，可以在任意的作用域下访问到
局部变量：在函数作用域下声明的变量，只能在当前的作用域下访问到
在函数内不加var声明的变量是全局变量，不推荐，后期再严格模式下会报错。
在程序执行前，会将var声明的变量提升到所在作用域的最前边，只是提升声明，不提升赋值

/*
//全局作用域
//全局变量
var a = '北京城管';
function shi(){
  //函数作用域
  //局部变量
  var b = '石景山城管';
  //访问全局变量
  console.log(a);
}
shi();
//console.log(b);//报错，全局下无法访问局部变量

function hai(){
  //函数作用域
  //局部变量
  var c = '海淀城管';
}


var n1 = 8;//标准的声明全局变量
function fn(){
  //函数内不加var声明的变量是全局变量
  n = 5;
  //给全局变量n1重新赋值
  n1 = 10;
}
fn();
console.log(n);
console.log(n1);
*/

//练习：查看以下程序的输入结果
function fun(){
  var m1 = m2 = m3 = 6;
  //m3 = 6
  //m2 = m3
  //var m1 = m2
}
fun();
console.log(m3); //6
console.log(m2); //6
console.log(m1); //报错

//在程序执行前，会将var声明的变量提升到所在作用域的最前边，只是提升声明，不提升赋值
/*
//var a
console.log(a);//undefined
//a=1
var a = 1;
console.log(a);//1

function fn(){
  //var b //提升
  console.log(b);//undefined
  var b = 2;
  console.log(b);//2
}
fn();


var c = 3;
function fun(){
  //var c;//提升后c值为undefined
  console.log(c);//undefined
  var c = 5;//给当前作用域下的c赋值为5，不会影响全局变量c
}
fun();
//在全局作用域下访问，找的全局变量c
console.log(c);//3
*/

function f1(n){
  //var n=2
  //形参n属于局部变量
}
f1(2);
//console.log(n);//报错，无法访问局部变量n

var m = 5;
function foo(m){
  //var m=7
  //访问的是当前作用域下的m，不会到全局下找m
  m = m + 3;
}
foo(7);
console.log(m);//访问全局的m

3.函数的作用域

全局函数：在全局作用域下创建的函数，可以在任意作用域下调用
局部函数：在函数作用域下创建的函数，只能在当前作用域下调用

//全局函数
function fn(){
}
//作用域链 
//闭包
var a=3;
function fun1(){
  function fun2(){
    //局部函数,只能在所在的作用域下调用
	console.log(a);
  }
  fun2();
}
fun1();

斐波那契数列

第1、2项固定是1，从第3项开始每项的值是前两项相加的和

1 1 2 3 5 8 13 21

(2)练习：创建函数fib，传递任意一个数字，返回斐波那契数列下某一项的值

fib(6) -> 8 fib(7) -> 13

循环的方法

function fib(n){
  //第1项和第2项固定是1
  var n1 = 1,n2 = 1;
  //如果要求第n项的值，需要先从求出第3项的值，然后一直往后求出每一项的值，直到第n项
  for(var i = 3;i <= n;i++){
    //每一项值的求法：
    //n2的值是上一次n1和n2相加的和
	//n1的值是上一次n2的值
	//n2代表求出的每一项的值
	var c = n2;
    n2 = n1 + n2;
	n1 = c;
	//打印每一项的值
	//console.log(n2);
  }
  //返回n2最后的结果，也就所求项的值
  return n2;
}
console.log( fib(8) );