枫の屋

CentOS 7 内核升级脚本 (kernel-lt-5.4)

Tue, 24 Feb 2026 00:00:00 GMT

脚本内容，均无加密可放心使用，如果不想看可以拉到最后看使用脚本

#!/bin/bash
# =====================================================
# CentOS 7 内核一键安装脚本 - 源修复版
# 版本: 3.0
# 描述: 修复CentOS 7源问题，直接从网络下载并安装kernel-lt-5.4.278
# =====================================================

# 设置严格模式（兼容老旧系统）
set -eo pipefail
set +u  # 避免未定义变量报错

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
WHITE='\033[1;37m'
NC='\033[0m'

# 配置常量
readonly KERNEL_VERSION="5.4.278-1.el7.elrepo.x86_64"
readonly KERNEL_PACKAGE="kernel-lt-${KERNEL_VERSION}.rpm"
readonly DOWNLOAD_URL="http://linux.6wd.cn/${KERNEL_PACKAGE}"
readonly LOG_FILE="/var/log/kernel-install-$(date +%Y%m%d-%H%M%S).log"
readonly BACKUP_DIR="/root/kernel-backup-$(date +%Y%m%d-%H%M%S)"

# 错误退出函数
error_exit() {
    echo -e "\n${RED}╔════════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${RED}║                         ❌ 安装失败 ❌                          ║${NC}"
    echo -e "${RED}╠════════════════════════════════════════════════════════════════╣${NC}"
    echo -e "${RED}║${WHITE} 错误: $1${NC}"
    echo -e "${RED}║${WHITE} 日志: $LOG_FILE${NC}"
    echo -e "${RED}╚════════════════════════════════════════════════════════════════╝${NC}"
    exit 1
}

# 清理函数
cleanup() {
    if [[ -f "$KERNEL_PACKAGE" ]]; then
        rm -f "$KERNEL_PACKAGE" 2>/dev/null
        echo -e "${BLUE}[清理] 已删除临时文件: $KERNEL_PACKAGE${NC}" | tee -a "$LOG_FILE"
    fi
}

# 设置陷阱
trap cleanup EXIT
trap 'echo -e "\n${RED}[中断] 脚本被用户终止${NC}" | tee -a "$LOG_FILE"; exit 130' INT TERM

# 打印横幅
print_banner() {
    clear 2>/dev/null || true
    echo -e "${PURPLE}╔════════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${PURPLE}║${WHITE}${BOLD}          CentOS 7 内核一键安装脚本 (源修复版)            ${PURPLE}║${NC}"
    echo -e "${PURPLE}╠════════════════════════════════════════════════════════════════╣${NC}"
    printf "${PURPLE}║${WHITE} 目标内核: ${GREEN}%-45s${PURPLE}║${NC}\n" "$KERNEL_VERSION"
    printf "${PURPLE}║${WHITE} 日志文件: ${BLUE}%-45s${PURPLE}║${NC}\n" "$LOG_FILE"
    echo -e "${PURPLE}╚════════════════════════════════════════════════════════════════╝${NC}"
    echo ""
}

# 修复CentOS 7源
fix_centos_repo() {
    echo -e "${BLUE}[1/7] 修复CentOS 7 yum源...${NC}" | tee -a "$LOG_FILE"
    
    # 备份原有源
    if [[ -d /etc/yum.repos.d ]]; then
        mkdir -p /etc/yum.repos.d/backup
        mv /etc/yum.repos.d/*.repo /etc/yum.repos.d/backup/ 2>/dev/null || true
    fi
    
    # 使用阿里云镜像源（CentOS 7 vault）
    cat > /etc/yum.repos.d/CentOS7-Aliyun.repo << 'EOF'
[base]
name=CentOS-7 - Base - Aliyun
baseurl=http://mirrors.aliyun.com/centos-vault/7.9.2009/os/\$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-7
enabled=1

[updates]
name=CentOS-7 - Updates - Aliyun
baseurl=http://mirrors.aliyun.com/centos-vault/7.9.2009/updates/\$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-7
enabled=1

[extras]
name=CentOS-7 - Extras - Aliyun
baseurl=http://mirrors.aliyun.com/centos-vault/7.9.2009/extras/\$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos-vault/RPM-GPG-KEY-CentOS-7
enabled=1

[epel]
name=Extra Packages for Enterprise Linux 7 - \$basearch
baseurl=http://mirrors.aliyun.com/epel/7/\$basearch
gpgcheck=0
enabled=1
EOF

    # 添加elrepo源（用于内核）
    rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org 2>/dev/null || true
    cat > /etc/yum.repos.d/elrepo.repo << 'EOF'
[elrepo]
name=ELRepo.org Community Enterprise Linux Repository - el7
baseurl=http://mirrors.aliyun.com/elrepo/elrepo/el7/\$basearch/
        http://elrepo.org/linux/elrepo/el7/\$basearch/
enabled=1
gpgcheck=1
gpgkey=https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
protect=0

[elrepo-kernel]
name=ELRepo.org Community Enterprise Linux Kernel Repository - el7
baseurl=http://mirrors.aliyun.com/elrepo/kernel/el7/\$basearch/
        http://elrepo.org/linux/kernel/el7/\$basearch/
enabled=1
gpgcheck=1
gpgkey=https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
protect=0
EOF

    # 清理缓存
    yum clean all >> "$LOG_FILE" 2>&1
    yum makecache >> "$LOG_FILE" 2>&1
    
    echo -e "${GREEN}✓ yum源修复完成${NC}" | tee -a "$LOG_FILE"
}

# 检查root权限
check_root() {
    echo -e "${BLUE}[2/7] 检查权限...${NC}" | tee -a "$LOG_FILE"
    if [[ $EUID -ne 0 ]]; then
        error_exit "此脚本必须以root权限运行"
    fi
    echo -e "${GREEN}✓ root权限验证通过${NC}" | tee -a "$LOG_FILE"
}

# 检查系统
check_system() {
    echo -e "${BLUE}[3/7] 检查系统版本...${NC}" | tee -a "$LOG_FILE"
    
    if [[ ! -f /etc/centos-release ]]; then
        error_exit "此脚本仅支持CentOS系统"
    fi
    
    local centos_version=$(cat /etc/centos-release | grep -oP '[0-9]+' | head -1)
    if [[ "$centos_version" != "7" ]]; then
        error_exit "此脚本仅支持CentOS 7，当前版本: $(cat /etc/centos-release)"
    fi
    
    local arch=$(uname -m)
    if [[ "$arch" != "x86_64" ]]; then
        error_exit "此脚本仅支持x86_64架构，当前架构: $arch"
    fi
    
    echo -e "${GREEN}✓ 系统版本: $(cat /etc/centos-release) ($arch)${NC}" | tee -a "$LOG_FILE"
}

# 检查磁盘空间
check_disk_space() {
    echo -e "${BLUE}[4/7] 检查磁盘空间...${NC}" | tee -a "$LOG_FILE"
    
    BOOT_FREE=$(df -m /boot | awk 'NR==2 {print $4}')
    if [[ "$BOOT_FREE" -lt 200 ]]; then
        error_exit "/boot分区空间不足（可用: ${BOOT_FREE}MB），需要至少200MB"
    fi
    echo -e "${GREEN}✓ /boot分区可用: ${BOOT_FREE}MB${NC}" | tee -a "$LOG_FILE"
}

# 下载内核文件
download_kernel() {
    echo -e "${BLUE}[5/7] 开始下载内核文件...${NC}" | tee -a "$LOG_FILE"
    echo "下载地址: $DOWNLOAD_URL" | tee -a "$LOG_FILE"
    
    # 选择下载工具
    if command -v wget &>/dev/null; then
        echo "使用 wget 下载..." | tee -a "$LOG_FILE"
        wget -O "$KERNEL_PACKAGE" "$DOWNLOAD_URL" --progress=bar:force 2>&1 | tee -a "$LOG_FILE"
    elif command -v curl &>/dev/null; then
        echo "使用 curl 下载..." | tee -a "$LOG_FILE"
        curl -L -o "$KERNEL_PACKAGE" "$DOWNLOAD_URL" --progress-bar 2>&1 | tee -a "$LOG_FILE"
    else
        error_exit "未找到 wget 或 curl，无法下载"
    fi
    
    # 验证下载
    if [[ ! -f "$KERNEL_PACKAGE" ]]; then
        error_exit "下载失败：文件未找到"
    fi
    
    # 兼容Linux/BSD的stat命令
    FILE_SIZE=$(stat -c%s "$KERNEL_PACKAGE" 2>/dev/null)
    if [[ -z "$FILE_SIZE" ]]; then
        FILE_SIZE=$(stat -f%z "$KERNEL_PACKAGE" 2>/dev/null)
    fi
    
    if [[ -z "$FILE_SIZE" || "$FILE_SIZE" -lt 10000000 ]]; then
        error_exit "下载文件不完整（大小: ${FILE_SIZE:-0} 字节）"
    fi
    echo -e "${GREEN}✓ 下载成功，文件大小: $((FILE_SIZE/1024/1024))MB${NC}" | tee -a "$LOG_FILE"
}

# 安装依赖
install_dependencies() {
    echo -e "${BLUE}[6/7] 安装依赖包...${NC}" | tee -a "$LOG_FILE"
    
    # 先安装epel-release
    yum install -y epel-release >> "$LOG_FILE" 2>&1 || true
    
    # 安装必要的工具
    local packages=(
        "grub2-tools"
        "coreutils"
        "numfmt"
        "file"
        "which"
    )
    
    local failed=0
    for pkg in "${packages[@]}"; do
        echo -n "  安装 $pkg... " | tee -a "$LOG_FILE"
        if yum install -y "$pkg" >> "$LOG_FILE" 2>&1; then
            echo -e "${GREEN}成功${NC}" | tee -a "$LOG_FILE"
        else
            echo -e "${YELLOW}跳过${NC}" | tee -a "$LOG_FILE"
        fi
    done
    
    echo -e "${GREEN}✓ 依赖安装完成${NC}" | tee -a "$LOG_FILE"
}

# 安装内核
install_kernel() {
    echo -e "${BLUE}[7/7] 安装内核...${NC}" | tee -a "$LOG_FILE"
    
    # 尝试yum安装
    echo "尝试使用yum安装..." | tee -a "$LOG_FILE"
    if yum localinstall -y "$KERNEL_PACKAGE" >> "$LOG_FILE" 2>&1; then
        echo -e "${GREEN}✓ yum安装成功${NC}" | tee -a "$LOG_FILE"
    else
        echo -e "${YELLOW}⚠ yum安装失败，尝试rpm强制安装...${NC}" | tee -a "$LOG_FILE"
        
        # 安装内核依赖
        yum install -y elfutils-libelf-devel >> "$LOG_FILE" 2>&1 || true
        
        # rpm强制安装
        rpm -ivh --replacepkgs "$KERNEL_PACKAGE" --nodeps >> "$LOG_FILE" 2>&1 || {
            error_exit "内核安装失败，请检查日志: $LOG_FILE"
        }
        echo -e "${GREEN}✓ rpm安装成功${NC}" | tee -a "$LOG_FILE"
    fi
    
    # 验证安装
    if rpm -q "kernel-lt-${KERNEL_VERSION}" &>/dev/null; then
        echo -e "${GREEN}✓ 内核安装验证通过${NC}" | tee -a "$LOG_FILE"
    else
        error_exit "内核安装验证失败：rpm数据库中未找到"
    fi
}

# 配置GRUB
configure_grub() {
    echo -e "${BLUE}[8/8] 配置GRUB引导...${NC}" | tee -a "$LOG_FILE"
    
    GRUB_CFG="/boot/grub2/grub.cfg"
    if [[ ! -f "$GRUB_CFG" ]]; then
        error_exit "GRUB配置文件不存在: $GRUB_CFG"
    fi
    
    # 获取GRUB菜单项
    GRUB_ENTRIES=$(awk -F\' '$1=="menuentry " {print i++ " : " $2}' "$GRUB_CFG" 2>/dev/null)
    if [[ -z "$GRUB_ENTRIES" ]]; then
        error_exit "无法读取GRUB菜单项"
    fi
    
    # 查找新内核索引
    NEW_INDEX=$(echo "$GRUB_ENTRIES" | grep -n "$KERNEL_VERSION" | head -1 | cut -d: -f1)
    if [[ -z "$NEW_INDEX" ]]; then
        KERNEL_MAIN_VER="${KERNEL_VERSION%%-*}"
        NEW_INDEX=$(echo "$GRUB_ENTRIES" | grep -n "$KERNEL_MAIN_VER" | head -1 | cut -d: -f1)
        echo -e "${YELLOW}⚠ 使用模糊匹配找到内核索引${NC}" | tee -a "$LOG_FILE"
    fi
    
    # 转换为0-based索引
    if [[ -n "$NEW_INDEX" ]]; then
        NEW_INDEX=$((NEW_INDEX - 1))
        echo -e "${GREEN}✓ 找到新内核GRUB索引: $NEW_INDEX${NC}" | tee -a "$LOG_FILE"
    else
        NEW_INDEX=0
        echo -e "${YELLOW}⚠ 未找到新内核索引，使用默认索引0${NC}" | tee -a "$LOG_FILE"
    fi
    
    # 设置默认启动项
    if grub2-set-default "$NEW_INDEX" >> "$LOG_FILE" 2>&1; then
        echo -e "${GREEN}✓ 默认启动项设置成功${NC}" | tee -a "$LOG_FILE"
    else
        echo -e "${YELLOW}⚠ grub2-set-default失败，尝试手动设置...${NC}" | tee -a "$LOG_FILE"
        GRUBENV="/boot/grub2/grubenv"
        if [[ -f "$GRUBENV" ]]; then
            cp -a "$GRUBENV" "${GRUBENV}.backup"
            if grep -q '^saved_entry=' "$GRUBENV"; then
                sed -i "s/^saved_entry=.*/saved_entry=$NEW_INDEX/" "$GRUBENV"
            else
                echo "saved_entry=$NEW_INDEX" >> "$GRUBENV"
            fi
            echo -e "${GREEN}✓ 手动设置成功${NC}" | tee -a "$LOG_FILE"
        fi
    fi
    
    # 重新生成GRUB配置
    grub2-mkconfig -o "$GRUB_CFG" >> "$LOG_FILE" 2>&1
    echo -e "${GREEN}✓ GRUB配置已更新${NC}" | tee -a "$LOG_FILE"
}

# 显示完成信息
show_completion() {
    echo -e "\n${GREEN}╔════════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${GREEN}║${WHITE}${BOLD}                      ✅ 安装成功！                          ${GREEN}║${NC}"
    echo -e "${GREEN}╠════════════════════════════════════════════════════════════════╣${NC}"
    echo -e "${GREEN}║${WHITE}  当前内核: ${NC}$(uname -r)" | tee -a "$LOG_FILE"
    echo -e "${GREEN}║${WHITE}  新内核:   ${GREEN}$KERNEL_VERSION${NC}" | tee -a "$LOG_FILE"
    echo -e "${GREEN}║${WHITE}  日志文件: ${BLUE}$LOG_FILE${NC}" | tee -a "$LOG_FILE"
    echo -e "${GREEN}╚════════════════════════════════════════════════════════════════╝${NC}"
    echo ""
    
    # 询问重启
    echo -ne "${YELLOW}是否立即重启系统？${NC} (y/n): "
    read -r reboot_choice
    if [[ "$reboot_choice" =~ ^[Yy]$ ]]; then
        echo -e "${BLUE}系统将在5秒后重启...${NC}"
        echo -e "${RED}按 Ctrl+C 取消重启${NC}"
        sleep 5
        sync && reboot
    else
        echo -e "${BLUE}请手动执行 'reboot' 重启系统${NC}"
        echo -e "${BLUE}重启后执行 'uname -r' 验证内核版本${NC}"
    fi
}

# ========== 主函数 ==========
main() {
    print_banner
    
    # 执行步骤
    check_root
    check_system
    check_disk_space
    fix_centos_repo      # 新增：修复yum源
    download_kernel
    install_dependencies
    install_kernel
    configure_grub
    
    # 完成
    show_completion
}

# ========== 执行主函数 ==========
main "$@"

✨ 主要修复内容

1. 修复yum源问题 (新增 `fix_centos_repo` 函数)

使用阿里云镜像源替换失效的腾讯云源
添加elrepo源用于内核支持
自动备份原有源配置

2. 增强依赖安装 (改进 `install_dependencies` 函数)

即使部分依赖安装失败也能继续
添加必要工具如 numfmt、file 等
更详细的安装状态显示

3. 改进错误处理

更友好的错误提示界面
详细的步骤显示
添加8个步骤的完整流程

4. 添加美化功能

使用Unicode边框
彩色进度显示
清晰的步骤分隔

📥 使用方法

# 直接运行（会自动修复源问题）
bash <(curl -s http://linux.6wd.cn/up.sh)

# 或者下载后运行
curl -o up.sh http://linux.6wd.cn/up.sh
chmod +x up.sh
./up.sh

这个版本会自动修复yum源问题，使用阿里云镜像，确保依赖包能正常下载！

Alist S3 上传指定目录脚本文档

Tue, 29 Jul 2025 00:00:00 GMT

自动生成子文件夹并上传至 Alist S3 脚本配置文档

<hr>

此文档将指导你如何使用修改后的 Python 脚本，其中包括以下功能：

手动设置主文件夹名称。
在主文件夹下自动生成一个 backup+时间 的子文件夹。
上传本地文件至 Alist S3 存储，并保存在 主文件夹/backup+时间 目录中。

本教程使用Alist中的S3协议进行搭建对接的123云盘

1，先进入Alist的官网安装并运行，由于网络上此教程太多，我这边不过多教学，官网的一键安装也十分方便（Alist官网地址：alist.nn.ci）

2，进入Alist后台->存储->添加来添加存储，我们以123pan为例

3，成功添加

4，进入123盘，在根目录新建`desktop`以及`mobile`文件夹用于存储手机和电脑访问时候呈现出不同尺寸的图片，并且检查是否正常创建

5，进入Alist后台创建S3协议的密钥以及id

在设置->对象存储中点击S3 generate来创建Key，在下方添加桶以及位置

配置完成后去Alist的配置文件位置修改配置文件让他启用S3服务

脚本的配置

完整代码

import os
import boto3
import schedule
import time
from datetime import datetime
from botocore.exceptions import NoCredentialsError, PartialCredentialsError

# ===================== 配置部分 =====================
DIRECTORY_TO_UPLOAD = '/path/to/your/local_directory'  # 本地需要上传的目录
S3_BUCKET_NAME = 'your-s3-bucket-name'  # S3 桶名称
ALIST_S3_ENDPOINT = 'http://YOUR_IP:YOUR_PORT'  # Alist S3 的 IP + 端口
AWS_ACCESS_KEY_ID = 'YOUR_AWS_ACCESS_KEY_ID'  # Alist S3 的访问密钥
AWS_SECRET_ACCESS_KEY = 'YOUR_AWS_SECRET_ACCESS_KEY'  # Alist S3 的密钥
UPLOAD_INTERVAL_MINUTES = 60  # 每隔 60 分钟上传一次
UPLOAD_NOW = True  # 设置为 True 表示立即上传, False 表示不立即上传
SCHEDULED_UPLOAD = True  # 设置为 True 表示定期上传，False 表示仅执行一次上传
CUSTOM_FOLDER_NAME = 'your-custom-folder'  # 手动设置的主文件夹名称
# ===================== 配置部分结束 =====================

# 初始化 S3 客户端，使用 Alist 的 IP + 端口作为 endpoint_url
s3 = boto3.client(
    's3',
    aws_access_key_id=AWS_ACCESS_KEY_ID,  # 替换为 Alist 的访问密钥
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,  # 替换为 Alist 的密钥
    endpoint_url=ALIST_S3_ENDPOINT,  # Alist S3 的 IP + 端口
    region_name='us-east-1'  # 区域随意设置一个
)

# 生成 backup+时间 文件夹名称的函数
def generate_backup_folder_name():
    # 使用当前日期时间生成文件夹名称，例如 'backup-2024-10-04-14-30'
    return f"backup-{datetime.now().strftime('%Y-%m-%d-%H-%M')}"

# 上传目录到 S3 的函数，带有自动生成的 backup+时间子文件夹名称
def upload_directory_to_s3(directory_path, bucket_name, custom_folder_name):
    try:
        # 生成 backup+时间 的子文件夹名称
        backup_folder_name = generate_backup_folder_name()
        # 在自定义的主文件夹下生成 backup+时间 的子文件夹
        full_folder_path = os.path.join(custom_folder_name, backup_folder_name)

        # 遍历指定目录中的所有文件和子目录
        for root, dirs, files in os.walk(directory_path):
            for file_name in files:
                full_file_path = os.path.join(root, file_name)  # 文件的完整路径
                # 定义 S3 中的文件路径，包含主文件夹和 backup+时间 文件夹
                s3_file_path = os.path.join(full_folder_path, os.path.relpath(full_file_path, directory_path))
                try:
                    # 上传文件到 S3
                    s3.upload_file(full_file_path, bucket_name, s3_file_path)
                    print(f"Uploaded: {full_file_path} to {bucket_name}/{s3_file_path}")
                except FileNotFoundError:
                    print(f"文件未找到: {full_file_path}")
                except NoCredentialsError:
                    print("无法找到 S3 凭证。")
                except PartialCredentialsError:
                    print("提供的 S3 凭证不完整。")
    except Exception as e:
        print(f"错误: {e}")

# 调度上传任务的函数
def schedule_upload(directory_path, bucket_name, custom_folder_name, interval_minutes):
    # 定义调度任务的函数
    def job():
        print(f"正在上传 {directory_path} 到 S3 桶 {bucket_name}...")
        upload_directory_to_s3(directory_path, bucket_name, custom_folder_name)

    # 安排任务按照指定的时间间隔运行
    schedule.every(interval_minutes).minutes.do(job)

    print(f"已安排每 {interval_minutes} 分钟上传一次。")

    # 持续运行调度程序
    while True:
        schedule.run_pending()  # 运行待处理的任务
        time.sleep(1)  # 等待 1 秒后检查下一个任务

# 主函数入口
if __name__ == "__main__":
    # 如果上传标志为 True，则立即上传一次
    if UPLOAD_NOW:
        print(f"立即上传 {DIRECTORY_TO_UPLOAD} 到 S3 桶 {S3_BUCKET_NAME}...")
        upload_directory_to_s3(DIRECTORY_TO_UPLOAD, S3_BUCKET_NAME, CUSTOM_FOLDER_NAME)
    
    # 根据 SCHEDULED_UPLOAD 判断是否定期上传
    if SCHEDULED_UPLOAD:
        # 启动上传任务的调度
        schedule_upload(DIRECTORY_TO_UPLOAD, S3_BUCKET_NAME, CUSTOM_FOLDER_NAME, UPLOAD_INTERVAL_MINUTES)
    else:
        print("已设置为仅执行一次上传任务。")

1. 本地需要上传的目录

变量: DIRECTORY_TO_UPLOAD
描述: 指定本地需要上传的目录路径。此目录中的文件会被上传到 S3 中。
示例:
```
DIRECTORY_TO_UPLOAD = '/path/to/your/local_directory'
```
将 '/path/to/your/local_directory' 替换为你实际想要上传的本地目录路径。例如：
```
DIRECTORY_TO_UPLOAD = '/home/user/documents'
```

2. S3 桶名称

变量: S3_BUCKET_NAME
描述: 指定你在 Alist S3 服务中的存储桶（bucket）名称，所有文件将被上传至该桶中。

示例:

S3_BUCKET_NAME = 'your-s3-bucket-name'

将 'your-s3-bucket-name' 替换为你实际的 S3 桶名称，例如：

S3_BUCKET_NAME = 'my-backup-bucket'

3. Alist S3 服务的 IP 和端口

变量: ALIST_S3_ENDPOINT
描述: 访问 Alist S3 服务的 IP 地址和端口。格式为 http://IP:PORT。
示例:
```
ALIST_S3_ENDPOINT = 'http://YOUR_IP:YOUR_PORT'
```
将 'http://YOUR_IP:YOUR_PORT' 替换为你的 Alist S3 服务的 IP 地址和端口。例如，如果服务在 192.168.1.100 上运行，端口为 9000：
```
ALIST_S3_ENDPOINT = 'http://192.168.1.100:9000'
```

4. 访问密钥 (AWS Access Key ID)

变量: AWS_ACCESS_KEY_ID
描述: 用于 Alist S3 服务的访问密钥，用于身份验证。
示例:
```
AWS_ACCESS_KEY_ID = 'YOUR_AWS_ACCESS_KEY_ID'
```
将 'YOUR_AWS_ACCESS_KEY_ID' 替换为你的实际 Alist S3 访问密钥，例如：
```
AWS_ACCESS_KEY_ID = 'ABCD1234EXAMPLE'
```

5. 密钥 (AWS Secret Access Key)

变量: AWS_SECRET_ACCESS_KEY
描述: 用于 Alist S3 服务的密钥，与访问密钥一起用于身份验证。

示例:

AWS_SECRET_ACCESS_KEY = 'YOUR_AWS_SECRET_ACCESS_KEY'

将 'YOUR_AWS_SECRET_ACCESS_KEY' 替换为你的实际密钥，例如：

AWS_SECRET_ACCESS_KEY = 'abcd1234secretEXAMPLE'

6. 手动设置的主文件夹名称

变量: CUSTOM_FOLDER_NAME
描述: 这是你手动设置的主文件夹名称。所有文件将会上传到 S3 中此主文件夹下的 backup+时间 子文件夹中。
示例:
```
CUSTOM_FOLDER_NAME = 'your-custom-folder'
```
例如，将此设置为 my-backups，脚本会将所有文件上传到 my-backups/backup-时间 的路径中。

7. 上传时间间隔（分钟）

变量: UPLOAD_INTERVAL_MINUTES
描述: 控制脚本自动上传的时间间隔，单位为分钟。脚本会按照该时间间隔定期上传文件。
示例:
```
UPLOAD_INTERVAL_MINUTES = 60
```
在此示例中，脚本会每隔 60 分钟上传一次文件。可以根据你的需求修改为不同的间隔时间。

8. 立即上传开关

变量: UPLOAD_NOW
描述: 布尔值，控制脚本在启动时是否立即上传文件。如果设置为 True，脚本会在启动时立即上传；如果为 False，则只按照调度时间上传。
示例:
```
UPLOAD_NOW = True
```
设置为 True 时，脚本会立即执行上传任务。如果不希望立即上传，可以将其设置为 False。

9. 定期上传开关

变量: SCHEDULED_UPLOAD
描述: 控制是否启用定期上传。如果设置为 True，脚本会按设定的时间间隔定期执行上传。如果设置为 False，脚本只会运行一次。
示例:
```
SCHEDULED_UPLOAD = True
```
如果设置为 True，脚本会按 UPLOAD_INTERVAL_MINUTES 定期上传文件。设置为 False 时，脚本只会执行一次上传任务，然后退出。

10. 自动生成 `backup+时间` 子文件夹

变量: generate_backup_folder_name()
描述: 这个函数会自动生成一个以 backup+时间 格式命名的子文件夹，用于存储每次上传的文件。
生成格式: backup-YYYY-MM-DD-HH-MM，例如：
```
backup-2024-10-04-14-30
```
每次运行脚本，都会在手动设置的主文件夹下生成一个新的 backup+时间 子文件夹，并将本地文件上传到这个子文件夹中。

运行方式：

将脚本保存为 .py 文件（例如 upload_to_s3.py）。
使用 Python 运行脚本：
```
python3 upload_to_s3.py
```
立即上传：如果 UPLOAD_NOW = True，脚本会立即执行上传任务。
定期上传：如果 SCHEDULED_UPLOAD = True，脚本会按设定的时间间隔定期上传。

示例配置：

DIRECTORY_TO_UPLOAD = '/home/user/documents'  # 本地目录
S3_BUCKET_NAME = 'my-backup-bucket'  # S3 桶名称
ALIST_S3_ENDPOINT = 'http://192.168.1.100:9000'  # Alist S3 服务 IP 和端口
AWS_ACCESS_KEY_ID = 'ABCD1234EXAMPLE'  # 访问密钥
AWS_SECRET_ACCESS_KEY = 'abcd1234secretEXAMPLE'  # 密钥
UPLOAD_INTERVAL_MINUTES = 30  # 每 30 分钟上传一次
UPLOAD_NOW = True  # 立即上传
SCHEDULED_UPLOAD = True  # 定期上传
CUSTOM_FOLDER_NAME = 'my-backups'  # 主文件夹名称

文件上传结构示例：

假设 CUSTOM_FOLDER_NAME = 'my-backups'，上传后的文件路径将如下所示：

S3_BUCKET_NAME/my-backups/backup-2024-10-04-14-30/file1.txt
S3_BUCKET_NAME/my-backups/backup-2024-10-04-14-30/file2.txt

通过该脚本配置，你可以灵活设置手动文件夹名称，同时利用自动生成的 backup+时间 子文件夹来管理文件的上传，方便备份和归档管理。如果你有任何其他问题，欢迎继续咨询！

批处理bat脚本自动配置java的jdk环境变量

Sat, 01 Jun 2024 00:00:00 GMT

每当更换电脑或者是重装系统之后，都需要重新配置java系统路径。但是又不想每次都去查配置方法，所以写了个脚本自动配置。

脚本内容

:: chcp 65001 代码表示更改为Unicode(utf-8)
chcp 65001
@echo off
@echo 第一步 输入要设置的JAVA_HOME路径:(As example: D:\Program Files\Java\jdk1.8.0_181)
set /p input="请输入JAVA_HOME路径："
@echo 第二步 设置JAVA_HOME路径
setx JAVA_HOME "%input%" /M
@echo 第三步 设置PATH
setx path "%path%;%%JAVA_HOME%%\bin" /M
@echo 第四步 设置classpath
setx classpath .;%%JAVA_HOME%%\lib\dt.jar;%%JAVA_HOME%%\lib\tools.jar /M
@echo “执行完成”
pause

步骤及意义

关闭回显@echo off
第一步是接收手动输入java安装路径，例：D:\Program Files\Java\jdk1.8.0_181

第二步是将输入的值设置给全局属性，并命名为JAVA_HOME

其中：加/M是代表设置system变量，可使所有用户可用，不加/M则只当前用户可用。
第三步是设置PATH,因为是覆盖更新，所以在之前要加上现有的PATH变量即%path%;
第四步是设置classpath

使用方式

新建一个txt文本文件，然后将上述全部语句粘贴进去，保存后，将文件后缀修改为.bat即可。

右键，使用管理员权限运行。

echo 和@echo的区别

echo: 会在shell中显示echo这条命令和后面要输出的内容

@echo: 不会显示echo这条命令，只会显示后面要输出的内容

例如:

echo “hello” 输出为：echo “hello” hello

@echo “hello” 输出为：hello

在执行命令之前会把要执行的命令进行输出，称之为回显

如果要执行的命令以字符@开始，则不会回显

set和setx的区别

1、SET命令：这种语法只能在Cmd Shell环境中有效，关闭运行环境环境变量将不保存。

2、SETX命令：Window XP 以上的系统都自带了该命令（如果没有，下载一个Setx.exe)，这种方式为永久设定环境变量。

CentOS Linux 安装MySQL

Sat, 01 Jun 2024 00:00:00 GMT

安装

首先，尝试一下直接使用 yum 安装 MySQL

yum install mysql-community-server

如果成功，表示不需要配置MySQL rpm 源信息，直接就安装完成了

但是，如果出现以下错误：

Loading mirror speeds from cached hostfile
没有可用软件包 mysql-community-server。
错误：无须任何处理

表示我们没有添加安装包的源信息，需要安装 MySQL rpm 源信息

安装 MySQL rpm 源信息

打开 http://dev.mysql.com/downloads/repo/yum/

根据你的系统版本，选择对应的安装包，例如我的是CentOS 7.5，这个系统的Linux内核是 Linux 7，所以我选择了红框内的地址，大家依次类推。

拼接下载地址头：http://dev.mysql.com/get/，得到以下地址

 http://dev.mysql.com/get/mysql80-community-release-el7-7.noarch.rpm

使用 wget + 刚才拼接的地址，下载安装包源信息

wget  http://dev.mysql.com/get/mysql80-community-release-el7-7.noarch.rpm

rpm 安装源信息

rpm -ivh mysql80-community-release-el7-7.noarch.rpm

安装

再尝试使用 yum 安装MySQL

yum install mysql-community-server

安装过程中，会提示让我们确认，一律输入 y 按回车即可

安装完成后，yum会自动覆盖自带的mariaDB，所以不需要我们手动卸载它

检查安装是否成功

检查一下刚才的安装是否成功

rpm -qa | grep mysql

输出：

mysql-community-libs-compat-8.0.33-1.el7.x86_64
mysql-community-icu-data-files-8.0.33-1.el7.x86_64
mysql80-community-release-el7-7.noarch
mysql-community-common-8.0.33-1.el7.x86_64
mysql-community-libs-8.0.33-1.el7.x86_64
mysql-community-server-8.0.33-1.el7.x86_64
mysql-community-client-8.0.33-1.el7.x86_64
mysql-community-client-plugins-8.0.33-1.el7.x86_64

输出类似以上内容，表示安装完成

检查mariaDB是否被覆盖

rpm -qa | grep mariadb

输出空，表示 mariaDB 已经被成功覆盖。

MySQL 常用命令

# 启动
systemctl start mysqld

# 第一次启动后，可以查看mysql初始化密码
grep 'temporary password' /var/log/mysqld.log

# 重启
systemctl restart mysqld

# 停止
systemctl stop mysqld

#查看状态
systemctl status mysqld

#开机启动
systemctl enable mysqld
systemctl daemon-reload

# 查看进程、版本信息
ps -ef | grep mysql
或
netstat -atp

# 登录
mysql -u root -p'密码内容'

# 查看所有表
show databases;

# 进入数据库
use 表名

# 查看所有表
show tables

# 查看某张表信息
desc 表名

# 查
select * from 表名
# 删
delete from 表名 where field=xx
# 改
update 表名 set field='xxx' where field='xxx';

登录和修改密码

我们安装的时候，并没有设置初始密码

所以 mysql 在第一次启动的时候，会自动初始化一个密码

通过以下这行代码，我们可以查看 mysql 自动初始化的密码：

# 第一次启动后，可以查看mysql初始化密码
grep 'temporary password' /var/log/mysqld.log

输出（root@localhost: 后面的是密码）：
2023-04-21T06:03:27.071550Z 6 [Note] [MY-010454] [Server] A temporary password
is generated for root@localhost: r2to%yZ%a)%s

# 登录mysql，一定要注意：-p和'密码'之间是没有空格的
mysql -u root -p'r2to%yZ%a)%s'

修改 root 密码

注意了，默认的密码策略，需要：大写英文 + 特殊字符 + 数字

