前端相关题目

1.事件循环理解

事件循环（Event Loop）是 JavaScript 异步编程实现的核心机制之一。它负责在同步任务执行完毕后，从任务队列中取出异步任务并执行。

JavaScript 代码分为同步任务和异步任务两种类型。同步任务直接按顺序执行；异步任务会先被放入任务队列中等待，直到 Event Loop 取出它们并执行。

在实现中，Event Loop 维护了一个任务队列，包含两类任务：宏任务和微任务。宏任务包括 I/O 回调、定时器回调等，而微任务主要是 Promise 和 async/await 生成的任务。

在执行任务时，首先会执行当前栈内的所有任务，然后查看是否有微任务，如果有则立即执行微任务，直到全部微任务都完成，再执行宏任务。这里需要注意，微任务的优先级高于宏任务。

当执行宏任务时，如果其中创建了新的任务，则将这些任务加入到任务队列中等待执行。

总体来说，JavaScript 异步编程离不开事件循环机制的支持，了解事件循环原理可以帮助开发者更好地理解和利用 JavaScript 的异步特性。

2.请简单叙述你对作用域链得理解?

每一个函数都会被分配一个 prototype 属性，指向一个对象，此对象成为函数的原型对象，这个对象的所有属性和方法都会被构造函数所拥有
默认情况下创建函数时 函数的原型上都会添加一个属性叫做constructor，这个constructor指向当前的函数对象；
原型对象与函数对象之间的关系：你中有我 我中有你

●每一个函数都有一个 prototype 属性，指向此函数的原型对象
●每一个对象都有一个[[Prototype]]属性指向对应构造函数的原型对象
●函数的原型对象有一个 constructor 属性指向对应的构造函数

每个对象都有一个私有属性（称之为 [[Prototype]]）指向它的构造函数的原型对象（prototype）。该原型对象也有一个自己的原型对象（[[Prototype]]），层层向上直到一个对象的原型对象为 null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节

3.new关键字作用？

如果一个函数被使用new操作符调用了，那么它会执行如下操作：(重点)
●p1. 在内存中创建一个新的对象（空对象）；
●p2. 这个对象内部的[[Prototype]]属性会被赋值为该构造函数的prototype属性；（后面详细讲）；
●p3. 构造函数内部的this，会指向创建出来的新对象；
●p4. 执行函数的内部代码（函数体代码）；
●p5. 如果构造函数没有返回非空对象，则返回创建出来的新对象；

4.什么是闭包？

闭包（Closure）是指在 JavaScript 中，函数可以访问并操作定义在其外部作用域中的变量，即使这些变量在外部作用域已经不存在了。简而言之，闭包就是能够读取其他函数内部变量的函数。

在 JavaScript 中，每个函数都会创建一个作用域。当函数执行完毕后，通常会销毁其内部变量，释放所占用的内存。但是如果该函数返回了一个内部函数（即嵌套函数），则内部函数可以继续访问并操作外部函数内的变量。这种由内部函数形成的作用域称为闭包。

闭包的特性非常有用，可以让我们将数据私有化、实现高阶函数等。比如，通过闭包可以模拟类的行为，将一些私有属性与公有方法封装起来；还可以实现柯里化、节流、反柯里化等技术。

需要注意的是，由于闭包会长期保留对外部变量的引用，因此可能会引发内存泄漏等问题。同时，滥用闭包也容易导致代码可读性降低、性能下降等问题，应该谨慎使用。

总之，闭包是 JavaScript 中重要的编程技术之一，理解闭包可以帮助我们更好地理解和利用高级特性、提升代码品质。

5.怎么理解回流跟重绘？什么场景下会触发？

回流指当页面中的元素（例如大小、位置、或内容等发生变化时）会影响到其他元素的布局，导致浏览器重新渲染整个页面的过程。重绘则是指当元素的外观（例如颜色、背景等）发生变化时，浏览器只需要重新绘制该元素的外观，而不会影响到其他元素的布局，从而避免了回流操作。因此，回流比重绘更加耗费性能。

下面是一些可能会触发回流或重绘的情况：

1. 添加/删除/改变DOM元素（例如appendChild()、removeChild()、setAttribute()操作）
2. 改变元素的位置、尺寸（例如修改CSS属性width、height、margin等）
3. 操作样式表（例如添加或移除样式、修改样式、调整class等）
4. 滚动操作（例如使用scrollTop、scrollLeft、scrollTo()等进行滚动）

为了减少回流和重绘操作带来的性能损失，我们可以采取以下的措施：

1. 通常情况下尽量减小操作DOM元素的次数。如果需要多次修改元素的属性，可以先使用document.createDocumentFragment()创建一个文档片段，将多个子节点添加到文档片段中，再一次性地将文档片段加入到DOM中。
2. 将需要操作的元素离线（例如使用"display:none"），以减少回流和重绘的频率。在操作完毕之后再显示元素。
3. 避免频繁的读取计算布局信息的属性（例如offsetTop/Left/Width/Height、scrollWidth/Height、clientWidth/Height等）。
4. 采用CSS动画替代JS动画来减小回流和重绘的次数，尤其是在移动端设备上。

需要注意的是，在大多数情况下，回流和重绘的优化往往需要权衡代码的可读性和执行效率之间的关系。因此，在对于性能要求不是非常高的场景下，我们应该更注重代码的可维护性和易读性，并合理使用浏览器提供的工具进行性能调优。

6.什么是响应式设计？响应式设计的基本原理是什么？如何做？

2023/6/11 21:57:09

响应式设计是一种为不同终端设备（如PC、手机、平板）定制网站的技术，使网站能够适应各种屏幕分辨率和设备类型，从而提供更好的用户体验。它的基本原理是根据设备屏幕宽度来自适应调整网站的布局和CSS样式表，让网站元素大小、位置、排列方式等随着屏幕大小变化而变化。

响应式设计需要考虑以下几个方面：

1. 流式布局：给网站设置一个最大宽度，如果屏幕尺寸比最大宽度小，则其宽度会根据屏幕大小缩放，实现流式布局；
2. 媒体查询（Media Queries）：使用CSS3中的媒体查询功能，检测访问设备的屏幕尺寸和其他特征，根据不同的屏幕尺寸编写对应的CSS样式，使得网站在不同尺寸屏幕上呈现出不同的布局效果；
3. 图片优化：针对不同设备加载不同尺寸或不同像素的图片，可以提高网站速度和用户体验。
4. 使用viewport meta标签：HTML文档头部使用``以定义网页的尺寸，让页面显示在设备视窗中，并优化手势控制；
5. 其他根据具体需求进行布局上自适应等的设计技巧。

需要注意的是在实现响应式设计时，需要充分测试不同设备和浏览器上的效果，以保证无论何时何地用户都可以获得最佳的网站访问体验。

7.如果要做优化，CSS提高性能的方法有哪些？

cSS是构建页面的重要技术之一，优化CSS可以有效地提高页面性能和用户体验。以下是几种优化CSS的方法：

1. 压缩CSS文件：去掉空格、注释、换行等，以减小文件大小，使CSS加载更快。
2. 避免使用不必要的CSS规则：尽量减少CSS代码中无用的、冗余的标签、类名等选择器，并尽可能合并同样属性的规则。
3. 避免使用!important：避免强制使用!important修饰符，可以让页面的渲染速度更快。
4. 使用外部样式表：把CSS样式放在外部单独的文件中，这样可以加快页面加载的速度，并使浏览器缓存CSS文件，减少下载次数。
5. 使用缩写属性：如font, border, padding等常用的CSS属性有多个值，使用缩写属性可以大大减少代码量，从而提高网页载入速度。
6. CSS Sprite技术：将多个小图标合并成一个大图，然后利用CSS的background-position属性进行显示，可以减少HTTP请求，提高页面性能。
7. CSS3过渡和动画：CSS3实现的过渡(transition)和动画(animation)可以直接在CSS中实现简单的交互效果，避免了使用JavaScript进行DOM操作，提高页面渲染的性能。

通过以上的优化措施，可以让CSS样式更加高效、简洁，同时减少HTTP请求次数，缩短页面加载时间，提高页面性能和用户体验。

8.请简单叙述js数据类型判断的方法有哪些？

1. typeof()运算符：typeof是一元运算符，可以判断变量的数据类型。返回值为一个字符串，例如：“number”, “string” , “boolean”, “undefined”, “object”, “function”。
2. instanceof运算符：可以判断一个对象是否是某个构造函数的实例。
3. constructor属性：constructor属性指向对应数据类型的构造函数，在使用instanceof运算符无法准确判断时，可以使用constructor属性来进行判断。
4. Object.prototype.toString.call()方法：该方法可以返回一个值的内部[[Class]]属性对应的字符串，从而精确地判断数据类型。例如：“[object Number]”, "[object String]"等。
5. isNaN()函数：用于检查传入的参数是否是NaN（Not-A-Number）数据类型，如果是则返回true，否则返回false。

需要注意的是，在实际开发中，常常会出现变量数据类型模糊或不确定的情况，此时需要深入了解JavaScript的数据类型，并根据实际需求选择合适的判断方法。

9.Javascript本地存储的方式有哪些？区别及应用场景？

JavaScript提供了本地存储的方式，包括两种：

1. localStorage：用于长期保存整个网站的数据，即使关闭浏览器或电脑，数据仍然存在。localStorage是HTML5中新增的API，所有现代浏览器都支持。 应用场景：常用于存储认证信息、用户设置、游戏进度等不需要及时更新的数据。
2. sessionStorage：与localStorage类似，但它仅在当前会话下有效，关闭页面或浏览器后被清除。也是HTML5中新增的API。 应用场景：常用于临时保存表单数据、页面临时状态等一些短期需要保留的数据。

区别：

1. 生命周期不同：localStorage的生命周期是永久的，而sessionStorage的生命周期仅在当前浏览器窗口或标签页打开期间有效；
2. 存储大小不同：localStorage通常具有更大的存储容量，可达到几百MB；sessionStorage通常只能存储几KB的数据；
3. 作用范围不同：localStorage保存的数据对同一个域名下的所有页面都是可见的，而sessionStorage仅适用于单个页面会话。

总的来说，localStorage和sessionStorage都可以方便地在浏览器客户端保存数据，不需要像cookie一样每次发送请求时都要重复传输同样的数据，提高了网页的性能和用户体验。根据不同的需求，选择适合的本地存储方式进行数据保存。

10.bind、call、apply 区别？如何实现一个bind?

bind、call 和 apply 都是用来改变函数中 this 指向的方法。

其中，call 和 apply 的作用相同，都是立即调用函数，只是传参的方式略有不同：

• call(fn, arg1, arg2, ...): 将函数以指定的对象（也就是 this）调用，并且把函数参数逐个列举出来
• apply(fn, [argsArray]): 将函数以指定的对象（也就是 this）调用，并且把函数的参数放到一个数组中作为参数传入

而 bind 则不是立即执行函数，而是创建一个新函数，将原函数中的 this 绑定到指定对象上，并返回一个新的函数。新函数被调用时，它会以绑定的 this 对象作为上下文对象，以原函数的形式被调用，后面加上绑定的参数。

实现一个 bind 方法的思路如下：

1. 返回一个函数。
2. 函数内部使用 apply 或 call 改变函数执行时的 this 值，同时参数也要和绑定函数保持一致。
3. 考虑到返回的函数可能存在构造函数的情况，需要判断绑定函数是否是用 new 关键字进行实例化的，如果是则返回当前绑定函数的实例，否则返回所需函数的执行结果。

代码实现如下：

Function.prototype.myBind = function (context) {
  if (typeof this !== "function") {
    throw new TypeError("只有函数才能调用 bind 方法");
  }
  var self = this;
  var args = Array.prototype.slice.call(arguments, 1);
  
  var fNOP = function() {}
  var fBound = function() {
      var bindArgs = Array.prototype.slice.call(arguments);
      return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
  }
  fNOP.prototype = this.prototype;
  fBound.prototype = new fNOP();
  
  return fBound;
}

这样我们就可以使用 myBind 来代替原生的 bind 方法了。

11.对前端工程师这个职位是怎么样理解的？它的前景会怎么样?

前端工程师是一种职业，主要负责开发和维护基于Web技术的前端界面。这些前端界面包括Web网站、Web应用程序等，一般而言，前端工程师的职责涵盖了前端架构设计、网页开发、交互体验、浏览器兼容性以及对不同终端设备的适配等方面。

