表单校验

背景

假设我们正在编写一个注册页面，在点击注册按钮之时，有如下几条校验逻辑：

• 用户名不能为空

• 密码长度不能少于6位

• 手机号码必须符合格式

常规写法：

const form = document.getElementById('registerForm');

form.onsubmit = function () {
  if (form.userName.value === '') {
    alert('用户名不能为空');
    return false;
  }

  if (form.password.value.length < 6) {
    alert('密码长度不能少于6位');
    return false;
  }

  if (!/^1[3|5|8][0-9]{9}$/.test(form.phoneNumber.value)) {
    alert('手机号码格式不正确');
    return false;
  }

  ...
}

这是一种很常见的代码编写方式，但它有许多缺点：

• onsubmit 函数比较庞大，包含了很多 if-else 语句，这些语句需要覆盖所有的校验规则。

• onsubmit 函数缺乏弹性，如果增加了一种新的校验规则，或者想把密码的长度从6改成8，我们都必须深入 obsubmit 函数的内部实现，这是违反开放-封闭原则的。

• 算法的复用性差，如果在项目中增加了另外一个表单，这个表单也需要进行一些类似的校验，我们很可能将这些校验逻辑复制得漫天遍野。

如何避免上述缺陷，更优雅地实现表单校验呢？

策略模式介绍

💡 策略模式是一种行为设计模式， 它能让你定义一系列算法， 把它们一个个封装起来， 并使它们可以相互替换。

真实世界类比

此图源自 refactoringguru.cn/design-patt…

假如你需要前往机场。 你可以选择骑自行车、乘坐大巴或搭出租车。这三种出行策略就是广义上的“算法”，它们都能让你从家里出发到机场。你无需深入它们的内部实现细节，如怎么开大巴、公路系统如何确保你家到机场有通路等。你只需要了解这些策略的各自特点：所需要花费的时间与金钱，你就可以根据预算和时间等因素来选择其中一种策略。

更广义的“算法”

在实际开发中，我们通常会把算法的含义扩散开来，使策略模式也可以用来封装一系列的“业务规则”。只要这些业务规则指向的目标一致，并且可以被替换使用，我们就可以用策略模式来封装它们。

策略模式的组成

一个策略模式至少由两部分组成。

第一个部分是一组策略类，策略类封装了具体的算法，并负责具体的计算过程。

第二个部分是环境类 Context，Context 接受客户的请求，随后把请求委托给某一个策略类。

利用策略模式改写

定义规则（策略），封装表单校验逻辑：

const strategies = {
  isNonEmpty: function (value, errMsg) {
    if (value === '') {
      return errMsg;
    }
  },
  minLenth: function (value, length, errMsg) {
    if (value.length < length) {
      return errMsg;
    }
  },
  isMobile: function (value, errMsg) {
    if (!/^1[3|5|8][0-9]{9}$/.test(value)) {
      return errMsg;
    }
  }
}

定义环境类 Context，进行表单校验，调用策略：

form.onsubmit = function () {
    const validator = new Validator();
    validator.add(form.userName, 'isNonEmpty', '用户名不能为空');
    validator.add(form.password, 'minLength:6', '密码长度不能少于6位');
    validator.add(form.phoneNumber, 'isMobile', '手机号码格式不正确');
    const errMsg = validator.start();
    if (errMsg) {
        alert(errMsg);
        return false;
    }
}

Validator 类代码如下：

class Validator {
    constructor() {
        this.cache = [];
    }

    add(dom, rule, errMsg) {
        const arr = rule.split(':');
        this.cache.push(() => {
            const strategy = arr.shift();
            arr.unshift(dom.value);
            arr.push(errMsg);
            return strategies[strategy].apply(dom, arr);
        })
    }

    start() {
        for (let i = 0; i < this.cache.length; i++) {
            const msg = this.cache[i]();
            if (msg) return msg;
        }
    }
}

使用策略模式重构代码之后，我们消除了原程序中大片的条件分支语句。我们仅仅通过“配置”的方式就可以完成一个表单校验，这些校验规则也能在程序中任何地方复用，还能作为插件的形式，方便地移植到其他项目中。

策略模式优缺点

优点：

1. 可以有效地避免多重条件选择语句。

2. 对开放-封闭原则完美支持，将算法封装在独立的 strategy 中，使得它们易于切换，易于理解，易于扩展。

3. 可以使算法复用在系统的其他地方，避免许多重复的复制粘贴工作。

缺点：

1. 使用策略模式会在程序中增加许多策略类或策略对象

2. 要使用策略模式，必须了解所有的 strategy，了解它们的不同点，我们才能选择一个合适的 strategy。这是违反最少知识原则的。

策略模式适合应用场景

💡 当你想使用对象中各种不同的算法变体， 并希望能在运行时切换算法时， 可使用策略模式。

策略模式让你能够将对象关联至可以不同方式执行特定子任务的不同子对象， 从而以间接方式在运行时更改对象行为。

💡 当你有许多仅在执行某些行为时略有不同的相似类时， 可使用策略模式。

策略模式让你能将不同行为抽取到一个独立类层次结构中， 并将原始类组合成同一个， 从而减少重复代码。

💡 如果算法在上下文的逻辑中不是特别重要， 使用该模式能将类的业务逻辑与其算法实现细节隔离开来。

策略模式让你能将各种算法的代码、 内部数据和依赖关系与其他代码隔离开来。 不同客户端可通过一个简单接口执行算法， 并能在运行时进行切换。

💡 当类中使用了复杂条件运算符以在同一算法的不同变体中切换时， 可使用该模式。

策略模式将所有继承自同样接口的算法抽取到独立类中， 因此不再需要条件语句。 原始对象并不实现所有算法的变体， 而是将执行工作委派给其中的一个独立算法对象。

总结

在上述例子中，使用策略模式虽然使得程序中多了许多策略对象和执行策略的代码。但这些代码可以在应用中任意位置的表单复用，使得整个程序代码量大幅减少，且易维护。下次面对多表单校验的需求时，别再傻傻写一堆 if-else 逻辑啦，快试试策略模式！

引用资料

• 深入设计模式——策略模式

• 《JavaScript 设计模式与开发实践》——曾探

作者：前端唯一深情
来源：juejin.cn/post/7069395092036911140

1 功能概述

在某些特殊情况下，需要凑齐一定的代码量，或者一定的提交次数，为了应急不得不采用一些非常规的手段来保证达标。本文分享的是一段自动提交代码的脚本，用于凑齐code review流程数量，将单次code review代码修改行数拉下来(备注：如果git开启自动生成code review流程，则每次push操作就会自动生成一次code review流程)。

2 友情提示

本脚本仅用于特殊应急场景下，平时开发中还是老老实实敲代码。

重要的事情说三遍：

千万不要在工作中使用、千万不要在工作中使用、千万不要在工作中使用

3 实现思路

3.1 准备示例代码

可以多准备一些样例代码，然后随机取用， 效果会更好。例如：

需要确保示例代码是有效的代码，有些项目可能有eslint检查，如果格式不对可能导致无法自动提交

function huisu(value, index, len, arr, current) {
  if (index >= len) {
      if (value === 8) {
          console.log('suu', current)
      }
      console.log('suu', current)
      return
  }
  for (let i = index; i < len; i++) {
      current.push(arr[i])
      console.log('suu', current)
      if (value + arr[i] === 8) {
          console.log('结果', current)
          return
      }
      huisu(value + arr[i], i + 1, len, arr, [...current])
      console.log('suu', value)
      current.pop()
      onsole.log('suu', current)
  }
}

3.2、准备一堆文件名

准备一堆文件名，用于生成新的问题，如果想偷懒，直接随机生成问题也不大。例如：

// 实现准备好的文件名称，随机也可以
const JS_NAMES = ['index.js', 'main.js', 'code.js', 'app.js', 'visitor.js', 'detail.js', 'warning.js', 'product.js', 'comment.js', 'awenk.js', 'test.js'];

3.3 生成待提交的文件

这一步策略也很简单，就是根据指定代码输出文件夹内已有的文件数量，来决定是要执行新增文件还是删除文件

