《javascript高级程序设计》笔记（五）

1.Object类型

创建Objectt实例的方法

一：使用new操作符后跟Object构造函数

var person = new Object();

二：对象字面量表示法，目的在于简化创建包含大量属性的对象的过程，数值属性名会转换成字符串。

var person{
    name : "Nicololas",
    age : 29
};

var person={};与new Object()相同

        function displayInfo(args) {
            var output = "";

            if (typeof args.name == "string"){
                output += "Name: " + args.name + "\n";
            }

            if (typeof args.age == "number") {
                output += "Age: " + args.age + "\n";
            }

            alert(output);
        }

        displayInfo({
            name: "Nicholas",
            age: 29
        });

        displayInfo({
            name: "Greg"
        });

方括号表示法

通常除非必须使用变量来访问属性，否则一般使用点表示法。

alert(person["name"]);  //等于alert(person.name);

var propertyName = "name";  //通过变量访问属性
alert(person[propertyName]);

person["first name"] = "nima"; //属性名包含会导致语法错误的字符，或者属性名使用关键字或保留字

2.Array类型

ECMAScript的数组每一项可以保存任何类型的数据，大小可以调整。

创建数组的方法：

1.使用Array构造函数 new可以省略

var colors = new Array();

var colors = new Array(20);  //创建长度为20的数组

var colors = new Array("red","green"); //创建包含2个字符串的数组

2.使用数组字面量表示法：由一对包含数组项的方括号表示，多个数组项之间以逗号隔开

var colors = ["red", "blue"];

var names = []; //创建空数组

var value = [1,2,] //在IE8及之前版本会创建1、2和undefined数组，其余会创建1、2数组

用length属性添加新项、移除项

var colors = ["red","blue"];

colors.length = 3;  //增加第三项， 值为undefined

colors.length = 1;//删除第二项，值未undefined

colors[colors.length] = "green"; //在位置3增加项

colors[99] = "black"; //colors长度增加为100

检测数组

instanceof方法假定只有一个全局执行环境，如果网页包含多个框架，那么实际上就存在两个以上不同的全局执行环境，从而存在两个以上不同版本的Array构造函数。如果你从一个框架向另一个框架传入数组，那么传入的数组与在第二个框架中原生创建的数组分别具有各自不同的构造函数。

支持isArray方法的有IE9+、Firefox4+、Safari 5+、Opera 10.5+和Chrome

if (Array.isArray(value)){
  //操作
}

转换方法

toLocaleString()

toString() ：返回由数组中每个值的字符串形式拼接成的以，分隔的字符串，调用数组的每一个项的toString()方法

valueOf() ：返回数组

join() ：使用不同符号分隔，如果不传入值或传入undefined，在IE7及之前版本会使用字符串undefined作为分隔符

栈方法

        var colors = new Array();
        var count = colors.push("red", "green");       //推入两项
        alert(count);  //2 即项的数目
        alert(colors) = red,green;

        count = colors.push("black");                  //推入另一项
        alert(count);  //3

        var item = colors.pop();                       //取得最后一项
        alert(item);   //"black"
        alert(colors.length);  //2

队列方法

shift():移除数组第一个项并返回该项。

unshift():在数组前端添加任意个项并返回新数组长度。

重排序方法

reverse()：反转数组项的顺序

sort()：按升序排列，数组项调用toString()方法，比较得到的字符串

var values=[0, 1, 5, 10, 15];
values.sort();
alert(values);     //0,1,10,15,5

加入比较函数：

        function compare(value1, value2) {
            if (value1 < value2) {
                return -1;
            } else if (value1 > value2) {
                return 1;
            } else {
                return 0;
            }
        }

       function compare2(value1, value2) //数值类型或其valueOf()方法返回数值{
          return value1 - value2;
       }    

        var values = [0, 1, 5, 10, 15];
        values.sort(compare);
        alert(values);    //0,1,5,10,15；

操作方法

concat():创建当前数组的副本，将参数依次添加到副本的末尾，返回新数组，如果参数是数组，则将每一个项分别添加到新数组。

        var colors = ["red", "green", "blue"];
        var colors2 = colors.concat("yellow", ["black", "brown"]);

        alert(colors2);    //red,green,blue,yellow,black,brown
        alert(colors2[4]);     //black
        alert(colors2[5]);     //brown

