map改变原数组(map修改数据)

JS Array(数组)所有作方法，改变数组方法、不改变数组方法

entries()、keys()、values()

定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。

map改变原数组(map修改数据)

map改变原数组(map修改数据)

7-7、二维地图的聚合，如果有十万个点，会做什么优化；

目的：Array.of() 出现的目的是为了解决上述构造器因参数个数不同，导致的行为有异的问题。

参数：

个参数(必需):要转化为真正数组的对象。

第二个参数(可选): 类似数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。

第三个参数(可选): 用来绑定this。

ps：spl方法从数组中添加/删除项目，然后返回被删除的项目

语法： array.spl(index,howmany,1,.....,X)

参数:

index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。

howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。

1, …, X： 可选。向数组添加的新项目。

返回值: 如果有元素被删除,返回包含被删除项目的新数组。

删除元素

删除并添加

不删除只添加

ps：方法接受两个参数，一个从哪里开始，一个是到哪里结束（但是不包括这个结束的元素本身）。如果是负数，就从倒数第几个。

参数可选: 规定排序顺序的比较 函数 。

默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。

比较函数的两个参数

sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：

sort排序常见用法

数组多条件排序

自定义比较函数

定义: 在当前数组内部，将指定位置的成员到其他位置,并返回这个数组。

语法: array.copyWithin(target, start = 0, end = this.length)

参数:

三个参数都是数值，如果不是，会自动转为数值.

target（必需）：从该位置开始替换数据。如果为负值，表示倒数。

end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。

浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

从上述例子:

个参数是开始被替换的元素位置

要替换数据的位置范围:从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取

读了几个元素就从开始被替换的地方替换几个元素

参数:

个元素(必须): 要填充数组的值

第二个元素(可选): 填充的开始位置,默认值为0

第三个元素(可选)：填充的结束位置，默认是为this.length

使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？

join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[object Object]字符串。

如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。

ps：当数组和字符串作的时候，js 会调用这个方法将数组自动转换成字符串

ps：字符串也有一个sl() 方法是用来提取字符串的，不要弄混了。

参数:

begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。

end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括一个元素)。

如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变

原因在定义上面说过了的：sl()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。

ES6扩展运算符...合并数组：

因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。

参数:

searchElement(必须):被查找的元素

fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。

严格相等的搜索:

数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。

注意：indexOf()不能识别NaN

参数:

searchElement(必须): 被查找的元素

fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。

关于fromIndex有三个规则:

正值。如果该值大于或等于数组的长度，则整个数组会被查找。

负值。将其视为从数组末尾向前的偏移。(比如-2，从数组第二个元素开始往前查找)

负值。其大于数组长度，则方法返回 -1，即数组不会被查找。

参数：

searchElement(必须):被查找的元素

fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值超过长数组度，重置从0开始搜索。

includes方法是为了弥补indexOf方法的缺陷而出现的:

indexOf方法不能识别Na数组的长度不会改变N

indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观

js数组移除制定对象 数组拆分成多个数组

18-10、除了链式调用，promise还可以怎么处理同步请求(async/await)；

一般的方法此处也不列举了，还是有很多的，如双层循环判断是否相等，或新建数组比较再push等等，需要注意的是，使用spl方法移除元素时，有可能会导致数组塌陷问题，需要处理一下

13-2、垂直居中方案；

本文中介绍了多种数组去重的方法，使用了较多的高阶方法及API，并给出相应解释及语法，还有其他多种组合调用方式，原理逻辑其实都不多，其中for循环可以与forEach方法相互转换，因此此处便不再一一列举，大家如果有更好的算法，可以留言给我，虚心请教！！

return sum + word.length;

给定一个数组 [1,2,2,4,null,null,’3′,’abc’,3,5,4,1,2,2,4,null,null,’3′,’abc’,3,5,4] 去除重复项

let arr = [1,2,2,4,null,null,’3′,’abc’,3,5,4,1,2,2,4,null,null,’3′,’abc’,3,5,4]

1. 利用对象的 key 众所周知，对象的key不可重复，否则后者将覆盖前者。利用该特性，实现数组去重，遍历数组，将数组的每一项做为对象的key值

let obj = {};

for (let i = 0; i < arr.length; i++) {

let = arr[i]

if (obj[] !== undefined) {

arr.spl(i, 1);

i–; // 解决删除元素后，数组塌陷问题

continue;

}obj[] =

}// arr: [1, 2, 4, null, “3”, “abc”, 3, 5]

2. 交换元素位置从而替换调 spl方法上述方法存在一定的性能问题，也就是说，基于spl实现删除性能不太好，当前项被删除后，随后每一项的索引都要向前移动一位，数据量较庞大时，一定会影响性能。

