node.js基础内容

node.js 

node.js是建立在谷歌Chrome的JavaScript引擎（v8）的web应用程序框架。

node.js 自带的运行环境可在JavaScript脚本的基础上解释和执行。这个运行是运行在浏览器以外的任何机器上执行JavaScript代码。所以也可以在服务端运行，Node.js还提供了各种丰富的JavaScript模块库，它极大简化了使用Node.js来扩展Web应用程序的研究与开发。

特性

Node.js库的异步和事件驱动的API全部都是异步就是非阻塞。它主要是指基于Node.js的服务器不会等待API返回的数据。服务器移动到下一个API调用，Node.js发生的事件通知机制后有助于服务器获得从之前的API调用的响应。

非常快的内置谷歌Chrome的V8 JavaScript引擎，Node.js库代码执行是非常快的。

单线程但高度可扩展 - Node.js使用具有循环事件单线程模型。

没有缓冲 - Node.js的应用从来不使用缓冲任何数据。这些应用只是输出数据在块中。

应用场景

适合：I/O 绑定应用程序，数据流应用，数据密集型实时应用(DIRT)，JSON API的应用程序，单页面应用。

不适合：CPU密集型应用。

下载安装完成后，通过cmd启动执行文件。

node.js - Hello World

node -v 查看当前node版本。

通过编写js文件，然后再cmd当前目录运行文件。

var http = require('http');
http.createServer(function(req,res){
    res.writeHead(200,{'Content-Type':'text/plain'});
    res.end('Hello World\n');
}).listen(1337,'127.0.0.1');
console.log('Server running at http://127.0.0.1:1337/');

执行当前文件目录执行node hello.js 

起一个简单的服务，在浏览器可输入地址，后显示

 

node.js - npm

npm 表示节点程序包管理器。是Node.js包/模块的在线软件仓库；可以在命令行实用程序安装包，作为Node.js版本管理和依赖包管理。

npm -v 查看当前npm版本。（一般安装node.js自带npm）-g  表示资源包全局安装。

npm  install express （一个实用的web框架）

npm  ls 查询

package.json 

package.json是存在于任何Node应用程序/模块的根目录，并用于定义一个包的属性。

Node.js - 回调

回调是一种异步相当于一个函数。回调函数被调用在完成既定任务。Node大量使用了回调。Node所有的API写的都是支持回调的这样一种方式。例如，一个函数读取一个文件可能开始读取文件，并立即返回控制到执行环境 使得下一个指令可以马上被执行。一旦文件 I/O 完成，它会调用回调函数，同时传递回调函数，该文件作为参数的内容。因此不会有堵塞或等待文件I/O。这使得Node.js高度可扩展，因此可以处理大量的请求，而无需等待任何函数来返回结果。

阻塞代码/非阻塞代码。

var fs = require('fs');

fs.readFile('text.txt',function(err,data){
    if(err) return console.log(err);
    console.log(data.toString());
})
console.log("end!!");

事件循环  &&  事件驱动编程

Node JS是单线程应用程序，但它通过事件和回调的概念，支持并发。NodeJS的每一个API都是异步的，作为一个单独的线程，它使用异步函数调用来维护并发。Node使用观察者模式。Node线程保持一个事件循环，每当任何任务完成后得到结果，它触发通知事件侦听函数来执行相应的事件。

Node.js使用大量事件，这也是为什么Node.js相对于其他类似技术比较快的原因之一。当Node启动其服务器，就可以简单地初始化其变量，声明函数，然后等待事件的发生。

// 声明需要事件
var events = require('events');
// 创建事件对象
var eventEmitter = new events.EventEmitter();
// 声明触发事件执行的函数
var connected = function connected() {
    console.log('connection succesful!')
    eventEmitter.emit('data_received.');
}
// 绑定事件
eventEmitter.on("connection",connected);
eventEmitter.on("data_received",function(){
    console.log('data received succesfully.');
});
// 事件触发
eventEmitter.emit('connection');
console.log('code end!');

错误处理：

var fs = require("fs");

fs.readFile('test.txt', function (err, data) {
    if (err){
       console.log(err.stack);
       return;
    }
    console.log(data.toString());
});
console.log("Program Ended");

事件监听的添加移除与触发

// 需要事件
var events = require('events'); 
// 创建事件对象
var eventEmitter = new events.EventEmitter();
// 事件1
var listner1 = function listner1() {
    console.log('this is 11111');
}
// 事件2
var listner2 = function listner2() {
    console.log('this is 22222');
}
// 事件监听addListener与on效果相同
eventEmitter.addListener('connection',listner1);
eventEmitter.on('connection',listner2);
// 另一种写法
var eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to connection event");
// 触发事件
eventEmitter.emit('connection');
// 移除事件监听
eventEmitter.removeListener('connection', listner1);
console.log("Listner111 will not listen now. removeListener");
// 再触发事件
eventEmitter.emit('connection');
// 添加事件监听
eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to connection event");

console.log("Program Ended.");

Buffer 类 缓冲器

