const uuidv1 = require('uuid/v1');
uuidv1() //  ⇨ 43d7e120-f963-11e8-999e-51f3e5aa256f

const formatedUUID = uuidv1().replace(/-/g, ''); // 去除横线-

const uuidv3 = require('uuid/v3');

// ... using predefined DNS namespace (for domain names)
uuidv3('hello.example.com', uuidv3.DNS); // ⇨ '9125a8dc-52ee-365b-a5aa-81b0b3681cf6'

// ... using predefined URL namespace (for, well, URLs)
uuidv3('http://example.com/hello', uuidv3.URL); // ⇨ 'c6235813-3ba4-3801-ae84-e0a6ebb7d138'

// ... using a custom namespace
//
// Note: Custom namespaces should be a UUID string specific to your application!
// E.g. the one here was generated using this modules `uuid` CLI.
const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
uuidv3('Hello, World!', MY_NAMESPACE); // ⇨ 'e8b5a51d-11c8-3310-a6ab-367563f20686'

const uuidv4 = require('uuid/v4');
uuidv4(); // ⇨ 57751a52-db27-4b2f-8a08-7e02f9e94a42

const uuidv5 = require('uuid/v5');

// ... using predefined DNS namespace (for domain names)
uuidv5('hello.example.com', uuidv5.DNS); // ⇨ 'fdda765f-fc57-5604-a269-52a7df8164ec'

// ... using predefined URL namespace (for, well, URLs)
uuidv5('http://example.com/hello', uuidv5.URL); // ⇨ '3bbcee75-cecc-5b56-8031-b6641c1ed1f1'

// ... using a custom namespace
//
// Note: Custom namespaces should be a UUID string specific to your application!
// E.g. the one here was generated using this modules `uuid` CLI.
const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
uuidv5('Hello, World!', MY_NAMESPACE); // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681'

{
  "presets": [],
  "plugins": []
}

{
  "presets": [
    "es2015",
    "react",
    "stage-2"
  ],
  "plugins": []
}

{
  "name": "6-babel",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "babel src -d lib"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "babel-cli": "^6.26.0",
    "babel-preset-es2015": "^6.24.1"
  }
}

$ babel-node
> (x => x * 2)(1)
2

{
  "scripts": {
    "script-name": "babel-node script.js"
  }
}

<script src="node_modules/babel-core/browser.js"></script>
<script type="text/babel">
// Your ES6 code
</script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.4.4/babel.min.js"></script>
<script type="text/babel">
// Your ES6 code
</script>
注意，网页中实时将ES6代码转为ES5，对性能会有影响。生产环境需要加载已经转码完成的脚本。

{
  "browserify": {
    "transform": [["babelify", { "presets": ["es2015"] }]]
  }
}

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;
    @Column()
    firstName: string;
    @Column()
    lastName: string;
    @Column()
    age: number;
}

createConnection({
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "root",
    password: "admin",
    database: "test",
    entities: [
        Photo//引用目录下的所有实体__dirname + "/entity/*.js"
    ],
    synchronize: true,
    logging: false
}).then(connection => {
    // 这里可以写实体操作相关的代码 
}).catch(error => console.log(error));

{
   "name": "default",
   "type": "mysql",
   "host": "172.16.3.34",
   "port": 3306,
   "username": "root",
   "password": "root",
   "database": "sonar",
   "synchronize": true,
   "logging": false,
   "cache": true,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.{ts,js}"
   ],
   "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
   }
}

import "reflect-metadata";
import {createConnection} from "typeorm";
import {User} from "./entity/User";
createConnection().then(async connection => {
    // 这里可以写实体操作相关的代码
    const users = await connection.manager.find(User);
    console.log("Loaded users: ", users);

}).catch(error => console.log(error));

import {Entity, PrimaryGeneratedColumn, Column, BaseEntity} from "typeorm";

@Entity("user")
export class Person extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number;
    @Column()
    firstName: string;
    @Column()
    lastName: string;
    @Column()
    age: number;
}