slice(): 1个参数：返回参数指定位置开始到数组末尾的项

2个参数：返回起始和结束位置之间（但不包括结束位置的项）的项

如果参数中有一个负数，则用数组长度加上该数来确定位置——一个有5项的数组slice(-2,-1)与slice(3,4)结果相同

结束位置小于起始位置，返回空数组

splice()：(删除的起始位置，删除的数目，[添加的项])

删除[x,y]

插入[x,0,项]

替换[x,y,项]

        var colors = ["red", "green", "blue"];
        var removed = colors.splice(0,1);              //删除第一项
        alert(colors);     //green,blue
        alert(removed);    //red
        removed = colors.splice(1, 0, "yellow", "orange");  //在位置1插入两项
        alert(colors);     //green,yellow,orange,blue
        alert(removed);    //空数组

        removed = colors.splice(1, 1, "red", "purple");    // 插入两项，删除一项
        alert(colors);     //green,red,purple,orange,blue
        alert(removed);    //yellow

位置方法

indexOf() 参数1：要查找的项参数2：查找起点位置。

lastIndexOf() 从数组末尾开始。

没找到返回-1

支持的浏览器IE9+、Firefox 2+、Sarifi 3+、Opera 9.5、Chrome。

迭代方法

参数：运行的函数（数组项的值、该项在数组中的位置、数组对象本身）[、运行该函数的作用域对象——影响this的值]

every()：如果该函数对true每一项都返回true，则返回true

filter()：返回该数组会返回的项组成的数组

forEach()：无返回值

map()：返回每次函数调用的结果组成的数组

some()：如果该数组对任一项返回true，则返回true

支持的浏览器：IE9+、Firefox 2+、Safari 3+、Opera 9.5+和Chrome

        var numbers = [1,2,3,4,5,4,3,2,1];

        var filterResult = numbers.filter(function(item, index, array){
            return (item > 2);
        });

        alert(filterResult);   //[3,4,5,4,3]

        var mapResult = numbers.map(function(item, index, array){
            return item * 2;
        });

        alert(mapResult);   //[2,4,6,8,10,8,6,4,2]

        var someResult = numbers.some(function(item, index, array){
            return (item > 2);
        });

        alert(someResult);       //true

归并方法

迭代数组所有项，构建一个返回值

array1.reduce(callbackfn[, initialValue])

callbackfn必需。一个接受最多四个参数的函数。对于数组中的每个元素，reduce 方法都会调用 callbackfn 函数一次。

initialValue可选。如果指定 initialValue，则它将用作初始值来启动累积。第一次调用 callbackfn 函数会将此值作为参数而非数组值提供。

function callbackfn(previousValue, currentValue, currentIndex, array1)

previousValue:通过上一次调用回调函数获得的值。如果向 reduce 方法提供 initialValue，则在首次调用函数时，previousValue 为 initialValue。

currentValue:当前数组元素的值。

currentIndex:当前数组元素的数字索引。

array1:包含该元素的数组对象。

支持的浏览器：IE9+、Firefox 3+、Safari 4+、Opera 10.5+和Chrome

reduce()

reduceRight()从最后一项开始

      function nima(prev, cur, index, array){
            return prev + cur;
        }
        var values = [1,2,3,4,5];
        var sum = values.reduce(nima,10);
        alert(sum);   //25

3.Data类型

不传递参数时，新创建的对象自动获取当前的日期和时间。

var now = new Date();

Date.parse()：接收一个表示时间的字符串参数，返回相应日期的毫秒数。直接将日期传递给Date构造函数也会在后台调用Date.parse()

月/日/年 9/14/2014

英文月名日,年 September 14,2014

英文星际几英文月名日年时:分:秒时区 Sun September 14 2014 18:27:33 GMT-0700

IOS 8601 扩展格式 YYYY-MM-DDTHH:mm:ss.sssZ 2014-9-14T28:27:33 只有兼容ECMAScript 5 的实现支持这种格式。

Date.UTC(year,month,day,hours,minutes,seconds,ms)：根据世界时返回 1970 年 1 月 1 日到指定日期的毫秒数。

