（四）nodejs循序渐进-函数,类和对象（基础篇）

小鱼儿 2022-12-22 09:24 307阅读 0赞

上一篇文章讲到了基本数据类型和运算符，相信大家都能做简单的运算，本篇文章将讲述函数，类，对象。

# 函数 #

在nodejs中，一个函数可以作为另一个函数的参数。我们可以先定义一个函数，然后传递，也可以在传递参数的地方直接定义函数。Node.js 中函数的使用与 JavaScript 类似，举例来说，你可以这样做：

function say(word) {
      console.log(word);
    }
    
    function execute(someFunction, value) {
      someFunction(value);
    }
    
    execute(say, "Hello");

以上代码中，我们把 say 函数作为 execute 函数的第一个变量进行了传递。这里传递的不是 say 的返回值，而是 say 本身！

这样一来， say 就变成了execute 中的本地变量 someFunction ，execute 可以通过调用 someFunction() （带括号的形式）来使用 say 函数。

当然，因为 say 有一个变量， execute 在调用 someFunction 时可以传递这样一个变量。

# 匿名函数 #

很多时候我们的某些函数只在一个地方被引用或者调用，那么我们为这个函数起一个名字就太不值了，没必要，所以我们可以临时写好这个函数，直接让引用它的人引用它，调用它的人调用它。所以函数可以省略函数名。

我们可以把一个函数作为变量传递。但是我们不一定要绕这个"先定义，再传递"的圈子，我们可以直接在另一个函数的括号中定义和传递这个函数：

function execute(someFunction, value) {
      someFunction(value);
    }
    
    execute(function(word){ console.log(word) }, "Hello");

我们在 execute 接受第一个参数的地方直接定义了我们准备传递给 execute 的函数。

用这种方式，我们甚至不用给这个函数起名字，这也是为什么它被叫做匿名函数 。

比如我们有两个版本的输出函数，一个是中文输出，一个是英文输出，那么如果不用匿名函数时候是这么写的：

function zh(a, b, sum) {
        console.log(a + " + " + b + " 的值是：" + sum);
    }
    
    function en(a, b, sum) {
        console.log(a + " plus " + b + " is " + sum);
    }
    
    sumab(1, 2, zh);
    sumab(3, 4, en);

执行一遍这段代码，输出的结果将会是：

1 + 2 的值是：3
    3 plus 4 is 7

这样的代码如果采用匿名函数的形式则将会是：

sumab(1, 2, function(a, b, sum) {
        console.log(a + " + " + b + " 的值是：" + sum);
    });
    sumab(3, 4, function(a, b, sum) {
        console.log(a + " plus " + b + " is " + sum);
    });

这种形式通常使用于回调函数。回调机制算是 nodejs** **的精髓。在以后的篇章会做介绍。

# JSON对象 #

json是我们常用的轻量级数据交换结构，它在这里并不是通过类实例化的对象，所以我这里把它单独提出来。

声明一个 JSON对象 非常简单：

var player = {
        "user_id"     : "1927u893233c2993u429o34",
        "user_name"   : "高司机",
        "gender"      : "man",
        "age"         : 18,
        "level"       : 2,
        "viplevel"    : 0,
        "exp"         : 23933,
        "section"     : 12,
        "achievement" : null,
        "resetinfo"       : {
            "dailyreset_time"  : "20201122000000",
            "prayreset_time"   : "20201122030000", 
        }
    };
    
    console.log("userid:"+player.user_id);
    console.log("userid:"+player["user_id"]);

有两种方式能得到 **JSON对象** 中的某个键名的键值，第一种是用点连接，第二种是用中括号.

# 类 #

严格意义上来讲，nodejs的类不能算是类，其实它只是一个函数的集合体，加一些成员变量。它的本质其实是一个函数。

不过为了通俗地讲，我们接下去以及以后都将其称为“类”，实例化的叫“对象”。

