《Javascript高级程序设计 (第三版)》第三章 基本概念

摘要：如在上列中结果实际上是给定数字的字符串形式无效语法有效语法在上列中结果是因为第一个被视为的一部分，第二个是属性访问运算符。用于检查传入的对象是否是传入对象的原型第章将讨论原型。返回对象的字符串表示。

</>复制代码 
只挑本人重要的写(有夹杂其他补充)

</>复制代码 
 单行注释以两个斜杠开头，如下所示：
    // 单行注释
 块级注释以一个斜杠和一个星号（ /* ）开头，
    以一个星号和一个斜杠（ */ ）结尾，如下所示：
    /*
    * 这是一个多行
    * （块级）注释
    */

严格模式(一些不确定的行为将得到处理，而且对某些不安全的操作也会抛出错误)

</>复制代码 
 要在整个脚本中启用严格模式可以在顶部添加如下代码：
   "use strict";
   在函数内部的上方包含这条编译指示，也可以指定函在严格模式下执行：
   function doSomething(){
   "use strict";
   //函数体
   }

语句
ECMAScript 中的语句以一个分号结尾；如果省略分号，则由解析器确定语句的结尾

</>复制代码 
描述： ECMAScript 的变量是松散类型的，所谓松散类型就是可以用来保存任何类型的数据。 
简单来说，每个变量仅仅是一个用于保存值的占位符而已。

注意
用 var 操作符定义的变量将成为定义该变量的作用域中的局部变量。简单来说，如果在函数中使用 var 定义一个变量，那么这个变量在函数退出后就会被销毁

</>复制代码 
 function test(){
    var message = "hi"; // 局部变量
  }
  test();
  alert(message); // 错误
  

可能会返回以下结果字符串:

</>复制代码 
"undefined"——如果这个值未定义;
 "boolean"——如果这个值是布尔值；
 "string"——如果这个值是字符串；
 "number"——如果这个值是数值；
 "object"——如果这个值是对象或null；
 "function"——如果这个值是函数。
注意： 
 a.对null返回是"object"。
     typeof null // object;
 b.不能区分对象、数组、正则，对它们操作都返回"object"。
     typeof Number()// object;
 c.对NaN返回是"number"    
     typeof parseInt("你") === "number" //true              

</>复制代码 
描述：声明变量但未对其加以初始化时，这个变量的值就是 undefined。

</>复制代码 
 下面几种情况会出现undefined：
     访问数组或对象不存在的成员
     定义的变量未赋值。
     函数没有返回值，或return后没有数据。
 注意：
     var a; // undefined
     b      // ReferenceErroe:b is not defined;
     typeof a; // undefined;
     typeof b; // undefined;          

</>复制代码 
描述：          表示一个空对象指针；   var car = null;   alert(typeof car); //
"object"   如果定义的变量准备在将来用于保存对象，那么最好将该变量初始化为 null 而不是其他值。

</>复制代码 
注意：
     console.log(null == undefined) // true;
     console.log(null === undefined) //false
判断值是否为null：
    var a = null;
    (!a && typeof a === "object");// true;   

可转转化布尔类型：

</>复制代码 
  a.假值
     undefined、null、false、+0、-0、NaN、"";
  b、假值对象
     var a = new Boolean(false);
     var b = new Number(0);
     var c = new String("");
     var d = Boolean(a && b && c );
     d // true;
     var e = a && b && c;
     e // String {length: 0[[PrimitiveValue]]: ""};
 

</>复制代码 
描述: 表示整数和浮点数值(双精度64位二进制); 整数就是没有小数的十进制数。所以42.0即等于“整数”42。

数字语法

a.十进制：

</>复制代码 
var a = 42; 
var b = 42.3;

b.前面的0可以省略：

</>复制代码 
var a = 0.42;
var b = .42;

c.小数点部分最后的0也可以省略

</>复制代码 
var a = 42.0;
var b = 42.;

d.默认情况下大部分数字都以十进制显示，小数部分最后的0被省略

</>复制代码 
var a = 42.3000 // 42.3
var b = 42.0 // 42     

e.特别大与特别小的数字默认用指数显示

</>复制代码 
var a = 5E10;
a; // 50000000000
a.toExponential(); // "5e+10"
 
