NodeJs 기본 구문 및 유형 소개

이 글은 NodeJ의 기본 구문과 종류에 대한 관련 정보를 주로 소개하고 있으니 필요하신 분들은 참고하셔도 됩니다.

앞에 쓰기#🎜🎜 ##🎜 🎜#오늘은 Node 종류에 대한 지식을 확인하고 싶어서 정리해보려고 합니다. Googol에서 기사를 봤는데, 스냅샷에 이 기사가 더 이상 나오지 않습니다. 원저자에게 질문이 있으시면 저에게 연락해주세요!

이 기사는 JS의 기본에 관한 모든 내용이므로 전문가는 자동으로 건너뛸 것입니다! 나는 이전에 js에 대해 많이 쓰지 않았고 상대적으로 이 분야에 약해서 node를 작성할 때 어려움을 겪었습니다. 여기에 나 자신을 위한 지식이 있습니다!

Text

Node.js는 JavaScript 스크립팅 언어를 기반으로 합니다. 대부분의 스크립팅 언어의 일반적인 특징은 "약한 타이핑"입니다.

PHP와 달리 PHP는 새 변수가 있어도 새 변수를 선언할 필요가 없지만 JavaScript에서는 변수를 선언하기 위해 여전히 var가 필요합니다. 그리고 이 var는 C++의 int, string, char 등과 같은 모든 유형, 심지어 함수의 의미도 포괄합니다.

이 기사와 다음 기사의 모든 내용은 Linux 또는 Cygwin에서 vim을 사용하여 편집한 다음(그렇지 않은 경우 자신만의 방법으로 변환하세요) 명령줄에서 결과를 확인하세요.

기본 구문

변수 선언

C/C++에서 우리는 다음과 같이 변수를 선언합니다:

"C++

void foo() {}
int a = 0;
char b = 'a';
float c = 1.0f;
void (*d)() = foo; ///< 忘了是不是这么写的了，总之是函数指针

그리고 Node.js에서는 다음과 같습니다:

"javascript

function foo() {}
var a = 0;
var b = 'a';
var c = 1.0;
var d = foo;

#🎜🎜 #그래서, 어떤 변수든 Node.js에서는 var로 해결됩니다.

Loop 문

for…i

이 루프 문은 기본적으로 C/C++와 동일합니다. # 🎜🎜#

"C++

for(int i = 0; i < foo; i++)
{
//...
}

Node.js는 약한 형식이므로 다음만 필요합니다.

"javascript

for(var i = 0; i < foo; i++) {
    //...
}
for…in

이것은 A 형식입니다. PHP의 foreach와 유사한 루프 문입니다.

예를 들어 다음과 같은 JSON 개체가 있습니다.

javascript

var foo = {
    "hello"     : "world",
    "node"      : "js",
    "blahblah"  : "bar"
};

이제 for...in을 사용하여 루프를 만들 수 있습니다. 통해:

javascript

for(var key in foo) {
    console.log(key + ": " + foo[key]);
}

명령줄에 다음 명령을 입력하면:

$ node foo.js

다음 내용이 화면에 표시됩니다. # 🎜🎜#

hello
: world
node: js
blahblah: bar

Tip: 위에서 볼 수 있듯이 for...in 문은 JSON 객체, 배열, 객체의 키 이름을 순회하는 데 사용되지만 키 값의 순회는 제공하지 않습니다. . 키 값을 얻으려면 foo[<현재 키 이름>] 형식으로만 얻을 수 있습니다. 이는 PHP의 foreach와 다소 다릅니다.

while…do, do…whill

이건 많이 설명하지 않겠습니다. 다른 언어와 크게 다르지는 않습니다. 변수 선언이 있으면 var이면 충분합니다.

operator

+, -, *, /

