// 用于创建网站服务器的模块
const http = require('http')
const url = require('url')
    // app对象就是网站服务器对象
const app = http.createServer()
    // 当客户端又请求来的时候
app.on('request', (req, res) => {
    res.writeHead(200, { 'content-type': 'text/html;charset=utf8' })
    url.parse(req.url)
    if (req.url == '/index') {
        res.end('首页')
    } else if (req.url == '/list') {
        res.end('list')
    }
})
app.listen(3000)
console.log('服务器启动成功');

在app.on里面

req.headers // 获取请求报文
req.url // 获取请求地址
req.method // 获取请求方法

响应报文

http状态码

res.writeHead(200,{'content-type': 'text/html';charset=utf8})

在处理get请求参数的时候，url很长，就需要处理这个字符串，

用到了系统内置模块url
有一个parse方法

url.parse(req.url,true).query.xxx // true是将查询参数解析成为对象形式
url.parse(req.url,true).pathname // 除去get请求参数后的url

post请求参数

post参数是通过事件的方式接受的
data 当请求参数传递的时候发出data事件
end 当参数传递完成的时候发出end事件

需要导入querystring,下面的parse方法能够把字符串转换为对象形式

const querystring = require('querystring')
let postParams = ' '

// 淘汰的方式，应该转换为对象形式
req.on('data', (params) => {
 // postParms += params // 这样得到的是一个和get上url一样的字符串
})

req.on('end'. () => {
  // log(postParams)
  log(querystring.parse(postParams))
})

res.end('ok')

利用url.parse(req.url)得到一个不含参数的url，对这个url进行判断从而实现路由

通过req.method获取请求的方式（是post还是get）

image.png

同步api和异步api(asnyc)

异步api不可以通过返回值的方式获取返回值，需要用回调函数

function getData (callback) {
  callback('123')
}
getData(() => {
  console.log('callback函数被调用了')
  console.log(n)
})

promise 解决异步编程中回调地狱问题

首先是回调地狱图

image.png

promise用法

const fs = require('fs')

let promise = new Promise((resolve, reject) => {
    fs.readFile('./1.txt', 'utf-8', (err, result) => {
        if (err != null) {
            reject(err)
        } else {
            resolve(result)
        }
    })
})

promise.then((result) => {
    console.log(result);
}).catch((err) => {
    console.log(err);
})

promise解决回调地狱

const fs = require('fs')

function p1() {
    return new Promise((resolve, reject) => {
        fs.readFile('./1.txt', 'utf-8', (err, result1) => {
            resolve(result1)
        })
    })
}

function p2() {
    return new Promise((resolve, reject) => {
        fs.readFile('./2.txt', 'utf-8', (err, result2) => {
            resolve(result2)
        })
    })
}

function p3() {
    return new Promise((resolve, reject) => {
        fs.readFile('./3.txt', 'utf-8', (err, result3) => {
            resolve(result3)
        })
    })
}
p1().then((r1) => {
    console.log(r1);
    return p2()
}).then((r2) => {
    console.log(r2);
    return p3()
}).then((r3) => {
    console.log((r3));
})

简化后的promise操作（es7）

// 1.在普通函数定义的前面加上async关键字 普通函数就变成了异步函数
// 2.异步函数默认的返回值是promise对象
// 3.throw 抛出异常
//
// await关键字
// 1.它只能出现在异步函数中
// 2.await promise 它可以暂停异步函数的执行 等待promise对象返回结果后再向下执行函数
async function fn() {
    throw '发生了一些错误'
    return 123
}

//console.log(fn());

fn().then((data) => {
    console.log(data); // 拿到返回值
}).catch((err) => {
    console.log(err);
})

接下来再来解决读取三个文件的例子

// 1.在普通函数定义的前面加上async关键字 普通函数就变成了异步函数
// 2.异步函数默认的返回值是promise对象
// 3.throw 抛出异常
//
// await关键字
// 1.它只能出现在异步函数中
// 2.await promise 它可以暂停异步函数的执行 等待promise对象返回结果后再向下执行函数
// 3.await等这次异步操作执行完之后再执行后面的操作,只能作用于promise对象
const fs = require('fs')

async function p1() {
    return 'p1'
}
async function p2() {
    return 'p2'
}
async function p3() {
    return 'p3'
}
async function run() {
    let r1 = await p1()
    let r2 = await p2()
    let r3 = await p3()
    console.log(r1);
    console.log(r2);
    console.log(r3);
}

run()

异步函数的应用(读取三个文件)

const fs = require('fs')
// 用来改造现有nodejs的异步api，让其返回promise对象从而支持异步编程语法
const promisify = require('util').promisify
const readFile = promisify(fs.readFile)
async function run() {
    let r1 = await readFile('./1.txt', 'utf-8')
    let r2 = await readFile('./2.txt', 'utf-8')
    let r3 = await readFile('./3.txt', 'utf-8')
    console.log(r1);
    console.log(r2);
    console.log(r3);
}
run()