import { Module } from '@nestjs/common'; 
import { MongooseModule } from '@nestjs/mongoose'; 

@Module({ 
  imports: [MongooseModule.forRoot('mongodb://localhost/koa',{ useNewUrlParser: true })] 
})

export class ApplicationModule {}

import * as mongoose from 'mongoose'; 

export const ArticleSchema = new mongoose.Schema({ 
  title: String, 
  keywords:String, 
  author: Number, 
  status: String, 
});

import { Module } from '@nestjs/common'; 
import { NewsController } from './news.controller'; 
import { NewsService } from './news.service'; 
import { ArticleSchema } from './schemas/article.schema'; 
import { MongooseModule } from '@nestjs/mongoose'; 

@Module({ 
  imports: [MongooseModule.forFeature([{ name: 'Article', schema: ArticleSchema,collection:"article" }])], controllers: [NewsController], 
  providers: [NewsService] 
})

export class NewsModule {}

import { Injectable } from '@nestjs/common'; 
import { InjectModel } from '@nestjs/mongoose';

@Injectable() 
export class NewsService { 
  constructor(@InjectModel('Article') private readonly articleModel) {} 
  async findAll() { 
    return await this.articleModel.find().exec(); 
  } 
}

const data = [
  "办公设备、附件和用品>>办公用品>>书写工具>>毛笔",
  "造纸原料和纸制品>>纸制品>>个人纸制品>>餐巾纸和餐巾",
  "造纸原料和纸制品>>纸制品>>个人纸制品>>丝巾",
  "办公设备、附件和用品>>办公用品>>测试分类>>苹果",
  "其它",
  "办公设备、附件和用品>>办公用品>>测试分类>>荔枝",
  "办公设备、附件和用品>>家具用品>>床头用品>>枕头",
  "食品、饮料和烟草>>肉和家禽产品>>加工和处理过的肉>>鲜的加工和处理过的肉",
  "食品、饮料和烟草>>巧克力、糖、甜品和糖果>>糖果>>口香糖",
  "食品、饮料和烟草>>饮料>>咖啡和茶>>咖啡饮料",
  "食品、饮料和烟草>>饮料>>非酒精饮料>>泉水和矿泉水",
  "办公设备、附件和用品>>办公用品>>书写工具>>水笔",
  "造纸原料和纸制品>>纸制品>>个人纸制品>>纸巾",
  "食品、饮料和烟草>>巧克力、糖、甜品和糖果>>巧克力、糖和甜品>>巧克力和巧克力代用品",
  "食品、饮料和烟草>>饮料>>非酒精饮料>>水",
  "食品、饮料和烟草>>乳制品和蛋>>牛奶和黄油产品>>贮藏的牛奶和黄油产品",
  "食品、饮料和烟草>>预制食品和罐头>>方便什锦和用品>>方便什锦小吃",
  "食品、饮料和烟草>>饮料>>咖啡和茶>>袋茶",
  "食品、饮料和烟草>>面包和烘焙食品>>蛋糕、派和糕点>>新鲜蛋糕、派和糕点",
  "休闲零食",
  "食品、饮料和烟草>>饮料>>咖啡和茶>>非乳场生产的乳品饮料",
  "服装、箱包、个人护理用品>>个人护理用品>>洗浴、身体护理品>>化妆品",
  "食品、饮料和烟草>>饮料>>非酒精饮料>>软饮料",
  "食品、饮料和烟草>>肉和家禽产品>>加工和处理过的肉>>贮藏加工和处理过的肉",
  "食品、饮料和烟草>>谷类和豆类制品>>豆类>>豆粉",
  "食品、饮料和烟草>>预制食品和罐头>>小吃>>坚果和水果干"
]

[
  {
    "value": "办公设备、附件和用品",
    "lable": "办公设备、附件和用品",
    "children": [
      {
        "value": "办公用品",
        "lable": "办公用品",
        "children": [
          {
            "value": "书写工具",
            "lable": "书写工具",
            "children": [
              {
                "value": "毛笔",
                "lable": "毛笔"
              }
              ...
            ]
          }
          ...
        ]
      }
      ...
    ]
  }
]

