js理解---数组相关

最新推荐文章于 2023-03-04 00:04:13 发布
最新推荐文章于 2023-03-04 00:04:13 发布
阅读量274 收藏
点赞数
分类专栏： js 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43932245/article/details/106261826
版权

哪些方法改变原有数组，哪些方法返回新的数组
sort()
Set()
Map()
Array.from()
操作数组常见方法
数组去重
冒泡排序
快速排序
选择排序
交集、并集、差集
找出数组中的最大值
数组降维

哪些方法改变原有数组，哪些方法返回新的数组

改变原数组：
  • push()
  • pop()
  • shift()
  • unshift()
  • sort()
  • reverse()
  • splice()
不改变原数组
  • slice()
  • concat()
  • join()
  • forEach()
  • filter()
  • map()
  • find()
  • findIndex()
  • every()
  • some()
  • reduce()

sort()

描述

sort() 方法用原地算法对数组的元素进行排序，并返回数组（改变原有数组）。默认排序顺序是先将元素转换为字符串，然后按照字符串的各个字符的Unicode位点进行排序。

语法
arr.sort([compareFunction])

如果指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

  • 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
  • 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；
  • 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
  • compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

所以，比较函数格式如下：

function compare(a, b) {
  if (a < b ) {           // 按某种排序标准进行比较, a 小于 b
    return -1;
  }
  if (a > b ) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

要比较纯数字而非字符串，比较函数可以简单的以 a 减 b，如下的函数将会将数组升序排列

function compareNumbers(a, b) {
  return a - b;
}

对象可以按照某个属性排序:

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic' },
  { name: 'Zeros', value: 37 }
];

// sort by value
items.sort(function (a, b) {
  return (a.value - b.value) // 因为value都是纯数字的
});

// sort by name
items.sort(function(a, b) {
  var nameA = a.name.toUpperCase(); // ignore upper and lowercase
  var nameB = b.name.toUpperCase(); // ignore upper and lowercase
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }

  
// names must be equal

  return 0;
});

Set()

描述

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。

语法
new Set([iterable]);
参数
  • iterable 如果传递一个可迭代对象，它的所有元素将不重复地被添加到新的 Set中。如果不指定此参数或其值为null，则新的 Set为空。
返回值

一个新的Set对象。

简述

Set对象是值的集合，你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次，即 Set 中的元素是唯一的 （可用于去重）。

案例
const arr = [1,2,2,3,4,5,5,5];
let netSet = new Set(arr);
console.log(netSet); // 1 2 3 4 5  Set对象

var myArr = Array.from(newSet);
console.log('myArr',myArr); // 1 2 3 4 5 
console.log('扩展为数组',[...newSet]); // 1 2 3 4 5 

var str = 'hello';
var strSet = new Set(str);
console.log('strSet',strSet); // h e l o; 对字符串也是会去重 保持唯一值

在这里插入图片描述

WeakSet()

描述

WeakSet 对象允许你将弱保持对象存储在一个集合中。
它和 Set 对象的区别有两点:

  • 与Set相比，WeakSet 只能是对象的集合，而不能是任何类型的任意值。
  • WeakSet持弱引用：集合中对象的引用为弱引用。 如果没有其他的对WeakSet中对象的引用，那么这些对象会被当成垃圾回收掉。 这也意味着WeakSet中没有存储当前对象的列表。 正因为这样，WeakSet 是不可枚举的。

Map()

描述

Map 对象保存键值对，并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。
一个Map对象在迭代时会根据对象中元素的插入顺序来进行 — 一个 for...of 循环在每次迭代后会返回一个形式为[key，value]的数组。

键的相等
  • NaN 是与 NaN 相等的（虽然 NaN !== NaN），剩下所有其它的值是根据 === 运算符的结果判断是否相等。
  • 在目前的ECMAScript规范中，-0和+0被认为是相等的，尽管这在早期的草案中并不是这样
案例
let myMap = new Map();
myMap.set('name','qfl')

