Node.js小示例

最新推荐文章于 2022-10-16 20:37:36 发布
最新推荐文章于 2022-10-16 20:37:36 发布
阅读量2.6k 收藏 1
点赞数 1
分类专栏： NodeJS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he90227/article/details/49127463
版权

1.http get和post

httpserverrequestget.js

复制代码 
/*
获取GET请求内容
由于GET请求直接被嵌入在路径中，URL是完整的请求路径，包括了?后面的部分，因此你可以手动解析后面的内容作为GET请求的参数。
node.js中url模块中的parse函数提供了这个功能。
 */
var http = require('http');
var url = require('url');
var util = require('util');

http.createServer(function(req, res){
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end(util.inspect(url.parse(req.url, true)));
}).listen(3000);

//在浏览器中访问http://localhost:3000/user?name=joey&email=joey@joey.com 然后查看返回结果
复制代码

 

httpserverrequestpost.js

复制代码 
/*
POST请求的内容全部的都在请求体中，http.ServerRequest并没有一个属性内容为请求体，原因是等待请求体传输可能是一件耗时的工作，
比如上传文件，而很多时候我们可能并不需要理会请求体的内容，恶意的POST请求会大大消耗服务器的资源，所有node.js默认是不会解析请求体的，
当你需要的时候，需要手动来做。
 */
var http = require('http');
var querystring = require('querystring');
var util = require('util');

http.createServer(function(req, res){
    var post = '';     //定义了一个post变量，用于暂存请求体的信息

    req.on('data', function(chunk){    //通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中
        post += chunk;
    });

    req.on('end', function(){    //在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。
        post = querystring.parse(post);
        res.end(util.inspect(post));
    });
}).listen(3000);
复制代码

注意：不要在真正的生产应用中使用上面这种简单的方法来获取POST请求，因为它有严重的效率问题和安全问题，这只是一个帮你理解的示例。

 

知识扩展：util.inherits继承

复制代码 
/*
 util.inherits
 定义了一个基础对象Base和一个继承自Base的Sub，Base有三个在构造函数内定义的属性和一个原型中定义的函数，通过util.inherits实现继承
 注意，Sub仅仅继承了Base在原型中定义的函数，而构造函数内部创造的base属性和sayHello函数都没有被Sub继承。
 */
var util = require('util');

function Base(){
    this.name = 'base';
    this.base = 1991;

    this.sayHello = function(){
        console.log('Hello ' + this.name);
    };
}

Base.prototype.showName = function(){
    console.log(this.name);
};

function Sub(){
    this.name = 'sub';
}

util.inherits(Sub, Base);

var objBase = new Base();
objBase.showName();
objBase.sayHello();
console.log(objBase);

var objSub = new Sub();
objSub.showName();
//objSub.sayHello();
console.log(objSub);
复制代码

2.文本提交与显式



index.js

复制代码 
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;

server.start(router.route, handle);
复制代码

server.js

复制代码 
var http = require("http");
var url = require("url");

