本文章建议有一定Nodejs开发经验和熟悉ES6/7的开发人员查看，文中若有错误望指出！

$ npm i egg-init -g

$ egg-init egg-crm --type=simple

$ cd egg-crm

$ npm i

npm run dev

[mongodb-org-4.0]

name=MongoDB Repository

baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.0/x86_64/

gpgcheck=1

enabled=1

gpgkey=https://www.mongodb.org/static/pgp/server-4.0.asc

sudo yum install -y mongodb-org-4.0.6 mongodb-org-server-4.0.6 mongodb-org-shell-4.0.6 mongodb-org-mongos-4.0.6 mongodb-org-tools-4.0.6

service mongod start

  "devDependencies": {

    "autod": "^3.0.1",

    "autod-egg": "^1.1.0",

    "baidu-aip-sdk": "^2.3.9",

    "bce-sdk-js": "^0.2.9",

    "decimal": "^0.0.2",

    "egg-bin": "^4.11.0",

    "egg-ci": "^1.11.0",

    "egg-cors": "^2.1.2",

    "egg-jwt": "^3.1.6",

    "egg-mock": "^3.21.0",

    "egg-mongoose": "^3.1.1",

    "egg-validate": "^2.0.2",

    "eslint": "^5.13.0",

    "eslint-config-egg": "^7.1.0",

    "lodash": "^4.17.11",

    "stream-to-array": "^2.3.0",

    "webstorm-disable-index": "^1.2.0",

    "xml2js": "^0.4.19"

  },

'use strict';



module.exports = appInfo => {

    const config = exports = {};



    // use for cookie sign key, should change to your own and keep security

    config.keys = appInfo.name + '_1539582326426_4353';



    // csrf配置

    config.security = {

        csrf: {

            enable: false,

            ignoreJSON: true

        },

        domainWhiteList: ['http://localhost:7001', 'http://192.168.0.123', 'http://localhost]

    };

    // 

    config.cors = {

        allowMethods: 'GET,HEAD,PUT,POST,DELETE,PATCH,OPTIONS',

        credentials: true

    };

    // // add your config here

    // config.middleware = ;

    config.middleware = ['errorHandler', 'responseFormatter', 'jwtErrorHandler'];

    config.middleware.errorHandler = {

        match: '/api',

    };

    config.middleware.responseFormatter = {

        match: '/api',

    };

    //短信配置

    config.sms = {

        svip: {

            uri: ‘',

            name: '',

            password: '',

        },

    };

    // 邮箱配置

    config.email = {

            service: 'QQex',

            port: 465,

            secureConnection: true,

            auth: {

                user: '',

                pass: '',

            }

        }

        // mongodb配置

    config.mongoose = {

        url: 'mongodb://127.0.0.1/geecrm',

        options: {},

    };

    // bos云存储

    /*****************begin********************/

    config.baiduBos = {

        endpoint: 'http://bj.bcebos.com',

        credentials: {

            ak: '',

            sk: ''

        }

    };

    config.baiduBosBucket = '';

    /*****************end***********************/

    // baidu AIP

    config.baiduAIP = {

        APP_ID: '',

        API_KEY: '',

        SECRET_KEY: ''

    };

    // baidu VOD

    config.baiduVod = {

        endpoint: 'http://vod.bj.baidubce.com',

        credentials: {

            ak: '',

            sk: ''

        }

    };

    // 企业微信配置

    config.weWork = {

        'corpid': '',

        'corpsecret': '',

        'agentId': ''

    };

    // 微信配置

    config.wechatApi = {

        appId: '',

        appSecret: '',

    };

    // 默认json 设置

    config.JSONS = {

        'code': 200,

        'message': 'success',

        'uri': 'https://api.lanjing.xyz',

    };

    config.alipay = {

        appId: "",

        rsaPrivate: "",

        notifyUrl: "", //异步回调

        signType: "RSA2",

        rsaPublic: "",

        sandbox: false //沙箱环境

    }



    config.wechatPay = {

            partnerKey: "",

            appId: "",

            mchId: "",

            notifyUrl: "http://www.langjing.xyz/wechat/notify", //异步回调，到微信平台设置下

            pfx: ""

        }

        // 

    return config;

};

'use strict';

exports.validate = {

    enable: true,

    package: 'egg-validate',

};

exports.mongoose = {

    enable: true,

    package: 'egg-mongoose',

};

exports.jwt = {

    enable: true,

    package: "egg-jwt"

};

exports.cors = {

    enable: true,

    package: "egg-cors"

};

ssh-keygen -t rsa -C example@mail.com

        const zd = [...document.querySelectorAll('font b')].map(e => e.nextSibling.nextSibling).filter(e => e != null).map(e => {

            const OBJ = {};

            OBJ[e.previousSibling.previousSibling.innerText] = ([...e.data.trim().replace(/\([^\)]*\)/g, "")].reduce((a, b) => a += '\\u' + b.charCodeAt(0).toString(16), ''));

            return OBJ

        });

