JavaScript函数

函数：

//定义一个函数
function sayHi(name){
	console.log("大家晚上好! 我是"+name);
}
//调用
sayHi("张三");		//大家晚上好! 我是张三
sayHi("李四");		//大家晚上好! 我是李四

计算函数：

function sum(num1,num2){      //num1,num2 形参
	console.log(num1+num2);
}
sum(10,20);     // （10，20）实参      
sum(50,60);  	// （50，60）实参		

函数是有返回值的：

function sum(num1,num2){
	return num1+num2;
}
let result=sum(10,20);
console.log(result);

return 注意事项：

function sum(num1,num2){
	//相当于在这里填写了  return undefined;
}
let result=sum(10,20);
console.log(result);   //undefined


//return 后面的语句不会执行
function sum(num1,num2){
	return num1+num2;
	console.log("hello world!");
}
let result=sum(10,20);
console.log(result);     //不会输出 hello world

取到里面的最大值：

function maxValue(num1,num2){
	if(num1>num2){
		return num1;
	}else{
		return nunm2;
	}
}
let result=maxValue(10,20);
console.log(result);

案例一：求区间和：(1-100)

function sum(start,end){
	let sums=0;
	for(let i=start;i<=end;i++){
		sums=sums+i;
	}
	return sums;
}
let result=sum(1,100);
console.log(result);    // 5050

案例二：设计一个函数 判断是奇数还是偶数

function  isEven(num){
	//判断类型
	if(typeof num!=="number"){
		alert("参数不正确");
		return;
	}
	//判断是奇数还是偶数
	if(num %2==0){
	console.log("它是一个偶数");
	}else{
		console.log("它是一个奇数");
	}
}
isEven(19);   //它是一个奇数

形参和实参不一致：

//形参设置了一个值，实参没有传，返回结果为NaN
function sum(num1,num2){
	return num1+num2;
}
let result=sum(10);
console.log(result);   	//NaN

function sum(num1=0,num2=0){    //设 num1和num2的初始值为0 
		return num1+num2
}
let result=sum(10);
console.log(result);  //10

藏在函数中的属性： argument

  function fn(num1,num2,num3){
         console.log(arguments);

         for(let i=0;i<arguments.length;i++){
             console.log(arguments[i]);
        }
     }
     fn(10,20,30);

函数的创建方式：

1. 函数声明式 
function fn(){
	consloe.log("今天周几了？");
}
fn();
2.函数表达式
let sum=function(num1,num2){
	return num1+num2;
}
let result=sum(10,20);
console.log(result);


3.构造函数
let sum=new Function(num1,num2,'return num1+num2');
let result=sum(10,20);
console.log(result);   //30

4.函数的自调用：
(function(num1,num2){
	console.log(num1,num2)
})(10,20)

设计函数 求数组的最大值，最小值，平均值：

求平均值：

 let arr=[1,2,3,4,5,6]
    function fn(arr){
        let sum=0;
        for(let i=0;i<arr.length;i++){
            sum=sum+arr[i];
         }
         return sum/arr.length;
      }
  let result= fn(arr);
  console.log(result);

求最大值：

  let arr=[1,2,3,4,5,6]
  function fn1(arr){
       let max=arr[0];
       for(let i=0;i<arr.length;i++){
           if(arr[i]>max){
               max=arr[i];
           }
       }
       return max;
   }
   let result=fn1(arr);
   console.log(result);

求最小值:

let arr=[1,2,3,4,5,6];
function fn2(arr){
    let min=arr[0]
    for(let i=0;i<arr.length;i++){
        if(arr[i]<min){
            min=arr[i]
        }
    }
    return min
}
let result=fn2(arr);
console.log(result);

作用域与作用域链：

age=10;
var age;
console.log(age);  //10

age1=10;
let age;
console.log(age);  //会报错


console.log(myName);// 未定义
var myName="小高";


console.log(MYNAME);  //会报错
let MYNAME="小白";

//总结： var 声明的变量会被拿到函数或者全局作用域的顶部 位于作用域中所有代码之前,这个现象叫做 提升

变量作用域的分类（全局作用域，函数作用域，块级作用域）

//全局作用域
var myName='小高';  //在全局作用域下定义的变量
cionsole.log(myName);

function fn(){
	console.log(myName);
}
fn() //小高


局部作用域
function fn(){
	var myName="gkf";  //在局部作用域中定义的变量 只能在函数中访问
	console.log(myName);  //gkf
}
console.log(myName);//会报错 ,因为这个myName只能在函数内使用
fn();

全局变量的另一种表示方式：
function fn(){
        myName='zzf';    // 不推荐 相当于全局变量
        console.log(myName);
 	}
   fn();
   console.log(myName);

/*
总结：全局变量和局部变量的区别：
全局变量：在全局变量或者局部变量可以使用，等到浏览器关闭才会销毁
局部变量：只能在函数内部使用，函数执行完后，里面的变量也会被销毁
*/

作用域链：

let color='red';
    function fn(){
        let color='green';
        
        function fun(){
            
            console.log(color);
        }
        fun();
    }
    fn();  // green

块级作用域：( let ,const)

function fn(){
	var myName="张三";
	console.log(myName);   //张三
}
console.log(myName);   //会报错



if(true){
	var myName="小李";   //相当于全局变量 没有局部
}
console.log(myName);    //小李



if(true){
	let myName1="小白";
}
console.log(myName1); //会报错

变量和函数预解析：

//变量预解析
console.log(myName);   //underfined
var myNmae="小高";

//函数预解析
sum();     //这是一个函数
function sum(){
	console.log("这是一个函数")
}

//函数表达式
var fun=function(){
	console.log("这是一个函数！");
}
fun()