JavaScript方法

1. Array

1）array.concat(item…)
该方法产生一个新数组，包含一份array的浅复制，并把一个或者多个参数item加在其后：

var a = [1,2,3];
var b = [4,5,6];
var c = a.concat(b,7);
// c : [1,2,3,4,5,6,7]

2) array.join(separator)
该方法是把一个array构造成一个字符串。separator默认是逗号“,”

var a = ["a","b","c"];
var b = a.join("");
//b : "abc"

3) array.pop()
pop和push方法使得数组array可以像堆栈一样工作。pop方法移除array中的最后一个元素并返回该元素，如果array是empty，则返回undefined

var a = ["a","b","c"];
var b = a.pop();
//a: ["a","b"]
//b : "c"

4) array.push(item…)
push方法把一个或者多个参数item加到array的尾部。会修改原数组array，返回新数组的长度：

var a = ["a","b","c"];
var b = [1,2,3];
var c = a.push(b, true);
// c : 5
// a : ["a","b","c",[1,2,3],true]

实现push：

Array.prototype._push = function(){
	this.splice.apply(this, [this.length, 0].concat(Array.prototype.slice.apply(arguments) ));
	return this.length;
}

5) array.reverse()
该方法是反转array里的元素的顺序，并返回反转的array：

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

6) array.shift()
该方法移除数组array中的第一个元素并返回该元素。如果这个数组是空的，返回undefined。shift比pop慢的多。

var a = [1,2,3];
var b = a.shift();
//a: [2,3], b: 1

实现shift：

Array.prototype._shift = function(){
	return this.splice(0,1)[0];
}

7) array.slice(start, end)
该方法是对array中的一段做浅复制。从array[start]一直复制到array[end];
end是可选的，默认是该数组的长度；
其中有一个值为负数时，该值和array.length相加；
start大于array.length，返回一个空数组；

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

8) array.sort(comparefn)
该方法对array中的内容进行排序

var a = [4,8,15,16,23,42];
a.sort();
//a: [15,16,23,4,42,8]

a.sort(function(a,b){
	return a-b;
});
//a: [4,8,15,16,23,42]

9) array.splice(start, deleteCount, item…)
该方法从array[start]开始删除deleteCount个，并用新的item替换它们。返回删除的元素。

var a = [1,2,3];
var b = a.splice(1,1,"aa","bb");
//a: [1,"aa","bb",3]
//b: [2]

实现splice：

Array.prototype._splice = function(){
	var max = Math.max,
		min = Math.min,
		delta,
		element,
		insertCount = max(arguments.length - 2, 0),
		k = 0,
		len = this.length,
		new_len,
		result = [],
		shift_count;
		
		start = start || 0;
		if(start < 0){
			start += len;
		}

		start = max(min(start,len),0);
		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 !== undefined){
				result[k] = element;
			}
			k += 1;
		}
		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;
}

10）array.unshift(item…)
该方法是把一个或者多个元素添加到数组的最前面。返回新数组的长度。

var a = [1,2,3];
var b = a.unshift("a","b");
//b: 5
//a: ["a","b",1,2,3]

实现unshift:

Array.prototype._unshift = function(){
	this.splice.apply(this, [0,0].concat(Array.prototype.slice.apply(arguments) ));
	return this.length;
}

2. Function

1）function.apply(this.arg, argArray)

apply方法调用function，传递一个会被绑定到this上的对象和一个可选的数组作为参数。

Function.prototype.bind = function(that){
	var method = this,
		slice = Array.prototype.slice,
		args = slice.apply(arguments, [1]);
		return function(){
			return method.apply(that,args.concat(slice.apply(arguments,[0])))
		}
}

var x = function(){

	return this.value;
}.bind({value:123});

x(); //666

3. Number

1) number.toExponential(fractionDigits)
该方法把这个number转换成一个指数形式的字符串，可选参数fractionDigits表示小数点后的位数。

(3).toExponential(2);   // "3.00e+0"
Math.PI.toExponential(2);   // "3.14e+0"

