首页 > 代码库 > js08--函数1

js08--函数1

2024-09-22 17:34:15   203人阅读

函数当成类看当成匿名对象看，都是跟java吻合的，只有当成函数看（函数自己可以执行）跟java区别在这里。


function fact(){}
var F = fact ;
函数名是函数对象的地址，是地址就有内存区域，执行就是地址名()小括号，var f = new F()，f就不是指向函数F的地址了，他是F类的对象，他的地址里面是对象，不仅仅是一个函数。

function fact(num){
    if(num <=1) return 1 ;
    else  return num*fact(num-1)，  //fact只是一个变量名存的是函数地址，
}        
alert(fact(5));    
var F = fact ;
fact = null;//进一步证明了fact只是一个变量名存的是函数地址，
alert(F(5));    //报错，fact不是一个函数

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Untitled Document</title>
        <script type=text/javascript charset=utf-8>
        //形参无类型
        function  test(a ,b){
            alert(a+b);
            alert(111);
            return a+b;
        }
        var c = test(10 , 20);
        //函数当成类看当成匿名对象看，都是跟java吻合的，只有当成函数看（函数自己可以执行）跟java区别在这里。
        
        alert(c);
        alert(typeof test);        //函数也是一种数据类型 (function类型)
        
        function test1(aa){
            aa();
        }
        function test2(){
            alert(‘执行啦‘);
        }
        test1(function(){ alert(‘我也执行啦!‘)});
        
        // 在js中函数是可以嵌套定义的 (尽量不要这样去定义)
        function test3(){
            function test4(){
                alert(‘我是test4!‘);
            }
            test4();//函数调用
        }
        test3();//函数调用
        </script>
    </head>
    <body>
    </body>
</html>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Untitled Document</title>
        <script type=text/javascript charset=utf-8>
            // 3种方式定义函数 
            // 1 function语句式
            function test1(){
                alert(‘我是test1‘);
            }
            test1();
            
            // 2函数的直接量 ECMAScript
            var test2 = function(){
                alert(‘我是test2‘);
            }
            test2();
            
            // 3function构造函数式
            var test3 = new Function("a" , "b" ,"return a+b;");//函数参数，函数体
            alert(test3(10,20));//30
            
            
            //效率对比
            var d1 = new Date();
            var t1 = d1.getTime();
            for(var i =0 ; i <100000;i++){
                function test1(){;}        //function语句的形式，最开始函数解析一次放在内存中，多次调用用同一个，
                var test2 = new Function();//函数调用一次就解析一次，执行完就销毁了，多次调用多次解析，
            }
            var d2 = new Date();
            var t2 = d2.getTime();
            alert(t2 -t1);             
            
            test1();//可以运行
            function test1(){
                alert(‘1111‘);
            }
            alert(test2); //undefined
            test2();//test2 is not a function 
            var test2 = function(){
                alert(‘2222‘);
            }
            
            /* 4 2 3 3 5 6
            { 
                var f : 未定义
                f ： function f(){return 4;}     
            }
            {
                var f : new Function("return 2;"); ---> function(){return 3;} ---> 
                        new Function("return 5");  ---> function(){return 6 ;}
            }
            */
            function f(){return 1;}                  
            alert(f());        //返回值为4  
            var f = new Function("return 2;"); 
            alert(f());        //返回值为2 
            var f = function(){return 3;}             
            alert(f());           //返回值为3  
            function f(){return 4;}              
            alert(f());        //返回值为3  
            var f = new Function("return 5");  
            alert(f());    //返回值为5  
            var f = function(){return 6 ;}         
            alert(f());        //返回值为6      
            
            
            
            //函数作用域的概念
            var k = 1 ; 
            function t1(){
                var k = 2 ; //局部变量 k
                function test(){return k ;}     //function语句,k = 2
                var test = function(){ return k};    //函数直接量,k = 2
                var test = new Function(‘return k;‘);    // 构造函数的方式,k = 1
                alert(test());
            }
            t1();            
        </script>
    </head>
    <body>
    </body>
</html>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Untitled Document</title>
        <script type=text/javascript charset=utf-8>
        //js中 函数的参数: 形参 实参
        function test(a,b){
            alert(test.length);        // 形参个数
            //内部就是用一个数组去接受函数的实际参数,arguments 对象 可以访问函数的实际参数,只能在函数的内部访问和使用 
            alert(arguments.length);
            alert(arguments[0]);
            alert(arguments[1]);
            if(arguments.callee.length == arguments.length){
                return a+b;
            } else {
                return ‘参数不正确!‘;
            }
            //arguments对象 用的最多的 还是做递归操作
            //arguments.callee 指的是函数本身。
        }
        alert(test(10,20));        // 30    
        
        function fact(num){
                if(num <=1) return 1 ;
                else  return num*arguments.callee(num-1); //num*fact(num-1)，fact只是一个变量名存的是函数地址，
        }        
        alert(fact(5));    
        var F = fact ;//函数名是函数对象的地址，是地址就有内存区域，执行就是地址名()小括号，var f = new F()，f就不是指向函数F的地址了，他是F类的对象，他的地址里面是对象，不仅仅是一个函数。
        fact = null;//就不能写num*fact(num-1)，进一步证明了fact只是一个变量名存的是函数地址，
        alert(F(5));        
        </script>
    </head>
    <body>
    </body>
</html>

 技术分享

js08--函数1


联系
我们