函数，初始作用域

函数

1. 减少耦合度

2. 高内聚，低耦合

         定义函数
          function test(){
    		 
    	 }
        //函数名test
        //函数名test()
   

3. 函数执行的次数，可以执行多次

4. 函数里内容 函数没有自执行时，要有执行函数

     <script type="text/javascript">
    	 function test(){
    		 var a = 123;
    		 var b = 234;
    		 var c= a+b;
    		 document.write(c)
    	 }
    	test();
      
    </script>
   

5. 定义一个功能，再调用

6. 函数外面不能访问里面，里面可以访问外面。

7. 函数名《==》变量名 要驼峰式命名法

8. console.log(test)===> function test(){}

9. 弱数据类型，不能打印地址

10. 函数要定义

• 定义一个函数test 变量 function test(){}
• {函数体}

11. 是否带参数

      1.1
       function abc(a,b){
           //var a;
           //var b;
       }
       abc(1,2)
    
        1.2
         function abc(a,b){
          var c= a+b;
          document.write(c)
       }
       abc(1,2)  
       //3
    
        1.3
        //a,b形参
         function abc(a,b){
         if(a>b){
             document.write(a+b)
         }else{
              document.write(a-b)
         } 
       }
       //实参
       abc(1,2)  
       //-1
    
        1.4 实参形参多少不报错
         function abc(a,b，c，d){
           document.write(a)//1
           document.write(b)//2
           document.write(c)//3
           document.write(d)//underfined
       }
       abc(1,2，3)
    

实参属性：数组

        1.4 隐式类型转换  arguments ====[]
         function abc(a){
          console.log(arguments)
          console.log(arguments.length)
       }
       abc(1,2，3)
       // [1,2,3]
       //3

形参属性：函数名.length

        1.5 for循环 实参arguments ====[]
		function abc(a) {
			for(var i=0;i<arguments.length;i++){
				console.log(arguments[i]) 
			}				
		}
		  abc(1, 2， 3)
		  //1，2，3

        1.5 for循环 形参函数名abc.length ====[]
		function abc(a) {
			console.log(abc.[i]) 
		}
		  abc(1, 2， 3)
		  //1，2，3

实参形参数量多少没事，只要是变量，类型没有限定，什么都可以

11. 命名函数定义函数

      var test = function abc(){}
      console.log(test)   ===》function abc(){}
      console.log(abc)  ====>报错
      function abc(){}是表达式忽略名字
      test.name====>abc
    

12. 匿名函数定义 是本身

    var demo = function(){}
     console.log(deno)   ===》function() {}
     console.log(demo.name)  ====>demo
    

13. 匿名函数定义 是本身

不定参数求和 功能强大

函数求和 任意个数求和，多个数求和，传多少数求所少数

      <script type="text/javascript">
		var result = 0
		function abc() {
			for (var i = 0; i < arguments.length; i++) {
				result += arguments[i]
			}
			console.log(result)
		}
		abc(1, 2, 3)
	</script>
	 //6

13. 形参与arguements[0]值变不变

      <script type="text/javascript">
       function abc(a, b) {
       	a = 2;
       	console.log(arguments[0])
       }
       abc(1, 2)
      </script>
      //2
    

14. arguements[0]值变，实参的值也变

    //两者都变，映射关系，两者一样的个数才会有映射，其余没有映射

     <script type="text/javascript">
       function abc(a, b) {
       	a = 2;
       	arguments[0]=3
       	console.log(a)
       }
       abc(1, 2)
    

    //3

形参与实参有一个映射规则（前提），一个变化另一个也不变化

15. 实参只传一个，形参传值2，给形参2赋值，打印也是underfined

实参不存在，不能添加实参

      <script type="text/javascript">
		function abc(a, b) {
			b = 2;
			console.log(arguments[1])
		}
		abc(1)
	</script>
//不相等不映射，不能赋值，b是个变量使用不映射

16. return 函数终止， 结束条件加返回值

      //若没写，函数自动添加return
      <script type="text/javascript">
       function abc(a, b) {
       	console.log("a")
       	return;
       	console.log("b")
       }
       abc(1)
    

    //a

函数，返回值，将函数的值返回到外部，都可以返回，自己定义的 函数也可以返回

     <script type="text/javascript">
		function abc(  ) {
			return 123;
		}
		var num = abc()
		console.log(num)
	</script>
	//123

即返回值又终止函数

     	<script type="text/javascript">
		function abc(  ) {
			return 123;				
			console.log('a')
		}
		var num = abc()
	</script>
	//123是num的值，console.log无值

函数基本 隐式调用执行（number《-----》+）

      //加号隐式调用number()
      <script type="text/javascript">
		function abc(target) {
			return+target
		}
		var num = abc('123')
		console.log(typeof(num)+" " + num);
	  </script>
	//number 123
	 函数是累加求和

typeof 的用法两种

       typeof(num)
       typeof num

函数作用域

函数里面能用外面的,外面的不能访问里面的

两个函数之间的数据不能访问独立存在的