2、作业题讲解

1、let str = 100 + true + 21.2 + null + undefined + 'Tencent' + [] + null + 9 + false

 +号规律：在+号两边出现字符串(或者对象)的情况下，加号一定是字符串拼接
对象本身是要转换为数字进行运算的，只不过在转换为数字的过程中，要先转
换为字符串，而一旦出现字符串，就直接变成了字符串拼接

100 + true => 100 + 1 = 101
101 + 21.2 = 122.2
122.2 + null =>122.2 + 0 = 122.2
122.2 +undefined => 122.2 + NaN = NaN
NaN + 'Tencent' => 'NaNTencent'
'NaNTencent' + [] => 'NaNTencent' + '' = 'NaNTencent'
'NaNTencent' + null = 'NaNTencentnull'
'NaNTencentnull' + 9 = 'NaNTencentnull9'
'NaNTencentnull9' + false = 'NaNTencentnull9false'

2、[] == false
![] == false

== 在进行数据比较的时候，如果左右两边的数据类型不一致，则需要先转换为一致的数据类型，然后再进行比较。
=== 绝对相等，两边的类型一致，值一致才相等，否则不相等。

== 的转换规律：
（1）对象 == 字符串  对象转换为字符串；
[10] == 10   // true
（2）null == undefined (三个等号下不相等)，但是和其他任何的值都不相等；
（3）NaN和任何值（包括自己）都不相等；
（5）剩下的情况都是转换为数字再进行比较；

[] == false => 两边都转换为数字
[]先调用 toString 方法转换为 ''，再转换为数字 0;
false变为数字 0 
[] == false  // true

![] == false
由于运算符优先级先运算 ![];
![]转换为布尔类型：只有 0/NaN/null/undefined/'' 五个值是false，其他值都是true
[] => true 
![] => false 
![] == false  //  true

{} + 0 ? alert('ok') : alert('no')
0+ {} ? alert('ok') : alert('no')

{}在JS中比较特殊：既可以作为对象，也可以当成代码块（块级作用域）
此处就是把 {} 当做代码块
{} + 0 ? alert('ok') : alert('no')   // alert('no')

{} + 0 ? alert('ok') : alert('no')  // alert('yes')

{} + 0  => 是把 {} 和 +0 分开，所以只剩 0 ? alert('ok') : alert('no') 
而 0 + {} 是把整个表达式进行运算，就变成了字符串拼接 '0[object Object]'

大括号运算规律：
（1）大括号在运算符前面，在没有使用 () 包裹 {} 的情况下，不认为是数学运算，当成代码块；
如果使用了 () 包裹，则认为是数学运算，变成了字符串拼接；
（2）大括号在运算符后面，只是数学运算；

var a = {}, b = '0', c = 0;
a[b] = '珠峰'
a[c] = '培训'
console.log(a[b])
================
var a = {}, b = Symbol('1'), c = Symbol('1');
a[b] = '珠峰';
a[c] = '培训';
console.log(a[b]);
================
var a = {}, b = {m:'1'}, c = {m:'2'};
a[b] = '珠峰';
a[c] = '培训';
console.log(a[b]);

考察只是：JS中普通对象的属性名问题：
（1）一种观点认为JS中普通对象的属性名只能是字符串；
（2）另一种观点认为JS中普通对象的属性名可以是基本数据类型的值；
两种观点的最终结果是一致的，但是个人认为第二种是最正确的理解；

var a = {}, b = '0', c = 0;
a[b] = '珠峰'
a[c] = '培训'
console.log(a[b])  // ‘培训’
JS底层在处理属性名时，a['0'] 和 a[0]不是同一个，但是底层处理的时候，
最终会转成 a['0']

var a = {}, b = Symbol('1'), c = Symbol('1');
a[b] = '珠峰';
a[c] = '培训';
console.log(a[b]);  // '珠峰'

var a = {}, b = {m:'1'}, c = {m:'2'};
a[b] = '珠峰';
a[c] = '培训';
console.log(a[b]);   // 培训  {[object Object]: "培训"}

var a = {n:1};
var b = a;
a.x = a = {n:2}
console.log(a.x)
console.log(b)

var a = {n:1};
var b = a;
a.x = a = {n:2}
console.log(a.x)  // undefined
console.log(b)  // { n: 1x: {n: 2}}

运算规律：因为运算符优先级的问题，会先给 a.x关联指向，再给 a 关联指向