原始类型：1、string；2、object；3、number；

不能改变已经创建出的实例的指向，改变的只是 prototype。如果 prototype 的指针变化，不会影响之前创建的实例已经有的指针，之前实例的指针还是指向原来创建他时的 prototype 的指针

将变量num变成数字: num - 0

将变量num变成字符串：num + ''

呜呜呜呜

JavaScript的数据类型

    弱类型特性：定义的时候不指定数据类型，在使用的时候赋值什么类型的数据就是什么类型的数据类型。

                        32 +32   // 64   

                        "32" + 32  //"3232"

                        "32" - 32  //0

    原始类型：number、string、boolean、nul、undefined

    对象类型：对象、函数、数组、日期。。。

上面就是对this的介绍，还有一个内容是bind，是传入对象的一个call（类似吧），这个不太懂所以没写

上面就是

//函数在js中是作为一个函数对象被使用的，所以你也可以给函数加一些属性值来表达一定的含义，另外就是函数是有不同的作用域和一个很重要的参数argument的

undefined

//函数中重点要讲述的就是this、arguments、作用域和不同函数调用方式以及不同的函数创建方式

undefined

//对于函数的调用

undefined

//1、可以直接调用：foo（）

undefined

//2、函数也可以作为对象上的一个方法被调用，object.method()

undefined

//3、可以作为一个构造器被调用，new Foo()

undefined

//4、可以用function.prototype上的一些属性例如call/apply/bind来调用

感觉可以怎么理解呢，就是首先就是一个指定上下文的功能，这个具体什么功能还要先介绍完AO和VO。

和C一样，你再编译的时候引入库的时候是要把一些函数先声明调用一波的。就是说会先创建一个函数的声明，然后会对变量进行声明，而且要注意的是每一个函数都会自己创建一个VO然后嵌套在global的VO里面，然后会对变量进行声明。所以顺序就是1、函数2、变量，而且变量一开始会被写成undefined

然后就是一些关于明名的问题，如果明名的函数与前面重复，就会覆盖，如果变量重复就会忽略。

你这个代码在编译的时候就会进行上面的操作，创建一个树或者说一个json对象（不可见）。先找到所有的函数、变量，然后再执行其他的操作，所以命名重复时候会出现变量丢失。

、

//对于作用域，主要用三种，一种是全局作用域

undefined

//全局作用域可以存在于直接定义，即内部函数之外的地方，也可以在for里面，在c里面是有块级作用域的，所以定义在for里面的变量拿到外边是不可以用的，但是js可以，

undefined

//还有就是函数作用域，这个作用域是只能在函数里面用

undefined

//最后就是eval

undefined

//！！没有块级

undefined

//还有就是利用函数封装作用域的方法，利用匿名函数的作用

undefined

//匿名函数可以体现出块的身影

undefined

(function(){

    var a = 1;

})

ƒ (){

    var a = 1;

}

!function(){

    var a,b;

}()

true

//关于闭包常见的错误：循环闭包

undefined

//要注意在第一个例子里面最后得到的全是4，因为这个for是全部执行之后的结果，你在编译完成之后执行就已经是4了，然后你触发事件的时候也全是4，也就是说你没保留住原来的i

undefined

//在第二个里面它定义的匿名函数里面是可以成功保留住i

undefined

//那个i会取自每一次bi bao的i

undefined

 //在第二张图里面我们可以看到bibao的另一个好处就是说你先通过export将它的访问权限定义在外，然后就可以通过export去访问里面的函数，但是不可能直接访问

undefined

//而且export只能访问一些方法，不能访问全部的变量

undefined

//但是bibao也是有缺点的，因为你定义的变量会被一直被存储，因为不知道你什么时候还会用，由此就会有内存的泄漏和性能消耗等缺点

//数组方法下

undefined

var arr = [1,2,3,4,5];

undefined

arr.forEach(function(x,index,a){

    console.log(x+'|'+index+'|'+(a===arr));

})

VM6289:3 1|0|true

VM6289:3 2|1|true

VM6289:3 3|2|true

VM6289:3 4|3|true

VM6289:3 5|4|true

undefined

//有些老的版本是不支持foreach方法的

undefined

arr.map(function(x){

    return x+10;

})

(5) [11, 12, 13, 14, 15]

//map是一个映射的函数，在函数里面可以传出一个数组内部的值然后return回去一个操作，在这个操作下面会创建一个新的数组，而且原来的数组是不会发生改变的

undefined

arr.filter(function(x,index){

    return (x%1)&&(x%x);

})

[]

arr.filter(function(x,index){

    return (x%2);

})

(3) [1, 3, 5]

//fiter是一个过滤器，它的作用就是将原来的数组里面的一些值进行一次过滤得到我们想要的值

undefined

arr.every(function(x){

    return x<10;

})

true

arr.some(function(x){

    return x===3;

}

)

true

//every和some是对数组里面所有的值进行一个遍历，然后判断是否满足某一个条件，every的用法类似于逻辑与，必须所有的都满足才行，而some只要求其中一个满足就可以

undefined

arr.reduce(function(x,y){

console.log(x+'|'+y);

return x>y?x:y;

})

