官网介绍链接：https://docs.mongodb.com/v3.2/core/index-ttl/

• ①TTL索引是单字段索引，混合索引不支持TTL，并且也会忽略expireAfterSeconds属性
• ②在_id 主键上不能建立TTL索引
• ③在capped collection中不能建立TTL索引，因为MongoDB不能从capped collection中删除文档
• ④你不能使用createIndex()去更改已经存在的TTL索引的expireAfterSeconds值，如果想更改expireAfterSeconds，可以使用collMod命令，否则你只能删除索引，然后重建了
• ⑤你不能在已有索引的字段上再创建TTL索引了，如果你想把非TTL索引改为TTL索引，那就只能删除重建索引了

db.getCollection('smscodes').ensureIndex({'expiresIn':1},{"expireAfterSeconds":60*1})

const AllPsListSchema = new Schema({

        // 分类中文名称

        psName: {

            type: String,

            required: [true, '服务名称不能为空'],

            unique: true,

        },

        // 分类英文名称

        psEnName: {

            type: String,

        },

        // 服务状态 [0/停用，1/正常，2/维护，3/下线]

        psState: {

            type: Number,

            default: 1

        },

        // 服务子类

        psChild: [{

            // 产品/服务名称

            name: {

                type: String,

                required: [true, '服务/产品名称不能为空'],

                unique: true

            },

            // 产品/服务英文名称

            enName: {

                type: String,

                required: [true, '服务/产品英文名称不能为空'],

                unique: true

            },

            // 服务状态 [0/停用，1/正常，2/维护，3/下线]            

            state: {

                type: Number,

                default: 1

            },

            // [0/删除，1/锁定,2/正常] 1/锁定意思为不可删除，系统保留

            status: {

                type: Number,

                default: 2

            }

        }],

        // [0:删除，1：锁定,2:正常] 1/锁定意思为不可删除，系统保留

        status: {

            type: Number,

            default: 2

        }

    }, {

            timestamps: {

                createdAt: 'created',

                updatedAt: 'updated'

            }

        })

        creatPSChild: async function (_id, bodys) {

            const result = await this.findOneAndUpdate({ _id, 'psChild.name': { $ne: bodys.name }, 'psChild.enName': { $ne: bodys.enName } }, {

                $push: {

                    'psChild': bodys

                }

            });

            return { data: result }

        }

mongodump -h dbhost -d dbname -o dbdir

C:\Program Files\MongoDB\Server\4.0>mongodump

2018-09-20T16:55:53.312+0800    writing admin.system.version to

2018-09-20T16:55:53.356+0800    done dumping admin.system.version (1 document)

2018-09-20T16:55:53.357+0800    writing test.servicebills to

2018-09-20T16:55:53.357+0800    writing test.smslists to

2018-09-20T16:55:53.357+0800    writing test.companylogs to

2018-09-20T16:55:53.357+0800    writing test.smssigns to

2018-09-20T16:55:53.370+0800    done dumping test.companylogs (106 documents)

2018-09-20T16:55:53.370+0800    writing test.companies to

2018-09-20T16:55:53.374+0800    done dumping test.servicebills (347 documents)

2018-09-20T16:55:53.374+0800    writing test.smstemps to

2018-09-20T16:55:53.375+0800    done dumping test.companies (5 documents)

2018-09-20T16:55:53.376+0800    writing test.smsmailcodes to

2018-09-20T16:55:53.385+0800    done dumping test.smstemps (3 documents)

2018-09-20T16:55:53.385+0800    writing test.admins to

2018-09-20T16:55:53.399+0800    done dumping test.smsmailcodes (2 documents)

2018-09-20T16:55:53.399+0800    writing test.users to

2018-09-20T16:55:53.405+0800    done dumping test.admins (1 document)

2018-09-20T16:55:53.405+0800    writing test.complicenses to

2018-09-20T16:55:53.423+0800    done dumping test.users (1 document)

2018-09-20T16:55:53.423+0800    writing test.smscodes to

2018-09-20T16:55:53.429+0800    done dumping test.complicenses (1 document)

2018-09-20T16:55:53.429+0800    writing test.tokens to

2018-09-20T16:55:53.440+0800    done dumping test.smscodes (1 document)

2018-09-20T16:55:53.440+0800    writing test.zones to

2018-09-20T16:55:53.444+0800    done dumping test.zones (0 documents)

2018-09-20T16:55:53.444+0800    writing test.smshistories to

2018-09-20T16:55:53.447+0800    done dumping test.tokens (1 document)

2018-09-20T16:55:53.448+0800    done dumping test.smshistories (0 documents)

2018-09-20T16:55:54.392+0800    done dumping test.smssigns (15 documents)

2018-09-20T16:55:54.402+0800    done dumping test.smslists (202 documents)

mongorestore -h hostname:port -d dbname <path>

C:\Program Files\MongoDB\Server\4.0>mongorestore -h IP:port --drop --dir ./dump

2018-09-20T16:57:17.847+0800    preparing collections to restore from

2018-09-20T16:57:17.898+0800    reading metadata for test.servicebills from dump\test\servicebills.metadata.json

2018-09-20T16:57:17.898+0800    reading metadata for test.companylogs from dump\test\companylogs.metadata.json

2018-09-20T16:57:17.899+0800    reading metadata for test.smslists from dump\test\smslists.metadata.json

2018-09-20T16:57:17.899+0800    reading metadata for test.smssigns from dump\test\smssigns.metadata.json

2018-09-20T16:57:17.900+0800    restoring test.servicebills from dump\test\servicebills.bson

2018-09-20T16:57:17.900+0800    restoring test.companylogs from dump\test\companylogs.bson

2018-09-20T16:57:17.900+0800    restoring test.smslists from dump\test\smslists.bson

2018-09-20T16:57:17.900+0800    restoring test.smssigns from dump\test\smssigns.bson

db.test.update({'_id':id},{

$push:{'arr':{'name':'value'}}

})

db.test.update({'_id':id,arr.name:'name'},{

$set:{'arr.$.name':'newName'}

})

db.test.update({'_id':id},{

$pull:{arr:{'name':'value'}}

})

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

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

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

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;

}