nodejs

時間 2019-12-13

標籤 nodejs 简体版

原文原文鏈接

Node.js概述：
Node.js官網：www.nodejs.org
1.Node.js是C++編寫的基於V8引擎的JS運行時環境。
2.Node.js是一門基於ECMAScript開發的服務器端語言，提供了（全端JS沒有的）不少擴展對象。
前端js：
1.ES原生對象：String、Number、Boolean、Math、Date、Error、Function、Object、Array、RegExp...
2.BOM&DOM
3.自定義對象
Node.js：
1.ES原生對象
2.Node.js內置對象
3.大量的第三方對象
4.自定義對象
3.Node.js能夠編寫獨立的服務器應用，無需藉助於其餘web服務器。html

Node.js的意義：
1.執行效率比PHP/JSP/JAVA要快
2.用一種語言統一了先後端開發。前端

全棧工程師node

特色：
1.單線程邏輯處理
2.非阻塞
3.異步I/O處理
4.事件驅動編程mysql

2.Node.js的兩種運行方式：
1.交互模式——用於測試
讀取用戶輸入、執行運算、輸出執行結果、繼續下一循環
執行方法：輸入一行js語句，回車執行
2.腳本模式——用於開發
把要執行的全部js語句編寫在一個獨立的js文件中，一次性的提交給nodejs處理。此文件能夠沒有後綴
執行方法：node d:\xx\xx.jsweb

3.Node.js的基礎語法及ES6新特性
1.數據類型：
（1）原始類型
string、number、boolean...
原始類型數據直接賦值便可
（2）引用類型
ES原生對象、Node.js對象、自定義對象
引用類型一般須要使用new關鍵字建立sql

//原始類型
var price=9.9;
var name="可口可樂";
var isOnsale=false;
var exDate=null;
var area=undefined;



//引用類型
var empName=new String('Tom');
var age=new Number(20);
var age=new Buffer(10);
var myObj=new Object();
function Myobj(name,age){
  this.name=name;
  this.age=age;
}
var han=new Myobj('hanxl',20);
console.log(han.name);
console.log(han.age);

View Code

2.模板字符串
ES6中提供的一種新的字符串形式
（1）使用模板方式定義字符串，數據能夠實現換行
（2）可使用${}拼接變量，而且能夠執行運算數據庫

//模板字符串
var info=`
  用戶名：唐牧
  密碼：123
`;
console.log(info);

var price=9.9,count=3;
var info2=`
  單價：${price},
  數量：${count},
  小計：${price*count},
  超過預算：${price*count>20?'是':'否'}
`;
console.log(info2);

View Code

3.嚴格模式
ES5中新增一種比普通模式更爲嚴格的js運行模式。
使用方法：
（1）在整個腳本文件中啓用嚴格模式
在腳本文件的開頭："use strict";
用於新項目
（2）在單個函數內啓用嚴格模式
function info(){
"use strict";
.........
}
用於老項目維護
規則：
（1）修改常量的值是非法的——將靜默失敗升級爲錯誤
（2）不容許對未聲明的變量賦值
（3）匿名函數的this再也不指向全局express

//"use strict";
const PI=3.14;
//PI=2;
console.log(PI);





function f1(){
  //"use strict"
  var name="tecu.cn";
  loc="北京市";
  console.log(name);
  console.log(loc);
}
f1();


(function(){
  'use strict';
  console.log(this);
})();

View Code

4.變量的做用域
全局做用域、局部做用域、塊級做用域（ES6中專有）
塊級做用域：只在當前代碼塊中使用
代碼塊：任何一個{}都是一個代碼塊，if/for/while...
代碼塊中使用「let」聲明塊級做用域變量，出了代碼塊，便不可以使用。使用let須要啓用嚴格模式。npm

"use strict";
/*var count=20;
if(count>10){
  //var cur=count;
  let cur=count;
}
console.log(cur);*/


for(let i=0;i<5;i++){}

console.log(i);

View Code

5.循環結構
for...of...(ES6)
遍歷數組的元素值編程

//for...in....遍歷對象的成員名
var obj={
  name:"tom",
  age:20
};
for(var i in obj){
  console.log(i+':'+obj[i]);
}
//for...in...遍歷數組的下標
var arr=[10,20,30];
for(var i in arr){
  console.log(i);
}

//for...of...遍歷數組的元素值
for(var i of arr){
  console.log(i);
}

View Code

6.函數
匿名函數的自調
=> 箭頭函數
() => {

}
箭頭函數只用於匿名函數
箭頭函數中不存在arguments對象

/*
(function(i){
  console.log(i)
})(111);

+function(){
  console.log(222);
}();

(function(num){
  if(num>0){
    arguments.callee(num-1);
    console.log(num);
  }
})(5);

*/

//箭頭函數 =>
(()=>{
  console.log(111)
})();
((n1,n2)=>{
  console.log(n1+n2);
})(10,20);

var f1=(n1,n2)=>{
  console.log(n1+n2);
};
f1(1,2);

/*((num)=>{
  if(num>0){
    arguments.callee(num-1);
    console.log(num);
  }
})(5); 錯誤！*/

