//对于稀疏数组，一般并不含有从0开始的连续索引，一般的length这个属性值比实际的元素个数多

undefined

var arr1 = [undefined];

undefined

var arr2 = new Array(1);

undefined

0 in arr1

true

0 in arr2

false

1 in arr2

false

arr2

[empty]length: 1__proto__: Array(0)

var arr2 = new Array(3,2)

undefined

arr2

(2) [3, 2]

0 in arr2

true

//上面发现一个很奇怪的现象，其实你在用new创建数组的时候，如果你只输入一个数字，那么这个时候就会默认这个数字是你的数组长度，但是如果你输入了一大堆的东西就会认为是一个数组里面的元素

undefined

//当然上面不是我们关注的重点，重点是我们如果只创建的话其实没有任何默认的赋值，甚至是undefined都没有，而只是单纯的申请了一点点的空间，所以用in方法的时候显示false

undefined

var arr3 = [1,2,3];

undefined

arr3.length = 100

100

arr[99] = 1;

VM8114:1 Uncaught ReferenceError: arr is not defined

    at <anonymous>:1:1

(anonymous) @ VM8114:1

arr3[99] = 1;

1

99 in arr3

true

98 in arr3

false

//上面给99赋值了所以有in，98没有

//上面记录的时候有点没有头脑，下面在记录的时候一定要分清楚先后的顺序，最好每个章节一起学习，并且要及时的复习

undefined

//这一章要学习数组，在JavaScript中的数组首先是一个“弱类型”的数组，就是说你可以在其中定义很多的东西，不一定非要是数字类型

undefined

var arr = [1,null,true,undefined,[1,1,2]];

undefined

//里面也可以定义对象，

undefined

//一、创建数组

undefined

//就像上面直接创建

undefined

var a = [,,];

undefined

//上面的方法不建议，创建了“两个”undefined，数组创建的长度是从0～2的23次方

undefined

//2、还可以用object的方法创建

undefined

var arr = new Array(100,false);//可以在里面直接加

undefined

arr

(2) [100, false]

delete arr[0]

true

//但是删除之后，长度是不变的，只是删除的地方变成了undefined

undefined

//push方法

undefined

var arr[];

VM2648:1 Uncaught SyntaxError: Unexpected token '['

var arr = [];

undefined

arr.[0] = 1

VM2722:1 Uncaught SyntaxError: Unexpected token '['

arr[0]= 1

1

arr.push(1)

2

//unshift方法

undefined

//unshift实在数组的头部添加元素

undefined

arr.unshift(1)

3

arr

(3) [1, 1, 1]

//in

undefined

//in方法可以判断数字是否在数组里面

undefined

1 in arr

true

//pop函数，删除掉尾部的元素，也可以用length-1的方法

undefined

arr.pop()

1

arr

(2) [1, 1]

//shift()函数是在头部删除元素

undefined

arr.shift

ƒ shift() { [native code] }

arr.shift()

1

arr

[1]

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

//以上可以看出来数组是动态的

undefined

//数组的遍历:

undefined

//第一种方法就是for循环，这里重要的是forin循环，要注意的是数组也作为一个对象，其实里面的每个元素也可以理解为数组的属性，但是同时原型链上的属性也是作为一个数组的属性会被输出出来，这样的话就会产生一些问题

undefined

arr.prototype.x = 1

VM4710:1 Uncaught TypeError: Cannot set property 'x' of undefined

    at <anonymous>:1:17

(anonymous) @ VM4710:1

Array.prototype.x = 1

1

Array.prototype.x = 'in'

"in"

for(i in arr){console.log(arr[i])}

VM4960:1 1

VM4960:1 in

undefined

//可以看到原型链上的属性也被输出出来了，而且要注意的是数组作为一个对象它的元素的名字就是相应的索引，而值就是里面的值

undefined

//当然可以用hasownproperty的方式判断

undefined

for(i in arr){if(arr.hasOwnProperty(i){console.log(arr[i]);})}

VM5688:1 Uncaught SyntaxError: Unexpected token '{'

for(i in arr){if(arr.hasOwnProperty(i)){console.log(arr[i]);}}

标签属性和标签函数自定义的应用，以及序列化的应用（序列化就是在对象和json之间进行转换，stringfied和parse）

//不能刷新，不能返回，不然全没了

undefined

//对象标签

undefined

//下面一个查看class的标签

undefined

var toString = Object.prototype.toString;//宏定义成一个方便后续使用，以前也讲过用with

undefined

function getType(o){return toString.call(o).slice(8,-1);}//这个是为了截取下来类型

undefined

toString.call(null)

"[object Null]"