因为类有着很多函数的特性，或者说它的本质就是一个函数,这个需要大家和其他C++，java语言要区别开，不要以为只有用class声明的才是类，不信你看下面：

## 函数的方式定义类 ##

### 声明类 ###

这里我用函数的特性来声明一个类

function fun() {
        console.log("hello world");
    }

好了，我们已经写好了一个fun类了。请继续保持怀疑的心态来看这段代码：

var fun1 = new fun();

别看它是一个函数，如果以这样的形式new写出来，它就是这个类的实例化。

而这个所谓的fun()其实就是这个fun()类的构造函数。

成员变量有好两种方法。

**第一种**就是在类的构造函数或者任何构造函数中使用 `this.<变量名>` 。你可以在任何时候声明一个成员变量，在外部不影响使用，反正就算在还未声明的时候使用它，也会有一个 `undefined` 来撑着。所以说这就是第一种方法：

function foo() {
        this.hello = "world";
    }

**注意**：只有在加了 `this` 的时候才是调用类的**成员变量**，否则只是函数内的一个局部变量而已。要分清楚有没有 `this` 的时候变量的作用范围。二话不说看代码：

function fun(){
            this.data = "this.data";
            var data = "local data";
            console.log("data:"+this.data);
            console.log("data:"+data);
    }
    var fun1 = new fun();

输出什么内容呢，请思考下再看结果。

**第二种**方法就是在构造函数或者任何成员函数外部声明，prototype 属性使您有能力向对象添加属性和方法。其格式是 `<类名>.prototype.<变量名>`：

function fun() { 
    }
    
    fun.prototype.print = "member value：this.print";
    var fun1 = new fun();
    console.log(fun1.print);

甚至你可以这么修改这个类：

function fun() {
        this.print = "in fun call print";
    }
    
    fun.prototype.print = "hello world";
    var fun1 = new fun();
    console.log(fun1.print);

然后再用上面的代码输出。

但是不如你所愿，你期望输出“hello world”，但是输出的是"in fun call print"，不要着急，等看完下面你就会有答案了，如果你还不懂，请在文章下方留言。

### 构造函数  ###

我们之前说过了这个fun()实际上是一个构造函数。那么显然我们可以给构造函数传参数，所以就有了下面的代码：

function fun(param) {
        if(param === undefined) {
            this.print = "hello wolrd";
        } else {
            this.print = param;
        }
    }

我们看到上面有一个奇葩的判断 `if(hello === undefined)`，这个判断有什么用呢？第一种可能，就是开发者很蛋疼地特意传进去一个 `undefined` 进去，这个时候它是 `undefined` 无可厚非。

还有一种情况。我们一开始就说了 JavaScript 是一门弱类型语言，其实不仅仅是弱类型，它的传参数也非常不严谨。你可以多传或者少传（只要保证你多传或者少传的时候可以保证程序不出错，或者逻辑不出错），原则上都是可以的。多传的参数会被自动忽略，而少传的参数会以 `undefined` 补足。

看看下面的代码就明白了：

var fun1 = new fun("hello");
    console.log(fun1.print);
    var fun2 = new fun();
    console.log(fun2.print);

输出结果是：

hello
    hello wolrd

显而易见，我们的fun2在声明的时候，被解释成

var fun2 = new fun(undefined);

###  成员函数 ###

成员函数的声明跟成员变量的第二种声明方法差不多，即 `<类名>.prototype.<函数名> = <函数>;`

上面这段代码显而易见，我们实现了fun类的Print函数，能通过它修改fun.print的值，所以输出结果为：

不好意思，我这里写个BUG

通常我们声明类的成员函数时候都是用匿名函数来声明的，因为反正那个函数也就是这个类的一个成员函数而已，不会在其它地方被单独引用或者调用，所以就有了下面的代码：

## class传统方式定义类 ##