year 必需。表示年份的四位数字。

month 必需。表示月份的整数，介于 0 ~ 11。

day 必需。表示日期的整数，介于 1 ~ 31。

hours 可选。表示小时的整数，介于 0 ~ 23。

minutes 可选。表示分钟的整数，介于 0 ~ 59。

seconds 可选。表示秒的整数，介于 0 ~ 59。

ms 可选。表示毫秒的整数，介于 0 ~ 999。

Date.now()返回调用这个方法适的日期和时间的毫秒数。

支持的浏览器：IE9+、Firefox 3+、Safari 3+、Opera 10.5+和Chrome

toLocalStriing()方法按与浏览器设置的时区相应的格式返回日期和时间，包含AM或PM，不包含时区信息。

toString()方法通常返回带有时区信息的日期时间，时间范围是0到23。

valueOf()返回日期的毫秒数。

4.RegExp类型

1.字面量形式

var expression = / pattern / flags ;

flag g:全局模式，将被应用与所有字符串。

i:不区分大小写模式。

m:多行模式，达到一行文本末尾还好继续查找下一行是否存在于模式匹配的项。

元字符: ( [ { \ ^ $ | )? * + . ] } 想要匹配字符串中的这些字符要转义

2.RegExp构造函数

传递给RegExp构造函数的两个参数都是字符串，所有元字符必须双重转义。

字符\在字符串被转义为\\在正则表达式字符串变成\\\\

var pattern2 = new RegExp("[bc]at", "i");

在ECMAScript 3中正则表达式字面量始终共享同一个RegExp实例，使用构造函数创建的每一个新RegExp实例都是新实例。各浏览器中，IE一直遵守ECMAScript 5中的规定，其他浏览器的较老版本则遵循ECMAScript 3的规定。因此在实际应用中，采取构造函数创建的方法比较安全，或者在使用lastIndex属性时要记得归0。

RegExp实例属性

gobal：布尔值，表示是否设置了g标志

ignoreCace：布尔值，表示是否设置了i标志

multiline：布尔值，表示是否设置了m标志

lastIndex：整数，表示开始搜索下一个匹配项的字符位置，从0开始

sorce：正则表达式的字符表示，按照字面量返回。

RegExp实例方法

exec()：接收一个要应用模式的字符串，然后返回包含第一个匹配项信息的数组，没有则返回NaN。

        var text = "mom and dad and baby";

        var pattern = /mom( and dad( and baby)?)?/gi;
        var matches = pattern.exec(text);

        alert(matches.index);    //0
        alert(matches.input);    //"mom and dad and baby"
        alert(matches[0]);       //"mom and dad and baby"
        alert(matches[1]);       //" and dad and baby"
        alert(matches[2]);       //" and baby"

即使设置了全局标志，它每次始终返回第一个匹配项的信息，不设置全局标志在同一个字符串上多次调用exec()始终返回第一个匹配项的信息。

设置全局标志每次调用exec()会在字符串中继续查找新匹配项。

 var text = "cat, bat, sat, fat";        var pattern2 = /.at/g;

        var matches = pattern2.exec(text);
        alert(matches.index);    //0
        alert(matches[0]);       //"cat"
        alert(pattern2.lastIndex);//3

        matches = pattern2.exec(text);
        alert(matches.index);    //5
        alert(matches[0]);       //"bat"
        alert(pattern2.lastIndex);//8

text()：接收一个字符串，模式与该参数匹配的情况下返回true，否则返回false。

var text = "000-00-0000";
var pattern = /\d{3}-\d{2}-\d{4}/;

if(pattern.test(text)){
    alert("The pattern was matched.");
}

toLocalString()和toString()都会返回正则表达式的字面量。

RegExp构造函数属性

Opera不支持短属性名，IE不支持multiline。

这些属性可以从exec()或test()执行的操作获取更具体的信息。抢开关抢开关

input $_ 最近一次要匹配的字符串

lastMatch $& 最近一次的匹配项

lastParen $+ 最近一次匹配的捕获组

