js基础升级打怪（二 类型转换）

一、类型转换

Summary

• Array/Object -> String -> Number
• Boolean -> Number
• 减、正、负、自加、自减、 -> Number
• 相等、大于、小于、大于等于、小于等于 -> Number/ASCII (运算符两边只包含一个引用类型的情形)
• 加 -> String

1 显示类型

Number parseInt

演练

/*----  Number  isNaN ----*/
let r1 = Number(1)
let r2 = Number(true)
let r3 = Number(false)
let r4 = Number('1')
let r5 = Number('0.3140')
let r6 = Number('str')
let r7 = Number('1str')
let r8 = Number(null)
let r9 = Number(NaN)
let r10 = Number(undefined)
let r11 = Number(Infinity) 
let r12 = Number(-Infinity)
let r13 =  Number([])
let r14 = Number([1])
let r15 = Number(['1'])
let r16 = Number([1,2])
let r17 = Number({})
let r18 = Number(new Date())
//结果
r1: 1
r2: 1
r3: 0
r4: 1
r5: 0.314
r6: NaN
r7: NaN
r8: 0
r9: NaN
r10: NaN
r11: Infinity
r12: -Infinity
r13: 0
r14: 1
r15: 1
r16: NaN
r17: NaN
r18: 1668650386232

/*----  parseInt  ----*/
let r1 = parseInt(10)
let r2 = parseInt(10.1)
let r3 = parseInt(10.9)
let r4 = parseInt('10.0')
let r5 = parseInt('10str')
let r6 = parseInt('str10')
let r7 = parseInt(null)
let r8 = parseInt(NaN)
let r9 = parseInt(undefined)
let r10 = parseInt(Infinity) 
let r11 = parseInt(-Infinity)
let r12 = parseInt(false)
let r13 = parseInt(true)

//结果
r1: 10
r2: 10
r3: 10
r4: 10
r5: 10
r6: NaN
r7: NaN
r8: NaN
r9: NaN
r10: NaN
r11: NaN
r12: NaN
r13: NaN

Summary

• Number转换结果是NaN的数据只有非数字字符串、undefined以及NaN；
• Number引用数据类型先转换成原始数据类型也就是字符，再转数字；
• isNaN判断 《===》 Nubner(any)的返回结果是否是NaN
• 任何对象的原始数据类型：{}.toString => '[object Object]',所以Number('[object Object]') => NaN
• 数组的原始数据类型：[].toString => 空,所以Number() => 0;
• ['1'].toString => '1',所以Number('1') => 1;
• ['1','2','3'].toString => '1,2,3',所以Number('1,2,3') => NaN;
• parseInt下取整；
• parseInt自左向右遇到非数字字符，就返回NaN；
• parseInt转换结果不是NaN的数据有：数字、以数字开头的字符串；

Boolean

演练

let r1 = Boolean(0)
let r2 = Boolean('0')
let r3 = Boolean('str')
let r4 = Boolean('')
let r5 = Boolean(false)
let r6 = Boolean(true)
let r7 = Boolean(null)
let r8 = Boolean(NaN)
let r9 = Boolean(undefined)
let r10 = Boolean(Infinity) 
let r11 = Boolean(-Infinity)
let r12 = Boolean([])
let r13 = Boolean({})
//结果
r1: false
r2: true
r3: true
r4: false
r5: false
r6: true
r7: false
r8: false
r9: false
r10: true
r11: true
r12: true
r13: true

Summary

• 只有0、false、''、null、undefined、NaN是假；

2 隐式类型

演练

let r1 = typeof(++a1) // a1 = '1'
let r2 = typeof(++a2) // a2 = '1str'
let r3 = typeof(a2++) // a2 = '1str'
let r4 = typeof(++a3) // a3 = false
let r5 = typeof(++a4) // a4 = true
let r6 = typeof(++a5) // a5 = undefined
let r7 = typeof(++a6) // a6 = null
let r8 = typeof(++a7) // a7 = []
let r9 = typeof(++a8)  //a8 = {}
let r10 = typeof(a1-a2)
let r11 = typeof(a7-a8)
let r12 = typeof(+a2)
let r13 = typeof(+a5)
let r14 = typeof(a1 == a2)
let r15 = typeof(a7 == a8)
let r16 = typeof(typeof(任何值))
//结果
r1: number -- 2
r2: number -- NaN
r3: number -- NaN
r4: number -- 1
r5: number -- 2
r6: number -- NaN
r7: number -- 1
r8: number -- 1
r9: number -- NaN
r10: number -- NaN
r11: number -- NaN
r12: number -- NaN
r13: number -- NaN
r14: boolean -- false
r15: boolean -- false
r15: string

Summary

• 减、正、负、自加、自减 -> 两边转Number
• 相等、大于、小于、大于等于、小于等于 -> 符号两边转Number/ASCII (运算符两边只包含一个引用类型的情形)
• 加 -> String
• ==左右两侧都是引用数据类型时，除自己本身外，和任何值不相等；
• typeof返回值类型是String；

