console.log(this === window);//true  全等号还是返回true  
   this.name = "jhon";
   console.log(window.name);//jhon
   window.age = 13 ;
   console.log(this.age);//13

var foo = "bar";
   console.log(this.foo);//bar
   console.log(window.foo);//bar

console.log(window.exp); //由于预解析  var exp ;会被提升到最上部，声明的对象未被定义的话，默认为undefined
if (exp in window){  //  返回true;
  //in  操作符，可以用来判断某个对象是否拥有某个属性，可以追溯对象所有的属性，包括原型上的;
        var exp = "example";//会进行预解析，声明exp属性给到window,解析到这一行代码的时候，会进行赋值
    //明确预解析:所谓预解析是浏览器的动作，它会在执行javascript代码之前，全局的检索javascript代码，将变量声明以及函数声明提升到函数的额最顶部，所以，变量声明提升的时候，相当于给window对象添加了一个属性
       console.log(window.exp);//example 
    }

if (exp in window){	//报错，程序停止运行
      exp = "example";//隐式全局变量，不会进行预解析，声明exp属性给到window
      console.log(exp);
  }

function test (){
      var obj = new Object();//实例化一个对象
      obj.foo = "bar";
      obj.func = function(){
          console.log("new的解析");
      }
      return obj;
  }

   function test (){
         this.foo = "bar is changed";
  		this.func = function(){
          	console.log("new的解析");
  		}
    }
var 
//1 方法new的瞬间 得到一个空的对象
var obj = { } ;
obj.__proto__ = test.prototype;
//2 方法的this指向空对象obj
//3 执行构造方法
{ }.foo = "bar is changed";
{ }.func = function(){
  	console.log("new的解析");
}
// 返回该对象
test.call(obj)

function test (name){
      this.name = name;
  }
  var obj1 = new test('Jhon');
  var obj2 = new test("Jhon");
  console.log(obj1.name);//Jhon
  console.log(obj2.name);//Jhon
  obj1.name = "kobe";
  console.log(obj1.name);//kobe
  console.log(obj2.name);//Jhon

var foo = "bar";
 console.log(this.foo);//bar
 var obj = {
     foo:"objBar",
     test:function (){
         return function(){
             console.log(this.foo);//bar   
         }
     }
 }
 obj.test()();//注意区分这两种情况:test()返回的是一个函数，函数直接在Window环境下执行

function fn1 (){
       console.log("fn1");
       console.log(this);
   }
   function fn2 (){
       console.log("fn2");
       console.log(this[2]);
   }
   var arr = [fn1,fn2,'things'];
   arr[0]();//fn1 [function, function, "things"]
   arr[1]();//fn2 things

function fn (){
      console.log(this.length);
  }
  var obj = {
      length : 10 ,
      method : function(f){
          console.log(this.length);//10
          console.log(arguments);
          arguments[0]();//1   this.length代表传入参数的个数
          arguments[0].call(this);//10
      }
  }
  obj.method(fn);

function fn() {
       'use strict';
       console.log(this);
   }
   fn(); //undefined //        fn是调用者，独立调用 
   window.fn();  //window  //  fn是调用者，被window所拥有

'use strict';
   var a = 20 ;
   function fn(){
       console.log(this.a);
   }
   fn();//报错

let {a,b};//报错
let [a,b];//报错

let [a,b,c] = [1,2,3] 
//等价于
let a = 1, b = 2 , c = 3 ;

let [a,b,c] = [1,2] 
console.log(c) ;//undefined

let [a,b,c] = [1,2,3,4]

let arr,first,second ;
arr = [first,second] = [1,2,3,4];
//arr // [1,2,3,4]
//first 1  second 2

let [a = 1 ,b=2 ,c] = [undefined,2222,3]; //右侧undefined不会赋值给a,右侧2222会赋值给b 
console.log(a);//1
console.log(b);//2222
console.log(c);//3

	let [a = b,b=5,c] = [1];
    console.log(a);//1
    console.log(b);//5
    console.log(c);//undefined
//等价于  let a = 1, b = 5 , c = undefined ;
//以下情况会报错
    let [a = b,b=5,c] = [];//直接报错
    console.log(a);//
    console.log(b);//
    console.log(c);//
//等价于 let a = b , b = 5 , c = undefined ;//let声明的变量使用之前必须先被声明
  --------------------------------------------
