function randomMembers1(arr, limit) {
  const result = [];

  for (let i = 0; i < limit; i++) {
    result[i] = arr[Math.floor(Math.random() * arr.length)];
    for (let j = 0; j < i; j++) {
      if (result[j] === result[i]) {
        i--;
        break;
      }
    }
  }
  return result;
}

randomMembers1([11, 12, 13, 14, 15, 16, 17, 18], 5); //[ 18, 16, 12, 17, 14 ]

function randomMembers2(arr, limit) {
  const hash = {};
  const result = [];

  while (limit > 0) {
    const index = Math.floor(Math.random() * arr.length);
    if (!hash[index]) {
      hash[index] = true;
      result.push(arr[index]);
      limit--;
    }
  }

  return result;
}

randomMembers2([11, 12, 13, 14, 15, 16, 17, 18], 5); //[ 16, 17, 13, 11, 18 ]

function randomMembers3(arr, limit) {
  const result = [];
  let num = arr.length > limit ? limit : arr.length;

  while (num > 0) {
    const index = Math.floor(Math.random() * arr.length);
    result.push(arr.splice(index, 1)[0]);

    num--;
  }

  return result;
}

function randomMembers4(arr, limit) {
  const result = [];
  const keyList = [...arr.keys()];
  let num = arr.length > limit ? limit : arr.length;

  while (num > 0) {
    const index = Math.floor(Math.random() * keyList.length);
    const key = keyList.splice(index, 1)[0];

    result.push(arr[key]);

    num--;
  }

  return result;
}

const operatorRand = {
  '+': 1,
  '-': 1,
  '*': 2,
  '/': 2,
};

/**
 * 中缀表达式转换成逆波兰表达式
 * @param {string[]} str 中缀表达式
 */
function convert(inputArr) {
  if (!Array.isArray(inputArr) || inputArr.length === 0) return [];

  const operatorArr = [];
  const outputArr = [];

  inputArr.forEach(input => {
    if (!Number.isNaN(Number(input))) {
      // 如果是数字，只接输出
      outputArr.push(input);
    } else if (input === '(') {
      // 如果是左括号，入操作符栈
      operatorArr.push(input);
    } else if (input === ')') {
      // 如果是右括号，循环输出，知道匹配到左括号为止
      while (operatorArr.length > 0) {
        const operator = operatorArr.pop();
        if (operator === '(') break;
        outputArr.push(operator);
      }
    } else {
      // 如果是运算符
      while (operatorArr.length >= 0) {
        const topOperator = operatorArr[operatorArr.length - 1];

        // 如果运算符栈为空，或者栈顶运算符是(，或者当前运算符优先级比栈顶运算符优先级高
        if (
          operatorArr.length === 0 ||
          topOperator === '(' ||
          operatorRand[input] > operatorRand[topOperator]
        ) {
          operatorArr.push(input);
          break;
        } else {
          outputArr.push(operatorArr.pop());
        }
      }
    }
  });

  // 输入循环结束，如果运算符栈不为空，循环输出
  while (operatorArr.length > 0) {
    outputArr.push(operatorArr.pop());
  }

  return outputArr;
}

function compute(leftNum, rightNum, operator) {
  switch (operator) {
    case '+':
      return leftNum + rightNum;
    case '-':
      return leftNum - rightNum;
    case '*':
      return leftNum * rightNum;
    default:
      // 除法
      return leftNum / rightNum;
  }
}

/**
 * 计算逆波兰表达式
 * @param {string} str 逆波兰表达式
 */
export function count(reversePolishArr) {
  if (!Array.isArray(reversePolishArr) || reversePolishArr.length === 0) return 0;

  const tmpArr = [];

  reversePolishArr.forEach(input => {
    if (!Number.isNaN(Number(input))) {
      // 数字接直接push
      tmpArr.push(Number(input));
    } else {
      // 运算符
      const num1 = tmpArr.pop();
      const num2 = tmpArr.pop();

      if (isNaN(num1) || isNaN(num2)) {
        throw new Error(`无效的表达式：${reversePolishArr.join(',')}`);
      }

      tmpArr.push(compute(num2, num1, input));
    }
  });

  return Number(tmpArr[0].toFixed(3));
}

