Go语言（也称为Golang）是由Google开发的一种静态类型、编译型的编程语言，以其简洁性、高效的并发支持而著称。以下是Go语言的一些基础语法要点：



### 1. 变量声明

在Go中，变量可以通过`var`关键字声明，并且需要指定类型。也可以使用`:=`操作符进行简短声明。

- 使用`var`声明：
```go
var a int
a = 42
```
- 简短声明：
```go
b := "hello"
```

### 2. 基本数据类型

Go支持多种基本数据类型，包括但不限于：

- 整型：`int`, `int8`, `int16`, `int32`, `int64`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`
- 浮点型：`float32`, `float64`
- 布尔型：`bool`
- 字符串：`string`
- 复数：`complex64`, `complex128`

### 3. 控制结构

#### 条件语句

```go
if x > 0 {
    // 当x大于0时执行的代码
} else if x < 0 {
    // 当x小于0时执行的代码
} else {
    // 当x等于0时执行的代码
}
```

#### 循环

- `for`循环是Go中唯一的循环语句。
```go
// 标准for循环
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 无限循环
for {
    // 需要手动break退出循环
}
```

### 4. 函数定义

函数通过`func`关键字定义，可以有参数和返回值。

```go
func add(a int, b int) int {
    return a + b
}

func main() {
    result := add(5, 7)
    fmt.Println(result) // 输出: 12
}
```

### 5. 数组与切片

- **数组**是一个固定大小的数据序列。
```go
var arr [5]int
arr[0] = 1
```

- **切片**是对数组的抽象，允许动态增加元素。
```go
s := []int{1, 2, 3}
s = append(s, 4)
fmt.Println(s) // 输出: [1 2 3 4]
```

### 6. 映射(Map)

映射是一种无序键值对集合。

```go
m := make(map[string]int)
m["apple"] = 2
fmt.Println(m["apple"]) // 输出: 2
```

### 7. 结构体(Struct)

用于定义复杂的数据类型。

```go
type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "John", Age: 30}
    fmt.Println(p.Name) // 输出: John
}
```

### 8. 接口(Interface)

接口定义了一组方法签名，任何实现了这些方法的类型都被认为实现了该接口。

```go
type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var s Speaker = Dog{}
    fmt.Println(s.Speak()) // 输出: Woof!
}
```

### 9. 并发

Go通过goroutine和channel支持简单的并发模型。

- 启动一个新的goroutine：
```go
go func(x int) {
    fmt.Println("Goroutine:", x)
}(1)
```

- Channel用于goroutine之间的通信：
```go
ch := make(chan int)
go func() {
    ch <- 1
}()
fmt.Println(<-ch) // 输出: 1
```

### 10. 错误处理

Go提倡显式错误处理而不是异常机制。

```go
result, err := someFunction()
if err != nil {
    log.Fatal(err)
}
fmt.Println(result)
```

### 11. **包管理**

Go 使用模块（`go.mod`）进行依赖管理和版本控制。从 Go 1.11 开始，默认支持模块功能。

- 初始化一个新的模块：
```bash
go mod init example.com/myapp
```
这会在当前目录下创建一个 `go.mod` 文件，定义了模块路径和依赖项。

- 添加依赖：
当你导入并使用第三方包时，运行 `go get` 命令来添加依赖。
```bash
go get github.com/some/package
```

- 更新依赖：
```bash
go mod tidy
```
这个命令会清理未使用的依赖，并确保所有直接和间接依赖都是最新版本。

### 12. **指针**

Go 支持指针，允许你直接操作内存地址，但不支持指针运算（如 C/C++ 中的指针加减）。

- 获取变量的地址：
```go
a := 42
p := &a // p 是指向 a 的指针
```

- 解引用指针：
```go
fmt.Println(*p) // 输出: 42
```

### 13. **方法**

方法是一种带有接收者的函数，接收者可以是值类型或指针类型。

- 定义方法：
```go
type MyInt int

func (m *MyInt) Add(n int) {
    *m += MyInt(n)
}

func main() {
    var m MyInt = 5
    m.Add(3)
    fmt.Println(m) // 输出: 8
}
```

### 14. **接口与多态性**

接口在 Go 中用于实现多态性。如果一个类型实现了接口的所有方法，则该类型被认为实现了此接口。

- 实现多个接口：
```go
type Speaker interface {
    Speak() string
}

type Mover interface {
    Move() string
}