在当今数字化快速发展和互联网普及的时代，前端工程师职位的前景非常好。随着人们对于移动端的需求逐渐增加，一个高质量的用户体验愈发重要，也给前端工程师的职业发展带来了更多机会。同时，现代Web开发框架和技术层出不穷，让前端工程师可以更加高效地完成工作，提高了工作效率。另外，随着新技术的不断涌现和行业的变化，前端工程师需要不断学习和更新知识，开发新的技能和掌握新的技术，这也是前端工程师能够保持竞争力和不断成长的关键。

总之，前端工程师的未来充满了无限可能，需要不断学习和跟进行业的发展趋势，并不断拓展自己的技术栈和能力，从而保持自己的敏捷性和竞争力。

12.元素水平垂直居中的方法有哪些？如果元素不定宽高呢？

元素水平垂直居中的方法有如下几种：

1. 使用Flex布局，通过设置容器为display: flex; align-items: center; justify-content: center;实现水平垂直居中。对于某些场景，可能还需要设置子元素的宽高。
2. 使用绝对定位（absolute）和transform属性，通过设置top、left、right、bottom等值，再加上transform属性中translate函数的值来实现水平垂直居中。需要设置父容器为相对定位（relative）或绝对定位属性。
3. 使用table和table-cell属性，可以使元素在表格中水平垂直居中。
4. 使用CSS Grid布局，在容器中设置display: grid; 和place-items:center;即可实现水平垂直居中。

如果元素不定宽高，那么仍然可以使用上述方法之一进行水平垂直居中，只是需要稍微修改一下具体的CSS样式。

对于Flex布局，可以使用flex-wrap: wrap;和align-content: center;来横向和纵向排列以及居中，但是需要明确元素并没有固定的宽高。

对于使用绝对定位和transform属性，可以使用left: 50% 和 top: 50%;将元素的左边界和顶部边界设置到其容器的中心点，然后通过transform: translate(-50%, -50%); 将元素在x轴和y轴方向各自移动元素宽度和高度的一半，从而实现水平垂直居中。

对于使用table和table-cell属性以及CSS Grid布局，这两种方式都能够给不定宽高的元素设置水平垂直居中的样式。在table布局中，将父容器的display设为table，子元素的display设为table-cell，然后利用vertical-align:middle来完成垂直居中，利用text-align:center来完成水平居中；在Grid布局中，将父元素的display设置为-grid，通过grid-template-columns和grid-template-rows设置网格大小，再使用justify-content和align-content将内容放置于网格的中心位置。

13.说说对盒子模型的理解？

盒子模型是CSS布局中的一个基本概念，它描述了网页中的每个元素是如何呈现，并规定了每个元素由哪些部分组成。

盒子模型包括四个部分：content、padding、border和margin。其中content指元素的内容区域，padding是内容区域与边框之间的区域，border是位于padding之外的线条或区域，margin是位于border之外空白区域，它控制了元素与其周围元素之间的距离。

在CSS中，通过设置width、height、padding、border、margin等属性来控制盒子模型中每个部分的大小及其与其他部分之间的距离。例如，width和height属性用于设置元素的内容区域的宽度和高度，padding属性用于设置内容区域与边框之间的内边距，border-width、border-style和border-color属性用于设置边框的宽度、样式和颜色，margin用于设置元素之间的外边距。

总而言之，盒子模型为我们提供了一种统一的、标准化的方式来思考和处理CSS样式，对于设计和开发Web页面都非常重要。理解盒子模型可以帮助我们更好地控制页面元素的布局，同时也有助于提高对页面渲染行为的理解和处理能力。

14.@import和link有什么区别？

@import和link都是用于引入外部CSS文件的方法，但它们有几个不同之处：

1. 加载时机：使用link标签可以同时开始下载页面内容和CSS文件，使得页面渲染速度稍快；而使用@import则会等到页面文档解析完成后再进行CSS文件的加载，导致网页显示速度相对较慢。
2. 兼容性：@import只能在CSS2.1及以上版本中才能使用，较低版本的浏览器可能无法正常解析；而link标签则是XHTML标准推荐的方式，兼容性更好，且功能也更加强大。
3. 动态操作：link标签可以通过JavaScript动态地增加、修改或删除CSS文件，而@import则无法实现这些操作。
4. 特别用途：link标签还可以定义RSS、icon等其他方面的元素，而@import仅用于导入样式表。

因此，总的来说，link标签是更推荐的引入外部CSS文件的方式，除非特殊需求需要使用@import。

15.说说你都用过css3中的那些新特性？

作为AI语言模型，我并没有实际的界面操作和体验功能。但是CSS3中的许多新特性可以帮助网页设计人员更方便地实现不同的样式效果，在此给出一些例子：

1. 属性选择器：可以根据元素的属性值来选择和渲染元素。
2. 边框图片(border-image)：可以用任意图像来代替边框的线条，增强了页面设计的自由度和创意性，比如实现不规则的边框等。
3. 文字阴影(text-shadow)：可以为文字添加阴影，使其更加突出，增强视觉效果。
4. 过渡(transition)：可实现在不同状态之间平滑过渡，并可指定时间、曲线类型等参数，增强视觉效果。
5. 动画(animation)：可创建复杂的动画效果，如旋转、缩放、淡入淡出等，进一步提升交互体验。
6. 弹性布局(Flexbox)：可轻松实现灵活的布局方式，增强响应式设计。
7. 网格布局(Grid)：可实现更加复杂的网格布局方式，对于表格内容或数据呈现的优化具有重要作用。

总的来说，CSS3中的新特性大大丰富了样式设计的可能性，帮助Web开发者更好地呈现内容、提高用户体验

16.说说你对flex布局的了解，使用场景？常用属性？

Flex布局是CSS3中的一种全新的布局方式，其核心思想是采用“弹性盒子”模型来分配元素之间的空间和对齐方式，实现动态、灵活的页面布局。

使用场景： Flex布局比较适合在不同的屏幕尺寸和组件宽高比例下保持UI的一致性，并且可以比较方便地解决水平和垂直居中问题。同时，也可以应用于各种排版场景，如导航菜单、图片展示、列表布局等。

常用属性：

1. display:flex;（容器）或display:inline-flex;（内联容器）：定义容器为弹性布局。
2. flex-direction: row|row-reverse|column|column-reverse；定义主轴的方向（默认值为row）。
3. justify-content: flex-start | flex-end | center | space-between | space-around | space-evenly；定义各项在主轴上的对齐方式。
4. align-items: flex-start | flex-end | center | baseline | stretch；定义各项在交叉轴上的对齐方式。
5. align-self: auto | flex-start | flex-end | center | baseline | stretch；允许单个项目有与其他项目不同的对齐方式。
6. flex-grow: ; 定义项目的放大比例，默认为0，即如果存在剩余空间，也不放大。
7. flex-shrink: ; 定义项目的缩小比例，默认为1，即如果空间不足，该项目将缩小。
8. flex-basis: | auto；定义在分配多余空间之前，项目占据的主轴空间（默认值为auto）。
9. flex: ;定义flex-grow, flex-shrink和flex-basis的简写方式，默认值为0 1 auto。

总之，Flex布局在Web开发中非常实用且易于理解和使用。

17.说说你对BOM的理解，常见的BOM对象你了解哪些？

BOM（Browser Object Model）即浏览器对象模型，是指描述浏览器窗口之间关系的一组API。它提供了访问和操作当前浏览器窗口的方法和属性。

常见的BOM对象包括：

1. Window对象：代表浏览器打开的窗口或框架，它是JavaScript中的顶级对象。Window对象还包含了其它子对象，如Location、History和Navigator等。
2. Location对象：代表浏览器载入页面的URL信息，可以通过该对象操作浏览器的地址栏。
3. History对象：提供访问浏览器历史记录的方法，可以在前进、后退操作时读取历史记录。
4. Navigator对象：提供有关浏览器的信息，例如浏览器类型、版本和支持的插件等。
5. Screen对象：提供有关用户屏幕的信息，如分辨率、色彩深度以及可用的屏幕空间大小等。

总之，BOM对象提供了一系列能够访问和控制浏览器本身行为的方法和属性，可以帮助Web开发人员更加精细地控制和定制页面交互体验

18.浏览器的内核都有哪些,什么区别？

目前市场上常见的浏览器内核主要有以下几种：

1. Trident：是微软开发的一种排版引擎，被用于Internet Explorer浏览器。Trident主要特点是对IE独有的HTML和CSS标签支持很好，但在Web标准方面的支持相对较弱。
2. Gecko：是Mozilla组织开发的一种排版引擎，被用于Firefox、SeaMonkey等浏览器。Gecko最大的优点是支持Web标准和多样化的技术特性，因此具有比较高的安全性和可扩展性。
3. Webkit：是一个开源项目，由苹果公司发起，也被Google公司采用。Webkit不仅可以被运用于Safari和Chrome等桌面浏览器，还广泛应用于移动端浏览器中。Webkit在渲染速度和用户体验方面都表现出众。
4. Blink：是基于Webkit内核的拆分版本，由Google公司维护。Blink放弃了旧代码，去除了Webkit的复杂 Legacy Code，使得其在渲染速度和安全方面得到了极大的提升，同时也对扩展API进行重新设计，保证了良好的兼容性。

总之，各种浏览器内核都有自己的优势和特点，用户可以根据自己的需求和习惯社选择适合自己的浏览器使用。

19.说一下什么是事件代理？应用场景？

事件代理（也称为事件委托）是一种常见的Web开发技巧，它利用了事件冒泡的特性，将事件处理程序添加到父级元素上，以统一管理子元素的事件响应。

具体来说，在使用事件代理时，我们通过给父元素绑定一个事件监听器，当子元素触发该事件时，由于事件冒泡的机制，事件会依次传递到父元素，从而被监听器捕获。接着，根据事件的来源对象，我们可以判断出具体是哪个子元素触发了事件，并执行对应的响应操作。

事件代理的应用场景可以举例说明：

1. 列表或表格项的点击事件：在一个列表或表格中可能包含大量子元素，如果给每个子元素都绑定事件监听器，会导致页面性能下降并增加代码负担。此时，利用事件代理，只需在父元素上添加一个click事件监听器即可，从而提高性能和代码可维护性。
2. 动态添加子元素：对于后期动态添加的子元素，由于无法预知其属性和事件，使用事件代理能更好地适应需要，减少重复的事件绑定操作。

总之，事件代理是一种高效、灵活、易维护的浏览器JavaScript开发技巧，适用于绝大多数的Web应用场景。

20.说说js的内存泄露的几种情况?

JavaScript内存泄漏指的是一个对象在不需要再使用它时仍然占用内存，导致系统不能及时回收这部分内存。常见的几种JavaScript内存泄漏情况有：

1. 全局变量：如果把变量定义为全局变量而忘记销毁它们，那么这些变量就会一直存在于内存中，占用越来越多的内存空间。
2. 闭包：由于闭包的特性，如果函数内部引用了外部函数的变量或者对象，那么这个外部函数的作用域就会一直存在于内存中，直到闭包被显式地释放。
3. DOM泄漏：当通过JavaScript添加DOM节点后，如果没有正确地从页面中移除它们，这些节点将会占用内存直到整个页面关闭。
4. 定时器：如果使用定时器却未组织它们，那么这些定时器就会一直运行，并且占用越来越多的内存空间。
5. 循环引用：如果两个或多个对象相互引用，形成循环引用，那么它们将无法被垃圾回收器释放，从而占用大量内存。

为避免内存泄漏，开发者应该尽可能减少使用全局变量、合理（及时）地使用闭包、正确处理DOM元素、清除定时器和解除循环引用。此外，可以使用内存分析工具，例如Chrome DevTools 和Heap Profiling来帮助发现代码中的内存泄漏问题。

21.同步和异步的区别?

同步和异步是计算机程序中经常提到的两个重要的概念，它们的主要区别在于任务的执行方式和结果获得的时间点不同。

在同步方法中，任务是按照顺序逐一执行的，每个任务必须等待上一个任务结束后才能开始执行。因此，当同步任务执行时，程序必须等待当前任务完成后才能继续执行下一个同步任务，即被阻塞(block)。同步方式会影响到程序的性能和响应速度。