[
  [ '办公设备、附件和用品', '办公用品', '书写工具', '毛笔' ],
  [ '造纸原料和纸制品', '纸制品', '个人纸制品', '餐巾纸和餐巾' ],
  [ '造纸原料和纸制品', '纸制品', '个人纸制品', '丝巾' ],
  [ '办公设备、附件和用品', '办公用品', '测试分类', '苹果' ],
  [ '其它' ],
  ...
]

const treeArr = []
const analysisData = (data) => { // 这样就得到了一个切分好的数组
  data.forEach((ele, index) => {
    treeArr.push(ele.split('>>'))
  })
}

const treeArr = []
const analysisData = (data) => {
  data.forEach(ele => {
    const eleArr = ele.split('>>')
    judgeData(treeArr, eleArr, 0)
  })
}

const judgeData = (treeArr, eleArr, step) => {
  if (!treeArr.some(item => {
    if (item.value === eleArr[step]) {
      return true
    }
  })) {
    const treeSon = {
      value: eleArr[step],
      lable: eleArr[step]
    }
    treeArr.push(treeSon)
    if (eleArr[step + 1] !== undefined) {
      treeSon.children = []
      judgeData(treeSon.children, eleArr, step + 1)
    }
  } else {
    treeArr.forEach(ele => {
      if (ele.value === eleArr[step]) {
        judgeData(ele.children, eleArr, step + 1)
      }
    })
  }
}

const data = [
  "办公设备、附件和用品>>办公用品>>书写工具>>毛笔",
  "造纸原料和纸制品>>纸制品>>个人纸制品>>餐巾纸和餐巾",
  "造纸原料和纸制品>>纸制品>>个人纸制品>>丝巾",
  "办公设备、附件和用品>>办公用品>>测试分类>>苹果",
  "其它",
  "办公设备、附件和用品>>办公用品>>测试分类>>荔枝",
  "办公设备、附件和用品>>家具用品>>床头用品>>枕头",
  "食品、饮料和烟草>>肉和家禽产品>>加工和处理过的肉>>鲜的加工和处理过的肉",
  "食品、饮料和烟草>>巧克力、糖、甜品和糖果>>糖果>>口香糖",
  "食品、饮料和烟草>>饮料>>咖啡和茶>>咖啡饮料",
  "食品、饮料和烟草>>饮料>>非酒精饮料>>泉水和矿泉水",
  "办公设备、附件和用品>>办公用品>>书写工具>>水笔",
  "造纸原料和纸制品>>纸制品>>个人纸制品>>纸巾",
  "食品、饮料和烟草>>巧克力、糖、甜品和糖果>>巧克力、糖和甜品>>巧克力和巧克力代用品",
  "食品、饮料和烟草>>饮料>>非酒精饮料>>水",
  "食品、饮料和烟草>>乳制品和蛋>>牛奶和黄油产品>>贮藏的牛奶和黄油产品",
  "食品、饮料和烟草>>预制食品和罐头>>方便什锦和用品>>方便什锦小吃",
  "食品、饮料和烟草>>饮料>>咖啡和茶>>袋茶",
  "食品、饮料和烟草>>面包和烘焙食品>>蛋糕、派和糕点>>新鲜蛋糕、派和糕点",
  "休闲零食",
  "食品、饮料和烟草>>饮料>>咖啡和茶>>非乳场生产的乳品饮料",
  "服装、箱包、个人护理用品>>个人护理用品>>洗浴、身体护理品>>化妆品",
  "食品、饮料和烟草>>饮料>>非酒精饮料>>软饮料",
  "食品、饮料和烟草>>肉和家禽产品>>加工和处理过的肉>>贮藏加工和处理过的肉",
  "食品、饮料和烟草>>谷类和豆类制品>>豆类>>豆粉",
  "食品、饮料和烟草>>预制食品和罐头>>小吃>>坚果和水果干"
]
// console.log(data)
const treeArr = []
const analysisData = (data) => {
  data.forEach(ele => {
    const eleArr = ele.split('>>')
    judgeData(treeArr, eleArr, 0)
  })
}
const judgeData = (treeArr, eleArr, step) => {
  if (!treeArr.some(item => {
    if (item.value === eleArr[step]) {
      return true
    }
  })) {
    const treeSon = {
      value: eleArr[step],
      lable: eleArr[step]
    }
    treeArr.push(treeSon)
    if (eleArr[step + 1] !== undefined) {
      treeSon.children = []
      judgeData(treeSon.children, eleArr, step + 1)
    }
  } else {
    treeArr.forEach(ele => {
      if (ele.value === eleArr[step]) {
        judgeData(ele.children, eleArr, step + 1)
      }
    })
  }
}
analysisData(data)
console.log('treeArr: ', JSON.stringify(treeArr))

