【JavaScript 从零开始】数字文本包装对象

JavaScript中的算术运算

JavaScript 还自称更加复杂的算术运算，这些复杂的运算通过作为Math对象的属性定义的函数和常量来实现：

Math.pow(2,53)                //=>9007199254740992: 2的53次幂

Math.round(.6)                 //=>1.0: 四舍五入

Math.ceil(.6)                     //=>1.0: 向上求整

Math.floor(.6)                   //=>0.0: 向下求整

Math.abs(-5)                    //=>5: 求绝对值

Math.max(x,y,z)               //=>返回最大值

Math.min(x,y,z)               //=>返回最小值

Math.random()                // 生成一个大于等于0小于1.0的伪随机数

Math.PI                           // π ： 圆周率

Math.E                            // e: 自然对数的底数

Math.sqrt(3)                    // 3 的平方根

Math.pow(3,1/3)              // 3 的立方根

Math.sin(0)                      // 三角函数：还有Math.cos等

Math.log(10)                    // 10的自然对数

Math.log(100)/ Math.LN10             // 以10为底100的对数

Math.log(512)/Math.LN2            // 以2为底512的对数

Math.exp(3)                      // e的三次幂

JavaScript采用可IEEE-754浮点数表示法（几乎所有现代变成语言所采用）,

这是一种二进制表示法，可以精确地表示分数，比如 1/2、1/8 和1/1024.遗憾的是，

我们常用的分数（特别是在金融计算方面）都是十进制分数1/10、1/100等。

二进制浮点表示法并不能精确表示似0.1这样的数字。

JavaScript 中的数字具有足够的精度，并可以及其近似于0.1.但事实是，数字不能精确表述的确带来了一些问题。

看下这段代码：

var x=.3-.2  ;                 //30美分减去20美分

var y=.2-.1 ;                  //20美分减去10美分

x==y                            //=>false : 两个值不相等！

x==1                            //=>false : .3-.2 不等于.1

y==1                            //=>true : .2-.1 等于.1

由于舍入误差，0.3和0.2之间的近似差值实际上并不等于0.2和0.1之间的近视差值。

注释：在JavaScript的真是运行环境中，0.3-0.2=0.099 999 999 999 999 98

这个问题不只在JavaScript中才会出现，理解这一点非常重要：

在任何使用二进制浮点数的编程语言中都会有这个问题。

同样要注意的是，上述代码中x和y的值非常接近彼此和最终的正确值。

这种计算结果可以胜任大多数的计算任务：这个问题也只有在比较两个值是否相等的时候才会出现。

JavaScript的未来版本或许会支持十进制数字类型以避免这些舍入问题。在这之前你可能更愿意只用大整数进行重要的金融计算。

例如，要使用整数 "分 " 不要使用小数 "元 “进行基于货币单位的运算。

在计算的时候，还请大家少用小数，也就是说当有金额为 1.6元的时候请用16分表示。

字符串的使用

JavaScript的内置功能之一就是字符串连接。如果将加号（+）运算符用于数字，表示两数相加。但将它作用于字符串，则表示字符串连接。

将第二个字符串拼接在第一个之后，例如：

var msg="Hello, "+"world";          //生成字符串 "Hello, world"

要确定一个字符串的长度---其所包含的16位值得个数---可以使用字符串的 length 属性。

比如要获取字符串 s 的长度： s.length

除了length 属性，字符串还提供许多可以调用的方法：

var s="hello,world";                    //定义一个字符串

s.charAt(0);                                 //=>"h" : 第一个字符

s.charAt(s.length-1);                    //=>”d" : 最后一个字符

s.substring(1,4) ;                         //=>”ell" : 第2~4个字符

s.slice(1,4);                                 //=>”ell" : 第2~4个字符

s.slice(-3);                                   //=>”ell" : 最后三个字符

s.indexOf("l");                              //=>2 : 字符l 首次出现的位置

s.lastIndexOf("l");                        //=>10 : 字符l 最后一次出现的位置

s.indexOf("l",3);                         //=>3 : 在位置3及之后出现字符l的位置

s.split(",");                                 //=>["hello","world"] : 分割成子串

s.replace("h","H");                     //=>"Hello, world": 全文字符替换

s.toUpperCase();                         //=>"HELLO,WORLD" :转为大写

记住，在JavaScript中字符串是固定不变的，

类似replace()和toUpperCase()的方法都返回新字符串，原字符串本身并没有发生改变。

null 和 undefined

在JavaScript开发中，被人问到：null与undefined到底有啥区别？

一时间不好回答，特别是undefined，因为这涉及到undefined的实现原理。于是，细想之后，写下本文，请各位大侠拍砖。

总所周知：null == undefined

但是：null !== undefined

那么这两者到底有啥区别呢？

null

这是一个对象，但是为空。因为是对象，所以 typeof(null) 返回 'object' 。

