1.把字符串分割成数组--split（不会改变原有的字符串）
stringObject.split(separator, len) //separator：必需，字符串或正则表达式 len：可选，该参数可指定返回的数组的最大长度2.判断是否为数组
var arr = ["Banana", "Orange", "Apple", "Mango"];
//系统默认是 arr.prototype.constructor = Array
console.log(arr.constructor === Array) //打印结果为true则是数组
console.log(arr instanceof Array) //打印结果为true则是数组
console.log(Object.prototype.toString.call(arr) === ‘[object Array]’) //打印结果为true则是数组
console.log(Array.isArray(arr)) //打印结果为true则是数组3.查找元素（indexOf）
//indexOf() 方法可返回数组中某个指定的元素位置，开始位置的索引为 0 ，如果在数组中没找到指定元素则返回 -1。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple"); //output 2 返回索引值4.将数组转换成字符串（join、toString）
arrayObject.join(separator) //separator：可选，指定字符串所使用的分隔符，默认是逗号
var names = ["David", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"];
var namestr = names.join();
print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer
namestr = names.toString();
print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer
//事实上，当直接对一个数组使用 print() 函数时，系统会自动调用那个数组的 toString() 方法
//print(names); // David,Cynthia,Raymond,Clayton,Mike,Jennifer5.合并数组（concat）
var hege = ["Cecilie", "Lone"];
var stale = ["Emil", "Tobias", "Linus"];
var kai = ["Robin"];
var children = hege.concat(stale,kai);//Cecilie,Lone,Emil,Tobias,Linus,Robin6.分割数组（slice）
//slice() 方法返回一个新的数组，包含从 start 到 end （不包括该元素）的元素，该方法不会改变原始数组。
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3); //Orange,Lemon7.删除添加元素（splice）
array.splice(index,howMany,item1,.....,itemX)
//index 必需。规定从何处添加/删除元素
//howMany 必需。规定应该删除多少元素
//item1, ..., itemX 可选。要添加到数组的新元素
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi"); //Banana,Orange,Lemon,Kiwi,Apple,Mangovar
fruits1 = ["Banana", "Orange", "Apple"];
fruits1.splice(2,1); //删除一个，返回删除元素的数组 ["Apple"]
//splice() 方法返回的是只包含被删除的元素的新数组，而且会改变原始数组8.删除添加一个元素（pop,push,shift,unshift）
//pop() 方法用于删除数组的最后一个元素并返回被删除的元素。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop(); //fruits: Banana,Orange,Apple
//push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi") //fruits: Banana,Orange,Apple,Mango,Kiwi
//shift() 方法用于把数组的第一个元素从其中删除，并返回被删除的第一个元素的值。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift() //fruits: Orange,Apple,Mango
//unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Pineapple");//fruits:Lemon,Pineapple,Banana,Orange,Apple,Mango9.数组排序（reverse、sort）
//reverse() 方法用于颠倒数组中元素的顺序，返回值是颠倒顺序后的数组
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse(); //Mango,Apple,Orange,Banana
//sort()方法用于排序：如果元素是字符串类型，那么数组的排序方法 sort() 就非常好使；但是如果数组元素是数字类型，sort() 方法的排序结果就不能让人满意了：
var names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];
names.sort();
print(names); // Bryan,Clayton,Cynthia,David,Mike,Raymond
//sort() 方法是按照字典顺序对元素进行排序的，因此它假定元素都是字符串类型，即使元素是数字类型，也被认为是字符串类型。
var nums = [3,1,2,100,4,200];
nums.sort();
print(nums); // 1,100,2,200,3,4
//为了让 sort() 方法也能排序数字类型的元素，可以在调用方法时传入一个大小比较函数，排序时，sort() 方法将会根据该函数比较数组中两个元素的大小，从而决定整个数组的顺序。
function compare(num1, num2) {
return num1 - num2;
}
var nums = [3,1,2,100,4,200];
nums.sort(compare);
print(nums); // 1,2,3,4,100,200
//此时sort() 函数使用了 compare() 函数对数组按照数字大小进行排序，而不是按照字典顺序10.数组迭代器方法（forEach、every、some、reduce、reduceRight）
forEach()方法接受一个函数作为参数，对数组中的每个元素使用该函数。
function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
//output: 1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81 10 100every()方法接受一个返回值为布尔类型的函数，对数组中的每个元素使用该函数。
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测；
如果所有元素都满足条件，则返回 true。
function isEven(num) {
return num % 2 == 0;
}
var nums = [2,4,6,8,10];
var even = nums.every(isEven);//truesome() 方法也接受一个返回值为布尔类型的函数，只要有一个元素使得该函数返回 true， 该方法就返回 true。
function isEven(num) {
return num % 2 == 0;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var someEven = nums.some(isEven); //truereduce() 方法接受一个函数，返回一个值。该方法会从一个累加值开始，不断对累加值和数组中的后续元素调用该函数，直到数组中的最后一个元素，最后返回得到的累加值。
function add(runningTotal, currentValue) {
return runningTotal + currentValue;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var sum = nums.reduce(add);
print(sum); // 显示 55reduceRight() 方法，和 reduce() 方法不同，它是从右到左执行
function concat(accumulatedString, item) {
return accumulatedString + item;
}
var words = ["the ", "quick ","brown ", "fox "];
var sentence = words.reduceRight(concat);
print(sentence); // 显示 "fox brown quick the"11.生成新数组的迭代器方法（map、filter）
map() 对数组中的每个元素使用某个函数，返回一个新的数组，该数组的元素是对原有元素应用这个函数得到的结果。map 方法不改变原数组。
array.map(function(currentValue,index,arr){}, thisValue)
function curve(grade) {
return grade += 5;
}
var grades = [77, 65, 81, 92, 83];
var newgrades = grades.map(curve);
print(newgrades); // 82, 70, 86, 97, 88filter() 方法检测数组元素，并返回一个符合条件的所有元素的新数组。该方法的参数即回调函数的返回值是布尔值。
function isEven(num) {
return num % 2 == 0;
}
var nums = [];
for (var i = 0; i < 20; ++i) {
nums[i] = i+1;
}
var evens = nums.filter(isEven);
print(evens); //2,4,6,8,10,12,14,16,18,2012.数组中的其他方法
arr.find()查找某个符合条件的元素
arr.find() 方法用于从数组中找到符合条件的第一个数组元素值，若找到则返回满足条件的第一个元素，否则返回 undefined。
该方法有两个参数，第一个参数是一个回调函数，第二个参数指定回调函数的 this 指针，第二个参数是可选的。
let arr = [{name: 'aaa',age: 12},{name: 'bbb',age: 22} ]
let obj = arr.find((item) => {
return item.name == 'bbb'
})
console.log(obj); //输出 {name: "bbb", age: 22}13.数组的去重
双层for循环
//双层for循环
function noRepeat1(arr){
// 第一层for用来控制循环的次数
for(var i=0; i<arr.length; i++){
//第二层for 用于控制与第一层比较的元素
for(var j=i+1; j<arr.length; j++){
//如果相等
if(arr[i] == arr[j]){
//删除后面的 即第 j个位置上的元素 删除个数 1 个
arr.splice(j,1);
// j--很关键的一步 如果删除 程序就会出错
//j--的原因是 每次使用splice删除元素时 返回的是一个新的数组
// 这意味这数组下次遍历是 比较市跳过了一个元素
/*
例如： 第一次删除后 返回的是 1 1 3 2 1 2 4
* 但是第二次遍历是 j的值为2 arr[2] = 3
* 相当于跳过一个元素 因此要 j--
* */
j--;
}
}
}
return arr;
}
单层for循环
function norepeat(arr){
arr.sort();
//先排序让大概相同的在一个位置，这里为什么说是大概相同 是因为sort排序是把元素当字符串排序的 它和可能排成 1 1 10 11 2 20 3 ... 不是我们想要的从小到大
for(var i = 0; i < arr.length-1;i++){
//还是两两比较 一样删除后面的
if(arr[i]==arr[i+1]){
arr.splice(i,1);
//i-- 和j--同理
i--;
}
}
return arr;
}
利用空数组去存首次出现的元素
利用 indexOf 属性 indexOf是返回某个指定的字符在字符串中出现的位置，如果没有就会返回-1
因此我们可以很好的利用这个属性 当返回的是 -1时 就让其存入数组
function noRepeat2(arr){
var newArr = [];
for(var i = 0; i < arr.length; i++){
if(newArr.indexOf(arr[i]) == -1){
newArr.push(arr[i]);
}
}
return newArr;
}利用对象的思想 如果对象里没有这个属性的话就会返回undefined
function norepeat3(arr) {
var obj = {};
var newArr = [];
for(var i = 0; i < arr.length; i++) {
if(obj[arr[i]] == undefined) {
newArr.push(arr[i]);
obj[arr[i]] = 1;
}
}
return newArr;
}
14.数组的排序
桶排序
var arr2=[];
for(var i=0;i<arr.length;i++){
var key=arr[i];
arr2[key]=1;
}
for(var j in arr2){
console.log(j);
}冒泡排序
冒泡排序法：将数组中的相邻两个元素进行比较，将比较大（较小）的数通过两两比较移动到数组
末尾（开始），执行一遍内层循环，确定一个最大（最小）的数，外层循环从数组末尾（开始）遍历到开始（末尾）
var arr = [1,3,4,5,6,2,8,7]
for(var i=0;i<arr.length-1;i++){
for(var j=0;j<arr.length-1;j++){
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
选择排序法
将要排序的数组分成两部分，一部分是从大到小已经排好序的，一部分是无序的，从无序的部分取出最小的放到已经排序的最后面
var arrs = [12,13,32,15,43,9,18]
var arr=[1,23,5,8,11,78,45];
var temp;
for(var i=0;i<arr.length-1;i++){
for(var j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
插入排序法
将要排序的数组分成两部分，每次从后面的部分取出索引最小的元素插入到前一部分的适当位置
var arr=[45,1,32,21,56,87,43,12,34,45];
for(var i=0;i<arr.length;i++){
var n=i;
while(arr[n]>arr[n+1] && n>=0){
var temp=arr[n];
arr[n]=arr[n+1];
arr[n+1]=temp;
n--;
}
}快速排序法（一拆为二）
function quickSort(arr){
if(arr.length <= 1){
return arr;
}
var left = [];
var right = [];
var midIndex = parseInt(arr.length / 2);
var mid = arr[midIndex];
for(var i = 0 ; i < arr.length ; i++){
if(i == midIndex) continue;
if( arr[i] < mid){
left.push(arr[i])
}else{
right.push(arr[i]);
}
}
return quickSort(left).concat([mid],quickSort(right));
}
[1,2].concat([3],[4,5]); //[1, 2, 3, 4, 5]
希尔排序（性能最好）
function xier(arr){
var interval = parseInt(arr.length / 2); //分组间隔设置
while(interval > 0){
for(var i = 0 ; i < arr.length ; i ++){
var n = i;
while(arr[n] < arr[n - interval] && n > 0){
var temp = arr[n];
arr[n] = arr[n - interval];
arr[n - interval] = temp;
n = n - interval;
}
}
interval = parseInt(interval / 2);
}
return arr;
}
xier([12,9,38,44,7,98,35,59,49,88,38]);
sort排序
//一维数组排序
var arr=[1,5,7,9,16,2,4];
arr.sort(function(a,b){
return b-a; //降序排列，return a-b; —>升序排列
}) //括号里不写回调函数，则默认按照字母逐位升序排列，结果为[1,16,2,4,5,7,9]
//对象数组排序
var arr = [
{name:'syy',age:0},
{name:'wxy',age:18},
{name:'slj',age:8},
{name:'wj',age:20}
];
function compare(property){
return function(a,b){
var value1 = a[property];
var value2 = b[property];
return value1 - value2;//升序,降序为value2 - value1
}
}
arr.sort(compare('age'))
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