基于以上考虑，交换元素的位置，效率会更高一点， 若当前元素重复，则与数组一位元素交换位置，i–再次进行判断即可，同时length–,作数组的长度实现删除数组的一个元素，这样便不会影响到数组中其他元素

let obj = {};

for (let i = 0; i < arr.length; i++) {

let = arr[i]

if (obj[] !== undefined) {

arr[i] = arr[arr.length-1]

arr.length–;

i–;

continue;

}obj[] =

}// arr: [1, 2, 4, null, “3”, “abc”, 3, 5]

3. Array.filter + Array.indexOffilter() 方法：创建一个新数组，新数组中的元素是指定数组中符合某种条件的所有元素。如果没有符合条件的元素则返回空数组。

语法：array.filter(function(,index,arr))

filter() 不会对空数组进行检测。

filter() 不会改变原始数组。

原理：返回 次出现的位置等于当前的index的元素

let newArr = arr.filter((, index) => arr.indexOf() === index);

// [1, 2, 4, null, “3”, “abc”, 3, 5]

4. Array.filter + Object.hasOwnPropertyhasOwnProperty() 方法：返回一个布尔值，表示对象自身属性中是否具有指定的属性

原理：利用对象的键名不可重复的特点

let obj = {}

arr.filter( => obj.hasOwnProperty(typeof + ) ? false : (obj[typeof + ] = true))

5. Array.reduce + Array.includesreduce() 方法：接收一个函数作为累加器，数组中的每个值从左到右开始计算，最终计算为一个值。

语法：arr.reduce(function(total, currValue, currIndex, arr), initValue)

reduce() 对于空数组是不会执行回调函数的。

total：必需。初始值, 或者计算结束后的返回值

currValue：必需。当前元素

currIndex：可选。当前元素的索引

arr ：可选。当前数组对象。

initValue：可选。累加器初始值

let newArr = arr.reduce((accu, cur) => {

return accu.includes(cur) ? accu : accu.concat(cur); // 1. 拼接方法

// return accu.includes(cur) ? accu : […accu, cur]; // 2. 扩展运算

// [1, 2, 4, null, “3”, “abc”, 3, 5]

6. Array.indexOfindexOf() 方法：返回数组中某个指定的元素位置。该方法遍历数组，查找有无对应元素并返回元素次出现的索引，未找到指定元素则返回 -1。

let newArr = []

if (newArr.indexOf(arr[i]) === -1) newArr.push(arr[i])

}//等同于 forEach 写法

arr.forEach( => newArr.indexOf() === -1 ? newArr.push() : ”)

console.log(newArr) // [1, 2, 4, null, “3”, “abc”, 3, 5]

7. Array.includesincludes() 方法：用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

let newArr = []

if (!newArr.includes(arr[i])) newArr.push(arr[i])

}//等同于 forEach 写法

arr.forEach( => !newArr.includes() ? newArr.push() : ”)

console.log(newArr) // [1, 2, 4, null, “3”, “abc”, 3, 5]

8. new Set + 扩展运算符 || Array.fromES6 提供了新的数据结构 Set。类似于数组，但是成员的值都是的，没有重复的值。

Set本身是一个构造函数，可以接受一个具有 iterable 接口数据结构作为参数（如数组，字符串），用来初始化。

let newArr = Array.from(new Set(arr)); // [1, 2, 4, null, “3”, “abc”, 3, 5]

let newStr = […new Set(‘ababbc’)].join(”) // ‘abc’

9. new MapES6 提供了新的数据结构 Map。类似于对象，也是键值对的，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。

set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。

get方法读取key对应的键值，如果找不到key，返回undefined。

let map = new Map();

let newStr = [];

for (let i = 0; i < arr.length; i++) {

if (!map.has(arr[i])) {

map.set(arr[i], true);

newStr.push(arr[i]);

}}

console.log(newArr) // [1, 2, 4, null, “3”, “abc”, 3, 5]

用HashMap存数据，然后赋值给另外一个Map类型的变量，更新另外一个变量后，原始的变量的值也更新了。

