javascript标准方法

1、Array
array.concat(item…)
concat方法返回一个新数组，它包含array的浅复制并将一个或多个参数item附加在其后。如果参数item是一个数组，那么它的每个元素会被分别添加。

var a = [‘a’,‘b’]
var b = [‘x’,‘y’]
var c = a.concat(b,true)
//c是[‘a’,‘b’,‘x’,‘y’,true]

array.join(separator)
join方法把一个array构造成一个字符串。它将array中的每个元素构造成一个字符串，并用一个separator为分隔符把它们连接在一起。默认的separator是‘，’。为了实现无间隔的连接，我们可以实用空字符串作为separator。

var a = [‘a’,‘b’,‘c’]
a.push(‘d’)
var c = a.join(’’) //c是’abcd’

array.pop()
pop和push方法是数组array像堆栈一样工作。pop方法移除array中的最后一个元素并返回该元素。如果该array是空的，它会返回undefined。

var a = [‘a’,‘b’,‘c’]
var c = a.pop() // a是[‘a,‘b’] c是’c’

array.push(item…)
push方法将一个或多个参数item附加到一个数组的尾部。不像concat方法那样，它会修改数组array，如果参数item是一个数组，它会将参数数组作为单个元素整个添加到数组中。它返回这个数组array的新长度值。

var a = [‘a’,‘b’,‘c’]
var b = [‘x’,‘y’,‘z’]
var c = a.push(b,true) //a是[‘a’,‘b’,‘c’,[‘x’,‘y’,‘z’],true] c是5

array.reverse()
reverse方法反转array中的元素的顺序。它返回当前的array。

var a = [‘a’,‘b’,‘c’]
var b = a.reverse() //a和b都是[‘c’,‘b’,‘a’]

array.shift()
shift方法一处数组array中的第一个元素并返回该元素。如果这个数组array是空的，它会返回undefined。shift通常比pop慢得多。

var a = [‘a’,‘b’,‘c’]
var c = a.shift() //a是[‘b’,‘c’] c是’a’

array.slice(start,end)
slice方法对array中的一段做浅复制。第一个被复制的元素是array[start]。它将一直复制到array[end]为止。end参数是可选的，并且默认值是该数组的长度array.length。如果两个参数中的任何一个是负数，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’]

array.sort(comparefn)
sort方法对array中的内容进行适当的排序。他不能正确的给一组数字排序。

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

javascript的默认比较函数假定所有要被排序的元素都是字符串，它尚未足够智能到在比较这些元素之前先检测它们的类型，所以要使用自己的比较函数来替换默认的比较函数。你的比较函数应该接受两个参数，并且如果这两个参数相等则返回0，如果第一个参数应该排列在前面，则返回一个负数，如果第二个参数应该排列在前面，则返回一个正数。

var n = [4,21,15,16,23,42]
n.sort(function(a,b){
return a - b
}) //n是[4, 15, 16, 21, 23, 42]

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

var a = [‘a’,‘b’,‘c’]
var r = a.splice(1,1,‘ache’,‘bug’)
//a是 [‘a’,‘ache’,‘bug’,‘c’]
//r是 [‘b’]

array.unshift(item…)
unshift方法像push方法一样用于将元素添加到数组中，但它是把item插入到array的开始部分而不是尾部。它返回array的新的长度值。

var a = [‘a’,‘b’,‘c’]
var r = a.unshift(’?’,’@’)
//a是[’?’,’@’,‘a’,‘b’,‘c’]
//r是 5

2、Function
function.apply(thisArg, argArray)
apply方法调用函数function，传递一个将被绑定到this上的对象和一个可选的参数数组。apply方法被用在apply调用模式中。

注意：call()方法的作用和 apply()
方法类似，区别就是call()方法接受的是参数列表，而apply()方法接受的是一个参数数组。

3、Number
number.toExponential(fractionDigits)
toExponential方法把这个number转换成一个指数形式的字符串。可选参数fractionDigits控制其小数点后的数字位数。它的值必须在0至20之间。