//如果上面没有截取就是显示一个带有括号的字符串

undefined

getType(null)

"Null"

getType(1)

"Number"

getTp

VM18518:1 Uncaught ReferenceError: getTp is not defined

    at <anonymous>:1:1

(anonymous) @ VM18518:1

getType(new Number(1))

"Number"

//会发现上面给的不是object而是number，是因为这个是一个传入的参数

undefined

getType([1,2])

"Array"

//extensible标签表示对象是否可以扩展，是否可以继续添加属性

undefined

var obj = {x:1,y:2};

undefined

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

//当然这个extensible是一类标签，他下面有很多方法来进行控制，首先是isExtensible还有seal还有freeze，我们会通过一个案例来进行判断

undefined

Object.isExtensible(obj)

true

Object.preventExtensions(obj)//这个是主要函数，防止扩展

{x: 1, y: 2}

Object.isExtensible(obj)

false

obj.z = 10

10

obj.z

undefined

//上面就会发现不能扩展了

undefined

Object.isSealed(obj)

false

Object.isSealed(obj)//这个函数是查看是否可以删除，sale是封装的意思

false

Object.seal(obj)

{x: 1, y: 2}

Object.isSealed(obj)

true

Object.getOwnPropertyDescriptor(obj)

undefined

Object.getOwnPropertyDescriptor(obj,'x')

{value: 1, writable: true, enumerable: true, configurable: false}

//上面就会发现里面的configureable都变成了false

undefined

Object.freeze(obj)//这个是冻结函数，这个可以进行将属性冻结住，这样这个对象下的所有属性都不可以被改写了

{x: 1, y: 2}

Object.getOwnPropertyDescriptor(obj,'x')

{value: 1, writable: false, enumerable: true, configurable: false}

//会发现上面的writable变成了false

undefined

//！！！但是我们都是只冻结这个对象并不会冻结它的原型链

undefined

//

undefined

//

undefined

//

undefined

//下面序列化的一种方法

undefined

//所谓的序列化就是将obj的所有属性变成一个json对象，这样方便后台进行操作

undefined

var obj = {val:undefined,a:NaN,b:Infinity,c:new Date()};

undefined

JSON.stringify(obj)//这个就是序列化的函数

"{"a":null,"b":null,"c":"2021-03-02T12:05:19.349Z"}"

//会发现输出的结果里面不会显示undefined的属性，nun和infinity都会变成null，date会被另一种格式输出

undefined

//单数不管怎么说，都是json的格式输出出来了

undefined

//当然也可以逆变换，就是将json的格式变成obj形式

undefined

var obj2 = JSON.parse('{"x":1}');

undefined

obj2

{x: 1}

//注意json格式的书写

undefined

//当然序列化也可以自定义，这个情况下就是需要在里面定义一个tojson的函数

undefined

var obj3 = {

    x:1,

    y:2,

}

undefined

var obj3 = {

    x:1,

    y:2,

    o:{

    o1:1,

    o2:2,

    toJSON:function(){return this.o1+this.o2;}

},

}

undefined

obj3.o.o1

1

//上面在属性里面又另外添加了一个toJSON的属性，所以再次序列化的时候就会调用里面的这个函数

undefined

JSON.stringify(obj3)

"{"x":1,"y":2,"o":3}"

//可以看到上面的o就是哦

undefined

//可以看到上面的o就是o1+o2

undefined

//以前讲变量类型的时候只讲过基本类型之间的转换，但是对象也可以转换成基本类型，这个涉及到对象的两个方法，一个是toString方法，一个是valueOf方法，这两个方法是将对象转换成基本类型的常用方法，而且是可以自己进行调用的，你只需要设置

undefined

obj3

{x: 1, y: 2, o: {…}}

obj3.toString()

"[object Object]"

obj.toString() = function(){return this.x+this.y;};

VM25614:1 Uncaught ReferenceError: Invalid left-hand side in assignment

    at <anonymous>:1:5

(anonymous) @ VM25614:1

obj.toString = function(){return this.x+this.y;};

ƒ (){return this.x+this.y;}

//上面就是对tostring的定义

undefined

obj3.toString = function(){return this.x+this.y;};

ƒ (){return this.x+this.y;}

"Result"+obj3;//这个时候就会对这个对象进行隐士的转换成基本类型

"Result3"

+obj3

3

obj3.valueOf = function(){return this.x*this.y;};

ƒ (){return this.x*this.y;}

//上面就是将对象转换成基本类型里面的数字，所以当我们想要转换成数字的时候，例如进行+obj3的操作时候，就会先调用valueOf这个函数，如果报错或者不存在就会寻找tostring这个函数，如果不存在就报错