var b = a * a;
b; // 2.5e+21
 
var c = 1/a;
c; // 2e-11        

f.由于数字可以使用Number对象进行封装，可以调用Number.prototype方法。如：

</>复制代码 
var a = 42.59;
a.toFixed(0); // "43"
a.toFixed(1); // "42.6";
a.toFixed(3); // "42.590"
在上列中结果实际上是给定数字的字符串形式    
// 无效语法
42.toFixed(3); // SyntaxError
//有效语法
(42).toFixed(3);
0.42.toFixed(3);
42..toFixed(3);
在上列中结果是因为第一个.被视为number的一部分，第二个.是属性访问运算符。      

较小的数值：(这是二进制浮点数最大的问题)

</>复制代码 
0.1 + 0.2 === 0.3; // false

</>复制代码 
解决方法(判断两数是否相等):
function numbersCloseEnoughToEqual(n1,n2) {
    return Math.abs(n1 - n2 ) < Math.pow(2,-52);
}

整数的安全范围：

</>复制代码 
  Number.MAX_SAFE_INTEGER = 2^53 -1;
  Number.MIN_SAFE_INTEGER = -(2^53 -1);
  如数据库中的64位ID等，由于JavaScript的数值类型无法精确呈现64位数值，所以必须将它保存为字符串。     

整数检测:

</>复制代码 
 Number.isInteger = function(num) {
     return typeof num === "number" && num % 1 === 0;
 }   

- 检测是否是安全整数：

</>复制代码 
Number.isSafeInteger = function(num) {
    return Number.isInteger(num) && Math.abs(num) <= Number.MAX_SAFE_INTEGER;
}

特殊的数字：

</>复制代码 
描述：数学运算的操作数不是数字类型，无法返回一个有效的数字，会返回NaN。

a.不是数字的数字

</>复制代码 
var a = 2/"foo"; // NaN
typeof a === "number"; // true
不是数字的数字是数字类型。
注意：
    NaN是一个特殊值，他和自身不相等；
    NaN != NaN; // true
    
可用isNaN()来判断(但有个bug)：
var a = 2 / "foo"
isNaN(a); // true                      
var b = "foo";
isNaN(b); // true
isNaN()检查参数是否不是NaN，也不是数字。
解决：
Number.isNaN = function(n){
    return (typeof n === "number" && window.isNaN(n))
}          

b.无穷数

</>复制代码 
 var a = 1 /0; // Infinity
 var b = -1/0; // -Infinity
 Infinity/Infinity; // NaN
 1/Infinity; // 0
 -1/Infinity; // -0                       

c.零值

</>复制代码 
var a = 0/ -3; //-0
var b = 0 * -3; // -0
a.toString(); // "0"
a + ""; // "0"
String(a); // "0"
JSON.stringfy(a); // "0"
+"-0"; // -0
Number("-0"); // -0
JSON.parse("-0"); // -0
-0 == 0; // true
-0 === 0; // true
0 > -0; // false
区分 -0 和 0：
   function isNegZero(n) {
       var n = Number(n);
       return (n === 0) && (1/n === -Infinity);
   }                                          

</>复制代码 
特点： 字符串是不可变的，也就是说，字符串一旦建， 它们的值就不能改变。
要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量

转换字符串：

</>复制代码 
基本类型值的转化规则为：
null转化为"null"，
undefined转化为"undefined"，
true转化为"true",
数字的字符串化则遵循通用规则，
数组的默认toString(),将所有单元字符串化后再用"，"链接起来。

JSON字符串化

</>复制代码 
注意：
a.JSON字符串化并非严格意义上的强制类型转换。
    序列化的结果总是字符串 
    JSON.stringify("42"); // ""42""
    JSON.stringify()在对象遇到undefined、function 和 symbol 时会自动将其忽略，在数组中返回null(以保证单元位置不变)                       
    JSON.stringify(undefined);// undefined
    JSON.stringify([1,undefined,function(){},4]); // "[1,null,null,4]"
    JSON.stringify({a:2,b:function(){}}) // "{"a":2}"
  
b.如果传递给JSON.stringify()的对象定义了toJSON()方法，该方法会在字符串前调用，以便将对象转换为安全的JSON值。
             

Object 的每个实例都具有下列属性和方法：

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