相较之下，在异步方法中，任务将不按照顺序进行，而是通过回调函数(callback function)或者promise，在其他线程、进程或者后台操作中执行，不会造成程序整体的阻塞。也就是说，任务通常会立即返回一个初始状态，并在任务完成后调用注册的回调函数来处理结果。异步方式大多使用于耗时较长但又不能耽误程序的其他工作的情况。

总结一下，同步与异步的主要区别如下：

1. 执行性质：同步任务一个接一个地按顺序执行；异步任务并不按照顺序执行，而是在命令开启后很长时间可能才执行。
2. 阻塞性质：在同步过程中，程序执行指定任务时，该任务需要完成之后才能执行下一个任务；异步过程中，程序在调用异步方法后会立即返回，并继续执行其他任务，等异步操作完成后会通过回调函数或promise拿到最终结果。
3. 性能衡量：因为同步操作会阻塞程序的正常执行，导致响应速度变慢。而异步操作不会影响程序的性能，在涉及高可用性、并发操作和界面渲染等方面得到广泛的应用。

需要注意的是，虽然异步方法可以提升程序的性能和响应速度，但如果使用不当也容易出现回调地狱的情况，导致代码难以维护。因此，在实际开发中，需要根据具体的场景和需求来选择合适的方式。

22.说说Promise和async/await的区别是？

Promise和async/await都是JavaScript中处理异步编程的两种方式，它们的主要区别如下：

1. 语法：Promise是ES6引入的一种语法，用于解决回调地狱的问题，实现方法主要包括then()和catch()。而async/await是ES7引入的新语法，可将异步操作和顺序逻辑混合起来书写。
2. 链式调用：使用 Promise进行异步操作时，我们可以通过链式调用在不同的任务之间传递结果，避免了回调地狱的问题。但是在底层使用了then方法导致代码可读性偏低；相比之下，使用 async/await 则能够直接在函数内部、顺序执行多个异步操作，并将值返回给上层调用者 。同时，使用try… catch块即可捕获错误而无需使用回调函数或catch(),代码层次更清晰易懂。
3. 错误处理：Promise通常通过reject()方法来抛出错误，可以在then()和catch()方法中捕获。而使用async/await则可以像同步代码一样使用try… catch块来捕获错误，这使得代码的错误处理更加简洁和直观。
4. 性能：在异步操作较多、嵌套较深的情况下，promise因为每个 then 方法只会返回一个新的 Promise 实例，多次使用可能会造成资源和性能的浪费。相比之下，Async/await 在语义上更直观，并且不会创建额外的 Promise 实例，具有更加优秀的性能表现。

需要注意的是，Promise 和 async/await 是同样都解决异步的问题，在具体使用中需要根据具体场景选择。以简单网络请求为例使用Promise可以减少请求成功、失败的回调函数的嵌套；使用async/await可与try…catch一起工作从而使代码结构更加清晰、易于阅读。

23.Javascript如何实现继承？

JavaScript是一种基于原型的语言，而不是面向对象的，它通过原型链实现继承。在JavaScript中，每一个对象都有一个内部属性[[Prototype]]（或者说是__proto__，有些浏览器未来会抛弃对这个属性的支持 ），指向它的原型（prototype）。当试图访问一个对象的属性时，如果该对象本身没有定义该属性，则会去它的原型中查找，如果还是没有找到，就一直沿着原型链往上查找，直到最顶层的Object.prototype。

常见的 JavaScript 继承方式主要有以下几种：

1.原型链继承：利用原型链机制，让子类的原型指向父类的实例，从而实现继承。这种方式简单，但存在父类引用属性被所有子类实例共用的问题，也无法给构造函数传递参数。例如：

function Parent() {
   this.name = 'parent';
};
Parent.prototype.sayHello = function() {
   console.log('Hello, I am'+this.name);
};

function Child() {};
Child.prototype = new Parent();
var child1 = new Child();
child1.sayHello(); // Hello, I am parent

2.借用构造函数继承（经典继承）：通过在子类构造函数中使用 call 或 apply 调用父类的构造函数，从而实现属性的继承。这种方式解决了原型链继承的问题，但不能继承父类原型链上的属性和方法。例如：

function Parent() {
   this.names = ['jack', 'tom'];
};
function Child() {
  Parent.call(this); //调用父类构造函数
};
var child1 = new Child();
child1.names.push('jerry');
console.log(child1.names); // ["jack", "tom", "jerry"]
var child2 = new Child();
console.log(child2.names); // ["jack", "tom"]

3.组合继承：将前两种方式结合起来，使用原型链实现父类原型属性和方法的继承，通过借用构造函数实现子类自身属性的初始化。这种方式是继承中较为常用的一种方式，并且解决了原型链继承和经典继承各自的缺陷。但还是存在不必要的父类实例化和子类原型重复的问题。例如：

function Parent() {
   this.name = 'parent';
   this.colors = ['red', 'blue', 'green'];
};
Parent.prototype.sayHello = function() {
   console.log('Hello, I am'+this.name);
};
function Child() {
   Parent.call(this); //调用父类构造函数，设置自己的实例属性
   this.age = 18;
};
Child.prototype = new Parent(); //设置原型，继承父类原型属性和方法
Child.prototype.constructor = Child; //修正constructor指向
var child1 = new Child();
console.log(child1.age); //18
console.log(child1.colors); //["red", "blue", "green"]

4.原型式继承：使用 Object.create 进行继承，可以基于一个原型对象创建一个新的对象，从而实现继承。例如：

var parent = {
   name: 'parent',
   friends: ['A', 'B']
};
var child1 = Object.create(parent);
child1.name = 'Jack';
console.log(child1.friends); // ["A", "B"]

5.寄生式继承：在原型式继承的基础上添加代码对原型对象进行增强，然后返回当前对象的副本，实现继承并对该副本进行修改或增强。但是它跟借用构造函数模式也一样，无法做到函数复用。例如：

function createChild(obj) {
   var child = Object.create(obj);
   child.sayHello = function() {
      console.log('Hello, I am'+this.name);
   };
   return child;
}

24.说说JavaScript中的数据类型？存储上的差别？

1. 原始数据类型（Primitive Data Types）：
   • 数字（Number）：用于表示数字，包括整数和浮点数。
   • 字符串（String）：用于表示文本数据。
   • 布尔值（Boolean）：用于表示真或假。
   • 空值（Null）：表示空或不存在的值。
   • 未定义（Undefined）：表示变量未被赋值。
2. 引用数据类型（Reference Data Types）：
   • 对象（Object）：用于存储键值对，可包含函数、数组、日期等各种类型的数据。
   • 数组（Array）：用于存储多个值的有序集合。
   • 函数（Function）：用于封装可重复使用的代码块。
   • 日期（Date）：用于表示日期和时间。
   • 正则表达式（RegExp）：用于匹配和操作字符串的模式。

关于存储上的差别，原始数据类型直接存储在栈内存中，而引用数据类型的值实际上是存储在堆内存中，而变量中只保存了对堆内存中的地址的引用。当我们创建一个原始数据类型的变量时，存储的是实际的数据；而创建一个引用数据类型的变量时，存储的是指向实际数据的引用地址。

25.什么是流体布局，圣杯布局

流体布局

流体布局（Fluid layout）是一种网页设计的布局方法，旨在实现网页内容的自适应和响应式展示。相比于固定布局（Fixed layout），流体布局可以根据用户设备的屏幕尺寸和窗口大小进行动态调整，以适应不同的显示环境。

流体布局主要基于相对单位（如百分比）和弹性盒子布局（Flexbox）等技术来实现。通过设定容器和元素的宽度、高度、边距和间距等属性为相对单位，使得它们能够根据可用空间或父容器的尺寸自动调整。

使用流体布局可以让网页在不同尺寸和分辨率的设备上都能良好地呈现，并且页面元素之间的相对位置关系也能得到保持。这样，无论用户使用台式电脑、平板电脑或手机等设备访问网页，都可以获得良好的浏览体验，并避免了水平滚动条的出现。

值得注意的是，虽然流体布局可以提供更好的可适应性，但在设计和开发时需要考虑不同屏幕尺寸和设备的显示效果，以确保内容在各种情况下都能清晰可读、布局合理。

圣杯布局

圣杯布局（Holy Grail layout）是一种常用于网页设计的三栏布局方式，其中主要内容位于中间列，而左右两侧列用于放置导航菜单、侧边栏等附加内容。

圣杯布局的目标是实现以下特点：

1. 中间列优先：主要内容位于中央，占据页面的主要宽度。
2. 左右列等高：左侧和右侧列具有相同的高度，并且允许比中间列更短。这有助于保持整体布局的一致性。
3. 可变宽度：左右列可以根据需要进行自适应调整，使其能够适应不同尺寸和分辨率的屏幕。

实现圣杯布局通常使用以下技术：

1. 使用浮动（float）或定位（position）将左右列从正常文档流中脱离出来，使它们可以并排显示。
2. 将中间列设置为相对定位（relative position），以便在左右列的宽度和位置发生变化时进行调整。
3. 通过设置左右列的宽度为固定值或百分比来控制它们的宽度，同时使用负边距（negative margin）将它们拉回到中间列后面去。
4. 使用顺序调整（order）或媒体查询（media query）等方式，在较小的屏幕上重新排列布局，以实现响应式设计。

圣杯布局是一种常见且灵活的布局方式，可以用于创建具有多栏结构的网页，并在不同设备上提供良好的用户体验。

26.伪类和伪元素区别

伪元素和伪类是CSS中用于选择和样式化特定元素或状态的机制，它们在用法和功能上有一些区别。

伪元素（pseudo-element）:

• 伪元素用来在文档结构中创建一个不存在的元素，并将其样式化。
• 伪元素通过双冒号(::)表示，例如::before和::after。
• 伪元素可以在选中的元素内部的特定位置插入内容，如在元素的前面或后面添加额外内容。
• 伪元素可用于添加装饰、生成特殊效果或实现排版等功能。
• 伪元素通常需要使用content属性定义要插入的内容，并通过CSS样式进行定位和样式设定。

伪类（pseudo-class）:

• 伪类用于选择处于特定状态或特定位置的元素。
• 伪类通过单冒号(:)表示，例如:hover、:active和:first-child。
• 伪类可以根据用户的交互行为（如:hover、:focus）、元素的位置（如:first-child、:last-child）或链接的状态（如:visited）等进行选择。
• 伪类定义了元素在特定条件下的样式变化，它只能基于已存在的元素。
• 伪类通常用于响应用户的操作、改变元素状态或为特定场景提供样式。

总结： 伪元素用于创建并样式化虚拟的元素，而伪类用于选择和样式化处于特定状态或位置的元素。伪元素通过双冒号(::)表示，伪类则通过单冒号(:)表示。它们在用法和功能上略有区别，但都为CSS提供了更灵活和强大的选择器机制。

27.小程序生命周期

小程序的生命周期是指小程序在运行过程中不同阶段触发的一系列事件和函数。以下是小程序的常见生命周期事件和函数：

1. onLaunch(options)： 小程序初始化时触发，只会执行一次。可以在该函数中进行一些全局的初始化操作，如获取用户信息、登录等。

2. onShow(options)： 小程序启动或从后台进入前台时触发。在该函数中可以处理小程序进入前台后的逻辑，如更新数据、重新请求接口等。

3. onHide()： 小程序从前台进入后台时触发。可以在该函数中保存一些数据，或进行一些清理操作。

4. onError(error)： 小程序发生错误时触发。可以在该函数中进行错误处理和上报。

5. onPageNotFound(options)： 小程序页面不存在时触发。可以在该函数中进行页面不存在时的处理逻辑。

6. onUnload()： 页面被关闭或卸载时触发。可以在该函数中进行页面的清理操作。

7. onPullDownRefresh()： 用户下拉刷新页面时触发。可以在该函数中处理刷新逻辑，如重新请求数据。

8. onReachBottom()： 页面上拉触底时触发。可以在该函数中处理加载更多数据的逻辑。

9. onShareAppMessage()： 用户点击分享按钮时触发。可以在该函数中返回自定义的分享信息。

10. onPageScroll(options)： 页面滚动时触发。可以在该函数中处理页面滚动事件。

