JS数组常用方法

 

1、将给定字符串转换成二进制字符串，如果字符串长度不足8位，则在前面补零到8位。

 

function test(num){
	var str=num.toString(2);
	if (str.length<8) {
		var arr=str.split("");
		var len=8-str.length;
		for (var i = 0; i < len; i++) {
			arr.unshift(0);
		}
		str=arr.join("");
	}
	return str;
}
alert(test(65));

 

说明：
toString(2)将十进制数字转换成二进制字符串
split("")将字符串分割为数组
unshift(0)在数组的开始插入0
join("")将数组转换成字符串

2、求a和b相乘的值，a和b可能是小数，需要注意结果的精度问题

 

var a=3,b=0.0001;
function multiply(a,b){
	var len1=0,len2=0;
	if (a%1===0&&b%1===0) { //a%1==0判定a为整数
		return a*b;
	}else{
		if (a%1!==0) {
			var arr1=getArr(a);
			len1=arr1[1].length; //获得a的小数长度
		}
		if (b%1!==0) {
			var arr2=getArr(b);
			len2=arr2[1].length; //获得b的小数长度
		}
		var len=len1+len2; //获得乘积的最大可能小数长度
		var num=a*b;
		var arr3=getArr(num);
		arr3[1]=arr3[1].substring(0,len); //获得乘积的小数长度
		var str=arr3.join("."); //乘积数组转字符串
		return parseFloat(str); //字符串转浮点数
	}
	function getArr(num){ //将浮点数一小数点分割为数组
		var str=num.toString();
		var arr=str.split(".");
		return arr;
	}
}
alert(multiply(a,b));

 

3、给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false 

 

function containsNumber(str) {
	var arr=str.split("");
	for (var i = 0; i < arr.length; i++) {
		if (isNaN(arr[i])) {
			continue;
		}else {
			return true;
		}
	}
	return false;
}
console.log(containsNumber('abc123'));  

 

说明：isNaN()判断是否不是数字，true表示不是数字
4、找出元素 item 在给定数组 arr 中的位置 ，如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1
答案：

 

function indexOf(arr, item) {
	return arr.indexOf(item)?arr.indexOf(item):-1;
}
console.log(indexOf([ 1, 2, 3, 4 ], 3));   //2

说明：indexOf()返回元素在数组中的位置，参数1：要查元素；参数2：起点索引
5、移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组

function remove(arr, item) {
	var newArr=[];
	for (var i = 0; i < arr.length; i++) {
		if (arr[i]!=item) {
			newArr.push(arr[i]);
		}
	}
	return newArr;
}
console.log(remove([1, 2, 3, 4, 2], 2)); //[1, 3, 4]

 

说明：循环查找不等于item的元素，将其添加到新数组中
push方法：在数组末尾添加元素
6、移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr数组上进行操作，并将结果返回
答案：

 

function removeWithoutCopy(arr, item) {
	for (var i = 0; i < arr.length; i++) {
		if (arr[i]==item) {
			arr.splice(i, 1);
			i--;
		}
	}
	return arr;
}
console.log(removeWithoutCopy([1, 2, 2, 3, 4, 2, 2], 2)); //[1, 3, 4]

 

说明：splice方法：移除、添加、替换数组中的某几项；参数1：起点索引；参数2：操作count项；参数3：可选，要添加的新元素
7、在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组 
答案：

 

function append(arr, item) {
	var newArr=[];
	newArr=arr.slice(0);
	newArr.push(item);
	return newArr;
}
console.log(append([1, 2, 3, 4],  10)); //[1, 2, 3, 4, 10]

 

说明：slice方法复制数组的某几项；参数1：起点索引；参数2：项数count，可选
8、删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组 
答案：

 

function truncate(arr) {
	var newArr=[];
	newArr=arr.slice(0);
	var len=newArr.length;
	newArr.pop(len-1);
	return newArr;
}
console.log(truncate([1, 2, 3, 4])); //[1, 2, 3]

 

说明：pop方法在数组末尾删除元素。参数：索引
9、在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组 
答案：

 

function prepend(arr, item){
	var newArr=[];
	newArr=arr.slice(0);
	newArr.unshift(item);
	return newArr;
}
console.log(prepend([1, 2, 3, 4], 10)); //[10, 1, 2, 3, 4]

 

说明：unshift(item)在数组开头添加元素
10、删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组 
答案：

 

function curtail(arr) {
	var newArr=[];
	newArr=arr.slice(0);
	newArr.shift(newArr[0]);
	return newArr;
}
console.log(curtail([1, 2, 3, 4])); //[2, 3, 4]

 

说明：shift方法删除数组第一项。参数：索引
11、合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组 
答案：

 