Buffer类是一个全局类，可以在应用程序，无需导入缓冲模块进行访问。缓冲区是一种整数数组并对应于原始存储器V8堆以外分配。 缓冲区不能调整大小。

在 ECMAScript 2015 引入 TypedArray 之前，JavaScript 语言没有读取或操作二进制数据流的机制。 Buffer 类被引入作为 Node.js API 的一部分，使其可以在 TCP 流或文件系统操作等场景中处理二进制数据流。

TypedArray 现已被添加进 ES6 中，Buffer 类以一种更优化、更适合 Node.js 用例的方式实现了 Uint8Array API。

var buffer = new Buffer(26);
console.log("buffer length: " + buffer.length);
var data = "YiiBai.com";

buffer.write(data);
console.log(data + ": " + data.length + " characters, " + Buffer.byteLength(data, 'utf8') + " bytes");

var buffer1 = buffer.slice(0,14);
console.log("buffer1 length: " + buffer1.length);
console.log("buffer1 content: " + buffer1.toString());

for (var i = 0 ; i < 26 ; i++) {
    buffer[i] = i + 97; // 97 is ASCII a
  }
  console.log("buffer content: " + buffer.toString('ascii'));
  
  var buffer2 = new Buffer(4);

  buffer2[0] = 0x3;
  buffer2[1] = 0x4;
  buffer2[2] = 0x23;
  buffer2[3] = 0x42;

//reading from buffer
console.log(buffer2.readUInt16BE(0));
console.log(buffer2.readUInt16LE(0));
console.log(buffer2.readUInt16BE(1));
console.log(buffer2.readUInt16LE(1));
console.log(buffer2.readUInt16BE(2));
console.log(buffer2.readUInt16LE(2));

var buffer3 = new Buffer(4);
buffer3.writeUInt16BE(0xdead, 0);
buffer3.writeUInt16BE(0xbeef, 2);
console.log(buffer3);

buffer3.writeUInt16LE(0xdead, 0);
buffer3.writeUInt16LE(0xbeef, 2);

console.log(buffer3);

//convert to a JSON Object
var json = buffer3.toJSON();
console.log("JSON Representation : ");
console.log(json);

//Get a buffer from JSON Object
var buffer6 = new Buffer(json);
console.log(buffer6);

//copy a buffer
var buffer4 = new Buffer(26);
buffer.copy(buffer4);
console.log("buffer4 content: " + buffer4.toString());

//concatenate a buffer
var buffer5 = Buffer.concat([buffer,buffer4]);
console.log("buffer5 content: " + buffer5.toString());

 

node.js 数据流

数据流是从源数据读取或写入数据到目标对象以。在节点中，有四种类型的流：

• Readable - 数据流，其是用于读操作

• Writable - 数据流，用在写操作

• Duplex - 数据流，其可以用于读取和写入操作

• Transform - 双相类型流，输出基于输入进行计算

每种类型的流是EventEmitter，并且一次引发几个事件。例如，一些常用的事件是：

• data - 当有数据可读取时触发此事件

• end - 当没有更多的数据读取时触发此事件

• error - 当有错误或接收数据写入时触发此事件

• finish - 当所有数据已刷新到底层系统时触发此事件

var fs = require("fs");
var data = '';
//create a readable stream
var readerStream = fs.createReadStream('text.txt');

//set the encoding to be utf8. 
readerStream.setEncoding('UTF8');

//handle stream events
readerStream.on('data', function(chunk) {
   data += chunk;
});

readerStream.on('end',function(){
   console.log(data);
});

readerStream.on('error', function(err){
   console.log(err.stack);
});
console.log("-------------Program Ended---------------");

var fs = require("fs");
var data = 'Yiibai.Com';
//create a writable stream
var writerStream = fs.createWriteStream('text1.txt');

//write the data to stream
//set the encoding to be utf8. 
writerStream.write(data,'UTF8');

//mark the end of file
writerStream.end();

//handle stream events
writerStream.on('finish', function() {
    console.log("Write completed.");
});

writerStream.on('error', function(err){
   console.log(err.stack);
});
console.log("--------------Program Ended---------------");

 

node.js 文件系统

--同步&异步  

每一个fs模块的方法都有同步和异步形式。异步方法接受一个最后的参数为完成回调函数，而回调函数的第一个参数是错误。它优选使用异步方法来代替同步方法，前者从未阻塞程序执行，而后者则会阻塞。

var fs = require("fs");
var buffer = new Buffer(1024);

//Example: Opening File打开文件
function openFile(){
   console.log("\nOpen file--------");
   fs.open('test.txt', 'r+', function(err,fd) {
      if (err) console.log(err.stack);
      console.log("File opened");     
   });
}

//Example: Getting File Info 统计信息
function getStats(){
   console.log("\nGetting File Info---------");
   fs.stat('test.txt', function (err, stats) {
      if (err) console.log(err.stack);
      console.log(stats);
      console.log("isFile ? "+stats.isFile());
      console.log("isDirectory ? "+stats.isDirectory());
   });
}