VM6798:3 1|2

VM6798:3 2|3

VM6798:3 3|4

VM6798:3 4|5

5

//reduce是一个比较复杂的办法，可以理解成是一个迭代的过程，先是选取两个数，然后操作一波得到一个数，然后将这个数字作为下一次迭代的第一个数

undefined

arr.reduceRight(function(x,y){

console.log(x+'|'+y);

return x>y?x:y;

})

VM6904:4 5|4

VM6904:4 5|3

VM6904:4 5|2

VM6904:4 5|1

5

arr.indexOf(2)

1

arr.indexOf(1,-1)

-1

//第二个参数是从哪里开始找，这个永远都是向右找，所以第二个结果才会返回-1

undefined

arr.lastIndexOf(1,-1)

0

//这回就找的到了

undefined

//在array构造器上定义了一个判断是否是array的方法叫做isArray

undefined

Array.isArray(arr)

true

//因为是定义在构造器上面的所以只能在上面用

undefined

//当然我们也有一些其他的办法

undefined

arr instanceof Array

true

arr.constructor ===Array

true

//但是构造器属性是可以继承而来的，所以一般来说也不一定准确

//这一小节我们会介绍数组的一些方法

undefined

//对于对象，我们之所以可以调用它下面的很多的方法，是因为它的原型链上有一个object.prototype这个对象，它下面包含着所有的方法（你也可以称之为属性）

undefined

//对于数组，我们也有一个array.prototype这个对象下的方法，当然我们一般来说是用es5的方法，因为老的版本ie678只支持一些非es5的放啊

undefined

//1、join方法，将数组转换成字符串，选择以什么方式将数组输出

undefined

var arr = [1,2,3];

undefined

arr

(3) [1, 2, 3]

arr.join('_')

"1_2_3"

//其实join最广泛的一个应用还是重复

undefined

function repeatString(str,n){return new Array(n+1).join(str);}

undefined

repeatString('a',3)

"aaa"

repeatString('Hi',4)

"HiHiHiHi"

//2、reverse方法是将数组倒过来，它也会影响到原来的arr

undefined

arr.reverse()

(3) [3, 2, 1]

arr

(3) [3, 2, 1]

//3、sort函数，实际上我们对JavaScript的里面有误解，默认情况下它是按照字符的顺序排列，而且还是将每个元素看作一个字符串，然后判断字符串的第一个元素的大小然后排序.

undefined

arr2 = ['a','c','b']

(3) ["a", "c", "b"]

arr2.sort()// 而且原数组也会被修改

(3) ["a", "b", "c"]

arr.sort()

(3) [1, 2, 3]

//所以我们要给这个数组加入一些方法函数

undefined

6164:1 Unchecked runtime.lastError: The message port closed before a response was received.

arr.sort(function(a,b){return a-b;//这个的意思是a大于b的话返回true，表示需要交换

})

(3) [1, 2, 3]

//而且上面可以看到直接在方法里面加函数的话不需要定义名字

undefined

//再举例

undefined

arr4 = [{age:1},{age:45},{age:70}]；

VM12181:1 Uncaught SyntaxError: Invalid or unexpected token

arr4 = [{age:1},{age:45},{age:70}];

(3) [{…}, {…}, {…}]

arr4.sort(function(a,b){return a.age-b.age;})

(3) [{…}, {…}, {…}]0: {age: 1}1: {age: 45}2: {age: 70}length: 3__proto__: Array(0)

arr4

(3) [{…}, {…}, {…}]

arr4.forEach(function(item){

    console.log(item.age);

})

VM12460:2 1

VM12460:2 45

VM12460:2 70

undefined

//上面是一个foreach的方法

undefined

//4、concat方法

undefined

//concat方法是将数组进行合并，这个和上面几个方法的不同点在于它并不会改变原来的数组，而是会产生一个新的数组，原来的数组并不会被修改

undefined

arr.concat([4,5])

(5) [1, 2, 3, 4, 5]

arr.concat([1,2],[4,[56,4]])

(7) [1, 2, 3, 1, 2, 4, Array(2)]

//上面可以看见会将括号里面的第一层数组拉平，但是里面嵌套的数组只会被当作元素

undefined

//5、slice方法是返回某个元素的一个片段，是一个左臂右开的区间,这个函数是支持负数索引的

undefined

arr = [1,2,3,4,5]

(5) [1, 2, 3, 4, 5]

arr.slice(1,3)

(2) [2, 3]

//slice也不会对原数组进行修改

undefined

//6、splice数组拼接，非常鸡肋

undefined

arr

(5) [1, 2, 3, 4, 5]

//function1

undefined

arr.splice(2)

(3) [3, 4, 5]

arr

(2) [1, 2]

// 愿数组被修改，表示从第二个元素一直到尾部全部切下来扔掉

undefined

//function2:添加第二个参数，表示切下来几个

undefined

var arr = [1,2,3,4,5];

undefined

arr.splice(2,2,'a','b')//这个懒得写function3了，基本就是因为是连续切的，你切下来的空白可以用另外一个数组补上

(2) [3, 4]

arr

(5) [1, 2, "a", "b", 5]