for (var i = 0; i < arr.length; i++) {

其实这和数组的时一样的：从指定源数组中一个数组,若是用int[] array1=int[] array2; 那么将来 得到的数组 改变一个 另一个跟着改变 使用System.arraycopy()方法可以实现数组。

13-9、前端优化方案；

那么 对于hashMap好像没有这样的方法，但是可以使用遍历hashMap的方法：

7-18、vue中跳转页面的方法；

public static void main(String[] args) {

Map map1 = new HashMap();

for(int i=0;i<10;i++){

map1.put(i, i+"--test");

}// System.out.println(map1.size());

Map map2=new HashMap();

for (int i = 0; i < map1.size(); i++) {

Iterator iter = map1.keySet().iterator();

while (iter.hasNext()) {

Object key = iter.next();

map2.put(i, map1.get(key));

i++;

}}

}你可以试验一下 ，应该没有问题的。

PS：为什么一定要把数据copy到新的map里去？给个理由先。这又不是C++，对象脱离作用域就会被销毁。直接把map的引用拿去用不就行了吗？

ja中如何把hashmap转换成object数组

如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。

hashmap是以键值对(key-value)的格式保存对象的容器, 数组是按顺序一个一个保存对象的容器 你把hashmap转换成数组是想把key转成数组呢还是把value转成数组呢或者key和value组合成的对象转换成数组呢.我把key和value的分别写出来,组合对象的同理...

import ja.util.HashMap;

import ja.util.Map;

public class MapToObject {

public static void main(String[] args){

Map m = new HashMap()13-3、let a=arr, b=a, c=arr.concat(), a[0]=3，打印b和c，应该是深浅拷贝；;

m.put(1,"one");

m.}, []);put(2,"two");

m.put(3,"three");

Object o[] =m.values().toArray();

for(int i=0;i

System.out.println(o[i]);

}}

}//就是在map中依次存在的顺序吧

如果你要保证有序，那使用TreeMap

如何在JaScript函数式编程里使用Map和Reduce方法的详解

start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。

所有人都谈论道workflows支持ECMAScript6里出现的令人吃惊的新特性，因此我们很容易忘掉ECM19-12、讲一下原型链； proto 和prototype有什么区别；字符串有没有原型；给定一个str，str.test()调用的谁的test方法；AScript5带给我们一些很棒的工具方法来支持在JaScript里进行函数编程，这些工具方法我们现在可以使用了。在这些函数方法里主要的是基于JaScript 数组对象的map()方法和reduce()方法。

数组元素为数字的升序、降序:

性能：一个当然，当现实状况需要保持提高性能时，你的代码的易读性和易维护性不得不在两者之间保持平衡。如今的浏览器使用更笨重的传统技术例如for循环来执行的更。

我写代码的方式通常是把可读性和可维护性放在编写代码的位，然后如果我发现在现实情况里代码运行出现了问题，再去为了提高性能而去优化代码。过早的优化代码是很困难的，而且这种优化会导致后面编写代码很困难。

值得考虑的是在JaScript引擎里使用诸如map()和reduce()这样的方法可以更好地改善代码的性能,而不是指望将来浏览器能为了改善性能而做出优化。除非我在一个性能问题上碰壁，要不然我更喜欢开心地写代码，然而以防我需要它们我却随时准备着为保持代码的性能而做出调整，尽管这样做使我的代码减少了吸引力。

使用Map方法映射是一个基本的函数式编程技术，它对一个数组中的所有元素和创建的具有相同长度并有着转换内容的其他数组起作用。

为了使刚才的说法更加具体一点，我想出了一个简单使用示例。例如，想象一下你有一个数组，数组里有字符数据，而且你需要把它们转换进另一个数组，这个数组里包含每一个字符数据的长度。(我知道，那没有复杂到火箭科学那种程度，这是你编写复杂的应用经常不得不去做的事情，但是理解它在一个简单示例例如这个里的工作原理将有助于你使用它，在这种情况下，你可以在你的代码里给它添加真实的数据值)。

你也许知道刚才我描述的在一个数组上使用for循环如何做。它可能看起来像这样:

var animals = ["cat","dog","fish"];

var lengths = [];

var ;

var count;

var loops = animals.length;

for (count = 0; count < loops; count++){

= animals[count];

lengths.push(.length);

}console.log(lengths); //[3, 3, 4]所有我们需要做的事情是定义少量的变量：一个命名为animals的数组包含了我们需要的字符数据，一个命名为lengths的空数组将来用来包含我们作数组数据输出的长度，和一个叫做的变量，这个变量用来临时存储每一次循环遍历该数组时我们需要作的数组项。我们定义了一个for循环，这个for循环有个内部变量和一个循环变量来初始化我们的for循环。然后我们循环迭代每一个项，直到迭代的数组长度等于animals数组的长度。每一次循环我们都计算迭代项的字符长度，然后把它保存到lengths数组里。

注意：需要讨论的是我们可以把上面的代码写得更简洁些，不需要那个变量,而直接把animals[count]的长度放到lengths数组里，这样就不需要中间的转换过程了。这样做可以帮我们省一点点代码空间，但是它也使得我们的代码有点不易阅读，即使是这个很简单的例子也一样。相同地，为了使代码更而少些直白，我们可能会使用已知的animals数组长度来通过new Array(animals.length)的方式来初始化我们的lengths数组，然后通过索引而不是使用push方法来插入选项数据长度。这取决于你在现实中准备如何去使用这些代码。