ALTER USER 'root'@'localhost' IDENTIFIED BY 'Root_123';

有些同学可能会觉得，老子密码想设置啥就设置啥，轮得到你这 mysql 在这里瞎BB？

那也是可以修改密码校验策略的

首先，安装密码验证插件

但是有个前提，你还是需要先按它的要求修改第一次密码，才能安装密码验证策略插件，哈哈

1、先按照mysql的要求，修改一次密码
ALTER USER 'root'@'localhost' IDENTIFIED BY 'Root_123';

2、退出mysql
exit

3、重新登录mysql
mysql -u root -p'Root_123'

4、安装密码验证插件
install plugin validate_password soname 'validate_password.so';

5、查看是否启用了插件
select plugin_name, plugin_status from information_schema.plugins where plugin_name like 'validate%';
+-------------------+---------------+
| plugin_name       | plugin_status |
+-------------------+---------------+
| validate_password | ACTIVE        |
+-------------------+---------------+
输出这样的内容，表示成功启用

查看验证策略的键、值信息

SHOW VARIABLES LIKE 'validate_password%';

对于高版本的mysql，例如mysql 8，验证策略的key，是 validate_password.xxx
+--------------------------------------+-------+
| Variable_name                        | Value |
+--------------------------------------+-------+
| validate_password.check_user_name    | ON    |
| validate_password.dictionary_file    |       |
| validate_password.length             | 8     |
| validate_password.mixed_case_count   | 1     |
| validate_password.number_count       | 1     |
| validate_password.policy             | MEDIUM|
| validate_password.special_char_count | 1     |
+--------------------------------------+-------+


对于低版本的mysql，例如mysql 5.7，验证策略的key，是 validate_password_xxx
+--------------------------------------+-------+
| Variable_name                        | Value |
+--------------------------------------+-------+
| validate_password.check_user_name    | ON    |
| validate_password.dictionary_file    |       |
| validate_password.length             | 8     |
| validate_password.mixed_case_count   | 1     |
| validate_password.number_count       | 1     |
| validate_password.policy             | MEDIUM|
| validate_password.special_char_count | 1     |
+--------------------------------------+-------+

我们修改密码策略和密码长度

我的策略信息的 key ，是 validate_password.xxx这个格式的，所以按照如下进行设置

设置密码校验策略为：0（只验证密码长度）
set global validate.password_policy=0;

设置密码最低长度=N，例如设置密码最低长度=6，也就是密码最少要设置6个字符及以上
set global validate.password_length=6;

好了，现在密码就可以按照你刚才配置的策略，来进行设置密码了

ALTER USER 'root'@'localhost' IDENTIFIED BY '123456';

开放 root 账户远程登录

# 登录
mysql -u root -p'密码'

# 如果你的数据库是 mysql 8 及以上
# 1、进入数据库
use mysql
# 2、修改user表
update user set host='%' where user='root';

# mysql 5.7 及之前，执行这行代码即可
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '你的密码' WITH GRANT OPTION;

# 重载授权表
FLUSH PRIVILEGES;

# 退出
exit

# 重启
systemctl restart mysqld

端口开放

经过实测，使用阿里云或者腾讯云，在服务器上，无需配置 iptables 端口信息

但必须在阿里云或者腾讯云控制台 - 服务器 - 安全组，开放 3306端口。

CentOS更换阿里源

Sat, 01 Jun 2024 00:00:00 GMT

CentOS8配置阿里云YUM源

2022-05-19 11:51 猎手家园阅读(6909) 评论(1) 编辑 [收藏](javascript:void(0)) [举报](javascript:void(0))

1、进入配置目录

cd /etc/yum.repos.d/

2、备份原yum源

mv CentOS-Linux-Base.repo CentOS-Linux-Base.repo.bak

3、下载阿里云源

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-8.repo

4、修改yum源

输入命令 “vim CentOS-Base.repo” 后，按“冒号” 进入命令模式

#首先输入：
%s/mirrors.cloud.aliyuncs.com/mirrors.aliyun.com/g

#回车后，再次按“冒号”后，输入：
%s/$releasever/$releasever-stream/g

#回车，然后再按“冒号”后输入保存命令：
wq

说明：在vim命令下，按下冒号键是命令模式，按回车键执行，最后输入 wq 是保存并退出命令

5、还需要改两个地方，否则会出现以下错误：

错误：为 repo ‘appstream‘ 下载元数据失败 : Cannot prepare internal mirrorlist: No URLs in mirrorlist

用vim打开文件CentOS-Linux-AppStream.repo、CentOS-Linux-Extras.repo，将原来的mirrorlist给注释掉，然后新增一行：

baseurl=https://mirrors.aliyun.com/centos/$releasever-stream/extras/$basearch/os/

6、重新缓存

#清理
yum clean all

#生成缓存
yum makecache

Centos更新内核

Sat, 01 Jun 2024 00:00:00 GMT

手动升级CentOS 7.9内核的正确方式

1.背景

不知道大家有没有遇到过这样的问题，在使用docker创建vlan网络时，会提示“Error response from daemon: kernel version failed to meet the minimum ipvlan kernel requirement of 4.2, found 3.10.0”，需要的内核为4.2，但找到的内核为3.10.0。

看一下系统的内核版本，使用以下命令：

uname -a

可以看到当前的内核确实为3.10.0.

查看一下CentOS的版本，使用以下命令：

cat /etc/redhat-release

可以看到是最新的7.9版本。

2.错误尝试

按照一贯的思路，那不就是update解决的事嘛！手指一划，敲下一条命令(生产环境下慎用！)：

yum -y update

没有效果！采用upgrade升级(生产环境下慎用！)

yum -y upgrade

好吧，没有用，内核没有变化。

3.正确尝试

先导入一个公钥。

rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org

安装一下CentOS 7.x的ELRepo包。

yum install -y https://www.elrepo.org/elrepo-release-7.el7.elrepo.noarch.rpm
# CentOS 8则采用下面的命令
# yum install -y https://www.elrepo.org/elrepo-release-8.el8.elrepo.noarch.rpm

然后依次执行下面的命令，等待进度条走完，下载升级：

yum --enablerepo=elrepo-kernel install kernel-ml -y &&
sed -i s/saved/0/g /etc/default/grub &&
grub2-mkconfig -o /boot/grub2/grub.cfg

重启系统：

reboot

再次查看CentOS的内核版本，发现已经把内核升级成了5.16.12：

uname -a

可以开心的玩耍了~

CentOS7配置阿里云镜像源（超详细过程）

Sat, 01 Jun 2024 00:00:00 GMT

前言

此方法亲测有效，适用于CentOS7版本所有的环境。 CentOS7本地yum源的配置，请参考本人的另一篇博客文章：https://blog.csdn.net/KingveyLee/article/details/114979418 RedHat7本地yum源的配置，请参考本人的另一篇博客文章：https://blog.csdn.net/KingveyLee/article/details/114981036

一、环境准备

你需要准备一台干净的CentOS7的环境，且可以ping的通外网~尤其是mirrors.aliyun.com。简单测试一下，如果通的话，再执行以下步骤完成设置。

ping mirrors.aliyun.com
1

二、手动配置阿里云源

备份官方的原yum源的配置

mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
1

下载Centos-7.repo文件

最小化安装，如果没有wget的命令，可使用curl代替wget，执行如下语句代替： curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
1

清除及生成缓存。

# 清除yum缓存
yum clean all
# 缓存阿里云源
yum makecache
# 测试阿里云源 
yum list
123456

三、脚本配置本地源

本人以/root/目录为例

vi /root/auto_aliyun.sh
1

编写如下内容：

#!/bin/bash

# 备份官方的原yum源的配置
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
# 下载Centos-7.repo文件,或者curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo，取决于你是否有wget的命令
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
# 清除yum缓存
yum clean all
# 缓存本地yum源
yum makecache
12345678910

按ESC。输入:wq保存，完成镜像阿里云源的脚本文件的编写
赋予脚本可执行的权限

chmod +x /root/auto_aliyun.sh
1

执行脚本文件，即可

/root/auto_aliyun.sh

Docker中文管理面板

Sat, 01 Jun 2024 00:00:00 GMT

portainer-ce中文版

源码仓库https://github.com/eysp/portainer-ce

其中arm和ppc64le架构没有设备测试，反馈bug 到GitHub issues

pull的已数量突破100K，我不懂编程，非常感谢大家的支持，想看预览图的点这里https://www.right.com.cn/forum/thread-4066518-1-1.html

已更新到2.19.1，新版删除左上角升级企业版的广告，删除首次登录弹出英文提示的公告，汉化的广告也隐藏，总之这是一个纯净版

如果汉化对你有帮助请往下拉支持我，另外欢迎大家进q群交流，群号758648462（备注portainer）

汉化作者：ysp QQ：360354879，基于CE版本更新汉化。工作量居大，感谢作者的辛苦奉献。

感谢群里@我不是矿神指导js精简 | @52Fancy 提供编译脚本

一键安装代码**

docker run -d --restart=always --name="portainer" -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock 6053537/portainer-ce

163镜像安装，portainer-ce中文，访问dockerhub网速不好的尝试

docker run -d --restart=always --name="portainer" -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock hub-mirror.c.163.com/6053537/portainer-ce

访问hub.docker.com网络慢，或者以上代码都无法安装成功尝试以下代码

docker pull hub-mirror.c.163.com/6053537/portainer-ce
docker run -d --restart=always --name="portainer" -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data 6053537/portainer-ce

docker常用命令

Sat, 01 Jun 2024 00:00:00 GMT

Docker 容器相关命令

启动docker

systemctl start docker

关闭docker

systemctl stop docker

查看docker的运行状态

systemctl status docker

容器是基于Docker镜像被创建的。

docker run [Options] image运行容器

docker run [Options] image

#参数说明
--name="名字"           指定容器名字
-d                     后台方式运行
-it                    使用交互方式运行,进入容器查看内容
-p                     指定容器的端口
	-p ip:主机端口:容器端口  配置主机端口映射到容器端口
	-p 主机端口:容器端口（常用）
	-p 容器端口
-P                     随机指定端口
-e					   环境设置
-v					   容器数据卷挂载

运行并进入容器centos

[root@localhost ~]# docker run -it centos /bin/bash
[root@ce2bbae9f151 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

进入容器，因为通常我们的容器都是使用后台方式来运行的，有时需要进入容器修改配置

docker exec -it 容器id /bin/bash

# docker exec 进入容器后开启一个新的终端，可以在里面操作
docker exec -it 容器id /bin/bash

docker attach 容器id

  # docker attach 进入容器正在执行的终端
  docker attach 容器id

退出容器

exit 	# 停止容器并退出（后台方式运行则仅退出）
Ctrl+P+Q  # 不停止容器退出

docker ps 查看运行的容器

# 查看当前正在运行的容器
docker ps 
     
-a   # 查看所有容器的运行记录
-n=? # 显示最近创建的n个容器
-q   # 只显示容器的id

docker start 容器id 启动容器

docker start 容器id          # 启动容器
docker restart 容器id        # 重启容器
docker stop 容器id           # 停止当前运行的容器
docker kill 容器id           # 强制停止当前容器

docker logs 容器id查看容器运行日志

docker logs -tf 容器id
docker logs --tail num 容器id  # num为要显示的日志条数

docker top 容器id查看容器中进程信息

docker top 容器id

docker inspect 容器id查看容器的元数据

docker inspect 容器id

对于centos7系统

centos7使用firewall命令来开启和关闭防火墙。

1.systemctl命令

（1）systemctl status firewalld.service查看防火墙的状态；

（2）systemctl start firewalld.service启动防火墙；

（3）systemctl stop firewalld.service关闭防火墙；

（4）systemctl restart firewalld.service重启防火墙；

（5）systemctl enable firewalld.service开机启动防火墙；

（6）systemctl disable firewalld.service开机禁用防火墙；

（7）systemctl is-enabled firewalld.service查看防火墙是否开机启动；

2.Firewall区域管理

firewall引入了zone概念，firewall能将不同的网络连接归类到不同的信任级别，为了便于理解，这里附上级别说明：

 block(阻塞区域)拒绝所有外部的连接，返回icmp-host-prohibited,允许内部发起的连接；

dmz(隔离区域)允许受限制的进入连接；

drop(丢弃区域)丢弃所有进入的包，而不给出任何响应；

external(外部区域)只有指定的连接被接受，一般用于路由转发；

home(家庭区域)允许受信任的计算机被限制的进入连接；

internal(内部区域)信任网络上其他计算机，不会损坏你的计算机。只有选择接受传入的网络连接；

public(公共区域)不信任网络上的任何计算机，只有选择接受传入的网络连接；

trusted(信任区域)信任所有连接；

work(工作区域)允许受信任的计算机被限制的进入连接。

查看区域管理命令示例：

（1）firewall-cmd --list-all-zones查看域详情列表；

（2）firewall-cmd --get-zones查看支持的区域列表；

（3）firewall-cmd --get-default-zone查看默认的区域列表；

（4）firewall-cmd --set-default-zone=home设置默认的区域；

（5）firewall-cmd --zone=home --list-all查看home区域l；

（6）firewall-cmd --get-active-zone查看活动的区域；

（7）firewall-cmd --permanent-new-zone=myself创建自己的区域；

（8）firewall-cmd --permanent-delete-zone=myself删除区域；

3.Firewall服务端口管理

在下面提到的命令示例中，带"--permanent"永久生效的策略记录（除了查看）执行后，必须执行"--reload"参数后才能立即生效，否则需要重启后再生效。不带"--permanent"的命令立即生效，但是reload或者restart后失效。

（1）firewall-cmd --state查看防火墙状态；

（2）firewall-cmd --get services查看已被firewall提供的一些常用服务；

（3）firewall-cmd --zone=public --permanent --list-services查看某域的服务（注：加了--permanent表示永久服务，不加显示所有服务，包含临时服务；不加--zone表示默认区域）；

（4）firewall-cmd --zone=public--permanent --add-service=http添加某域的服务；

（5）firewall-cmd --zone=public--permanent --remove-service=http移除某域的服务（注：加了--permanent表示永久服务，不加显示所有服务，包含临时服务；不加--zone表示默认区域）；

（6）firewall-cmd --zone=home--permanent --add-por=5000/tcp添加端口；

（7）firewall-cmd --zone=home--permanent --remove-por=5000/tcp删除端口；

（8）firewall-cmd --zone=home--permanent --add-por=5000-5005/tcp添加多端口（注：加了--permanent表示永久服务，不加显示所有服务，包含临时服务；不加--zone表示默认区域；端口后面的tcp和udp表示协议类型）；

（9）firewall-cmd --zone=public --permanent --list-ports查看端口情况（注：加了--permanent表示永久服务，不加显示所有服务，包含临时服务；不加--zone表示默认区域）；

（10）firewall-cmd --zone=public --query-service=ssh查询服务是否被允许（不加--zone表示默认区域）；

（11）firewall-cmd --permanent --zone=public --add-forward-port=80:proto=tcp:toport=8080将80端口的流量转发至8080端口；

（12）firewall-cmd --permanent --zone=public --add-forward-port=80:proto=tcp:toaddr=192.168.1.1将80端口的流量转发至192.168.1.1；

（13）firewall-cmd --permanent --zone=public --add-forward-port=80:proto=tcp:toaddr=192.168.1.1:toport=8080将80端口的流量转发至192.168.1.1的端口8080端口（注：不加ip地址，默认转发到本地的端口；不加--zone表示默认区域；不加--permanent表示临时增加，reload或则restart后失效）。

4.手动编写服务

可以将某个程序需要的端口写在一个自己编写的服务里，然后直接添加服务就可以。

/usr/lib/firewalld/services创建自己的服务，格式可以拷贝/etc/firewalld/services任意一个服务。

（1）查找服务：

firewalld-cmd --get-srvice |grep myself

（2）重新加载配置：

firewall-cmd --reload

1、安装软件的命令格式 rpm -ivh filename.rpm 1 2、卸载软件的命令格式 rpm -e filename.rpm 1 3、升级软件的命令格式　rpm -Uvh filename.rpm 1 4、查询软件描述信息的命令格式 rpm -qpi filename.rpm 1 5、列出软件文件信息的命令格式 rpm -qpl filename.rpm 1 6、查询文件属于哪个RPM的命令格式 rpm -qf filename.rpm

docker镜像操作

Sat, 01 Jun 2024 00:00:00 GMT

docker创建的容器，容器目录在哪里

Docker中的Emby容器的系统目录通常位于容器内部的特定路径中，这取决于您在创建容器时指定的挂载点和配置。通常情况下，Emby的系统目录包括配置文件、数据库和其他运行时数据。

您可以通过以下步骤来查找Emby容器的系统目录：

查找Emby容器的ID或名称：运行 docker ps 命令，找到正在运行的Emby容器的ID或名称。
进入容器的Shell：运行以下命令来进入Emby容器的Shell（替换 CONTAINER_ID 为您的容器ID或名称）：
```
docker exec -it CONTAINER_ID /bin/bash
```
寻找Emby的系统目录：一旦进入容器的Shell，您可以浏览容器内部的文件系统，通常Emby的系统目录位于 /config 或类似的路径中。您可以使用 cd 命令来导航到相应的目录，然后执行 ls 命令查看其内容。

请注意，路径和位置可能会因Emby容器的不同版本和配置而有所不同。如果您在创建容器时进行了自定义配置，系统目录的位置可能会有所改变。

如果bash用不了

抱歉，看来在您的Emby容器中并没有找到 /bin/bash 这个Shell。这可能是因为容器内并没有默认的bash shell。

您可以尝试使用容器内存在的其他Shell，比如 /bin/sh 或 /bin/ash。您可以使用以下命令来进入容器的Shell：

docker exec -it CONTAINER_ID /bin/sh

或者

docker exec -it CONTAINER_ID /bin/ash

一旦您成功进入了容器的Shell，您可以使用 ls 命令来查找Emby的系统目录。通常情况下，Emby的配置文件和数据存储在 /config 或类似的路径中。请注意，具体路径可能因Emby版本和容器配置而有所不同。

要退出容器内的Shell模式，您可以输入 exit 命令，然后按下回车键。这会使您返回到主机操作系统的命令行界面。例如：

exit

这将关闭您在容器内打开的Shell会话，并将您带回到之前的命令行终端。

如何将docker容器打包成镜像

将Docker容器打包成镜像通常需要使用Docker命令 docker commit 来创建一个新的镜像。以下是基本步骤：

确认容器状态： 在您想要打包成镜像的容器内部，确保容器处于一个稳定的状态，您可以保存为一个镜像。
获取容器ID或名称： 使用 docker ps 命令找到您要打包成镜像的容器的ID或名称。
创建镜像： 运行 docker commit 命令来创建一个新的镜像。命令的格式如下：
```
docker commit CONTAINER_ID NEW_IMAGE_NAME:TAG
```
其中，CONTAINER_ID 是容器的ID或名称，NEW_IMAGE_NAME 是您想要为新镜像设置的名称，TAG 是镜像的标签（如版本号等）。示例命令：
```
docker commit my_container my_image:latest
```
这将基于 my_container 容器创建一个名为 my_image 的新镜像，标签为 latest。
验证镜像创建： 运行 docker images 命令，您将能够看到刚刚创建的新镜像在列表中。
上传镜像（可选）： 如果您想要分享或在其他地方使用这个新创建的镜像，您可以使用 docker push 命令将镜像上传到Docker Hub或其他容器注册表。注意，上传镜像需要您在Docker Hub上有一个账号。

请注意，使用 docker commit 创建镜像可能不是最佳的实践，因为它不会包含完整的构建历史和Dockerfile信息。更好的方式是使用 Dockerfile 来构建镜像，这样可以更好地追踪镜像的构建过程和配置。

emby linux一件脚本

Sat, 01 Jun 2024 00:00:00 GMT

echo "-------------------web 端开心-------------------"
echo "使用脚本前，请先进入到 emby 的 system 目录下"
echo "官方包直接安装的路径为：cd /opt/emby-server/system/"
echo ""
echo "docker 安装请自己找路径进入再执行"
echo "-------------------我们的域名：https://hexsen.com-------------------"
rm -f Emby.Web.dll
wget https://ff.6wd.cn/file/emby/Emby.Web.dll
rm -f MediaBrowser.Model.dll
wget https://ff.6wd.cn/file/emby/MediaBrowser.Model.dll
echo "核心开心完成..."lient/
cd dashboard-ui/embypremiere/
rm -f embypremiere.js
wget https://ff.6wd.cn/file/emby/embypremiere.js
chmod 777 /embypremiere.js
echo "web 开心完成..."
cd ../../
rm -f Emby.Server.Implementations.dll
wget https://ff.6wd.cn/file/emby/Emby.Server.Implementations.dll
echo "Implementations 替换认证..."
chmod 644 Emby.Web.dll Emby.Server.Implementations.dll MediaBrowser.Model.dll

emby本地破解方法

Sat, 01 Jun 2024 00:00:00 GMT

Emby.Server.Implementations.dll

get_expDate    返回值  DateTimeOffset.UtcNow.AddDays(999.0);（RegRecord）
get_isValid    返回值  true;（RegRecord）
get_registered 返回值  true;（RegRecord）

源码所在地

MediaBrowser.Model.dll

源码位置

get_IsMBSupporter 返回值  true;

何先生建议不修改此项：get_SupporterKey 返回值  "何先生破解";

关闭检测更新
方法
hasUpdateAvailable 返回值 false (systeminfo)

EnableAutomaticRestart 返回值 false

Emby.Web.dll

提取 Emby.Web.dashboard_ui.modules.emby_apiclient.connectionmanager.js 

搜索 timeSinceLastValidation=Date.now()-(feature.lastValidDate||0);
将 return timeSinceLastValidation<=864e5?(console.log("getRegistrationInfo returning cached info"),Promise.resolve()):
替换为 if (true) return console.log("getRegistrationInfo returning cached info"),Promise.resolve();

提取 Emby.Web.dashboard_ui.modules.registrationservices.registrationservices.js 
//如果是 mac 客户端，文件在/Applications/Emby.app/Contents/Resources/www/modules/registrationservices/registrationservices.js

搜索 validateFeature 最后

从 _exports.default={validateFeature:function(feature,options){ 后面
全部替换
return Promise.resolve();},showPremiereInfo:showPremiereInfo}});

embypremiere.js

文位置在system\dashboard-ui\embypremiere

搜索 _loading.default.show(),
将前面的 return 删除

搜索 Plugins/SecurityInfo
将 getJSON(apiClient.getUrl("Plugins/SecurityInfo")).then(function(info){ 到 if(statusInfo) 中间的代码替换为：
page.querySelector(".txtSupporterKey").value = info.SupporterKey || "",
            page.querySelector(".txtSupporterKey").classList.add("invalidEntry"), 
            page.querySelector(".notSupporter").classList.add("hide"),
            page.querySelector(".supporterContainer").classList.add("hide"),key = info.SupporterKey;
                    var statusInfo = {
                  "deviceStatus": "0",
                  "planType": "Lifetime",
                  "subscriptions": {}
                };
比如下面：
page.querySelector(".txtSupporterKey").value=info.SupporterKey||"",info.SupporterKey&&!info.IsMBSupporter?(page.querySelector(".txtSupporterKey").classList.add("invalidEntry"),page.querySelector(".notSupporter").classList.remove("hide")):(page.querySelector(".txtSupporterKey").classList.remove("invalidEntry"),page.querySelector(".notSupporter").classList.add("hide")),info.IsMBSupporter?(page.querySelector(".supporterContainer").classList.add("hide"),function(key){key="key="+key+"&serverId="+ApiClient.serverId();return fetch("https://mb3admin.com/admin/service/registration/getStatus",{method:"POST",body:key,headers:{"Content-Type":"application/x-www-form-urlencoded"}}).then(function(response){return response.json()})}(info.SupporterKey).then(function(statusInfo){

替换

page.querySelector(".txtSupporterKey").value = info.SupporterKey || "",
            page.querySelector(".txtSupporterKey").classList.add("invalidEntry"), 
            page.querySelector(".notSupporter").classList.add("hide"),
            page.querySelector(".supporterContainer").classList.add("hide"),key = info.SupporterKey;
                    var statusInfo = {
                  "deviceStatus": "0",
                  "planType": "Lifetime",
                  "subscriptions": {}
                };

然后删除替换 var subs,key;_loading.default.hide()})):(page.querySelector(".supporterContainer").classList.remove("hide"),page.querySelector(".isSupporter").classList.add("hide"),_loading.default.hide(),Promise.resolve())});

为 }),_loading.default.hide();
        
在 classList.remove("hide")}}) 后面添加 ,_loading.default.hide()

