JavaScript 入门教程四 语言基础【2】

一、数据类型介绍: undefined null NaN

　1、判断当前变量是否为 undefined： if (i === undefined) 或者 if (typeof (i) === "undefined")

　　　 未初始化的变量默认会取得 undefined 值。而未声明的变量只有使用 typeof 不会出错，其余情况下都会出错。

　　　 例子： var message;

　　　　　　  alert(message); // "undefined"

　　　　　　  alert(message1); // 错误

　　　　　　  alert(typeof (message)); // "undefined"

　　　　　　  alert(typeof (message1)); // "undefined"

　2、判断当前变量是否为 null ： if (i === null) null 的类型为object，表示的是一个空对象指针。

　3、注意 === 要求两边的值以及类型都一样。而==只要求两边的值一样 故 “1”==true 返回的是 true 而 “1”===true 返回的是 false）。

　4、undefined 是为了定义未初始化的变量或者未声明的变量，而null 值是为了保存对象。

　　　　所以当想用一个变量存储对象时 可以这样： var car = null;

　　　　而声明普通变量而且想使用它存储字符串时 可以这样： var message = "message"; // 如果想用 message 存储 数字，应该这样 var message = 0;

　5、涉及NaN 的所有操作返回结果都为 NaN。 与判断 NaN 使用函数 isNaN(返回结果为bool值 true 或者 false)： if(isNaN(0 / 0)) 返回结果true。NaN的数据类型为 number 它不与任何数值相等，包括它自己。

　　 isNaN 可以适用于任何变量，只要该变量可以转化成数值，则返回false。

　　alert(isNaN("1")); // false

　　alert(isNaN(true)); //false

　　alert(isNaN("blue")); // true

　　所以判断一个变量是否为 NaN，判断条件为 var test;  if(isNaN(test)&&typeof(test)==="number"){}

二、数据类型介绍: Boolean

　　Boolean 类型只有两个值：true false。 任何数据类型都可以转换成 Boolean 类型（使用函数 Boolean()）。在 IF 等控制语句中会自动执行相应的转换。

　　undefined 和 null 只能转换为 false

0 和 Nas 转化成 false ，其余均为 true

　　空字符串转换为 false，其余均为true

　　Object 转换为 true

三、数据类型介绍: Number

　1、几个特殊数值的计算：

　　　　　　alert(0/0); // NaN

　　　　　　alert(0/1);// 0

　　　　　　alert(1/0); // Infinity

　　　　　　alert(-1/0); // -Infinity

　　　　　　可以使用函数 isFinite() 验证数值是不是位于 -Infinity 与 Infinity 之间。

2、数值中的整数可以用 10进制 8进制 16进制表示。

　　　　　例如：11

　　　　　　十进制表示是11

　　　　八进制表示是 013

　　　　十六进制表示是 0xb 或者 0xB

　　　　八进制在严格模式下会报错，建议不要使用。如果八进制字面值中的数字超出了范围，将被解析成十进制，例如 018，将被解释为 18.

　3、浮点数必须包含一个小数点，而且小数点后必须至少有一位数字。

　　　　　　var float1 = 1.0； // 有效 但是会被存储为整数 1

　　　　　　var float1 = 1.； // 有效 但是会被存储为整数 1

　　　　　　var float2 = 1.1;  //有效浮点数

　　　　　　var float3 = .1; // 有效，被解释称 0.1 但是不推荐。

　　　　　对于极大或者极小的数值，使用e表示法。例如： var float4 = 3.14e2; 或者 var float5 = 3.14E2 表示的就是 3.14 × 10²  即 314。

　4、浮点数的计算

　　　　　　alert((0.1+0.2)==0.3) 返回的结果为 false，因为 0.1+0.2 的计算结果为 0.30000000000000004 这是因为计算机是先把0.1 和 0.2 转换成二进制再进行计算，而javaScript 没有处理这种精度误差，所以会出现这样结果。

　　　　　　解决精度问题：　　　　　　

　　　　　　　　Math.formatFloat = function (f, digit) {

　　　　　　　　　　var m = Math.pow(10, digit);
　　　　　　　　　　return parseInt((f * m)) / m;
　　　　　　　　}

　　　　　　　　alert(Math.formatFloat(0.1 + 0.2, 1)); // 0.3

　　　　　　将计算结果先转化为整数，再除以幂次。

　　　　　　其他方法参考文章 JavaScript精度计算

