第8章-方法

Array

array.concat(item...)

concat方法产生一个新数组。并把一个或多个参数item附加在其后。

        var a = ['a','b','c'];
        var b = ['x','y','z'];
        var c = b.concat(a,true,34);
        console.log(c);    //["x", "y", "z", "a", "b", "c", true, 34]

 

array.join(spearator)

join方法把一个array构造成一个字符串，它先把array中的每个元素构造成一个字符串，接着用一个separator分隔符把他们链接在一起，默认的separator是逗号','。要想做无间隔连接，我们可以使用空字符串作为separator

        var a = ['a','b','c'];
        a.push('d');
        var c = a.join('');    //"abcd"
        var b = ['a',23,['e',true]];
        var d = b.join(',');    //"a,23,e,true"

 

array.pop()

移除数组中最后一个元素并返回它，如果该array是empty，它会返回underfined。

        var a = ['a','b','c'];
        var c = a.pop();    //a 是["a", "b"]，c是"c"

 

array.push(item...)

把一个或多个参数item附加到array的尾部，与concat方法不同的是如果item是一个数组，它将把它作为单个元素添加到array中，并返回这个数组的新长度值

        var a = ['a','b','c'];
        var b = ['x','y','z'];
        var c = a.push(b);    //a是["a", "b", "c", Array[3]0: "x"1: "y"2: "z"length: 3__proto__: Array[0]]
        console.log(c);    //4
        var e = [];
        var first = [1,2,3],second = [4,5,6];
        e.push(first);
        e.push(second);
        e[1][1]    //5

push方法可以像这样实现：

        Array.method('push',function(){
            this.splice.apply(
                this,
                [this.length,0].
                    concat(Array.prototype.slice.apply(arguments)));
        });

 

 

array.reverse()

反转array里的元素顺序，并返回array本身

        var a = ['a','b','c'];
        var b = a.reverse();
        //a和b都是["c", "b", "a"]

 

array.shift()

移除数组array中的第1个元素并返回该元素。如果这个数组array是空的，返回underfined。

        var a = ['a','b','c'];
        var b = a.shift();    //a是["b", "c"]，b是"a"

shift可以这样实现：

        Array.method('shift',function(){
            return this.splice(0,1)[0];
        });

 

array.slice(start,end)

slice方法对array中的一段做浅复制，从array[start]一直复制到array[end],不包括array[end]。end参数是可选的，默认值是array.length。如果参数中有负数，则会将它和array.length相加，让他们成为非负数。如果start大于等于array.length，得到的结果将是一个新的空数组

        var a = ['a','b','v'];
        var b = a.slice(0,1);    //["a"]
        var c = a.slice(1);        //["b", "v"]
        var d = a.slice(1,2);    //["b"]

 

array.sort(comparefn)

fort方法对array中的内容进行排序。它不能正确地给一组数字排序:

        var n = [4,5,18,56,32];
        n.sort();    //[18, 32, 4, 5, 56]

错误的原因是JavaScript的默认比较函数把要排序的元素都视为字符串。但是我们可以使用自己的比较函数来替换默认的比较函数。你的比较函数应该接受两个参数，并且如果这两个参数相等则返回0，如果第一个参数应该排列在前面，则返回一个负数，如果第二个参数应该排在前面，则返回一个正数。

        n.sort(function(a,b){
            return a - b;
        });    //[4, 5, 18, 32, 56]

上面这个函数可以使数字正确的排序，但它不能使字符串排序，优化后：

        var m = ['aa','bb','a',4,8,12,35,8,98];
        m.sort(function (a,b){
            if(a === b){
                return 0;
            }
            if(typeof a === typeof b){
                return a < b ? -1 : 1;
            }
            return typeof a < typeof b ? -1 : 1;
        });
        //[4, 8, 8, 12, 35, 98, "a", "aa", "bb"]

如果大小写不重要，你的比较函数应该在比较之前先将两个运算数转化为小写