console.log('myMap',myMap);//{"name" => "qfl"}
console.log('name', myMap.get('name')); // qfl
console.log('myMap values',myMap.values()); // qfl
console.log('myMap keys',myMap.keys()); // name
myMap.forEach((item)=>{
console.log('item',item); // name
 })

// 使用常规的Map构造函数可以将一个二维键值对数组转换成一个Map对象
let kvArray = [["key1", "value1"], ["key2", "value2"]];
let myMap = new Map(kvArray); 
console.log('myMap', myMap); //{"key1" => "value1", "key2" => "value2"}
console.log('key1', myMap.get('key1')); // value1
console.log('from', Array.from(myMap)); //[["key1", "value1"], ["key2", "value2"]]

//正确使用属性
let myMap = new Map()
myMap.set('bla', 'blaa')
myMap.set('bla2', 'blaa2')
console.log(myMap)  // Map { 'bla' => 'blaa', 'bla2' => 'blaa2' }

console.log(myMap.has('bla') )   // true
myMap.delete('bla') // true
console.log(myMap)  // Map { 'bla2' => 'blaa2' }

在这里插入图片描述

WeakMap()

描述

WeakMap 对象是一组键/值对的集合，其中的键是弱引用的。其键必须是对象，而值可以是任意的。

与Map的区别：

  • WeakMap 的 key 只能是 Object 类型。 原始数据类型 是不能作为 key 的。
  • 原生的 WeakMap 持有的是每个键对象的“弱引用”，这意味着在没有其他引用存在时垃圾回收能正确进行。原生 WeakMap 的结构是特殊且有效的，其用于映射的 key 只有在其没有被回收时才是有效的。正由于这样的弱引用，WeakMap 的 key 是不可枚举的

阶段总结

在这里插入图片描述
在这里插入图片描述

Array.from()

描述

Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。

语法
Array.from(arrayLike[, mapFn[, thisArg]])
参数
  • arrayLike 想要转换成数组的伪数组对象或可迭代对象。
  • mapFn 可选,如果指定了该参数，新数组中的每个元素会执行该回调函数
  • thisArg 可选，执行回调函数 mapFn 时 this 对象。
返回值

一个新的数组实例。

案例
从 String 生成数组
Array.from('foo'); 
// [ "f", "o", "o" ]
从 Set 生成数组
const set = new Set(['foo', 'bar', 'baz', 'foo']);
Array.from(set);
// [ "foo", "bar", "baz" ]
从 Map 生成数组
const map = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(map);
// [[1, 2], [2, 4], [4, 8]]
const mapper = new Map([['1', 'a'], ['2', 'b']]);
Array.from(mapper.values());
// ['a', 'b'];

Array.from(mapper.keys());
// ['1', '2'];
从类数组对象（arguments）生成数组
function f() {
  return Array.from(arguments);
}

f(1, 2, 3);

// [ 1, 2, 3 ]
在 Array.from 中使用箭头函数
Array.from([1, 2, 3], x => x + x);
// [2, 4, 6]
Array.from({length: 5}, (v, i) => i);
// [0, 1, 2, 3, 4]
数组去重合并
function combine(){ 
    let arr = [].concat.apply([], arguments);  //没有去重复的新数组 
    return Array.from(new Set(arr));
} 

var m = [1, 2, 2], n = [2,3,3]; 
console.log(combine(m,n));                     // [1, 2, 3]

在这里插入图片描述

操作数组常见方法

map()
filter()
every()
some()
find()
findIndex()
reduce()

map()

描述

map() 方法遍历数组，使用传入函数处理每个元素，并返回函数的返回值组成的新数组(可理解为将数组的每个元素映射成指定的形式，新数组的长度与原数组相同)。

语法
arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])
参数
  • callback 生成新数组元素的函数，使用三个参数：
    • currentValue callback 数组中正在处理的当前元素。
    • index可选 callback 数组中正在处理的当前元素的索引。
    • array可选 map 方法调用的数组。
  • thisArg 可选 执行 callback 函数时值被用作this。