leftContext $` input字符串中lastMatch之前的文本

rightContext $‘ input字符串中lastMatch之后的文本

multiline $* 布尔值，表示是否所有表达式都使用多行模式

 var text = "this has been a short summer";
        var pattern = /(.)hort/g;

        if (pattern.test(text)){
            alert(RegExp.input);               //this has been a short summer
            alert(RegExp.leftContext);         //this has been a
            alert(RegExp.rightContext);        // summer
            alert(RegExp.lastMatch);           //short
            alert(RegExp.lastParen);           //s
            alert(RegExp.multiline);           //false

短属性名需要通过方括号语法来访问。

5.Function类型

使用不带圆括号的函数名是访问函数指针而非调用函数。

没有重载

声明两个同名函数，后面的函数覆盖前面的。

函数声明与函数表达式

解析器会先解读函数声明，并使其在执行任何代码之前可用；函数表达式，必须等解析器执行到它所在的代码还才被解析执行。

alert(sum(10, 10));
function sum(num1, num2){  //可用执行
    return num1 + num2;
}

alert(sum(10, 10));
var sum = function(num1, num2){    //错误
    return num1 + num2;
};

作为值的函数

不仅可以像传递参数一样把函数传递给另一个函数，而且也可以将一个函数作为另一个函数的结果返回。

        function callSomeFunction(someFunction, someArgument){
            return someFunction(someArgument);
        }

//函数1
        function add10(num){
            return num + 10;
        }

        var result1 = callSomeFunction(add10, 10);
        alert(result1);   //20

//函数2
        function getGreeting(name){
            return "Hello, " + name;
        }

        var result2 = callSomeFunction(getGreeting, "Nicholas");
        alert(result2);   //Hello, Nicholas

从一个函数返回另一个函数。根据某个对象属性对数组排序。可以定义一个函数接收一个属性名，根据这个属性名穿件一个比较函数。

        function createComparisonFunction(propertyName) {
        //传递给数组sort()方法的比较函数要接收两个参数
            return function(object1, object2){
               //取得给定属性的值
                var value1 = object1[propertyName];
                var value2 = object2[propertyName];

                if (value1 < value2){
                    return -1;
                } else if (value1 > value2){
                    return 1;
                } else {
                    return 0;
                }
            }; //注意分号
        }

//创建一个包含两个对象的数组，每个都包含name属性和age属性
        var data = [{name: "Zachary", age: 28}, {name: "Nicholas", age: 29}];

        data.sort(createComparisonFunction("name"));
        alert(data[0].name);  //Nicholas

        data.sort(createComparisonFunction("age"));
        alert(data[0].name);  //Zachary

函数内部属性

函数内部有两个特殊的对象：arguement和this。它有一个callee属性，该属性是一个指针，指向拥有这个arguement对象的函数。

this引用的是函数据以执行的环境对象。

caller属性保存着调用当前函数的函数的引用，如果在全局作用域调用它的值为null。

        function outer(){
            inner();
        }

        function inner(){
            alert(inner.caller);
        }

        outer();

outer()调用了inner()所以inner.caller就指向了outer

函数属性和方法

length：函数喜欢接收的命名参数的个数。

prototype：保存引用类型的所有实例方法的

方法： apply()：接收两个参数，一个是在其中运行函数的作用域，另一个是参数数组，第二个参数可以是Array的实例，也可以是arguements对象。

        function sum(num1, num2){
            return num1 + num2;
        }

        function callSum1(num1, num2){
            return sum.apply(this, arguments);
        }

        function callSum2(num1, num2){
            return sum.apply(this, [num1, num2]);
        }

        alert(callSum1(10,10));   //20
        alert(callSum2(10,10));   //20

call()方法与apply()的区别在于接收参数的方式不同。call()方法第一个参数也是this，但其余参数都是直接传递给函数。

它们的真正强大的是能扩充函数的作用域。

        window.color = "red";
        var o = { color: "blue" };

        function sayColor(){
            alert(this.color);
        }

        sayColor();            //red

        sayColor.call(this);   //red
        sayColor.call(window); //red
        sayColor.call(o);      //blue

对this.color的求值会转换为对window.color的求值。当运行sayColor.call(o)时，函数体内的this对象指向o。

bind()方法会创建一个函数的实例，其this值会被绑定到传给bind()函数的值。支持bind()的浏览器有IE9+、Firefox 4+、Safari 5.1+、Opera 12+和Chrome。

每个函数继承的toLocalString()和toString()方法始终返回函数的代码，但返回的格式因浏览器而异。valueOf()方法也只返回函数代码。

6.基本包装类型

每当读取一个基本类型值的时候，后天就会创建一个对应的基本包装类型的对象，从而让我们能够调用一些方法来操作这些数据。

var s1 = "some"
var s2 = s1.substring(2);

当第二行当妈访问s1时，访问过程处于一种读取模式，后天会自动完成下列操作：

（1）创建String类型的一个实例 var s1 = new String("some");

（2）在实例上调用指定的方法 var s2 = s1.substring(2);

（3）销毁这个实例 s1 = null;

引用类型和基本包装类型的主要区别是对象的生存期。自动创建的基本包装类型的对象只存在于一行代码的执行瞬间，然后立即被销毁。这意味着我们不能在运行时为基本类型值添加属性和方法。

使用new调用基本包装类型的构造函数与直接调用同名的转型函数不一样。

var value = "25";
var number = Number(value);  //转型函数   number
var obj = new Number(value);  //构造函数   object

Boolean类型

Boolean类型的实例重写了valueOf()方法，返回基本类型值true或false，重写了toString()方法，返回字符串"true"或"false"，但还是不要用Boolean对象。

 var falseObject = new Boolean(false);  //创建Boolean对象
        var result = falseObject && true;
        alert(result);  //true  布尔表达式所有对象都转换为true

        var falseValue = false;
        result = falseValue && true;
        alert(result);  //false

        alert(typeof falseObject);   //object
        alert(typeof falseValue);    //boolean
        alert(falseObject instanceof Boolean);  //true
        alert(falseValue instanceof Boolean);   //false

Number类型

valueOf()返回对象表示的基本类型的值，toLocalString()和toString()方法返回字符串形式的数值。

toFixed()方法会安装指定的小数位返回数值的字符串表示。

var num = 10;
alert(num.toFixed(2));   //"10.00"

var num2 = 10.005;
alert(num.toFixed(2));   //"10.01"

不同浏览器给这个方法设定的舍入规则可能不同。给toFixed传入0，IE8和之前版本不能舍入范围在(-0.94,-0.5],[0.5,0.9)之间的值，IE会返回0。

toExponential()返回指数表示法。

toPrecision()可能返回固定大小格式，也能返回指数格式。

        numberObject = new Number(99);
        alert(numberObject.toPrecision(1));    //"1e+2"
        alert(numberObject.toPrecision(2));    //"99"
        alert(numberObject.toPrecision(3));    //"99.0"

不建议直接实例化Number 类型——在使用typeof和instanceof操作符测试基本类型数值与引用类型数值时，得到的结果完全不同。

        var numberObject = new Number(10);
        var numberValue = 99;

        //typeof
        alert(typeof numberObject);   //object
        alert(typeof numberValue);    //number
        //instanceof
        alert(numberObject instanceof Number);  //true
        alert(numberValue instanceof Number);   //false

String类型

valueOf()、toString()、toLocalString()方法都返回对象的基本字符串值。

每个实例都有length属性，即使字符串包含双字节字符（不是占一个字节的ASCII字符），每个字符也仍算一个字符。

1.字符方法

charAt()：以单字符字符串的形式返回给特定位置的那个字符

charCodeAt()：以字符串的形式返回特定位置的字符的字符编码

方括号加字符索引来访问字符串中的特定字符（IE7及之前的版本会返回undefined）

     var string = "hello world";
     alert(string.charAt(1));           //"e"
     alert(string[1]);                 //"e"
     alert(string.charCodeAt(1));     //"101"

2.字符串操作方法

concat()：将一个或多个字符串连接起来，得到新的字符串——使用加号操作符在大多数情况下比这方法要简单（特别是拼接多个字符串）。

第一个参数都是子字符串开始的位置 slice()和 substring()的第二个参数指定子字符串最后一个字符后面的位置，substr()的第二个字符串返回字符个数。

slice()：所有负值与字符串的长度相加。

substr()：负的第一个参数加上字符串的长度，负的第二个参数转换为0。

substring()：所有负值参数转换为0。

        alert(stringValue.slice(-3));         //"rld"
        alert(stringValue.substring(-3));     //"hello world"
        alert(stringValue.substr(-3));        //"rld"
        alert(stringValue.slice(3, -4));      //"lo w"
        alert(stringValue.substring(3, -4));  //"hel"  等于substring(0,3)
        alert(stringValue.substr(3, -4));     //"" (empty string)

3.字符串位置方法

indexOf() 参数1：要查找的项参数2：查找起点位置。

lastIndexOf() 从数组末尾开始。

没找到返回-1

4.trim方法

trim()：返回字符串的副本，删除字符串前置和后置的空格。

支持的浏览器：IE9+、Firefox 3.5+、Safari 5+、Opera 10.5+和Chrome。

Firefox 3.5+、Sarifi 5+和Chrome 8+还支持非标准的trimLeft()和trimRight()。

5.字符串大小写转换方法

toUpperCase()：将字符串转化为大写。

toLowerCase()：将字符串转化为小写。

toLocaleUpperCase()、 toLocaleLowerCase()：只有几种语言（如土耳其语）具有地方特有的大小写映射，所有该方法的返回值通常与 toUpperCase() 一样。

6.字符串的模式匹配方法

match()：本质上与调用RegExp的exec()方法相同。只接受一个参数，只能是正则表达式或RegExp对象。

search()：参数与match()方法相同，返回字符串中第一个匹配项的索引，没有则返回-1。

replace()：第一个参数是一个RegExp对象或字符串（不会被转换成正则表达式），第二个是字符串或函数。如果第一个参数是字符串，只会替换第一个子字符串。要替换所有子字符串必须提供正则表达式，而且要指定全局标志。

 var text = "cat, bat, sat, fat";
 var result = text.replace("at","ond";)
 alert(result);  //"cond, bat, sat, fat"

 var text = "cat, bat, sat, fat";
 var result = text.replace("/at/g","ond";)
 alert(result);  //"cond, bond, sond, fond"

第二个参数是字符串可以使用特殊的字符序列，将正则表达式操作得到的值插入到结果字符串中。

字符序列替换文本

$$ $

$& 匹配整个模式的子字符串，与RegExp.lastMatch的值相同

$‘ 匹配子字符串之前的子字符串，与RegExp.leftContext的值相同

$` 匹配子字符串之右的子字符串，与RegExp.rightContext的值相同

