我在那日界线奔跑之JS---基础

基本点

数据结构

原本制做的是脑图，思惟导图，导出来很差上传，就这样md+png吧

js

基本的数据类型

Undefined

undefined,null区别

undefined,null区别：
1.undefined表示声明了一个变量var a，没有初始化的状况下输出该变量为undefined以及未声明直接typeof一个未声明的变量结果也为undefined；js中的变量是弱类型的，java中声明一个int即便未赋值也会自动初始化为int类型的0；而且若是一个变量未声明，直接输出该变量会报错；
2.null表示Object类型的空引用；
3.typeof undefined="undefined"
typeof null="object"
Number(undefined)=NaN
Number(null)=0
null==undefined为true
4.typeof输出的都是字符串，包括：undefined,object(对象和数组),string,number,boolean,function

操做符

一元操做符

只对数感兴趣递增和递减++,--

递增递减遇只对数值感兴趣“1”也会转换成1；而普通的字符串都为NaN;
固然全部的运算遇到boolean值的都：false=0;true=1;
前置递增（减）先增或减再其余操做，后置递增（减），先执行其余操做再对数值增或减

Number下一元+,-

+对数值无影响，非数值会Number()下，对象会valueOf()或toString()下再Number()
-先进行+相同的转换再取负

非数就拼接加性操做符

对同为数值的两个操做数加法运算
只要有一个是字符串就变成了拼接操做

typeof

"undefined"

"object"

"string"

"number"

"function"

"boolean"

位操做符

~:按位非，取负数减1
&:按位与，同为1真则为1真，其他为0假
|:按位或，有一个为1真则1真
^:按位异或，只有一个1时结果为
<<:左移

:有符号右移

:无符号右移，对负数来讲无符号右移会获得很大的jieguo

关系操做符

!非
&&与
||或

六个感叹号家族!

!a,当a为什么值时此条件为真；当a为false或者Boolean()后为false;
Boolean(false) false
Boolean(0) false
Boolean(NaN) false
Boolean(undefined) false
Boolean(null) false
Boolean("") false

布尔操做符

Number乘性操做符

条件操做符

相等操做符

==

null==undefied

===

首先类型必须相同

逗号操做符

Null

Number

Boolean

String

Object

Array

伪数组arguments

参数值和arguments伪数组存的值同步
严格模式下修改参数值，arguments内的值不变，arguments值和执行函数时传入的参数个数一致
伪数组不具备真正数组的操做方法，有length属性，也能够访问每个元素

检测数组

Array.isArray(arguments)为false
检测数组的方法：
Array.isArray()
arr instanceof Array;此方法缺陷是不一样框架建立的数组，分别是不一样Array的实例

真正的数组

增删改查

增

头部添加arr.unshift("a");

返回值更改后数组的长度；原数组被更改
var a=[1,2,3];a.unshift(0);
4
var a=[1,2,3];a.unshift(0);a
[0, 1, 2, 3]

尾部添加arr.push("z");

自定义位置和数量arr.splice(0,0,1,2,3,4);

返回删除的元素组成的shuzu
var a=[0,1,2,3];a.splice(4,0,5,6,7);a
[0, 1, 2, 3, 5, 6, 7]
var a=[0,1,2,3];a.splice(4,0,5,6,7);
[]

链接数组不改变原数组从新建立新数组arr.concat(arr1)

只是链接数组，不改变原数组；返回新数组
var a=[1,2,3];a.concat([0]);
[1, 2, 3, 0]
var a=[1,2,3];a.concat([0]);a
[1, 2, 3]

删

头部删arr.shift("a");

返回第一个元素即删除的元素；改变原来的数组
var a=[1,2,3];a.shift();
1
var a=[1,2,3];a.shift();a
[2, 3]

尾部删arr.pop("z");

var a=[1,2,3];a.pop();
3
var a=[1,2,3];a.pop();a
[1, 2]

自定义位置和数量arr.splice(0,2);

