nodejs笔记总结

nodejs笔记

本笔记根据河北师范大学软件学院王顶老师授课内容及网络资料编写，如果侵权，联系删除~

如有错误欢迎联系更正~

nodejs简介，及常见名词解释

（此处的简介可以在后面文章中遇到疑问再返回此处查看）

nodejs是什么

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。
Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型。
Node 是一个让 JavaScript 运行在服务端的开发平台。
实质是对Chrome V8引擎进行了封装，使用C++实现。

node主要特征

1、单线程
在Java、PHP或者.net等服务器端语言中，会为每一个客户端连接创建一个新的线程。而每个线程需要耗费大约2MB内存。也就是说，理论上，一个8GB内存的服务器可以同时连接的最大用户数为4000个左右。要让Web应用程序支持更多的用户，就需要增加服务器的数量，而Web应用程序的硬件成本当然就上升了。
Node.js不为每个客户连接创建一个新的线程，而仅仅使用一个线程。当有用户连接了，就触发一个内部事件，通过非阻塞I/O、事件驱动机制，让Node.js程序宏观上也是并行的。使用Node.js，一个8GB内存的服务器，可以同时处理超过4万用户的连接。另外，单线程的带来的好处，还有操作系统完全不再有线程创建、销毁的时间开销。坏处，就是一个用户造成了线程的崩溃，整个服务都崩溃了，其他人也崩溃了。
2、异步I/O
例如，当在访问数据库取得数据的时候，需要一段时间。在传统的单线程处理机制中，在执行了访问数据库代码之后，整个线程都将暂停下来，等待数据库返回结果，才能执行后面的代码。也就是说，I/O阻塞了代码的执行，极大地降低了程序的执行效率。
由于Node.js中采用了非阻塞型I/O机制，因此在执行了访问数据库的代码之后，将立即转而执行其后面的代码，把数据库返回结果的处理代码放在回调函数中，从而提高了程序的执行效率。
当某个I/O执行完毕时，将以事件的形式通知执行I/O操作的线程，线程执行这个事件的回调函数。为了处理异步I/O，线程必须有事件循环，不断的检查有没有未处理的事件，依次予以处理。
阻塞模式下，一个线程只能处理一项任务，要想提高吞吐量必须通过多线程。而非阻塞模式下，一个线程永远在执行计算操作，这个线程的CPU核心利用率永远是100%。
3、事件驱动
在Node中，客户端请求建立连接，提交数据等行为，会触发相应的事件。在Node中，在一个时刻，只能执行一个事件回调函数，但是在执行一个事件回调函数的中途，可以转而处理其他事件（比如，又有新用户连接了），然后返回继续执行原事件的回调函数，这种处理机制，称为“事件环”机制。
Node.js底层是C++（V8也是C++写的）。底层代码中，近半数都用于事件队列、回调函数队列的构建。

运行 node.js 脚本文件时要省略 node 命令，如何操作

在脚本代码前面加入#!/usr/bin/node，并对脚本文件增加可执行权限
增加 linux 文件的可执行权限 chmod u+x file-name

node的单线程

​ 在开启电脑后，会运行浏览器，微信，视频等软件，然而cpu数量很少，所以使用的时并发的方式，即cpu给不同的进程分配时间片。打开视频，不仅可以有画面，还有音频播放等等，其实是这些进程内的线程在起作用。 一个进程至少要有一个线程。
​ node和浏览器中的JavaScript都是单线程的。 但是，我们要理解node的单线程到底是什么意思？实际上， 这里所说的单线程是指我们所编写的代码运行在单线程上，实际上node不是真正的单线程。比如我们执行 node app.js 时启动了一个进程，但是这个进程并不是只有一个线程，而是同时创建了很多歌线程（比如：异步IO需要的一些IO线程）。 但是，仍然只有一个线程会运行我们编写的代码。 这就是node中单线程的含义。

但是node单线程会导致下面的问题：

无法利用多核CPU（只能获得一个CPU的时间分片）。
错误就会引起整个应用退出（整个应用就一个进程，挂了就挂了）。
大量计算长时间占用CPU，导致阻塞线程内的其他操作（异步IO发不出调用，已完成的异步IO回调不能及时执行）。

http请求协议

http介绍

根据HTTP标准，HTTP请求可以使用多种请求方法。例如：HTTP1.1支持7种请求方法：GET、POST、HEAD、OPTIONS、PUT、DELETE和TARCE。在Internet应用中，最常用的方法是GET和POST。

