基本数据类型 string number boolean null underfined
复杂数据类型 object Math Date String Number Boolean ...
Symbol
-ES6新增的基本数据类型
-ES6引入Symbol的原因：
ES5的对象属性名都是字符串，容易造成属性名冲突，比如，使用了一个他人提供的对象，想为这个对象添加新的方法，新方法的名字就有可能与现有方法产生冲突。如果有一种机制，保证每个属性名字为独一无二，这样会从根本上防止了属性名的冲突。
-Symbol表示独一无二的值
定义： let sym=Symbol()
let sym=Symbol(描述符) ==>描述Symbol表示什么意义
function test() {
let num = 100
let str = 'ahja'
let sname = Symbol('name')
let sname2 = Symbol('name')
let obj = {
name: 'jack',
age: 18
}
let newObj = {
...obj,
name2: 'rose'
}
console.log(newObj)
}
test() 
若是将newObj中的name2改为name，则打印输出为：
rose的name会覆盖掉jack,若是rose写在...obj的前面， 则rose会被jack覆盖
function test2(){
let num=100
let srt='helloword'
let sname=Symbol('name')
let sname2=Symbol('name')
console.log(typeof num)
console.log(typeof str)
console.log(typeof sname)
console.log(sname==sname2) //判断两个Symbol是否相等，为false，所以Symbol是独一无二的值
}
test2()set复杂数据类型：
作用：存储无序数据的集合
创建：new语句
let set =new Set() // 空集合
let set =new Set ( [ 1,2 ,{ name : 'jack' }],[ function () {}, ' hello ' ] )
function test(){
let set=new Set([1,2,'hello',{name:'jack'},function(){console.log(1)}])
console.log(set)
}
test()
属性和方法：
size:用来获取该数据结构中有多少个数据
function test1(){
let set=new Set([10,20,30])
console.log(set)
console.log('size',set.size)
}test1()
add：用来向该数据类型中追加数据
let set=new Set([10,20,30])
btnAdd.addEventListener('click',function(){
set.add(40)
console.log(set)
})
delete：用来删除该数据结构中的某一个数据
let set=new Set([10,20,30])
btnDelete.addEventListener('click',function(){
set.delete(30)
console.log(set)
})
clear：清空数据结构中的所有数据
let set=new Set[10,20,30]
btnDelete.addEventListener('click',function(){
set.clear()
console.log(set)
})
forEach：用来遍历Set数据结构的方法
let set=new Set([10,20,30])
set.forEach(function (item) {
console.log(item)
}) 
获取Set结构里面的数据需要借助一个...展开运算符
//获取数据
function test2(){
//集合转数组
let set =new Set([11,2,3])
let arr=[...set]
console.log(arr)
console.log(arr[0])
}
test2() 
Set特点：集合中的元素不能重复
应用：数组去重：
// 数组去重
function test3(){
let arr=[10,20,30,40,50,10,20]
// 方法一：
let set=new Set(arr)
arr=[...set]
console.log(arr)
// 方法二
// arr=[...new Set(arr)]
// console.log(arr)
}
test3()
回忆之前学习数组去重时，用的两种方法是：
+indexof（找数组中某一项的索引，找到返回1）或者includes（检测数组中是否包含有所找的元素）以及+ 双重for循环 + splice
思想：定义一个新数组,存储不重复元素
遍历原数组, 判断新数组中是否存在原数组元素，如果不存在，加入新数组
let arr = [1,2,1,2,4]
let newArr = []
arr.forEach((item)=>{
if(newArr.indexOf(item) == -1){
newArr.push(item)
}
for(let i = 0; i < arr.length; i++){
let item = arr[i]
for(let j = i+1; j<arr.length; j++){
if(item == arr[j]){
arr.splice(j,1)
j--
}
}
}
Map为复杂数据类型
作用：一个数据集合，是一个很类似于对象object的数据集合
map存储的数据也是key/value形式，key可以是任意类型
创建：
let map=new Map()
let map=new Map( [ ['name','jack' ]，[ 100,18 ] ] )
属性和方法：
size：获取该数据类型中数据的个数
function test2(){
let map=new Map([['name','jack'],[100,18],])
console.log(map)
console.log(map.size)
}test2()
delete:删除该数据集合中的某一个数，注意点：map中的属性有‘’号，在delete的方法中，应该要对应的加上，如下图的name一样。
function test2(){
let map=new Map([[100,18],['name','jack'],])
//删除元素
map.delete(100)
//map.delete('name')
console.log(map)
}test2() 
set：向该数据集合中添加数据
function test2(){
let map=new Map([['name','jack'],[100,18],])
//添加元素
map.set(true,'成立')
console.log(map)
}test2()
get：获取该数据中的某一个数据
function test2(){
let map=new Map([[100,18],['name','jack'],])
//获取元素
let map1= map.get('name')
console.log(map1)
}test2()
clear：清空该数据中所有数据
function test2(){
let map=new Map([[100,18],['name','jack'],])
map.clear()
console.log(map)
}test2()
has：判断该数据中是否存在一个数据
function test2(){
let map=new Map([[100,18],['name','jack'],])
//判断集合是否有数据
let isHas=map.has('name')
console.log(isHas)
}test2()
特点:查找存储在map中的数据，可以不用遍历，根据key直接获取
value = map.get(key)
function test3(){
let arr=[
{ name: '钢筋', value: 11 },
{ name: '水泥', value: 12 },
{ name: '混泥土', value: 13 },
{ name: '加气砖', value: 14 },
]
let map=new Map()
arr.forEach(item=>{
map.set(item.value,item.name)
})
// arr.forEach(function(item,index){
// })
console.log(map.get(12))
}
test3()
for - of 循环
作用: 遍历数组， 字符串 Map
对象 for-in
语法:
for(let v of arr){
//遍历数组 v:数组元素
}
let str = 'hellworld'
for(let v of str) {
//v 字符
}
function test1(){
//遍历对象object
//for-in
let obj={
name:'jack',
age:18
}
for (let key in obj){
console.log(key,obj[key])
}
}
// test1() 
function test2() {
let arr = [10, 20, 30, 40]
for (const v of arr) {
console.log(v)
}
let str = 'hello'
for (const v of str) {
console.log(v)
}
let map = new Map([['hello','world'],[100,true]])
for (const v of map) {
console.log(v);
}
}
test2() 
模块化语句 ：import / export
模块化：
- 每个js文件可以看作一个模块xx.js
- 每个js模块中的内容与其它模块相互独立
=> 模块间通讯
第一次方式
a.js 暴露模块 export 变量或方法名
b.js 引入模块
import {变量,方法} from './a.js'
index.html
<script type="module">
import {变量,方法} from './a.js'
</script>
第二方法
export default {
name:'jack'
}
import A from 'c.js'
如果这样暴露，默认暴露，只能用一次
js错误处理机制
javascript引擎负责执行javascript代码,
如果发现错误代码，抛出异常错误, 如果异常错误没有处理语句,继续向上抛,至到系统处理
系统处理方式: 终止程序执行，在控制显示异常错误信息
异常错误类型
每个异常对应一个异常对象
SyntaxError 语法错误
ReferenceError 引用错误
TypeError 类型错误
RangeError 值超出有效范围时发生的错误
自己捕获异常进行处理
try{
// 可能发生异常的代码
}catch(error){
console.log(error)
}