关于函数的定义与使用

最新推荐文章于 2024-10-08 13:51:35 发布
wdadwa565
最新推荐文章于 2024-10-08 13:51:35 发布
阅读量84
点赞数
文章标签： javascript
本文链接：https://blog.csdn.net/wdadwa565/article/details/119508542
版权
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        //定义的函数是不会直接执行的
        // function name() {
            // console.log("您好")
            // console.log("您好")
            // console.log("您好")
// 
        // }
        //函数调用了才会执行 会执行三次
        // name();
        // name();
        // name();


//语句执行顺序*
        // function  fun () {
            // console.log("A")
            // console.log("B")
            // console.log("C")
        // }//不会最先输出
        // console.log(1);//1
        // console.log(2);//2
        // console.log(3);//3
        // fun();//A B C
        // console.log(4);//4
        // console.log(5);//5
        // console.log(6);//6
        //函数声明的提升 可以把函数调用放在前面,再把函数声明放在后面  函数表达式不能提升
    //  fun();
    //  function fun() {
        // alert("函数执行") 
    //  }
     //函数表达式不能被提升的
    //  fun();//引发错误
    //  var fun=function(){
        //  alert("函数被执行");
    //  }


//函数优选提升*
        //   fun();//优选弹出B
        //   var fun=function(){
            //   alert('a');
        //   }
        //   function fun(){
            //   alert('b')
        //   }
        //   fun()//弹出A
//总结：变量声明提升，无法覆盖提升的函数,变量提升只提升定义不提升值。

//函数的参数*
//参数是函数内的一些待定值，在调用函数时，必须传入这些参数的具体值
//函数的参数可多可少，函数可以没有参数，也可以有多个参数，多个参数之间需要用逗号隔开
//圆括号中定义：形参参数   调用函数时传入实际参数
//比如传入总的实际参数有3个 形参只有两个  那么就只会返回两个形参
//比如说实际参数有2个，形参只有三个那么第三个形参只会返回NaN

// arguments*
// 函数内arguments表示它接收到的实参列表，它是一个类数组对象
// function name() {
    // var sum=0;
    // for(var i=0;i<arguments.length;i++){
        // sum+=arguments[i];
    // }
    // console.log('所有参数的和是'+sum)
// }
// 
// name(33,44,23,34);
//总结：不管用户传入多少个实际参数，永远能够计算它们的和

//函数的返回值*
//定义:函数体内可以使用return关键字表示“函数的返回值”
// function name(a,b) {
    // return a+b
// }
// var result=name(3,4);
// console.log('两个数字的和是'+result)//7
// 同时调用一个返回值的函数，可以被当做一个普通值，从而可以出现在任何可以书写值的地方
// function name(a,b) {
    // return a+b;
// }
// var result =name(3,(4*5)) //12

//一旦遇见return语句则会立即退出函数，
// function name() {
    // console.log('a');//1
    // return 'b';
    // console.log('c')//A
    // B
// }
// console.log(1)
// var char=fun();
// console.log(char);
// console.log(2);//2

//遇见return 即退出函数
//结合if语句的时候，往往不需要写else分支了
// function checkEven(n) {
    // if(n%2==0) return true;
    // return false;
// }
// var result=checkEven(6)
// console.log(result);
//总结实际就是一个函数简写方式

//javascript 内置的sort()方法
//数组排序可以使用sort()方法，这个方法的参数又是一个函数

// var arr=[33,22,55,11];
// arr.sort(function (a,b) {
    // if(a>b){
        // return 1;
    // }else{
        // return -1;
    // }
    // return a-b;
    // 
// });
// console.log(arr);
//总结：这个函数中的a、b分别表示数组中靠前和靠后的项，如果需要将它们交换位置，则返回任意正数;否则就返回负数。
//同时排序，函数是JS中的一等公民，它可以当做参数传入另一个函数arr.sort( function (a, b) {

//递归
//当函数自己调用自己的时候就会现成递归
//递归要素 边界条件:确定递归到何时终止，也称为递归出口
//递归模式:大问题是如何分解为小问题的，也称为递归体
//求4的阶乘举例
// function name(n) {
    // if (n==1) return 1;//这个就是4的阶乘
    // 如果询问的不是1的阶层，那就返回n*(n-1)
    // return n *name(n-1);
    
//}
// var result=name(4);
// alert(result);

//总结：递归 什么时候不需要重新调用自身了 确定递归出口

// 浅克隆实现的思路
//浅克隆:准备一个空的结果数组，然后使用for循环遍历原数组，将遍历到的项都推入结果数组
//但是会造成藕断丝涟的情况发生
// var arr1=[33,44,11,22];
// 
// var result=[];
// for(var i=0;i<arr1.length;i++){
    // result.push(arr1[i])
// }
// console.log(result)

