:::info{title="相关信息"}
在 JavaScript 中，算术操作符和其他运算符有严格的优先级规则。以下是一个涵盖 JavaScript 算术优先级（以及其他常见运算符优先级）的完整清单，优先级从高到低排列。优先级越高，运算符会越早被执行。
:::




---

### **JavaScript 运算符优先级表**
| 优先级 | 运算符                          | 描述                               | 结合性   |
|--------|--------------------------------|------------------------------------|----------|
| 1      | `()`                          | 圆括号（分组）                     | 从左到右 |
| 2      | `.` `[]` `()`                 | 成员访问、数组索引、函数调用        | 从左到右 |
| 3      | `new`（带参数列表）           | 创建对象实例                       | 从右到左 |
| 4      | `++` `--`（后缀）             | 自增、自减（后缀形式）             | 从左到右 |
| 5      | `++` `--`（前缀）、`+` `-`    | 自增、自减（前缀）、正负号         | 从右到左 |
|        | `~` `!` `typeof` `void` `delete` | 按位取反、逻辑非、类型、空值、删除 | 从右到左 |
| 6      | `**`                          | 幂运算                            | 从右到左 |
| 7      | `*` `/` `%`                   | 乘法、除法、取余                  | 从左到右 |
| 8      | `+` `-`                       | 加法（字符串拼接）、减法           | 从左到右 |
| 9      | `<<` `>>` `>>>`               | 左移、右移、无符号右移             | 从左到右 |
| 10     | `<` `<=` `>` `>=` `in` `instanceof` | 小于、小于等于、大于、大于等于、是否包含、实例比较 | 从左到右 |
| 11     | `==` `!=` `===` `!==`         | 相等、不相等、全等、不全等         | 从左到右 |
| 12     | `&`                           | 按位与                            | 从左到右 |
| 13     | `^`                           | 按位异或                          | 从左到右 |
| 14     | `|`                           | 按位或                            | 从左到右 |
| 15     | `&&`                          | 逻辑与                            | 从左到右 |
| 16     | `||`                          | 逻辑或                            | 从左到右 |
| 17     | `??`                          | 空值合并                          | 从左到右 |
| 18     | `? :`                         | 条件（三元）运算符                | 从右到左 |
| 19     | `=` `+=` `-=` `*=` `/=` `%=`  | 赋值及复合赋值运算符              | 从右到左 |
|        | `<<=` `>>=` `>>>=` `&=` `^=` `|=` | 按位操作符复合赋值               | 从右到左 |
| 20     | `yield` `yield*`              | 生成器运算                        | 从右到左 |
| 21     | `,`                           | 逗号                              | 从左到右 |

---

### **说明**
1. **括号 (`()`)**：
   - 括号的优先级最高，用于明确运算顺序。
   - 例如：`(2 + 3) * 4` 将先计算 `2 + 3`。

2. **一元运算符 (`+`, `-`, `!`, `~`)**：
   - 在数字前使用 `+` 和 `-` 表示正数和负数。
   - `!` 表示逻辑非，`~` 表示按位取反。

3. **幂运算符 (`**`)**：
   - 比乘法和除法优先级更高，右结合。
   - 例如：`2 ** 3 ** 2` 等同于 `2 ** (3 ** 2)`。

4. **加法与字符串拼接 (`+`)**：
   - 如果操作数包含字符串，`+` 将进行字符串拼接。

5. **赋值运算符 (`=`)**：
   - 右结合，表示右侧值赋给左侧变量。
   - 例如：`a = b = 5` 等同于 `a = (b = 5)`。

6. **逻辑与/或 (`&&`, `||`) 和空值合并 (`??`)**：
   - `&&` 和 `||` 用于短路逻辑。
   - `??` 仅在值为 `null` 或 `undefined` 时触发。

7. **条件（三元）运算符 (`? :`)**：
   - 用于简洁条件判断，例如：`x > 10 ? 'big' : 'small'`。