View Code

//一個簡單的一次性定時器
var i=1;
setTimeout(()=>{
  console.log(i);
},1000);
//一秒以後，輸出0,1,2
for(var i=0;i<3;i++){
  setTimeout(outer(i),1000);
}
function outer(num){
  return function inner(){
    console.log(num);
  }
}
//改寫爲箭頭函數
for(var i=0;i<3;i++){
  setTimeout((num=>{
    return ()=>{console.log(num);}
  })(i),1000);
}

View Code

7.對象
建立對象的方式：
（1）對象直接量
（2）構造函數方式
（3）原型繼承方式
（4）class方式——ES新增
class 類：是一組類似對象的屬性和行爲的抽象集合。（描述一類事物統一的屬性和功能的程序結構）
事物的屬性就是class的屬性，事物的功能就是class的方法。
使用class方式建立自定義對象是，必須啓用嚴格模式。
"use strict";
//建立自定義對象
class Emp {
constructor(ename){
this.ename=ename;
}
work(){
}
}
var e1=new Emp("tom");

實現繼承：
class Programmer extends Emp{
constructor(ename,salary,skills){
super(ename,salary);
this.skills=skills;
}
}

"use strict";
//建立自定義對象
class Emp {
  constructor(ename,salary){//聲明一個構造函數
    this.ename=ename;
    this.salary=salary;
  }
  work(){
    return `${this.ename} is working.`;
  }
  sal(){
    return `${this.ename}'s salary is ${this.salary}.`;
  }
}
var e1=new Emp("tom",8000);
console.log(e1.ename);
console.log(e1.work());
console.log(e1.sal());
var e2=new Emp("Mary",9000);
console.log(e2.ename);



//實現繼承
class Programmer extends Emp{
  constructor(ename,salary,skills){
    super(ename,salary);
    this.skills=skills;
  }
  work(){
    return super.work()+'skills are'+this.skills;
  }
}
var p1=new Programmer("Jack",8800,"PHP&MYSQL");
console.log(p1.ename);
console.log(p1.work());

View Code

4.全局對象
Node.js中的全局對象是Global.
在交互模式下，聲明的全局變量是global的成員。——全局對象的污染
在腳本模式下，聲明的全局變量不是global的成員。——避免了全局對象的污染
Global對象的成員屬性和成員方法
1.console 用於向stdout(標準輸出)和stderr(標準錯誤)輸出信息。

console.log() //向stdout輸出日誌信息
console.info() //同上
console.error() //向stderr輸出錯誤信息
console.warn() //同上
console.trace() //向stderr輸出棧軌跡信息
console.dir() //向stdout輸出指定對象的字符串表示
console.assert() //斷言，爲真的斷言，錯誤信息不會輸出；爲假的斷言，拋出錯誤對象，輸出錯誤信息，而且終止腳本的運行，能夠自定義錯誤信息。
console.time() console.timeEnd()//測試代碼的執時間

注意：console中的成員方法是異步的，輸出順序和書寫順序不必定徹底一致。

var age=20;
console.log(age);
//console.log(global.age);



//process.kill(pid)向指定進程id發送退出信號
process.kill(3456);

View Code

<!DOCTYPE html>
<html>
<head lang="en">
  <meta charset="UTF-8">
  <title></title>
</head>
<body>
<script>
  var age=20;
  console.log(age);
  console.log(window.age);
</script>

</body>
</html>

View Code

/*
//console.log
console.log("msg1");
console.log("msg1","msg2",123,true,new Date());
var user={name:"tom",age:20};
console.log(`姓名：${user.name},年齡：${user.age}`);
//百分號佔位符，每個佔位符一一對應後面的參數值，%s表示string類型，%d表示number類型
console.log('姓名：%s，年齡：%d',user.name,user.age);

//console.error
console.error(`姓名：${user.name},年齡：${user.age}`);

//console.trace
function outer(){
  function inner(){
    console.trace("stack trace");
  }
  inner();
}
outer();

//console.dir
console.dir(user);
var arr=[20,30,"tom"];
console.dir(arr);
//console.log和console.dir的區別，dir()能夠帶一些參數
console.log(Buffer);
console.dir(Buffer,{colors:true});
*/
/*
//console.assert
function add(n1,n2){
  return n1+n2;
}
var sum=20;
console.assert(add(10,20)==sum,"add函數執行結果不符合要求");
*/


//console.time()  console.timeEnd()
console.time("mycode");//開始計時
var sum=0;
for(var i=0;i<1000000;i++){
  sum+=i;
}
console.timeEnd("mycode");//結束計時

View Code

2.process 進程
process.arch //獲取CPU架構類型
process.platform //獲取操做系統類型
process.env //獲取操做系統環境變量
process.cwd() //獲取當前文件所在工做目錄
process.execPath //獲取Node.js解釋器所在目錄
process.versions //獲取Node.js版本信息
process.uptime() //獲取Node.js進程運行時間(s)
process.memoryUsage()//獲取Node.js進程內存使用信息
process.pid //獲取進程ID號
process.kill( pid ) //向指定進程ID號發送退出信號