null 是 JavaScript 保留关键字。

null 参与数值运算时其值会自动转换为 0 ，因此，下列表达式计算后会得到正确的数值：

　　　　表达式：123 + null　　　　结果值：123

　　　　表达式：123 * null　　　　结果值：0

undefined

　　undefined是全局对象（window）的一个特殊属性，其值是未定义的。但 typeof(undefined) 返回 'undefined' 。

虽然undefined是有特殊含义的，但它确实是一个属性，而且是全局对象（window）的属性。请看下面的代码：

 alert('undefined' in window);   //输出：true

     var anObj = {};

     alert('undefined' in anObj);    //输出：false

从中可以看出，undefined是window对象的一个属性，但却不是anObj对象的一个属性。

　　注意：尽管undefined是有特殊含义的属性，但却不是JavaScript的保留关键字。

　　undefined参与任何数值计算时，其结果一定是NaN。

　　随便说一下，NaN是全局对象（window）的另一个特殊属性，Infinity也是。这些特殊属性都不是JavaScript的保留关键字！

提高undefined性能

　　当我们在程序中使用undefined值时，实际上使用的是window对象的undefined属性。

　　同样，当我们定义一个变量但未赋予其初始值，例如：

　　　　var aValue;

　　这时，JavaScript在所谓的预编译时会将其初始值设置为对window.undefined属性的引用，

　　于是，当我们将一个变量或值与undefined比较时，实际上是与window对象的undefined属性比较。这个比较过程中，JavaScript会搜索window对象名叫‘undefined'的属性，然后再比较两个操作数的引用指针是否相同。

　　由于window对象的属性值是非常多的，在每一次与undefined的比较中，搜索window对象的undefined属性都会花费时间。在需要频繁与undefined进行比较的函数中，这可能会是一个性能问题点。因此，在这种情况下，我们可以自行定义一个局部的undefined变量，来加快对undefined的比较速度。例如：

 function anyFunc()

    {

        var undefined;          //自定义局部undefined变量

        if(x == undefined)      //作用域上的引用比较

        while(y != undefined)   //作用域上的引用比较

    };

其中，定义undefined局部变量时，其初始值会是对window.undefined属性值的引用。新定义的局部undefined变量存在与该函数的作用域上。在随后的比较操作中，JavaScript代码的书写方式没有任何的改变，但比较速度却很快。因为作用域上的变量数量会远远少于window对象的属性，搜索变量的速度会极大提高。

　　这就是许多前端JS框架为什么常常要自己定义一个局部undefined变量的原因！

包装对象

JavaScript对象是一种复合纸：它是属性或已命名值得集合。

通过"."符号来引用属性值。当属性值是一个函数的时候，称其为方法。通过o.m()来调用对象o中的方法。

我们看到字符串也同样具有属性和方法：

var s= "hello world!";                                               //一个字符串

var word = s.substring(s.indexOof(" ")+1,s.length);    //使用字符串的属性

字符串既然不是对象，为什么它会有属性呢？

只要引用了字符串 s 的属性，JavaScript就会将字符串值通过调用 new String(s)的方法转换成对象，这个对象继承了字符串的方法，并被用来处理属性的引用。

一旦属性引用结束，这个新创建的对象就会销毁（其实在实现上并不一定创建或销毁这个临时对象，然而整个过程看起来这样）。

同字符串一样，数字和布尔值也具有各自的方法：通过Number()和Boolean()构造函数创建一个临时对象，这些方法的调用均是来用于这个临时对象。

null和undefined没有包装对象：访问它们的属性对照成一个类型错误。

看如下代码：

var s = "test";      //创建一个字符串

s.len= 4;             //给它设置一个属性

var t =s.len;         //查询这个属性

// t 的值是undefined

需要注意的是，可以同String(), Number() 或 Boolean()构造函数来显示创建包装对象：

var s="test",n=1,b=true;  //一个字符串、数字、布尔值

var S=new String(s);         //一个字符串

var N=new Number(n);      //一个数字

var B=new Boolean(b);      //一个布尔值

JavaScript 会在必要时将包装对象转化成原始值，因此上段代码中对象 S 、N 和 B常常----但不总是----表现的和值 s、n和 b一样。

“==”等于运算符将原始值和其包装对象视为相等，

但是“===”全等运算符将它们视为不等。

通过typeof 运算符可以看到原始值和包装对象的不同。

var s="test",n=1,b=true;  //一个字符串、数字、布尔值

var S=new String(s);         //一个字符串

var N=new Number(n);      //一个数字

var B=new Boolean(b);      //一个布尔值

s==S ;                           //=> true : 等于运算符视为相等

s===S;                           //=> false: 全等运算符视为不等

//原因如下

typeof s ;                          //=> "string": s 的 type 是string

typeof S ;                          //=> "object": S 的 type 是object