数组与字符串

• Array
  数组的声明方式:
  1.字面量：var arr = [1,2,3,4];
  2.通过new声明:var arr = new Array(1,2,3,4);
  3.只声明初始长度的数组：var arr = new Array(3);
  数组的常用方法：
  分为两类：一类是改变原数组的，另一类是不改变原数组的
  1、改变原数组：

• push、pop、shift、unshift、reverse、sort、splice

• push在原数组最后一位添加新的元素，返回添加后的长度。

var arr = [1,2,3,4];
var n = arr.push(5);
console.log(n);//返回5
console.log(arr);//返回[1,2,3,4,5]

• pop把数组的最后一位剪切出来，返回剪切出的元素

var arr = [1,2,3,4];
var num = arr.pop();
console.log(num);//返回4
console.log(arr);//返回[1,2,3]

• unshift从数组的首位开始添加数据,返回添加后的长度

var arr = [1,2,3,4];
var arr2 = arr.unshift(0);
console.log(arr2);//返回5
console.log(arr);//返回[0,1,2,3,4]

• shift从数组头部开始剪切数据，返回剪切到的元素

var arr = [1,2,3,4];
var num = arr.shift();
console.log(num);//返回1
console.log(arr);//返回[2,3,4]

• reverse，将原数组逆序，返回逆序后的数组

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

• splice(start,length,data);第二、三个参数可选，该方法意为从数组的第start位开始剪切，剪切length个；如果有第三个参数，就将data放在切口处，返回值为剪切到的数据；如果只有start，就从start位剪切到结尾；如果start是负数，就倒着剪切，也就是从（start+length）位开始剪切。返回值都是剪切到的数据

var arr = [1,2,3,4,5];
var arr1 = arr.splice(1,3);
console.log(arr1);//返回[2,3,4]
console.log(arr);//返回[1,5]
/*******************/
var arr2 = [1,2,3,4,5];
var arr3 = arr2.splice(1,3,6);
console.log(arr3);//返回[2,3,4]
console.log(arr2);//返回[1,6,5]

• sort对数组进行排序，默认是升序,；
  sort排序的原理是冒泡排序，其参数可以是一个函数,如果内部不写参数默认按照ASCII码进行排序，如下：

var arr = ['14','1','2','4','12']
arr.sort()
//返回 ["1", "12", "14", "2", "4"]

，ASCII码排序，是逐位进行比较的，只说两个例子如12和14，第一位的1相同，第二位的4大于2，所以14大于12；对于14和2，第一位的1小于2，所以不用再比，14小于2。
上例算是sort排序的bug。如何解决呢，sort排序给出了一个参数，这个参数是一个函数，例子如下

 var arr = [1,7,4,5,9,2];
 arr.sort(function(a,b){
     return a-b;//升序
     //return b-a;//降序
 })

var arr = ['14','1','2','4','12']
arr.sort((a,b)=>{
return a-b;
})
//返回 ["1", "2", "4", "12", "14"]

什么意思呢？sort是根据内部函数的返回值进行排序，内部函数返回值大于零就是升序，小于零就是逆序。每次从数组中去两个元素，当作内部函数的实参，传进去，如果a>b那么返回值就是大于零的，也就是升序，反之异然（字符串的比较会被隐式转换为数字类型）。
好了，以上几种均会改变原数组，不再多说。

2、不改变原数组的方法

• concat、join、slice、
• concat连接两个数组，返回一个连接后的新数组

var arr = [1,2,3];
arr.concat(0);
console.log(arr);//这里是个坑哦

记住只有congcat操作后的返回值是新数组，原数组并未改变。用个变量接收var arr2 = arr.concat(0);这里才会得到新数组，即:[1,2,3,0];
- join是将数组按照传入的参数连接成一个字符串，如果没有参数，就按照逗号连接。
如下：

var arr = [1,2,3,4];
var arr2 = arr.join('-');
var arr3 = arr.join();
console.log(arr2);//返回字符串'1-2-3-4'
console.log(arr3);//返回字符串'1,2,3,4'
console.log(arr);//返回原数组[1,2,3,4]

• slice(start,stop);从第start位开始,截取到第stop位，返回截取到的结果数组

var arr = [1,2,3,4];
var num = arr.slice(1,2);
var num2 = arr.slice(1,3);
console.log(num);//[2]
console.log(num2);//[2,3]
console.log(arr);//[1,2,3,4]

---

• String
  声明方式：
  1.字面量：var str = ‘1234’;
  常用方法：

• charAt(i);查找索引位为i的字符,返回查找到的结果

• indexOf(s1,num);//查找字符串中是否含有s1字符，num可选参数，意为从第num位查找。返回查找到得的位置结果。如果没有返回-1

var str = 'abcd';
var n = str.indexOf('b');
console.log(n);//返回数字1
var n2 = str.indexOf('b',2);
console.log(n2);

• lastindexOf(s1);查询最后一次出现s1字符的位置。返回位置结果.如果没有返回-1

var str = 'abcd';
var n = str.lastIndexOf('b');
console.log(n);//返回数子1

• slice(start,end);截取字符串，从start位开始截取，截取到end位。若end为空，从start截取到尾，负数表示从倒数第几位截取。返回截取到的结果，如果没截取到返回空。

var str = 'abcde';
var str1 = str.slice(1,2);
var str2 = str.slice(1,3);
console.log(str1);//返回b
console.log(str2);//返回bc

• substring(start,end);与slice方法效果相同，区别在于substring不接收负数，若参数为负，自动转0.

• split(sp,len);从指定的sp为边界分割字符串，返回最大长度为len的数组，若无len，返回分割后的数组。

var str = 'a-b-c-d';
var arr = str.split('-');
var arr2 = str.split('-',3);
console.log(arr);//返回[a,b,c,d]
console.log(arr2);//返回[a,b,c]

再提另外三个模式匹配：
replace(reg,str);reg为正则表达式，用str替换掉符合reg正则条件的字符串。返回值是一个新的字符串，是用 str 替换了 reg 的第一次匹配或所有匹配之后得到的
//例子

var str="Hello World!"
document.write(str.replace(/World/, "NodeJS"));

match(reg);reg为正则表达式，查找符合此正则的字符串，返回查找到的结果数组。查找一个或多个符合条件的结果，依赖全局匹配符/g

var str="Hello World!"
console.log(str.match(/o/));//返回['o']
console.log(str.match(/o/g));//返回['o','o']

search(reg);返回第一次找到符合正则的字符串的位置，没有匹配到返回-1。会忽略全局匹配标志g。
//例子

var str="Hello World!"
console.log(str.search(/e/));//返回1
console.log(str.search(/o/));//返回4
console.log(str.search(/World/));//返回6

先说么多…….