如   querySelector(".isSupporter").classList.remove("hide")}}),_loading.default.hide()  
将 page.querySelector(".txtSupporterKey")前的return删除
搜索删除 ),_loading.default.hide(
/*
删除 var subs,key;
            })) : (page.querySelector(".supporterContainer").classList.remove("hide"), page.querySelector(".isSupporter").classList.add("hide")), _loading.default.hide()
 
在 }) 后面添加 ,_loading.default.hide();

例如 querySelector(".isSupporter").classList.remove("hide")}}),_loading.default.hide()  
*/

/Contents/Resources/www/modules/emby-apiclient/connectionmanager.js 文件修改，针对 mac 客户端

//搜索以下代码
getRegistrationInfo(feature, apiClient, options) { 中间的代码全部替换为以下代码 } 

//替换代码
      getRegistrationInfo(feature, apiClient, options) {
        const params = {
          serverId: apiClient.serverId(),
          deviceId: this.deviceId(),
          deviceName: this.deviceName(),
          appName: this.appName(),
          appVersion: this.appVersion()
        };
      
        // Simulate successful validation without making a request
        const simulatedResponse = {
          cacheExpirationDays: 999
        };
      
        // Generate cache key
        const cacheKey = getCacheKey(feature, apiClient, options);
      
        // Store simulated response in app storage
        this.appStorage.setItem(cacheKey, JSON.stringify({
          lastValidDate: Date.now(),
          deviceId: params.deviceId,
          cacheExpirationDays: simulatedResponse.cacheExpirationDays,
          lastUpdated: Date.now()
        }));
      
        // Return a resolved Promise
        return Promise.resolve();
      }

在线升级版本：ESXI6.5升级7.0

Sat, 01 Jun 2024 00:00:00 GMT

将一台使用ESXI6.7的虚升级条件 1、首先确保硬件是否能升级到7.0版本，注意：物理网卡驱动为e1000e不能升级，如果是igbn（只要不是e1000e都行），则可以顺利升级。拟机升级到了7.0版本。

升级方法升级方法有补丁升级、在线升级和U盘升级三种方式，我使用的是补丁升级，下面是升级过程。

1.查询+下载补丁

VMware-ESXi-7.0b-16324942-depot.zip

2、上传文件

通过Web管理界面，将文件VMware-ESXi-7.0b-16324942-depot.zip上传到ESXI存储设备的根目录。如下图所示：

3.在Terminal终端软件上SSH到ESXi

$ ssh root@X.X.X.X

自己服务器的IP地址，然后输入账号密码。

5、删除不兼容驱动

先找到存储设备位置并记录下来，如下图所示：

/vmfs/volumes/60c85952-d6d7deec-9ef6-40f2e930abd8

进入执行以下命令：

cd /vmfs/volumes/60c85952-d6d7deec-9ef6-40f2e930abd8

升级第一步，找到升级模块名称。

esxcli software sources profile list -d /vmfs/volumes/5cb88c50-f1c6a935-c840-406231072a3a/VMware-ESXi-7.0b-16324942-depot.zip

这里显示有三个模块，我们要升级的模块为“ESXi-7.0b-16324942-standard”

升级第二步，检查是否能正常升级。注意用查到的升级模块替换对应的参数。

esxcli software profile update -p ESXi-7.0b-16324942-standard -d /vmfs/volumes/5cb88c50-f1c6a935-c840-406231072a3a/VMware-ESXi-7.0b-16324942-depot.zip --dry-run

如果出现跟上图一样的情况，就说明老版本集成的驱动与7.0版本不兼容。需要卸载老版本集成的不兼容驱动。

先记下不兼容的驱动文件版本名称，这里是 sata-xahci-1.3-1。输入以下命令查看原系统集成的所有驱动，找到不兼容驱动的文件名称：

esxcli software vib list

该不兼容驱动的文件名称为“sata-xahci”，执行以下命令删除集成驱动：

esxcli software vib remove -n sata-xahci

如果有多个不兼容驱动，可以一起进行删除。

6、正常升级

解决了驱动兼容问题以后，执行下面的升级命令：

esxcli software profile update -p ESXi-7.0b-16324942-standard -d /vmfs/volumes/5cb88c50-f1c6a935-c840-406231072a3a/VMware-ESXi-7.0b-16324942-depot.zip 如果升级正常，就会出现大量的字符。

接着手动输入重启命令，升级完成。（下图中已经接着升级到了7.01版本）

reboot

至此，升级过程全部完成。

esxi7升级83种方式！

Sat, 01 Jun 2024 00:00:00 GMT

现在可以下载esxi 8.0版本，许多人可能会考虑将他们的esxi7升级8来安装新版本。让我们通过三种方式了解esxi升级8.0的不同方式。

引入新的vSphere 8

如果你使用vSphere 7并且关注IT新闻，你可能听说过VMware发布了稳定的新版本vSphere 8.0。

vSphere 8.0支持每个虚拟机可以运行8个vGPU，与vSphere 7 U3相比增加了两倍，让您可以运行更多、更强大的虚拟机，并更快地执行任务。此外，还有更多新品vSphere 8 功能：

vSphere分布式服务引擎
Tanzu Kubernetes Grid 2.0
Lifecycle Management
...

那么，您是否需要立即从vSphere 7升级到vSphere 8？这取决于您的需求。但为了避免发生意外，提前做好esxi7升级8.0和vCenter 8的准备总是必不可少的。接下来，本文将提供从vSphere 7升级到vSphere 8的3种方式，并回答一些常见问题。

vSphere 8的预升级

在开始升级到vSphere 8之前，您应该对vSphere环境执行一些维护和管理活动。

**检查兼容性：**vSphere 8不支持6.5或更早版本的任何组件。因此，您可能先需要将某些组件升级到版本6.7以上，并在继续升级之前检查这些不兼容性组件。
**健康检查：**如果环境不处于健康状态，可能会发生错误，可能需要回滚。
**SSO域拓扑重新配置：**您可以选择自动执行外部平台服务控制器（Platform Services Controller）融合，或在升级之前手动执行聚合或域重新指向任务。
**移除vCenter HA：**停用和移除vCenter HA可简化升级工作流程，并在升级失败时更容易进行故障排除。
**备份您的环境：**升级前备份您的vSphere环境非常重要，包括ESXi VM、ESXi和vCenter 配置、Platform Services Controller、分布式虚拟交换机等。

通过傲梅企业备份旗舰版可以批量备份由vCenter管理的虚拟机：

傲梅企业备份旗舰版是一款不需要代理的VM备份软件，支持付费和免费版本的VMware ESXi。它还允许您批量备份由vCenter Server管理的多个虚拟机，并集中监控这些虚拟机的数据保护，让您摆脱繁重而费力的管理任务。

如何将vSphere 7升级到8

在将ESXi 7主机升级到ESXi 8之前，您应该首先检查ESXi8的安装要求，包括硬件、兼容性要求等。我将通过以下3种方式升级到ESXi 8：

使用ISO镜像文件
使用vSphere Lifecycle Manager
使用ESXCLI命令

**注意：**如果升级由vCenter Server管理的主机，您必须在升级ESXi主机之前更新vCenter Server。如果您没有按照正确的顺序升级您的环境，您可能会丢失数据并无法访问服务器。

✔ 使用ISO从esxi7升级8

你应该下载ESXi 8.0 ISO映像在将esxi7升级8之前。

访问您的VMware ESXi Web客户端（ESXi 7.0），右键单击左侧清单中的**“管理”并选择“进入维护模式”**。

您可以将ISO挂载到您的远程控制台，将引导配置为从ISO引导并重新启动您的服务器。开始ESXi 8.0引导，引导至安装程序/升级程序。然后按照菜单选择安装ESXI的磁盘。

升级过程成功完成后，安装程序会要求您移除安装介质，然后重新启动。

✔ 使用vSphere Lifecycle Manager将esxi7升级8

对于由vCenter在集群级别管理的主机中您可以使用vSphere Lifecycle Manager作为虚拟中心服务器。

启动vSphere Client并登录到vCenter Server，然后导航到vSphereCluster的属性，单击**“更新”选项卡。然后单击“映像”>“设置映像”**。

从ESXi版本的下拉列表中选择ESXi 8.0版本。点击**“保存”**。
确认继续完成映像设置。
检查集群级别的合规性。我们需要修复主机。在这里，我单击**“全部修复”**按钮。

提示操作影响的对话框将弹出。单击**“开始修复”**按钮。

主机开始修复。几分钟后，您将看到ESXi主机重新启动，并在从vSphere Lifecycle Manager升级后引导至ESXi 8.0。

✔ 使用命令行升级到ESXi 8

接下来，我们可以使用命令行升级现有的ESXi主机。只需几个命令即可轻松完成此操作，包括以下命令：

esxcli network firewall ruleset set -e true -r httpClient
esxcli software profile update -d https://hostupdate.vmware.com/software/VUM/PRODUCTION/main/vmw-depot-index.xml -p ESXi-8.0.0-20513097-standard

当您看到**“The update completed successfully”**时，您需要重新启动ESXi主机。

Esxi7升级8的过程很简单。在大多数情况下，许多人会尝试在实验室环境中执行此操作，因为大多数人可能会在其生产环境中推迟。但是，如果要将ESXi主机升级到8.0版本，则必须备份VMware ESXi以防发生故障。

问答：有关esxi升级8.0的常见问题解答

ESXi 6.7 将支持多长时间？ vSphere 6.7计划于2022年10月15日达到停止维护，并于2023年11月15日达到停止技术支持。
ESXi版本可以高于vCenter吗？ 不可以，VMware不建议使用内部版本号高于vCenter Server的ESXi主机。vCenter Server版本必须与ESXi主机版本相同或更高，或者内部版本号必须高于或与ESXi主机内部版本号相同。
我可以远程升级ESXi吗？ 可以的，您可以通过在线捆绑包将ESXi更新到新版本。此方法适合拥有免费ESXi许可证但无法访问脱机捆绑包的用户。
我可以回滚ESXi升级吗？ 可以的，您可以使用直接控制台用户界面恢复到先前版本或ESXi内部版本。

总结

将现有esxi7升级8非常简单，可以通过多种方式完成，包括使用ISO、命令行和vSphere Lifecycle Manager。希望本文提供的多种方法有助于快速使您的实验室环境保持更新的状态。

防火墙常用命令

Sat, 01 Jun 2024 00:00:00 GMT

CentOS6/7

查看防火墙状态

systemctl status firewalld.service

运行上述命令后，如果看到有绿色字样标注的“active（running）”，说明防火墙是开启状态。

开启防火墙

systemctl start firewalld.service

关闭防火墙

systemctl stop firewalld.service

关闭后，可查看防火墙状态，当显示disavtive（dead）的字样，说明CentOS 7防火墙已经关闭。但要注意的是，上面的命令只是临时关闭了CentOS 7防火墙，当重启操作系统后，防火墙服务还是会再次启动。如果想要永久关闭防火墙则还需要禁用防火墙服务。

禁用防火墙服务

systemctl disable firewalld.service

查看防火墙规则

firewall-cmd –list-all

查询端口是否开放

firewall-cmd –query-port=8080/tcp

重启防火墙

firewall-cmd –reload

开放指定(如8080)端口

firewall-cmd --zone=public --add-port=8080/tcp --permanent

(修改配置后需要重启防火墙)

移除某个防火墙开启的端口

firewall-cmd --zone=public --remove-port=5000-6000/tcp --permanent1.

(修改配置后需要重启防火墙)

CentOS Stream 8/9

查看防火墙状态

systemctl status firewalld

firewall-cmd --state

开启/关闭/重启防火墙

systemctl start firewalld

systemctl stop firewalld

systemctl restart firewalld

放行指定端口

firewall-cmd --zone=public --add-port=端口号/tcp --permanent

firewall-cmd --zone=public --add-port=80/tcp --permanent # http
firewall-cmd --zone=public --add-port=443/tcp --permanent #https

放行范围端口

firewall-cmd --zone=public --add-port=5000-6000/tcp --permanent1.

删除防火墙端口

firewall-cmd --zone=public --remove-port=5000-6000/tcp --permanent1.

修改防火墙后，都要对防火墙进行刷新

firewall-cmd --reload

查看防火墙某个端口是否开放与开放哪些端口

firewall-cmd --query-port=端口号/tcp
firewall-cmd --zone=public --list-ports

Ubuntu

在 Ubuntu 中，可以使用 ufw（Uncomplicated Firewall）来管理防火墙。以下是在 Ubuntu 中查看、开启、关闭和永久关闭防火墙的方法：

查看防火墙状态：

要查看 Ubuntu 中 ufw 防火墙的状态，可以执行以下命令：

sudo ufw status

这将显示当前防火墙规则的状态，包括是否启用和允许的规则。

开启防火墙：

如果防火墙没有启用，可以使用以下命令来启用 ufw 防火墙：

sudo ufw enable

启用防火墙后，它将按照默认规则开始工作，通常会拒绝所有传入连接，但允许所有传出连接。

关闭防火墙：

要关闭 ufw 防火墙，可以执行以下命令：

sudo ufw disable

关闭防火墙后，所有传入和传出的连接将被允许，不再受到防火墙的限制。

永久关闭防火墙：

如果想永久关闭 ufw 防火墙，可以执行以下步骤：

停止 ufw 服务：

sudo systemctl stop ufw
禁用 ufw 服务的自动启动：

sudo systemctl disable ufw
重启系统，以确保防火墙不会在系统启动时重新启用。

halo自动备份到alist-s3脚本

Sat, 01 Jun 2024 00:00:00 GMT

Halo 备份和 S3 上传教程

环境要求

Python 3.x
boto3 库：用于与 S3 兼容服务交互
requests 库：用于发送 HTTP 请求

前提要求：`如果你还没有安装alist或者任何s3服务的，你可以参考我的这篇文章`(Alist/S3/阿里ossz制作随机图片api | 枫の屋 (6wd.cn))

注：如果你完成了alist的s3配置或者任何s3服务，您可以继续往下看了

步骤一：安装依赖

使用以下命令安装所需的库：

pip install boto3 requests

步骤二：创建 Python 脚本

创建一个新的 Python 脚本（例如 backup_script.py），并将以下代码粘贴到文件中：

# 代码示例
import os
import base64
import time
import requests
import json
import boto3
from botocore.exceptions import NoCredentialsError, PartialCredentialsError
from datetime import datetime, timedelta  # 确保导入 timedelta
import logging

# 设置日志配置
log_file_path = '/www/wwwroot/Docker/halo/backup-auto/backup_log.txt'
logging.basicConfig(filename=log_file_path, level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Halo用户信息
user = "username"  # 替换为您的 Halo 用户名
password = "password"  # 替换为您的 Halo 密码

# 自定义 S3 兼容服务配置
aws_access_key_id = "aws-id"  # 替换为您的 AWS 访问密钥ID
aws_secret_access_key = "aws-key"  # 替换为您的 AWS 秘密访问密钥
aws_bucket_name = "bucket-name"  # 替换为您的 S3 存储桶名称
aws_region = "auto"  # S3 存储桶所在的 AWS 区域
endpoint_url = "http://ip:端口"  # 自定义的 S3 兼容服务的 endpoint(ip+端口/域名)

# 网站地址
website = "https://6wd.cn"  #halo域名地址
# halo备份文件夹路径
backup_halo_path = "~/halo/halo2/backups" #填写你的备份文件地址

# 设置有效期（天）
expiry_days = 3  # 可以设置为任何值，例如3天
expires_at = (datetime.utcnow() + timedelta(days=expiry_days)).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'

# Halo API不变
backup_api = website + "/apis/migration.halo.run/v1alpha1/backups"
check_api = website + "/apis/migration.halo.run/v1alpha1/backups?sort=metadata.creationTimestamp%2Cdesc"

# 获取当前时间
now_time = datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
auth_header = "Basic " + base64.b64encode((user + ":" + password).encode()).decode()

payload = json.dumps({
    "apiVersion": "migration.halo.run/v1alpha1",
    "kind": "Backup",
    "metadata": {
        "generateName": "suki-backup-",
        "name": ""
    },
    "spec": {
        "expiresAt": expires_at,  # 设置有效期
    }
})
headers = {
    'Content-Type': 'application/json',
    'Authorization': auth_header,
}

# 发送备份请求
response = requests.post(backup_api, headers=headers, data=payload)
logging.info(response.text)  # 记录响应内容

if response.status_code == 201:
    logging.info("备份请求成功！")
    while True:
        time.sleep(10)  # 等待10秒后再次检查状态
        check_response = requests.get(check_api, headers=headers)
        if check_response.status_code == 200:
            backup_data = json.loads(check_response.text)
            items = backup_data.get("items", [])
            if items and items[0]["status"]["phase"] == "SUCCEEDED":
                logging.info("备份完成！")
                # 捕获带有时间戳的最新文件
                backup_files = [f for f in os.listdir(backup_halo_path) if f.endswith('.zip')]
                backup_files.sort(reverse=True)
                if backup_files:
                    new_backup_name = backup_files[0]
                    file_path = os.path.join(backup_halo_path, new_backup_name)
                    logging.info(f"文件准备上传：{file_path}")
                    break
            elif items and items[0]["status"]["phase"] == "RUNNING":
                logging.info("正在备份！")
        else:
            logging.error(f"查询备份请求失败！错误代码：{check_response.status_code}")
else:
    logging.error(f"备份请求失败！错误代码：{response.status_code}")

# 检查文件是否存在并上传到自定义 S3 兼容服务
if os.path.exists(file_path):
    def upload_to_s3(file_path):
        try:
            # 创建 S3 客户端
            s3_client = boto3.client(
                's3',
                aws_access_key_id=aws_access_key_id,
                aws_secret_access_key=aws_secret_access_key,
                endpoint_url=endpoint_url,
                region_name=aws_region
            )

            logging.info(f"正在上传文件 {file_path} 到存储桶 {aws_bucket_name}...")
            # 使用 upload_file 方法上传整个文件
            s3_client.upload_file(file_path, aws_bucket_name, os.path.basename(file_path))
            logging.info("上传完成！")
            return True

        except FileNotFoundError:
            logging.error(f"文件不存在：{file_path}")
            return False
        except NoCredentialsError:
            logging.error("AWS 凭证未找到，请检查配置。")
            return False
        except PartialCredentialsError:
            logging.error("AWS 凭证不完整，请检查配置。")
            return False
        except Exception as e:
            logging.error(f"上传过程中发生错误：{e}")
            return False

    # 尝试上传到自定义 S3 兼容服务
    upload_to_s3(file_path)
else:
    logging.error(f"文件不存在：{file_path}")

步骤三：配置脚本

在脚本中，您需要输入以下信息：

Halo 用户名：在提示中输入您的 Halo 用户名。
Halo 密码：在提示中输入您的 Halo 密码。
AWS 访问密钥ID：在提示中输入您的 AWS 访问密钥ID。
AWS 秘密访问密钥：在提示中输入您的 AWS 秘密访问密钥。
S3 存储桶名称：输入您创建的 S3 存储桶名称。
自定义 S3 兼容服务的 endpoint：输入您的 S3 服务的 endpoint (ip+端口/域名)。

步骤四：设置有效期

您可以在脚本中设置备份的有效期（以天为单位）。例如，将 expiry_days 设置为 3 表示有效期为 3 天。

expiry_days = 3  # 备份有效期（天）

步骤五：运行脚本

在终端中运行以下命令：

python3 /path/to/your/backup_script.py

步骤六：查看日志

所有输出信息将显示在终端中。确保检查 S3 存储桶，以确认文件是否上传成功。

步骤七：设置自动化

自动化一般使用宝塔的计划任务点击右上角的“添加任务”按钮，在“任务类型”中选择“Shell 脚本”或“Python 脚本”，在“任务内容”中输入以下命令：

python3 /www/wwwroot/Docker/halo/backup-auto/backup_script.py >> /www/wwwroot/Docker/halo/backup-auto/backup_log.txt 2>&1

这条命令会将脚本的标准输出和错误输出都重定向到 backup_log.txt 文件中。

在“定时”部分，选择您希望执行任务的频率（例如：每小时、每天等）。点击“提交”按钮，保存您的定时任务。

可以手动运行一次任务，确保一切正常，并查看日志文件确认任务是否如预期执行。（不要着急！！！他会有几分钟延迟没有日志，这是脚本正在执行，请不要连续点击，否则服务器会炸掉）

如果在设置过程中遇到任何问题，或者有其他问题需要解决，请告诉我！

注意事项

确保您的 AWS 凭证正确且具有上传权限。
确保脚本能够访问指定的 S3 存储桶。

如何升级nodejs版本

Sat, 01 Jun 2024 00:00:00 GMT

方法一：用n升级nodejs（建议使用此方法）

# 查看当前node版本
$ node -v

# 清除npm缓存
$ npm cache clean -f

# 全局安装n
$ npm install -g n

# 升级到最新稳定版
$ n stable

# 升级到最新版
$ n latest

# 升级到定制版
$ n v14.6.0

# 切换使用版本
$ n 13.10.0 (ENTER)

# 删除制定版本
$ n rm 13.10.0

# 用制定的版本执行脚本
$ n use 13.10.0 some.js

# 升级完成查看 node版本
$ node -v

注意： 如果在第一步安装n模块报错npm ERR! code EBADPLATFORM 遇到这样错误信息，先将生成的node_modules文件夹删除，再在命令后面加上 --force重新运行；如：npm install --force即可；如果不行，再反复执行上面的步骤。

方法二：用NVM来升级nodejs

github 下载nvm

配置项目到环境变量中

$ source ~/.bashrc

$ nvm --version

# 升级到到定制版

$ nvm install 13.10.0

# 升级到最新版

$ nvm install lastest

# 升级到稳定版

$ nvm install stable

方法三：官网下载

去官网下载 LTS版本的 node 然后安装即可

状态码含义

Sat, 01 Jun 2024 00:00:00 GMT

详细介绍:https://cloud.tencent.com/developer/chapter/13553

Http状态码	状态码含义
100	客户端应当继续发送请求。这个临时响应是用来通知客户端它的部分请求已经被服务器接收，且仍未被拒绝。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。服务器必须在请求完成后向客户端发送一个最终响应。
101	服务器已经理解了客户端的请求，并将通过Upgrade消息头通知客户端采用不同的协议来完成这个请求。在发送完这个响应最后的空行后，服务器将会切换到在Upgrade消息头中定义的那些协议。只有在切换新的协议更有好处的时候才应该采取类似措施。例如，切换到新的HTTP版本比旧版本更有优势，或者切换到一个实时且同步的协议以传送利用此类特性的资源。
102	由WebDAV（RFC 2518）扩展的状态码，代表处理将被继续执行。
200	请求已成功，请求所希望的响应头或数据体将随此响应返回。
201	请求已经被实现，而且有一个新的资源已经依据请求的需要而建立，且其URI已经随Location头信息返回。假如需要的资源无法及时建立的话，应当返回'202 Accepted'。
202	服务器已接受请求，但尚未处理。正如它可能被拒绝一样，最终该请求可能会也可能不会被执行。在异步操作的场合下，没有比发送这个状态码更方便的做法了。返回202状态码的响应的目的是允许服务器接受其他过程的请求（例如某个每天只执行一次的基于批处理的操作），而不必让客户端一直保持与服务器的连接直到批处理操作全部完成。在接受请求处理并返回202状态码的响应应当在返回的实体中包含一些指示处理当前状态的信息，以及指向处理状态监视器或状态预测的指针，以便用户能够估计操作是否已经完成。
203	服务器已成功处理了请求，但返回的实体头部元信息不是在原始服务器上有效的确定集合，而是来自本地或者第三方的拷贝。当前的信息可能是原始版本的子集或者超集。例如，包含资源的元数据可能导致原始服务器知道元信息的超级。使用此状态码不是必须的，而且只有在响应不使用此状态码便会返回200 OK的情况下才是合适的。
204	服务器成功处理了请求，但不需要返回任何实体内容，并且希望返回更新了的元信息。响应可能通过实体头部的形式，返回新的或更新后的元信息。如果存在这些头部信息，则应当与所请求的变量相呼应。如果客户端是浏览器的话，那么用户浏览器应保留发送了该请求的页面，而不产生任何文档视图上的变化，即使按照规范新的或更新后的元信息应当被应用到用户浏览器活动视图中的文档。由于204响应被禁止包含任何消息体，因此它始终以消息头后的第一个空行结尾。
205	服务器成功处理了请求，且没有返回任何内容。但是与204响应不同，返回此状态码的响应要求请求者重置文档视图。该响应主要是被用于接受用户输入后，立即重置表单，以便用户能够轻松地开始另一次输入。与204响应一样，该响应也被禁止包含任何消息体，且以消息头后的第一个空行结束。
206	服务器已经成功处理了部分GET请求。类似于FlashGet或者迅雷这类的HTTP下载工具都是使用此类响应实现断点续传或者将一个大文档分解为多个下载段同时下载。该请求必须包含Range头信息来指示客户端希望得到的内容范围，并且可能包含If-Range来作为请求条件。响应必须包含如下的头部域：Content-Range用以指示本次响应中返回的内容的范围；如果是Content-Type为multipart/byteranges的多段下载，则每一multipart段中都应包含Content-Range域用以指示本段的内容范围。假如响应中包含Content-Length，那么它的数值必须匹配它返回的内容范围的真实字节数。Date ETag和/或Content-Location，假如同样的请求本应该返回200响应。Expires,Cache-Control，和/或Vary，假如其值可能与之前相同变量的其他响应对应的值不同的话。假如本响应请求使用了If-Range强缓存验证，那么本次响应不应该包含其他实体头；假如本响应的请求使用了If-Range弱缓存验证，那么本次响应禁止包含其他实体头；这避免了缓存的实体内容和更新了的实体头信息之间的不一致。否则，本响应就应当包含所有本应该返回200响应中应当返回的所有实体头部域。假如ETag或Last-Modified头部不能精确匹配的话，则客户端缓存应禁止将206响应返回的内容与之前任何缓存过的内容组合在一起。任何不支持Range以及Content-Range头的缓存都禁止缓存206响应返回的内容。
207	由WebDAV(RFC 2518)扩展的状态码，代表之后的消息体将是一个XML消息，并且可能依照之前子请求数量的不同，包含一系列独立的响应代码。
300	被请求的资源有一系列可供选择的回馈信息，每个都有自己特定的地址和浏览器驱动的商议信息。用户或浏览器能够自行选择一个首选的地址进行重定向。除非这是一个HEAD请求，否则该响应应当包括一个资源特性及地址的列表的实体，以便用户或浏览器从中选择最合适的重定向地址。这个实体的格式由Content-Type定义的格式所决定。浏览器可能根据响应的格式以及浏览器自身能力，自动作出最合适的选择。当然，RFC 2616规范并没有规定这样的自动选择该如何进行。如果服务器本身已经有了首选的回馈选择，那么在Location中应当指明这个回馈的URI；浏览器可能会将这个Location值作为自动重定向的地址。此外，除非额外指定，否则这个响应也是可缓存的。
301	被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个URI之一。如果可能，拥有链接编辑功能的客户端应当自动把请求的地址修改为从服务器反馈回来的地址。除非额外指定，否则这个响应也是可缓存的。新的永久性的URI应当在响应的Location域中返回。除非这是一个HEAD请求，否则响应的实体中应当包含指向新的URI的超链接及简短说明。如果这不是一个GET或者HEAD请求，因此浏览器禁止自动进行重定向，除非得到用户的确认，因为请求的条件可能因此发生变化。注意：对于某些使用HTTP/1.0协议的浏览器，当它们发送的POST请求得到了一个301响应的话，接下来的重定向请求将会变成GET方式。
302	请求的资源现在临时从不同的URI响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求。只有在Cache-Control或Expires中进行了指定的情况下，这个响应才是可缓存的。新的临时性的URI应当在响应的Location域中返回。除非这是一个HEAD请求，否则响应的实体中应当包含指向新的URI的超链接及简短说明。如果这不是一个GET或者HEAD请求，那么浏览器禁止自动进行重定向，除非得到用户的确认，因为请求的条件可能因此发生变化。注意：虽然RFC 1945和RFC 2068规范不允许客户端在重定向时改变请求的方法，但是很多现存的浏览器将302响应视作为303响应，并且使用GET方式访问在Location中规定的URI，而无视原先请求的方法。状态码303和307被添加了进来，用以明确服务器期待客户端进行何种反应。
303	对应当前请求的响应可以在另一个URI上被找到，而且客户端应当采用GET的方式访问那个资源。这个方法的存在主要是为了允许由脚本激活的POST请求输出重定向到一个新的资源。这个新的URI不是原始资源的替代引用。同时，303响应禁止被缓存。当然，第二个请求（重定向）可能被缓存。新的URI应当在响应的Location域中返回。除非这是一个HEAD请求，否则响应的实体中应当包含指向新的URI的超链接及简短说明。注意：许多HTTP/1.1版以前的浏览器不能正确理解303状态。如果需要考虑与这些浏览器之间的互动，302状态码应该可以胜任，因为大多数的浏览器处理302响应时的方式恰恰就是上述规范要求客户端处理303响应时应当做的。
304	如果客户端发送了一个带条件的GET请求且该请求已被允许，而文档的内容（自上次访问以来或者根据请求的条件）并没有改变，则服务器应当返回这个状态码。304响应禁止包含消息体，因此始终以消息头后的第一个空行结尾。该响应必须包含以下的头信息：Date，除非这个服务器没有时钟。假如没有时钟的服务器也遵守这些规则，那么代理服务器以及客户端可以自行将Date字段添加到接收到的响应头中去（正如RFC 2068中规定的一样），缓存机制将会正常工作。ETag和/或Content-Location，假如同样的请求本应返回200响应。Expires,Cache-Control，和/或Vary，假如其值可能与之前相同变量的其他响应对应的值不同的话。假如本响应请求使用了强缓存验证，那么本次响应不应该包含其他实体头；否则（例如，某个带条件的GET请求使用了弱缓存验证），本次响应禁止包含其他实体头；这避免了缓存了的实体内容和更新了的实体头信息之间的不一致。假如某个304响应指明了当前某个实体没有缓存，那么缓存系统必须忽视这个响应，并且重复发送不包含限制条件的请求。假如接收到一个要求更新某个缓存条目的304响应，那么缓存系统必须更新整个条目以反映所有在响应中被更新的字段的值。
305	被请求的资源必须通过指定的代理才能被访问。Location域中将给出指定的代理所在的URI信息，接收者需要重复发送一个单独的请求，通过这个代理才能访问相应资源。只有原始服务器才能建立305响应。注意：RFC 2068中没有明确305响应是为了重定向一个单独的请求，而且只能被原始服务器建立。忽视这些限制可能导致严重的安全后果。
306	在最新版的规范中，306状态码已经不再被使用。
307	请求的资源现在临时从不同的URI响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求。只有在Cache-Control或Expires中进行了指定的情况下，这个响应才是可缓存的。新的临时性的URI应当在响应的Location域中返回。除非这是一个HEAD请求，否则响应的实体中应当包含指向新的URI的超链接及简短说明。因为部分浏览器不能识别307响应，因此需要添加上述必要信息以便用户能够理解并向新的URI发出访问请求。如果这不是一个GET或者HEAD请求，那么浏览器禁止自动进行重定向，除非得到用户的确认，因为请求的条件可能因此发生变化。
400	1、语义有误，当前请求无法被服务器理解。除非进行修改，否则客户端不应该重复提交这个请求。2、请求参数有误。
401	当前请求需要用户验证。该响应必须包含一个适用于被请求资源的WWW-Authenticate信息头用以询问用户信息。客户端可以重复提交一个包含恰当的Authorization头信息的请求。如果当前请求已经包含了Authorization证书，那么401响应代表着服务器验证已经拒绝了那些证书。如果401响应包含了与前一个响应相同的身份验证询问，且浏览器已经至少尝试了一次验证，那么浏览器应当向用户展示响应中包含的实体信息，因为这个实体信息中可能包含了相关诊断信息。参见RFC 2617。
402	该状态码是为了将来可能的需求而预留的。
403	服务器已经理解请求，但是拒绝执行它。与401响应不同的是，身份验证并不能提供任何帮助，而且这个请求也不应该被重复提交。如果这不是一个HEAD请求，而且服务器希望能够讲清楚为何请求不能被执行，那么就应该在实体内描述拒绝的原因。当然服务器也可以返回一个404响应，假如它不希望让客户端获得任何信息。
404	请求失败，请求所希望得到的资源未被在服务器上发现。没有信息能够告诉用户这个状况到底是暂时的还是永久的。假如服务器知道情况的话，应当使用410状态码来告知旧资源因为某些内部的配置机制问题，已经永久的不可用，而且没有任何可以跳转的地址。404这个状态码被广泛应用于当服务器不想揭示到底为何请求被拒绝或者没有其他适合的响应可用的情况下。
405	请求行中指定的请求方法不能被用于请求相应的资源。该响应必须返回一个Allow头信息用以表示出当前资源能够接受的请求方法的列表。鉴于PUT，DELETE方法会对服务器上的资源进行写操作，因而绝大部分的网页服务器都不支持或者在默认配置下不允许上述请求方法，对于此类请求均会返回405错误。
406	请求的资源的内容特性无法满足请求头中的条件，因而无法生成响应实体。除非这是一个HEAD请求，否则该响应就应当返回一个包含可以让用户或者浏览器从中选择最合适的实体特性以及地址列表的实体。实体的格式由Content-Type头中定义的媒体类型决定。浏览器可以根据格式及自身能力自行作出最佳选择。但是，规范中并没有定义任何作出此类自动选择的标准。
407	与401响应类似，只不过客户端必须在代理服务器上进行身份验证。代理服务器必须返回一个Proxy-Authenticate用以进行身份询问。客户端可以返回一个Proxy-Authorization信息头用以验证。参见RFC 2617。
408	请求超时。客户端没有在服务器预备等待的时间内完成一个请求的发送。客户端可以随时再次提交这一请求而无需进行任何更改。
409	由于和被请求的资源的当前状态之间存在冲突，请求无法完成。这个代码只允许用在这样的情况下才能被使用：用户被认为能够解决冲突，并且会重新提交新的请求。该响应应当包含足够的信息以便用户发现冲突的源头。冲突通常发生于对PUT请求的处理中。例如，在采用版本检查的环境下，某次PUT提交的对特定资源的修改请求所附带的版本信息与之前的某个（第三方）请求向冲突，那么此时服务器就应该返回一个409错误，告知用户请求无法完成。此时，响应实体中很可能会包含两个冲突版本之间的差异比较，以便用户重新提交归并以后的新版本。
410	被请求的资源在服务器上已经不再可用，而且没有任何已知的转发地址。这样的状况应当被认为是永久性的。如果可能，拥有链接编辑功能的客户端应当在获得用户许可后删除所有指向这个地址的引用。如果服务器不知道或者无法确定这个状况是否是永久的，那么就应该使用404状态码。除非额外说明，否则这个响应是可缓存的。410响应的目的主要是帮助网站管理员维护网站，通知用户该资源已经不再可用，并且服务器拥有者希望所有指向这个资源的远端连接也被删除。这类事件在限时、增值服务中很普遍。同样，410响应也被用于通知客户端在当前服务器站点上，原本属于某个个人的资源已经不再可用。当然，是否需要把所有永久不可用的资源标记为'410 Gone'，以及是否需要保持此标记多长时间，完全取决于服务器拥有者。
411	服务器拒绝在没有定义Content-Length头的情况下接受请求。在添加了表明请求消息体长度的有效Content-Length头之后，客户端可以再次提交该请求。
412	服务器在验证在请求的头字段中给出先决条件时，没能满足其中的一个或多个。这个状态码允许客户端在获取资源时在请求的元信息（请求头字段数据）中设置先决条件，以此避免该请求方法被应用到其希望的内容以外的资源上。
413	服务器拒绝处理当前请求，因为该请求提交的实体数据大小超过了服务器愿意或者能够处理的范围。此种情况下，服务器可以关闭连接以免客户端继续发送此请求。如果这个状况是临时的，服务器应当返回一个Retry-After的响应头，以告知客户端可以在多少时间以后重新尝试。
414	请求的URI长度超过了服务器能够解释的长度，因此服务器拒绝对该请求提供服务。这比较少见，通常的情况包括：本应使用POST方法的表单提交变成了GET方法，导致查询字符串（Query String）过长。重定向URI“黑洞”，例如每次重定向把旧的URI作为新的URI的一部分，导致在若干次重定向后URI超长。客户端正在尝试利用某些服务器中存在的安全漏洞攻击服务器。这类服务器使用固定长度的缓冲读取或操作请求的URI，当GET后的参数超过某个数值后，可能会产生缓冲区溢出，导致任意代码被执行[1]。没有此类漏洞的服务器，应当返回414状态码。
415	对于当前请求的方法和所请求的资源，请求中提交的实体并不是服务器中所支持的格式，因此请求被拒绝。
416	如果请求中包含了Range请求头，并且Range中指定的任何数据范围都与当前资源的可用范围不重合，同时请求中又没有定义If-Range请求头，那么服务器就应当返回416状态码。假如Range使用的是字节范围，那么这种情况就是指请求指定的所有数据范围的首字节位置都超过了当前资源的长度。服务器也应当在返回416状态码的同时，包含一个Content-Range实体头，用以指明当前资源的长度。这个响应也被禁止使用multipart/byteranges作为其Content-Type。
417	在请求头Expect中指定的预期内容无法被服务器满足，或者这个服务器是一个代理服务器，它有明显的证据证明在当前路由的下一个节点上，Expect的内容无法被满足。
421	从当前客户端所在的IP地址到服务器的连接数超过了服务器许可的最大范围。通常，这里的IP地址指的是从服务器上看到的客户端地址（比如用户的网关或者代理服务器地址）。在这种情况下，连接数的计算可能涉及到不止一个终端用户。
422	从当前客户端所在的IP地址到服务器的连接数超过了服务器许可的最大范围。通常，这里的IP地址指的是从服务器上看到的客户端地址（比如用户的网关或者代理服务器地址）。在这种情况下，连接数的计算可能涉及到不止一个终端用户。
422	请求格式正确，但是由于含有语义错误，无法响应。（RFC 4918 WebDAV）423 Locked当前资源被锁定。（RFC 4918 WebDAV）
424	由于之前的某个请求发生的错误，导致当前请求失败，例如PROPPATCH。（RFC 4918 WebDAV）
425	在WebDav Advanced Collections草案中定义，但是未出现在《WebDAV顺序集协议》（RFC 3658）中。
426	客户端应当切换到TLS/1.0。（RFC 2817）
449	由微软扩展，代表请求应当在执行完适当的操作后进行重试。
500	服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这个问题都会在服务器的程序码出错时出现。
501	服务器不支持当前请求所需要的某个功能。当服务器无法识别请求的方法，并且无法支持其对任何资源的请求。
502	作为网关或者代理工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。
503	由于临时的服务器维护或者过载，服务器当前无法处理请求。这个状况是临时的，并且将在一段时间以后恢复。如果能够预计延迟时间，那么响应中可以包含一个Retry-After头用以标明这个延迟时间。如果没有给出这个Retry-After信息，那么客户端应当以处理500响应的方式处理它。注意：503状态码的存在并不意味着服务器在过载的时候必须使用它。某些服务器只不过是希望拒绝客户端的连接。
504	作为网关或者代理工作的服务器尝试执行请求时，未能及时从上游服务器（URI标识出的服务器，例如HTTP、FTP、LDAP）或者辅助服务器（例如DNS）收到响应。注意：某些代理服务器在DNS查询超时时会返回400或者500错误
505	服务器不支持，或者拒绝支持在请求中使用的HTTP版本。这暗示着服务器不能或不愿使用与客户端相同的版本。响应中应当包含一个描述了为何版本不被支持以及服务器支持哪些协议的实体。
506	由《透明内容协商协议》（RFC 2295）扩展，代表服务器存在内部配置错误：被请求的协商变元资源被配置为在透明内容协商中使用自己，因此在一个协商处理中不是一个合适的重点。
507	服务器无法存储完成请求所必须的内容。这个状况被认为是临时的。WebDAV(RFC 4918)
509	服务器达到带宽限制。这不是一个官方的状态码，但是仍被广泛使用。
510	获取资源所需要的策略并没有没满足。（RFC 2774）

Hyper-V Centos7 网络设置虚拟机固定IP

Sat, 01 Jun 2024 00:00:00 GMT

在网上看到很多篇文章，自己也去试验过，结果实现的效果都不是很理想，并不是自己所需要的，下面是我自己研究，最后成功的经验，希望能够帮到大家。少走一些弯路。

需求

1.无论物理机的网络环境怎么变化，都需要保持虚拟机的IP地址不变，保证我本机使用xshell等终端访问始终用同一个IP地址，或者在安装了其他软件后，访问虚拟机的IP地址保持不变。

2.物理机可访问虚拟机，虚拟机是否可访问网络都行。重点保证本机可访问虚拟机，以及虚拟机之间能互相访问。

3.无论物理机的网络环境怎么变化，虚拟机可以连接到外网。

hyper-v会自动生成一个default switch，根据微软的描述，default switch是为了无论物理机的网络环境怎么变化，虚拟机可以连接到外网。一句话，物理机可以上网，虚拟机就可以。

这里以centos7为例

固定IP

新建虚拟机
应用虚拟机

设置虚拟交换机的IP

打开控制面板，进入网络与共享中心，更改适配器的设置。找到刚才创建的虚拟机交换机。右键属性，修改IP地址。IP地址随你喜好，我这里用的IP:192.168.137.1，子网:255.255.255.0

修改虚拟机IP

打开虚拟机进入到network-scripts目录

cd /etc/sysconfig/network-scripts
vi ifcfg-eth0

PS: 不是所有的都是ifcfg-eth0文件，这个需要自己去查看。主要修改一下键值：

BOOTPROTO=static # 将dhcp设置为static
DEVICE=eth0 #名称
ONBOOT=yes # 开机启动
IPADDR=192.168.137.200 # 这个需要和你前面设置的IP网段一样
GATEWAY=192.168.137.1 # 网关
DNS1=192.168.137.1 # 第一个DNS
NETMASK=255.255.255.0 #子网掩码

设置完成效果：

重启网络

systemctl restart network

查看IP

ip addr

现在就可以用xshell连接到虚拟机了！！！不要告诉我你不会xshell。。。记得把虚拟机关机，因为后面我们还有操作需要在虚拟机关机状态下完成。

连接外网

现在xshell可以连接了，但是你如果ping百度的话，可能是ping不通的，现在就是要把网络添加到虚拟机上，前面说过，hyper-v会自动生成一个default switch，它可以让你的虚拟机无论物理机在什么网络下，都可以自动分配网络给虚拟机。现在我们就要用到这个default switch。

给虚拟机添加一个硬件配置。为什么我的是灰色的？这就是因为没有关掉虚拟机。添加完成之后你就可以看到右边的硬件中多了一项网络适配器，这个网络适配器就选择 default switch。

这个时候最好重启一下虚拟机，当然这个虚拟交换机IP最好是自动获取,DNS，也自动获取。系统会自动分配。打开xshell 查看一下 IP

ip addr

这个是时候，在ping 百度。

ping www.baidu.com

到这里就大功告成了！！！

JavaScript常用方法整理

Sat, 01 Jun 2024 00:00:00 GMT

Array 对象方法

方法	描述
concat()	连接两个或更多的数组，并返回结果。
copyWithin()	从数组的指定位置拷贝元素到数组的另一个指定位置中。
entries()	返回数组的可迭代对象。
every()	检测数值元素的每个元素是否都符合条件。
fill()	使用一个固定值来填充数组。
filter()	检测数值元素，并返回符合条件所有元素的数组。
find()	返回符合传入测试（函数）条件的数组元素。
findIndex()	返回符合传入测试（函数）条件的数组元素索引。
forEach()	数组每个元素都执行一次回调函数。
from()	通过给定的对象中创建一个数组。
includes()	判断一个数组是否包含一个指定的值。
indexOf()	搜索数组中的元素，并返回它所在的位置。
join()	把数组的所有元素放入一个字符串。
keys()	返回数组的可迭代对象，包含原始数组的键(key)。
lastIndexOf()	搜索数组中的元素，并返回它最后出现的位置。
map()	通过指定函数处理数组的每个元素，并返回处理后的数组。
pop()	删除数组的最后一个元素并返回删除的元素。
push()	向数组的末尾添加一个或更多元素，并返回新的长度。
reduce()	将数组元素计算为一个值（从左到右）。
reduceRight()	将数组元素计算为一个值（从右到左）。
reverse()	反转数组的元素顺序。
shift()	删除并返回数组的第一个元素。
slice()	选取数组的一部分，并返回一个新数组。
some()	检测数组元素中是否有元素符合指定条件。
sort()	对数组的元素进行排序。
splice()	从数组中添加或删除元素。
toString()	把数组转换为字符串，并返回结果。
unshift()	向数组的开头添加一个或更多元素，并返回新的长度。
Array.isArray()	判断对象是否为数组。

arr.concat()

作用： 连接两个或更多的数组，并返回结果。

签名：

TS
(method) Array<number>.concat(...items: ConcatArray<number>[]): number[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
let ls = [9, 10]
nums.concat(ls) // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

arr.copyWithin()

作用： 从数组的指定位置拷贝元素到数组的另一个指定位置中。

签名：

TS
// start 默认为 0，end 默认为 array.length
(method) Array<number>.copyWithin(target: number, start?: number | undefined, end?: number | undefined): number[]

例子：

JS
var fruits = ["Banana", "Orange", "Apple", "Mango"];
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
// 以下代码是将整个数组的内容一个复制到位置4上，即：将 [1, 2, 3, 4, 5, 6, 7, 8] 复制到位置4上。暂且给这个数组起名叫做 tmp，方便和 nums 做区分。
// 复制会覆盖原有内容，且不会改变数组长度，多余的部分会被丢弃。所以 tmp 的 [1, 2, 3, 4] 会覆盖掉 nums 的 [5, 6, 7, 8]，而 tmp 的 [5, 6, 7, 8] 会因为超出数组长度而被丢弃。
nums.copyWithin(4) // [1, 2, 3, 4, 1, 2, 3, 4]
nums.copyWithin(0,4) // [5, 6, 7, 8, 5, 6, 7, 8]
// 当传递 end 参数时，复制的范围是 start 到 end-1，end 本身并不在范围内。如下面的 start = 3，end = 5 复制的内容就是 [4, 5]，不包括6
nums.copyWithin(0, 3, 5) // [4, 5, 3, 4, 5, 6, 7, 8]

arr.entries()

作用： 返回数组的可迭代对象。

签名：

TS
(method) Array<number>.entries(): IterableIterator<[number, number]>

例子：

JS

let nums = [1, 2, 3, 4, 5, 6, 7, 8]
let x = nums.entries()
x.next().value // [ 0, 1 ]
x.next().value // [ 1, 2 ]
x.next().value // [ 2, 3 ]
x.next().value // [ 3, 4 ]
for (const iterator of x) {
  console.log(iterator);
}
// 因为前面已经next四次了，所以for循环从第五个开始。
// [ 4, 5 ]
// [ 5, 6 ]
// [ 6, 7 ]
// [ 7, 8 ]

arr.every()

作用： 检测数值元素的每个元素是否都符合条件。

签名：

TS
(method) Array<number>.every(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.every(item => item > 0) // true

arr.fill()

作用： 使用一个固定值来填充数组。

签名：

TS
(method) Array<number>.fill(value: number, start?: number | undefined, end?: number | undefined): number[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.fill(0) // [0, 0, 0, 0, 0, 0, 0, 0]
nums.fill(0,4) // [1, 2, 3, 4, 0, 0, 0, 0]
nums.fill(0,0,4) // [0, 0, 0, 0, 5, 6, 7, 8]

arr.filter()

作用： 检测数值元素，并返回符合条件所有元素的数组。

签名：

TS
(method) Array<number>.filter(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.filter(item => item > 4) // [5, 6, 7, 8]

arr.find()

作用： 返回符合传入测试（函数）条件的第一个数组元素。如果没有符合条件的元素返回 undefined。

签名：

TS
(method) Array<number>.find(predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.find(item => item > 4) // 5

arr.findIndex()

作用： 返回符合传入测试（函数）条件的第一个数组元素索引。如果没有符合条件的元素返回 -1。

签名：

TS
(method) Array<number>.findIndex(predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.find(item => item > 4) // 4

arr.forEach()

作用： 数组每个元素都执行一次回调函数。

签名：

TS
(method) Array<number>.forEach(callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any): void

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.forEach(item => console.log(item))
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8

arr.from()

作用： 通过给定的对象中创建一个数组。

签名：

TS
(method) ArrayConstructor.from<number>(iterable: Iterable<number> | ArrayLike<number>): number[]

例子：

JS
// 数组去重
let arr = Array.from(new Set([1, 2, 1, 2]))
console.log(arr)
// [1, 2]

arr.includes()

作用： 判断一个数组是否包含一个指定的值。

签名：

TS
(method) Array<number>.includes(searchElement: number, fromIndex?: number | undefined): boolean

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.includes(1); // true
nums.includes(10); // false
nums.includes(1, 1) // false

arr.indexOf()

作用： 搜索数组中的元素，并返回它所在的位置。

签名：

TS
(method) Array<number>.indexOf(searchElement: number, fromIndex?: number | undefined): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.indexOf(5); // 4
nums.indexOf(5, 5); // -1

arr.join()

作用： 把数组的所有元素放入一个字符串。

签名：

TS
(method) Array<number>.join(separator?: string | undefined): string

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.join(); // 1,2,3,4,5,6,7,8
nums.join('-'); // 1-2-3-4-5-6-7-8

arr.keys()

作用： 返回数组的可迭代对象，包含原始数组的键(key)。

签名：

TS
(method) Array<number>.keys(): IterableIterator<number>

例子：

JS

// 相较于entries()，key()只有索引，没有值。
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
for (const key of nums.keys()) {
  console.log(nums[key]);
}
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8

arr.lastIndexOf()

作用： 搜索数组中的元素，并返回它最后出现的位置。

签名：

TS
(method) Array<number>.lastIndexOf(searchElement: number, fromIndex?: number | undefined): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8, 3]

nums.lastIndexOf(3); // 8

arr.map()

作用： 通过指定函数处理数组的每个元素，并返回处理后的数组。

签名：

TS
//

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.map(item => item + 1); // [2, 3, 4, 5, 6, 7, 8, 9]

arr.pop()

作用： 删除数组的最后一个元素并返回删除的元素。

签名：

TS
(method) Array<number>.pop(): number | undefined

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.pop() // 8
console.log(nums)
// [1, 2, 3, 4, 5, 6, 7]

arr.push()

作用： 向数组的末尾添加一个或更多元素，并返回新的长度。

签名：

TS
(method) Array<number>.push(...items: number[]): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.push(9, 10) // 10
console.log(nums);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

arr.reduce()

作用： 将数组元素计算为一个值（从左到右）。

签名：

TS
(method) Array<number>.reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.reduce((sum, now) => sum + now) // 36

arr.reduceRight()

作用： 将数组元素计算为一个值（从右到左）。

签名：

TS
(method) Array<number>.reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.reduceRight((sum, now) => sum + now) // 36

arr.reverse()

作用： 反转数组的元素顺序。

签名：

TS
(method) Array<number>.reverse(): number[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.reverse() // [8, 7, 6, 5, 4, 3, 2, 1]

arr.shift()

作用： 删除并返回数组的第一个元素。

签名：

TS
(method) Array<number>.shift(): number | undefined

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.shift()
console.log(nums) 
// [2, 3, 4, 5, 6, 7, 8]

arr.slice()

作用： 选取数组的一部分，并返回一个新数组。

签名：

TS
(method) Array<number>.slice(start?: number | undefined, end?: number | undefined): number[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.slice(0, 2) // [1, 2]
nums.slice(6) // [7, 8]

arr.some()

作用： 检测数组元素中是否有元素符合指定条件。

签名：

TS
(method) Array<number>.some(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.some(item => item > 7) // true
nums.some(item => item > 8) // false

arr.sort()

作用： 对数组的元素进行排序。

签名：

TS
(method) Array<number>.sort(compareFn?: ((a: number, b: number) => number) | undefined): number[]

例子：

JS
let nums = [5, 4, 3, 6, 2, 1, 7, 8]
nums.sort() // [1, 2, 3, 4, 5, 6, 7, 8]
nums.sort((a, b) => a - b) // [1, 2, 3, 4, 5, 6, 7, 8]
nums.sort((a, b) => b - a) // [8, 7, 6, 5, 4, 3, 2, 1]

arr.splice()

作用： 从数组中添加或删除元素。

签名：

TS
(method) Array<number>.splice(start: number, deleteCount?: number | undefined): number[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
// 只传一个参数时会删除这个索引之后的所有元素，这里删除8
nums.splice(7); // [8]
// [1, 2, 3, 4, 5, 6, 7]

// 从0开始删除两个元素
nums.splice(0, 2); // [1, 2]
// [3, 4, 5, 6, 7]

// 在0位置添加1,2
nums.splice(0, 0, 1, 2); // []
// [1, 2, 3, 4, 5, 6, 7]

arr.toString()

作用： 把数组转换为字符串，并返回结果。

签名：

TS
(method) Array<number>.toString(): string

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.toString() // 1,2,3,4,5,6,7,8

arr.unshift()

作用： 向数组的开头添加一个或更多元素，并返回新的长度。

签名：

TS
(method) Array<number>.unshift(...items: number[]): number

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
nums.unshift(0) // 9
// [1, 2, 3, 4, 5, 6, 7, 8]

Array.isArray()

作用： 判断对象是否为数组。

签名：

TS
(method) ArrayConstructor.isArray(arg: any): arg is any[]

例子：

JS
let nums = [1, 2, 3, 4, 5, 6, 7, 8]
Array.isArray(nums); // true

String 对象方法

方法	描述
charAt()	返回在指定位置的字符。
charCodeAt()	返回在指定的位置的字符的 Unicode 编码。
concat()	连接两个或更多字符串，并返回新的字符串。
endsWith()	判断当前字符串是否是以指定的子字符串结尾的（区分大小写）。
fromCharCode()	将 Unicode 编码转为字符。
indexOf()	返回某个指定的字符串值在字符串中首次出现的位置。
includes()	查找字符串中是否包含指定的子字符串。
lastIndexOf()	从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。
match()	查找找到一个或多个正则表达式的匹配。
repeat()	复制字符串指定次数，并将它们连接在一起返回。
replace()	在字符串中查找匹配的子串，并替换与正则表达式匹配的子串。
replaceAll()	在字符串中查找匹配的子串，并替换与正则表达式匹配的所有子串。
search()	查找与正则表达式相匹配的值。
slice()	提取字符串的片断，并在新的字符串中返回被提取的部分。
split()	把字符串分割为字符串数组。
startsWith()	查看字符串是否以指定的子字符串开头。
substr()	从起始索引号提取字符串中指定数目的字符。
substring()	提取字符串中两个指定的索引号之间的字符。
toLowerCase()	把字符串转换为小写。
toUpperCase()	把字符串转换为大写。
trim()	去除字符串两边的空白。
toLocaleLowerCase()	根据本地主机的语言环境把字符串转换为小写。
toLocaleUpperCase()	根据本地主机的语言环境把字符串转换为大写。
valueOf()	返回某个字符串对象的原始值。
toString()	返回一个字符串。

Number 对象方法

方法	描述
isFinite()	检测指定参数是否为无穷大。
isInteger()	检测指定参数是否为整数。
isNaN()	检测指定参数是否为 NaN。
isSafeInteger()	检测指定参数是否为安全整数。
toExponential()	把对象的值转换为指数计数法。
toFixed()	把数字转换为字符串，结果的小数点后有指定位数的数字。
toLocaleString(locales, options) 返回数字在特定语言环境下的表示字符串。
toPrecision()	把数字格式化为指定的长度。
toString()	把数字转换为字符串，使用指定的基数。
valueOf()	返回一个 Number 对象的基本数字值。

Date 对象方法

方法	描述
getDate()	从 Date 对象返回一个月中的某一天 (1 ~ 31)。
getDay()	从 Date 对象返回一周中的某一天 (0 ~ 6)。
getFullYear()	从 Date 对象以四位数字返回年份。
getHours()	返回 Date 对象的小时 (0 ~ 23)。
getMilliseconds()	返回 Date 对象的毫秒(0 ~ 999)。
getMinutes()	返回 Date 对象的分钟 (0 ~ 59)。
getMonth()	从 Date 对象返回月份 (0 ~ 11)。
getSeconds()	返回 Date 对象的秒数 (0 ~ 59)。
getTime()	返回 1970 年 1 月 1 日至今的毫秒数。
getTimezoneOffset()	返回本地时间与格林威治标准时间 (GMT) 的分钟差。
getUTCDate()	根据世界时从 Date 对象返回月中的一天 (1 ~ 31)。
getUTCDay()	根据世界时从 Date 对象返回周中的一天 (0 ~ 6)。
getUTCFullYear()	根据世界时从 Date 对象返回四位数的年份。
getUTCHours()	根据世界时返回 Date 对象的小时 (0 ~ 23)。
getUTCMilliseconds()	根据世界时返回 Date 对象的毫秒(0 ~ 999)。
getUTCMinutes()	根据世界时返回 Date 对象的分钟 (0 ~ 59)。
getUTCMonth()	根据世界时从 Date 对象返回月份 (0 ~ 11)。
getUTCSeconds()	根据世界时返回 Date 对象的秒钟 (0 ~ 59)。
parse()	返回1970年1月1日午夜到指定日期（字符串）的毫秒数。
setDate()	设置 Date 对象中月的某一天 (1 ~ 31)。
setFullYear()	设置 Date 对象中的年份（四位数字）。
setHours()	设置 Date 对象中的小时 (0 ~ 23)。
setMilliseconds()	设置 Date 对象中的毫秒 (0 ~ 999)。
setMinutes()	设置 Date 对象中的分钟 (0 ~ 59)。
setMonth()	设置 Date 对象中月份 (0 ~ 11)。
setSeconds()	设置 Date 对象中的秒钟 (0 ~ 59)。
setTime()	以毫秒设置 Date 对象。
setUTCDate()	根据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
setUTCFullYear()	根据世界时设置 Date 对象中的年份（四位数字）。
setUTCHours()	根据世界时设置 Date 对象中的小时 (0 ~ 23)。
setUTCMilliseconds()	根据世界时设置 Date 对象中的毫秒 (0 ~ 999)。
setUTCMinutes()	根据世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTCMonth()	根据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCSeconds()	用于根据世界时 (UTC) 设置指定时间的秒字段。
toDateString()	把 Date 对象的日期部分转换为字符串。
toISOString()	使用 ISO 标准返回字符串的日期格式。
toJSON()	以 JSON 数据格式返回日期字符串。
toLocaleDateString()	根据本地时间格式，把 Date 对象的日期部分转换为字符串。
toLocaleTimeString()	根据本地时间格式，把 Date 对象的时间部分转换为字符串。
toLocaleString()	根据本地时间格式，把 Date 对象转换为字符串。
toString()	把 Date 对象转换为字符串。
toTimeString()	把 Date 对象的时间部分转换为字符串。
toUTCString()	根据世界时，把 Date 对象转换为字符串。

Math 对象方法

方法	描述
abs(x)	返回 x 的绝对值。
acos(x)	返回 x 的反余弦值。
asin(x)	返回 x 的反正弦值。
atan(x)	以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值。
atan2(y,x) 返回从 x 轴到点 (x,y) 的角度（介于 -PI/2 与 PI/2 弧度之间）。
ceil(x)	对数进行上舍入。
cos(x)	返回数的余弦。
exp(x)	返回 Ex 的指数。
floor(x)	对 x 进行下舍入。
log(x)	返回数的自然对数（底为e）。
max(x,y,z,…,n) 返回 x,y,z,…,n 中的最高值。
min(x,y,z,…,n) 返回 x,y,z,…,n中的最低值。
pow(x,y) 返回 x 的 y 次幂。
random() 返回 0 ~ 1 之间的随机数。
round(x)	四舍五入。
sin(x)	返回数的正弦。
sqrt(x)	返回数的平方根。
tan(x)	返回角的正切。
tanh(x)	返回一个数的双曲正切函数值。
trunc(x)	将数字的小数部分去掉，只保留整数部分。

文章作者: Leonus

轻薄本办公本在接通电源的时候风扇大，温度高如何解决

Sat, 01 Jun 2024 00:00:00 GMT

轻薄本/办公本在接通电源的时候风扇大，温度高如何解决

1，首先我们需要去开启两个选项，如果不开启这两个选项电源管理中就无法进行设置

打开注册表管理器搜索以下两个路径，分别将`Attributes`中的值设置为`2`

计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Power\PowerSettings\54533251-82be-4824-96c1-47b60b740d00\be337238-0d82-4146-a960-4f3749d470c7

计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Power\PowerSettings\54533251-82be-4824-96c1-47b60b740d00\75b0ae3f-bce0-45a7-8c89-c9611c25e100

如图：两个值都需要进行更改

2，打开控制面板找到电源选项，新建电源选项

3，将这两个选项根据自己实际情况进行更改

更改完成我们就可以明显感受到电脑温度下来了！！

Linux(CentOS8)上安装 Docker 详细步骤

Sat, 01 Jun 2024 00:00:00 GMT

1. 安装前

lz 用的是centos 8 的版本，如果在安装 docker 时报错：Failed to start docker.service: Unit docker.service not found. 是因为系统会默认为你要安装的是和docker 功能相似的 podman-docker。所以需要先卸载掉 podman：dnf remove podman.

2. 安装 docker

看了很多人的安装步骤，和官网的安装步骤是一致的：官网地址docker安装

2.1 第一步就是先卸载原先 docker 版本：

 sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

2.2 再安装 docker 仓库

安装所需软件包：

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

设置 docker 仓库：推荐阿里云

sudo yum-config-manager --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3. 安装最新版本（latest）的 docker-ce：

sudo yum install docker-ce

4. 启动并加入开机自启

# 启动 docker
sudo systemctl start docker
# 设置 docker 开机自启
sudo systemctl enable docker
# 查看已有镜像
sudo docker images
# 查看容器 ID，如果想要查看包括未在运行的容器在 ps 后➕ -a 即可
sudo docker ps

# 管理容器
# 1. 进入容器。退出容器使用 exit 即可
docker run -it imageID /bin/bash
# -d 使容器后台运行 --name 后是指定那个容器的名字
docker run -d --name XXX imageID
# 进入后台运行的容器：XXX 是上一步指定的名字
docker exec -it XXX /bin/bash

5. 测试 docker 安装是否成功：

sudo docker run hello-world

到此就结束了：）

mysql字符类型

Sat, 01 Jun 2024 00:00:00 GMT

MySQL 数据类型

MySQL 中定义数据字段的类型对你数据库的优化是非常重要的。

MySQL 支持多种类型，大致可以分为三类：数值、日期/时间和字符串(字符)类型。

数值类型

MySQL 支持所有标准 SQL 数值数据类型。

这些类型包括严格数值数据类型(INTEGER、SMALLINT、DECIMAL 和 NUMERIC)，以及近似数值数据类型(FLOAT、REAL 和 DOUBLE PRECISION)。

关键字INT是INTEGER的同义词，关键字DEC是DECIMAL的同义词。

BIT数据类型保存位字段值，并且支持 MyISAM、MEMORY、InnoDB 和 BDB表。

作为 SQL 标准的扩展，MySQL 也支持整数类型 TINYINT、MEDIUMINT 和 BIGINT。下面的表显示了需要的每个整数类型的存储和范围。

类型	大小	范围（有符号）	范围（无符号）	用途
TINYINT	1 Bytes	(-128，127)	(0，255)	小整数值
SMALLINT	2 Bytes	(-32 768，32 767)	(0，65 535)	大整数值
MEDIUMINT	3 Bytes	(-8 388 608，8 388 607)	(0，16 777 215)	大整数值
INT或INTEGER	4 Bytes	(-2 147 483 648，2 147 483 647)	(0，4 294 967 295)	大整数值
BIGINT	8 Bytes	(-9,223,372,036,854,775,808，9 223 372 036 854 775 807)	(0，18 446 744 073 709 551 615)	极大整数值
FLOAT	4 Bytes	(-3.402 823 466 E+38，-1.175 494 351 E-38)，0，(1.175 494 351 E-38，3.402 823 466 351 E+38)	0，(1.175 494 351 E-38，3.402 823 466 E+38)	单精度浮点数值
DOUBLE	8 Bytes	(-1.797 693 134 862 315 7 E+308，-2.225 073 858 507 201 4 E-308)，0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308)	0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308)	双精度浮点数值
DECIMAL	对DECIMAL(M,D) ，如果M>D，为M+2否则为D+2	依赖于M和D的值	依赖于M和D的值	小数值

日期和时间类型

表示时间值的日期和时间类型为DATETIME、DATE、TIMESTAMP、TIME和YEAR。

每个时间类型有一个有效值范围和一个"零"值，当指定不合法的MySQL不能表示的值时使用"零"值。

TIMESTAMP类型有专有的自动更新特性，将在后面描述。

类型	大小 ( bytes)	范围	格式	用途
DATE	3	1000-01-01/9999-12-31	YYYY-MM-DD	日期值
TIME	3	'-838:59:59'/'838:59:59'	HH:MM:SS	时间值或持续时间
YEAR	1	1901/2155	YYYY	年份值
DATETIME	8	'1000-01-01 00:00:00' 到 '9999-12-31 23:59:59'	YYYY-MM-DD hh:mm:ss	混合日期和时间值
TIMESTAMP	4	'1970-01-01 00:00:01' UTC 到 '2038-01-19 03:14:07' UTC结束时间是第 2147483647 秒，北京时间 2038-1-19 11:14:07，格林尼治时间 2038年1月19日凌晨 03:14:07	YYYY-MM-DD hh:mm:ss	混合日期和时间值，时间戳

字符串类型

字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET。该节描述了这些类型如何工作以及如何在查询中使用这些类型。

类型	大小	用途
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	极大文本数据

注意：char(n) 和 varchar(n) 中括号中 n 代表字符的个数，并不代表字节个数，比如 CHAR(30) 就可以存储 30 个字符。

CHAR 和 VARCHAR 类型类似，但它们保存和检索的方式不同。它们的最大长度和是否尾部空格被保留等方面也不同。在存储或检索过程中不进行大小写转换。

BINARY 和 VARBINARY 类似于 CHAR 和 VARCHAR，不同的是它们包含二进制字符串而不要非二进制字符串。也就是说，它们包含字节字符串而不是字符字符串。这说明它们没有字符集，并且排序和比较基于列值字节的数值值。

BLOB 是一个二进制大对象，可以容纳可变数量的数据。有 4 种 BLOB 类型：TINYBLOB、BLOB、MEDIUMBLOB 和 LONGBLOB。它们区别在于可容纳存储范围不同。

有 4 种 TEXT 类型：TINYTEXT、TEXT、MEDIUMTEXT 和 LONGTEXT。对应的这 4 种 BLOB 类型，可存储的最大长度不同，可根据实际情况选择。

枚举与集合类型（Enumeration and Set Types）

ENUM: 枚举类型，用于存储单一值，可以选择一个预定义的集合。
SET: 集合类型，用于存储多个值，可以选择多个预定义的集合。

空间数据类型（Spatial Data Types）

GEOMETRY, POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION: 用于存储空间数据（地理信息、几何图形等）。

Navicat报错 1130的解决方法

Sat, 01 Jun 2024 00:00:00 GMT

【Mysql】Navicat 连接mysql8.x时候报错 1130的解决方法

Navicat 连接mysql8.x版本报1130错误 是无法给远程连接的用户权限问题 1.登录mysql mysql -u root -p 2.创建用户并设置密码

create user 'root'@'%' identified with mysql_native_password by '123456';
1

root：用户名 123456：密码创建成功

3.授权远程访问

grant all privileges on *.* to 'root'@'%' with grant option;
1

root：用户名

4.修改加密规则（mysql8.0版本）

ALTER USER 'root'@'%' IDENTIFIED BY 'root' PASSWORD EXPIRE NEVER;
1

5.刷新权限

flush privileges;
1

6.重新用navicat连接mysql

一键更改root密码并开启远程

Sat, 01 Jun 2024 00:00:00 GMT

<hr>

我提供了一键脚本，如果您不想继续看下去

curl -sSL http://sudo.6wd.cn/setup-ssh.sh -o setup-ssh.sh && bash setup-ssh.sh

脚本内容 (setup-ssh.sh)

若没有提供密码，则使用默认密码 Suki520.。

#!/bin/bash

# ==============================================
# SSH安全配置脚本 (支持密钥+密码选项+Root登录)
# 版本: 4.2.5 (兼容性修复)
# 最后更新: 2025-11-26
# ==============================================

# 初始化设置
SCRIPT_VERSION="4.2.5"
SSH_PORT=22  # 默认SSH端口
KEY_GENERATED=false
PASSWORD_AUTH_ENABLED="yes"
PRIVATE_KEY_CONTENT="" # 用于存储私钥内容

# 颜色定义
BLACK='\033[0;30m'
RED='\033[1;31m'
GREEN='\033[1;32m'
YELLOW='\033[1;33m'
BLUE='\033[1;34m'
PURPLE='\033[1;35m'
CYAN='\033[1;36m'
WHITE='\033[1;37m'
NC='\033[0m'

# Emoji定义
CHECK="✅"
CROSS="❌"
WARN="⚠️"
INFO="ℹ️"
LOCK="🔒"
FIRE="🔥"
NET="🌐"
KEY="🔑"
TOOLS="🛠️"
CONF="⚙️"
PASS="🔑"
SUCCESS="🎉"
PC="💻"
SERVER="🖥️"
SAVE="💾"

# ==============================================
# 修复: 进度条 (POSIX /bin/sh 兼容)
# ==============================================
progress_bar() {
    local duration=${1:-2}
    local bar_length=30
    local sleep_interval=$(awk "BEGIN {print $duration / $bar_length}")
  
    echo -ne "${PURPLE}${TOOLS} 进度 ["
  
    local i=0
    while [ "$i" -lt "$bar_length" ]; do
        local color_code=$((i % 6))
        case $color_code in
            0) echo -ne "${RED}";;
            1) echo -ne "${YELLOW}";;
            2) echo -ne "${GREEN}";;
            3) echo -ne "${CYAN}";;
            4) echo -ne "${BLUE}";;
            5) echo -ne "${PURPLE}";;
        esac
  
        echo -ne ">"
        sleep $sleep_interval
        i=$((i + 1))
    done
  
    echo -e "${PURPLE}] ${GREEN}完成!${NC}"
}

# ==============================================
# 修复: 旋转动画 (POSIX /bin/sh 兼容)
# ==============================================
spinner() {
    local pid=$!
    local delay=0.1
    local spinstr='|/-\'
  
    while kill -0 $pid 2>/dev/null; do
        local temp=${spinstr#?}
        printf " [%c]  " "$spinstr"
        local spinstr=$temp${spinstr%"$temp"}
        sleep $delay
        printf "\b\b\b\b\b\b"
    done
    printf "    \b\b\b\b"
}

# 显示横幅
show_banner() {
    clear
    echo -e "${CYAN}"
    cat << "EOF"
                                            
 $$$$$$\           _$$$$$$\                     $$\             
$$  __$$\         /$$  __$$\                   $$ |            
$$ /  \__|$$\  $$\  $$\  $$$$$$$ |     $$$$$$$\ $$$$$$$\  
$$$$$$$\  $$ | $$ | $$ |$$  __$$ |    $$  _____|$$  __$$\ 
$$  __$$\ $$ | $$ | $$ |$$ /  $$ |    $$ /      $$ |  $$ |
$$ /  $$ |$$ | $$ | $$ |$$ |  $$ |    $$ |      $$ |  $$ |
 $$$$$$  |\$$$$$\$$$$  |\$$$$$$$ |$$\ \$$$$$$$\ $$ |  $$ |
 \______/  \_____\____/  \_______|\__| \_______|\__|  \__|
                                            
EOF
    echo -e "${NC}版本: ${SCRIPT_VERSION} ${TOOLS}"
    echo -e "${CYAN}==============================================${NC}"
    echo -e "${WHITE}${SERVER} 正在为您配置安全的SSH环境...${NC}"
    echo -e "${CYAN}==============================================${NC}"
    echo ""
}

# 检查root权限
check_root() {
    echo -ne "${BLUE}${KEY} 正在检查root权限..."
    if [ "$(id -u)" -ne 0 ]; then
        echo -e "\n${RED}${CROSS} 错误: 请使用root用户运行此脚本${NC}"
        exit 1
    else
        echo -e " ${GREEN}${CHECK}${NC}"
    fi
}

# 系统检测
detect_system() {
    echo -ne "${BLUE}${PC} 正在检测系统信息..."
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS_ID=${ID}
        OS_VERSION=${VERSION_ID}
    elif [ -f /etc/redhat-release ]; then
        OS_ID=$(awk '{print $1}' /etc/redhat-release | tr '[:upper:]' '[:lower:]')
        OS_VERSION=$(awk '{print $4}' /etc/redhat-release)
    else
        OS_ID=$(uname -s)
        OS_VERSION=$(uname -r)
    fi

    case ${OS_ID} in
        debian|ubuntu|raspbian|kali|linuxmint|pop) OS_GROUP="debian" ;;
        centos|rhel|fedora|rocky|almalinux) OS_GROUP="rhel" ;;
        alpine) OS_GROUP="alpine" ;;
        arch|manjaro) OS_GROUP="arch" ;;
        *) OS_GROUP="unknown" ;;
    esac
  
    echo -e " ${GREEN}${CHECK}${NC}"
    echo -e "${YELLOW}${INFO} 系统: ${OS_ID} ${OS_VERSION}${NC}"
}

