JS的字符串和数组常用函数

一、字符串（String）

1、String对象常用的方法：

方法作用	方法名	返回值
搜索字符
1 返回指定位置的字符	stringObject.charAt(index)	字符串中第一个字符的下标是 0。如果参数 index 不在 0 与 string.length 之间，该方法将返回一个空字符串。3 返回值：找到的字符或者空字符
2 返回某个指定的字符串值在字符串中首次出现的位置。	str.indexOf(searchValue,[fromIndex])	从fromIndex位置开始找，找到返回 searchvalue 的第一次出现的位置(下标数字），找不到返回-1
3 符串内检索指定的值，或找到一个或多个正则表达式的匹配。	stringObject.match(searchvalue或regexp)	存放匹配结果的数组
字符串转数组
字符串分割为字符数组	stringObject.split(separator,【howmany】)	一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身
5 检所指定字符串或者正则表达式	stringObject.search(regexp或str)	stringObject 中第一个与 regexp 相匹配的子串的起始位置(下标数字)。注释：如果没有找到任何匹配的子串，则返回 -1
截取字符
1 字符串的截取slice(切片，截取)	stringObject.slice(start,end)	一个新的字符串。包括字符串 stringObject 从 start 开始（包括 start）到 end 结束（不包括 end）为止的所有字符。
2 截取抽取从 start 下标开始的指定数目的字符	stringObject.substr(start,【length】)	一个新的字符串，包含从 stringObject 的 start（包括 start 所指的字符） 处开始的 length 个字符。如果没有指定 length，那么返回的字符串包含从 start 到 stringObject 的结尾的字符。
3 提取字符串中两个指定的索引号之间的字符	stringObject.substring(start,【stop】)	一个新的字符串，该字符串值包含 stringObject 的一个子字符串，其内容是从 start 处到 stop-1处的所有字符，其长度为 stop 减 start。
字符串连接（拼接）
连接字符串	stringObject.concat(stringX,stringX,…,stringX)	1concat() 方法将把它的所有参数转换成字符串，然后按顺序连接到字符串 stringObject 的尾部，并返回连接后的字符串。请注意，stringObject 本身并没有被更改。 2 stringObject.concat() 与 Array.concat() 很相似。
替换字符串
替换与正则表达式匹配的子串	stringObject.replace(regexp/substr,replacement)	一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。
英文字符串转大小写
转小写	stringObject.toLocaleLowerCase() stringObject.toLowerCase()	小写
转大写	stringObject.toLocaleUpperCase() toUpperCase()	大写

2、字符串循环

for(var i = 0;i<str.length;i++){
     console.log(str[i]);
}

输出结果：打印输出一行一行的结果

二、数组（Array）

2.1、Array对象常用的方法：

方法作用	方法名	返回值
数组合并
	arrayObject.concat(arrayX,【arrayX,…,arrayX】)	新的数组
数组转字符串
	arrayObject.join(separator)	返回一个字符串
	arrayObject.toString()	返回值与没有参数的 join() 方法返回的字符串相同
	arrayObject.toLocaleString()	浏览器以字符串用逗号隔开输出
数组截取
	arrayObject.slice(start,【end】)	注意1：该方法并不会修改数组，而是返回一个子数组。
		2如果想删除数组中的一段元素，应该使用方法 Array.splice()
数组删除/【添加】
	arrayObject.splice(index,howmany,【item1,…,itemX】)	index：删除的位置，howmanny：删除个数，item：向数组填的新项目
数组栈方法
头部增加	arrayObject.unshift(newelement1,【newelement2,…,newelementX】)	返回值：arrayObject 的新长度
头部删除	arrayObject.shift()	1 数组原来的第一个元素的值。2 如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。
尾部增添	arrayObject.push(newelement1,【newelement2,…,newelementX】)	把指定的值添加到数组后的新长度(数字)，会改变原数组的值
尾部删除	arrayObject.pop()	删除并返回数组的最后一个元素
数组排序
	arrayObject.sort(sortby)	1 按照字符编码的顺序进行排序 2 会改变原数组的排序
颠倒数组顺序
	arrayObject.reverse()	返回数组本身，会改变原数组，不会创建新数组
数组过滤
	arrayObject.filter(callback(element[, index[, array]])[, thisArg])	1filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。2 注意： filter() 不会对空数组进行检测。3 注意： filter() 不会改变原始数组。

2.3、数组循环

2.4、forEach循环

2.4.1、形式

arr.forEach(function (item, index){},arr);

2.4.2、作用：

遍历数组

2.4.3、参数说明

（1）可以接收两个参数，第一个参数是一个函数，就是数组的每一项要运行这个函数。这个函数接收三个参数，分别是：数组中的项，下标，数组本身（2）第二个参数是一个数组(可有可无)。如果有，前面函数中的this就指向这个数组；如果没有，前面函数的this就指向window。

let arr = [1, 2, 3, 4, 5, 6, 7];
arr.forEach(function(item, index, arr) {
   console.log(item+"============"+index);
   //console.log(arr, '-----------------')
   console.log(this);
   //(7) [1, 2, 3, 4, 5, 6, 7]
},arr);
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i]+"============"+i);
}

