JS内置对象String和Array

String 对象

String对象是 JavaScript 原生提供的三个包装对象之一，用来生成字符串对象。

var s1 = 'abc';
var s2 = new String('abc');

typeof s1 // "string"
typeof s2 // "object"

s2.valueOf() // "abc"

字符串对象是一个类似数组的对象（很像数组，但不是数组）

new String('abc')
// String {0: "a", 1: "b", 2: "c", length: 3}

(new String('abc'))[1] // "b"

除了用作构造函数，String对象还可以当作工具方法使用，将任意类型的值转为字符串

String(true) // "true"
String(5) // "5"

1.静态方法
String.fromCharCode()该方法的参数是一个或多个数值，代表 Unicode 码点，返回值是这些码点组成的字符串,参数为空，就返回空字符串

String.fromCharCode(101, 102, 103);//efg
 String.fromCharCode() // ""

2.实例属性
2.1 length ,字符串实例的length属性返回字符串的长度

'abc'.length // 3

2.2 charAt(索引) 获取指定位置处字符，如果索引不在范围内返回空的字符，没有给参数默认索引0,如果参数为负数，或大于等于字符串的长度，charAt返回空字符串。

 var str='hello word';
console.log(str.charAt(1));//e

2.3 charCodeAt(索引) 获取指定位置处字符的ASCII码 如果索引不在范围内返回NAN，没有给参数默认索引0

 var str='hello word';
 console.log(str.charCodeAt(1));//101

2.4 concat() 方法用于连接两个字符串，返回一个新字符串，不改变原字符串，该方法可以接受多个参数，如果参数不是字符串，concat方法会将其先转为字符串，然后再连接

var s1 = 'abc';
var s2 = 'def';
s1.concat(s2) // "abcdef"
s1 // "abc"
'a'.concat('b', 'c') // "abc"

var one = 1;
var two = 2;
var three = '3';
''.concat(one, two, three) // "123"
one + two + three // "33"

2.5 indexOf() 方法用于确定一个字符串在另一个字符串中第一次出现的位置，返回结果是匹配开始的位置。如果返回-1，就表示不匹配。**lastIndexOf()**方法的用法跟indexOf方法一致，主要的区别是lastIndexOf从尾部开始匹配，indexOf则是从头部开始匹配。indexOf方法还可以接受第二个参数，表示从该位置开始向后匹配。lastIndexOf的第二个参数表示从该位置起向前匹配。

var str='hello word';
console.log(str.indexOf('o'));//4
console.log(str.lastIndexOf('o'));//7

2.6 截取字符串
slice(beginIndex[,endIndex]) 提取的新字符串包括beginIndex但不包括 endIndex,不改变原字符串，如果省略第二个参数，则表示子字符串一直到原字符串结束，如果第一个参数大于第二个参数，slice方法返回一个空字符串。
substring(beginIndex[,endIndex]) 方法用于从原字符串取出子字符串并返回，不改变原字符串，跟slice方法很相像。它的第一个参数表示子字符串的开始位置，第二个位置表示结束位置（返回结果不含该位置），如果省略第二个参数，则表示子字符串一直到原字符串的结束。不改变原字符串，如果第一个参数大于第二个参数，substring方法会自动更换两个参数的位置。
substr(beginIndex[,length]) 方法返回一个字符串中从指定位置开始,长度为length字符数的字符，不改变原字符串。如果第一个参数是负数，表示倒数计算的字符位置。如果第二个参数是负数，将被自动转为0，因此会返回空字符串；如果省略第二个参数，则表示子字符串一直到原字符串的结束。

    var str='abcdefg';
    console.log(str.slice(0));//abcdefg
    console.log(str.slice(1, -2));//bcde

    console.log(str.substring(0));//abcdefg
    console.log(str.substring(1, -3));//b 如果参数是负数，substring方法会自动将负数转为0
    console.log(str.substring(1, 3));//bc

    console.log(str.substr(0,3));//abc
    console.log(str.substr(1, 1));//b