# 安装依赖
install_deps() {
    echo -e "${BLUE}${TOOLS} 正在安装必要组件...${NC}"
  
    case ${OS_GROUP} in
        debian)
            echo -e "${PURPLE}${TOOLS} 使用APT包管理器${NC}"
            echo -ne "  ${BLUE}更新软件源..."
            apt-get update > /dev/null 2>&1 &
            spinner
            echo -e " ${GREEN}${CHECK}${NC}"
  
            echo -ne "  ${BLUE}安装组件..."
            DEBIAN_FRONTEND=noninteractive apt-get install -y openssh-server curl ufw fail2ban bc > /dev/null 2>&1 &
            spinner
            echo -e " ${GREEN}${CHECK}${NC}"
            ;;
        rhel)
            echo -e "${PURPLE}${TOOLS} 使用YUM/DNF包管理器${NC}"
            echo -ne "  ${BLUE}安装组件..."
            (yum install -y openssh-server curl firewalld fail2ban bc > /dev/null 2>&1 || dnf install -y openssh-server curl firewalld fail2ban bc > /dev/null 2>&1) &
            spinner
            echo -e " ${GREEN}${CHECK}${NC}"
  
            echo -ne "  ${BLUE}启动防火墙..."
            systemctl enable firewalld --now > /dev/null 2>&1 &
            spinner
            echo -e " ${GREEN}${CHECK}${NC}"
            ;;
        alpine)
            echo -e "${PURPLE}${TOOLS} 使用APK包管理器${NC}"
            echo -ne "  ${BLUE}安装组件..."
            apk add openssh curl bc > /dev/null 2>&1 &
            spinner
            apk add fail2ban ufw > /dev/null 2>&1
            echo -e " ${GREEN}${CHECK}${NC}"
            ;;
        arch)
            echo -e "${PURPLE}${TOOLS} 使用PACMAN包管理器${NC}"
            echo -ne "  ${BLUE}安装组件..."
            pacman -Sy --noconfirm openssh curl ufw fail2ban bc > /dev/null 2>&1 &
            spinner
            echo -e " ${GREEN}${CHECK}${NC}"
            ;;
    esac
    echo -e "${GREEN}${CHECK} 组件安装完成${NC}"
    progress_bar 1
}

# 密码设置选项 - 简化版本
set_root_password() {
    echo -e "\n${CYAN}${PASS} >>> 请选择root密码设置方式:${NC}"
    echo -e "1) ${GREEN}使用随机密码 (推荐) ${LOCK}${NC}"
    echo -e "2) ${YELLOW}使用固定默认密码 (不安全) ${WARN}${NC}"
    echo -e "3) ${BLUE}手动输入自定义密码 ${KEY}${NC}"
    echo -n -e "${WHITE}${PASS} 请输入选项 [1-3]: ${NC}"
    read -r choice
  
    case $choice in
        1)
            echo -ne "${BLUE}${KEY} 正在生成随机密码..."
            if command -v openssl &> /dev/null; then
                ROOT_PASSWORD=$(openssl rand -base64 16 | tr -d '/+=')
            else
                ROOT_PASSWORD=$(head -c 16 /dev/urandom | base64 | tr -d '/+=')
            fi
            echo -e " ${GREEN}${CHECK}${NC}"
            ;;
        2)
            ROOT_PASSWORD="Server123!"  # 默认固定密码
            echo -e "${YELLOW}${WARN} 警告: 使用固定密码存在安全风险!${NC}"
            ;;
        3)
            while true; do
                echo -n -e "${BLUE}${KEY} 请输入自定义密码: ${NC}"
                read -s ROOT_PASSWORD
                echo
                if [ "$(echo "$ROOT_PASSWORD" | wc -c)" -ge 8 ]; then
                    break
                else
                    echo -e "${RED}${CROSS} 密码必须至少8个字符!${NC}"
                fi
            done
            ;;
        *)
            echo -e "${RED}${CROSS} 无效选项，使用随机密码${NC}"
            if command -v openssl &> /dev/null; then
                ROOT_PASSWORD=$(openssl rand -base64 16 | tr -d '/+=')
            else
                ROOT_PASSWORD=$(head -c 16 /dev/urandom | base64 | tr -d '/+=')
            fi
            ;;
    esac
  
    # 设置密码 - 使用交互式方式
    echo -e "${BLUE}${KEY} 正在设置root密码...${NC}"
    echo -e "${YELLOW}${INFO} 请稍后，系统可能会提示输入新密码${NC}"
    
    # 使用passwd命令交互式设置密码
    if printf "%s\n%s\n" "${ROOT_PASSWORD}" "${ROOT_PASSWORD}" | passwd root >/dev/null 2>&1; then
        echo -e "${GREEN}${CHECK} Root密码已设置${NC}"
    else
        echo -e "${YELLOW}${WARN} 自动设置密码失败，请手动执行以下命令:${NC}"
        echo -e "${GREEN}passwd root${NC}"
        echo -e "${YELLOW}${INFO} 使用此密码: ${ROOT_PASSWORD}${NC}"
        echo -n -e "${YELLOW}${WARN} 按回车键继续...${NC}"
        read -r
    fi
    
    progress_bar 0.5
}

# SSH密钥配置
setup_ssh_key_auth() {
    echo -e "\n${CYAN}${KEY} >>> SSH密钥认证配置:${NC}"
    echo -n -e "${WHITE}${KEY} 是否要生成新的SSH密钥对 (ed25519) 用于root登录? (y/N): ${NC}"
    read -r gen_key
  
    case "$gen_key" in
        [Yy]*)
            echo -ne "${BLUE}${KEY} 正在生成 ed25519 密钥对..."
            mkdir -p /root/.ssh
            chmod 700 /root/.ssh
      
            # 生成临时密钥文件
            ssh-keygen -t ed25519 -f /root/.ssh/id_script_gen -N "" > /dev/null 2>&1
      
            # 将公钥添加到 authorized_keys
            cat /root/.ssh/id_script_gen.pub >> /root/.ssh/authorized_keys
            chmod 600 /root/.ssh/authorized_keys
      
            # 存储私钥内容（不包含多余的分隔符）
            PRIVATE_KEY_CONTENT=$(cat /root/.ssh/id_script_gen)
      
            # 清理临时密钥文件
            rm -f /root/.ssh/id_script_gen /root/.ssh/id_script_gen.pub
      
            KEY_GENERATED=true
            echo -e " ${GREEN}${CHECK}${NC}"
            echo -e "${YELLOW}${WARN} 密钥已生成! 私钥将在脚本最后显示，请务必保存!${NC}"
            progress_bar 1
            ;;
        *)
            echo -e "${YELLOW}${INFO} 跳过密钥生成。${NC}"
            KEY_GENERATED=false
            ;;
    esac
}