打印结果:

    1============0
    2============1
    3============2
    4============3
    5============4
    6============5
    7============6

2.5、for-of循环

let a = ['A', 'B', 'C'];
for (let attr of a) {
   console.log(attr);//A B C
}

2.6、返回数组函数的引用

var arr = ["夏敏","355354","24123324","11222"];
/*
 * 1 返回对创建此对象的数组函数的引用。
 * constructor 属性返回对创建此对象的数组函数的引用。
 */
if(arr.constructor == Array){
	console.log("数组成员！！！");
}else if(arr.constructor == Function){
	console.log("函数成员！！！");
}else{
    console.log("不知道");
}

2.7、过滤（filter）方法

获取数组中的偶数

var arr = [1,2,3,4,6,1,3,2,2,2];
Array.prototype.getEven = function(){
    //注意arr是一个一个值传进来的
	return this.filter((arr) => arr%2==0);
}
console.log(arr.getEven());//返回：(6) [2, 4, 6, 2, 2, 2]

filter(element,index,self,thisValue)参数说明

        var result = arr.filter(function(element,index,self,thisValue) {
        	var something = "返回结果~！！！";
        	console.log("当前元素的值："+element);
        	console.log("当前元素的索引："+index);
        	console.log("当前元素属于的数组对象："+self);
        	console.log("回调时用的值，传递给函数："+thisValue);
        	add(thisValue);
        	return something;
        });
        function add(obj){
        	console.log("hello world"+obj);
        }
		console.log(result)//(10) [1, 2, 3, 4, 6, 1, 3, 2, 2, 2]

2.8、数组去重

题目：给一个数组，找出不重复的数，并且返回它们。
思路：1 新建空数组 2 遍历原数组，在新数组中没有出现就添加到新数组中

1. 方法一：

var arr = [1,2,3,4,6,1,3,2,2,2];
function removeRepeat(obj){
	var newArr = [];
	for (var i = 0; i < obj.length; i++) {
		if (newArr.indexOf(obj[i])== -1) {
			newArr.push(obj[i]);
		}else{
			console.log('元素重复！！！');
		}
	}
	return newArr;
}
console.log(removeRepeat(arr));//返回：(5)[1,2,3,4,6]

2. 方法二：

通过过滤函数arr.filter(element,index,arr,thisValue)去重

var result = arr.filter(function (element,index,self){
	return self.indexOf(element) == index;
});
console.log(result);//(5) [1, 2, 3, 4, 6]

3. 方法三

双层for循环遍历，标记是否有相等元素，找到相同的元素，标记false，加入新的数组，跳出本次循环。遍历完成之后返回新数组。

function unique(arr){
	let newArr = [];
	let isRepeat ;
	for (var i = 0; i < arr.length; i++) {
		isRepeat = false;
		for (var j = i+1; j < arr.length; j++) {
			if(arr[j] == arr[i]){
				isRepeat = true;
				break;
			}
		}
		if (isRepeat == false) {
			newArr.push(arr[i]);
		}
	}
    return newArr;
}
console.log(unique(arr));//(5)[4, 6, 1, 3, 2]