let num = 10;
let num2 = ~num;

// ~num 效果同下
num2 = -num - 1;

console.log(num2); // -11

let num = 2;
let num2 = num << 2;

// 效果同下
 num2 = num * 4;

console.log(num2); // 8

let num = 12;
let num2 = num >> 2;

// 效果同下
num2 = num / 4;

console.log(num2) // 3

var arr = base64.split(','), mime = arr[0].match(/:(.*?);/)[1],
               bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
                while (n--) {
                    // charCodeAt() 方法可返回指定位置的字符的 Unicode 编码
                    u8arr[n] = bstr.charCodeAt(n);
                }
                // 'application/octet-binary' (默认值)
                let blob = new Blob([u8arr], { type: mime })

atob("amF2YXNjcmlwdA==")
// 解码结果 "javascript"

window.btoa(javascript)
// 转码结果 "amF2YXNjcmlwdA=="

var str = "China，**";

// 先用 encodeURI() 编码
window.btoa(window.encodeURIComponent(str))
// "Q2hpbmElRUYlQkMlOEMlRTQlQjglQUQlRTUlOUIlQkQ="

// atob 解码 Base64 再用 decodeURI() 解码
window.decodeURIComponent(window.atob('Q2hpbmElRUYlQkMlOEMlRTQlQjglQUQlRTUlOUIlQkQ='))
// "China，**"

var array = [11, 65, 23, 108, 99, 11, 55, 11, 33, 100, 108, 100];

console.time('快排');
const quickSort = array => {
    // 数组只剩一个元素时停止
    if (array.length <= 1) return array;
    // 取参照物
    let pivotIndex = Math.floor(array.length / 2),
        // 这里用splice删除参照物避免重复循环
        pivot = array.splice(pivotIndex, 1),
        leftArr = [],
        rightArr = [];
    // 分区
    for (let i = 0; i < array.length; i++) {
        if (array[i] < pivot) {
            leftArr.push(array[i]);
        } else {
            rightArr.push(array[i]);
        }
    }
    return quickSort(leftArr).concat(pivot, quickSort(rightArr));
}
console.log(quickSort(array)); // [ 11, 11, 11, 23, 33, 55, 65, 99, 100, 100, 108, 108 ]

console.timeEnd('快排'); // 4ms 左右

console.time('快排2');
// 互换
const swap = (items, firstIndex, secondIndex) => {
    let temp = items[firstIndex];
    items[firstIndex] = items[secondIndex];
    items[secondIndex] = temp;
}
// 分区
const partition = (items, left, right) => {
    let pivot = items[Math.floor((right + left) / 2)],
        i = left,
        j = right;

    while (i <= j) {
        while (items[i] < pivot) {
            i++;
        }
        while (items[j] > pivot) {
            j--;
        }
        if (i <= j) {
            swap(items, i, j);
            i++;
            j--;
        }
    }
    return i;
}
// 排序
const quickSortTwo = (items, left, right) => {
    let index;
    if (items.length > 1) {
        left = typeof left != "number" ? 0 : left;
        right = typeof right != "number" ? items.length - 1 : right;

        index = partition(items, left, right);

        if (left < index - 1) {
            quickSortTwo(items, left, index - 1);
        }

        if (index < right) {
            quickSortTwo(items, index, right);
        }
    }
    return items;
}

console.log(quickSortTwo(array));
console.timeEnd('快排2');

console.time('原生');
array.sort((a, b) => {
    if (a > b) return 1
    else if (a < b) return -1
    else return 0
});
console.log(array);
// 5ms 左右
console.timeEnd('原生')

使用函数和闭包来构造模块. 模块是一个提供接口却隐藏状态与现实的函数或对象.

const serial_maker = _ => {
	// 私有变量
	let prefix = '';
	let num = 0;

	return {
		// 特权方法
		set_prefix: str => {
			prefix = String(str);
		},
		set_num: n => {
			num = +n;
		},
		get_sum: _ => {
			let result = prefix + num;
			num++;
			return result;
		}
	}
}

let seqer = serial_maker();
seqer.set_prefix('Hi');
seqer.set_num(0101);

console.log(seqer.get_sum()) // 'Hi0101'

var math = require('math');

math.add(2, 3);

require([module], callback);

require(['module'], module => {
	module.increment(1, 2)
}) 

// types.js
export const foo = 'foo';

export const fn = n => n+1;

// 在 index.html 引入
import {foo, fn} from 'types.js'

// types.js
export default const foo = 'foo';