返回删除元素组成的数组；原数组gaibia
var a=[0,1,2,3];a.splice(0,3);
[0, 1, 2]
var a=[0,1,2,3];a.splice(0,3);a
[3]

改

arr.splice(第几个元素位置,删除的个数,增长或修改成新数);

删除该位置元素，替换上新元素；返回删除元素组成的数组，修改原shuzu
var a=[1,2,3];a.splice(0,1,0);
[1]
var a=[1,2,3];a.splice(0,1,0);a
[0, 2, 3]

查

查位置arr.indexOf("a");

返回该元素第一次出现的位置
var a=[1,2,3];a.indexOf(1);
0

查最后出现的位置lastIndexOf

不改变原数组返回切出来的数组arr.slice(0);

第一个参数从哪开始，第二个参数数几个数；返回这几个数组成的数组，不改变原数组；只有一个参数的状况下，取到最后
var a=[1,2,3];a.slice(0);
[1, 2, 3]
var a=[1,2,3];a.slice(0,2);
[1, 2]
var a=[1,2,3];a.slice(0,2);a
[1, 2, 3]

不改变原数组五个迭代

some(function(item,index,array){})

有一项符合要求就返回true

every

每一项都符合要求，最后返回tru

filter

返回符合条件的元素组成的shuz

map

返回新数组，对应每一项都操做后的新数组

forEach

无返回值
var a=[1,2,3,4],b=[];a.forEach(function(item,index,array){b[index]=item-1});b
[0, 1, 2, 3]

不改变原数组两个缩小

arr.reduce(function(pre,cur,index,array){return pre+cur});返回和

reduceRight()

查找最大值

Math.max.call(arr);

sort(逆序排序);取下标0的元素值

排序

排序sort

默认ASII码值排序arr.sort()

数值正序arr.sort(function(a,b){return a-b;})

数值逆序arr.sort(function(a,b){return b-a;});

汉字按拼音排序arr.sort(function(a,b){return a.localeCompare(b);});正序啊你为

反转reverse

var a=[4,1,2,5,3];a.reverse()
[3,5,2,1,4]

转换

数组->字符串

.toString()

结果是以逗号隔开的字符串

.join(",")

返回以自定义符号隔开的字符串

.toLocaleString()

字符串->数组

.split("")

var str="1,2,3";var arr=str.split(",");

Function

函数内部属性

伪数组参数arguments

arguments.callee

指向拥有该arguments对象的函数
递归函数会用到Arguments对象的callee属性

上下文执行环境对象this

当在全局做用域调用函数，this指向window的引用
当某个对象调用时，就指向对象的引用
var a={color:"red",getA:function(){console.log(this.color);}};var b=a.getA;b()
undefined
var color="window";var getA=function(){console.log(this.color)};var o={color:"o"};o.getA=getA;o.getA()
o

闭包

闭包概念：一个函数内部建立另外一个函数；内部函数能够访问包含函数的变量外部没法访问内部函数的变量；
闭包优缺点：封装性，减小全局变量污染；对外部变量的引用致使垃圾回收没法清除变量形成内存泄漏

内存泄漏

哪些操做会形成内存泄漏
闭包；循环引用；setTimeout第一个参数为字符串

垃圾回收

垃圾回收的两种方式：
标记清除，垃圾回收器运行时给存储在内存的全部变量都加上标记，而后去掉环境中的变量和被环境中变量引用着的变量的标记，最后将仍旧被标记着的变量清除释放内存（闭包就是由于变量仍旧被引用着没法清除）
引用计数，跟踪每一个变量被引用的次数，当一个变量被赋值给另外一个变量时，该变量就被引用1次，当赋值另一个值时，该变量被引用次数减一（若是存在两个变量循环引用，引用次数一直2，不能清除）

caller