function Person(name = '人') {
  this.name = name
}

const p1 = new Person('小明')
console.log(p1) // Person { name: '小明' }

function Person(name = '人') {
  this.name = name
  this.say = function() {
    console.log(`大家好，我是：${this.name}`)
  }
}

const p1 = new Person('小明')
const p2 = new Person('小刚')
console.log(p1, p2) // Person { name: '小明', say: [Function] } Person { name: '小刚', say: [Function] }
p1.say() // 大家好，我是：小明
p2.say() // 大家好，我是：小刚
console.log(p1.say === p2.say) // false

function Person(name = '人') {
  this.name = name
}
Person.prototype.say = function() {
  console.log(`大家好，我是：${this.name}`)
}

const p1 = new Person('小明')
const p2 = new Person('小刚')
console.log(p1, p2) // Person { name: '小明' } Person { name: '小刚' }
p1.say() // 大家好，我是：小明
p2.say() // 大家好，我是：小刚
console.log(p1.say === p2.say) // true

function Person(name = '人') {
  this.name = name
}

console.log(Person.prototype.constructor = Person) // true

function Person(name = '人') {
  this.name = name
}
const p1 = new Person('小明')
console.log(p1 instanceof Person) // true
console.log(p1.constructor === Person) // true
console.log(p1.__proto__.constructor === Person) // true

'32' * 1 // 32
'ds' * 1 // NaN
null * 1 // 0
undefined * 1 // NaN
1 * { valueOf: () => '3' }  // 3

+ '123' // 123
+ 'ds' // NaN
+ '' // 0
+ null // 0
+ undefined // NaN
+ { valueOf: () => '3' } // 3

'the Math object:' + Math // "the Math object:[object Math]"
'the JSON object:' + JSON // "the JSON object:[object JSON]"

2  * { valueOf: () => '3' } // 6
'J' + { toString: () => 'S' } // "JS"

'' + { toString: ()=> 'S', valueOf: () => 'J' } // J

const compact = arr => arr.filter(Boolean)
compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34]) // [ 1, 2, 3, 'a', 's', 34 ]

Math.floor(4.9) === 4 //true
// 简写为：
~~4.9 === 4  //true

~~4.5 // 4
Math.floor(4.5) // 4
~~-4.5 // -4
Math.floor(-4.5) // -5

let variable1
let variable2 = variable1  || 'foo'    

let variable = param && param.prop

1.3 | 0 // 1
-1.9 | 0  // -1

const num = 3;
!!(num & 1) // true
!!(num % 2) // true

func = (l, m = 3, n = 4 ) => (l * m * n);
func(2)  //output: 24

mandatory = () => {
  throw new Error('Missing parameter!');
}
foo = (bar = mandatory()) => { // 这里如果不传入参数，就会执行manadatory()函数报出错误
  return bar;
}

function calcCircumference(diameter) {
  return Math.PI * diameter
}
// 简写为：
calcCircumference = diameter => (
  Math.PI * diameter;
)

function foo(){
    if(a !== b){
        console.log('aaa')
    }else{
        console.log('bbb')
    }
}

// 优化后
function foo(){
    if(a != b){
        foo = function(){
            console.log('aaa')
        }
    }else{
        foo = function(){
            console.log('bbb')
        }
    }
    return foo();
}