11. onResize(options)： 页面尺寸变化时触发，如屏幕旋转时。可以在该函数中处理页面尺寸变化时的逻辑。

这些生命周期事件和函数提供了对小程序不同阶段和操作的响应和处理能力。开发者可以根据具体的需求，在对应的生命周期函数中编写相应的逻辑代码，以实现更丰富的小程序功能和交互体验。

28.如何css绘制一个三角形

要使用CSS绘制一个三角形，可以利用CSS的边框和尺寸来创建一个零宽度或零高度的元素，并使用边框属性来定义三角形的形状。下面是两种常见的方法：

方法一：使用边框属性

<div class="triangle"></div>

.triangle {
  width: 0;
  height: 0;
  border-left: 50px solid transparent;
  border-right: 50px solid transparent;
  border-bottom: 100px solid red;
}

在上述代码中，通过设置元素的宽度和高度为0，然后使用边框属性来定义三角形的形状。通过调整border-left和border-right的宽度以及border-bottom的宽度和颜色，可以实现不同大小和颜色的三角形。

方法二：使用伪元素

<div class="triangle"></div>

.triangle {
  position: relative;
  width: 100px;
  height: 100px;
}

.triangle::before {
  content: "";
  position: absolute;
  top: 0;
  left: 0;
  border-width: 0 100px 100px 0;
  border-style: solid;
  border-color: red;
}

在上述代码中，通过在元素上使用伪元素::before，并设置其边框属性来创建一个三角形。通过调整border-width和border-color，可以实现不同大小和颜色的三角形。

这些方法只是其中的两种常见方式，实际上还有其他方法可以使用CSS绘制三角形。具体使用哪种方法取决于实际需求和设计要求。

29.css选择器有哪些，优先级，有哪些特性，可以继承

CSS选择器是用于选择HTML元素并为其应用样式的模式。以下是一些常见的CSS选择器：

1. 元素选择器（Element Selector）： 通过HTML元素的标签名选择元素。例如：p选择所有<p>元素。

2. 类选择器（Class Selector）： 通过HTML元素的class属性选择元素。以.开头，后跟类名。例如：.highlight选择所有class为"highlight"的元素。

3. ID选择器（ID Selector）： 通过HTML元素的id属性选择元素。以#开头，后跟id名。例如：#header选择id为"header"的元素。

4. 属性选择器（Attribute Selector）： 通过HTML元素的属性选择元素。例如：[type="text"]选择所有具有type属性且值为"text"的元素。

5. 后代选择器（Descendant Selector）： 通过元素的后代关系选择元素。以空格分隔，例如：.container p选择所有class为"container"的元素内的所有<p>元素。

6. 子元素选择器（Child Selector）： 通过元素的直接子元素关系选择元素。以>符号分隔，例如：.container > p选择所有class为"container"的元素的直接子元素中的<p>元素。

7. 相邻兄弟选择器（Adjacent Sibling Selector）： 选择位于同一父元素下紧接在指定元素后面的元素。以+符号分隔，例如：h2 + p选择紧接在<h2>元素后面的<p>元素。

CSS选择器的优先级决定了当多个选择器应用于同一个元素时，哪个选择器的样式将被应用。选择器的优先级由以下几个因素决定（按重要性从高到低）：

1. 内联样式（Inline Styles）： 使用style属性直接在HTML元素上定义的样式，具有最高的优先级。

2. ID选择器（ID Selectors）： 使用ID选择器定义的样式。

3. 类选择器、属性选择器和伪类选择器（Class Selectors, Attribute Selectors, Pseudo-class Selectors）： 使用类选择器、属性选择器或伪类选择器定义的样式。

4. 元素选择器和伪元素选择器（Element Selectors, Pseudo-element Selectors）： 使用元素选择器或伪元素选择器定义的样式。

5. 通用选择器和组合选择器（Universal Selectors, Combinators）： 通用选择器（*）和组合选择器（+, >, ~）的优先级最低。

CSS具有一些特性和行为，如：

1. 层叠性（Cascading）： 当多个样式规则应用于同一元素时，

根据选择器的优先级和特定性，样式将被层叠应用。

2. 继承性（Inheritance）： 某些样式属性可以从父元素继承到子元素，如字体样式、文本颜色等。这意味着父元素上设置的样式会自动应用到子元素上，除非子元素显式地覆盖了这些样式。

3. 优先级： 如上所述，不同类型的选择器具有不同的优先级，通过计算优先级可以确定应用的样式。

需要注意的是，选择器的特性和行为可能会因浏览器的差异而有所不同，因此在编写CSS样式时应仔细考虑选择器的使用和样式的优先级。

30.防抖，节流区别

防抖（Debouncing）和节流（Throttling）是用于控制函数在高频率触发时执行的技术。

防抖（Debouncing）： 防抖是指在事件触发后等待一段时间，如果在这段时间内没有再次触发事件，则执行该事件处理函数。如果在等待时间内又触发了该事件，则重新计时。防抖适用于处理频繁触发的事件，如浏览器窗口的调整、搜索框输入等。

节流（Throttling）： 节流是指在一段时间内只允许函数执行一次。当事件触发后，函数将立即执行，然后在指定的时间间隔内忽略后续的触发。节流适用于限制函数的执行频率，如滚动事件、鼠标移动事件等。

区别：

• 防抖和节流都是为了控制函数执行的频率，避免函数在高频率触发时过于频繁地执行。
• 防抖是在事件触发后等待一段时间，如果在等待时间内没有再次触发事件，则执行函数。如果在等待时间内又触发了事件，则重新计时。
• 节流是在事件触发后立即执行函数，然后在指定的时间间隔内忽略后续的触发，直到时间间隔过去后才允许再次执行。

适用场景：

• 防抖适用于需要等待一段时间后执行的事件，例如输入框输入事件、窗口调整事件等。它可以减少频繁触发的事件导致的重复计算或请求，只在用户停止操作一段时间后执行最后一次操作。
• 节流适用于限制函数执行的频率，特别是在高频率触发的事件中。例如，滚动事件、鼠标移动事件等，通过控制函数的执行频率，可以减少事件处理的次数，提高性能。

需要根据具体的应用场景和需求来选择使用防抖或节流技术。

31.接收数据类型的存储方式

数据类型在计算机内部存储时，采用不同的表示方式。以下是几种常见数据类型的存储方式：

1. 整数（Integer）： 整数通常以二进制形式存储，使用固定长度的字节来表示。常见的整数表示方式有补码表示、无符号整数表示等。

2. 浮点数（Floating-Point）： 浮点数使用科学计数法表示，包括一个符号位、尾数和指数。常见的浮点数表示方式有单精度浮点数（32位）和双精度浮点数（64位）。

3. 字符（Character）： 字符通常使用编码方式存储，例如ASCII编码、Unicode编码等。每个字符在内存中占用一定的字节。

4. 布尔值（Boolean）： 布尔值通常以一个字节来表示，其中true通常用1表示，false用0表示。

5. 数组（Array）： 数组是一组相同类型的数据元素的集合。数组的存储方式取决于编程语言和实现方式，可以是连续的内存块，也可以是指针或引用的集合。

6. 对象（Object）： 对象通常由多个属性组成，每个属性包含一个键值对。对象的存储方式也因编程语言和实现方式而异，可以是连续的内存块，也可以是通过指针或引用相互关联的数据结构。

7. 指针（Pointer）： 指针是一种存储内存地址的数据类型，用于表示变量或数据的存储位置。

8. 字符串（String）： 字符串通常是字符序列的集合，可以使用不同的存储方式，如以null结尾的字符数组、使用指针表示的字符序列等。

以上是常见数据类型的存储方式，具体的实现方式会根据编程语言、编译器和操作系统等因素而有所不同。

32.画一条0.5px的直线

在标准的屏幕上，像素（Pixel）是最小的显示单元，通常表示为整数值。因此，绘制一条精确宽度为0.5像素的直线是不可能的，因为屏幕无法显示出这样的细微细节。

在实际情况下，可以通过一些技巧来模拟绘制0.5像素宽度的线条，但效果可能会有所不同，具体取决于浏览器和设备的渲染机制。

以下是两种常见的模拟0.5像素线条的方法：

1. 使用1像素实线和1像素透明边框：

   .line {
     height: 1px;
     border-bottom: 0.5px solid transparent;
   }
   

   这种方法利用了边框的一半宽度可以透明显示的特性。通过设置边框宽度为0.5像素，并且将边框样式设置为实线，然后使用透明颜色，可以模拟出视觉上的0.5像素宽度的线条效果。

2. 使用伪元素绘制半透明线条：

   .line::before {
     content: "";
     display: block;
     height: 1px;
     background-color: rgba(0, 0, 0, 0.5);
   }
   

   这种方法使用伪元素(::before或::after)来创建一个具有指定高度和半透明背景颜色的元素，从而模拟出0.5像素宽度的线条。

需要注意的是，这些方法仅是通过视觉效果来模拟0.5像素宽度的线条，并不是真正的0.5像素。实际显示效果可能因浏览器、设备和屏幕分辨率的差异而有所不同。在大多数情况下，使用整数像素的线条是更可靠和精确的做法。

33.1rem,1em,1vh,1px各自代表的含义

下面是每个单位的含义：

1. 1rem： rem 表示相对于根元素（通常是 <html> 元素）的字体大小的单位。例如，如果根元素的字体大小设置为 16 像素，那么 1rem 就等于 16 像素。

2. 1em： em 表示相对于当前元素的字体大小的单位。例如，如果一个元素的字体大小为 16 像素，那么 1em 就等于 16 像素。如果嵌套在另一个元素中，且父元素的字体大小为 20 像素，那么子元素中的 1em 就等于 20 像素。

3. 1vh： vh 表示视口高度的百分比单位。视口高度是指浏览器窗口的可见区域的高度。例如，如果视口高度为 800 像素，那么 1vh 就等于 8 像素（1% * 800）。

4. 1px： px 表示绝对长度单位像素，是显示设备上的最小可见点。一个像素的大小可以因设备的屏幕密度而有所不同。在标准屏幕上，1像素通常相当于一个物理像素，但在高密度屏幕（如Retina屏幕）上，1像素可能由多个物理像素组成。

这些单位在前端开发中常用于定义元素的尺寸、间距、字体大小等样式属性。了解每个单位的含义和用法有助于编写灵活且响应式的样式代码。

34.分片上传

分片上传（Chunked Upload）是一种将大文件拆分成多个小块（分片）进行上传的方法。通过将文件切割为较小的块，可以提高上传的效率和可靠性，并减轻服务器和网络的负担。每个分片可以独立上传，甚至可以并发上传，而不需要等待整个文件完成。

实现分片上传可以按照以下步骤进行：

1. 切割文件： 将待上传的文件按照指定的大小切割成多个分片。分片大小通常根据实际需求和网络情况来确定，常见的大小为几十KB到几MB。

2. 上传分片： 将切割后的每个分片独立上传到服务器。可以使用HTTP或其他协议进行分片上传。对于每个分片，需要在上传请求中包含分片索引、总分片数和文件标识等信息，以便服务器能够正确地接收并合并分片。

3. 服务器端接收和保存分片： 服务器端接收到每个分片后，根据分片索引和文件标识进行合并。服务器可以将每个分片暂时保存在内存或磁盘中，直到所有分片都上传完毕。

4. 校验和合并： 在所有分片上传完成后，服务器会进行校验以确保所有分片完整无误。如果有任何分片上传失败或损坏，可以触发重试或中断上传。

5. 完成上传： 当所有分片都上传成功且校验通过后，服务器会将分片合并为完整的文件，并将其保存到目标位置。上传完成后，可以进行一些后续的处理操作，如生成文件链接、更新数据库记录等。

分片上传的具体实现方式可以根据应用程序和技术栈的不同而有所不同。通常可以借助前端的文件API（如File API）来读取文件内容和切割分片，然后通过HTTP请求将分片上传到服务器。服务器端可以使用相应的框架或库来处理上传请求并进行分片的接收、保存和合并操作。

需要注意的是，在实现分片上传时，还需要处理并发上传的情况，确保分片按正确的顺序上传，并且服务器能够正确处理并发上传的分片。此外，还需要考虑上传过程中的断点续传、上传进度显示和错误处理等方面的需求。

35.怎么优化H5让它可以在300ms以内打开？