注意：于’JavaScript’.substring(4, 0)。由于第二个参数小于第一个参数，会自动互换位置，所以返回Java。由于这些规则违反直觉，因此不建议使用substring方法，应该优先使用slice。

2.7 split() 方法使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置

var str='a-b-c-d-e';
console.log(str.split('-'));// ["a", "b", "c", "d", "e"] length: 5
console.log(str.split(''));//["a", "-", "b", "-", "c", "-", "d", "-", "e"] length: 9
console.log(str.split('', 6));//["a", "-", "b", "-", "c", "-"] length: 6

2.8 toLowerCase()和toLocaleLowerCase() 会将调用该方法的字符串值转为小写形式，并返回。

var str='String.prototype.toLowerCase';
console.log(str.toLocaleLowerCase());//string.prototype.tolowercase

2.9 toUpperCase()和toLocaleUpperCase() 将调用该方法的字符串值转换为大写形式，并返回。

var str='String.prototype.toLowerCase';
console.log(str.toLocaleUpperCase());//STRING.PROTOTYPE.TOLOWERCASE

2.10 trim() 方法用于去除字符串两端的空格，返回一个新字符串，不改变原字符串，该方法去除的不仅是空格，还包括制表符（\t、\v）、换行符（\n）和回车符（\r）

    var str='  a  b  c  d  ';
    console.log('==='+str.trim()+'====');//===a  b  c  d====
    '\r\nabc \t'.trim() ;// 'abc'

2.11 replace() 一个部分或全部匹配由替代模式所取代的新的字符串

var str ='abcd';
console.log(str.replace('a', 'A'));//Abcd

Array 对象

Array是 JavaScript 的原生对象，同时也是一个构造函数，可以用它生成新的数组。
Array构造函数有一个很大的缺陷，就是不同的参数，会导致它的行为不一致。

// 无参数时，返回一个空数组
new Array() // []

// 单个正整数参数，表示返回的新数组的长度
new Array(1) // [ empty ]
new Array(2) // [ empty x 2 ]

// 非正整数的数值作为参数，会报错
new Array(3.2) // RangeError: Invalid array length
new Array(-3) // RangeError: Invalid array length

// 单个非数值（比如字符串、布尔值、对象等）作为参数，
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]

// 多参数时，所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']

可以看到，Array作为构造函数，行为很不一致。因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。

// bad
var arr = new Array(1, 2);

// good
var arr = [1, 2];

1.静态方法
1.1 Array.isArray() 方法返回一个布尔值，表示参数是否为数组。它可以弥补typeof运算符的不足。

var arr = [1, 2, 3];

typeof arr // "object"
Array.isArray(arr) // true

//判断对象是不是数组还有一种方式instanceof
 console.log(arr instanceof Array);//true

2.实例方法
2.1 concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

    var arr=new Array(1,2,3,4);
    var arr2=[5,6,7,8];
    var tempArr=arr.concat(arr2);
    console.log(arr);//(4) [1, 2, 3, 4]
    console.log(arr2);//(4) [5, 6, 7, 8]
    console.log(tempArr);//(8) [1, 2, 3, 4, 5, 6, 7, 8]

2.2 indexOf(searchElement[, fromIndex = 0]) 方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

  var arr=new Array(1,2,3,4);
   console.log(arr.indexOf(3));//2
   console.log(arr.indexOf(3, 3));//-1

2.3 arr.join([separator]) 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。
separator指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。
如果省略()，数组元素用逗号分隔。默认为 “,”。如果separator是空字符串("")，则所有元素之间都没有任何字符。

    var arr=new Array(1,2,3,4);
    console.log(arr.join());//1,2,3,4
    console.log(arr.join(' '));//1 2 3 4
    console.log(arr.join('-'));//1-2-3-4

2.4 pop() 方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度,当数组为空时返回undefined。

    var arr=new Array(1,2,3,4);
    console.log(arr);//(4) [1, 2, 3, 4]
    console.log(arr.pop());//4
    console.log(arr);//(3) [1, 2, 3]

