1、循环

1）for循环

  1. // 1、声明变量且赋值 2、判断条件 3、条件自加
  2. for (var i = 0; i < 10; i++) {
  3.   console.log(i);
  4. }

在for循环的初始化代码中，其实是可以不使用变量声明关键字的。不过，初始化定义的迭代器变量在循环执行完成后几乎不可能再用到了。

  1. // 无穷循环
  2. for (;;) {  
  3.   doSomething(); 
  4. }

for循环的执行过程可以拆分为：

  • 声明变量 var i = 0;
  • 判断条件 i < 10;
  • 变量自加 i++
  • 判断条件…（下一轮）
  • …

根据执行过程可以将for循环拆分成：

  1. var i = 0;
  2. for(;i<10;){
  3.   console.log(i)
  4.   i++
  5. }

这里插入一到面试题： 用 for 循环输出 0-100 的数字，() 只能有一句，不能写比较，{} 不能出现 i++ 或者i— 

  1. var i = 100; // 从 100 开始自减
  3. // () 只能有一句，不能写比较，所以我们要考虑判断条件
  4. // 当 100 自减到 0 的时候就会判断 0 为 false
  5. // {} 不能出现 i++ 或者i-- ，所我我们只能将 i-- 放到 （） 中
  6. for (; i--; ) {
  7.   console.log(i);
  8. }

2）while循环
先判断循环条件，再执行循环体内的代码。

  1. while (i < 10) {
  2.   console.log(i);
  3.   i++;
  4. }

3）do...while...循环
不在乎循环条件是否成立都会先执行一次，然后再判断循环条件。

  1. do {
  2.   console.log("执行")
  3. } while (condition);

4）终止循环
break和continue语句为执行循环代码提供了更严格的控制手段。
break语句用于立即退出循环，强制执行循环后的下一条语句。
continue语句也用于立即退出循环，但会再次从循环顶部开始执行。

  1. for (let i = 1; i < 10; i++) {
  2.   if (i == 5) {
  3.     break;
  4.   }
  5.   console.log(i) // 1 2 3 4
  6. }
  1. for (let i = 1; i < 10; i++) {
  2.   if (i == 5) {
  3.     continue;
  4.   }
  5.   console.log(i) // 1 2 3 4 6 7 8 9
  6. }

2、引用值初识

JS中「引用数据类型」有：Object、Array、Function、Date、RegExp

Array的基本使用：

  1. var arr = [1,2,3,4,5];
  2. arr[0];
  3. arr[3] = null;
  4. arr.length; // 5

Object的基本使用：

  1. var obj = {
  2.   name:"Job",
  3.   age:18
  4. }
  5. obj.height = 180;
  6. obj.name; // "Job"

3、typeof 数据检测

typeof用来确定任意变量的数据类型。对一个值使用typeof操作符会返回下列字符串之一：

  1. // typeof(123) 和 typeof 123 是一样的。
  3. console.log(typeof 123); // number
  4. console.log(typeof "123"); // string
  5. console.log(typeof true); // boolean
  6. console.log(typeof undefined); // undefind
  7. console.log(typeof null); // object
  8. console.log(typeof {}); // object
  9. console.log(typeof []); // object
  10. console.log(typeof function () {}); // function

根据以上的输出可以看出：Object、Array、Function都属于object类型。

可是null为什么也属于object呢？
这是一个历史遗留问题，因为特殊值null被认为是一个对空对象的引用。

面试题： console.log(typeof a); // string console.log(typeof typeof a) // string 记住 typeof 的返回值是 String 类型！！！

4、显示类型转换

显示类型转换主要有：Number、String、Boolean

Number 类型

1) Number()

  1.   console.log(Number("123")); // 123
  2.   console.log(Number("true")); // NaN，非字符串数字返回 Not a Number
  3.   console.log(Number(null)); // 0，记住！！！
  4.   console.log(Number(undefined)); // NaN，记住！！！
  5.   console.log(Number(true)); // 1
  6.   console.log(Number(false)); // 0

2) parseInt()
只要不是数字和字符串数字全部返回NaN
如果第一个字符不是数字，立马返回NaN
如果第一个字符是数字，或者+、-则继续检测每个字符，直到遇到非数字或者末尾

  1. console.log(parseInt("123")); // 123
  2. console.log(parseInt("abc123")); // NaN
  3. console.log(parseInt("123abc")); // 123
  4. console.log(parseInt("")); // NaN
  5. console.log(parseInt(3.5)); // 3.5
  6. console.log(parseInt(true)); // NaN
  7. console.log(parseInt(null)); // NaN
  8. console.log(parseInt(undefined)); // NaN
  9. console.log(parseInt(NaN)); // NaN

