前面一句话: 挖掘知识的边界,抠的越细,深度和广度才越高,才越牛.

js的性能已经达到java的五分之一

(1) == ===的区别??

null == undefined //true
      '' == false //true
      总结 ==不靠谱, 只用===

(2) 不使用continue;

效率低,出处:javascript语言精粹111页

(2) var a = {};

a.b='xx';
      a['delete'] = 'yy'; ///关键词也无所谓了

(3) delete 删属性
      全局变量和局部变量删除不掉???

var aaaa = 123;
      delete aaaa;
      console.log(aaaa); //123

window.aaaa = 123;
      delete window.aaaa;
      console.log(window.aaaa); //undefined

function a(){
            var a= 123;
            delete a;
            console.log(a); //123
      }a();

设为a=null;祈祷上天,等待垃圾回收机制回收.

注：当使用var声明一个变量时，创建的这个属性是不可配置的，也就是说无法通过delete运算符删除

var name=1    ->不可删除

sex=”girl“         ->可删除

this.age=22    ->可删除

(4) typeof instanceof

typeof 2 === 'number' //true
      typeof new Number(2) === 'number' //false
      typeof '2' === 'string' //true
      typeof new String('2') === 'string' //false
      typeof true === 'boolean' //true
      typeof new Boolean(true) === 'boolean' //false
      typeof [] === 'object' //true
      var a = function(){}; typeof a === 'function'; //true

[] instanceof Object //true
      2 instanceof Number //false
      new Number(2) instanceof Number //true

var a = function(){}
      var b = function(){};
      a.prototype = new b();
      new a() instanceof b; //true

// typeof 能判断 基本类型 和 function
      // instanceof 能判断 自定义对象

//扩展 Object.prototype.toString.call([]) === '[object Array]'; 这样是最棒的判断

(4) if语句
      if( xxxx ) ? //6种情况为false

// null undefined NaN 0 '' false

(4) for in 
      //遍历对象

//遍历松散的数组

var a = new Array(10); a[2]=10; a[5]=10; for(var i in a){ console.log(i); }

性能,确实优化了

var a = new Array(10000000);
      a[2]=10;
      a[5]=10; 
      var time1 = new Date().getTime();
      for(var i in a ){ 
            Math.random()* Math.random()* Math.random() * Math.random();
      }
      var time2 = new Date().getTime();
      for(var i=0; i<a.length; a++){ 
            Math.random()* Math.random()* Math.random() * Math.random();
      }
      var time3 = new Date().getTime();
      console.log(time2-time1); //~100ms
      console.log(time3-time2); //~200ms

(5) 函数字面量 与 函数声明

var a = 2;
      function a(){}
      console.log(typeof a); //function ? number ?

总结：
      变量的声明被提前到作用域顶部，赋值保留在原地；
      声明式函数整个“被提前”；
      函数表达式只有变量“被提前”了，函数没有“被提前”；
      函数的声明比变量的声明具有高的优先级。
      赋值会根据前后顺序进行覆盖！

var a = function(){
            console.log('aaa');
      }
      function a(){
            console.log('bbb');
      }
      //var b = function b(){} === function b(){}
      a();

(6) 函数返回值
      var a = function(b,c){
            console.log(b+','+c);
      }
      console.log( a() );

(7) this指向
      function a(){

var that = self = this;

this.v = 'aaa';
            function b(){
                  console.log(this);
                  console.log(this.v);
            }
            b();
      }
      new a();

(8) arguments
      function a(a,b,c,d){
            //var args = [].slice.call(arguments);
      }

(9) apply call
      function a(){
            console.log(this.x+this.y);
      }
      a.call({x:100,y:100});

function C(){
            this.m = function(){
                  console.log(this.x+this.y); 
            }
      }
      var c = new C();
      c.m.call({x:100,y:100});

//这个就是this的重定向,原谅我吧,没法解释的很准确和浅显易懂,只能多练习

(10) try catch throw 关键逻辑加上就好
      var a = 'aaa';
      try{
            a = xxxx(); //不存在的方法
      }catch(e){
            throw(new Error('error'));
            a = 0;
      }
      console.log("go go go"); //这里走吗???

(11) 闭包
      for(var i=0; i<2; i++){
      }
      console.log(i);

function a(){
            //只有方法体的才有作用域
      }

var a;
      function c(){
      var v = 'vvv';
      function b(){
            return {v:v};
      };
      a = b();
      }
      c();
      console.log(a.v); //方法体是作用域, 这个大家都知道了, 内部的方法体需要给个口子出来,让外面可以访问到.

(12) 回调

function a(callback){
            callback();
      }
      a(function(){
            console.log('aaa');
      });

(13) 自执行函数, 也叫自调函数

(function(a){
            console.log(a);
      })('aaa');

(14) 正则
      var regexp = / /img
            //i   大小写
            //m 换行
            //g  检索到第一个匹配不停止,检索全部

(15) prototype
      //prototype是什么?
      function a(){
            this.v='vvv';
      }
      console.log(a.prototype); //当前对象,函数也是对象,
      console.log(a.prototype.constructor); //当前方法
      console.log(a.prototype.constructor.__proto__ === a.__proto__); //true
      //prototype是函数的内置属性，__proto__是对象的内置属性,都是查找原型链的

//prototype使用场景?
      var b = {};
      //function b(){};
      //var b = function(){}
      b.prototype.bbb='bbb';
      console.log(b.bbb);
      //console.log(new b().bbb); //构造器

//prototype咋玩? (下面的都是不好的用法)
      function a(){};
      a.prototype = function(){ console.log("aaa") };
      console.log( new a.prototype() );

// function a(){}
      // function b(){}
      // a.prototype = {aaa:'aaa'};
      // b.prototype = a.prototype;
      // var aa1 = new a(),
      // aa2 = new a(),
      // bb1 = new b();
      // aa1.prototype.aaa='xxx';
      // console.log( aa2.aaa );
      // console.log( bb1.aaa );

// function a(){}
      // function b(){ this.bbb='bbb'};
      // a.prototype = new b();
      // console.log(new a().bbb );

//-----4 其实是这样的
      Object.create();

最后一句话: !!!只有最佳技术实践才能救命!!!