type Dog struct{}

func (d Dog) Speak() string { return "Woof!" }
func (d Dog) Move() string { return "Running" }

func main() {
    var s Speaker = Dog{}
    var m Mover = Dog{}
    fmt.Println(s.Speak()) // 输出: Woof!
    fmt.Println(m.Move()) // 输出: Running
}
```

### 15. **嵌入类型**

Go 支持通过匿名字段实现组合（Composition），这种方式常被称为“嵌入”。

- 结构体嵌入：
```go
type Animal struct {
    Name string
}

func (a *Animal) Eat() {
    fmt.Println(a.Name, "is eating")
}

type Dog struct {
    Animal // 嵌入 Animal
}

func main() {
    d := Dog{Animal{Name: "Buddy"}}
    d.Eat() // 输出: Buddy is eating
}
```

### 16. **延迟调用（Defer）**

`defer` 关键字用于安排一个函数调用在周围的函数返回之后执行。通常用于资源清理。

- 示例：
```go
func main() {
    defer fmt.Println("World")
    fmt.Println("Hello")
}
// 输出:
// Hello
// World
```

### 17. **闭包**

闭包是一个函数值，它引用了其函数体内定义的变量。这些变量会被保存在闭包中，即使它们超出了原始作用域。

- 示例：
```go
func makeAdder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    adder := makeAdder()
    fmt.Println(adder(1)) // 输出: 1
    fmt.Println(adder(2)) // 输出: 3
}
```

### 18. **选择语句（Select）**

`select` 语句用于等待多个通信操作。它类似于 `switch`，但专门用于通道操作。

- 示例：
```go
ch1 := make(chan string)
ch2 := make(chan string)

go func() {
    time.Sleep(time.Second * 1)
    ch1 <- "one"
}()
go func() {
    time.Sleep(time.Second * 2)
    ch2 <- "two"
}()

for i := 0; i < 2; i++ {
    select {
    case msg1 := <-ch1:
        fmt.Println("Received", msg1)
    case msg2 := <-ch2:
        fmt.Println("Received", msg2)
    }
}
// 可能输出:
// Received one
// Received two
```

### 19. **测试**

Go 提供了内置的测试框架。测试文件名应以 `_test.go` 结尾。

- 编写测试：
```go
package mypkg

import "testing"

func TestAdd(t *testing.T) {
    result := add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}
```

- 运行测试：
```bash
go test ./...
```

### 20. **性能优化**

- 避免不必要的内存分配。
- 使用适当的同步机制（如互斥锁、读写锁）来保护共享数据。
- 利用 Go 的垃圾回收机制，但也要注意避免过度分配导致频繁GC。

以上是对 Go 语言更全面的基础语法介绍。

go语言的基础语法

JavaScript 是一种广泛用于网页和网络应用的编程语言，支持事件驱动、函数式以及基于原型的编程风格。



### 1. 变量声明
在 ES6（ECMAScript 2015）之前，主要使用 `var` 来声明变量。ES6 引入了 `let` 和 `const`。

- **var**: 函数作用域或全局作用域。
- **let**: 块级作用域。
- **const**: 声明常量，块级作用域且一旦赋值不可更改（对于对象和数组，可以修改其内容，但不能重新赋值）。

```javascript
var globalVar = "I'm global";
let blockScoped = "Block scoped";
const constantValue = "Constant value"; // 不可重新赋值
```

### 2. 数据类型
JavaScript 支持多种数据类型：
- **基本类型**：`number`, `string`, `boolean`, `null`, `undefined`, `symbol` (ES6 新增)。
- **复杂类型**：`object`（包括数组、日期等）。

```javascript
let age = 25; // number
let name = "Alice"; // string
let isStudent = true; // boolean
let nothing = null; // null
let und = undefined; // undefined
let sym = Symbol("foo"); // symbol
```

### 3. 运算符
包括算术运算符（如 `+`, `-`, `*`, `/`, `%`）、比较运算符（如 `==`, `===`, `!=`, `!==`, `>`, `<`）、逻辑运算符（如 `&&`, `||`, `!`）等。

```javascript
let result = 5 + 3; // 8
console.log(result === 8); // true, 使用严格等于避免类型转换问题
```

### 4. 控制结构
#### 条件语句
```javascript
if (condition) {
    // code to execute if condition is true
} else if (anotherCondition) {
    // alternative condition
} else {
    // default case
}
```

#### 循环
- `for` 循环
```javascript
for (let i = 0; i < 5; i++) {
    console.log(i);
}
```
- `while` 循环
```javascript
let j = 0;
while (j < 5) {
    console.log(j++);
}
```

### 5. 函数定义与调用
```javascript
function greet(name) {
    return "Hello, " + name;
}