var sca = function() {
  console.log('msg')
  sca = function() {
    console.log('foo')
  }
}
sca() // msg
sca() // foo
sca() // foo

function validate(values) {
  if(!values.first)
    return false;
  if(!values.last)
    return false;
  return true;
}
console.log(validate({first:'Bruce',last:'Wayne'})); // true

// object validation rules
const schema = {
  first: {
    required:true
  },
  last: {
    required:true
  }
}
 
// universal validation function
const validate = (schema, values) => {
  for(field in schema) {
    if(schema[field].required) {
      if(!values[field]) {
        return false;
      }
    }
  }
  return true;
}
console.log(validate(schema, {first:'Bruce'})); // false
console.log(validate(schema, {first:'Bruce',last:'Wayne'})); // true

29 // 10 进制
035 // 8 进制 29  原来的方式
0o35 // 8 进制 29 ES6 的方式
0x1d // 16 进制 29
0b11101 // 2 进制 29

const round = (n, decimals = 0) => Number(`${Math.round(`${n}e${decimals}`)}e-${decimals}`)
round(1.345, 2) // 1.35
round(1.345, 1) // 1.3

const addZero1 = (num, len = 2) => (`0${num}`).slice(-len)
const addZero2 = (num, len = 2) => (`${num}`).padStart( len   , '0')

addZero1(3) // 03
addZero2(32,4)  // 0032

const numbers = [10, 20, 30, 40];
const doubledOver50 = numbers.reduce((finalList, num) => {
  num = num * 2;
  if (num > 50) {
    finalList.push(num);
  }
  return finalList;
}, []);
doubledOver50; // [60, 80]

var cars = ['BMW','Benz', 'Benz', 'Tesla', 'BMW', 'Toyota'];
var carsObj = cars.reduce(function (obj, name) {
  obj[name] = obj[name] ? ++obj[name] : 1;
  return obj;
}, {});
carsObj; // => { BMW: 2, Benz: 2, Tesla: 1, Toyota: 1 }

let param1 = 1;
let param2 = 2;
[param1, param2] = [param2, param1];
console.log(param1) // 2
console.log(param2) // 1

var temp = a; a = b; b = temp                
b = [a, a = b][0]                         
a = a + b; b = a - b; a = a - b	
```		
### 接收函数返回的多个结果
在下面的代码中，我们从 /post 中获取一个帖子，然后在 /comments 中获取相关评论。由于我们使用的是 async/await，函数把返回值放在一个数组中。而我们使用数组解构后就可以把返回值直接赋给相应的变量。
```javascript
async function getFullPost(){
  return await Promise.all([
    fetch('/post'),
    fetch('/comments')
  ]);
}
const [post, comments] = getFullPost();

const flatten = (arr, depth = 1) =>
  depth != 1
    ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flatten(v, depth - 1) : v), [])
    : arr.reduce((a, v) => a.concat(v), []);
flatten([1, [2], 3, 4]); // [1, 2, 3, 4]
flatten([1, [2, [3, [4, 5], 6], 7], 8], 2); // [1, 2, 3, [4, 5], 6, 7, 8]

const csvFileLine = '1997,John Doe,US,john@doe.com,New York';
const { 2: country, 4: state } = csvFileLine.split(',');
 
country // US
state // New Yourk

let {_internal, tooBig, ...cleanObject} = {el1: '1', _internal: "secret", tooBig: {}, el2: '2', el3: '3'};
 
console.log(cleanObject); // {el1: '1', el2: '2', el3: '3'}

var car = {
  model: 'bmw 2018',
  engine: {
    v6: true,
    turbo: true,
    vin: 12345
  }
}
const modelAndVIN = ({model, engine: {vin}}) => {
  console.log(`model: ${model} vin: ${vin}`);
}
modelAndVIN(car); // => model: bmw 2018  vin: 12345

