js教程

理解什么是Node.js?

零下一度

Jun 26, 2017 am 11:47 AM

javascriptnode.js学习教程

理解Node.js

为了理解Node.js是如何工作的，首先你需要理解一些使得Javascript适用于服务器端开发的关键特性。Javascript是一门简单而又灵活的语言，这种灵活性让它能够经受住时间的考验。函数、闭包等特性使Javascript成为一门适合Web开发的理想语言。

有一种偏见认为Javascript是不可靠的，然而事实并非如此。人们对Javascript的偏见来源于DOM,DOM是浏览器厂商提供的用于Javascript与浏览器交互的API，不同浏览器厂商实现的DOM存在差异。然而，Javascript本身是一门定义清晰的语言，可以在不同的浏览器及Node.js中运行。本节，我会先介绍一些Javascript的基础以及Node.js是如何使用Javascript提供了一个性能优异的Web开发平台。

变量

Javascript使用var关键字定义变量。例如下面的代码创建了一个名为foo的变量，并在命令行中输出。(可以通过node variable.js在命令行中执行下面的代码文件。)

代码文件 variable.js

var foo = 123;console.log(foo); // 123

Javascript运行环境（浏览器或者Node.js）通常会定义一些我们可以使用的全局变量，例如console对象，console对象包含一个成员函数log，log函数能够接受任意数量的参数并输出它们。我们接下来会遇到更多的全局对象，你将会发现，Javascript具有一个优秀的编程语言应该包含的大部分特性。

数值

Javascript支持常见的算数操作符（+，-，*，/，%）。例如下列代码：

var foo = 3;
var bar = 5;
console.log(foo+1); //4
console.log(foo / bar); //0.6
console.log(foo * bar); //15
console.log(foo - bar); //-2
console.log(foo % 2); //取余：1

布尔值

布尔值包括true和false。你可以给变量赋值为true或false，并对其进行布尔操作。例如下列代码：

var foo = true;
console.log(foo); //true//常见的布尔操作符号: &&，||， !
console.log(true && true); //true
console.log(true && false); /false
console.log(true || false); //true
console.log(false || false); //false
console.log(!true); //false
console.log(!false); //true

数组

在Javascript中，我们可以通过[]创建数组。数组对象包含很多有用的函数，例如下列代码所示：

var foo = [];

foo.push(1); //添加到数组末尾
console.log(foo); // [1]

foo.unshift(2);  //添加到数组头部
console.log(foo); // [2, 1]//数组起始位置从0开始
console.log(foo[0]); // 2

对象字面量

Javascript中通常使用对象字面量{}创建对象，例如下列代码所示：

var foo = {};
console.log(foo); // {}
foo.bar = 123;
console.log(foo); // {bar: 123}

上面的代码在运行时添加对象属性，我们也可以在创建对象时定义对象属性：

var foo = {  bar: 123
};
console.log(foo); // {bar: 123}

对象字面量中可以嵌套其它对象字面量，例如下列代码所示：

var foo = {
  bar: 123,
  bas: {
    bas1: &#39;some string&#39;,
    bas2: 345
  }
};
console.log(foo);

当然，对象字面量中也可以包含数组：

var foo = {  bar: 123,  bas: [1,2,3]
};
console.log(foo);

数组当中也可以包含对象字面量：

var foo = {  bar: 123,  bas: [{      qux: 1
    },
    {      qux: 2
    },
    {      qux: 3
    }]
};
console.log(foo.bar); //123
console.log(foo.bas[0].qux); // 1
console.log(foo.bas[2].qux); // 2

函数

Javascript的函数非常强大，我们接下来将通过一系列的例子来逐渐了解它。
通常情况下的Javascript函数结构如下所示：

function functionName(){  //函数体
}

Javascript的所有函数都有返回值。在没有显式声明返回语句的情况下，函数会返回undefined。例如下面代码所示：

function foo(){return 123;}console.log(foo); // 123function bar(){ }console.log(bar()); // undefined

立即执行函数

我们在定义函数以后立即执行它，通过括号()包裹并调用函数。如下列代码所示：