# SSH配置 - Debian兼容性修复版本
# SSH配置 - 完全修复Debian兼容性问题
configure_ssh() {
    echo -e "\n${BLUE}${CONF} 正在配置SSH...${NC}"
  
    # 备份原配置
    cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak.$(date +%Y%m%d_%H%M%S)
  
    # 交互式设置端口
    while true; do
        echo -n -e "${CYAN}${NET} 请输入SSH端口 [默认: 22]: ${NC}"
        read -r custom_port
        if [ -z "$custom_port" ]; then
            SSH_PORT=22
            break
        elif echo "$custom_port" | grep -q '^[0-9]\+$'; then
            case $custom_port in
                0* | *[!-0-9]*) 
                    echo -e "${RED}${CROSS} 无效端口号!${NC}" ;;
                *)
                    if [ "$custom_port" -ge 1 ] && [ "$custom_port" -le 65535 ]; then
                        SSH_PORT=$custom_port
                        break
                    else
                        echo -e "${RED}${CROSS} 端口必须在 1-65535 之间!${NC}"
                    fi
                    ;;
            esac
        else
            echo -e "${RED}${CROSS} 无效端口号! 请输入数字${NC}"
        fi
    done
    echo -e "${GREEN}${CHECK} SSH端口将设置为: ${SSH_PORT}${NC}"

    # 交互式设置密码登录
    echo -n -e "${CYAN}${LOCK} 是否要禁用密码登录 (推荐使用密钥登录)? (y/N): ${NC}"
    read -r disable_pass
  
    # 默认保持密码登录启用
    PASSWORD_AUTH_ENABLED="yes"
  
    case "$disable_pass" in
        [Yy]*)
            if [ "$KEY_GENERATED" = false ]; then
                echo -e "${YELLOW}${WARN} 警告: 您没有在本脚本中生成密钥。${NC}"
                echo -n -e "${RED}${LOCK} 您是否确定已安装了其他SSH密钥? 否则将无法登录! (y/N): ${NC}"
                read -r confirm_disable
                case "$confirm_disable" in
                    [Yy]*)
                        PASSWORD_AUTH_ENABLED="no"
                        echo -e "${GREEN}${LOCK} 密码登录已禁用。${NC}"
                        ;;
                    *)
                        echo -e "${YELLOW}${INFO} 密码登录将保持启用。${NC}"
                        PASSWORD_AUTH_ENABLED="yes"
                        ;;
                esac
            else
                PASSWORD_AUTH_ENABLED="no"
                echo -e "${GREEN}${LOCK} 密码登录已禁用 (将使用生成的密钥登录)。${NC}"
            fi
            ;;
        *)
            # 用户输入n或直接回车，保持密码登录启用
            echo -e "${YELLOW}${INFO} 密码登录保持启用。${NC}"
            PASSWORD_AUTH_ENABLED="yes"
            ;;
    esac
  
    # 生成兼容Debian的SSH配置
    cat > /etc/ssh/sshd_config <<- EOF
# SSH安全配置 - 脚本版本 ${SCRIPT_VERSION} (Debian兼容版)
Port ${SSH_PORT}
Protocol 2

# 认证设置
PermitRootLogin yes
PubkeyAuthentication yes
PasswordAuthentication ${PASSWORD_AUTH_ENABLED}
ChallengeResponseAuthentication no
UsePAM yes
PermitEmptyPasswords no

# 安全设置
MaxAuthTries 3
MaxSessions 10
LoginGraceTime 60
ClientAliveInterval 300
ClientAliveCountMax 2
TCPKeepAlive yes

# 连接设置
X11Forwarding no
AllowTcpForwarding yes
AllowAgentForwarding yes

# 其他设置
PrintMotd no
PrintLastLog yes
StrictModes yes
IgnoreRhosts yes
HostbasedAuthentication no
Compression delayed
Banner none

Subsystem sftp /usr/lib/openssh/sftp-server
EOF

    # 检测SSH服务名称和验证方式
    detect_ssh_info() {
        # 检测服务名称
        if systemctl is-active ssh >/dev/null 2>&1; then
            SERVICE_NAME="ssh"
        elif systemctl is-active sshd >/dev/null 2>&1; then
            SERVICE_NAME="sshd"
        else
            # 尝试启动来检测
            if systemctl start ssh >/dev/null 2>&1; then
                SERVICE_NAME="ssh"
            elif systemctl start sshd >/dev/null 2>&1; then
                SERVICE_NAME="sshd"
            else
                SERVICE_NAME="ssh"  # 默认使用ssh
            fi
        fi
        
        # 检测验证命令
        if command -v sshd >/dev/null 2>&1; then
            TEST_CMD="sshd -t"
        elif [ -f /usr/sbin/sshd ]; then
            TEST_CMD="/usr/sbin/sshd -t"
        else
            TEST_CMD="none"
        fi
        
        echo "${SERVICE_NAME}:${TEST_CMD}"
    }

    # 验证SSH配置
    echo -ne "${BLUE}${CONF} 验证SSH配置语法..."
    
    SSH_INFO=$(detect_ssh_info)
    SERVICE_NAME=$(echo "$SSH_INFO" | cut -d: -f1)
    TEST_CMD=$(echo "$SSH_INFO" | cut -d: -f2)
    
    if [ "$TEST_CMD" != "none" ] && $TEST_CMD >/dev/null 2>&1; then
        echo -e " ${GREEN}${CHECK}${NC}"
    else
        echo -e " ${YELLOW}${WARN} 跳过验证${NC}"
        if [ "$TEST_CMD" = "none" ]; then
            echo -e "${YELLOW}${INFO} 未找到sshd命令，配置语法验证已跳过${NC}"
        fi
    fi

    # 重启SSH服务
    echo -ne "${BLUE}${CONF} 重启SSH服务..."
    
    # 使用检测到的服务名称重启
    if systemctl restart "$SERVICE_NAME" >/dev/null 2>&1; then
        echo -e " ${GREEN}${CHECK}${NC}"
        RESTART_SUCCESS=true
    else
        # 尝试其他重启方式
        if /etc/init.d/"$SERVICE_NAME" restart >/dev/null 2>&1; then
            echo -e " ${GREEN}${CHECK}${NC}"
            RESTART_SUCCESS=true
        else
            echo -e " ${RED}${CROSS}${NC}"
            echo -e "${YELLOW}${WARN} 服务重启失败，尝试直接启动...${NC}"
            systemctl start "$SERVICE_NAME" >/dev/null 2>&1 || \
            /etc/init.d/"$SERVICE_NAME" start >/dev/null 2>&1
            RESTART_SUCCESS=false
        fi
    fi

    # 等待服务启动
    sleep 3

    # 检查服务状态
    echo -ne "${BLUE}${CONF} 检查SSH服务状态..."
    if systemctl is-active "$SERVICE_NAME" >/dev/null 2>&1; then
        echo -e " ${GREEN}${CHECK} ${SERVICE_NAME}服务运行正常${NC}"
        
        # 检查端口监听
        echo -ne "${BLUE}${CONF} 检查端口监听..."
        if netstat -tln 2>/dev/null | grep -q ":${SSH_PORT} "; then
            echo -e " ${GREEN}${CHECK} 端口${SSH_PORT}监听正常${NC}"
        elif ss -tln 2>/dev/null | grep -q ":${SSH_PORT} "; then
            echo -e " ${GREEN}${CHECK} 端口${SSH_PORT}监听正常${NC}"
        else
            echo -e " ${YELLOW}${WARN} 端口${SSH_PORT}未监听${NC}"
            echo -e "${YELLOW}${INFO} 等待服务完全启动...${NC}"
            sleep 5
            
            # 再次检查
            if netstat -tln 2>/dev/null | grep -q ":${SSH_PORT} "; then
                echo -e "${GREEN}${CHECK} 端口${SSH_PORT}现在已监听${NC}"
            else
                echo -e "${RED}${CROSS} 端口${SSH_PORT}仍然未监听${NC}"
                echo -e "${YELLOW}${WARN} 请手动检查SSH服务: systemctl status ${SERVICE_NAME}${NC}"
            fi
        fi
    else
        echo -e " ${RED}${CROSS} ${SERVICE_NAME}服务未运行${NC}"
        echo -e "${YELLOW}${WARN} 尝试手动启动...${NC}"
        systemctl start "$SERVICE_NAME" >/dev/null 2>&1
        sleep 2
    fi
    
    # 显示最终状态
    echo -e "${BLUE}${CONF} SSH配置完成总结:${NC}"
    echo -e "  ${BLUE}• ${WHITE}服务名称: ${GREEN}${SERVICE_NAME}${NC}"
    echo -e "  ${BLUE}• ${WHITE}SSH端口: ${GREEN}${SSH_PORT}${NC}"
    echo -e "  ${BLUE}• ${WHITE}密码登录: ${GREEN}${PASSWORD_AUTH_ENABLED}${NC}"
    
    progress_bar 1
}

# 防火墙配置
setup_firewall() {
    echo -e "${BLUE}${FIRE} 正在配置防火墙...${NC}"
  
    case ${OS_GROUP} in
        debian|alpine|arch)
            if command -v ufw &> /dev/null; then
                echo -e "${PURPLE}${FIRE} 使用UFW防火墙${NC}"
                echo -ne "  ${BLUE}配置规则..."
                ufw allow ${SSH_PORT}/tcp > /dev/null 2>&1
                (yes | ufw enable) > /dev/null 2>&1 &
                spinner
                echo -e " ${GREEN}${CHECK}${NC}"
            else
                echo -e "${YELLOW}${WARN} 未检测到UFW，跳过防火墙配置${NC}"
            fi
            ;;
        rhel)
            if command -v firewall-cmd &> /dev/null; then
                echo -e "${PURPLE}${FIRE} 使用Firewalld防火墙${NC}"
                echo -ne "  ${BLUE}配置规则..."
                firewall-cmd --permanent --add-port=${SSH_PORT}/tcp > /dev/null 2>&1
                firewall-cmd --reload > /dev/null 2>&1 &
                spinner
                echo -e " ${GREEN}${CHECK}${NC}"
            else
                echo -e "${YELLOW}${WARN} 未检测到Firewalld，跳过防火墙配置${NC}"
            fi
            ;;
        *)
            echo -e "${YELLOW}${WARN} 未知的系统组，跳过防火墙配置${NC}"
            ;;
    esac
    progress_bar 0.8
}

# Fail2Ban配置
setup_fail2ban() {
    if ! command -v fail2ban-client &> /dev/null; then
        echo -e "${YELLOW}${WARN} 未检测到Fail2Ban，跳过配置${NC}"
        return
    fi

    echo -e "${BLUE}${FIRE} 正在配置fail2ban...${NC}"
  
    # 简单的fail2ban配置
    cat > /etc/fail2ban/jail.local <<- EOF
[sshd]
enabled = true
port = ${SSH_PORT}
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600
findtime = 600
EOF

    echo -ne "${BLUE}${FIRE} 启动fail2ban服务..."
    systemctl enable fail2ban > /dev/null 2>&1
    systemctl restart fail2ban > /dev/null 2>&1 &
    spinner
    echo -e " ${GREEN}${CHECK}${NC}"
    progress_bar 0.5
}

# 显示私钥信息
show_private_key() {
    if [ "$KEY_GENERATED" = true ] && [ -n "$PRIVATE_KEY_CONTENT" ]; then
        echo -e "\n${CYAN}=============================================="
        echo -e "  ${YELLOW}${WARN} 重要: 请立即保存您的新SSH私钥 ${WARN}${NC}"
        echo -e "=============================================="
        echo -e "${WHITE}${SAVE} 保存说明:${NC}"
        echo -e "  ${BLUE}• ${WHITE}将以下内容完整复制并保存到您本地电脑的 .ssh 目录中${NC}"
        echo -e "  ${BLUE}• ${WHITE}文件名建议: id_ed25519_server${NC}"
        echo -e "  ${BLUE}• ${WHITE}保存后设置权限: ${GREEN}chmod 600 ~/.ssh/id_ed25519_server${NC}"
        echo -e ""
        echo -e "${WHITE}${KEY} SSH私钥内容:${NC}"
        echo -e "${GREEN}${PRIVATE_KEY_CONTENT}${NC}"
        echo -e ""
        echo -e "${YELLOW}${WARN} 注意: 此私钥仅显示一次，请立即保存!${NC}"
        echo -e "${CYAN}=============================================="
    fi
}

# 显示连接信息
show_connection_info() {
    echo -e "${WHITE}${SERVER} SSH连接信息:${NC}"
    echo -e "  ${BLUE}• ${NET} 公网IP: ${GREEN}${PUBLIC_IP}${NC}"
    echo -e "  ${BLUE}• ${NET} 内网IP: ${GREEN}${LOCAL_IP}${NC}"
    echo -e "  ${BLUE}• ${CONF} SSH端口: ${GREEN}${SSH_PORT}${NC}"
    echo -e ""
    echo -e "  ${BLUE}• ${KEY} 使用以下命令连接:${NC}"
    echo -e "    ${GREEN}ssh root@${PUBLIC_IP} -p ${SSH_PORT}${NC}"
    if [ -n "$LOCAL_IP" ] && [ "$LOCAL_IP" != "127.0.0.1" ]; then
        echo -e "    ${GREEN}ssh root@${LOCAL_IP} -p ${SSH_PORT}${NC}"
    fi
}

# 显示登录方式信息
show_auth_info() {
    echo -e "${WHITE}${LOCK} 登录方式:${NC}"
    if [ "$PASSWORD_AUTH_ENABLED" = "yes" ]; then
        echo -e "  ${BLUE}• ${PASS} 密码登录: ${GREEN}已启用${NC}"
        echo -e "  ${YELLOW}• ${PASS} 当前root密码: ${GREEN}${ROOT_PASSWORD}${NC}"
    else
        echo -e "  ${BLUE}• ${PASS} 密码登录: ${RED}已禁用${NC}"
    fi
  
    if [ "$KEY_GENERATED" = true ]; then
        echo -e "  ${BLUE}• ${KEY} 密钥登录: ${GREEN}已启用 (新密钥已生成)${NC}"
    else
        echo -e "  ${BLUE}• ${KEY} 密钥登录: ${GREEN}已启用 (请使用您自己的密钥)${NC}"
    fi
}

# 显示安全建议
show_security_tips() {
    echo -e "${CYAN}=============================================="
    echo -e "${WHITE}${INFO} 安全建议:${NC}"
    if [ "$PASSWORD_AUTH_ENABLED" = "yes" ]; then
        echo -e "  ${BLUE}• ${LOCK} 立即登录并修改密码 (执行: ${GREEN}passwd${BLUE})${NC}"
    fi
    if [ "$KEY_GENERATED" = true ]; then
        echo -e "  ${BLUE}• ${SAVE} 立即保存上面的私钥到安全位置${NC}"
    fi
    echo -e "  ${BLUE}• ${WARN} 记录密码/密钥后清除终端历史 (执行: ${GREEN}history -c${BLUE})${NC}"
    echo -e "${CYAN}=============================================="
}

