加载笔记内容...
加载笔记内容...
JavaScript 的变量类型：
值类型的特点：
占用空间固定，保存在栈中（当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量将会逐个放入这块栈内存里，随着方法的执行结束，这个方法的内存栈也将自然销毁了。因此，所有在方法中定义的变量都是放在栈内存中的；栈中存储的是基础变量以及一些对象的引用变量，基础变量的值是存储在栈中，而引用变量存储在栈中的是指向堆中的数组或者对象的地址，这就是为何修改引用类型总会影响到其他指向这个地址的引用变量。）
保存与复制的是值本身
使用 typeof 检测数据的类型
| Type | Result |
|---|---|
| Undefined | "undefined" |
| Null | "object" (see below) |
| Boolean | "boolean" |
| Number | "number" |
| BigInt | "bigint" |
| String | "string" |
| Symbol | "symbol" |
| Function (implements [[Call]] in ECMA-262 terms; classes are functions as well) | "function" |
| Any other object | "object" |
In the first implementation of JavaScript, JavaScript values were represented as a type tag and a value. The type tag for objects was 0. null was represented as the NULL pointer (0x00 in most platforms). Consequently, null had 0 as type tag, hence the typeof return value "object". (reference)
A fix was proposed for ECMAScript (via an opt-in), but was rejected. It would have resulted in typeof null === 'null'.
基本类型数据是值类型
JavaScript 在底层存储变量的时候，会在变量的机器码的低位1-3位存储其类型信息
undefined 和 null 来说，这两个值的信息存储是有点特殊的。null：所有机器码均为0
undefined：用 −2^30 整数来表示
但是没人说一下 Symbol 和 BigInt 的
引用类型的特点：
依然不会被销毁，只有当一个对象没有任何引用变量引用它时，系统的垃圾回收机制才会在核实的时候回收它。）object instanceof constructor
1const arr = [1, 2];
2// 判断Object的prototype有没有在数组的原型链上
3console.log(arr instanceof Object); // true
4// 数组arr的原型
5const proto1 = Object.getPrototypeOf(arr);
6console.log(proto1); // []
7// 数组arr的原型的原型
8const proto2 = Object.getPrototypeOf(proto1);
9console.log(proto2); // []
10// Object的prototype
11console.log(Object.prototype);
12// 判断arr的原型是否与Object的prototype相等
13console.log(proto1 === Object.prototype); // false
14// 判断arr的原型的原型是否与Object的prototype相等
15console.log(proto2 === Object.prototype); // trueinstanceof operator tests to see if the prototype property of a constructor appears anywhere in the prototype chain of an object. The return value is a boolean value. Its behavior can be customized with Symbol.hasInstance.this和arguments两个变量名变量提升，改变解析顺序。
Variables declared by var keyword are scoped to the immediate function body (hence the function scope) while let variables are scoped to the immediate enclosing block denoted by { } (hence the block scope).
While variables declared with var keyword are hoisted (initialized with undefined before the code is run) which means they are accessible in their enclosing scope even before they are declared:
1var a = 1;
2function f() {
3 console.log(a);
4 var a = 2;
5}
6f();let variables are not initialized until their definition is evaluated. Accessing them before the initialization results in a ReferenceError. The variable is said to be in "temporal dead zone" from the start of the block until the initialization is processed.
1let a = 1;
2function f() {
3 console.log(a); // 1
4 a = 2;
5}
6f();At the top level, let, unlike var, does not create a property on the global object:
1var foo = "Foo"; // globally scoped
2let bar = "Bar"; // not allowed to be globally scoped
3
4console.log(window.foo); // Foo
5console.log(window.bar); // undefinedIn strict mode, var will let you re-declare the same variable in the same scope while let raises a SyntaxError.
1'use strict';
2var foo = "foo1";
3var foo = "foo2"; // No problem, 'foo1' is replaced with 'foo2'.
4
5let bar = "bar1";
6let bar = "bar2"; // SyntaxError: Identifier 'bar' has already been declaredThe entire contents of JavaScript modules are automatically in strict mode, with no statement needed to initiate it.
1function myStrictFunction() {
2 // because this is a module, I'm strict by default
3}
4export default myStrictFunction;Copy to Clipboard
All parts of a class's body are strict mode code, including both class declarations and class expressions.
1class C1 {
2 // All code here is evaluated in strict mode
3 test() {
4 delete Object.prototype;
5 }
6}
7new C1().test(); // TypeError, because test() is in strict mode
8
9const C2 = class {
10 // All code here is evaluated in strict mode
11};
12
13// Code here may not be in strict mode
14delete Object.prototype; // Will not throw error