function concat(arr1, arr2) {
	var newArr=arr1.slice(0); 
    newArr=newArr.concat(arr2);
    return newArr;
}
console.log(concat([1, 2, 3, 4], ['a', 'b', 'c', 1])); //[1, 2, 3, 4, 'a', 'b', 'c', 1]

 

说明：concat方法连接多个数组
12、在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组 
答案：

 

function insert(arr, item, index) {
	 var newArr=arr.slice(0);
	 newArr.splice(index, 0, item);
	 return newArr;
}
console.log(insert([1, 2, 3, 4], 'z', 2)); //[1, 2, 'z', 3, 4]

 

13、统计数组 arr 中值等于 item 的元素出现的次数 
答案：

 

function count(arr, item){
	var count=0;
	 for (var i = 0; i < arr.length; i++) {
	 	if (arr[i]==item) {
	 		count++;
	 	}
	 }
	 return count;
}
console.log(count([1, 2, 4, 4, 3, 4, 3], 4)); // 3

 

14、找出数组 arr 中重复出现过的元素 
答案：

 

function duplicates(arr) {
	var obj={};
	var newArr=[];
	for (var i = 0; i < arr.length; i++) {
		if (!obj[arr[i]]) {
			obj[arr[i]]=[arr[i]];
		}else{
			obj[arr[i]].push(arr[i]);
		}
	}
	for (var attr in obj) {
		if (obj[attr].length>1) {
			newArr.push(obj[attr][0]);
		}
	}
	return newArr;
}
console.log(duplicates([1, 2, 4, 4, 3, 3, 1, 5, 3]).sort()); // [1, 3, 4]

 

思路：定义一个对象，将数组的元素值定义为对象的属性，并将重复的数组值添加到每个对象属对应的数组中。
1、可以得到重复的元素有哪些
2.可以得到重复的元素个数
14、为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组
答案：

 

function square(arr) {
	var newArr=arr.slice(0);
	for (var i = 0; i < newArr.length; i++) {
		newArr[i]=newArr[i]*newArr[i];
	}
	return newArr;
}
console.log(square([1, 2, 3, 4])); // [1, 4, 9, 16]

 

15、在数组 arr 中，查找值与 item 相等的元素出现的所有位置
答案：

 

function findAllOccurrences(arr, item) {
	var newArr=[];
	for (var i = 0; i < arr.length; i++) {
		if (arr[i]==item) {
			newArr.push(i);
		}
	}
	return newArr;
}
console.log(findAllOccurrences('abcdefabc'.split(''), 'a').sort()); // [0, 6]

备注：indexOf方法找到一个元素会就返回


※数组常用方法及其相关总结：
①栈方法：
push（）：末尾添加元素，返回修改后的数组长度；
pop（）：移除数组的最后一项，返回移除的项；
②：队列方法：
shift（）：移除数组第一项，返回移除的项；
unshift（）：添加元素到开头，返回新数组长度；
③重排序方法：
reverse（）：反转数组项顺序；
sort（）：默认升序，比较的是toString（）后的字符串；
④操作方法：
slice（）：截取数组的某几项；参数1：起点索引；参数2：项数count，可选；常用来复制数组
splice（）：移除、添加、替换数组中的某几项；参数1：起点索引；参数2：操作count项；参数3：可选，要添加的新元素；返回新数组，包含原数组中删除的项
concat（）:连接多个数组，创建了副本，返回新数组
join（）：使用分隔符将数组项连接为字符串
⑤位置方法：
indexOf（）：从前向后查找。参数1：要查找的项；参数2：可选，起点索引；返回在数组中的位置，没找到返回-1
lastIndexOf（）：从后向前查找。参数1：要查找的项；参数2：可选，起点索引；返回在数组中的位置，没找到返回-1
⑥归并方法：
reduce（）：从前向后迭代数组的所有项。参数1：回调函数；参数2：初始值。回调函数接收4个参数：前一个值、当前值、当前值的索引、数组对象。函数返回的任何值都作为第一个参数自动传给下一项。
reduceRight（）：从后向前迭代数组的所有项。参数1：回调函数；参数2：初始值。回调函数接收4个参数：前一个值、当前值、当前值的索引、数组对象。函数返回的任何值都作为第一个参数自动传给下一项。
⑦迭代方法：以下这五个方法都接受两个参数。参数1：回调函数；参数2：运行该函数的作用域。对数组的每一项都运行回调函数，且都不会修改原数组。
every（）：每一项返回true，则返回true；
filter（）：返回true的项构成数组并返回；
forEach（）：无返回值。
map（）：返回每次调用结果组成的数组。
some（）：只要有一项返回true，则返回true
回调函数接收三个参数：数组项的值item、在数组中的位置index、数组对象本身array
※split（）是字符串常用的方法。用来分割字符串，返回字符串形成的数组。