8. **逗号运算符 (`,`)**：
   - 多用于将多个表达式合并为一个表达式，返回最后一个表达式的值。

---

JavaScript 运算符优先级表

:::info{title="相关信息"}
如果你的代理都是 HTTP 的，并且是自己使用的，那么 HTTP 代理是完全可以满足需求的。以下是通过终端输入的方式，分别为 **Python (pip)** 和 **Node.js (npm)** 设置全局 HTTP 代理的具体步骤：
:::


---

### **1. 为 pip 设置全局 HTTP 代理**
在终端中执行以下命令：

```bash
pip config set global.proxy http://username:password@proxy_address:port
```

如果代理不需要用户名和密码认证，直接写代理地址：
```bash
pip config set global.proxy http://proxy_address:port
```

#### 示例：
```bash
pip config set global.proxy http://192.168.1.1:8080
```

**查看配置是否生效：**
```bash
pip config list
```

如果需要删除全局代理：
```bash
pip config unset global.proxy
```

---

### **2. 为 npm 设置全局 HTTP 代理**

#### 设置 HTTP 代理
在终端中执行以下命令：
```bash
npm config set proxy http://username:password@proxy_address:port
```

如果代理不需要用户名和密码认证：
```bash
npm config set proxy http://proxy_address:port
```

#### 设置 HTTPS 代理（建议同时设置）
即使代理是 HTTP 的，建议同时为 HTTPS 设置，方便访问 HTTPS 网站：
```bash
npm config set https-proxy http://username:password@proxy_address:port
```

#### 示例：
```bash
npm config set proxy http://192.168.1.1:8080
npm config set https-proxy http://192.168.1.1:8080
```

#### 查看代理配置：
```bash
npm config get proxy
npm config get https-proxy
```

#### 删除代理配置：
如果需要移除代理设置：
```bash
npm config delete proxy
npm config delete https-proxy
```

---

### **总结**
如果你只有 HTTP 代理，直接在 pip 和 npm 中使用 `http://proxy_address:port` 即可，它们会自动适配 HTTP 和 HTTPS 请求。

两者的命令对比总结：
- **pip**：使用 `pip config set global.proxy`。
- **npm**：使用 `npm config set proxy` 和 `npm config set https-proxy`。

希望这对你有帮助！ 😊

pip-npm配置代理

:::info{title="相关信息"}
`path` 对象上的方法都是用来替换 AST 节点的，但它们在用法和适用场景上有所不同。下面我来逐一解释：
:::


**1. `path.replaceInline(nodes)`**

*   **作用:** 将当前节点替换为**多个**节点。这些节点会被视为**并列的兄弟节点**。
*   **参数:** `nodes`，一个包含多个 AST 节点的数组。
*   **特点:**
    *   它会移除当前节点，并将其替换为数组中的所有节点。
    *   这些新节点会与当前节点的父节点保持相同的父子关系。
    *   适用于将单个节点展开为多个节点的情况，例如将一个函数调用展开为多个语句。
*   **示例:**
    ```javascript
    // 假设 path 指向一个 CallExpression 节点：console.log("hello");
    path.replaceInline([
      types.expressionStatement(types.stringLiteral("before")),
      path.node,
      types.expressionStatement(types.stringLiteral("after"))
    ]);
    // 会将 console.log("hello"); 替换为：
    // "before";
    // console.log("hello");
    // "after";
    ```

**2. `path.replaceExpressionWithStatements(nodes)`**

*   **作用:** 将当前**表达式**节点替换为**多个语句**节点。
*   **参数:** `nodes`，一个包含多个 AST 语句节点的数组。
*   **特点:**
    *   它只能用于替换表达式节点。
    *   它会将当前表达式节点替换为多个语句。
    *   适用于将一个表达式展开为多个语句的情况，例如将一个三元表达式展开为 `if-else` 语句。