1. 减少页面资源大小：通过压缩和合并CSS和JavaScript文件，以及对图片进行优化和懒加载，减小页面资源的总体大小。
2. 延迟加载非关键资源：将非关键资源（如广告、统计代码等）延迟加载，以保证页面首次打开时能够快速呈现内容。
3. 使用CDN加速：将静态文件（例如CSS、JavaScript和图片）部署到全球分布式的内容分发网络（CDN）上，可以加快文件加载速度。
4. 使用缓存：通过设置合适的缓存策略，浏览器可以缓存页面的静态资源，再次访问时可以直接从缓存中获取，提高页面加载速度。
5. 减少HTTP请求：减少页面上的HTTP请求次数，合并CSS和JavaScript文件，并尽量使用雪碧图或SVG精灵图来减少图片请求次数。
6. 使用异步加载：将不影响页面渲染的JavaScript文件采用异步加载方式，以防止其阻塞页面的加载。
7. 优化服务器响应时间：确保服务器响应时间尽可能短，可以通过优化数据库查询、减少不必要的计算和IO操作等方式来提高服务器性能。
8. 前端性能优化：使用有效的HTML结构、CSS样式和JavaScript代码来减少页面渲染时间，避免不必要的布局重绘和重排。
9. 使用预加载技术：可以通过使用标签预加载关键资源，以提前获取页面所需的资源，加快页面打开速度。

请注意，具体的优化策略还需要根据项目的具体情况来确定，并进行一定的性能测试和调优。

36.怎么判断webview是否加载完成？

要判断WebView是否加载完成，可以使用WebView提供的监听器来实现。下面是一种常用的方法：

1. 设置WebViewClient：

java复制代码WebView webView = findViewById(R.id.webView);
webView.setWebViewClient(new WebViewClient() {
    @Override
    public void onPageFinished(WebView view, String url) {
        // 页面加载完成的回调
        // 在这里进行对应的操作或逻辑处理
    }
});

1. 监听onPageFinished回调： 在WebViewClient的onPageFinished方法中，当页面加载完成时会触发回调，你可以在这里执行相应的操作。

需要注意的是，Web页面的加载过程可能包含多个阶段，如页面开始加载、页面正在加载、页面加载完成等，你可以根据具体需要选择合适的回调方法来判断WebView是否加载完成。

另外，在某些情况下，WebView加载的网页可能会包含异步加载的资源（如图片、视频等），如果需要等待所有相关资源都加载完成才算完全加载完成，可以使用如下方法：

1. 使用WebView的setPictureListener方法：

java复制代码webView.setPictureListener(new WebView.PictureListener() {
    @Override
    public void onNewPicture(WebView view, Picture picture) {
        // 通过判断picture是否为null，来确定是否加载完成
    }
});

1. 使用WebChromeClient的onProgressChanged方法：

java复制代码webView.setWebChromeClient(new WebChromeClient() {
    @Override
    public void onProgressChanged(WebView view, int newProgress) {
        // 根据newProgress的变化来判断加载完成的进度
    }
});

通过上述方法，你可以根据具体需求来判断WebView是否加载完成，并在适当的时机执行相应的操作。

37.客端怎么处理JS事件失效的问题

当客户端遇到JavaScript事件失效的问题时，可以尝试以下解决方法：

1. 检查代码错误：检查JavaScript代码中是否存在错误，如语法错误、逻辑错误等。使用开发者工具（如浏览器的控制台）查看是否有报错信息，并逐个排查和修复错误。
2. 确保元素存在：确保事件绑定的元素存在于DOM中。如果元素是动态生成的，需要确保在绑定事件之前元素已经被正确创建和插入到DOM中。
3. 绑定事件顺序：确认事件绑定的顺序是否正确。某些情况下，先后绑定多个事件可能会影响它们的执行顺序，导致事件失效。可以按照需要调整事件绑定的顺序，或合理使用事件委托以确保事件能够正常执行。
4. 避免重复绑定：确保事件只绑定一次，避免重复绑定相同的事件。多次绑定同一事件可能会导致事件触发多次或执行顺序混乱，从而产生问题。
5. 检查事件类型和选择器：确认事件类型和事件处理函数的选择器是否匹配。例如，如果绑定了点击事件，但用户实际操作的是键盘回车键，那么事件不会触发。还需确保选择器与目标元素的结构和属性匹配。
6. 确认事件绑定时机：部分情况下，可能是由于在合适的时机绑定事件。确保在DOM完全加载（如DOMContentLoaded或window.onload事件）之后再绑定事件，以避免因为元素尚未加载完成而导致事件失效。
7. 考虑事件代理：对于动态生成的元素或大量重复元素，可以使用事件代理（Event Delegation）的方式来绑定事件。通过将事件绑定在它们的祖先元素上，利用事件冒泡原理捕获并处理目标元素的事件，从而简化事件绑定和改善性能。
8. 测试兼容性：不同浏览器对某些事件的支持和实现可能存在差异，可能导致事件失效。可进行跨浏览器测试，查看是否有兼容性问题，并根据需要进行针对性的处理和修复。

38.webpack plugin的原理是什么?

Webpack是一个现代化的静态模块打包工具，它通过读取项目中的源代码并解析依赖关系，将代码和相关资源打包成最终的静态文件。在Webpack构建过程中，插件（plugins）起着至关重要的作用。

Webpack插件可以修改、优化或操纵Webpack打包过程中的各个阶段，以满足特定的需求。插件可以对模块进行转换、资源优化、环境变量注入等操作，从而扩展Webpack的功能和灵活性。

插件的原理基本如下：

1. 插件是一个JavaScript对象，通常包含一个apply方法用于接收Webpack的compiler对象，并在适当的时机执行相应的功能。
2. 在Webpack的构建过程中，compiler对象负责整个构建过程的管理和控制。
3. 插件在合适的时机以钩子（hooks）的形式注册到Webpack的构建流程中，比如在解析模块、生成资源、优化代码等阶段。
4. 当Webpack执行到对应的构建阶段时，会触发插件注册的钩子，并调用插件的apply方法，在这里可以执行各种自定义的操作。
5. 插件可以访问Webpack的编译器对象和配置信息，通过编写特定的逻辑来实现对源代码、资源和构建流程的处理和修改。

总结来说，Webpack插件通过注册钩子函数，在Webpack构建过程中的各个阶段执行自定义的逻辑，从而影响构建结果。这使得开发者可以根据需要，对代码进行转换、优化或操纵构建过程，以满足特定的项目需求

39.Node服务怎么去定位CPU占用暴涨的情况?怎么去定位内存泄露?

定位CPU占用暴涨和内存泄露是Node服务性能调优的关键任务。下面是一些常用的方法来定位这些问题：

1. 定位CPU占用暴涨：
   • 使用操作系统自带的工具，如Linux的top命令或Windows的Task Manager，可以查看进程的CPU占用情况，并确定哪个进程消耗了大量的CPU资源。
   • 使用工具进行性能分析，例如Node.js自带的profiler（v8-profiler）或第三方工具如Chrome开发者工具（Chrome DevTools）的CPU Profiler，可以捕获CPU执行时间较长的函数或代码块，从而确定具体是哪部分代码造成了CPU占用暴涨。
2. 定位内存泄露：
   • 使用Node.js自带的内存分析工具，如heapdump模块，可以生成堆快照（heap snapshot），并通过分析快照中的对象引用关系，找到可能导致内存泄露的对象。
   • 使用第三方工具如Chrome开发者工具的Heap Profiler，在浏览器中查看和分析内存使用情况，包括内存泄露的对象可视化。
   • 监测Node进程的内存使用情况，例如使用process.memoryUsage()方法获取内存的详细信息，并跟踪内存的变化，特别注意逐渐增长的趋势，可以帮助发现内存泄露问题。

在定位问题后，可以根据具体情况采取相应的优化策略和调整：

• 对于CPU占用高的情况，可以考虑优化算法、减少不必要的计算、并发控制等方式来降低CPU负载。
• 对于内存泄露问题，可以检查代码中的对象引用是否正确释放，尤其是事件监听、定时器、循环引用等地方可能造成的泄露。使用缓存或连接池时，也需要注意及时释放资源。

40.如果有一个非常大的react页面 我想优先染某一部分该怎么做

如果你有一个非常大的React页面，并且希望优先加载和渲染其中的某一部分，可以考虑以下几种方法：

1. 组件拆分：将整个页面拆分成多个小组件，按照页面的逻辑结构划分。然后，确保优先加载和渲染需要优先显示的部分所对应的组件，而将其他部分作为延迟加载的组件。这样，用户首先能够看到并与重要内容进行交互，而不必等待整个页面全部加载完成。
2. Code Splitting（代码分割）：使用Webpack或者其他打包工具支持的Code Splitting功能，将页面中的代码拆分成多个独立的块（chunks）。可以通过动态导入（dynamic import）、React.lazy()和Suspense组件等技术，根据需要按需加载特定模块，并在加载时显示占位符。这样可以实现在网页加载过程中逐步渲染各个模块的效果，优先展示目标部分。
3. Virtualized rendering（虚拟化渲染）：对于大量数据列表，可以使用虚拟化渲染技术，如react-virtualized、react-window或react-lazy-load等库，只渲染可视区域内的部分，延迟加载其余部分。这种方式可以减少初始渲染的负载，并提高性能和用户体验。
4. 懒加载图片：对于页面中的图片资源，可以使用懒加载（lazy loading）技术。当用户滚动到图片所在的位置时，再进行真正的加载和显示，而不是一次性加载所有的图片。使用像LazyLoad这样的React库可以方便地实现图片懒加载。

41.浏览器渲染机制简要解析

浏览器渲染机制是指浏览器在接收和处理HTML、CSS和JavaScript等资源时，将这些资源转化为可视化的网页页面的过程。以下是浏览器渲染的简要解析：

1. 浏览器渲染流程：
   • 构建DOM树：浏览器将接收到的HTML文档解析成DOM树，表示文档的结构和层次关系。
   • 构建CSSOM树：解析CSS文件并构建CSSOM树，表示样式规则的层次关系和定义。
   • 将DOM和CSSOM合并成Render树：将DOM树和CSSOM树合并，创建Render树，该树包含了需要被渲染的元素和对应的样式信息。
   • 布局（Layout）：计算各个元素在页面中的位置和大小，形成布局树（Box Model）。
   • 绘制（Paint）：根据布局树进行具体像素的绘制，在屏幕上展示出来。
   • 合成（Composition）：将不同图层的绘制结果进行合成，创建最终的页面显示。
2. 优化页面渲染的技巧：
   • 减少重绘和重排：尽量避免频繁修改影响页面布局的样式属性，因为每次修改会导致浏览器计算布局并重新绘制，影响性能。
   • 使用合适的CSS选择器：避免使用过于复杂的CSS选择器，这可能导致解析和匹配过程耗时，建议使用高效的选择器。
   • 虚拟列表（Virtualized List）：对于大型列表或表格，可以只渲染可见区域内的元素，动态加载和卸载列表项，减少页面渲染的工作量。
   • 懒加载（Lazy Loading）：延迟加载不必要的资源，如图片、视频等，在需要时再进行加载，提高初始加载速度和减轻服务器负载。
   • 分割任务（Chunking）：将大型任务分割成多个小任务处理，利用浏览器的异步执行机制，确保优先渲染重要的部分。

通过以上优化技巧，我们可以在特定场景下优先渲染某一部分内容，提高页面加载速度和用户体验。需要根据具体情况进行优化，并结合性能测试和监控来评估效果

42.HTTPS如何实现安全通信，建立通信过程

HTTPS（Hypertext Transfer Protocol Secure）是一种通过SSL/TLS加密保护的HTTP协议，用于在网络上进行安全的通信。以下是HTTPS实现安全通信并建立通信过程的步骤：

1. 客户端发送请求：
   • 当客户端发起HTTPS请求时，在URL中使用"https://"前缀标识。
   • 客户端向服务器发送一个具有保密性要求的连接请求。
2. 服务器证书：
   • 服务器接收到客户端请求后，会将自己的数字证书发送给客户端。
   • 证书包含服务器公钥、证书颁发机构（Certification Authority）签名等信息。
3. 客户端验证证书：
   • 客户端收到服务器证书后，会验证其有效性。
   • 客户端检查证书是否由受信任的证书颁发机构签署，确认证书的真实性和合法性。
