Javascript 知识与经验（一）—— 基本数据类型

1、数值类型 Number，Javascript 中的数值都是按照IEEE-754 双精度存储的：

1 的表示方式：1，0000000001（八进制数），0x0001（十六进制）1e1，1e0（科学计数法），1e+1（科学计数法），1e-1（科学计数法）
-0.001 的表示方式：-0.001，-1e-3，-.001
特殊值：Infinity（无穷大），-Infinity（负无穷大），NaN（不是数值，类型为number）

    console.log(NaN + 0.1);// NaN；
    console.log(0.2+0.3);//0.30000000000000004（不精确）；
    console.log(0.1+1);//1.1（精确）；
    console.log(0.20 + null);// 0.2；
    console.log(0.2 + undefined);// NaN
    console.log(0.2 / 0); //Infinity
    console.log(0.2 / 0);// -Infinity
    console.log(0.2 / -0);// Infinity（注意，可见js运算时先进行符号处理了）
    console.log(isNaN(NaN));//true
    console.log(isNaN(undefined));// true
    console.log(isNaN(Infinity));//false
    console.log(isNaN(null));//fasle 

  参数为 Number 类型的常用函数：isNaN，toFixed，toPrecision

2、字符串类型 String，特殊的 Object 类型：

类型判断 typeof str === “string”
‘这是一个字符串’ （使用单引号或双引号括起来的表达式）
‘我说：”我爱你!”’（单引号中使用双引号或双引号中使用单引号）
”或“”（空字符串）

var str = "abc"; //类型为 string
str = "\u{41}\u{42}\u{43}"; //"ABC" ES6 Unicode 字符的新表示法
var str2 = new String("abc"); //类型为 object,明确指明 str2 为引用类型的 String 类型，防止js解释器混淆字符串和数值
表达式的值：
console.log('这是一个字符串'+null); // 这是一个字符串null
console.log('这是一个字符串'+undefined); // 这是一个字符串undefined
console.log('这是一个字符串'+NaN); // 这是一个字符串NaN
console.log('这是一个字符串'+Infinity); // 这是一个字符串Infinity （可见特殊对象都是先调用了toString转为了字符串

3、布尔类型 boolean，true和false：

在布尔判断上下文中（如if语句，?:三元判断，!0 等!求非运算），空串、NaN、null、undefined、0（数值0，0.00等）和关键字 false都被认为是 布尔值false，其他值都被解析为布尔true，常使用 !0、!undefined、!null表示 true，，!!0、!1 表示 false
类型判断 typeof bool === “boolean”

4、对象类型 Object：

类型判断：typeof obj === “object”
类型继承，参见 Function 代码
对象的重要属性：
　　constructor：返回对创建此对象的函数的引用
　　prototype：用于给对象类型添加属性和方法。
　　hasOwnProperty： 判断一个对象是否有某个属性，不检查对象的类原型链
　　isPrototypeOf：判断其

var obj = new Object();//使用构造函数创建对象
obj.prop = {name:"张三"};//为对象obj 添加一个对象属性 prop  的类型也是一个对象，该对象使用了json对象表达方式构造
console.log(obj.prop.name);//输出obj的 prop 属性的name属性的值
Object.prototype.name = "李四";//给类型Object添加一个类型属性name，该类型属性为对象类型
var newObj = {};//使用 json 对象表达式方式构造创建一个新对象
console.log(newObj.name);//由于给类型Object 添加了name属性，newObj 可使用到类的属性，于是输出 李四
console.log(obj.name);//虽然给类 Object 添加属性在 obj 构造调用之后，但该属性也附加到对象 obj 上了
Object.prototype.prop = {name:"王五"};
console.log(newObj.prop.name);//输出 王五 无疑义
console.log(obj.prop.name); //优先使用 对象的属性
newObj.prop2 ={name:"prop2"};
Object.prototype.prop2 = {name:"Object prop2"}
console.log(newObj.prop2.name);//证明优先使用 对象的属性，类的属性没有覆盖掉 对象的属性
var prop;
for(prop in obj){
    console.log(prop+":"+obj[prop]);//属性值对
}

5、函数类型 Function：

类型判断：typeof func === “function”

    var func = function(){}
    console.log(func.name); //输出 func
    var strToJson = function(str) { return  new Function('return '+str)();}//使用json字符串构造json对象
    console.log(strToJson('{name:"张三"}'));// 生成对象 Object{name:'张三'}
    function Parent(){console.log('构造Parent父类');}
    function Base(){console.log("构造Base基类")}
    Base.prototype.eat = function(){console.log('基类吃饭！');}
    Parent.prototype = new Base();//使用继承
    Parent.prototype.work = function(){console.log('父类工作！');}
    var p = new Parent();
    p.eat();
    p.work();//基类工作 或 父类工作，取决于下一句是否重写了基类方法
    Parent.prototype.eat = function(){console.log("父类吃饭！");}//该句注释将对上一句结果影响，说明js语句并非按顺序处理，而是按照先类型定义后代码调用的方式执行
    p.work();
    //闭包函数：它处于一个函数体重，并引用了函数体当前执行上下文中的变量
    var name = "Tom";
    var hello = (function(name){
        console.log("参数："+name);//仅在闭包函数被定义并构建时调用一次，以后闭包函数执行时不变
        return function(){
            console.log("Hello "+name);
        } 
    })(name);//闭包在创建时因为其执行上下文已经被确定
    hello(); // Hello Tom
    name = "Peter";
    console.log(name);//n
    hello();// Hello Tom
    hello("Li Li");// Hello Tom
    hello();// Hello Tom

6、Undefined 类型：

类型判断：typeof undefinedVar === “undefined”;
已存在一个该类型对象 undefined，其他未定义的符合变量命名规则的变量均被认为是 undefined 类型

console.log(typeof v === "undefined");//true
console.log(typeof undefined === "undefined");//true
console.log(null == undefined);//true null是内存中没有引用（或地址），与undefined 相同
console.log(NaN == undefined);//false NaN不是数值 是一个对象，是有引用（地址）的