class Rect {
        //构造函数
        constructor(w, h) {
            this.width = w;
            this.height = h;
        }
        //类成员函数
        toString() {
            return '(' + this.width + ', ' + this.height + ')';
        }
       //类静态成员函数
        static setParam(name){
            //修改类静态成员变量
            this.para = name;
            return   this.para;
        }
    }
    //初始化类静态成员变量
    Rect.para = 'hello world';
    
    //新创建Rect对象
    var rect = new Rect(1024, 960);
    console.log(rect.toString());
    console.log(Rect.para);
    console.log(Rect.setParam('高司机'));
    console.log(Rect.para);

好了，这代码块相信你应该看的懂（如果不懂可以继续给我留言，我将完善尽可能让更多的人没有阅读理解障碍。），类静态成员函数也是通过static来修饰，静态成员也是在类外部进行声明并初始化。构造函数一般是通过constructor来声明。

光会写这块代码，我相信你肯定不满足，那么我们继续根据这个代码做变化，更加熟悉nodejs的类：

### **1.能不能有多个构造函数呢？** ###

相信你已经跃跃欲试了

class Rect {
        constructor(w, h) {
            this.width = w;
            this.height = h;
        }
        constructor(w, h, z) {
            this.width = w;
            this.height = h;
        }
    
        Rect(){
            console.log("call Rect\n");
            }
        toString() {
            return '(' + this.width + ', ' + this.height + ')';
        }
        static setParam(name){
            this.para = name;
            return this.para;
        }
    }
    Rect.para = 'hello world';
    
    var rect = new Rect(1024, 960);
    console.log(rect.toString());
    console.log(Rect.para);
    console.log(Rect.setParam('高司机'));
    console.log(Rect.para);

然鹅，实际运行中报错了：

/root/app1.js:7
        constructor(w, h, y) {
        ^^^^^^^^^^^
    
    SyntaxError: A class may only have one constructor
        at createScript (vm.js:56:10)
        at Object.runInThisContext (vm.js:97:10)
        at Module._compile (module.js:549:28)
        at Object.Module._extensions..js (module.js:586:10)
        at Module.load (module.js:494:32)
        at tryModuleLoad (module.js:453:12)
        at Function.Module._load (module.js:445:3)
        at Module.runMain (module.js:611:10)
        at run (bootstrap_node.js:394:7)
        at startup (bootstrap_node.js:160:9)

所以呀nodejs的类只有一个构造函数

###  2.能不能像C++一样通过类名这样的方式声明一个构造函数 ###

比如：

class Rect {
    
        Rect(){
            console.log("call Rect");
        }
        toString() {
            return '(' + this.width + ', ' + this.height + ')';
        }
        static setParam(name){
            this.para = name;
            return this.para;
        }
    }
    Rect.para = 'hello world';
    
    var rect = new Rect();
    rect.Rect();

你会发现实际上 var rect = new Rect()并不会调用Rect函数，而只有rect.Rect（）才会调用Rect方法。

### 3.如果创建对象的时候传入构造函数的参数少呢？ ###

class Rect {
        constructor(w, h) {
            this.width = w;
            this.height = h;
            console.log("call  constructor\n");
        }
    
        Rect(){
            console.log("call Rect\n");
            }
        toString() {
            return '(' + this.width + ', ' + this.height + ')';
        }
        static setParam(name){
            this.para = name;
            return this.para;
        }
    }
    Rect.para = 'hello world';
    
    var rect = new Rect(1024);
    console.log(rect.toString());

输出的结果：

call  constructor
    
    (1024, undefined)

# 类的自由性 #

所谓类的自由性即你可以在任何地方修改你的类，比如说 S`tring`类，有着诸如 `length` 这样的成员变量，也有 `indexOf`、`substr` 等成员函数。但是万一我们觉得这个 `string` 有些地方不完善，想加自己的方法，那么可以在你想要的地方给它增加一个函数，比如：

String.prototype.fun = function() {
         return "hello world";
    };

这个string类的fun函数的意思就是返回hello world。

我们来测试一下：

var str = "高司机又要开始写bug了";
    console.log(str.fun());

你将会得到这样的结果：

hello world