NodeJs开发（三）

let arr = [];
while(true) {
	arr.push\(1\);
}

let arr = []
while(true) {
	arr.push\(\)
}

let arr = [];
while(true) {
	arr.push(new Buffer(1000));
}

//单例：　任意对象都是单例，无须特别处理
var obj = {name: 'michaelqin', age: 30};

//工厂: 就是同样形式参数返回不同的实例
function Person() { this.name = 'Person1'; }
	function Animal() { this.name = 'Animal1'; }

	function Factory() {}
	Factory.prototype.getInstance = function(className) {
		return eval('new ' + className + '()');
	}

	var factory = new Factory();
	var obj1 = factory.getInstance('Person');
	var obj2 = factory.getInstance('Animal');
	console.log(obj1.name); // Person1
	console.log(obj2.name); // Animal1

//代理: 就是新建个类调用老类的接口,包一下
	function Person() { }
	Person.prototype.sayName = function() { console.log('michaelqin'); }
	Person.prototype.sayAge = function() { console.log(30); }

	function PersonProxy() {
		this.person = new Person();
		var that = this;
		this.callMethod = function(functionName) {
			console.log('before proxy:', functionName);
			that.person[functionName](); // 代理
			console.log('after proxy:', functionName);
		}
	}

	var pp = new PersonProxy();
	pp.callMethod('sayName'); // 代理调用Person的方法sayName()
	pp.callMethod('sayAge'); // 代理调用Person的方法sayAge()

4) 观察者: 就是事件模式，比如按钮的onclick这样的应用.
	function Publisher() {
		this.listeners = [];
	}
	Publisher.prototype = {
		'addListener': function(listener) {
			this.listeners.push(listener);
		},

		'removeListener': function(listener) {
			delete this.listeners[this.listeners.indexOf(listener)];
		},

		'notify': function(obj) {
			for(var i = 0; i < this.listeners.length; i++) {
				var listener = this.listeners[i];
				if (typeof listener !== 'undefined') {
					listener.process(obj);
				}
			}
		}
	}; // 发布者

	function Subscriber() {

	}
	Subscriber.prototype = {
		'process': function(obj) {
			console.log(obj);
		}
	};　// 订阅者


	var publisher = new Publisher();
	publisher.addListener(new Subscriber());
	publisher.addListener(new Subscriber());
	publisher.notify({name: 'michaelqin', ageo: 30}); // 发布一个对象到所有订阅者
  publisher.notify('2 subscribers will both perform process'); // 发布一个字符串到所有订阅者

npm i express@next

const express= require('express')
const app = express()

app.listen(3000,()=>{
   console.log('')
})

const express = require('express')
const router = express.Router()

router.get('/add',(req,res)=>{
res.send('user add')
}) 

router.get('/del',(req,res)=>{
res.send('del add')
})

module.exports = router

app.get

npm i cors

var app = express();

app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});
app.get('/user/:id', function (req, res, next) {
  res.end(req.params.id);
});

//引入router
var router= express.Router();
//全局路由中间件
router.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});
//具体http方法
router.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next router
  if (req.params.id == 0) next('route');
  // otherwise pass control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});
//加载中间件
app.use('/', router);

app.use(function(err,req,res,next){
    console.log(err.stack);
    res.status(500).send('somethingbroke');
})

npm install cookie-parser

var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');

//加载中间件
app.use(cookieParser)

npm install socket.io --save

let io = require("socket.io")(http);

io.on("connection",function(socket){
  console.log("连接成功")
  socket.emit("new message",{mess:"初识消息"})
})

npm install pug --save

app.set('view engine', 'pug');

html
  head
    title= title
  body
    h1= message

app.get('/', function (req, res) {
  res.render('index', { title: 'Hey', message: 'Hello there!'});
});

npm install cors

const cors = require('cors')

app.use(cors())

$ npm install --save multer

const express = require('express')
const multer  = require('multer')
const upload = multer({ dest: 'uploads/' })

const app = express()

app.post('/profile', upload.single('avatar'), function (req, res, next) {
  // req.file is the `avatar` file
  // req.body will hold the text fields, if there were any
})

app.post('/photos/upload', upload.array('photos', 12), function (req, res, next) {
  // req.files is array of `photos` files
  // req.body will contain the text fields, if there were any
})

const cpUpload = upload.fields([{ name: 'avatar', maxCount: 1 }, { name: 'gallery', maxCount: 8 }])
app.post('/cool-profile', cpUpload, function (req, res, next) {
  // req.files is an object (String -> Array) where fieldname is the key, and the value is array of files
  //
  // e.g.
  //  req.files['avatar'][0] -> File
  //  req.files['gallery'] -> Array
  //
  // req.body will contain the text fields, if there were any
})

{
   "user1" : {
      "name" : "mahesh",
      "password" : "password1",
      "profession" : "teacher",
      "id": 1
   },
   "user2" : {
      "name" : "suresh",
      "password" : "password2",
      "profession" : "librarian",
      "id": 2
   },
   "user3" : {
      "name" : "ramesh",
      "password" : "password3",
      "profession" : "clerk",
      "id": 3
   }
}

var express = require('express');
var app = express();
var fs = require("fs");