if (codeFiles.length > MIN_COUNT) {
  rmFile(codeFiles);
} else {
  createFile(codeDir);
}

【新增文件】

根据前面两步准备的示例代码和文件命名，随机获取文件名和代码段，然后创建新文件

// 创建新的代码文件
function createFile(codeDir) {
  const ran = Math.floor(Math.random() * JS_NAMES.length);
  const name = JS_NAMES[ran];
  const filePath = `${codeDir}/${name}`;
  const content = getCode();
  writeFile(filePath, content);
}

【删除文件】

这一步比较简单，直接随机删除一个就行了

// 随机删除一个文件
function rmFile(codeFiles) {
  const ran = Math.floor(Math.random() * codeFiles.length);
  const filePath = codeFiles[ran];
  try {
    if (fs.existsSync(filePath)) {
      fs.unlinkSync(filePath);
    }
  } catch (e) {
    console.error('removeFile', e);
  }
}

3.4 准备commit信息

这一步怎么简单怎么来，直接准备一堆，然后随机取一个就可以了

const msgs = ['feat：消息处理', 'feat：详情修改', 'fix: 交互优化', 'feat:新增渠道', 'config修改'];
const ran = Math.floor(Math.random() * msgs.length);
console.log(`${msgs[ran]}--测试提交，请直接通过`);

3.5 扩大增幅

上述步骤执行一次可能不太够，咱们可以循环多来几次。随机生成一个数字，用来控制循环的次数

const ran = Math.max(3, parseInt(Math.random() * 10, 10));
console.log(ran);

3.6 组合脚本

组合上述步骤，利用shell脚本执行git提交，详细代码如下：

#! /bin/bash

git pull

cd $(dirname $0)

# 执行次数
count=$(node ./commit/ran.js)
echo $count

# 循环执行
for((i=0;i<$count;i++))
do
node ./commit/code.js
git add .

msg=$(node ./commit/msg.js)
git commit -m "$msg"

git push
done

总结

总的来就就是利用shell脚本执行git命令，随机生成代码或者删除代码之后执行commit提交，最后push推送到远程服务器。

源码

欢迎有需要的朋友取用，《源码传送门》

作者：先秦剑仙
来源：juejin.cn/post/7160649931928109092

前言

四面的时候被问到了这个问题，当时第一时间没有反应过来，觉得这个需求好奇特

面试官给了一些提示，我才明白这道题目的意思，最后回答的也是磕磕绊绊

后来花了一些时间整理了下思路，那么如何设计这样的环境呢？

最终实现

实现思路：

1）利用 iframe 创建沙箱，取出其中的原生浏览器全局对象作为沙箱的全局对象

2）设置一个黑名单，若访问黑名单中的变量，则直接报错，实现阻止\隔离的效果

3）在黑名单中添加 document 字段，来实现禁止开发者操作 DOM

4）在黑名单中添加 XMLHttpRequest、fetch、WebSocket 字段，实现禁用原生的方式调用接口

5）若访问当前全局对象中不存在的变量，则直接报错，实现禁用三方库调接口

6）最后还要拦截对 window 对象的访问，防止通过 window.document 来操作 DOM，避免沙箱逃逸

下面聊一聊，为何这样设计，以及中间会遇到什么问题

如何禁止开发者操作 DOM ？

在页面中，可以通过 document 对象来获取 HTML 元素，进行增删改查的 DOM 操作

如何禁止开发者操作 DOM，转化为如何阻止开发者获取 document 对象

1）传统思路

简单粗暴点，直接修改 window.document 的值，让开发者无法获取 document

// 将document设置为null
window.document = null;

// 设置无效，打印结果还是document
console.log(window.document); 

// 删除document
delete window.document

// 删除无效，打印结果还是document
console.log(window.document);

好吧，document 修改不了也删除不了🤔

使用 Object.getOwnPropertyDescriptor 查看，会发现 window.document 的 configurable 属性为 false（不可配置的）

Object.getOwnPropertyDescriptor(window, 'document');
// {get: ƒ, set: undefined, enumerable: true, configurable: false}

configurable 决定了是否可以修改属性描述对象，也就是说，configurable为false时，value、writable、enumerable和configurable 都不能被修改，以及无法被删除

此路不通，推倒重来

2）有点高大上的思路

既然 document 对象修改不了，那如果环境中原本就没有 document 对象，是不是就可以实现该需求？

说到环境中没有 document 对象，Web Worker 直呼内行，我曾在《一文彻底了解Web Worker，十万、百万条数据都是弟弟🔥》中聊过如何使用 Web Worker，和对应的特性

并且 Web Worker 更狠，不但没有 document 对象，连 window 对象也没有😂

在worker线程中打印window

onmessage = function (e) {
  console.log(window);
  postMessage();
};

浏览器直接报错

在 Web Worker 线程的运行环境中无法访问 document 对象，这一条符合当前的需求，但是该环境中能获取 XMLHttpRequest 对象，可以发送 ajax 请求，不符合不能调接口的要求

此路还是不通……😓

如何禁止开发者调接口 ？

常规调接口方式有：

1）原生方式：XMLHttpRequest、fetch、WebSocket、jsonp、form表单

2）三方实现：axios、jquery、request等众多开源库

禁用原生方式调接口的思路：

1）XMLHttpRequest、fetch、WebSocket 这几种情况，可以禁止用户访问这些对象

2）jsonp、form 这两种方式，需要创建script或form标签，依然可以通过禁止开发者操作DOM的方式解决，不需要单独处理

如何禁用三方库调接口呢？

三方库很多，没办法全部列出来，来进行逐一排除

禁止调接口的路好像也被封死了……😰

最终方案：沙箱（Sandbox）

通过上面的分析，传统的思路确实解决不了当前的需求

阻止开发者操作DOM和调接口，沙箱说：这个我熟啊，拦截隔离这类的活，我最拿手了😀

沙箱（Sandbox） 是一种安全机制，为运行中的程序提供隔离环境，通常用于执行未经测试或不受信任的程序或代码，它会为待执行的程序创建一个独立的执行环境，内部程序的执行不会影响到外部程序的运行

前端沙箱的使用场景：

1）Chrome 浏览器打开的每个页面就是一个沙箱，保证彼此独立互不影响

2）执行 jsonp 请求回来的字符串时或引入不知名第三方 JS 库时，可能需要创造一个沙箱来执行这些代码

3）Vue 模板表达式的计算是运行在一个沙箱中，模板字符串中的表达式只能获取部分全局对象，详情见源码

4）微前端框架 qiankun ，为了实现js隔离，在多种场景下均使用了沙箱

沙箱的多种实现方式

先聊下 with 这个关键字：作用在于改变作用域，可以将某个对象添加到作用域链的顶部

with对于沙箱的意义：可以实现所有变量均来自可靠或自主实现的上下文环境，而不会从全局的执行环境中取值，相当于做了一层拦截，实现隔离的效果

简陋的沙箱

题目要求： 实现这样一个沙箱，要求程序中访问的所有变量，均来自可靠或自主实现的上下文环境，而不会从全局的执行环境中取值

举个🌰： ctx作为执行上下文对象，待执行程序code可以访问到的变量，必须都来自ctx对象

// ctx 执行上下文对象
const ctx = {
  func: variable => {
    console.log(variable);
  },
  foo: "f1"
};

// 待执行程序
const code = `func(foo)`;

沙箱示例：

// 定义全局变量foo
var foo = "foo1";

// 执行上下文对象
const ctx = {
  func: variable => {
    console.log(variable);
  },
  foo: "f1"
};

// 非常简陋的沙箱
function veryPoorSandbox(code, ctx) {
  // 使用with，将eval函数执行时的执行上下文指定为ctx
  with (ctx) {
    // eval可以将字符串按js代码执行，如eval('1+2')
    eval(code);
  }
}

// 待执行程序
const code = `func(foo)`;

veryPoorSandbox(code, ctx); 
// 打印结果："f1"，不是最外层的全局变量"foo1"

这个沙箱有一个明显的问题，若提供的ctx上下文对象中，没有找到某个变量时，代码仍会沿着作用域链一层层向上查找

假如上文示例中的 ctx 对象没有设置 foo属性，打印的结果还是外层作用域的foo1