curl --silent --location https://rpm.nodesource.com/setup_8.x | sudo bash -

sudo yum -y install nodejs

npm config set registry https://registry.npm.taobao.org

arr.reduce(callback[, initialValue])

• accumulator
• currentValue
• currentIndex
• array

[...'abcdaabdcfggtre'].reduce((a,b)=>{a[b]?a[b]++:a[b]=1;return a},{})

const anagrams = str => {

 if (str.length <= 2) {

  return str.length === 2 ? [str, str[1] + str[0]] : str;

 }

 return str.split("").reduce((acc, letter, i) => {

  return acc.concat(anagrams(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val));

 }, );

}

 

anagrams("abc"); 

const sum = arr => arr.reduce((acc, val) => acc + val, 0);

sum([1, 2, 3]);

const countOccurrences = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);

countOccurrences([1, 2, 3, 2, 2, 5, 1], 1);

const curry = (fn, arity = fn.length, ...args) => 

  arity <= args.length ? fn(...args) : curry.bind(null, fn, arity, ...args);



curry(Math.pow)(2)(10);

curry(Math.min, 3)(10)(50)(2);

通过判断函数的参数取得当前函数的length(当然也可以自己指定)，如果所传的参数比当前参数少，则继续递归下面，同时储存上一次传递的参数。

const deepFlatten = arr =>

 arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), );

deepFlatten([1, [2, [3, 4, [5, 6]]]]);

const fibonacci = n => Array(n).fill(0).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), );

fibonacci(5);

const pipe = (...funcs) => arg => funcs.reduce((acc, func) => func(acc), arg);

pipe(btoa, x => x.toUpperCase())("Test");

通过对传递的参数进行函数加工，之后将加工之后的数据作为下一个函数的参数，这样层层传递下去。

const dispatch = action => {

    console.log('action', action);

    return action;

}



const middleware1 = dispatch => {

    return action => {

        console.log("middleware1");

        const result = dispatch(action);

        console.log("after middleware1");

        return result;

    }

}



const middleware2 = dispatch => {

    return action => {

        console.log("middleware2");

        const result = dispatch(action);

        console.log("after middleware2");

        return result;

    }

}



const middleware3 = dispatch => {

    return action => {

        console.log("middleware3");

        const result = dispatch(action);

        console.log("after middleware3");

        return result;

    }

}



const compose = middlewares => middlewares.reduce((a, b) => args => a(b(args)))



const middlewares = [middleware1, middleware2, middleware3];

const afterDispatch = compose(middlewares)(dispatch);



const testAction = arg => {

    return { type: "TEST_ACTION", params: arg };

};

afterDispatch(testAction("1111"));

const reducers = {

    totalInEuros: (state, item) => {

        return state.euros += item.price * 0.897424392;

    },

    totalInYen: (state, item) => {

        return state.yens += item.price * 113.852;

    }

};