undefined

+obj3

2

//这个时候就会变成2

undefined

可以

//会发现上面是不能修改了configurable所以一定要进行判断，在这里还有一个configurable和writable不同值情况下的操作情况，有些情况可以被操作，有些不能

undefined

//这集讲解属性的标签

undefined

//一般都有writable表示是否可以写入，enumerable表示是否可以被forin枚举到，configurable表示是否可以删除掉

undefined

//下面我们介绍一种可以进行访问的函数，这个函数可以查看当前属性下的所有的标签

undefined

var person{};

VM16631:1 Uncaught SyntaxError: Unexpected token '{'

Object.defineProperty(person,'name',{

    configurable : false;

})

VM16689:2 Uncaught SyntaxError: Unexpected token ';'

Object.defineProperty(person,'name',{

    configurable : false,

    writable: true,

    enumerable:false,

    value:"Yangdainyi",

})

VM16747:1 Uncaught ReferenceError: person is not defined

    at <anonymous>:1:23

(anonymous) @ VM16747:1

Object.defineProperty(person,'type',{

    value : "OBject",

    writable:true,

    enumerable:true,

    configuarable:false,

})

VM16824:1 Uncaught ReferenceError: person is not defined

    at <anonymous>:1:23

(anonymous) @ VM16824:1

//上面在person下创建了两个属性，我们可以用keys去访问person下所有的属性，会发现只有type，是因为name2的enumerable是false

undefined

Object.keys(person)

VM16922:1 Uncaught ReferenceError: person is not defined

    at <anonymous>:1:13

(anonymous) @ VM16922:1

Object.defineProperties(person,{

    salary:{value:50000,enumerable:true,writable:true},

    luck:{

        get:function(){

        return Math.random()>0.5? 'good':'bad';

},

     promote:{

        set:function(level){

        this.salary *= 1+level*0.1;//给自己加工资，这个下面是会更改当下的salary的

}

} , 

}

})

VM16972:1 Uncaught ReferenceError: person is not defined

    at <anonymous>:1:25

(anonymous) @ VM16972:1

//上面在person下创建了两个属性，我们可以用keys去访问person下所有的属性，会发现只有type，是因为name2的enumerable是false

//读写对象的属性

undefined

//1、属性读写

undefined

var obj = {x:2,y:3}

undefined

obj.x

2

//下面是属性继承和属性枚举的知识，首先是关于属性继承要求是你在创建的时候就要说明的，比如说是

undefined

//上面是两种的方式

undefined

//当然也可以for in 去遍历，但是问题就是会把原型链上的也弄出来，而且顺序不一定

undefined

//还可以用hasOwnProperty

undefined

//这集讲的是关于get和set的方法

undefined

//上集由于脑袋问题没有录上，气死了

undefined

var man = {name:'Boso',weibo:'@Bosn',get age(){return new Date().getFullYear()-2000;},set age(val){console.log('Age can\'t be set to'+val);}}

undefined

console.log(man.age)

VM7522:1 21

undefined

man.age

21

man.age = 100

VM7469:1 Age can't be set to100

100

//这个里面就是有一个get和set进行赋值

undefined

//下面是一种更加高级的做法

undefined

var man = {

    weibo:'@Bosn',

}

undefined

6006:1 Uncaught (in promise) DOMException: The play() request was interrupted by a call to pause(). https://goo.gl/LdLk22

var man = {

    weibo:'@Bosn',

    $age:null,//这个情况下就是将age作为一个可以改变的变量放在里面

    get age(){

    if(this.$age==undefined){

        this.$age = new Date().getFullYear()-2000;

    }

    return this.$age;

},//这个千万不要忘记添加上，因为里面定义的函数也是作为一个元素放在里面

    set age(val){

     val = +val;//这里面的+操作是为了变成数字，隐式转换

     if(!isNaN(val)&&val>0&&val<150){

        this.$age = +val;

}else{

    throw new Error('Incorrect val' + val);

}

}

}

undefined

man.age

21

man.age = 100

100

man.age

100

man.age = 160

function foo(){}

undefined

Object.defineProperty(foo.prototype,)

VM8890:1 Uncaught TypeError: Property description must be an object: undefined

    at Function.defineProperty (<anonymous>)

    at <anonymous>:1:8

(anonymous) @ VM8890:1

Object.defineProperty(foo.prototype,'z',{get:function(){return 1;}});

{constructor: ƒ}

var obj = new foo();

undefined

obj.z = 1

1

obj.z = 10

10

obj.z

1

Object.defineProperty(obj,'z',{value:100,configurable:true});

foo {z: 100}

obj.z

100

delete obj.z