3.定時器
global.setTimeout() //一次性定時器
global.setInterval() //週期性定時器
global.setImmediate()//在下次事件循環開始以前當即執行的定時器
process.nextTick() //本次事件循環結束以後當即執行的定時器

/*//一個簡單的一次性定時器
var counter=0;
var timer=setTimeout(function(){
  counter++;
  console.log('%d hello',counter);
  clearTimeout(timer);
},1000);
//週期性定時器，輸出1,2,3,4,5
var counter2=0;
var timer2=setInterval(function(){
  counter2++;
  console.log(counter2);
  if(counter2>=5){
    clearInterval(timer2);
  }
},1000);

//練習：使用一次性定時器模擬上面週期性定時器的效果，輸出1,2,3,4,5
var counter3=0;
var timer3=setTimeout(function(){
  counter3++;
  if(counter3<=5){
    console.log(counter3);
    setTimeout(arguments.callee,1000)
  }else {
    clearTimeout(timer3);
  }
},1000);*/
//setImmediate()  process.nextTick
setImmediate(function(){
  console.log("setImmediate1...");
});
process.nextTick(function(){
  console.log("nextTick1...");
});
setTimeout(function(){
  console.log("setTimeout...");
},100)
setImmediate(function(){
  console.log("setImmediate2...");
});
process.nextTick(function(){
  console.log("nextTick2...");
});
console.log("end...");

View Code

5.模塊系統：
Node.js中使用「Module(模塊)」來規劃不一樣的功能對象。
模塊的分類：
（1）核心模塊——Node.js的內置模塊（有些不需引入可直接使用，有些須要引入）
（2）第三方模塊
（3）自定義模塊
每個被加載的js文件對應一個模塊對象，包含響應的功能和函數。
模塊中聲明的變量或函數的做用域叫作「模塊做用域」，這些變量和函數都不是global的成員，默認只能在當前的js文件（當前模塊）中使用。
Node.js啓動時運行的第一個模塊叫作「主模塊」——main module，也是自身模塊。
獲取主模塊對象：
process.mainModule
require.main

除主模塊以外的其餘模塊都稱爲子模塊。
默認狀況下，某一個模塊不能直接使用其餘模塊中封裝的數據，可是每一個模塊能夠導出(exports)本身內部的對象供其餘模塊使用，也可用引入(require)並使用其餘模塊導出的對象。

每個模塊內部均可以使用一個變量：module，指向當前模塊本身。
//判斷當前模塊是否主模塊
console.log(require.main===module);
模塊的引入：require()
(在交互模式下，Node.js自帶的模塊無需引入，直接使用)

/*
//獲取主模塊對象
console.log(process.mainModule);
console.log(require.main);
//獲取當前模塊本身
console.log(module);
//判斷當前模塊是否主模塊
console.log(require.main===module);
*/


//引入其餘模塊
var fs=require("fs");//引入文件系統模塊
fs.readFile('./10-window.html',(err,data)=>{
  if(err){
    console.log("文件讀取失敗");
    console.log(err);
  }else{
    console.log("文件讀取成功");
    console.log(data);
  }
});

View Code

1.模塊系統：
Node.js中使用「Module(模塊)」來規劃不一樣的功能對象。
模塊的分類：
（1）核心模塊——Node.js的內置模塊（有些不需引入可直接使用，有些須要引入）
（2）第三方模塊
（3）自定義模塊
每個被加載的js文件對應一個模塊對象，包含響應的功能和函數。
模塊中聲明的變量或函數的做用域叫作「模塊做用域」，這些變量和函數都不是global的成員，默認只能在當前的js文件（當前模塊）中使用。
Node.js啓動時運行的第一個模塊叫作「主模塊」——main module，也是自身模塊。
獲取主模塊對象：
process.mainModule
require.main

預約義的模塊做用域成員：
__dirname //當前模塊文件所在的目錄
__filename //當前模塊文件所在的目錄以及文件名
module //指向當前模塊的引用
module.exports //指向當前模塊中待導出的供其餘模塊使用的對象
exports //指向module.exports對象的引用
require //引入其餘模塊，使用其餘模塊的module.exports對象

/*
//獲取主模塊對象
console.log(process.mainModule);
console.log(require.main);
//獲取當前模塊本身
console.log(module);
//判斷當前模塊是否主模塊
console.log(require.main===module);
*/


//引入其餘模塊
var fs=require("fs");//引入文件系統模塊
fs.readFile('./10-window.html',(err,data)=>{
  if(err){
    console.log("文件讀取失敗");
    console.log(err);
  }else{
    console.log("文件讀取成功");
    console.log(data);
  }
});

View Code

//求圓的面積和周長
const PI=3.14;
var size=function(r){
  return PI*r*r;
};
var perimeter=function(r){
  return 2*PI*r;
};
exports.s=size;
exports.p=perimeter;
//=================end circle.js


var c=require('./02-circle.js');
console.log(c.s(5));
console.log(c.p(5).toFixed(2));

View Code