$n 匹配第n个捕获组的子字符串，n等于0~9。如果正则表达式没有定义捕获组，使用空字符串。

$nn 匹配第nn个捕获组的子字符串，n等于1~99。如果正则表达式没有定义捕获组，使用空字符串。

第二个参数也可以是一个函数。在只有一个匹配项（与模式匹配的字符串）的情况下，会向这个函数传递3个参数：模式的匹配项、模式匹配项在字符串中的位置和原始字符串。

在正则表达式中定义了多个捕获组的情况下，传递给函数的参数依次是模式的匹配项、第一个捕获组的匹配项、第二个捕获组的匹配项……但最后两个参数依然分别是模式的匹配项在字符串中的位置和原始字符串。

function htmlEscape(text){
            return text.replace(/[<>"&]/g, function(match, pos, originalText){
                switch(match){
                    case "<":
                        return "&lt;";
                    case ">":
                        return "&gt;";
                    case "&":
                        return "&amp;";
                    case "\"":
                        return "&quot;";
                }
            });
        }

        alert(htmlEscape("<p class=\"greeting\">Hello world!</p>")); //&lt;p class=&quot;greeting&quot;&gt;Hello world!&lt;/p&gt;

split()：基于指定的分隔符将一个字符串分隔成多个子字符串，将结果放到一个字符串，分隔符可以是字符串，也可以是RegExp()对象（不会将字符串看成正则表达式）。可以接受可选的第二个参数，用于指定数组的大小，确保返回的数组不会超过既定大小。

        var colorText = "red,blue,green,yellow";
        var colors1 = colorText.split(",");      //["red", "blue", "green", "yellow"]
        var colors2 = colorText.split(",", 2);   //["red", "blue"]
        var colors3 = colorText.split(/[^\,]+/); //["", ",", ",", ",", ""]

