JavaScript数据类型-运算符-流程控制语句

JavaScript 定义了几种数据类型? 哪些是原始类型?哪些是复杂类型?原始类型和复杂类型的区别是什么?

• JS共有6种数据类型。
  • 数值（number）：整数和小数（比如1和3.14）
  • 字符串（string）：字符组成的文本（比如”Hello World”）
  • 布尔值（boolean）：true（真）和false（假）两个特定值
  • undefined：表示“未定义”或不存在，即由于目前没有定义，所以此处暂时没有任何值
  • null：表示无值，即此处的值就是“无”的状态。
  • 对象（object）：各种值组成的集合
• 其中：number、string、boolean、undefined、null属于原始类型（基本类型）；object属于复杂类型（引用类型）；
• 基本类型与引用类型的区别：
  • 基本数据类型的值是不可变的，而引用类型的值是可以改变的
  • 基本数据类型不可以添加属性和方法，而引用类型可以添加属性和方法
  • 基本数据类型的赋值是简单赋值，从一个变量向另一个变量赋值基本类型的值，会直接把该值复制到为新变量分配的位置上；而引用类型的赋值是对象引用
  • 基本数据类型的比较是值的比较，而引用类型的比较是引用的比较
  • 基本数据类型是存放在栈区的；而引用类型是将对象的引用保存在栈区，对象实体保存在堆区中的

typeof和instanceof的作用和区别?

typeof

• typeof操作符返回一个字符串,指示未经计算的操作数的类型。通常用来判断基本类型的值

  语法：typeof operand
  operand 是一个表达式，表示对象或原始值，其类型将被返回。
  

• typeof除对null外的基本类型使用会返回代表这个类型的字符串，如:

  typeof 1 -> "number"
  typeof "1" -> "string"
  typeof null -> "object"
  

• typeof除对function以外的所有的引用类型使用都会返回"object", 如：

  typeof {} -> "object"  
  typeof [] -> "object"
  
  function f(){}
  typeof f -> "function"
  

instanceof

• instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。通常用来判断一个对象是否属于某个引用类型

  语法：object instanceof constructor
  object 要检测的对象.
  constructor 某个构造函数
  

• 如：

  [] instanceof Array -> true
  
  // 定义构造函数
  function C(){} 
  function D(){} 
  var o = new C();
  
  // true，因为 Object.getPrototypeOf(o) === C.prototype
  o instanceof C;
  
  // false，因为 D.prototype不在o的原型链上
  o instanceof D;  
  
  // true,因为Object.prototype.isPrototypeOf(o)返回true;(Object是所有引用类型的根类型）
  o instanceof Object;
  

如何判断一个变量是否是数字、字符串、布尔、函数

• 对于这些数据类型都可以用typeof判断，如：

  typeof 1 === "number" -> true
  typeof "1" === "string" -> true
  
  function f(){}
  typeof f === "function" -> true
  

NaN是什么? 有什么特别之处?

• 全局属性 NaN 表示 Not-A-Number 的值。
• NaN 属性的初始值就是 NaN，和 Number.NaN 的值一样。在现代浏览器中（ES5中）， NaN 属性是一个不可配置（non-configurable），不可写（non-writable）的属性。
• 在编码很少直接使用到 NaN。通常都是在计算失败时，作为 Math 的某个方法的返回值出现的（例如：Math.sqrt(-1)）或者尝试将一个字符串解析成数字但失败了的时候（例如：parseInt("blabla")）。
• 判断一个值是否是NaN

  • 等号运算符（== 和 ===） 不能被用来判断一个值是否是 NaN。必须使用 Number.isNaN() 或 isNaN() 函数。在执行自比较之中：NaN，也只有NaN，比较之中不等于它自己。

    NaN === NaN;        // false
    Number.NaN === NaN; // false
    isNaN(NaN);         // true
    isNaN(Number.NaN);  // true
    

如何把非数值转化为数值?

• 1.使用Number()函数。

  Number(true) // 1
  Number("1") // 1
  Number("1.23") // 1.23
  
  // 当字符串中有字母时返回NaN
  Number("a") // NaN
  Number("123e3") // NaN
  

• 2.parseInt(),用于将字符串转为整数。

  parseInt('123') // 123
  parseInt('   81') // 81
  parseInt(1.23) // 1
  
  // 当字符串中有其它字母时返回字母前的数字，当第一个字符为字母或不是字符串时返回NaN
  parseInt('15e2') // 15
  parseInt('abc') // NaN
  

• 3.parseFloat(),用于将一个字符串转为浮点数。

  parseFloat('3.14') // 3.14
  
  // 当字符串中有其它字母时返回字母前的数字，当第一个字符为字母或不是字符串时返回NaN
  parseInt('15e2') // 15
  parseInt('abc') // NaN
  