如果有一个更智能的比较函数，可以对对象数组排序，我们将编写一个构造比较函数的函数：

        var by = function(name){
            return function(o,p){
                var a,b;
                if(typeof o === 'object' && typeof p === 'object' && o && p){
                    a = o[name];
                    b = p[name];
                    if(a === b){
                        return 0;
                    }
                    if(typeof a === typeof b){
                        return a < b ? -1 : 1;
                    }
                    return typeof a < typeof b ? -1 : 1;
                }else{
                    throw{
                        name: 'Error',
                        message: 'You are too '
                    };
                }
            };
        };

        var s = [
            {first: 'Jo',        last: 'Be'},
            {first: 'Moe',        last: 'Ho'},
            {first: 'Jo',       last: 'De'},
            {first: 'Sh',        last: 'Ho'},
            {first: 'La',        last: 'Fi'},
            {first: 'Cu',        last: 'Ho'}
        ];
        s.sort(by('first'));

sort方法是不稳定的，所以下面的调用：

        s.sort(by('first')).sort(by('last'));    

不能保证产生正确的序列，如果想要基于多个值进行排序，你需要做更多的工作：

        var s = [
            {first: 'Jo',        last: 'Be'},
            {first: 'Moe',        last: 'Ho'},
            {first: 'Jo',       last: 'De'},
            {first: 'Sh',        last: 'Ho'},
            {first: 'La',        last: 'Fi'},
            {first: 'Cu',        last: 'Ho'}
        ];
        var by = function(name,minor){
            return function(o,p){
                var a,b;
                if(typeof o === 'object' && typeof p === 'object' && o && p){
                    a = o[name];
                    b = p[name];
                    if(a === b){
           
                        return typeof minor === 'function' ? minor() : 0;
                        //return typeof minor === 'function' ? minor(o,p) : 0;
                        //return typeof minor === 'function' ? minor : 0;
                    }
                    if(typeof a === typeof b){
                        return a < b ? -1 : 1;
                    }
                    return typeof a < typeof b ? -1 : 1;
                }else{
                    throw{
                        name: 'Error',
                        message: 'XXXXXXX '
                    };
                }
            };
        };
        s.sort(by('last',by('first')))

 

array.splice(start,deleteCount,item....)

aplice方法从array中移除一个或多个元素，并用新的item替换他们，参数start是从数组array中移除元素的开始位置，参数deleteCount是要移除的元素个数。如果有额外的参数，那些item会插入到被移除元素的位置上。它返回一个包含被移除元素的数组。
splice最主要的用处是从一个数组中删除元素。

        var a = ['a','b','c'];
        var r = a.splice(1,1,'ache','bug');
        //a 是 ["a", "ache", "bug", "c"]
        //b 是 ["b"]

splice可以像这样实现：

        Array.method('splice',function(start,deleteCount){
            var max = Math.max,
                min = Math.min,
                dalta,
                element,
                insertCount = max(arguments.length - 2,0),
                k = 0,
                len = this.length,
                new_len,
                result = [],
                shift_count;

            //判断start参数是否为负数，如果是负数，转换为正值
            start = strat || 0;
            if(start < 0){
                start += len;
            }
            start = max(min(start,len),0);
            //如果deleteCount大于数组中剩余的项数，则给它赋值数组中剩余的项数
            deleteCount = max(min(typeof deleteCount === 'number' ? deleteCount : len,len - start),0);
            //判断插入的项数是否大于删除的项数
            delta = insertCount - deleteCount
            //数组新长度
            new_len = len + delta;
            //构建返回值
            while(k < deleteCount){
                element = this[start + k];
                if(element !== underfined){
                    result[k] = element;
                }
                k += 1;
            }
            //删除deleteCount项数后，array剩余的项数
            shift_count = len - start - deleteCount;
            //插入项数小于删除项数
            if(delta < 0){
                k = start + insertCount;
                // 将后面的项数往前移
                while(shift_count){
                    this[k] = this[k - delta];
                    k += 1;
                    shift_count -= 1;
                }
                this.length = new_len;
            // 插入项数大于删除项数
            }else if(delta > 0){
                k = 1;
            // 将剩余的项往后移
                while(shift_count){
                    this[new_len - k] = this(len - k);
                    k += 1;
                    shift_count -= 1;
                }
                this.length = new_len;
            }
            //赋值
            for(k = 0;k < insertCount; k += 1){
                this[start + k] = arguments[k + 2];
            }
            return result;
        });

 

 

array.unshift(item...)