이것은 여러 연산자에 대해 주의해야 할 것은 +입니다. 문자열과 숫자 연산 모두에서 작동할 수 있습니다. 약한 유형의 언어는 유형이 약하다고 말하지만 숫자가 문자열의 형태로 나타날 수도 있고 문자열이 숫자 값의 형태로 나타날 수도 있습니다. 그러나 필요한 경우에는 여전히 그것이 어떤 유형인지 말해야 합니다. 다음 코드를 사용하여 결과를 볼 수 있습니다.

var a = "1";
var b = 2;
console.log(a + b);
console.log(parseInt(a) + b);

여기서parseInt는 문자열을 int 유형의 변수로 구문 분석하는 데 사용되는 Node.js의 내장 함수입니다.

위 코드의 실행 결과는 다음과 같습니다.

12
3

참고: 첫 번째 console.log 결과는 12입니다. a는 문자열이므로 b도 문자열로 처리됩니다. 시스템에 의해 결과적으로 두 줄이 서로 접착되어 12가 됩니다. 두 번째 console.log 결과는 첫 번째 a를 int 유형으로 변환했기 때문에 3입니다. 두 개의 int 유형 변수를 추가하면 결과는 당연히 3입니다.

==, ===, !=, !==

여기서 설명할 것이 하나 있는데, 언제 이 논리는 연산자 길이가 2(==, !=)인 경우 외부 값이 동일한지 여부만 판단할 뿐, 유형을 판단하지는 않습니다. 예를 들어

var a = 1, b = "1";
console.log(a == b);

출력 결과는 true입니다. 하지만 판단 중간에 등호를 추가하면 유형과 값이 동일할 때만 참이고, 그렇지 않으면 거짓입니다. 즉,

var a = 1, b = "1";
console.log(a === b);

일 때 a는 int 유형이고 b는 문자열이기 때문에 반환된 결과는 false입니다.

그런데 조건문에 대해 이야기해 볼까요. 사실 여기도 다른 언어와 별반 차이가 없다면 두 개의 등호와 세 개의 등호만 있으면 됩니다. 그래서 너무 자세히 설명하지는 않겠습니다.

typeof

여기에서는 함수가 아닌 연산자로 처리하겠습니다.

이 연산자의 기능은 변수의 유형을 결정하는 것입니다. 이는 문자열, 즉 유형 이름을 반환합니다.

function foo() {}
var a = 0;
var b = '嘘~蛋花汤在睡觉。';
var c = 1.0;
var d = foo;
var e = { "a" : a };
var f = [ 1, 2, 3 ];
var g = null;
var h = undefined;
console.log(typeof a);
console.log(typeof b);
console.log(typeof c);
console.log(typeof d);
console.log(typeof e);
console.log(typeof f);
console.log(typeof g);
console.log(typeof h);

여기서 실행 결과는 다음과 같습니다:

number
string
number
function
object
object
object
undefined

null, undefine, NaN

In JavaScript에는 제목에 표시된 것처럼 세 가지 특수 값이 있습니다. 첫 번째는 C/C++에서도 찾아볼 수 있지만 그 본질은 "C++

define NULL 0

입니다. JavaScript, 이 세 가지 값은 서로 다른 의미를 갖습니다

### null ###

.

null 是一种特殊的 object，大致的意思就是空。比如说：

var a = null;

大家都能看懂，就不多做解释了。但是跟 C/C++ 不同的是，这个 null 跟 0 不相等。

### undefined ###

这个东西的意思就是说这个变量未声明。为了能够更好地区分 null，我们的样例代码如下写：

"javascript

var a = {
    "foo" : null
};
console.log(a["foo"]);
console.log(a["bar"]);

上面的代码中，我们让 a["foo"] 的值为空，即 null。而压根没有声明 a["bar"] 这个东西，它连空都不是。输出的结果大家都差不多应该猜到了：

null
undefined
NaN

这是一个空的数值，是一个特殊的 number。它的全称是 Not a Number。有点奇怪，大家可以理解为 不是数字形态，或者数值出错的 number 类型变量。

