如题。不要说什么window.onload这种随意查出来的了

比如N个图片  我要的是这个页面上所有的图片都完整渲染出来了 已经可以看见了

onload有时候会出现图片还没渲染完成

可以用print试试

如何监听页面所有资源渲染完毕？

有一个容器 放大到了原来的两倍

里面的元素可以自由拖拽。

但是原来的拖拽逻辑和缩放之后的就有了冲突

移动距离和鼠标不对等。

有什么好思路

如何处理缩放后的位移逻辑？

一般我们flex外围的容器限定了宽度

而flex内的宽度却超过了显示宽度

这时虽然可以正常布局

但是如果通过获取clientWidth和offsetWidth是最多只能获取到容器的宽度的

也就是以下情况

```html
<div class="box">
    <div class="flex">
        ...若干子元素
    </div>
 </div>
```

这时候我们直接获取flex的宽度  最大就是box的宽度

而不是flex的实际宽度

这里我们就要使用scrollWidth来获取实际宽度

flex容器宽度不真实解决办法

JSX是一种描述组件内容的数据结构，为JS赋予了更多的视觉表现力


Fiber相对于JSX来说是储存的JSX的编译结果，并且会多出一些信息。

比如组件更新的优先级，

组件的state

被打上的Renderer标记 等等


所以，在组件mount的时候，Reconciler根据JSX描述的组件内容生成Fiber节点

在update时，Reconciler将JSX与Fiber节点保存的数据进行比对，生成组件对应的Fiber节点，并根据对比结果为Fiber节点打上标记

____________________________________________________________________________________________________________________

大多数的Vue模板编译发生在打包阶段，但提供了runtime-with-complier的版本可以在运行时编译。做一些特殊需求。

什么是JSX?

首先一个问题困扰了我很久。AST到底是一种标准还是一个概念？

先讲一下我对标准和概念的区分。


#### 标准

标准就是一种定式。大家都按这种定式去做，大家所做出来的东西只要按照这种标准去理解都可以看的懂，可以互用。就像js，你写的和我写的尽管再不相同，但大家都是遵循JS语法规范去做的。所以不影响我阅读和使用你写的东西。

#### 概念

概念就是一种想法，有利于处理这个问题的思路。大家都按照这种好的思路去做，做出来的东西可以互相看不懂，但是核心思想都是基于这个概念。就像面向对象，java(我也不懂，就这么一说)和js。大家实现的都是基于封装，继承，多态的思想。但是我直接使用你的甚至阅读是不互通的，因为我们都有自己定义好的实现细节。


先讲我截至(2021年01月28日17:13:53) 的理解结论：是一种概念(但因为做的人多了，就诞生出了小范围的标准，但你可以不遵守标准也丝毫不影响你实现这个概念)。

> 
>
> 

以上两张截图来自于https://blog.flqin.com/367.html

先感谢这位大佬的文章解决了我查阅很多资料和文档都没有解决的困惑。拜谢！

主要集中到这句话：每一个JS引擎都会有自己的抽象语法树格式。

然后我去粗略看了babel和jsx实现。果然如此！

那么就可以断定AST是一种处理语言的思想概念，基于这种转化可以更好，更简单有效的对语法做出分析。然后进行具体实现。也就是说即使我们没有按照AST对象文档的标准来做解析，只要我们是按照这种抽象语法提取思想去对目标语言去进行分析从而所生出的对象结构你都可以叫他AST，而不是非得有loc,source等什么的这种对象结构。你可以任意的命名，任意的分析，从而诞生出对你所解析的这段文本模板的抽象描述。只要他符合你接下来的编译需求。


理解了什么是AST之后我们来模拟回答两个问题。

1. 为什么vue要生成AST？
2. 为什么不直接使用AST转化VNode,而要经过render?


我的回答：

1. 要理解为什么生成AST,首先要知道AST的作用在哪。

那么AST的作用在于通过对语言文本模板的静态解析形成抽象语法树，以至于更好的表现编程语言的语法结构。从而将解析，验证逻辑以及具体实现所分离（就像语法解析，验证检测，和实际执行分开）。

这样做如果有语法层面的错误将会及时暴露，而不会出现在具体实现该语法的逻辑时出现错误。而以上这些东西实际都是对某种语言所进行的编译处理时做的。

而vue也加入了自己定义的模板，所以我把它称之为建立在前端部分语言(html,js)之上建立的一种新的，就算不称之为语言但可以称之为新语法的语法模板。所以使用AST概念去作为编译具体指令，词法等等之前的抽象准备是很有必要的。当然你也可以不实现这个概念，直接通过字符串解析去实现具体指令也是可以的。但是请记住，虽然我们不能说谁是最好的方式，但是方式不同，到目的地的路程可能差的很多。

