nodejs笔记

最新推荐文章于 2024-10-08 16:04:22 发布

技术钱

最新推荐文章于 2024-10-08 16:04:22 发布

阅读量1k

点赞数 9

文章标签：笔记 node.js 前端

本文链接：https://blog.csdn.net/qq_40121308/article/details/141388970

版权

概念

Node.js是一个javascript运行环境，它让javascript可以开发后端程序，实现几乎其他后端语言实现的所有功能，可以与php、java、paython、.net、ruby等后端语言平起平坐。

模快、包、commonjs

为什么要有模块化开发
CommonJs规范
modules模块化规范写法
可以把公共的功能抽离成为一个单独的js文件作为一个模块，默认情况下面这个模块里面的方法或者属性，外面是没办法访问的，如果让外部访问模块里面的方法或属性，就必须在模块里面通过exports或者module.exports暴露属性或者方法。
Npm & Yarn

npm的使用

npm init 
npm install 包名 -g (uninstall, update)
npm install 包名 --save-dev (uninstall,update)
npm list -g (不加-g, 列举当前目录下的安装包)
npm info 包名（详细信息）npm info 包名 version(获取最新版本)
npm install md5@1(安装指定版本)
npm outdated(检查包是否已经过时)

"dependencies": { "md5": "^2.1.0" } ^表示 如果直接 npm install 将会安装md5 2.*.* 最小版本
"dependencies": { "md5": "~2.1.0" } ~表示 如果直接 npm install 将会安装md5 2.1.*最新版本
"dependencies": { "md5": "*" } * 表示 如果直接npm install将会安装md5最新版本

全局安装nrm

nrm是npm的镜像源管理工具，有时候国外资源太慢，使用这个就可以快速地在npm源间切换。
手动切换方法：npm config set registry https://registry.npm.taobao.org

安装nrm

npm install -g nrm

使用nrm

执行命令nrm ls 查看可选的源，其中，带*的是当前使用的源，上面的输出表明当前源是官方源

切换nrm

如果要切换到taobao源，执行命令nrm use taobao

测试速度

可以通过nrm test测试相应源的响应速度

npm install -g cnpm --registry=https://registry.npmmirror.com

yarn使用

npm install -g yarn

对比npm:
  速度超快：Yarn缓存了每个下载过的包，所有再次使用时无需重复下载，同时利用并行下载以最大化资源利用率，因此安装速度快，
  超级安全：在执行代码之前，Yarn会通过算法校验每个安装包的完整性。
开始项目 yarn init
添加依赖包
  yarn add [package]
  yarn add [package]@[version]
  yarn add [package] --dev
升级依赖包
  yarn upgrade [package]@[version]
移除依赖包
  yarn remove [package]  
安装项目的全部依赖
  yarn install

内置模块

http模块
要使用HTTP服务器和客户端，则必须require(‘http’)

const http = require('http')
// 创建本地服务器来从其接受数据
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-Type': 'application/json' })
  res.end(JSON.stringify({
    data: 'hello world'
  }))
})
server.listen(8000)

const http = require('http')
// 创建本地服务器来从其接受数据
const server = http.createServer()

// 监听请求事件
server.on('request', (request, res) => {
  res.writeHead(200, { 'Content-type': 'application/json' })
  res.end(JSON.stringfy({
    data: 'hello world'
  }))
})

server.listen(8000)

url模块

2.1 parse

const url = require('url')
const urlString = 'https://www.baidu.com:443/ad/index.html?id=8&name=mouse#tag=110'
const parsedStr = url.parse(urlString)
console.log(parsedStr)

2.2 format

const url = require('url')
const urlObject = {
  protocol:'https:',
  slashes: true,
  auth: null,
  host: "www.baidu.com:443",
  port: '443',
  hostname: 'www.baidu.com',
  hash: '#tag=110',
  search: '?id=8&name=mouse',
  query: { id: 8, name: 'mouse' },
  pathname: '/ad/index.html',
  path: '/ad/index.html?id=8&name=mouse'
}
const parseobj = url.format(urlObject)
console.log(parseobj)

2.3 resolve

const url = require('url')
var a = url.resolve('/one/two/three', 'four')
var b = url.resolve('http://example.com/', '/one')
var c = url.resolve('http://example.com/one', '/two')
console.log(a + ',' + b + ',' + c)

querystring模块

3.1 parse 将字符串转成对象

const querystring = require('querystring')
var qs = 'x=3&y=4'
var parsed = querystring.parse(qs)
console.log(parsed) // {x:3, y: 4}