import "reflect-metadata";
import {createConnection} from "typeorm";
import {Person} from "./entity/Person";
createConnection().then(async connection => {
    console.log("Loaded users: ", await Person.findOne(2));
    process.exit();
}).catch(error => console.log(error));

const users = await connection
    .createQueryBuilder(User, "user")
    .where("user.isAdmin = :isAdmin", { isAdmin: true })
    .cache(true)
    .getMany();


const users = await connection
    .getRepository(User)
    .find({
        where: { isAdmin: true },
        cache: true
    });


const users = await connection
    .createQueryBuilder(User, "user")
    .where("user.isAdmin = :isAdmin", { isAdmin: true })
    .cache(60000) // 设置缓存时间 1 minute
    .getMany();

//设置缓存时间
{
    cache: {
        duration: 30000 // 30 seconds
    }
}

const users = await connection
    .createQueryBuilder(User, "user")
    .where("user.isAdmin = :isAdmin", { isAdmin: true })
    .cache("users_admins", 25000)//缓存名称和时间
    .getMany();

{
    type: "mysql",
    host: "localhost",
    ...
    cache: {
        type: "redis",
        options: {
            host: "localhost",
            port: 6379
        }
    }
}

//主键自动生成列类型，主要为整型、小数等数值类型
export type PrimaryGeneratedColumnType = "int" // mysql, mssql, oracle, sqlite
    |"int2" // postgres, sqlite
    |"int2" // postgres, sqlite
    |"int4" // postgres
    |"int8" // postgres, sqlite
    |"integer" // postgres, oracle, sqlite
    |"tinyint" // mysql, mssql, sqlite
    |"smallint" // mysql, postgres, mssql, oracle, sqlite
    |"mediumint" // mysql, sqlite
    |"bigint" // mysql, postgres, mssql, sqlite
    |"dec" // oracle, mssql
    |"decimal" // mysql, postgres, mssql, sqlite
    |"numeric" // postgres, mssql, sqlite
    |"number"; // oracle
 
//带有精度的列类型，主要为各种浮点数、小数类型
export type WithPrecisionColumnType = "float" // mysql, mssql, oracle, sqlite
    |"double" // mysql, sqlite
    |"dec" // oracle, mssql
    |"decimal" // mysql, postgres, mssql, sqlite
    |"numeric" // postgres, mssql, sqlite
    |"real" // mysql, postgres, mssql, oracle, sqlite
    |"double precision" // postgres, oracle, sqlite
    |"number" // oracle
    |"datetime" // mssql, mysql, sqlite
    |"datetime2" // mssql
    |"datetimeoffset" // mssql
    |"time" // mysql, postgres, mssql
    |"time with time zone" // postgres
    |"time without time zone" // postgres
    |"timestamp" // mysql, postgres, mssql, oracle
    |"timestamp without time zone" // postgres
    |"timestamp with time zone"; // postgres, oracle
 
//带有长度的列类型，
export type WithLengthColumnType = "int" // mysql, postgres, mssql, oracle, sqlite
    |"tinyint" // mysql, mssql, sqlite
    |"smallint" // mysql, postgres, mssql, oracle, sqlite
    |"mediumint" // mysql, sqlite
    |"bigint" // mysql, postgres, mssql, sqlite
    |"character varying" // postgres
    |"varying character" // sqlite
    |"nvarchar" // mssql
    |"character" // mysql, postgres, sqlite
    |"native character" // sqlite
    |"varchar" // mysql, postgres, mssql, sqlite
    |"char" // mysql, postgres, mssql, oracle
    |"nchar" // mssql, oracle, sqlite
    |"varchar2" // oracle
    |"nvarchar2" // oracle, sqlite
    |"binary" // mssql
    |"varbinary"; // mssql
 