//求圓的面積和周長
const PI=3.14;
function Circle(r){
  this.size=function(){
    return PI*r*r;
  };
  this.perimeter=function(){
    return 2*PI*r;
  };
}
module.exports=Circle;
//===================end circle.js


var c=require("./03-circle.js");
var circle=new c(5);
console.log(circle.size());
console.log(circle.perimeter());

View Code

自定義模塊：
（1）文件模塊
沒有後綴的文件模塊，被做爲js文件加載
.js後綴的文件模塊，被做爲js文件加載
.json後綴的文件模塊，被做爲JSON字符串加載，會自動解析爲對象
.node後綴的文件模塊，被做爲C/C++二進制加載
（2）目錄模塊——目錄模塊引入時只需引入目錄名便可
包含一個package.json文件的目錄模塊
"main":"" 指向該模塊的主文件
包含index.js文件的目錄模塊
包含index.json文件的目錄模塊
包含index.node文件的目錄模塊

放到node_modules目錄下的模塊，引入的時候直接寫模塊名稱便可，沒必要指定路徑。
模塊查找的順序：
（1）文件/目錄模塊的緩存
（2）原生模塊的緩存
（3）原生模塊
（4）文件/目錄模塊

包和npm
包(package)是根據CommonJS規範，對模塊進行的標準封裝。
包規範：
-包是一個目錄
-目錄中包含一個package.json包說明文件，存放於包頂級目錄下
-目錄中包含js文件，若有index.js，能夠放到包頂級目錄下
-其餘js文件，放到lib目錄下
-二進制文件放到bin目錄下
-文檔應該放到doc目錄下
-單元測試文件放到test目錄下
CommonJS規範要求，包應該位於當前目錄或者父目錄下的node_modules文件夾下，require函數由近及遠依次查找。

NPM包管理器
npm官網：www.npmjs.com
npm是Node.js的包管理工具，用於下載、安裝、升級、刪除包，或者發佈並維護包。
Node.js的安裝文件中，已經集成了npm。
下載第三方包
（1）安裝在當前項目目錄下
npm install 包名
會安裝到指定目錄的node_modules文件夾下
查看目標路徑：npm root
（2）安裝到全局
npm install 包名 -g
會安裝到npm目錄下
查看目標路徑：npm root -g
列出已經安裝的包：npm ls
更新已經安裝的包：npm update 包名
卸載已經安裝的包：npm uninstall 包名

生成包：
使用npm init命令，能夠在當前目錄下生成一個package.json文件

發佈包：
（1）在http://www.npmjs.com上註冊用戶（此步能夠省略）
（2）使用npm adduser命令註冊帳號或登陸已有帳號
（3）進入配置完成的包目錄，使用npm publish命令發佈包
（4）到npmjs.com上搜索已發佈的包

2.Node.js核心模塊
1.console
global.console 用於向stdout和stderr輸出日誌信息
Console class console模塊中的Console構造函數，用於向任意指定的輸出流（文件）中輸入信息。

//向任意輸出流中執行輸入
var fs=require("fs");//引入fs模塊
var out=fs.createWriteStream("./log/out.log");//建立文件
var err=fs.createWriteStream("./log/err.log");

var c=require("console");//引入console模塊
var loger=new c.Console(out,err);//實例化Console構造函數
loger.log("log...");
loger.error("err...");

View Code

2.Query String模塊
提供了處理URL中「查詢字符串」部分的相關操做
parse() //從查詢字符串中解析出數據對象，參數爲一個查詢字符串
stringify() //將一個數據對象反向解析爲一個查詢字符串格式，參數1，爲一個數據對象；可選參數2，指定鍵值對之間的分隔符；可選參數3，指定鍵和值之間的分隔符。

var qs=require("querystring");
var str="name=tom&age=20";
console.log(qs.parse(str));

var obj={ name: 'tom', age: '20' };
console.log(qs.stringify(obj));
console.log(qs.stringify(obj,","));
console.log(qs.stringify(obj,",","-"));

View Code

3.URL模塊
提供了處理url中不一樣部分的相關操做
parse() //解析出url的各個組成部分，參數1，要解析的url字符串；可選參數2，若爲true，能夠將查詢字符串部分解析爲對象
format() //將對象反向格式化爲url格式，參數爲一個對象
resolve() //根據基地址和相對地址解析出目標地址，參數1，基地址；參數2，相對地址

var url=require("url");
var str="http://tom:123@tedu.cn:8080/news/index.html?pid=20#section";
console.log(url.parse(str));//解析出url的各個組成部分
console.log(url.parse(str,true));//第二個參數，把查詢字符串部分解析爲對象

var obj={
  protocol:"http:",
  host:"tedu.cn",
  pathname:"course_list/index.html",
  query:{cid:30}
};
console.log(url.format(obj));

var url1="project/static/base.html";
var url2="../img/1.jpg";
console.log(url.resolve(url1,url2));

View Code

4.Path模塊
提供了對文件路徑進行操做的相關方法
parse() //解析一個路徑，參數爲路徑字符串
format() //將路徑對象格式化爲路徑字符串，參數爲對象
join() //用於鏈接路徑，會正確使用當前系統的路徑分隔符
resolve() //根據基礎路徑，解析出目標路徑的絕對路徑
relative() //根據基礎路徑，獲取目標路徑與其的相對關係