document.writeln(Math.PI.toExponential(0)) //3e+0
document.writeln(Math.PI.toExponential(2)) //3.14e+0

number.toFixed(fractionDigits）
toFixed方法把这个number转换成为一个十进制形式的字符串。可选参数fractionDigits控制其小数点后的数字位数。它的值必须在0到20之间。默认为0.

document.writeln(Math.PI.toFixed(0)) //3
document.writeln(Math.PI.toFixed(2)) //3.14

number.toPrecision(precision)
toPrecision方法把这个number转换成为一个十进制形式的字符串。可选参数precision控制有效数字的位数。它的值必须在0到21之间。

document.writeln(Math.PI.toPrecision(2)) //3.1
document.writeln(Math.PI.toPrecision(7)) //3.141593

number.toString(radix)
toString方法把这个number转换成为一个字符串。可选参数radix控制基数。它的值必须是2和36之间。默认的radix是以10为基数的。radix参数最常用的是整数，但是它可以用任意的数字。
在最普通的情况下，number.toString()可以更简单地写为String(number)。

console.log(Math.PI.toString(2));
//11.001001000011111101101010100010001000010110100011
console.log(Math.PI.toString(8)); //3.1103755242102643

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

if(typeof Object.beget !== ‘function’) {
Object.beget = function(o) {
var F = function() { };
F.prototype = o;
return new F();
} }
var a = {member:true}
var b = Object.beget(a)
var t = a.hasOwnProperty(‘member’) //true
var u = b.hasOwnProperty(‘member’) //false
var v = b.member //true

5、RegExp
regexp.exec(string)
exec方法是使用正则表达式的最强大（和最慢）的方法。如果它成功地匹配regexp和字符串string，它会返回一个数组。数组的下标为0的元素将包含正则表达式regexp匹配的子字符串。下标为1的元素是分组1捕获的文本，下标为2的元素是分组2捕获的文本。以此类推，如果匹配失败，那么它会返回null。
如果regexp带有一个g标志（全局标志），查找不是从这个字符串的起始位置开始，而是从regexp.lastIndex（它初始化为0）位置开始。如果匹配成功，那么regexp.lastIndex将被设置为该匹配后的第一个字符的位置。不成功的匹配会重置regexp.lastIndex为0.
这就允许你通过在一个循环中调用exec去查询一个匹配模式在一个字符串中发生几次。有两件事需要注意，如果你提前退出了这个循环，再次进入这个循环前必须把regexp.lastIndex重置到0。^因子也仅匹配regexp.lastIndex为0的情况。

var str = “I want to go”;
var patt = new RegExp(“want”, “g”);
var result;
while ((result = patt.exec(str)) != null) {
document.write(result); //want
document.write(patt.lastIndex); //6
}

regexp.test(string)
test方法是使用正则表达式的最简单（和最快）的方法。如果该regexp匹配string，它返回true；否则，它返回false。不要对这个方法使用g标识。

var str = “I want to go”;
var patt1 = new RegExp(“want”);
var result = patt1.test(str);
document.write("Result: " + result); //true

6、String
string.charAt(pos)
charAt方法返回在string中pos位置处的字符串。如果pos小于0或大于等于字符串的长度string.length，它会返回空字符串。JavaScript没有字符类型。这个方法返回的结构是一个字符串。

var name = ‘Curly’;
var initial = name.charAt(0) //initial是’C’

string.charCodeAt(pos)
charCodeAt方法同charAt一样，只不过它返回的不是一个字符串，而是以整数形式表示的在string中的pos位置处的字符的字符码位。如果pos小于0或大于等于字符串的长度string.length，它返回NaN。

var name = ‘Curly’;
var initial = name.charCodeAt(0) //initial是 67

string.concat(string…)
concat方法通过将其他的字符串连接在一起来构建一个新的字符串。它很少被使用，因为+运算符更为方便。

var s = ‘C’.concat(‘a’, ‘t’) //s是 ‘Cat’

string.indexOf(searchString，position)
indexOf方法在string内查找另一个字符串searchString。如果它被找到，则返回第一个匹配字符的位置，否则返回-1。可选参数position可设置从string的某个指定的位置开始查找。

var text = ‘Mississippi’
var p = text.indexOf(‘ss’) //p是2
p = text.indexOf(‘ss’ , 3) //p是5
p = text.indexOf(‘ss’ , 6) //p是-1

string.lastIndexOf(searchString , position)
lastIndexOf方法和indexof方法类似，只不过它是从该字符串的末尾开始查找而不是从开头

var text = ‘Mississippi’
var p = text.lastIndexOf(‘ss’) //p是5
p = text.lastIndexOf(‘ss’ , 3) //p是2
p = text.lastIndexOf(‘ss’ , 6) //p是5

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

var m = [‘AAA’ , ‘A’ , ‘aa’ , ‘a’ , ‘Aa’ , ‘aaa’]
m.sort(function (a , b) { return a.localeCompare(b) }
//m（在某些本地环境下）是 [‘a’, ‘A’, ‘aa’, ‘Aa’, ‘aaa’ , ‘AAA’]

string.match(regexp)
match方法匹配一个字符串和一个正则表达式。它依据g标识来决定如何进行匹配。如果没有g标识，那么调用string.math(regexp)的结果与调用regexp.exec(string)的结果相同。然而，如果regexp带有g标识，那么它返回一个包含处捕获分组之外的所有匹配的数组。

var str = “1 plus 2 equal 3”
document.write(str.match(/\d+/g)) //1,2,3

var str = “Hello world!” document.write(str.match(“world”)) //world
document.write(str.match(“World”)) //null
document.write(str.match(“worlld”)) //null
document.write(str.match(“world!”)) //world!

string.replace(searchValue , replaceValue)
replace方法对string进行查找和替换的操作，并返回一个新的字符串。参数searchValue可以是一个字符串或一个正则表达式对象，如果它是一个字符串，那么searchValue只会在第一次出现的地方被替换。如果searchValue是一个正则表达式并且带有g标志，那么它将替换所有匹配之处。如果它没有带g标志，那么它将仅替换第一个匹配之处。
string.search(regexp)
search方法和indexOf方法类似，只是它接受一个正则表达式对象作为参数而不是一个字符串。如果找到匹配，它返回第一个匹配的首字符位置，如果没有找到匹配，则返回-1。此时方法会忽略g标志，且没有position参数。

var text = ‘and in it he says "Any damn fool could’
var pos = text.search(/["’]/) //pos是18

string.slice(start , end)
slice方法复制string的一部分来构造一个新的字符串。如果start参数是负数，它将与string.length相加。end参数是可选的，并且它的默认值是string.length。如果end参数是负数，那么它将与string.length相加。end参数是一个比最末一个字符的位置至还大的数。要想得到从位置p开始的n个字符，就用string.slice(p，p+n)。

var text = ‘and in it he says "Any damn fool could’
var a = text.slice(18) console.log(a); // "Any damn fool could
var b = text.slice(-5) console.log(b); // could

string.split(separator , limit)
split方法把这个string分割成片段来创建一个字符串数组。可选参数limit可以限制被分割的片段数量。separator参数可以是一个字符串或一个正则表达式。
如果separator是一个空字符串，将返回一个单字符的数组。

var digits = ‘0123456789’
var a = digits.split(’’, 5) //a是 [“0”, “1”, “2”, “3”, “4”]

var c = ’ |a|b|c|’.split(’|’)
console.log©; //c是 [" ", “a”, “b”, “c”, “”]

string.substring(start , end)
substring的用法和slice方法一样，只是它不能处理负数参数。没有任何理由去使用substring方法。请用slice替代它。

string.toLocaleLowerCase()

string.toLocaleUpperCase()

string.toLowerCase()
toLowerCase方法返回一个新的字符串，这个string中的所有字母都被转化为小写格式。

string.toUpperCase()
toUpperCase方法返回一个新的字符串，这个string中的所有字母都被转化为大写格式。

String.fromCharCode(char…)
string.fromCharCode函数从一串数字中返回一个字符串。

var cc = String.fromCharCode(67,97,116);
console.log(cc); // cc是’Cat’