//        let a = b ;//b is not defined
//        let b = 5 ;
//        let c ;
    //对于let声明变量，变量的使用必须在声明之前才可以使用

var [a = b,b=5,c] = [];//这个不会报错，所以需要理解数据结构赋值的原理
    console.log(a);//undefined
    console.log(b);//5
    console.log(c);//undefined
//--------------------------------------------------
    //左边进行声明
//    var a = b ;//这个相当于对 b 进行了变量提升，但是没有运行到b=5的时候，a的值被赋予undefined;
//    var b = 5 ;
//    var c ;
//    console.log(a);//undefined
    //然后右边进行赋值,原来有默认值的不会发生变化
//    ------------------------------------------------------
//        var a = b ;//b is not defined
//
//        var c ;
//        console.log(a);//
//    ----------------------------------------------------------

//如果等号的右边不是数组或者严格地说，不是可遍历的结构，那么将会报错。如下
let [foo] = 1;
let [foo] = false;
let [foo] = NaN;
let [foo] = undefined;
let [foo] = null;
let [foo] = {};

let {foo,bar} = {foo:"aaa",bar:"bbb"};
let {bar,foo} = {foo:"aaa",bar:"bbb"};
//foo aaa
//bar bbb
//这点和数组的结构赋值不同，数组的结构赋值是按照元素的位置进行解构赋值，而对象的解构赋值是根据无序的属性名进行匹配，然后在进行赋值

let {baz} = {foo1:'aaa',foo2:'bbb'}
console.log(baz);//undefined

let {baz} = {}
console.log(baz);//undefined

let{foo} = {foo:'aaa',bar:'bbb'};
console.log(foo);//aaa

let{foo:baz} = {foo:'aaa',bar:'bbb'};//采用这种写法时，变量的声明和赋值是一体的
console.log(baz);//aaa
console.log(foo);//foo is not defined

let { foo,bar} = { foo: "aaa", bar: "bbb" };
let { foo: foo, bar: bar } = { foo: "aaa", bar: "bbb" };

({foo:baz} = {foo:'aaa'});
console.log(baz);//aaa

let{foo:baz} = {};
console.log(baz);//undefined
console.log(foo);//foo is not defined
//这个时候，我们应该能理解   let{foo:baz} 声明的变量是baz ,并不是foo,foo是匹配的模式，匹配的根据

console.log(name);//报错 name is not defined
let {heheh:name} = {heheh:'aaa'};
console.log(name);
//这个也证明了 let {heheh:name} 声明的是 : 后面的变量
//而let{foo ,bar } 其实是分为两步，第一对象的简洁写法{foo,bar} ==> {foo:foo,bar:bar}
//所以let声明的变量还是 : 冒号后面的变量，然后在进行解构赋值操作

console.log(name);//aaa
({heheh:name} = {heheh:'aaa'});
console.log(name);//aaa

({p:[x,{y:z}]} = {p:['hello',{}]} );
console.log(x);//hello
console.log(z);//undefined
console.log(y);//y is not defined
// p 和 y 都是匹配模式

let _temp = {bar:"baz"};
console.log(_temp.foo);//undefined
console.log(_temp.foo.anything);// Cannot read property 'anything' of undefined

let {foo:{bar:baz}} = {hehe:{bar:'value'}}
//上面代码中，等号左边对象的foo属性，对应一个子对象。该子对象的bar属性，解构时会报错。原因很简单，因为foo这时等于undefined，再取子属性就会报错，请看下面的代码

console.log(module);
console.log(module.exports);

Module {
  id: '.',
  exports: {},
  parent: null,  //
  filename: 'F:\\workspace\\01-node\\b.js', //代表文件的路径
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }
{}   //这个是module.exports  本身是一个空对象

var res = require('./b.js');
console.log(res);

Module {
  id: 'F:\\workspace\\01-node\\b.js',
  exports: {},
  parent:
   Module {
     id: '.',
     exports: {},
     parent: null,
     filename: 'F:\\workspace\\01-node\\a.js',
     loaded: false,
     children: [ [Circular] ],
     paths:
      [ 'F:\\workspace\\01-node\\node_modules',
        'F:\\workspace\\node_modules',
        'F:\\node_modules' ] },
  filename: 'F:\\workspace\\01-node\\b.js',
  loaded: false,
  children: [],        //被该模块引用的模块对象。
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }
{}   //以上是b.js输出
{}  //这个是a.js输出

