JavaScript入门之基本函数

系列专题：JavaScript入门

江岸网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、响应式网站开发等网站项目制作，到程序开发，运营维护。创新互联成立于2013年到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

总的来说，函数在JavaScript中可以：

◆ 被赋值给一个变量

◆ 被赋值为对象的属性

◆ 作为参数被传入别的函数

◆ 作为函数的结果被返回

◆ 用字面量来创建

函数对象

1.1 创建函数

创建JavaScript函数的一种不长用的方式(几乎没有人用)是通过new操作符来作用于Function“构造器”：

 
 
 
    
  
  
  
  1. var funcName = new Function( [argname1, [... argnameN,]]body ); 
    2.

参数列表中可以有任意多的参数，然后紧跟着是函数体，比如：

 
 
 
    
  
  
  
  1. var add = new Function("x", "y", "return(x+y)");  
    2. 
  
  
  
  2. print(add(2, 4)); 
    3.

将会打印结果：

6

但是，谁会用如此难用的方式来创建一个函数呢?如果函数体比较复杂，那拼接这个String要花费很大的力气，所以JavaScript提供了一种语法糖，即通过字面量来创建函数：

 
 
 
    
  
  
  
  1. function add(x, y){  
    2. 
  
  
  
  2.     return x + y;  
    3. 
  
  
  
  3. } 
    4.

或：

 
 
 
    
  
  
  
  1. var add = function(x, y){  
    2. 
  
  
  
  2.     return x + y;  
    3. 
  
  
  
  3. } 
    4.

事实上，这样的语法糖更容易使传统领域的程序员产生误解，function关键字会调用Function来new一个对象，并将参数表和函数体准确的传递给Function的构造器。

通常来说，在全局作用域(作用域将在下一节详细介绍)内声明一个对象，只不过是对一个属性赋值而已，比如上例中的add函数，事实上只是为全局对象添加了一个属性，属性名为add，而属性的值是一个对象，即function(x, y){return x+y;}，理解这一点很重要，这条语句在语法上跟：

 
 
 
    
  
  
  
  1. var str = "This is a string"; 
    2.

并无二致。都是给全局对象动态的增加一个新的属性，如此而已。

为了说明函数跟其他的对象一样，都是作为一个独立的对象而存在于JavaScript的运行系统，我们不妨看这样一个例子：

 
 
 
    
  
  
  
  1. function p(){  
    2. 
  
  
  
  2.     print("invoke p by ()");  
    3. 
  
  
  
  3. }  
    4. 
  
  
  
  4.    
    5. 
  
  
  
  5. p.id = "func";  
    6. 
  
  
  
  6. p.type = "function";  
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8. print(p);  
    9. 
  
  
  
  9. print(p.id+":"+p.type);  
    10. 
  
  
  
  10. print(p()); 
    11.

没有错，p虽然引用了一个匿名函数(对象)，但是同时又可以拥有属性，完全跟其他对象一样，运行结果如下：

function (){
print("invoke p by ()");
}
func:function
invoke p by ()

1.2 函数的参数

在JavaScript中，函数的参数是比较有意思的，比如，你可以将任意多的参数传递给一个函数，即使这个函数声明时并未制定形式参数，比如：

 
 
 
    
  
  
  
  1. function adPrint(str, len, option){  
    2. 
  
  
  
  2.     var s = str || "default";  
    3. 
  
  
  
  3.     var l = len || s.length;  
    4. 
  
  
  
  4.     var o = option || "i";  
    5. 
  
  
  
  5.      
    6. 
  
  
  
  6.     s = s.substring(0, l);  
    7. 
  
  
  
  7.     switch(o){  
    8. 
  
  
  
  8.        case "u":  
    9. 
  
  
  
  9.            s = s.toUpperCase();  
    10. 
  
  
  
  10.            break;  
    11. 
  
  
  
  11.        case "l":  
    12. 
  
  
  
  12.            s = s.toLowerCase();  
    13. 
  
  
  
  13.            break;  
    14. 
  
  
  
  14.        default:  
    15. 
  
  
  
  15.            break;  
    16. 
  
  
  
  16.     }  
    17. 
  
  
  
  17.      
    18. 
  
  
  
  18.     print(s);  
    19. 
  
  
  
  19. }  
    20. 
  
  
  
  20.    
    21. 
  
  
  
  21. adPrint("Hello, world");  
    22. 
  
  
  
  22. adPrint("Hello, world", 5);  
    23. 
  
  
  
  23. adPrint("Hello, world", 5, "l");//lower case  
    24. 
  
  
  
  24. adPrint("Hello, world", 5, "u");//upper case 
    25.

