2021/12/31

2021/12/30

一、js

(1)函数参数

function test(a,b)里面的a,b相当于我在函数里面定义了a，b，只是不赋值。调用test()的时候可以给a，b赋值.

	var aa = Number(window.prompt('a'));
            var bb =Number(window.prompt('b'));
            function test(a,b){ //a,b相当于函数里面定义了a，b

                      console.log(a+b);
            }
            test(aa,bb);

如果这么写，外面的test(aa,bb)不能给a，b赋值.

所以函数给我们的功能，就是让我们能够给函数里面所需要的数据，在调用的时候去赋值

		function test(){ //a,b相当于函数里面定义了a，b
						var a ,b;
                      console.log(a+b);
            }
            test(aa,bb);

1、形参与实参

形参就是占位符，实参就是给占位符赋值

新参就是变量，实参就是给变量赋上实际的值

1.形参

占位->形式上占位，形式参数（形参）a,b

  function test(a,b){

2.实参

实际参数:aa,bb

 test(aa,bb);

例子：

a输入1，b输入5时候，b-a输出4

var aa = Number(window.prompt('a'));
            var bb =Number(window.prompt('b'));
            function test(a,b){

                      console.log(b-a);
            }
            test(aa,bb);

调换形参test(a,b)位置变成 test(b,a）之后，a输入1，b输入5时 b-a输出-4

 			 var aa = Number(window.prompt('a'));
            var bb =Number(window.prompt('b'));
            function test(b,a){

                      console.log(b-a);
            }
            test(aa,bb);

所以在赋值的时候，参数要一一对应，顺序不能改，不能a对应bb，b对应aa

总结一下：

参数就相当于，函数内部声明的变量（有点像，类似于）

区别在于：参数 可以在函数被调用的时候赋值，而在函数内部声明变量的话，无法在函数被调用的时候赋值

所以说，如果像函数内部的var a,b;要像被赋值，就得变成占位符放到function (a,b){}里面来，这样才能解决，函数调用时，赋值的问题。

2、传参过程

1.在传参的过程中，参数的数据类型不限制，就是任何数据类型都可以往里面传

			var aa = Number(window.prompt('a'));
            var bb =Number(window.prompt('b'));
            function test(a,b){

                      console.log(a,b);
            }
            test(false,null);//false,null

2.形参和实参数量不一样

形参比实参多：

 function test(a,b,c){//岁然c没有定义，但是c已经占位了

                      console.log(a,b,c);//1,2,undefined  
            }
            test(1,2);

实参比形参多：

	function test(a,b){

                      console.log(a,b);//1,2
            }
            test(1,2,3);

总结：

函数形参与实参的特征：形参和实参数量可以不等

考虑：在函数内部的时候，我能知道有哪些实参吗？

通过arguments（打印实参）知道有哪些实参

function test(a,b){

              console.log(arguments);
            }
            test(1,2,3);

3.实参数组打印：

 function test(a,b){
              for(var i = 0 ;i<arguments.length;i++){

                console.log(arguments[i]);
              }
              
            }
            test(1,2,3);

4.实参的长度:

 function test(a,b){

                  console.log(arguments.length);//长度为3

                }
                test(1,2,3);

5.形参的长度：

用函数名.length

unction test(a,b){

                  console.log(test.length);//长度为2

                }
                test(1,2,3);

6.打印数组指定位置实参数：

function test(a,b){

        console.log(arguments[1]);//2
   }
   test(1,2,3);

7.函数内部给形参赋值，会更改实参的值。即在函数内部，是可以更改实参的值

比如用户输入了不合法的数，我们可以通过判断这个实参的值去更改

 function test(a,b){

        a = 3;
        console.log(a);//输出3
		console.log(arguments[0]);//输出3

    }
    test(1,2);

8.实参并没有传递，在函数内部赋值，不会打印实参

 function test(a,b){

         b=2;
        
            console.log(b);//2
            console.log(arguments[1]);//undefined

    }
    test(1);

总结：

在实参里面传值的，可以在函数内部修改这个实参的值

如果在实参里面没有值，在函数内部给形参赋值的，没有用

3、函数例题

1.(输入一串数字累加)一个函数被调用时，累加它的实参,不知道实参有多少个。

		function sum(){    //不能填参数，因为不知道参数多少个不好填，占位都不知道怎么占位
               var count =0; 
            for(var i =0;i<arguments.length;i++){
                count+=arguments[i];

            }
            console.log(count);//110
    }
    sum(10,20,8,9,7,56);

4、映射

下面代码中的arguments[0]跟a=3不是一个变量和值，不是一个东西
a=3;存在栈内存里面的

arguments[]存在堆内存里面的,它在下面是一个存1和2的一个数组，然后在栈内存，存储这个地址，给一个指针

  function test(a,b){
            a=3;//存在栈内存里面的
        console.log(arguments[0]);//arguments[]存在堆内存里面的

    }
    test(1,2);

但是，虽然实参和形参，虽然不是一个变量，但在函数的基础上，在系统内部，它们是一个映射关系

映射关系解释：

就是说形参和实参，它并不是同一个量，他们是存放在不同地方的，但是系统的设置它们存在着映射关系

也就是说，无论你的实参怎么赋值，你的形参都会跟着变，但是必须是形参里面这个数组里面有这个对应的值才行。

如果没有对应的值，没有用，就算在函数里你的形参赋值了，实参输出undefined

但是如果实参和形参的对应关系是存在的，那么他们当中就有必然的映射关系

5、return问题

1.函数执行到最后一行，系统会自己增加一条return语句，并不是没有，是系统增加的

叫隐式添加

function test(a){
           console.log(a);
            //return 中止这个函数的执行
    }
    test(1);

2.return中断函数的执行，return放到哪里，retrun下面的语句是不会执行的

function test(a,b){
           console.log(a);
            return;
    		console.log(b);//不执行
    }
    test(1,2);

3.第一个功能，中断

  function test(name){

            if(!name){

                return;
            }
            console.log(name);//打印出施政             }
  			}      
      test('施政');

4.第二个功能，返回一个值。

返回值过程中，也执行了函数的中止过程

	var name =prompt('请输入您的姓名'); 
    function test(){

            if(!name){

                return '您没有填写姓名';
            }
            return name;
            }
            alert('您的姓名为:'+test(name));//里面没有打印，要在外面打印

5.如果没填写return，不输入姓名

没有一个中止的过程

function test(name){

            if(!name){

          console.log('您没有填写姓名'); 
            }
                    console.log(name); 
            }
            test();

输出：

6.用与或的方式

或运算，当前是假，就往后走，

与运算,当前是真，往后走

下面用或语句，当前是真的话，就返回name。如果name是假，是空值，则走到您没有填写姓名这一句 字符串是真、

或语句，是遇假就往后走，走到最后无论真假，都返回最后一个

假有undefined null NaN '' 0 false

 var name =prompt('请输入姓名') 
        function test(){
            
                  return  name || '您没有填入姓名'

         }
         console.log(test(name));

8.var再外部是全局变量，在块级作用域中是局部变量

	 var b=2;
            function test(){
                var a =1;
                console.log(b);//打印出2

            }
            test()
			console.log(a);//报错

包到typeof里面就不报错

var b=2;
            function test(){
                var a =1;
                console.log(b);//打印出2

            }
            test()
			console.log(typeof(a));//undefined

9.问a，b c是否能打印

 			var a=1;//全局变量
            function test(){
                var b = 2;//局部变量
                console.log(a);//打印1
            function test2(){

                var c =3;//局部变量 
                a =3;
                console.log(b);//打印2
            }
            test2();
             console.log(c);//报错,未被定义
            }
            test();
			console.log(a)//3

10. 类似作用域

 function test1(){

                var a = 1;
                console.log(b);//报错

            }
            function test2(){

                var b = 2;
                console.log(a);//报错
            }
            test1();
            test2();

6、函数式编程

计算机里面的函数：固定的功能或者是程序段被封装的过程，

实现一个固定的功能或程序，

在这个封装体中需要一个入口和一个出口，

入口就是参数，出口就是返回 。

函数就像一个盒子，把程序封装起来了。

每次要用程序就调用这个盒子

  function test(str1,str2,str3){

                    console.log(str1);
                    console.log(str2);
                    console.log(str3);
            }
            test(
                '1',
                '2',
                '3'
                     );

 function test(str){

                return str;
            }
            console.log(test('我爱编程'));

7、作业

1.定义一个函数，从wp接收一个饮料的名称，函数返回对应的价格；

  var wp=prompt('请输入饮料的名称');
              function prize(){
                        if (wp=='冰红茶')
                        alert('5元');
                        else if(wp=='绿茶'){
                            alert('4.5元');
                        }else{

                            alert('没有对应的饮料');
                        }
                  
                    }
           prize(wp);

2.定义一个函数，从wp接收第一个数，接收一个运算符号（+ - * / %）,接收第二个数，利用这个函数作运算，并返回结果；

3.定义一个函数，从wp接收一个n，算出n的阶乘，不能用for；

4.定义一个函数，从wp接收一个n，算出斐波那契数列的第N位，不能用for循环；

新知识

（1）typeof机制

typeof检测数据类型的方式，是根据二进制码的后三位判断

数据类型	二进制码后三位
数值型（number）	001
字符串（string）	100
布尔型(boolean)	110
数组（Array)	1000100010001000
null	0000000000000000