Node.js基础 请求与相应 模块系统 路由 回调函数 事件驱动程序

 Node.js是运行在服务端的js

请求与相应   

// 引入http模块
var http = require(`http`)

// 创建服务器require请求 response相应（返回）
http.createServer(function (request, response) {
    // 发送响应
    // writeHead 获取  相应头  //应头决定了对应的返回数据的格式以及编码格式
    response.writeHead(200, { 'Content-Type': "text/html" })
    console.log(response);
    // 输出响应内容
    response.write("<h1>hello world<h1>")

    response.end(); //结束
}).listen(8888)


console.log(`我的服务器,访问http://127.0.0.1:8888`);

模块系统

Hello.js

// exports.world = function () {
//     console.log("Hello World");
// }

function Hello() {
    let name;
    this.setName = function (theName) {
        name = theName
    }
    this.setHello = function () {
        console.log(`Hello ${name}`);
    }
}

module.exports = Hello;

 main.js

// // 导入Hello模块
// var hello = require('./Hello')
// // 请用Hello中的方法
// hello.world() // Hello World 


var Hello = require('./Hello')
let hello = new Hello()

hello.setName("李四")
hello.setHello()

url模块

Node.js的url模式提供了用于分析和解析的url的实用程序 ，可以调用require（'url'）来访问

var url = require('url')
const reUrl = 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash';
const urlObj = url.parse(reUrl);

console.log(urlObj);

// console.log(urlObj.port); //端口  8080

// console.log(urlObj.host); //主机   host.com:8080

// console.log(urlObj.query); //获取查询参数  query=string

// http://  协议
// www.baidu.com  //主机
// 端口  8080
// https://mp.csdn.net/mp_blog/creation/editor

三个参数 （当第一个为参数时 第二个为参数时  第三个为参数时 分别是什么）

var url = require('url')
const reUrl = 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash';
const urlObj = url.parse(reUrl);


console.log(urlObj.query);  //query=string  字符串  第一个默认true
// 当第二个参数为true时
const urlObj2 = url.parse(reUrl, true); //[Object: null prototype] { query: 'string' } 对象
console.log(urlObj2.query);
// 当第三个参数为true时
const reqUrl3 = "//foo/bar"
const reqUr1 = url.parse(reqUrl3, false)
console.log(reqUr1.host, reqUr1.pathname); //pathname  获取他的参数

const reqUr2 = url.parse(reqUrl3, false, true)
console.log(reqUr2.host, reqUr2.pathname);

路由   

 index.js

var server = require('./server')
var router = require('./route')
server.start(router.router);

 route.js

function router(pathname) {
    console.log(`即将路由请求${pathname}`);
}
exports.router = router

server.js

// 引入url http模块
var url = require('url')
var http = require('http')
// 函数
function start(route) {
    // OnRequest   request请求   response相应
    function OnRequest(request, response) {
        let pathname = url.parse(request.url).pathname;
        console.log(`接收到${pathname}的请求`);
        route(pathname);
        response.writeHead(200, { 'Content-Type': "text/plain" });
        response.write("Hello Node.js! ")
        response.end();
    }
    http.createServer(OnRequest).listen(8888)
    console.log("服务器已启动访问:http://127.0.0.1:8888");
}
exports.start = start

回调函数   

Node.js异步调用的直接体现就是回调

回调函数在完成任务后 就会被调用Node使用了大量的回调函数Node所有的API都支持回调函数

同步和异步 ：

// 获取fs模块
// 同步
const fs = require("fs")
// 获取记事本的文本
// let data = fs.readFileSync('./input.txt')
// console.log(data.toString());
// console.log("请求成功");

// 异步执行  fs.readFile() 
fs.readFile("./input.txt", function (err, data) {
    if (err) {
        console.error(err.stack)
        return
    }
    console.log(data.toString());
})
console.log("加载完毕");

事件驱动程序

事件循环

 简单一点的案例

// 引入events模块
const events = require("events")
// 实例化
let eventEmitter = new events.EventEmitter()
// 绑定事件
eventEmitter.on("demo", function () {
    console.log("我是执行的demo");
})

// 自动触发
eventEmitter.emit("demo")
console.log(("执行完毕"));

 嵌套案例

// 引入模块
const events = require("events")
// 实例化对象
let eventEmitter = new events.EventEmitter();

// 创建一个函数   里面放一个自动触发事件
let connect = function () {
    console.log("事件绑定成功。。。。。");
    eventEmitter.emit("data") //触发事件第二个事件  "事件出发成功"
}
eventEmitter.on("connection", connect) // 1 绑定一个 connect事件

eventEmitter.on("data", function () {   // 2 绑定第二个 事件 
    console.log("事件出发成功");
})
eventEmitter.emit("connection")   // 1 自动触发connect事件