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服务器。

Node.js的意义:
1.执行效率比PHP/JSP/JAVA要快
2.用一种语言统一了前后端开发。

全栈工程师

特点:
1.单线程逻辑处理
2.非阻塞
3.异步I/O处理
4.事件驱动编程

2.Node.js的两种运行方式:
1.交互模式——用于测试
读取用户输入、执行运算、输出执行结果、继续下一循环
执行方法:输入一行js语句,回车执行
2.脚本模式——用于开发
把要执行的所有js语句编写在一个独立的js文件中,一次性的提交给nodejs处理。此文件可以没有后缀
执行方法:node d:\xx\xx.js

3.Node.js的基础语法及ES6新特性
1.数据类型:
(1)原始类型
string、number、boolean...
原始类型数据直接赋值即可
(2)引用类型
ES原生对象、Node.js对象、自定义对象
引用类型通常需要使用new关键字创建

//原始类型
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不再指向全局

//"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需要启用严格模式。

"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



  
  





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

除主模块之外的其他模块都称为子模块。
默认情况下,某一个模块不能直接使用其他模块中封装的数据,但是每个模块可以导出(exports)自己内部的对象供其他模块使用,也可用引入(require)并使用其他模块导出的对象。

每一个模块内部都可以使用一个变量:module,指向当前模块自己。
//判断当前模块是否主模块
console.log(require.main===module);
模块的引入:require()
(在交互模式下,Node.js自带的模块无需引入,直接使用)
导出模块中的属性和方法供其他模块使用:exports

预定义的模块作用域成员:
__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:[email protected]: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 //重命名文件

---------------------------------------------------------
fs.stat() & fs.statSync() //用于返回一个文件或目录的统计信息对象(fs.Stats对象)
fs.Stats对象的方法:
stats.isFile() //是否为文件
stats.isDirectory() //是否为目录
----------------------------------
操作目录:
fs.mkdir() & fs.mkdirSync() //创建目录
fs.rmdir() & fs.rmdirSync() //删除目录
fs.readdir()& fs.readdirSync() //读取目录下的内容

 

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("");//向客户端输出的响应主体内容
  res.write("");
  res.write("");
  res.write("

欢迎访问我的页面

"); res.write(""); res.write(""); 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){
      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

 

转载于:https://www.cnblogs.com/skorzeny/p/7674842.html

你可能感兴趣的:(javascript,运维,json,ViewUI)