这种实现方式没有任何的技术错误。它在任何标准的JaScript引擎里都可以用，并且它能很好的完成工作。一旦你知道怎么使用map()方法了，通过这种方法来实现就显得有些笨拙了。

让我展示给你看使用map()方法是如何实现上面的代码的:

var animals = ["cat","dog","fish"];

var lengths = animals.map(function(animal) {

return animal.length;

});

console.log(lengths); //[3, 3, 4]在这个小例子里,我们首先再次为我们的animal类型的数组创建一个animals变量。然而，其他我们需要声明的变量就是lengths变量了，然后我们直接分配它的值到映射一个匿名内联函数到animals数组的每一个元素上的结果中。

那个匿名函数执行在每一个animal 上的的作，然后返回该animal的字符长度。这样做的结果是，lengths变成了具有与原始animals数组有相同长度的数组，并且该数组包含了每一个字符的长度。

这种方式需要注意的一些事情。首先，它比最初编写的代码更简洁。其次，我们仅需要申明更少的变量。更少的变量意味着在全局命名空间里杂音更少，并且如果相同代码的其他部分使用了相同的变量名就会减少碰撞的机会。，我们的变量不可能从头到脚都会改变它们的值。随着你深入函数式编程，你将会欣赏使用常量和不变的变量的优雅的能力，现在开始使用并不算早。

这种实现方式的另一个优点是，我们可以通过在整个代码编写过程中通过将代码放进一个个命名的函数里而简化代码而有机会提升自己编写代码的多功能性。匿名的内联函数看着有些乱，并且使得重复使用代码更困难。我们可以定义一个命名为getLength()的函数，并且像下面的方式来使用:

var animals = ["cat","dog","fish"];

function getLength(word) {

return word.length;

}console.log(animals.map(getLength)); //[3, 3, 4]看看上面的代码看上去多简洁啊?只是把你处理数据的部分映射一下就使你的代码达到一个全新的功能水平。

什么是函子?有趣的一点是，通过在数组对象里添加映射，ECMAScript5把基本的数组类型变成了一个完整的函子，这使得函数式编程对我们来说更加的容易。

根据传统的函数编程定义，一个函子需要满足三个条件:

1.它保存着一组值。

2.它实现了一个map函数来作每一个元素。

3.它的map函数返回一个具有同样大小的函子。

这个将会在你下一次的JaScript聚会上被翻来覆去的讨论。

如果你想了解更多关于函子的信息,你可以看看Mattias Petter Johansson录制的关于这方面的视频。

使用Reduce方法Reduce()方法在ECMAScript5里也是新增的，而且它和map()方法很类似，除了不产生其他的函子，reduce()方法产生的一个结果是它可能是任何类型。例如，设想一下，如果你想得到我们animals数组里的所有字符长度都分别作为一个数字然后相加的结果。你也许会像下面这样做:

var animals = ["cat","dog","fish"];

var total = 0;

var ;

= animals[count];

total += .length;

}console.log(total); //10在我们定义我们的初始数组之后，我们为运行总计定义了一个total变量，并把它的初始值设为0。我们也定义一个变量来保存每一次for循环迭代animals数组的迭代值，并且再定义一个count变量作为一个循环计数器，并且用这两个变量来初始化我们的迭代。然后我们运行for循环来迭代animals数组里的所有字符数据，每次迭代都会把迭代的结果保存到变量。最终我们把每一次迭代到的的长度加到我们的total变量里就可以了。

var animals = ["cat","dog","fish"];

var total = animals.reduce(function(sum, word) {

}, 0);

console.log(total);这里发生变化的是，我们定义了一个名为total的新变量，并且把执行animals数组对象的reduce方法的返回值分配给它，在reduce方法里有两个参数：一个匿名内联function方法，和初始化total的值为0。对于数组中的每一个项reduce()方法都会执行，它在数组的那一项上执行这个function函数，并且把它添加到运行总计，然后再进行下一次迭代。这里我们的内联function方法有两个参数：运行总计，和当前程序正在处理的从数组中获取的字符。这个function函数把当前total的值添加到当前word的长度上。

注意的是：我们设置reduce()方法的第二个参数值为0，这样做确定了total变量包含的是一个数值。如果没有第二个参数reduce方法仍然可以执行，但是执行的结果将不是你期望的那样。(你可以试试并且可以看看当运行总计结束后你是否能推测出JaScript所使用的编程逻辑。)

那看上去似乎比它需要做的更有一点复杂，因为当调用reduce()方法时需要在一个内联function里综合的定义。我们再那么，但是首先让我们定义一个命名的function函数，而不再使用匿名内联函数:

