聚合(aggregate)主要用于计算数据，类似sql中的sum(),avg()。

db.集合名称.aggregate({管道:{表达式}})

• $group：将集合中的文档分组，可用于统计结果
• $match：过滤数据，只输出符合条件的文档
• $project：修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
• $sort：将输入文档排序后输出
• $limit：限制聚合管道返回的文档数
• $skip：跳过指定数量的文档，并返回余下的文档
• $unwind：将数组类型的字段进行拆分

 const compAccountDealrecordSchema = new Schema({

        // billing 订单标识

        numer: {

            type: String

        },

        // 公司名称

        _comp: {

            type: Schema.Types.ObjectId,

            ref: 'Company',

            required: true,

            index: true

        },

        // 消费金额

        amount: {

            type: Number,

            default: 0.00

        },

        // 账户余额

        balance: {

            type: Number,

            default: 0.00

        },

        // 渠道类型	

        channelType: {

            type: String,

            default: 'BALANCE'

        },

        // 日账单

        dailyBill: {

            type: Boolean,

            default: false

        },

        // 按需扣费账单

        debtDeduct: {

            type: Boolean,

            default: false

        },

        // 描述

        detail: {

            type: String,

            default: ''

        },

        // 账单

        detailRequest: {

            type: Schema.Types.ObjectId,

            ref: 'Company',

        },

        // 账单类型

        detailType: {

            type: String,

            default: 'LINK'

        },

        // 账单链接

        detailUrl: {

            type: String,

            default: ''

        },

        // 订单ID

        orderId: {

            type: Schema.Types.ObjectId,

            ref: 'comp_account_billing_order'

        },

        // 账单产品详细

        serviceItem: [],

        // 产品类型

        serviceType: {},

        // 交易类型 [RECHARGE:收入,CONSUME:支出]

        transactionType: {

            type: String,

            default: 'CONSUME'

        },

        // 备注

        remark: {



        }

    }, {

        timestamps: {

            createdAt: 'created',

            updatedAt: 'updated'

        }

    });

    compAccountDealrecordSchema.statics = {

        getAll: async function(queryMix, _comp) {

            const {

                querys,

                select

            } = queryMix;

            const models = this.find({

                    ...!!_comp && {

                        _comp

                    }

                })

                .sort({

                    '_id': -1,

                });

            try {

                return {

                    data: {

                        result: await models,

                        totalCount: await models.count()

                    }

                };

            } catch (error) {

                return error

            }

        },

        getOne: async function(_id, _comp) {

            const MODELS = this.findOne({..._comp && {

                    _comp

                },

                _id

            }).sort({

                '_id': -1

            });

            try {

                return {

                    data: await MODELS

                }

            } catch (error) {

                return error

            }

        },

        createOne: async function(bodys) {

            return await this.create(bodys)

        },

        backCashAdd: async function(bodys, auth) {

            const {

                _comp,

                serviceBillCash,

                serviceBillChannel,

                serviceBillRemark

            } = bodys

            // 生成流水

            await this.create({

                '_comp': _comp,

                'serviceBillProduct': '-',

                'serviceBillType': '充值',

                'serviceBillCash': `+${serviceBillCash}`,

                'serviceBillChannel': `${serviceBillChannel}`,

                'serviceBillRemark': `手工入款/n${serviceBillChannel}/n${serviceBillRemark}`,

                '_admin': auth.id

            });

            return await ctx.model.Company.cashFN(serviceBillCash, auth, 'cash', 'add', _comp);

        },

        seachComp: async function(name) {

            return await ctx.model.Company.find({

                'compName': eval(`/${name}.*/i`)

            }, {

                'compEmail': 1,

                'compName': 1,

                'compPhone': 1

            })

        },

        // 图表数据

        /**

         * 

         * @param {*} type      订单类型

         * @param {*} scope     月份计算 

         * @param {*} _comp 

         */

        getPanelChart: async function(type = 'all', classify = "line", _comp) {

            const MODEL = this.aggregate([

                ...classify === 'pie' ? [{

                    $unwind: `$serviceItem`,

                }] : [],

                ...[{

                        $match: {

                            '_comp': mongoose.Types.ObjectId(_comp),

                            'created': {

                                "$gt": new Date(subtractMoment(1, 'month'))

                            },

                            "channelType": "CASH",

                            ...type !== 'all' && {

                                'serviceItem.serviceType': type

                            }

                        }

                    },

                    {

                        $project: {

                            '_comp': 1,

                            'amount': 1,

                            'created': 1,

                            "serviceItem": 1,

                            'day': {

                                $substr: ["$created", 0, 10]

                            }

                        }

                    },

                    {

                        $group: {

                            ...classify === "line" ? {

                                '_id': `$day`

                            } : {

                                '_id': '$serviceItem.serviceType'

                            },

                            'count': {

                                $sum: classify === 'pie' ? '$serviceItem.price' : '$amount'

                            }

                        }

                    },

                    {

                        $project: {

                            ...classify === "line" ? {

                                'days': '$_id'

                            } : {

                                'serviceType': '$_id'

                            },

                            'count': 1,

                            _id: 0

                        }

                    },

                    {

                        $sort: {

                            'days': 1

                        }

                    }

                ]

            ]);

            try {

                const lastMonth = subtractMoment(1, 'month', 'subtract');

                const DateMaps = (getDayAll(lastMonth, new Date()));

                const data = await MODEL;

                return {

                    ...classify === 'pie' ? {

                        data

                    } : {

                        'data': {

                            datas: DateMaps.reduce((a, b) => {

                                let count;

                                data.forEach(e => {

                                    if (e.days === b) count = e.count

                                });

                                a.push(count ? count : 0);

                                return a

                            }, []),

                            dates: DateMaps

                        }

                    }

                }

            } catch (error) {

                console.log(error)

            }

        },

        /**

         * @param {String}      type     产品类型()

         */

        getCashCount: async function(ctx, auth, type, _comp) {

            const {

                endDate

            } = ctx.helper.getPrevMoment('month');

            const yestoday = ctx.helper.subtractMoment(1, 'day');

            const typeoObj = type === 'all' ? {} : {

                'serviceBillProduct': type,

                '_comp': mongoose.Types.ObjectId(_comp ? _comp : auth.id)

            };

            return [(await this.aggregate([{

                    $match: {...typeoObj,

                        'created': {

                            "$gt": new Date(endDate)

                        },

                        'serviceBillType': '消费'

                    }

                },

                {

                    $group: {

                        '_id': {

                            '_comp': auth.id

                        },

                        'monthCashSum': {

                            $sum: "$serviceBillCash"

                        }

                    }

                },

                {

                    $project: {

                        '_id': 0

                    }

                }

            ]))[0], (await this.aggregate([{

                    $match: {...typeoObj,

                        'created': {

                            "$gt": new Date(yestoday)

                        },

                        'serviceBillType': '消费'

                    }

                },

                {

                    $group: {

                        '_id': {

                            '_comp': auth.id

                        },

                        'dayCashSum': {

                            $sum: "$serviceBillCash"

                        }

                    }

                },

                {

                    $project: {

                        '_id': 0

                    }

                },

            ]))[0]]

        },

    };

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<strong>?a<strong>++:a<strong>=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);

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

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");

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

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));