// 在 index.html 引入
import foo from 'types.js'
// 等价于
import {default as foo} from 'types.js'

 class Foo {
    constructor ( count ) {
        this.cash = count;
        this.myCash = !!count;
    }
}
var emptyFoo = new Foo(0);
console.log(foo.cash); // 0
console.log(foo.myCash); // false

var foo = new Foo(100);
console.log(foo.cash); // 100
console.log(foo.myCash); // true

var toNumber = strNumber => {
    return +strNumber;
}
console.log( toNumber("123") ); // 123
console.log( toNumber(" abc")); // NaN

// Date也可以使用
console.log( +new Date() ); // 返回时间戳

if (isConcat) {
    Login()
}

var arr = [1,2,3,4,5];
console.log( arr.slice(-1) ); // [5]
conosle.log( arr.slice(-2) ); // [4,5]
以此类推

var arr = [1,2,3,4,5];
console.log( arr.length); // 5
arr.length = 3;
console.log( arr.length ); // 3
console.log( arr ); // [1,2,3]

var els = document.querySelectorAll( 'p' );
[].slice.call( els );
OR:
var arrElement = Array.from( els );
ES6:
var arr = [...els]

var list = [1,2,3];
console.log(list.sort(()=>{ Math.random() - 0.5}))

if ( child == null || child.length == 0 ){
        // 省市区只有三级
        // area-code 是当前选中的地区编码
	var length = area-code.length / 2;
       // 现有城市数组
	var array = areaList;
	for ( var i = 0 ; i < length ; i++ ){
		for ( el of array ){
			if ( el.area-code == area-code.substr(i*2,2) ){
				if ( i == length - 1 ){
					delete el.children
					return;
				}else{
					array = el.children;
					break;
				}
			}
		}
	}
}

 var rtsp = require('rtsp-ffmpeg');
 // 推流
 var uri = 'rtsp://accout:password@ip:port/h264/ch1/main/av_stream',
     stream = new rtsp.FFMpeg({
         input: uri,
         rate: 10,
         resolution: '320x240',
         quality: 3
     });

 var cameraInfo = {}
 io.on('connection', socket => {
     console.log('connection')
     var pipeStream = function(data) {
         socket.emit('data', data);
     };
     stream.on('data', pipeStream);
     socket.on('URI', data => {
         console.log(data);
         cameraInfo.cameraName = data.cameraName;
         cameraInfo.groupName = data.groupName;
         uri = `rtsp://${data.userName}:${data.passWord}@${data.ip}:${data.RTSP}/h264/ch1/main/av_stream`;
         stream.input = uri;
         stream.restart();
         socket.emit('CameraInfo', cameraInfo);
     })
     socket.on('disconnect', function() {
         stream.removeListener('data', pipeStream);
     });
 })

    function shallowCopy ( parent ) {
        let o = {};
        for (let i in parent) {
             o[i] = parent[i]
        }
        return o
    }

    function deepCopy ( parent, child = {} ) {
        for ( let i in parent ) {
            if ( typeof parent[i] === 'object' ) {
                child[i] = ( parent[i].constructor == Array ) ? [] : {};
                deepCopy( parent[i], child[i])
             } else {
                 child[i] = parent[i]
             }
        }
    }

    var o = {
        age: '18',
        friends: ['老张', '老王'],
        job: {
           main: '睡觉',
           sub: '躺着'
        }
    };
    var result = JSON.parse( JSON.stringify(o));
    result.name = 'cara';
    result.friends.push('老李');
    console.dir(o);
    console.dir(result)

// 先扩展一个方法, 懒得每次打prototype
// 这个不是必须的
Function.prototype.method = (name, fn) => {
	this.prototype[name] = fn;
	return this	
}

// 语言精粹里的例子 (其实这一步就是在模仿 new 的实现)
Function.method('new', _ => {

	// 创建一个新对象, 它继承构造器函数的原型对象
	let that = Object.create(this.prototype);

	// 调用构造器函数, 将 this 绑定到新对象上
	let other = this.apply(that, arguments);

	return (typeof other === 'object' && other) || that
})

// 现在定义一个构造器
let Bar = name => {
	this.name = name;
}

// 扩展这个构造函数的原型
Bar.prototype.get_name = _ => this.name;
Bar.prototype.say = _ => this.saying || '';

// 然后构造一个实例
let myBar = new Bar('妲己');
console.log(myBar.get_name()) // 妲己

/**
 *  掩盖掉丑陋的 prototype
 */