callback 函数会被自动传入三个参数：数组元素，元素索引，原数组本身。

如果 thisArg 参数提供给map，则会被用作回调函数的this值。否则undefined会被用作回调函数的this值。

案例
求平方根
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log('roots',roots); // [1,2,3]

使用一个包含一个参数的函数来构建一个数字数组
var numbers = [1, 4, 9];
var doubles = numbers.map(function(num) {
  return num * 2;
});

// doubles数组的值为： [2, 8, 18]
// numbers数组未被修改： [1, 4, 9]

通常情况下，map 方法中的 callback 函数只需要接受一个参数，就是正在被遍历的数组元素本身。但这并不意味着 map 只给 callback 传了一个参数。这个思维惯性可能会让我们犯一个很容易犯的错误。

["1", "2", "3"].map(parseInt); 我们期望输出 [1, 2, 3], 而实际结果是 [1, NaN, NaN].

parseInt有两个参数：

  • 第一个是传递的字符串
  • 第二个（可选）要解析的数字的基数，该值介于 2 ~ 36 之间。如果该参数小于 2 或者大于 36，则 parseInt() 将返回 NaN。

map的callbackl有三个参数:

  • 当前值
  • 索引 0,1，2
  • 当前数组

在这里parseInt没有传参，默认将map的参数对应到parseInt中，所以第一个参数就是当前值，第二个参数是对应的索引，就变成下面这样：

// parseInt(string, radix) -> map(parseInt(value, index))
/*  first iteration (index is 0): */ parseInt("1", 0);  1    参数省略或者为0 默认以10进制进行解析
/* second iteration (index is 1): */ parseInt("2", 1);  NaN  基数基于2~36之间 除了0之外 都会返回NaN
/*  third iteration (index is 2): */ parseInt("3", 2);  NaN  2进制只有01 3不符合二进制转化 所有是NaN

解决方式有很多种：

function returnInt(element) { // 只接收一个参数
  return parseInt(element, 10);
}

['1', '2', '3'].map(returnInt); // [1, 2, 3]
// Actual result is an array of numbers (as expected)

// Same as above, but using the concise arrow function syntax
['1', '2', '3'].map( str => parseInt(str) );

// A simpler way to achieve the above, while avoiding the "gotcha":
['1', '2', '3'].map(Number); // [1, 2, 3]
Mapping 含 undefined的数组

当返回undefined 或没有返回任何内容时:

var numbers = [1, 2, 3, 4];
var filteredNumbers = numbers.map(function(num, index) {
  if(index < 3) {
     return num;
  }
});
//index goes from 0,so the filterNumbers are 1,2,3 and undefined.
// filteredNumbers is [1, 2, 3, undefined]
// numbers is still [1, 2, 3, 4]

在这里插入图片描述

filter()

描述

filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
filter 为数组中的每个元素调用一次 callback 函数，并利用所有使得 callback 返回 true 或等价于 true 的值的元素创建一个新数组。

语法
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
参数
  • callback 用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数：
    • element 数组中当前正在处理的元素。
    • index可选 正在处理的元素在数组中的索引。
    • array可选 调用了 filter 的数组本身。
  • thisArg 可选 执行 callback 函数时值被用作this。
返回值

一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

案例

筛选排除所有较小的值

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

过滤 JSON 中的无效条目

var arr = [
  { id: 15 },
  { id: -1 },
  { id: 0 },
  { id: 3 },
  { id: 12.2 },
  { },
  { id: null },
  { id: NaN },
  { id: 'undefined' }
];

var invalidEntries = 0;

function isNumber(obj) {
  return obj !== undefined && typeof(obj) === 'number' && !isNaN(obj);
}

function filterByID(item) {
  if (isNumber(item.id) && item.id !== 0) {
    return true;
  } 
  invalidEntries++;
  return false; 
}