4. 生成共享密钥：
   • 客户端使用服务器的公钥对生成一个随机的对称密钥（称为会话密钥或对称密钥）。
   • 这个对称密钥用于后续的数据加密和解密。
5. 加密通信：
   • 客户端使用服务器的公钥对会话密钥进行加密，并发送给服务器。
   • 服务器使用自己的私钥解密客户端发来的会话密钥。
6. 数据传输：
   • 客户端和服务器使用会话密钥对数据进行加密和解密。
   • 所有通过HTTPS通信的数据都经过加密处理，保证数据在传输过程中的机密性。

通过以上步骤，HTTPS实现了安全通信和数据加密保护，确保了客户端和服务器之间的数据传输的安全性和完整性。这样可以有效防止网络拦截、窃听和篡改等安全威胁。

43.微信小程序架构设计，声明周期，运行机制，部署架构及性能优化

微信小程序的架构设计主要包括前端框架和后端服务组成。前端使用WXML、WXSS和JS开发，后端服务提供数据接口。

微信小程序的声明周期包括App、Page和Component三个层级的生命周期。其中，App生命周期包括onLaunch、onShow、onHide等方法；Page生命周期包括onLoad、onShow、onHide等方法；Component生命周期包括created、attached、ready等方法。

微信小程序的运行机制是基于WebView和JavaScriptCore引擎实现的。在微信客户端内部，通过WebView渲染小程序的界面，并通过JavaScriptCore引擎解析执行小程序的逻辑代码。

微信小程序的部署架构是基于微信平台的云开发能力。开发者将小程序的代码上传到微信服务器，微信服务器负责将小程序的代码分发给用户，在用户打开小程序时进行动态加载和解析。

对于性能优化方面，可以从以下几点进行优化：

• 减少网络请求：合理使用缓存和本地存储，减少冗余的网络请求。
• 合理使用setData：避免频繁调用setData方法，可通过节流和防抖技术进行优化。
• 优化列表渲染：使用wx:key来标识列表项的唯一性，避免重复渲染整个列表。
• 图片加载优化：合理使用图片压缩、懒加载和预加载等技术，提升图片加载性能。
• 避免布局过于复杂：优化小程序的布局结构，减少节点层级和不必要的样式计算。
• 使用网络分析工具：通过网络分析工具检测和优化小程序的网络请求和响应时间。
• 代码逻辑优化：通过优化代码逻辑，减少不必要的计算和操作，提升小程序的性能。

44.如何定义客户端的首屏，如何通过技术手段来监控各种时间的耗时

客户端的首屏指的是应用程序在打开后首次展示给用户的页面。定义客户端的首屏通常可以根据业务需求和用户体验进行确定。

要监控各种时间的耗时，可以使用以下技术手段：

1. 首屏渲染时间（First Contentful Paint，FCP）：FCP表示网页内容中第一个图像、文本或其他可视元素在浏览器视口内呈现的时间点。可以通过浏览器提供的性能API（如Performance API）来获取FCP的时间戳。
2. 首次可交互时间（First Input Delay，FID）：FID表示页面响应用户首次交互（例如点击按钮）的延迟时间。通过监听用户交互事件，并记录事件触发的时间戳与用户操作之间的差值来计算FID。
3. 页面加载时间：可通过浏览器的Navigation Timing API来获取关于页面加载的各项指标，如页面加载开始时间、DNS解析时间、TCP连接时间、DOM解析时间、资源加载时间等，借此对整个页面加载过程进行监控。
4. AJAX请求时间：通过监听AJAX请求的发送和接收状态，可以获取每个请求的起始时间和完成时间，从而计算请求耗时，并对请求时间较长的接口进行优化。
5. JavaScript执行时间：使用console.time和console.timeEnd等方法，可以在代码中标记JS逻辑的起始点和结束点，并通过浏览器开发者工具的性能面板来获得JS执行时间。
6. 图片加载时间：通过监控图片的onload和onerror事件，可以获取每张图片加载的开始时间和结束时间，从而计算图片加载耗时，进而优化图片加载策略。
7. 用户操作响应时间：记录用户交互事件的触发时间，并在对应的操作完成后计算时间差，可以了解用户操作响应的速度是否达到要求。

45.XSS及CSRF攻击是什么，如何防御

XSS攻击（跨站脚本攻击）是指攻击者通过在目标网页中插入恶意脚本，使其在用户浏览器中执行，从而能够窃取、篡改用户数据，甚至控制用户账号。XSS攻击通常利用未过滤或不正确转义的输入来实现。

CSRF攻击（跨站请求伪造）是指攻击者利用用户已认证过的身份，在用户毫不知情的情况下，向目标网站发送恶意请求。通过这种方式，攻击者可以执行未经授权的操作，如更改密码、发表评论等。

为了防御XSS和CSRF攻击，可以采取以下措施：

1. 输入验证和过滤：对于用户输入的数据，进行严格的验证和过滤，剔除非法或潜在恶意的内容。常见的做法包括使用白名单机制、正则表达式过滤、HTML标签转义等。
2. 输出编码：将用户的输入正确地进行编码和转义，确保输出到HTML、CSS、JavaScript等上下文中的数据不会被解释为可执行的代码。可借助编程语言或框架提供的安全函数，如htmlspecialchars()、encodeURIComponent()等。
3. 设置HttpOnly标记：对于存储敏感信息的Cookie，应将其标记为HttpOnly，这样可以防止客户端脚本获取和修改Cookie的值，从而减少XSS攻击的风险。
4. 随机化安全令牌：在执行敏感操作（如修改密码、发表评论等）时，引入一个随机生成的安全令牌。该令牌将与用户会话相关联，并在每次请求时进行验证，确保请求是合法的。
5. 启用CORS（跨源资源共享）：在服务器端配置CORS策略，限制网页的跨域请求，仅允许特定的源发送请求。这有助于防止CSRF攻击者利用其他网站发送恶意请求。
6. 在敏感操作中使用双因素认证：为了增加用户账号的安全性，可以引入双因素认证方式，要求用户在登录或进行敏感操作时，除了密码外，还需要提供其他形式的身份验证，如手机验证码、指纹识别等。
7. 定期更新、修补漏洞：及时更新和修补应用程序、框架和插件的安全漏洞，以确保系统的整体安全性。

46.组件封装有哪些原则

组件封装是指将一部分逻辑和功能进行抽象和封装，以便于在不同的场景和应用中复用。以下是常见的组件封装原则：

1. 单一责任原则（Single Responsibility Principle）：每个组件应该有清晰明确的功能和职责，只关注一个特定的功能或目标。
2. 开放封闭原则（Open-Closed Principle）：组件应该对扩展开放，对修改关闭。即在不修改现有代码的情况下，通过继承、接口实现等方式来增加新的功能或变化。
3. 高内聚低耦合原则（High Cohesion, Low Coupling Principle）：组件内部的各个元素功能相互关联紧密（高内聚），而与外部的其他组件的依赖关系较弱（低耦合）。这样可以提高组件的可维护性和可复用性。
4. 接口隔离原则（Interface Segregation Principle）：设计组件时，应该根据使用者的需求和角色来定义合适的接口，避免单一接口过于臃肿和复杂，而是根据具体场景提供精简的接口。
5. 最小化暴露原则（Principle of Least Exposure）：组件应该最小化地暴露公共接口，仅仅对外暴露必要的信息，隐藏实现细节和内部状态，以增强组件的封装性和安全性。
6. 可配置化原则（Principle of Configurability）：允许组件的某些行为、样式或功能可以通过配置参数进行自定义。这样可以提高组件的灵活性，适应多样化的需求。
7. 文档化和示例化原则（Documentation and Examples Principle）：良好的组件封装应该具备清晰完整的文档和示例，以便其他开发者能够快速理解和正确使用组件。

47.前端跨域有什么好的解决方案

前端跨域是指在浏览器环境下，当一个网页的执行环境（源）与该网页所请求资源的服务器域名、端口或协议不一致时，会出现跨域问题。为了解决前端跨域问题，可以采用以下几种常见的解决方案：

1. JSONP（JSON with Padding）：利用 标签的可跨域特性，通过动态创建 标签并指定请求的 URL，服务器返回经过函数封装的 JSON 数据，实现跨域数据获取。
2. CORS（Cross-Origin Resource Sharing）：在服务端设置响应头信息，允许特定域名的请求进行跨域访问。需要注意，在浏览器环境下，只有针对 XMLHttpRequest 或 Fetch 发起的非简单请求（如跨域的 POST、PUT、DELETE 请求等）才会触发预检请求（OPTIONS），来验证是否允许跨域访问。
3. 代理服务器：将前端的 HTTP 请求发送到同源的后端服务器，由后端服务器转发请求到目标服务器并返回响应。前端需要配置代理服务器的地址和路径映射关系，使得浏览器认为请求是同源的，从而避免跨域问题。
4. WebSocket：使用 WebSocket 协议进行通信，该协议可以在 JavaScript 中直接建立持久化的双向通信，不受同源策略限制。
5. Nginx 反向代理：通过在 Nginx 配置文件中添加反向代理规则，将前端请求转发到目标服务器，并在配置中设置跨域响应头信息，实现跨域访问。
6. postMessage API：使用 HTML5 提供的 postMessage API，在不同窗口或标签间进行安全跨域通信。

48.react native是否了解，与原生的开发方式有什么区别

是的，我了解React Native。React Native 是一个基于React的开源框架，可以用于构建跨平台的移动应用程序。与原生开发方式相比，React Native 的主要区别在于以下几个方面：

1. 代码复用：React Native 使用JavaScript编写，可以实现对多个平台的共享代码。大部分代码可以在 iOS 和 Android 平台上重用，减少了开发者需要编写和维护的代码量。
2. 跨平台开发：使用React Native，你可以同时开发iOS和Android应用，共享一部分代码，并根据特定平台的需求进行适配。这样可以大大减少开发时间和工作量。
3. 原生组件集成：React Native提供了与原生组件交互的能力。通过封装原生代码和使用Bridge（桥接）技术，可以轻松地将原生组件嵌入到React Native应用中，使得应用具备更丰富的功能和自定义性。
4. 开发效率：React Native的热加载机制使得开发者可以实时预览代码更改的效果，减少了调试和重启应用的时间。在开发过程中，React Native还提供了丰富的调试工具和第三方库，便于快速开发和测试。
5. 用户体验：尽管React Native应用并不完全等同于原生应用，但它在性能和用户体验方面已经达到了相当高的水平。React Native应用可以使用原生控件，可以获得接近原生应用的性能和交互效果。

总的来说，React Native在开发效率、跨平台和代码复用等方面具有显著优势，适合对多个平台进行开发和维护的项目，同时也需要考虑到其一些局限性，如特定平台的特性和性能要求。

49.对称加密与非对称加密的区别，HTTPS证书的作用

对称加密和非对称加密是两种常见的加密算法，它们在加密和解密数据过程中存在一些关键区别。

1. 对称加密：
   • 使用相同的密钥进行加密和解密。
   • 加密和解密速度较快。
   • 密钥的管理相对简单。
   • 存在安全性问题，因为密钥需要在通信双方之间共享和保密。
2. 非对称加密：
   • 使用公钥和私钥进行加密和解密。
   • 公钥用于加密数据，私钥用于解密数据。
   • 加密和解密速度相对慢。
   • 通过使用不同的密钥，提供了更高的安全性和可靠性。

HTTPS证书的作用是确保通过HTTP进行的网站通信的安全性。它使用了非对称加密算法来实现安全连接，并通过数字证书认证和验证网站的身份。HTTPS证书的主要作用包括：

1. 加密通信：HTTPS使用非对称加密算法对传输的数据进行加密，确保数据在传输过程中的机密性和安全性。只有具备正确的私钥的接收方才能解密和查看数据。
2. 身份验证：HTTPS证书由受信任的第三方机构（证书颁发机构）签发，确认和验证了网站的身份。通过验证证书中的数字签名，用户可以确定所访问的网站是来自可信任的实体，并避免受到伪装和中间人攻击。
3. 数据完整性：HTTPS使用数字签名技术来确保传输的数据在传输过程中没有被篡改或损坏。接收方可以使用公钥对接收到的数据进行验证，并确保数据的完整性和可靠性。

