`

javaScript之function定义

阅读更多
背景知识

变量类型与变量声明

函数定义
在javaScript中,function的定义有 3 种:

//

// 1、匿名定义
               function(){}

// 2、非匿名定义
               function fn(){}

// 3、使用 Functon 对象定义
               fn = new Function("some code");

// 这里说明一下:
// function 是一个关键字,而 Function 是一个对象。



触发函数执行
1、对于匿名函数:
                       (function(){})();       //执行一个匿名函数
                       var f = function(){}(); //执行一个匿名函数,并将匿名函数的返回值,赋值给f
                       !function(){}();        //执行一个匿名函数
                 
              以上三种写法,
              无非就是要把 匿名函数 作为一个表达式块 然后执行。



2、对于非匿名函数:
                       函数名();       //如: fn();


用法示例
例子 1
function add(x, y){
   return(x + y); 
}
例子 2
var add = new Function("x", "y", "return(x+y)");

例子 3
var fn = function(){ } 
将匿名函数的引用赋值给一个变量。(最常用的写法)如:

var add = function(x, y){
   return(x + y); 
}
----------------------------------------------------------------
可以用如下代码行调用以上函数:
add(2, 3);

注意 : 在调用函数时,请确保包含了括号和必需的参数。调用函数时不用括号导致返回函数的文本而不是函数执行的结果。
add(2, 3);// return  "5"
add;      // renturn  " function add(x, y){return(x + y);}





1、用法剖析

<html>
<head>
<style type="text/css">
p{ background-color: #ada; height:40px; width:300px;line-height:40px;border-radius:10px;padding:0 20px;}
#myDiv{margin:auto;width:400px;background-color:#fefefe;}
body{padding-top:20px;}
</style>
</head>
<body>
    <div id="myDiv">
        <p>test_0</p>
        <p>test_1</p>
        <p>test_2</p>
        <p>test_3</p>
        <p>test_4</p>
        <p>test_5</p>
    </div>
    
        <script type="text/javascript">
        
        /********************Method 1********************************/
        
        //常规的写法(正确的写法)
        function method_1(){
            var item=document.getElementsByTagName('p');
            for(var i=0;i<item.length;i++){
                item[i].onclick=(function(i){
                    return function(){
                      alert(i);
                    }
                })(i);
            }
        }
        

        
        /********************Method 2********************************/
        
        //所有的 p 都 alert() 最后一个 i 的值(错误的写法)
        function method_2(){
            var item=document.getElementsByTagName('p');
            for(var i=0;i<item.length;i++){
                item[i].onclick=function(){
                    alert(i);
                };
            }
        }
       /*
        说明:
        item[i].onclick=(function(){})(); 匿名函数与立即执行 ,然后把结果给item[i].onclick
        */
        
        
        /********************Method 3********************************/
        //最能表达含义的写法(正确的写法)
        function method_3(){
            function createFunction(index){
                return function(){
                            alert(index);
                        }
            }
           
            var elems = document.getElementsByTagName('p');
            for(var i=0,len=elems.length; i<len; i++){
                elems[i].onclick = createFunction(i);
            }
        }

        
        
        /*说明:
         *      return function(){ alert(letter); }
         *      =
         *      return var fn = new Function(){ alert(letter);}
         *   
         *      调用 function ,生成(定义)function.
         *      renturn 的 时候其实是 new 了一个function 出来。
         */
         
         //===================================================================================
         //run function.
         
         //window.onload = method_3;         
         //or
         window.onload = function(){
            method_1();
         }
         
        </script>
    </body>
</html>


注:关于 window.onload : Launching Code on Document Ready

2、运行效果图







3、深入理解js的dom机制


js的一切对象(包括函数)都是依赖于 html的dom而存在的。

默认对象是window,所有的方法、属性,默认都是window对象的属性和方法
---------------------------
alert() = window.alert()
---------------------------
var x = window.x
var x = 10;
alert(window.x ); //10

我们猜测所有js函数运行时的环境,也是基于某个对象的(该对象的属性就是其运行环境)。

请看下面的例子:

例子一
<html>
    <head>
        <style type="text/css">
        p{
            width:200px;
            height:30px;
            background-color:#F0F0F0;
        }
        </style>
    </head>
    <body>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <script type="text/javascript">
        window.onload=function(){
            var adiv=document.getElementsByTagName('p');
            for(var i=0;i<adiv.length;i++){
                adiv[i].onclick=function(){
                    alert(i);
                }
            }
        }
        </script>
    </body>
</html>

结果:(无论点那个都alert 6)






例子二
<html>
    <head>
        <style type="text/css">
        p{
            width:200px;
            height:30px;
            background-color:#F0F0F0;
        }
        </style>
    </head>
    <body>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <p>test </p>
        <script type="text/javascript">
        window.onload=function(){
            var adiv=document.getElementsByTagName('p');
            for(var i=0;i<adiv.length;i++){
                adiv[i].onclick=(function(i){
                    return function(){ alert(i);};
                })(i);
            }
        }
        </script>
    </body>
</html>

结果:(正常)






原因:

在例子二中,
改变了onclick事件的function的作用域范围。
(function(){
    return fuction(){};
})();
新new了一个function作用域,赋值给onclick事件。



分析:



例子一:
当onclick触发时,它实际(引用)运行的环境是 window.onload ,
window.onload是一个function,而它又有自己的属性:
window.onload.adiv
window.onload.i
window.onload.adiv[0].onclick
window.onload.adiv[1].onclick
window.onload.adiv[2].onclick
window.onload.adiv[3].onclick
...

onclick 会在当前作用域中找adiv(找到了) ,也会去找 i ,但是此时 i 的值 是 adiv.leng-1
所以会一直 alert 一个值



而如下方式(例子二):
window.onload=function(){
    var adiv=document.getElementsByTagName('p');
    for(i=0;i<adiv.length;i++){
        adiv[i].onclick=(function(i){
            return function(){alert(i)};
        })(i);
        }
    }
}
是采用匿名函数立即执行,利用立即执行为匿名函数,window.onload为自身创建属性(一个匿名函数)
此匿名又有2个属性(一个参数i,一个funcion)
并把执行后的结果赋值给 adiv[i].onclick
此时window.onload的结构大致是:
window.onload.adiv
window.onload.i
window.onload.adiv[0].onclick
window.onload.(function(0){})
window.onload.(function(0){}).i
window.onload.(function(0){}).function

window.onload.adiv[1].onclick
window.onload.(function(1){})
window.onload.(function(1){}).i
window.onload.(function(1){}).function

...

赋值后
window.onload.adiv[0].onclick =
window.onload.(function(0){}).function

此时adiv[0].onclick的作用域是:window.onload.(function(0){})
                 不再是原来的:window.onload

                
在新的作用域中是有 i 的,而 i 的值,就是当初传进来的值。
            



再看下面的例子:
<html>
    <head>
        <style type="text/css"></style>
    </head>
    <body>
        <script type="text/javascript">
        /*
        //1.
        function Wen(){
            this.name = "taobao";
            this.waitMes=function(){
                setTimeout(function(){this.fn(this.name);},1000);                 
            };
            this.fn=function(name){
                alert(name);
            }
        }
        var foo=new Wen();
        foo.waitMes();
        
        //**运行结果:空。
        // *因为setTimeout 运行时的上下文环境是window
        // *而 window 没有 fn 和 name 属性
        //**故alert值为空
        
        //2.
        var name = "taobao";       
        function fn (name){
            alert(name);
        }       
        function Wen(){
            this.waitMes=function(){
                setTimeout(function(){this.fn(this.name);},1000); 
            };
        }
        var foo=new Wen();
        foo.waitMes();
        
        //**运行结果:非空。       
        // *将 fn 和 name 放在 window 对象下
        
        
        //3.
        function Wen(){
            this.name = "taobao";
            this.waitMes=function(){
                var that = this;
                setTimeout(function(){that.fn(that.name);},1000); 
            };
            this.fn=function(name){
                alert(name);
            }
        }
        var foo=new Wen();
        foo.waitMes();
        
        //**运行结果:非空。       
        // *that作为参数传递到this中
        */
        
       //4. 
       function Wen(){
            this.name = "taobao";
            this.waitMes=function(){
                var that = this;
                setTimeout(that.fn,1000); 
            };
            this.fn=function(){               
                alert(this.name);
            };
           
        }
        var foo=new Wen();
        foo.waitMes();
        
        //**运行结果:空。       
        // * this 仍然是指 window 对象。
        // * 因为调用的是 window 对象的 setTimeout()方法。
        // */
           
        </script>
    </body>
</html>

            

            

4、变量作用域之 变量覆盖

原理:
由于js function对象的 hoisting 特性(函数内的所有变量都相当于自动在函数头部声明,赋值部分位置不变),
可能会导致访问变量时出现 undefined。

例子:
 <script type="text/javascript">
            //1.
            var foo = 'This is foo.';
            (function(){
               alert(foo);//This is foo.
            })();
            
            //2.
            var foo = 'This is foo.';
            (function(){
               alert(foo);//undefined
               var foo = 2;
            })();
            
            /**
            function对象的 hoisting 特性:函数内的所有变量都相当于自动在函数头部声明
            故 2 等价于这种写法:
            
            var foo = 'This is foo.';
            (function(){
               var foo;
               alert(foo);
               foo = 2;
            })();
           
            在2中,又定义了一个局部变量foo,(覆盖了上级范围的foo),但是没有给赋初值,
            故访问foo时,出现 undefined 提示。
            */
</script>


所以,在函数定义时,其所有用到的变量,要写在函数体前。








补录:
---
匿名函数自动执行,只是一种简便的写法而已,并无新奇或创意。
(function(){})();
等价于
var fn = function(){};
fn();//执行
在任何使用过程中,完全可以用后一种方式替代。




—————————————

javascript 函数基础系列文章

1、JavaScript之变量的作用域
2、javascript之变量类型与变量声明及函数变量的运行机制
3、javaScript之function定义
4、javascript之function的prototype对象
5、javascript之function的(closure)闭包特性
6、javascript之function的this   
7、javascript之function的apply(), call()



___________


javascript 面向对象编程系列文章:

    1、javaScript之面向对象编程
    2、javascript之面向对象编程之属性继承
    3、javascript之面向对象编程之原型继承 
   

-






-转载请注明出处:
http://lixh1986.iteye.com/blog/1947017



-
  • 大小: 8.2 KB
  • 大小: 8.8 KB
  • 大小: 8.7 KB
分享到:
评论
1 楼 guodongkai 2015-04-25  
谢谢您能将知识精华汇编总结,让初学者们从原理中学会和提高。

相关推荐

    JavaScript使用function定义对象并调用的方法

    这就是标题中提到的"JavaScript使用function定义对象并调用的方法"。 首先,我们要理解构造函数的概念。构造函数是一种特殊的函数,用于初始化新创建的对象。在JavaScript中,我们通常使用`function`关键字来定义一...

    javascript Function

    这在JavaScript中是非常有用的特性之一: ```javascript (function() { // 独立的作用域 })(); ``` 通过这种方式定义的函数形成了一个独立的作用域,其中的变量不会被外部访问到。 #### 五、作为选择器 在某些...

    JavaScript中的function使用方法.docx

    JavaScript 中的 function 使用方法 JavaScript 中的 function 使用方法可以分为两种:作为普通逻辑代码容器和作为对象。 一、function 作为普通函数 在 JavaScript 中,function 可以作为普通函数使用,类似于 C...

    JavaScript 定义function的三种方式小结

    如: 代码如下: function func() { //body code } (3) 使用JavaScript内置Function对象构造。如: 代码如下: var func = new Function(“/*parameters*/”,”/*body code*/”); 声明变量定义与使用function表达式...

    JavaScript通过function定义对象并给对象添加toString()方法实例分析

    主要介绍了JavaScript通过function定义对象并给对象添加toString()方法,实例分析了javascript中function定义对象及添加方法的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下

    javascript定义对象

    在JavaScript中,对象是语言的核心特性之一,它们用于组织数据和封装功能。下面将详细介绍JavaScript定义对象的四种主要方式:字面量语法、构造函数、对象解构和Proxy。 1. **字面量语法** 字面量语法是定义...

    【JavaScript源代码】JavaScript的function函数详细介绍.docx

    JavaScript中的`function`函数是其核心特性之一,它允许我们定义可重复使用的代码块,能够封装任意数量的语句,并且可以在程序的任何位置被调用。JavaScript的函数与许多其他编程语言(如C)相比,具有独特的特点,...

    javascript两种function的定义介绍及区别说明

    在JavaScript中有两种主要的函数定义方式,即函数声明(Function Declaration)和函数表达式(Function Expression)。这两种方式在大部分场景下表现相同,但在特定条件下会有差异。下面将详细讨论这两种函数定义...

    Javascript 使用function定义构造函数

    在JavaScript中,每个构造函数都有一个与之关联的原型对象。当访问一个对象的属性或方法时,如果在对象本身找不到,JavaScript会继续在该对象的原型对象中查找。这一点体现了JavaScript基于原型继承的特性。 通过...

    javascript工厂方式定义对象.docx

    JavaScript中的对象创建是编程中的重要概念,特别是在面向对象编程中。本文主要探讨了四种常见的创建JavaScript对象的方法:工厂方式、构造函数方式、原型方式以及混合构造函数/原型方式。 1. **工厂方式**: 工厂...

    javascript面向对象之定义成员方法实例分析.docx

    ### JavaScript面向对象之定义成员方法实例分析 #### 一、引言 JavaScript 是一种支持面向对象编程的语言,尽管它的面向对象特性与传统类基于的语言有所不同。在 JavaScript 中,可以通过多种方式来定义对象及其...

    JavaScript函数的定义方法及函数的参数和优化.docx

    JavaScript 函数的定义方法及函数的参数和优化 JavaScript 函数是定义一次但可以调用或执行任意多次的一段 JavaScript 代码。函数可能有参数,即函数被调用时指定了值的局部变量。 JavaScript 函数的定义有两种方法...

    JavaScript对象定义

    JavaScript对象定义是编程语言中的核心概念,它在Web开发中起着至关重要的作用。JavaScript是一种基于原型的对象导向语言,它的对象定义方式具有独特的灵活性。在本文中,我们将深入探讨JavaScript对象的定义、创建...

    JavaScript闭包的定义和理解,含代码示例

    在JavaScript中,每个函数都有自己的作用域链,作用域链中包含了函数定义时所在的作用域内的所有变量。当一个函数作为另一个函数的返回值时,它将保留对其外部作用域的引用,从而形成闭包。 #### 三、闭包的应用...

    深化浅析JavaScript中的Function类型_.docx

    JavaScript中的Function类型是编程语言的核心概念之一,它既是创建可执行代码的构造器,也是一种数据类型。在JavaScript中,函数是一种一等公民,这意味着函数可以作为变量赋值、作为参数传递,甚至作为其他函数的...

    Javascript 面向对象的JavaScript进阶

    在JavaScript中,可以通过构造函数或类来创建对象,并通过定义方法来隐藏具体的实现细节。此外,ES6引入了类的概念,进一步增强了抽象的能力。 **示例代码:** ```javascript class USBDevice { constructor(name)...

Global site tag (gtag.js) - Google Analytics