3.2 stringify 将对象转成字符串

const querystring = require('querystring')
var qo = {
  x: 3,
  y: 4
}
var parsed = querystring.stringify(qo)
console.log(parsed) // x=3&y=4

3.3 escape/unescape

这时正常情况下能查询到一条数据，如果将param修改成
let param = ‘ns"–’
sql语句就会变成 select*from tb_nature where nature = ‘ns’–" and del_status=1后面的del_status机会被参数中的–注释掉，失去作用，能查询到到多条数据。
如果对param使用escape包装下，就能将参数中的特性字符进行转义，防止sql的注入。let sql = ‘select *from tb_nature where nature=’ + mysql.escape(param) + ‘and del_status=1’

const querystring = require('querystring')
var str = 'id=3&city=北京&url=https://www.baidu.com'
var escaped = querystring.escape(str)
console.log(escaped) // id%3D3%26city%3D%E5%8C%97%E4%BA%AC%26url%3Dhttps%3A%2F%2Fwww.baidu.com

const querystring = require('querystring')
var str = 'id%3D3%26city%3D%E5%8C%97%E4%BA%AC%26url%3Dhttps%3A%2F%2Fwww.baidu.com'
var unescaped = querystring.unescape(str)
console.log(unescaped) // id=3&city=北京&url=https://www.baidu.com

http模块补充

4.1 接口： jsonp

const http = require('http')
const url = require('url')
const app = http.createServer((req, res) => {
  let urlobj = url.parse(req.url, true)
  switch(urlobj.pathname) {
    case '/api/user':
      res.end(`${urlobj.query.cb}({"name":"gp145"})`)
      break;
    default:
      res.end('404.')
      break;  
  }
})

app.listen(8080, () => {
  console.log('localhost:8080')
})

4.2 跨域： CORS

const http = require('http')
const url = require('url')
const querystring = require('querystring')

const app = http.createServer((req, res) => {
  let data = ''
  let urlObj = url.parse(req.url, true)
  res.writeHead(200, {
    'Content-type': 'application/json;charset=utf-8',
    'Access-control-Allow-Origin': '*'
  })
  req.on('data', (chunk) => {
    data += chunk
  })
  req.on('end', () => {
    responseResult(querystring.parse(data))
  })
  
  function responseResult(data) {
    switch(urlobj.pathname) {
      case '/api/login':
        res.end(JSON.stringify({
          message: 'data'
        }))
    }
  }
})

4.3 get

var http = require('http')
var https = require('https')
var url = require('url')

http.createServer((req, res) => {
    var urlobj = url.parse(req.url, true)
    res.writeHead(200, {
        'Content-type': 'application/json;charset=utf-8',
        'Access-control-Allow-Origin': '*'
    })

    switch(urlobj.pathname) {
        case "/api/aaa":
            httpget(data=> {
              res.end(data)
            })
            break;
        default : 
        res.end('404')    
    }
}).listen(3000)

function httpget(cb) {
    var data = ''
    https.get('xxx.com', (res) => {
        res.on('data', (chunk) => {
            data+=chunk
        })
        res.on('end', () => {
            cb(data)
        })
    })
}

4.4 post

var http = require('http')
var https = require('https')
var url = require('url')

http.createServer((req, res) => {
    var urlobj = url.parse(req.url, true)
    res.writeHead(200, {
        'Content-type': 'application/json;charset=utf-8',
        'Access-control-Allow-Origin': '*'
    })

    switch(urlobj.pathname) {
        case "/api/aaa":
            httpPost(data => {
                res.end(data)
            })
            break;
        default : 
        res.end('404')    
    }
}).listen(3000)

function httpPost(cb) {
    var data = ''

    var options = {
        hostname: 'xxx.com',
        port: '443',
        path: '路径',
        method: 'POST',
        headers: {
            "Content-Type": 'application/json'
        }
    }
    var req = https.request(options, (res) => {
        res.on('data', chunk => {
            data+=chunk
        })
        res.on('end', () => {
            cb(data)
        })
    })
    req.write(JSON.stringify([{},{"baseParam":{"ypClient": 1}}]))
    req.end()
}

4.5 爬虫

var http = require('http')
var https = require('https')
var url = require('url')

var cheerio = require('cheerio');

http.createServer((req, res) => {
    var urlobj = url.parse(req.url, true)
    res.writeHead(200, {
        'Content-type': 'application/json;charset=utf-8',
        'Access-control-Allow-Origin': '*'
    })

    switch(urlobj.pathname) {
        case "/api/aaa":
            httpget(data => {
                res.end(spider(data))
            })
            break;
        default : 
        res.end('404')    
    }
}).listen(3000)