console.log(greet("World")); // 输出: Hello, World
```
ES6 引入了箭头函数：
```javascript
const greet = (name) => "Hello, " + name;
```

### 6. 对象与数组
#### 对象
```javascript
let person = {
    firstName: "John",
    lastName: "Doe",
    fullName: function() {
        return this.firstName + " " + this.lastName;
    }
};
console.log(person.fullName()); // John Doe
```

#### 数组
```javascript
let fruits = ["Apple", "Banana", "Cherry"];
console.log(fruits[1]); // Banana
fruits.push("Date");
console.log(fruits); // ["Apple", "Banana", "Cherry", "Date"]
```

### 7. 错误处理
使用 `try...catch` 结构来处理异常。
```javascript
try {
    // 可能抛出错误的代码
    notDefinedFunction();
} catch (e) {
    console.error("Caught an error: ", e.message);
}
```

### 8. **事件处理**
JavaScript 在网页开发中广泛用于响应用户操作（如点击、输入等）。这通过事件处理机制实现。

#### 示例：添加一个点击事件监听器
```javascript
document.getElementById('myButton').addEventListener('click', function() {
    alert('Button clicked!');
});
```
这段代码会在用户点击 ID 为 `myButton` 的按钮时弹出一个警告框。

### 9. **异步编程**
JavaScript 是单线程语言，但支持异步操作，主要通过回调函数、Promise 和 async/await 实现。

#### 回调函数
```javascript
setTimeout(function() {
    console.log("This runs after 2 seconds");
}, 2000);
```

#### Promise
```javascript
let promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("Done!"), 1000);
});

promise.then(result => console.log(result)); // 输出: Done!
```

#### Async/Await
```javascript
async function asyncFunction() {
    let result = await new Promise((resolve) => 
        setTimeout(() => resolve("Finished"), 2000)
    );
    console.log(result); // 输出: Finished
}

asyncFunction();
```

### 10. **模块化**
ES6 引入了原生的模块支持，允许你将代码分割成多个文件，并在需要的地方导入使用。

#### 导出模块
```javascript
// math.js
export function add(a, b) { return a + b; }
export function subtract(a, b) { return a - b; }
```

#### 导入模块
```javascript
// main.js
import { add, subtract } from './math.js';

console.log(add(5, 3)); // 输出: 8
console.log(subtract(5, 3)); // 输出: 2
```

### 11. **类与继承**
ES6 引入了更接近传统面向对象编程的语言特性，比如类和继承。

#### 定义类
```javascript
class Animal {
    constructor(name) {
        this.name = name;
    }
    
    speak() {
        console.log(`${this.name} makes a noise.`);
    }
}
```

#### 继承
```javascript
class Dog extends Animal {
    speak() {
        console.log(`${this.name} barks.`);
    }
}