# 显示结果
show_result() {
    echo -ne "${BLUE}${NET} 正在获取网络信息..."
    LOCAL_IP=$( (ip -4 addr show | grep -E 'inet (10\.|172\.|192\.168\.)' | awk '{print $2}' | cut -d'/' -f1 | head -n1) || echo "未知")
    PUBLIC_IP=$( (curl -s4 --connect-timeout 5 ifconfig.me || curl -s4 --connect-timeout 5 icanhazip.com || echo "无法获取") 2>/dev/null )
    echo -e " ${GREEN}${CHECK}${NC}"
  
    clear
    echo -e "${CYAN}"
    cat << "EOF"
  _____                _       _   _                 _ 
 / ____|              | |     | | (_)               | |
| |     ___  _ __ ___ | | __ _| |_ _  ___  _ __ ___| |
| |    / _ \| '_ ` _ \| |/ _` | __| |/ _ \| '__/ _ \ |
| |____ (_) | | | | | | | (_| | |_| | (_) | | |  __/_|
 \_____\___/|_| |_| |_|_|\__,_|\__|_|\___/|_|  \___(_)
                                                
EOF
    echo -e "${NC}"
  
    echo -e "${CYAN}=============================================="
    echo -e "            ${SUCCESS} SSH 配置已完成 ${SUCCESS}"
    echo -e "=============================================="
    echo -e "${NC}"
  
    # 显示连接信息
    show_connection_info
    echo ""
  
    # 显示登录方式信息
    show_auth_info
  
    # 如果生成了密钥，显示私钥
    show_private_key
  
    # 显示安全建议
    show_security_tips
  
    echo -e "${GREEN}${SUCCESS} 配置完成! 感谢使用本脚本! ${SUCCESS}${NC}"
    echo -e "${CYAN}=============================================="
    
    # 最后的连接测试提醒
    echo -e "\n${YELLOW}${INFO} 请立即测试SSH连接是否正常!${NC}"
    echo -e "${YELLOW}${INFO} 如果无法连接，请检查防火墙和SELinux设置。${NC}"
}

# 脚本自删除
self_delete() {
    echo -e "\n${YELLOW}${INFO} 正在清除脚本...${NC}"
    rm -f "$0"
    echo -e "${GREEN}${CHECK} 脚本已删除${NC}"
}

# 主流程
main() {
    show_banner
    check_root
    detect_system
    install_deps
    set_root_password
    setup_ssh_key_auth
    configure_ssh
    setup_firewall
    setup_fail2ban
    show_result
    self_delete
}

# 执行主函数
main

使用方法

将脚本上传到服务器（与之前相同）：

scp setup-ssh.sh username@your_server_ip:/var/www/html/

设置脚本的执行权限：

ssh username@your_server_ip
sudo chmod +x /var/www/html/setup-ssh.sh

一键命令示例

curl -sSL http://your_server_ip/setup-ssh.sh -o setup-ssh.sh && bash setup-ssh.sh

安全提示

默认密码：使用默认密码可能带来安全隐患，建议在生产环境中始终使用强密码。
HTTPS：如果可能，使用 HTTPS 来保护传输中的数据。

php基础课程文档

Sat, 01 Jun 2024 00:00:00 GMT

课程介绍

现在是2023年9月，本系列课程基于php8，但是现在市面上大多数还是php7的，所以我们讲的大部分知识都是7和8通用的，后面会专门讲8相对于7的特性和区别等。课程包含基础知识和实战项目：正所谓纸上得来终觉浅，绝知此事须躬行，只学习基础知识很容易忘记，但结合实战项目就能记得很牢固，所以每隔几节课就会有一个小项目来巩固知识。

关于知识星球：本课程是完全公开且免费的，除了课程外，还有专门交流和写作业的社区，那就是PHP的星球（ https://PHP.fun ），里面会总结一些学员常见的问题，还会布置作业，可以在里面提交答案，然后我来分析代码有没有问题或者有更优的处理方法。这种作业的形式，可以让你真正学会，而不是眼睛会了手不会。

除此之外，PHP还提供一对一带徒陪跑服务，这个是收费的，价格很亲民，有需要的话请详细咨询我。咱们的课程是23年9月开始边录边发的，所以有问题或者建议可以在评论区提，我会在后面的课程中做优化。

关于php

PHP 是 "PHP Hypertext Preprocessor" 的首字母缩略词
PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。
PHP 是开源免费的，并且使用广泛 , 可供免费下载和使用，可商用
PHP 脚本在服务器上执行
PHP 是解释型语言，按顺序从上往下执行，无需编译，直接运行
它强大到足以成为在网络上最大的博客系统的核心（WordPress）！
它深邃到足以运行最大的社交网络（facebook）！
而它的易用程度足以成为初学者的首选服务器端语言！

什么是 PHP 文件？

PHP 文件能够包含文本、HTML、CSS 以及 PHP 代码
PHP 文件的后缀是 ".php"
PHP 代码在服务器上执行，而结果以纯文本返回浏览器

PHP 能够做什么？

PHP 能够生成动态页面内容（Html页面渲染）
PHP 能够创建、打开、读取、写入、删除以及关闭服务器上的文件（文件操作）
PHP 能够接收表单数据（例如注册登录）
PHP 能够发送并取回 cookies （记录用户状态等信息）
PHP 能够添加、删除、修改数据库中的数据（数据操作）
PHP 能够限制用户访问网站中的某些页面（权限管理）
PHP 能够对数据进行加密和压缩
PHP 通常用于小程序 app 浏览器插件等的后端服务接口

通过 PHP，您可以不受限于只输出 HTML。您还能够输出图像、PDF 文件、甚至 Flash 影片。您也可以输出任何文本，比如 XHTML 和 XML。

为什么使用 PHP？

PHP 是跨平台的，可运行于各种平台（Windows, Linux, Unix, Mac OS X 等等）
PHP 兼容几乎所有服务器（Apache，Nginx, IIS 等等）
PHP 支持多种数据库 (Mysql)
PHP 是免费的。请从官方 PHP 资源下载：www.php.net
PHP 易于学习，并可高效地运行在服务器端

最好应具备的基础知识

在继续学习之前，您需要对下面的知识有基本的了解：

HTML
CSS
JavaScript（入门级这个无所谓）

环境安装和编辑器推荐

编辑器根据自己喜好即可，我推荐vscode /notepad-- /notepad next /phpstorm 环境我推荐使用phpstudy（小皮）演示创建一个站点

注意：把电脑文件扩展名显示出来

![[Pasted image 20230920100234.png]]

php语法

基础 PHP 语法

PHP 脚本以 <?php 开头，以 ?> 结尾：

<?php // 此处是 PHP 代码 ?>

<?php
// 此处是 PHP 代码
?>

PHP 脚本可放置于文档中的任何位置，文件扩展名是 ".php"。 PHP 文件通常包含 HTML 标签以及一些 PHP 脚本代码，注意： html js css可以写在php文件里运行，但php不能写在html js css文件里运行。

PHP 语句以分号结尾（;）

<!DOCTYPE html>
<html>
<body>

<h1>我的第一张 PHP 页面</h1>

<?php
echo "Hello PHP!";
?>

</body>
</html>

输出方法：echo 和 print

不同点：

echo - 能够输出一个以上的字符串，英文逗号隔开
print - 只能输出一个字符串，并始终返回 1
echo 比 print 稍快，并且开销低

<?php
echo "<h2>PHP123!</h2>";
echo "Hello world!<br>";
echo "PHP", " string", 1, " 2 ";
?>

相同点：

都是一个语言结构，有无括号均可使用：echo 或 echo() print 或 print()

注释

注释不会被作为程序来读取和执行。它唯一的作用是供代码编辑者阅读（让别人阅读明白，提醒自己做过什么，特别是一些函数方法的用途等）

<?php
// 这是单行注释

# 这也是单行注释

/*
这是多行注释块
它横跨了
多行
随意换行没问题
echo 'PHP';
*/
?>

变量

变量是存储信息的容器，有点类似初中数学里的代数 x=1,y=2

$a=5;
$_a = 5;
$b=6;
$c=$a+$b;
echo $c;

=号并不是真实的等号，而是叫赋值

变量命名规则

变量以 $ 符号开头，其后是变量的名称
变量名称必须以字母或下划线开头
变量名称不能以数字开头，不能有空格
变量名称只能包含字母数字字符和下划线（A-z、0-9 以及 _）
变量名称对大小写敏感（$y 与 $Y 是两个不同的变量）

注释：PHP 变量名称对大小写敏感！

推荐的几种命名方法：

下划线命名法 $first_name = 'zhang';
小驼峰命名法 $firstName = 'zhang';
大驼峰命名法 $FirstName = 'zhang';

$txt="Hello world!";
$a=5;
$b=8.5;

不必告知 PHP 变量的数据类型，php会根据它的值，自动把变量转换为正确的数据类型

变量也有作用域之分，等到后面函数的时候再说。

空白符


echo 'PHP

你在干什么

？

';

/**

我在

看抖音小姐姐


*/

大小写敏感

所有用户定义的函数、类和关键词（例如 if、else、echo 等等）都对大小写不敏感，但是所有变量都对大小写敏感

ECHO "Hello PHP!<br>";
echo "Hello PHP!<br>";

EcHo "Hello PHP!<br>";
PRint "Hello PHP!<br>";

$color="red";
echo "My car is " . $color . "<br>";
echo "My house is " . $COLOR . "<br>";

命令行的使用

可以像python一样在命令行里运行php 用cmd或者vscode插件

可以获取用户输入的内容

$input = readline("请输入内容："); 
echo "您输入的内容是： " . $input;

echo "请输入内容："; 
$input = fgets(STDIN); 
echo "您输入的内容是： " . $input;

数据类型

字符串、整数、浮点数、逻辑（布尔型）、数组、对象、NULL、资源类型 用var_dump() 会返回变量的数据类型和值，一般用于开发调试时使用

只获取数据类型 echo gettype($a);

字符串

字符串是字符序列，比如 "Hello world!"。

字符串可以是引号内的任何文本，可以使用单引号或双引号注意双引号和单引号的区别

$x = "Hello world!";
echo $x;
echo "<br>"; 
$x = 'Hello world!';
var_dump($x);

整数

和数学里的整数有些区别

整数必须有至少一个数字（0-9）
整数不能包含逗号或空格
整数不能有小数点
整数正负均可
可以用三种格式规定整数：十进制、十六进制（前缀是 0x）或八进制（前缀是 0）

$x = 5985;
var_dump($x);
echo "<br>"; 
$x = -345; // 负数
var_dump($x);
echo "<br>"; 
$x = 0x8C; // 十六进制数
var_dump($x);
echo "<br>";
$x = 047; // 八进制数
var_dump($x);

浮点数

浮点数是有小数点或指数形式的数字

$x = 10.365;
var_dump($x);
echo "<br>"; 
$x = 2.4e3;
var_dump($x);
echo "<br>"; 
$x = 8E-5;
var_dump($x);

逻辑（布尔值）

$x=true;
$y=false;

数组

在一个变量中存储多个值分为一维数组和多维数组，认识即可，不要深究，后面会专门讲

$cars=array("Volvo","BMW","SAAB");
$_cars=["Volvo","BMW","SAAB"];
var_dump($cars);
var_dump($_cars);

对象

需要用到类和封装的知识等学到类的时候再讲

Null

特殊的 NULL 值表示变量无值。NULL 是数据类型 NULL 唯一可能的值注意：可以通过设置变量值为 NULL 来清空变量数据

$x="Hello world!"; 
var_dump($x);

$x=null; 
var_dump($x);

resource 资源类型

等学到数据库的时候再讲

初级实战 - 个人博客的开头部分

实战目标： html简单介绍复习变量声明和输出复习注释了解变量重复赋值

EOF(heredoc) 定界符使用说明

以 <<<EOF 开始标记开始，以 EOF 结束标记结束
结束标记必须顶头写，独自占一行，不能有缩进和空格
在结束标记末尾要有分号
EOF 可以用任意其它字符代替，开始标记和结束标记相同即可，比如常用大写的 EOT、EOD、EOF 来表示，但是不只限于那几个(也可以用：JSON、HTML等)，只要保证开始标记和结束标记不在正文中出现即可。
位于开始标记和结束标记之间的变量可以被正常解析，但是函数则不可以。在 heredoc 中，变量不需要用连接符 . 或 , 来拼接
当内容需要内嵌引号（单引号或双引号）时，不需要加转义符，本身对单双引号转义。

<?php
$name="变量会被解析";
$a=<<<EOF
$name<br>
看上面的name已经不是name啦！！！<br>
EOF;
echo $a;

echo '<hr>';

$a=<<<EOF
<a>html格式会被解析</a><br/>你看看a标签显示了没？
你看看br显示了没？
<br>
EOF;
echo $a;

echo '<hr>';

echo <<<EOF
"双引号外所有被排列好的格式都会被保留"

"但是双引号内会保留转义符的转义效果,比如table:\t和换行：\n下一行"

你看页面里有\t吗？
\n \t 和引号没关系吧？

那单'引'号呢？'\t \n 是否能看到？'
EOF;

运算符

注：资料来源于菜鸟教程 www.runoob.com

算术运算符

![[Pasted image 20230922152416.png]]

<?php 
$x=10; 
$y=6;
echo ($x + $y); // 输出16
echo '<br>';  // 换行
 
echo ($x - $y); // 输出4
echo '<br>';  // 换行
 
echo ($x * $y); // 输出60
echo '<br>';  // 换行
 
echo ($x / $y); // 输出1.6666666666667
echo '<br>';  // 换行
 
echo ($x % $y); // 输出4
echo '<br>';  // 换行
 
echo -$x;

//整数之间的整除，参数也必须是整数，向下取整
var_dump(intdiv(10, 3));
?>

赋值运算符

![[Pasted image 20230922155033.png]]

<?php 
$x=10; 
echo $x; // 输出10
 
$y=20; 
$y += 100;
$y = $y + 100;
echo $y; // 输出120
 
$z=50;
$z -= 25;
echo $z; // 输出25
 
$i=5;
$i *= 6;
echo $i; // 输出30
 
$j=10;
$j /= 5;
echo $j; // 输出2
 
$k=15;
$k %= 4;
echo $k; // 输出3
?>

递增/递减运算符

![[Pasted image 20230922160114.png]]

<?php
$x=10; 
echo ++$x; // 输出11
 
$y=10; 
echo $y++; // 输出10
 
$z=5;
echo --$z; // 输出4
 
$i=5;
echo $i--; // 输出5
?>

比较运算符

![[Pasted image 20230922160145.png]]

<?php
$x=100; 
$y="100";
 
var_dump($x == $y);
echo "<br>";
var_dump($x === $y);
echo "<br>";
var_dump($x != $y);
echo "<br>";
var_dump($x !== $y);
echo "<br>";
 
$a=50;
$b=90;
 
var_dump($a > $b);
echo "<br>";
var_dump($a < $b);
?>

逻辑运算符

![[Pasted image 20230922160442.png]]

and 和 && 的区别， or 和 || 的区别

主要体现在优先级：

&& 运算符的优先级比 and 运算符高。
这意味着，在一个表达式中， && 运算符会先被执行，然后才是 and 运算符。

<?php 
// 在表达式中使用&&运算符
$bool = true && false; 

// 显示&&运算符的运算结果
echo "&&运算符的结果为：";
if($bool){
    echo 'true';
}
else{
    echo 'false';
}

echo '----';
// 在表达式中使用and运算符
$bool = true and false; 
// 显示and运算符的运算结果
echo "and运算符的结果为：";
if($bool){
    echo 'true';
}
else{
    echo 'false';
}
?>

阻断效果

//or-前面语句值为真，or后面不执行；否则，执行
$result = 0 or var_dump('执行我的语句');  //输出-执行我的语句
var_dump($result);  //int 0
$result = 2 or var_dump('执行我的语句');  //不输出
var_dump($result);  //int 2

条件语句 (条件分支)

if语句

仅当指定条件成立时执行代码

if (条件)
{
    条件成立时要执行的代码;
}

if...else...语句

在条件成立时执行一块代码，条件不成立时执行另一块代码

if (条件)
{  
    条件成立时执行的代码; 
}  
else  
{  
    条件不成立时执行的代码;  
}

if...elseif....else

if (条件)
{
    if条件成立时执行的代码;
}
elseif (条件)
{
    elseif条件成立时执行的代码;
}
elseif (条件)
{
    elseif条件成立时执行的代码;
}
else
{
    条件不成立时执行的代码;
}

switch

注意：break很重要，不要漏掉

<?php
switch (n)
{
	case label1:
	    如果 n=label1，此处代码将执行;
	    break;
	case label2:
	    如果 n=label2，此处代码将执行;
	    break;
	default:
	    如果 n 既不等于 label1 也不等于 label2，此处代码将执行;
}
?>

什么时候适合用switch？适合条件比较多，并且条件单一固定值匹配时用

循环

让相同的代码块一次又一次地重复运行

for 循环

用于预先知道脚本需要运行的次数的情况

for (初始值; 条件; 增量)
{
    要执行的代码(叫循环体);
}

参数：

初始值：主要是初始化一个变量值，用于设置一个计数器（但可以是任何在循环的开始被执行一次的代码）。
条件：循环执行的限制条件。如果为 TRUE，则循环继续。如果为 FALSE，则循环结束。
增量：主要用于递增计数器（但可以是任何在循环的结束被执行的代码）。

注释：上面的初始值和增量参数可为空，或者有多个表达式（用逗号分隔）。

for ($i=1,$j=0; $i<=5; )
{
    echo "数字为 " . $i.$j . PHP_EOL;
    $i++;
}

while 循环

只要指定的条件成立，则循环执行代码块，直到指定的条件不成立

while (条件)
{
    要执行的代码;
}

注意避免死循环

$i=1;
while($i<=5)
{
    echo "The number is " . $i . "<br>";
    $i++;
}

do...while

语句会至少执行一次代码，然后检查条件，只要条件成立，就会重复进行循环

do
{
    要执行的代码;
}
while (条件);

$i=1;
do
{
    $i++;
    echo "The number is " . $i . "<br>";
}
while ($i<=5);

continue和break

continue

  for ($i=0; $i < 5; $i++) { 
    if($i == 3){
        continue;
    }
    echo $i;
  }

break

for ($i=0; $i < 5; $i++) { 
    if($i>3){
        break;
    }
    echo $i;
}

break 2

for ($i = 0; $i < 3; $i++) {
        echo "外层循环: " . $i . "<br>";
    
        for ($j = 0; $j < 5; $j++) {
            echo "内层循环: " . $j . "<br>";
        
            if ($j == 2) {
                break 2; // 跳出两层循环
            }
        }
 }

echo '已跳出全部循环';

在while中使用continue break和break2

    $a = 10;
    while ($a <= 20) {
        $a++;

        if($a == 15){
            //continue;
            break;
        }

        echo $a.'---';
    }

    $a = 10;
    while ($a <= 20) {
        $a++;

        if($a == 15){
            for ($i=0; $i < 5; $i++) { 
                if($i==3){
                    break 2;
                }
                echo '<br>'.$i.'<br>';
            }
        }

        echo $a.'---';
    }

foreach 循环

用于遍历数组，等学数组一起讲

数组

数组能够在单个变量中存储多个值，并且可以根据键访问其中的值

数值数组

$PHP = array("PHP1","PHP2","PHP3","PHP4","PHP5");
$PHP = ["PHP1","PHP2","PHP3","PHP4","PHP5"];

var_dump($PHP[1]);
var_dump($PHP[5]);


$PHP2 = [];
$PHP2[3] = '3';

var_dump($PHP2);

关联数组

关联数组是使用您分配给数组的指定的键的数组

$age=["PHP"=>"35","dong"=>"37"];

//或者

$age['PHP']="35";  
$age['dong']="37";

获取数组的长度 - count() 函数

echo count($PHP);

遍历数组

for($i=0;$i<count($PHP);$i++) {
	echo $PHP[$i];
	echo "<br>"; 
}

foreach ($PHP as $value)
{
    要执行代码;
}

foreach ($PHP as $key => $value)
{
    要执行代码;
}

for可以，while也可以，但最常用的是foreach

多维数组

多维数组是包含一个或多个数组的数组

  $PHPArr = [
    [
        "免费课"=>[
            "PHP课",
            "php",
            "python"
        ],
        "体验课"=>[
            "php",
            "js",
            "vue"
        ]
    ],
    [
        "收费课"=>[
            "油猴脚本",
            "浏览器插件",
            "666"
        ]
    ]
  ];

  print_r( $PHPArr );

 $PHPArr = [
   "test" => [
        "免费课"=>[
            "PHP课",
            "php",
            "python",
        ],
        "体验课"=>[
            "php",
            "js",
            "vue",
        ]
    ],
   "product" => [
        "免费课"=>[
            "产品1",
            "产品2",
        ],
        "体验课"=>[
            "产品3",
            "产品4",
        ]
    ]
  ];

  print_r( $PHPArr );

遍历多维数组

foreach ($PHP as $key => $value)
{
    要执行代码;
	foreach ($value as $kk => $vv)
	{
	    要执行代码;
	}
}

初级实战2 - 个人博客的开头部分

实战目标：

复习运算符的使用
复习条件语句的使用
复习循环
学会使用数组

任务：循环数组：输出顶部导航栏，输出博客标题和时间条件语句：如果为第一个导航，则给出突出显示运算：输出数字的大小从大到小排列

函数

函数是一段可重复使用的代码块，可以将一系列操作封装起来，使代码更加模块化、可维护和可重用，来大大节省我们的开发时间和代码量，提高编程效率。

内置函数

内置函数有很多，之前学的print_r() count() 就是一个内置函数，获取当前时间 time()，date('Y-m-d H:i:s')

这节我们主要讲自定义函数

创建（定义）函数和调用

PHP 函数准则：

函数的名称应该提示出它的功能
函数名称以字母或下划线开头（不能以数字开头）

function functionName() { 
// 要执行的代码 
}
//调用
functionName();

function test(){
    echo '我的名字是：写代码的PHP';
}

test();

// 获取当前的时间
function nowTime(){
	echo date('Y-m-d H:i:s');
}

nowTime();

添加参数

为了给函数添加更多的功能，我们可以添加参数，参数类似变量

function myName($name){
	echo "我的名字是：$name";
}

myName("PHP");

// 获取当前的时间
function nowTime($type){
    if($type=="time"){
        echo date('Y-m-d H:i:s');
    }
    else if($type=="day"){
        echo date('Y-m-d');
    }
}

nowTime("time");

多个参数

function plus($a,$b)
{
  echo $a+$b;
}

plus(2,3);

//严格模式
declare(strict_types=1);
function plus(int $a,int $b)
{
  echo $a+$b;
}

plus('2','13');

返回值

return ，可有可无，但一般都有

function plus($a,$b)
{
  return $a+$b;
}

echo plus(2,3);

变量作用域

讲完了函数，就可以学习前面提到过的变量作用域了

变量的作用域是脚本中变量可被引用/使用的部分。

局部和全局(global) 作用域

在所有函数外部定义的变量，拥有全局作用域
除了函数外，全局变量可以被脚本中的任何部分访问
要在一个函数中访问一个全局变量，需要使用 global 关键字
函数内部声明的变量是局部变量，仅能在函数内部访问

$PHP="写代码的PHP";
function test(){
	global $PHP;
	$age="35";
	echo $PHP;
}
test();
echo $age;

static 作用域

当一个函数完成时，它的所有变量通常都会被删除。然而，有时候希望某个局部变量不要被删除。要做到这一点，请在第一次声明变量时使用 static 关键字

每次调用该函数时，该变量将会保留着函数前一次被调用时的值，但是该变量仍然是函数的局部变量

function myTest()
{
    static $a=0;
    echo $a;
    $a++;
    echo PHP_EOL;    // 换行符
}
 
myTest();
myTest();
myTest();

函数的参数作用域

参数是通过调用代码将值传递给函数的局部变量

function test($PHP){
	echo $PHP;
}

test('PHP');
var_dump($PHP);

unset和isset函数

unset()可以删除变量，isset() 可以判断变量是否存在


$PHP="写代码的PHP";

function test(){
	// global $PHP;
	$age="35";
    var_dump(isset($age));
	unset($age);

    var_dump(isset($age));
}
test();
var_dump($PHP);

超级全局变量

- $GLOBALS
- $_SERVER

- $_REQUEST
- $_POST
- $_GET
- $_FILES
- $_ENV
- $_COOKIE
- $_SESSION

$GLOBALS

是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。

print_r($GLOBALS);

$PHP="PHP";
$age=35;
function test3(){
	global $PHP,$age;
	$age = "38";
    $PHP = "写代码的PHP";
}
test3();
echo $age;
echo $PHP;

$PHP="PHP";
$age=35;

function test2(){
    $GLOBALS["age"]="38";
    $GLOBALS["PHP"] = "写代码的PHP";

    echo $GLOBALS["PHP"].'---'.$GLOBALS["age"];
}

test2();
echo PHP_EOL; 
echo $age;
echo $PHP;

`$_SERVER`

$_SERVER 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组。
这个数组中的项目由 Web 服务器创建。
不能保证每个服务器都提供全部项目；服务器可能会忽略一些，或者提供一些没有在这里列举出来的项目。

print_r($_SERVER)

资料来自 PHP 超级全局变量 | 菜鸟教程 (runoob.com)

![[Pasted image 20230927152355.png]] ![[Pasted image 20230927152441.png]]

初级实战3 - 函数的使用

编写一个函数getFactors，接受一个正整数参数，计算并返回该整数的所有因子（除了1和自身的所有正整数因子）。
注：因子是能够整除给定数的正整数（例如，对于数值 24，它的因子包括 1、2、3、4、6、8、12 和 24。因为这些数都可以整除 24，没有余数。）
补充知识：怎么往数组内插入数据
要求使用函数

其他运算符

数组运算符

+号运算符（合并）注意：只会保留第一个数组中的键值对，而忽略后面数组中相同键名的元素，如果想要合并两个数组并覆盖相同键名的元素，可以使用array_merge()函数

  $a = [
    "m" => "测试",
    "n" => "PHP"
  ];

  $b = [
    "m" => "测试2",
    "o"=>"测试o",
    "p"=>"测试p",
    "q"=>[
        "cs"=>"二维测试"
    ]
  ];

  $c=[
    "m" => "测试3",
    "cc"=>123
  ];

  print_r($a+$b+$c);

==
=== 有相同的键/值对，且顺序相同、类型相同

    $a = [1,2,3];
    $b = [1,2,"3"];
	var_dump($a == $b);
	var_dump($a === $b);
	
    $a = [
        "a"=>123,
        "b"=>456,
    ];

    $b = [
        "b"=>456,
        "a"=>123,
    ];

    var_dump($a == $b);
    var_dump($a === $b);

!= 和 <>
!==

三元运算符 ?:

// $name = $username?$username:"测试";

$name = isset($username)?$username:"测试";

// $name = $username?:"测试";
var_dump($name);

空合并运算符 ??

用于简化处理可能为null的变量或数组元素的情况。它的作用是判断一个变量是否未定义或者为null，如果未定义或为null，则返回指定的默认值；否则返回该变量的值

$name = $username ?? "PHP";
echo $name;

组合比较符 <=>

可比较整型浮点型字符串

$c = $a <=> $b;

如果 $a > $b, 则 $c 的值为 1 如果 $a == $b, 则 $c 的值为 0 如果 $a < $b, 则 $c 的值为 -1

$a = "acd";
$b = "ace";

var_dump($a <=> $b);

比较

数据类型的比较

虽然 PHP 是弱类型语言，但也需要明白变量类型及它们的意义因为我们经常需要对 PHP 变量进行比较，包含松散和严格比较。

松散比较：使用两个等号 == 比较，只比较值，不比较类型。
严格比较：用三个等号（全等） === 比较，除了比较值，也比较类型。

例如，"42" 是一个字符串而 42 是一个整数。false 是一个布尔值而 "false" 是一个字符串。

<?php
if(42 == "42") {
    echo '1、值相等';
}
 
echo PHP_EOL; // 换行符
 
if(42 === "42") {
    echo '2、类型相等';
} else {
    echo '3、类型不相等';
}
?>

问题：如果只想比较类型是否相同，怎么比较？

比较undefined、 0、false、null、空值

分析 isset() is_null() empty()的区别

var_dump(!isset($name));
var_dump(is_null($name));

$name = null;
var_dump(!isset($name));
var_dump(is_null($name));
var_dump(empty($name));

empty

注意：empty() 函数对于未定义的变量也会返回true，因此在使用empty() 函数之前，应该确保变量已经被定义

$var1 = ""; // 空字符串
$var2 = 0; // 整数0
$var3 = null; // null
$var4 = false; // false
$var5 = array(); // 空数组 []

var_dump(empty($var1));
var_dump(empty($var2));
var_dump(empty($var3));
var_dump(empty($var4));
var_dump(empty($var5));

字符串相关函数

  $strZh = "我是写代码的PHP";

  $strEn = "Hello PHP,I am a person who loves to share";

strlen() 获取字符串长度
strpos() 在字符串内查找一个字符或一段指定的文本，返回第一次出现的位置或false
stripos() 同上，但不区分大小写
strrpos() 同上上，返回最后一次出现的位置或false
strripos() 同上，但不区分大小写
explode() 把字符串打散成数组
implode() 把数组拼接成字符串
strtoupper() 把字符串转换为大写
strtolower() 把字符串转换为小写
ucfirst() 将单词的首字母转换为大写
lcfirst() 将单词的首字母转换为小写
ucwords() 将字符串中每个单词的首字母转换为大写
str_replace($search, $replace, $string) 将字符串中的某个子字符串替换为另一个字符串
strrev()：将字符串反转
trim()：去除字符串两端的空格
substr() 截取字符串的一部分
mb_substr() 截取字符串的一部分(中文) 需要安装扩展mbstring

初级实战4 - 字符串函数的使用

编写一个函数，接受一个英文字符串参数"Hello PHP, HOW Are You?"，将字符串中的每个单词的首字母转换为小写，并返回修改后的字符串。

考察字符串的函数使用
考察数组的使用
考察循环的使用

  $str = 'Hello PHP,HOW,Are,You';

  $arr = explode(' ',$str);
  //   print_r($arr);

  $newArr = [];
  foreach ($arr as $key => $value) {
    if(strpos($value,',') !== false){
        $valueArr = explode(',',$value);
        $newValueArr = [];
        foreach ($valueArr as $kk => $vv) {
            $newValueArr[] = lcfirst($vv); 
        }

        $newArr[] = implode(',',$newValueArr);
    }
    else{

        $newArr[]= lcfirst($value); 
    }
  }

  echo implode(' ',$newArr);

数组相关函数

$array = ["a","b","c","d"];

array()：创建一个数组。
count()：返回数组中元素的数量。
array_push($array, $newElement)：将一个或多个元素添加到数组的末尾。
array_unshift($array, $newElement)：将一个或多个元素添加到数组的开头。
array_pop()：删除并返回数组中的最后一个元素。
array_shift()：删除并返回数组中的第一个元素。
array_slice()：从数组中提取一部分元素，组成新的数组。
array_merge()：合并两个或多个数组。
array_reverse()：反转数组中的元素的顺序。
in_array()：检查数组中是否存在某个值。
array_key_exists()：检查数组中是否存在某个键。
array_keys()：返回数组中的所有键，组成新数组。
array_values()：返回数组中的所有值，组成新数组。
array_search()：在数组中搜索给定的值，并返回对应的键。
array_unique()：移除数组中的重复值（原数组不变）。
max() min() 最大值和最小值
sort() 数组排序（升序）
rsort() 数组排序（降序）
array_sum() 数组求和
array_product() 数组求乘积

暂时就想到这些函数，后面如果我们遇到了会再做补充。

初级实战5 - 数组函数的使用

编写一个PHP函数 testArray($numbers) ，该函数接收一个整数数组 $numbers 作为参数，并返回一个关联数组，包含以下统计信息：

"count" ：数组中的元素个数。
"sum" ：数组中所有元素的总和。
"average" ：数组中元素的平均值。
"max" ：数组中的最大值。
"min" ：数组中的最小值。
"sorted" ：按照从小到大排序的数组。

测试数组：

$numbers = [5, 9, 3, 2, 7, 1, 6];

时间、日期相关知识

函数

time() 获取当前时间戳（10位），例如：1697520502
microtime(true) 返回一个浮点数时间戳（秒数和微秒数的总和）
date(格式，时间戳) 日期格式化

$time = time();
echo date('Y-m-d H:i:s',$time);

strtotime(string)

strtotime("next Monday");

$baseTime = strtotime("2023-10-01");
echo strtotime("next Monday", $baseTime);

$baseTime = time();
echo strtotime("+1 day", $baseTime);

mktime($hour, $minute, $second, $month, $day, $year) 生成时间戳
date_create() 来创建一个日期时间对象 date_create('2023-11-01')
date_format() 用于将日期和时间格式化为指定的字符串格式

date_format($date, "Y-m-d H:i:s");
date_format($date, "Y年m月d日 H:i:s")

date_diff() 计算两个日期之间的差

$date1 = date_create('2023-10-20 12:00:00');
$date2 = date_create('2023-10-21 12:00:00');
$diff = date_diff($date2, $date1);
echo $diff->format('%a 天');
echo $diff->format('%m 月');
echo $diff->format('%y 年 %m 月 %d 天');

-  %Y ：完整年份的差异 
-  %y ：年份的差异（两位数） 
-  %m ：月份的差异 
-  %d ：天数的差异 
-  %a ：总共的天数差异 
-  %H ：小时的差异 
-  %h ：小时的差异（12小时制） 
-  %I ：分钟的差异 
-  %S ：秒数的差异 
-  %R ：正负
-  %r ：正负(必须是负的才会显示)

strftime($format, $timestamp) ：根据指定的格式，将时间戳格式化为可读的日期和时间字符串，支持本地化的日期和时间格式 (php8已废弃)。

$timestamp = time();
$dateString = strftime("%A %Y-%m-%d %H:%M:%S", $timestamp);
echo $dateString;

gmdate($format, $timestamp) ：根据指定的格式，将GMT时间戳格式化为可读的日期和时间字符串。 gmdate() 和 date()的区别 gmdate() 函数使用格林威治标准时间（GMT）作为默认的日期/时间基准，会忽略服务器的时区设置，始终返回格林威治标准时间（GMT）的日期和时间； date() 函数则使用本地时间作为基准，它会根据当前服务器的时区设置来格式化日期和时间。
date_default_timezone_set($timezone) ：设置默认的时区。

"UTC", "localtime"本地时区, "Asia/Shanghai"上海

注意：只能在脚本开始时设置默认时区，不能在运行时动态设置。

timezone_identifiers_list() ：返回所有可用时区标识符的数组。

DateTime对象

$dateTime = new DateTime("2023-11-01 12:34:56");
//增加或减少指定的时间间隔
$dateTime->modify('+1 day');
$dateTime->modify('-1 hour');

//设置日期部分 setDate($year, $month, $day)
$dateTime->setDate(2024, 1, 3);

//设置时间部分 setTime($hour, $minute, $second)
$dateTime->setTime(13, 1, 5);

// 设置时区
$dateTime->setTimezone(new DateTimeZone("Asia/Shanghai")); 
// 获取时区
$dateTimeZone = $dateTime->getTimezone(); 
print_r($dateTimeZone->getName());
print_r($dateTimeZone->getLocation());

//将日期时间格式化为指定的字符串格式
echo $dateTime->format("Y-m-d H:i:s");

//获取时间戳
$timestamp = $dateTime->getTimestamp();
echo $timestamp;

//计算时间差
$dateTime2 = new DateTime('2023-12-05');
$diff = $dateTime->diff($dateTime2);
echo $diff->format('%R %m %d %h %i %s');

$datetime = new DateTime('2024-01-01');
$interval = new DateInterval('P1D'); // 一天的时间间隔
$datetime->add($interval);
//$datetime->sub($interval);

echo $datetime->format('Y-m-d');

特殊的变量写法和常量

交流社区地址：https://PHP.fun

特殊的变量写法

$a ='PHP';
$$a = "测试";

echo $a;
echo ' ---- ';
echo $$a;
echo ' ---- ';
echo $PHP;

实际使用场景：


for ($i=0; $i < 5; $i++) { 
    $a = "PHP".$i;
    $$a = "测试-".$i;
}

echo $PHP1;
echo $PHP2;

常量

常量值被定义后，在脚本的其他任何地方都不能被改变。命名规则和变量类似，严格区分大小写，但无需$符 注意： 默认是全局的，可以在整个运行的脚本的任何地方使用。

define("PHP", "写代码的PHP PHP.fun");
echo PHP;

echo '<hr>';

const PHP1 = "猫大叔";
echo PHP1;

$a = 2;
define("PHP".$a, "PHP1");
echo constant("PHP".$a);

echo '<hr>';

实际使用场景：

for ($i=0; $i < 5; $i++) { 
    $a = "PHP".$i;
    // $$a = "测试-".$i;
    define($a,'测试-'.$i);
}

echo PHP1;
echo PHP2;

const和define的区别

const不能在条件语句中定义常量

$a = 1;
if($a==1){
    define("PHP".$a, "PHP1");
    echo constant("PHP".$a);
    
    const PHP2 = "猫大叔";
    echo PHP2;
}

const用于类成员变量的定义，define不可以用于类成员变量的定义，可用于全局常量。
const可在类中使用，define不能

class ceshi {
    
    const Ceshi = 'PHP';
    public function cc()
    {
        define('MS','写代码的PHP');
        echo self::Ceshi;
    }

}
$c = new ceshi;
$c->cc();

echo '----';
echo MS;

常量和变量的区别：

常量前面没有美元符号($)，而且不能有
常量可以不用理会变量的作用域在任何地方定义和访问
常量一旦定义就不能重新定义或取消定义
常量的值只能是标量（字符串、整数、浮点数、布尔值）,注意：现在也支持数组了

获取所有的常量

get_defined_constants()
get_defined_constants(true)
get_defined_constants(true)["user"]

魔术常量

魔术常量：它的值随着它在代码中的位置改变而改变

`LINE`

文件中的当前行号

echo '这是第 " ' . __LINE__ . ' " 行';

`FILE`

文件的完整路径和文件名，包含（盘符）根目录

echo '该文件的完整路径为 " ' . __FILE__ . ' " ';

`DIR`

文件所在的目录

echo '该文件位于 " ' . __DIR__ . ' " ';

`FUNCTION`

该函数被定义时的名字（区分大小写）

function test() {
    echo  '函数名为：' . __FUNCTION__ ;
}
test();

`CLASS`

该类被定义时的名字（区分大小写）

<?php
class testClass {
    function test() {
        echo '类名为：'  . __CLASS__ . "<br>";
        echo  '函数名为：' . __FUNCTION__ ;
    }
}
$t = new testClass();
$t->test();
?>

`NAMESPACE`

命名空间

namespace MyProject; 
echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject"

`METHOD`

包含了：命名空间类名函数名

namespace PHP;
class MyClass {
    public function myMethod() {
        echo __METHOD__; // 输出：PHP\MyClass::myMethod
    }
}

$obj = new MyClass();
$obj->myMethod();

`TRAIT`

当前使用的 trait 的名称

trait MyTrait {
    public function myMethod() {
        echo "trait的名称为: " . __TRAIT__;
    }
}

class MyClass {
    use MyTrait;
}

$obj = new MyClass();
$obj->myMethod();

包含文件

在当前文件内引入其他PHP文件、HTML文件或文本文件等，一般用于包含公共方法，公共页面等，例如header footer sider等网页通用部分。

include 和 require 语句

区别： include 和 require 除了处理错误的方式不同之外，在其他方面都是相同的：

require 生成一个致命错误（E_COMPILE_ERROR），在错误发生后脚本会停止执行。
include 生成一个警告（E_WARNING），在错误发生后脚本会继续执行。

因此：如果你希望被包含的文件是必需的且缺少文件会导致脚本无法正常运行，应使用require（推荐）。如果你希望被包含的文件是可选的，或者即使缺少文件也希望脚本继续执行，可以使用include。

例如：

header.php

<?php 
	$siteTitle = "PHP星球(PHP.fun)";
?>
<html>
<head>
<meta charset="utf-8">
<title><?php echo $siteTitle;?></title>
</head>

index.php

<?php include 'header.php'; ?>
<body>
<h1>欢迎来到<?php echo $siteTitle;?> !</h1>
<p>有问必答。</p>

</body>
</html>

include_once 和 require_once 语句

和上面的一样，但他只会调用一次，防止重复调用

面向对象（OO）

概念

对象：

在现实世界里我们所面对的事情都是对象，如苹果猫电视机等。而在面向对象的程序设计(OOP)中，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象。

例如：小猫名字：Tom，性别：公，花色：橘色；会叫，会吃饭，会打闹小狗名字：Jack，性别：公，花色：黑色；会叫，会吃饭，会打闹

区分：谁在叫，谁在吃饭，谁在打闹

面向对象：

面向对象是一种编程思想和方法，它将程序中的数据和操作数据的方法封装在一起，形成"对象"，并通过对象之间的交互和消息传递来完成程序的功能。
面向对象编程(OOP)强调数据的封装、继承、多态和动态绑定等特性，使得程序具有更好的可扩展性、可维护性和可重用性。

对象的主要三个特性：

对象的行为：对象可以执行的操作，比如：开灯，关灯就是行为。
对象的形态：对对象不同的行为是如何响应的，比如：颜色，尺寸，外型。
对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同（在面向对象编程中，对象的表示通常通过类来实现）。

面向对象编程的三个主要特性：

封装：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。
继承：指可以创建一个新的类，该类继承（extends）了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。
多态：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在 PHP 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。

类（class）

定义了一件事物的抽象特点。
类的定义包含了数据的形式以及对数据的操作。

类的定义和调用

类的定义

class Animal {
	public $name = "小猫仔";
    public function eat() {
        echo " 在吃饭.";
    }
}

类的调用

new 实例化对象

$cat = new Animal;
//$cat = new Animal();
echo $cat->name;
$cat->eat();

方法和属性

类方法（函数）

class Animal {
	public $name = "小猫仔";
    public function eat() {
        echo " 在吃饭.";
    }
    function say() {
        echo " 在说话.";
    }
}

$this

代表自身的对象

class Animal {
	public $name = "小猫仔";
    public function eat() {
        echo $this->name." 在吃饭.";
    }
    function say() {
        echo $this->name." 在说话.";
    }
}

$cat = new Animal;
$cat->name = "小花";
$cat->say();

$dog = new Animal;
$dog->name = "小黑";
$dog->say();

访问控制

关键字 public、private、protected

public（公有）：公有的类成员可以在任何地方被访问。
protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问（咱家的）。
private（私有）：私有的类成员则只能被其定义所在的类访问（自己的）。

`__construct`构造函数

构造函数是一种特殊的方法，在创建一个新对象时，它会被自动调用。
它可以用来 初始化 对象的属性或执行其他必要的操作
没有返回值

  class Animal {
	private $name;
	private $birth;
	private $age;

    public function __construct($name,$birth)
    {
        $this->name = $name;
        $this->birth = $birth;
        
        $days = (time() - strtotime($this->birth))/3600/24;
        $this->age = floor($days);
    }

    public function eat() {
        echo  $this->name." 在吃饭.";
    }
}

$cat = new Animal("猫仔","2023-05-23");
echo $cat->name;
echo ' -- ';
echo $cat->birth;
echo ' -- ';
echo $cat->age;

`__destruct`析构函数

析构函数是一种特殊的方法，它在对象被销毁时自动调用
它可以用来执行一些清理操作，例如释放资源或关闭数据库连接。
当对象不再被引用或脚本执行结束时，析构函数会被自动调用。

class MyClass {
    public function say($i)
    {
      echo 'saying-'.$i;
    }
    public function __destruct() {
        echo "析构函数被调用\n";
    }
}

// 创建对象
$obj = new MyClass();

// 执行其他操作...
for ($i=0; $i < 4; $i++) {
    if($i==3){
        unset($obj);
    }
    if($obj)
        $obj->say($i);
}

static 静态变量和 self

「静态」指的是无需对类进行实例化，就可以直接调用这些属性和方法所有对静态变量进行的操作都会对所有对象起作用举例：小猫小狗听到指令来吃饭，指令变化，全部都要听从

public static $cat = "PHP";

echo self::$cat;

类常量

静态属性与类常量相似，唯一的区分是类常量不可以更改，静态属性可以更改使用场景：所有的对象共用一个属性

const PHP = "PHP";

echo self::PHP;

static 静态方法

public static function say() {
        echo self::$name;
}

可以调用静态方法、静态变量可以调用非静态方法、非静态变量

public function eat() {

        echo $this->name." 在吃饭.";

}
public static function say() {

        echo (new self)->eat();

}

类的继承（extends）：

指可以创建一个新的类，该类继承（extends）了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。

注意：继承不一定能访问

class Animal {
    public $name="小动物";
    protected $age=3;
    private $birth='2023';
}

class Cat extends Animal {}


var_dump(new Animal);
var_dump(new Cat);

class Animal {
    protected $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function eat() {
        echo $this->name . " 在吃饭.";
    }
}

class Cat extends Animal {
    public function meow() {
        echo $this->name . " 在喵呜.";
    }
}

$cat = new Cat("Tom");
var_dump($cat);
$cat->eat();  // 继承自父类 Animal 的方法
$cat->meow();  // 子类 Cat 自己的方法

方法和属性重写

如果从父类继承的方法或属性不能满足子类的需求，可以对其进行改写

final 关键字

作用：

防止类被继承
防止类的方法被重写

如果在一个类前加final，那么这个类就不能被继承；

final class myClass {
    // 类的内容
}

如果在一个方法前加final，那么这个方法就不能被重写

    final public function eat() {
        echo $this->name . " 在吃饭.";
    }

注意：final不能用于属性

调用父类方法

parent:: parent::__construct()

静态延迟绑定 static

是指在运行时根据实际调用的类来确定静态方法或属性的绑定语法：static::$name

class Animal {
    protected static $name="小动物";

    public static function eat() {
        echo self::$name. " 在吃饭.";
        echo ' ---- ';
        echo static::$name. " 在吃饭.";
    }
}

class Cat extends Animal {
    protected static $name="小猫";
}

Animal::eat();
Cat::eat();

类的多态

多态性允许不同类的对象对相同的消息作出不同的响应。
多态性通过方法重写（覆盖）和方法重载来实现。
方法重写是指子类重写父类的方法，以改变方法的实现细节。
方法重载是指在同一个类中根据参数个数或类型不同来实现不同功能。
需要注意的是，多态性只适用于继承关系的类。子类必须重写父类的方法才能实现多态性。

class Animal {
    protected $name="动物";
    public function makeSound() {
        echo "$this->name 在吼叫。";
    }
}

class Dog extends Animal {
    protected $name="小狗";
    public function makeSound() {
        echo "$this->name 在汪汪。";
    }
}

class Cat extends Animal {
    protected $name="小猫";
    public function makeSound() {
        echo "$this->name 在喵喵。";
    }
}

$animal = new Animal();
$dog = new Dog();
$cat = new Cat();

$animal->makeSound();
$dog->makeSound();
$cat->makeSound();

方法重载

$args = func_get_args(); 
$numArgs = func_num_args();

function test(){

    $args = func_get_args(); 
    $numArgs = func_num_args();
    
    var_dump($args[1]);
    var_dump($numArgs);
}

test(1,2,3,4);

class Animal {
    public function makeSound() {
        echo "动物在吼叫";
    }
}


class Cat extends Animal {
    public function makeSound() {
        // $args = func_get_args();
        $numArgs = func_num_args();
        
        switch($numArgs){
            case 2:
                echo '执行参数个数为2的事件';
                break;
            case 3:
                echo '执行参数个数为3的事件';
                break;
            default:
                echo '执行默认事件';
        }
    }
}

// $animal = new Animal();
$cat = new Cat();

$cat->makeSound("测试","2");

接口和抽象类

interface(接口)

interface Animals {
	public function a();
	public function b();
}

class Cat implements Animals {
	public function a(){
	
	};
	public function b(){
	
	};
}

接口是指一组方法的集合，不是类，不能被实例化。

可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容
只可以使用public
通常用于定义一些规范，让代码更加有条理不易出错。例如：小动物必须要吃饭和睡觉，否则就会死！这是必须的，每个小动物都必须有这2个方法！


interface Animals {
    const PHP = "PHP";
    public function eat();
    public function sleep($hours);
    public static function jump();
}
  
class Cat implements Animals {
    public function eat() {
        echo "Cat 在吃饭.";
    }

    public function sleep($hours) {
        echo "Cat 要睡 $hours 小时.";
    }

    public static function jump(){
        echo '跳跳跳';
    }
}

$cat = new Cat();
$cat->eat();
$cat->sleep(18);

echo Cat::PHP;
echo Cat::jump();

interface Animals {
    public function eat();
    public function sleep($hours);
}
interface Sports {
    public function run();
    public function jump();
}
class Cat implements Animals,Sports {
    public function eat() {
        echo "Cat 在吃饭";
    }

    public function sleep($hours) {
        echo "Cat 要睡 $hours 小时";
    }

    public function run() {
        echo "Cat 在跑步";
    }

    public function jump() {
        echo "Cat 在蹦跳";
    }
}

抽象类和抽象方法

和接口非常类似，使用它也是定义一种约束或规范，适合较大型的项目或库使用

抽象类

abstract class Animals{

}

抽象类是一种特殊的类，只能被继承，不能被实例化
抽象类用于定义一组相关的方法，但这些方法的具体实现由继承它的子类来完成。
子类继承抽象类后，必须实现抽象类中的所有抽象方法。
抽象类可以包含抽象方法和普通方法

抽象方法

abstract public function xxx();
abstract protected function xxx();

抽象方法是没有具体实现的方法，只有方法的声明，而不需要方法体。
抽象方法只能存在于抽象类中。
可以使用protected，但不能使用private私有。

abstract class Animals
{
    abstract public function eat();
    abstract protected function sleep($hours);

    public function play()
    {
      echo '玩耍';
    }
}

class Cat extends Animals
{
    public function eat()
    {
        echo "Cat 在吃饭.";
    }

    protected function sleep($hours)
    {
        echo "Cat 要睡 $hours 小时.";
    }
}


$cat = new Cat();
$cat->eat();
//$cat->sleep(12);
$cat->play();

抽象类与接口的区别

抽象类可以包含非抽象方法的实现，而接口只能包含方法的声明，没有方法的实现。
类只能继承一个抽象类，但可以实现多个接口。
抽象类可以有构造函数，而接口不能有构造函数。
抽象类中的方法可以有public、protected和private访问修饰符，而接口中的方法只能是public。
子类继承抽象类时，必须实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。子类实现接口时，必须实现接口中的所有方法。

`trait`代码复用

解决类的单一继承问题
可同时使用多个trait，用逗号隔开
把常用的、通用的代码抽离出来，写成trait

trait A{

}
trait B{

}
class C {
	use A,B;
}

和类的继承非常像，但是trait里面不能有类常量，且trait不能被实例化。根据下面类的继承来修改，对比看下他们的相同点：

class Animal {
    protected $name;
    const PHP="PHP";

    public function __construct($name) {
        $this->name = $name;
    }

    public function eat() {
        echo $this->name . " 在吃饭.";
    }
}

class Cat extends Animal {
    public function meow() {
        echo $this->name . " 在喵呜.";
    }
}

$cat = new Cat("Tom");
var_dump($cat);
$cat->eat();  // 继承自父类 Animal 的方法
$cat->meow();  // 子类 Cat 自己的方法

trait中可使用抽象方法
trait中可使用静态属性和静态方法
trait中可使用其他trait
trait中可使用parent


class MainClass{
    public function main()
    {
      echo '这是主方法的'.__METHOD__;
    }
}
trait Animal {

    public function eat() {
        parent::main();
        echo $this->name . " 在吃饭.";
        echo __TRAIT__;
    }
}

class Cat extends MainClass {
    use Animal;
    protected $name;
    public function __construct($n) {
        $this->name = $n;
    }
    public function meow() {
        echo $this->name . " 在喵呜.";
        echo __TRAIT__;
    }
}

$cat = new Cat("Tom");
var_dump($cat);
$cat->eat();  // 继承自父类 Animal 的方法
echo '----';
$cat->meow();  // 子类 Cat 自己的方法

同名冲突

当一个类同时引入了多个Trait，并且这些Trait中存在同名方法时，就会产生方法冲突。

use A,B{
	//A::eat insteadof B;
    B::eat insteadof A;
    //别名定义
    A::eat as Aeat;
}

trait A
{
    public function eat(){
        echo '这是A的';
    }
}

trait B
{
    public function eat(){
        echo '这是B的';
    }
}

class T{
    use A,B{
        A::eat insteadof B;
        B::eat as Beat;
    }
}

$t = new T;

$t->eat();
$t->Beat();

表单和请求

主要用到了$_GET 和 $_POST超全局变量，分别对应两种不同的请求方式

表单

input select radio checkbox submit

<form action="./user.php" method="post">
    用户名: <input type="text" name="username">
    密码: <input type="text" name="password">
    <select multiple name="arr[]">
        <option value="">请选择:</option>
        <option value="1">大猫</option>
        <option value="2">二猫</option>
        <option value="3">三猫</option>
    </select>
    <input type="submit" value="提交">
</form>

关于网络请求

GET请求和POST请求是两种常用的HTTP请求方法，用于从客户端向服务器发送数据

GET请求：

通过URL（网址）参数将数据附加在URL上发送给服务器。这些参数以键值对的形式出现在URL的末尾，使用问号"?"将URL和参数分隔开。

POST请求：

将数据作为请求的主体发送给服务器，而不是附加在URL上。这使得POST请求更适合发送敏感数据或超长大段内容，例如表单中的密码、博客文本内容等。

区别：

GET参数对任何人都是可见的，POST参数对任何人都是不可见的
GET对发送信息的量也有限制，不适合大型的变量值，它的值不能超过 2000 个字符；POST对发送信息的量没有限制（默认POST 发送的最大值为 8 MB，但可通过设置 php.ini 的 post_max_size 进行更改；发送的变量数最大值max_input_vars）
可以在收藏夹中收藏GET请求页面，或者发送带参数的网址给别人可以直接访问，例如带页码的网址、带商品id的淘宝商品、带文章id的博文。这一点POST做不到。

超全局变量`$_REQUEST`

$_REQUEST 变量包含了 $_GET、$_POST 和 $_COOKIE 的内容 $_SERVER获取请求方式

htmlspecialchars()函数

用于将字符串中的特殊字符转换为HTML实体，以避免在HTML文档中引起解析错误或安全漏洞。

& （和号）成为 &
" （双引号）成为 "
' （单引号）成为 '
< （小于）成为 <
> （大于）成为 >

mysql数据库

本课程只讲解最简单的增删改查语句，不做更深入的语句讲解。

配置环境变量

mysql -u root -p

查看数据库列表： SHOW DATABASES;

使用数据库 USE xxx;

查看数据表列表： SHOW TABLES;

数据库工具：SQL_Front(小皮内置)、Navicat、DBeaver

操作数据库的方式：MySQLi 和 PDO

MySQLi

首先要启用扩展mysqli

面向过程

<?php
$servername = "localhost";
$username = "root";
$password = "root";
 
// 创建连接
$conn = mysqli_connect($servername, $username, $password);
 
// 检测连接
if (!$conn) {
    die("连接失败: " . mysqli_connect_error());
}
echo "连接成功";

//关闭
mysqli_close($conn);
?>

面向对象

<?php
$servername = "localhost";
$username = "root";
$password = "root";
 
// 创建连接
$conn = new mysqli($servername, $username, $password);
 
// 检测连接
if ($conn->connect_error) {
    die("连接失败: " . $conn->connect_error);
} 
echo "连接成功";

//关闭
$conn->close();
?>

resource 资源类型

is_resource() 是否为资源类型
get_resource_type() 获取资源的类型名称

$servername = "localhost";
$username = "root";
$password = "root";
$conn = mysql_connect($servername, $username, $password);
var_dump(is_resource($conn));
var_dump(gettype($conn));
var_dump(get_resource_type($conn));

$handle = fopen("test.txt", "r");
var_dump($handle);
var_dump(is_resource($handle));
var_dump(gettype($handle));
var_dump(get_resource_type($handle));

//$content = fread($handle, filesize("test.txt"));
//echo $content; 
fclose($handle);

接下来将主讲面向对象方式操作

创建数据库

// 创建数据库
$sql = "CREATE DATABASE IF NOT EXISTS PHPDB";
//if (mysqli_query($conn, $sql)) {
if ($conn->query($sql) === TRUE) {
    echo "数据库创建成功";
} else {
    echo "数据库创建失败 " . $conn->error;
}

创建数据库表

NOT NULL - 每一行都必须含有值（不能为空），null 值是不允许的。
DEFAULT value - 设置默认值
UNSIGNED - 使用无符号数值类型，0 及正数
AUTO INCREMENT - 设置 MySQL 字段的值在新增记录时每次自动增长 1
PRIMARY KEY - 设置数据表中每条记录的唯一标识。通常列的 PRIMARY KEY 设置为 ID 数值，与 AUTO_INCREMENT 一起使用。

每个表都应该有一个主键(本列为 "id" 列)，主键必须包含唯一的值。

//$conn->query("USE PHPDB");
// 使用 sql 创建数据表
$sql = "CREATE TABLE IF NOT EXISTS user (
  id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
  username VARCHAR(30) NOT NULL COMMENT \"用户名\",
  password VARCHAR(64) NOT NULL COMMENT '密码',
  phone VARCHAR(11),
  status INT(1) NOT NULL DEFAULT 1,
  create_date TIMESTAMP
  ) COMMENT '用户'";
