let obj = {
  [Symbol.toPrimitive](hint) {
    switch (hint) {
      case 'number':
        return 123
      case 'string':
        return 'str'
      case 'default':
        return 'default'
      default:
        throw new Error()
    }
  }
}

2 * obj // 246
3 + obj // '3default'
obj == 'default' // true
String(obj) // 'str'

//1、在自定义对象中没有重新定义toString()方法
const obj = {}
console.log(obj.toString()) // [object Object]

//2、重新定义了toString()方法和valueOf()方法
//首先尝试toString()方法，其存在且返回原始值，就使用该值将其转换为字符串
const obj = {
  toString() {
    return '42'
  },
  valueOf() {
    return '422'
  }
}
console.log(String(obj)) // 42

//3、toString()方法不返回原始值,尝试valueOf
const obj = {
  toString() {
    return {}
  },
  valueOf() {
    return '422'
  }
}
console.log(String(obj)) // 422

//1、在自定义对象中没有重新定义toString()方法和valueOf()方法
//valueOf()方法默认情况下只返回对象本身，而非返回原始值,因此它会再去尝试toString方法
该对象的toString方法返回的是[object Object]，因此再进行Number转换时为NaN
const obj = {}
console.log(Number(obj)) // NaN

//2、偏数值算法首先尝试valueOf()方法，该方法存在且返回422，因此最后转换的值为422
const obj = {
  toString() {
    return '42';
  },
  valueOf() {
    return '422';
  }
};
console.log(Number(obj));  // 422


//3、valueOf()方法不存在，因此再尝试toString方法，该方法返回42，因此最后转换的值为42
const obj = {
  toString() {
    return '42';
  }
};
console.log(Number(obj));  // 42

console.log(Number([])) // 0
console.log(Number([2])) //2
console.log(Number([1, 2, 3])) //NaN

var a = new Boolean(false)
console.log(a) // Boolean {false}
if (!a) {
  console.log('假')
} else {
  console.log('真')
}
//最终执行的结果为"真"

const a = null
const b = undefined
const c = new Number(12)
const d = new Boolean(false)

//使用原生函数String()转换
console.log(String(a)) //'null'
console.log(String(b)) //'undefined'

//调用内部属性toString()方法返回值
console.log(c.toString()) //'12'
console.log(d.toString()) // 'false'

const a = 1.07 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000
console.log(a.toString()) //'1.07e+21'

//布尔值，数字，字符串的包装对象在序列化过程中会自动转换成对应的原始值
console.log(JSON.stringify(new Number('11'))) //11
console.log(JSON.stringify(new String(false))) //"false"
console.log(JSON.stringify(new Boolean([]))) //true

//如果undefined，函数，symbol值被单独转换时，会返回undefined
console.log(JSON.stringify(undefined)) //undefined
console.log(JSON.stringify(function () {})) //undefined
console.log(JSON.stringify(Symbol(''))) //undefined

//NaN，Infinity格式的数值以及null都会被当做null
console.log(JSON.stringify(NaN)) //null
console.log(JSON.stringify(Infinity)) // null

//Date日期调用了toJSON()将其转换为了string字符串，因此会被当做字符串处理
console.log(JSON.stringify(new Date())) //"2022-08-04T12:09:16.131Z"

//对包含循环引用的对象（对象之间相互引用，形成无限循环）执行此方法会出现错误
let obj = {
  name: 'Bruce'
}
obj.obj1 = obj
console.log(JSON.stringify(obj)) // Converting circular structure to JSON

var a = new Boolean(false)
var b = new Number(0)
var c = new String('')
var d = Boolean(a && b && c)
console.log(d) // true
console.log(a && b && c) //  String {''}

Boolean({}) // true

var a = []
var b = {}
var c = function () {}
var d = Boolean(a && b && c)
console.log(d) // true

基本类型
console.log(String(null));  //'null'
console.log(String(undefined));  //'undefined'
console.log(String(12));         //'12'
console.log(String(true));         //'true'

引用类型   详见上述抽象操作ToPrimitive 对象到字符串的转换
String({})    // '[object Object]'
String([])    // ''