http请求头

1. 起始行：HTTP请求方法 URL HTTP版本
2. 请求头：请求头的形式通过一个键值对进行渲染
3. 请求体：get方法的请求体是没有内容的（放在了url里） post方法的请求体包含请求的内容

/*起始行*/
GET /sample.jsp HTTP/1.1
/*请求头*/
Accept:image/gif.image/jpeg,*/*
Accept-Language:zh-cn
Connection:Keep-Alive
Host:localhost
User-Agent:Mozila/4.0(compatible;MSIE5.01;Window NT5.0)
Accept-Encoding:gzip,deflate 
/*请求体*/
username=jinqiao&password=123412345678

http响应头

1. 起始行：HTTP协议版本 响应状态码 响应状态信息
2. 响应头(Response Header) ：通过键值对的形式进行表示
3. 响应体： 网页代码 HTML、CSS、JS代码文件

HTTP/1.1 200 OK
Server:Apache Tomcat/5.0.12
Date:Mon,6Oct2003 13:23:42 GMT
Content-Length:112


    
        


    
<%=description%>
    

<% function data(data) { %>
        
<%=data.time%><%=data.title%>
<% } %>
<% datas.map(data) %>
    

以上为模板的代码，然后再在创建的服务器中将其返回给浏览器

function showpage(req,res){
  	var html = fs.readFileSync('./template.html');
  	html = html.replace('%',item.map(function(item){  //yong %tihuan
  		return '
' + item + '
';
	}).join('\n'));
 	res.end(html);
}

后台模板渲染与前后端分离的比较

后端渲染：

页面呈现速度：快，受限于用户的带宽
流量消耗：少一点点（可以省去前端框架部分的代码）
可维护性：差（前后端东西放一起，掐架多年，早就在闹分手啦）
seo友好度：好
编码效率：低（这个跟不同的团队不同，可能不对）

前端渲染：

页面呈现速度：主要受限于带宽和客户端机器的好坏，优化的好，可以逐步动态展开内容，感觉上会更快一点。
流量消耗：多一点点（一个前端框架大概50KB）当然，有的用后端渲染的项目前端部分也有在用框架。
度可维护性：好，前后端分离，各施其职，代码一目明了。
SEO友好度：差，大量使用ajax，多数浏览器不能抓取ajax数据。
编码效率：高，前后端各自只做自己擅长的东西，后端最后只输出接口，不用管页面呈现，只要前后端人员能力不错，效率不会低。

http高级编程用法

获取文件

//将上传的文件输出到同级目录下
getFile(){
    req.setEncoding('binary');  //设置编码
    var file;
    req.on('data', (data)=>{
      file += data;
    });

    req.on('end', ()=>{
      log(file.split('\r\n'));
      var buf = file.split('\r\n')[4];
      var files = file.split('\r\n')[1].split(';');
      var fileName = qs.parse(files[2].trim())['filename'];
      fileName = fileName.slice(1, fileName.length-1);
      fs.writeFileSync(fileName, buf, {'encoding': 'binary'});
    });
}
//此方法不能用于所有图片，具体split截取的内容要根据图片不同类型或大小做出调整，统一式获取下文中有介绍，此处介绍的为底层方法

图片操作

//上传图片
function writePic(file) {
  var data = file.split('\r\n');
  var fileName = qs.parse(data[1].split(';')[2].trim())['filename'],
      start = data[0].length + data[1].length + data[2].length + data[3].length + 8,
      end   = file.indexOf('------WebKitFormBoundary', start),
      buf   = file.slice(start, end);

  fileName = fileName.slice(1, fileName.length-1);

  if(fileName === '') return false;

  fileName = path.join(__dirname, 'images', fileName);
  fs.writeFileSync(fileName, buf, {'encoding': 'binary'});
  
  return true;
}

//向浏览器发送图片
function sendPic(req, res) {
  var info = req.url.split('/'),
      pic  = path.join(__dirname, req.url),
      ext = info[2].split('.')[1];

  if(info.length !== 3 || !fs.existsSync(pic)) {
    show(res, errorPage);
    return;
  }

  res.statusCode = 200;
  res.setHeader('Content-Type', 'image/' + ext);
  res.setHeader('Content-length', fs.statSync(pic).size);
  res.end(fs.readFileSync(pic));
}