调用当前函数的函数的引用
var outter=function (){inner()};var inner=function(){console.log(arguments.callee.caller)};outter();
function (){inner()}
undefined
var outter=function (){inner()};var inner=function(){console.log(inner.caller)};outter();
function (){inner()}
严格模式下，caller属性值不能修改

函数属性和方法

属性

length

函数须要接收的命名参数的个数

length!==arguments.length

arguments表示实例化时传入的参数伪数组

prototype

原型链

将一个类的实例赋值给另外一个类的原型造成原型链；
构造函数、实例、原型之间的关系：每个构造函数都有一个原型，每个原型对象都有一个指针指向构造函数，每个构造函数的实例都有一个内部属性指向原型对象

继承

原型链式继承

原型链继承致使引用类型的属性被共享，而且子类实例不能向父类传递参数
function parent(){this.name="姓";this.friends=["w","f"];}
function child(){}
child.prototype=new parent();
var child1=new child();
var child2=new child();
console.log(child1.name);
console.log(child2.name);
VM15914:6 姓
VM15914:7 姓

function parent(){this.name="姓";this.friends=["w","f"];}
function child(){}
child.prototype=new parent();
var child1=new child();
var child2=new child();
console.log(child1.friends);child1.friends.push("m");
console.log(child2.friends);
VM15915:6 ["w", "f"]
VM15915:7 ["w", "f", "m"]

借用构造函数继承

方法在每一个子类原型上都要建立一遍，没法达到方法共享
function parent(name){this.name=name;this.friends=[1,2,3]}
function child(name){parent.call(this,name);}
var child1=new child("1");
var child2=new child("2");
console.log(child1.name);
child1.name="3";
console.log(child1.name);
console.log(child2.name);
console.log(child1.friends);
child1.friends.push("m");
console.log(child1.friends);
console.log(child2.friends);
VM15918:1
VM15918:7 3
VM15918:8 2
VM15918:9 [1, 2, 3]
VM15918:11 [1, 2, 3, "m"]
VM15918:12 [1, 2, 3]

组合式继承

call,new两次致使实例和原型上都存在相同属性
function parent(name){this.name=name;this.friends=[1,2,3]}
parent.prototype.getFriends=function(){console.log(this.friends);};
function child(name){parent.call(this,name)}
child.prototype=new parent();
var child1=new child();
var child2=new child();
child1.friends.push(4);
child1.getFriends();
child2.getFriends();
VM15920:[1, 2, 3, 4]
VM15920:[1, 2, 3]

寄生式继承

function obj(o){
    function f(){}
    f.prototype=o;
    return new f();
}
function createChild(original){
    var clone=obj(original);
    clone.say=function(){
        console.log("hi");
    };
    return clone;
}
var parent={
    name:"p",
    friends:[1,2,3]
};
var child1=createChild(parent);
var child2=createChild(parent);
child1.friends.push(4);
console.log(child1.friends);
console.log(child2.friends);

VM15922:20 [1, 2, 3, 4]
VM15922:21 [1, 2, 3, 4]

原型式继承

function obj(o){
    function f(){}
    f.prototype=o;
    return new f();
}
var parent={
    name:"p",
    friends:[1,2,3]
};
var child1=obj(parent);
var child2=obj(parent);
child1.friends.push(4);
console.log(child1.friends);
console.log(child2.friends);

VM15921:13 [1, 2, 3, 4]
VM15921:14 [1, 2, 3, 4]

寄生组合式继承

function obj(o){
    function f(){}
    f.prototype=o;
    return new f();
}
function inheritPrototype(subType,supperType){
    var prototype=obj(supperType.prototype);
    prototype.constructor=subType;
    subType.portotype=prototype;
}
function parent(name){
    this.name=name;
    this.friends=[1,2,3];
}
function child(name){
    parent.call(this,name);
}
inheritPrototype(child,parent);
var child1=new child("1");
var child2=new child("2");
child1.friends.push(4);
console.log(child1.friends);
console.log(child2.friends);

VM15923:22 [1, 2, 3, 4]
VM15923:23 [1, 2, 3]