第一项和最后一项是两个字符串，因为通过正则表达式指定的分隔符出现在字符串的开头。

7.localecompare()方法

比较两个字符串——

如果字符串在字母表中应排在字符串参数之前，则返回一个负数（大多数是-1）。

如果字符串等于字符串参数，则返回0。

如果字符串在字母表中应排在字符串参数之后，则返回一个正数（大多数是1）。

8.fromCharCode()方法

接收一个或多个字符编码，将它们转换为一个字符串。

alert(String.fromCharCode(104, 101, 108, 108, 111)); //"hello"

9.HTML方法

尽量不使用，因为它们创建的标志通常无法表达语义。

7.单体内置对象

Global对象

不属于任何其他对象的属性和方法，都是它的属性和方法。没有全局变量或全局函数，所有在全局作用域定义的属性和函数，都是Global对象的属性。isNaN()、isFinite()、parseInt()和parseFloat()都是Global对象的方法。

1.URI编码方法

对URI（通用资源标识符）进行编码，以便发送给浏览器。有效的URI不能包括某些字符，例如空格。

encodeURI()主要用于整个URI不会对本身属于URI的特殊字符进行编码、例如:、/、?和#。

encodeURIComponent()主要用于对URI的某一段，会对它发现的任何非标准字符进行编码。

