《JavaScript语言精粹》学习笔记——8.方法

JavaScript 提供数组、函数、数字、对象、字符串标准类型的标准方法集。

1、数组（Array）

array.concat(item...)

concat 方法产生一个新数组，包含 array 的浅复制和附加在后面的一个或多个item参数，并不改变原数组的值。如果一个 item 参数是数组，它的每个元素会被分别添加。

<pre name="code" class="javascript">var a = ['a', 'b', 'c'];

var b = ['x', 'y', 'z'];var c = a.concat(b, true);// c =['a', 'b', 'c', 'x', 'y', 'z', true];

array.join(separator)

join 方法把 array 构造成一个字符串。先把 array 中的每个元素变为一个字符串，再用 separator 分隔符把他们连接起来。默认的分隔符是逗号 ',' 。

var a = ['a', 'b', 'c'];
var c = a.join(' ');  // c 是 'abc'

array.pop()

pop方法移除array中的最后一个元素并返回该元素。如果array是empty，会返回 undefined 。

var a = ['a', 'b', 'c'];
var c = a.pop();  //  a 是 ['a', 'b']  c 是 'c'  // 改变了数组，返回了移除的值

array.push(item...)

push方法把一个或多个item参数添加到array数组的尾部，改变了这个数组的内容，并返回数组的新长度值。每个参数item都作为单个元素添加到数组中。

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 中的第一个元素并返回该元素。 如果数组是空的，会返回 undefined。

var a = ['a', 'b', 'c'];
var c = a.shift();  // a 是 ['b', 'c']  &  c 是 'a'

array.slice(start, end)

slice 方法对 array 中的一段做浅复制，从 array[start] 开始复制，一直到 array[end]。start 默认值是 0 ，end 默认值是数组长度。如果 start 或 end 为负数，则 array.length 会和参数相加，如若还为负数则取值 0 。如果 start 大于 array.length 或 start 等于 end ，则返回空数组。

var a = ['a', 'b', 'c'];
var b = a.slice(0, 1);  // b 是 ['a']<pre name="code" class="javascript">var c = a.slice(1);     // c 是 ['b', 'c']
var d = a.slice(1, 2);  // d 是 ['b']

array.sort(comparefn)

sort 方法对 array 中的内容进行排序，JavaScript 的默认比较函数把要排序的对象都视为字符串。不能对一组数字正确排序。

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

可以用自己的比较函数替换默认比较函数。默认比较函数接受 2 个参数，两个参数相等时返回 0 ，如果第一个参数应排在前面时，返回一个负数 ，如果第二个参数应排在前面，返回一个正数。

对数字正确排序：

n.sort( function (a, b) {
     return a - b;
});
<pre name="code" class="javascript">// n 是[4, 8, 15, 16, 23, 42]

对包含任意简单值的数组排序：

var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 42];
m.sort ( function (a, b){
       if (a ===b) {
              return 0;
       }
       if ( type of a === type of b) {
              return a < b ? -1 : 1;
       }
       return typeof a < typeof b ? -1 : 1;
})
//  m 是 [ 4, 8, 15, 16, 23, 42, 'a', 'aa', 'bb'];

使对象数组按照对象中的某个属性排序，构造比较函数的函数：

var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 42];<pre name="code" class="javascript">var by = function (name) {
      return function (o, p) {

var a, b;
if (typeof o === 'object' && typeof p === 'object' && o && p){

              a = o[name];
              b = p[name];

if (a === b) { return 0; } if ( typeof a === typeof b) { return a < b ? -1 : 1; } } else {

              throw {
                  name : 'Error',
                  message : 'Expected an object when sorting by ' + name
              };
          }
     };

};

//  使用方法  s.sort(by('first')).sort(by('last'));

sort方法是不稳定的，即两个值相等还是有可能改变数组的顺序，因此如果对多个键值排序采用以下的方法：