var a = 42
console.log(a.toString()) // "42"

//false,null,''（空字符串）转换为0，true转换为1，undefined转换为NaN
console.log(Number(null)); // 0
console.log(Number(false)); //0
console.log(Number(true)); //1
console.log(Number(undefined)); //NaN

//字符串转换为数字，处理失败时转换为NaN
console.log(Number('12')); // 12
console.log(Number('a12')); //NaN
console.log(Number('12a')); //NaN
console.log(Number('0x99f')); //2463  (十六进制转为十进制)
console.log(Number('0b110')); // 6（二进制转十进制）
console.log(Number('0o117')); //79 （八进制转十进制）

引用类型   详见上述抽象操作ToPrimitive 对象到数值的转换
Number({})    // NaN
Number([])    // 0

var a = '3.14'
console.log(+a, typeof +a) // 3.14  number

//获取时间戳
console.log(Date.now()) // 1661496319213
console.log(+new Date()) // 1661496330400

//强制将字符串转换为数字,字符串中含有非数字时返回NaN
console.log(Number('123ab')) //NaN

//解析数字字符串,允许含有非数字
console.log(parseInt('123ab')) //123

//数组首先会被隐式转换为字符串'1,2,3'，然后在对其进行解析，遇到非数字字符停止解析
console.log(parseInt([1, 2, 3])) // 1

//布尔值转换为"true"，再对其进行解析，由于解析非数字，则返回NaN
console.log(parseInt(true)) //NaN

// 1/0首先被隐式转换为字符串'Infinity',然后遇到第一个字符I在十九进制数中为18
console.log(parseInt(1 / 0, 19)) // 18   不是NaN
// 首先字符串转换为'0.00006',再进行解析
console.log(parseInt(0.00006)) // 0  不是0.00006
// 首先字符串转换为'6e-7',再进行解析
console.log(parseInt(0.0000006)) //6  不是0.0000006

基本类型
Boolean(undefined) // false
Boolean(null) // false
Boolean(false) // false
Boolean(0) // false
Boolean(NaN) // false
Boolean('') // false

引用类型
Boolean({}) // true
Boolean([]) // true

let a = '12'
let b = '34'
console.log(a + b) //'1234'

//数组首先调用ToPrimitive抽象操作转换为字符串'1,2'和'3,4'
console.log([1, 2] + [3, 4]) //'1,23,4'

console.log(1 + true) // 2

console.log(1 + '1') // '11'
console.log('1' + true) // '1true'
console.log('1' + null) // '1null'

console.log([2] - [1]) // 1
console.log('2' - '1') // 1

let a = '18123'
let b = '12dddd'
let c = null
let d = true

a = a * 1
b = b - 1
c = c - 1
d = d / 1

console.log(a) // 18123 a转换为Number为18123
console.log(b) // NaN   b转换为Number为NaN
console.log(c) //-1     c转换为Number为0
console.log(d) // 1     d转换为Number为1

const a = []
a && console.log('真') // 真
!a && console.log('假')

const b = {}
b && console.log('真') // 真
!b && console.log('假')

const c = null
c && console.log('真')
!c && console.log('假') //假

var a = 42;
var b = '42';
console.log(a===b) // false
console.log(a==b) // true
对于严格相等，a===b为false，因为其类型不同
对于非严格相等，a==b为true，这两个值得类型不同，非严格相等会对其中之一或两者进行强制类型转换
比较规则：判断b是字符串，首先将b转换为数值类型，再和a进行比较。

//1、字符串与布尔类型的比较
console.log("42" == true)  //false
// 比较规则：布尔类型true转换为数值类型为1，字符串'42’转换为数值为42,1和42再进行比较结果不成立，因此为false

//2、数值与布尔类型比较
console.log(1 == true)  //true
比较规则：布尔类型true转换为数值类型为1，1和1比较相等，因此为true

console.log(42 == [42])  // true
比较规则：[42]转换为原始值-> '42',然后再根据字符串与数值的比较规则进行比较

console.log(0 == []) //true
比较规则：[]转换为原始值-> '',然后再根据字符串与数值的比较规则进行比较