1、typeof操作符

描述：检测给定变量的数据类型，结果如下：

"undefined"——如果这个值未定义；
"boolean"——如果这个值是布尔值；
"string"——如果这个值是字符串；
"number"——如果这个值是数值；
"object"——如果这个值是对象或 null；
"function"——如果这个值是函数。

var message = "some string";
typeof linName; // "undefined"
typeof null; // "object"
typeof message; // "string"
typeof(message); // "string"
typeof 95; // "number"
typeof 'lin';  // "string"
typeof {}; // "object"
typeof function () {}; // "function"

2、 Undefined类型

描述：只有一个值，即特殊的 undefined，表示变量未初始化。

var message;
console.log(message == undefined); //true

包含 undefined 值的变量与尚未定义的变量还是不一样的

var message; // 这个变量声明之后默认取得了 undefined 值
// 下面这个变量并没有声明
// var age
console.log(message); // "undefined"
console.log(age); // 产生错误

令人困惑的是：对未初始化的变量执行 typeof 操作符会返回 undefined 值，而对未声明的变量执行 typeof 操作符同样也会返回 undefined 值。

var message; // 这个变量声明之后默认取得了 undefined 值
// 下面这个变量并没有声明
// var age
console.log(typeof message); // "undefined"
console.log(typeof age); // "undefined"

3、 Null类型

描述：只有一个值，即特殊的值是 null。
从逻辑角度来看， null 值表示一个空对象指针，而这也正是使用 typeof 操作符检测 null 值时会返回"object"的原因。

var car = null;
alert(typeof car); // "object"

定义的变量准备在将来用于保存对象，那么最好将该变量初始化为 null 而不是其他值。

var obj = null;  // 将来用来保存数据类型为对象的变量

实际上， undefined 值是派生自 null 值的，因此 ECMA-262 规定对它们的相等性测试要返回 true：

console.log(null == undefined); //true

4、 Boolean类型

描述：该类型只有两个字面值： true 和 false。

var found = true;
var lost = false;

Boolean()函数，接受一个参数，将该值转换成布尔值。事实上，很多情况都会隐式的调用该函数，比如判断语句、循环语句、以及比较运算等等。

var message = "Hello world!";
var messageAsBoolean = Boolean(message);

下表给出了各种数据类型及其对应的转换规则。

| 数据类型   | 转换为true的值 | 转换为false的值 |
| --------- | ------------- | --------------- |
| Boolean   | true          | false           |
| String    | 任何非空str    | " "(空str)      |
| Number    | 任何非0值      | 0和NaN          |
| Object    | 任何对象       | null            |
| Undefined | n/a           | undefined       |

5、 Number类型

描述：使用 IEEE754 格式来表示整数和浮点数值。 支持二进制（010101）、十进制（100）、十六进制（0XFFAA）

var intNum = 55; // 十进制
var octalNum1 = 070; // 八进制的 56
var octalNum2 = 079; // 无效的八进制数值——解析为 79
var octalNum3 = 08; // 无效的八进制数值——解析为 8
var hexNum1 = 0xA; // 十六进制的 10
var hexNum2 = 0x1f; // 十六进制的 31

浮点数值，就是该数值中必须包含一个小数点，并且小数点后面必须至少有一位数字。

var floatNum1 = 1.1;
var floatNum2 = 0.1;
var floatNum3 = .1; // 有效，但不推荐
var floatNum1 = 1.; // 小数点后面没有数字——解析为 1
var floatNum2 = 10.0; // 整数——解析为 10

对于那些极大或极小的数值，可以用 e 表示法（即科学计数法）表示的浮点数值表示。

var floatNum = 3.125e7; // 等于 31250000

浮点数值的最高精度是 17 位小数，但在进行算术计算时其精确度远远不如整数。

if (a + b == 0.3){ // 不要做这样的测试！
  alert("You got 0.3.");
}

isFinite(num)函数，接受一个数值作为参数，若该值在最小值与最大值之间，则返回布尔值true。

 var result = Number.MAX_VALUE + Number.MAX_VALUE;
 console.log(isFinite(result)); //false

NaN（非数值），一个特殊数值，自身也不相等，用于表示一个本来要返回数值的操作数未返回数值的情况。

alert(NaN == NaN); //false

isNaN(param)函数，接受一个参数，该参数可以是任何数据类型，而函数会帮我们确定这个参数是否“不是数值”（会执行类型转换），任何不能被转换为数值的值都会返回布尔值true。

console.log(isNaN(NaN)); //true
console.log(isNaN(10)); //false（ 10 是一个数值）
console.log(isNaN("10")); //false（可以被转换成数值 10）
console.log(isNaN("blue")); //true（不能转换成数值）
console.log(isNaN(true)); //false（可以被转换成数值 1）

Number(param)函数，接受一个参数，将其转为Number类型，规则如下：