　5、有三个函数可以把非数值转换为数值。

　　　　　　㈠ Number() 可转换整数和浮点数

　　　　　　　　alert(Number()); //0　　　　　　

　　　　　　　　alert(Number(null)); //0
　　　　　　　　alert(Number(undefined)); //NaN
　　　　　　　　alert(Number(NaN)); //NaN NaN 是数值型，所以返回自己

　　　　　　　　alert(Number(true)); //1
　　　　　　　　alert(Number(false)); //0 Boolean 的转换　　　　　　　

　　　　　　　　alert(Number("")); //0 空字符返回0

　　　　　　　　alert(Number("-1"));  // -1

　　　　　　　　alert(Number("012")); //12 对于纯数字的字符串将其转为十进制返回　　　　　　　　

　　　　　　　　alert(Number("1.12")); //1.12
　　　　　　　　alert(Number(".1")); //0.1
　　　　　　　　alert(Number("1.0")); //1 对于带小数点的纯浮点数，返回对应的浮点值

　　　　　　　　alert(Number("0xa")); //10
　　　　　　　　alert(Number("0x12")); //18
　　　　　　　　alert(Number("0x1h")); //NaN 对于包含有效十六进制的字符串，返回对应的十进制值

　　　　　　　　alert(Number("123abc")); //NaN
　　　　　　　　alert(Number("a123")) //NaN
　　　　　　　　alert(Number("A")); //NaN 其余字符串均返回 NaN

　　　　　　㈡ parseInt(value,radix) 主要是对字符串进行整数转换

　　　　　　　　参数value  需要转换的变量  radix 转换基数（多少进制）

　　　　　　　　对于非字符串的 null undefined NaN true false  转换结果均为 NaN　　　　　　　　

　　　　　　　　alert(parseInt("")); //NaN  
　　　　　　　　alert(parseInt("abc123")); //NaN 转换字符串时寻找第一个非空字符，如果没有或者不是数字或者不是 - 则返回NaN

　　　　　　　　alert(parseInt("-123-456")); //-123 转换字符串时寻找第一个非空字符 - 直遇到一个非数字字符 -  返回之前的 -123
　　　　　　　　alert(parseInt("123abc456")); //123 // 遇到第一个非空字符 1 解析后续字符，直遇到一个非数字字符 a  返回之前的 123　　　　　　　　

　　　　　　　　alert(parseInt(100)); //100
　　　　　　　　alert(parseInt(100.58)); //100  无法解析小数点 返回 100

　　　　　　　　由于 ES 解析的差异，我们需要添加第二位参数: 转换基数

　　　　　　　　例如 alert(parseInt(070)); // ES3认为其为8进制 返回 56  而 ES5 认为其为十进制 忽略前导0 返回 70　　　　　　　　

　　　　　　　　alert(parseInt("012", 10)); //12 十进制 忽略前导0 返回12
　　　　　　　　alert(parseInt("012", 8)); //10  八进制，返回 1×8 + 2 = 10
　　　　　　　　alert(parseInt("012", 16)); //18 十六进制，返回 1×16 + 2 = 18

　　　　　　　　加上第二个参数后，八进制前面的数字 0 以及十六进制前面的 0x 可以省略　　　　

　　　　　　　　alert(parseInt("0xa")); //10
　　　　　　　　alert(parseInt("a", 16)); //10
　　　　　　　　alert(parseInt("a")); //NaN 没有加第二个参数，当作普通字符串处理

　　　　　　㈢ parseFloat(value) 也主要是处理对字符串的转换 只有一个参数

　　　　　　　　它转换的字符串可以包含小数点.

　　　　　　　　它只解析十进制数,其他进制数返回0　　　　　　　　

　　　　　　　　alert(parseFloat("1234blue")); //1234 （整数) 
　　　　　　　　alert(parseFloat("0xA")); //0  只解释十进制
　　　　　　　　alert(parseFloat("22.5")); //22.5
　　　　　　　　alert(parseFloat("22.34.5")); //22.34
　　　　　　　　alert(parseFloat("0908.5")); //908.5
　　　　　　　　alert(parseFloat("3.125e7")); //31250000

　　　　　　　　alert(parseFloat(".5")); //0.5
　　　　　　　　alert(parseFloat("1.5e3F")); //1500
　　　　　　　　alert(parseFloat("1.5ea3")); //1.5 从非空处(- . 数字开头)开始解析,到遇见一个无效的浮点数为止