var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 42];
var by = function (name, minor) {
      return function (o, p) {
          var a, b;
          if (typeof o === 'object' && typeof p === 'object' && o && p){
              a = o[name];
              b = p[name];
              if (a === b) {
                  return typeof minor === 'function' ? minor(o, p) : 0;
              }
              if ( typeof a === typeof b) {
                  return a < b ? -1 : 1;
              }
          } else {
              throw {
                  name : 'Error',
                  message : 'Expected an object when sorting by ' + name
              };
          }
     };
};
//  使用方法  s.sort(by('first',by('last')));

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

splice 方法从 array 的 start 位置开始移除 deleteCount (1个或多个) 个元素，并用新的 item 替换它们。返回一个包含移除元素的数组。

var a = ['a', 'b', 'c'];
var r = a.splice(1, 1, 'ache', 'bug');
<pre name="code" class="javascript">//  a 是 ['a', 'ache', 'bug', 'c'];

// r 是 ['b'];

array.unshift(item...)

unshift 方法类似于 push 方法，将元素添加到数组中，返回数组的新长度，不同的是将元素插在数组的最前面。

var a = ['a', 'b', 'c'];
var r = a.unshift('ache', 'bug');
<pre name="code" class="javascript">//  a 是 ['ache', 'bug', 'a', 'b', 'c'];

// r 是 5;

数组的方法总结，

三个添加元素方法，push（加到数组最后面）、unshift（加到数组最前面）、concat（数组和参数组合成新数组返回）

三个删除元素方法，pop（删除最后一个）、shift（删除第一个）、splice（删除指定的几个连续元素，并用新的替换）

复制方法，slice（复制其中的连续几个元素）

反转方法，reverse

排序方法，sort（可以更改默认的排序函数）

拼接为字符串方法，join（使用separator参数将元素连接起来）

2、函数

function.apply(thisArg, argArray)

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

3、数字

number.toExponential( fractionDigits )
toExponential 方法把 number 转换成一个指数形式的字符串。fractionDigits 参数是可选的，控制小数点后的数字位数，范围在 0 ~ 20。无参数不改变小数位。

document.writeln(Math.PI.toExponential(0));
document.writeln(Math.PI.toExponential(2));
document.writeln(Math.PI.toExponential());

// 结果

3e+0
3.14e+0
3.141592653589793e+0

number.toFixed( fractionDigits )

toFixed 方法把 number 转换成一个十进制形式的字符串。fractionDigits 参数是可选的，控制小数点后的数字位数，范围在 0 ~ 20，默认是 0。

document.writeln(Math.PI.<span style="font-size:18px;">toFixed</span>(0));
document.writeln(Math.PI.<span style="font-size:18px;">toFixed</span>(2));
document.writeln(Math.PI.<span style="font-size:18px;">toFixed</span>());

// 结果

3
3.14
3

number.toPrecision( precision)

toPrecision 方法把 number 转换成一个十进制形式的字符串。precision 参数是可选的，控制数字精度，范围在 1 ~ 21。无参数不改变数字精度。

<pre name="code" class="javascript">document.writeln(Math.PI.<span style="font-size:18px;">toPrecision</span>(2));
document.writeln(Math.PI.<span style="font-size:18px;">toPrecision</span>(7));
document.writeln(Math.PI.<span style="font-size:18px;">toPrecision</span>());

// 结果

3.1
3.141593<pre name="code" class="javascript">3.141592653589793

number.toString( radix )

toString 方法把 number 转换成一个字符串。radix 参数是可选的，控制基数，范围在 2 ~ 36，通常为整数，可以为任意数字。默认值是10。

document.writeln(Math.PI.toString(8));
document.writeln(Math.PI.toString(16));
document.writeln(Math.PI.toString());

// 结果

3.1103755242102643
3.243f6a8885a3
3.141592653589793

4、对象

object.hasOwnProperty(name)

如果对象是否包含一个名为 name 的属性，返回ture。不检查原型链中是否包同名属性。如果属性名就是 ‘hasOwnProperty’，则不起作用，会返回false。
5、字符串