//简单列类型
export type SimpleColumnType =
    //简单数组，为typeorm特有，对饮数据库中string类型
    "simple-array" // typeorm-specific, automatically mapped to string
    //string类型，对应数据库中varchar类型
    |"string" // typeorm-specific, automatically mapped to varchar depend on platform
    //数值类型
    |"bit" // mssql
    |"int2" // postgres, sqlite
    |"integer" // postgres, oracle, sqlite
    |"int4" // postgres
    |"int8" // postgres, sqlite
    |"unsigned big int" // sqlite
    |"float4" // postgres
    |"float8" // postgres
    |"smallmoney" // mssql
    |"money" // postgres, mssql
 
    //boolean类型
    |"boolean" // postgres, sqlite
    |"bool" // postgres
 
    //二进制、文本类型
    |"tinyblob" // mysql
    |"tinytext" // mysql
    |"mediumblob" // mysql
    |"mediumtext" // mysql
    |"blob" // mysql, oracle, sqlite
    |"text" // mysql, postgres, mssql, sqlite
    |"ntext" // mssql
    |"citext" // postgres
    |"longblob" // mysql
    |"longtext" // mysql
    |"bytea" // postgres
    |"long" // oracle
    |"raw" // oracle
    |"long raw" // oracle
    |"bfile" // oracle
    |"clob" // oracle, sqlite
    |"nclob" // oracle
    |"image" // mssql
 
    //日期类型
    |"timestamp with local time zone" // oracle
    |"smalldatetime" // mssql
    |"date" // mysql, postgres, mssql, oracle, sqlite
    |"interval year" // oracle
    |"interval day" // oracle
    |"interval" // postgres
    |"year" // mysql
 
    //几何类型，只有postgres支持
    |"point" // postgres
    |"line" // postgres
    |"lseg" // postgres
    |"box" // postgres
    |"circle" // postgres
    |"path" // postgres
    |"polygon" // postgres
 
    // other types
    |"enum" // mysql, postgres
    |"cidr" // postgres
    |"inet" // postgres
    |"macaddr"// postgres
    |"bit" // postgres
    |"bit varying" // postgres
    |"varbit"// postgres
    |"tsvector" // postgres
    |"tsquery" // postgres
    |"uuid" // postgres
    |"xml" // mssql, postgres
    |"json" // mysql, postgres
    |"jsonb" // postgres
    |"varbinary" // mssql
    |"cursor" // mssql
    |"hierarchyid" // mssql
    |"sql_variant" // mssql
    |"table" // mssql
    |"rowid" // oracle
    |"urowid" // oracle
    |"uniqueidentifier"; // mssql
 
//列数据类型，为联合类型，各个类型之间可能有重复
export type ColumnType = 
    //带有精度类型
    WithPrecisionColumnType
    //带有长度类型
    |WithLengthColumnType
    //简单类型
    |SimpleColumnType
    //boolean类型
    |BooleanConstructor
    //Date类型
    |DateConstructor
    //数字类型
    |NumberConstructor
    //字符串类型
    |StringConstructor;

'use strict';
const mysql=require('mysql');
module.exports = {
    config: {
        host: '210.14.139.118',
        port: 44257,
        database: 'jk_newcenter',
        user: 'jk_newcenter',
        password: 'aMF3va%d$cc'
    },
    connection: null,
    //创建连接池并连接
    openConnection: function (callback) {
        this.connection = mysql.createConnection(this.config);
    },
    closeConnection: function () {
        var me = this;
        me.connection.end(function (err) {
            console.log(err);
        });
    },

    execute: function (config) {
        const me = this;
        this.openConnection();
        me.connection.query(config.sql, config.params, function (err, res) {
            if (err) {
                console.log(err);
            } else if (config.callback) {
                config.callback(res);
            }
            // 关闭数据库连接
            me.closeConnection();
        });
    }
};

import * as mysql from "mysql";

const mysqlPool = mysql.createPool({
    host: "172.16.3.34",
    user: "root",
    password: "root",
    port: 3306,
    database: "sonar",
    connectionLimit: 10000
});

const timeout = 4000;

export interface ISqlResults {
    results: Array<any>;
    fields: Object;
}

interface IQueryObject {
    [name: string]: string | number
}

