Js

解释 module 和 closure（模块模式与闭包）

export语句输出的接口，与其对应的值是动态绑定关系。
CommonJS 输出的是一个值的拷贝（简单类型拷贝，引用类型拷贝引用）；ES Modules 生成一个引用（仿佛所有的类型通过 export 与 import 连接后都成为了引用类型），等到真的需要用到时，再到模块里面去取值，模块里面的变量，绑定其所在的模块。
https://juejin.cn/post/6844904191840747533#comment

CommonJS 是值的缓存（snapshot），没有动态更新

  • CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
  • CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。
  • CommonJS 模块的require()是同步加载模块，ES6 模块的import命令是异步加载，有一个独立的模块依赖的解析阶段。

第二个差异是因为 CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

模块导出变量的引用（不管是简单类型还是引用类型）不可被修改，也就是 import 后的接口变量都是只读的，但是引用类型接口变量的内部内容是可以修改的，且一旦修改了，其他导入该模块引用类型变量的地方，也会收到修改后的内容。
image.png

https://medium.com/javascript-in-plain-english/javascript-from-closure-to-modules-21d1ba30ab36
The ‘classic’ or ‘revealing’ module pattern states as follows: “Modules encapsulate data and behavior (methods) together. The state (data) of a module is held by its methods via closure.
模块将数据和行为（方法）封装到了一起。一个模块的自有数据则通过闭包，被模块的方法所持有。
The module pattern is the grouping of a set of behavior (functions), and data into one logical unit.
模块模式：一组行为（functions）与数据被放到了一个逻辑单元，
image.png
词法作用域（lexical scoping）：Global，Module，Function，Block
闭包（closures）
所以用原生的函数作用域加闭包，也是可以模拟模块的：

  1. function PetShopModule(animal){
  2.    function animalName(name){
  3.        console.log(`${name} is a ${animal}`)
  4.    }
  6.    var publicAPI = { animalName };
  7.    return publicAPI;
  8. }
  10. var animal = PetShopModule("Dog")
  11. animal.animalName("Kim")   // "Kim is a Dog"

It is important to note is that these file-based modules are also singletons，meaning even though they are imported many times into an application, they only run once.

es module 中的模块文件都是 单例的，因为本质上所有的 import 都是对模块的引用，所以无论模块被 import 多少次，属于模块词法作用域内的内容，始终只存在一份，且只执行一次。
所以只要维持单例，加闭包返回函数作用域内部变量，就可以简单模拟es module了
而 commonjs 则始终是一个执行完再复制的操作，require 完后简单类型被复制了一份，引用类型则多了一个引用，执行则每次 require 都会执行。

位运算符

只支持 32 位，溢出的会从最高位开始移除：
|：左右同位有 1，则为1，同位都为0，则为0
image.png
&：左右同位都为 1 则为 1 否则都为 0
image.png
^：左右同位只能有一个为1，否则为0 XOR
image.png
位运算意味着更快的速度，更少的内存占用，更简洁的代码（更看不懂）
所以常见于一些底层库的运算