var arrByID = arr.filter(filterByID);

console.log('Filtered Array\n', arrByID); 
// Filtered Array
// [{ id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 }]

console.log('Number of Invalid Entries = ', invalidEntries); 
// Number of Invalid Entries = 5

在数组中搜索

var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];

/**
 * Array filters items based on search criteria (query)
 */
function filterItems(query) {
  return fruits.filter(function(el) {
      return el.toLowerCase().indexOf(query.toLowerCase()) > -1;
  })
}

console.log(filterItems('ap')); // ['apple', 'grapes']
console.log(filterItems('an')); // ['banana', 'mango', 'orange']

在这里插入图片描述

every()

every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。
every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个会使 callback 返回 falsy 的元素。如果发现了一个这样的元素，every 方法将会立即返回 false。

总结：只有所有元素都满足条件才返回为true

注意：若收到一个空数组，此方法在一切情况下都会返回 true。

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

some()

some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。
some() 为数组中的每一个元素执行一次 callback 函数，直到找到一个使得 callback 返回一个“真值”（即可转换为布尔值 true 的值）。如果找到了这样一个值，some() 将会立即返回 true。

总结：只要有一个满足条件就返回为true

注意：如果用一个空数组进行测试，在任何情况下它返回的都是false。

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

find()

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。

find方法对数组中的每一项元素执行一次 callback 函数，直至有一个 callback 返回 true。当找到了这样一个元素后，该方法会立即返回这个元素的值，否则返回 undefined。

总结：返回匹配的第一个元素，没有匹配到返回undefined.

var inventory = [
    {name: 'apples', quantity: 2},
    {name: 'bananas', quantity: 0},
    {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
    return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }

findIndex()

findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
findIndex方法对数组中的每个数组索引0..length-1（包括）执行一次callback函数，直到找到一个callback函数返回真实值（强制为true）的值。如果找到这样的元素，findIndex会立即返回该元素的索引。如果回调从不返回真值，或者数组的length为0，则findIndex返回-1。

总结：返回匹配的第一个元素的索引值，没有匹配到返回-1.

function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, not found
console.log([4, 6, 7, 12].findIndex(isPrime)); // 2

reduce()

reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

callback参数:

  • accumulator 累计器
  • currentValue 当前值
  • currentIndex 当前索引
  • array 数组
    第二个参数：
  • initialValue 初始值，如果没有提供初始值，则将使用数组中的第一个元素。

回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供 initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值。
每次执行完callback，accumulator 是上次计算的返回值，currentValue 是接下来的元素

没有初始值 ，accumulator 为第一个元素，currentValue 为第二个元素

[0, 1, 2, 3, 4].reduce((prev, curr) => prev + curr ); // 10

在这里插入图片描述
有初始值 ，accumulator 为initialValue 的值，currentValue 为第一个元素

[0, 1, 2, 3, 4].reduce((accumulator, currentValue, currentIndex, array) => { return accumulator + currentValue; }, 10 );//20

在这里插入图片描述

计算数组中每个元素出现的次数

var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];

var countedNames = names.reduce(function (allNames, name) { 
	if(!allNames[name]){
		allNames[name] = 1;
	}else{
	 	allNames[name]++;
	}
    return allNames;
}, {});
// countedNames is:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }

按属性对object分类

var people = [
  { name: 'Alice', age: 21 },
  { name: 'Max', age: 20 },
  { name: 'Jane', age: 20 }
];

function groupBy(objectArray, property) {
  return objectArray.reduce(function (acc, obj) {
    var key = obj[property];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  }, {});
}

var groupedPeople = groupBy(people, 'age');
// groupedPeople is:
// { 
//   20: [
//     { name: 'Max', age: 20 }, 
//     { name: 'Jane', age: 20 }
//   ], 
//   21: [{ name: 'Alice', age: 21 }] 
// }

数组去重