函数adPrint在声明时接受三个形式参数：要打印的串，要打印的长度，是否转换为大小写的标记。但是在调用的时候，我们可以按顺序传递给adPrint一个参数，两个参数，或者三个参数(甚至可以传递给它多于3个，没有关系)，运行结果如下：

Hello, world
Hello
hello
HELLO

事实上，JavaScript在处理函数的参数时，与其他编译型的语言不一样，解释器传递给函数的是一个类似于数组的内部值，叫arguments，这个在函数对象生成的时候就被初始化了。比如我们传递给adPrint一个参数的情况下，其他两个参数分别为undefined.这样，我们可以才adPrint函数内部处理那些undefined参数，从而可以向外部公开：我们可以处理任意参数。

我们通过另一个例子来讨论这个神奇的arguments:

 
 
 
    
  
  
  
  1. function sum(){  
    2. 
  
  
  
  2.     var result = 0;  
    3. 
  
  
  
  3.     for(var i = 0, len = arguments.length; i < len; i++){  
    4. 
  
  
  
  4.        var current = arguments[i];  
    5. 
  
  
  
  5.        if(isNaN(current)){  
    6. 
  
  
  
  6.            throw new Error("not a number exception");  
    7. 
  
  
  
  7.        }else{  
    8. 
  
  
  
  8.            result += current;  
    9. 
  
  
  
  9.        }  
    10. 
  
  
  
  10.     }  
    11. 
  
  
  
  11.      
    12. 
  
  
  
  12.     return result;  
    13. 
  
  
  
  13. }  
    14. 
  
  
  
  14.    
    15. 
  
  
  
  15. print(sum(10, 20, 30, 40, 50));  
    16. 
  
  
  
  16. print(sum(4, 8, 15, 16, 23, 42));//《迷失》上那串神奇的数字  
    17. 
  
  
  
  17. print(sum("new")); 
    18.

函数sum没有显式的形参，而我们又可以动态的传递给其任意多的参数，那么，如何在sum函数中如何引用这些参数呢?这里就需要用到arguments这个伪数组了，运行结果如下：

150
108
Error: not a number exception

函数作用域

作用域的概念在几乎所有的主流语言中都有体现，在JavaScript中，则有其特殊性：JavaScript中的变量作用域为函数体内有效，而无块作用域，我们在Java语言中，可以这样定义for循环块中的下标变量：

 
 
 
    
  
  
  
  1. public void method(){  
    2. 
  
  
  
  2.     for(int i = 0; i < obj1.length; i++){  
    3. 
  
  
  
  3.        //do something here;  
    4. 
  
  
  
  4.     }  
    5. 
  
  
  
  5.     //此时的i为未定义  
    6. 
  
  
  
  6.     for(int i = 0; i < obj2.length; i++){  
    7. 
  
  
  
  7.        //do something else;  
    8. 
  
  
  
  8.     }    
    9. 
  
  
  
  9. } 
    10.

而在JavaScript中：

 
 
 
    
  
  
  
  1. function func(){  
    2. 
  
  
  
  2.     for(var i = 0; i < array.length; i++){  
    3. 
  
  
  
  3.        //do something here.  
    4. 
  
  
  
  4.     }  
    5. 
  
  
  
  5.     //此时i仍然有值，及I == array.length  
    6. 
  
  
  
  6.     print(i);//i == array.length;  
    7. 
  
  
  
  7. } 
    8.

JavaScript的函数是在局部作用域内运行的，在局部作用域内运行的函数体可以访问其外层的(可能是全局作用域)的变量和函数。JavaScript的作用域为词法作用域，所谓词法作用域是说，其作用域为在定义时(词法分析时)就确定下来的，而并非在执行时确定，如下例：

 
 
 
    
  
  
  
  1. var str = "global";  
    2. 
  
  
  
  2. function scopeTest(){  
    3. 
  
  
  
  3.     print(str);  
    4. 
  
  
  
  4.     var str = "local";  
    5. 
  
  
  
  5.     print(str);  
    6. 
  
  
  
  6. }  
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8. scopeTest(); 
    9.

