数组是数据的有序集合，对象被ECMA定义为一组数据的无序集合，拥有自己的方法和属性（外观和作用）

属性：对象使用的一些数据

方法：对象拥有的操作

内置对象

本地对象，JS语言自带的，还有自定义的对象

创建对象

字面量

let obj = {};//创建一个空对象
let obj = { /创建一个对象并赋值
    name: `zhangsan`,//属性
    age: 18,//属性
    talk: function() {}//方法
};
其中 name age talk为键，`zhangsan` 18为值，他们之间用：分割

构造函数

let obj = new Obiect();
obj.name = `zhangsan`;
obj.age = 18;
obj.talk = function() {};

对象和键和值

对象的某一条数据的键所对应的值是非函数类型，这条数据就是对象的属性

对象的某一条数据的键所对应的值是函数类型，这条数据就是对象的方法

对象属性的操作

点访问法

let obj = {
    age: 18
};
​
obj.name = `zhangsan`; //新增了一个对象的属性
obj.name = `lisi`; //更改了一个对象的属性
delete obj.name; //删除了一个对象的属性
console.log(obj.age); //访问对象的属性，得到的是对象的值//18

方括号访问法[string|variable]

let obj = {
    name = `zhangsan`,
    age = 18
};
console.log(obj[`age`]); //18  以字符串类型访问
let type = `name`; //把name换成了type
console.log([`type`]); //zhangsan  
let type = `age`; //把age换成了type
console.log([`type`]); //18
let type = `job`;
console.log([`type`]); //undefined

对象方法的操作

let obj = {
    name = `zhangsan`,
    age = 18,
    talk = function() {}
};
obj.talk(); //调用方法
delete obj.talk; //删除方法，不能加（）
obj.walk = function() {}; //新增一个方法

语法糖

一条数据放在一个变量中，对象中也有个同变量同名的key，Key所对应的值就是变量所对应的值，可以使用语法糖简写

就是对象的键和值相同，就可以直接写一个

let username = `zhangsan`;
let person = {
    username: username
};
console.log(username); //zhangsan
​
​
let username = `zhangsan`;
let person = {
    username
};
console.log(username); //zhangsan

案例：登录
​

let arr = [{
   username: `zhangsan`,
   password: 123
}, {
   username: `lisi`,
   password: 456
}]
console.log(`请输入用户名`);
let name = readline.question();
console.log(`请输入密码`);
let psw = readline.question();
​
let result = arr.filter(item => item.username == name && item.password == psw)[0];
//undefined   {} 如没有[0]，则返回的是[{ username: `zhangsan`,
   password: 123}],有[0]，返回的是 {username: `zhangsan`,
   password: 123}，
if (result) {
   console.log(`登录成功`);
} else {
   console.log(`输入有误`);
}

对象的遍历

for in

let obj = {
    name: `zhangsan`,
    age: 18,
    gender: `male`
}
for (let key in obj) {
    console.log(key); // name age gender  访问的是对象的键
    console.log(obj[key]); //zhangsan 18 male  访问的是对象的键对应的值
}

Obiect.keys()

let obj = {
    name: `zhangsan`,
    age: 18,
    gender: `male`
}
let arr = Object.keys(obj);
console.log(arr); //[`name`,`age`,`gender`]
for (let item of arr) { //[`name`,`age`,`gender`]
    console.log(obj[item]); //zhangsan 18 male
}

对象的嵌套

let family = {
    peggy: {
        name: `peggy`,
        age: 18
    },
    geo: {
        name: `geo`,
        age: 20
    }
}
console.log(family.geo.name); //geo

解构

解构符号=两边的数据类型必须是一样的

let { name: a } = { name: `zhangsan` };
console.log(a); //zhangsan
​
let { name } = { name: `zhangsan` }//语法糖
console.log(name); //zhangsan

当对象解构没有值就为Undefined,如果设置了默认值，在解构时没有值的情况下，就会选用默认值

let obj = {};
let { name } = obj;
console.log(name); //undefined
​
let { name = `zhangsan` } = obj;
console.log(name); //zhangsan

将对象作参数

可以同时传递多个，顺序可以打乱

let obj1 = {
    name: `zhangsan`,
    age: 18
}
let obj2 = {
    name: `lisi`,
    age: 20
}
let fn = function({ name, age }) { //以对象形式接收
    console.log(`我是${name},${age}岁了`); //我是zhangsan，18岁了
}
fn(obj1);
fn(obj2);

内置对象

常用的字符串属性和方法

常用的数学对象的方法

静态方法和实例方法

静态方法是通过放在类的身上的方法，也叫静态方法（Math.rando() ,Object.keys()）

实例方法是通过实例化new出来的方法，就是我们自己随时let出来的实例（arr.map(), user.some() ,arr.push()）

案例 模糊查询

let str = `徐鑫,郑义,张胜于,赵杰,邓翔,黄飞翔,刘嘉豪,赵鑫勇,吴建磊,何静,孙妃燕,蔡梦蝶,秦阳,何正乾,赖运,刘朝先,赵玲,赵霖,李志超,袁会,陈建良,刘株汛,曾正旭`;
//转换成数组
function find(name) {
   let arr = str.split(`,`).map(item => {
       return { name: item }
   }); //返回一个数组[{}]
   // let name = `GOU`;
   let result = arr.filter(item => item.name.indexOf(name) != -1); //进行删选，把满足条件的返回给一个变量
   return result;
}
let A = find(`赵`) //函数返回值用一个变量去接收
console.log(A);
if (A.length) { //如果有长度代表查到了
   console.log(`查询结果:`, A);
} else { //没有长度，空数组
   console.log(`没有查询到`);
}

创建日期对象

let timeObj = new Date();

获取当前年月日时分秒

let timeObj = new Date();//创建日期对象 //新创建的Date对象表示实例化时刻的日期和函数
let year = timeObj.getFullYear();//获取年份
let month = timeObj.getMonth()+1;//获取月份 从第0月开始 所以需要+1
let day = timeObj.getDate();//获取日
let hour = timeObj.getHours();//获取小时 24小时制
let minute = timeObj.getMinutes();//获取年份分钟
let second = timeObj.getSeconds();//获取秒
console.log(timeObj);

时间戳

//从1970年1月1日0时0点0分0秒到现在的毫秒数
console.log(new Date().getTime());
//获取1970.1.1 0：0：0到现在的秒数
console.log(Math.floor(new Date().getTime()) / 1000); //毫秒转换为秒的计量单位 //到现在的秒数

生成Symbol

使用Symbol()创建

//使用Symbol()创建
let s = Symbol();
console.log(s); //Symbol
console.log(typeof s); //symbol

Symbol 是唯一的

Symbol 对象永远不相等，即便创建是传入了相同的描述信息

// Symbol 对象永远不相等，即便创建是传入了相同的描述信息
let s1 = Symbol("1");
let s2 = Symbol("1");
console.log(s1 == s2);//false
​
let s = Symbol(`一个symbol值`);
let s = Symbol(`一个symbol值`);

​

使用 Symbol 定义key

添加

//Symbol值作为对象key时不能使用.运算符操作；要使用[]
 
obj[symbol] = value
let obj = { [symbol]: value }
Object.defineProperty(obj, symbol, { value: "string" });//.defineProperty  定义属性
​

访问

obj[symbol]