string.charAt(pos)

charAt 方法返回在 string 中 pos 位置处的字符。如果 pos 不合法（小于0 或者大于等于字符串的长度），会返回一个空字符串。

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

string.charCodeAt(pos)

charAt 方法返回在 string 中 pos 位置处的字符的字符码位。如果 pos 不合法（小于0 或者大于等于字符串的长度），会返回NaN。

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

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 方法类似，只不过是从字符串的末尾开始查找。可选参数 position 可设置从 string 的指定位置开始向前查找 。

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，则结果为 -1，如果相等，结果为 0。类似于数组 sort 方法的默认比较函数。

string.match(regexp)

match 方法让字符串和一个正则表达式进行匹配。如果 regexp 包含 g 标识，生成一个包含所有匹配（除捕获分组之外）的数组。

string.replace(searchValue, replaceValue)

replace 方法在string 中查找 searchValue 字符串，替换为 replaceValue 字符串，并返回一个新的字符串。如果 searchValue 是一个字符串，仅在第一次出现的时候被替换；如果 searchValue 是一个正则表达式，并带有g标识，则会替换所有的匹配。

string.search(regexp)

search 方法和 indexOf 方法类似，只是参数是正则表达式，如果找到匹配，返回第一个匹配的首字符位置，没有找到匹配，则返回 -1 。忽略参数的 g 标识，且没有 position 参数。

string.slice(start, end)

slice 方法复制 string 的一部分字符构造一个新的字符串。用法与 Array.slice 方法相一致。

var text = 'and in it he says "Any damn fool could';
var a = text.slice(18);
<pre name="code" class="javascript">// a 是 '"Any damn fool could'

var b = text.slice(0, 3);// b 是 'and'var c = text.slice(-5);// c 是 'could'

string.split(separator, limit)

split 方法根据 separator 将 string 分割成片段来创建一个字符串数组。可选参数 limit 是限制分割的数量。separator 可以是一个正则表达式或字符串。

如果 separator 是一个空字符，返回一个单字符的数组：

var digits = '0123456789';
var a = digits.split(' ', 5);
// a 是 ['0', '1', '2', '3', '4']

分隔符两边的每个单元文本都会被复制到数组中：

var c = '|a|b|c|'.split('|');
// c 是 [' ', 'a', 'b', 'c', ' '];

此方法会忽略 g 标识。

string.toLocaleLowerCase()

toLocaleLowerCase 方法返回一个新字符串，使用本地化规则将string中的所有字母转换为小写格式。主要用在土耳其语上。

string.toLocaleUpperCase()

toLocaleUpperCase 方法返回一个新字符串，使用本地化规则将string中的所有字母转换为大写格式。主要用在土耳其语上。

string.toLowerCase()

toLowerCase 方法返回一个新字符串，将string中的所有字母转换为小写格式。

string.toUpperCase()

toUpperCase 方法返回一个新字符串，将string中的所有字母转换为大写格式。

String.fromCharCode(char...)

String.fromCharCode 根据一串数字编码返回一个字符串。

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

字符串方法总结：

根据位置获取一个字符或编码：charAt（获取字符）、charCodeAt（获取字符编码）

字符编码转字符：String.fromCharCode（根据字符编码转字符串）

查找字符：indexOf（从前往后找）、lastIndexOf（从后往前找）、match（找正则表达式）、search（找正则表达式）、replace（查找后替换为新字符串）

复制：slice（从 start 复制到 end 的字符串）

转为数组：split（将字符串根据分隔符创建数组）

字母大小写转换：toLocaleLowerCase（本地规则转小写）、toLocaleUpperCase（本地规则转大写）、toLowerCase（转小写）、toUpperCase（转大写）

字符串方法中，忽略了 concat 方法和 substring 方法，concat 方法用 '+' 运算符替代，substring 方法用 slice 完全可以实现其功能。