2.5 push(element1, …, elementN) 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

    var arr=new Array(1,2,3);
    console.log(arr.push(30, 40, 50));//6
    console.log(arr);//(6) [1, 2, 3, 30, 40, 50]

2.6 shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

arr= [1, 2, 3, 30, 40, 50];
console.log(arr.shift());//1
console.log(arr);//(5) [2, 3, 30, 40, 50]

2.7 unshift(element1, …, elementN) 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。

    arr= [2, 3, 30, 40, 50];
    console.log(arr.unshift(100, 200));//7
    console.log(arr);//(7) [100, 200, 2, 3, 30, 40, 50]

2.8 slice([begin[, end]]) 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

     arr= [100, 200, 2, 3, 30, 40, 50];
    console.log(arr.slice(1, 3));//(2) [200, 2]
    console.log(arr.slice(1));//(6) [200, 2, 3, 30, 40, 50]
    console.log(arr.slice(-2));//(2) [40, 50]

2.9 splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组, 并以数组形式返回被修改的内容。此方法会改变原数组。
array.splice(start[, deleteCount[, item1[, item2[, …]]]])
array.splice(开始索引[, 删除的个数[, 新增元素1[, 新增元素2[, …]]]])

    arr=['aa','bb','cc','dd','ee'];
    //splice来增加元素
    console.log(arr.splice(1, 0, 'ZZ'));//[]
    console.log(arr);//(6) ["aa", "ZZ", "bb", "cc", "dd", "ee"]
    //splice来删除元素
    console.log(arr.splice(4, 1));//["dd"]
    console.log(arr);//(5) ["aa", "ZZ", "bb", "cc", "ee"]
    //splice来修改元素
    console.log(arr.splice(3, 1, 'FF'));//["cc"]
    console.log(arr);//(5) ["aa", "ZZ", "bb", "FF", "ee"]

2.10 reverse() 方法将数组中元素的位置颠倒,并返回该数组。该方法会改变原数组。

var arr=[1,2,3,4,5];
console.log(arr.reverse());//(5) [5, 4, 3, 2, 1]

2.11 sort() 方法用原地算法对数组的元素进行排序，并返回数组。排序算法现在是稳定的。默认排序顺序是根据字符串Unicode码点。

arr=[1,2,5,3,4];
    arr.sort();
    console.log(arr);//(5) [1, 2, 3, 4, 5]

    arr=[80,1,3,12,100];
    arr.sort();
    console.log(arr);//(5) [1, 100, 12, 3, 80]
    arr.sort(function compare(a, b) {
        if (a < b ) {           // 按某种排序标准进行比较, a 小于 b
            return -1;
        }
        if (a > b ) {
            return 1;
        }
        // a must be equal to b
        return 0;
    });
    console.log(arr);//(5) [1, 3, 12, 80, 100]

2.12 forEach(callback) 方法遍历数组
*callback====>function (value[,index][,array]) {}*

arr=[1,2,3,4,5];
arr.forEach(function (value,index,array) {
        console.log(value,index,array);
 });

2.13 every(callback) 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

function isBigEnough(element, index, array) {
        return element >= 10;
 }
console.log([12, 5, 8, 130, 44].every(isBigEnough));   // false
console.log([12, 54, 18, 130, 44].every(isBigEnough)); // true

var flag=[12, 5, 8, 130, 44].every(function (element, index, array) {
                return element>=10;
          });
console.log(flag);//false

2.14 filter(callback) 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

function isBigEnough(element) {
        return element >= 10;
    }
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
console.log(filtered);//(3) [12, 130, 44]

2.15 some(callback) 方法测试是否至少有一个元素可以通过被提供的函数方法。该方法返回一个Boolean类型的值。

var arr= [12, 5, 8, 1, 4];
var flag= arr.some(function (value, index, array) {
        return value >10;
    });
console.log(flag);// true

注意：以上方法中参数使用[]，括起来的表示，该参数可有可无。