2.这里就要理解好AST的作用对象。它解析的对象实质上只是这些文件的静态字符串(模板，随你怎么称呼，他都只是一段文本，一段由人敲键盘所产生的字符串)。而这段文本在具体执行时是不会变的(至少你写的const a = 1;不会在执行这段代码的时候变成const b #￥%等等)。所以即便你看到的AST对象和VNode再像也不是属于一个时空的东西。VNode是会变化的，会随着代码的执行，逻辑的变化而变化的东西。

那为什么需要经过render?这里我们不谈具体的细节，我们只需要知道render对AST做了什么。render拿到AST然后才确定了对每一段编译过的代码，比如v-if,{{xxx}}等等该做了什么样的逻辑处理，记住这段逻辑处理行为在编译完生成render之后就固定了(借此我们也可以理解到各编程语言在你写完代码，编译完之后。你的代码的执行逻辑就固定了，就像a + b他就是会处理两个变量的相加)。而转化VNode也是在render之后就固定好的其中一段逻辑处理而已。所以核心就是他们所处的时空是不一样的。

AST学习记录(不需要内部细节)

由于递归执行，所以更新一旦开始，中途就无法终端。当层级很深时，递归更新时间超过了16ms，用户交互就会卡顿。


React16的架构在15的基础上增加了Scheduler

Scheduler负责调度任务的优先级，高优任务优先进入Reconciler


在React16中Reconciler更新工作从递归变成了可以中断的循环过程。每次循环都会调用shouldYield来判断当前是否还有剩余时间


而为了解决中断更新带来的DOM渲染不完全问题，Reconciler和Renderer不再是交替工作。当Scheduler将任务交给Reconciler之后，Reconciler会为变化的虚拟DOM打上代表增/删/更新等标记。整个Scheduler和Reconciler的工作都在内存中进行。只有当所有组件都完成Reconciler的工作，才会统一交给Renderer。


其实浏览器原生就支持类似的实现，就是Generator。但是Generator的缺陷是具有传染性，使用了Generator则上下文的其他函数也需要做出改变。心智负担比较重。


而且Generator执行的中间状态是上下文关联的，当高优先级任务插队的时候，无法复用之前已经执行出的结果。需要重新计算。如果通过全局变量保存之前的执行结果，又会引入新的复杂度。


在React中JSX最终会变编译成React.createElement的显式调用，所以这也是为什么每个JSX的js文件中必须要显式声明React

递归更新的缺点

首先让我们来看看《JavaScript高级程序设计》的原话

> 变量或函数的上下文决定了它们可以访问哪些数据，以及它们的行为。
>
> 每个上下文都有一个关联的变量对象（variable object），而这个上下文中定义的所有变量和函数都存在于这个对象上

假设把每个人都看做一段代码。

正如我们的执行环境在宇宙。

对我们来说宇宙就是一个全局执行上下文，所以宇宙中的变量比如太阳，地球的都挂在宇宙这个对象上虽然可能层级是(宇宙.xxx.xxx.地球)但是不影响我们用这个来理解。

那么在浏览器中全局上下文就是我们常说的 window 对象，nodejs中就是global对象。

知道了这个概念，我们就很容易去理解这句话

> 上下文在其所有代码都执行完毕后会被销毁，包括定义在它上面的所有变量和函数
>
> （全局上下文在应用程序退出前才会被销毁，比如关闭网页或退出浏览器）

但是所有行为都是有生命周期的，不可能每个人做一件事都必须等到宇宙毁灭才会真正结束。

所以宇宙为了更好的利用资源，从而可以产生更多的行为来充实这一次短暂而又漫长的生命。

就出现了内部(包含)上下文。正如我们每个人会有自己学习环境，工作环境，家庭环境等等一样。

JS的每个函数都会有自己的执行上下文。

> 当代码执行流进入函数时，函数的上下文被推到一个上下文栈上。
>
> 在函数执行完之后，上下文栈会弹出该函数上下文，将控制权返还给之前的执行上下文

那么这段话如何理解？上下文在哪？

### 变量对象&活动对象

函数执行上下文的创建，发生在函数调用时但在执行函数体内的具体代码之前在创建阶段JS引擎会使用当前函数的参数列表（arguments）初始化一个上面最开始提到的变量对象。

并将当前执行上下文与之关联，函数代码块中声明的 变量 和 函数 将作为属性添加到这个变量对象上。

> 注意：只有函数声明（function declaration）会被加入到变量对象中，而函数表达式（function expression）会被忽略

```
// 这里是函数声明 会被加入变量对象
function haha(){}

// 这里是函数表达式 只有hehe会被已变量的形式加入变量对象  而_hehe不会被加入
var hehe = function _hehe(){}
```

在这一阶段，会进行变量和函数的初始化声明，然后再接着往下开始执行(父级上下文)。

> 这里又有一个概念，具体执行之前。非全局上下文的变量对象(VO)此时还是处于不能使用的状态。是无法直接访问的。在进入执行阶段之时，变量对象（VO）被激活为活动对象（AO）时，我们才能访问到其中的属性和方法。
>
> 其实变量对象和活动对象是一个东西，只不过处于不同的状态和阶段而已。

如果碰到新的需要创建上下文的函数调用，又会开始重复创建上下文的工作（子级上下文）。但是此时会将控制权从手中交出，给到子级上下文执行。直到执行完毕退出，子级将控制权又返还给到父级上下文。如此这般周而复始，直到全局上下文销毁。

看下面的代码

```
function a() {
    console.log('a')
}

function b() {
    a();
}

function c() {
    b();
}

c();
```

首先创建全局上下文，然后定义a,b,c三个函数，所以此时全局上下文作为最外层的上下文环境被压入上下文栈。

然后碰到c函数执行，于是开始创建c函数上下文。之后全局上下文将控制权交给c函数上下文，并将c函数上下文压入上下文栈。

c函数上下文开始执行，碰到b函数执行，于是开始创建b函数上下文。之后c将控制权交出给到b。并将b压入上下文栈。

b函数上下文开始执行，碰到a函数执行，于是开始创建a函数上下文。之后b将控制权交出给到a。并将a压入上下文栈。

此时上下文栈内按照先进顺序展示是 全局->c->b->a

那么a执行中执行完了console.log('a')之后。a函数告诉上下文栈我执行完毕了，于是a被推出上下文栈，并将控制权交给b，告诉b可以继续执行剩下的东西了。

而b拿到控制权之后开始继续往下执行，找不到需要执行的。就执行完毕了，于是第二个被推出了栈。同样的将控制权交给了c。c又重复了上面那个过程。直到c执行完毕被推出了栈。此时控制权回到全局上下文。而全局上下文上面说了会等到整个环境被销毁，比如关闭页面，或者nodejs执行完毕了所有东西 才会被销毁。

至此对于执行上下文的变量对象我们已经有了一定的了解。

### 作用域

那么是什么让我们可以在子级上下文中使用父级，爷级...乃至全局上下文的各种资源呢?

> 上下文中的代码在执行的时候，会创建变量对象的一个作用域链（scope chain）。这个作用域链决定
>
> 了各级上下文中的代码在访问变量和函数时的顺序。代码正在执行的上下文的变量对象始终位于作用域
>
> 链的最前端。如果上下文是函数，则其活动对象（activation object）用作变量对象。活动对象最初只有
>
> 一个定义变量：arguments。（全局上下文中没有这个变量。）作用域链中的下一个变量对象来自包含上
>
> 下文，再下一个对象来自再下一个包含上下文。以此类推直至全局上下文；全局上下文的变量对象始终
>
> 是作用域链的最后一个变量对象。

没错，链如其名。用人话讲，这就是在执行阶段会创建一根绑了很多变量对象的链子。

嗯~大概长下面这样


(图片来自网络，侵删)

链子的两头是当前变量对象和全局变量对象。而这中间可以经历无数个上级变量对象

所以当前执行代码会优先从当前变量对象中找需要的变量。(毕竟是自家人)。

如果没有找到，则会去上级找，再没有再上一级，直到找到全局中为止。 我们假设一条链上两个变量对象之间的距离需要十分钟才能走完。那么全局是距离当前最远的。所以你知道就近原则怎么来的嘛。

所以作用域链的核心就是这句话： 作用域链决定了各级上下文中的代码在访问变量和函数时的顺序

### 闭包

那么闭包呢？闭包的执行已经结束，而闭包内的变量都是挂载闭包那个上下文对象的。为什么出来后还可以继续使用？

那么这里先看看闭包的定义

> 有权访问另一个函数内部变量的函数。简单说来，如果一个函数被作为另一个函数的返回值，并在外部被引用，那么这个函数就被称为闭包。

```
// 我是闭包啊
function f(){
  var a = 1;
  return function(){
    console.log(a)
  }
}
var demo = f()
demo() // -> 1
```

这段代码里可以看到在f的变量对象中会有一个a，这个a被return 出去的匿名函数引用了。所以即使f的执行上下文执行完毕之后已经销毁，但辣鸡回收机制还是无法回收a变量，也就是f的变量对象无法销毁，一直常驻内存中。但f的作用域链已经随着上下文的销毁而寿终正寝。而f的变量对象只有等到外部引用的demo执行上下文也销毁完毕才会被释放。 所以这就是闭包为什么能在执行结束之后还可以在外部继续使用内部变量。其核心就是变量对象没用被销毁。

### 作用域链增强

什么是作用域链增强？

我们上面介绍了作用域链的核心：作用域链决定了各级上下文中的代码在访问变量和函数时的顺序。

那么增强就可以理解为人为的去改变作用域链。怎么能不刺激？

来看书里的原话：

> 虽然执行上下文主要有全局上下文和函数上下文两种（eval()调用内部存在第三种上下文），但有
>
> 其他方式来增强作用域链。某些语句会导致在作用域链前端临时添加一个上下文，这个上下文在代码执
>
> 行后会被删除。通常在两种情况下会出现这个现象，即代码执行到下面任意一种情况时：
>
>  try/catch 语句的 catch 块
>
>  with 语句
>
> 这两种情况下，都会在作用域链前端添加一个变量对象。对 with 语句来说，会向作用域链前端添
>
> 加指定的对象；对 catch 语句而言，则会创建一个新的变量对象，这个变量对象会包含要抛出的错误
>
> 对象的声明

所以我们可以了解到 catch会创建一个新的变量对象来加入到作用域链中

with会将一个变量对象添到作用域链的最前端来

虽然不推荐但我们可以看看效果

##### with


with把本属于全局变量对象的location 放到内部块的作用域链最前端。

所以会优先先去location对象中找href变量。

##### catch


carth则是在捕获到异常的情况，创建了一个新的error变量对象。并放置在内部的作用域的前面。

### 变量提升

上了点年纪的前端都受到过这个问题的困扰，没上年纪的也在面试中被经常作为基础题问到。

那么什么是变量提升？

上面我们知道了执行上下文内的所有变量(var声明的)和函数都会挂在生成的变量对象上。

然鹅 知其然也要知其所以然。

所以我们需要先了解什么是变量声明以及这个挂载的过程。

```
var a = 1;
```

上面的代码在JS生成变量对象的时候。会先检测内部的变量和函数。 然后将其提升到执行上下文的顶部最先初始化。

所以var a = 1 就会先变成 var a; 然后在变成 a = 1; 分开两步走。

那么我们通过代码来验证一下

```
console.log(a); // undefined
var a = 1;
```

可以看到在变量声明之前的打印已经可以打印出undefined。

var 声明会被拿到函数或全局作用域的顶部，位于作用域中所有代码之前。这个现象叫作“提升”

那么在JS中还存在一种这样的写法

```
function demo(){
    a = 2;
}
demo();
console.log(a); // 2
```

此时我们可以看到 变量a并没有使用var语句以及其他语句来声明，而是直接赋值。

这是因为如果省略var语句声明变量，该变量就会被提升到最顶级也就是全局上下文的变量对象中区初始化。

### ES6.let&const

#### let

> ES6 新增的 let 关键字跟 var 很相似，但它的作用域是块级的，这也是 JavaScript 中的新概念。

什么是块级作用域？非常容易理解，你只需要记住，最近的一对花括号{}就是一个块级作用域。

那么这个块级作用域有什么用呢？

顾名思义就是由let声明的变量只能在这个块内起作用。所以我们可以来干下面这样的事情

```
for (var i = 0; i < 10; ++i) {} 
console.log(i); // 10 
for (let j = 0; j < 10; ++j) {} 
console.log(j); // ReferenceError: j 没有定义
```

和var的区别在于：

1. 使用 var 声明的迭代变量会泄漏到循环外部，let不会
2. var可以重复声明，let不可以
3. 都会变量提升但是var的变量可以在赋值之前访问到，而let的变量会在提升之后，赋值之前形成一个封闭区域(暂时性死区),此时无法访问。

#### const

> 使用 const 声明的变量必须同时初始化为某个值。一经声明，在其生命周期的任何时候都不能再重新赋予新值。

核心就是两点：

1. 声明的同时必须有值
2. 常量，任何时候不可以更改

其他都和上面的let一致


所以你以为到此就结束了嘛，龙宫法术，博大精深。远不止于此。

### 词法环境

没错，出现了一个新的东西(至少在JS高程4里我没看到)。

出现于各种介绍JS执行上下文的文章之中，但我最终确实没有看懂什么是词法环境，以及他出现的原因和解决的问题。

那么什么是词法环境？先看JS说明书的原文

> A Lexical Environment is a specification type used to define the association of Identifiers to specific variables and functions based upon the lexical nesting structure of ECMAScript code. A Lexical Environment consists of an Environment Record and a possibly null reference to an outer Lexical Environment. Usually a Lexical Environment is associated with some specific syntactic structure of ECMAScript code such as a FunctionDeclaration, a BlockStatement, or a Catch clause of a TryStatement and a new Lexical Environment is created each time such code is evaluated.
>
> An Environment Record records the identifier bindings that are created within the scope of its associated Lexical Environment. It is referred to as the Lexical Environment's EnvironmentRecord.
>
> The outer environment reference is used to model the logical nesting of Lexical Environment values. The outer reference of a (inner) Lexical Environment is a reference to the Lexical Environment that logically surrounds the inner Lexical Environment. An outer Lexical Environment may, of course, have its own outer Lexical Environment. A Lexical Environment may serve as the outer environment for multiple inner Lexical Environments. For example, if a FunctionDeclaration contains two nested FunctionDeclarations then the Lexical Environments of each of the nested functions will have as their outer Lexical Environment the Lexical Environment of the current evaluation of the surrounding function.
>
> A global environment is a Lexical Environment which does not have an outer environment. The global environment's outer environment reference is null. A global environment's EnvironmentRecord may be prepopulated with identifier bindings and includes an associated global object whose properties provide some of the global environment's identifier bindings. As ECMAScript code is executed, additional properties may be added to the global object and the initial properties may be modified.

> A module environment is a Lexical Environment that contains the bindings for the top level declarations of a Module. It also contains the bindings that are explicitly imported by the Module. The outer environment of a module environment is a global environment.

> A function environment is a Lexical Environment that corresponds to the invocation of an ECMAScript function object. A function environment may establish a new this binding. A function environment also captures the state necessary to support super method invocations.

> Lexical Environments and Environment Record values are purely specification mechanisms and need not correspond to any specific artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to directly access or manipulate such values.


嗯~通过强大的谷歌翻译再加我自己的大脑翻译

大致就是这么个意思(个人理解)：

首先词法环境你可以说是一个类似于变量环境的东西。但说明书里只说这是一种定义的规范机制，不应该把他和任何实现联系。但是有趣的是通过查阅其他文章和资料我们发现，和一些具体实现还是有联系的。

> Lexical Environments and Environment Record values are purely specification mechanisms and need not correspond to any specific artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to directly access or manipulate such values.

首先与变量环境只挂载var变量不同，你用let和const声明的变量是挂在词法环境的，而说明书里也说了词法环境实质上不可访问，所以我们可以把暂时性死区放到这边关联起来就说的通。而这个阶段实际上有个专业名称叫词法分析。

而整个往下过程也和上面的执行环境介绍惊人相似。

通过说明书可以看到，词法环境也是分为全局词法环境(实际上说明书并不承认这是全局词法环境，但我的理解全局词法环境其实就是和全局上下文一样。最外层的那个词法环境)，模块环境(不要被这些高大上的名字欺骗，我的理解就是块级作用域)，函数环境(递归上面的概念，但是会创建一个新的this绑定，没错)所以看完这些 我的理解词法环境的核心就是：一个比执行环境原有概念和功能更丰富的，但机制和流程上没有区别的新的环境对象，内部也会有类似变量对象(let&const 函数 挂载地),作用域链(词法环境嵌套).---有错误请大佬及时指正

#### 环境记录

详细说明说可以看这里 https://262.ecma-international.org/10.0/#sec-declarative-environment-records

大致就是将整个环境记录分为了三个过程， 声明记录，对象记录，以及全局记录

其中声明记录又分为 模块记录 和 函数记录两个过程

所以我这边理解一下就是

对于变量的let&const 函数 import/export 以及class 都是在声明记录的过程中去进行解析和挂载。

而对象记录， 就是对于对象内部的一个环境记录，也就是基于对象型的值内部做解析和挂载。有提到with的其实我也把他理解为一个对象，因为上面说了with就是类似复制了一个变量对象添加到作用域链前端

函数记录就相对比较好理解， 只要不是箭头函数和super，在此都会提供一个this绑定进去.

全局环境记录，就理解成全局环境就好了，具体里面做的事情也很多 绑定全局对象，设定内置变量等等

模块环境记录，这个从名字上就可以知道。是对于import/export的对象进行一个记录和解析。


以上仅是个人学习之后的理解，如有错误，请各位大佬指正。





JS执行环境

## 什么是链表

来自该文章，链表的定义 下面的定义都是来源这篇文章，解释的很好

### 链表的定义

链表是物理存储单元上非连续的、非顺序的存储结构，它是由一个个结点，通过指针来联系起来的，其中每个结点包括数据和指针。


链表的非连续，非顺序，对应数组的连续，顺序，我们来看看整型数组 1，2，3，4 在内存中是如何表示的


可以看到数组的每个元素都是连续紧邻分配的，这叫连续性，同时由于数组的元素占用的大小是一样的，在 Java 中 int 型大小固定为 4 个字节,所以如果数组的起始地址是 100， 由于这些元素在内存中都是连续紧邻分配的，大小也一样，可以很容易地找出数组中任意一个元素的位置，比如数组中的第三个元素起始地址为 100 + 2 * 4 = 108,这就叫顺序性。查找的时间复杂度是O(1),效率很高！

那链表在内存中是怎么表示的呢


可以看到每个结点都分配在非连续的位置，结点与结点之间通过指针连在了一起，所以如果我们要找比如值为 3  的结点时，只能通过结点 1 从头到尾遍历寻找，如果元素少还好，如果元素太多（比如超过一万个），每个元素的查找都要从头开始查找，时间复杂度是O(n)，比起数组的 O(1)，差距不小。

除了查找性能链表不如数组外，还有一个优势让数组的性能高于链表,这里引入程序局部性原理，啥叫程序局部性原理。

我们知道 CPU 运行速度是非常快的，如果 CPU 每次运算都要到内存里去取数据无疑是很耗时的，所以在 CPU 与内存之间往往集成了挺多层级的缓存，这些缓存越接近CPU，速度越快，所以如果能提前把内存中的数据加载到如下图中的 L1, L2, L3 缓存中，那么下一次 CPU 取数的话直接从这些缓存里取即可，能让CPU执行速度加快，那什么情况下内存中的数据会被提前加载到 L1,L2,L3 缓存中呢，答案是当某个元素被用到的时候，那么这个元素地址附近的的元素会被提前加载到缓存中


以上文整型数组 1，2，3，4为例，当程序用到了数组中的第一个元素（即 1）时，由于 CPU 认为既然 1 被用到了，那么紧邻它的元素 2，3，4 被用到的概率会很大，所以会提前把 2，3，4 加到 L1,L2,L3 缓存中去，这样 CPU 再次执行的时候如果用到 2，3，4，直接从 L1,L2,L3 缓存里取就行了，能提升不少性能

画外音：如果把 CPU 的一个时种看成一秒，则从 L1 读取数据需要 3 秒，从 L2 读取需要 11 秒，L3读取需要 25秒，而从内存读取呢，需要 1 分 40 秒，所以程序局部性原理能对 CPU 执行性能有很大的提升

而链表呢，由于链表的每个结点在内存里都是随机分布的，只是通过指针联系在一起，所以这些结点的地址并不相邻，自然无法利用 程序局部性原理 来提前加载到 L1,L2,L3 缓存中来提升程序性能。

画外音：程序局部性原理是计算机中非常重要的原理，这里不做展开，建议大家查阅相关资料详细了解一下

如上所述，相比数组，链表的非连续，非顺序确实让它在性能上处于劣势，那什么情况下该使用链表呢？考虑以下情况

* 大内存空间分配

由于数组空间的连续性，如果要为数组分配 500M 的空间，这 500M 的空间必须是连续的，未使用的，所以在内存空间的分配上数组的要求会比较严格，如果内存碎片太多，分配连续的大空间很可能导致失败。而链表由于是非连续的，所以这种情况下选择链表更合适。

* 元素频繁删除和插入

如果涉及到元素的频繁删除和插入，用链表就会高效很多，对于数组来说，如果要在元素间插入一个元素，需要把其余元素一个个往后移（如图示），以为新元素腾空间（同理，如果是删除则需要把被删除元素之后的元素一个个往前移），效率上无疑是比较低的。

(在 1，2 间插入 5，需要把2，3，4 同时往后移一位)

而链表的插入删除相对来说就比较简单了，修改指针位置即可，其他元素无需做任何移动操作（如图示：以插入为例）

综上所述：如果数据以查为主，很少涉及到增和删，选择数组，如果数据涉及到频繁的插入和删除，或元素所需分配空间过大，倾向于选择链表。

什么是链表

时间戳的概念和历史有兴趣可以看看

> http://jerey.cn/time/2018/02/10/Time%E7%B3%BB%E5%88%97%E4%B9%8B%E5%90%84%E4%B8%AA%E6%97%B6%E9%97%B4%E7%9A%84%E5%90%AB%E4%B9%89/

浏览器中JS获取时间戳我知道的有以下6种方法，这里主要记录以下他们的使用场景不同和性能优劣(忽略不计，但是你需要知道，不然怎么应对面试官)以及为什么。

为什么说浏览器中，因为Nodejs甚至别的JS引擎可能还有别的方法。

### Date.parse(str)

> Date.parse() 方法解析一个表示某个日期的字符串，并返回从1970-1-1 00:00:00 UTC 到该日期对象（该日期对象的UTC时间）的毫秒数，如果该字符串无法识别，或者一些情况下，包含了不合法的日期数值（如：2015-02-31），则返回值为NaN。


很明显我们可以看到这是Date类的静态方法。所以他不需要实例化。

根据MDN文档的说明这是一层显示调用。实际是使用了我们接下来要介绍的一种方法(接着看)。

### new Date().getTime()

> getTime() 方法返回一个时间的格林威治时间数值。
>
> 你可以使用这个方法把一个日期时间赋值给另一个Date 对象。这个方法的功能和 valueOf() 方法一样。

这个就是Date.parse的隐示调用。所以我们把两个结合起来说。

因为getTime是Date.parse的实际实现，所以无需测试就可以判断getTime的性能是优于Date.parse的。至于为什么，因为parse无论如何多一层调用栈，所以设getTime的开销为n，那么paser的开销至少是n+1。(所以我没有去做测试，如果有错请告诉我，更何况在实例化之前还有别的操作增加开销)

那么既然如此为何还要多此一举做一个静态API呢？

这里我们就可以看到使用层面了，先说Date.parse。

因为可以接收任意的时间格式字符串，实际上相当于帮我们做了一步 new Date(str)的封装。所以当你碰到任意一个日期字符串想转换成时间戳的时候都可以可以直接用这个。比如Date.parse('2021-02-07')。

那么new Date().getTime()呢？这里我们实际拆成两步看，第一是实例化Date对象。然后是获取时间戳。换句话说这个实例你可以是现new的，也可以是其他任何方式早就准备好的。所以我们在想获取一个Date对象的时间戳的时候就可以用这个。当然你非要说两者差不多的话，我可以告诉你，他就是一个东西，两种写法，方便调用而已。嗯，我目前的理解就是这样。

然后这里插一个小知识。

```
console.log(Date.parse('2021/02/07'))
// 1612627200000
console.log(Date.parse('2021-02-07'))
// 1612656000000
```

可以看到不同的分隔符其实是差了8小时的(当然这只是因为我在中国吧)。所以就可以看到因为分隔符的不同解析也不同。具体的原因可以看看这个，你不看也可以，我会总结的

> https://segmentfault.com/a/1190000003710954

大致就是以'/'为日期分隔符的日期字符串，在parse里会被解析成UTC时间，也就是对我们来说是外国人的2021年2月7日。而'-'分隔的日期字符串会被解析成当地时区时间。也就是我们中国人的2021年2月7日。但是因为我们在东八区，所以实际上是比外国人多过了8小时才到一致的时间的。所以就有了时间戳的差异。另外IOS也不识别'-'分隔，所以如果哪天你的IOS页面上时间出了问题，可以看看是不是这个原因。

然后我们接着来说第三种方式。

### Date.now()

这个方法我找了很多地方没有找到底层实现代码，但是不妨碍我们通过调用方式猜想一下其中的机制。

首先根据ES规范他是返回一个Number类型的时间戳，而这个时间戳就是当now方法调用的那个时刻的时间戳。

而now又是Date的静态类方法，获取的时间戳又是单一的所谓现在。所以我们假设有一个系统API会给到JS某个时刻的时间戳的话，当前时刻的获取无疑是最快的。当然了这是猜想，因为我找不到实现的相关说明。但是从性能来说，我的猜想没毛病。稍后我会在文末放出大佬做过的性能评测。结论目前(不考虑不支持now的情况)就是now > getTime > parse

但是这个Date.now性能这么好对我们来说使用场景却受到了限制，也就是我们不能通过now获取自定义时间的时间戳。所以像这个我们一般可以用在调用接口签名等等场景。

好了抬走，下一个。

### new Date().valueOf()

这个你也不要问我为什么，文档说返回原始值。所以他就返回了时间戳。所以我的理解就是Date对象的原始值就是时间戳值。这里查了比较的资料显示实际行为和getTime是一样的。但是经过我的实测性能是略差于getTime的。而又可知道valueOf是挂在Object.prototype上的。所以在Date上调用还要往上走一层，而经过性能结果反推，猜测getTime是缓存了valueOf方法等等相似的内部实现。所以寻找距离短，因而性能更好。

### +new Date()

这里我先告诉你们结论，就是它的性能并没有比上面的三兄弟好。那为什么？

这先分两步看+在这里实际是一个Number(xxx)的调用过程。然后其中的xxx是一个Date对象实例化的过程。

而Number构造函数在面对Date对象的时候实际上是调用了Date的valueOf方法。所以就有了这个结果。

上面这么多的方法，结果虽然一样，但是他们内部走的步数却都不相同。理解了他们对我们深入理解JS会有很好的帮助。

抬走再下一个。

### performance.timeOrigin + performance.now()

performance这个对于浏览器性能有了解一些的都认识。它提供了一系列性能相关的API，但这不是今天的重点。

timeOrigin是表示这个JS环境也就是你的页面的起始时间(创世时间)，而performance.now()这个方法返回从创世时间到目前过了多少毫秒。所以我们可以通过这种迂回的方式来获取当前时间戳。

即 当前时间 = 起始时间 + 消耗时间

而在我后面提供的那个大佬的文章里面说这个是性能最好的。本着怀疑的态度，我测试了一下。结果却不是这样。

直接上图


可以看到在足够的数量级下面我的现场测试，performance反而是性能最差的，这个我其实不是很奇怪。我的猜测也是我对他怀疑的原因在于，我看到这个组合方式的时候。

我们分两步看，第一步performance.timeOrigin 从performance对象中读取起始时间，是一个找到对象并找到属性的过程。第二步，performance.now()，根据我们上面的猜测，时间戳的最终获取其实是系统API给的结果，那么反推这个now怎么出来的？那肯定是 now = 当前时间 - 起始时间 。所以这样的猜测才能符合我们这个测试的结果。

你不要问我为什么猜，因为我真的找不到哪里讲了具体实现。而且就算找不到，这种推测的过程才是最刺激的不是吗？结果并不重要！

最后抬走，下一个？没有了我也目前只知道这些，有多的一定要告诉我。

然后是大佬的文章里面有测试说明，虽然和我的不一样，但是他的很详细。

> https://www.jianshu.com/p/d601f22f38dc

JS时间戳的一些记录

标识符

483DAB9E-B587-4DAE-936C-201F5BC4BCBA

备注

Error Domain=kCFStreamErrorDomainSSL Code=-9806"(null)" UserInfo=/NSLocalizedRecoverySuggestion=Errorcode definition can be found in Apple's SecureTransport.h}

请求信息

CONNECT m.m******(手动打码).pt:443 HTTP/1.1

请求头部

Host: m.m*******.ptConnection: keep-alive

发送请求头部

未发送

服务端开始响应

未响应

请求完成2024/04/26 10:11:40.529

 app无法登录，抓包数据。网页版可以登录，求分析求解

前些天一直在找便宜的云服务器，偶然间发现一免费的云平台，这里推荐给大家。

就是阿贝云，网站是https://www.abeiyun.com

说一下感受

1、阿贝云虽然是一小众的云平台，重在免费，该有的东西都有，还能免备案这是最舒服的。

2、使用了一天，上了项目，网速不慢。

3、唯一要指出来就是磁盘太小。

分享免费云服务器

拉取了rustbuster的v3.0.3版本文件, 二进制文件无法使用, 执行结果如下:

```bash
[root_cn@archlinux target]$ ./rustbuster-v3.0.3-x86_64-unknown-linux-gnu
./rustbuster-v3.0.3-x86_64-unknown-linux-gnu: error while loading shared libraries: libssl.so.1.1: cannot open shared object file: No such file or directory
```

拉取了main源码, 想自行尝试编译, 然后卡在了openssl, 以下为报错信息:

```rust
The following warnings were emitted during compilation:

warning: openssl-sys@0.9.47: build/expando.c:4:24: error: pasting "RUST_VERSION_OPENSSL_" and "(" does not give a valid preprocessing token
warning: openssl-sys@0.9.47:     4 | #define VERSION2(n, v) RUST_VERSION_##n##_##v
warning: openssl-sys@0.9.47:       |                        ^~~~~~~~~~~~~
warning: openssl-sys@0.9.47: build/expando.c:5:23: note: in expansion of macro ‘VERSION2’
warning: openssl-sys@0.9.47:     5 | #define VERSION(n, v) VERSION2(n, v)
warning: openssl-sys@0.9.47:       |                       ^~~~~~~~
warning: openssl-sys@0.9.47: build/expando.c:10:1: note: in expansion of macro ‘VERSION’
warning: openssl-sys@0.9.47:    10 | VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
warning: openssl-sys@0.9.47:       | ^~~~~~~

error: failed to run custom build command for `openssl-sys v0.9.47`

Caused by:
  process didn't exit successfully: `/mnt/d/work/file/rust/rustbuster/target/debug/build/openssl-sys-c5a482a9e0e49574/build-script-main` (exit status: 101)
  --- stdout
  cargo:rustc-cfg=const_fn
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_LIB_DIR
  OPENSSL_LIB_DIR unset
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_INCLUDE_DIR
  OPENSSL_INCLUDE_DIR unset
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_DIR
  OPENSSL_DIR unset
  cargo:rustc-link-lib=ssl
  cargo:rustc-link-lib=crypto
  OPT_LEVEL = Some("0")
  TARGET = Some("x86_64-unknown-linux-gnu")
  HOST = Some("x86_64-unknown-linux-gnu")
  CC_x86_64-unknown-linux-gnu = None
  CC_x86_64_unknown_linux_gnu = None
  HOST_CC = None
  CC = None
  CFLAGS_x86_64-unknown-linux-gnu = None
  CFLAGS_x86_64_unknown_linux_gnu = None
  HOST_CFLAGS = None
  CFLAGS = None
  CRATE_CC_NO_DEFAULTS = None
  DEBUG = Some("true")
  CARGO_CFG_TARGET_FEATURE = Some("fxsr,sse,sse2")
  running: "cc" "-O0" "-ffunction-sections" "-fdata-sections" "-fPIC" "-g" "-fno-omit-frame-pointer" "-m64" "-Wall" "-Wextra" "-E" "build/expando.c"
  cargo:warning=build/expando.c:4:24: error: pasting "RUST_VERSION_OPENSSL_" and "(" does not give a valid preprocessing token
  cargo:warning=    4 | #define VERSION2(n, v) RUST_VERSION_##n##_##v
  cargo:warning=      |                        ^~~~~~~~~~~~~
  cargo:warning=build/expando.c:5:23: note: in expansion of macro ‘VERSION2’
  cargo:warning=    5 | #define VERSION(n, v) VERSION2(n, v)
  cargo:warning=      |                       ^~~~~~~~
  cargo:warning=build/expando.c:10:1: note: in expansion of macro ‘VERSION’
  cargo:warning=   10 | VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
  cargo:warning=      | ^~~~~~~
  exit status: 1

  --- stderr
  thread 'main' panicked at /home/root_cn/.cargo/registry/src/mirrors.sjtug.sjtu.edu.cn-4f7dbcce21e258a2/openssl-sys-0.9.47/build/main.rs:126:13:

  Header expansion error:
  Error { kind: ToolExecError, message: "Command \"cc\" \"-O0\" \"-ffunction-sections\" \"-fdata-sections\" \"-fPIC\" \"-g\" \"-fno-omit-frame-pointer\" \"-m64\" \"-Wall\" \"-Wextra\" \"-E\" \"build/expando.c\" with args \"cc\" did not execute successfully (status code exit status: 1)." }

  Failed to find OpenSSL development headers.

  You can try fixing this setting the `OPENSSL_DIR` environment variable
  pointing to your OpenSSL installation or installing OpenSSL headers package
  specific to your distribution:

      # On Ubuntu
      sudo apt-get install libssl-dev
      # On Arch Linux
      sudo pacman -S openssl
      # On Fedora
      sudo dnf install openssl-devel

  See rust-openssl README for more information:

      https://github.com/sfackler/rust-openssl#linux

  note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
warning: build failed, waiting for other jobs to finish...
```

经过检查openssl与rust均为最新版本, 

```bash
[root_cn@archlinux target]$ sudo pacman -S rust
[sudo] password for root_cn:
warning: rust-1:1.77.2-1 is up to date -- reinstalling
resolving dependencies...
looking for conflicting packages...

Package (1)  Old Version  New Version  Net Change

extra/rust   1:1.77.2-1   1:1.77.2-1     0.00 MiB

Total Installed Size:  249.41 MiB
Net Upgrade Size:        0.00 MiB

:: Proceed with installation? [Y/n] n
[root_cn@archlinux target]$ sudo pacman -S openssl
warning: openssl-3.2.1-1 is up to date -- reinstalling
resolving dependencies...
looking for conflicting packages...

Package (1)   Old Version  New Version  Net Change

core/openssl  3.2.1-1      3.2.1-1        0.00 MiB

Total Installed Size:  11.45 MiB
Net Upgrade Size:       0.00 MiB

:: Proceed with installation? [Y/n] n
```

在网上找了一下, 查到资料, 在[rust-openssl的issues](https://github.com/sfackler/rust-openssl/issues/1227)中提到类似报错, 得到解释如下:

> If you are cross compiling to MUSL, you either need to point openssl-sys to the location that you have a copy of OpenSSL cross compiled to MUSL, or tell it to build a copy of OpenSSL itself with the vendored feature.
>
>	如果你是交叉编译到MUSL，你需要将openssl-sys指向你有一个交叉编译到MUSL的OpenSSL副本的位置，或者告诉它用vendored特性构建一个OpenSSL本身的副本。

由于不会rust, 依靠关键词"交叉编译"+"cargo"搜索到了[cargo交叉编译rust程序](https://blog.csdn.net/tyc880616/article/details/104371502), 顺着找到文件:

```
[root_cn@archlinux .cargo]$ cat ~/.cargo/config
[source.crates-io]
replace-with = 'sjtu' # 指定使用下面哪个源，修改为source.后面的内容即可

# 中国科学技术大学
[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index"

# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index/"

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# rustcc社区
[source.rustcc]
registry = "https://code.aliyun.com/rustcc/crates.io-index.git"
```

没有找到交叉编译的设置, 由于本人不会rust, 线索断了, 尝试向大家寻求一波帮助, 非常感谢阅读.



急切寻求rust编译问题帮助(archlinux, openssl)

永久免费，无需注册

[https://good.xjai.top](https://good.xjai.top)

分享免费GPT4站点

[MoienTajik/AspNetCore-Developer-Roadmap (github.com)](https://github.com/MoienTajik/AspNetCore-Developer-Roadmap/blob/master/ReadMe.zh-Hant.md)

![](https://github.com/MoienTajik/AspNetCore-Developer-Roadmap/raw/master/aspnetcore-developer-roadmap.zh-Hant.png)



【轉貼】ASP.NET Core Developer Roadmap in 2024

南京大学数字金融 - 新华报业集团联合诚邀全职博士后！

【研究方向涵盖】

数智传播、数智金融经济、数据金融经济、数智政务、数智监管治理，以及“大数据、大模型、大计算”全新范式等方向理论与实践

 【具体研究领域】

包括 Bigdata4SocialScience、AI4SocialScience、LLM4SocialScience、Blockchain4SocialScience，以及先进信息技术融合创新在数智金融经济、数智传播社会、数智健康医疗、数智政务治理中的应用。

【薪资待遇优渥】

年薪可达 30 万人民币左右，另有绩效奖金及江苏省和南京市人才补贴。具体薪资需与HR面议，总收入依据专业背景和技能经验而定（计算机 AI 背景者薪资更优）。

【欢迎学科交叉、专业背景不限】

不限制专业背景，致力于构建一个多元、开放、包容的科研环境，因此，欢迎计算机、软件、大数据、人工智能、区块链、隐私计算、数据安全、数据科学等背景的博士人才，也热切邀请具有人文社科背景的博士加入我们的团队，共同探索信息技术与社会科学的交叉前沿。也欢迎其他编程能力强的理工科博士毕业生（即使没有AI等背景也欢迎）。

【南京大学研究中心】

南京大学研究中心为双院士领军的校级科研和创新平台，详情请见：fintech.nju.edu.cn。

【团队氛围】

学科交叉、理论与实践相结合、国际化视野、行业前沿视角和项目。

【联系我们】

请感兴趣的朋友将个人简历发送至邮箱:blockchainfintech@126.com。

【更多招募】 南京大学研究中心招收硕士生、博士生、博士后、青年教师、研究员，也欢迎访问、客座、联培以及科研助理（有些岗位可兼职或远程合作）等

欢迎加入我们，您将在这个富有挑战性和机遇的环境中，开启广阔的职业发展道路，实现个人价值与学术梦想的双赢！

期待您的加入，携手共创数智未来！

南京大学研究中心诚募博士后



![](https://image.hackertalk.net/images/62537abc-405f-44da-a67e-9f18082f3d74)















sqlmap -u "xxxxx.com/#/login" --all  --delay 1 --batch --random-agent

[CRITICAL]can't establish SSL connection.

![](https://image.hackertalk.net/images/4a856cac-750c-4972-aa1f-4bf02f000394)

sqlmap -r win.txt --dbs

**

[CRITICAL] anti-CSRF token 'XSRF-TOKEN' can't be found 


**