它把元素添加到数组中的开始部分

        var a = ['a','b','c'];
        var b = a.unshift('?','@');
        // a是["?", "@", "a", "b", "c"]
        // b是5

unshift可以像这样实现：

        Array.method('unshift',function(){
            this.splice.apply(this,[0,0].concat(Array.prorotype.slice.apply(arguments)));
            return this.length;
        });

 

Function

function.apply(thisArg,argArray)

//后续补充......

 

Number

 

number.toExponential(fractionDigits)

转换成一个指数形式的字符串，fractionDigits控制其小数点后的数字位数，它的值必须在0~20；

        document.writeln(Math.PI.toExponential(0));
        //3e+0
        document.writeln(Math.PI.toExponential(16));
        // 3.1415926535897931e+0

 

number.toFixed(fractionDigits)

将number转换成一个十进制形式的字符串。fractionDigits控制其小数点后的数字位数，它的值必须在0~20；

        document.writeln(Math.PI.toFixed(16));
        //3.1415926535897931
        document.writeln(Math.PI.toFixed(0));
        //3

 

number.toPrecision(precision)

将number转换成一个十进制形式的字符串。fractionDigits控制数字的精度，它的值必须在1~20；

        document.writeln(Math.PI.toPrecision(16));
        //3.141592653589793
        document.writeln(Math.PI.toPrecision(2));
        //3.1

 

number.toString(radix)

把number转换成一个字符串。radix控制基数。它的值必须在2~36.默认的radix是以10位基数的

        document.writeln(Math.PI.toString(16));
        //3.243f6a8885a
        document.writeln(Math.PI.toString(2));
        //11.001001000011111101101010100010001000010110100011

 

Object

 

object.hasOwnProperty(name)

如果这个object包含一个名为name的属性，那么hasOwnProperty方法返回true。原型链中的同名属性是不会被检查的。这个方法对name就是hasOwnProperty时不起作用，此时会返回false

        var a = {member: true};
        var b = Object.create(a);
        var t = a.hasOwnProperty('member');    //true
        var u = b.hasOwnProperty('member');    //false
        var v = b.member;    //true

 

 

RegExp

//后续补充

regexp.exec(string)

regexp.test(string)

 

String

 

String.charAt(pos)

返回在string中pos位置处的字符，如果pos小于或大于等于字符串的长度string.length,它会返回空字符串。

        var name = 'Curly';
        var initial = name.charAt(0);    //"C"

 

string.charCodeAt(pos)

以整数形式表示在string中pos位置处的字符的字符编码

        var name = 'Curly';
        var initial = name.charCodeAt(0);    //67

 

string.concat(string...)

把其他的字符串链接在一起来构造一个新的字符串

         var a = 'C'.concat('a','t');    //"Cat"

 

string.indexOf(searchString,position)

在string内查找一个字符串searchString。如果它被找到，返回第1个匹配字符的位置，否则返回-1。position课设置从string的某个指定位置开始查找：

        var text = "Mississippi";
        var p = text.indexOf('i',2);    //4

 

string.lastIndexOf(searchString,position)

和indexOf方法类似，只不过是从string的尾部开始向开头查找

 

string.localeCompare(that)

方法比较两个字符串。如何比较字符串的规则没有详细的说明如果String比字符串that小，那么结果为负数。如果他们是相等的，那么结果为0。这类似于array.sort比较函数的约定：

        var m = ['AAA','A','a','Aa','aaa'];
        m.sort(function(a,b){
            return a.localeCompare(b);
        });
        //m是["a", "A", "Aa", "aaa", "AAA"]

//以后补充

string.match(regexp)

match方法让字符串个一个正则表达式进行匹配

string.replace(searchValue,replaceValue)

string.search(regxp)

string.slice(start,end)

string.split(separator,limit)

string.toLocaleLowerCase()

按照本地规则把string中的所有字母转换为小写形式

 

string.toLocaleUpperCase()

按照本地规则把string中的所有字母转换为大写形式

 

string.toUpperCase()

返回一个字符串，这个string中的所有字母都被转换为大写形式

 

string.toLowerCase()

返回一个字符串，这个string中的所有字母都被转换为小写写形式

 

String.fromCharCode(char...)

根据一串数字编码返回一个字符串

        var a = String.fromCharCode(67,97,116);
        //a是'Cat'