With + Proxy 实现沙箱

题目要求： 希望沙箱中的代码只在手动提供的上下文对象中查找变量，如果上下文对象中不存在该变量，则提示对应的错误

举个🌰： ctx作为执行上下文对象，待执行程序code可以访问到的变量，必须都来自ctx对象，如果ctx对象中不存在该变量，直接报错，不再通过作用域链向上查找

实现步骤：

1）使用 Proxy.has() 来拦截 with 代码块中的任意变量的访问

2）设置一个白名单，在白名单内的变量可以正常走作用域链的访问方式，不在白名单内的变量，会继续判断是否存 ctx 对象中，存在则正常访问，不存在则直接报错

3）使用new Function替代eval，使用 new Function() 运行代码比eval更为好一些，函数的参数提供了清晰的接口来运行代码

new Function与eval的区别

沙箱示例：

var foo = "foo1";

// 执行上下文对象
const ctx = {
  func: variable => {
    console.log(variable);
  }
};

// 构造一个 with 来包裹需要执行的代码，返回 with 代码块的一个函数实例
function withedYourCode(code) {
  code = "with(shadow) {" + code + "}";
  return new Function("shadow", code);
}

// 可访问全局作用域的白名单列表
const access_white_list = ["func"];

// 待执行程序
const code = `func(foo)`;

// 执行上下文对象的代理对象
const ctxProxy = new Proxy(ctx, {
  has: (target, prop) => {
    // has 可以拦截 with 代码块中任意属性的访问
    if (access_white_list.includes(prop)) {
      // 在可访问的白名单内，可继续向上查找
      return target.hasOwnProperty(prop);
    }
    if (!target.hasOwnProperty(prop)) {
      throw new Error(`Not found - ${prop}!`);
    }
    return true;
  }
});

// 没那么简陋的沙箱
function littlePoorSandbox(code, ctx) {
  // 将 this 指向手动构造的全局代理对象
  withedYourCode(code).call(ctx, ctx); 
}
littlePoorSandbox(code, ctxProxy);

// 执行func(foo)，报错： Uncaught Error: Not found - foo!

执行结果：

天然的优质沙箱（iframe）

iframe 标签可以创造一个独立的浏览器原生级别的运行环境，这个环境由浏览器实现了与主环境的隔离

利用 iframe 来实现一个沙箱是目前最方便、简单、安全的方法，可以把 iframe.contentWindow 作为沙箱执行的全局 window 对象

沙箱示例：

// 沙箱全局代理对象类
class SandboxGlobalProxy {
  constructor(sharedState) {
    // 创建一个 iframe 标签，取出其中的原生浏览器全局对象作为沙箱的全局对象
    const iframe = document.createElement("iframe", { url: "about:blank" });
    iframe.style.display = "none";
    document.body.appendChild(iframe);
    
    // sandboxGlobal作为沙箱运行时的全局对象
    const sandboxGlobal = iframe.contentWindow; 

    return new Proxy(sandboxGlobal, {
      has: (target, prop) => {
        // has 可以拦截 with 代码块中任意属性的访问
        if (sharedState.includes(prop)) {
          // 如果属性存在于共享的全局状态中，则让其沿着原型链在外层查找
          return false;
        }
        
        // 如果没有该属性，直接报错
        if (!target.hasOwnProperty(prop)) {
          throw new Error(`Not find: ${prop}!`);
        }
        
        // 属性存在，返回sandboxGlobal中的值
        return true;
      }
    });
  }
}

// 构造一个 with 来包裹需要执行的代码，返回 with 代码块的一个函数实例
function withedYourCode(code) {
  code = "with(sandbox) {" + code + "}";
  return new Function("sandbox", code);
}
function maybeAvailableSandbox(code, ctx) {
  withedYourCode(code).call(ctx, ctx);
}

// 要执行的代码
const code = `
  console.log(history == window.history) // false
  window.abc = 'sandbox'
  Object.prototype.toString = () => {
      console.log('Traped!')
  }
  console.log(window.abc) // sandbox
`;

// sharedGlobal作为与外部执行环境共享的全局对象
// code中获取的history为最外层作用域的history
const sharedGlobal = ["history"]; 

const globalProxy = new SandboxGlobalProxy(sharedGlobal);

maybeAvailableSandbox(code, globalProxy);

// 对外层的window对象没有影响
console.log(window.abc); // undefined
Object.prototype.toString(); // 并没有打印 Traped

可以看到，沙箱中对window的所有操作，都没有影响到外层的window，实现了隔离的效果😘

需求实现

继续使用上述的 iframe 标签来创建沙箱，代码主要修改点

1）设置 blacklist 黑名单，添加 document、XMLHttpRequest、fetch、WebSocket 来禁止开发者操作DOM和调接口

2）判断要访问的变量，是否在当前环境的 window 对象中，不在的直接报错，实现禁止通过三方库调接口

// 设置黑名单
const blacklist = ['document', 'XMLHttpRequest', 'fetch', 'WebSocket'];

// 黑名单中的变量禁止访问
if (blacklist.includes(prop)) {
  throw new Error(`Can't use: ${prop}!`);
}

但有个很严重的漏洞，如果开发者通过 window.document 来获取 document 对象，依然是可以操作 DOM 的😱

需要在黑名单中加入 window 字段，来解决这个沙箱逃逸的漏洞，虽然把 window 加入了黑名单，但 window 上的方法，如 open、close 等，依然是可以正常获取使用的

最终代码：

// 沙箱全局代理对象类

class SandboxGlobalProxy {

  constructor(blacklist) {

    // 创建一个 iframe 标签，取出其中的原生浏览器全局对象作为沙箱的全局对象

    const iframe = document.createElement("iframe", { url: "about:blank" });

    iframe.style.display = "none";

    document.body.appendChild(iframe);



    // 获取当前HTMLIFrameElement的Window对象

    const sandboxGlobal = iframe.contentWindow;



    return new Proxy(sandboxGlobal, {

      // has 可以拦截 with 代码块中任意属性的访问

      has: (target, prop) => {



        // 黑名单中的变量禁止访问

        if (blacklist.includes(prop)) {

          throw new Error(`Can't use: ${prop}!`);

        }

        // sandboxGlobal对象上不存在的属性，直接报错，实现禁用三方库调接口

        if (!target.hasOwnProperty(prop)) {

          throw new Error(`Not find: ${prop}!`);

        }



        // 返回true，获取当前提供上下文对象中的变量；如果返回false，会继续向上层作用域链中查找

        return true;

      }

    });

  }

}



// 使用with关键字，来改变作用域

function withedYourCode(code) {

  code = "with(sandbox) {" + code + "}";

  return new Function("sandbox", code);

}



// 将指定的上下文对象，添加到待执行代码作用域的顶部

function makeSandbox(code, ctx) {

  withedYourCode(code).call(ctx, ctx);

}



// 待执行的代码code，获取document对象

const code = `console.log(document)`;



// 设置黑名单

// 经过小伙伴的指导，新添加Image字段，禁止使用new Image来调接口

const blacklist = ['window', 'document', 'XMLHttpRequest', 'fetch', 'WebSocket', 'Image'];



// 将globalProxy对象，添加到新环境作用域链的顶部

const globalProxy = new SandboxGlobalProxy(blacklist);



makeSandbox(code, globalProxy);

打印结果：

持续优化

经过与评论区小伙伴的交流，可以通过 new Image() 调接口，确实是个漏洞

// 不需要创建DOM 发送图片请求
let img = new Image();
img.src= "http://www.test.com/img.gif";

黑名单中添加'Image'字段，堵上这个漏洞。如果还有其他漏洞，欢迎交流讨论💕

总结

通过解决面试官提出的问题，介绍了沙箱的基本概念、应用场景，以及如何去实现符合要求的沙箱，发现防止沙箱逃逸是一件挺有趣的事情，就像双方在下棋一样，你来我往，有攻有守😄

关于这个问题，小伙伴们如果有其他可行的方案，或者有要补充、指正的，欢迎交流讨论

参考资料：
浅析 JavaScript 沙箱机制

作者：海阔_天空
来源：juejin.cn/post/7157570429928865828

前言