const manageReducers = reducers => {

    return (state, item) => {

        return Object.keys(reducers).reduce((nextState, key) => {

            reducers[key](state, item);

            return state;

        }, {})

    }

}



const bigTotalPriceReducer = manageReducers(reducers);

const initialState = { euros: 0, yens: 0 };

const items = [{ price: 10 }, { price: 120 }, { price: 1000 }];

const totals = items.reduce(bigTotalPriceReducer, initialState);

const get = (p, o) => p.reduce((xs, x) => (xs && xs[x] ? xs[x] : null), o);

const groupBy = (arr, func) =>

arr.map(typeof func === 'function' ? func : val => val[func]).reduce((acc, val, i) => {

    acc[val] = (acc[val] || ).concat(arr);

    return acc;

}, {});

groupBy([6.1, 4.2, 6.3], Math.floor); 

groupBy(['one', 'two', 'three'], 'length'); 

const pick = (obj, arr) =>

    arr.reduce((acc, curr) => (curr in obj && (acc[curr] = obj[curr]), acc), {});



pick({ a: 1, b: '2', c: 3 }, ['a', 'c']);

const runPromisesInSeries = ps => ps.reduce((p, next) => p.then(next), Promise.resolve());



const delay = d => new Promise(r => setTimeout(r, d));

const print = args => new Promise(r => r(args));

runPromisesInSeries([() => delay(1000), () => delay(2000), () => print('hello')])

const orderBy = (arr, props, orders) =>

    [...arr].sort((a, b) =>

        props.reduce((acc, prop, i) => {

            if (acc === 0) {

                const [p1, p2] = orders && orders === 'desc' ? [b[prop], a[prop]] : [a[prop], b[prop]];

                acc = p1 > p2 ? 1 : p1 < p2 ? -1 : 0;

            }

            return acc;

        }, 0)

    );



const users = [{ name: 'fred', age: 48 }, { name: 'barney', age: 36 }, { name: 'fly', age: 26 }];

orderBy(users, ['name', 'age'], ['asc', 'desc']); 

orderBy(users, ['name', 'age']);

const select = (from, selector) =>

    selector.split('.').reduce((prev, cur) => prev && prev[cur], from);



const obj = { selector: { to: { val: 'val to select' } } };

select(obj, 'selector.to.val');

菜单或者分类等业务场景时，每个顶级节点的parentId约定为0，当存在多个顶级节点，显得不是一个完整的树。所以在这类特殊情况下，我们需要构造一个顶级节点。将菜单或者分类的原有顶级节点存储至该节点的children中。 所以最后约定顶级节点如下。

root = null || {

  id: 0,

  parentId: null,

  children: [node1, node2, ...],  

}

function listConvertTree(list) {

  let root = null;

  if (list && list.length) {

    root = { id: 0, parentId: null, children:};

    const group = {};

    for (let index = 0; index < list.length; index += 1) {

      if (list[index].parentId !== null && list[index].parentId !== undefined) {

        if (!group[list[index].parentId]) {

          group[list[index].parentId] = ;

        }

        group[list[index].parentId].push(list[index]);

      }

    }

    const queue = ;

    queue.push(root);

    while (queue.length) {

      const node = queue.shift();

      node.children = group[node.id] && group[node.id].length ? group[node.id] : null;

      if (node.children) {

        queue.push(...node.children);

      }

    }

  }

  return root;

}

function treeConvertList(root) {

const list = ;

if (root) {

const Root = JSON.parse(JSON.stringify(root));

const queue = ;

queue.push(Root);

while (queue.length) {

const node = queue.shift();

if (node.children && node.children.length) {

queue.push(...node.children);

}

delete node.children;

if (node.parentId !== null && node.parentId !== undefined) {

list.push(node);

}

}

}

return list;

}