(function foo(){
  console.log(&#39;foo was executed!&#39;);
})();

出现立即执行函数的原因是为了创建新的变量作用域。if、else、while不会创建新的变量作用域，如下列代码所示：

var foo = 123;if(true){  var foo = 456;
}console.log(foo); // 456

在Javascrit中，我们通过函数创建新的变量作用域，例如使用立即执行函数：

var foo = 123;if(true){
  (function(){      var foo = 456;
  })();
}console.log(foo); // 123

在上面的代码中，我们没有给函数命名，这被称为匿名函数。

匿名函数

没有名字的函数被称为匿名函数。在Javascript中，我们可以把函数赋值给变量，如果准备将函数当作变量使用，就不需要给函数命名。下面给出了两种等价的写法：

var foo1 = function nameFunction(){  console.log(&#39;foo1&#39;);
}
foo1(); // foo1var foo2 = function(){  console.log(&#39;foo2&#39;);
}
foo2(); // foo2f

据说如果一门编程语言能够把函数当作变量来对待，它就是一门优秀的编程语言，Javascript做到了这一点。

高阶函数

由于Javascript允许我们将函数赋值给变量，所以我们可以将函数作为参数传递给其它函数。将函数作为参数的函数被称为高阶函数。setTimeout就是常见的高阶函数。

setTimeout(function(){console.log(&#39;2000 milliseconds have passed since this demo started&#39;);
}, 2000);

如果在Node.js中运行上面的代码，会看到命令窗口2秒钟后输出信息。在上面的代码中，我们传递了一个匿名函数作为setTimeout的第一个参数。我们也可以传递一个普通的函数：

function foo(){  console.log(&#39;2000 milliseconds have passed since this demo started&#39;);
}
setTimeout(foo, 200);

现在，我们已经了解了对象字面量和函数，接下来我们会了解闭包的概念。

闭包

闭包是能够访问其它函数内部变量的函数。如果在函数内部定义另一个函数，内部函数能够访问外部函数的变量，这就是闭包的常见形式。我们会通过一些例子来解释。
在下面的代码中，你可以看到内部函数能够访问外部函数的变量：

function outerFunction(arg){  var variableInOuterFunction = arg;  function bar(){console.log(variableInOuterFunction);
  }

  bar();
}

outerFunction(&#39;hello closure!&#39;);   // hello closure!

令人惊喜的是：内部函数在外部函数返回之后依然可以访问外部函数作用域中的变量。这是因为，变量仍然被绑定于内部函数，不依赖于外部函数。例如：

function outerFunction(arg){  var variableInOuterFunction = arg;  return function(){console.log(variableInOuterFunction);
  }
}var innerFunction = outerFunction(&#39;hello closure!&#39;);

innerFunction(); // hello closure!

现在，我们已经了解了闭包，接下来，我们会探究一下使Javascript成为一门适合服务器端编程的语言的原因。

Node.js性能

Node.js致力于开发高性能应用程序。接下来的部分，我们会介绍大规模I/O问题，并分别展示传统方式及Node.js是如何解决这个问题的。

大规模I/O问题

大多数Web应用通过硬盘或者网络（例如查询另一台机器的数据库）获取数据，从硬盘或网络获取数据的速度远远慢于CPU的处理周期。当收到一个HTTP请求以后，我们需要从数据库获取数据，请求会一直等待直到获取数据完成。这些创建的连接和还未结束的请求会消耗服务器的资源（内存和CPU）。为了使同一台Web服务器能够处理大规模请求，我们需要解决大规模I/O问题。

每一个请求创建一个进程

传统的Web服务器为每一个请求创建一个新的进程，这是一种对内存和CPU开销都很昂贵的操作。PHP最开始就是采用的这种方法。在等待响应期间，进程仍然会消耗资源，并且进程的创建更慢。所以现代Web应用大多使用线程池的方法。

线程池

现代Web服务器使用线程池来处理每个请求。线程和进程相比，更加轻量级。在创建线程池以后，我们就不再需要为开始或结束进程而付出额外代价。当收到一个请求，我们为它分配一个线程。然而，线程池仍然会浪费一些资源。

单线程模式

我们知道为请求分别创建进程或者线程会导致系统资源浪费。与之相对，Node.js采取了单线程来处理请求。单线程服务器的性能优于线程池服务器的理念并不是Node.js首创，Nginx也是基于这种理念。Nginx是一种单线程服务器，能够处理极大数量的并发请求。
Javascript是单线程的，如果你有一个耗时操作（例如网络请求），就必须使用回调。下面的代码使用setTimeout模拟了一个耗时操作，可以用Node.js执行。

function longRunningOperation(callback){
  setTimeout(callback, 3000);
}function UserClicked(){  console.log(&#39;starting a long operation&#39;);
  longRunningOperation(function(){      console.log(&#39;ending a long operation&#39;);
  })
}
UserClicked();

让我们模拟一下Web请求：

function longRunningOperation(callback){
  setTimeout(callback, 3000);
}function webRequest(request){  console.log(&#39;starting a long operation for request:&#39;, request.id);
  longRunningOperation(function(){console.log(&#39;ending a long operation for request:&#39;, request.id);
  });
}

webRequest({id: 1});
webRequest({id: 2});

//输出
//starting a long operation for request: 1//starting a long operation for request: 2//ending a long operation for request: 1//ending a long operation for request: 2

更多的Javascript

精通Javascript使得Node.js开发者不仅能够写出更加容易维护的项目，而且能够利用到Javascript生态链的优势。

默认值

Javascript变量的默认值是undefined。如下列代码所示：

var foo;console.log(foo);  //undefined

变量不存在的属性也会返回undefined

var foo = {bar: 123};
console.log(foo.bar); // 123
console.log(foo.bas); // undefined

全等

需要注意Javascript当中 ==与===的区别。==会对变量进行类型转换，===不会。推荐的用法是总是使用===。

console.log(5 == &#39;5&#39;); // true
console.log(5 === &#39;5&#39;); // false

null

null是一个特殊的Javascript对象，用于表示空对象。而undefined用于表示变量不存在或未初始化。我们不需要给变量赋值为undefined，因为undefined是变量的默认值。

透露模块模式

透露模块模式的关键在于Javascript对闭包的支持以及能够返回任意对象的能力。如下列代码所示:

function printableMessage(){  var message = &#39;hello&#39;;  function setMessage(newMessage){if(!newMessage) throw new Error(&#39;cannot set empty message&#39;);
    message = newMessage;
  }  function getMessage(){return message;
  }  function printMessage(){
    console.log(message);
  }  return {
    setMessage: setMessage,
    getMessage: getMessage,
    printMessage: printMessage
  };
}var awesome1 = printableMessage();
awesome1.printMessage(); //hellovar awesome2 = printableMessage();
awesome2.setMessage(&#39;hi&#39;);
awesome2.printMessage(); // hi

awesome1.printMessage(); //hello

理解`this`

this总是指向调用函数的对象。例如：

var foo = {  bar: 123,  bas: function(){console.log(&#39;inside this.bar is: &#39;, this.bar);
  }
}console.log(&#39;foo.bar is:&#39;, foo.bar); //foo.bar is: 123
foo.bas(); //inside this.bar is: 123

由于函数bas被foo对象调用，所以this指向foo。如果是纯粹的函数调用，则this指向全局变量。例如：

function foo(){  console.log(&#39;is this called from globals? : &#39;, this === global); //true
}
foo();

如果我们在浏览器中执行上面的代码，全局变量global会变为window。
如果函数的调用对象改变，this的指向也会改变：

var foo = {  bar: 123
};function bas(){  if(this === global){console.log(&#39;called from global&#39;);
  }  if(this === foo){console.log(&#39;called from foo&#39;);
  }
}//指向global
bas(); //called from global//指向foo
foo.bas = bas;
foo.bas(); //called from foo

如果通过new操作符调用函数，函数内的this会指向由new创建的对象。

function foo(){  this.foo = 123;
  console.log(&#39;Is this global? : &#39;, this == global);
}

foo(); // Is this global? : true
console.log(global.foo); //123var newFoo = new foo(); //Is this glocal ? : false
console.log(newFoo.foo); //123

通过上面代码，我们可以看到，在通过new调用函数时，函数内的this指向发生改变。

理解原型

Javascript通过new操作符及原型属性可以模仿面向对象的语言。每个Javascript对象都有一个被称为原型的内部链接指向其他对象。
当我们调用一个对象的属性，例如:foo.bar，Javascript会检查foo对象是否存在bar属性，如果不存在，Javascript会检查bar属性是否存在于foo._proto_，以此类推，直到对象不存在_proto_。如果在任何层级发现属性的值，则立即返回，否则，返回undefined。

var foo ={};
foo._proto_.bar = 123;
console.log(foo.bar); //123

当我们通过new操作符创建对象时，对象的_proto_会被赋值为函数的prototype属性，例如：

function foo(){};
foo.prototype.bar = 123;var bas = new foo();console.log(bas._proto_ === foo.prototype); //trueconsole.log(bas.bar);

函数的所有实例共享相同的prototype

function foo(){};
foo.prototype.bar = 123;

var bas = new foo();
var qux = new foo();
console.log(bas.bar); //123
console.log(qux.bar); //123

foo.prototype.bar = 456;
console.log(bas.bar); //456
console.log(qux.bar); //456

只有当属性不存在时，才会访问原型，如果属性存在，则不会访问原型。

function foo(){};
foo.prototype.bar = 123;var bas = new foo();var qux = new foo();

bas.bar = 456;console.log(bas.bar);//456console.log(qux.bar); //123

上面的代码表明，如果修改了bas.bar, bas._proto_.bar就不再被访问。

错误处理

Javascript的异常处理机制类似其它语言，通过throw关键字抛出异常，通过catch关键字捕获异常。例如：

try{
  console.log(&#39;About to throw an error&#39;);  throw new Error(&#39;Error thrown&#39;);
}
catch(e){
  console.log(&#39;I will only execute if an error is thrown&#39;);
  console.log(&#39;Error caught: &#39;, e.message);
}finally{
  console.log(&#39;I will execute irrespective of an error thrown&#39;);
}