node.js学习笔记

时间  2019-12-08
标签 node.js node 学习 笔记 栏目 Node.js 繁體版
原文   原文链接

最近一直在学习node.js，因此总结了一些笔记，记录在这里。javascript

  • 模块化和做用域
  • node中经常使用到的模块
  • ffer
  • File
  • Http
  • stream

模块化和做用域

this

浏览器中的this指的是window
node脚本文件中未定义时全局的this指向global ，定义时指的是module.exportshtml

a = 10
console.log(global.a) // 10
  • 全局做用域

没用用var let const 定义的声明的都是全局做用域java

  • 模块做用域

使用变量修饰的都是模块做用域node

  • 函数做用域
  • 块级做用域

Buffer

处理二进制数据web

// 数组拼接buffer
var rs = require('fs').createReadStream('test.txt', { highWaterMark: 10 })
var data = []
rs.on('data', function (chunk) {
  data.push(chunk)
})
rs.on('end', function (chunk) {
  var buf = Buffer.concat(data)
  console.log(buf.toString())
})

File System

  • readFile

用来异步读取文本文件中的内容，会将一个文件的所有内容都读到内存中，适用于体积较小的文本文件；
读取大文件，使用stream， readFileSync直接返回文本数据内容express

  • readFile 第一个参数是文件名，若是没有回自动建立。
  • fs.stat 获取文件的状态

一般开发者能够在调用open() read() 或者write方法以前调用fs.stat方法，用来判断该文件是否存在。
fs.stat 和fs.fstat功能是同样的，npm

区别是 fstat方法第一个参数是文件描述符，格式为integer，fstat方法一般搭配open方法使用，由于open方法返回的结果就是一个文件描述。api

var fs= require('fs')
var data = fs.readFileSync('test.txt', {encoding: 'utf-8'})
console.log(data)


fs.writeFile('foo.txt', "hello world", {flag: 'a', encoding: 'utf-8'},
function (err) {
  if(err) {
    console.log(err)
    return
  } 
  console.log('success')
})
  • fs.stat
// 用来获取文件的状态 来判断文件是否存在
// 常在调用open read witer是调用
fs.stat("foo.txt", function(err, result) {
  if(err) {
    console.log(err)
    return
  }
  console.log(result)
}) 

// fs.fstat

fs.open("foo.txt",'a',function(err,fd){
    if(err){
        console.log(err);
        return;
    }
    console.log(fd);
    fs.fstat(fd,function(err,result){
        if(err){
            console.log(err);
            return;
        }
        console.log(result);
    })
})
// 例子
// 获取目录下的说有文件名。
// fs.readdir 和fs.stat两个api
var fs = require("fs");
function getAllFileFromPath(path) {
    fs.readdir(path, function (err, res) {
        for (var subPath of res) {
            var statObj = fs.statSync(path + "/" + subPath); //这里使用了同步方法而非异步
            if (statObj.isDirectory()) {//判断是否为文件夹
                console.log("Dir:", subPath);
                getAllFileFromPath(path + "/" + subPath)//若是是文件夹，递归获取子文件夹中的文件列表
            } else {
                console.log("File:", subPath);
            }
        }
    })
}
getAllFileFromPath(__dirname);

http

var http = require('http')
var server =http.createServer(function(req, res) {
  // 处理http请求
var method = req.method
var url = req.url
console.log(method, url)
  res.writeHead(200, {'content-type': 'text/plain'})
  res.end('hello  node!')
})
// 监听来自客户端的事件
server.on('connection', function(req, res) {
  console.log('connection')
})
server.on('request', function(req, res) {
  console.log('request')
})
server.listen(8080)

// 当访问8080时，控制台输出 
// connected
// request
// request 打印两次是由于其中一个是favicon.ico的请求
// 一个简单的静态服务器
var http = require('http')
var fs = require('fs')
var server = http.createServer(function (req, res) {

  if (req.url == '/') { //访问8080
    var fileList = fs.readdirSync('./')
    res.writeHead(200, { 'content-type': 'text/plain' })
    // 将数组转化为字符串返回
    res.end(fileList.toString())
  } else {
    var path = req.url;
    // 在路径字符串前加.表示当前目录，避免在nix系统访问/文件夹
    fs.readFile('.' + path, function (err, data) {
      if (err) {
        res.end('不存在')
        throw err;
      }
      res.writeHead(200, { 'content-type': 'text/plain' })
      res.end(data)
    })
  }

})
//1buffer.js,2http.js,3httpexmple.js,4.js,foo.txt,login.html,md.md,readFile.js,test.txt,this.js,upload.js
server.listen(8080)
// 处理异常
process.on('uncaughtException', function() {
  console.log('got error')
})

