Node服务器

一、创建http服务器

　　node.js的web程序不用放入web容器中运行，可以自己创建一个http服务器运行程序。需要使用http核心模块。　

//创建一个http服务器
const http=require('http');
//创建一个http服务器
const server=http.createServer((req,res)=>{
        //设置响应头
        res.writeHead(200, {'Content-Type': 'text/html;charset=utf8'});
        //通知服务器，所有响应头和响应主体都已被发送
        res.end("hello world");
});
server.listen('8080',"127.0.0.1",(err)=>{
    if(err)
        throw err;
    console.log("服务器启动成功");
})

　　可以在浏览器通过http://localhost:8080访问服务器。

二、访问服务器上的静态页面　　

//创建一个http服务器
const http = require('http');
const fs = require('fs');
//创建一个http服务器
const server = http.createServer((req, res) => {
    if (req.url == "/yuan") {
        //访问页面yuan.html
        fs.readFile('./yuan.html', "utf8", (err, data) => {
            if (err)
                throw err;
            //设置响应头
            res.writeHead(200, { 'Content-Type': 'text/html;charset=utf8'});
            //通知服务器，所有响应头和响应主体都已被发送
            res.end(data);
        });
    } else if (req.url == '/fang') {
        //访问页面fang.html
        fs.readFile('./fang.html', "utf8", (err, data) => {
            if (err)
                throw err;
            //设置响应头
            res.writeHead(200, { 'Content-Type': 'text/html', 'charset': "utf8" });
            //通知服务器，所有响应头和响应主体都已被发送
            res.end(data);
        });
    }
    else if (req.url == "/tupian") {
        //为图片配置路由
        fs.readFile('./node.png', (err, data) => {
            if (err)
                throw err;
            //设置响应头
            //通知服务器，所有响应头和响应主体都已被发送
            res.end(data);
        });
    }
    else {
        //加载含有图片的页面要配置多个路由
        fs.readFile('./tupian.html', (err, data) => {
            if (err)
                throw err;
            //设置响应头
            //通知服务器，所有响应头和响应主体都已被发送
            res.end(data);
        });
    }
});
server.listen('8080', "127.0.0.1", (err) => {
    if (err)
        throw err;
    console.log("服务器启动成功");
})

　　设置四个简单的路由，获取服务器上的静态页面。

三、闭包和链式调用

　　使用下面的代码读取./album文件夹下的所有文件，把其中的文件夹放入dir数组中。然后遍历dir数组。./album下的文件如下：

　　　

const fs = require('fs');
var  dir=[];
fs.readdir('./album',(err,files)=>{
    for(var i=0;i<files.length;i++){
        var  thefile=files[i];
        fs.stat(`./album/${thefile}`,(err,state)=>{       
           if(state.isDirectory())
                dir.push(thefile);
            console.log(dir);
        });
    }
})

　　控制台打印的结果如下：

　　

　　分析： fs.readdir()的回调函数中定义了变量thefile，回调函数在调用的时候会把变量thefile绑定到相关的对象上。回调函数中又定义了回调函数，所以嵌套的回调函数会把这个对象添加到自己的作用域上。但是fs.readdir（）调用时循环会改变thefile的值，所以回调函数的作用域连上的thedfile指向最后一个文件名。　　

 fs.stat(`./album/${thefile}`，callback)中我们传入的实参是对应的每一个的文件名。
 解决方法1：利用闭包让thefile变量不共享。

const fs = require('fs');
var  dir=[];
fs.readdir('./album',(err,files)=>{
    for(var i=0;i<files.length;i++){
        var  thefile=files[i];
        (function (f){
            fs.stat(`./album/${f}`,(err,state)=>{       
                if(state.isDirectory())
                     dir.push(f);
                     console.log(dir);
             });
        }(thefile))     
    }
})

　　

　　解决方法2:每次只让事件队列中有一个fs.stat()函数在执行。　

const fs = require('fs');
var  dir=[];
fs.readdir('./album',(err,files)=>{
        (function itera(f){
            //结束递归
            if(f===files.length){
                console.log(dir);
                return;
            }            
            fs.stat(`./album/${files[f]}`,(err,state)=>{       
                if(state.isDirectory())
                     dir.push(files[f]);
                     console.l
                     og(`./album/${files[f]}`);
                   itera(++f);
             });
        }(0))     
})

　　