使用encodeURIcomponent()方法的时候比encodeURI()多，因为在实践中更常见的是查询字符串参数而不是对URI进行编码。

decodURI:只能对使用encodeURI替换的字符进行编码

decodeURIComponent()：解码使用encodeURIcomponent()编码的所有字符

        var uri = "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start";

        //http%3A%2F%2Fwww.wrox.com%2Fillegal value.htm%23start
        alert(decodeURI(uri));

        //http://www.wrox.com/illegal value.htm#start
        alert(decodeURIComponent(uri));

2.eval()方法

可计算某个字符串，并执行其中的的 JavaScript 代码。

3.Global对象的属性

特殊值undefined NaN Infinity

构造函数Object Array Function Boolean String Number Date RegExp Error EvalError RangeError ReferenceError SyntaxError TypeError URIError

4.window对象

Math对象

1.Math对象的属性

Math.E 自然对数的底数，即常数e的值

Math.LN10 10的自然对数

Math.LOG2E 以2为底e的对数

Math.PI π的值

Math.SQRT1_2 1/2的平方根

Math.SQRT2 2的平方根

2.min()和max()方法

        var max = Math.max(3, 54, 32, 16);
        alert(max);    //54

        var min = Math.min(3, 54, 32, 16);
        alert(min);    //3

3.舍入方法

Math.ceil()：向上取舍

Math.floor()：向下取舍

Math.round()：标准取舍——四舍五入

4.random()方法

返回大于等于0小于1的一个随机数。

从某个整数范围内随机选一个值：

值 = Math.floor(Math.random() * 可能值的总数 +第一个可能的值)

        function selectFrom(lowerValue, upperValue) {
            var choices = upperValue - lowerValue + 1;
            return Math.floor(Math.random() * choices + lowerValue);
        }

        var num = selectFrom(2, 10);
        alert(num);   //2到10（包括2和10）之间的数值

        var colors = ["red", "green", "blue", "yellow", "black", "purple", "brown"];
        var color = colors[selectFrom(0, colors.length-1)];
        alert(color);  //可能是数组中任何一个字符串

5.其他方法

Math.abs(num) 返回num的绝对值 Math.asin(x) 返回x的反余弦值

Math.exp(num) 返回Math.E的num次幂 Math.atan(x) 返回x的反正切值

Math.log(num) 返回num的自然对数 Math.atan2(y,x) 返回y/x的反正切值

Math.pow(num,power) 返回num的power次幂 Math.cos(x) 返回x的余弦值

Math.sqrt(num) 返回num的平方根 Math.sin(x) 返回x的正弦值

Math.acos(x) 返回x的反余弦值 Math.tan(x) 返回x的正切值

时间： 2024-11-05 20:28:49