function httpget(cb) {
    var data = ''
    https.get('xxx.com', (res) => {
        res.on('data', (chunk) => {
            data+=chunk
        })
        res.on('end', () => {
            cb(data)
        })
    })
}

function spider(data) {

    let $ = cheerio.load(data)
    let $moviewList = $('.column.content')
    let movies = []

    $moviewList.each((index, value) => {
        movies.push({
            title: $(value).find('.title').text(),
            grade: $(value).find('.grade').text(),
            actor: $(value).find('.actor').text()
        })
    })
    // console.log(movies)
    return JSON.stringify(movies)
}

event模块

const EventEmitter = require('events')
class MyEventEmitter extends EventEmitter {}
const event = new MyEventEmitter()
event.on('play', (movie) => {
  console.log(movie)
})
event.emit('play', '我和我的祖国')
event.emit('play', '中国机长')

fs文件操作模块

const fs = require('fs')
const fsp = require('fs').promises
// 创建文件夹
fs.mkdir('./logs', (err) => {
  console.log('done.')
})
// 文件夹改名
fs.rename('./logs', './log', () => {
  console.log('done')
})
// 删除文件夹
fs.rmdir('./log', () => {
  console.log('done.')
})
// 写内容到文件里
fs.writeFile('./logs/log1.txt', 'hello', (err) => {
  if(err) {
    console.log(err.message)
  } else {
    console.log('文件创建成功')
  }
})
// 追加内容到文件里
fs.appendFile('./avatar/a.txt', '\n你好', err => {
    console.log(err)
})
// 读取文件内容
fs.readFile('./avatar/a.txt','utf-8', (err, data) => {
    if(!err) {
        console.log(data)
    }
})
// 删除文件
fs.unlink('./avatar/a.txt', err => {
    console.log(err)
})
// 批量写入
for(var i=0;i<10;i++) {
  fs.writeFile(`./logs/log-${i}.txt`, `log-${i}`, err => {
    console.log('done.')
  })
}
// 读取文件/目录信息
fs.readdir('./avatar', (err, data) => {
    data.forEach((value, index) => {
       fs.stat(`./${value}`, (err, stats) => {
         console.log(value + ' is' + (stats.isDirectory() ? 'directory' : 'file'))
       })
    })
})
// 同步读取文件
try{
  const content = fs.readFileSync('./logs/log-1.txt', 'utf-8')
  console.log(content)
  console.log(0)
} catch(e) {
  console.log(e.message)
}
// 异步读取文件，方法一
fs.readFile('./logs/log-0.txt', 'utf-8', (err, content) => {
  console.log(content)
  console.log(0)
})
console.log(1)
// 异步读取文件： 方法二
const fs = require('fs').promises
fs.readFile('./logs/log-0.txt', 'utf-8').then(result => {
  console.log(result)
})
// 判断是文件夹还是文件
fs.stat('./avatar', (err, data) => {
    console.log(data.isFile())
    console.log(data.isDirectory())
})

在fs模块中，提供同步方法是为了方便使用，那我们到底是应用异步方法还是同步方法
由于Node环境执行的javascript代码是服务器代码，所有，绝大部分需要在服务器运行期反复执行业务逻辑的代码，必须使用异步代码，否则，同步代码在执行期，服务器停止响应，因为javascript只有一个执行线程。服务器启动时如果需要读取配置文件，或者结束时需要写入到状态文件时，可以使用同步代码，因为这些代码只在启动和结束时执行一次，不影响服务器正常运行时的异步执行。

stream流模块
stream是nodejs提供的又一个仅在服务端可用的模块，目的是支持流这种数据结构。
什么是流？流是一种抽象的数据结构。想象水流，当在水管中流动时，就可以从某个地方源源不断地到达另一个地方。我们也可以把数据看做成是数据流，比如你敲键盘的时候，就可以把每个字符依次连起来，看成字符流。这个流是从键盘输入到应用程序，实际上它还对应一个名字，标准输入流

如果应用程序把字符一个一个输出到显示器上，这也可以看成是一个流，这个流也有名字：标准输出流。流的特点是数据是有序的，而且必须依次读取，或者依次写入，不能像Array那样随机定位。
有些流用来读取数据，比如从文件读取数据时，可以打卡一个文件流，然后从文件流中不断地读取数据，有些流用来写入数据，比如同文件写入数据时，只需要把数据不断地往文件流中写进行就可以。
在nodejs中，流也是一个对象，我们只需要响应流的事件就可以；data事情表示流的数据已经可以读取了，end事件表示这个流已经到末尾了，没有数据可以读取了，error事件表示出错了。