// 实现深克隆
// 使用递归思想，整体思路和浅克隆类似，但稍微进行一些改动:如果遍历到项是基本类型值，则直接推入结果数组;如果遍历到的项是又是数组，则重复执行浅克隆的操作。

// var arr1=[33,44,11,22,[77,88,[33,44]]];

//函数，这个函数会被递归
// function deepclone(arr) {
//结果数组 "每一层都有个结果数组"
// var result = [];
//遍历数组的每一项
// for (var i = 0; i < arr.length; i++) {
//类型判断，如果遍历到的项是数组
// if (Array.isArray( arr[i])) {
//递归
// result.push(deepclone( arr[i]));
// }
// else {
//如果遍历到的项不是数组，是基本类型值，就直接推入到结果数组中，
//相当于是递归的出口
// result.push(arr[i]);
// }
// }
//返回结果数组
// return result;
// }

// 变量作用域
// JavaScript是函数级作用域编程语言:变量只在其定义时所在的function内部有意义。

// function name() {
    // var a=10;
// }
// fun();
// console.log(a);//报错

// 总结:变量a是在fun函数中被定义的,所以变量a只在fun
// 函数内部有定义，fun函
// 数就是a的“作用域”，
// 变量a被称为局部变量。

// 全局变量
// 如果不将变量定义在任何函数的内部，此时这个变量就是夭局变量，它在任何函数内都可以被访问和更改。

// var a;
// function name() {
//    a=5;
//    a++;
// }
// fun();
// console.log(a) //6
//总结：变量a没有定义在任何函数内部，它是“全局变量”

// 遮蔽效应
// 如果函数中也定义了和全局同名的变量，则函数内的变量会将全局的变量“遮蔽”
// var a = 10;
// function fun( ) {
// var a = 5; //总结局部变量a将全局变量a "遮蔽"了
// a++;
// console.log(a);//输出6
// }
// fun();
// console.log(a);//输出10


// 变量提升
// var a=10;
// function name() {
    // a++; //局部变量a被自增1，a此时是undefined，自增1结果是NaN
    // var a=5;//重新将a赋值为5
    // console.log(a);//输出5
// }
// fun();
// console.log(a);//输出10
// 


// 形参也是局部变量
// 这个程序的运行结果是什么呢?
// var a = 10;
// function fun(a) { //注意形参a也是函数内部的局部变量
// a++;
// console.log(a); //输出8
// }
// fun(7);
// console.log(a);//输出10

// 作用域链
// 函数的嵌套:一个函数内部也可以定义一个函数。和局部变量类似，定义在一个函数内部的函数是局部函数。
// function fun() {
// function inner() {
// console.log('你好');
// }            //局部函数
// inner(); //调用内部函数
// }
// fun(); //调用外部函数


// 作用域链
// 在函数嵌套中，变量会从内到外逐层寻找它的定义。
//   var a = 10;
//   var b = 20;
//   function fun( ) {
//   var c = 30;
//   function inner( ) {
//   var a = 40;var d = 50;
//   console.log(a,b, c, d); //使用变量时,js会从当前层开始，逐层向上寻找定义  结果40 20 30 50
//   }
//   inner();
//   }
//   fun();


// 不加var将定义全局变量
// 在初次给变量赋值时，如果没有加var，则将定义全局变量
// function fun() {
// a = 3;
// }
// fun();
// console.log(a); // 3


//闭包
// function fun() {
// var name ='慕课网';
// function innerFun() {
// alert(name ) ;
// }
// return innerFun;//返回了内部函数
// }
// var inn = fun(); //内部函数被移动到了外部执行
// inn(); //内部函数被移动到了外部执行

//创建一个函数
// function fun(){
//定义局部变量
// var name = '慕课网';
//返回一个局部函数
// return function fun () {
// alert(name) ;
// };
// }
//调用外部函数，就能得到内部函数，用变量inn来接收
// var inn = fun();
//定义一个全局变量
// var name = 'ABC ' ;
//执行inn函数，就相当于在fun函数的外部，执行了内部函数
// inn();

// 什么是闭包
// JavaScript中函数会产生闭包(closure)闭包是函数本身和该函数声明时所处的环境状态的组合。
//函数能够“记忆住”其定义时所处的环境，即使函数不在其定义的环境中被调用，也能访问定义时所处环境的变量。
// 观察闭包现象
// 在JavaScript中，每次创建函数时都会创建闭包。
// 但是，闭包特性往往需要将函数“换一个地方”执行，才能被观察出来。
//闭包非常实用
// 闭包很有用，因为它允许我们将数据与操作该数据的函数关联起来。这与“面向对象编程”有少许相似之处。
// 闭包的功能:记忆性、模拟私有变量。
//闭包用途1-记忆性
// 当闭包产生时，函数所处环境的状态会始终保持在内存中，不会在外层函数调用后被自动清除。这就是闭包的记忆性。

    </script>
</body>
</html>