class ConsoleTransport extends winston.transports.Console {
  constructor(options) {
    super(options);

    this.format = winston.format.combine(
      winston.format(info => {
        info.hostname = hostname();
        info.pid = process.pid;
        info.level = info.level.toUpperCase();
        return info;
      })(),
      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss,SSSS' }),
      winston.format.ms(),
      winston.format.colorize(),
      winston.format.printf(options.formatter),
    );
  }
}

const winston = require('winston');
require('winston-daily-rotate-file');

class FileTransport extends winston.transports.DailyRotateFile {
  constructor(options) {
    super(options);

    this.datePattern = 'YYYY-MM-DD';
    this.zippedArchive = true;
    this.maxSize = '100m';
    this.maxFiles = '14d';

    const defaultFormatter = winston.format.combine(
      winston.format(info => {
        info.hostname = hostname();
        info.pid = process.pid;
        info.level = info.level.toUpperCase();
        return info;
      })(),
      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss,SSSS' }),
      winston.format.ms(),
    );

    if (options.json) {
      // 输出json格式
      this.format = winston.format.combine(
        defaultFormatter,
        winston.format.json(options.formatter),
      );
    } else {
      this.format = winston.format.combine(
        defaultFormatter,
        winston.format.printf(options.formatter),
      );
    }
  }
}

const options = {
  name: 'app',
  module: 'app',
  filePath: './logs',
  formatter: meta => {
    return `${meta.timestamp} ${meta.level} ${meta.hostname} ${meta.pid} (${meta.ms}) [${
      meta.module
    }] ${meta.message}`;
  },
  consoleLevel: 'error',
  json: false,
};

const consoleTransport = new ConsoleTransport({
  level: options.consoleLevel,
  name: options.name,
  formatter: options.consoleFormatter,
});

const infoTransport = new FileTransport({
  level: 'info',
  name: options.name,
  filename: join(options.filePath, `info/${options.name}-info-%DATE%.log`),
  formatter: options.formatter,
  json: options.json,
});

const errorTransport = new FileTransport({
  level: 'error',
  name: options.name,
  filename: join(options.filePath, 'error/error-%DATE%.log'),
  formatter: options.formatter,
  json: options.json,
});

const transports = [consoleTransport, infoTransport, errorTransport];
const logger = winston.createLogger({ transports });

logger.info('log1');
logger.error('error 1');

const sequelize = new Sequelize(config.database, config.username, config.password, {
  host: config.host,
  port: config.port,
  dialect: 'mysql',
  pool: {
    max: 5,
    min: 0,
    idle: 10000,
  },
  timezone: '+08:00',
});

// new操作符创建对象
let person1 = new Object();
person.name = 'Zubin';
person.age = 18;

// 字面量表示法
let person2 = {
  name: 'Zubin',
  age: 18,
};

var today = new Date();
var today = new Date(1453094034000); // by timestamp(accurate to the milliseconds)
var birthday = new Date('December 17, 1995 03:24:00');
var birthday = new Date('1995-12-17T03:24:00');
var birthday = new Date(1995, 11, 17);
var birthday = new Date(1995, 11, 17, 3, 24, 0);

var unixTimestamp = Date.now(); // in milliseconds

var regex1 = /\w+/;
var regex2 = new RegExp('\\w+');

console.log(regex1);
// expected output: /\w+/

console.log(regex2);
// expected output: /\w+/

console.log(regex1 === regex2);
// expected output: false

var sum = new Function('a', 'b', 'return a + b');

console.log(sum(2, 6));
// expected output: 8

let a = new String('abc');
typeof a; // 是"object"，不是"String"
a instanceof String; // true
Object.prototype.toString.call(a); // "[object String]"

Object.prototype.toString.call([1, 2, 3]); // "[object Array]"
Object.prototype.toString.call(/regex-literal/i); // "[object RegExp]"

Object.prototype.toString.call(null); // "[object Null]"
Object.prototype.toString.call(undefined); // "[object Undefined]"

Object.prototype.toString.call('abc'); // "[object String]"
Object.prototype.toString.call(42); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"

var a = 'abc';

a.length; // 3
a.toUpperCase(); // "ABC"

var b = new Boolean(false);
if (!b) {
  console.log('Oops'); // 执行不到这里
}

var a = new String('abc');
var b = new Number(42);
var c = new Boolean(true);

a.valueOf(); // "abc"
b.valueOf(); // 42
c.valueOf(); // true