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); //4 5 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 - deleteCount
23 //数组新长度
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+0 3 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.1415926535897931 3 document.writeln(Math.PI.toFixed(0)); 4 //3
number.toPrecision(precision)
将number转换成一个十进制形式的字符串。fractionDigits控制数字的精度，它的值必须在1~20；
1 document.writeln(Math.PI.toPrecision(16)); 2 //3.141592653589793 3 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.243f6a8885a 3 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‘); //true
4 var u = b.hasOwnProperty(‘member‘); //false
5 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‘