• Boolean 值， true 和 false 将分别被转换为 1 和 0；
• 数字值，只是简单的传入和返回；
• null 值，返回 0；
• undefined，返回 NaN；
• 字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值；
• 字符串中包含有效的浮点格式，如"1.1"，则将其转换为对应的浮点数值（同样，也会忽略前导零）；
• 字符串中包含有效的十六进制格式，例如"0xf"，则将其转换为相同大小的十进制整数值；
• 字符串是空的（不包含任何字符），则将其转换为 0；
• 字符串中包含除上述格式之外的字符，则将其转换为 NaN。
• 对象，则调用对象的 valueOf()方法，然后依照前面的规则转换返回的值。如果转换的结果是 NaN，则调用对象的 toString()方法，然后再次依照前面的规则转换返回的字符串值。

var num1 = Number("Hello world!"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number(true); //1

parseInt(param1, param2)函数，接受两个参数，第一个是转为整数的值，第一个是基数类型（十进制、十六进制、二进制等等）。

var num1 = parseInt("1234blue"); // 1234
var num2 = parseInt(""); // NaN
var num3 = parseInt("0xA"); // 10（十六进制数）
var num4 = parseInt(22.5); // 22
var num5 = parseInt("070"); // 56（八进制数）
var num6 = parseInt("70"); // 70（十进制数）
var num7 = parseInt("0xf"); // 15（十六进制数）
var num1 = parseInt("10", 2); //2 （按二进制解析）
var num2 = parseInt("10", 8); //8 （按八进制解析）
var num3 = parseInt("10", 10); //10 （按十进制解析）
var num4 = parseInt("10", 16); //16 （按十六进制解析）

parseFloat(param1, param2)函数，同上，区别是遇到第一个(.)会解析成小数点。

var num1 = parseFloat("1234blue"); //1234 （整数）
var num2 = parseFloat("0xA"); //0
var num3 = parseFloat("22.5"); //22.5
var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5
var num6 = parseFloat("3.125e7"); //31250000

6、 String类型

描述：用于表示由零或多个 16 位 Unicode 字符组成的字符序列，即字符串。

字符串可以由双引号（"）或单引号（'）表示，因此下面两种字符串的写法都是有效的：

var firstName = "Nicholas";
var lastName = 'Zakas';
var firstName = 'Nicholas"; // 语法错误（左右引号必须匹配）

String 数据类型包含一些特殊的字符字面量，也叫转义序列，用于表示非打印字符，或者具有其
他用途的字符。

console.log('\n');  //换行
console.log('\t');  // 制表
console.log('\b');  // 空格
console.log('\r');  // 回车
console.log('\f');  // 进纸
console.log('\\');  // 斜杠
console.log('\'');  // 在用单引号表示的字符串中使用。例如： 'He said, \'hey.\''
console.log('\"'');  // 在用双引号表示的字符串中使用。例如： "He said, \"hey.\""
console.log('\xnn');  // 以十六进制代码nn表示的一个字符（其中n为0～F）。例如， \x41表示"A"
console.log('\unnnn'); // 以十六进制代码nnnn表示的一个Unicode字符（其中n为0～F）。例如， \u03a3表示希腊字符Σ

ECMAScript 中的字符串是不可变的，也就是说，字符串一旦创建，它们的值就不能改变。要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量。

var lang = "Java";
lang = lang + "Script";

把一个值转换为一个字符串有两种方式。第一种是使用几乎每个值都有的 toString()方法。

var age = 11;
var ageAsString = age.toString(); // 字符串"11"
var found = true;
var foundAsString = found.toString(); // 字符串"true"

通过传递基数， toString()可以输出以二进制、八进制、十六进制，乃至其他任意有效进制格式表示的字符串值。

var num = 10;
alert(num.toString()); // "10"
alert(num.toString(2)); // "1010"
alert(num.toString(8)); // "12"
alert(num.toString(10)); // "10"
alert(num.toString(16)); // "a"

转型函数 String()，这个函数能够将任何类型的值转换为字符串。 String()函数遵循下列转换规则：

如果值有 toString()方法，则调用该方法（没有参数）并返回相应的结果；
如果值是 null，则返回"null"；
如果值是 undefined，则返回"undefined"。

var value1 = 10;
var value2 = true;
var value3 = null;
var value4;
alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined"

7、 Object类型

描述：对象其实就是一组数据和功能的集合。对象可以通过执行 new 操作符后跟要创建的对象类型的名称来创建。而创建 Object 类型的实例并为其添加属性和（或）方法，就可以创建自定义对象。

var o = new Object();
var o = new Object; // 有效，但不推荐省略圆括号

Object 类型是所有它的实例的基础，Object 类型所具有的任何属性和方法也同样存在于更具体的对象中。

• constructor：保存着用于创建当前对象的函数。对于前面的例子而言，构造函数（constructor）就是 Object()。
• hasOwnProperty(propertyName)：用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是存在。其中，作为参数的属性名（propertyName）必须以字符串形式指定（例如：o.hasOwnProperty("name")）。
• isPrototypeOf(object)：用于检查传入的对象是否是传入对象的原型（第 5 章将讨论原型） 。
• propertyIsEnumerable(propertyName)：用于检查给定的属性是否能够使用 for-in 语句（本章后面将会讨论）来枚举。与 hasOwnProperty()方法一样，作为参数的属性名必须以字符串形式指定。
• toLocaleString()：返回对象的字符串表示，该字符串与执行环境的地区对应。
• toString()：返回对象的字符串表示。
• valueOf()：返回对象的字符串、数值或布尔值表示。通常与 toString()方法的返回值相同