// 借助一个辅助函数
Function.method('inherit', parent => {
	this.prototype = new parent();
	return this
})

// 重新定义一个构造函数
// 去继承上面的 Bar
let Foo = name => {
	this.saying = 'wow';
}
// 这里 inherit 和 method 都直接返回 this
// 所以可以采用联级
.inherit(Bar)
.method('noise', _ => {
	return this.name + this.say()
})

// 先构造一个基础对象
const baseObject = {
	name: 'base',
	get_name: _ => this.name
}

// 接下来构造定制化的对象
let myObj = Object.create(baseObject);
myObj.name = 'wow';
myObj.saying = 'Hi';
myObj.purr = n => {
	let str = '';
	for (let i = 0; i < n; i++) {
		if (s) {
			str += 'hello'
		}
		str += 'world'
	}
	return str
}

// spec 对象包含构造器所需要的所有信息
// my 对象允许其他构造器分享他们的私有属性
// 以便在我们的构造器中使用
let constructor = (spec, my) => {
	let that = {}; // 私有实例变量

	let my = my || {};
	
	// 扩展共享的变量和方法
	...

	that = 一个新对象

	// 给 that 添加特权方法 
	...

	// 返回这个对象
	return that
}

cosnt mammal = spec => {
	let that = {};

	that.get_name = _ => spec.name;
	that.says = _ => spec.saying || '';

	return that
}

let myMammal = mammal({name: 'Herb'});

let cat = spec =>{
	spec.saying = spec.saying || 'meow';
	// 继承
	let that = mammal(spec);
	
	that.purr = n => {
		let i, s = '';

		for (i = 0; i < n; i++) {
			if (s) {
				s += '-';	
			}
			s += 'r';
		}
		return s
	};
	that.get_name = _ => {
		return that.says() + ' ' + spec.name + ' ' + that.says();
	}

	return that
}

let myCat = car({name: 'Henrietta'});

// 构造器
const mammal = spec => {
	let that = {};

	that.get_name = _ => spec.name;
	that.says = _ => spec.saying || 'Hi';

	return that
}

let myMammal = mammal({name: 'Cara'});

console.log(myMammal.says()) // 'Hi'


// 构造器2
const cat = spec => {
	spec.saying = spec.saying || 'meow';

	// 此时 that 已经包含: get_name 和 says 方法
	let that = mammal(spec);

	that.purr = n => {
		let str = '';

		for (let i = 0; i < n; i++) {
			if (str) {
				str += '-';
			}
			str += 'r';
		}
		return str
	};
	that.get_name = n => {
		return n || "i dont't have name"
	};

	return that
}

let myCat = cat({name: 'Henrietta'});

// i dont't have name
console.log(myCat.get_name())

// 这个时候 cat 还不能访问父类方法的能力
// 所以超类 super 还是有必要的

// 先扩展两个方法
// 这个方法不能用箭头函数来定义, 否则 this 指向的window
// 这里 this 需要的是被调用的对象
Function.prototype.method =  function (name, fn) {
	this.prototype[name] = fn;
	return this
}

// 定义调用父类的函数
Object.method('superior', function (name) {
	var that = this,
        method = that[name];
    return n => {
    	// this cat function
    	console.log(n)
        return method.call(that, n);
    };
})

// 来试试调用父类
const coolCat = spec => {
	let that = cat(spec);
	let	super_get_name = that.superior('get_name');

	// n 给父类方法传参
	that.get_name = n => {
        return 'like ' + super_get_name.call(this, n) + ' baby';
    };

	return that
}

let myCoolCat = coolCat({name: 'Bix', saying: 'Hi'});

let name = myCoolCat.get_name('this cat function');

console.log(name) // like this cat function baby

let arr = [1, 2, 3];
let arr2 = [4, 5, 6];
let result = arr.concat(arr2, 'wow');

console.log(result); // [1, 2, 3, 4, 5, 6, 'wow'];

let array = ["a", "b", "c"];
array.push("d");

let result = array("|");
console.log(result); // "a|b|c|d"

let arr = [1, 2, 3];
arr.pop()

console.log(arr); // 3

let array = [1, 2, 3];
let arr = [4, 5, 6];

let result = array.push(arr. 'Hi');
console.log(result); 
// array: [1, 2, 3, [4, 5, 6], 'Hi']
// result: 5

let array = [1, 2, 3];

let result = array.reverse();
console.log(result); // [3, 2, 1]

let array = [1, 2, 3];
let result = array.shift();

console.log(result); // 1

let array = [1, 2, 3];