多在浮点型数值运算错误（如被0除）的情况下出现，甚至可以是用户自己让一个变量等于 NaN 以便返回一个错误值让大家知道这个函数运算出错了云云。

小杂碎

其它剩余的语句也跟已存在的其它语言差不多，比如说 break 啊、switch 啊、continue 啊等等等等。

变量类型

这一节主要讲的是 JavaScript 对象，其它类型差不多一带而过吧。

基础类型

Node.js 包含的基础类型差不多有如下几个：

number
string
boolean
array
其中前三种类型可以直接赋值， 而 array 的赋值只是一个引用赋值而已，在新变量中改变某个值的话旧变量的值也会改变 ，直接可以试试下面的代码：

javascript
var foo = [ 1, 2, 3 ];
var bar = foo;
bar[0] = 3;
console.log(foo);

它得出的结果是：

javascript
[ 3, 2, 3 ]

也就是说 array 要是复制出一个新的数组的话，不能用直接赋值的方法，而必须“深拷贝”。

这里有必要讲一下 array 的三种创建方法。

第一种：

javascript

var dog = new Array();
dog[0] = "嘘~";
dog[1] = "蛋花汤";
dog[2] = "在睡觉";

第二种：

javascript

var dog = new Array( "嘘~", "蛋花汤", "在睡觉" );

第四种：

javascript

var dog = [
    "嘘~",
    "蛋花汤",
    "在睡觉"
];

我个人比较喜欢第三种写法，比较简洁。

JSON对象

这里我把 JSON对象 单独拎出来而不是把它归类为 JavaScript对象，如果觉得我有点误人子弟就可以直接跳过这一节了。

本人对于 JSON对象 和 JavaScript 对象的区分放在 是否只用来存储数据，而并非是一个类的实例化。其实 JSON 的本质便是 JavaScript Object Notation。

更多有关 JSON 的信息请自行百科。

在 Node.js 中声明一个 JSON对象 非常简单：

javascript

var dog = {
  "pre" : "嘘~",
  "sub" : {
    "name" : "蛋花汤",
    "act"  : "在睡觉",
    "time" : 12
    },
  "suf" : [ "我说了", "它在睡觉", "就是在睡觉" ]
};

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

javascript

dog
.pre;
dog["pre"];

注意：上面在用点的时候，后面直接跟的是JSON中的key，如果把key当成是变量去当问，只能用dog[key]试试看：现在你自己动手试试看，用 for...in 的形式遍历一遍上面的 JSON对象。别忘了用上 typeof 喵~

类（对象）的基础

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

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

因为类有着很多 函数 的特性，或者说它的本质就是一个 函数，所以这里面我们可能一不留神就顺带着把函数基础给讲了。

类的声明和实例化

声明一个类非常简单，大家不要笑：

javascript
function foo() {
    //...
}

好了，我们已经写好了一个 foo 类了。

真的假的？！真的。

不信？不信你可以接下去打一段代码看看：

javascript
var bar = new foo();
别看它是一个函数，如果以这样的形式（new）写出来，它就是这个类的实例化。

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

成员变量

成员变量有好两种方法。

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

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

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

第二种方法就是在构造函数或者任何成员函数外部声明，其格式是 <类名>.prototype.<变量名>：

javascript

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

无论上面哪种方法都是对成员变量的声明，我们可以看看效果：

javascript

var bar = new foo();
console.log(bar.hello);

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

javascript

function foo() {
    this.hello = "world";
}
foo.prototype.hello = "蛋花汤";

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

想想看为什么输出的还是 world 而不是 蛋花汤。

构造函数

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

javascript

// 代码2.1
function foo(hello) {
    if(hello === undefined) {
        this.hello = "world";
    } else {
        this.hello = hello;
    }
}

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

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

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

javascript

// 上接代码2.1
var bar1 = new foo();
var bar2 = new foo("蛋花汤");