*   **示例:**
    ```javascript
    // 假设 path 指向一个 ConditionalExpression 节点：a ? b : c
    path.replaceExpressionWithStatements([
      types.ifStatement(
        path.node.test,
        types.blockStatement([types.expressionStatement(path.node.consequent)]),
        types.blockStatement([types.expressionStatement(path.node.alternate)])
      )
    ]);
    // 会将 a ? b : c 替换为：
    // if (a) { b; } else { c; }
    ```

**3. `path.replaceWith(node)`**

*   **作用:** 将当前节点替换为**单个** AST 节点。
*   **参数:** `node`，一个 AST 节点。
*   **特点:**
    *   这是最常用的替换方法。
    *   它会将当前节点替换为新的单个节点。
    *   适用于替换单个节点的情况，例如替换一个变量标识符，或者替换一个表达式。
*   **示例:**
    ```javascript
    // 假设 path 指向一个 Identifier 节点：a
    path.replaceWith(types.identifier("b"));
    // 会将 a 替换为 b
    ```

**4. `path.replaceWithSourceString(sourceString)`**

*   **作用:** 将当前节点替换为从**源代码字符串**解析得到的 **单个** AST 节点。
*   **参数:** `sourceString`，一个字符串，表示要替换成的新代码。
*   **特点:**
    *   它会自动解析 `sourceString` 为 AST 节点。
    *   适用于直接使用源代码字符串替换节点的情况。
    *   相对于 `path.replaceWith()`，更加方便，但灵活性稍差。
*   **示例:**
    ```javascript
    // 假设 path 指向一个 Identifier 节点：a
    path.replaceWithSourceString("b + 1");
    // 会将 a 替换为 b + 1
    ```

**5. `path.replaceWithMultiple(nodes)`**

*   **作用:** 将当前节点替换为**多个**节点。这些节点会被视为**并列的兄弟节点**。
*   **参数:** `nodes`，一个包含多个 AST 节点的数组。
*   **特点:**
    *   与 `path.replaceInline()` 功能相似。
    *   `replaceWithMultiple` 是 `replaceInline` 的别名，两者完全相同。
*   **示例:**
    ```javascript
    // 假设 path 指向一个 CallExpression 节点：console.log("hello");
    path.replaceWithMultiple([
      types.expressionStatement(types.stringLiteral("before")),
      path.node,
      types.expressionStatement(types.stringLiteral("after"))
    ]);
    // 会将 console.log("hello"); 替换为：
    // "before";
    // console.log("hello");
    // "after";
    ```

**总结：**

| 方法                       | 作用                                         | 参数                               | 替换结果        | 适用场景                                                                  |
| -------------------------- | -------------------------------------------- | ---------------------------------- | ------------- | ------------------------------------------------------------------------- |
| `replaceInline(nodes)`     | 替换为多个兄弟节点                             | AST 节点数组 (`nodes`)              | 多个同级节点    | 将一个节点展开为多个同级节点                                                     |
| `replaceExpressionWithStatements(nodes)` | 将表达式替换为多个语句                        | AST 语句节点数组 (`nodes`)           | 多个语句      | 将一个表达式展开为多个语句                                                        |
| `replaceWith(node)`        | 替换为单个节点                                | AST 节点 (`node`)                   | 单个节点       | 替换单个节点，如标识符、表达式、语句等                                            |
| `replaceWithSourceString(sourceString)` | 替换为从源代码字符串解析的单个节点 | 源代码字符串 (`sourceString`)      | 单个节点       | 使用源代码字符串替换节点，方便快捷，但灵活性稍差                                         |
| `replaceWithMultiple(nodes)` | 替换为多个兄弟节点                             | AST 节点数组 (`nodes`)              | 多个同级节点    |  与 `replaceInline`  功能相同，将一个节点展开为多个同级节点                                                  |

**选择哪个方法？**