2) number.toFixed(fractionDigits)
该方法是把这个number转为一个十进制形式的字符串，可选参数是控制小数点后数字位数。

(3).toFixed(2);     //"3.00"
Math.PI.toFixed(2);  // "3.14"

3) number.toPrecision( precision )
该方法是把这个number转换成为一个十进制数形式的字符串，可选参数控制数字的精度。

Math.PI.toPrecision(2);  // "3.1"
Math.PI.toPrecision(3);  // "3.14"

4) number.toString(radix)
该方法是把这个number转成为一个字符串，可选参数radix控制基数（值必须在2-36，默认值是10）。

(3).toString(2);   //"3.00"
(3).toString();    //"3"

4. Object

1) object.hasOwnProperty(name)
如果object包含一个名为name的属性，hasOwnProperty则返回为true。原型链中的同名属性是不会被检查的。

var obj = {number: true};
var a = Object.create(obj);

obj.hasOwnProperty("number");  // true
a.hasOwnProperty("number");    // false
a.number;     // true

5. String

1) string.charAt(pos)
该方法返回字符串pos位置处的字符，如果pos小于0或者大于等于字符串的长度则返回空字符串

var str = "hello";
var aa = str.charAt(0);
aa    // "h"

charAt的实现：

String.prototype._charAt = function(){
	return this.slice(pos, pos-1);
}

2) string.charCodeAt(pos)
该方法返回的是string中pos位置处的字符的字符码位。如果pos小于0或者大于字符串的长度则返回NaN

var str = "hello";
var a = str.charCodeAt(0);
a;   // 104

3) string.concat(string…)
该方法是把其他的字符串连接在一起构造一个新的字符串。用+运算符更简单。

var s = "a".concat("b","c");
s;  // "abc"

4) string.indexOf(searchString, position)
该方法是在string中查找searchString字符串，能找到返回该字符串的第一个字符在string中的下标值，如果没有找到返回-1；可选参数position指定从某处开始查找。

var str = "hello world";

str.indexOf("o");   //4
str.indexOf("a");   //-1
str.indexOf("o",5); //7

5) string.lastIndexOf(searchString, position)
该方法和indexOf方法很相似，只不过该方法是从末尾开始查找。

6）string.localeCompare(that)

a.localeCompare(b);

该方法是比较两个字符串
如果a字符串在字母表的位置在b的后面，则返回一个正数（大多数情况是1）；
如果a字符串在字母表的位置在b的前面，则返回一个负数（大多数情况是-1）；
如果a字符串等于b字符串，则返回0；
7）string.match(regexp)
该方法让字符串和一个正则表达式进行匹配。

8）string.replace(searchValue, replaceValue)
该方法对string进行查找和替换，返回一个新的字符串。searchValue可以是一个字符串也可以是一个正则表达式。
如果是字符串，它只会在第一次出现的地方被替换。

var str = "h-e-l-l-o";
str.replace9(“-”，“”)；   //"he-l-l-o"

如果是正则：

var str = "h-e-l-l-o";
str.replace9(/-/g，“”)；   //"hello"

第二个参数replaceValue可以是一个函数。

9）string.search(regexp)
该方法接受一个正则表达式对象作为参数，如果找到匹配返回匹配首字母的下标值，如果没有找到返回-1.

var text = "hello world!";
var pos = text.search(/!/);   // 11

10) string.slice(start, end)
该方法是复制string的一部分字符串来构造一个新的字符串。
如果start小于零，则和string.length相加；
end可选，默认值为string.length;
end 小于零，则和string.length相加；

var text = "hello world!";
var str = text.slice(6);   //"world!"

11) string.split(separator, limit)
该方法是将string分割成片段来创建一个字符串数组。limit可以限制被分割的片段的数量。
12）string.substring(start,end)

13) string.toLocaleLowerCase(),string.toLowerCase()
把string中所有的字符转为小写字母
14）string.toLocaleUpperCase(),string.toUpperCase()
把string中所有的字符转为大写字母
15) string.fromCharCode(char…)
该方法可以根据一串数字编码返回一个字符串。