方法

fn.call(替换this的对象，传入的参数序列);

fn.apply(替换this的对象，传入参数组成的数组)

fn.bind(替换this的对象，传入的参数序列);返回函数未执行

var color={color:"red"};function a(num1,num2){console.log(this.color+num1+num2);} var b=a.bind(color,1,2);b()
VM15615:1 red12

Object

面向对象编程

封装性

继承

多态

自定义方法

深度克隆

深度克隆:
function clone(obj){

var buf=null;
if(Array.isArray(obj)){
    buf=[];
    for(var i=0,len=obj.length;i<len;i++){
        buf[i]=clone(obj[i]);
    }
    return buf;
}else if(obj instanceOf Object){
    buf={};
    for(var e in obj){
        buf[e]=clone(obj[e]);
    }
    return buf;
}else{
    return obj;
}

}

数组去重定义，在Array.prototype上；但不更改原数组，返回一个新的数组

Array.prototype.unique=function(){

var hash={},r=[];
for(vari=0,len=this.length;i<len;i++){
if(!hash[this[i]]){
        hash[this[i]]=true;
        r.push(this[i])
}

}

return r

};
var a=[1,1,2,2,3,3];
a.unique();//返回的是r，a并未改变

内置对象

Global

parseInt(num)

parseFloat(num)

Math

方法

向下取整Math.floor(num)

向上取整Math.ceil(num)

四舍五入Math.round(num)

Math.max(1,2,3)

Math.max.apply(null,arr)

Math.min(1,2,3)

Math.random()返回0-1之间的小数

Math.floor(Math.random()*10+1);1-10之间的10个数
function selectFrom(lowerValue,upperValue){

var choices=upperValue-lowerValue;
return Math.floor(Math.random()*choices+lowerValue);

}
selectFrom(1,5);

其余方法

绝对值Math.abs(num)

平方根Math.sqrt(num)

幂运算Math.power(num,power)num的power次幂

Math.PI

1/2的平方根Math.SQRT1_2

BOM

Window.open(url,位置,大小)

window.open("http://baidu.com","someFrameName","height:400,width:400,top:10,left:10,resizable:yes")
第二个参数能够是
某个窗口的名称
已存在的窗口_self,_parent,_top,_blank( 打开一个新的标签页)

系统对话框

alert("msg")

confirm("msg")

prompt("msg","inputValue")

location

location属性

?的内容location.search

返回URL中？后的字符串location.search
"?isSave=1"
decodeURIComponent(ite)能够参数值解码

的内容location.hash

location.hash
"#/history?eventId=gulf_p_g_home_timech_ck&eventName=%E7%82%B9%E5%87%BB%E5%87%BA%E5%8F%91%E6%97%B6%E9%97%B4&appName=%E6%BB%B4%E6%BB%B4%E5%87%BA%E8%A1%8C&fav=1"

location.hostname

location.hostname
"bigdata-test.xiaojukeji.com"
location.pathname
"/ddc_action_analyse/"
location.port
""

location.port

location.pathname

方法

location.assign(url)打开网页==window.location=url;location.href=url;

navigator

浏览器名称navigator.appName

navigator.platform

navigator.plugins

screen

history

前进

history(1)前进一页history(2)前进两页

history.forward()前进一页

后退

history(-1)后退一页

history.back()后退一页

history.length===0代表用户打开窗口后的第一个页面

DOM

事件流

事件捕获

目标阶段

事件冒泡

html事件标签中加onclick="name()"

dom0级事件elem.onclick=function(){};

dom2级事件

addEventListener(事件名称click，处理函数，false代表发生在冒泡阶段默然就是false)

事件委托和事件代理

ajax

json

同源策略+跨域方法

html

css

行内元素

块级元素

样式

position+z-index

opacity,rgba

background-color=width+padding

垂直水平居中，flex

浮动，清除浮动

盒模型

布局

http

设计模式