原文作者无从考究了，侵删！
受益匪浅，整理分享出来，希望对大家有所启示

var str = "www.baidu.com/?page";

str = str.replace('?page', "");

console.log(str);

str = str.substring(0, str.indexOf("/"));

console.log(str);

var str = "";

var week = new Date().getDay();

if (week === 0) {

    str = "今天是星期日";

} else if (week === 1) {

    str = "今天是星期一";

} else if (week === 2) {

    str = "今天是星期二";

} else if (week === 3) {

    str = "今天是星期三";

} else if (week === 4) {

    str = "今天是星期四";

} else if (week === 5) {

    str = "今天是星期五";

} else if (week === 6) {

    str = "今天是星期六";

}



// 或者更好一些

var str1 = "今天是星期";

var week1 = new Date().getDay();

switch (week1) {

    case 0 :

        str1 += "日";

        break;

    case 1 :

        str1 += "一";

        break;

    case 2 :

        str1 += "二";

        break;

    case 3 :

        str1 += "三";

        break;

    case 4 :

        str1 += "四";

        break;

    case 5 :

        str1 += "五";

        break;

    case 6 :

        str1 += "六";

        break;

}



console.log(str);

console.log(str1);

var str = "www.baidu.com/?page";

str = str.replace(/?page/, "");

console.log(str);

var a = ["日", "一", "二", "三", "四", "五", "六"];

var week = new Date().getDay();

var str = "今天是星期" + a[week];

console.log(str)

var str = "www.baidu.com/?page";

// 1、字符串剪裁

str.substring(0, str.indexOf("?page"));

// 2、正则表达式

str.replace(/?page/, "");

// 3、字符串分拆、合并

str.split("?page").join("");

var str = "今天是星期" + "日一二三四五六".charAt(new Date().getDay());

• 切勿以为自己能写一手漂亮的代码而自满；
• 切莫以为别人“尊称”你一声“大侠”你就以 “大侠”自居；
• 切莫以为自己积累了一些得意的代码就成了框架式开发。

• 代码性能的差异、运行平台（浏览器）的差异、需求的隐性扩展、代码的向后兼容等等。
• 再通读几遍HTML/CSS/JavaScript帮助文档。

var str = "http://www.xxx.com/?pn=0"; // 删除指定字符 pn=0

var a = [

    "http://www.xxx.com/VMpn=?pn=0", // pn= 可能出现在 ? 前

    "http://www.xxx.com/VMpn=?pn=", // URL里允许pn 值为空

    "http://www.xxx.com/VMpn=?pn=0&a=1", // URL 里可有多个字段

    "http://www.xxx.com/VMpn=?a=1&pn=0", // 可能排在最后

    "http://www.xxx.com/VMpn%3D%3Fa ... ot%3B, // 可能有多个 pn 字段

    "http://www.xxx.com/VMpn%3D%3Fa ... ot%3B, // 可能在中间

    "http://www.xxx.com/VMpn%3D%3Fa ... ot%3B, // 可能在中间成组

    "http://www.xxx.com/VMpn%3D%3Fa ... ot%3B // 可能零星分布

];

var reg = /((?)(pn=[^&]*&)+(?!pn=))|(((?|&)pn=[^&]*)+$)|(&pn=[^&]*)/g;

for (var i = 0; i < a.length; i++) {

    console.log(a[i] + "n" + a[i].replace(reg, "$2"));

}

function escapeReg(str) {

    return str.replace(new RegExp("([.*+?^=!:x24{}()|[\]/\\])", "g"), "\x241");

}



function delUrlQuery(url, key) {

    key = escapeReg(key);

    var reg = new RegExp("((\?)(" + key + "=[^&]*&)+(?!" + key + "=))|(((\?|&)" + key + "=[^&]*)+$)|(&" + key + "=[^&]*)", "g");

    return url.replace(reg, "x241")

}



// 应用实例