五、自己实现静态服务　　

//用node提供静态服务
const http = require('http');
const fs = require('fs');
const url = require('url');
const path = require('path');
const server = http.createServer((req, res) => {
    //获取要访问的文件路径
    let requrl = url.parse(req.url).pathname;
    //拼合成绝对路径
    let dirpath = path.join(__dirname, 'static', requrl);
    //读取当前路径下的文件
    fs.readFile(dirpath, (err, data) => {
        //当前文件不存在
        if (err) {
            let p404 = path.join(__dirname, 'static/404.html');
            fs.readFile(p404, (err, data) => {
                if (err)
                    throw err;
                res.writeHead(404, { 'Content-Type': `text/html;charset=utf8` });
                res.end(data)
            });
            return;
        }
        //文件存在
        //获取文件的后缀名
        let ext = path.extname(requrl);
        //异步的方式获取响应头
        getMime(ext, (mime) => {
            res.writeHead(200, { 'Content-Type': `${mime};charset=utf8` });
            res.end(data);
        });
    });
});
server.listen('8080', 'localhost', (err) => {
    if (err)
        throw err;
    console.log("服务器成功启动！");
});
//根据文件的类型给出对应的mime类型
function getMime(extname, callback) {
    let file = path.join(__dirname, 'mime.json');
    fs.readFile(file, (err, data) => {
        if (err)
            throw err;
        data = JSON.parse(data);
        let mime = data[extname] || "text/plain";
        callback(mime);
    })
}

当服务器启动时，放在static文件下的问价可以被直接访问。

六、post请求和get请求　

//post请求
const http = require('http');
const fs = require('fs');
const querystring=require('querystring');
http.createServer((req, res) => {
　　　　//读取服务器上的静态页面
    if (req.url == '/') {
        fs.readFile('./form.html', (err, data) => {
            if (err)
                throw err;
            res.writeHead(200, { 'Content-Type': `text/html;charset=utf8` });
            res.end(data);
        })
    }
　　　　//接受post请求
    else if (req.url = "/dopost" && req.method.toLocaleLowerCase() == 'post') {
        let data = '';
        req.addListener('data', (chunk) => {
            data += chunk;
        });
        req.addListener('end', () => {
　　　　　　　　　　//打印接受的数据
            console.log(data);
　　　　　　　　　　//将数据转换成字符串
            let dataObj=querystring.parse(data);
            console.log(dataObj.user);
        })    
        res.writeHead(200, { 'Content-Type': `text/html;charset=utf8` });
        res.end('success');
    }
    else {
        res.writeHead(200, { 'Content-Type': `text/html;charset=utf8` });
        res.end('404');
    }
}).listen('8080', 'localhost');

　

//get请求
const  http=require('http');
const  url=require('url');
//创建一个服务器
http.createServer((req,res)=>{
        //解析接受到url
        //输入http://localhost:8080/lijunjie.hml?name=123
        let urlObj=url.parse(req.url);
        //输出name=123
        console.log(urlObj.query);
        res.end('请求成功');
}).listen(8080,'localhost');

七、ejs模板引擎

　　

　　首先需要通过npm安装ejs模块。创建index.ejs文件。　　

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>

<body>
    <p> 我买了一个小米
        <%=a%>
    </p>
    <% for(var i=0;i<news.length;i++){%>
        <li>
            <%=news[i]%>
        </li>
        <%}%>
</body>

bind.js文件　　

//创建一个http服务器
const http = require('http');
const fs = require('fs');
const ejs=require('ejs');
//创建一个http服务器
const server = http.createServer((req, res) => {
    //读取模板
    fs.readFile('./index.ejs', (err, data) => {
        //接受模板
        let template = data.toString();
        //数据
        let datas = { a: 3, news: ['adsada', 'xiaomi'] };
        let html=ejs.render(template,datas);
        res.end(html);
    })

});
server.listen('8080', "127.0.0.1", (err) => {
    if (err)
        throw err;
    console.log("服务器启动成功");
})