cookie使用

//查看cookie
log(req.headers['cookie']);   //a=1; b=2
log(req.headers['cookie'].split(';'));    //[ 'a=1', ' b=2' ]
//设置cookie
res.setHeader('Set-cookie', ['name=wangding; Httponly', 'age=42; max-age=1000']);

/*
*有的网站会默认请求favicon.ico，所以当你用cookie记录增量时会成双倍增加
*此时须添加if(req.url === '/favicon.ico') return;
*/

其他一些功能如session辅助登录、服务器代理等功能将在express中介绍，此处将不再使用原生去写。

express框架

使用express框架既可以写后台模板渲染的服务器也可以写前端渲染的服务器。

前端渲染（即使用模板）

​ 使用生成器

$ npm install express-generator -g   //全局下载生成器
$ express --view=ejs myapp           //创建叫做myapp的项目，使用ejs模板
$ cd myapp                           //进入项目中
$ npm install                        //安装全部依赖
$ DEBUG=myapp:* npm start            //mac或linux中的打开项目
> set DEBUG=myapp:* & npm start      //windows中的打开项目

.
├── app.js 
├── bin
│   └── www    （入口文件）
├── package.json   
├── public 
│   ├── images
│   ├── javascripts
│   └── stylesheets
│       └── style.css
├── routes
│   ├── index.js
│   └── users.js
└── views
    ├── error.pug
    ├── index.pug
    └── layout.pug

//此项目为mvc架构，routes为C，views为V，此后手动添加数据存储（文件存储或数据库）作为M。

后端渲染（即提供接口）

​ 通常我们将创建两个服务器，一个提供静态资源，一个提供接口服务