50.小程序端如何进行异常监控?什么是染色测试，如何进行染色测试

为了进行小程序端的异常监控，可以考虑以下几个步骤：

1. 异常捕获：在小程序的代码中，使用try-catch语句或错误处理函数来捕获可能发生的异常。可以通过监听全局异常、页面级别异常或特定功能模块的异常等方式进行捕获。
2. 错误信息记录：在捕获异常后，将相关的错误信息记录下来。包括错误的类型、发生的时间、错误堆栈信息等。
3. 数据上报：将捕获的错误信息上报给服务器或相关的监控平台。可以通过构建网络请求，将错误信息作为参数发送给后端。通过统计错误信息的数量和频次，进行问题分析和处理。
4. 可视化监控：结合监控平台或工具，将异常信息进行可视化展示。这样可以更直观地查看异常情况、进行趋势分析，以及在发生异常时及时报警通知。
5. 崩溃重现：对于频繁发生的错误或崩溃，可以尝试重现问题，并进行调试和修复。通过确定问题的具体原因，并进行代码优化和Bug修复。

异常监控可以帮助开发者及时发现和解决问题，提高小程序的稳定性和用户体验。

染色测试（Chaos Engineering）是一种用于评估系统容错性的技术。它通过有意诱发系统中的故障和异常情况，来测试系统在这些情况下的表现和可靠性。

进行染色测试的一般步骤如下：

1. 定义目标：明确要测试的系统、服务或功能的范围和目标。确定测试的关键指标和期望的结果。
2. 设计实验：设计一系列实验来模拟故障和异常情况。可以包括停止服务、引入网络延迟、增加负载等。确保实验的影响范围可控，并考虑安全性和数据完整性。
3. 执行实验：按照设计好的实验方案逐个执行实验。监测系统的表现，包括性能、可用性、可恢复性等指标，并记录相关数据。
4. 分析结果：根据实验结果和收集的数据进行分析。评估系统在不同故障场景下的表现，并找出存在的问题和潜在风险。
5. 总结改进：根据分析的结果，提出改进建议和修复措施。优化系统架构、增加容错机制、

51.什么是NGINX负载均衡，常用的NGINX负载均衡算法有哪些?

NGINX负载均衡是一种将网络流量平衡地分发到多个服务器上的技术，以实现高可用性、提高性能和扩展性。它可以根据预定的算法和规则将传入的请求动态地转发给后端的多台服务器进行处理。

常用的NGINX负载均衡算法包括：

1. 轮询（Round Robin）：将请求按照顺序轮流分发给每台服务器，实现简单公平的负载均衡。
2. 加权轮询（Weighted Round Robin）：为每台服务器分配一个权重值，根据权重不同来决定分发请求的比例，使得处理能力较强的服务器能够处理更多的请求。
3. IP哈希（IP Hash）：根据客户端的IP地址进行哈希计算，确定将该请求发送给固定的一台服务器，这样可以保证相同IP的请求 always land on the same server。
4. 最少连接（Least Connections）：将新的请求发送到当前连接数最少的服务器，以实现负载均衡和避免因某些请求需要更长时间导致服务器负载过高的问题。
5. 动态负载（Dynamic Load）：通过监控服务器的负载情况，动态地调整权重或者添加/移除服务器，以确保系统在任何情况下都能够保持平衡。

52.个人比较挑战性的项目，疑难问题解决

1. 构建一个复杂的软件应用程序：从需求分析到设计和实现，构建一个功能强大且复杂的软件应用程序是一个极具挑战性的项目。
2. 设计和优化一个大规模的分布式系统：在处理大量数据和用户同时访问的情况下，设计和优化分布式系统是一个具有挑战性的任务，需要考虑可扩展性、容错性和性能等因素。
3. 解决硬件或网络故障引起的系统故障：当系统遇到硬件或网络故障时，需要快速定位问题并采取相应措施来修复故障，这需要技术深度和故障排除能力。
4. 优化性能瓶颈：在软件开发和系统运行过程中，可能会遇到性能瓶颈，需要通过对系统进行分析和调优来提高性能。
5. 解决复杂的数据相关问题：处理大规模数据集、设计高效的数据存储方案、实现复杂的数据分析或机器学习算法等都是具有挑战性的任务。

在面对这些挑战性项目和疑难问题时，以下方法可能有助于解决问题：

1. 深入研究和学习相关领域的知识：通过学习和了解相关领域的基础知识和最新技术发展，提升对问题的理解和解决能力。
2. 建立合适的团队和合作伙伴关系：寻找具备相关专业知识和经验的人员合作，共同解决问题，集思广益。
3. 利用开源社区和在线资源：利用开源社区、技术论坛、文档和在线教程等资源，从其他人的经验和解决方案中获取启发和帮助。
4. 实践和持续改进：通过实际操作和不断试错，积累经验并优化解决方案，从而不断提高问题解决能力。

无论在哪个领域，挑战性项目和疑难问题的解决需要充分的准备、深入的思考和持久的努力。

53.说一下DOM0、DOM2、DOM3事件处理的区别是什么？

• DOM0事件处理：是最早出现的一种事件处理方式，通过在DOM节点上直接指定事件处理函数来实现。
• DOM2事件处理：DOM2级事件定义了两种方法，addEventListener和removeEventListener，它们可以动态地添加和移除事件处理函数。DOM2事件处理可以添加多个事件处理函数，它们按照添加的顺序依次执行
• DOM3事件处理：DOM3级事件增加了更多的事件类型，例如鼠标滚轮事件、键盘按键事件、文本输入事件等。除此之外，DOM3事件处理还增加了更多的方法，例如preventDefault()、stopPropagation()、stopImmediatePropagation()等，这些方法可以更加精确地控制事件的传播和处理。

总体来说，DOM2事件处理相比DOM0事件处理有更多的优势，而DOM3事件处理进一步扩展了事件的类型和方法。但是，由于DOM0事件处理在一些场景下的兼容性更好，所以在实际开发中也需要根据具体情况来选择不同的事件处理方式。

54.说说html和css渲染的过程是什么

HTML和CSS渲染的过程一般分为三个阶段：解析、渲染和合成。下面是具体的流程：

• 解析HTML：浏览器首先会解析HTML，生成一颗DOM树。DOM树是由一些个体（HTML标签、CSS样式）构成的树形结构，表示整个页面的结构和层级关系。

• 解析CSS：浏览器接着解析CSS文件，生成一份CSSOM树。CSSOM树也是由一些个体（CSS样式）构成的树形结构，表示整个页面的样式信息。

• 合成：在完成DOM树和CSSOM树的解析后，浏览器就可以开始将它们合成为一颗渲染树（Render Tree），这个过程就是合成。渲染树只包含渲染网页所必须的节点，例如可见的节点，所有的CSS信息和计算后的样式属性，不可见的节点和一些不需要渲染的节点就不在渲染树中。

• 布局：渲染树生成后，浏览器会根据每个节点的内容、样式等信息计算其在页面中的位置和大小，这个阶段称为布局（Layout）。

• 绘制：最后是绘制（Painting）阶段，浏览器遍历渲染树，并依据树中节点的几何信息将所有的节点绘制出来，呈现在屏幕上。

需要注意的是，HTML和CSS渲染的过程是一个复杂的过程，可以受到很多因素的影响，并且在实际渲染中会涉及到很多细节和优化，了解渲染的基本流程可以帮助我们更好的理解页面渲染的过程，从而更好地进行前端的开发和调试。

55.说说你对预编译器的理解？

预编译器是一种将代码预处理成标准化代码的工具。它们通过增加特性和语法来扩展普通的CSS、HTML、JS，并将这些扩展内容转换成浏览器可识别的CSS、HTML、JS代码。常见的预编译器包括Sass、Less、Stylus、Pug等。

预编译器的优点包括：

• 增加特性：预编译器能够增加CSS、HTML、JS的特性，比如在CSS中添加变量、嵌套等语法；在HTML中添加变量、条件语句等语法；在JS中添加类似于Typescript的类型检查、ES6的语法等。
• 提高可读性：预编译器能够更加语义化和清晰地书写代码，让代码更易读、易维护。
• 提高开发效率：使用预编译器能够极大地提高开发效率，减少代码量和重复劳动。
• 支持自定义扩展：预编译器支持自定义扩展，能够满足特定需求或组织特定的业务逻辑。

缺点则包括：

• 需要学习新的语法和工具：使用预编译器需要熟悉其特定的语法和工具，增加了学习成本。
• 不易调试：使用预编译器需要将其转换成标准的代码，当出现问题时，调试起来比较困难。
• 增加编译时间：使用预编译器需要编译成标准代码，增加了编译时间。

总之，预编译器在前端开发中被广泛使用，能够提高开发效率和代码质量，减少重复劳动。但也需要注意其对开发成本和调试难度的影响。

56.什么是FOUC? 如何避免？

FOUC是指页面在加载时，由于CSS文件的加载顺序导致页面的样式先后变化，从而出现页面闪烁的现象。FOUC的全称是“Flash of Unstyled Content”。

要避免FOUC，我们可以采取以下几种方式：

• 将CSS样式表放在HTML文档头部，这样浏览器加载HTML时就可以同时加载CSS文件，避免了样式变化的闪烁。
• 使用媒体查询，对不同的设备采取不同的CSS样式，以避免因页面元素的尺寸改变导致的样式变化。
• 使用JavaScript将CSS样式表动态地插入到页面中，可以避免页面的样式变化。
• 使用CSS样式表中的特定属性，如visibility: hidden或者opacity: 0，避免在页面加载时元素的显示

在HTML标签上加上style="display:none"的方式，避免页面的样式变化。在JS中，我们可以使用window.onload事件，在页面元素加载完毕后再显示页面。

57.说说你对递归的理解？封装一个方法用递归实现树形结构封装

递归是一种在函数内部调用自身的方法，通常用来解决需要反复执行同一任务的问题，其思想是将大问题分解成小问题进行解决。

在Vue中，递归可以用于展示树形结构的数据，它通过不断递归调用相同的组件，使得数据能够依次按照树形结构展开。

<template>
  <div>
    <li v-for="item in list" :key="item.id">
      {{ item.label }}
      <tree :list="item.children"></tree>
    </li>
  </div>
</template>

<script>
export default {
  name: "tree",
  props: {
    list: {
      type: Array,
      default: () => []
    }
  },
  components: {
    Tree: () => import('./Tree.vue') // 注册为异步组件，避免无限递归
  }
};
</script>

58.如何解决跨域问题？

跨域是指在同源策略下，一个网页无法向另一个网页发送请求。同源策略是一种浏览器安全策略，主要限制一个源加载的文档或脚本如何与另一个源进行交互。如果一个源包含的文档或脚本，试图向另一个源的资源发起请求，那么浏览器就会拦截这个请求。

解决跨域问题有多种方式，常见的有以下几种：

• CORS（跨域资源共享）：在服务端设置相应的头部信息，允许跨域访问。需要后端支持。

• JSONP：利用 script 标签可以跨域请求的特性，将请求封装成 script 请求，服务器返回 JavaScript 脚本，通过回调函数的方式将数据返回到前端。只支持 get 请求。

• 反向代理：通过 nginx、Apache 等反向代理服务器，将前端请求转发到目标服务器，再将目标服务器返回的数据返回给前端，使得前端代码和目标服务器属于同一域名和端口。需要服务器的配置和管理。

• WebSocket：建立双向通信通道，通过特定的 API 实现浏览器和服务器之间的实时数据传输。需要服务器的支持。

59.怎么判断一个变量arr的话是否为数组（此题用 typeof 不行）

• 使用 instanceof 运算符， 该运算符左边是我们想要判断的变量， 右边则是我们想要判断的对象的类，
• 利用构造函数来判断他的原型是否为Array， 用法： 变量.constructor === 变量类型
• 利用的一个专门的方法 isArray()， 用法：Array.isArray(变量)，返回true，则说明该变量是数组类型；反之，说明该变量不是数组类型
• 调用Object.prototype.toString.call()，返回true，则说明该变量是数组类型；反之，说明该变量不是数组类型
• 通过对象的原型方式来判断
• 通过 Object.getPrototypeOf()来判断是否为数组类型
• 是通过 isPrototypeOf() 方法来判断是否为数组类型

