JS —— 变量、转换、判断

变量

1. 声明
   ES6新增关键字 let 关键字，替代了之前的 var 关键字。
   还新增了 const 关键字来声明常量，声明时必须初始化，且不可修改，其他特性和 let 类似。
   变量区分类型，变量值才会区分类型。

• let const 声明变量的优点：
  变量不提升，即必须先定义后使用
  不允许声明同名变量，在同一作用域下是不符合逻辑的
  块级作用域，防止变量污染
  不自动作为全局上下文的属性
  对于for循环，其外部不能访问

// 变量不提升

> console.log(a); // ReferenceError: a is not defined
> let a = 10;
// 同一作用域下不允许声明同名变量
> let a = 9; // SyntaxError: Identifier 'a' has already been declared
// 块级作用域
> { let b = 8; }
> console.log(b); // ReferenceError: b is not defined
// 不自动作为全局上下文属性（浏览器环境为例）
> console.log(window.c); // undefined
// for外部不可访问内部变量
> for( let a in [] ) { }
> console.log(a);		 // ReferenceError: a is not defined
// const声明变量
> const C;	// SyntaxError: Missing initializer in const declaration
> const C = 7;
> C = 6;	// TypeError: Assignment to constant variable.

1. 创建
   变量值的类型分为原始值和引用值，因此，对应变量的创建有两种方式：
   字面量创建、 构造函数创建

// 字面量
let d = 1;		// 原始值：Number Boolean String Undefined Null都适用
let e = [2,3]	// 数组字面量
let f = {name:"JS"}; // 对象字面量
let g = "abc";	// 字符串字面量
let h = /a/i;	// 正则字面量
// 构造函数：都返回对应的实例对象
let i = new Number(1);	// 包装类型：Number Boolean String
let j = new Array(2,3);				// [2,3]
let k = new Object({name:"JS"});	// {name:"JS"}
let l = new String("abc");			// "abc"
let m = new RegExp("a","i"); 		// /a/i
// Symbol比较特殊：没有字面量语法，也没有构造函数
let n = Symbol("n");	// Symbol是原始类型，参数表示符号的描述

转换

1. 自动转换

1. 原始值通过点语法调用属性或方法时，自动转换，完成后自动销毁包装类对象
2. +号运算符的操作数中有String，则其他操作数先自动转字符串，再拼接
3. 逻辑运算符的操作数先自动转布尔原始值，再逻辑运算

> let a = "abc";
> console.log(a.length);	// 3
> let b = 1;
> console.log(b.prototype);	// [Number: 0]
> a + b;	// 'abc1' 先自动转为字符，再拼接
> !a		// false 先自动转为布尔值，再运算

2. 显式转换

=> Number：Number() parseInt() parseFloat()
=> Boolean：Boolean()
=> String：String()

// => Number
// Number()，适用任意类型数据
> Number(null);		// 0
> Number(undefined);// NaN
> Number(false);	// 0 true为1
> Number(1);		// 1 还支持0o八进制、0x十六进制、e科学计数
> Number("");		// 0
> Number(" 011 ");  // 11 自动去除字符串首尾的空格和0
> Number("0x11");	// 17 同样支持0o八进制、0x十六进制、e科学计数
> Number(" 011a");	// NaN 字符串含其他不可识别字符则返回NaN

//  parseInt()提高了字符串解析，但不能识别小数点
> parseInt("11abc");     // 11
> parseInt("0x11z", 16); // 17 可解析0x 0o
> parseInt("11z", 16);   // 17 第二个参数表示第一个参数的进制
> parseInt("2.1e3");     // 2

//parseFloat() 可解析小数点，不能指定参数进制
> parseFloat(".1");   // 0.1 
> parseFloat("1.1a");	// 1.1
> parseFloat("1.1e3");// 1100

// => Boolean：假值只有false 0 null defined "" NaN N/A，其余全为true
> Boolean(null);		// false
> Boolean(undefined);	// false
> Boolean(0);			// false
> Boolean("");			// false
> Boolean(NaN);			// false

// => String：转为字符串字面量
> String(0);			// '0' 其他原始值都是一样的
> String(Symbol("S"));	// 'Symbol(S)'
> String(NaN);			// 'NaN' Infinity同理
> String([1,2,3])  		// '1,2,3' 自动调用join方法
> String(11, 8);     	// '13' 先转为指定进制再转字符串

判断

1. 运算符：
   typeof 判断数据类型，返回字符串形式

> typeof 1;			// 'number'
> typeof false;		// 'boolean'
> typeof "abc";		// 'string'
> typeof [1,2];		// 'object'
> typeof null		// 'object'
> typeof undefined;	// 'undefined'

3. 方法：

// 判断是否为非数值数据
> Number.isNaN(0);	// false
> Number.isNaN(NaN);// true
// 判断是否是整数数值
> Number.isInteger("1");	// false
> Number.isInteger(1);		// true

注意事项：

> NaN == NaN			// false NaN和任何数据都不相等
> null == undefined		// true
> null === undefined	// false 不严格相等
// 实现了caller方法的对象，typeof才返回function