请自行输出一下两个 bar 的 hello 变量，会发现一个是 world 一个是 蛋花汤。显而易见，我们的第一个 bar1 在声明的时候，被 Node.js 自动看成了：

javascript

var bar1 = new foo(undefined);

所以就有了它是 world 一说。

还有就是在这个构造函数中，我们看到了传进去的参数是 hello 而这个类中本来就有个成员变量就是 this.hello。不过我们之前说过了有 this 和没 this 的时候作用域不同，那个参数只是作用于构造函数中，而加了 this 的那个则是成员变量。用一个 this 就马上区分开来他们了，所以即使同名也没关系。

成员函数

成员函数声明

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

javascript

// 上接代码2.1
function setHello(hello) {
  this.hello = hello;
}
foo.prototype.setHello = setHello;
bar1.setHello("鸡蛋饼");

上面这段代码显而易见，我们实现了 foo 类的 setHello 函数，能通过它修改 foo.hello 的值。

但是这么写是不是有点麻烦？接下去我要讲一个 JavaScript 函数重要的特性了。

★ 匿名函数 ★

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

javascript

function(hello) {
    this.hello = hello;
}

至于怎么引用或者调用呢？如果是上面的那个类需要引用的话，就是写成这样的：

javascript

foo.prototype.setHello = function(hello) {
    this.hello = hello;
}

这样的写法跟 成员函数 声明 是一个效果的，而且省了很多的代码量。而且实际上，基本上的类成员函数的声明都是采用这种匿名函数的方式来声明的。

至于说怎么样让匿名函数被调用呢？这通常用于传入一个只被某个函数调用的函数时这样写。

比如我们有一个函数的原型是：

javascript

/**
 * 我们将传入a，b两个变量，
 * 在算出a+b的值后，交由func(num)
 * 去进行输出
 */
function sumab(a, b, func) {
    var c = a + b;
    func(a, b, c);
}

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

javascript

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
这样的代码如果采用匿名函数的形式则将会是：

javascript

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);
});

这种形式通常使用于回调函数。回调机制算是 Node.js 或者说 JavaScript 的精髓。在以后的篇章会做介绍。

成员函数声明的匿名函数声明方式

虽然上一节讲过了，不过还是再讲一遍吧。

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

javascript

// 上接代码2.1
foo.prototype.setHello = function(hello) {
    this.hello = hello;
}

这样我们就使得 foo 类有了 setHello 这个函数了。

2.3.4. 类的随意性

这个又是我胡扯的。所谓类的随意性即 JavaScript 中你可以在任何地方修改你的类，这跟 Ruby 有着一定的相似之处。

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

javascript

String.prototype.sb = function() {
  var newstr = "";
  for(var i = 0; i < this.length; i++) {
    if(i % 2 === 0) newstr += "s";
    else newstr += "b";
  }
  return newstr;
};

这个函数的意思就是填充一个字符串，使其变成 sb 的化身。

我们来测试一下：

var str = "嘘~蛋花汤在睡觉。";
console.log(str.sb());

你将会得到这样的结果：

sbsbsbsbs
你跟你的电脑说“嘘~蛋花汤在睡觉。”，你的电脑会骂你四次半傻逼。（赶快砸了它）

3. 附

3.1. 深拷贝

所谓深拷贝就是自己新建一个数组或者对象，把源数组或者对象中的基础类型变量值一个个手动拷过去，而不是只把源数组或者对象的引用拿过来。所以这就涉及到了一个递归的调用什么的。

下面是我实现的一个深拷贝函数，大家可以写一个自己的然后加入到自己的 Node.js 知识库中。

javascript

function cloneObject(src) {
  var dest = {};
  for(var key in src) {
    if(typeof src === "object") dest[key] = cloneObject(src[key]);
    else dest[key] = src[key];
  }
  return dest;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

如何快速使用node.js进行web开发

关于NodeJS、NPM安装配置步骤(windows版本) 以及环境变量的介绍

위 내용은 NodeJs 기본 구문 및 유형 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!