true

obj.z

1

//因为上面删除掉了原来的本身obj上的z所以只能向上寻找z

undefined

//另外有一个上面删掉的内容，就是create这个继承的东西

undefined

var o = {};

undefined

Object.defineProperty(o,'x',{value:1});

{x: 1}

var n = Object.create(o);

undefined

n.x

1

o.x = 100

100

o.x

1

//会发现上面依旧是1，是因为在默认情况下o里面的x是不可writeable的

undefined

//如果要改变这种状态可以先创建一个x，这样在原型链上的x就不会被先访问到

undefined

Object.cra

undefined

Object.defineProperty(n,'x',{value:1,writable:true});

{x: 1}

n.x = 100

100

n.x

100

//就可以更改了

Object.getOwnPropertyDescriptor({pro:true},'pro')

value:属性值

writable:该属性是否可写，可修改true/false

enumerable:该属性是否可被枚举，在for in中出现（是否可遍历true/false）

configurable:该属性的标签是否可改变，是否可用delete将该属性删除true/false

get/set与原型链：

验证对象的属性：hasOwnProperty     obj.hasOwnProperty('a')

验证对象的属性和对象原型链内的属性：in     'a' in obj

严格模式：

try语句如果抛出异常，则执行catch语句，否则不执行，无论有没有异常，都执行finally语句；try语句必须跟catch或finally语句中至少一个组合使用。
try catch语句的嵌套语句执行顺序：
1）如果内部嵌套的try语句抛出异常，但内部没有相配套的catch语句，先执行内部的finally语句，然后跳到最近一层的catch语句执行。
2）如果内部嵌套的try语句抛出异常，内部有相配套的catch语句，先执行此语句处理异常，再执行内部的finally语句。不会再在外部处理异常。
3）如果内部嵌套的try语句抛出异常，内部有相配套的catch语句，并且catch语句也抛出异常，如果内部的catch语句有对异常的处理，先执行异常处理语句，然后执行内部的finally语句，最后执行离内部catch语句抛出异常最近一层的catch语句处理异常。

9

//function

undefined

//对于函数有两种思路，首先是直接声明并配置好，就是我们一般的做法，但是也可以

undefined

var fe = fuction(){};

VM16933:1 Uncaught SyntaxError: Unexpected token '{'

var fe = function(){};

undefined

//但是这个时候就不能在它之前进行调用

undefined

//for

undefined

//for in语句

undefined

var p;

undefined

var obj = {x:1,y:2}

undefined

for(p in obj){

}

undefined

//上面的forin 语句可以调用一个obj里面的一些属性对象，但是问题就是顺序是不确定的，而且会受到原型链的影响，当enumerable为false时候不会出现

undefined

//with语句是一个用来限制作用域的语句，它的作用首先就是用with把语句限制在一定的范围里面，然后在这个范围里面有一个块函数可以进行操作

undefined

with({x:1}){

console.log(x);}

VM18409:2 1

undefined

//会发现上面其实就不再需要进行调用obj。x了

undefined

//但是上面的那个也很鸡肋，因为完全可以先把你的作用域定义给一个函数，然后再在这个函数下进行相关操作

undefined

//运算符

undefined

//比较少见的有一个，运算符

undefined

var val = (1,2,3)

undefined

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

val

3

//，其实是每个都会计算，但是只输出最后的一个

undefined

//2另外就是删除这个

undefined

var obj = {x:1};

undefined

obj.x

1

Object.defineProperties(obj,'x'{

                        })

VM13336:1 Uncaught SyntaxError: missing ) after argument list

Object.defineProperties(obj,'x'{

                        })

VM13340:1 Uncaught SyntaxError: missing ) after argument list

Object.defineProperties(obj,'x',{configurable

                        })

VM13393:1 Uncaught ReferenceError: configurable is not defined

    at <anonymous>:1:34

(anonymous) @ VM13393:1

Object.defineProperty(obj,'x'{})

VM13539:1 Uncaught SyntaxError: missing ) after argument list

Object.defineProperty(obj,'x',{})

{x: 1}

Object.defineProperty(obj,'x',{

    configurable : false,

})

{x: 1}

delete obj.x

false

//这个时候就会发现里面的configurable是true

undefined

//in判断符

undefined

window.x = 1

1

x in window

true

function Foo(){}

undefined

Foo

ƒ Foo(){}

Foo.prototype.x = 1;

1

var obj = new Foo()

undefined

obj.x

1

obj.hasOwnProperty('x');//判断在obj里面是否含有x这个属性，因为x是在obj的prototype里面，所以也不会被检测到

false

obj.__proto__.hasOwnProperty('x')

true