*   **`replaceWith(node)`:**  最常用，适用于大多数替换单个节点的情况。
*   **`replaceWithSourceString(sourceString)`:**  当你需要直接使用源代码字符串替换节点时，更方便。
*   **`replaceInline(nodes)` 或 `replaceWithMultiple(nodes)`:** 当你需要将一个节点替换为多个同级节点时使用。
*   **`replaceExpressionWithStatements(nodes)`:** 当你需要将一个表达式替换为多个语句时使用。

了解这些方法的区别和适用场景，可以帮助你更有效地操作 Babel AST，完成代码转换和分析任务。

Path中方法替换 AST 节点

:::info{title="相关信息"}
记录了hysteria2配置一键安装脚本安装时的详细细节
:::




# 全部



## 1.基本描述

```
当前日期
2024-11-19

官方地址
https://github.com/apernet/hysteria

使用的ubuntu2204
root@s12676:~# uname -a
Linux s12676 5.15.0-122-generic #132-Ubuntu SMP Thu Aug 29 13:45:52 UTC 2024 x86_64 x86_64 x86_64 GNU/Linux

使用的ssh
finalshell

服务器是
https://claw.cloud/
CPU 1 vCPU
内存 1 GiB
存储 20 GiB
带宽 1000 Mbps
流量 500 GB

客服端是v2rayN
地址 https://github.com/2dust/v2rayN/releases
直接下载最新的 v2rayN-windows-64-SelfContained-With-Core.7z
```

## 2.开始

### 2.1更新

```
apt update -y && apt install -y curl socat wget
```

### 2.2端口放行  

```
一般vps都是直接在机子里面放行就可以了

sudo ufw allow 800
sudo ufw allow 5678
sudo ufw reload

root@s12676:~# sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
20/tcp                     ALLOW       Anywhere                  
21/tcp                     ALLOW       Anywhere                  
22/tcp                     ALLOW       Anywhere                  
80/tcp                     ALLOW       Anywhere                  
443/tcp                    ALLOW       Anywhere                  
888/tcp                    ALLOW       Anywhere                  
27624/tcp                  ALLOW       Anywhere                  
39000:40000/tcp            ALLOW       Anywhere                  
6379/tcp                   ALLOW       Anywhere                  
3306/tcp                   ALLOW       Anywhere                  
5678/tcp                   ALLOW       Anywhere                  
800/tcp                    ALLOW       Anywhere                  
20/tcp (v6)                ALLOW       Anywhere (v6)             
21/tcp (v6)                ALLOW       Anywhere (v6)             
22/tcp (v6)                ALLOW       Anywhere (v6)             
80/tcp (v6)                ALLOW       Anywhere (v6)             
443/tcp (v6)               ALLOW       Anywhere (v6)             
888/tcp (v6)               ALLOW       Anywhere (v6)             
27624/tcp (v6)             ALLOW       Anywhere (v6)             
39000:40000/tcp (v6)       ALLOW       Anywhere (v6)             
6379/tcp (v6)              ALLOW       Anywhere (v6)             
3306/tcp (v6)              ALLOW       Anywhere (v6)             
5678/tcp (v6)              ALLOW       Anywhere (v6)             
800/tcp (v6)               ALLOW       Anywhere (v6)   
```

### 2.3一键安装脚本

```
wget -N --no-check-certificate https://raw.githubusercontent.com/flame1ce/hysteria2-install/main/hysteria2-install-main/hy2/hysteria.sh && bash hysteria.sh
```

- 选择

```
必应自签证书
Hysteria 2 端口 输入800
单端口(我是选择的单端口 跳跃的话我的服务器有点问题)
密码 输入自己的
伪装网站地址 输入www.bing.com
```

- 选择完后会显示一些连接方法 文件

## 3.配置到v2rayN

```
1.打开客服端软件
2.点击服务器
3.点击添加[Hysteria2]服务器
```

```
1.别名随便填
2.地址填服务器ip
3.端口800
4.密码自己设置的
5.传输层安全选择tls
6.SNI填www.bing.com
7.跳过证书认证选择true
```

```
右键服务器 选择一键多线程测试..
有显示延迟和速度就可以了
```