var str = "http://www.xxx.com/?pn=0"; // 删除指定字符 pn=0

delUrlQuery(str, "pn");

1. 不再是就事论事，头疼医头，而是把一类问题抽象理论化，一招破万招；
2. 有封装的概念，不再是每次从零开始，而是站在半山腰开始爬。

1. 选择一门强语言（C++/C#/Java等）观察理解这些语 言的组织结构，语言设计；
2. 看看原型链，链式语法编程，泛型，接口编程，DOM遥控器等等；
3. 仔细阅读成熟的WEB前端开发框架的设计文档，看他们为什么要这样设计。

// 库文件 /mz/string/escapeReg.js

mz.string.escapeReg = function (str) {

    return str.replace(new RegExp("([.*+?^=!:x24{}()|[\]/\\])", "g"), "\x241");

};



// 库文件 /mz/url/delQuery.js

/// include mz.string.escapeReg;

mz.url.delQuery = function (url, key) {

    key = mz.string.escapeReg(key);

    var reg = new RegExp("((\?)(" + key + "=[^&]*&)+(?!" + key + "=))|(((\?|&)" + key + "=[^&]*)+$)|(&" + key + "=[^&]*)", "g");

    return url.replace(reg, "x241");

};

// 应用实例 

/// include mz.url.delQuery;

var str = "http://www.xxx.com/?pn=0"; // 删除指定字符 pn=0

mz.url.delQuery(str, "pn");

// 库文件 /mz/url/delQuery.js 

/// include mz.string.escapeReg;

String.prototype.delQuery = function (key) {

    key = mz.string.escapeReg(key);

    var reg = new RegExp("((\?)(" + key + "=[^&]*&)+(?!" + key + "=))|(((\?|&)" + key + "=[^&]*)+$)|(&" + key + "=[^&]*)", "g");

    return this.replace(reg, "x241");

};



// 应用实例

/// include mz.url.delQuery;

var str = "http://www.xxx.com/?pn=0"; // 删除指定字符 pn=0

str.delQuery("pn");

 

db.users.find() 

select * from users  



db.users.find({"age" : 27}) 

select * from users where age = 27  



db.users.find({"username" : "joe", "age" : 27}) 

select * from users where "username" = "joe" and age = 27 



db.users.find({}, {"username" : 1, "email" : 1}) 

select username, email from users



db.users.find({}, {"username" : 1, "_id" : 0}) // no case  

// 即时加上了列筛选，_id也会返回；必须显式的阻止_id返回 



db.users.find({"age" : {"$gte" : 18, "$lte" : 30}}) 

select * from users where age >=18 and age <= 30 

// $lt(<) $lte(<=) $gt(>) $gte(>=) 



db.users.find({"username" : {"$ne" : "joe"}}) 

select * from users where username <> "joe"  



db.users.find({"ticket_no" : {"$in" : [725, 542, 390]}}) 

select * from users where ticket_no in (725, 542, 390)



db.users.find({"ticket_no" : {"$nin" : [725, 542, 390]}}) 

select * from users where ticket_no not in (725, 542, 390)



db.users.find({"$or" : [{"ticket_no" : 725}, {"winner" : true}]}) 

select * form users where ticket_no = 725 or winner = true  



db.users.find({"id_num" : {"$mod" : [5, 1]}})

select * from users where (id_num mod 5) = 1  



db.users.find({"$not": {"age" : 27}})

select * from users where not (age = 27)  



db.users.find({"username" : {"$in" : [null], "$exists" : true}}) 

select * from users where username is null 

// 如果直接通过find({"username" : null})进行查询，那么连带"没有username"的纪录一并筛选出来  



db.users.find({"name" : /joey?/i}) 

// 正则查询，value是符合PCRE的表达式  



db.food.find({fruit : {$all : ["apple", "banana"]}}) 

// 对数组的查询, 字段fruit中，既包含"apple",又包含"banana"的纪录  