大家好，我是林三心，用最通俗的话讲最难的知识点是我的座右铭，基础是进阶的前提是我的初心，今天跟大家来唠唠嗑，如果后端真的返回给前端10万条数据，咱们前端要怎么优雅地展示出来呢？（哈哈假设后端真的能传10万条数据到前端）

前置工作

先把前置工作给做好，后面才能进行测试

后端搭建

新建一个server.js文件，简单起个服务，并返回给前端10w条数据，并通过nodemon server.js开启服务

没有安装nodemon的同学可以先全局安装npm i nodemon -g

// server.js

const http = require('http')
const port = 8000;

http.createServer(function (req, res) {
  // 开启Cors
  res.writeHead(200, {
    //设置允许跨域的域名，也可设置*允许所有域名
    'Access-Control-Allow-Origin': '*',
    //跨域允许的请求方法，也可设置*允许所有方法
    "Access-Control-Allow-Methods": "DELETE,PUT,POST,GET,OPTIONS",
    //允许的header类型
    'Access-Control-Allow-Headers': 'Content-Type'
  })
  let list = []
  let num = 0

  // 生成10万条数据的list
  for (let i = 0; i < 100000; i++) {
    num++
    list.push({
      src: 'https://p3-passport.byteacctimg.com/img/user-avatar/d71c38d1682c543b33f8d716b3b734ca~300x300.image',
      text: `我是${num}号嘉宾林三心`,
      tid: num
    })
  }
  res.end(JSON.stringify(list));
}).listen(port, function () {
  console.log('server is listening on port ' + port);
})

前端页面

先新建一个index.html

// index.html

// 样式
<style>
    * {
      padding: 0;
      margin: 0;
    }
    #container {
      height: 100vh;
      overflow: auto;
    }
    .sunshine {
      display: flex;
      padding: 10px;
    }
    img {
      width: 150px;
      height: 150px;
    }
  </style>

// html部分
<body>
  <div id="container">
  </div>
  <script src="./index.js"></script>
</body>

然后新建一个index.js文件，封装一个AJAX函数，用来请求这10w条数据

// index.js

// 请求函数
const getList = () => {
    return new Promise((resolve, reject) => {
        //步骤一:创建异步对象
        var ajax = new XMLHttpRequest();
        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数
        ajax.open('get', 'http://127.0.0.1:8000');
        //步骤三:发送请求
        ajax.send();
        //步骤四:注册事件 onreadystatechange 状态改变就会调用
        ajax.onreadystatechange = function () {
            if (ajax.readyState == 4 && ajax.status == 200) {
                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的
                resolve(JSON.parse(ajax.responseText))
            }
        }
    })
}

// 获取container对象
const container = document.getElementById('container')

直接渲染

最直接的方式就是直接渲染出来，但是这样的做法肯定是不可取的，因为一次性渲染出10w个节点，是非常耗时间的，咱们可以来看一下耗时，差不多要消耗12秒，非常消耗时间

const renderList = async () => {
    console.time('列表时间')
    const list = await getList()
    list.forEach(item => {
        const div = document.createElement('div')
        div.className = 'sunshine'
        div.innerHTML = `<img src="${item.src}" /><span>${item.text}</span>`
        container.appendChild(div)
    })
    console.timeEnd('列表时间')
}
renderList()

setTimeout分页渲染

这个方法就是，把10w按照每页数量limit分成总共Math.ceil(total / limit)页，然后利用setTimeout，每次渲染1页数据，这样的话，渲染出首页数据的时间大大缩减了

const renderList = async () => {
    console.time('列表时间')
    const list = await getList()
    console.log(list)
    const total = list.length
    const page = 0
    const limit = 200
    const totalPage = Math.ceil(total / limit)

    const render = (page) => {
        if (page >= totalPage) return
        setTimeout(() => {
            for (let i = page * limit; i < page * limit + limit; i++) {
                const item = list[i]
                const div = document.createElement('div')
                div.className = 'sunshine'
                div.innerHTML = `<img src="${item.src}" /><span>${item.text}</span>`
                container.appendChild(div)
            }
            render(page + 1)
        }, 0)
    }
    render(page)
    console.timeEnd('列表时间')
}

requestAnimationFrame

使用requestAnimationFrame代替setTimeout，减少了重排的次数，极大提高了性能，建议大家在渲染方面多使用requestAnimationFrame

const renderList = async () => {
    console.time('列表时间')
    const list = await getList()
    console.log(list)
    const total = list.length
    const page = 0
    const limit = 200
    const totalPage = Math.ceil(total / limit)

    const render = (page) => {
        if (page >= totalPage) return
        // 使用requestAnimationFrame代替setTimeout
        requestAnimationFrame(() => {
            for (let i = page * limit; i < page * limit + limit; i++) {
                const item = list[i]
                const div = document.createElement('div')
                div.className = 'sunshine'
                div.innerHTML = `<img src="${item.src}" /><span>${item.text}</span>`
                container.appendChild(div)
            }
            render(page + 1)
        })
    }
    render(page)
    console.timeEnd('列表时间')
}

文档碎片 + requestAnimationFrame

文档碎片的好处

• 1、之前都是每次创建一个div标签就appendChild一次，但是有了文档碎片可以先把1页的div标签先放进文档碎片中，然后一次性appendChild到container中，这样减少了appendChild的次数，极大提高了性能

• 2、页面只会渲染文档碎片包裹着的元素，而不会渲染文档碎片

const renderList = async () => {
    console.time('列表时间')
    const list = await getList()
    console.log(list)
    const total = list.length
    const page = 0
    const limit = 200
    const totalPage = Math.ceil(total / limit)

    const render = (page) => {
        if (page >= totalPage) return
        requestAnimationFrame(() => {
            // 创建一个文档碎片
            const fragment = document.createDocumentFragment()
            for (let i = page * limit; i < page * limit + limit; i++) {
                const item = list[i]
                const div = document.createElement('div')
                div.className = 'sunshine'
                div.innerHTML = `<img src="${item.src}" /><span>${item.text}</span>`
                // 先塞进文档碎片
                fragment.appendChild(div)
            }
            // 一次性appendChild
            container.appendChild(fragment)
            render(page + 1)
        })
    }
    render(page)
    console.timeEnd('列表时间')
}

懒加载

为了比较通俗的讲解，咱们启动一个vue前端项目，后端服务还是开着

其实实现原理很简单，咱们通过一张图来展示，就是在列表尾部放一个空节点blank，然后先渲染第1页数据，向上滚动，等到blank出现在视图中，就说明到底了，这时候再加载第二页，往后以此类推。

至于怎么判断blank出现在视图上，可以使用getBoundingClientRect方法获取top属性

IntersectionObserver 性能更好，但是我这里就拿getBoundingClientRect来举例

<script setup lang="ts">
import { onMounted, ref, computed } from 'vue'
const getList = () => {
  // 跟上面一样的代码
}

const container = ref<HTMLElement>() // container节点
const blank = ref<HTMLElement>() // blank节点
const list = ref<any>([]) // 列表
const page = ref(1) // 当前页数
const limit = 200 // 一页展示
// 最大页数
const maxPage = computed(() => Math.ceil(list.value.length / limit))
// 真实展示的列表
const showList = computed(() => list.value.slice(0, page.value * limit))
const handleScroll = () => {
  // 当前页数与最大页数的比较
  if (page.value > maxPage.value) return
  const clientHeight = container.value?.clientHeight
  const blankTop = blank.value?.getBoundingClientRect().top
  if (clientHeight === blankTop) {
    // blank出现在视图，则当前页数加1
    page.value++
  }
}

onMounted(async () => {
  const res = await getList()
  list.value = res
})
</script>

<template>
  <div id="container" @scroll="handleScroll" ref="container">
    <div class="sunshine" v-for="(item) in showList" :key="item.tid">
      <img :src="item.src" />
      <span>{{ item.text }}</span>
    </div>
    <div ref="blank"></div>
  </div>
</template>

结语

如果你觉得此文对你有一丁点帮助，点个赞，鼓励一下林三心哈哈。

作者：Sunshine_Lin
来源：juejin.cn/post/7031923575044964389