module.exports = function(){
}
console.log(module.exports);

module.exports.prop = function(){}
console.log(module.exports);

{ prop: [Function] }

//sayHello.js
exports.sayhi = function(){ //exports对象可以定义sayhello.js将该模块的接口
    console.log("this is a module we made");
}

//main.js
var hello = require('./sayHello'); 
console.log(hello) ;//{ sayhi: [Function] }
hello.sayhi();

//square.js
module.exports = (width) => {
    return{
            area : () => width*width
    }
}

//main.js
const square = require('./square');  
console.log(square);//[Function]
var res = square(2);//{ area: [Function: area] }
console.log(res);
console.log(res.area());

const square = require('./square');
//可以理解为 
const square = (width) => {
    return{
            area : () => width*width
    }
}

//myevents.js
module.exports = function myEvents(){
    this.on = function(){
        console.log("通过on绑定事件");
    };
    this.emit = function(){
        console.log("通过emit触发事件");
    };
}

//main.js
const Event = require('./myevents');
console.log(Event);
var event = new Event();
console.log(event);
console.log(event.on);
console.log(event.emit);

const Event = require('./myevents');
//可以理解为 
const Event = function myEvents(){
    this.on = function(){
        console.log("通过on绑定事件");
    };
    this.emit = function(){
        console.log("通过emit触发事件");
    };
}

console.log(module);
exports.name = "Jhon";
//可以被导出到引用的模块
console.log(module);

Module {
  id: '.',
  exports: {},
  parent: null,
  filename: 'F:\\workspace\\01-node\\10b.js',
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }
Module {
  id: '.',
  exports: { name: 'Jhon' },
  parent: null,
  filename: 'F:\\workspace\\01-node\\10b.js',
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }

var res = require('./b.js');//可以得到 b 模块定义的数据  { name: 'Jhon' }

console.log(module);
exports = {name:"Jhon"};//此时exports不再和module.exports指向同一块内存地址，最后导出的module.exports 还是未初始化的时候的一个空对象
//不会导出到引用的模块，只在模块内有效
console.log(module);

Module {
  id: '.',
  exports: {},
  parent: null,
  filename: 'F:\\workspace\\01-node\\10b.js',
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }
Module {
  id: '.',
  exports: {},
  parent: null,
  filename: 'F:\\workspace\\01-node\\10b.js',
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }

var res = require('./b.js');//此时得到 b 模块到处的内容  为 { }

console.log(module);
module.exports = {name:"Jhon"};
console.log(module);

Module {
  id: '.',
  exports: {},
  parent: null,
  filename: 'F:\\workspace\\01-node\\10b.js',
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }
Module {
  id: '.',
  exports: { name: 'Jhon' },
  parent: null,
  filename: 'F:\\workspace\\01-node\\10b.js',
  loaded: false,
  children: [],
  paths:
   [ 'F:\\workspace\\01-node\\node_modules',
     'F:\\workspace\\node_modules',
     'F:\\node_modules' ] }

var res = require('./b.js');//可以得到 b 模块定义的数据  { name: 'Jhon' }

//require()实现
function require(...) {
    var module = { exports: {} };
        ((module, exports) => {
            // 你的模块代码在这。在这个例子中，定义了一个函数。
            function some_func() {};
            exports = some_func;// exports在文件执行前被赋值为 module.exports,这里在重新赋值其他数据，
        // 此时，exports 不再是一个 module.exports 的快捷方式，
        // 且这个模块依然导出一个空的默认对象。
            module.exports = some_func;
        // 此时，该模块导出 some_func，而不是默认对象。
        })(module, module.exports);
    return module.exports; //require函数导出的是模块的 module.exports,而不是exports
}

var PI = Math.PI;
exports.area = function (r) {
    return PI * r * r;
};
exports.circumference = function (r) {
    return 2 * PI * r;
};

var circle = require('./circle.js');
console.log( 'The area of a circle of radius 4 is ' + circle.area(4));

(function (exports, require, module, __filename, __dirname) {
    var circle = require('./circle.js');
    console.log('The area of a circle of radius 4 is ' + circle.area(4));
});

var data = '{"b":2,"nema":"jhon"}'; //这是一个字符串
//第一种方法，通过eval()将其解析成对象
var objData1 = eval( "("+data+")"  ); ////Object {b: 2, nema: "jhon"}
//第二种方法
var objData2 = JSONparse(data);//Object {b: 2, nema: "jhon"}