export function formatDate (oldDate, fmt) {  
  let date = new Date()  
  if (typeof oldDate === 'string' || typeof oldDate === 'number') {    
    date = new Date(+oldDate)  
  } else {    
    date = oldDate  
  }  
if (/(y+)/.test(fmt)) {    
  fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))  }  
  let o = {    
  'M+': date.getMonth() + 1,    
  'd+': date.getDate(),    
  'h+': date.getHours(),    
  'm+': date.getMinutes(),    
  's+': date.getSeconds()  }  
  function padLeftZero (str) {    
    return ('00' + str).substr(str.length)  
  }  
  for (let k in o) {    
    if (new RegExp(`(${k})`).test(fmt)) {      
      let str = o[k] + ''      
      fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : padLeftZero(str))    
    }  
  }  
  return fmt
}

export function setDate(num) {  return Date.now() + num * 24 * 60 * 60 * 1000}

var urlParams = new URLSearchParams('?post=1234&action=edit');
console.log(urlParams.get('action')); // "edit"

getUrlParams(param){
  // 有赖于浏览器环境， window.location.search 是浏览器函数
  // 意思是:设置或返回从问号 (?) 开始的 URL（查询部分）。       
  var query = window.location.search.substring(1);       
  var vars = query.split("&");       
  for (var i=0;i<vars.length;i++) {               
    var pair = vars[i].split("=");               
    if(pair[0] == param){return pair[1];}       
  }       
  return(false);
}

BrowserInfo = {      
  isAndroid: Boolean(navigator.userAgent.match(/android/ig)),      
  isIphone: Boolean(navigator.userAgent.match(/iphone|ipod/ig)),      
  isIpad: Boolean(navigator.userAgent.match(/ipad/ig)),      
  isWeixin: Boolean(navigator.userAgent.match(/MicroMessenger/ig)),      
  isAli: Boolean(navigator.userAgent.match(/AlipayClient/ig)),
  isPhone: Boolean(/(iPhone|iPad|iPod|iOS|Android)/i.test(navigator.userAgent))
}

let arr = [ [1], [2], [3] ]
arr = Array.prototype.concat.apply([], arr); // [1, 2, 3]

let arr = [1, 2, [3], [[4]]]
arr = arr.flat(3) // [1, 2, 3, 4]

function deepClone() {
    return JSON.parse(JSON.stringify(obj))
}

function deepClone(obj) {  
  function isClass(o) {    
  if (o === null) return "Null";    
  if (o === undefined) return "Undefined";    
    return Object.prototype.toString.call(o).slice(8, -1);  
  }  
  var result;  
  var oClass = isClass(obj);  
  if (oClass === "Object") {    
    result = {};  
  } else if (oClass === "Array") {
    result = [];  
  } else {    
    return obj;  
  }  
  for (var key in obj) {    
    var copy = obj[key];    
    if (isClass(copy) == "Object") {      
      result[key] = arguments.callee(copy);//递归调用    
    } else if (isClass(copy) == "Array") {      
      result[key] = arguments.callee(copy);    
    } else {      
      result[key] = obj[key];    
    }  
  }  
  return result;
}

function debounce(func, wait) {
    let timeout;
    return function () {
        let context = this;
        let args = arguments;

        if (timeout) clearTimeout(timeout);
        
        timeout = setTimeout(() => {
            func.apply(context, args)
        }, wait);
    }
}

function throttle(func, wait) {
    let previous = 0;
    return function() {
        let now = Date.now();
        let context = this;
        let args = arguments;
        if (now - previous > wait) {
            func.apply(context, args);
            previous = now;
        }
    }
}

function smallest(array){                           
  return Math.min.apply(Math, array);             
}                                                 
function largest(array){                            
  return Math.max.apply(Math, array);             
}  
smallest([0, 1, 2.2, 3.3]); // 0
largest([0, 1, 2.2, 3.3]); // 3.3

let list = [1, 2, 3, 4, 5]
Math.max(...list) // 5
Math.min(...list) // 1

function epsEqu(x,y) {  
  return Math.abs(x - y) < Math.pow(2, -52);
}
// 举例
0.1 + 0.2 === 0.3 // false
epsEqu(0.1 + 0.2, 0.3) // true

function epsEqu(x,y) {  
  return Math.abs(x - y) < Number.EPSILON;
}