// 实现增删改查基本方法
export const sqlQuery = (sql: mysql.QueryOptions) => new Promise((resolve, reject) =>
    mysqlPool.query(sql, (err, results, fields) => err ? reject(err) : resolve(<ISqlResults>{results, fields}))
);

export const and = (dataObject: IQueryObject) => {
    let queryString = "";
    Object.keys(dataObject).forEach(key => {
        queryString += mysql.escape(key) + "=" + dataObject[key] + " and "
    });
    return queryString.replace(/\sand\s$/, "")
};

export const tableQuery = (table: string, condition: IQueryObject | string) => sqlQuery({
    sql: typeof condition === "string" ?
        mysql.format("select * from ?? where ??", [table, condition]) :
        mysql.format("select * from ?? where ?", [table, condition]),
    timeout
});


export const insertTable = (table: string, data: IQueryObject | Array<string | number>) => sqlQuery({
    sql: Array.isArray(data) ?
        mysql.format("insert into ?? values(??)", [table, (<Array<string | number>>data).join(", ")]) :
        mysql.format("insert into ?? set ?", [table, data]),
    timeout
});

export const updateTable = (table: string, update: IQueryObject, condition: IQueryObject | string) => sqlQuery({
    sql: typeof condition === "string" ?
        mysql.format("update ?? set ? where ??", [table, update, condition]) :
        mysql.format("update ?? set ? where ?", [table, update, condition]),
    timeout
});

export const deleteRow = (table: string, condition: IQueryObject | string) => sqlQuery({
    sql: typeof condition === "string" ?
        mysql.format("delete from ?? where ??", [table, condition]) :
        mysql.format("delete from ?? where ?", [table, condition]),
    timeout
});

export default mysqlPool;

import { sqlQuery, insertTable, deleteRow, tableQuery, updateTable, ISqlResults } from "./connection";
import { format } from "mysql";

export interface IField {
    [name: string]: string | number
}

export interface IError {
    err: boolean;
    message?: string;
}

export interface IORM<TableType, TableTypeRest> {
    fieldMap: IField;
    map: IField;
    table: string;
    defaultValue: TableType;

    fetchAll (condition: TableTypeRest | string): Promise<Array<TableType>>;

    fetch (query: TableTypeRest | string): Promise<TableType>;

    insert (data: TableType): Promise<IError>;

    update (data: TableTypeRest, condition: TableTypeRest | string): Promise<IError>;

    delete (condition: TableTypeRest | string): Promise<IError>;
}

//ORM framework
export default class MyOrm<Type, TypeRest> implements IORM<Type, TypeRest> {
    public fieldMap: IField;
    public map: IField;
    public table: string;
    public defaultValue: Type;

    public async delete (condition: TypeRest | string): Promise<IError> {
        const dbCondition: IField | string = typeof condition === "string" ? condition :
            Object.keys(condition).reduce((acc, curKey) => {acc[this.fieldMap[curKey]] = condition[curKey];
                return acc;
            }, {});
        const { results, fields } = <ISqlResults>await deleteRow(this.table, dbCondition);
        return results ? <IError>{ err: false } :
            <IError>{
                err: true,
                message: "you have err on delete from " + this.table
            };
    }

    public async fetch (query: TypeRest | string): Promise<Type> {
        const dbQuery: IField = typeof query === "string" ? query :
            Object.keys(query).reduce((acc, curKey) => {
                acc[this.fieldMap[curKey]] = query[curKey];
                return acc;
            }, {});
        let { results, fields } = <ISqlResults>await tableQuery(this.table, dbQuery);

        results.length || (results = [{}]);
        Array.isArray(results) && (results = results[0]);
        return <Type>Object.keys(results).reduce((acc, curKey) => {
            acc[this.map[curKey]] = results[curKey];
            return acc
        }, {});
    }

    public async fetchAll (condition?: TypeRest | string): Promise<Array<Type>> {

        const { results, fields } = <ISqlResults>await sqlQuery({
            sql: !condition ? format("select * from ??", [this.table]) :
                typeof condition === "string" ?
                    format("select * from ?? where ??", [this.table, condition]) :
                    format("select * from ?? where ?", [this.table, condition]),
            timeout: 2000
        });

        return <Array<Type>>results.map(value => Object.keys(value).reduce((acc, curKey) => {
            acc[this.map[curKey]] = value[curKey];
            return acc;
        }, {}));
    }