​ 基本路由 (var app = express()

const express = require("express");
const path = require("path");
const bodyParser = require("body-parser");
const data = require("./data.json");
var app = express();

app.use(express.static(path.join(__dirname, 'public')));   //设置静态资源，html中的资源会自动将public当作根目录去查询资源
app.use(bodyParser.json());     //设置post请求的中间件，与下面一行同时使用后app方可使用post()方法
app.use(bodyParser.urlencoded({ extended: false }));   //与上一句同时使用设置post请求


app.use('/list/', (req, res, next) => {
    loginOK = false;
    for (let i = 0; i < data.users.length; i++) {
        if (data.users[i].username == req.body.username && data.users[i].password == req.body.pwd) {
            loginOK = true;
        }
    }
    if (loginOK) {
        next()
    } else {
        res.writeHead(200, {
            'Content-Type': 'text/html;charset=utf-8'
        });
        res.end("用户名或密码错误")
    }
})


app.get('/', (req, res) => {
    res.type('text/html');
    res.status(200);
    res.sendfile(`${__dirname}/public/login.html`)
})



app.post('/list/', (req, res) => {
    var query = req.body;    //post请求的数据存在此处
    console.log(req.body);
    res.type('text/html');
    res.status(200);
    res.sendfile(`${__dirname}/public/list.html`)
})

app.get('/listDetil/', (req, res) => {
    console.log("ok");
    res.type('text/html');
    res.status(200);
    res.json(data.chapterList);
    // res.end("neirong");
})

app.listen(8080);

​ 模块化路由 (var router = express.Router()

 //将路由模块化，通过模块引入到app.js 
//app.js
const express = require('express');
const app = express();

const books = require('./router/books.js');

app.get('/', function(req, res) {
  res.end('hello world');
});

app.use('/books', books);

app.listen(8080);
//books.js
  
const express = require('express');
const router = express.Router();

router.use(function(req, res, next) {
  console.log(Date.now());
  next();
});

router.get('/', function(req, res) {
  res.end('books');
});

router.get('/list', function(req, res) {
  res.end('books-list');
});

module.exports = router;

常用功能

​ 实现代理（解决跨域问题）

//当前后端分离的时候，常开启两个服务器，一个提供静态资源，一个提供接口服务。
//当一个服务器开启两个服务的时候，必须打开两个接口（例如3000和5000），拿在3000端口返回的html文件就无法请求到5000端口中的接口，也就是所谓的跨域问题
//在提供静态服务的服务器中（假设静态服务打开的是3000端口），加入一下代码

//使用到的中间件 http-proxy-middleware

var proxy=require("http-proxy-middleware");

app.use('/api',proxy({
  target:'http://localhost:5000',    //要转接到的地址
  changeOrigin:false,
  pathRewrite:{
    "^/api":""
  }
}))

//这样在3000端口的静态资源中请求接口可直接写为src='/api'

​ 图片上传

//使用到中间件 multer

let fs = require('fs');
let express = require('express');
let multer = require('multer');

let app = express();

/**
 * 多文件上传
 * 设置文件名 filename()
 * 设置存储图片路径 destination()
 * 图片信息 req.files
 * 其他非图片数据 req.body
 */
const storage = multer.diskStorage({
    destination: function (req, file, cb) {   //设置存放位置
        cb(null, './datadb/upload-multer/')     
    },
    filename(req, file, cb) {   //设置文件名字，此处设为时间戳
        const filenameArr = file.originalname.split('.');
        cb(null, Date.now() + '.' + filenameArr[filenameArr.length - 1]);
    }
});

let uploadMulti = multer({ storage })
//uploadMulti.array中参数第一个为图片名字，第二个参数为上传图片个数
app.post('/upload-multi', uploadMulti.array('logos', 1), (req, res, next) => {
    var files = req.files;
    var fileInfos = [];

    // 获取文件信息
    for (let i in files) {
        var file = files[i];
        var fileInfo = {};

        fileInfo.mimetype = file.mimetype;
        fileInfo.originalname = file.originalname;
        fileInfo.size = file.size;
        fileInfo.path = file.path;

        fileInfos.push(fileInfo);
    }

    // 设置响应类型及编码
    res.set({
        'content-type': 'application/json; charset=utf-8'
    });
    console.log(req.body);
    res.end(JSON.stringify(fileInfos), 'utf8');
});


/**
 * http服务
 */
app.get('/', (req, res, next) => {
    let form = `

    
多文件上传
    

        
    
    

         
    
    上传
`
//此处两个表单name名字相同
    res.send(form);
});

app.listen(8080);

​ cooike使用

const express = require('express'),
      cookieParser = require('cookie-parser'),
      app     = express();

app.use(cookieParser());     //设置中间件
app.get('/', (req, res) => {
  if(typeof req.cookies.login === 'undefined') {    //cookie存储在req.cookies中
    res.render('login');
  } else if(req.cookies.login === 'true') {
    res.render('index');
  } else {
    res.render('login');
  }
  console.log('cookie:', req.cookies);

  res.cookie('name', 'wangding', {maxAge: 100000, httpOnly: true});//设置cookie
  res.cookie('age', 41, {maxAge: 100000});
  res.send('OK!');
});

app.listen(8080);

​ session会话

//服务器端生成了一个sessionn-id，客户端使用了cookie保存了session-id这个加密的请求信息，而将用户请求的数据保存在服务器端，但是它也可以实现将用户的数据加密后保存在客户端。

//session记录的是客户端与服务端之间的会话状态，该状态用来确定客户端的身份。可以存放在cookie中，也可以存放在内存中，或者是redis、mongodb等第三方服务器中。session默认存放在内存中，存放在cookie中安全性太低，存放在非redis数据库中查询速度太慢，一般项目开发中都是存放在redis中(缓存数据库)。

//cookie保存session
//session信息是不可见的，同时也是不可改的，而且在客户端关闭浏览器后数据消失。
var path = require('path');
var express = require('express');
var session = require('express-session');
var app = express();

app.use(session({
    name: 'session-name', // 这里是cookie的name，默认是connect.sid
    secret: 'my_session_secret', // 建议使用 128 个字符的随机字符串
    resave: true,
    saveUninitialized: false,
    cookie: { maxAge: 60 * 1000, httpOnly: true }
}));

app.get('/', function(req, res, next) {
    if(req.session.isFirst || req.cookies.isFirst) {
        res.send("欢迎再一次访问");
    } else {
        req.session.isFirst = 1;
        res.cookie('isFirst', 1, { maxAge: 60 * 1000, singed: true});
        res.send("欢迎第一次访问。");
    }
});

app.listen(3030, function() {
    console.log('express start on: ' + 3030)
});



//数据库保存session
//用数据库保存session，我们一般使用redis，因为它是缓存数据库，查询速度相较于非缓存的速度更快。
//使用数据库保存session数据，在浏览器端的session-id会随着浏览器的关闭而消失，下次打开浏览器发送请求时，服务器依然不能识别请求者的身份。
var path = require('path');
var express = require('express');
var redisStore = require('connect-redis')(session);
var session = require('express-session');
var app = express();

app.use(session({
    name: 'session-name', // 这里是cookie的name，默认是connect.sid
    secret: 'my_session_secret', // 建议使用 128 个字符的随机字符串
    resave: true,
    saveUninitialized: false,
    store: new redisStore({
        host: '127.0.0.1',
        port: '6379',
        db: 0,
        pass: '',
    })
}));

app.get('/', function(req, res) {
    if (req.session.isFirst) {
        res.send("欢迎再一次访问。");
        console.log(req.session)
    } else {
        req.session.isFirst = 1;
        res.send("欢迎第一次访问。");
    }
});

app.listen(3030, function() {
    console.log('express start on: ' + 3030)
});


//cookie和数据库同时保存session
var path = require('path');
var express = require('express');
var cookieParser = require('cookie-parser');
var redisStore = require('connect-redis')(session);
var session = require('express-session');
var app = express();

app.use(cookieParser());
app.use(session({
    name: 'session-name', // 这里是cookie的name，默认是connect.sid
    secret: 'my_session_secret', // 建议使用 128 个字符的随机字符串
    resave: true,
    saveUninitialized: false,
    // cookie: { maxAge: 60 * 1000, httpOnly: true },
    store: new redisStore({
        host: '127.0.0.1',
        port: '6379',
        db: 0,
        pass: '',
    })
}));

app.get('/', function(req, res, next) {
    if(req.session.isFirst || req.cookies.isFirst) {
        res.send("欢迎再一次访问");
    } else {
        req.session.isFirst = 1;
        res.cookie('isFirst', 1, { maxAge: 60 * 1000, singed: true});
        res.send("欢迎第一次访问。");
    }
});

app.listen(3030, function() {
    console.log('express start on: ' + 3030)
});

res方法总结

express封装后res的常用方法	描述
res.end()	快速结束响应，可传数据，但不建议
res.json()	发送json相应
res.sendFile()	在给定的位置传输文件
res.send()	发送http相应可以是buf对象可以是String对象
res.render()	可发送html文件
res.sendStatus()	返回状态码
res.set()	设置请求头 ({ ‘content-type’: ‘application/json; charset=utf-8’ });

数据库编程（以mysql为例）

数据存储的方式一共有三种：内存存储、文件存储、数据库存储

配置mysql

• 运行配置命令

mysql_secure_installation

• 配置MySQL支持中文

# 打开my.cnf配置文件进行编辑
sudo vi /etc/my.cnf
# 修改对应的代码文件
[mysqld]
character-set-server=utf8
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8

# 重新启动服务
sudo systemctl restart mariadb

MySql操作（此命令为在centos上下载mysql）

su # 切换到root用户
yum install -y mariadb mariadb-server # 安装MySQL服务器
systemctl start mariadb # 启动MySQL服务

eg：若安装mysql后无法启动，可参考本篇文章解决问题

数据库操作

mysql -u root -p     #使用root用户登录数据库

##数据库
#查看所有数据库
show databases;
#创建数据库
create database nodejs;
#删除数据库
drop database nodejs;
#连接数据库
use nodejs;


##表
#创建表
create table MyClass(
> id int(4) not null primary key auto_increment,
> name char(20) not null,
> sex int(4) not null default '0',
> degree double(16,2));
#删除表
drop table MyClass;


##数据
#增
insert into MyClass values(1,'Tom',1,96.45),(2,'Joan',1,82.99), (3,'Wang',1, 96.59);
#删
delete from MyClass where id=1;
#改
update MyClass set name='Mary' where id=1;
#查
select * from MyClass;

在nodejs中使用数据库

const mysql = require('mysql');   //引入第三方库

const con = mysql.createConnection({
  host:'localhost',
  user:'root',
  password:'123456',
  database:'MyClass'
});

con.conent();   //连接数据库
// database operation
// 查 const sql = 'select * from books';
// 增 const sql = 'insert into books where book_id = ?';
// 改 const sql = 'update books set status = ? where book_id = ?';
// 删 const sql = 'delete from books where book_id = ?';
con.query(sql,[1],(err,result)=>{
  	if(err){
  		console.error(err);
      	process.exit(1000);
	}
  	console.log(result);
});

con.end();