1、函数的创建

1.1、以直接量的方式创建（推荐）

tips:在函数前后调用都是可以的

  1. function go(){
  2.             console.log("hello world")
  3.         }

1.2、以变量的方式创建

tips:只能在函数之后调用

  1. var b = function(){
  2.             console.log("good")
  3.         }
  4.  b();

2、函数的返回值

定义:函数的执行结果

  1.     <script>
  3.         /* 函数的返回值
  4.         函数的执行结果
  5.         tips:
  6.         1、函数调用之后,return后面的语句不会执行
  7.         2、函数遇到return语句会立即停止，退出
  8.         3、return语句的作用，将函数内容的值返回给外部
  9.          */
  10.         function go(){
  11.             return 10;
  12.             console.log("hello world")
  13.         }
  14.         var res = go();
  15.         console.log(res)
  16.     </script>

2.1、函数return之后，return后面的语句就不会执行了
作用：将函数内部的值返回外部

  1.                 function go(){
  2.             return "hello world";
  3.             console.log("good");  // 不会执行
  4.         }
  5.         console.log(go()); // hello world


3、函数的参数

函数的参数是局部变量 js传不定参

  1. <script>
  2.         function go(a,b){
  3.             /* 函数的参数是局部变量 */
  4.             console.log(a);
  5.             console.log(b);
  6.         }
  8.         /*
  9.         function go(var a,b){
  10.             console.log(a);
  11.             console.log(b);
  12.         } 
  13.          */
  14.         /* tips:js传不定参 */
  15.         go();
  16.         go(10)
  17.         go(10,20)
  18.     </script>

4、重载

重载：就是根据参数的不同，动态决定调用哪个方法
js中没有重载的概念，因为重复声明，下面的会覆盖上面的
使用function声明的方法,本质上是window的方法

  1. <script>
  2.         /* 使用function声明的方法,本质上是window的方法 */
  3.         function go(a){
  4.             console.log(a)
  5.         }
  6.         function go(a,b){
  7.             console.log(a);
  8.             console.log(a+b);
  9.         }
  10.         window.go(10);
  11.         go(10,20)
  12.     </script>

重载:函数名相同,参数不同,根据传入的参数动态决定调用那个方法 JS不支持重载
就要JS支持 arguments对象
JS传不定参,函数使用arguments对象管理函数内部的参数

  1. function go(){
  2.             console.log(arguments)
  3.         }
  4.         go(10,23,4)

4.1、使用arguments对象模拟重载

  1. <script>
  2.         /* 
  3.         一个参数
  4.         二个参数
  5.          */
  6.         function go(){
  7.             if(arguments.length ==1){
  8.                 console.log(arguments[0])
  9.             }else if(arguments.length==2){
  10.                 console.log(arguments[0]);
  11.                 console.log(arguments[0]+arguments[1])
  12.             }
  13.         }
  14.         // go(10)
  15.         go(10,20)
  16.     </script>

5、函数的对象

函数作为对象的方法

  1.  var obj ={
  2.             name:"html",
  3.             sayName:function(){
  4.                 console.log(this.name)
  5.             }
  6.         }
  7.         /* 函数是对象的一个方法 */
  8.         obj.sayName();
  10.               this关键字指向问题
  11.         1、onclick  谁执行事件,this指向谁
  12.         2、谁执行方法,this指向谁

6、回调

回调函数就是这个函数作为参数传到另一个函数里面，当那个函数执行完之后，再执行传进去的这个函数。这个过程就叫做回调。
场景：一般在异步调用中使用作用：
1.将函数内部的值返回到外部
2.取代了return语句

6.1、jquery中的回调

  1. <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.js"></script>
  2. </head>
  3. <body>
  4.     <!-- 回调函数 -->
  5.     <button id="btn">btn</button>
  6.     <script>
  7.         $("#btn").click(function(){
  8.             console.log("hello")
  9.         })
  10.     </script>

6.2、js回调

  1. <script>
  2.         /* 回调函数:就是将函数作为函数传递给另一个函数
  3.         使用场景:异步问题
  4.          */
  5.         var show= function(a){
  6.             console.log(a)
  7.         }
  8.         function go(callback){
  9.             var b = 10;
  10.             callback(b);
  11.             /* show(b); */
  12.         }
  13.         go(show);
  14.     </script>
  16. <script>
  17.         function go(callback){
  18.             var b = 20;
  19.             callback(b);
  20.         }
  21.         go(function(res){
  22.             console.log(res)
  23.         })
  24.     </script>