var fs = require('fs')

// 打开一个流
var rs = fs.createReadStream('sample.txt', 'utf-8')

rs.on('data', function(chunk) {
  console.log('DATA:')
  console.log(chunk)
})

rs.on('end', function(){
  console.log('end')
})

rs.on('error', function(err){
  console.log('error' + err)
})

要注意，data事件可能会有多次，每次传递的chunk是流的一部分数据。
要以流的形式写入文件，只需要不断调用write()方法，最后以end()结束；

var fs = require('fs')
var ws1 = fs.createwritestream('output1.txt', 'utf-8')
ws1.write('使用stream写入文本数据...\n')
ws1.write('end.')
ws1.end()

pipe就像可以把两个水管串成一个更长的水管一样，两个流也可以串起来。一个readable流和一个writeable流串起来后，所有的数据自动从readable流进入writable流，这种操作叫pipe
在nodejs中，readable流有一个pipe()方法，就是用来干这个事情的
让我们用pipe()把一个文件流和另一个文件流串起来，这样源文件的所有数据就自动写入到目标文件里了，所有，这实际上是一个复制文件的程序。

const fs = require('fs')

const readstream = fs.createReadStream('./1.txt')
const writestream = fs.createwriteStream('./2.txt')
readstream.pipe(writestream)

zlib

const fs = require('fs')
const zlib = require('zlib')

const gzip = zlib.createGzip()
const readstream = fs.createReadstream('./note.txt')
const writestream = fs.createWriteStream('./note2.txt')
readstream.pipe(gzip).pipe(writestream)

crypto
crypto模块目的是为了提供通用的加密和哈希算法。用纯javascript代码实现这些功能不是不可能，但速度会非常慢，nodejs用c/c++实现这些算法后，通过crypto这个模块暴露为javascript接口，这样用起来很方便，运行速度也快。
MD5是一种常用的哈希算法，用于给任意数据一个签名，这个签名通常用一个十六进制的字符串表示：

const crypto = require('crypto')
const hash = crypto.createHash('md5')
// 可任意多次调用update()
hash.update('hello, world!')
hash.update('hello, nodejs!')
console.log(hash.digest('hex'))

update()方法默认字符串编码为UTF-8,也可以传入Buffer
如果要计算SHA1,只需要把’MD5’改成‘sha1’,就可以得到SHA1的结果
5eb63bbbe01eeed093cb22bb8f5acdc3
Hmac算法也是一种哈希算法，它可以利用MD5或SHA1等哈希算法。不同的是，Hmac还需要一个密钥：

const crypto = require('crypto')
const hmac = crypto.createHmac('sha256', 'secret-key')
hmac.update('hello, world!')
hmac.update('hello,nodejs!')
console.log(hmac.digest('hex'))

只要密钥发生了变化，那么同样的输入数据也会得到不同的签名，因此，可以把Hmac理解为用随机数增强的哈希算法。
AES是一种常用的对称算法，加解密都用同一个密钥。crypto模块提供了AES支持，但是需要自己封装好函数，便于使用：

const crypto = require('crypto')

function encrypt(key, iv, data) {
  let decipher = crypto.createCipheriv('aes-128-cbc', key, iv)
  // decipher.setAutoPadding(true)
  return decipher.update(data, 'binary', 'hex') + decipher.final('hex')
}

function decrypt(key, iv, crypted) {
  crypted = Buffer.from(crypted, 'hex').toString('binary')
  let decipher = crypto.createDecipheriv('aes-128-cbc', key, iv)
  return decipher.update(crypted, 'binary', 'utf8') + decipher.final('utf8')
}

Express

https://www.expressjs.com.cn
基于nodejs平台，快速、开放、极简的web开发框架

安装

npm install express --save

路由

var app = express()

app.get('/', (req, res) => {
  res.send('hello world')
})

路由路径和请求方法一起定义了请求的端点，它可以是字符串、字符串模式或者正则表达式。

// 匹配根路径的请求
app.get('/', function(req, res) {
  res.send('root')
})

// 匹配 /about路径的请求
app.get('/about', function(req, res) {
  res.send('about')
})

// 匹配 /random.text路径的请求
app.get('/random.text', function(req, res){
  res.send('random.text')
})

使用字符串模式的路由路径实例：