var animals = ["cat","dog","fish"];

var addLength = function(sum, word) {

};

var total = animals.reduce(addLength, 0);

console.log(total);这个代码稍微有点长，但是代码有点长并不总是坏事。这样写你应该看到它使代码更加清晰些，只是在reduce()方法里发生了一点变化。

该程序里reduce()方法有两个参数：一个function函数，用来调用数组里的每一个元素，和一个为total变量设置的运行总计初始值。在这个代码示例中，我们放入了一个名为addLength的新function和为运行总计变量赋初始值为0。在上一行代码中，我们定义了一个名为addLength的function函数，这个函数也需要两个参数：一个当前和一个要处理的字符串。

结论经常使用map()方法和reduce()方法将会为你的代码更加简洁，更加多功能，更加可维护性提供了选择。同时它们为你使用更多的JaScript功能函数技术铺平了道路。

map()方法和reduce()方法仅是被添加进ECMAScript5中新方法中的两个。从使用它们的今天你将会明白代码质量的提高和开发人员满意度的提升胜过任何在性能上的临时影响。在判断map()方法和reduce()方法是否适合你的应用之前，试着用功能函数技术来开发和度量一下它在你现实世界里的影响，然后再判断是否去用。

JS数组方法

for (var count = 0, loops = animals.length; count < loops; count++){

数组的创建方式

该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不使用。

1.字面量的形式： var arr=[1,2,3];

1.构造函数： var arr1=new Array();//不常用

Array构造函数有一个很大的缺陷，就是不同的参数，会导致它的行为不一致。

1.单个数值作为参数，参数表示数组的元素个数

可以看到，Array作为构造函数，行为很不一致。因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。

push/pop/unshift/shift//增加、删除元素 （数组的方法，所以使用时应调用

数组名.方法名（））

arr. sl/spl//截取元素

arr.sl(); 原数组不发生改变

无参数时，返回原数组，相当于数组的。

一个参数时，从参数作为下标的元素截取，至数组结束。

二个参数时，从个参数作为下标（索引）的元素开始截取，到第二个参数作为下标的元素结束，但不包括第二个参数作为下标的函数。 （起始元素包含，结尾元素不包含）

多个参数时，前两个参数起效，后边的参数无效。

arr.spl(); 原数组改变

无参数时，返回空数组。

一个参数时，从参数作为下标的元素截取，至数组结束。

二个参数时，从个参数作为下标（索引）的元素开始截取，即表示截取的起始位置，第二个参数表示截取的元素个数。

多个参数时，前两个参数起效，后边的参数从原数组的截取起始位置开始填充，填充到原数组。

rrse/sort//改变元素位置

arr.rrse(); //数组翻转(元素位置颠倒)

arr.sort(); 从小到大排序，但遵循的是字符串的按位比较规则，所以排序结果容易出现异常。

join();//不改变原数组

join() 以指定参数作为连接符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。

concat();//拼接数组 不改变原数组

ES5新增数组作方法

indexOf () 返回元素在数组中对应的索引值，找不到的话，返回-1，用以测试元素是否存在于数组中

forEach(function(,index)) 遍历数组,没有返回值

map(function(,index)) 遍历数组,存在返回值

filter(function()) {return >2} 返回大于2的元素

some 返回布尔值，条件部分成立|| arr.some(function(){return >2} )

ry 返回布尔值，条件全部成立&& arr.ry(function(){return >2} )

reduce (对数组中的所有元素调用指定的回调函数。该回调函数的返回值为累积结果，并且此返回值在下一次调用该回调函数时作为参数提供。)arr.reduce(function(a,b){return a+b;});

toString()和toLocaleString()

功能：将数组的每个元素转化为字符串，并且输出用逗号分隔的字符串列表。功能类似join()；

参数：无

输出：字符串

indexOf()和lastIndexOf()

功能：搜索整个数组中具有给定值的元素，返回找到的个元素的索引或者如果没有找到就返回-1；lastIndexOf为反向搜索。

参数：元素的值，起点索引（可选）

输出：索引值或-1

Array.from()

功能：将两类对象转为真正的数组：类似数组的对象和可遍历的对象

参数：待转换的对象，第二个参数可选，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。

输出：数组

Array.of()

功能：将一组值，转换为数组。

参数：数组元素

输出：数组

copyWithin()

功能：在当前数组内部，将指定位置的成员到其他位置，返回变化后的数组。

参数：索引（从该位置开始替换数据）；索引（从该位置开始读取数据，默认为0，负值表示倒数）；索引（到该位置前停止读取，默认为索引）

输出：返回当前替换后的数组。

注意：改变了当前数组

let newArr = […new Set(arr)]; // [1, 2, 4, null, “3”, “abc”, 3, 5]find()和findIndex()

功能：找到个符合条件的数组成员。

参数：回调函数，所有数组成员依次执行该函数，直到找到个返回值为true的成员。回调函数可以接受三个参数，依次为值，位置，原数组。

输出：find()返回找到的成员；findIndex()返回成员的位置。

fill()

功能：使用给定的值，填充一个数组。

参数：个参数为待填充的值，第二和第三参数可选，分别表示填充的起始和结束位置(不包括)。

输出：填充后的数组

功能：用于遍历数组，可以用for…of循环进行遍历。区别是keys()是对键名的遍历、values是对键值的遍历、entries()是对键值对的遍历。

参数：无

输出：遍历器对象

includes()

功能：表示某个数组是否包含给定的值

参数：个参数必选（待检查的给定值），第二个参数可选，表示搜索的起始位置，默认为0，负数表示倒数的位置。

输出：一个布尔值。

注意：和indexOf的区别，indexOf进行了运算符的强比对，会导致对NaN误判。

Ja 中Map与数组的比较

这种实现方式也没有任何的技术错误。我们从定义一个数组开始，然后得到一个结果值就结束了。但是如果我们使用了reduce()方法，我们可以使上面的代码更加简单明了:

1、数组特点高效、保存基本类型，带array的底层由数组实7-27、div垂直水平居中，grid知不知道怎么用；现，还有一部分由链表或者树

2、数组大小固定（巨大缺点，内存中一定连续），各种实现吧！

3、数组只能19-15、comd的实现原理，怎么实现一个comd；放一种类型，不考虑泛型可以存很多类型。

4、放原始类型其实是通过装箱拆箱来实现的，说白了以前原生类型只能用数组，现在也可以了。因为这个改进，所以现在基本上除了性能外，均使用。

2022前端开发面试记录（深圳篇）

2022年来到深圳，感觉到了与之前所在城市的异，心里多少有点落。虽然时机不太对吧，但是相信一切都会好起来的，给自己加油呀！

整理了一些面试被问到的问题，虽然很多是无效面试，但是我也强行问了面试官，从他们的回答中猜测了一下他们关注的面试点，所以也算是有has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。点收获吧，只是浪费了很多和路费，哭唧唧。

——1、区块链——

1-1、vue生命周期；

1-2、vuex属性；

1-3、用户开始登录到登录成功都发生了什么；

1-4、git常用的命令；

——2、金融：vue——

笔试：

2-1、深浅拷贝的区别，为什么会出现深浅拷贝，浅拷贝的优势；

2-2、强制中断 foreach 遍历；

2-3、多处组件复用；

2-4、你对前端是什么概念，前端在整个软件生态内是什么角色；

2-5、Vue2 中数据变化但视图没有发生同步更新，描述一下出现的场景，解决方式，以及该问题发生的可能原因；

2-6、nextTick 是如何确保开发者能够获取到的 DOM 状态的；

2-7、如何使用 mixins，有何利弊；

2-8、使用 Hooks 模式开发时，useMemo，useCallback 常用来作为优化的手段。描述一下它们各自的适用场景，以及背后的原理实现?；

2-9、前端从 Jquery 时代演变至如今的三大框架，这种演变的根源是什么，jquery 解决了什么问题，如今的三大框架又是为了解决什么问题出现的？

视频面试：

2-10、js遍历树形结构，每个都有一个ID，只能遍历一次；

2-11、组件封装的意义；

——3、知识产权：vue2、vue3、ts、react——

3-1、说一说面向对象的理解，包括继承、封装、多态等；

3-2、说一说promise；

3-3、webpack优化；

3-4、vuex使用场景；

3-5、描述一下对vue响应式原理的理解；

3-6、vue生命周期；

3-7、父子组件钩子函数执行顺序；

3-8、v-if和v-show；

3-9、js数据类型；

3-10、实现深拷贝；

——4、物流——

4-1、vue生命周期；

4-2、生命周期-修改元素样式在生命周期的哪个阶段；

4-3、生命周期-修改数据在哪个阶段；

4-4、生命周期-destroy里面会做哪些作；

4-5、怎么修改title的内4-14、call,apply,bind是干什么的；容；

4-6、父子组件传参的具体写法；

4-7、v-model的多种写法；

4-8、js数据类型；

4-9、判断数组的方法；

4-10、实现左边固定右边自适应的布局；

4-11、实现div垂直水平居中；

4-12、flex:1；

4-13、flex详解；

——5、新兴产业——

5-1、封装路由，怎么拦截路由；

5-2、浏览器缓存有哪些，又问localStorage和sessionStrorage的区别和应用场景；

5-3、浏览器强缓存和协商缓存；

5-4、webpack打包机制，构建过程和配置；

5-5、性能优化方法；

5-6、前端的业务和后端的API是怎么做到数据实时请求的（问的其实是前端对后端API接口的封装和管理）；

5-7、comd和watch；

5-8、说了几个关于大屏的应用场景，有没有做过，怎么做的；

——6、某水果：vue2、vue3、ts、各种前沿技术都用——

6-1、怎么封装一个组件库/工具类库，比如vue封装过什么复杂组件，jquery封装过什么类库；

6-2、get和t的区别，传参格式等；

6-3、promise怎么用的；

6-4、原型链，test()的原型链；

6-5、websocket；

6-6、es6中的generator；

6-7、es6中的set和map有啥区别，set为什么能去重；

6-8、项目难点；

——7、医疗健康：vue——

7-1、vue自定义指令配置；

7-2、webpack的理解；

7-3、对node的了解，用过express吗；

7-4、项目中的拖拽是怎么做的；

7-5、websocket和socket的区别；

7-6、听过mqtt吗，因为没听过所以解释了一下activemq的用法；

7-8、地图实现多个点连成一条线会怎么做；

7-9、地图实现一条曲线；

7-10、内网下git怎么用的；

7-11、openlayers渲染机制；

7-12、父子组件通信方法；

7-13、router中实现拦截；

7-14、对象合并的方法；

7-15、父子组件的生命周期执行顺序，渲染阶段为什么会先执行父组件再执行子组件；

7-16、vue生命周期；

7-17、npm run dev, run build可以在项目中的什么位置找到；

7-19、mixins用过吗；

7-20、判断引用类型的方法；

7-21、js数据类型；

7-22、判断基本数据类型的方法；

7-23、for in和for of的用法和区别，两者遍历的是索引还是属性值，两者都可以遍历对象吗；

7-24、foreach和map的区别，两者会不会改变原数组；

7-25、主要用什么技术栈；

7-26、行内元素和块级元素的区别，分别都有哪些，行块级元素有哪些；

7-28、spl和sl；

——8、智慧园区：vue2、vue3、ts、uniapp——

8-1、flex了解吗，flex布局方向，flex:1 0的页面效果是怎样的；

8-2、做过移动端吗，了解uniapp吗；

8-3、keep-alive；问了一个没听明白的，可能和keep-alive有关系；

8-4、vuex中的action；不用vuex，怎么代替vuex；

8-5、promise.all和promise.on；

8-6、防止表单重复提交；

8-7、async，await的使用；

8-8、vue3和ts的了解；

8-9、防抖怎么控制时间；

8-10、vue中的data为什么要设计成一个函数；

——9、智慧工地：vue、uniapp、小程序——

9-1、Vuex是干什么的；

9-2、openlayers怎么用的；

9-3、性能优化；

9-4、spa首屏加载优化；

9-5、bundler.js太大，打包怎么优化；

9-6、加密方式了解多少，比如md5,base64等，一大堆没听过的；

9-7、冒泡排序的实现原理；

9-8、js设计模式；

——10、某快递公司外包——

10-1、一棵树的数据，给的是列表格式，转换成树形结构；

10-2、项目相关的，聊天怎么做的，拖拽怎么做的，拖拽的数据怎么渲染的，拖拽重叠怎么处理的；

10-3、js设计模式；

——11、三维：vue、cesium——

11-1、一棵树的数据，给的是列表格式，转换成树形结构；

11-2、openlayers怎么用的，发布过wms吗，发布流程是怎样的；

11-3、openlayers转换经纬度的方法名是什么；

11-4、cesium常用的函数；

11-5、vue数据双向绑定原理；

11-6、Vue中data属性如果改变一个数组的下标，会不会马上发生变化，不变化可以怎么解决

11-7、数组常如果你如今还没有使用map()和reduce()方法，那么现在是时候开始使用了。如今绝大部分的JaScript开发平台都与生俱来的支持ECMAScript5。使用Map方法和reduce方法可以使你的代码更加简洁和更容易阅读和更容易维护，而且把你带到朝向更简洁的功能开发的路上。用方法有哪些；

11-8、 map和filter的区别；

11-9、es6常用的方法；

11-10、父子组件通信，兄弟组件通信；

11-11、new具体进行了什么作；

——12、医疗：vue、angular——

12-1、js渲染机制和运行机制；

12-2、vue数据绑定原理；

——13、建设行业：vue、uniapp——

笔试：

13-1、||与&运算符；

13-4、实现font-size:12；

13-5、接口路径，给一个地址 ，根据请求接口路径写出完整路径，’/ get.do ’，’ get.do ’，’../ get.do ’；

13-6、微信小程序流程和主要文件；

13-7、获取参数及内容；

13-8、$(function(){}) / (function(){}) / (function(){})()的区别；

面试：

13-10、项目难点；

13-11、git工作流；

13-12、jquery项目会不会用webpack打包；

13-13、webpack优化；

13-14、web优化；

——14、文化：uniapp——

14-1、ssr渲染；

14-2、ajax和axios的区别；

14-3、cookie和session的区别；

14-4、vue生命周期；

14-5、数据请求写在哪个生命周期中；

14-6、router的history模式和hash模式；

14-7、工作中的开发流程；

14-8、uniapp的开发流程和坑；

14-9、uniapp滑动问题，下滑切换视频不生效，一般是什么原因；

14-10、uniapp加载速度慢，点击加载速度太慢，一般是什么原因；

——15、企业平台某外包：vue，node，性能优化——

15-1、说一说websocket；

15-2、vue数据双向绑定原理；

15-3、项目难点；

15-4、对mvvm、mvc、mvp等的理解；

15-5、vue的常见指令；

15-6、comd和watch；

15-7、class和style怎么绑定；

15-8、ajax和axios的区别；

15-9、axios，axios的t请求；

15-10、对前端渲染，服务端渲染的理解；

——16、智慧城市：vue，node，three.js——

16-1、vue生命周期；

16-2、vue组件通信方法；

16-3、js的继承；

16-4、oracle、mysql、sqllite的区别；

16-5、oracle连表查询；

16-6、openlayers项目场景；

16-7、cesium项目场景；

——17、租房：jquery+layui，vue2——

17-1、笔试：

17-2、foo打印题；

17-3、this打印题；

17-4、变量提升打印题；

17-5、let arr=[1,2,[5,8,[9,[3,5,]7,]20,37]] 把数组扁平化成一个数组，并进行去重升序;

17-6、let a=[1,2,3,4,5,6,7]; let b=[4,5,6]; 求b在a中次出现的位置；

17-7、面试：主要问项目

——18、跑腿：vue2，vue3+ts——

18-1、对html5语义化的理解；

18-2、css实现一个三角形；

18-3、css怎么实现0.5px的线，为什么有这种需求，涉及到兼容性问题；

18-4、怎么解决变量提升的问题；

18-5、es6新增了哪些定义变量的方式；

18-6、const定义的变量可以被修改吗；

18-7、map和filter的区别，会改变原数组吗；

18-8、es6去重的方法；

18-9、谈一谈对promise的理解；

18-11、对vue响应式原理的理解，核心是什么；

18-12、对vue生命周期每个阶段的理解；

18-13、为什么要用key，key有什么作用；

18-14、v-if和v-show；

18-15、Vue中data为什么是一个函数；

18-16、vue各场景下的传值方式有哪些，比如父子组件，兄弟组件，祖孙组件；

18-17、对vuex的理解和使用场景；

18-18、vue常见修饰符；

18-19、Vue3用过吗(因为没用过，所以就只针对响应式原理说了一下vue3和vue2的区别)；

——19、实业：jquery，vue2，vue3——

笔试：需要解释

19-1、html5新标签，css3新特性；

19-2、js+css3实现某元素以50px每秒的速度左移100px；

19-3、css实现左中右布局，不改变文档流；

19-4、js兼容性有哪些，以及常见的解决方案；

19-5、描述一下循环机制ntloop，ntloop解决了什么问题；

19-6、给了一个题，大概是后端返回的接口数据，data的格式有很多，比如null，对象，数组，字符串等，怎么处理这种问题；

19-7、前端性能优化方法，首屏页面怎么优化；

19-8、用js写一个方法实现数据去重并排序(用es5和es6+实现)；

19-9、给定一个数组，把数组中为0的往后排，其他值按顺序排序; （示例：[1,0,4,0,5,3]转换结果为[1,3,4,5,0,0]）

19-10、用0，1，2代表红黄蓝三种颜色，实现以下排序，不能用array.sort实现;（示例：[0,1,0,2,0,1,2]转换结果为[0,0,0,1,1,2,2]）

面试：

19-11、flex布局；flex:1对应的属性；

19-13、讲一下闭包；什么情况下才能算是闭包；形成闭包的条件；列了三个题让你判断是不是闭包；

19-14、v-if和v-show是干什么的；应用场景有哪些；给定一对父子组件，默认值是false，另外有一个ajax请求，值发生了以下变化（false true false true true），在v-show和v-if中，父子组件的哪个阶段里会请求ajax；

19-16、css中，transform，margin，ition的都是怎么渲染的，渲染机制是什么；amd，cmd，commonjs了解吗；