前面一句话: 挖掘知识的边界,抠的越细,深度和广度才越高,才越牛.
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();