var myArray = ['a', 'b', 'a', 'b', 'c', 'e', 'e', 'c', 'd', 'd', 'd', 'd'];
var myOrderedArray = myArray.reduce(function (accumulator, currentValue) {
  if (accumulator.indexOf(currentValue) === -1) {
    accumulator.push(currentValue);
  }
  return accumulator
}, [])

console.log(myOrderedArray);

数组去重

经典面试题，数组去重的几种方式：

1、利用对象的属性，如果不存在放入新数组

function unique1(arr) {
 var res = [], obj = {};
 for (var i = 0; i < arr.length; i++) {
   if (!obj[arr[i]]) {
     obj[arr[i]] = 1;
     res.push(arr[i])
   }
 }
 return res;
}
console.log('unique1', unique1(arr)); // [1, 2, 7, 5, 4, 3, "a", "c", "b"]

2、利用indexOf

function unique2(arr) {
  var res = [];
  for (var i = 0; i < arr.length; i++) {
    if (res.indexOf(arr[i]) == -1) {
      res.push(arr[i])
    }
  }
  return res;
}
console.log('unique2', unique2(arr)); // [1, 2, 7, 5, 4, 3, "a", "c", "b"]

3、利用数组的includes()

function unique3(arr) {
 var res = [];
 for (var i = 0; i < arr.length; i++) {
   if (!res.includes(arr[i])) {
     res.push(arr[i])
   }
 }
 return res;
}
console.log('unique3', unique3(arr)); // [1, 2, 7, 5, 4, 3, "a", "c", "b"]

4、new Set()

var setArr = Array.from(new Set(arr));
var setArr =[...new Set(arr)];
console.log('setArr',setArr); // [1, 2, 7, 5, 4, 3, "a", "c", "b"]

冒泡排序

var arr = [3,2,5,9,1,6,33,4,65,22];
var temp = 0;

for(var i=0;i<arr.length;i++){
 for(var j= i+1;j<arr.length;j++){
   if(arr[i]>arr[j]){  //相邻比较，如果前一个大，就调换位置
     temp = arr[i];//temp储存前一个大的数
     arr[i] = arr[j];//前一个换成小的那个数
     arr[j] = temp;//将大的赋值给后一个
   }
 }
}
console.log(arr) //1 2 3 4 5 6 9 22 33 65

快速排序

快速排序采用了一种分治的策略，通常称其为分治法，其基本思想是：
将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。 (取中间值 递归处理左右)

var arr = [3,2,5,9,1,6,33,4,65,22];

function quickSort(arr){
 if(arr.length < 1) return arr;
 var middleIndex = Math.floor(arr.length/2);//取中间值
 var middle = arr.splice(middleIndex,1) ; //删除并返回这个值，即把中间这个值拿出来用作比较
 var left = [];
 var right = [];
 for(var i=0;i<arr.length;i++){
   if(arr[i] > middle){
     right.push(arr[i])
   }else{
     left.push(arr[i])
   }
 }
 return quickSort(left).concat(middle,quickSort(right));//递归 直到length<=1

}
console.log(quickSort(arr));// [1, 2, 3, 4, 5, 6, 9, 22, 33, 65]

选择排序

首先从原始数组中找到最小的元素，并把该元素放在数组的最前面，然后再从剩下的元素中寻找最小的元素，放在之前最小元素的后面，直到排序完毕。

var arr=[8,94,15,88,55,76,21,39];