运行结果是什么呢?初学者很可能得出这样的答案：

global
local

而正确的结果应该是：

undefined
local

因为在函数scopeTest的定义中，预先访问了未声明的变量str，然后才对str变量进行初始化，所以***个print(str)会返回undifined错误。那为什么函数这个时候不去访问外部的str变量呢?这是因为，在词法分析结束后，构造作用域链的时候，会将函数内定义的var变量放入该链，因此str在整个函数scopeTest内都是可见的(从函数体的***行到***一行)，由于str变量本身是未定义的，程序顺序执行，到***行就会返回未定义，第二行为str赋值，所以第三行的print(str)将返回”local”。

#p#

函数上下文

在Java或者C/C++等语言中，方法(函数)只能依附于对象而存在，不是独立的。而在JavaScript中，函数也是一种对象，并非其他任何对象的一部分，理解这一点尤为重要，特别是对理解函数式的JavaScript非常有用，在函数式编程语言中，函数被认为是一等的。

函数的上下文是可以变化的，因此，函数内的this也是可以变化的，函数可以作为一个对象的方法，也可以同时作为另一个对象的方法，总之，函数本身是独立的。可以通过Function对象上的call或者apply函数来修改函数的上下文：

call和apply

call和apply通常用来修改函数的上下文，函数中的this指针将被替换为call或者apply的***个参数，我们不妨来看看JavaScript入门之对象与JSON中的例子：

 
 
 
    
  
  
  
  1. //定义一个人，名字为jack  
    2. 
  
  
  
  2. var jack = {  
    3. 
  
  
  
  3.     name : "jack",  
    4. 
  
  
  
  4.     age : 26  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6.    
    7. 
  
  
  
  7. //定义另一个人，名字为abruzzi  
    8. 
  
  
  
  8. var abruzzi = {  
    9. 
  
  
  
  9.     name : "abruzzi",  
    10. 
  
  
  
  10.     age : 26  
    11. 
  
  
  
  11. }  
    12. 
  
  
  
  12.    
    13. 
  
  
  
  13. //定义一个全局的函数对象  
    14. 
  
  
  
  14. function printName(){  
    15. 
  
  
  
  15.     return this.name;  
    16. 
  
  
  
  16. }  
    17. 
  
  
  
  17.    
    18. 
  
  
  
  18. //设置printName的上下文为jack, 此时的this为jack  
    19. 
  
  
  
  19. print(printName.call(jack));  
    20. 
  
  
  
  20. //设置printName的上下文为abruzzi,此时的this为abruzzi  
    21. 
  
  
  
  21. print(printName.call(abruzzi));  
    22. 
  
  
  
  22.    
    23. 
  
  
  
  23. print(printName.apply(jack));  
    24. 
  
  
  
  24. print(printName.apply(abruzzi)); 
    25.

只有一个参数的时候call和apply的使用方式是一样的，如果有多个参数：

 
 
 
    
  
  
  
  1. setName.apply(jack, ["Jack Sept."]);  
    2. 
  
  
  
  2. print(printName.apply(jack));  
    3. 
  
  
  
  3.    
    4. 
  
  
  
  4. setName.call(abruzzi, "John Abruzzi");  
    5. 
  
  
  
  5. print(printName.call(abruzzi)); 
    6.

得到的结果为：

 
 
 
    
  
  
  
  1. Jack Sept.  
    2. 
  
  
  
  2. John Abruzzi 
    3.

apply的第二个参数为一个函数需要的参数组成的一个数组，而call则需要跟若干个参数，参数之间以逗号(,)隔开即可。

使用函数

前面已经提到，在JavaScript中，函数可以

◆ 被赋值给一个变量

◆ 被赋值为对象的属性

◆ 作为参数被传入别的函数

◆ 作为函数的结果被返回

我们就分别来看看这些场景：

赋值给一个变量：

 
 
 
    
  
  
  
  1. //声明一个函数，接受两个参数，返回其和  
    2. 
  
  
  
  2. function add(x, y){  
    3. 
  
  
  
  3.     return x + y;  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5.    
    6. 
  
  
  
  6. var a = 0;  
    7. 
  
  
  
  7. a = add;//将函数赋值给一个变量  
    8. 
  
  
  
  8. var b = a(2, 3);//调用这个新的函数a  
    9. 
  
  
  
  9. print(b); 
    10.

这段代码会打印”5”，因为赋值之后，变量a引用函数add，也就是说，a的值是一个函数对象(一个可执行代码块)，因此可以使用a(2, 3)这样的语句来进行求和操作。

赋值为对象的属性：

 
 
 
    
  
  
  
  1. var obj = {  
    2. 
  
  
  
  2.     id : "obj1" 
    3. 
  
  
  
  3. }  
    4. 
  
  
  
  4.    
    5. 
  
  
  
  5. obj.func = add;//赋值为obj对象的属性  
    6. 
  
  
  
  6. obj.func(2, 3);//返回5 
    7.

事实上，这个例子与上个例子的本质上是一样的，***个例子中的a变量，事实上是全局对象(如果在客户端环境中，表示为window对象)的一个属性。而第二个例子则为obj对象，由于我们很少直接的引用全局对象，就分开来描述。

作为参数传递：

 
 
 
    
  
  
  
  1. //高级打印函数的第二个版本  
    2. 
  
  
  
  2. function adPrint2(str, handler){  
    3. 
  
  
  
  3.     print(handler(str));  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5.    
    6. 
  
  
  
  6. //将字符串转换为大写形式，并返回  
    7. 
  
  
  
  7. function up(str){  
    8. 
  
  
  
  8.     return str.toUpperCase();  
    9. 
  
  
  
  9. }  
    10. 
  
  
  
  10.    
    11. 
  
  
  
  11. //将字符串转换为小写形式，并返回  
    12. 
  
  
  
  12. function low(str){  
    13. 
  
  
  
  13.     return str.toLowerCase();  
    14. 
  
  
  
  14. }  
    15. 
  
  
  
  15.    
    16. 
  
  
  
  16. adPrint2("Hello, world", up);  
    17. 
  
  
  
  17. adPrint2("Hello, world", low); 
    18.

运行此片段，可以得到这样的结果：

HELLO, WORLD
hello, world

应该注意到，函数adPrint2的第二个参数，事实上是一个函数，将这个处理函数作为参数传入，在adPrint2的内部，仍然可以调用这个函数，这个特点在很多地方都是有用的，特别是，当我们想要处理一些对象，但是又不确定以何种形式来处理，则完全可以将“处理方式”作为一个抽象的粒度来进行包装(即函数)。

作为函数的返回值：

先来看一个最简单的例子：

 
 
 
    
  
  
  
  1. function currying(){  
    2. 
  
  
  
  2.     return function(){  
    3. 
  
  
  
  3.        print("curring");  
    4. 
  
  
  
  4.     }  
    5. 
  
  
  
  5. } 
    6.

函数currying返回一个匿名函数，这个匿名函数会打印”curring”，简单的调用currying()会得到下面的结果：

 
 
 
    
  
  
  
  1. function (){  
    2. 
  
  
  
  2.     print("curring");  
    3. 
  
  
  
  3. } 
    4.

如果要调用currying返回的这个匿名函数，需要这样：

 
 
 
    
  
  
  
  1. currying()(); 
    2.

***个括号操作，表示调用currying本身，此时返回值为函数，第二个括号操作符调用这个返回值，则会得到这样的结果：

currying

原文：http://abruzzi.iteye.com/blog/646798

【系列文章】

JavaScript入门之对象与JSON

JavaScript概述

JavaScript内核之基本概念

网页名称：JavaScript入门之基本函数
文章转载：http://www.shufengxianlan.com/qtweb/news40/274340.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

面包屑导航知识

分类信息网

成都温江机房　　 　成都商城开发　　 　营销型网站建设　　 　ssl数字证书　　 　成都广告设计　　 　高防机房　　 　外贸网站建设　　 　成都网站改版　　 　广东帝美豪门窗　　 　成都小程序开发　　 　温江网站制作　　 　品牌设计　　 　达州电信机房　　 　乐山中领科信　　 　成都做网站　　 　内江托管服务器　　 　中建建业环保　　 　成都众诚伟业　　 　教育培训网站建设方案　　 　成都网站建设