本人是 95 前端菜鸟一枚，目前在广州打工混口饭吃。刚好换了工作，感觉生活节奏变得慢了下来，打了这么多年工总觉得想纪录些什么，怕以后自己老了忘记自己还有这么一些风流往事。书接上回

// after
return permission ? children : React.Children.map(children, child => React.cloneElement(child as React.ReactElement, { onClick: () => { message.error('无权限'); } }));

一个Vue.js差异查看器插件，可以用来比较两个代码片断之间的差异。

Github地址：github.com/hoiheart/vu…

支持语言：

• css

• xml: xml, html, xhtml, rss, atom, xjb, xsd, xsl, plist, svg

• markdown: markdown, md, mkdown, mkd

• javascript: javascript, js, jsx

• json

• plaintext: plaintext, txt, text

• typescript: typescript, ts

如何使用:

1. 导入并注册diff查看器。

import VueDiff from 'vue-diff'
import 'vue-diff/dist/index.css'
app.use(VueDiff);

2.向模板中添加组件。

<Diff />

3.可用的组件props。

mode: {
  type: String as PropType<Mode>,
  default: 'split' // or unified
},
theme: {
  type: String as PropType<Theme>,
  default: 'dark' // or light
},
language: {
  type: String,
  default: 'plaintext'
},
prev: {
  type: String,
  default: ''
},
current: {
  type: String,
  default: ''
},
inputDelay: {
  type: Number,
  default: 0
},
virtualScroll: {
  type: [Boolean, Object] as PropType<boolean|VirtualScroll>,
  default: false
}

4.使用 highlight.js 扩展插件。

// 注册一门新语言
import yaml from 'highlight.js/lib/languages/yaml'
VueDiff.hljs.registerLanguage('yaml', yaml)

作者：杭州程序员张张
来源：juejin.cn/post/7156839676677423112

背景

🎨(美术): 这是这次需求的切图 📁 ，你看看有没问题？

🧑‍💻(前端): 好的。

页面上线 ...

🧑‍💼(产品): 这图片怎么半天加载不出来 💢 ？

🧑‍💻(前端): 我看看 🤔 (卑微)。

... 📁(size: 15MB)

🧑‍💻(前端): 😅。

很多时候，我们从 PS 、蓝湖或摹客等工具导出来的图片，或者是美术直接给到切图，都是未经过压缩的，体积都比较大。这里，就有了可优化的空间。

TinyPng

TinyPNG使用智能的「有损压缩技术」来减少WEBP、JPEG和PNG文件的文件大小。通过选择性地减少图像中的「颜色数量」，使用更少的字节来存储数据。这种效果几乎是看不见的，但在文件大小上有非常大的差别。