处理http请求

  • method url header

get post put delete update数组

// 处理http请求
var method = req.method
var url = req.url

Response 对象

上传数据

  • upload.html
<form action="/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="file"/>
    <br/>
    <input type="text" name="kind">
    <input type="submit" name="submit" value="submit"/>
</form>
  • js
// npm 安装依赖  formidable 
var http = require('http')
var fs = require('fs')
var formidable = require("formidable");
var server = http.createServer(function (req, res) {
  if (req.url == '/upload') {
    switch (req.method) {
      case 'GET':
        fs.createReadStream('upload.html').pipe(res)
        break
      case 'POST':
        dealpost(req, res) // 自定义方法处理
        break
      default:
        console.log('other request')
    }
  } else {
    res.writeHead(302, {
      'Location': './upload'
    })
    res.end() // 将全部的url访问都转到/login路径
  }
})

function dealpost(req, res) {
  var form = new formidable.IncomingForm();
  form.keepExtensions = true
  form.uploadDir = __dirname
  form.parse(req, function(err, fields, files) {
    if(err) {
      throw err
    }
    console.log(fields)
    console.log(files)
    res.writeHead(200, {'content-type': 'text/plain'})
    res.end('upload finished')
  })
}
server.listen(8080)

stream

stream 模块是node操做流失数据浏览器

四种基础的stream类型
  1. readable 可读流
  2. writable 可写流
  3. duplex 便可读又可写的流
  4. transform 操做写入的数据，而后读取结果，一般用于数据数据和输出数据不要求匹配的场景，
var stream =require('stream')
var fs = require('fs')
var readStream = fs.createReadStream("./text.txt", 'utf-8')
readStream.on('data', function(data) {
  console.log(data)
})
readStream.on('close', function() {
  console.log('close')
})
readStream.on('error', function() {
  console.log('error')
})

当建立一个可读流读取一个较大的文件，在调用pipe方法将数据经过一个可写流写入另外一个位置。若是读取的速度大于写入的速度，那么node将会在内存中缓存这些数据。

pipe 方法至关于在可读流和可写流之间加起来的桥梁，是的数据能够经过管道由可读流进入可写流，

  • 使用pipe改写的静态文件服务器
var stream = require('stream')
var http = require('http')
var fs = require('fs')
var server = http.createServer(function (req, res) {
  if (req.url == '/') {
    var fileList = fs.readdirSync('./')
    res.writeHead(200, { 'Content-type': 'text/plain' })
    res.end(fileList.toString())
  } else {
    try {
      var readStream = fs.createReadStream(path).pipe(res);
    } catch (e) {
      res.end("file not exists");
    }
  }
})
server.listen(3000)
console.log("Listening on 3000");

//处理异常
process.on("uncaughtException", function () {
  console.log("got error");
})

// pipe方法接收一个writable对象，当readable对象调用pipe方法时，会在内部调用writable对象的write方法进行写入。

Events

事件和监听器

eventsnode程序中的对象会产生一系类的事件，他们被称为事件触发器，

全部能触发事件的对下你给都是eventEmitter类的实例。eventEmitter定义了on方法。

var eventEmitter = require("events");
var myEmitter = new eventEmitter();
myEmitter.on("begin",function(){
    console.log("begin");
})
myEmitter.emit("begin");

第五章

中间件middleware

  • 1 中间价的概念

express 自己是有路由和中间件构成的，从本质上来讲，express的运行就是在不断调用这个中间件。

中间件的本质上是接收请求而且作出相应动做的函数，该函数一般接收req和res做为参数，以便对request和response对象进行操做，在web应用中，客户端发起的每个请求，首先要通过中间件的处理才能继续向下。

中间件的第三个参数通常写做next,它表明一个方法，即下一个中间件。若是咱们在中间件的方法体中调用了next方法，即表示请求会通过下一个中间件处理。

  • 2中间件的功能

中间件是一个函数，能够作到node代码能作到的任何事情，除此以外还包括修改request和response对象、终结请求-响应循环，以及调用下一个中间件等功能，这一般是经过在内部调用next方法来实现的。若是某个中间件中没有调用next方法，则表示对请求的处理到此为止，下一个中间件不会被执行。

  • 中间件的加载

中间件的加载使用use方法来实现，改方法定义在express或者koa对象的实例上，

var app =express()
app.use(md)
  • express中的中间件

express应用可以使用以下几种中间件

  • 应用级中间件
  • 路由级中间件
  • 错误处理中间件
  • 内置中间件
  • 第三方中间件
应用级中间件  使用app.use方法，绑定在app对象上的中间件
路由级中间件 路由处理是express的一部分，koa是经过第三方 koa-router
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程