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'