node常用api

fs

fs.mkdir( ) 异步创建文件夹

fs.readdir( )

// 读取目录文件(不包含文件内容)，返回结果为数组
// 注意 读取路径：要读取的文件的所在目录的路径，与调用fs.readdir()的文件无关,所以路径多数为绝对路径
fs.readdir(path, [options], callback(err, res)) 
fs.readdirSync(path) // 同步

fs.readFile( )

// 读取文件内容不设置utf-8 结果为流格式：<Buffer 0d 0a 0d 0a 0d 0a 61 61 61 0d 0a>
// 设置utf-8 格式就是字符串格式的数据
// path 读取文件的路径，建议使用绝对路径，否则很容易出现文件找不到的错误
readFile(path, 'utf-8', (err, res)=> {} ) 

fs.writeFile( ) / fs.appendFile( )

// 向文件写入内容（覆盖），如果文件不存在会先创建一个文件
writeFile(path, content, (err)=>{}) 
// 向文件写入内容（追加）
fs.appendFile(path, content, (err)=>{}) 

常用方法 - 封装成promise

mkdir、rmdir、readdir、readFile、copyFile、appendFile、writeFile

/**
 * 封装
 * 'mkdir', 'rmdir', 'readdir', 'readFile', 'copyFile'
 * 'appendFile', 'writeFile'
 *
 *
 * */
const path = require('path')
const fs = require('fs')
class GeneratorPromise{
    constructor(){
        this.arr = ['mkdir', 'rmdir', 'readdir', 'readFile', 'copyFile']
        this.writeClass = ['appendFile', 'writeFile']
        this.box = []
    }
    init() {
        this.arr.forEach(item => {
            exports[item] = (mypath, newFilePath = '') => { // 挂载到exports对象上，导出的是一个对象
                const PATH = this.newpath(mypath, newFilePath) // 处理路径
                if( PATH instanceof Array ) {
                    return this.promise(item, PATH[0], PATH[1])
                }else {
                    return this.promise(item, PATH)
                }
            }
        })
        this.writeClass.forEach(writeitem => {
            exports[writeitem] = (PATH, content) => {
                return this.promise(writeitem, PATH, content)
            }
        })
    }
    promise(item, PATH, powerfulParam = '') {
        return new Promise((resolve, reject) => {
            const fn = (err, res) =>{
                if (err) reject(err)
                resolve(res || '')
            }
            this.box = []
            if(item === 'readFile') {
                if(!/(\.jpg|\.png|\.ico|\.gif)$/ig.test(PATH)) {
                    this.box.push('utf-8')
                }
            }
            // item === 'readFile' ? this.box.push('utf-8') : null
            if( item === 'copyFile' || item === 'appendFile' || item === 'writeFile' ){
                this.box.push(powerfulParam)
            }
            fs[item](PATH, ...this.box, fn)
        })
    }
    newpath(mypath, newFilePath) {
        if(newFilePath){
            return [path.resolve(path.resolve(), mypath), path.resolve(path.resolve(), newFilePath)]
        }else{
            return path.resolve(path.resolve(), mypath) // path.resolve() 路径拼接时，极易出现问题，后边如果可以拼接成一个绝对路径，那么path.resolve()就没有了
        }
    }
}
new GeneratorPromise().init()
/**
 * 调用
 *
 *
   const { readFile } = requrie('commonModule.js')
    readFile('./https/https.txt').then((res) => {
        console.log(res)
    })
 *
 * */

 

http

let server = http.createServer( (request, response) =>{} ) 创建服务

server.listen( port ，() =>{} ) 启动http服务，创建链接

回调函数中的参数：

request: 请求对象

req.url // 请求地址及问号后边参数
req.method // 请求方式
req.headers // 请求头 [object]

response：响应对象

res.write() // 向客户端返回信息
res.end() // 结束响应，返回结果必须为string 或 buffer, 内容有中文，会有乱码，需要配置响应头+ utf-8，如下：
// 设置响应头 重写响应头，参数一为：状态码（必传参数）
res.writeHead(status, {
    'content-type': 'text/plan;charset=utf-8' // 内容类型 通常会： res.end() 在end里边直接返回数据，最后结束响应
})

 

url

url.parse( url, [flag] ) 解析url地址

const _url = require('url')
const url = 'www.baidu.com/index?name=lxc&age=20#hash'
console.log(_url.parse(url))
Url {
  protocol: null,
  slashes: null,
  auth: null,
  host: null,
  port: null,
  hostname: null,
  hash: '#hash',
  search: '?name=lxc&age=20',
  query: 'name=lxc&age=20', // 常用
  pathname: 'www.baidu.com/index', // 常用
  path: 'www.baidu.com/index?name=lxc&age=20',
  href: 'www.baidu.com/index?name=lxc&age=20#hash'
}

url.parse( url, true ) 解析url地址 - query 值为对象

const _url = require('url')
const url = 'www.baidu.com/index?name=lxc&age=20#hash'
console.log(_url.parse(url))
Url {
  // ··· ···
  query: { name: 'lxc', age: '20' }, // 常用
}