var path=require("path");
var str="E:/hanxl/nodejs/day02/01-module.js";
console.log(path.parse(str));

var obj={
  dir:"e:/hanxl/day01",
  base:"01.js"
};
console.log(path.format(obj));

console.log(path.join('d:','hanxl','nodejs','01.js'));

var path1="e:/htdocs/01/login";
console.log(path.resolve(path1,'../img/2.jpg'));
console.log(path.relative(path1,'e:/htdocs/img/3.jpg'));

View Code

5.DNS模塊
提供了域名和IP地址的雙向解析功能。
lookup() //把一個域名解析成一個IP地址，從操做系統中查詢（緩存）
resolve() //把一個域名解析爲一個DNS的記錄解析數組，從DNS服務器中查詢
reverse() //把一個IP地址反向解析爲一組域名

var dns=require("dns");
//把一個域名解析爲一個IP地址，參數1，錯誤對象；參數2，IP地址；參數3，IPV4 OR IPV6
dns.lookup('www.baidu.com',function(err,address,family){
  if(err){
    cosole.log(err);
  }else{
    console.log("lookup():");
    console.log(address);
    console.log(family);
  }
});
//把一個域名解析爲一個DNS記錄解析數組
dns.resolve('www.baidu.com',function(err,address){
  if(err){
    cosole.log(err);
  }else{
    console.log("resolve():");
    console.log(address);
  }
});
//把一個IP地址反向解析爲一組域名
dns.reverse('60.221.254.230',function(err,hostnames){
  if(err){
    console.log(err);
  }else{
    console.log(hostnames);
  }
});

View Code

6.Util 工具模塊
format() //使用帶佔位符的方式格式化字符串
inspect() //返回一個對象的字符串表示
inherits() //實現構造方法之間的繼承

var util=require("util");
var obj={name:"Cola",price:3.9,isOnsale:false};
var s1=util.format('產品名稱：%s，價格：%d，是否促銷商品：%s，%j',obj.name,obj.price,obj.isOnsale,obj);
console.log(s1);

console.log(util.inspect(obj));


//實現構造方法之間的繼承
function Base(){
  this.name="base";
}
Base.prototype.age=20;
function Sub(){
  this.name="sub";
}

util.inherits(Sub,Base);
var user=new Sub();
console.log(user.name);
console.log(user.age);

View Code

7.Buffer
緩衝區，一塊專用於存儲數據的內存區域，與string類型相對應，用於存儲二進制數據。
Buffer對象的實例，能夠經過讀取文件得到，也能夠手動創
建。
Buffer是Global對象的成員，無需require引入。

//建立一個長度爲32字節的緩衝區
var buf1=new Buffer(32);
console.log(buf1);

//建立一個長度爲3字節的緩衝區
var buf2=new Buffer([65,66,67]);//存入十進制
console.log(buf2);
console.log(buf2.toString());//將buffer轉換爲字符串表示

//建立一個長度爲4字節的緩衝區，直接存入英文字符串
var buf3=new Buffer("ABCD");
console.log(buf3);
console.log(buf3.length);

//建立一個緩衝器，存入字符串（英文+中文）,指定編碼方式
var buf4=new Buffer("AB一二","utf8");
console.log(buf4);//一個漢字佔3個字節
console.log(buf4.length);

View Code

8.fs模塊——文件系統模塊
fs模塊提供了文件的讀寫、改名、刪除、遍歷目錄等操做。
fs模塊中大多數方法都帶有同步和異步兩種
全部的異步方法都有一個回調函數，此回調函數的第一個參數都是一個錯誤對象。
異步方法中若是有錯誤的話，會靜默失敗，不會本身拋出error，一般狀況下都須要手動處理。
經常使用Class:
fs.Stats //文件或目錄的統計信息描述對象
fs.ReadStream //stream.Readable接口的實現對象
fs.WriteStream //streamWriteable接口的實現對象
fs.FSWatcher //可用於監視文件修改的文件監視器對象

經常使用的方法：
fs.stat() //用於返回一個文件或目錄的統計信息對象（fs.Stats對象）
fs.mkdir() //建立目錄
fs.rmdir() //刪除目錄
fs.readdir()//讀取目錄下的內容
fs.readFile() //讀取文件內容
fs.writeFile() //向文件中寫入內容
fs.appendFile() //向文件末尾追加內容
fs.unlink() //刪除文件
fs.rename //重命名文件

var fs=require("fs");

var path1="./log";
var path2="./log/out.log";
var stats1=fs.statSync(path1);//同步讀取目錄
//console.log(stats1);
var stats2=fs.statSync(path2);//同步讀取文件
//console.log(stats2);
//異步讀取文件或目錄
fs.stat(path1,(err,stats)=>{
  if(err){
    console.log("文件或目錄讀取失敗！");
  }else{
    console.log("文件讀取成功！");
  }
});

