let obj ={} let a={ n:100 } let b= { n:200 } obj[a]=100 obj[b]=200 console.log(obj[a])
说答案
结果 ：200
原因：
因为索引 key 为数字或字符串，对象会被转为字符串 "[object Object]"，所以obj[a],obj[b]访问的都是同一个key
let a={ n:100 } let b= { n:200 }
中间 这段代码无意义。
const 声明
const 的行为与 let 基本相同，唯一一个重要的区别是用它声明变量时必须同时初始化变量，且
尝试修改 const 声明的变量会导致运行时错误。
但是！
const 声明的限制只适用于它指向的变量的引用。换句话说，如果 const 变量引用的是一个对象，
那么修改这个对象内部的属性并不违反 const 的限制。
const person = {}; person.name = 'Matt'; // ok
Null 类型同样只有一个值，即特殊值 null。逻辑上讲，null 值表示一个空对象指针，这也是给typeof 传一个 null 会返回"object"的原因：
let car = null; console.log(typeof car); // "object"
存储浮点值使用的内存空间是存储整数值的两倍, 所以 ECMAScript 总是想方设法把值转换为整数
浮点值的精确度最高可达 17 位小数，但在算术计算中远不如整数精确。例如，0.1 加 0.2 得到的不是 0.3，而是 0.300 000 000 000 000 04
NaN 不等于包括 NaN 在内的任何值。例如，下面的比较操作会返回 false：
console.log(NaN == NaN); // false
8/27 又来一题
一：
let p = new Promise(function(resolve,reject){ reject(); resolve(); }) p.then(function(){ console.log('成功') },function(){ console.log('失败') })
不要试图敲代码输出
答案： console.log('失败')
解析： promise最重要的特性就是状态一经改变就无法更改， 首先初始化状态为pending，执行reject后状态变为rejected，变为失败之后 即使后面是resolve， 也不执行了
二：
Promise.resolve(1) .then(res => 2) .catch(err => 3) .then(res => 5). then(res=> console.log(res))
答案： 5
解析：除了第一个 then ，以后的所有的 then 都是上一个 then 中的返回结果，首先是promise具有链式调用的特性， then接收两个函数一个成功，一个是失败函数， 第一个resolve(1)， 不管括号里是什么。 其实就是返回一个成功的状态
三：
Promise.resolve(1) .then((x) => x + 1) .then((x) => { throw new Error('My Error') }) .catch(() => 1) .then((x) => x + 1) .then((x) => console.log(x)) .catch(console.error)
答案： 2
promise为什么能形成链式调用？ 因为他返回的不是本身this而是创建了一个新的promise Promise.resolve(1) .then((x) => x + 1) .then((x) => { throw new Error('My Error') }) .catch(() => 1) // 虽然上一个then抛出错误，但是这里catch返回的是常量。 就会继续走下一个then .then((x) => x + 1) // 1 +1 .then((x) => console.log(x)) // 2 .catch(console.error)
catch函数依旧return 的是常量。 就继续走then。 没有返回值，就停止了
链式调用只要有返回值就是返回新的promise函数，这样你就不会觉得错误直接就停止
四：
Promise.resolve(1) .then((res) => { console.log(res) return 2 }) .catch((err) => { return 3 }) .then((res) => { console.log(res) })
答案： 1,2
五：
Promise.resolve() .then(() => { return new Error('error!!!') }) .then((res) => { console.log('then: ', res) }) .catch((err) => { console.log('catch: ', err) })
答案： console.log('then: ', res)
除了promise.reject或者throw error 。 其他无论返回什么都走外层then函数， 第一个 .then(() => { return new Error('error!!!') }) 里面 是return 的一个错误， 会继续走下一个then。
如果第一个 ， 修改成这样 .then(() => { throw error（‘xxx’） }) 答案就是console.log('catch: ', err)
六：
Promise.resolve() .then(() => { return Promise.reject('错误') }) .then((res) => { console.log('then: ', res) }) .catch((err) => { console.log('catch: ', err) })
答案： console.log('catch: ', err)
Promise.resolve(1) .then(2) .then(Promise.resolve(3)) .then(console.log)
答案： 1
解析：
因为resolve后面的then传递的是一个非函数，promise就会把值传递给下一个then函数,发现下一个then函数还不是函数,就一直传到最后
.then((x) => x + 1) 这种即是 返回的是函数 .then(2) 这种就是非函数,意思就是个常量传进去了
这是then函数里面的实现，throw error他会用try catch 捕获，执行reject。
而只是单纯return ，你传的newError这个实例，他会走resolve
就是throw error 其实和reject 走的相同路线了
var lsg = '笨' let zqh =lsg zqh ='聪明' console.log('lsg', lsg)
打印"笨"。 lsg 是字符串。 zqh = lsg。 现在他俩值相同。 修改各自的值， 别人不会受影响
var lsg = { zs:'笨' } let zqh =lsg zqh.zs = '聪明' console.log('lsg', lsg.zs)
打印“聪明” 说明zs指向了同一个内存地址，所以值相同 . 因为lsg是obj类型。 zqh = lsg 也就是浅拷贝了一份lsg的数据。修改lsg 或者zqh 。 zs的值， 两个都会被修改。
因为他们分属不同内存地址
let a = { n: 1 } a.x = a = { n: 2 } let b = a console.log(a.x) console.log(b)
首先我们看执行顺序 首先我们命名变量 a，其次开启一个空间去储存n:1,然后变量a指向内存地址1。
第二部分 a.x =a = {n:2}, 我们在内存地址1的地方开辟一个x变量储存a ，而a指向了内存2，内存2没有x属性，所以为 undefined
let a = { n: 1 } let b = a a.x = a = { n: 2 } console.log(a.x) console.log(b)
打印b：
{ n: 1， x :{ n: 2 } }