let d = new Dog('Mitzie');
d.speak(); // 输出: Mitzie barks.
```

### 12. **模板字符串**
ES6 引入了模板字符串，使得字符串拼接更加方便。
```javascript
let name = "Alice";
let greeting = `Hello, ${name}!`;
console.log(greeting); // 输出: Hello, Alice!
```

### 13. **解构赋值**
解构赋值是一种从数组或对象中提取数据并赋值给变量的便捷方式。

#### 数组解构
```javascript
let [a, b] = [10, 20];
console.log(a); // 输出: 10
console.log(b); // 输出: 20
```

#### 对象解构
```javascript
let person = {name: "John", age: 30};
let {name, age} = person;
console.log(name); // 输出: John
console.log(age); // 输出: 30
```

### 14. **Rest 参数和 Spread 操作符**
- **Rest 参数** (`...`) 允许我们将不定数量的参数表示为数组。
- **Spread 操作符** (`...`) 可以展开数组或对象。

#### Rest 参数
```javascript
function sum(...numbers) {
    return numbers.reduce((total, num) => total + num, 0);
}
console.log(sum(1, 2, 3)); // 输出: 6
```

#### Spread 操作符
```javascript
let arr1 = [1, 2, 3];
let arr2 = [...arr1, 4, 5, 6];
console.log(arr2); // 输出: [1, 2, 3, 4, 5, 6]
```

这些是 JavaScript 更多的基础知识。

javascript的基础语法

`nmap`（Network Mapper）是一个开源的网络扫描工具，广泛用于网络发现和安全审计。它可用于主机发现、端口扫描、版本检测、操作系统检测等。以下是`nmap`的基本使用方法：




### nmap安装

#### **1. 在 Linux 上安装 Nmap**

##### **Debian/Ubuntu 系列**
在基于 Debian 的系统（如 Ubuntu）上，可以使用 `apt` 包管理器安装：
```bash
sudo apt update
sudo apt install nmap
```

##### **CentOS/RHEL/Fedora 系列**
在基于 Red Hat 的系统（如 CentOS、RHEL 或 Fedora）上，可以使用 `yum` 或 `dnf` 包管理器安装：
```bash
sudo yum install nmap    # CentOS/RHEL
sudo dnf install nmap    # Fedora
```

##### **Arch Linux**
在 Arch Linux 上，可以使用 `pacman` 安装：
```bash
sudo pacman -S nmap
```

##### **从源码编译安装**
如果需要最新版本的 Nmap，可以从官网下载源码并手动编译安装：
```bash
# 下载最新版本
wget https://nmap.org/dist/nmap-<version>.tar.bz2

# 解压文件
tar -xvjf nmap-<version>.tar.bz2

# 进入解压后的目录
cd nmap-<version>