console.log(stats2.isFile());//判斷是否爲文件
console.log(stats2.isDirectory());//判斷是否爲目錄

View Code

var fs=require("fs");
var path='./test';
//讀取一個目錄，若是此目錄不存在，則建立，若是存在，則刪除
fs.stat(path,(err,stats)=>{
  if(err){
    fs.mkdir(path);//建立指定目錄
  }else{
    fs.rmdir(path);//刪除指定目錄
  }
});


//判斷一個目錄是否存在，若存在，讀取目錄下的內容
var path2 ='./node_modules';
fs.stat(path2,(err,stats)=>{
  if(err){
    console.log("當前目錄不存在");
  }else{
    fs.readdir(path2,(err,list)=>{//讀取目錄下的內容
      console.log(list);
    });
  }
});

View Code

fs模塊——文件系統模塊
fs模塊提供了文件的讀寫、改名、刪除、遍歷目錄等操做。
fs模塊中大多數方法都帶有同步和異步兩種
全部的異步方法都有一個回調函數，此回調函數的第一個參數都是一個錯誤對象。
異步方法中若是有錯誤的話，會靜默失敗，不會本身拋出error，一般狀況下都須要手動處理。
經常使用Class:
fs.Stats //文件或目錄的統計信息描述對象
fs.ReadStream //stream.Readable接口的實現對象
fs.WriteStream //streamWriteable接口的實現對象
fs.FSWatcher //可用於監視文件修改的文件監視器對象

經常使用的方法：
fs.stat() //用於返回一個文件或目錄的統計信息對象（fs.Stats對象）
fs.mkdir() //建立目錄
fs.rmdir() //刪除目錄
fs.readdir()//讀取目錄下的內容
fs.readFile() //讀取文件內容
fs.writeFile() //向文件中寫入內容
fs.appendFile() //向文件末尾追加內容
fs.unlink() //刪除文件
fs.rename //重命名文件

---------------------------------------------------------
fs.stat() & fs.statSync() //用於返回一個文件或目錄的統計信息對象（fs.Stats對象）
fs.Stats對象的方法：
stats.isFile() //是否爲文件
stats.isDirectory() //是否爲目錄
----------------------------------
操做目錄：
fs.mkdir() & fs.mkdirSync() //建立目錄
fs.rmdir() & fs.rmdirSync() //刪除目錄
fs.readdir()& fs.readdirSync() //讀取目錄下的內容
------------------------------------
操做文件：
fs.readFile() & fs.readFileSync //讀取文件內容
fs.writeFile() & fs.writeFileSync //向文件中寫入內容
當使用writeFile()方法向文件寫入內容是，若文件不存在，會自動建立指定文件；若是存在，則會替換本來的內容
fs.appendFile() & fs.appendFileSync //向文件末尾追加內容
當使用appendFile()方法向文件寫入內容是，若文件不存在，會自動建立指定文件；若是存在，會在文件末尾追加內容
fs.unlink() & fs.unlinkSync() //刪除文件
fs.rename & fs.renameSync() //重命名文件

var fs=require("fs");//引入fs模塊
//讀取文件
fs.readFile('../day02/02.js',(err,data)=>{
  if(err){
    console.log("文件讀取失敗");
  }else{
    console.log("文件讀取成功");
    console.log(data.toString());
  }
});

//寫入內容
var file1='./log/out.log';
var data1="out.log test file";
fs.writeFile(file1,data1,(err)=>{
  if(err){
    console.log("文件寫入失敗");
    console.log(err);
  }
});
//向文件中追加內容
var file2='./log/out2.log';
var data2="This is test2";
fs.appendFile(file2,data2,(err)=>{
  if(err){
    console.log("文件寫入失敗");
    console.log(err);
  }
});

//刪除文件
fs.unlink('./log/test.txt',(err)=>{
  if(err){
    console.log("刪除文件失敗");
  }
});

//重命名文件
var pathOld="./log/index.html";
var pathNew="./log/login.html";
fs.rename(pathOld,pathNew,(err)=>{
  if(err){
    console.log("重命名失敗");
  }
});

View Code

HTTP模塊
用於構建使用HTTP協議的客戶端應用或服務器端應用
建立併發起請求消息，等待並解析響應消息——實現web客戶端
接收並解析請求消息，構建併發送響應消息——實現web服務器
經常使用對象：
http.ClientRequest
http.Server
http.ServerResponse
http.IncomingMessage

經常使用方法：
http.createServer
http.get()
http.request()

1.http.request
http.request是一個HTTP客戶端工具
用於向web服務器發起一個http請求，並獲取響應數據
有兩個主要方法：
http.get()
http.request()
該方法返回一個http.ClientRequest對象，用來描述請求信息，回調函數的參數是一個http.IncomingMessage，封裝着響應信息。
http.ClientRequest對象經常使用方法：
write()：向服務器追加請求主體數據
end()：提交請求消息主體結束
setTimeout()：設置請求消息超時時間
abort()：終止請求
http.ClientRequest對象經常使用事件：
response：接收到響應消息
abort：請求終止事件
error：請求發生錯誤
注意：使用get()方法不須要手動調用end()方法，使用request()的時候，必須手動調用end()方法。