// 匹配 acd 和 abcd
app.get('/ab?cd', function(req, res) {
  res.send('ab?cd')
})
// 匹配 /ab/****
app.get('/ab/:id', function(req, res) {
  res.send('aaaaaa')
})
// 匹配abcd、abbcd、abbbcd等
app.get('/ab+cd', function(req, res){
  res.send('ab+cd')
})
// 匹配abcd、abxcd、abRABDOMcd、ab123cd等
app.get('/ab*cd', function(req, res){
  res.send('ab*cd')
})
// 匹配 /abe 和 /abcde
app.get('/ab(cd)?e', function(req, res) {
  res.send('ab(cd)?e')
})

使用正则表达式的路由路径实例：

// 匹配任何路由中含有 a 的路径
app.get(/a/, function(req, res){
  res.send('/a/')
})

// 匹配butterfly, dragonfly, 不匹配 butterflyman、dragonfly man 等
app.get(/.*fly$/, function(req, res){
  res.send('/。*fly$/')
})

可以为请求处理提供多个回调函数，其行为类似中间件。唯一区别的这些回调函数可能调用next（‘route’）方法而略过其他路由回调函数，可以利用这机制为路由定义前提条件，如果在现有路径上继续执行没有意义，则可将控制权交给剩下的路径。

app.get('/example/a', function(req, res){
  res.send('hello from A！')
})

中间件
Express是一个自身功能极简，完全是由路由和中间件构成一个的web开发框架；从本质上来说，一个Express应用就是在调用各种中间件。
中间件（middleware）是一个函数，它可以访问请求对象（request object(req)）,响应对象（response object(res)）,和web应用中处于请求-响应循环流程中的中间件，一般被命名为next的变量。
中间件的功能包括：

执行任何代码
修改请求和响应对象
终结请求-响应循环
调用堆栈中的下一个中间件。
如果当前中间件没有终结请求-响应循环，则必须调用next()方法将控制权交给下一个中间件，否则请求就会挂起。
Express 应用可使用如下几种中间件
应用级中间件
路由级中间件
错误处理中间件
内置中间件
第三方中间件

使用可选则挂载路径，可在应用级别或路由级别装载中间件，另外，你还可以同时装在一系列中间件函数，从而在一个挂载点上创建一个子中间件栈。

应用级中间件
应用级中间件绑定app对象，使用app.use()和app.METHOD()，其中，METHOD是需要处理的HTTP请求的方法，列如：GET、PUT、POST等等，全部小写。列入：

var app = express()
// 没有挂载路由的中间件，应用的每个请求都会执行该中间件
app.use(function(req, res, next){
  console.log('Time:', Date.now())
  next()
})

路由级中间件
路由级中间件和应用级中间件一样，只是它绑定的对象为experss.Router()

var router = express.Router()

var app = express()
var router = express.Router()
// 没有挂载路径的中间件，通过该路由的每个请求都会执行该中间件
router.use(function(req, res, next){
  console.log('Time:', Date.now())
  next()
})
// 一个中间件，显示任何指向/user/：id 的HTTP请求的信息
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originaUrl)
  next()
}, function(req, res, next) {
  console.log('Request Type:', req.method)
  next()
})

// 一个中间件栈，处理指向 /user/:id 的get请求
router.get('/user/:id', function(req, res, next) {
  // 如果user id 为0，跳到下一个路由
  if(req.params.id == 0) next('route')
  // 负责将控制权交给栈中下一个中间件
  else next()
}, function(req, res, next) {
  // 渲染常规页面
  res.render('regular')
})
// 处理 /user/:id 渲染一个特需页面
router.get('/user/:id', function(req, res, next) {
  console.log(req.params.id)
  res.render('special')
})

// 将路由挂载至应用
app.use('/', router)

错误处理中间件
错误处理中间件和其他中间件定义类似，只是要使用4个参数，而不是3个，其签名如下：（err, req, res, next）

app.use(function(err, req, res, next) {
  console.log(err.stack)
  res.status(500).send('something broke!')
})

内置的中间件
express.static是Express唯一内置的中间件，它基于serve-static,负责在Express应用中提托管静态资源，每个应用可有多个静态目录

app.use(express.static('public'))
app.use(express.static('uploads'))
app.use(express.static('files'))

第三方中间件
安装所需功能的node模块，并在应用中加载，可以在应用级加载，也可以在路由级加载。
下面的例子安装并加载了一个解析cookie的中间件：cookie-parser

npm install cookie-parser

var express = reqiure('express')
var app = express()
var cookieParser = require('cookie-parser')

// 加载用于解析cookie的中间件
app.use(cookieParser())

技术钱

关注

9
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