# 编译和安装
./configure
make
sudo make install
```
> 替换 `<version>` 为具体的版本号，例如 `7.94`。

---

#### **2. 在 macOS 上安装 Nmap**

##### **通过 Homebrew 安装**
如果你已经安装了 Homebrew，可以通过以下命令安装 Nmap：
```bash
brew install nmap
```

##### **通过 MacPorts 安装**
如果你使用 MacPorts，可以运行以下命令：
```bash
sudo port install nmap
```

##### **直接下载安装包**
也可以从 [Nmap 官方网站](https://nmap.org/download.html) 下载 macOS 版本的 `.dmg` 文件，然后双击安装。

---

#### **3. 在 Windows 上安装 Nmap**

##### **通过官方安装程序**
1. 访问 [Nmap 官方下载页面](https://nmap.org/download.html)。
2. 找到 Windows 版本的部分，下载 `.exe` 安装程序。
3. 双击下载的文件，按照向导完成安装。

##### **验证安装**
安装完成后，打开命令提示符（CMD）或 PowerShell，运行以下命令检查是否安装成功：
```cmd
nmap --version
```
如果安装成功，会显示 Nmap 的版本信息。

---

#### **4. 使用 Docker 安装 Nmap**

如果你喜欢使用容器化技术，可以通过 Docker 安装和运行 Nmap：
```bash
docker pull instrumentisto/nmap
```

运行 Nmap 扫描：
```bash
docker run --rm instrumentisto/nmap <options> <target>
```
例如：
```bash
docker run --rm instrumentisto/nmap -sP 192.168.1.0/24
```

---

#### **5. 验证安装是否成功**
无论在哪种操作系统上安装，都可以通过以下命令验证安装是否成功：
```bash
nmap --version
```
如果安装正确，会显示类似以下输出：
```
Nmap version 7.94 ( https://nmap.org )
Platform: x86_64-pc-linux-gnu
...
```

---

#### **6. 升级 Nmap**
如果你已经安装了 Nmap，但想升级到最新版本，可以按以下方式操作：

##### **Linux**
```bash
sudo apt update && sudo apt upgrade nmap   # Debian/Ubuntu
sudo yum update nmap                      # CentOS/RHEL
sudo dnf upgrade nmap                     # Fedora
```

##### **macOS**
```bash
brew upgrade nmap
```

##### **Windows**
重新下载最新版本的安装程序并覆盖安装即可。

---

#### **7. 常见问题**
##### **Q1: 安装时提示权限不足怎么办？**
确保使用 `sudo` 或以管理员身份运行命令。

##### **Q2: 安装后无法找到 nmap 命令？**
检查是否将 Nmap 的安装路径添加到环境变量中。如果是 Windows，可以在安装时选择“Add to PATH”选项。

##### **Q3: 如何卸载 Nmap？**
- **Linux**:
  ```bash
  sudo apt remove nmap   # Debian/Ubuntu
  sudo yum remove nmap   # CentOS/RHEL
  ```
- **macOS**:
  ```bash
  brew uninstall nmap
  ```
- **Windows**:
  通过“控制面板 -> 程序和功能”找到 Nmap 并卸载。

### 基本命令格式
```bash
nmap [扫描类型] [选项] 目标
```

### 常见用法

#### 1. 简单扫描
扫描目标主机的常见端口：
```bash
nmap target
```
- `target` 可以是 IP 地址、域名或 IP 范围。

#### 2. 扫描特定端口
扫描指定的端口：
```bash
nmap -p 80,443 target
```
- `-p` 后跟要扫描的端口号，可以是单个端口、逗号分隔的列表或范围（如 1-1000）。

#### 3. 检测操作系统
尝试检测目标操作系统的类型：
```bash
nmap -O target
```
- `-O` 表示启用操作系统检测。

#### 4. 全面扫描
执行一次全面的扫描，包括端口扫描、操作系统检测、版本检测、脚本扫描等：
```bash
nmap -A target
```
- `-A` 选项用于启用操作系统检测、版本检测、脚本扫描和 traceroute。

#### 5. 发现在线主机
仅用于发现哪些主机在线（即存活主机）：
```bash
nmap -sn target
```
- `-sn` （以前为 `-sP`）表示 Ping 扫描，不进行端口扫描。

#### 6. 扫描网段
对一个 C 类 IP 地址段进行扫描：
```bash
nmap 192.168.1.0/24
```
- 使用 CIDR 标记来指定 IP 地址范围。

#### 7. 使用脚本引擎（NSE）
Nmap Scripting Engine (NSE) 是 Nmap 强大的一部分，它允许用户编写或使用现有的脚本来执行更复杂的任务。例如：
- **漏洞检测**：
  ```bash
  nmap --script vuln target
  ```
  这个命令会运行所有标记为“vuln”的脚本进行常见漏洞扫描。
  
- **暴力破解服务密码**：
  ```bash
  nmap --script brute target
  ```
  使用此命令可以对某些服务尝试进行密码暴力破解（注意合法性）。

#### 8. 版本检测
确定开放端口上运行的服务版本信息：
```bash
nmap -sV target
```
这有助于识别正在运行的服务及其版本，对于安全审计特别有用。

#### 9. 指定源端口
有时可能需要从特定的源端口发送数据包：
```bash
nmap --source-port 53 target
```
上述命令指定了源端口为53，可用于测试防火墙规则是否正确配置。

#### 10. 确认主机在线状态
除了 `-sn`（Ping 扫描），还可以通过其他方式确认主机是否在线：
```bash
nmap -PS target
```
这里 `-PS` 表示使用 TCP SYN ping 来探测目标。

#### 11. 路由跟踪
为了了解数据包到达目标经过了哪些路由器，可以使用路由跟踪功能：
```bash
nmap --traceroute target
```

#### 12. 时间模板
Nmap 提供了6种预设的时间模板，用以控制扫描速度，分别是 T0 至 T5：
```bash
nmap -T4 target
```
`-T4` 表示更快的扫描速度，但可能会增加网络负担；相反，`-T0` 则是最慢且最隐蔽的方式。

### 输出格式
Nmap 支持多种输出格式，便于后续分析：
- **普通文本输出**：
  ```bash
  nmap -oN output.txt target
  ```
- **XML 格式输出**，适合与其他工具集成：
  ```bash
  nmap -oX output.xml target
  ```
- **Grepable 输出**，方便使用 grep 工具处理：
  ```bash
  nmap -oG output.gnmap target
  ```

### 实际案例应用

假设你希望对内部网络进行一次全面的安全评估，包括发现存活主机、开放端口、运行服务及版本、操作系统类型等信息，并保存结果以便后续分析，你可以使用如下命令：
```bash
nmap -A -oA full_scan_results 192.168.1.0/24
```
该命令将对指定网段进行全面扫描，结果将以三种格式（正常文本、XML 和 Grepable）保存到文件中。

### 高级选项

- **速率控制**：通过 `--min-rate <number>` 和 `--max-rate <number>` 控制发送探测包的速率。
- **隐蔽扫描**：使用 `-sS`（SYN 扫描）、`-sF`（FIN 扫描）等选项实现更隐蔽的扫描方式。
- **输出结果**：使用 `-oN filename` 输出普通文本文件，`-oX filename` 输出 XML 文件，或者 `-oG filename` 输出 Grepable 文件。

### 示例
以下是一些实际应用中的例子：

- 执行一次完整的扫描并输出到文件：
  ```bash
  nmap -A -oN scan_results.txt 192.168.1.1
  ```

- 对某个网段进行快速在线主机发现：
  ```bash
  nmap -sn 192.168.1.0/24
  ```

`nmap` 是一个非常强大且灵活的工具。对于更多高级功能和选项，建议查看官方文档或使用 `man nmap` 获取帮助。

nmap的基本使用

`cpolar` 是一款强大的内网穿透工具，它能够帮助用户轻松地将本地运行的服务通过安全隧道暴露到公网，使得外部网络可以访问这些通常只能在局域网内部访问的服务。这对于开发人员来说特别有用，尤其是在需要进行开发调试、展示本地项目或测试回调接口等场景时。



- [cpolar官网](https://www.cpolar.com/)

### 主要特点

- **简单易用**：无论是初学者还是有经验的开发者，都可以快速上手使用。
- **安全连接**：所有数据传输都通过TLS加密，确保你的数据在网络上传输的安全性。
- **动态域名**：即使本地服务重启后IP地址发生变化，也能保持一个固定的公网URL，非常适合用于开发中的频繁重启和调试。
- **多种协议支持**：不仅支持HTTP/HTTPS，还支持TCP等多种协议，满足不同的应用需求。
- **自定义域名**：允许绑定自己的域名，为专业用途提供便利。
- **全球节点选择**：可以选择全球多个地区的服务器节点，以获得最佳的访问速度和稳定性。

### 使用步骤详解

#### 1. 注册并安装 `cpolar`

首先，你需要访问 [cpolar官网](https://www.cpolar.com/) 注册账号，并根据你的操作系统下载相应的客户端版本。`cpolar` 支持Windows、macOS以及Linux等多个平台。

#### 2. 登录 `cpolar`

安装完成后，在终端或命令提示符中输入以下命令来登录：

```bash
cpolar authtoken <你的认证令牌>
```

这里的 `<你的认证令牌>` 可以从你的cpolar账户中找到。

#### 3. 创建隧道

创建隧道的方式有两种：通过命令行直接创建或者编辑配置文件。

- **命令行方式**：例如，如果你想将本地8080端口映射出去，可以使用如下命令：
  
  ```bash
  cpolar http 8080
  ```
  
  这条命令将会把本地8080端口的服务通过http协议暴露给公网。

- **通过配置文件创建**：你也可以编辑配置文件（一般位于用户目录下的`.cpolar`文件夹内）来添加更多复杂的配置。比如设置自定义子域名、指定地区等高级选项。
- 通过下面的命令来查看cpolar的文档

```
./cpolar help
```

:::warning{title="注意"}
暴露的端口会每天刷新，需要登陆cpolar官网查看新端口
:::
#### 4. 查看公网地址

一旦隧道建立成功，`cpolar`会显示一个公网URL。这个URL就是外界访问你本地服务的入口。你可以把这个URL分享给其他人，让他们可以直接访问你的本地服务。

#### 5. 管理隧道

`cporal` 提供了一个简单的Web界面（默认是`http://localhost:9200`），通过这个界面你可以方便地查看当前所有的隧道状态、管理现有的隧道、以及创建新的隧道。

#### 6. 高级配置

对于更复杂的需求，如需要设置多个隧道、定制化配置等，可以通过修改配置文件来实现。此外，还可以利用cpolar提供的API来进行自动化管理。

#### 7. web页面管理`cpolar`

访问本地地址并登录管理隧道

```
http://127.0.0.1:9200
```

#### 8. 登录官网查看`cpolar`信息

访问官网地址登录查看`cpolar`信息

### 安全注意事项

尽管`cpolar`提供了便捷的内网穿透功能，但在使用时也需要注意安全性问题，确保不会因为不当的配置导致内部网络暴露给不必要的风险。建议定期检查你的隧道配置，关闭不再使用的隧道，并且不要将敏感信息直接暴露于公网之上。

cpolar内网穿透

`aligo` 是一个用于 Python 的第三方库，主要用于与阿里云网盘（阿里云盘）进行交互。它是由社区开发者维护的一个非官方 SDK，提供了方便的接口来操作阿里云盘中的文件和资源。



- GitHub 地址：[https://github.com/foyoux/aligo](https://github.com/foyoux/aligo)

### **1. 安装 aligo**
你可以通过 `pip` 来安装 `aligo` 包：

```bash
pip install aligo
```

### **2. 主要功能**
`aligo` 提供了以下主要功能：
- 文件上传、下载。
- 文件夹创建、删除。
- 文件/文件夹的移动、复制。
- 获取文件列表。
- 搜索文件。
- 分享文件或文件夹。
- 获取分享链接。

---

### **3. 使用示例**

#### **(1) 初始化客户端**
在使用 `aligo` 之前，需要先登录阿里云盘。`aligo` 支持通过二维码扫码登录。

```python
from aligo import Aligo

# 初始化 Aligo 对象
ali = Aligo()
```

执行上述代码后，会弹出一个二维码，你需要用阿里云盘 App 扫码登录。登录成功后，`aligo` 会自动保存登录状态，下次使用时无需再次扫码。


#### **(2) 上传文件**
将本地文件上传到阿里云盘：

```python
file_path = '/path/to/local/file.txt'  # 本地文件路径
parent_folder_id = 'root'  # 目标文件夹 ID，'root' 表示根目录

uploaded_file = ali.upload_file(file_path, parent_folder_id)
print(f"Uploaded file: {uploaded_file.name}")
```

#### **(3) 下载文件**
从阿里云盘下载文件到本地：

```python
file_id = 'your-file-id'  # 文件的 ID
local_path = '/path/to/save/file.txt'  # 本地保存路径

downloaded_file = ali.download_file(file_id, local_path)
print(f"Downloaded file to: {downloaded_file}")
```

#### **(4) 列出文件**
列出某个文件夹下的所有文件：

```python
parent_folder_id = 'root'  # 文件夹 ID，'root' 表示根目录

files = ali.get_file_list(parent_folder_id)
for file in files:
    print(f"File name: {file.name}, File ID: {file.file_id}")
```

#### **(5) 创建文件夹**
在阿里云盘中创建一个新的文件夹：

```python
parent_folder_id = 'root'  # 父文件夹 ID，'root' 表示根目录
new_folder_name = 'My New Folder'

new_folder = ali.create_folder(new_folder_name, parent_folder_id)
print(f"Created folder: {new_folder.name}")
```

#### **(6) 删除文件夹**
在阿里云盘中删除一个新的文件夹：

```python
from aligo import Aligo

# 初始化 Aligo 客户端
ali = Aligo()

# 获取文件夹的 file_id
def get_folder_id_by_name(parent_file_id, folder_name):
    # 列出父目录下的文件和文件夹
    file_list = ali.get_file_list(parent_file_id)
    for file in file_list:
        if file.name == folder_name and file.type == 'folder':
            return file.file_id
    return None

# 删除文件夹
def delete_folder(parent_file_id, folder_name):
    # 获取文件夹的 file_id
    folder_id = get_folder_id_by_name(parent_file_id, folder_name)
    if folder_id:
        # 删除文件夹
        response = ali.delete_file(file_id=folder_id)
        if response:
            print(f"文件夹 '{folder_name}' 已成功删除！")
        else:
            print(f"文件夹 '{folder_name}' 删除失败！")
    else:
        print(f"未找到文件夹 '{folder_name}'！")

# 示例：删除名为 "test_folder" 的文件夹
parent_file_id = 'root'  # 根目录的 file_id，默认为 'root'
folder_name = 'test_folder'

delete_folder(parent_file_id, folder_name)
```

#### **(7) 分享文件**
生成文件的分享链接：

```python
file_id = 'your-file-id'  # 文件的 ID
share_link = ali.share_file(file_id)
print(f"Share link: {share_link}")
```


### **4. 注意事项**
1. **非官方 SDK**：`aligo` 是由社区开发者维护的非官方工具，因此可能存在一定的风险或兼容性问题。使用时请确保了解其工作原理，并注意账户安全。
   
2. **API 限制**：阿里云盘的 API 可能有一定的速率限制或其他约束，频繁调用可能会导致请求失败。

3. **登录状态**：登录状态会被缓存，通常存储在用户目录下的 `.aligo` 文件夹中。如果需要重新登录，可以删除该缓存文件。

4. **依赖项**：`aligo` 依赖于一些第三方库，比如 `requests` 和 `qrcode`，安装时会自动处理这些依赖。