//使用get()方法發送請求
var http=require("http");

var options={
  hostname:"www.tmooc.cn",
  port:"80",
  path:"/web/index_new.html"
};
var req=http.get(options,(res)=>{
  console.log("接收到響應消息...");
  //console.log(res);
  console.log(`響應狀態碼：${res.statusCode}`);
  console.log(`響應頭：${JSON.stringify(res.headers)}`);

  res.on("data",(chunk)=>{
    console.log(chunk.toString());
  });

});

req.setTimeout(2000,()=>{
  req.abort();
  console.log("請求超時，已終止請求。");
});

req.on("error",(err)=>{
  console.log(`請求發生錯誤：${err}`);
});

View Code

//使用request()方法發送請求
var http=require("http");

var options={
  hostname:"www.tmooc.cn",
  port:"80",
  path:"/web/index_new.html"
};
var req=http.request(options,(res)=>{
  console.log("接收到響應消息...");
  //console.log(res);
  console.log(`響應狀態碼：${res.statusCode}`);
  console.log(`響應頭：${JSON.stringify(res.headers)}`);

  res.on("data",(chunk)=>{
    console.log(chunk.toString());
  });

});

req.setTimeout(2000,()=>{
  req.abort();
  console.log("請求超時，已終止請求。");
});

req.on("error",(err)=>{
  console.log(`請求發生錯誤：${err}`);
});

req.end();

View Code

2.http.server
http.server是一個基於事件的http服務器。
用於建立web服務器，接收客戶端請求，返回響應消息。全部的請求都被封裝到獨立的事件當中，咱們只需對它的事件編寫響應的處理程序，就可用實現http服務器的全部功能。
方法：http.createServer()
用於建立web服務器應用，能夠接收客戶端請求，並返回響應消息。
該方法的返回值是一個http.Server對象
http.Server對象的經常使用方法：
listen()：啓動服務器，監聽指定的服務端口
close()：中止服務器的運行
setTimeout()：設置服務器的響應消息超時時間
http.Server對象的經常使用事件：
connection：出現客戶端鏈接
request：接收到請求消息
close：服務器中止事件
error：響應發生錯誤
http.Server對象的request事件回調函數中有兩個參數
第一個參數，是一個http.IncomingMessage對象，封裝着客戶端提交的請求消息數據。
第二個參數：是一個http.ServerResponse對象，用於構建向客戶端輸出的響應消息數據。

//建立一個簡單的web服務器——沒有給客戶端響應
//引入http模塊
var http=require("http");

//使用http模塊，建立web服務器
var server=http.createServer();

//爲服務器的request事件綁定處理函數
server.on("request",(req,res)=>{
  console.log("web服務器接收到一個請求...");
  console.log(`請求方法：${req.method}`);
  console.log(`請求URL：${req.url}`);
  console.log(`請求版本：${req.httpVersion}`);
  console.log(`請求頭：`);
  console.log(req.headers);
});

//啓動web服務器，監聽指定端口
server.listen(8000,'127.0.0.1',(err)=>{
  if(err){
    console.log("web服務器啓動失敗，錯誤消息爲：");
    console.log(err);
  }else{
    console.log("web服務器啓動成功，正在監聽8000端口...");
  }
});

View Code

/*建立web服務器——給客戶端一個固定響應*/
//引入http模塊
var http=require("http");

//建立web服務器
var server=http.createServer();

//爲http.Server的request事件綁定處理函數
server.on("request",(req,res)=>{
  console.log("接收到一個客戶端請求...");
  res.statusCode=200;//設置響應狀態碼
  res.setHeader("Content-Type","text/html;charset=UTF-8");//設置響應消息頭部
  res.write("<html>");//向客戶端輸出的響應主體內容
  res.write("<head></head>");
  res.write("<body>");
  res.write("<h1>歡迎訪問個人頁面</h1>");
  res.write("</body>");
  res.write("</html>");
  res.end();//響應主體內容完畢，向客戶端發送響應
});

//啓動web服務器，監聽指定端口
server.listen(8000,"127.0.0.1",(err)=>{
  if(err){
    console.log("服務器啓動失敗");
  }else{
    console.log("服務器啓動成功，正在監聽8000端口");
  }
});

View Code

/*建立一個web服務器——根據客戶端請求響應對應的內容*/
//引入模塊
var http=require("http");
var url=require("url");
var fs=require("fs");
//建立web服務器
var server=http.createServer();
//爲server的request事件綁定處理函數
server.on("request",(req,res)=>{
  //1.解析出客戶端請求的url，req.url
  var urlInfo=url.parse(req.url);
  var path='.'+urlInfo.pathname;
  //2.讀取客戶端請求的文件內容，fs.readFile()
  fs.readFile(path,(err,data)=>{
    if(err){
      console.log("文件讀取失敗");
    }else{
      //3.向客戶端輸出響應內容，res.write()
      res.statusCode=200;
      res.setHeader('Content-Type','text/html;charset=UTF-8');
      res.write(data);
      res.end();
    }
  });

});
//啓動web服務器，監聽指定端口
server.listen(8000,"127.0.0.1",(err)=>{
  if(err){
    console.log("服務器啓動失敗");
  }else{
    console.log("服務器啓動成功，正在監聽8000端口...");
  }
});

