Array

 

array.concat(item...)

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

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

 

array.join(spearator)

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

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

 

array.pop()

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

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

 

array.push(item...)

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

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

push方法可以像这样实现：

1         Array.method('push',function(){2             this.splice.apply(3                 this,4                 [this.length,0].5                     concat(Array.prototype.slice.apply(arguments)));6         });

 

 

array.reverse()

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

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

 

array.shift()

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

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

shift可以这样实现：

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

 

array.slice(start,end)

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

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

 

array.sort(comparefn)

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

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

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

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

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

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

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

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

1         var by = function(name){ 2             return function(o,p){ 3                 var a,b; 4                 if(typeof o === 'object' && typeof p === 'object' && o && p){ 5                     a = o[name]; 6                     b = p[name]; 7                     if(a === b){ 8                         return 0; 9                     }10                     if(typeof a === typeof b){11                         return a < b ? -1 : 1;12                     }13                     return typeof a < typeof b ? -1 : 1;14                 }else{15                     throw{16                         name: 'Error',17                         message: 'You are too '18                     };19                 }20             };21         };22 23         var s = [24             {first: 'Jo',        last: 'Be'},25             {first: 'Moe',        last: 'Ho'},26             {first: 'Jo',       last: 'De'},27             {first: 'Sh',        last: 'Ho'},28             {first: 'La',        last: 'Fi'},29             {first: 'Cu',        last: 'Ho'}30         ];31         s.sort(by('first'));

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

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

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

 

1         var s = [ 2             {first: 'Jo',        last: 'Be'}, 3             {first: 'Moe',        last: 'Ho'}, 4             {first: 'Jo',       last: 'De'}, 5             {first: 'Sh',        last: 'Ho'}, 6             {first: 'La',        last: 'Fi'}, 7             {first: 'Cu',        last: 'Ho'} 8         ]; 9         var by = function(name,minor){10             return function(o,p){11                 var a,b;12                 if(typeof o === 'object' && typeof p === 'object' && o && p){13                     a = o[name];14                     b = p[name];15                     if(a === b){16            17                         return typeof minor === 'function' ? minor() : 0;18                         //return typeof minor === 'function' ? minor(o,p) : 0;19                         //return typeof minor === 'function' ? minor : 0;20                     }21                     if(typeof a === typeof b){22                         return a < b ? -1 : 1;23                     }24                     return typeof a < typeof b ? -1 : 1;25                 }else{26                     throw{27                         name: 'Error',28                         message: 'XXXXXXX '29                     };30                 }31             };32         };33         s.sort(by('last',by('first')))

 

 

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

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

splice最主要的用处是从一个数组中删除元素。

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

splice可以像这样实现：

1         Array.method('splice',function(start,deleteCount){ 2             var max = Math.max, 3                 min = Math.min, 4                 dalta, 5                 element, 6                 insertCount = max(arguments.length - 2,0), 7                 k = 0, 8                 len = this.length, 9                 new_len,10                 result = [],11                 shift_count;12 13             //判断start参数是否为负数，如果是负数，转换为正值14             start = strat || 0;15             if(start < 0){16                 start += len;17             }18             start = max(min(start,len),0);19             //如果deleteCount大于数组中剩余的项数，则给它赋值数组中剩余的项数20             deleteCount = max(min(typeof deleteCount === 'number' ? deleteCount : len,len - start),0);21             //判断插入的项数是否大于删除的项数22             delta = insertCount - deleteCount23             //数组新长度24             new_len = len + delta;25             //构建返回值26             while(k < deleteCount){27                 element = this[start + k];28                 if(element !== underfined){29                     result[k] = element;30                 }31                 k += 1;32             }33             //删除deleteCount项数后，array剩余的项数34             shift_count = len - start - deleteCount;35             //插入项数小于删除项数36             if(delta < 0){37                 k = start + insertCount;38                 // 将后面的项数往前移39                 while(shift_count){40                     this[k] = this[k - delta];41                     k += 1;42                     shift_count -= 1;43                 }44                 this.length = new_len;45             // 插入项数大于删除项数46             }else if(delta > 0){47                 k = 1;48             // 将剩余的项往后移49                 while(shift_count){50                     this[new_len - k] = this(len - k);51                     k += 1;52                     shift_count -= 1;53                 }54                 this.length = new_len;55             }56             //赋值57             for(k = 0;k < insertCount; k += 1){58                 this[start + k] = arguments[k + 2];59             }60             return result;61         });

 

 

array.unshift(item...)

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

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

unshift可以像这样实现：

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

 

Function

function.apply(thisArg,argArray)

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

 

Number

 

number.toExponential(fractionDigits)

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

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

 

number.toFixed(fractionDigits)

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

1         document.writeln(Math.PI.toFixed(16));2         //3.14159265358979313         document.writeln(Math.PI.toFixed(0));4         //3

 

number.toPrecision(precision)

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

1         document.writeln(Math.PI.toPrecision(16));2         //3.1415926535897933         document.writeln(Math.PI.toPrecision(2));4         //3.1

 

number.toString(radix)

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

1         document.writeln(Math.PI.toString(16));2         //3.243f6a8885a3         document.writeln(Math.PI.toString(2));4         //11.001001000011111101101010100010001000010110100011

 

Object

 

object.hasOwnProperty(name)

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

1         var a = {member: true};2         var b = Object.create(a);3         var t = a.hasOwnProperty('member');    //true4         var u = b.hasOwnProperty('member');    //false5         var v = b.member;    //true

 

 

RegExp

 

 

//后续补充

regexp.exec(string)

regexp.test(string)

 

String

 

String.charAt(pos)

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

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

 

string.charCodeAt(pos)

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

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

 

string.concat(string...)

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

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

 

string.indexOf(searchString,position)

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

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

 

string.lastIndexOf(searchString,position)

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

 

string.localeCompare(that)

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

1         var m = ['AAA','A','a','Aa','aaa'];2         m.sort(function(a,b){3             return a.localeCompare(b);4         });5         //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...)

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

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