请求是否有主体	        否

成功的响应是否有主体	是

安全	                是

幂等	                是

可缓存	                是

HTML 表单是否支持	    是

请求是否有主体	        是

成功的响应是否有主体	是

安全	                否

幂等	                否

可缓存	                仅缓存最近的数据

HTML 表单是否支持	    是

请求是否有主体	        否

成功的响应是否有主体	否

安全	                否

幂等	                是

可缓存	                否

HTML 表单是否支持	    否

请求是否有主体	        是

成功的响应是否有主体	否

安全	                否

幂等	                是

可缓存	                否

HTML 表单是否支持	    否

• PUT与POST方法的区别在于，PUT方法是幂等的：调用一次与连续调用多次是等价的（即没有副作用），而连续调用多次POST方法可能会有副作用，比如将一个订单重复提交多次。
• PUT 用于整体覆盖

请求是否有主体	        也许有

成功的响应是否有主体	否

安全	                否

幂等	                否

可缓存	                否

HTML 表单是否支持	    否

在HTTP协议中，?PUT?方法已经被用来表示对资源进行整体覆盖， 而?POST?方法则没有对标准的补丁格式的提供支持。不同于??PUT?方法，而与?POST?方法类似，PATCH??方法是非幂等的，这就意味着连续多个的相同请求会产生不同的效果。

• 当GET,PUT和PATCH请求成功时，要返回对应的数据，及状态码200，即SUCCESS
• 当PUT,POST创建数据成功时，要返回创建的数据，及状态码201，即CREATED
• 当DELETE删除数据成功时，不返回数据，状态码要返回204，即NO CONTENT
• 当GET不到数据时，状态码要返回404，即NOT FOUND
• 任何时候，如果请求有问题，如校验请求数据时发现错误，要返回状态码400，即BAD REQUEST
• 当API 请求需要用户认证时，如果request中的认证信息不正确，要返回状态码401，即NOT AUTHORIZED
• 当API 请求需要验证用户权限时，如果当前用户无相应权限，要返回状态码403，即FORBIDDEN

1. 数据类型校验，如字段类型如果是int，那么给字段赋字符串的值则报错
2. 数据格式校验，如邮箱或密码，其赋值必须满足相应的正则表达式，才是正确的输入数据
3. 数据逻辑校验，如数据包含出生日期和年龄两个字段，如果这两个字段的数据不一致，则数据校验失败（目前而言最复杂）

app.all('*', (req, res, next) => {

    res.header("Access-Control-Allow-Origin", "*");

    res.header("Access-Control-Allow-Headers", "X-Requested-With,token,authorization");

    res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,PATCH,OPTIONS");

    res.header("X-Powered-By", ' 3.2.1');

    res.header("Content-Type", "application/json;charset=utf-8");

    next();

});

GET /api/v1/posts/

GET /api/v2/posts/

GET /api/Article/1/

GET /api/deleteArticle?id=1

GET /api/lopo/Article/1/

GET /api/comp/?user=lopo&&column=id,name,label

{

  "page": 1,            # 当前是第几页

  "pages": 3,           # 总共多少页

  "per_page": 10,       # 每页多少数据

  "has_next": true,     # 是否有下一页数据

  "has_prev": false,    # 是否有前一页数据

  "total": 27           # 总共多少数据

}

• Url 严格区分大小写的 不同大小写会被定为到不同的资源
• 建议以/对Url进行结尾
• 建议Url 片段组合时用-，params用_