//if (mysqli_query($conn, $sql)) {
if ($conn->query($sql) === TRUE) {
    echo "数据表创建成功";
} else {
    echo "数据表创建错误: " . $conn->error;
}

注：如果要加注释，那么后面加上 COMMENT 即可

插入数据

注意： 如果列设置 AUTO_INCREMENT (如 "id" 列) 或 TIMESTAMP (如 "create_date" 列)，我们就不需要在 SQL 语句中指定值； MySQL 会自动为该列添加值。

INSERT INTO table_name (column1, column2, column3,...)
VALUES (value1, value2, value3,...)

用$conn->query($sql) === TRUE来判断是否插入成功

$sql = "INSERT INTO user (username, password, phone)
VALUES ('da mao', '123456', 13888888888)";
//if (mysqli_query($conn, $sql)) {
if ($conn->query($sql) === TRUE) {
    echo "新记录插入成功";
} else {
    echo "错误: " . $sql . "<br>" . $conn->error;
}

字符串进行转义处理

$conn->real_escape_string($string); 可以确保特殊字符被正确转义，从而避免了SQL注入等安全问题，并保证查询语句的语法正确性，例如：

$name="这是一个'送命题'";

插入多条数据

$sql = "INSERT INTO user (username, password, phone)
VALUES 
    ('大猫', '123456', 13888888888),
    ('小猫', '123456', 13888888887),
    ('中猫', '123456', 13888888886)
    ";
$conn->query($sql);

foreach循环插入，或者使用语句： mysqli_multi_query()

$sql = "INSERT INTO user (username, password, phone)
VALUES ('大猫', '123456', 13888888888);";

$sql .= "INSERT INTO user (username, password, phone)
VALUES ('小猫', '123456', 13888888887);";

$sql.= "INSERT INTO user (username, password, phone)
VALUES ('中猫', '123456', 13888888886);";

//if (mysqli_multi_query($conn, $sql)) {
if ($conn->multi_query($sql) === TRUE) {
    echo "新记录插入成功";
} else {
    echo "错误: " . $sql . "<br>" . $conn->error;
}

查询数据

SELECT column1,column2 FROM table_name

$sql = "SELECT * FROM user";
$result = $conn->query($sql);
//if (mysqli_num_rows($result) > 0) {
if ($result->num_rows > 0) {
    echo "$result->num_rows 条结果";
    // 输出数据
    //while($row = mysqli_fetch_assoc($result)) {
    while($row = $result->fetch_assoc()) {
        echo "id: " . $row["id"]. " - Name: " . $row["username"]. " " . $row["phone"]. "<br>";
    }
} else {
    echo "0 条结果";
}

$result->num_rows 获取到的数据条数
$result->fetch_assoc() 是一种用于从结果集中获取一行数据的函数。它以关联数组的形式返回结果，其中列名作为键，对应的值则是该行中各列的值
除了fetch_assoc 还有 fetch_row和fetch_array和fetch_all

while($row = $result->fetch_row()) {
    echo "id: " . $row[0]. " - Name: " . $row[1]. " " . $row[2]. "<br>";
}

    //$datas = mysqli_fetch_all($result, MYSQLI_ASSOC);
    $datas = $result->fetch_all(MYSQLI_ASSOC);
    var_dump($datas);

free_result()

释放结果集所占用的内存资源。在使用 query() 函数执行查询后，会返回一个结果集对象，该结果集对象占用一定的内存空间。

//mysqli_free_result($result);
$result->free_result();

where 条件筛选

WHERE用于在查询中指定筛选条件，来限制返回的行

SELECT 列名
FROM 表名
WHERE 条件;

条件判断： > < = != <> >= <= like "%xxx%" like "%xxx" like "xxx%" between and is null is not null in (a,b,c)

and or not 括号

order by 排序

ASC升序、DESC降序根据两列进行排序，用逗号隔开即可，注意：只有第一列的值相同时才使用第二列

offset limit

SELECT 列名
FROM 表名
LIMIT 行数 OFFSET 偏移量;

更新数据

UPDATE 表名
SET column1=value, column2=value2,...
WHERE 条件

注意：如果省去 WHERE 子句，所有的记录都会被更新

使用计算表达式更新字段

UPDATE 表名 SET 列名 = 列名 + 值 WHERE 条件;

$sql = "UPDATE user SET num = num*3 WHERE id = 2";
$result = $conn->query($sql);

删除数据

DELETE FROM 表名
WHERE 条件

注意：如果省去 WHERE 子句，所有的记录都会被删除

删除表中的重复行

DELETE t1 FROM 表名 t1, 表名 t2 WHERE t1.列名 = t2.列名 AND t1.id > t2.id;

修改数据表

修改数据表名：
ALTER TABLE 旧表名 RENAME 新表名;

重置自增起始值为1：
ALTER TABLE 表名 AUTO_INCREMENT = 1;

添加新的列：
ALTER TABLE 表名 ADD COLUMN 列名 数据类型;

修改列名和数据类型：
ALTER TABLE 表名 CHANGE COLUMN 旧列名 新列名 新数据类型;

修改列的默认值： 
ALTER TABLE 表名 ALTER COLUMN 列名 SET DEFAULT 默认值;

删除列：
ALTER TABLE 表名 DROP COLUMN 列名;

修改列的注释：
ALTER TABLE 表名 MODIFY COLUMN 列名 数据类型 COMMENT '新注释';

删除数据表：
DROP TABLE IF EXISTS 表名

清空数据表：
TRUNCATE TABLE 表名;

删除数据库：
DROP database

咱们只讲了最基本的mysql，关于关联查询索引等更深入的知识就需要专门学习了。

预处理语句

预处理语句（Prepared Statements），用于执行带有参数的SQL语句。

预处理语句可以提高安全性，对于防止 SQL 注入是非常有用的
允许重复使用相同的sql模板而只需更改参数，提高执行效率。

关于sql注入

当涉及到SQL查询时，注入攻击是一种常见的安全漏洞

1. 直接执行用户输入的SQL查询：

$query = $_GET['query'];
$result = $conn->query($query);

如果用户能够直接执行他们自己构造的SQL查询，就会产生严重的安全问题。恶意用户可以执行任意的SQL语句，包括删除、修改或泄露敏感数据。

2. 使用字符串拼接的方式构建SQL查询：

$username = $_POST['username'];
$password = $_POST['password'];

$sql = "SELECT * FROM user WHERE username = '" . $username . "' AND password = '" . $password . "'";
$result = $conn->query($sql);

这种方式存在安全风险，如果用户在输入框中输入恶意代码，可以破坏原始的SQL查询结构，例如输入 ' OR 1=1 -- ，会导致查询条件永远为真，从而绕过身份验证。

转义特殊字符也不保险：

$username = $conn->real_escape_string($_POST['username']);
$password = $conn->real_escape_string($_POST['password']);

$query = "SELECT * FROM users WHERE username = '" . $username . "' AND password = '" . $password . "'";
$result = $conn->query($query);

我们使用 ->real_escape_string() 函数对用户输入的用户名和密码进行转义，以防止SQL注入，但仍然可能存在注入漏洞。假设用户在用户名输入框中输入 admin'-- ，并在密码输入框中输入任意值。由于转义字符未正确处理，生成的SQL查询语句如下

SELECT * FROM users WHERE username = 'admin'--' AND password = 'password'

在这种情况下， -- 是SQL注释的开始，后面的 AND password = 'password' 将被忽略。这样，攻击者可以绕过密码验证并成功登录，即使没有提供正确的密码。

预处理方法

查询

$sql = "SELECT * FROM user WHERE username = ? AND password = ? ";
$stmt = $conn->prepare($sql);
//绑定
$stmt->bind_param("ss", $username, $password);
//执行
$stmt->execute();

//获取结果
$result = $stmt->get_result();
print_r('<pre>');
print_r($result->fetch_all());

//关闭
$stmt->close();

插入

// 预处理
$sql = "INSERT INTO user (username, password, phone)
VALUES (?, ?, ?)";
$stmt = $conn->prepare($sql);
//绑定
$stmt->bind_param("sss", $username, $password, $phone);
//执行
$stmt->execute();

//获取结果
if ($stmt->affected_rows > 0) {
    echo "插入成功";
} else {
    echo "插入失败";
}


//关闭
$stmt->close();

其中的?为占位符

通过告诉数据库参数的数据类型，可以降低 SQL 注入的风险。参数有以下四种类型:

i - integer（整型）
d - double（双精度浮点型）
s - string（字符串）
b - BLOB（binary large object:二进制大对象）

每个参数都需要指定类型。

php8新方法

$name="这是一个'送命题'";
//mysqli_execute_query
$sql = "INSERT INTO user (username, password, phone)
VALUES (?, ?, ?)";
$conn->execute_query($sql,[$name,'123456','13888888888']);
$conn->execute_query($sql,[$name,'123456','13888888888']);

PDO

安装php_pdo_mysql扩展，用phpinfo() 函数来查看是否安装了PDO扩展

PDO执行sql语句分为2种方法：

exec() 方法：

适用于执行不返回结果集的SQL语句，例如INSERT、UPDATE和DELETE等操作。
exec() 方法返回受影响的行数（即被插入、更新或删除的行数），如果没有受影响的行，返回0。
通常用于执行不需要获取结果集的简单操作。

query() 方法：

适用于执行返回结果集的SQL语句，例如SELECT查询。
query() 方法返回一个PDOStatement对象，你可以使用该对象的方法（如 fetch() 、 fetchAll() ）来获取查询结果。
通常用于执行需要获取结果集的查询操作。

创建连接

<?php
$dbms='mysql';     //数据库类型
$host='localhost'; //数据库主机名
$dbName='PHPdb';    //使用的数据库
$user='root';      //数据库连接用户名
$pass='root';          //对应的密码
$dsn="$dbms:host=$host;dbname=$dbName";

try {
    $conn = new PDO($dsn, $user, $pass); //初始化一个PDO对象
    echo "连接成功<br/>";
	// 关闭连接
    $conn = null;
} catch (PDOException $e) {
    die ("错误!: " . $e->getMessage() . "<br/>");
}
?>

创建数据库

	//设置 PDO 错误模式为异常
	$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
	//PDO::ERRMODE_WARNING 警告
	//PDO::ERRMODE_SILENT 错误码
	//$conn->errorCode()
	//$conn->errorInfo()

    // 创建数据库
    $sql = "CREATE DATABASE 数据库名";
    $conn->exec($sql);
    echo "数据库创建成功";

创建数据表

    $sql = "CREATE TABLE IF NOT EXISTS user6 (
        id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
        username VARCHAR(30) NOT NULL COMMENT \"用户名\",
        password VARCHAR(64) NOT NULL COMMENT '密码',
        phone VARCHAR(11),
        status INT(1) NOT NULL DEFAULT 1,
        create_date TIMESTAMP
        ) COMMENT '用户'";
    $conn->exec($sql);

查询数据

	// 执行查询语句
    $sql = "SELECT * FROM user WHERE id<5";
    $result = $conn->query($sql);

    // 获取结果
    $result = $result->fetchAll(PDO::FETCH_ASSOC);
    var_dump($result);

更新数据

	$sql = "UPDATE user SET num = num+3 WHERE id =2";
    $stmt = $conn->exec($sql);
    var_dump($stmt);

删除数据

	$sql = "DELETE FROM user WHERE id =26";
    $stmt = $conn->exec($sql);

插入数据

和mysqli的类似，不做特殊说明了预处理

    // 执行插入语句
    $sql = "INSERT INTO 表名 (列1, 列2, 列3) VALUES (:value1, :value2, :value3)";
    $stmt = $conn->prepare($sql);

    // 绑定参数
    $stmt->bindParam(':value1', $value1);
    $stmt->bindParam(':value2', $value2);
    $stmt->bindParam(':value3', $value3);

    // 设置参数值
    $value1 = "值1";
    $value2 = "值2";
    $value3 = "值3";

    // 执行插入语句
    $stmt->execute();
    
	// 获取插入的条数
    $rowCount = $stmt->rowCount();

批量插入

    $sql = "INSERT INTO user (username, password, phone) VALUES (?,?,?)";
    $stmt = $conn->prepare($sql);

    // 执行插入语句
    $stmt->execute(["test1","1234","13888888888"]);
    $stmt->execute(["test2","1232","13888888888"]);

事务

事务（Transaction）是一组数据库操作的集合，这些操作要么全部成功执行，要么全部回滚（撤销）。事务提供了一种机制来确保数据库操作的一致性和完整性。

    try {
        // 开始事务
        $conn->beginTransaction();
    
        // 执行批量插入语句
        $sql = "INSERT INTO user (username, password, phone) VALUES (?,?,?)";
        $stmt = $conn->prepare($sql);
    
        $data = array(
            array("值1", "值2", "值3"),
            array("值4", "值5", "值6"),
            array("值7", "值8", "值9")
        );
        
        $insertedRows = 0;
        foreach ($data as $row) {
            $stmt->execute($row);
            $insertedRows += $stmt->rowCount();
        }
    
        // 提交事务
        $conn->commit();
    
        echo "批量插入成功";
    } catch(PDOException $e) {
        // 回滚事务
        $conn->rollback();
        echo "插入失败: " . $e->getMessage();
    }

作业：把PDO里没有用预处理的改为预处理方式。如果有时间，可以把上面的增删改查封装为一个DB类，方便调用。后面我们实战的时候也会讲PDO类的二次封装和调用。

cookie session

cookie

cookie 常用于识别用户。 cookie 是一种服务器留在用户计算机上的小文件。每当同一台计算机通过浏览器请求页面时，这台计算机将会发送 cookie。通过 PHP，能够创建并取回 cookie 的值。

创建cookie

setcookie(name, value, expire, path, domain);

参数说明：

name ：Cookie的名称。
value ：Cookie的值。
expire ：Cookie的过期时间，可以是一个Unix时间戳（例如： time() + 3600 表示一小时后过期），或者是一个具体的日期时间字符串（例如： "2024-01-01 00:00:00" ）。
path ：可选参数，指定Cookie的有效路径。默认为当前路径。
domain ：可选参数，指定Cookie的有效域名。默认为空，表示当前域名。
secure ：可选参数，指定是否仅通过安全的HTTPS连接传输Cookie。默认为 false 。
httponly：可选参数，指定是否仅通过HTTP协议访问Cookie。默认为 false 。

$expire=time()+60*60*24*7;
setcookie("username", "PHP", $expire);
setcookie("userid", "1", $expire);

setcookie("user[name]", "PHP", $expire);
setcookie("user[phone]", "18611112222", $expire);
setcookie("user[age]", "35", $expire);

获取cookie

// 输出 cookie 值
if(isset($_COOKIE["username"])){
	echo $_COOKIE["username"];
}	

// 查看所有 cookie
print_r($_COOKIE);

删除 Cookie

setcookie("username", "", time()-3600);

session

用于在服务器上存储关于用户会话（session）的信息，并且对于程序中的所有页面都是可用的。
会话信息是临时的，在用户离开网站后将被删除。
它允许在同一个用户的多个请求之间保持数据的状态，便于传递数据。 Session 的工作机制是：为每个访客创建一个唯一的 id (UID)，并基于这个 UID 来存储变量。UID 存储在 cookie 中，或者通过 URL 进行传导。

启动session

通常，将该函数放在PHP文件的顶部

session_start();

存取 Session 变量

一旦Session启动，可以使用 $_SESSION 超全局变量来存储和访问Session数据。

// 存储 session 数据 
$_SESSION['username']='PHP';

//取值
echo $_SESSION['username'];

if(isset($_SESSION['views']))
{
    $_SESSION['views']=$_SESSION['views']+1;
}
else
{
    $_SESSION['views']=1;
}
echo "浏览量：". $_SESSION['views'];

销毁 Session

if(isset($_SESSION['views']))
{
    unset($_SESSION['views']);
}

//销毁
session_destroy();

注意：session_destroy() 将重置 session，您将失去所有已存储的 session 数据

Session和Cookie的关系和区别

关系：

Session和Cookie都是用于在不同请求之间保持数据的状态。
Session使用Cookie来跟踪和标识用户，通过在Cookie中存储Session ID来关联服务器端的Session数据。

区别：

存储位置：Cookie数据存储在客户端的浏览器中，而Session数据存储在服务器端。
容量限制：Cookie的容量限制通常较小，一般为几KB，而Session的容量限制较大，通常取决于服务器的配置。
安全性：由于Cookie存储在客户端，可能会被篡改或窃取，因此存储敏感信息的安全性较低。相比之下，Session数据存储在服务器端，相对更安全。
生命周期：Cookie可以设置过期时间，可以在浏览器关闭后仍然保持，具有较长的生命周期。而Session通常在用户关闭浏览器或一段时间不活动后自动过期。
存储方式：Cookie以键值对的形式存储数据，可以在客户端进行读取和修改。Session数据存储在服务器端，客户端只保存了一个Session ID。

在实际应用中，Cookie通常用于存储一些较小、不敏感的数据，如用户首选项、购物车信息等。而Session通常用于存储用户的身份验证信息、敏感数据等，因为Session数据存储在服务器端，相对更安全。

实战案例：个人中心

案例介绍：我们会用最基础的原生 php 方式去做这个项目，不用任何前后端框架，考虑到一些学员没有前端基础，所以我会尽量少的使用 js，但会用到 fetch 请求等基础语句，并且 html 和 css 会有入门级的讲解（简单）；我会尽可能多的使用学到的知识，以达到学以致用的效果；我们会使用面向对象去对一些常用的方法进行封装，例如数据库操作，让大家学会在实际项目中使用类和对象。

讲解的内容：

什么是前端，什么是后端；什么是前台，什么是后台
页面搭建 (从 0 到 1)
什么是 json
简单的 Api 接口和请求
Php 调试代码
封装类
文件包含
数据库的使用
用户状态

![[Pasted image 20231116090904.png]]

用户注册

用户登录

用户中心

个人信息

登录记录

修改密码

退出登录

实战补充知识

`str_repeat()` 和 `rtrim ()` `ltrim()` 函数

`floor()` 和 `ceil()` `round()` 函数

`md5()` 加密

die 和 exit 函数

常量 DIRECTORY_SEPARATOR

Pdo 补充知识

$stmt->closeCursor() If($condition instanceof Closure)

`dirname ()`

dirname 函数用于返回指定路径的目录部分。它接受一个字符串参数，该参数是一个文件或目录的路径，并返回该路径的父级目录。

$path = '/var/www/html/index.php';
$directory = dirname($path);
echo $directory;  // 输出: /var/www/html

$path = '/var/www/html/';
$directory = dirname($path);
echo $directory;  // 输出: /var/www

$path = '/var/www/html';
$directory = dirname($path);
echo $directory;  // 输出: /var/www

header ()函数

header() 函数用于发送原始的 HTTP 头信息。它通常用于在服务器响应中设置 HTTP 头，例如设置重定向、设置响应状态码、设置内容类型等。

header(string $header, bool $replace = true, int $http_response_code = null): void

参数说明：

$header ：要设置的 HTTP 头信息，以字符串形式表示。
$replace （可选）：指定是否替换之前设置的相同类型的 HTTP 头信息。默认为 true ，表示替换。
$http_response_code（可选）：指定要设置的响应状态码。

//重定向
header("Location: ./login.php");
//设置响应状态码：
header("HTTP/1.1 404 Not Found");
//设置内容类型
header("Content-Type: application/json");

注意： header() 函数必须在发送任何实际输出之前调用，包括 HTML 标记、空格、换行符等。如果在输出之后调用 header() 函数，将会导致 "headers already sent" 错误。

静态变量的使用

与类或函数相关联，而不是与对象或函数的实例相关联。静态变量在整个脚本的执行过程中保持其值不变。

类

class MyClass {
    public static $count = 0;
    public static function toObj()
    {
      return new self;
    }
    public function plusCount() {
        self::$count++;
        echo self::$count.PHP_EOL;
    }
}
MyClass::toObj()->plusCount();
MyClass::toObj()->plusCount();
MyClass::toObj()->plusCount();
echo MyClass::$count;

普通函数

静态变量只在函数的作用域内有效，不同函数中的同名静态变量是相互独立的

function myFunction() {
    static $count = 0;
    
    $count++;
    echo $count.PHP_EOL;
}

function mySecond() {
    static $count = 0;
    echo $count.PHP_EOL;
}
myFunction();
myFunction();
myFunction();

mySecond();

关于phpinfo()

php讲课思路与大纲

Sat, 01 Jun 2024 00:00:00 GMT

PHP流程控制语句知识点：

一、条件判断语句：

1. if语句

这是个选择语句，代码如下

# 基础语法
if (条件) {//这里的条件是一个bool类型的值（true,false），当这里的条件为true时进入大括号内（执行大括号内的代码块）。
  代码块;//代码块内写想要执行的代码
}

# if...else 除了基础语法的if语句还有一个适用于不属于条件1的其他结果，就是if...else...
if(条件){
    代码块1;//代码块1内写想要执行的代码
}else{
    代码块2;//此处写当条件的结果为false时，进入else的代码块。
}

# if...elseif...else... 这个就用于多条件判断（根据两个以上的条件执行不同的代码）
if (条件1) {
  条件1为 true 时执行的代码;
} elseif (条件2) {//当代码运行到此处就代表条件1的结果为false，再判断条件2的结果，如果也为false那就继续往下走（条件2的方法体不执行！！）
  条件2为 true 时执行的代码;
} else {
  条件为 false 时执行的代码;
}

# 例子：
$time = rand(0,23);//这里的作用是调用rand方法生成随机数（0-23之间）-------（1）
if($time>=7&&$time<12){//这里的作用是判断时间在7-12点之间 ---------------（2）
    echo '早上好，又是美好的一天';
}elseif($time>=12&&$time<2){//同（1）
    echo '中午啦，起来重睡';//同（2）
}elseif($time>=2&&$time<8){//同（1）
    echo '下午了，想想晚上吃啥';//同（2）
}else{//当代码运行到这里代表上面条件都为false，此时执行else中的代码。
    echo '这都几点了，还不睡？？？'//同（2）
}

通过上述模板和例子，我们可以明白if选择语句的基础用法，同时也明白每个区域的作用。

注：在php中if的执行语句块为一行的时候，可以神略大括号！

2. switch语句：

如果您希望有选择地执行若干代码块之一，请使用 Switch 语句。使用 Switch 语句可以避免冗长的 if..elseif..else 代码块。

switch要搭配case关键字来使用，但是要注意在代码内有一个异常情况，我介绍完例子会解释

# 标准语法
switch (表达式){//这里的表达式一般为基础数据表达式
case 值1://case关键字用于判断表达式的值是否等于后面的值，若为true则执行冒号（:）后面的代码块，若为false则继续判断
  表达式 = 值1 时执行的代码 ;
  break;  //这个break是个重点，我下面会说
case 值2://...
  表达式 = 值2 时执行的代码 ;
  break;
default://这里代表上面的条件都为true时执行这里的内容，也可以看作“默认执行方法”
  表达式的值不等于 值1 及 值2 时执行的代码;
}

注:当break不写的时候，可能会存在数据穿透的异常，可能会把结果为true后的的所有代码块都执行（在开发中要十分注意）

二、循环控制语句：

3. while循环：

在编写代码时，经常需要反复运行同一代码块。所以我们可以使用循环来重复执行这样的任务，而不是在脚本中添加若干几乎相等的代码块，使整个代码十分臃肿。

while - 只要指定条件为真，则循环代码块

示例代码及解释如下

while (条件为真) {
  要执行的代码;
}
# 这个真没啥讲的，举个例子吧
# 比如:康总需要反复往返于郑州和新郑,就是典型的循环结构.假设康总投资这个项目需要往返郑州100次,每次访问都会计数一次.难道写一百遍同样的代码?显然对于智商极高的程序员来说不可能这样处理。
# 示例：

//while后面接布尔值判断,为真执行,为假停止
$count=0;
//循环开始处
while($count < 100){//$count小于100的时候执行,也就是$count为0至99的时候执行.如果$count不小于100了,循环停止执行后续的代码
    echo "这是康总第 $count 次出差";
    PHP_EOL;//这行相当于html中的<br>换行
    //每次执行让$count+1,这样的话,就不会产生$count永远小于100的情况了
    $count++;
}
//循环结束

4. do…while循环：

说说区别吧:do…while与while的语法结构基本一样,也是一个布尔型循环,功能也基本一样.基础语法如下

do{
   代码块;
}while(判断)

do…while与while区别是,它们的值得检查时机不同. do…while不论while判断是否成立,先执行一次代码块循环语句,保证会执行一次(表达式的真值在每次循环结束后检查) 然而我们之前的while循环会检查条件表达式,结果为true则执行,结果为false则不执行.

$i=0;
do {
  echo $i++;
}while($i<0);
//输出结果是0
//这里涉及到两个知识点
1, 已知$i=0，在while后面的条件判断中，判断条件为$i<0 (结果为false)，但是却执行了一次循环，代表了什么？
    代表do...while就算结果是false也最少执行一次。
2, echo $i++ 输出为0，应为 $i++ 的意义是先赋值再自加一（也可见说先传值）

5. for循环：

如果您已经提前确定脚本运行的次数，可以使用 for 循环。基础语法如下

for (表达式1;表达式2;表达式3) {
/*
    1、表达式1是初始化赋值,可以同时赋值多个代码;
    2、表示式2在每次循环开始前求值,如果值为true,则继续循环,执行嵌套的循环语句,如果值为false,则终止循环.
    3、表达式3在每次循环之后被求值.
    4、表达式1和表达式3是可以不在括号内写.
*/
  代码块;
}

# 我举个例子吧，当你需要计算1-100的和
$sum = 0;//初始化一个值用于存储每次循环结束的结果
for($i = $sum;$i <= 100;$i++){//这行的意思是定义了一个变量$i让他等于$sum，为什么第二次循环不把第一次循环结束的$sum再重新赋值给$i?
    						//	因为for循环中表达式一中的初始化赋值只赋值一遍！
    $sum += $i;//+=赋值运算
}
echo $sum;//结果是5050

6. foreach循环：

foreach 循环只适用于数组，并用于遍历数组中的每个键/值对。

foreach ($array as $value) {
  代码块;
}
//每进行一次循环迭代，当前数组元素的值就会被赋值给 $value 变量，并且数组指针会逐一地移动，直到到达最后一个数组元素。
$phone = array("huawei","vivo","oppo","mi","iphone");//创建数组
foreach($phone as $value) {//数组值赋值给 $value 变量
   echo "Value=" . $value;//打印！
   echo "<br>";//换行
}
# 用的有点少，自己补充一下啊哈！！

三、跳转控制语句：

7. break语句：

break是被用在上面所提的各种循环和switch语句中的。他的作用是跳出当前的语法结构，执行下面的语句。break语句可以带一个参数n，表示跳出循环的层数，如果要跳出多重循环的话，可以用n来表示跳出的层数，如果不带参数默认是跳出本重循环。

就不举例了，很简单的！

8. Continue语句：

continue是用来用在循环结构中，控制程序放弃本次循环continue语句之后的代码并转而进行下一次循环。continue本身并不跳出循环结构，只是放弃这一次循环。如果在非循环结构中(例如if语句中，switch语句中)使用continue，程序将会出错。

太晚了，这个咱就自力更生吧！

PowerEdge R720 上安装 ESXi 8

Sat, 01 Jun 2024 00:00:00 GMT

在 PowerEdge R720 上安装 ESXi 8

这是在我的 poweredge r720 上全新安装 ESXi 8 的演练，我正在使用 VMware 站点中的自定义戴尔映像，并且我正在使用 force 选项安装 ESXi 8，因为我的硬件被认为是旧的。

下载戴尔自定义映像

VMware vSphere - VMware Customer Connect

下载ESXi 8戴尔自定义映像后，使用Rufus将其转换为USB可启动驱动器并将其插入服务器。

否则，如果您有 IDRAC，则可以将 iso 附加到那里。

进入 bios 启动管理器以从 USB 驱动器 F11 启动它

选择 BIOS 启动菜单

选择插入 USB 驱动器的位置。

在安装程序上按回车键

重要！！！！

解决方法如下：

1，在安装时ESXI 8.0启动的第一个画面，按shift + O组合键，速度要快。

2，在显示的cdromBoot runweasel后输入autoPartitionOSDataSize=10240

完整显示：cdromBoot runweasel autoPartitionOSDataSize=10240，注意大小写，8192表示指定OSDataSzie为10GB，对比6.7系统，给出8GB完全可以满足VMware tools、scratch以及coredump空间的需求。

按回车键继续

推动 F11 接受协议

选择要安装 ESXi 8 的驱动器

选择键盘布局

输入要用于 root 帐户的密码

按回车键

按回车键可强制安装不受支持的 ESXi 8

F11 安装

移除 USB 驱动器并按回车键

转到 BIOS 启动管理器

选择 BIOS 引导菜单

选择安装了 ESXi 8 的驱动器

按 F2 自定义系统

输入密码并按回车键

进入配置管理网络，按回车键

Go VLAN 并按回车键

输入管理VLAN并按回车键

转到 IPv4 配置

选择“设置静态 ipv4”，键入 IP 地址、子网掩码和默认网关，然后按回车键

选择DNS配置并按回车键

选择使用以下 dns 服务器，然后键入 esxi 主机的 dns IP 地址和 fqdn。

按回车键

按压 Esc

按 Y 键重启管理网络

选择测试管理网络并按回车键

按回车键

按压 Esc

转到浏览器并输入 esxi 主机的 FQDN

https://esxi-mon-00.vmware.local/

输入凭据

取消勾选加入，然后单击确定

全部完成后，不要忘记输入您的许可证密钥，以免它在 60 天后过期

PVE直通物理磁盘到 Proxmox VM 虚拟机

Sat, 01 Jun 2024 00:00:00 GMT

<hr>

准备工作-PVE开启iommu直通