parseInt()还支持第二个参数，指定要转换的数据进制。

  1. // 16进制：0123456789abcdef
  2. // 2进制：01
  3. // 10进制：0123456789
  5. var a = "b";
  6. console.log(parseInt(a, 16)); // 11,因为b在16进制中11的位置

3) parseFloat()
parseFloat()转换的规则和paresInt()一样

  1. console.log(parseFloat("3.1415926")); // 3.1415926
  2. console.log(parseFloat("3.1415acb926")); // 3.1415
  3. console.log(parseFloat(3)); // 3

总结：parseInt()和parseFloat()更专注字符串数字，而Number()会尝试将各种数据类型转换成Number类型。

4) isNaN()
该函数接收一个参数，可以是任意数据类型，然后判断这个参数是否“不是数值”。把一个值传给isNaN()后，该函数会尝试把它转换为数值。某些非数值的值可以直接转换成数值，如字符串”10”或布尔值。任何不能转换为数值的值都会导致这个函数返回true

  1. console.log(isNaN(NaN)); // true
  2. console.log(isNaN(10)); // false，10 是数值
  3. console.log(isNaN("10")); // false，可以转换为数值10
  4. console.log(isNaN("blue"));  // true，不可以转换为数值
  5. console.log(isNaN(true));  // false，可以转换为数值1

NaN 不等于包括 NaN 在内的任何值。

  1. console.log(NaN == NaN); // false

String 类型

1) toString()
除了Null和Undefind几乎所有的值都有toString()方法。

  1. console.log(123.toString()); // "123"
  2. console.log("123".toString()); // "123"
  3. console.log(true.toString()); // "true"
  5. var a = {};
  6. a.toString() // '[object Object]'
  8. var b = function(){}
  9. b.toString() // 'function(){}'
  11. var c = undefind;
  12. c.toString(); // error

2) String()
如果不确定一个值是Undefind或者Null，可以使用String()

  1. String(undefined) // "undefind"
  2. String(null) // "null"
  3. String(123) // "123"
  4. String(true) // "true"

Boolean 类型

Boolean()尝试将数据转换成Boolean类型
Boolea()会将undefind、null、NaN、""、0、false转换成false，其他的都是true

  1. console.log(Boolean(1)); // true
  2. console.log(Boolean(null)); // flase
  3. console.log(Boolean(" ")); // true
  4. console.log(Boolean("")); // false

5、隐式类型转换

明文意思就是不告诉你偷偷的转换。
哪些情况会偷偷转换呢？

  1. -、*、/、%

运算的时候会进行隐式类型转换：

  1. var a = "123";
  2. a++;
  3. console.log(a); // 124，因为a会隐式转换成Number类型
  5. var b = "45a";
  6. b++;
  7. console.log(b); // NaN
  9. var c = "3" * 2;
  10. console.log(c); // 5
  1. >、<、>=、<=、==

比较的时候会进行隐式类型转换：

  1. var a = "1" > 2;
  2. console.log(a);  // false，"1"转换成1，1 < 2= false;
  4. var b = 1 > 2 > 3;
  5. console.log(b); // false，1 > 2 = flase; flase 会被转化成 0，然后就是 0 > 3 = false;
  7. var c = 2 > 1 == 1; // true，2 > 1 = true; true 会被转化成 1，然后就是 1 == 1 = true;
  9. // 从某种意义上来说，undefind 和 null 都表示一个数据的空值。
  10. var bool1 = undefind == null;
  11. console.log(bool1); // true
  13. // 严格来说，undefind 表示声明了一个值没有赋值的状态，null 表示一个空对象的占位
  14. var bool1 = undefind === null;
  15. console.log(bool1); // flase

===不会进行类型转换，==会进行类型转换。

在隐式类型转换中，undefind和null是个特殊的存在。
null在==和!=隐式类型转换的时候不会进行类型转换！！！点击访问

  1. // undefind 在进行隐式类型转换的时候，Number(undefined)转换成 NaN
  2. undefind == undefind; // true
  3. undefind == 0; // false
  4. undedind > 0; // false
  5. undedind < 0; // false
  6. undefind >= 0; // false
  8. // null 在进行隐式类型转换的时候，Number(null)转换成 0
  9. // null在 == 和 != 隐式类型转换的时候不会进行类型转换
  10. null == null; // true
  11. null == 0; // false
  12. null != 0; // true
  13. null > 0; // false
  14. null < 0; // false
  15. null >= 0; // true