function selectSort(arr){
  var minIndex,temp;
  for(var i=0;i<arr.length-1;i++){
    minIndex = i;
    for(var j=i+1;j<arr.length;j++){
      if(arr[j] < arr[minIndex]){
        minIndex = j
      }
    }
    temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}
console.log(selectSort(arr)); // 8 15 21 39 55 76 88 94

交集、并集、差集

var a = [1, 2, 3],b=[2,4,5];
// 并集
let union = a.concat(b.filter(v => !a.includes(v))) // [1,2,3,4,5]
// 交集
let intersection = a.filter(v => b.includes(v)) // [2]
// 差集
let difference = a.concat(b).filter(v => !a.includes(v) || !b.includes(v)) // [1,3,4,5]

// 并集
var union = a.concat(b.filter(function(v) {
return a.indexOf(v) === -1})) // [1,2,3,4,5]
// 交集
var intersection = a.filter(function(v){ return b.indexOf(v) > -1 }) // [2]
// 差集
var difference = a.filter(function(v){ return b.indexOf(v) === -1 }).concat(b.filter(function(v){ return a.indexOf(v) === -1 })) // [1,3,4,5]

考虑含有NaN的情况:

var aHasNaN = a.some(function(v){ return isNaN(v) })
var bHasNaN = b.some(function(v){ return isNaN(v) })
// 并集
var union = a.concat(b.filter(function(v) {
return a.indexOf(v) === -1 && !isNaN(v)})).concat(!aHasNaN & bHasNaN ? [NaN] : []) // [1,2,3,4,5]
// 交集
var intersection = a.filter(function(v){ return b.indexOf(v) > -1 }).concat(aHasNaN & bHasNaN ? [NaN] : []) // [2]
// 差集
var difference = a.filter(function(v){ return b.indexOf(v) === -1 && !isNaN(v) }).concat(b.filter(function(v){ return a.indexOf(v) === -1 && !isNaN(v) })).concat(aHasNaN ^ bHasNaN ? [NaN] : []) // [1,3,4,5]

var nums1 = [1,2,2,1,4], nums2 = [2,2,4,5];

// 交集
function intersection(num1,num2){
 var temp = [];
 for(var i=0;i<num1.length;i++){
   if(num2.indexOf(num1[i]) !== -1){
     num2.splice(num2.indexOf(num1[i]),1);
     temp.push(num1[i])
   }
 }
 return temp;
}
console.log('交集',intersection(nums1,nums2)); // 2 2 4

找出数组中的最大值

var arrMax = [1,2,3,4,5];
//1.for循环,古老的写法，遍历之后取最大值
var arrRes = arrMax[0];
for(var i = 1 ;i <arrMax.length; i++){
var result = Math.max(arrRes,arrMax[i]) //两者比较 返回最大值
}
console.log(result)
//2.Math最大值。用到apply方法，可以将数组转换成参数列表再调用Math方法
Math.max.apply(null,arrMax)
//3.sort()
arrMax.sort((num1,num2) => {return num2-num1})[0] //或者sort()后reverse()
//4.reduce()
arrMax.reduce((num1,num2) => {return num1 > num2 ? num1 : num2})

数组降维

var arrDown = [[1,2,3],[4,5],[9,8,7]];
//1.二维数组，双层遍历
function down(arr) {
var resDown = [];
for(var i = 0;i < arr.length; i++){
for (var j = 0; j < arr[i].length; j++){
resDown.push(arr[i][j])
}
}
return resDown
}
console.log(down(arrDown))
//2.concat()
function down2(arr) {
var resDown = [];
for(var i = 0; i < arr.length; i++){
resDown = resDown.concat(arr[i])
}
return resDown
}
console.log(down2(arrDown))
//3.concat()和apply()结合
function down3(arr) {
var resDown = [];
return Array.prototype.concat.apply(resDown,arr)
}
console.log(down3(arrDown))

多级数组递归降维

var arrDown = [[1,2,3],[4,5,[6,1]],[9,8,7]];

function down(arr){
var temp = [];
for(var i =0;i<arr.length;i++){
  if(arr[i].constructor == Array){
   temp = temp.concat(down(arr[i])) 
  }else{
  temp.push(arr[i])
  }
}
return temp;
}
console.log(down(arrDown)); // [1, 2, 3, 4, 5, 6, 1, 9, 8, 7]
邱先生~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
个人对数组的总结与理解
qq_51993933的博客
02-27 282
数组 什么是数组？ 前面在学习Java数据类型的时候曾经谈到，Java的数据类型分为基本类型和引用类型。 基本类型包括整型、浮点型、字符类型、布尔类型四种。引用类型包括类、接口、数组等。 数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 Java 语言中提供的数组是用来存储固定大小的同类型元素。 数组定义 是相同类型数据的集合 描述的是相同类型的若干个数据，按照一定的先后顺序组合而成 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们 声明
对数组的认识
duck_iam的博客
07-30 369
数组的定义 数组是相同类型数据的有序集合； 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成； 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们； 数组中的元素可以是任何数据类型，包括基本类型和引用类型； 数组其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。 数组的三种初始化（用一维数组举例） //静态初始化 int[] a={1,2,3,4,5,6,7,8}; ​ //动态初始化 ...
对数组的基本认识
m0_51418215的博客
11-05 753
数组 1、数组的概念： 数组，它是一组具有相同数据类型，并且按照顺序排列的变量的集合。在内存中，数组表现为一块连续的存储区域。 2、数组的定义： 数组：在变量名后多加一个下标号[]来指定元素的个数 下标号[ ]内必须是一个常量表达式而不能是变量！ 3、数组元素的调用 #include <stdio.h> int main(){ const int N = 6; int a[N]; int i = N; while (i--) a[i] = i * 8 + 2; while (++
我对数组的理解
ITkobebryant的博客
03-28 263
数组作用：保存多个数据 数组格式：1.数据类型 数组名 =new 数据类型 [长度] 2.数据类型 数组名 ={元素1 元素2 元素3……} 数组的长度，必须要在数组创建的时候指定 “数组是引用类型” 注：数组长度是final修饰的，所以不可改变 数组有一维、二维、三维数组 二维数组：一维数组的一维数组 顾名思义三维数组就是一维数组的一维数组的一维数组 数组在内存中是连续的 数组的下标是从零...
数组的详细讲解
lu_lu_n的博客
02-28 350
了解数组 数组是相同类型的数据的有序集合 数组描述的是相同类型的若干个数据 数组变量属于引用类型 数组可以看作对象 数组中的每一个元素相当于该对象的成员变量 基本特点： 长度是确定的 元素类型必须相同 数组的整个类型可以是任何类型 数组的声明以及初始化 String name[]； 或者 String[] name； 初始化给数组分配空间 int arr[] = new int[100]; ...
js代码-数组相关计算
07-15
本压缩包文件"js代码-数组相关计算"包含两个文件：main.js和README.txt，主要关注的是JavaScript中的数组处理技巧和算法。让我们深入探讨一下JavaScript数组的常用方法和相关计算。 1. **数组创建与初始化** ...
js代码-数组转化树形结构
07-16
总结起来，JavaScript中将数组转换为树形结构的关键在于理解数据的层级关系，并通过构建节点映射和递归处理子节点来实现。`main.js`中的函数`arrayToTree`就是这样一个实现，适用于具有"id"和"parentId"键的数组数据...
js代码-数组filter测试
07-15
在JavaScript中，数组的`filter()`方法是一个非常重要的功能，用于创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。这个方法在处理数据过滤、筛选、去重等场景时非常实用。让我们深入了解...
js代码-数组去重-indexOf
07-15
在JavaScript编程中，数组去重是一项常见的操作，特别是在处理数据集合时。`indexOf`方法是JavaScript数组的一个内置方法，它可以用来检测一个特定元素在数组中首次出现的位置。在这个场景下，我们可以利用`indexOf`...
数组的简述
呵呵博客
10-07 466
-、数组的创建
初学java对数组的认识
chris__x的博客
07-19 153
数组：是一组相关类型变量的集合，并且这些变量可以按照统一的方式进行操作，它是引用类型数据，有内存分配问题 数组定义：int[ ] arr=new int[5]; 注意事项： 1、可以访问的索引范围是0到length-1，即0到4，超出这个范围就会产生java.lang,ArrayIndexOutOfBoundsException，即数组下标越界 2、开辟好之后，每个元素都是该数据类型的默认值，...
数组的常用的方法API
qq_45715615的博客
03-02 227
方法 是否改变原数组 特点 forEach() 否 数组方法，不改变原数组，没有返回值 map() 否 数组方法，不改变原数组，有返回值，可链式调用 filter() 否 数组方法，过滤数组，返回包含符合条件的元素的数组，可链式调用 for...of 否 for...of遍历具有Iterator迭代器的对象的属性，返回的是数组的元素、对象的属性值，不能遍历普通的obj对象，将异步循环变成同步循环 every() 和 some..
JS: splice()的三个方法
weixin_59519449的博客
09-05 3562
思路： splic 可以简单的归总为三个方法： 删除，添加，替换 1.删除，可以删除任何数量的项；只要指定两个 参数 ：要删除的第一项的位置和删除的项数。例如splice(0,2)会删除数组中的前两项 var arr=[1,2,3,4,5,6] arr.splice(0,2) console.log(arr)//控制台输出为3，4，5，6 2.插入：可以向指定的位置插入任意数量的项，需要三个参数：起始位置，0（要删除的项数）和要插入的项。；例如：splice(2,0,..
JS中数组的splice()方法介绍 及 用原生JS手写数组splice()方法
nibabaoo的博客
08-23 5114
JS中数组的splice()方法 及 用原生JS手写数组splice()方法
（超详细）数组方法 ——— splice( )
最新发布
dandanmei0513的博客
03-04 1万+
（超详细）数组方法 ——— splice( )
splice函数有三个作用。　
weixin_33901641的博客
05-10 280
splice函数有三个作用。第一个作用是向数组中间的一部分插入内容。例如：　　　@d=(1..9);　　　my @e=("a".."f"); splice(@d,2,2,@e);#目标数组, 插入起始位置, 覆盖长度, 插入数组将会得到12abcdef56789，注意这里是从第二个开始插入，不是从下标为2的元素开始插入的。splice的第二个功能是删除，例如在刚才的代码上面再...
javascript-你不知道的数组
火腿肠的博客
05-31 184
1. 用console.table来打印数组看的更清楚 2. cosnt声明数组/对象（引用类型）的改变机制 引用类型是将一个地址存在于变量中，而const无法改变的是当前变量所对应的内容，所以： const arr = [1,2,3]; =>arr = [1,2]; //可以改变 =>arr = []; //不可以改变 3. array.of创建数组 array.of创建的数组 let a = new Array(6); // [6] console.log(a.
js中数组的splice()方法
热门推荐
回头等终点的博客
07-31 1万+
splice 有如下几个功能： 1.删除-用于删除元素，两个参数，第一个参数（要删除第一项的位置），第二个参数（要删除的项数）  2.插入-向数组指定位置插入任意项元素。三个参数，第一个参数（起始位置），第二个参数（0），第三个参数（插入的项数）  3.替换-向数组指定位置插入任意项元素，同时删除任意数量的项，三个参数。第一个参数（起始位置），第二个参数（删除的项数），第三个参数（插入任
slice(),splice(),split(),substring(),substr()使用方法和区别
前端技术的学习整理
08-20 9724
《一》 1.slice（）； Array和String对象都有 在Array中  slice(i,[j])    i为开始截取的索引值,负数代表从末尾算起的索引值，-1为倒数第一个元素 j为结束的索引值，缺省时则获取从i到末尾的所有元素 参数返回： 返回索引值从i到j的数组，原数组不改变 在String中 slice(i,[j]) 参数说明： i为开始截取的索引值，负数代表从末尾算...
JavaScript教程：从入门到精通-理解数组实例与特性
"这篇教程主要介绍了JavaScript中的数组实例创建，以及JavaScript语言的基本特性和与Java的区别。" 在JavaScript中，数组是一种数据结构，允许我们存储多个值在一个单一的变量中。创建数组实例的过程如下： ```...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值