Node 学习笔记

简单创建一个服务器

var http = require('http')

var app = http.createServer((req, res) => {
    res.write('hello')

    res.end()
})

app.listen(3000,() => {
    console.log('服务器已启动')
})

想让服务器实时更新：npm i nodemon -g 	
启动命令：nodemon index.js

Node 模块化

三大模块：
	1.全局模块（npm等包管理工具下载的）
	2.核心模块（node自带模块）
	3.自定义模块（自己写的模块）

自定义模块的创建和导出导入

function sayHello() {
    console.log('hello')
}

module.exports = sayHello 	//模块的导出

var strParse = require('./demo')   //模块导入
strParse()

path模块

path.normalize()		自动解析路径
path.join()				将所有给定的path片段连接到一起
path.resolve()			将路径或路径片段的序列解析为绝对路径
path.isAbsolute()		判断path是不是绝对路径
path.basename()			返回path路径最后一部分
path.extname()			返回最后一个部分的扩展名
path.dirname()			返回目录名，不返回文件名
path.parse()			解析path路径
path.format()			与parse恰好相反，根据对象返回path

var path = require('path')

var pathStr = path.normalize('a/b///c//d//\\\e')

var pathStr2 = path.join('a','/b','/c','//d')

var pathStr3 = path.resolve('a/b/c')

var pathStr4 = path.isAbsolute('./a/b/c')

var pathStr5 = path.basename('././index.js')

var pathStr6 = path.extname('././index.js')

var pathStr7 = path.dirname('c/d/e.js')

var pathStr8 = path.parse('/a/b/c.txt')

var pathStr9 = path.format({ root: '/', dir: '/a/b', base: 'c.txt', ext: '.txt', name: 'c' })

console.log(pathStr)
console.log(pathStr2)
console.log(pathStr3)
console.log(pathStr4)
console.log(pathStr5)
console.log(pathStr6)
console.log(pathStr7)
console.log(pathStr8)
console.log(pathStr9)

/*
    输出结果：
        a\b\c\d\e
        a\b\c\d
        D:\学习笔记\Nodejs学习\Path_demo\a\b\c
        false
        index.js
        .js
        c/d
        { root: '/', dir: '/a/b', base: 'c.txt', ext: '.txt', name: 'c' }
        \a\b\c.txt
 */

fs文件系统模块

fs.readFileSync()			同步读取文件
fs.readFile()				异步读取文件
fs.writeFlieSync()			同步写入文件
fs.writeFile()				异步写入文件

const fs = require('fs')

//同步读取
var data = fs.readFileSync('./hello.txt')

console.log('同步读取', data.toString())

//异步读取
fs.readFile('./hello.txt', (err, data) => {
    if(err) {
        console.error(err)
        return
    }

    console.log('异步读取', data.toString())
})

//同步写入
fs.writeFileSync('./hello.txt', '这是使用wirteFileSync输入的内容')

//异步写入
fs.writeFile('./hello.txt', '这是使用writeFile写入的内容', (err) => {
    if(err) {
        console.error(err)
        return
    }

    console.log('写入完毕')
})

buffer模块

buffer模块特点：
	1.buffer用来处理二进制数据流
	2.buffer实例类似数组，大小是固定的
	3.buffer是使用C++代码在V8堆外分配的物理内存
	4.buffer是一个全局变量

buffer创建：

//创建一个长度为10,内容都是0的buffer对象
let buf1 = Buffer.alloc(10)

//创建一个长度为5,内容都是1的buffer对象
let buf2 = Buffer.alloc(5, 1)

//创建一个不安全buffer
let buf3 = Buffer.allocUnsafe(5)

//创建一个从数组中内容相同的buffer对象
let buf4 = Buffer.from([1,2,3])

//创建一个utf-8编码格式输出的buffer对象
let buf5 = Buffer.from('hello')

//使用base-64编码格式创建buffer对象
let buf6 = Buffer.from('hello','base64')

console.log(buf1)
console.log(buf2)
console.log(buf3)
console.log(buf4)
console.log(buf5)
console.log(buf6)

/* 
    输出结果：
        <Buffer 00 00 00 00 00 00 00 00 00 00>
        <Buffer 01 01 01 01 01>
        <Buffer a0 38 4c ef 0f>
        <Buffer 01 02 03>
        <Buffer 68 65 6c 6c 6f>
        <Buffer 85 e9 65>
*/

buffer函数使用：

//内容所占用的buffer长度
let length = Buffer.byteLength('hello')

console.log(length)

//判断是否是buffer对象
let a = {}
let buf = Buffer.from('hello')

console.log(Buffer.isBuffer(a))
console.log(Buffer.isBuffer(buf))

//连接不同的buffer对象
let buf2 = Buffer.from('world')
let BufObj = Buffer.concat([buf,buf2])

console.log(BufObj.toString())

/**
    5
    false
    true
    helloworld
 */

events模块

on('事件名'，回调函数)											创建事件
once('事件名'，回调函数)											创建只能触发一次的事件
emit('触发的事件'，向触发的事件的回调函数中传的参数)				触发事件
removeListener('要撤销的事件名'，'要撤销的回调函数')				删除事件
removeAllListeners('要撤销的事件名')								删除这个事件名称下所有事件函数

const EventEmitter = require('events')

class CustomEvent extends EventEmitter {}

const ce = new CustomEvent()

ce.on('test', () => {
    console.log('this is a test!');
})

setInterval(() => {
    ce.emit('test')
},1000)

ce.on('error', (err,date) => {
    console.log(err)
    console.log(date)
})

ce.emit('error',new Error('this is a Error!'), Date.now())

//只执行一次
ce.once('test', () => {
    console.log('test')
})

setInterval(() => {
    ce.emit('test')
},1000)

function fn1() {
    console.log('fn1')
}

function fn2() {
    console.log('fn2')
}

ce.on('test', fn1)
ce.on('test', fn2)

setInterval(() => {
    ce.emit('test')
},1000)

setTimeout(() => {
    ce.removeListener('test',fn1)
},3000)