let a  = array.slice(0, 1); // [1]
let b = array.slice(1); // [2, 3]
let c = array.slice(-1); // [3]

// 对字符串和数字排序
const compare = (a, b) => {
	if (a === b) {
		return 0
	}
	if (typeof a === typeof b) {
		return  a < b ? -1 : 1
	}
	return typeof a < typeof b ? -1 :1
}

let array = ['bb', 'aa', 2, 'cc', 3, 1, 7];

console.log(array.sort(compare())); // [ 1, 2, 3, 7, 'aa', 'bb', 'cc' ]

const by = name => {
	// o/p 每组相比较的数据
	return (o, p) => {
		let a, b;

		if(o && p && typeof o === 'object' && typeof p === 'object') {
			a = o[name];
			b = p[name];
			// 全等时
			if (a === b) {
				return 0
			}
			// 同类型
			if (typeof a === typeof b) {
				return a < b ? -1 : 1 
			}
			// 不同类型
			return typeof a < typeof b ? -1 : 1
		}else {
			console.log('排序失败')
		}
	}
}

let s = [
	{first: 'Joe', last: 'DeRita'},
	{first: 'Moe', last: 'Howard'},
	{first: 'Joe', last: 'Besser'},
	{first: 'Shemp', last: 'Howard'},
	{first: 'Larry', last: 'Fine'},
	{first: 'Curly', last: 'Howard'},
]

console.log(s.sort(by('first')).sort('last'));
/*
[ 
	{ first: 'Curly', last: 'Howard' },
	{ first: 'Joe', last: 'DeRita' },
	{ first: 'Joe', last: 'Besser' },
	{ first: 'Larry', last: 'Fine' },
	{ first: 'Moe', last: 'Howard' },
	{ first: 'Shemp', last: 'Howard' }  
]
 */

// 让函数接收两个参数, 当第一个函数相等时
// 由第二个参数再次比较, 第二个次要比较函数可选
const betterBy = (name, minor) => {
	return (o, p) => {
		let a, b;
		if (o && p && typeof o === 'object' && typeof 'object') {
			a = o[name];
			b = p[name];
			if (a === b) {
				// 用次要比较函数再次对比
				return typeof minor === 'function' ? minor(o, p) : 0
			}
			if (typeof a === typeof b) {
				return a < b ? -1 : 1
			}
			return typeof a < typeof b ? -1 : 1
		}else {
			console.log('排序失败');
		}
	}

}

let a = [
	{first: 'Joe', last: 'DeRita'},
	{first: 'Moe', last: 'Howard'},
	{first: 'Joe', last: 'Besser'},
	{first: 'Shemp', last: 'Howard'},
	{first: 'Larry', last: 'Fine'},
	{first: 'Curly', last: 'Howard'},
];

console.log(a.sort(by('last',by('first'))));
/*[ 
	{ first: 'Joe', last: 'Besser' },
	{ first: 'Joe', last: 'DeRita' },
	{ first: 'Larry', last: 'Fine' },
	{ first: 'Moe', last: 'Howard' },
	{ first: 'Shemp', last: 'Howard' },
	{ first: 'Curly', last: 'Howard' } 
]
 */

let arr = ['b', 'a', 'c', 'bug'];
let remove = arr.splice(1, 1, 'newItem', 'Hi');

console.log(arr); // ['b', 'newItem', 'Hi','c', 'bug']
console.log(remove); // ['a']

let arr = ['a', 'b', 'c'];
let insert = arr.unshift('Hi', 'd');

console.log(arr); // ['Hi', 'd', 'a', 'b', 'c']
console.log(insert); // 5

let b = /&.+/.test('frank & beans');

console.log(b); // true

let name = 'Cara';
let initial = name.charAt(0);

console.log(initial); // 'C'

let text = 'Mississippi';
let p = text.indexOf('ss'); // 2
p = text.indexOf('ss', 3); // 5

let text = 'Mississippi';
let p = text.lastIndexOf('ss'); // 5
p = text.lastIndexOf('ss', 3); // 2
p = text.lastIndexOf('ss', 6); // 5

let str = '1-10-1001';
let reg = /-(\d+)-/;

str.replace(reg, '栋$1单元');
console.log(str); // 1栋10单元1001

// str.length == 39
let str = 'and in it he says "Any damn fool could';
let a = str.slice(0, 3); // 'and'
let b = str.slice(-5); // 'could'

let str = '0123456789';
let a = str.split('', 5);

console.log(a); // ['0', '1', '2', '3', '4']