db.food.find({"fruit.2" : "peach"}) 

// 对数组的查询, 字段fruit中，第3个(从0开始)元素是peach的纪录  



db.food.find({"fruit" : {"$size" : 3}}) 

// 对数组的查询, 查询数组元素个数是3的记录，$size前面无法和其他的操作符复合使用  



db.users.findOne(criteria, {"comments" : {"$slice" : 10}}) 

// 对数组的查询，只返回数组comments中的前十条，还可以{"$slice" : -10}， {"$slice" : [23, 10]}; 分别返回最后10条，和中间10条  



db.people.find({"name.first" : "Joe", "name.last" : "Schmoe"})  

// 嵌套查询  



db.blog.find({"comments" : {"$elemMatch" : {"author" : "joe", "score" : {"$gte" : 5}}}}) 

// 嵌套查询，仅当嵌套的元素是数组时使用,  



db.foo.find({"$where" : "this.x + this.y == 10"}) 

// 复杂的查询，$where当然是非常方便的，但效率低下。对于复杂查询，考虑的顺序应当是 正则 -> MapReduce -> $where  



db.foo.find({"$where" : "function() { return this.x + this.y == 10; }"}) 

// $where可以支持javascript函数作为查询条件  



db.foo.find().sort({"x" : 1}).limit(1).skip(10); 

// 返回第(10, 11]条，按"x"进行排序; 三个limit的顺序是任意的，应该尽量避免skip中使用large-number  

函数 一等公民 ，越简单的函数越快，把一个复杂的函数打散成多个简单的小函数来执行，能增加执行的速度喝效率,和复用性?。在很多的js大牛的博客上肯定能找到许多的关于这个几把万一二的一些文章喝装13套路的文章，大多数都是互相的复制粘贴之流。简单的说柯里化就是把一个多参函数转换成嵌套的一元函数（毕竟一元最牛逼，因为脸都是绿的）。扯到柯里化 肯定就要继续再扯其他的反柯里化 偏函数 之类的 ，那个以后又空了再装逼。
?

const add=>(x,y)=>x+y; //一般套路

add(1,2);

const addcurry = a=>b=>a+b;//curry套路套路套路

addcurry(1)(2);

// 写下面的代码方便大家理解

var addcurry = function(a){

    return function(b){

        return b+a

    }

}

const client = new AipNlp(...aipconf);

// 

const AIPFC = (res) => async(aipfn) => {

    const DATA = Object.assign({}, BACKJSON);

    let result;

    try {

        result = await aipfn;

    } catch (error) {

        result = error

    }

    res.json(Object.assign(DATA, { data: result })).end();

};



exports.lexer = (req, res) => {

    let aipfc = AIPFC(res);

    aipfc(client.lexer(req.body.texts));

}

const fn = (x) => x

const fn = (x,y) = > x+y

const fn =(a,...b)=>b.reduce((x,y)=>x+y,a)

const add = (a,b)=>a+b;

const curry = (fn)=>(fir)=>(sec)=>fn(fir,sec);

写了那么多东西，你肯定要说，这有屁用啊，屁用都没有，我什么要拆开他，老子的用户都是16核，16G的高端电脑，好好，说个吉娃娃，下面继续李子发起走，我们慢慢的玩上去，来波澳门赌场，澳门皇家赌场开业了。。。。扑哧

const list2 = y=>2*y;

const list3 = y=>3*y;

const list4 = y=>4*y

const clist = (a,b)=>a*b;

//

clist(2,2)

clist(2,3)

clist(2,4)

//

const list2 =curry(clist)(2);

const list3 =curry(clist)(3);

const list4 =curry(clist)(4);



console.log(list2(2));

console.log(list2(3));

console.log(list2(4));

console.log(list3(2));

console.log(list3(3));

console.log(list3(4));

console.log(list4(2));

console.log(list4(3));

console.log(list4(4));