60.你对SPA单页面的理解，它的优缺点分别是什么？如何实现SPA应用呢

SPA应用就是一个web应用，可理解为：是一种只需要将单个页面加载到服务器之中的web应用程序。当浏览器向服务器发出第一个请求时，服务器会返回一个index.html文件，它所需的js，css等会在显示时统一加载，部分页面需要时加载。

优点：1：良好的交互式体验 2：良好的前后端分离模式（MVVM），减轻服务端压力。3：共用同一套后端程序代码，不用修改就可用于web界面，手机和平板等客户端设备

缺点：1.不利于SEO优化。2.不能使用浏览器自带的前进和后退功能3…首屏加载过慢。

实现一个SPA：

1. 监听地址栏中hash变化驱动界面变化
2. 用pushsate记录浏览器的历史，驱动界面发送变化

61.SPA首屏加载速度慢怎么解决

加载慢的原因
1.网络延时问题
2.资源文件是否体积过大
3.资源是否重复发送请求加载
4.加载脚本的时候，渲染内容堵塞
解决优化方案
1.减小入口文件体积
2.静态资源本地缓存
3.第三方插件按需加载或者使用CDN引用
4.图片资源压缩
5.抽离公共组件避免重复打包
6.开启GZip压缩
7.使用SSR

62.说说箭头函数和普通函数的区别

1. 语法上的区别：箭头函数使用箭头符号（=>）来定义函数，而普通函数使用 function 关键字定义。
2. this 指向不同：箭头函数没有自己的 this，它的 this 指向的是定义时的作用域中的 this；而普通函数的 this 指向的是调用时的上下文对象。
3. 箭头函数没有 arguments 对象，因此不能直接访问函数参数；而普通函数可以使用 arguments 对象来访问函数参数。
4. 箭头函数不能作为构造函数使用，因为它没有自己的 this 对象；而普通函数可以通过 new 关键字来作为构造函数使用，生成一个新的实例对象。

总的来说，箭头函数相对于普通函数来说更加简洁，但是在某些场景下可能会有一些限制，需要根据实际情况进行选择。

63.如何快速的让一个打乱一个数组的顺序，比如 var arr = [1,2,3,4,5,6,7,8,9,10

1.时间复杂度O（n^2）

2.时间复杂度O（n）

原理：主要是将数组里的索引值随机打乱，然后将当前的索引值与随机变化之后的索引值互换。

(1).首先遍历的开始是从最大的索引开始，然后逐次递减；

(2).然后选取一个随机值randomIndex，这个随机值的产生是在0-len（即数组的长度）之间产生，由于这个值不能为len（因为数组的索引是从0开始的），只能为len-1，故只能向下取整Math.floor；

(3).取到随机值之后，将这个随机值对应的数组值即arr[randomIndex]赋值给当前遍历的i对应的数组值即arr[i]；

3.sort 是对数组进行排序，每次从数组里面挑选两个数 进行运算。

• 如果传入的参数是0，两个数位置不变
• 如果参数小于0，就交换位置
• 如果参数大于0，就不交换位置

我们利用 Math.random-0.5，这个运算的结果要么是大于0,要么是小于0.这样要么交换位置，要么不交换位置。当然大于或者小于0是随即出现的。所以数组就被随即排序了。

64.说说什么是严格模式，限制都有哪些

严格模式：当我们在开发项目时，难免会有写的不规范的js代码，当我们开启严格模式后就会提示我们当前的代码有需要改进的地方，比如定义了一个未使用的变量。

定义未使用的变量或方法、严格使用双引号、等等

严格模式的限制：

• 变量必须声明后再使用
• 函数的参数不能有同名属性，否则报错
• 不能使用with语句
• 不能对只读属性赋值，否则报错
• 不能使用前缀 0 表示八进制数，否则报错
• 不能删除不可删除的属性，否则报错
• 不能删除变量delete prop，会报错，只能删除属性delete global[prop]
• eval不会在它的外层作用域引入变量
• eval和arguments不能被重新赋值
• arguments不会自动反映函数参数的变化
• 不能使用arguments.callee
• 不能使用arguments.caller
• 禁止this指向全局对象
• 不能使用fn.caller和fn.arguments获取函数调用的堆栈
• 增加了保留字（比如protected、static和interface）

65. 说说Promise和async/await的区别是？

Promise是原生的解决异步代码的对象，promise中有三个状态分别是pedding等待中、rejected失败、resolve成功，根据三个状态可以拿到我们的异步任务执行的结果，其中通过链式的.then回调方法中操作。

Async/await是基于promise封装的解决异步编程带来的回调地狱的终极方案，当我们呢在有很多的异步任务相互嵌套执行时就会出现，无限的层级嵌套，代码相当不清晰，async和await的出翔解决了这个问题。

66.伪类和伪元素的区别有哪 些？ Css3新增了哪些选择器

1. 伪类本质上是为了弥补常规CSS选择器的不足，以便获取到更多信息；
2. 伪元素本质上是创建了一个有内容的虚拟容器；
3. CSS3中伪类和伪元素的语法不同；
4. 可以同时使用多个伪类，而只能同时使用一个伪元素；

CSS3 新增了很多选择器，其中一些比较常用的包括：

• :nth-child(n)选择器可以选中父元素下的第n个子元素，例如：nth-child(3)可以选中父元素下的第3个子元素。
• :not(selector)选择器可以排除某些元素，例如:not(.class)可以选中除了具有class类名的元素以外的所有元素。
• :first-child选择器可以选中父元素下的第一个子元素，例如：p:first-child可以选中父元素下的第一个p元素。
• :last-child选择器可以选中父元素下的最后一个子元素，例如：p:last-child可以选中父元素下的最后一个p元素。
• :before伪元素可以在元素内容前插入一些内容，例如：p::before { content: “前缀” }可以在每个p元素前插入一个“前缀”文本。

67. null，undefined 的区别

他们的数据类型不一样：null的数据类型为object、而undefined为undefined

他们相等于但是不恒等于，null定义的数据表示数据为空

总结来说，undefined 表示的是变量未定义或未初始化，而 null 表示变量的值为空。 需要注意的是，在条件判断时，null==undefined 返回 true，但它们的数据类型不同，所以 null === undefined 返回 false。

68.说说css中元素脱离文档流的方式有哪些？定位的方式有哪些以及区别？

元素脱离文档流的方式有以下几种：

• position: absolute：将元素从文档流中移除，相对于最近的已定位祖先元素定位。
• position: fixed：将元素从文档流中移除，相对于浏览器窗口定位。
• float：将元素从文档流中移除，允许文本和行内元素环绕它。

定位的方式有以下几种：

• position: static：默认值，元素正常的文档流定位方式，不会受到 top、bottom、left、right 等属性的影响。
• position: relative：相对定位，元素在正常的文档流中，相对于自己原来的位置进行定位，不会影响其他元素的位置。
• position: absolute：绝对定位，元素脱离文档流，相对于最近的已定位祖先元素定位，如果没有已定位的祖先元素，则相对于 html 元素定位。
• position: fixed：固定定位，元素脱离文档流，相对于浏览器窗口进行定位。
• position: sticky：粘性定位，元素在跨越特定阈值前为相对定位，之后为固定定位。

相对定位和绝对定位的区别在于，相对定位是相对于元素原来的位置进行定位，不会影响其他元素的位置，而绝对定位是相对于最近的已定位祖先元素进行定位。

固定定位和绝对定位的区别在于，固定定位是相对于浏览器窗口进行定位，不会随着滚动而移动，而绝对定位是相对于最近的已定位祖先元素进行定位，如果没有已定位的祖先元素，则相对于 html 元素定位。

69. 网站性能优化的方案都有哪些？

1. 尽量减少HTTP请求次数
2. 延迟加载内容
3. 使用离线缓存
4. CSS、JS放置正确位置
5. 静态资源压缩
6. 静态资源使用多个域名
7. 静态资源使用cdn存储
8. 预加载
9. DOM操作优化
10. 优化算法

70.说说浏览器的渐进增强和优雅降级的区别？

渐进增强可以理解为向上兼容，一开始针对较为低版本的浏览器来构建页面，保证页面的所有基本的功能点都能实现；然后根据更高版本的浏览器设计一些在用户体验上更为良好的交互界面、追加更多的功能。

优雅降级可以理解为向下兼容，一开始就对高版本的浏览器构建功能、性能、体验都较为完美页面，然后针对低版本的浏览器进行兼容补充。

两者的区别在于：渐进增强属于从基础的页面中增加更多的功能（加）；优雅降级是属于从功能丰富的页面上慢慢地减少页面的功能、用户的体验等等。

71.举一些ES6对Array数组类型做的常用升级优化

优化部分:

数组的解构赋值

ES6可以直接以下形式进行变量赋值

在声明较多变量时，不需要再写很多let（或var），且映射关系清晰，支持赋默认值。

扩展运算符

ES6新增的扩展运算符（…），可以轻松的实现数组和松散序列（比如集合等）的相互转换，可以取代arguments对象和apply方法，轻松获取未知参数个数情况下的参数集合。（尤其是在ES5即传统js中，arguments不是一个真正的数组，而是一个类数组的对象，但是扩展运算符的逆运算却可以返回一个真正的数组）。扩展运算符还可以轻松实现数组的复制和解构。

升级部分:

ES6在Array原型上新增了find（）方法，用于取代传统只能indexOf()查找数组项目的方法，且修复了indexOf查找不到NaN的bug

此外，还新增了copyWithin()、includes()、fill()、flat()等方法，可方便用于数组的查找，补全，和转换等。

72.babel是什么，有什么作用?

Babel 是 JavaScript 编译器：他能让开发者在开发过程中，直接使用各类方言（如 TS、Flow、JSX）或新的语法特性，而不需要考虑运行环境，因为Babel可以做到按需转换为低版本支持的代码；Babel内部原理是将 JS 代码转换为 AST，对 AST 应用各种插件进行处理，最终输出编译后的 JS 代码。

Babel 编译流程:

1. 解析阶段：Babel 默认使用 @babel/parser将代码转换为AST。解析一般分为两个阶段：词法分析和语法分析。
   1. 词法分析：对输入的字符序列做标记化(tokenization)操作。
   2. 语法分析：处理标记与标记之间的关系，最终形成一颗完整的 AST 结构。
2. 转换阶段：Babel 使用 @babel/traverse 提供的方法对 AST 进行深度优先遍历，调用插件对关注节点的处理函数，按需对 AST 节点进行增删改操作
3. 生成阶段：Babel默认使用 @babel/generator 将上一阶段处理后的 AST 转换为代码字符串。

73.let有什么用，有了var为什么还要用let

var是全局声明，let是块级作用的，只适用于当前代码块

var变量会发生变量提升，let则不会进行变量提升

var 会造成重复赋值，循环里的赋值可能会造成变量泄露至全局

let在一个块级作用只能赋一次值，并进行当前代码块的锁区，就是说当前块只有let声明的这个变量是有用的

let在一个块级内，只能声明一个一个相同的变量名

74.举一些ES6对String字符串类型做的常用升级优化?

优化部分:

ES6新增了字符串模板，在拼接大段字符串时，用反引号(`)取代以往的字符串相加的形式,能保留所有空格和换行，使得字符串看起来更加直观、优雅。

ES6模板字符串，允许换行和空格，读写性强

升级部分:

ES6在String原型上新增了includes（）方法，用于取代传统只能用indexOf查找包含字符串的方法（indexOf返回-1表示没查到，不如includes（）返回false更明确，语义更清晰），此外还新增了startsWith（）、endsWith（）、padStarts（）、padEnd（）、repeat（）等方法，可更加方便的用于查找、补全字符串

75.ES5、ES6和ES2015有什么区别?

三者区别：

ES2015特指在2015年发布的新一代JS语言标准，ES2015可以理解为ES5和ES6的时间分界线

ES6泛指下一代JS语言标准，包含ES2015、ES2016、ES2017、ES2018等。现阶段在绝大部分场景下，ES2015默认等同ES6。

ES5泛指上一代语言标准。

ES6新增特性：

let const 定义块级作用域
箭头函数
解构赋值
扩展运算符
常见的数组的方法，伪数组
模板字符串
class类
参数设置默认值
promise
for…of for…in

76.如何让CSS只在当前组件中起作用?

当前组件