js基础总结

基础

普通---立即执行
async---异步加载,立即执行,不按照顺序执行
defer---异步加载,最后执行
<noscript>

数据类型

number
    NaN---未知的数值 通过inNaN(判断是否能转化为数值)来判断
    infinity
    指数形式:aE+n a乘10的n次方,11E-3 ===> 11*10^-3 = 0.011
undefined---未定义
null---空对象指针
string
boolean
object
typeof操作符:undefined boolead string number object(null) function
基本转义字符 \n换行,\b空格

控制结构

1.do-while
先执行,再判断
2.while
判断再执行
3.for
---都是为假就跳出循环
4.for-in-迭代读取对象的key,可能不会按照顺序读取...
5.label,break,continue
6.with---将代码的作用域设定到特定对象中
with(a){
    var x=b;
    var y=c;
}---将作用域设定到a对象中;
等同于
var x=a.b;
var y=a.c;
7.switch
    case x : 语句;break;
    default: 语句;

变量,作用域和内存

变量类型:
基本类型---简单数据段
引用类型---对象类
1.对于直接赋值 a=b
基本类型传递值
引用类型传递指针,所以改变b,a会改变;
2.对于向函数传递参数
都是传递值;

执行环境及作用域
function  a(){
    function b(){
    }
}
环境栈: ↓
        b的环境对象---活动对象,包括arguments变量
        a的环境对象---第二级作用域
        window---全局作用域

引用类型

通过new或者字面量的形式创建
公共方法:
    tostring()
    tolocalstring()
    valueof()
引用类型包括以下几类:
1.object
2.array
3.date
    获得时间
     var now = new Date;
     然后通过getTime()等方法
    创建时间
     var dateTime = new Date("2016/05/20 23:42:00");
4.RegExp
5.Function
6.包装类型-boolean,string,number
---
var a='xx';
var b=a.length; b=2;
相当于:
var a='xx';
a1=new string('xx');
b=a1.length;
a1=null;
基本数据类型能使用方法,是因为转换成了这些包装类型,然后立即被释放;
a.color='red';---a变成包装类型string,添加属性color,然后被释放
alert(a.color);---undefined,又变成了基本类型.
---
var value='1';
Number(value);---转换函数,转成数值
new Number(value);---构造函数,构造了一个包装类型
7.单体内置对象
Global
    全局对象---最底层的对象---没有直接调用的方法,只有通过window对象调用
    window对象是Global(js语法中的最底层对象)与浏览器对象之和;
Math

面向对象

对于一个属性--由一个name,6个特性组成;
可配置性 configurable ---能否delete删除;能否修改特效;能否设置为访问器属性;
可枚举性 enumerable---能否for-in
数据属性:
可修改性 writable
数值 value---默认undefined
访问器属性:(es5标准,ie8及以下没有--主要 适用与移动端);
set
get

前三个特性,默认true,但是如果开始设置,任意一个特性,其余的默认false;   
数据属性和访问器属性不能混用;

var a = {};
Object.defineProperty(a,"name",{
    value:"lh",
    writable:false          --- 这个时候,其余两个属性设置为了false;
})
var b = Object.getOwnPropertyDescriptor(a,"name");
得到特性名=>值组成的对象;