function start(route, handle) {
  function onRequest(request, response) {
    var postData = "";
    var pathname = url.parse(request.url).pathname;
    console.log("Request for " + pathname + " received.");

    request.setEncoding("utf8");

    request.addListener("data", function(postDataChunk) {
      postData += postDataChunk;
      console.log("Received POST data chunk '"+
      postDataChunk + "'.");
    });

    request.addListener("end", function() {
      console.log("data received ending" + pathname);
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
  console.log("Server has started.");
}

exports.start = start;
复制代码

requestHandlers.js

复制代码 
var querystring = require("querystring");

function start(response, postData) {
  console.log("Request handler 'start' was called.");

  var body = '<html>'+
    '<head>'+
    '<meta http-equiv="Content-Type" content="text/html; '+
    'charset=UTF-8" />'+
    '</head>'+
    '<body>'+
    '<form action="/upload" method="post">'+
    '<textarea name="text" rows="20" cols="60"></textarea>'+
    '<input type="submit" value="Submit text" />'+
    '</form>'+
    '</body>'+
    '</html>';

    response.writeHead(200, {"Content-Type": "text/html"});
    response.write(body);
    response.end();
}

function upload(response, postData) {
  console.log("Request handler 'upload' was called.");
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("You've sent the text: "+
  querystring.parse(postData).text);
  response.end();
}

exports.start = start;
exports.upload = upload;
复制代码

router.js

复制代码 
function route(handle, pathname, response, postData) {
  console.log("About to route a request for " + pathname);
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    console.log("No request handler found for " + pathname);
    response.writeHead(404, {"Content-Type": "text/plain"});
    response.write("404 Not found");
    response.end();
  }
}

exports.route = route;
复制代码

 

result:

  

 

 

知识点：

require和exports的用法：

index.js中代码

var Hello = require('.hello');

hello = new Hello();
hello.setName('Joey');
hello.sayHello();

hello.js中代码

复制代码 
function Hello(){
    var name;

    this.setName = function(thyName){
        name = thyName;
    }

    this.sayHello = function(){
        console.log('Hello ' + name);
    }
}

//exports.Hello = Hello;  //此时我们在其他文件中需要通过 require('./hello').Hello来获取Hello对象，这种写法有点冗余
module.exports = Hello; //输出的就是Hello对象本身，不是上面的exports，上面的是暴露.Hello，.Hello赋予了Hello对象
复制代码

3.图片上传与显式

index.js

复制代码 
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;

server.start(router.route, handle);
复制代码

server.js

复制代码 
var http = require("http");
var url = require("url");

function start(route, handle) {
  function onRequest(request, response) {
    var postData = "";
    var pathname = url.parse(request.url).pathname;
    console.log("Request for " + pathname + " received.");

    request.setEncoding("utf8");

    request.addListener("data", function(postDataChunk) {
      postData += postDataChunk;
      console.log("Received POST data chunk '"+
      postDataChunk + "'.");
    });

    request.addListener("end", function() {
      console.log("data received ending" + pathname);
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
  console.log("Server has started.");
}

exports.start = start;
复制代码

requestHandlers.js

复制代码 
var querystring = require("querystring");

function start(response, postData) {
  console.log("Request handler 'start' was called.");

  var body = '<html>'+
    '<head>'+
    '<meta http-equiv="Content-Type" content="text/html; '+
    'charset=UTF-8" />'+
    '</head>'+
    '<body>'+
    '<form action="/upload" method="post">'+
    '<textarea name="text" rows="20" cols="60"></textarea>'+
    '<input type="submit" value="Submit text" />'+
    '</form>'+
    '</body>'+
    '</html>';

    response.writeHead(200, {"Content-Type": "text/html"});
    response.write(body);
    response.end();
}

function upload(response, postData) {
  console.log("Request handler 'upload' was called.");
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("You've sent the text: "+
  querystring.parse(postData).text);
  response.end();
}

exports.start = start;
exports.upload = upload;
复制代码

router.js

复制代码 
function route(handle, pathname, response, postData) {
  console.log("About to route a request for " + pathname);
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    console.log("No request handler found for " + pathname);
    response.writeHead(404, {"Content-Type": "text/plain"});
    response.write("404 Not found");
    response.end();
  }
}

exports.route = route;
复制代码

 

result:

  

 

 

知识点：

require和exports的用法：

index.js中代码

var Hello = require('.hello');

hello = new Hello();
hello.setName('Joey');
hello.sayHello();

hello.js中代码

复制代码 
function Hello(){
    var name;

    this.setName = function(thyName){
        name = thyName;
    }

    this.sayHello = function(){
        console.log('Hello ' + name);
    }
}

//exports.Hello = Hello;  //此时我们在其他文件中需要通过 require('./hello').Hello来获取Hello对象，这种写法有点冗余
module.exports = Hello; //输出的就是Hello对象本身，不是上面的exports，上面的是暴露.Hello，.Hello赋予了Hello对象
复制代码

index.js

复制代码 
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
handle["/show"] = requestHandlers.show;

server.start(router.route, handle);
复制代码

server.js

复制代码 
var http = require("http");
var url = require("url");

function start(route, handle) {
  function onRequest(request, response) {
    var pathname = url.parse(request.url).pathname;
    console.log("Request for " + pathname + " received.");
    route(handle, pathname, response, request);
  }

  http.createServer(onRequest).listen(3000);
  console.log("Server has started.");
}

exports.start = start;
复制代码

requestHandlers.js

复制代码 
var querystring = require("querystring"),
    fs = require("fs"),
    formidable = require("formidable");

function start(response) {
    console.log("Request handler 'start' was called.");

    var body = '<html>'+
        '<head>'+
        '<meta http-equiv="Content-Type" content="text/html; '+
        'charset=UTF-8" />'+
        '</head>'+
        '<body>'+
        '<form action="/upload" enctype="multipart/form-data" '+
        'method="post">'+
        '<input type="file" name="upload" multiple="multiple">'+
        '<input type="submit" value="Upload file" />'+
        '</form>'+
        '</body>'+
        '</html>';

    response.writeHead(200, {"Content-Type": "text/html"});
    response.write(body);
    response.end();
}

function upload(response, request) {
    console.log("Request handler 'upload' was called.");

    var form = new formidable.IncomingForm();
    form.uploadDir = "D:\\min\\nodejsExample2\\tmp";
    console.log("about to parse1");
    form.parse(request, function(error, fields, files) {
        console.log("parsing done");
        console.log(files.upload.path);
        fs.renameSync(files.upload.path, "D:\\min\\nodejsExample2\\tmp\\test.png");
        response.writeHead(200, {"Content-Type": "text/html"});
        response.write("received image:<br/>");
        response.write("<img src='/show' />");
        response.end();
  });
}

function show(response) {
    console.log("Request handler 'show' was called.");
    fs.readFile("D:\\min\\nodejsExample2\\tmp\\test.png", "binary", function(error, file) {
        if(error) {
            response.writeHead(500, {"Content-Type": "text/plain"});
            response.write(error + "\n");
            response.end();
        } else {
            response.writeHead(200, {"Content-Type": "image/png"});
            response.write(file, "binary");
            response.end();
        }
    });
}

exports.start = start;
exports.upload = upload;
exports.show = show;
复制代码

router.js

复制代码 
function route(handle, pathname, response, request) {
    console.log("About to route a request for " + pathname);
    if (typeof handle[pathname] === 'function') {
        handle[pathname](response, request);
    } else {
        console.log("No request handler found for " + pathname);
        response.writeHead(404, {"Content-Type": "text/html"});
        response.write("404 Not found");
        response.end();
    }
}

exports.route = route;
复制代码

 

result:

 

 

知识点：

其中用到了fs模块的readFile读取文件，它有同步和异步两个版本。node.js中，并不是所有的API都提供了异步和同步版本，node.js不鼓励使用同步I/O。

复制代码 
//this is async 异步
/*
 fs.readFile调用时所做的工作只是将异步式I/O请求发送给了操作系统，然后立即返回并执行后面的语句，执行完以后进入事件循环监听事件。
 当fs接收到I/O请求完成的事件时，事件循环会主动调用回调函数以完成后续工作。
 */
var fs = require('fs');
fs.readFile('file.txt', 'utf-8', function(err, data){
    if (err){
        console.error(err);
    } else {
        console.log(data);
    }
});
复制代码

 

//this is sync 同步
var fs = require('fs');
var data = fs.readFileSync('file.txt', 'utf-8');
console.log(data);
console.log('end.');

 

4.服务器监听

index.js

复制代码 
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;

server.start(router.route, handle);
复制代码

server.js

复制代码 
var http = require("http");
var url = require("url");

function start(route, handle) {
  function onRequest(request, response) {
    var postData = "";
    var pathname = url.parse(request.url).pathname;
    console.log("Request for " + pathname + " received.");

    request.setEncoding("utf8");

    request.addListener("data", function(postDataChunk) {
      postData += postDataChunk;
      console.log("Received POST data chunk '"+
      postDataChunk + "'.");
    });

    request.addListener("end", function() {
      console.log("data received ending" + pathname);
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
  console.log("Server has started.");
}

exports.start = start;
复制代码

requestHandlers.js

复制代码 
var querystring = require("querystring");

function start(response, postData) {
  console.log("Request handler 'start' was called.");

  var body = '<html>'+
    '<head>'+
    '<meta http-equiv="Content-Type" content="text/html; '+
    'charset=UTF-8" />'+
    '</head>'+
    '<body>'+
    '<form action="/upload" method="post">'+
    '<textarea name="text" rows="20" cols="60"></textarea>'+
    '<input type="submit" value="Submit text" />'+
    '</form>'+
    '</body>'+
    '</html>';

    response.writeHead(200, {"Content-Type": "text/html"});
    response.write(body);
    response.end();
}

function upload(response, postData) {
  console.log("Request handler 'upload' was called.");
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("You've sent the text: "+
  querystring.parse(postData).text);
  response.end();
}

exports.start = start;
exports.upload = upload;
复制代码

router.js

复制代码 
function route(handle, pathname, response, postData) {
  console.log("About to route a request for " + pathname);
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    console.log("No request handler found for " + pathname);
    response.writeHead(404, {"Content-Type": "text/plain"});
    response.write("404 Not found");
    response.end();
  }
}

exports.route = route;
复制代码

 

result:

  

 

 

知识点：

require和exports的用法：

index.js中代码

var Hello = require('.hello');

hello = new Hello();
hello.setName('Joey');
hello.sayHello();

hello.js中代码

复制代码 
function Hello(){
    var name;

    this.setName = function(thyName){
        name = thyName;
    }

    this.sayHello = function(){
        console.log('Hello ' + name);
    }
}

//exports.Hello = Hello;  //此时我们在其他文件中需要通过 require('./hello').Hello来获取Hello对象，这种写法有点冗余
module.exports = Hello; //输出的就是Hello对象本身，不是上面的exports，上面的是暴露.Hello，.Hello赋予了Hello对象
复制代码

httpsnifferInvoke.js

复制代码 
var http = require('http');
var sniffer = require('./httpsniffer');

var server = http.createServer(function(req, res){
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello, World!\n');
});

sniffer.sniffOn(server);
server.listen(3000);
复制代码

httpsniffer.js

复制代码 
//http sniffer 监听每个服务器事件，然后输出每个事件的相关信息
var url = require('url');
var util = require('util');

exports.sniffOn = function(server){
    server.on('request', function(req, res){
        util.log('e_request');
        util.log(reqToString(req));
    });

    server.on('close', function(error){
        util.log('e_close error=' + error);
    });

    server.on('checkContinue', function(req, res){
        util.log('e_checkContinue');
        util.log(reqToString(req));
        res.writeContinue();
    });

    server.on('upgrade', function(req, socket, head){
        util.log('e_upgrade');
        util.log(reqToString(req));
    });

    server.on('clientError', function(){
        util.log('e_clientError');
    });
}

var reqToString = function(req){
    var ret = 'request' + req.method + ' ' + req.httpVersion + ' ' + req.url + '\n';
    ret += JSON.stringify(url.parse(req.url, true)) + '\n';
    var keys = Object.keys(req.headers);
    for (var i = 0; i < keys.length; i++){
        var key = keys[i];
        ret += i + ' ' + key + ': ' + req.headers[key] + '\n';
    }
    if (req.trailers) ret += req.trailers + '\n';
    return ret;
}

exports.reqToString = reqToString;
复制代码

 


5.EventEmitter发送和接收事件

pulser.js

复制代码 
/*
 EventEmitter发送和接收事件
 HTTPServer和HTTPClient类，它们都继承自EventEmitter

 EventEmitter被定义在Node的事件(events)模块中，直接使用EventEmitter类需要先声明require('events')，
 否则不必显式声明require('events')，因为Node中很多对象都无需你调用require('events')就会使用EventEmitter
 */
var events = require('events');
var util = require('util');

function Pulser(){
    events.EventEmitter.call(this);
}
util.inherits(Pulser, events.EventEmitter);

Pulser.prototype.start = function(){
    var self = this;
    this.id = setInterval(function(){
        util.log('>>>>pulse');
        self.emit('pulse');
        util.log('<<<<pulse');
    }, 1000);
}
//定义了一个类Pulser，该类(通过util.inherits)继承自EventEmitter，它的作用是每隔一秒钟向所有监听器发送一个定时事件。
//start方法使用了setInterval这个函数来定期重复执行回调函数，并调用emit方法将pulse事件发送给每一个监听器


//使用Pulser对象
/*
创建了一个Pulser对象并处理其pulse事件，执行pulser.on('pulse'..)为pulse事件和回调函数建立联系
 */
var pulser = new Pulser();
pulser.on('pulse', function(){
    util.log('pulse received');
});
pulser.start();


//对象使用emit函数发送事件，所有注册到对应事件的监听器都可以收到事件；
//通过调用.on方法注册监听器，参数是事件名，并用一个回调函数接收事件
//通常来说，有一些数据需要伴随着事件同时发送  self.emit('eventName', data1, data2, ..);
//emitter.on('eventName', function(data1, data2,..){
       //接收到事件后的操作
// });
复制代码

  每秒输出一次



6.发送HTTP客户端请求并显示响应结果

wget.js：发送HTTP客户端请求并显示响应的各种结果

options对象描述了将要发出的请求。
data事件在数据到达时被触发，error事件在发生错误时被触发。
HTTP请求中的数据格式通过MIME协议来声明，例如，提交HTML表单时它的Content-Type会被设置成multipart/form-data。
要在HTTP客户端请求中发送数据，只需调用.write方法并写入符合规范的数据（见第二个例子）。

复制代码 
var http = require('http');
var url = require('url');
var util = require('util');

var argUrl = process.argv[2];
var parsedUrl = url.parse(argUrl, true);

var options = {host: null, port: -1, path: null, method: 'GET'};
options.host = parsedUrl.hostname;
options.port = parsedUrl.port;
options.path = parsedUrl.pathname;

if (parsedUrl.search) options.path += "?" + parsedUrl.search;

var req = http.request(options, function(res){
    util.log('STATUS: ' + res.statusCode);
    util.log('HEADERS: ' + util.inspect(res.headers));
    res.setEncoding('utf8');
    res.on('data', function(chunk){
        util.log('BODY: ' + chunk);
    });
    res.on('error', function(err){
        util.log('RESPONSE ERROR: ' + err);
    });
});

req.on('error', function(err){
    util.log('REQUEST ERROR: ' + err);
});
req.end();
复制代码

node wget.js http://example.com

 

又一个发送客户端httprequest例子：使用req.write发送数据

复制代码 
var http = require('http');
var querystring = require('querystring');

var contents = querystring.stringify({
    name: 'joey',
    email: 'joey@joey.com',
    address: 'joey university'
});

var options = {
    host: 'www.joey.com',
    path: '/application/node/post.php',
    method: 'POST',
    headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Content-Length': contents.length
    }
};

var req = http.request(options, function(res){
    res.setEncoding('uft8');
    res.on('data', function(data){
        console.log(data);
    });
});

req.write(contents);
req.end();  //不能漏掉，结束请求，否则服务器将不会收到信息。
复制代码

7.连接SQLite3和mongodb

setup.js：初始化数据库

复制代码 
var util = require('util');
var async = require('async');   //npm install async
var notesdb = require('./nodesdb-sqlite3');
// var notesdb = require('./notesdb-mongoose');

notesdb.connect(function(error){
    if (error) throw error;
});
notesdb.setup(function(error){
    if (error){
        util.log('ERROR ' + error);
        throw error;
    }
    async.series([   //async.series函数可以控制函数按顺序执行，从而保证最后的函数在所有其他函数完成之后执行
        function(cb){
            notesdb.add("test", "testtest",
            function(error){
                if (error) util.log('ERROR ' + error);
                cb(error);
            });
        }
    ],
        function(error, results){
            if (error) util.log('ERROR ' + error);
            notesdb.disconnect(function(err){});
        }
    );
});
复制代码

nodesdb-sqlite3.js

SQLite3 是一个轻量级的进程内SQL引擎
它是一个无服务器且无需配置的SQL数据库引擎，仅仅是作为一个独立的库被链接到应用程序上

npm install sqlite3 安装此模块之前先在系统上安装sqlite3库 http://www.sqlite.org/download.html 下载

复制代码 
//数据库接口库
var util = require('util');
var sqlite3 = require('sqlite3');

sqlite3.verbose();
var db = undefined;

/*
 数据库名是直接硬编码的，所以当调用connect和setup函数时，当前目录中就会生成chap06.sqlite3文件
 */

exports.connect = function(callback){
    db = new sqlite3.Database("chap06.sqlite3", sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE,
        function(err){
            if (err){
                util.log('FAIL on creating database ' + err);
                callback(err);
            } else {
                callback(null);
            }
        });
}

//此处的disconnect函数是空的
exports.disconnect = function(callback){
    callback(null);
}

exports.setup = function(callback){
    db.run("CREATE TABLE IF NOT EXISTS notes " +
        "(ts DATETIME, author VARCHAR(255), note TEXT)",
        function(err){
            if (err){
                util.log('FAIL on creating table ' + err);
                callback(err);
            } else {
                callback(null);
            }
        });
}

exports.emptyNote = {"ts": "", author: "", note: ""};
exports.add = function(author, note, callback){
    db.run("INSERT INTO notes (ts, author, note) " +
        "VALUES (?, ?, ?);",
        [new Date(), author, note],
        function(error){
            if (error){
                util.log('FAIL on add ' + error);
                callback(error);
            } else {
                callback(null);
            }
        });
}
/*
run函数接受一个字符串参数，其中?表示占位符，占位符的值必须通过一个数组传递进来
调用者提供了一个回调函数，然后通过这个回调函数来声明错误
 */

exports.delete = function(ts, callback){
    db.run("DELETE FROM notes WHERE ts = ?;",
        [ts],
        function(err){
            if (err){
                util.log('FAIL to delete ' + err);
                callback(err);
            } else {
                callback(null);
            }
        });
}

exports.edit = function(ts, author, note, callback){
    db.run("UPDATE notes " +
        "SET ts = ?, author = ?, note = ? " +
        "WHERE ts = ?",
        [ts, author, note, ts],
        function(err){
            if (err){
                util.log('FAIL on updating table ' + err);
                callback(err);
            } else {
                callback(null);
            }
        });
}

exports.allNotes = function(callback){
    util.log(' in allnote');
    db.all("SELECT * FROM notes", callback);
}
exports.forAll = function(doEach, done){
    db.each("SELECT * FROM notes", function(err, row){
        if (err){
            util.log('FAIL to retrieve row ' + err);
            done(err, null);
        } else {
            doEach(null, row);
        }
    }, done);
}
/*
allNotes和forAll函数是操作所有数据的两种方法，allNotes把数据库中所有的数据行收集到一个数组里，
而forAll方法可以接受两个回调函数，每当从数据集中拿一行数据，回调函数doEach都会执行一遍，当读完所有数据时，回调函数done就会执行
 */

exports.findNoteById = function(ts, callback){
    var didOne = false;
    db.each("SELECT * FROM notes WHERE ts = ?",
        [ts],
        function(err, row){
            if (err){
                util.log('FAIL to retrieve row ' + err);
                callback(err, null);
            } else {
                if (!didOne){
                    callback(null, row);
                    didOne = true;   //保证回调函数只被执行一次
                }
            }
        });
}
复制代码

notesdb-mongoose.js

MongoDB是nosql数据库的领头羊之一，"可扩展、高性能、开源、面向文档的数据库"，它使用JSON风格的文档。
Mongoose是用于访问MongoDB的模块之一，它是一个对象建模工具，意味着你的程序负责定义模式对象来描述数据，
而Mongoose负责数据到MongoDB的存储。
Mongoose对于Node和MongoDB而言是一个非常强大的对象建模工具，使用嵌入式文档，是一个类型灵活的系统，
适用于字段输入、字段验证、虚拟字段等。

MongoDB Windows 下安装部署 http://www.cnblogs.com/EricaMIN1987_IT/p/3571773.html
安装Mongoose模块 npm install mongoose

Mongoose不是唯一一个在node中使用MongoDB的工具。

复制代码 
var util = require('util');
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var dburl = 'mongodb://localhost/chap06';  //dburl用于连接已运行的MongoDB

exports.connect = function(callback){
    mongoose.connect(dburl);
}
exports.disconnect = function(callback){
    mongoose.disconnect(callback);
}

exports.setup = function(callback){callback(null);}

//定义模式
var NoteSchema = new Schema({
    ts: {type: Date, default: Date.now},  //默认值
    author: String,
    note: String
});
//将NoteSchema作为Mongoose的模型注册进去
mongoose.model('Note', NoteSchema);
var Note = mongoose.model('Note');

exports.emptyNote = {"_id": "", author: "", note: ""};

exports.add = function(author, note, callback){
    var newNote = new Note();
    newNote.author = author;
    newNote.note = note;
    newNote.save(function(err){
        if (err){
            util.log('FATAL ' + err);
            callback(err);
        } else {
            callback(null);
        }
    });
}

exports.delete = function(id, callback){
    exports.findNoteById(id, function(err, doc){
        if (err){
            callback(err);
        } else {
            util.log(util.inspect(doc));
            doc.remove();
            callback(null);
        }
    });
}

exports.edit = function(id, author, note, callback){
    exports.findNoteById(id, function(err, doc){
        if (err){
            callback(err);
        } else {
            doc.ts = new Date();
            doc.author = author;
            doc.note = note;
            doc.save(function(err){
                if (err){
                    util.log('FATAL ' + err);
                    callback(err);
                } else {
                    callback(null);
                }
            });
        }
    });
}

exports.allNotes = function(callback){
    Note.find({}, callback);
}

exports.forAll = function(doEach, done){
    Note.find({}, function(err, docs){
        if (err){
            util.log('FATAL ' + err);
            done(err, null);
        }
        docs.forEach(function(doc){
            doEach(null, doc);
        });
        done(null);
    });
}

/*
_id字段是MongoDB提供的全局唯一的ID，用于标识存储的文档
 */
var findNoteById = exports.findNoteById = function(id, callback){
    Note.findOne({_id: id}, function(err, doc){
        if (err){
            util.log('FATAL ' + err);
            callback(err, null);
        }
        callback(null, doc);
    });
}
复制代码

 

app.js

复制代码 
//在数据库需要放置在一台计算机上时，应该考虑使用SQLite3
//控制器，在nodesdb-sqlite3.js和notesdb-mongoose.js模块之间切换
var util = require('util');
var url = require('url');
var express = require('express');
var nmDbEngine = 'sqlite3';  //用于命名数据库引擎、选择合适的notesdb实现和选择合适的views目录
//var nmDbEngine = 'mongoose';
var notesdb = require('./nodesdb-' + nmDbEngine);
var app = express();
app.use(express.logger());
app.use(express.cookieParser()); //添加cookieParser中间件
app.use(express.bodyParser());
app.engine('.html', require('ejs').__express);   //3.X
//app.register('.html', require('ejs'));    //2.X
app.set('views', __dirname + '/views-' + nmDbEngine);
app.set('view engine', 'ejs');

//是一个路由中间件函数，用于在一些路由器函数中解析URL查询参数
var parseUrlParams = function(req, res, next){
    req.urlP = url.parse(req.url, true);
    next();
}

//检查用户是否被允许访问，这里只检查cookie是否等于AOK，这个单词通常意味着一切都没问题
/*
 很多应用都需要用户登录，然后用户才能进行一些特权操作。由于HTTP是一个无状态的协议，
 验证用户的唯一方式就是发送一个cookie到浏览器上，然后验证标识符。cookie包含了应用中用于验证用户的数据。

 cookieParser中间件在这里做了很多工作，查找cookie，解析cookie，然后将解析出来的值让到req对象中。
 当存在cookie时，它的值会被放入req.cookies中。
 */
var checkAccess = function(req, res, next){
    if (!req.cookies || !req.cookies.notesaccess || req.cookies.notesaccess !== "AOK"){
        res.redirect('/login');
    } else {
        next();
    }
}

notesdb.connect(function(error){
    if (error) throw error;
})

app.on('close', function(error){
    notesdb.disconnect(function(err){});
});

app.get('/', function(req, res) {res.redirect('/view');});
app.get('/view', checkAccess, function(req, res){  //可以在每个路由上加checkAccess检查
    notesdb.allNotes(function(err, notes){
        if (err){
            util.log('ERROR ' + err);
            throw err;
        } else {
            res.render('viewnotes.html', {title: "Notes ("+ nmDbEngine +")", notes: notes});
        }
    });
});

/*
当用户点击ADD按钮时app.get('/add', ...)内的函数就会被调用，浏览器会发出一个发往/add的HTTP GET请求。
这个函数使用addedit.html模板来创建一个表单，让用于通过这个表单输入标签，然后通过单击SUBMIT按钮提交，
当用户提交表单，浏览器就会发出一个HTTP POST请求，app.post('/add', ...)内的函数就会被调用，
用户输入的数据会被存放在请求主体中，而请求主体会被bodyParser(app.use(express.bodyParser()))中间件处理并存放在req.body中
 */
app.get('/add', function(req, res){
    res.render('addedit.html', {title: "Notes ("+ nmDbEngine +")", postpath: '/add', note: notesdb.emptyNote});
});
app.post('/add', function(req, res){
    notesdb.add(req.body.author, req.body.note,
        function(error){
            if (error) throw error;
            res.redirect('/view');
        });
});

app.get('/del', parseUrlParams, function(req, res){
    notesdb.delete(req.urlP.query.id,
        function(error){
            if (error) throw error;
            res.redirect('/view');
        });
});

app.get('/edit', parseUrlParams, function(req, res){
    notesdb.findNoteById(req.urlP.query.id,
        function(error, note){
            if (error) throw error;
            res.render('addedit.html',
                {title: "Notes ("+ nmDbEngine +")", postpath: '/edit', note: note});
        });
});
app.post('/edit', function(req, res){
    notesdb.edit(req.body.id, req.body.author, req.body.note,
        function(error){
            if (error) throw error;
            res.redirect('/view');
        });
});

app.get('/login', function(req, res){
    res.render('login.html', {title: "Notes LOGIN ("+ nmDbEngine +")"});
});
app.post('/login', function(req, res){
    //此处可以添加检查用户信息的逻辑
    //...
    res.cookie('notesaccess', 'AOK');
    res.redirect('/view');
});

app.listen(3000);
复制代码

show.js

复制代码 
//控制台显示
var util = require('util');
var notesdb = require('./notesdb-sqlite3');
// var notesdb = require('./notesdb-mongoose');

notesdb.connect(function(error){
    if (error) throw error;
});
notesdb.forAll(function(error, row){
    util.log('ROW: ' + util.inspect(row));
}, function(error){
    if (error) throw error;
    util.log('ALL DONE');
    notesdb.disconnect(function(err){});
});
复制代码

前台页面在views-sqlite3目录下

layout.html

复制代码 
<!DOCTYPE html>
<html>
<head>
    <title><%= title%></title>
</head>
<body>
    <h1><%= title%></h1>
    <p><a href='/view'>View</a> | <a href='/add'>Add</a></p>
</body>
</html>
复制代码

viewnotes.html

复制代码 
<% include layout.html %>
<table><% notes.forEach(function(note){ %>
    <tr>
        <td>
            <p><%=new Date(note.ts).toString()%>: by <b><%=note.author%></b></p>
            <p><%=note.note%></p>
        </td>
        <td>
            <form method="get" action="/del">
                <input type="submit" value="Delete" />
                <input type="hidden" name="id" value="<%=note.ts%>" />
            </form>
            <br/>
            <form method="get" action="/edit">
                <input type="submit" value="Edit" />
                <input type="hidden" name="id" value="<%=note.ts%>" />
            </form>
        </td>
    </tr>
    <% }); %>
</table>
复制代码

addedit.html

复制代码 
<% include layout.html %>
<form method="post" action="<%=postpath%>">
    <% if (note){ %>
    <input type="hidden" name="id" value="<%=note.ts%>" />
    <% } %>
    <input type="text" name="author" value="<%=note.author%>" />
    <br/>
    <textarea rows="5" cols="40" name="note">
        <%=note.note%>
    </textarea>
    <br/>
    <input type="submit" value="Submit" />
</form>
复制代码

login.html

<% include layout.html %>
<form method="POST" action="/login">
    <p>Click the <i>Login</i> to log in.</p>
    <input type="submit" value="Login" />
</form>

node setup.js

node app.js



8.设置HTTP头


server.js

复制代码 
//basic server的配置文件
var port = 3000;
var server = require('./basicserver').createServer();
server.useFavIcon("localhost", "./docroot/favicon.png");
server.addContainer(".*", "/l/(.*)$", require('./redirector'), {})
server.docroot("localhost", "/", "./docroot");
//server.useFavIcon("127.0.0.1", "./docroot/favicon.png");
//server.docroot("127.0.0.1", "/", "./docroot");
server.listen(port);
复制代码

basicserver.js

Response Header 服务器发送到客户端
文件扩展名不足以完全恰当的标识文件类型，而且文件扩展名没有标准，于是，人们设计了Content-Type头和整个MIME类型标准来作为数据类型的表示系统。

对于某些应用，特别是一些处理固定数据的小型应用，我们可以精准的知道该使用哪一种Content-Type头，因为应用发送的数据是特定已知的。然而staticHandler能发送任何文件，通常不知道该使用哪种Content-Type。通过匹配文件扩展名列表和Content-Type可以解决这个问题，但是这个方案不完美。最好的实践方案是使用一个外部的配置文件，它通常由操作系统提供。

MIME npm包使用了Apache项目的mime.types文件，该文件包含超过600个Content-Type的有关数据，如果有需要，mime模块也支持添加自定义的MIME类型。

npm install mime

var mime = require('mime');
var mimeType = mime.lookup('image.gif'); //==> image/gif
res.setHeader('Content-Type', mimeType);

一些相关的HTTP头：
Content-Encoding 数据被编码时使用，例如gzip
Content-Language 内容中使用的语言
Content-Length 字节数
Content-Location 能取到数据的一个候补位置
Content-MD5 内容主题的MD5校验和

HTTP协议是无状态的，意味着web服务器不能辨认不同的请求发送端。现在普遍的做法是，服务器发送cookie到客户端浏览器，cookie中定义了登陆用户的身份，对于每一次请求，web浏览器都会发送对应所访问网站的cookie。

发送cookie时，我们应以如下方式为Set-Cookie或Set-Cookie2头设一个值：
res.setHeader('Set-Cookie2', ..cookie value..);

 

 

复制代码 
/*
 Basic Server的核心模块会创建一个HTTP服务器对象，附加Basic Server上用于检查请求，然后给予适当响应的功能
 Basic Server可以通过判断Host头部匹配的容器对象响应来自多个域名的请求
 */
var http = require('http');
var url = require('url');

exports.createServer = function(){
    var htserver = http.createServer(function(req, res){
        req.basicServer = {urlparsed: url.parse(req.url, true)};
        processHeaders(req, res);
        dispatchToContainer(htserver, req, res);
    });
    htserver.basicServer = {containers: []};
    htserver.addContainer = function(host, path, module, options){
        if (lookupContainer(htserver, host, path) != undefined){
            throw new Error("Already mapped " + host + "/" + path);
        }
        htserver.basicServer.containers.push({host: host, path: path, module: module, options: options});
        return this;
    }
    htserver.useFavIcon = function(host, path){
        return this.addContainer(host, "/favicon.ico", require('./faviconHandler'), {iconPath: path});
    }
    htserver.docroot = function(host, path, rootPath){
        return this.addContainer(host, path, require('./staticHandler'), {docroot: rootPath});
    }

    return htserver;
}

var lookupContainer = function(htserver, host, path){
    for (var i = 0; i < htserver.basicServer.containers.length; i++){
        var container = htserver.basicServer.containers[i];
        var hostMatches = host.toLowerCase().match(container.host);
        var pathMatches = path.match(container.path);
        if (hostMatches !== null && pathMatches !== null){
            return {container: container, host: hostMatches, path: pathMatches};
        }
    }
    return undefined;
}

//用于搜索req.headers数组以查找cookie和host头部，因为这两个字段对请求的分派都很重要
//这个函数在每一个HTTP请求到达时都会被调用
//还有很多其他的HTTP头部字段(Accept Accept-Encoding Accept-Language User-Agent)
var processHeaders = function(req, res){
    req.basicServer.cookies = [];
    var keys = Object.keys(req.headers);
    for (var i = 0; i < keys.length; i++){
        var hname = keys[i];
        var hval = req.headers[hname];
        if (hname.toLowerCase() === "host"){
            req.basicServer.host = hval;
        }
        //提取浏览器发送的cookie
        if (hname.toLowerCase() === "cookie"){
            req.basicServer.cookies.push(hval);
        }
    }
}

//查找匹配的容器，分派请求到对应的容器中
//这个函数在每一个HTTP请求到达时都会被调用
var dispatchToContainer = function(htserver, req, res){
    var container = lookupContainer(htserver, req.basicServer.host, req.basicServer.urlparsed.pathname);
    if (container !== undefined){
        req.basicServer.hostMatches = container.host;
        req.basicServer.pathMatches = container.path;
        req.basicServer.container = container.container;
        container.container.module.handle(req, res);
    }else {
        res.writeHead(404, {'Content-Type': 'text/plain'});
        res.end("no handler found for " + req.basicServer.host + "/" + req.basicServer.urlparsed);
    }
}
复制代码

staticHandler.js

复制代码 
//用于处理文件系统内的文件，docroot选项指被存放文件所在文件夹的路径，读取该目录下的指定文件
var fs = require('fs');
var mime = require('mime');
var sys = require('sys');

exports.handle = function(req, res){
    if (req.method !== "GET"){
        res.writeHead(404, {'Content-Type': 'text/plain'});
        res.end("invalid method " + req.method);
    } else {
        var fname = req.basicServer.container.options.docroot + req.basicServer.urlparsed.pathname;
        if (fname.match(/\/$/)) fname += "index.html";  //如果URL以/结尾
        fs.stat(fname, function(err, stats){
            if (err){
                res.writeHead(500, {'Content-Type': 'text/plain'});
                res.end("file " + fname + " not found " + err);
            } else {
                fs.readFile(fname, function(err, buf){
                    if (err){
                        res.writeHead(500, {'Content-Type': 'text/plain'});
                        res.end("file " + fname + " not readable " + err);
                    } else {
                        res.writeHead(200, {'Content-Type': mime.lookup(fname),
                            'Content-Length': buf.length});
                        res.end(buf);
                    }
                });
            }
        });
    }
}
复制代码

faviconHandler.js

复制代码 
//这个处理函数处理对favicon.ico的请求
//MIME模块根据给出的图标文件确定正确的MIME类型，网站图标favicon可以是任何类型的图片，但是我们必须要告诉浏览器是哪个类型
//MIME模块，用于生成正确的Content-Type头
var fs = require('fs');
var mime = require('mime');

exports.handle = function(req, res){
    if (req.method !== "GET"){
        res.writeHead(404, {'Content-Type': 'text/plain'});
        res.end("invalid method " + req.method);
    } else if (req.basicServer.container.options.iconPath !== undefined){
        fs.readFile(req.basicServer.container.options.iconPath, function(err, buf){
            if (err){
                res.writeHead(500, {'Content-Type': 'text/plain'});
                res.end(req.basicServer.container.options.iconPath + "not found");
            } else {
                res.writeHead(200, {'Content-Type': mime.lookup(req.basicServer.container.options.iconPath),
                'Content-Length': buf.length});
                res.end(buf);
            }
        });
    } else {
        res.writeHead(404, {'Content-Type': 'text/plain'});
        res.end("no favicon");
    }
}
复制代码

redirector.js

复制代码 
/*
 把一个域的请求重定向到另一个上，例如将www.example.com重定向到example.com上，或者使用简短的URL跳转到较长的URL
 实现这两种情况，我们需要在HTTP响应中发送301(永久移除)或者302(临时移除)状态码，并且指定location头信息。有了这个组合
 信号，web浏览器就知道要跳转到另一个web位置了
 */
//地址http://localhost:3000/l/ex1 会跳转到http://example1.com
var util = require('util');
var code2url = {'ex1': 'http://example1.com', 'ex2': "http://example2.com"};
var notFound = function(req, res){
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.end("no matching redirect code found for " + req.basicServer.host + "/" + req.basicServer.urlparsed.pathname);
}

exports.handle = function(req, res){
    if (req.basicServer.pathMatches[1]){
        var code = req.basicServer.pathMatches[1];
        if (code2url[code]){
            var url = code2url[code];
            res.writeHead(302, {'Location': url});
            res.end();
        } else {
            notFound(req, res);
        }
    } else {
        notFound(req, res);
    }
}
复制代码

docroot目录下：有favicon.png

index.html

复制代码 
<html>
<head>
</head>
<body>
    <h1>Index</h1>
    <p>this is a index html.</p>
</body>
</html>
复制代码



index.js

复制代码 
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;

server.start(router.route, handle);
复制代码

server.js

复制代码 
var http = require("http");
var url = require("url");

function start(route, handle) {
  function onRequest(request, response) {
    var postData = "";
    var pathname = url.parse(request.url).pathname;
    console.log("Request for " + pathname + " received.");

    request.setEncoding("utf8");

    request.addListener("data", function(postDataChunk) {
      postData += postDataChunk;
      console.log("Received POST data chunk '"+
      postDataChunk + "'.");
    });

    request.addListener("end", function() {
      console.log("data received ending" + pathname);
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
  console.log("Server has started.");
}

exports.start = start;
复制代码

requestHandlers.js

复制代码 
var querystring = require("querystring");

function start(response, postData) {
  console.log("Request handler 'start' was called.");

  var body = '<html>'+
    '<head>'+
    '<meta http-equiv="Content-Type" content="text/html; '+
    'charset=UTF-8" />'+
    '</head>'+
    '<body>'+
    '<form action="/upload" method="post">'+
    '<textarea name="text" rows="20" cols="60"></textarea>'+
    '<input type="submit" value="Submit text" />'+
    '</form>'+
    '</body>'+
    '</html>';

    response.writeHead(200, {"Content-Type": "text/html"});
    response.write(body);
    response.end();
}

function upload(response, postData) {
  console.log("Request handler 'upload' was called.");
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("You've sent the text: "+
  querystring.parse(postData).text);
  response.end();
}

exports.start = start;
exports.upload = upload;
复制代码

router.js

复制代码 
function route(handle, pathname, response, postData) {
  console.log("About to route a request for " + pathname);
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    console.log("No request handler found for " + pathname);
    response.writeHead(404, {"Content-Type": "text/plain"});
    response.write("404 Not found");
    response.end();
  }
}

exports.route = route;
复制代码

 

result:

  

 

 

知识点：

require和exports的用法：

index.js中代码

var Hello = require('.hello');

hello = new Hello();
hello.setName('Joey');
hello.sayHello();

hello.js中代码

复制代码 
function Hello(){
    var name;

    this.setName = function(thyName){
        name = thyName;
    }

    this.sayHello = function(){
        console.log('Hello ' + name);
    }
}

//exports.Hello = Hello;  //此时我们在其他文件中需要通过 require('./hello').Hello来获取Hello对象，这种写法有点冗余
module.exports = Hello; //输出的就是Hello对象本身，不是上面的exports，上面的是暴露.Hello，.Hello赋予了Hello对象
复制代码
小飞鹤
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从0到1使用NodeJS编写后端接口的实战案例（仅供参考）
不怕麻烦的鹿丸的博客
06-18 4979
基于vue和node.js来开发的一个在线商城管理系统。
Mongoose的用法笔记
逍遥飞鹤的专栏
10-23 7876
1.关于Mongoose 1.Mongoose支持的数据类型 String -- 字符串 Number -- 数字，包括整数和小数 Date -- 日期 Boolean -- 布尔 Buffer -- 用于存储二进制数据，eg：图片，最大不超过16M O
nodejs简单登录案例
08-08
nodejs简单登录案例
know:nodejs实战案例（Express框架+ mongoDB）
03-23
知道 nodejs开篇：关于作者：本人是属于比较纯的前端，做的js开发比较多，对于某些语言了解很少（了解一些php的开发，在实践中做过简单的php网页），这个实战系列属于从零开始自己琢磨，顺着学习了很多很多知识。如果你和我一样属于前端开发，对js比较熟悉，对与此比较生疏，个人觉得这个系列很适合你，因为我会把我在从另一个，这个实例我分别在mac和window下开发，两个系统的相对我也会详解出来。 感谢：这个实战我完全是在网上找各种资料学习，总结的最直接的帮助我是完整的学习了一边这个教程，才开始我自己的这个实战练习的 //www.nodebeginner.org/index-zh-cn.html介绍文章我看了好几遍，推荐 我用到的框架，数据库和插件：数据库存储用的mongodb框架express前端框架：jquery和bootstrap，以及下划线摸版ejs功能：并实现ajax-不跨越，然后扩
云计算-运维笔记
热门推荐
weixin_52099680的博客
07-13 1万+
source 刷新环境变量的作用是当前终端可以生效使用 切换另一个终端时会重新加载一便环境变量 awk ‘{print $1}’ 1.log |sort -n |uniq -c |sort -n xargs 将上一个命令的输出 变成下一个命令的参数 删除中文 a d 你 好 ls | grep -vP[a-z-.]+|rm -rf ‘xargs’ #egrep -P 扩展正则 ‘[ ]’ 规范写法加’’ 号 *脚本 1.系统初始化脚本 #!/bin/bash cat <<EOF
全国职业院校技能大赛改革试点赛云计算赛项
snoopy
06-21 3016
全国职业院校技能大赛改革试点赛云计算赛项 国基北盛云基础架构平台软件（私有云平台） 用户手册 V1.0 2020年10月 目 录 简介 7 1 基本环境配置 8 1.1安装CentOS7说明 9 1.2配置网络、主机名 9 1.3配置yum源 11 1.4编辑环境变量 13 1.5通过脚本安装服务 15 1.6安装Openstack包 15 1.7配置域名解析 15 1.8安装chrony服务 16 1.9通过脚本安装数据库服务 16 1.10安装Mysql数据库服务 17 1.11安装RabbitM
Node.js入门案例Demo项目，学生管理系统（Express+MySQL）
Certainly_的博客
03-01 1535
Node.js学生管理系统（Express+MySQL） 这次的案例，数据持久化，用的MySQL 目录 一、完成功能：实现对“学生信息”的增删改查。并且实现了数据持久化。 数据库为MySQL。 二、使用到的技术：基于Express框架和art-template模板引擎，并且将路由模块分离出来，更利于开发和维护 三、编写代码 1.首先初始化项目（package.json） 2.安装要用到的包 4.路由模块router.js 5.封装MySQL对学生处理模块student.js 6.视图 四、页面展示
初识 Nodejs (附带案例)
qq_41045128的博客
07-03 1318
目录一、什么是Node.js二、Node.js 可以做什么三、Node.js内置API3.1、fs 模块3.2、path 路径模块3.3、http模块四、本地服务案例 它不是一门语言，库，框架，而是js运行时的环境。nodejs可以解析和执行js代码，相比于以前只用浏览器才可以解析执行js代码，现在的Js可以完全脱离浏览器来运行。Nodejs作者把Chrome中的V8引擎移植出来，开发了一个独立的js运行时环境(Nodejs)。 Node.js 中无法调用 DOM 和 BOM 等
Node.js简介及示例
前端御书房
12-05 997
什么是Nodejs Node.js（中文网链接 官网链接）是一个基于 Chrome V8 引擎的 JavaScript 运行环境。可以使javascript在服务器环境中运行。 怎么使用 在你官网下载Node.js安装程序，进行安装，在 cmd环境 中输入node命令，即可进入node环境，可以输入javascript代码运行。 从上面可以看到node的版本号，由此说明进入node环境，接下来输入代码试一下 由此看出，js代码可以再ndoe环境中运行，那么仅仅在cmd中运行是不够的，那么我们可以创建一个
学习杂记
在大海里翱翔的猪
02-10 362
学习杂记～～有些东西太小，不够一篇文章，都记到一块儿去！
【鸟哥杂谈】十分钟搭建自己的本地 Node-Red可拖拽图形化物联网
单片机菜鸟哥的博客
10-16 8918
本文简单介绍了Node-RED工具以及它能给我们开发物联网带来那些功能效果，先搭建好环境，然后去玩转起来，静待后续篇章。
node.js.gif简单示例
01-03
node.js简单示例
Node-Samples:Node.js示例
04-29
节点样本Node.js示例集合01.基本Node.js基础模块：如何加载模块以及如何在模块中使用类和函数全局：全局对象02.基本模块基本模块示例实用程序：实用程序模块事件：事件模块缓冲区：缓冲区流：流模块示例FileSystem：...
chat_node:node.js 聊天示例
07-10
聊天节点node.js 聊天示例(english) 这是一个在 node.js 中进行的聊天示例。 为了让它工作，你必须： 安装节点（ ） 制作这个 repo 的 git clone 在根文件夹中运行“npm start” 聪明的！ （英文）这是一个 node.js ...
node.js入门最佳示例demo
03-01
最佳node入门例子，用到了express + ejs + mysql，程序功能是给出音乐列表，音乐可以播放，可以上传音乐。程序中没有用到其它各种包，很单纯，而且项目的readme文件中对...把本程序研究清楚，node.js就可以算是入门了。
graphqlexample:node.js GraphQL示例
05-15
node.js GraphQL范例示例 2018.06.03by Chih-Han Liuhttps://justjii.justdrink.com.tw/
Node.js学习技术栈
逍遥飞鹤的专栏
10-10 7304
1.Node.js学习技术栈 nodejs是比较简单的，只有你有前端js基础，那就按照我的办法来吧！一周足矣 推荐技术栈 express 4.x （express最新版本，初学者先别去碰koa）mongoose（mongodb）bluebird（Promise/A+实现）jade（视图层模板）mocha（测试）node-inspector(调试) https://git
Node.js+Express4.x+mongodb3.x做Web开发时的Session处理
逍遥飞鹤的专栏
10-20 3912
Node.js+Express4.x+mongodb3.x做Web开发时的Session处理
Node.js中的Mongoose实用笔记
逍遥飞鹤的专栏
10-22 3510
1.Mongoose学习参考文档 前言：本学习参考文档仅供参考，如有问题，师请雅正 ##一、快速通道 ###1.1 名词解释 Schema ： 一种以文件形式存储的数据库模型骨架，不具备数据库的操作能力 Model ： 由Schema发布生成的模型，具有抽象属性和行为的数据库操作对 Entity ： 由Model创建的实体，他的操作也会影响数
快手支付node.js示例
最新发布
08-17
以下是一个使用 Node.js 进行快手支付的示例代码： ```javascript const axios = require('axios'); // 设置请求头 const headers = { 'Content-Type': 'application/json', 'Authorization': 'Bearer {your_access_token}', }; // 构建请求参数 const data = { amount: 100, // 支付金额，单位为分 subject: '订单支付', // 支付主题 outOrderNo: 'your_order_number', // 商户订单号 notifyUrl: 'https://yourdomain.com/notify', // 异步通知回调地址 }; // 发起支付请求 axios.post('https://pay.kuaishou.com/api/v1/payments', data, { headers }) .then(response => { console.log(response.data); // 处理支付结果 }) .catch(error => { console.error(error); // 处理错误 }); ``` 请注意，上述示例代码中的 `{your_access_token}` 需要替换为你实际的访问令牌，`your_order_number` 需要替换为你的商户订单号，`https://yourdomain.com/notify` 需要替换为你的异步通知回调地址。另外，你需要确保已经安装了 axios 模块，可以通过 `npm install axios` 命令进行安装。 这只是一个基本示例，实际上你可能需要根据快手支付的接口文档进行更详细的参数配置和错误处理。请参考快手支付的官方文档以获取更多信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值