二、代码逻辑

for 机器执行逻辑

for (var i = 0; i < 10; i++) {
  //满足条件执行
  console.log(i)
}
// 第一步： 变量声明 var i； 变量赋值 i = 0；
// 第二步： 判断 0 < 10; 满足条件执行代码块{}；
// 第三步： i++； i=1；
// ...重复第二三步，直到i=10时，不满足条件结束循环；

// 等价
var i = 0
for (; i < 10; ) {
  //满足条件执行
  console.log(i)
  i++
}

// 等价
var i = 1
for (; i++ ; ) {
  //满足条件执行
  console.log(i-1)
  if(i > 9){
    i = 0 || false || undefined || null || NaN || ''
  }
}

// 等价
var i = 1
while(i){
  console.log(i-1);
  i++
  if(i>10){
    i = 0 || false || undefined || null || NaN || ''
  }
}

// 等价
var i = 1
while(i){
  console.log('1',i-1);
  i++
  if(i>10){
    break
  }
}

演练

1. Test： 打印1-100，逢7过；

for (var i = 0; i < 100; i++) {
  //满足条件执行
  (
  (i%7) && 
  (i%10 !== 7) && 
  (parseInt(i/10%10) !==7)
  ) &&
  console.log(i)
}
//排除7的倍数，各位是7，十位是7的数字；

2.  打印0-100数字，（）不能出现i++ i—; {}不能写比较

for (var i = 101; i ;) {
  i-- && console.log(i) 
}

// i++是必然得有的，不能在()中出现，就只能放在{}中；
//上面代码是倒叙打印0-100；
//正序打印只需要改成console.log(100-i)即可；

3. 不用break continue 怎样跳出循环

//判断条件等于false：0、 false、 undefined、 null、 NaN、  ''；
i = 0 || false || undefined || null || NaN || ''

4. 打印2的n次方

for(var sum=1,i = 10; i > 0; i--){
  sum *= 2
}
console.log(sum);

//1024

//累乘

5. 打印n的阶乘 

for(var sum=1,i = 10; i > 0; i--){
  sum *= i
}
console.log(sum);

//3628800

6. 打印123456的个位数 十位数 百位数

//方式一： for
for (var a = 123456, arr = []; a; ) {
  arr.push(a % 10)
  a = parseInt(a / 10)
}
console.log(arr)

// [ 6, 5, 4, 3, 2, 1 ]

//方式二： string方法
var a = 123456
console.log(('' + a ).split('').reverse())

// [ '6', '5', '4', '3', '2', '1' ]

//方式三： 结构赋值
var a = 123456
console.log([...('' + a )].reverse())

// [ '6', '5', '4', '3', '2', '1' ]

7. 打印最大值

const arr = [12, 5, 6, 8, 100, 333]
for (var i = 1, max=arr[i]; i < arr.length; i++) {
  if(max < arr[i+1]){
    max = arr[i+1]
  }
}
console.log(max)

8. 打印100以内的质数

for (var i = 1, arr=[], count = 0; i < 100; i++) {
  for(var j = 1; j <= i ; j++){
    !(i%j) && count++
  }
  if(count == 2) {arr.push(i)}
  count = 0
}
console.log(arr)

//质数只能被1和本身整除，所以满足条件是能被整除的次数是2

9. 打印100以内的斐波那契数列（斐波那契数列 黄金分割数列 兔子数列）

let condition = 0
for (var i = 0, arr = []; condition < 100; i++) {
  if (i <= 1) {
    arr[i] = 1
  } else {
    arr[i] = arr[i - 1] + arr[i - 2]
    condition = arr[i] + arr[i - 1]
  }
}
console.log(arr)

//[1,  1,  2,  3, 5,  8, 13, 21, 34, 55, 89]

10.有一段楼梯有10级台阶，规定每一步只能跨一级或两级，要登上第 10 级台阶有几种不同的走法?

 for( var step = 1, combination = []; step <= 10; step++){
   if(step == 1) {
    combination[step] = 1
   }else if(step == 2) {
    combination[step] = 2
   }else {
    combination[step] = combination[step-1] + combination[step-2]
   }
}
console.log(combination[10]);

// 89

// 一次只能走一级或者两级， 所以走上第十级台阶，只能是从第八级或者第九级登上去的；
// 10级的走法 = 8级的走法 + 9级的走法；

11.一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔子都不死，开始有一对兔子，第十个月有多少只兔子？

// 89

// 假设所有的兔子每个月都能生出一对小兔
// 10月份的兔子数 = 9月份的兔子 + 9月份的兔子
//but 实际上
// 10月份的兔子数 = 9月份的兔子 + 9月份的兔子 - 9月份一月大的兔子
// 10月份的兔子数 = 9月份的兔子 + 8月份的兔子

////所以逻辑和走阶梯一样，当月的兔子数量是前两个月的和；

Summary

• 跳出循环的逻辑就是，让判断条件为false；
• false有：0、 false、 undefined、 null、 NaN、 ''；

---finish