• 4.在非数值前添加一个"+"号

  // 行为与Number()函数类似
  +"1" // 1
  +true //1
  +"1.1" //1.1
  +"123a" //NaN
  

==与===有什么区别

• ES5提供两种不同的值比较操作：
  • 严格相等 ("triple equals" 或 "identity")，使用 ===
  • 宽松相等 ("double equals") ，使用 ==
• 严格相等 ===
  • 全等操作符比较两个值是否相等，两个被比较的值在比较前都不进行隐式转换。如果两个被比较的值具有不同的类型，这两个值是不全等的。否则，如果两个被比较的值类型相同，值也相同，并且都不是 number 类型时，两个值全等。最后，如果两个值都是 number 类型，当两个都不是 NaN，并且数值相同，或是两个值分别为 +0 和 -0 时，两个值被认为是全等的。全等操作符认为 NaN 与其他任何值都不全等，包括它自己。
    如：1 === "1" //false
• 非严格相等 ==
  • 相等操作符比较两个值是否相等，在比较前将两个被比较的值转换为相同类型。在转换后（等式的一边或两边都可能被转换），最终的比较方式等同于全等操作符 === 的比较方式。 相等操作符满足交换律。如：1 == "1" // true

break与continue有什么区别

• break 语句可用于跳出循环。break 语句跳出循环后，会继续执行该循环之后的代码（如果有的话）

  for (var i = 1; i < 10; i++) {
    if (i % 4 === 0) {
      break
    }
    console.log(i)
  }
  // 输出1，2，3
  

• continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下一个迭代。

  for (var i = 1; i < 10; i++) {
      if (i % 4 === 0) {
        continue
      }
      console.log(i)
    }
    // 输出1，2，3，5，6，7，9
  

void 0 和 undefined在使用场景上有什么区别

• void 会执行后面的表达式并返回 undefined，但是某些情境下undefined是可以被赋值的，比如在函数中，这样的话就不能用undefined来进行判断了。所以用void 0返回undefined来进行判断。既减少了在原形链上查找 window.undefined 的时间，也避免了误用被修改过的 undefined。

以下代码的输出结果是?为什么?

  console.log(1+1); 
  // 2 当+两边都是数字表示两个数字相加   
  console.log("2"+"4");
  // "24" 当+两边有一个是字符串时表示字符串连接  
  console.log(2+"4"); 
  // "24" 同上
  console.log(+"4");
  // 4 当+放在一个值前面时，表示将这个值转换为数值

以下代码的输出结果是?

  var a = 1;  
  a+++a;  
  typeof a+2;
  // "number2"
  // 解析：(a++)+a -> 3; (typeof a)+2 -> "number2"

以下代码的输出结果是? 为什么

  var a = 1;
  var b = 3;
  console.log( a+++b );
  // 4, 因为++的优先级高于+，所以(a++)+b,a++返回a的值，所以：1+3=4

遍历数组，把数组里的打印数组每一项的平方

 var arr = [3,4,5]
 for (var i = 0, len = arr.length; i < len; i++) {
   console.log(arr[i] * arr[i])
 }

遍历 JSON, 打印里面的值

var obj = {
  name: 'hunger', 
  sex: 'male', 
  age: 28 
}
for (var x in obj) {
  console.log(obj[x])
}

以下代码输出结果是? 为什么

  var a = 1, b = 2, c = 3;
  var val = typeof a + b || c >0
  console.log(val) 
  // "number2" ,解析：typeof的优先级高于+ ，所以typeof a + b =》"number2",因为当||左边的值为true时返回这个值，而除了空字符串外所有字符串的布尔值为true，所以直接返回"number2"

  var d = 5;
  var data = d ==5 && console.log('bb')
  console.log(data)
  // undefined, 解析：d == 5为true，当&&左边的值为true时返回它右边的值，而console.log的返回值为undefined。

  var data2 = d = 0 || console.log('haha')
  console.log(data2)
  // undefined, 解析：d = 0返回值为undefined,它的布尔值为false，当||左边的值为false时返回它右边的值，而console.log的返回值为undefined。
  
  var x = !!"Hello" + (!"world", !!"from here!!");
  console.log(x)
  // 2， 解析：!表示取反，!!相当于将一个值转化为布尔值，非空字符串的布尔值为true，所以!!"Hello"=》true；，操作符返回后面的值，同上可知!!"from here!!"=》true；当+两边的值为布尔值时，它会将他们转换为数值，true转换为数值得到1，所以x = 1 + 1.