    public async insert (data: Type): Promise<IError> {
        const dbData: IField = Object.keys(data).reduce((acc, curKey) => {
            acc[this.fieldMap[curKey]] = data[curKey];
            return acc;
        }, {});
        const { results } = <ISqlResults>await insertTable(this.table, dbData);
        return results ? <IError>{ err: false } : <IError>{ err: true, message: "you have some error in insert data" };
    }

    public async update (data: TypeRest, condition: TypeRest | string): Promise<IError> {
        const dbData: IField = Object.keys(data).reduce((acc, curKey) => {
            acc[this.fieldMap[curKey]] = data[curKey];
            return acc;
        }, {});
        const dbCondition: IField | string = typeof condition === "string" ? condition : Object.keys(condition).reduce((acc, curKey) => {
            acc[this.fieldMap[curKey]] = condition[curKey];
            return acc;
        }, {});
        console.log(dbData,dbCondition);
        const { results } = <ISqlResults>await updateTable(this.table, dbData, dbCondition);
        return results ? <IError>{ err: false } : { err: true, message: "you have message in update" };
    }
}

import ORM from "./MyOrm";

export interface IUserType {
    readonly id: number;
    readonly firstName: string;
    readonly lastName: string;
    readonly age: number;
}

export interface IUserTypeRest {
    readonly id?: number;
    readonly firstName?: string;
    readonly lastName?: string;
    readonly age?: number;
}
// 只需要继承ORM类即可
export default class User extends ORM<IUserType, IUserTypeRest> {
    // 类属性与数据库列字段的映射
    public fieldMap = {
        id: "id",
        firstName: "firstName",
        lastName: "lastName",
        age: "age"
    };
    // 默认值
    public defaultValue: IUserType = {
        id: 0,
        firstName: "",
        lastName: "",
        age: 0
    };
    public table: string = "user"; // 指定数据库表名

    public map = Object.keys(this.fieldMap).reduce((acc, curKey) => {
        acc[this.fieldMap[curKey]] = curKey;
        return acc;
    }, {});
}

import User, {IUserType} from "./User";

const user = new User();

async function main() {
    const user = new User();
    /*await user.insert(<IUserType>{
        id: 10,
        firstName: "hu",
        lastName: "hu",
        age: 20
    });*/
    const data = await user.fetchAll();
    console.log(data)
}
main();

const fs = require('fs');

const readFile = function (fileName) {
  return new Promise(function (resolve, reject) {
    fs.readFile(fileName, function(error, data) {
      if (error) return reject(error);
      resolve(data);
    });
  });
};

