7.3k 次阅读
nodejs+mysql 服务端搭建
手动创建nodejs项目
1、创建项目文件
1、在指定目录下，右击创建文件夹（myapp项目名称）
2、通过命令行创建
a、在指定目录下，右击打开 git bash here ,这里默认安装了命令（Git-2.12.0-64-bit.exe）
b、创建项目文件夹,进入文件夹
mkdir myapp
c、创建package.json文件，初始化
npm init -y # -y表示自动创建完成
d、安装express并保存到以来文件中package.json
npm install express -S # 国外资源
或cnpm install express -S # 淘宝镜像，如果网络不行建议选择这一个
2、进入 myapp 目录，创建一个名为 app.js 的文件，然后将下列代码复制进去：
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello World!');
var server = app.listen(3000, function () {
var host = server.address().
var port = server.address().
console.log('Example app listening at http://%s:%s', host, port);
3、通过如下命令启动此应用：
node app.js
通过脚手架创建项目
通过应用生成器工具 express 可以快速创建一个应用的骨架。
1、全局安装express-generator
npm install express-generator -g 或 cnpm install express-generator -g
2、创建一个命名为 myapp 的应用：
express myapp
3、然后安装所有依赖包：
npm install或cnpm install
4、启动项目
5、项目结构
├── app.js
├── bin
└── www
├── node_modules/ # 依赖包
├── package.json
├── public
├── images
├── javascripts
└── stylesheets
└── style.css
├── routes
├── index.js
└── users.js
└── views
├── error.jade
├── index.jade
└── layout.jade
创建路由，在routes文件夹中创建register.js文件，内容如下：
var express = require("express");
var router = express.Router();
router.post("/", function(req, res) {
res.send("我是register")
connection.end();
module.exports = # 导出路由
路由配置，在app.js文件中
1、路由导入
var index = require('./routes/index');
var users = require('./routes/users');
var register = require('./routes/register');
2、创建路由路径
app.use('/', index);
app.use('/users', users);
app.use('/WWW/register', register);
3、测试访问
http://localhost:3000/···
链接数据库
这里我使用的是MySQL
var mysql = require('mysql')
# 导入模块
var connection = mysql.createConnection({
host: '····', # 主机名
user: '···',
password: '···',
# 用户密码
database: '···' # 数据库名称
connection.connect(); #创建链接
数据库操作
这个链接有详细的数据库操作指令，这里直接借鉴一下。
遇到的问题
1、在一面中打开:3000/时，浏览器显示出一段字符串：
&!DOCTYPE html&&html&&head&&title&Express&/title&&link rel="stylesheet"
href="/stylesheets/style.css"&&/head&&body&&h1&Express&/h1&&p&Welcome to Express&/p&&/body&&html&
说明页面没有解析出html标签
在工程文件中找到 view/layout.jade文件 在里面添加一句：
&meta http-equiv="content-type" content="text/charset=utf-8"&
方案一使用nodemon
$ npm install -g nodemon/cnpm install -g nodemon
$ npm install --save-dev nodemon
nodemon ./bin/www
配置package.json
在package.json文件的"scripts"选项中添加"dev": "nodemon ./bin/www"
"scripts": {
"start": "node ./bin/www",
"dev": "nodemon ./bin/www"
npm run dev
方案二使用supervisor
$ npm install supervisor -g
supervisor ./bin/www
配置package.json
"scripts": {
"start": "node ./bin/www",
"sup": "supervisor ./bin/www"
npm run sup
方案三使用pm2
$ npm install pm2 -g
$ pm2 start ./bin/www
配置package.json
"scripts": {
"start": "node ./bin/www",
"pmStart": "pm2 start ./bin/www"
npm run pmStart
新手之作，如果有什么不好的地方，希望可以得到大家的指点。
9 收藏&&|&&17
内容详细，适合小白学习，已赞已收藏
内容详细，适合小白学习，已赞已收藏
马克，回头看
马克，回头看
分享到微博？
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。架构（MongoDB + Express + Vue + NODEJS）制作网站_心得技巧_动态网站制作指南
架构（MongoDB + Express + Vue + NODEJS）制作网站
来源：人气：782
架构（MongoDB + Exess + Vue + NODEJS）制作网站
MEVN 架构是 MongoDB + Express + Vue + NODEJS 搭建的网站架构。四个部分都可以用Scrt实现。
一个完整的网站服务架构包括web frame, web server, Database, 以及前端展示实现。这里有一篇知乎答案，讲一个网站的整个访问流程，讲的很清晰。
在这个架构里，web server 就是nodejs，webframe 就是express，database是mongoDB，前端展示用了vue。我们一个一个来搭建。
我们在这里模拟实现一个登录功能。
功能很简单，填写完账号密码点击登录按钮，就把账号密码插入，并且查出现在已经有哪些数据。
Database MongoDB
brew install mongodb
mongod --config /usr/local/etc/mongod.conf
这时只是启动了Mogod，链接数据库需要再另外的窗口执行
MongoDB shell version v3.4.1
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 3.4.1
Welcome to the MongoDB shell.
这个地址mongodb://127.0.0.1:27017就是我们本机的mogo数据库地址
使用 Vue-cli 生成一个vue框架
安装Vue-Cli
npm i -g vue-cli
去到你想要放置项目的目录，进行初始化
vue init webpack XXX（你想要项目的名字）
按提示一直下一步，完成后按提示
npm install （这里建议使用淘宝镜像cnpm，不然墙外的东西……）
npm run dev
由于需要使用http请求，安装一个vue-resource工具。
在main.js中使用
import vueResource from 'vue-resource'
Vue.use(vueResource)
使用npm安装
npm install express –save
搭建node服务器环境
在项目的根目录新建一个叫server的目录，用于放置Node的东西。进入server目录，再新建三个js文件：
index.js （入口文件）
db.js （设置数据库相关）
api.js （编写接口）
// 引入编写好的api
const api = require('./api');
// 引入文件模块
const fs = require('fs');
// 引入处理路径的模块
const path = require('path');
// 引入处理post数据的模块
const bodyParser = require('body-parser')
// 引入Express
const express = require('express');
const app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(api);
// 访问静态资源文件 这里是访问所有dist目录下的静态资源文件
app.use(express.static(path.resolve(__dirname, '../dist')))
// 因为是单页应用 所有请求都走/dist/index.html
app.get('*', function(req, res) {
const html = fs.readFileSync(path.resolve(__dirname, '../dist/index.html'), 'utf-8')
res.send(html)
// 监听8088端口
app.listen(8088);
console.log('success listen…………');
// Schema、Model、Entity或者Documents的关系请牢记，Schema生成Model，Model创造Entity，Model和Entity都可对数据库操作造成影响，但Model比Entity更具操作性。
const mongoose = require('mongoose');
// 连接数据库 如果不自己创建 默认test数据库会自动生成
mongoose.connect('mongodb://127.0.0.1:27017'); // 地址跟第一步的地址对应。
// 为这次连接绑定事件
const db = mongoose.
db.once('error',() =& console.log('Mongo connection error'));
db.once('open',() =& console.log('Mongo connection successed'));
/************** 定义模式loginSchema **************/
const loginSchema = mongoose.Schema({
account : String,
pass : String
/************** 定义模型Model **************/
const Models = {
Login : mongoose.model('Login',loginSchema)
module.exports = M
// 可能是我的node版本问题，不用严格模式使用ES6语法会报错
"use strict";
const models = require('./db');
const express = require('express');
const router = express.Router();
/************** 创建(create) 读取(get) 更新(update) 删除(delete) **************/
// 创建账号接口
router.post('/api/login/createAccount',(req,res) =& {
// 这里的req.body能够使用就在index.js中引入了const bodyParser = require('body-parser')
let newAccount = new models.Login({
account : req.body.account,
password : req.body.password
// 保存数据newAccount数据进mongoDB
newAccount.save((err,data) =& {
if (err) {
res.send(err);
res.send('createAccount successed');
// 获取已有账号接口
router.get('/api/login/getAccount',(req,res) =& {
// 通过模型去查找数据库
models.Login.find((err,data) =& {
if (err) {
res.send(err);
res.send(data);
module.exports =
至此我们的后端代码就编写好了，进入server目录，敲上 node index命令，node就会跑起来，这时在浏览器输入http://localhost:8088/api/login/getAccount就能访问到这个接口了
现在我们的本地开发环境的 web server的接口是 index.js 里的8088，但是本地的webpack生成的网页端口是8080，这两个不一致。需要进行代理（proxy）在config/index.js 中修改
proxyTable: {
target: 'http://localhost:8088/api/',
changeOrigin: true,
pathRewrite: {
'^/api': ''
这时，我们在前端接口地址前加上/api，就会指向http://localhost:8088/api/，于是我们就能访问到后端的接口了！让我们来点击一下登录按钮，会发现接口请求成功了！再去数据库看看！也插入了一条新数据！成功！
前后端开发完成，最后一步，前端打包，后端部署。
前端打包就很简单了，一个命令：
npm run build 这就生成了一个dist目录，里面就是打包出来的东西。
现在回过头来看server里面的入口文件index.js
// 访问静态资源文件 这里是访问所有dist目录下的静态资源文件
app.use(express.static(path.resolve(__dirname, ‘../dist’)))
// 因为是单页应用 所有请求都走/dist/index.html
app.get(‘*’, function(req, res) {
const html = fs.readFileSync(path.resolve(__dirname, '../dist/index.html'), 'utf-8')
res.send(html)
// 监听8088端口
app.listen(8088);
这里的关键是express.static，利用 Express 托管静态文件。于是我们才能访问到前端打包出来的静态页面index.html。
最后，我们在浏览器输入http://localhost:8088/，就会跳到index.html。
到此为止，我们就完成了整个前后端各自开发到正式部署的流程。
优质网站模板多重背包问题：
有N种物品和容量为V的背包，若第i种物品，容量为v[i]，价值为w[i]，共有n[i]件。怎样装才能使背包内的物品总价值最大？
网上关于“多重背包”的资料倒是不少，但是关于怎么实现O(N*V)算法的资料，真得好少呀，关于“单调队列”那部分算法，又没说明得很清楚，看了几遍没看懂原理，只好自己动脑去想怎么实现O(N*V)算法。
若用F[i][j]表示对容量为j的背包，处理完前i种物品后，背包内物品可达到的最大总价值，并记m[i] = min(n[i], j / v[i])。放入背包的第i种物品的数目可以是：0、1、2……，可得：
F[i][j] = max { F[i - 1] [j – k * v[i] ] + k * w[i] }
(0 &= k &= m[i])
如何在O(1)时间内求出F[i][j]呢？
先看一个例子：取m[i] = 2, v[i] = v, w[i] = w, V & 9 * v，
并假设 f(j) = F[i - 1][j]，观察公式右边要求最大值的几项：
f(6*v)、f(5*v)+w、f(4*v)+2*w 这三个中的最大值
f(5*v)、f(4*v)+w、f(3*v)+2*w 这三个中的最大值
f(4*v)、f(3*v)+w、f(2*v)+2*w 这三个中的最大值
显然，公式㈠右边求最大值的几项随j值改变而改变，但如果将j = 6*v时，每项减去6*w，j=5*v时，每项减去5*w，j=4*v时，每项减去4*w，就得到：
f(6*v)-6*w、f(5*v)-5*w、f(4*v)-4*w 这三个中的最大值
f(5*v)-5*w、f(4*v)-4*w、f(3*v)-3*w 这三个中的最大值
f(4*v)-4*w、f(3*v)-3*w、f(2*v)-2*w 这三个中的最大值
很明显，要求最大值的那些项，有很多重复。
根据这个思路，可以对原来的公式进行如下调整：
假设d = v[i]，a = j / d，b = j % d，即 j = a * d + b，代入公式㈠，并用k替换a - k得：
F[i][j] = max { F[i - 1] [b + k * d] - k * w[i] } + a * w[i]
(a – m[i] &= k &= a)
对F[i - 1][y] （y= b
F[i][j]就是求j的前面m[i] + 1个数对应的F[i - 1] [b + k * d] - k * w[i]的最大值，加上a * w[i]，如果将F[i][j]前面所有的F[i - 1][b + k * d] – k * w放入到一个队列，那么，F[i][j]就是求这个队列最大长度为m[i]
+ 1时，队列中元素的最大值，加上a * w[i]。因而原问题可以转化为：O(1)时间内求一个队列的最大值。
该问题可以这样解决：
① 用另一个队列B记录指定队列的最大值（或者记录最大值的地址），并通过下面两个操作保证队列B的第一个元素（或其所指向的元素）一定是指定队列的当前最大值。
② 当指定队列有元素M进入时，删除队列B中的比M小的（或队列B中所指向的元素小等于M的）所有元素，并将元素M（或其地址）存入队列B。
③ 当指定队列有元素M离开时，队列B中的第一个元素若与M相等（或队列B第一个元素的地址与M相等），则队列B的第一个元素也离队。
经过上述处理，可以保证队列B中的第一个元素（或其指向的元素）一定是所指定队列所有元素的最大值。显然队列B的元素（或其所指向的元素）是单调递减的，这应该就是《背包九讲》中的提到的“单调队列”吧，初看的时候被这个概念弄得稀里糊涂，网上的资料提到“维护队列的最大值”，刚开始还以为是维护这个单调队列的最大值，对其采用的算法，越看越糊涂。其实，只要明白用一个“辅助队列”，求另一个队列的最值，那么具体的算法，和该“辅助队列”的性质（单调变化），都很容易推导出来。
在多重背包问题中，所有要进入队列的元素个数的上限值是已知的，可以直接用一个大数组模拟队列。
“多重背包”通用模板:
//“多重背包”通用模板
const int MAX_V = 100004;
//v、n、w：当前所处理的这类物品的体积、个数、价值
//V：背包体积， MAX_V：背包的体积上限值
//f[i]：体积为i的背包装前几种物品，能达到的价值上限。
inline void pack(int f[], int V, int v, int n, int w)
if (n == 0 || v == 0) return;
if (n == 1) {
for (int i = V; i &= --i)
if (f[i] & f[i - v] + w) f[i] = f[i - v] +
if (n * v &= V - v + 1) {
//完全背包(n &= V / v)
for (int i = i &= V; ++i)
if (f[i] & f[i - v] + w) f[i] = f[i - v] +
int va[MAX_V], vb[MAX_V];
//va/vb: 主/辅助队列
for (int j = 0; j & ++j) {
//多重背包
int *pb = va, *pe = va - 1;
//pb/pe分别指向队列首/末元素
int *qb = vb, *qe = vb - 1;
//qb/qe分别指向辅助队列首/末元素
for (int k = j, i = 0; k &= V; k += v, ++i) {
== pb + n) {
//若队列大小达到指定值，第一个元素X出队。
if (*pb == *qb) ++
//若辅助队列第一个元素等于X，该元素也出队。
int tt = f[k] - i *
//元素X进队
//删除辅助队列所有小于X的元素，qb到qe单调递减，也可以用二分法
while (qe &= qb && *qe & tt) --
//元素X也存放入辅助队列
f[k] = *qb + i *
//辅助队列首元素恒为指定队列所有元素的最大值
多重背包特例：物品价值和体积相等（w = v）
由于w = v，上面的代码可进行如下修改：
入队的元素： tt = f[k] - (k / v) * w = f[k] - (k - j) = f[k] - k + j
返回的最大值：*qb + (k / v) * w =
*qb + k - j
由于j是定值，可调整入队的元素为: f[k] - k，最大值为 *qb + k
但这种做法相当低效。实际上，这相当于一个“覆盖”问题：在放入前i个物品后，体积为j的背包，只存在两种状态：是否能刚好装满，也就是，是否能被覆盖。因而只要记录下该状态就可以了，前面的分析进行相应的调整：
对F[i - 1][y] （y= b
F[i][j]就是求j的前面m[i] + 1个数对应的F[i - 1] [b + k * d]（其值为0或1）的最大值，即j前面的m[i] + 1个0、1数据中是否存在1，这又可以简化为判断它们的和是否不等于0。
const int MAX_V = 100004;
//w = v 特例
inline void pack(bool f[], int V, int v, int n)
if (n == 0 || v == 0) return;
if (n == 1) {
for (int i = V; i - v &= 0; --i)
if (! f[i] && f[i - v]) f[i] = true;
//if (f[i - v]) f[i] =
if (n * v &= V - v + 1) {
//完全背包 n &= V / v
for (int i = i &= V; ++i)
if (! f[i] && f[i - v]) f[i] = true;
//if (f[i - v]) f[i] =
bool va[MAX_V];
for (int j = 0; j & ++j) {
//多重背包
bool *pb = va, *pe = va - 1;
size_t sum = 0;
for (int k = k &= V; k += v) {
if (pe == pb + n) sum -= *pb++;
//队列已满，队首元素出队
*++pe = f[k];
sum += f[k];
if (! f[k] && sum != 0) f[k] = true;
//f[k] = (bool)
另外，可以倒着读数据，这样就不需要额外使用一个数组存放临时数据：
//w = v 特例
inline void pack(bool f[], int V, int v, int n)
if (n == 0 || v == 0) return;
if (n == 1) {
for (int i = V; i - v &= 0; --i)
if (! f[i] && f[i - v]) f[i] = true;
//if (f[i - v]) f[i] =
if (n * v &= V - v + 1) {
//完全背包 n &= V / v
for (int i = i &= V; ++i)
if (! f[i] && f[i - v]) f[i] = true;
//if (f[i - v]) f[i] =
for (int j = 0; j & ++j) {
//多重背包
int k = V - j, sum = 0;
//前n + 1个元素入队，前面的判断可以保证： V - j - n * v & 0
for (; k &= std::max(0, V - j - n * v); k -= v) sum += f[k];
for (int i = V - i & 0; k -= v, i -= v) {
if (f[i]) --
//出队: sum -= f[i]
else if (sum != 0) f[i] = true;
//int tt = f[i]; f[i] = (bool) sum -=
if (k &= 0) sum += f[k];
前面的代码，都在循环中对队列的元素个数进行判断，这可以通过下面的方法避免，将循环拆分成两部分：一部分都有入队和出队操作、另一部分只有入队（或出队）操作。
对该特例，还有一种O(N * V)解法：用一个数组记录当前物品已经使用数，关键代码：
if (! f[i] && f[i - v] && count[i - v] & n)
f[i] = true, count[i] = count[i - v] + 1;
每计算一类物品，count数组都要初始化一次，比较费时，可以再用一个数组记录上一次处理的物品编号，通过判断上一次放入那一类的物品编号与当前这类物品编号是否一致（不一致时，相当于count[i]值为0的情况），从而避免对count数组的初始化操作。还可以将初始化count数组和后面的循环整合在一起。
for (int i = 0; i &= V; ++i)
count[i] = 0;
for (int i = i &= V; ++i) {
//多重背包
if (! f[i] && f[i - v] && count[i - v] & n) {
count[i] = count[i - v] + 1;
f[i] = true;
cur为当前这类物品的编号
for (int i = i &= V; ++i) {
//多重背包
if (! f[i] && f[i - v]) {
if (last[i - v] != cur)
count[i] = 1, last[i] = cur, f[i] = true;
else if (count[i - v] & n) {
count[i] = count[i - v] + 1;
f[i] = true;
for (int i = i &= V; ++i) {
//多重背包
if (f[i]) count[i] = 0;
else if (f[i - v]) {
if (i & 2 * v)
count[i] = 1, f[i] = true;
else if (count[i - v] & n) {
count[i] = count[i - v] + 1;
f[i] = true;
POJ 1742：有若干不同面值的纸币，问能组合出1到m中的几种面值？
#include&algorithm&
#include&cstdio&
#define AB 0
//MAX_N 物品种类数最大值 MAX_n每种物品数目的最大值，MAX_V背包体积最大值
const int MAX_N = 101, MAX_V = 100004;
//w = v特例
inline void pack(bool f[], int V, int v, int n, int& total)
//if (n == 0 || v == 0)
if (n == 1) {
for (int i = V; i - v &= 0; --i)
if (! f[i] && f[i - v]) f[i] = true, ++
if (n * v &= V - v + 1) {
//完全背包 n &= V / v
for (int i = i &= V; ++i)
if (! f[i] && f[i - v]) f[i] = true, ++
for (int j = 0; j & ++j) {
//多重背包
int k = V - j, sum = 0;
//前n + 1个元素入队，前面的判断可以保证： V - j - n * v & 0
for (; k &= V - j - n * k -= v) sum += f[k];
for (int i = V - i & 0; k -= v, i -= v) {
if (f[i]) --
//出队: sum -= f[i]
else if (sum != 0) f[i] = true, ++
//int tt = f[i]; f[i] = (bool) sum -=
if (k &= 0) sum += f[k];
struct Node {
int n, v, V;
bool operator&(const Node& other) const { return V & other.V;}
int main()
#if AB == 1
freopen("src.txt","r",stdin);
freopen("z-b.txt","w",stdout);
Node node[MAX_N];
bool f[MAX_V];
while (scanf("%d %d",&N,&V) != EOF) {
if (N + V == 0) break;
Node *np = node + N;
for (Node *p = p & ++p) scanf("%d", &p-&v);
for (Node *p = p & ++p) {
scanf("%d", &p-&n);
p-&V = std::min(p-&n * p-&v, V);
std::sort(node, np);
int total = 0;
f[0] = true;
for (int i = 1; i &= V; ++i) f[i] = false;
int mv = 0;
for (Node *p = p & np && total & V; ++p) {
mv = std::min(mv + p-&V, V);
pack(f,mv,p-&v,p-&n, total);
printf("%d/n",total);
用自己随机生成的数据测试了下，上面提到的几种方法，所用时间都是7秒多点，有排序的比没排序的稍微快点。但在POJ上提交的结果，不同代码的耗时相差挺大，快的在1秒左右，慢的接近1.5秒。
还有一种特例：
给定面值为1、2、5的纸币若干个，问其所不能支付的最低价格（假设为自然数）。
这可以用多重背包（或母函数）来解决，但实际上是有O(1)解法的。
中级篇——背包问题3（多重背包）
上一篇讲的完全背包是指在所有物品件数无限多的情况下选择最值，现在引申出多重背包问题，即各物品个数均有限且不一定相同，求轙类情况下的最值。...
多重背包中多次背包 O(VN) 算法1 (单调队列优化) 带参考程序
多次背包多次背包问题：给定 n 种物品和一个背包。第 i 种物品 的价值是 Wi ，其体积为 Vi，数量是 Ki件，背包的容量为 C。可以任意选择装入背包中的物品，求装入背包中物品的最大总价值。 方法...
01背包，完全背包，多重背包的个人总结
大一刚接触背包问题的时候就觉得绕。那时候真的是一点代码基础都没有强行去理解。每次都是以失败告终，一直到大二都还不会写背包问题。
后来某次模拟赛之后碰到了背包问题，觉得这个还是挺简单的，终于是下定决心准...
多重背包详解
本文包含的内容：
基本思路（和完全背包类似）
转换为01背包问题求解（直接利用01背包）
-----------------------------------...
背包问题详解：01背包、完全背包、多重背包
参考链接：
http://www.cnblogs.com/fengty90/p/3768845.html
http://blog.csdn.net/mu399/article/details/7722...
背包问题(0-1背包,完全背包,&em&多重背包&/em&知识概念&em&详解&/em&)内含实例代码解析,详细讲解了背包的基本概念及简单运用问题 综合评分:0 收藏评论举报 所需: 1积分/C币 开通...
有一个储蓄罐，告知其空时的重量和当前重量，并给定一些钱币的价值和相应重量求储蓄罐中最少有多少现金输入 第一行T 表示后面有T行测试用例第二行两个数字 空储蓄罐重量 当前储蓄罐重量第三行一个 整形N 其...
多重背包O(VN)算法——单调队列优化
多重背包问题：
有N种物品和容量为V的背包，若第i种物品容量为v[i],价值为w[i],总共有n[i]件，怎样装才能使背包内的物品总价值最大？
设dp[i][j]表示对容量为j的背包，处理完前i种...
没有更多推荐了，Node v0.12.2 (Stable) - 为程序员服务
Node v0.12.2 (Stable)
, Version 0.12.2 (Stable)
uv: Upgrade to 1.4.2
npm: Upgrade to 2.7.4
V8: Fix --max_old_space_size=4096 integer overflow (Andrei Sedoi)
asyncwrap: fix constructor condition for early ret (Trevor Norris)
buffer: align chunks on 8-byte boundary (Fedor Indutny)
buffer: fix pool offset adjustment (Trevor Norris)
console: allow Object.prototype fields as labels (Colin Ihrig)
fs: make F_OK/R_OK/W_OK/X_OK not writable (Jackson Tian)
fs: properly handle fd passed to truncate() (Bruno Jouhier)
http: fix assert on data/end after socket error (Fedor Indutny)
lib: fix max size check in Buffer constructor (Ben Noordhuis)
lib: fix stdio/ipc sync i/o regression (Ben Noordhuis)
module: replace NativeModule.require (Herbert Voj?ík)
net: allow port 0 in connect() (cjihrig)
net: unref timer in parent sockets (Fedor Indutny)
path: refactor for performance and consistency (Nathan Woltman)
smalloc: extend user API (Trevor Norris)
src: fix for SIGINT crash on FreeBSD (Fedor Indutny)
src: fix builtin modules failing with --use-strict (Julien Gilli)
watchdog: fix timeout for early polling return (Saúl Ibarra Corretgé)
Source Code:
Macintosh Installer (Universal):
Windows Installer:
Windows x64 Installer:
Windows x64 Files:
Linux 32-bit Binary:
Linux 64-bit Binary:
Solaris 32-bit Binary:
Solaris 64-bit Binary:
Other release files:
Documentation:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512
bfdba242dbef3c6b2567c3cffd06fa4dcdab93ba
node-v0.12.2-darwin-x64.tar.gz
f6d3abee7f30c7b53f53a8c53914b70
node-v0.12.2-darwin-x86.tar.gz
db9ebfe5b46f83de96ec67fe
node-v0.12.2-linux-x64.tar.gz
b1d9ecc2baaeafa8a6a64dfbc3a3
node-v0.12.2-linux-x86.tar.gz
node-v0.12.2-sunos-x64.tar.gz
f0df61d6def8adca6898dd95afba0d
node-v0.12.2-sunos-x86.tar.gz
bdc711c0c8e6a48ff54ad0d55bb13
node-v0.12.2-x86.msi
cddb7cae5c3b7488b3cd
node-v0.12.2.pkg
a969f17a0a6c6d96e8d39be8eb957
node-v0.12.2.tar.gz
afdcd542da1ee1850bdaa9365e44
be95280eeb97abc7e490c21f75c45eb
d6ba2bec16
ca2f0bc793d458beee
d877da4f9f05c56fd7de
openssl-cli.exe
de0ab27f9304852bee967bc8a378
openssl-cli.pdb
ade79f2d0d5cbfe
x64/node-v0.12.2-x64.msi
bb7ffbe0cfda654ca552
x64/node.exe
b94fd4aa06ac7ba476b9
x64/node.exp
5a806ff3b0db15a70eea
x64/node.lib
b509a605aea1ea28af8fb05ec42e
x64/node.pdb
f67c2dee109c16e4efd165a530a7f
x64/openssl-cli.exe
da80165e13ada3cae
x64/openssl-cli.pdb
-----BEGIN PGP SIGNATURE-----
Comment: GPGTools - https://gpgtools.org
iQIcBAEBCgAGBQJVGyv+AAoJEFCjBR+IjGKNJYsP/2nF/1489IXga69k2PkyDwaa
hFiWHpASH0hmcnoISDeMOwCLQIiqUsVx4a3ou5Dd844MNyPSDlzL4mvUYhAEklVZ
xZHvWqvqdkMkUFQY6Safz/ZN19667uVr0n5yzjkjtp1kONfUHA+PDIimFFXD0NQx
oUssDP2qnfr8IoCWGp8oY0BaHiw3VN1F1P5KWt3G3nkIcNeeoSp1MYl5OX5zxSo5
mj9Y2i9qaIE3NAkkX5GJxNytbj82VJjlREbevtvLk/5F1whOuE/Ipq
Qa2xmQlKtC1FrH3EV4v0TVyZzJyy8PZDmLQZIxkQJHdJc511zf1MZ1j0lBUBbf+c
xCYyg1IVpntOF9KAzXpV9k3Ffv9vdGbWMkGUaUfAsSmU6Pu86l96cYKtRTUT7zGv
Bw+wWsvmIOnT1EIRvzK+lCDrTfNEhDEyhItGWiWS8UobEtvuXoCEriI32LYPPa6o
CC8q18VzKonn5t0ixjkrx4JN/Vtx4f5nDNRbi3397uiUilVLc6c0MYwO7lgpv8Xw
Ztj4z+epqoyqKTbRUHH8euuQkW0G25Of0a/By1AGPWVxxmYv1XM/2qdkWJcZnijO
pDu3K4GheyMSvFlqzt9uEZYAXVKAEiHG3Z2MyEQVLvjHN0ug7w+X87YU0DBJlRi
iAY7/T05CiLJ1+f4Czn
-----END PGP SIGNATURE-----
The Blog about Node.js
原文地址：, 感谢原作者分享。
您可能感兴趣的代码