//Example: Writing File 写
function writeFile(){
   console.log("\nWrite file-----------");
   fs.open('test2.txt', 'w+', function(err,fd) {
      var data = "Yiibai.com - Simply Easy Learning!";
      buffer.write(data); 
      
      fs.write(fd, buffer,0,data.length,0,function(err, bytes){
         if (err) console.log(err.stack);
         console.log(bytes + " written!");         
      });    
   });
}

//Example: Read File 读取
function readFile(){
   console.log("\nRead file----------");
   fs.open('test1.txt', 'r+', function(err,fd) {
      if (err) console.log(err.stack);
      fs.read(fd, buffer,0,buffer.length,0,function(err, bytes){
         if (err) console.log(err.stack);
         console.log(bytes + " read!");
         if(bytes > 0){
            console.log(buffer.slice(0,bytes).toString());
         }
      });    
   });
}
// 关闭
function closeFile(){
   console.log("\nClose file-------------");
   fs.open('test.txt', 'r+', function(err,fd) {
      if (err) console.log(err.stack);      
      fs.close(fd,function(){
         if (err) console.log(err.stack);      
         console.log("File closed!");
      });
   });
}
// 删除
function deleteFile(){
   console.log("\nDelete file-----------");
   fs.open('test1.txt', 'r+', function(err,fd) {
       fs.unlink('test1.txt', function(err) {
          if (err) console.log(err.stack);                  
          console.log("File deleted!");     
       });
   });
}
// 缩短，删节？
function truncateFile(){
   console.log("\nTruncate file------------");
   fs.open('test.txt', 'r+', function(err,fd) {
       fs.ftruncate(fd, function(err) {
          if (err) console.log(err.stack);                  
          console.log("File truncated!");     
       });
   });
}

function createDirectory(){
    console.log("\nCreate Directory--------------");
    fs.mkdir('test',function(err){
      if(!err){
         console.log("Directory created!");
      }
      if(err && err.code === 'EEXIST'){
         console.log("Directory exists!");    
      } else if (err) {       
         console.log(err.stack);           
      }
    });
}
// 移除
function removeDirectory(){
    console.log("\nRemove Directory---------------");
    fs.rmdir('test',function(err){
      if(!err){
         console.log("Directory removed!");
      }
      if (err) {      
         console.log("Directory do not exist!");                   
      }
    });
}
// 监听
function watchFile(){
   fs.watch('test.txt', function (event, filename) {
      console.log('event is: ' + event);   
   });
}

//Opening file
openFile();

//Writing File
writeFile();

//Reading File   
readFile();

//Closing Files
closeFile();

//Getting file information
getStats();
   
//Deleting Files
deleteFile();
   
//Truncating Files
truncateFile();
   
//Creating Directories
createDirectory();

//Removing Directories
removeDirectory();
   
//Watching File Changes
watchFile();

 

 node.js - 进程 （process）

 process 是一个全局性对象，并用于表示Node进程。

 Process（进程）是一个eventEmitter，并且它发出下列事件

 Process（进程）提供了许多有用的特性，以更好地控制系统的相互作用。

 Process（进程）提供了许多有用的方法，以更好的控制系统的相互作用。

 

var util = require('util');

//printing to console
process.stdout.write("Hello World!" + "\n");

//reading passed parameter
process.argv.forEach(function(val, index, array) {
   console.log(index + ': ' + val);
});

//executable path
console.log(process.execPath);

//print the current directory
console.log('Current directory: ' + process.cwd());
    
//print the process version
console.log('Current version: ' + process.version);

//print the memory usage
console.log(util.inspect(process.memoryUsage()));

node.js - psth

path 模块用于处理和转换文件路径。path模块可以使用以下语法导入。

var path = require("path")

var path = require("path");

//normalization
console.log('normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/..'));

//join
console.log('joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..'));

//resolve
console.log('resolve : ' + path.resolve('test.js'));

//extName
console.log('ext name : ' + path.extname('test.js'));

node.js - Net 

net 模块是用来创建服务器和客户端。它提供了一个异步网络包装。 net模块可以使用以下语法导入。

var net = require("net")

node.js - DNS 

dns 模块是用来做实际的DNS查找，以及使用底层操作系统的名称解析功能..它提供了一个异步网络包装。dns模块可以使用以下语法导入。

var dns = require("dns")

node.js - Domain

domain 模块是用于拦截未处理的错误。这些未处理的错误可以使用内部绑定或外部绑定来拦截。如果错误都那么不处理，那么Node应用会崩溃。

• 内部绑定 - 错误发生执行代码是在一个域的run方法。

• 外部绑定 - 使用它的add方法将错误发生明确地加入到域。

domain（域）模块可以使用以下语法导入。

var domain = require("domain")

域模块的Domain类是用来提供路由错误以及未捕获异常活动域对象的功能。 这是一个EventEmitter的子类。为了处理它捕获错误，监听它的错误事件。它使用如下的语法创建：

var domain = require("domain");
var domain1 = domain.create();

 

一点基础内容，没深入研究，了解基础，创建文本服务应用，以后再进行跟深层次的挖掘！！