const gen = function* () {
  const f1 = yield readFile('/etc/fstab');
  const f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

const asyncReadFile = async function () {
  const f1 = await readFile('/etc/fstab');
  const f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

function timeout(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

async function asyncPrint(value, ms) {
  await timeout(ms);
  console.log(value);
}

asyncPrint('hello world', 50);

// 函数声明
async function foo() {}

// 函数表达式
const foo = async function () {};

// 对象的方法
let obj = { async foo() {} };
obj.foo().then(...)

// Class 的方法
class Storage {
  constructor() {
    this.cachePromise = caches.open('avatars');
  }

  async getAvatar(name) {
    const cache = await this.cachePromise;
    return cache.match(`/avatars/${name}.jpg`);
  }
}

const storage = new Storage();
storage.getAvatar('jake').then(…);

// 箭头函数
const foo = async () => {};

async function getTitle(url) {
    let response = await fetch(url);
    let html = await response.text();
    return html.match(/<title>([\s\S]+)<\/title>/i)[1];
}

getTitle('www.baidu.com').then(console.log);

async function f() {
  // 等同于
  // return 123;
  return await 123;
}

f().then(v => console.log(v))
// 123

class Sleep {
    constructor(timeout) {
        this.timeout = timeout;
    }
    then(resolve, reject) {
        const startTime = Date.now();
        setTimeout(
            () => resolve(Date.now() - startTime),
            this.timeout
        );
    }
}

/**
 * await命令后面是一个Sleep对象的实例。这个实例不是 Promise 对象，但是因为定义了then方法，await会将其视为Promise处理。
 */
(async () => {
    const sleepTime = await new Sleep(1000);
    console.log(sleepTime);
})();

//JavaScript 一直没有休眠的语法，但是借助await命令就可以让程序停顿指定的时间。
function sleep(interval) {
    return new Promise(resolve => {
        setTimeout(resolve, interval);
    })
}

// 用法
async function one2FiveInAsync() {
    for(let i = 1; i <= 5; i++) {
        console.log(i);
        await sleep(1000);
    }
}

one2FiveInAsync();

async function f() {
  await Promise.reject('出错了');
  await Promise.resolve('hello world'); // 不会执行
}

async function f() {
  try {
    await Promise.reject('出错了');
  } catch(e) {
  }
  return await Promise.resolve('hello world');
}

f()
.then(v => console.log(v))
// hello world



//或
async function f() {
  await Promise.reject('出错了')
    .catch(e => console.log(e));
  return await Promise.resolve('hello world');
}

f()
.then(v => console.log(v))
// 出错了
// hello world

function* helloWorldGenerator() {
    yield 'hello';
    yield 'world';
    return 'ending';
}

var hw = helloWorldGenerator();

console.log(hw.next());

hw.next()
// { value: 'hello', done: false }

hw.next()
// { value: 'world', done: false }

hw.next()
// { value: 'ending', done: true }

hw.next()
// { value: undefined, done: true }

var myIterable = {};
myIterable[Symbol.iterator] = function* () {
  yield 1;
  yield 2;
  yield 3;
};

[...myIterable] // [1, 2, 3]

function* f() {
  for(var i = 0; true; i++) {
    var reset = yield i;
    if(reset) { i = -1; }
  }
}

var g = f();

g.next() // { value: 0, done: false }
g.next() // { value: 1, done: false }
g.next(true) // { value: 0, done: false }

//通过next方法的参数，向 Generator 函数内部输入值的例子。
function* dataConsumer() {
  console.log('Started');
  console.log(`1. ${yield}`);
  console.log(`2. ${yield}`);
  return 'result';
}

let genObj = dataConsumer();
genObj.next();
// Started
genObj.next('a')
// 1. a
genObj.next('b')
// 2. b

function wrapper(generatorFunction) {
  return function (...args) {
    let generatorObject = generatorFunction(...args);
    generatorObject.next();
    return generatorObject;
  };
}

const wrapped = wrapper(function* () {
  console.log(`First input: ${yield}`);
  return 'DONE';
});

wrapped().next('hello!')
// First input: hello!

function* foo() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
  return 6;
}

for (let v of foo()) {
  console.log(v);
}
// 1 2 3 4 5

function* fibonacci() {
  let [prev, curr] = [0, 1];
  for (;;) {
    yield curr;
    [prev, curr] = [curr, prev + curr];
  }
}

for (let n of fibonacci()) {
  if (n > 1000) break;
  console.log(n);
}

function* foo() {
  yield 'a';
  yield 'b';
}

function* bar() {
  yield 'x';
  // 手动遍历 foo()
  for (let i of foo()) {
    console.log(i);
  }
  yield 'y';
}

for (let v of bar()){
  console.log(v);
}
// x
// a
// b
// y

function* bar() {
  yield 'x';
  yield* foo();
  yield 'y';
}

// 等同于
function* bar() {
  yield 'x';
  yield 'a';
  yield 'b';
  yield 'y';
}

// 等同于
function* bar() {
  yield 'x';
  for (let v of foo()) {
    yield v;
  }
  yield 'y';
}

for (let v of bar()){
  console.log(v);
}
// "x"
// "a"
// "b"
// "y"