var buf = new Buffer(arg) //1 必须传入参数 2  传入的参数类型 string, Buffer, ArrayBuffer, Array, or array-like object.

var buf1 = new Buffer(10);//这个是指定Buffer实例的长度，区分 var buf1 = new Buffer('10');
console.log(buf1);
console.log(buf1.length);
console.log(buf1.toString());
var buf2 = new Buffer([10, 40, 30]);//数组的长度 作为Buffer实例的长度
console.log(buf2);
console.log(buf2.length);
//buf2.write('hahhahahahhah')
console.log(buf2.toString());
var buf3 = new Buffer({length:12});//类数组对象 的长度作为Buffer的长度
console.log(buf3);
console.log(buf3.length);
console.log(buf3.toString());
var buf4 = new Buffer('this is it yeah'); //直接将字符串写入Buffer实例，长度等于字符串的长度
console.log(buf4);
console.log(buf4.length);
console.log(buf4.toString());
var buf5 = new Buffer(buf4);//将Buffer实例直接作为参数传入
console.log(buf5);
console.log(buf5.length);
console.log(buf5.toString());

buf.write(string[, offset[, length]][, encoding])
参数描述如下：
    string - 写入缓冲区的字符串。
    offset - 缓冲区开始写入的索引值，默认为 0 。
    length - 写入的字节数，默认为 buffer.length
    encoding - 使用的编码。默认为 'utf8' 。
返回值
	返回实际写入的大小。如果 buffer 空间不足， 则只会写入部分字符串。

buf.toString([encoding[, start[, end]]])
参数描述如下：
    encoding - 使用的编码。默认为 'utf8' 。
    start - 指定开始读取的索引位置，默认为 0。
    end - 结束位置，默认为缓冲区的末尾。
返回值
	解码缓冲区数据并使用指定的编码返回字符串。

buf.length;  返回Buffer实例实际所占据的内存的长度

buf.toJSON();将Buffer实例转化为JSON对象

buf.slice(start,end);默认start 0 end 为buf.length 
返回一个新的缓冲区，它和旧缓冲区指向同一块内存，但是从索引 start 到 end 的位置剪切。

Buffer.concat(list[, totalLength]) 返回一个多个成员合并的新 Buffer 对象。

//console.log(Buffer) 可以尝试着输入下Buffer类，看下其属性和方法
var buf = new Buffer('this is it yeah');
console.log(buf);
console.log(buf.length);//15
console.log(buf.toString());
var wLen = buf.write('changed?');
console.log(buf.toString());//changed?it yeah
console.log(wLen);//8
console.log(buf.toJSON());
/*{
	type: 'Buffer',
 	data: [ 99, 104, 97, 110, 103, 101, 100, 63, 105, 116, 32, 121, 101, 97, 104 ] 
 }
 */
var sliceBuf = buf.slice(2,5);
console.log(sliceBuf);
console.log(sliceBuf.length);//3
console.log(sliceBuf.toString());//ang
var con = Buffer.concat ([buf,sliceBuf]);
console.log(con);
console.log(con.length);//18
console.log(con.toString());//changed?it yeahang

1 window 事件:onload  onunload onafterprint onbeforeprint onerror  onresize 
2 From表单 事件(仅在表单元素中有效):onblur  onfocus onreset onsubmit onselect onchange  oninput
3 键盘事件 : onkeydown  onkeyup onkeyup
4 鼠标事件: onclick onmouseout onmouseleave onmouseenter onmousedown onmouseup onscroll(当元素滚动条被滚动的时候) ondrag ondragstart ondragend ondragenter ondragover ondragleave ondrop 
//键盘事件和鼠标事件在base, bdo, br, frame, frameset, head, html, iframe, meta, param, script, style, title 元素无效；
5 触摸事件 :touchstart touchend touchmove 
6 媒介事件 : 
7 自定义事件:
8 所有的事件都是成元素的一个属性，原始值为null;输出一个DOM元素可以查看其所有的属性;

ele.on+事件类型 = function(){  };     ele.addEventListener("事件类型"，function(){ } );
ele.onclick = function(){ };		ele.addEventListener("click",function(){ } );
ele.onmouseout = function(){ };      ele.attachEvent("onclick",function(){ } );(注意有on)
window.onlaod = function(){ };		window.addEventListener("load",function(){ } );
ele.ondragstart = function(){ };	ele.addEventListener("dragstart",function(){ } );