View Code

MySQL模塊
方法：
createConnection() //建立一個mysql服務器的鏈接
該方法返回一個鏈接對象，該對象有如下經常使用方法：
connect() //鏈接數據庫
query() //提交SQL語句給MySQL服務器執行
end() //斷開與MySQL服務器的鏈接

/*查詢mysql數據庫中的數據*/
//引入mysql模塊
var mysql=require("mysql");
//鏈接到mysql服務器
var options={
  host:"127.0.0.1",
  user:"root",
  password:"",
  database:"user_0120"
};
var conn=mysql.createConnection(options);
conn.connect();//能夠省略

//提交SQL語句給mysql服務器執行
var sql='SELECT * FROM user';
conn.query(sql,(err,rows)=>{
  if(err){
    console.log("數據查詢失敗");
  }else{
    console.log("查詢完成");
    //console.log(rows);
    for(var i=0;i<rows.length;i++){
      console.log(`用戶名：${rows[i].uname},密碼：${rows[i].upwd}`);
    }
  }
});

//斷開與mysql服務器的鏈接
conn.end();

View Code

/*向mysql數據庫中插入數據*/
//引入mysql模塊
var mysql=require("mysql");
//建立鏈接
var options={
  host:"127.0.0.1",
  user:"root",
  password:"",
  database:"user_0120"
};
var conn=mysql.createConnection(options);

//提交SQL語句
var sql='INSERT INTO user VALUES(NULL,"Jack","111")';
conn.query(sql,(err,data)=>{
  if(err){
    console.log("寫入數據失敗");
  }else{
    console.log("寫入數據成功");
    console.log(`SQL語句影響的行數：${data.affectedRows}`);//得到影響的行數
    console.log(`INSERT產生的自增編號：${data.insertId}`);//得到自增主鍵
  }
});

//斷開鏈接
conn.end();

View Code

express模塊
能夠方便的實現服務器的路由、發送和接收http請求，返回響應、發送和接收cookie以及實現模板引擎功能。

app.method(path,[middleware,]function(req,res){})

中間件

/*實現動態web服務器*/
//引入相關模塊
var http=require("http");
var url=require("url");
var fs=require("fs");
var mysql=require("mysql");
var path=require("path");
//建立web服務器
var server=http.createServer();
//爲request事件綁定處理函數
server.on("request",doRequest);
//啓動服務器，監聽指定端口
server.listen(8001,"127.0.0.1",(err)=>{
  if(err){
    console.log("服務器啓動失敗");
    console.log(err);
  }else{
    console.log("服務器啓動成功，正在監聽8001端口");
  }
});

var urlInfo;
//處理客戶端的http請求
function doRequest(req,res){
  console.log("請求的url爲："+req.url);
  urlInfo=url.parse(req.url,true);//解析請求的url
  //獲得請求的url的文件名後綴
  var urlSuffix=path.parse(urlInfo.pathname).ext;
  //console.log(urlSuffix);
  if(urlSuffix==".do"){//以.do結尾的動態請求
    doDynamic(req,res);//處理動態請求
  }else{//其餘結尾的靜態請求
    doStatic(req,res);//處理靜態請求
  }
}

//處理靜態請求,直接讀取指定的文件發送給客戶端便可
function doStatic(req,res){
  var path='.'+urlInfo.pathname;
  fs.readFile(path,(err,data)=>{
    if(err){
      console.log("文件讀取失敗");
    }else{
      //3.向客戶端輸出響應內容，res.write()
      res.statusCode=200;
      res.setHeader('Content-Type','text/html;charset=UTF-8');
      res.write(data);
      res.end();
    }
  });
}

//處理動態請求
function doDynamic(req,res){
  var base=path.parse(urlInfo.pathname).base;
  if(base=="login.do"){//處理登陸
    console.log(urlInfo.query);

  }else if(base=="register.do"){//處理註冊

  }
}

View Code

/*使用express搭建服務器*/
//引入express模塊
var express=require("express");
//建立express類的實例，做爲http服務器
var app=express();
//啓動express服務器，監聽8002端口
app.listen(8002);

//訪問根目錄
app.get("/",(req,res)=>{
  res.send("您訪問的是根目錄");
});
//訪問具體目錄
app.get("/html/index.html",(req,res)=>{
  res.send("您訪問的是html目錄");
});
//使用正則匹配
app.get(/\/log/,(req,res)=>{
  res.send("您訪問的是log目錄");
});

View Code

/*使用express搭建服務器*/
//引入express模塊
var express=require("express");
//建立express類的實例，做爲http服務器
var app=express();
//啓動express服務器，監聽8002端口
app.listen(8003);


//訪問靜態資源
app.use(express.static(__dirname));
//app.use("/h",express.static("html"));

app.get('/html/login.do',(req,res)=>{
});

app.get('/html/register.do',(req,res)=>{
});

View Code

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。