Object.defineProperty(a,"name",{
    set:function(e){
        this.name=e+1;
    }
设置多个属性
Object.defineProperties(a,{
    name:{},
    vale:{}
})

Object模式  
var x = new Object()
x.name='';
...

对象字面量
var x = {
    name:'',
    ...
    }
    
工厂模式
function x (){
    var o = new Object();
    o.name='';
    ...;
    return o;
}

构造函数
function x(){
    this.name='';
    }
var y =new x (); 

除了构造函数,这几种方法原型链都是
对象--对象原型(Object.prototype)--null
构造函数是
实例化的对象(y)--实例原型(y.__proto__/x.prototype)--对象原型(Object.prototype)--null


function a(){
    this.fn=function(){}
}---构造函数a中创建一个方法fn;
var b1 = new a();
var b2 = new a();
这个时候 b1.fn并不等于b2.fn;
要他们共用一个方法,要将方法放在原型a上;
a.prototype.fn = function(){...};

----------------------------------------
实际使用:
function student(){
    this.name=prop.name||"匿名";
};
student.prototype.fn=function(){...};
function createstudent(prop){
    return new student(prop||{});
}
---然后直接用 var xiaoming = createstudent();来创建
1.不要new
2.传参数不用管顺序,和有没有,还能设置默认值...
3.完全匹配json数据;
var x = createstudent({
    "name":"xiaoming",
    ...
}) 

function mor(obj) {
    var rs = [];
    while(obj) {
       rs.push(obj);
       obj = Object.getPrototypeOf(obj);
    } 
    return rs;
}




原型上的变量,实例中赋值后,变成不继承了??--继承,但是优先级不同
q.hasOwnProperty("vv") true
w.hasOwnProperty("vv") flase  --
在q中添加了vv属性,因为调用是从上至下的,所以现在实例中查找,再去原型--
可以通过delete q.vv;然后调用的又是原型中的了.

function empty(){};??
                            实例a	                   构造函数b		           原型c	
---------------------------------------------------------------------------------------------

constructor				     b 			    	functon Function(){}     		     b
-----------------------------------------------------------------------------------------------

prototype                   undefine       				c           		     undefine
-----------------------------------------------------------------------------------------------

__proto__					    c          		function Empty(){}               Object
-----------------------------------------------------------------------------------------------
__proto__才是原型,继承.
定义函数时,就会有construct和prototype出现
    函数的原型是个空对象,继承自Object;
    new的作用是将this绑定?
------------------------------------------------------------------------------------------------


构造函数模式+原型模式实际运用
var prop = {
	name:"gou",
	cat:"miao"
}

function a(){
	this.cat=prop.cat||'mao' 
};
a.prototype={
	constructor:a,
	建立对象的时候,设置原型的时候.只能单个设置
eg:
    a.prototype.name:'="name',
	say:function(){
		return this.say+this.name;
	}
}

function createA(){
	return new a (prop||{})
}

var b = createA(prop);

稳妥构造模式
function a (){
    var o = new Object();
    name="xx";
    o.sayname=function(){
        alert(name);
    }
    return o;
}
适应在需要安全的地方--除了o.sayname方法,无法访问内部属性;

函数

闭包:
能访问函数内部.
匿名函数的返回---
			function a(x){
				var t='he';
				console.info(x);						
				return function (x){
				console.info(t,x,this);
				}
			}
		var b=a('he');---'he',b=function(){...};this指向windows,但是环境仍然为a;
		能访问到t,x又作为匿名函数的参数了,所以如b不赋值,则为undefined;
	    b('he');---'he,he,window';
严格模式下,不能使用arguments.callee;
var a = (function b(){})---用来内部调用自己;
闭包用途:
function a(){
	var x=1;
	add=function(t){
		x=x+t;
		console.info(x);
	};
	return function b(){
		x++;
	console.info(x);
	};

}
var b=a();
b();2
b();3
add(1);5

---通过闭包,b函数赋予给全局变量b,b函数又依赖a,所以将a环境一直保存在内存中了...
add没用var创建,所以是个能访问a内部的全局函数,可以用来设置a内的变量;

其他

错误处理

所以抛出的错误都是error对象的实例

error对象:
    message:错误提示信息
    name：错误名称（非标准属性）
    stack：错误的堆栈（非标准属性)
派生的六种对象
1.syntaxError---语法错误
2.refrenceError---引用了不存在的变量
3.rangeError---超出范围
4.typeError---使用变量或参数不是预期类型
5.URIError---URI相关函数的参数不正确
6.EvalError---Eval函数没有正确执行
自定义错误:
function a(){}
a.prototype=new Error;
a.contructor=a;
var b=new a;

throw语法
throw抛出一个对象,然后中断
try{}
catch(){}
finally{}
执行try中的语句,如果完成,执行finally语句
如果错误,catch捕获错误(不抛出错误),然后执行catch语句,再finally语句

常用操作符与方法汇总

操作符
typeof---主要检测基本类型
instanceof---主要检测引用类型 检测对象的cunstructor
1.Object
实例 instanceof 原型
Object.getPrototypeOf() 获得对象的原型
Object.constructor 对象的构造函数 
Object.hasOwnProperty( ) 检查属性是否被继承 
Object.isPrototypeOf(a) 一个对象是否是另一个对象的原型 (a原型链上是否有Object);
Object.propertyIsEnumerable( ) 是否可以通过for/in循环看到属性 
Object.toLocaleString( ) 返回对象的本地字符串表示 
Object.toString( ) 定义一个对象的字符串表示 
Object.valueOf( ) 指定对象的原始值 
2.Array
Array.concat( ) 连接数组 
Array.join( ) 将数组元素连接起来以构建一个字符串 
Array.length 数组的大小 
Array.pop( ) 删除并返回数组的最后一个元素 
Array.push( ) 给数组添加元素 
Array.reverse( ) 颠倒数组中元素的顺序 
Array.shift( ) 将元素移出数组 
Array.slice( ) 返回数组的一部分 
Array.sort( ) 对数组元素进行排序 
Array.splice( ) 插入、删除或替换数组的元素 
Array.toLocaleString( ) 把数组转换成局部字符串 
Array.toString( ) 将数组转换成一个字符串 
Array.unshift( ) 在数组头部插入一个元素 
Array.


3.Boolean
Boolean.toString( ) 将布尔值转换成字符串 
Boolean.valueOf( ) Boolean对象的布尔值 
4.Function
Function.apply( ) 将函数作为一个对象的方法调用 
Function.arguments[] 传递给函数的参数 
Function.call( ) 将函数作为对象的方法调用 
Function.caller 调用当前函数的函数 
Function.length 已声明的参数的个数 
Function.prototype 对象类的原型 
Function.toString( ) 把函数转换成字符串 
5.Number
Number.MAX_VALUE 最大数值 
Number.MIN_VALUE 最小数值 
Number.NaN 特殊的非数字值 
Number.toLocaleString( ) 把数字转换成本地格式的字符串 
Number.toPrecision( ) 格式化数字的有效位 
Number.toString( ) 将—个数字转换成字符串 
Number.valueOf( ) 返回原始数值 
6.String（字符串对象）
String.charAt( ) 返回字符串中的第n个字符 
String.charCodeAt( ) 返回字符串中的第n个字符的代码 
String.concat( ) 连接字符串 
String.indexOf( ) 检索字符串 
String.lastIndexOf( ) 从后向前检索一个字符串 
String.length 字符串的长度 
String.localeCompare( ) 用本地特定的顺序来比较两个字符串 
String.slice( ) 抽取一个子串 
String.split( ) 将字符串分割成字符串数组 
String.substr( ) 抽取一个子串 
String.substring( ) 返回字符串的一个子串 
String.toLocaleLowerCase( ) 把字符串转换小写 
String.toLocaleUpperCase( ) 将字符串转换成大写 
String.toLowerCase( ) 将字符串转换成小写 
String.toString( ) 返回字符串 
String.toUpperCase( ) 将字符串转换成大写 
String.valueOf( ) 返回字符串 
7.其他
parseInt(x,16/10/8) --- 如果x=08 有没有指定radix 那就会输出8进制
parseFloat(x,16/10/8)
isNaN()
isFinite() 检测是不是infinity与NaN
escape() 对整个字符串进行转义 (% ? 等在url中有意义的也会被转义)
encodeURI() 对URL进行转义(只会对参数)  --- decode...反转义
encodeURIComponent() 对整个url转义(当url作为参数时,如跳转)