1.进入PVE WEB端的管理页面并登陆,打开PVE节点的shell，输入命令： 要忽略 dmesg 输出中的一些烦人的错误，请运行以下命令(# 这一步对于直通来说不是必需的，但有助于保持干净。)

nano /etc/modprobe.d/kvm.conf
options kvm ignore_msrs=Y report_ignored_msrs=0
# 按 Ctrl + X，然后按 Y + Enter 保存更改。

**2.启动内核IOMMU支持 IOMMU（Input-Output Memory Management Unit）是一种硬件功能，用于管理设备对系统内存的访问。启用 IOMMU 后，可以在虚拟机中直接访问物理设备，并允许虚拟机独立于主机操作系统运行 **

nano /etc/default/grub # 将以下行粘贴到其中，并在旧标签前面添加一个注释标签#,以下为常用的一些写法。
# 对于 Intel CPU
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt initcall_blacklist=sysfb_init pcie_acs_override=downstream,multifunction pci=nommconf"
# 对于 AMD CPU (本文不涉及)
GRUB_CMDLINE_LINUX_DEFAULT="quiet iommu=pt initcall_blacklist=sysfb_init pcie_acs_override=downstream,multifunction pci=nommconf"
# 其他的一些写法(如果是AMD处理器,将intel改为amd)
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt i915.enable_gvt=1 video=efifb:off" # 这是GVT模式，也就是共享模式，少部分cpu支持，但体验很好
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt video=efifb:off" # 这是独占模式，都支持，但显示器没有pve的控制台输出，也只能直通个一个虚拟机
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt pcie_acs_override=downstream,multifunction"
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on initcall_blacklist=sysfb_init pcie_acs_override=downstream,multifunction"
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on" #本期教程我使用的就是这个
# 参数释义
1.iommu=pt：启用 Intel VT-d 或 AMD-Vi 的 IOMMU。这是一种硬件功能，用于管理设备对系统内存的访问。在虚拟化环境中，启用 IOMMU 后，可以将物理设备直通到虚拟机中，以便虚拟机可以直接访问硬件设备。“iommu=pt”不是必须的，PT模式只在必要的时候开启设备的IOMMU转换，可以提高未直通设备PCIe的性能，建议添加。
2.initcall_blacklist=sysfb_init：禁用 sysfb_init 内核初始化函数。这个函数通常用于在内核启动过程中初始化系统帧缓冲。在使用 GPU 直通的情况下，这个函数可能会干扰直通操作，因此需要禁用它。
3.i915.enable_gvt=1：启用 Intel GVT-g 虚拟 GPU 技术。这个选项用于创建一个虚拟的 Intel GPU 设备，以便多个虚拟机可以共享物理 GPU 设备。启用 GVT-g 需要在支持虚拟 GPU 的 Intel CPU 和主板上运行，并且需要正确配置内核和虚拟机。想开启GVT-g的就添加这条，显卡直通的就不要添加了。
4.initcall_blacklist=sysfb_init：屏蔽掉pve7.2以上的一个bug，方便启动时候就屏蔽核显等设备驱动；
5.pcie_acs_override=downstream,multifunction：便于iommu每个设备单独分组，以免直通导致物理机卡死等问题
6.pci=nommconf：意思是禁用pci配置空间的内存映射,所有的 PCI 设备都有一个描述该设备的区域（您可以看到lspci -vv），访问该区域的最初方法是通过 I/O 端口，而 PCIe 允许将此空间映射到内存以便更简单地访问。

3.使用以下命令更新 grub

update-grub

更新后可以重启电脑

reboot

4.主机重新启动并运行后，运行以下命令,验证是否开启iommu

dmesg | grep -e DMAR -e IOMMU -e AMD-Vi
# 如果没有输出，则说明有问题。你应该看到这样的东西；“DMAR: IOMMU enabled”
# 另外一种验证方式
dmesg | grep iommu
# 出现如下例子。则代表成功
[ 1.341100] pci 0000:00:00.0: Adding to iommu group 0
[ 1.341116] pci 0000:00:01.0: Adding to iommu group 1
[ 1.341126] pci 0000:00:02.0: Adding to iommu group 2
[ 1.341137] pci 0000:00:14.0: Adding to iommu group 3
[ 1.341146] pci 0000:00:17.0: Adding to iommu group 4
# 此时输入命令
find /sys/kernel/iommu_groups/ -type l
# 出现很多直通组，就代表成功了。如果没有任何东西，就是没有开启

5.对于某些平台，可能需要允许不安全中断。运行以下命令

nano /etc/modprobe.d/iommu_unsafe_interrupts.conf # 添加以下行；请注意，此选项可能会使您的系统不稳定。
options vfio_iommu_type1 allow_unsafe_interrupts=1

6.启用必要的内核模块，运行以下命令

nano /etc/modules # 添加以下行；
vfio
vfio_iommu_type1
vfio_pci
vfio_virqfd

7.将驱动程序模块列入黑名单，以使虚拟机能够完全访问显卡等。运行以下命令

nano /etc/modprobe.d/pve-blacklist.conf # 添加以下行；
blacklist nouveau
blacklist nvidia
blacklist nvidiafb
blacklist snd_hda_codec_hdmi
blacklist snd_hda_intel
blacklist snd_hda_codec
blacklist snd_hda_core
blacklist radeon
blacklist amdgpu
blacklist i915
options vfio_iommu_type1 allow_unsafe_interrupts=1
# 如果有重复项,记得删除,解释：屏蔽三大显卡驱动，屏蔽hdmi声音驱动；options

8**.查看直通设备**

#执行 lspci -nn 可命令查看需要直通设备

9.更新模块并重新启动主机以应用更改

update-initramfs -u -k all
reboot

<hr>

硬盘直通详细操作步骤

方式一：

直接PCI添加硬盘 (这里不推荐)

方式二：

1.在“数据中心->pve->磁盘”选项卡下，查找您想要直通给虚拟机的目标磁盘。找到它后，记下它的名称串行序列号(我的是9XG9TM11)。注:可选步骤；点击擦除磁盘。这将删除磁盘的所有内容并将其完全擦除，因此请确保上面没有留下任何重要的内容！

2.接下来，在 Shell 终端中输入以下内容

find /dev/disk/by-id/ -type l|xargs -I{} ls -l {}|grep -v -E '[0-9]$' |sort -k11|cut -d' ' -f9,10,11,12

然后它会显示您想要的磁盘的完整路径。像这样复制路径并记下它。

/dev/disk/by-id/{disk-serial}
我的是:/dev/disk/by-id/ata-ST91000640NS_9XG9TM11

3.进入您要为其提供磁盘的虚拟机的“硬件”选项卡，并查看当前的磁盘类型（类型一般为scsi1、virtio0等），避免后续直通冲突。

再次返回 Shell 终端，然后输入

qm set {vmid} -{disk-type}{number} /dev/disk/by-id/{disk-serial}

对于 Linux，硬盘类型推荐； SCSI。对于 Windows ，硬盘类型推荐； sata。例子win（qm set 101 -sata1 /dev/disk/by-id/ata-ST91000640NS_9XG9TM11）例子linux（qm set 100 -virtio1 /dev/disk/by-id/ata-ST91000640NS_9XG9TM11）只要出现这个就代表挂载成功

前往101虚拟机->硬件中查看

成功了！

racamd重置idrac密码

Sat, 01 Jun 2024 00:00:00 GMT

ESXi版本的racadm 下载地址:https://www.dell.com/support/home/zh-cn/drivers/driversdetails?driverid=jywk1

ESXi下载的文件名为DellEMC-iDRACTools-Web-ESXi.VIB-9.4.0-3749_A00.tar.gz

通过xftp或者ESXi网页版上传到ESXi的目录中

ESXi目录为/vmfs/volumes/604454ef-89990d88-e0fe-1418776fbf60

xftp可以直接传到根目录/

以根目录为例

# 解压
tar -xvf DellEMC-iDRACTools-Web-ESXi.VIB-9.4.0-3749_A00.tar.gz
# 切换目录
cd /iDRACTools/racadm/ESXi67
# 执行
esxcli software vib install -d Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip
# 结果报错
[MetadataDownloadError]
 Could not download from depot at zip:/var/log/vmware/Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip?index.xml, skipping (('zip:/var/log/vmware/Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip?index.xml', '', "Error extracting index.xml from /var/log/vmware/Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip: [Errno 2] No such file or directory: '/var/log/vmware/Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip'"))
        url = zip:/var/log/vmware/Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip?index.xml
 Please refer to the log file for more details.
# 报错原因是没传全路径，执行
esxcli software vib install -d /vmfs/volumes/datastore1/iDRACTools/racadm/ESXi67/Racadm-Dell-EMC-Web-9.4.0-3749.VIB-ESX67i.zip 
# 安装成功，执行
racadm getsysinfo

安装完成

使用racadm命令获取root用户id；

racadm getconfig -u root

使用racadm命令重置root用户密码；

racadm set iDRAC.Users.2.Password 123456    #123456为重置后的密码

提示密码重置成功。

远程桌面出现CredSSP无法连接

Sat, 01 Jun 2024 00:00:00 GMT

Windows远程桌面出现CredSSP加密数据修正问题解决方案

问题现象:**

解决方案：**

<h4 style="color:red;" >专业版请看方案一，家庭版请看方案二</h4>

方案一：**

1、win+R打开运行窗口

2、输入gpedit.msc命令，点击“确定”

3、依次展开“计算机配置”->“管理模板”->“系统”->“凭据分配”设置名称：加密数据库修正

4、双击“加密数据库修正”，将状态改为“启用”，保护级别改为“易受攻击”，应用—>确定

方案二：**

1、win+R打开运行窗口

2、输入regedit命令，点击“确定”，打开注册表文件

3、在注册表中进入如下路径：

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\CredSSP\Parameters

注意“一般系统下，大概到了System后面再没有后面的路径，需要自行手动新建”

先新建项“CredSSP”，然后在CredSSP下新建项“Parameters”

然后在“Parameters”下新建DWORD(32位)，名称为“AllowEncryptionOracle”，设置值为“2”。

然后进行尝试，如果不行，请重启一下自己的计算机。

RustDesk中继以及管理端搭建教程

Sat, 01 Jun 2024 00:00:00 GMT

<hr>

想必大家都有了解RustDesk吧，它分为社区版和专业版，专业版多了后台管理的功能，但是收费十分的昂贵！！下面我教大家用GitHub开源的后端管理项目来部署。

项目来源：lejianwen/rustdesk-api: Custom Rustdesk Api Server, include web admin ,web client and odic login

作者其实写的已经很详细了，但是有些配置地方，我要补充一下，本次使用的服务端管理平台是1Panel，这个平台安装教程十分简单，我在这里就不赘述了。具体可以看官网。

新建模板

1，进入1panel之后，按照以下步骤点击

2，名称我们可以随意，将docker compose复制到对应位置

networks:
  rustdesk-net:
    external: false
services:
  hbbs:
    container_name: hbbs
    ports:
      - 21115:21115
      - 21116:21116 # 自定义 hbbs 映射端口
      - 21116:21116/udp # 自定义 hbbs 映射端口
      - 21118:21118 # web client
    image: rustdesk/rustdesk-server
    command: hbbs -r 服务器公网:端口 -k <key> # 填入个人域名或 IP + hbbr 暴露端口 这里的key要保证和下面的key一样，并且可以自己编写,端口需要和下面的hbbr端口一样，默认是21117
    volumes:
      - ./data:/root # 自定义挂载目录
    networks:
      - rustdesk-net
    depends_on:
      - hbbr
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 64M
  hbbr:
    container_name: hbbr
    ports:
      - 21117:21117 # 自定义 hbbr 映射端口
      - 21119:21119 # web client
    image: rustdesk/rustdesk-server
    command: hbbr -k <key>  # 与上文的key相同
    volumes:
      - ./data:/root
    networks:
      - rustdesk-net
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 64M
  rustdesk-api:
    container_name: rustdesk-api
    environment:
      - TZ=Asia/Shanghai
      - RUSTDESK_API_RUSTDESK_ID_SERVER=服务器公网IP:21116 #这里都需要替换为您的公网ip
      - RUSTDESK_API_RUSTDESK_RELAY_SERVER=服务器公网IP:21117 #这里都需要替换为您的公网ip
      - RUSTDESK_API_RUSTDESK_API_SERVER=http://服务器公网IP:21114 #这里都需要替换为您的公网ip
      - RUSTDESK_API_RUSTDESK_KEY=<key>
    ports:
      - 21114:21114
    image: lejianwen/rustdesk-api
    volumes:
      - /data/rustdesk/api:/app/data #将数据库挂载出来方便备份
    networks:
      - rustdesk-net
    restart: unless-stopped

创建容器

这里无论如何，在核对一边是否填完整，不然很麻烦

看到这个就代表成功了

完结

当看到这三个容器正常运行，即代表配置成功

访问http://ip:21114即可登录后台，默认账户密码为admin/admin

然后就可以配置了

测试上下传网速

Sat, 01 Jun 2024 00:00:00 GMT

Speedtest 是一个旧宠。它用 Python 实现，并打包在 Apt 中，也可用 pip 安装。你可以将它作为命令行工具或在 Python 脚本中使用。

使用以下命令安装：

sudo apt install speedtest-cli
sudo yum install speedtest-cli

或者

sudo pip3 install speedtest-cli

然后使用命令 speedtest 运行它：

$ speedtestRetrieving speedtest.net configuration...Testing from CenturyLink (65.128.194.58)...Retrieving speedtest.net server list...Selecting best server based on ping...Hosted by CenturyLink (Cambridge, UK) [20.49 km]: 31.566 msTesting download speed................................................................................Download: 68.62 Mbit/sTesting upload speed......................................................................................................Upload: 10.93 Mbit/s

它给你提供了互联网上传和下载的网速。它快速而且可脚本调用，因此你可以定期运行它，并将输出保存到文件或数据库中，以记录一段时间内的网络速度。

系统镜像站

Sat, 01 Jun 2024 00:00:00 GMT

CentOS下载时版本选择：

 1. DVD版：常用版本，就是普通安装版，推荐。里面包含大量的常用软件，大部分情况下安装时无需再在线下载，体积为4G左右。	
 2. Everything版：包含所有软件组件，体积庞大，是DVD版的2倍
 3. LiveCD版：是一个光盘CentOS系统，可通过光盘启动电脑，启动出CentOS系统，也有图形界面，也有终端。也可以安装到计算机，但是有些内容可能还需要再次到网站下载
 4. Minimal版：精简版本，包含核心组件，体积600多MB
 5. NetInstall版：网络安装版本，一般不用这个版本

阿里巴巴开源镜像站-OPSX镜像站-阿里云开发者社区 (aliyun.com)

华为开源镜像站_软件开发服务_华为云 (huaweicloud.com)

清华大学开源软件镜像站 | Tsinghua Open Source Mirror

欢迎访问网易开源镜像站 (163.com)

Ubuntu开启root的ssh链接

Sat, 01 Jun 2024 00:00:00 GMT

1、先进行一下更新软件列表和更新软件，在此之前可以先换国内源，本文就不写了，官方源一样安装ssh。

sudo apt-get update
sudo apt-get upgrade

安装配置SSH

4.1 具体配置SSH步骤

#1、安装openssh-client
sudo apt install openssh-client
#2、安装openssh-server
sudo apt install openssh-server
#3、ssh服务重启
service  ssh  restart

#4、安装net-tools (使用ifconfig时，需要net-tools)
sudo apt install net-tools

#5、查看ip,找到inet的值
ifconfig
#6、验证SSH是否正在运行
sudo systemctl status ssh

##如果为inactive（dead）,可以手动开启SSH##
/etc/init.d/ssh start

#补充：
#启用ssh的指令
启动ssh服务：
#sudo /etc/init.d/ssh start
停止ssh服务：
#sudo /etc/init.d/ssh stop
重启ssh服务：
#sudo /etc/init.d/ssh restart

修改sshd_config的内容

root用户在命令行或图形化界面中，也是无法直接登录，这是因为ubuntu23.04系统默认root用户是无法直接登录，需要先登录普通用户($)，后使用su root命令切换到root用户(#)。

正确设置和使用root用户后，此时会发现root用户仍然无法直接登录xftp等远程登录软件，想要直接远程登录root用户需要配置系统sshd_config文件，该文件位于/etc/ssh/sshd_config 。

4.3.1 修改内容

#具体的操作步骤如下:
1、编辑sshd_config
sudo nano /etc/ssh/sshd_config  
或者(不推荐)
sudo vim /etc/ssh/sshd_config

3、将PermitRootLogin prohibit-password修改为PermitRootLogin yes，去掉前面的#号，表示允许root登录。。
   将port 22前面的#去掉。
 
  或者
3、将port 22前面的 #符号删除。
在Authentication的配置后面，增加上 PermitRootLogin yes ，表示允许root登录。
   


4、保存

5、cat /etc/ssh/sshd_config  或者cat sshd_config 查看是否修改成功

6、重启SSH服务(最后一步)。
service ssh restart
或者
/etc/init.d/ssh restart

效果图如下

Ubuntu获取本地root登录

Sat, 01 Jun 2024 00:00:00 GMT

使用过Ubuntu的都知道,在本地安装Ubuntu桌面版时,会让我们创建一个普通用户,用户目录(即~目录)在/home/[username]/,在使用一些命令时需要在命令前加sudo然后输入密码才能获得权限才能执行,这样使用就很麻烦.而购买过阿里云、华为云等云服务器的都知道,购买的服务器版本,直接给我们root用户使用,用户目录在/root/,在执行几乎所有的命令都有权限,不需要加sudo,用起来很方便. 那么下面就记录一下Ubuntu桌面版设置root用户并使用root用户登录的方法.

设置root密码 1)登录普通用户,打开终端(方法很多,比如桌面空白如右键菜单,选择'打开终端') 2)输入命令sudo passwd root,提示输入当前用户的密码 3)提示'输入新的UNIX密码',输入要设置的root密码,提示'重新输入新的UNIX密码',再输入一次root密码 4)提示 'passwd:已成功更新密码'
设置root用户登录图形桌面 1)在终端中输入命令sudo vim /etc/pam.d/gdm-autologin (前提是系统中安装有vim编辑器,安装命令是sudo apt-get install vim,也可以使用vi编辑器或nano编辑器) 2)注释'auth requied pam_succeed_if.so user != root quiet success'这一行,保存退出 3)在终端输入命令sudo vim /etc/pam.d/gdm-password 4)注释'auth requied pam_succeed_if.so user != root quiet success'这一行,保存退出 5)在终端输入命令sudo vi /root/.profile 6)在'mesg n || true'这一行前添加'tty -s && ',改为'tty -s && mesg n || true' 7)重启计算机,此时可以用ROOT用户登录,也可以使用原来安装时自己创建的普通用户登录,但是选择了普通用户后的用户选择列表并没有root用户,需要点击未列出手动输入root和密码来登录

Ubuntu获取root权限

Sat, 01 Jun 2024 00:00:00 GMT

$是普通管员，#是系统管理员，在Ubuntu下，root用户默认是没有密码的，因此也就无法使用（据说是为了安全）。想用root的话，得给root用户设置一个密码：

在终端中输入：

sudo passwd root

如果想获得root权限，只需进行如下的操作：

su root

如果要再次禁用 root 帐号，那么可以执行

sudo passwd -l root

如果需要让此用户有root权限，执行命令：

root@pc-googlh:# visudo

修改文件如下：

# User privilege specification
root    ALL=(ALL:ALL) ALL
googlh  ALL=(ALL:ALL) ALL

最后Ctrl + O写入，然后Ctrl + X退出

查看里面的文件是否写入

root@pc-googlh:# sudo vim /etc/sudoers

退出：:qa 回车

vim安装方法：

root@pc-googlh:# apt-get install vim

ubuntu建用户最好用adduser，虽然adduser和useradd是一样的在别的linux糸统下，但是我在ubuntu下用useradd时，并没有创建同名的用户主目录。使用adduser 会自动创建用户主目录，创建用户同名的组。

root@pc-googlh:~# sudo adduser linuxidc

Ubuntu换源

Sat, 01 Jun 2024 00:00:00 GMT

本文系原创，转载请注明出处 update 2022.04.23:

Ubuntu 22.04 的稳定版已经于 2022 年 4 月 21 日发布，Ubuntu 22.04 稳定版下载地址：https://ubuntu.com/download/desktop

Ubuntu 22.04 的稳定版计划于 2022 年 4 月 21 日发布。开发工作已经在紧锣密鼓地进行，它将遵循如下发布时间表：

2022 年 2 月 24 日：功能冻结
2022 年 3 月 17 日：用户界面冻结
2022 年 3 月 31 日：测试版发布
2022 年 4 月 14 日：候选版本
2022 年 4 月 21 日：最终稳定版本

Linux 5.15 LTS是Ubuntu 22.04的默认内核，GCC 11.2是默认的系统编译器，Mesa 22.0提供开源图形驱动支持。Canonical一直在为Ubuntu开发新的桌面安装程序，但是随着22.04 LTS的发布，现有的Ubiquity仍然是默认使用的。

如果你想在备用机器或虚拟机上测试它，你可以从 Ubuntu 的网站下载Ubuntu 22.04 每日构建版。下载 Ubuntu 22.04 每日构建（不稳定）https://cdimage.ubuntu.com/daily-live/current/ 国内有很多Ubuntu的镜像源，包括阿里的、网易的，还有很多教育网的源，比如：清华源、中科大源。我们这里以清华源为例讲解如何修改Ubuntu 22.04里面默认的源。编辑/etc/apt/sources.list文件, 在文件最前面添加以下条目(操作前请做好相应备份)：

清华源

# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-updates main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-backports main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-security main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-security main restricted universe multiverse

# 预发布软件源，不建议启用
# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-proposed main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-proposed main restricted universe multiverse

然后执行命令：

sudo apt-get update
sudo apt-get upgrade

其他几份国内源如下：

阿里源

deb http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse

中科大源

deb https://mirrors.ustc.edu.cn/ubuntu/ jammy main restricted universe multiverse
deb-src https://mirrors.ustc.edu.cn/ubuntu/ jammy main restricted universe multiverse
deb https://mirrors.ustc.edu.cn/ubuntu/ jammy-updates main restricted universe multiverse
deb-src https://mirrors.ustc.edu.cn/ubuntu/ jammy-updates main restricted universe multiverse
deb https://mirrors.ustc.edu.cn/ubuntu/ jammy-backports main restricted universe multiverse
deb-src https://mirrors.ustc.edu.cn/ubuntu/ jammy-backports main restricted universe multiverse
deb https://mirrors.ustc.edu.cn/ubuntu/ jammy-security main restricted universe multiverse
deb-src https://mirrors.ustc.edu.cn/ubuntu/ jammy-security main restricted universe multiverse
deb https://mirrors.ustc.edu.cn/ubuntu/ jammy-proposed main restricted universe multiverse
deb-src https://mirrors.ustc.edu.cn/ubuntu/ jammy-proposed main restricted universe multiverse

网易163源

deb http://mirrors.163.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-security main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-backports main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-security main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-updates main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-backports main restricted universe multiverse

VMware Workstation 与 Hyper-V 不兼容

Sat, 01 Jun 2024 00:00:00 GMT

解决VMware Workstation 与 Hyper-V 不兼容。请先从系统中移除 Hyper-V 角色，然后再运行 VMware Workstation的最全详解

问题点：VMware Workstation 与 Hyper-V 不兼容。

一、请先从系统中移除 Hyper-V 角色，然后再运行 VMware Workstation。

1、控制面板->控制面板->程序->启用或关闭Windows功能-> 找到Hyper-V，点击关闭 2、然后win +x ,以windows powershell(管理员)身份运行运行命令：

bcdedit /set hypervisorlaunchtype off

然后重启电脑即可

如果解决不了，往下看

二、如果系统中找不到Hyper-V

复制下面代码，命名为Hyper-V.cmd，然后以管理员身份运行，等待，再重启电脑代码如下（）：

pushd "%~dp0"
dir /b %SystemRoot%\servicing\Packages\*Hyper-V*.mum >hyper-v.txt
for /f %%i in ('findstr /i . hyper-v.txt 2^>nul') do dism /online /norestart /add-package:"%SystemRoot%\servicing\Packages\%%i"
del hyper-v.txt
Dism /online /enable-feature /featurename:Microsoft-Hyper-V-All /LimitAccess /ALL

最后输入Y,重启电脑即可

三、系统中Hyper-V显示关闭，依旧报错

此时，只能修改注册表，然后重启电脑具体步骤（示例）： win+R ->regedit 然后依次点击，如下图\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity 双击，各个名称，将最后两个修改为0，然后重启电脑即可

vue 无法加载文件 CUsersXXXAppDataRoamingnpmvue.ps1，因为在此系统上禁止运行脚本

Sat, 01 Jun 2024 00:00:00 GMT

vue : 无法加载文件 C:\Users\XXX\AppData\Roaming\npm\vue.ps1，因为在此系统上禁止运行脚本

经过不断的查资料我知道了正确的解决办法，如下：首先要启动PowerShell（以管理员身份）

点击“开始”单击“ Windows PowerShell”然后右键点击Windows PowerShell，单击“以管理员身份运行”即以管理员身份启动
这时候右键单击如下图图标选择管理员那个运行

最后运行powershell（管理员身份）输入 set-ExecutionPolicy RemoteSigned 就可以完美解决了。

windows 安全中心Defender 存在威胁（历史记录），但点执行操作无反应，一直存在红叉

Sat, 01 Jun 2024 00:00:00 GMT

windows 安全中心/Defender 存在威胁（历史记录），但点执行操作无反应，一直存在红叉

1 问题详细描述分析

windows安全中心一直显示一个红叉，有一个威胁存在（可能这个威胁发现的时间很久之前，并不一定是当时扫描出来的），推荐你执行操作，但点击执行操作后无任何反应，威胁依然存在

点击快速扫描后，并没有发现任何威胁，大概断定，这个问题是历史出现威胁，你手动或者其他软件把威胁处理后，windows的系统记录却奇怪的保留下来导致一直显示威胁，你执行操作也不会有任何用（这个威胁实际已经不存在了，windows的奇怪bug）

(3) 删除DetectionHistory目录下的相关文件（问题最终解决方案，权限问题已解决）

删除C:\ProgramData\Microsoft\Windows Defender\Scans\History\Service\DetectionHistory文件夹下的所有子文件夹即可（子文件夹名称应该均为数字），这样保护历史记录里“已组织访问受保护的文件夹”相关记录也被清除了，问题便得到解决

有的帖子建议也删除C:\ProgramData\Microsoft\Windows Defender\Scans\History\Results中子文件夹Quick和Resource里的文件删除，这个重启Windows后查看快速扫描的记录不见了，个人觉得没必要删除。

这种方法主要的坑在于权限问题，本人是通过安全模式启动删除成功的。

在文件资源管理器进入C:\ProgramData\Microsoft\Windows Defender\Scans\因为权限问题直接进不去，如下：

安全模式打开删除DetectionHistory方法

Win+R打开运行，输入msconfig点击确定，引导，安全引导，确定后点击重启电脑，重启后进入安全模式即可通过文件资源管理器进入C:\ProgramData\Microsoft\Windows Defender\Scans\History\Service\DetectionHistory文件夹删除文件，删除后再用同样的方式关闭安全引导重启电脑即可

zerossl获取一年免费泛证书

Sat, 01 Jun 2024 00:00:00 GMT

环境配置：

本脚本推荐使用centos stream 8 ，在使用本脚本前，请先更新源，并且安装wget这个插件

开始教程

首先去zerossl官网注册一个账号Dashboard - ZeroSSL(这个邮箱可以随便填，不会验证)

新建脚本文件`zerossl.sh`

将账号密码替换以下User_Name，User_Pawd字段

#!/bin/bash
# ZeroSSL 证书申请脚本
# 作者: null

# 用户邮箱
User_Name='邮箱'
# 用户密码
User_Pawd='密码'
# 密码编码
User_Pawd_E=$(echo -n "${User_Pawd}"|sha256sum |awk '{print $1}')

# 登录信息
Login_Info=`curl -v -X POST -c cookie.db -A 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0' -H 'Content-Type: application/x-www-form-urlencoded; charset=UTF-8' -d "postArray={\"email_address\":\"${User_Name}\",\"password\":\"${User_Pawd_E}\"}" 'https://app.zerossl.com/ajax/public_ajax_handler.php?type=sign_in' 2>&1`

if [[ "${Login_Info}" =~ 'success":1,' ]];then
	echo "用户 ${User_Name} 登录成功."
else
	echo "用户 ${User_Name} 登录失败."
	exit 1
fi

# Cookie
Login_Cpt=`echo "${Login_Info}"|awk -F'[ :=;]+' '/Set-Cookie:[[:space:]]_cpt/ {print $4}'`

User_Login_Cookie(){
	curl -s -b cookie.db -A 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0' "${@}"
}

Login_Auth=`User_Login_Cookie 'https://app.zerossl.com/dashboard'`
if [ -z "${Login_Auth}" ];then
	echo "$User_Name 未登录."
	exit 1
fi

# 密钥目录
SSL_Key_Dir='ssl_key'
# 检查目录是否存在
if [ ! -d "${SSL_Key_Dir}" ];then
	mkdir "${SSL_Key_Dir}"
fi

if [ -z "${1}" ];then
	read -ep '请输入域名:' Gen_Domain
else
	Gen_Domain="${1}"
fi

# 订阅
Subscription_Plan=`User_Login_Cookie -H 'Content-Type: application/x-www-form-urlencoded; charset=UTF-8' -d 'postArray={"plan_id":"512","payment_frequency":"monthly"}' "https://app.zerossl.com/ajax/advanced_ajax_handler.php?type=change_subscription_plan&_cpt=${Login_Cpt}"`
if [[ "${Subscription_Plan}" =~ 'success":1,' ]];then
	echo "用户 ${User_Name} 订阅成功."
else
	echo "用户 ${User_Name} 订阅失败."
	exit 1
fi

# 降级订阅
Downgrade_Plan=`User_Login_Cookie -H 'Content-Type: application/x-www-form-urlencoded; charset=UTF-8' -d 'postArray={"plan_id":"477","payment_frequency":"monthly"}' "https://app.zerossl.com/ajax/advanced_ajax_handler.php?type=change_subscription_plan&_cpt=${Login_Cpt}"`

# ZeroSSL API 密钥
User_Token=`User_Login_Cookie 'https://app.zerossl.com/developer' |grep -A 1 '"access_key"'|awk -F'[ ><]+' '/span/ {print $3}'`
if [ -z "${User_Token}" ];then
	echo "用户密钥为空"
	exit 1
fi

Gen_Domain_D=$(echo "${Gen_Domain}"|sed -r 's/\*\./_/g;s/\./_/g')
echo "域名信息: ${Gen_Domain} ${Gen_Domain_D}"
Domain_Key_Path="${SSL_Key_Dir}/${Gen_Domain_D}.key"
Domain_Csr_Path="${SSL_Key_Dir}/${Gen_Domain_D}_csr.pem"
if [ ! -f "${Domain_Key_Path}" ];then
	openssl genrsa -out "${Domain_Key_Path}" 2048
fi

if [ ! -f "${Domain_Csr_Path}" ];then
	openssl req -new -key ${Domain_Key_Path} -out ${Domain_Csr_Path} -subj "/C=CN/CN=${Gen_Domain}"
fi

# 格式化
Domain_Csr_Code=$(cat "${Domain_Csr_Path}" | tr -d '\n')
Post_Cert_Code=$(curl -s -X POST -H 'Content-Type: application/json' -H 'User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0' -d "{\"certificate_domains\": \"${Gen_Domain}\", \"certificate_validity_days\": 365, \"certificate_csr\": \"${Domain_Csr_Code}\",    \"strict_domains\": 1}" "http://api.zerossl.com/certificates?access_key=${User_Token}")

if [[ "${Post_Cert_Code}" =~ 'success' ]];then
	echo "订单失败: ${Post_Cert_Code}"
else
	echo "订单成功: ${Post_Cert_Code}"
fi

使用`sh zerossl.sh`运行脚本

随后输入泛域名列如*.xxx.com,普通域名可以直接使用xxx.com,1.xxx.com

枫の屋

CentOS 7 内核升级脚本 (kernel-lt-5.4)

脚本内容，均无加密可放心使用，如果不想看可以拉到最后看使用脚本

✨ 主要修复内容

1. 修复yum源问题 (新增 fix_centos_repo 函数)

2. 增强依赖安装 (改进 install_dependencies 函数)

3. 改进错误处理

4. 添加美化功能

📥 使用方法

Alist S3 上传指定目录脚本文档

自动生成子文件夹并上传至 Alist S3 脚本配置文档

本教程使用Alist中的S3协议进行搭建对接的123云盘

1，先进入Alist的官网安装并运行，由于网络上此教程太多，我这边不过多教学，官网的一键安装也十分方便（Alist官网地址：alist.nn.ci）

2，进入Alist后台->存储->添加 来添加存储，我们以123pan为例

3，成功添加

4，进入123盘，在根目录新建desktop以及mobile文件夹用于存储手机和电脑访问时候呈现出不同尺寸的图片，并且检查是否正常创建

5，进入Alist后台创建S3协议的密钥以及id

脚本的配置

完整代码

1. 本地需要上传的目录

2. S3 桶名称

3. Alist S3 服务的 IP 和端口

4. 访问密钥 (AWS Access Key ID)

5. 密钥 (AWS Secret Access Key)

6. 手动设置的主文件夹名称

7. 上传时间间隔（分钟）

8. 立即上传开关

9. 定期上传开关

10. 自动生成 backup+时间 子文件夹

运行方式：

示例配置：

文件上传结构示例：

批处理bat脚本自动配置java的jdk环境变量

脚本内容

步骤及意义

使用方式

echo 和@echo的区别

set和setx的区别

CentOS Linux 安装MySQL

安装

安装 MySQL rpm 源信息

安装

检查安装是否成功

MySQL 常用命令

登录和修改密码

开放 root 账户远程登录

端口开放

CentOS更换阿里源

CentOS8配置阿里云YUM源

Centos更新内核

手动升级CentOS 7.9内核的正确方式

1.背景

2.错误尝试

3.正确尝试

CentOS7配置阿里云镜像源（超详细过程）

前言

一、环境准备

二、手动配置阿里云源

三、脚本配置本地源

Docker中文管理面板

portainer-ce中文版

感谢群里@我不是矿神 指导js精简 | @52Fancy 提供编译脚本

docker常用命令

Docker 容器相关命令

docker镜像操作

docker创建的容器，容器目录在哪里

如果bash用不了

如何将docker容器打包成镜像

emby linux一件脚本

emby本地破解方法

Emby.Server.Implementations.dll

MediaBrowser.Model.dll

Emby.Web.dll

embypremiere.js

/Contents/Resources/www/modules/emby-apiclient/connectionmanager.js 文件修改，针对 mac 客户端

在线升级版本：ESXI6.5升级7.0

升级方法 升级方法有补丁升级、在线升级和U盘升级三种方式，我使用的是补丁升级，下面是升级过程。

1.查询+下载补丁

2、上传文件

3.在Terminal终端软件上SSH到ESXi

1. 修复yum源问题 (新增 `fix_centos_repo` 函数)

2. 增强依赖安装 (改进 `install_dependencies` 函数)

2，进入Alist后台->存储->添加来添加存储，我们以123pan为例

4，进入123盘，在根目录新建`desktop`以及`mobile`文件夹用于存储手机和电脑访问时候呈现出不同尺寸的图片，并且检查是否正常创建

10. 自动生成 `backup+时间` 子文件夹

感谢群里@我不是矿神指导js精简 | @52Fancy 提供编译脚本

升级方法升级方法有补丁升级、在线升级和U盘升级三种方式，我使用的是补丁升级，下面是升级过程。

前提要求：`如果你还没有安装alist或者任何s3服务的，你可以参考我的这篇文章`(Alist/S3/阿里ossz制作随机图片api | 枫の屋 (6wd.cn))

方法一：用n升级nodejs（建议使用此方法）

方法二：用NVM来升级nodejs

Hyper-V Centos7 网络设置虚拟机固定IP