//获取用户列表
app.get('/listUsers', function (req, res) {
   fs.readFile( __dirname + "/" + "user.json", 'utf8', function (err, data) {
       console.log( data );
       res.end( data );
   });
})

 //添加用户
 //添加的新用户数据
 var user = {
    "user4" : {
       "name" : "mohit",
       "password" : "password4",
       "profession" : "teacher",
       "id": 4
    }
 }

 app.get('/addUser', function (req, res) {
    // 读取已存在的数据
    fs.readFile( __dirname + "/" + "user.json", 'utf8', function (err, data) {
        data = JSON.parse( data );
        data["user4"] = user["user4"];
        console.log( data );
        res.end( JSON.stringify(data));
    });
 })

 //删除用户
 var id = 3;

 app.get('/deleteUser', function (req, res) {
 
    // First read existing users.
    fs.readFile( __dirname + "/" + "user.json", 'utf8', function (err, data) {
        data = JSON.parse( data );
        delete data["user" + id];
        
        console.log( data );
        res.end( JSON.stringify(data));
    });
 })

app.get('/:id', function (req, res) {
    // 首先我们读取已存在的用户
    fs.readFile( __dirname + "/" + "user.json", 'utf8', function (err, data) {
        data = JSON.parse( data );
        var user = data["user" + req.params.id] 
        console.log( user );
        res.end( JSON.stringify(user));
    });
 })


var server = app.listen(8081, function () {

  var host = server.address().address
  var port = server.address().port

  console.log("应用实例，访问地址为 http://%s:%s", host, port)

})

npm install mysql

var mysql = require('mysql')
var connection = mysql.createConnection({
  host:'localhost',
  user:'root',
  password:'',
  database:'my_db'
})

connection.connect();

npm i mongoose

const mongoose = require('mongoose');
mongoose.connect(
  'mongodb://localhost:27017/test', 
  {
    useNewUrlParser: true, 
    useUnifiedTopology: true
  }
);

var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  // we're connected!
});

  //将scheme对象实例化并创建
  var user = mongoose.Schema;
  //创建对象
  var userschema = new user({
  name:
  age:
  length:
})
转化为数据模型
  var blog = mongoose.model('Blog', blogSchema);

blog.insertMany()
blog.remove()
blog.update()
blog.find({ name: 'john', age: { $gte: 18 }});

npm install redis

var redis = require('redis')

var client = redis.createClient(6379,'127.0.0.1')
client.on('error',function(err){
    console.log('Error'+error)
})；

client.set('color','red',redis.print)
client.get('color',function(err,value){
    if(err)throw err;
    console.log('Got:'+value)
    client.quit();
})

//对键（key）的操作
del('key') //删除key
exists('key') //查询key
expire/pexpire('key',seconds/milliseconds) //设置key的过期秒数/毫秒数
persist('key')//移除key的过期时间
flushdb//清空当前数据库

//对键值对的操作
set('key','value')//设置键的值
get('key')//获取键对应的值
del('key')//删除键对应的值
增加键对应的值
incrby('key',increment)
减去键对应的值
der('key',increment)

//对列表（队列）的操作
lrange('key',0,-1)//获取列表内指定范围的值
lindex('key',1)//获取列表在指定位置的值
lpop('key')//在列表左边弹出一个值，并返回
rpop('key')//在列表右边弹出一个值，并返回
rpush('key','value')//在列表右边推入指定值
rtrim('key','start','end')//将列表的内容在指定范围裁剪

//对有序集合(zset)的操作
zadd('zset-key',score,key)//添加元素到集合
zrange  //获取集合中指定位置的元素
zrangebyscore  //获取集合中指定范围的元素
zcard('key')  //获取一个有序集合中成员数量
zrem //移除有序集合中的成员

//对集合的操作
smembers('key')//返回集合中包含的所有元素
scad('key')//返回集合中元素的数量
sismenber('key','value')//检查元素是否存在于集合中
smove('source-key','dest-key','item')//一个集合迁移到另一个集合
srem('key','value')//移除集合中指定元素
spop('key')//随机删除集合元素，并返回值
sdiff('key','key2')//返回存在于第一个集合，但不存在于其他集合的元素（差集）
sdiffstore('dest-key','key','key2')//将存在于第一个集合，但不存在于其他集合的元素存储到指定键
sinter('key','key2')//返回不同集合的交集部分
sinterstore('dest-key','key','key2')//将不同集合的交集部分存储到指定键
sunion('key','key2')//返回不同集合的并集
sunionstore('dest-key','key','key2')////将不同集合的并集存储到指定键

//对哈希散列的操作

npm install remult

import express from 'express';
import { remultExpress } from 'remult/remult-express';

const app = express();

app.use(remultExpress({ entities: [/* entity types */] }));

app.listen(3000);

import fastify from 'fastify';
import { remultFastify } from 'remult/remult-fastify';

(async () => {
    const server = fastify();

    await server.register(remultFastify({ entities: [/* entity types */] }));

    server.listen({ port: 3000 });
})();

import * as koa from 'koa';
import * as bodyParser from 'koa-bodyparser';
import { createRemultServer } from 'remult/server';

const app = new koa();

app.use(bodyParser());

const api = createRemultServer({ entities: [/* entity types */] });

app.use(async (ctx, next) => {
    const r = await api.handle(ctx.request);
    if (r) {
        ctx.response.body = r.data;
        ctx.response.status = r.statusCode;
    } else
        return await next();
});

app.listen(3000, () => { });

import axios from 'axios';
import { remult } from 'remult';

remult.apiClient.httpClient = axios;