使用过TinyPng的都知道，它的压缩效果非常好，体积大幅度降低且显示效果几乎没有区别( 👀 看不出区别）。因此，选择其作为压缩工具，是一个不错的选择。

TinyPng提供两种压缩方法：

1. 通过在官网上进行手动压缩；

2. 通过官方提供的tinify进行压缩；

身为一个程序员 🧑‍💻 ，是不能接受手动一张张上传压缩这种方法的。因此，选择第二种方法，通过封装一个工具，对项目内的图片自动压缩，彻底释放双手 🤲 。

工具类型

第一步，思考这个工具的「目的」是什么？没错，「压缩图片」。

第二步，思考在哪个「环节」进行压缩？没错，「发布前」。

这样看来，开发一个webpack plugin是一个不错选择，在打包「生产环境」代码的时候，启用该plugin对图片进行处理，完美 🥳 ！

但是，这样会面临两个问题 🤔 ：

1. 页面迭代，新增了几张图片，重新打包上线时，会导致旧图片被多次压缩；

2. 无法选择哪些图片要被压缩，哪些图片不被压缩；

虽然可以通过「配置」的方式解决上述问题，但每次打包都要特殊配置，略显麻烦，这样看来plugin好像不是最好的选择。

以上两个问题，使用「命令行工具」就能完美解决。在打包「生产环境」代码之前，执行「压缩命令」，通过命令行交互，选择需要压缩的图片。

效果演示

话不多说，先上才艺 💃 ！

1. 安装

$ npm i yx-tiny -D

1. 使用

$ npx tiny 

1. 根据命令行提示输入

流程：输入「文件夹名称-tinyImg」，接着工具会找到当前项目下所有的tinyImg，接着选择一或多个tinyImg，紧接着，工具会找出tinyImg下所有的png、jpe?g和svga，最后选择压缩模式「全量」或「自定义」，选择需要压缩的图片。

从最后的输出结果可以看到，压缩前的资源体积为2.64MB，压缩后体积为1.02MB，足足压缩了1.62MB 👍 ！

实现思路

总体分为五个过程：

1. 查找：找出所有的图片资源；

2. 分配：均分任务到每个进程；

3. 上传：把原图上传到TinyPng；

4. 下载：从TinyPng中下载压缩好的图片；

5. 写入：用下载的图片覆盖本地图片；

项目地址：yx-tiny

查找

找出所有的图片资源。

packages/tiny/src/index.ts

/**
 * 递归找出所有图片
 * @param { string } path
 * @returns { Array<imageType> }
 */
interface IdeepFindImg {
  (path: string): Array<imageType>
}
let deepFindImg: IdeepFindImg
deepFindImg = (path: string) => {
  // 读取文件夹的内容
  const content = fs.readdirSync(path)
  // 用于保存发现的图片
  let images: Array<imageType> = []
  // 遍历该文件夹内容
  content.forEach(folder => {
    const filePath = resolve(path, folder)
    // 获取当前内容的语法信息
    const info = fs.statSync(filePath)
    // 当前内容为“文件夹”
    if (info.isDirectory()) {
      // 对该文件夹进行递归操作
      images = [...images, ...deepFindImg(filePath)]
    } else {
      const fileNameReg = /\.(jpe?g|png|svga)$/
      const shouldFormat = fileNameReg.test(filePath)
      // 判断当前内容的路径是否包含图片格式
      if (shouldFormat) {
        // 读取图片内容保存到images
        const imgData = fs.readFileSync(filePath)
        images.push({
          path: filePath,
          file: imgData
        })
      }
    }
  })
  return images
}

通过命令行交互后，拿到目标文件夹的路径path，然后获取该path下的所有内容，接着遍历所有内容。首先判断该内容的文件信息：若为“文件夹”，则把该文件夹路径作为path，递归调用deepFindImg；若不为“文件夹”，判断该内容为图片，则读取图片数据，push到images中。最后，返回所有找到的图片。

分配

均分任务到每个进程。

packages/tiny/src/index.ts

// ...
cluster.setupPrimary({
    exec: resolve(__dirname, 'features/process.js')
})

// 若资源数小于则创建一个进程，否则创建多个进程
const works: Array<{
    work: Worker;
    tasks: Array<imageType>
}> =[]
if (list.length <= cpuNums) {
    works.push({
        work: cluster.fork(),
        tasks: list
    })
} else {
    for (let i = 0; i < cpuNums; ++i) {
        const work = cluster.fork()
        works.push({
            work,
            tasks: []
        })
    }
}

// 平均分配任务
let workNum = 0 
list.forEach(task = >{
    if (works.length === 1) {
        return
    } else if (workNum >= works.length) {
        works[0].tasks.push(task)
        workNum = 1
    } else {
        works[workNum].tasks.push(task)
        workNum += 1
    }
})

// 用于记录进程完成数
let pageNum = works.length

// 初始化进度条
// ...

works.forEach(({
    work,
    tasks
}) = >{
    // 发送任务到每个进程
    work.send(tasks)
    // 接收任务完成
    work.on('message', (details: Idetail[]) = >{
        // 更新进度条
        // ...
        pageNum--
        // 所有任务执行完毕
        if (pageNum === 0) {
            // 关闭进程
            cluster.disconnect()
        }
    })
})

使用cluster，根据「cpu核心数」创建等量的进程，works用于保存已创建的进程，list中保存的是要处理的压缩任务，通过遍历list，把任务依次分给每一个进程。接着遍历works，通过send方法发送进程任务。通过监听message事件，利用pageNum记录进程任务的完成情况，当所有进程任务执行完毕后，则关闭进程。

上传

官方提供的tinify工具有「500张/月」的限额，超过限额后，需要付费。

由于家境贫寒，且出于学习的目的，就没有使用tinify，而是通过构造随机IP来直接请求「压缩接口」来达到「破解限额」的目的。大家在真正使用的时候，还是要使用tinyfy来压缩，不要做这种投机取巧的事。

好了，回到正文。

把原图上传到TinyPng。

packages/tiny/src/features/index.ts

/**
 * 上传函数
 * @param { Buffer } file 文件buffer数据
 * @returns { Promise<DataUploadType> }
 */
interface Iupload {
  (file: Buffer): Promise<DataUploadType>
}
export let upload: Iupload
upload = (file: Buffer) => {
  // 生成随机请求头
  const header = randomHeader()
  return new Promise((resolve, reject) => {
    const req = Https.request(header, res => {
      res.on('data', data => {
        try {
          const resp = JSON.parse(data.toString()) as DataUploadType
          if (resp.error) {
            reject(resp)
          } else {
            resolve(resp)
          }
        } catch (err) {
          reject(err)
        }
      })
    })
    // 上传图片buffer
    req.write(file)
    req.on('error', err => reject(err))
    req.end()
  })
}

使用node自带的Https模块，构造请求头，把deepFindImg中返回的图片进行上传。上传成功后，会返回已经压缩好的图片的url链接。

下载

从TinyPng中下载压缩好的图片。

packages/tiny/src/features/index.ts

/**
 * 下载函数
 * @param { string } path
 * @returns { Promise<string> }
 */
interface Idownload {
  (path: string): Promise<string>
}
export let download: Idownload
download = (path: string) => {
  const header = new Url.URL(path)
  return new Promise((resolve, reject) => {
    const req = Https.request(header, res => {
      let content = ''
      res.setEncoding('binary')
      res.on('data', data => (content += data))
      res.on('end', () => resolve(content))
    })
    req.on('error', err => reject(err))
    req.end()
  })
}

使用node自带的Https模块把upload中返回的图片链接进行下载。下载成功后，返回图片的buffer数据。

写入

把下载好的图片覆盖本地图片。

packages/tiny/src/features/process.ts

/**
 * 接收进程任务
 */
process.on('message', (tasks: imageType[]) => {
  ;(async () => {
    // 优化 png/jpg
    const data = tasks
      .filter(({ path }: { path: string }) => /\.(jpe?g|png)$/.test(path))
      .map(ele => {
        return compressImg({ ...ele, file: Buffer.from(ele.file) })
      })

    // 优化 svga
    const svgaData = tasks
      .filter(({ path }: { path: string }) => /\.(svga)$/.test(path))
      .map(ele => {
        return compressSvga(ele.path, Buffer.from(ele.file))
      })

    const details = await Promise.all([
      ...data.map(fn => fn()),
      ...svgaData.map(fn => fn())
    ])

    // 写入
    await Promise.all(
      details.map(
        ({ path, file }) =>
          new Promise((resolve, reject) => {
            fs.writeFile(path, file, err => {
              if (err) reject(err)
              resolve(true)
            })
          })
      )
    )

    // 发送结果
    if (process.send) {
      process.send(details)
    }
  })()
})

process.on监听每个进程发送的任务，当接收到任务类型为「图片」，使用compressImg方法来处理图片。当任务类型为「svga」，使用compressSvga方法来处理svga。最后把处理好的资源写入到本地覆盖旧资源。

compressImg

packages/tiny/src/features/process.ts

/**
 * 压缩图片
 * @param { imageType } 图片资源
 * @returns { promise<Idetail> }
 */
interface IcompressImg {
  (payload: imageType): () => Promise<Idetail>
}
let compressImg: IcompressImg
compressImg = ({ path, file }: imageType) => {
  return async () => {
    const result = {
      input: 0,
      output: 0,
      ratio: 0,
      path,
      file,
      msg: ''
    }
    try {
      // 上传
      const dataUpload = await upload(file)

      // 下载
      const dataDownload = await download(dataUpload.output.url)

      result.input = dataUpload.input.size
      result.output = dataUpload.output.size
      result.ratio = 1 - dataUpload.output.ratio
      result.file = Buffer.alloc(dataDownload.length, dataDownload, 'binary')
    } catch (err) {
      result.msg = `[${chalk.blue(path)}] ${chalk.red(JSON.stringify(err))}`
    }
    return result
  }
}

compressImg返回一个async函数，该函数先调用upload进行图片上传，接着调用download进行下载，最终返回该图片的buffer数据。

compressSvga

packages/tiny/src/features/process.ts

/**

 * 压缩svga

 * @param { string } path 路径

 * @param { buffer } source svga buffer

 * @returns { promise<Idetail> }

 */

interface IcompressSvga {

  (path: string, source: Buffer): () => Promise<Idetail>

}

let compressSvga: IcompressSvga

compressSvga = (path, source) => {

  return async () => {

    const result = {

      input: 0,

      output: 0,

      ratio: 0,

      path,

      file: source,

      msg: ''

    }

    try {

      // 解析svga

      const data = ProtoMovieEntity.decode(

        pako.inflate(toArrayBuffer(source))

      ) as unknown as IsvgaData

      const { images } = data

      const list = Object.keys(images).map(path => {

        return compressImg({ path, file: toBuffer(images[path]) })

      })



      // 对svga图片进行压缩

      const detail = await Promise.all(list.map(fn => fn()))

      detail.forEach(({ path, file }) => {

        data.images[path] = file

      })



      // 压缩buffer

      const file = pako.deflate(

        toArrayBuffer(ProtoMovieEntity.encode(data).finish() as Buffer)

      )

      result.input = source.length

      result.output = file.length

      result.ratio = 1 - file.length / source.length

      result.file = file

    } catch (err) {

      result.msg = `[${chalk.blue(path)}] ${chalk.red(JSON.stringify(err))}`

    }

    return result

  }

}

compressSvga的「输入」、「输出」和compressImg保持一致，目的是为了可以使用promise.all同时调用。在compressSvga内部，对svga进行解析成data，获取到svga的图片列表images，接着调用compressImg对images进行压缩，使用压缩后的图片覆盖data.images，最后再把data编码后，写入到本地覆盖原本的svga。

最后

再说一遍，大家真正使用的时候，要使用官方的tinify进行压缩。

参考文章：

• protobuf.js

• SVGAPlayer-Web-Lite

• tinify

祝大家生活愉快，工作顺利！

作者：JustCarryOn
链接：juejin.cn/post/7153086294409609229

这天在实验室和学长一起写学校的项目，学长突然问我一句：“你用过 Symbol 吗？” 然而我的大脑却遍历不出这个关键性名词，啊，又要补漏了

let a = Symbol()
typeof a

let a = new Symbol()
typeof a // Symbol is not a constructor

let a = Symbol()
let b = Object(a)
typeof b // object

let a = Symbol()
let b = Symbol()

let a = Symbol("a")
let b = Symbol("b")

let a = Symbol()
let obj = {}
obj[a] = "hello world"

if (name === "猪痞恶霸") {
    console.log(1)
}

switch (name) {
        case "猪痞恶霸"
        console.log(1)
        case "Ned"
        console.log(2)
}

const judge = {
    name_1:"猪痞恶霸"
    name_2:"Ned"
}
switch (name) {
        case judge.name_1
        console.log(1)
        case judge.name_2
        console.log(2)
}

const judge = {
    rectangle:Symbol("rectangle"),
    triangle:Symbol("triangle")
}
function getArea(model, size) {
    switch (model) {
        case judge.rectangle:
            return size.width * size.height
        case judge.triangle:
            return size.width * size.height / 2
    }
}
let area = getArea(judge.rectangle ,{width:100, height:200})
console.log(area)

let a = Symbol.for("a")
let b = Symbol.for("a")
a === b // true

let a = Symbol("a")
let b = Symbol.for("a")
a === b // false

let a = Symbol("a")
let b = Symbol.for("a")
Symbol.keyFor(a) // undefined
Symbol.keyFor(b) // 'a'

class demo {
    static [Symbol.hasInstance](item) {
        return item === "猪痞恶霸"
    }
}
"猪痞恶霸" instanceof demo // true

埋点统计在我们业务里经常有遇到，或者很普遍的，我们自己网站也会加入第三方统计，我们会看到动态加载方式去加载jsdk,也就是你常常看到的insertBefore操作，我们很少考虑到为什么这么做，直接同步加载不行吗？统计代码会影响业务首屏加载吗？同步引入方式，当然会，我的业务代码还没加载，首屏就加载一大段统计的jsdk,在移动端页面打开要求比较高的苛刻条件下，首屏优化，你可以在埋点统计上做些优化，那么页面加载会有一个很大的提升，本文是一篇笔者关于埋点优化的笔记，希望看完在项目中有所思考和帮助。

正文开始...

最近遇到一个问题，先看一段代码

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>埋点</title>
    <script>
      window.formateJson = (data) => JSON.stringify(data, null, 2);
    </script>
    <script async defer>
      (function (win, head, attr, script) {
        console.log("---111---");
        win[attr] = win[attr] || [];
        const scriptDom = document.createElement(script);
        scriptDom.async = true;
        scriptDom.defer = true;
        scriptDom.src = "./js/tj.js";
        scriptDom.onload = function () {
          win[attr].push({
            id: "maic",
          });
          win[attr].push({
            id: "Tom",
          });
          console.log("---2222---");
          console.log(formateJson(win[attr]));
        };
        setTimeout(() => {
          console.log("setTimeout---444---");
          head.parentNode.insertBefore(scriptDom, head);
        }, 1000);
      })(window, document.getElementsByTagName("head")[0], "actd", "script");
    </script>
    <script async defer src="./js/app.js"></script>
  </head>
  <body>
    <div id="app"></div>
  </body>
</html>

我们会发现,打印的顺序结果是下面这样的：

---111---
app.js:2 ---333--- start load app.js
app.js:4 [
  {
    "id": "pink"
  }
]
(index):30 setTimeout---444---
(index):26 ---2222---
(index):27 [
  {
    "id": "pink"
  },
  {
    "id": "maic"
  },
  {
    "id": "Tom"
  }
]

冥思苦想,我们发现最后actd的结果是

 [
  {
    "id": "pink"
  },
  {
    "id": "maic"
  },
  {
    "id": "Tom"
  }
]

其实我想要的结果是先添加maic,Tom,最后添加pink,需求就是，必须先在这个ts.js执行后，预先添加基础数据，然后在其他业务app.js添加其他数据，所以此时，无论如何都是满足不了我的需求。

试下想，为什么没有按照我的预期的要求走，问题就是出现在这个onload方法上

onload事件

于是查询资料寻得，onload事件是会等引入的外部资源 加载完毕后才会触发

外部资源加载完毕是什么意思？

举个栗子,我在引入的index2.html引入index2.js,然后在引入脚本上写一个onload事件测试loadIndex2方法是否在我延时加载后进行调用的

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <script>
      function loadIndex2() {
        console.log("script loader...");
      }
    </script>
    <script src="./js/index2.js" onload="loadIndex2()"></script>
  </body>
</html>

index2.js中写入一段代码

var startTime = Date.now()
const count = 1000;
let wait = 10000;
/// 设置延时
const time = wait * count;
for (let i = 0; i < time; i++) { }

var endTime = Date.now()
console.log(startTime, endTime)
console.log(`延迟了：${Math.ceil((endTime - startTime) / 1000)}s后执行的`)

最后看下打印结果

所以可以证实，onload是会等资源下载完了后，才会立即触发

所以我们回头来看

在浏览器的事件循环中，同步任务主线程肯定优先会先顺序执行

从打开印---111---,

然后到onload此时不会立即执行

遇到定时器，定时器设置了1s后会执行，是个宏任务，会放入队列中，此时不会立即执行

然后接着会执行<script async defer src="./js/app.js"></script>脚本

所以此时，执行该脚本后，我们可以看到会先执行push方法。

所以我们看到pink就最先被推入数组中，当该脚本执行完毕后，此时会去执行定时器

定时器里我们看到我们插入方式insertBefore,当插入时成功时，此时会调用onload方法，所以此时就会添加maic与Tom

很明显，我们此时的需求不满足我们的要求，而且一个onload方法已经成了拦路虎

那么我去掉onload试试，因为onload方法只会在脚本加载完毕后去执行，他只会等执行定时器后，成功插入脚本后才会真正执行，而此时其他脚本已经优先它的执行了。

那该怎么解决这个问题呢？

我把onload去掉试试,于是我改成了下面这样

<script async defer>
(function (win, head, attr, script) {
        console.log("---111---");
        win[attr] = win[attr] || [];
        const scriptDom = document.createElement(script);
        scriptDom.async = true;
        scriptDom.defer = true;
        scriptDom.src = "./js/tj.js";
        win[attr].push({
          id: "maic",
        });
        win[attr].push({
          id: "Tom",
        });
        console.log("---2222---");
        console.log(formateJson(win[attr]));
        setTimeout(() => {
          console.log("setTimeout---444---");
          head.parentNode.insertBefore(scriptDom, head);
        }, 1000);
      })
  (window, document.getElementsByTagName("head")
  [0], "actd", "script");
</script>

去掉onload后，我确实达到了我想要的结果

最后的结果是

[
  {
    "id": "maic"
  },
  {
    "id": "Tom"
  },
  {
    "id": "pink"
  }
]

但是你会发现

我先保证了window.actd添加了我预定提前添加的基础信息，但是此时，这个脚本并没有真正添加到dom中，我们执行完同步任务后，就会执行app.js，当1s后，我才真正执行了这个插入的脚本，而且我统计脚本你会发现此时是在先执行了app.js再加载tj.js的

当执行setTimeout时，我们会发现先执行了内部脚本，然后才执行打印

 <script async defer>
      (function (win, head, attr, script) {
        console.log("---111---");
        win[attr] = win[attr] || [];
        const scriptDom = document.createElement(script);
        scriptDom.async = true;
        scriptDom.defer = true;
        scriptDom.src = "./js/tj.js";
        win[attr].push({
          id: "maic",
        });
        win[attr].push({
          id: "Tom",
        });
        console.log("---2222---");
        console.log(formateJson(win[attr]));
        setTimeout(() => {
          console.log("setTimeout---444444---");
          window.actd.push({
            id: "setTimeout",
          });
          head.parentNode.insertBefore(scriptDom, head);
          console.log(formateJson(window.actd));
        }, 1000);
      })(window, document.getElementsByTagName("head")[0], "actd", "script");
    </script>

最后的结果，可以看到是这样的

[

  {

    "id": "maic"

  },

  {

    "id": "Tom"

  },

  {

    "id": "pink"

  },

  {

    "id": "setTimeout"

  }

]

看到这里不知道你心里有没有一个疑问，为什么在动态插入脚本时，我要用一个定时器1s钟？为什么我需要用insertBefore这种方式插入脚本？，我同步方式引入不行吗？不要定时器又会有什么样的结果？

我们通常在接入第三方统计时，貌似都是一个这样一个insertBefore插入的jsdk方式(但是一般我们都是同步方式引入jsdk)

没有使用定时器(3237ms)

 <script async defer>

      (function (win, head, attr, script) {

        ...

        console.log("setTimeout---444444---");

        window.actd.push({

          id: "setTimeout",

        });

        head.parentNode.insertBefore(scriptDom, head);

        console.log(formateJson(window.actd));

      })(window, document.getElementsByTagName("head")[0], "actd", "script");

    </script>

结果:

[

  {

    "id": "maic"

  },

  {

    "id": "Tom"

  },

  {

    "id": "setTimeout"

  },

  {

    "id": "pink"

  },

]

使用用定时器的(1622ms)

<script async defer>

      (function (win, head, attr, script) {

        ...

        setTimeout(() => {

          console.log("setTimeout---444444---");

          window.actd.push({

            id: "setTimeout",

          });

          head.parentNode.insertBefore(scriptDom, head);

          console.log(formateJson(window.actd));

        }, 1000);

      })(window, document.getElementsByTagName("head")[0], "actd", "script");

    </script>

当我们用浏览器的Performance去比较两组数据时，我们会发现总长时间，使用定时器的性能大概比没有使用定时器的性能时间上大概要少50%,在summary中所有数据均有显著的提升。

不经感叹，就一个定时器这一点点的改动，对整个应用提升有这么大的提升，我领导说，快应用在线加载时，之前因为这个统计js的加载明显阻塞了业务页面打开速度，做了这个优化后，打开应用显著提升不少。

我们再继续上一个问题，为什么不同步加载？

我把代码改造一下,去除了一些无关紧要的代码

<!DOCTYPE html>

<html lang="en">

  <head>

    <meta charset="UTF-8" />

    <meta http-equiv="X-UA-Compatible" content="IE=edge" />

    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    <title>js执行的顺序问题</title>

    <script>

      window.formateJson = (data) => JSON.stringify(data, null, 2);

    </script>

    <script async defer src="./js/tj.js"></script>

    <script async defer>

      (function (win, head, attr, script) {

        win[attr] = win[attr] || [];

        win[attr].push({

          id: "maic",

        });

        win[attr].push({

          id: "Tom",

        });

        console.log("---2222---");

        console.log(formateJson(win[attr]));

      })(window, document.getElementsByTagName("head")[0], "actd", "script");

    </script>

    <script async defer src="./js/app.js"></script>

  </head>

  <body>

    <div id="app"></div>

  </body>

</html>

结果

[

  {

    "id": "maic"

  },

  {

    "id": "Tom"

  },

  {

    "id": "pink"

  }

]

嘿，需求是达到了，因为我的业务app.js加的数据是最后一条，说明业务功能上是ok的，但是我们看下分析数据

首先肯定是加载顺序会发生变化，会先加载tj.js然后再加载业务app.js,你会发现同步加载这种方式有个弊端，假设tj.js很大，那么是会阻塞影响页面首屏打开速度的，所以在之前采用异步，定时器方式，首屏加载会有显著提升。

同步加载(1846ms)

我们发现tj.js与app.js相隔的时间很少，且我们从火焰图中分析看到，Summary的数据是1846ms

综上比较，虽然同步加载依然比不上使用定时器的加载方式，使用定时器相比较同步加载，依然是领先11%左右

异步标识async/defer

在上面的代码中，我们多次看到async和defer标识，在之前文章中笔者有写过一篇你真的了解esModule吗,阐述一些关于script标签中type="moudle", defer,async的几个标识，今天再次回顾下

其实从脚本优先级来看，同步的永远优先最高，当一个script标签没有指定任何标识时，此时根据js引擎执行来说，谁放前面，谁就会优先执行，前面没执行完，后面同步的script就不会执行

注意到没有，我在脚本上有加async与defer

在上面栗子中，我们使用insertBefore方式，这就将该插入的js脚本的优先级降低了。

我们从上面火焰图中可以分析得处结论，排名先后顺序依次如下

1、setTimeout+insertBefore

执行顺序:app.js->tj.js

2、同步脚本加载

执行顺序:tj.js->app.js

3、不使用定时器+insertBefore

执行顺序:app.js->tj.js

当我们知道在1中，app.js优先于tj.js

因为insertBefore就是一种异步动态加载方式

举个例子

<script async defer>
  // 执行
  console.log(1)
  // 2 insertBefore 这里再动态添加js
</script>
<script async defer>
  // 执行
  console.log(3)
</script>

执行关系就是1,3,2

关于async与defer谁先执行时，defer的优先级比较低，会等异步标识的async下载完后立马执行，然后再执行defer的脚本，具体可以参考以前写的一篇文章你真的了解esModule吗

总结

• 统计脚本，我们可以使用定时器+insertBefore方式可以大大提高首屏的加载速度，这也给我们了一些启发，首屏加载，非业务代码，比如埋点统计可以使用该方案做一点小优化加快首屏加载速度

• 如果使用insertBefore方式，非常不建议同步方式+insertBefore,这种方式还不如同步加载统计脚本

• 在特殊场景下，我们需要加载统计脚本，有基础信息的依赖后，我们也需要在业务代码使用统计，我们不要在动态加载脚本的同时使用onload,在onload中尝试添加基础信息，实际上这种方式并不能满足你的需求

• 一些关于async与defer的特性，记住，执行顺序，同步任务会优先执行，async是异步，脚本下载完就执行，defer优先级比较低。

• 本文示例code example

作者：Maic
来源：juejin.cn/post/7153216620406505480

酸奶喝对，事半功倍！对于一些晦涩难懂，近乎神话的专业名词，切莫抓耳挠腮，我们直接上代码，加上通俗易懂地语言去渲染，且看今天我们如何拿捏javascript中的小山丘--作用域&作用域链，不止精解。

前言

我们需要先知道的是引擎，引擎的工作简单粗暴，就是负责javascript从头到尾代码的执行。引擎的一个好朋友是编译器，主要负责代码的分析和编译等；引擎的另一个好朋友就是今天的主角--作用域。那么作用域用来干什么呢？作用域链跟作用域又有什么关系呢？

一、作用域(scope)

作用域的定义：作用域是在运行时代码中的某些特定部分中变量，函数和对象的可访问性。

1、作用域的分类

(1)全局作用域

var name="global";
function foo(){
    console.log(name);
}
foo();//global

这里函数foo()内部并没有声明name变量，但是依然打印了name的值，说明函数内部可以访问到全局作用域，读取name变量。再来一个例子：

hobby='music';
function foo(){
    hobby='book';
    console.log(hobby);
}
foo();//book

这里全局作用域和函数foo()内部都没有声明hobby这个变量，为什么不会报错呢？这是因为hobby='music';写在了全局作用域，就算没有var,let,const的声明，也会被挂在window对象上，所以函数foo()不仅可以读取，还可以修改值。也就是说hobby='music';等价于window.hobby='music';。

(2)函数体作用域 函数体的作用域是通过隐藏内部实现的。换句话说，就是我们常说的，内层作用域可以访问外层作用域，但是外层作用域不能访问内层。原因，说到作用域链的时候就迎刃而解了。

function foo(){
    var age=19;
    console.log(age);
}
console.log(age);//ReferenceError:age is not defined

很明显，全局作用域下并没有age变量，但是函数foo()内部有，但是外部访问不到，自然而然就会报错了，而函数foo()没有调用，也就不会执行。

(3)块级作用域 块级作用域更是见怪不怪，像我们接触的let作用域，代码块{}，for循环用let时的作用域，if,while,switch等等。然而，更深刻理解块级作用域的前提是，我们需要先认识认识这几个名词：

--标识符：能在作用域生效的变量。函数的参数，变量，函数名。需要格外注意的是：函数体内部的标识符外部访问不到。

--函数声明：function 函数名(){}

--函数表达式： var 函数名=function(){}

--自执行函数： (function 函数名(){})()；自执行函数前面的语句必须有分号，通常用于隐藏作用域。

接下来我们就用一个例子，一口气展示完吧

function foo(sex){
    console.log(sex);
}
var f=function(){
    console.log('hello');
}
var height=180;
(
    function fn(){
        console.log(height);
    }
)();
foo('female');
//依次打印：
//180
//female

分析一下：标识符:foo,sex,height,fn;函数声明：function foo(sex){};函数表达式：var f=function(){};自执行函数：(function fn(){})();需要注意，自执行函数fn()前面的var height=180;语句，分号不能抛弃。否则，你可以试一下。

二、预编译

说好只是作用域和作用域链的，但是考虑到理解作用域链的必要性，这里还是先聊聊预编译吧。先讨论预编译在不同环境发生的情况下，是如何进行预编译的。

1. 发生在代码执行之前

（1）声明提升

console.log(b);
var b=123;//undefined

这里打印undefined,这不是报错，与Refference:b is not defined不同。这是代码执行之前，预编译的结果，等同于以下代码：

var b;//声明提升
console.log(b);//undefined
b=123;

（2）函数声明整体提升

test();//hello123  调用函数前并没有声明，但是任然打印，是因为函数声明整体提升了
function test(){
    var a=123;
    console.log('hello'+a);
}

2.发生在函数执行之前

理解这个只需要掌握四部曲：