ele.addEventListener("touchstart",function(){ } );

// 1注册事件
	my$("btn1").onclick = fn;//(onclick指向一个函数体)
//1移除事件
	my$("btn1").onclick = null;//(将指向设置为null,则可以清除事件)
// 2 注册事件
my$("btn1").addEventListener("click",fn,false);
// 2 移除事件
my$("btn1").removeEventListener("click",fn,false);
// 3 注册事件  谷歌和火狐不支持
 my$("btn1").attachEvent("onclick",fn);
// 3 移除事件
 my$("btn1").detachEvent("onclick",fn);

--ready(fn):当DOM元素载入就绪就可以执行的一个函数
data 是传递给jQuery事件对象参数event.data的数据，fn是绑定在该事件上的处理程序，events和type是要绑定的事件类型
--$("selector").on(events,data,fn)   可以一次绑定多个事件  
  $("selector").off(events,data,fn)  移除on绑定的事件 如果不写任何参数，则移除匹配元素的所有事件
  $("selector").bind(type,data,fn)   可以一次绑定多个事件，可以绑定自定义事件;
  $("selector").unbind(type,data,fn) 移除bind绑定的事件 如果不写任何参数，则移除匹配元素的所有事件
--$("selector").mouseover(), $("selector").mouseover(fn)  如果不写参数，将触发选定元素的该事件，如果写   了函数体，则将为选定的元素绑定事件  
  mouseout  mousemove  mouseenter mouseleave mouseup mousedown  click keyup keydown change blur
    都是一样的特性，如果不传函数体，就是触发该事件;如果传了函数体，就是绑定该事件的处理程序.
--$("selector").hover(fn(in)/fn(oout)  可以给选中的元素绑定hover事件，鼠标悬浮在上面的时候，执行			fn(in),鼠标离开元素的时候执行fn(out);
//事件委派 使用 delegate() 方法的事件处理程序适用于当前或未来的元素（比如由脚本创建的新元素）。
--$("selector1").delegate("selector2","type",fn)  selector1必须是selector2的父元素，事件的执行程序绑定在selector2(子元素选择器)上 。

// 绑定事件
function addEvent(obj,type,fn){
  obj.listener = obj.listener || {};
  obj.listener[type] = obj.listener[type] || [];
  obj.listener[type].push(fn);
}
// 触发事件
function fireEvent(obj,type){
  var arr = obj.listener[type];
  for (var i = 0; i < arr.length; i++) {
    arr[i]();
  }
}

var url ='http://www.myvirtual.com?username=Jhon&age=12';//将查询字符串转换为js对象
function queryParam(url){
  var newUrl = url.slice(url.indexOf('?')+1);
  var urlArr = newUrl.split('&');
  var ret = {}
  for(var i = 0 ; i < urlArr.length ; i++){
    var arr = urlArr[i].split('=');
    ret[arr[0]] = arr[1];
  }
  return ret ;
}
queryParam(url);

var reg = /\byou/g; //  \b可以匹配单词的边界,单词中以you开头的you将会被匹配到
var result ;
while((result = reg.exec(str)) != null){
  console.log(result);
  console.log(reg.lastIndex);
}

var str = 'hello youthereyou yourighthere ';
var reg2 = /\Bthere/g  ;//用来匹配 不在单词开头的there
var result ;
while((result = reg2.exec(str)) != null){
  console.log(result);
  console.log(reg2.lastIndex);
}
//---------------------------------------------
var reg2 = /there\B/g ;//匹配不在单词结尾的there

//exec() 方法用于检索字符串中的正则表达式的匹配。如果找不到，则返回null
var str = 'that is hot';
var reg = /h.t/g;
var ret ;
while( (ret = reg.exec(str) ) != null){
  console.log(ret);// Array[1][0:"hat"index:1,input:"that is hot",length:1]
  //Array[1][0:"hot"index:8,input:"that is hot",length:1]
  console.log(reg.lastIndex);// 4 11  exec()方法 RegExpObject 的 lastIndex 属性设置为匹配文本的最后一个字符的下一个位置
}

//match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。返回匹配结果的数组，如果找不到返回null
var str = 'that is hot';
var reg = /h.t/g;
var ret = str.match(reg);
console.log(ret1);//["hat", "hot"]