命令 [选项] [参数] [目标]

# 查看命令的简短帮助

ls --help

# 查看命令的详细手册

man ls

# 查看命令的简要信息

whatis ls

# 显示当前所在目录

pwd

# 输出示例：/home/username

# 列出当前目录的文件

ls

# 输出示例：Documents Downloads Pictures Videos

# 查看当前时间和日期

date

# 输出示例：Mon Jun 9 14:30:25 CST 2025

# 显示当前登录用户

whoami

# 输出示例：username

# 切换到根目录

cd /

# 切换到家目录

cd ~

# 或者

cd

# 切换到上级目录

cd ..

# 切换到上上级目录

cd ../..

# 创建目录

mkdir my_project

# 创建文件

touch readme.txt

# 复制文件

cp readme.txt readme_backup.txt

# 移动/重命名文件

mv readme.txt project_readme.txt

# 查看文件权限

ls -l filename.txt

# 给文件添加执行权限

chmod +x script.sh

# 递归修改目录权限

chmod -R 755 /path/to/directory

# 查看根目录结构

ls -la /

# 查看家目录

ls -la ~

# 查看当前用户家目录位置

echo $HOME

# 绝对路径示例

ls /home/username/Documents

# 相对路径示例

cd Documents # 从当前目录进入Documents

cd ~/Documents # 从任何位置进入用户家目录下的Documents

# 立即关机（需要root权限）

sudo shutdown -h now

# 1分钟后关机，并发送消息给所有用户

sudo shutdown -h 1 "系统将在1分钟后关机进行维护"

# 定时关机（晚上10点关机）

sudo shutdown -h 22:00

# 取消已计划的关机

sudo shutdown -c

# 立即重启

sudo reboot

# 同步内存数据到磁盘（重要！）

sync

# 安全关机的完整流程

sync # 同步数据

ps aux | grep -v grep # 检查运行的进程

sudo shutdown -h 1 "系统即将关机维护" # 预警关机

# 查看当前登录用户

whoami

# 查看所有登录用户

who

# 查看详细登录信息

w

# 切换到其他用户（需要密码）

su username

# 切换到root用户

su -

# 以其他用户身份执行命令

sudo command

# 注销当前用户（命令行界面）

logout

# 或者使用快捷键 Ctrl + D

# 添加新用户（需要root权限）

sudo useradd username

# 为新用户设置密码

sudo passwd username

# 添加用户并创建家目录

sudo useradd -m username

# 添加用户并指定家目录

sudo useradd -m -d /home/custompath username

# 删除用户（保留家目录）

sudo userdel username

# 删除用户及其家目录

sudo userdel -r username

# 修改用户信息

sudo usermod -c "用户全名" username

# 查看用户信息

id username

# 查看所有用户

cat /etc/passwd | grep -v nologin

# 创建用户组

sudo groupadd groupname

# 将用户添加到组

sudo usermod -aG groupname username

# 查看用户所属组

groups username

# 查看所有组

cat /etc/group

# 创建一个开发人员用户

sudo useradd -m -s /bin/bash developer

sudo passwd developer

# 将用户添加到sudo组（获得管理员权限）

sudo usermod -aG sudo developer

# 验证用户创建成功

id developer

ls -la /home/developer

# 1. 打开文件进行编辑

vim filename.txt

# 2. 在命令模式下，按i进入插入模式

# 3. 输入或编辑文本内容

# 4. 按Esc键返回命令模式

# 5. 输入:wq保存并退出

i # 在光标前插入

a # 在光标后插入

o # 在下一行插入新行

O # 在上一行插入新行

A # 在行末插入

I # 在行首插入

# 基本方向移动

h # 左移一个字符

j # 下移一行

k # 上移一行

l # 右移一个字符

# 单词级移动

w # 移到下一个单词开头

b # 移到上一个单词开头

e # 移到当前单词末尾

# 行内移动

0 # 移到行首

$ # 移到行末

^ # 移到行首第一个非空字符

# 文档级移动

gg # 移到文件开头

G # 移到文件末尾

5G # 移到第5行

x # 删除当前字符

dd # 删除当前行

5dd # 删除从当前行开始的5行

dw # 删除当前单词

d$ # 删除从光标到行末

d0 # 删除从光标到行首

/keyword # 向下搜索keyword

?keyword # 向上搜索keyword

n # 跳到下一个匹配项

N # 跳到上一个匹配项

# 实用搜索技巧

/^start # 搜索以start开头的行

/end$ # 搜索以end结尾的行

yy # 复制当前行

5yy # 复制5行

yw # 复制当前单词

p # 在光标后粘贴

P # 在光标前粘贴

u # 撤销上一个操作

Ctrl+r # 重做被撤销的操作

:w # 保存

:q # 退出

:wq # 保存并退出

:q! # 强制退出不保存

:w! # 强制保存

:x # 保存并退出（等同于:wq）

# 指定文件名保存

:w newfile.txt # 另存为新文件

:s/old/new # 替换当前行第一个old为new

:s/old/new/g # 替换当前行所有old为new

:%s/old/new/g # 替换全文所有old为new

:%s/old/new/gc # 替换全文所有old为new，每次替换前确认

# 创建一个练习文件

vim practice.txt

# 练习流程：

# 1. 按i进入插入模式

# 2. 输入几行文本：

# Line 1: Hello Linux

# Line 2: Learning vim

# Line 3: This is practice

# 3. 按Esc返回命令模式

# 4. 尝试以下操作：

# - 按gg移到文件开头

# - 按/vim搜索vim

# - 按dd删除当前行

# - 按u撤销删除

# - 按:wq保存退出

# 错误1：在插入模式下使用方向键导致乱码

# 解决：按Esc回到命令模式，再使用hjkl移动

# 错误2：忘记当前在哪个模式

# 解决：按Esc确保回到命令模式

# 错误3：使用Ctrl+C强制退出可能丢失数据

# 解决：使用:q!强制退出或:wq保存退出

# 错误4：不小心进入了vim不知道怎么退出

# 解决：按Esc，然后输入:q!强制退出

# 文本编辑快捷键

Ctrl+A # 光标移到行首（不是全选！）

Ctrl+E # 光标移到行末

Ctrl+U # 删除光标前的所有内容

Ctrl+K # 删除光标后的所有内容

Ctrl+W # 删除光标前的一个单词

Ctrl+L # 清屏（等同于clear命令）

# 历史命令快捷键

Ctrl+R # 搜索历史命令

Ctrl+P # 上一个命令（等同于↑）

Ctrl+N # 下一个命令（等同于↓）

# 进程控制快捷键

Ctrl+C # 终止当前命令

Ctrl+Z # 暂停当前命令

Ctrl+D # 退出当前shell（等同于exit）

# 终端文本操作

Ctrl+Shift+C # 复制选中文本

Ctrl+Shift+V # 粘贴文本

鼠标中键 # 粘贴（Linux特有）

# tar命令基本语法：tar [选项] 文件名 [要处理的文件/目录]

# 创建tar包（打包但不压缩）

tar -cf archive.tar file1 file2 directory/

# 创建压缩包（推荐使用）

tar -czf archive.tar.gz file1 file2 directory/

tar -cjf archive.tar.bz2 file1 file2 directory/

# 查看压缩包内容

tar -tf archive.tar.gz

# 解压到当前目录

tar -xzf archive.tar.gz

# 解压到指定目录

tar -xzf archive.tar.gz -C /path/to/extract/

# 显示详细过程

tar -czvf archive.tar.gz directory/ # 压缩时显示

tar -xzvf archive.tar.gz # 解压时显示

# 基础选项

-c # create，创建压缩包

-x # extract，解压

-t # list，列出内容

-f # file，指定文件名（必须）

# 压缩选项

-z # 使用gzip压缩（.gz）

-j # 使用bzip2压缩（.bz2）

-J # 使用xz压缩（.xz）

# 显示选项

-v # verbose，显示详细过程

-C # 指定解压目录

# 场景1：备份整个项目目录

tar -czf project_backup_$(date +%Y%m%d).tar.gz ~/myproject/

# 场景2：压缩日志文件

tar -czf logs_backup.tar.gz /var/log/*.log

# 场景3：分别压缩多个目录

tar -czf backup.tar.gz ~/Documents ~/Pictures ~/Downloads

# 场景4：排除某些文件

tar -czf backup.tar.gz --exclude="*.tmp" --exclude="node_modules" ~/project/

# 场景5：查看压缩包大小

ls -lh *.tar.gz

# 创建zip压缩包

zip -r archive.zip directory/

zip archive.zip file1 file2

# 解压zip文件

unzip archive.zip

# 解压到指定目录

unzip archive.zip -d /path/to/extract/

# 查看zip内容

unzip -l archive.zip

# 测试zip文件完整性

unzip -t archive.zip

# 创建测试文件比较压缩效果

echo "大量重复文本大量重复文本大量重复文本" > test.txt

# 不同压缩方式对比

tar -cf test.tar test.txt # 只打包

tar -czf test.tar.gz test.txt # gzip压缩（快）

tar -cjf test.tar.bz2 test.txt # bzip2压缩（慢但压缩率高）

zip test.zip test.txt # zip压缩

# 查看压缩效果

ls -lh test.*

# 权限位的数值

读权限 r = 4

写权限 w = 2

执行权限 x = 1

# 常用权限组合

7 = 4+2+1 = rwx （读写执行）

6 = 4+2 = rw- （读写）

5 = 4+1 = r-x （读执行）

4 = 4 = r-- （只读）

0 = 0 = --- （无权限）

# 文件权限（不需要执行权限）

chmod 644 file.txt # rw-r--r-- 用户读写，组和其他只读

chmod 600 file.txt # rw------- 只有用户可读写

# 目录权限（需要执行权限才能进入）

chmod 755 directory/ # rwxr-xr-x 用户全权限，组和其他可读执行

chmod 750 directory/ # rwxr-x--- 用户全权限，组可读执行，其他无权限

# 可执行文件权限

chmod 755 script.sh # rwxr-xr-x 所有人可执行

chmod 700 script.sh # rwx------ 只有用户可执行

# 数字方法（推荐）

chmod 755 file

# 符号方法

chmod u+rwx file # 给用户增加读写执行权限

chmod g+rx file # 给组增加读执行权限

chmod o-w file # 移除其他用户的写权限

chmod a+r file # 给所有人增加读权限

# 递归修改目录权限

chmod -R 755 directory/

# 只修改目录权限，不影响文件

find directory/ -type d -exec chmod 755 {} \;

# 只修改文件权限，不影响目录

find directory/ -type f -exec chmod 644 {} \;

# 查看文件所有者和权限

ls -l filename

# 修改文件所有者

sudo chown username filename

sudo chown username:groupname filename

# 只修改组

sudo chgrp groupname filename

# 递归修改目录所有者

sudo chown -R username:groupname directory/

# 修改为当前用户

sudo chown $USER filename

# Set UID（SUID）- 4000

chmod 4755 file # 执行时以文件所有者身份运行

# Set GID（SGID）- 2000

chmod 2755 directory # 在此目录创建的文件继承目录的组

# Sticky bit - 1000

chmod 1755 directory # 只有文件所有者可以删除自己的文件（如/tmp）

# 查看特殊权限

ls -l file

# -rwsr-xr-x （s表示SUID）

# drwxrwsrwx （s表示SGID）

# drwxrwxrwt （t表示sticky bit）

# 检查当前用户权限

id

# 检查文件权限

ls -la filename

# 检查目录权限（需要x权限才能进入目录）

ls -ld directory/

# 测试权限

test -r filename && echo "可读" || echo "不可读"

test -w filename && echo "可写" || echo "不可写"

test -x filename && echo "可执行" || echo "不可执行"

# Web服务器文件权限

sudo chown -R www-data:www-data /var/www/html/

chmod -R 755 /var/www/html/

chmod -R 644 /var/www/html/*.html

# SSH密钥权限（必须严格设置）

chmod 700 ~/.ssh/

chmod 600 ~/.ssh/id_rsa

chmod 644 ~/.ssh/id_rsa.pub

# 脚本文件权限

chmod +x script.sh # 添加执行权限

chmod 755 script.sh # 标准脚本权限

# 配置文件权限

chmod 600 config.conf # 敏感配置文件，只有用户可访问

# 确保在自己的家目录

cd ~

pwd

# 创建练习目录

mkdir linux_practice

cd linux_practice

# 显示当前目录位置

pwd

# 列出文件和目录（基本格式）

ls

# 列出详细信息

ls -l

# 列出所有文件（包括隐藏文件）

ls -a

# 进入目录

cd Documents

# 返回上级目录

cd ..

# 返回家目录

cd ~

# 查看文件内容（适合小文件）

cat filename.txt

# 分页查看文件内容（适合大文件）

less filename.txt

# 按q退出less

# 查看文件前几行

head filename.txt

# 查看文件后几行

tail filename.txt

# 创建空文件

touch newfile.txt

# 创建目录

mkdir newfolder

# 复制文件

cp source.txt destination.txt

# 移动/重命名文件

mv oldname.txt newname.txt

# 完整的练习流程

cd ~/linux_practice

# 创建几个练习文件

touch file1.txt file2.txt

mkdir folder1 folder2

# 查看创建结果

ls -la

# 向文件中写入内容

echo "Hello Linux" > file1.txt

echo "Learning Linux is fun" > file2.txt

# 查看文件内容

cat file1.txt

cat file2.txt

# 复制文件

cp file1.txt file1_backup.txt

# 移动文件到文件夹

mv file2.txt folder1/

# 验证操作结果

ls -la

ls -la folder1/

# 错误：文件名大小写敏感

ls File.txt # 如果实际文件是file.txt，会提示找不到

# 正确：检查实际文件名

ls -la | grep -i file

# 错误：路径分隔符

cd folder1\subfolder # Windows风格，Linux中无效

# 正确：使用正斜杠

cd folder1/subfolder

# 错误：权限不足

mkdir /etc/myconfig # 普通用户无权在/etc创建目录

# 正确：在有权限的目录操作

mkdir ~/myconfig

# 确保在自己的家目录

cd ~

pwd

# 创建练习目录

mkdir linux_practice

cd linux_practice

echo "当前在练习目录：$(pwd)"

# 创建文件的多种方法

touch newfile.txt # 创建空文件

echo "content" > file.txt # 创建并写入内容

cat > input.txt # 手动输入内容（Ctrl+D结束）

# 查看文件内容的多种方法

cat small_file.txt # 适合小文件

less large_file.txt # 适合大文件（q退出）

head file.txt # 查看开头10行

tail file.txt # 查看末尾10行

head -5 file.txt # 查看开头5行

# 文件复制的不同场景

cp file.txt backup.txt # 基本复制

cp file.txt /tmp/ # 复制到指定目录

cp *.txt backup/ # 复制所有txt文件

cp -r folder1/ folder2/ # 递归复制目录

# 文件移动和重命名

mv old_name.txt new_name.txt # 重命名文件

mv file.txt ~/Documents/ # 移动文件到其他目录

mv folder1/ ~/Desktop/ # 移动目录

# * 匹配任意字符

ls *.txt # 列出所有txt文件

cp *.log backup/ # 复制所有log文件

rm temp*.txt # 删除以temp开头的txt文件

# ? 匹配单个字符

ls file?.txt # 匹配file1.txt, fileA.txt等

cp data?.csv backup/ # 复制data1.csv, data2.csv等

# [] 匹配括号内的任意字符

ls file[123].txt # 匹配file1.txt, file2.txt, file3.txt

ls [abc]*.txt # 匹配以a、b、c开头的txt文件

# {} 匹配大括号内的任意选项

cp file.{txt,doc,pdf} backup/ # 同时复制三种格式的file文件

# 交互式删除（推荐新手使用）

rm -i unwanted.txt # 删除前会询问确认

# 查看要删除的内容

ls -la temp* # 先查看匹配的文件

rm temp* # 确认后再删除

# 删除目录

rmdir empty_directory/ # 删除空目录

rm -r directory/ # 删除目录及其内容（危险！）

rm -rf directory/ # 强制删除（非常危险！）

# 安全删除的最佳实践

ls -la what_to_delete* # 1. 先看看要删除什么

mv what_to_delete* /tmp/ # 2. 先移动到临时目录

# 确认没问题后再从/tmp删除

# 练习项目：创建一个个人文档管理系统

cd ~/linux_practice

# 1. 创建目录结构

mkdir -p documents/{work,personal,backup}

mkdir -p documents/work/{projects,reports}

mkdir -p documents/personal/{photos,notes}

# 2. 创建一些示例文件

echo "工作项目1的说明" > documents/work/projects/project1.txt

echo "月度报告" > documents/work/reports/monthly_report.txt

echo "个人笔记" > documents/personal/notes/my_notes.txt

echo "待办事项" > documents/personal/todo.txt

# 3. 查看创建的结构

tree documents/ # 如果没有tree命令，用ls -R

ls -R documents/

# 4. 练习复制和移动

cp documents/personal/todo.txt documents/backup/

mv documents/personal/notes/my_notes.txt documents/backup/

# 5. 使用通配符操作

ls documents/*/*.txt # 查找所有txt文件

cp documents/work/*.txt documents/backup/

# 6. 验证结果

echo "备份目录内容："

ls -la documents/backup/

# 错误1：使用反斜杠

cd documents\work # Windows风格，错误！

cd documents/work # Linux正确方式

# 错误2：忽略大小写

ls Documents # 如果目录名是documents，会找不到

ls documents # 正确

# 错误3：文件名包含空格的处理

touch my file.txt # 错误，会创建两个文件

touch "my file.txt" # 正确方式1

touch my\ file.txt # 正确方式2

# 错误4：路径概念混淆

cd C:\Users\username # Windows路径概念

cd /home/username # Linux正确路径

# 每次操作后都要验证结果

echo "创建文件后检查："

ls -la

echo "复制文件后检查："

ls -la backup/

echo "删除文件后检查："

ls -la | grep -v "deleted_file"

# 显示详细文件信息（权限、大小、时间）

ls -l

# 显示所有文件（包括隐藏文件，以.开头）

ls -a

# 组合选项使用

ls -la # 详细信息+隐藏文件

# 以人类可读格式显示文件大小（KB、MB、GB）

ls -lh

# 按修改时间排序显示文件（最新的在前）

ls -lt

# 按文件大小排序

ls -lS

# 反向排序

ls -lr # 最旧的在前

# 递归显示目录内容（显示子目录内容）

ls -R

# 只显示目录

ls -d */ # 显示当前目录下的所有目录

# 按扩展名分类显示

ls -X

# 执行 ls -l 后看到的权限信息解释

# -rw-r--r-- 1 user group 1024 Jun 9 10:30 filename.txt

# ↑ 文件类型（-文件 d目录 l链接）

# ↑↑↑ 用户权限（rw-=读写不可执行）

# ↑↑↑ 组权限（r--=只读）

# ↑↑↑ 其他权限（r--=只读）

# 文件类型识别

ls -la | head -10

# d开头：目录

# -开头：普通文件

# l开头：软链接

# b开头：块设备文件

# c开头：字符设备文件

# 保持原文件属性复制（权限、时间戳等）

cp -p source.txt backup.txt

# 递归复制整个目录

cp -r source_dir destination_dir

# 只在源文件较新时才复制

cp -u source.txt backup.txt

# 复制前备份已存在的目标文件

cp -b source.txt existing_file.txt # 会创建existing_file.txt~备份

# 交互式复制（覆盖前询问）

cp -i source.txt existing_file.txt

# 详细显示复制过程

cp -v source.txt backup.txt

# 组合选项：递归、保持属性、详细输出

cp -rpv source_directory/ backup_directory/

# 交互式移动（覆盖前询问）

mv -i old_file.txt new_location/

# 创建备份后移动

mv -b source.txt destination.txt

# 详细显示移动过程

mv -v old_name.txt new_name.txt

# 批量重命名技巧

for file in *.txt; do

mv "$file" "${file%.txt}.backup"

done

# 将所有.txt文件重命名为.backup

# 使用rename命令（如果可用）

rename 's/\.txt$/.backup/' *.txt

# 安全级别1：交互式删除（最安全）

rm -i unwanted_file.txt

# 安全级别2：先查看再删除

ls -la temp* # 先看看要删除什么

rm temp* # 确认后删除

# 安全级别3：移动到临时目录

mkdir ~/.trash 2>/dev/null # 创建回收站目录

mv unwanted_files ~/.trash/ # 移动而不是删除

# 危险操作警告

rm -f file.txt # 强制删除，不询问

rm -rf directory/ # 递归强制删除目录（危险！）

# 安全删除目录的步骤

ls -la directory_to_delete/ # 1. 查看目录内容

mv directory_to_delete /tmp/ # 2. 先移动到临时目录

# 3. 确认无误后再从/tmp删除

# 复杂通配符模式

ls file[0-9].txt # 匹配file0.txt到file9.txt

ls file[a-z].txt # 匹配filea.txt到filez.txt

ls file[!0-9].txt # 匹配非数字的文件

# 大括号扩展

cp file.{txt,doc,pdf} backup/ # 同时复制多种格式

mkdir {2023,2024,2025} # 创建多个年份目录

touch file{1..10}.txt # 创建file1.txt到file10.txt

# 实用的批量操作

cp *.{jpg,png,gif} ~/Pictures/ # 复制所有图片文件

rm temp{1..5}.log # 删除temp1.log到temp5.log

# 在当前目录查找文件

find . -name "*.txt" # 查找所有txt文件

find . -name "file*" # 查找以file开头的文件

# 按文件大小查找

find . -size +1M # 查找大于1MB的文件

find . -size -100k # 查找小于100KB的文件

# 按修改时间查找

find . -mtime -7 # 查找7天内修改的文件

find . -mtime +30 # 查找30天前修改的文件

# 按文件类型查找

find . -type f # 只查找文件

find . -type d # 只查找目录

# 创建一个更复杂的文件管理练习

cd ~/linux_practice

# 1. 创建混乱的文件环境

touch {report,data,backup}{1..5}.{txt,doc,pdf}

touch temp{a..e}.log

mkdir {old,new,archive} 2>/dev/null

# 2. 查看创建的文件

ls -la

# 3. 按类型整理文件

ls -1 *.txt | head -5 # 查看前5个txt文件

cp *.txt old/ # 复制所有txt文件到old目录

mv *.pdf archive/ # 移动所有pdf文件到archive目录

# 4. 清理临时文件

ls -la temp*.log # 先查看临时文件

mv temp*.log /tmp/ # 移动到系统临时目录

# 5. 验证整理结果

echo "=== 当前目录 ==="

ls -la

echo "=== old目录 ==="

ls -la old/

echo "=== archive目录 ==="

ls -la archive/

# 自动补全文件名

ls doc[Tab] # 自动补全为documents（如果唯一）

cd /u[Tab]/l[Tab]/b[Tab] # 自动补全为/usr/local/bin

# 双击Tab显示所有可能的匹配

ls fi[Tab][Tab] # 显示所有以fi开头的文件

# 自动补全命令选项

ls --[Tab][Tab] # 显示ls的所有长选项

# head和tail的详细用法

head filename.txt # 查看前10行（默认）

head -5 filename.txt # 查看前5行

head -c 100 filename.txt # 查看前100个字符

tail filename.txt # 查看后10行（默认）

tail -5 filename.txt # 查看后5行

tail -n +10 filename.txt # 从第10行开始显示到文件末尾

# 实时监控文件变化（重要！）

tail -f /var/log/syslog # 实时查看系统日志

tail -f access.log # 实时监控访问日志

# more和less的区别

more filename.txt # 分页查看（只能向前）

less filename.txt # 分页查看（可前后翻页）

# less中的操作：

# 空格键：下一页

# b：上一页

# /：搜索

# q：退出

# 查看文件的特定行数范围

sed -n '10,20p' filename.txt # 查看第10到20行

sed -n '10p' filename.txt # 只查看第10行

# 基本搜索

grep "search_text" filename.txt

# 常用选项

grep -i "hello" filename.txt # 忽略大小写

grep -n "error" logfile.txt # 显示行号

grep -v "debug" logfile.txt # 显示不包含debug的行（反向匹配）

grep -c "warning" logfile.txt # 只显示匹配行数

grep -l "pattern" *.txt # 只显示包含模式的文件名

# 搜索多个文件

grep "pattern" *.txt # 在所有txt文件中搜索

grep "pattern" file1.txt file2.txt # 在指定文件中搜索

# 递归搜索目录

grep -r "search_text" /path/to/directory

grep -r "config" /etc/ # 在/etc目录递归搜索config

# 使用正则表达式（基础）

grep "^start" filename.txt # 搜索以start开头的行

grep "end$" filename.txt # 搜索以end结尾的行

grep "[0-9]" filename.txt # 搜索包含数字的行

grep "Error\|Warning" logfile.txt # 搜索包含Error或Warning的行

# wc命令统计文件信息

wc filename.txt # 显示行数、单词数、字符数

# 分别统计

wc -l filename.txt # 只统计行数

wc -w filename.txt # 只统计单词数

wc -c filename.txt # 只统计字符数

wc -m filename.txt # 统计字符数（支持多字节字符）

# 实用例子

wc -l /etc/passwd # 统计系统用户数量

ls | wc -l # 统计当前目录文件数量

ps aux | wc -l # 统计当前进程数量

# sort排序

sort filename.txt # 按字母顺序排序

sort -n numbers.txt # 按数字大小排序

sort -r filename.txt # 反向排序

sort -k2 data.txt # 按第2列排序

# uniq去重（注意：需要先排序）

sort filename.txt | uniq # 去除重复行

sort filename.txt | uniq -c # 统计每行出现次数

sort filename.txt | uniq -d # 只显示重复的行

sort filename.txt | uniq -u # 只显示不重复的行

# 实用组合

sort /etc/passwd | uniq # 查看系统用户（去重）

history | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

# 统计最常用的命令

# 按名称查找

find /home -name "*.txt" # 查找所有txt文件

find . -name "file*" # 查找以file开头的文件

find . -iname "*.PDF" # 忽略大小写查找PDF文件

# 按大小查找

find /home -size +10M # 查找大于10MB的文件

find . -size -100k # 查找小于100KB的文件

find . -size 1M # 查找恰好1MB的文件

# 按时间查找

find . -mtime -7 # 查找7天内修改的文件

find . -mtime +30 # 查找30天前修改的文件

find . -atime -1 # 查找1天内访问的文件

# 按文件类型查找

find . -type f # 只查找普通文件

find . -type d # 只查找目录

find . -type l # 只查找符号链接

# 按权限查找

find . -perm 755 # 查找权限为755的文件

find . -perm -644 # 查找至少有644权限的文件

# 组合条件

find . -name "*.log" -size +1M # 查找大于1MB的log文件

find . -name "*.tmp" -mtime +7 -delete # 查找并删除7天前的临时文件

# 场景1：分析日志文件

grep -i error /var/log/syslog # 查找错误信息

grep "404" /var/log/nginx/access.log | wc -l # 统计404错误数量

tail -f /var/log/mysql/error.log | grep -i warning # 实时监控MySQL警告

# 场景2：代码文件分析

find . -name "*.py" | wc -l # 统计Python文件数量

grep -r "TODO" --include="*.py" . # 查找代码中的TODO注释

find . -name "*.py" -exec wc -l {} + | tail -1 # 统计Python代码总行数

# 场景3：系统文件管理

find /tmp -type f -mtime +7 -size +100M # 查找临时目录中的大文件

grep -r "192.168" /etc/ # 查找配置文件中的IP地址

find /home -name "*.bak" -size +10M # 查找大型备份文件

# 场景4：文本数据处理

cut -d':' -f1 /etc/passwd | sort # 提取并排序用户名

awk -F':' '{print $1, $3}' /etc/passwd # 提取用户名和UID

grep "^#" config.file | wc -l # 统计配置文件中的注释行数

# 场景5：清理和维护

find . -name "*~" -delete # 删除备份文件

find . -name "*.tmp" -mtime +1 -exec rm {} \; # 删除1天前的临时文件

# 按分隔符分割

cut -d':' -f1 /etc/passwd # 提取第1个字段（用户名）

cut -d':' -f1,3 /etc/passwd # 提取第1和第3个字段

cut -d',' -f2-4 data.csv # 提取CSV文件的第2到4列

# 按字符位置分割

cut -c1-10 filename.txt # 提取每行的前10个字符

cut -c5- filename.txt # 从第5个字符开始到行末

ps aux | cut -c1-20 # 提取进程信息的前20个字符

# 创建练习数据

cd ~/linux_practice

cat > sample_log.txt << 'EOF'

2024-06-09 10:30:15 INFO User login successful: admin

2024-06-09 10:31:22 ERROR Database connection failed

2024-06-09 10:32:05 WARNING Memory usage high: 85%

2024-06-09 10:33:18 INFO User logout: admin

2024-06-09 10:34:25 ERROR File not found: config.xml

2024-06-09 10:35:30 INFO System backup completed

2024-06-09 10:36:45 WARNING Disk space low: 90%

2024-06-09 10:37:52 ERROR Authentication failed: user123

EOF

# 练习各种文本处理操作

echo "=== 日志文件分析练习 ==="

# 1. 查看文件基本信息

echo "文件行数：$(wc -l < sample_log.txt)"

echo "单词数：$(wc -w < sample_log.txt)"

# 2. 查找特定类型的日志

echo "错误日志："

grep "ERROR" sample_log.txt

# 3. 统计各类型日志数量

echo "日志类型统计："

cut -d' ' -f3 sample_log.txt | sort | uniq -c

# 4. 提取时间信息

echo "所有记录的时间："

cut -d' ' -f1-2 sample_log.txt

# 5. 查找特定用户的活动

echo "admin用户的活动："

grep "admin" sample_log.txt

# 管道的基本语法：命令1 | 命令2

# 将ls的输出传递给grep进行过滤

ls -la | grep "\.txt$"

# 查看文件内容并计算行数

cat filename.txt | wc -l

# 查看进程并过滤特定服务

ps aux | grep nginx

# 排序后去重

cat names.txt | sort | uniq

# 统计重复项数量

cat access.log | cut -d' ' -f1 | sort | uniq -c

# 输出重定向：覆盖文件内容

echo "Hello Linux" > greeting.txt

# 追加重定向：在文件末尾添加内容

echo "Learning is fun" >> greeting.txt

# 错误重定向：将错误信息保存到文件

find / -name "*.log" 2> error.log

# 同时重定向输出和错误

find / -name "*.log" > results.txt 2> error.log

# 将输出和错误都重定向到同一文件

find / -name "*.log" &> all_output.log

# 丢弃输出（发送到黑洞）

some_noisy_command > /dev/null 2>&1

# 查找最大的几个文件

ls -la | sort -k5 -nr | head -10

# 统计目录中文件类型

ls -la | grep "^-" | wc -l # 统计普通文件数量

ls -la | grep "^d" | wc -l # 统计目录数量

# 查看系统负载

uptime | awk '{print $10 $11 $12}'

# 实时监控网络连接数

watch "netstat -an | grep ESTABLISHED | wc -l"

# 查找并统计特定内容

grep -r "ERROR" /var/log/ | wc -l

# 处理CSV文件（假设有一个简单的CSV）

cut -d',' -f2 data.csv | sort | uniq -c

# tee可以同时输出到文件和屏幕

echo "重要信息" | tee important.log

# 这会既显示在屏幕上，又保存到文件中

# 追加模式的tee

echo "更多信息" | tee -a important.log

# 在管道中使用tee保存中间结果

ps aux | tee process_list.txt | grep nginx

# 场景1：分析Web服务器日志

tail -1000 /var/log/nginx/access.log | \

awk '{print $1}' | sort | uniq -c | sort -nr | head -10

# 分析最近1000条访问记录中访问最多的IP

# 场景2：系统监控脚本

ps aux | awk '{sum+=$3} END {print "总CPU使用率:", sum"%"}'

# 场景3：文件整理

find ~/Downloads -name "*.pdf" | \

xargs -I {} mv {} ~/Documents/PDFs/

# 场景4：快速备份配置文件

tar -czf config_backup_$(date +%Y%m%d).tar.gz /etc/nginx /etc/mysql | \

tee backup.log

#!/bin/bash

# 系统监控脚本示例

# 检查磁盘使用率

check_disk_usage() {

usage=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')

if [ $usage -gt 80 ]; then

echo "警告：磁盘使用率超过80%"

fi

}

# 检查内存使用

check_memory() {

free_mem=$(free | grep Mem | awk '{printf "%.2f", $3/$2 * 100.0}')

echo "内存使用率：${free_mem}%"

}

# 清理日志文件

cleanup_logs() {

find /var/log -name "*.log" -mtime +7 -exec rm {} \;

echo "已清理7天前的日志文件"

}

# 备份重要配置

backup_configs() {

tar -czf "/backup/config_$(date +%Y%m%d).tar.gz" /etc/nginx /etc/mysql

echo "配置文件已备份"

}

# 检查命令是否执行成功

if ! command -v nginx > /dev/null; then

echo "错误：nginx未安装"

exit 1

fi

# 检查文件是否存在

if [ ! -f "/path/to/file" ]; then

echo "错误：文件不存在"

exit 1

fi

# 使用trap处理中断信号

trap 'echo "脚本被中断"; exit 1' INT TERM

# 零停机服务更新脚本

rolling_update() {

servers=("server1" "server2" "server3")

for server in "${servers[@]}"; do

echo "更新服务器：$server"

# 从负载均衡器移除

curl -X POST "http://lb/remove/$server"

# 等待连接耗尽

sleep 30

# 更新应用

ssh $server "systemctl stop myapp && \

cp /tmp/new_version/* /opt/myapp/ && \

systemctl start myapp"

# 健康检查

if curl -f "http://$server:8080/health"; then

# 重新加入负载均衡器

curl -X POST "http://lb/add/$server"

echo "$server 更新成功"

else

echo "$server 更新失败，回滚"

# 回滚逻辑

fi

done

}

# 系统性能监控

monitor_system() {

# CPU使用率

cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | sed 's/%us,//')

# 内存使用率

mem_usage=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}')

# 磁盘I/O

io_wait=$(iostat 1 2 | tail -1 | awk '{print $4}')

# 发送到监控系统

curl -X POST "http://monitoring/metrics" \

-d "cpu=$cpu_usage&memory=$mem_usage&iowait=$io_wait"

}

# 实时日志分析

tail -f /var/log/nginx/access.log | \

awk '{print $1}' | sort | uniq -c | sort -nr | head -10

# 错误日志监控

journalctl -u myservice -f | \

grep -i error | \

while read line; do

echo "$line" | mail -s "服务错误" admin@company.com

done

# 系统资源监控

while true; do

echo "$(date): $(uptime)" >> /var/log/system_load.log

sleep 60

done

# 1. 环境准备

cd ~ # 切换到家目录

# 2. 创建项目根目录

mkdir -p ~/projects/my_web_app

cd ~/projects/my_web_app

# 3. 创建标准项目结构

mkdir -p {src,tests,docs,config,logs}

mkdir -p src/{js,css,images}

# 4. 创建基础文件

touch README.md

touch src/index.html

touch src/css/style.css

touch src/js/main.js

touch .gitignore

# 5. 设置合适的权限

chmod 755 ~/projects/my_web_app

chmod 644 src/*

# 6. 初始化Git仓库

git init

echo "node_modules/" >> .gitignore

echo "*.log" >> .gitignore

# 7. 创建初始提交

git add .

git commit -m "Initial project setup"

# 检查目录结构

tree ~/projects/my_web_app

# 检查权限设置

ls -la ~/projects/my_web_app

# 检查Git状态

git status

#!/bin/bash

# 日志分析脚本

LOG_DIR="/var/log/nginx"

ACCESS_LOG="$LOG_DIR/access.log"

REPORT_FILE="/tmp/log_analysis_$(date +%Y%m%d).txt"

# 1. 检查日志文件是否存在

if [ ! -f "$ACCESS_LOG" ]; then

echo "错误：日志文件不存在 $ACCESS_LOG"

exit 1

fi

echo "开始分析日志文件：$ACCESS_LOG" > $REPORT_FILE

echo "分析时间：$(date)" >> $REPORT_FILE

echo "========================================" >> $REPORT_FILE

# 2. 分析访问量最大的IP地址（前10个）

echo "Top 10 访问IP地址：" >> $REPORT_FILE

awk '{print $1}' $ACCESS_LOG | \

sort | uniq -c | sort -nr | head -10 >> $REPORT_FILE

echo "" >> $REPORT_FILE

# 3. 分析最受欢迎的页面（前10个）

echo "Top 10 访问页面：" >> $REPORT_FILE

awk '{print $7}' $ACCESS_LOG | \

sort | uniq -c | sort -nr | head -10 >> $REPORT_FILE

echo "" >> $REPORT_FILE

# 4. 分析HTTP状态码分布

echo "HTTP状态码分布：" >> $REPORT_FILE

awk '{print $9}' $ACCESS_LOG | \

sort | uniq -c | sort -nr >> $REPORT_FILE

echo "" >> $REPORT_FILE

# 5. 查找异常访问（404错误）

echo "404错误页面：" >> $REPORT_FILE

awk '$9==404 {print $7}' $ACCESS_LOG | \

sort | uniq -c | sort -nr | head -20 >> $REPORT_FILE

# 6. 清理30天前的日志文件

echo "清理旧日志文件..." >> $REPORT_FILE

find $LOG_DIR -name "*.log.*" -mtime +30 -print >> $REPORT_FILE

find $LOG_DIR -name "*.log.*" -mtime +30 -delete

echo "日志分析完成，报告保存在：$REPORT_FILE"

# 7. 如果是root用户，压缩当前日志

if [ "$EUID" -eq 0 ]; then

gzip $LOG_DIR/access.log.1 2>/dev/null

gzip $LOG_DIR/error.log.1 2>/dev/null

fi

#!/bin/bash

# 生产环境自动化部署脚本

set -e # 遇到错误立即退出

# 配置变量

APP_NAME="my_web_app"

APP_DIR="/opt/$APP_NAME"

BACKUP_DIR="/backup/$APP_NAME"

GIT_REPO="https://github.com/company/my_web_app.git"

BRANCH="main"

HEALTH_URL="http://localhost:8080/health"

LOG_FILE="/var/log/deploy.log"

# 日志函数

log() {

echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE

}

# 错误处理函数

error_exit() {

log "错误：$1"

exit 1

}

# 健康检查函数

health_check() {

local max_attempts=30

local attempt=1

while [ $attempt -le $max_attempts ]; do

if curl -f -s "$HEALTH_URL" > /dev/null; then

log "健康检查通过"

return 0

fi

log "健康检查失败，重试 $attempt/$max_attempts"

sleep 10

((attempt++))

done

return 1

}

# 备份当前版本

backup_current() {

log "备份当前版本..."

if [ -d "$APP_DIR" ]; then

backup_name="backup_$(date +%Y%m%d_%H%M%S)"

cp -r "$APP_DIR" "$BACKUP_DIR/$backup_name"

log "备份完成：$BACKUP_DIR/$backup_name"

fi

}

# 拉取最新代码

pull_code() {

log "拉取最新代码..."

if [ -d "$APP_DIR/.git" ]; then

cd "$APP_DIR"

git fetch origin

git reset --hard "origin/$BRANCH"

else

rm -rf "$APP_DIR"

git clone -b "$BRANCH" "$GIT_REPO" "$APP_DIR"

fi

cd "$APP_DIR"

local commit_hash=$(git rev-parse HEAD)

log "代码更新到版本：$commit_hash"

}

# 构建应用

build_app() {

log "构建应用..."

cd "$APP_DIR"

# 安装依赖

if [ -f "package.json" ]; then

npm ci --production

fi

# 构建前端资源

if [ -f "webpack.config.js" ]; then

npm run build

fi

# 设置权限

chown -R www-data:www-data "$APP_DIR"

chmod -R 755 "$APP_DIR"

}

# 重启服务

restart_service() {

log "重启服务..."

systemctl stop "$APP_NAME" || true

sleep 5

systemctl start "$APP_NAME"

# 等待服务启动

sleep 10

}

# 回滚函数

rollback() {

log "开始回滚..."

# 找到最新的备份

latest_backup=$(ls -t "$BACKUP_DIR" | head -1)

if [ -n "$latest_backup" ]; then

rm -rf "$APP_DIR"

cp -r "$BACKUP_DIR/$latest_backup" "$APP_DIR"

restart_service

if health_check; then

log "回滚成功"

else

error_exit "回滚失败"

fi

else

error_exit "没有找到备份文件"

fi

}

# 主部署流程

main() {

log "开始部署 $APP_NAME"

# 检查权限

if [ "$EUID" -ne 0 ]; then

error_exit "需要root权限"

fi

# 备份当前版本

backup_current

# 拉取代码

pull_code

# 构建应用

build_app

# 重启服务

restart_service

# 健康检查

if health_check; then

log "部署成功完成"

# 清理旧备份（保留最近5个）

cd "$BACKUP_DIR"

ls -t | tail -n +6 | xargs rm -rf

else

log "健康检查失败，开始回滚"

rollback

fi

}

# 执行部署

main "$@"

# 监控脚本运行状态

tail -f /var/log/deploy.log

# 查看服务状态

systemctl status my_web_app

# 手动健康检查

curl -v http://localhost:8080/health

# 查看应用日志

journalctl -u my_web_app -f

# 错误：路径分隔符

cd C:\Users\name # Windows风格，Linux中无效

# 正确：使用正斜杠

cd /home/name

# 错误：大小写敏感

ls Desktop # 如果实际目录是desktop会失败

# 正确：注意大小写

ls desktop

# 错误：权限不足

rm /etc/important_file

# 正确：使用sudo

sudo rm /etc/important_file

# 错误：直接修改系统文件

echo "new content" > /etc/hosts

# 正确：使用sudo重定向

echo "new content" | sudo tee /etc/hosts

# 错误：递归删除没有确认

rm -rf * # 非常危险！

# 正确：先列出要删除的内容

ls -la

rm -rf specific_directory

# 错误：没有检查命令是否成功

backup_database

restart_service

# 正确：检查返回值

if backup_database; then

restart_service

else

echo "备份失败，取消重启"

fi

# 使用长选项增加可读性

tar --create --verbose --file=backup.tar /home/user

# 在脚本中使用错误处理

command || { echo "命令失败"; exit 1; }

# 使用变量避免硬编码

LOG_DIR="/var/log/myapp"

LOG_FILE="$LOG_DIR/application.log"

# 输出重定向最佳实践

command > output.log 2>&1 # 同时重定向标准输出和错误

# 检查文件是否存在再操作

[ -f "$file" ] && rm "$file"

# 使用绝对路径避免PATH问题

/usr/bin/mysql -u root -p

# 敏感信息不要出现在命令行

mysql -u root -p < script.sql # 而不是 mysql -u root -ppassword

# 使用临时目录

temp_dir=$(mktemp -d)

trap "rm -rf $temp_dir" EXIT

# 权限示例：-rwxr--r--

# - : 文件类型（-文件，d目录）

# rwx : 用户权限（读写执行）

# r-- : 组权限（只读）

# r-- : 其他权限（只读）

# 数字表示：755 = rwxr-xr-x

# 7(4+2+1) = rwx, 5(4+1) = r-x, 5(4+1) = r-x

# 基本语法：find [路径] [条件] [动作]

# 按名称查找

find /home -name "*.log"

# 按大小查找大于100M的文件

find /var -size +100M

# 按时间查找7天前修改的文件

find /tmp -mtime +7

# 组合条件：查找大于10M的log文件并删除

find /var/log -name "*.log" -size +10M -delete

# 查找并执行命令

find /home -name "*.tmp" -exec rm {} \;

# 创建用户

sudo useradd -m username # 创建用户并创建家目录

sudo passwd username # 设置用户密码

# 删除用户

sudo userdel username # 删除用户（保留家目录）

sudo userdel -r username # 删除用户及家目录

# 修改用户

sudo usermod -aG sudo username # 将用户添加到sudo组

sudo usermod -s /bin/bash user # 修改用户shell

# 查看用户信息

id username # 查看用户ID和组信息

groups username # 查看用户所属组

cat /etc/passwd | grep username # 查看用户详细信息

# 1. 打开文件

vim filename.txt

# 2. 模式切换

# 命令模式 → 插入模式：按i、a、o

# 插入模式 → 命令模式：按Esc

# 命令模式 → 底线命令模式：按:

# 3. 基本编辑

i # 在光标前插入

a # 在光标后插入

o # 在下一行插入

dd # 删除当前行

5dd # 删除5行

x # 删除当前字符

# 4. 搜索和替换

/keyword # 向下搜索keyword

?keyword # 向上搜索keyword

n # 跳到下一个匹配项

:s/old/new # 替换当前行第一个old为new

:%s/old/new/g # 替换全文所有old为new

# 5. 保存退出

:w # 保存

:q # 退出

:wq # 保存并退出

:q! # 强制退出不保存

# tar.gz格式（最常用）

tar -czf archive.tar.gz directory/ # 压缩

tar -xzf archive.tar.gz # 解压

# tar.bz2格式（压缩率高）

tar -cjf archive.tar.bz2 directory/ # 压缩

tar -xjf archive.tar.bz2 # 解压

# zip格式（Windows兼容）

zip -r archive.zip directory/ # 压缩

unzip archive.zip # 解压

# 查看压缩包内容

tar -tf archive.tar.gz # 查看tar.gz内容

unzip -l archive.zip # 查看zip内容

# 解压到指定目录

tar -xzf archive.tar.gz -C /path/to/extract/

unzip archive.zip -d /path/to/extract/

# 权限的数字表示

# 读(r)=4, 写(w)=2, 执行(x)=1

# 755 = rwxr-xr-x (用户：读写执行，组：读执行，其他：读执行)

# 644 = rw-r--r-- (用户：读写，组：只读，其他：只读)

# 修改权限

chmod 755 file.txt # 数字方式

chmod u+rwx,g+rx,o+rx file.txt # 符号方式

chmod +x script.sh # 添加执行权限

# 递归修改权限

chmod -R 755 directory/

# 修改所有者

sudo chown user:group file.txt

sudo chown -R user:group directory/

# 查看权限

ls -l file.txt

ls -ld directory/

# 查看进程

ps aux # 查看所有进程

ps aux | grep nginx # 查找特定进程

top # 实时查看进程

htop # 更友好的进程查看器

# 查找进程PID

pgrep nginx # 按名称查找进程ID

pidof nginx # 查找进程ID

# 终止进程

kill PID # 温和终止进程

kill -9 PID # 强制终止进程

killall process_name # 按名称终止进程

pkill process_name # 按名称终止进程

# 后台进程管理

command & # 后台运行

jobs # 查看后台任务

fg %1 # 将后台任务调到前台

Ctrl+Z; bg %1 # 暂停任务并后台运行

nohup command & # 进程不受终端关闭影响

# 管道（|）：将前一个命令的输出作为后一个命令的输入

ps aux | grep nginx | wc -l # 统计nginx进程数

# 重定向输出（>）：覆盖文件

echo "hello" > file.txt

# 重定向追加（>>）：追加到文件末尾

echo "world" >> file.txt

# 重定向错误（2>）：重定向错误信息

find /etc -name "*.conf" 2>/dev/null

# 同时重定向输出和错误（&>）

command &> output.log

# tee命令：同时输出到文件和屏幕

echo "重要信息" | tee important.log

# 复杂管道组合

cat access.log | grep "404" | awk '{print $1}' | sort | uniq -c | sort -nr

# 分析访问日志中404错误的IP统计

# 1. 先预览要删除的文件

find /path/to/files -name "*.tmp" -type f

# 2. 统计数量确认

find /path/to/files -name "*.tmp" -type f | wc -l

# 3. 分批删除避免系统负载过高

find /path/to/files -name "*.tmp" -type f | head -1000 | xargs rm

# 4. 使用交互模式再次确认

find /path/to/files -name "*.tmp" -type f -ok rm {} \;

# 5. 安全的脚本化删除

#!/bin/bash

files_to_delete=$(find /path -name "*.tmp" -type f)

echo "将要删除 $(echo "$files_to_delete" | wc -l) 个文件"

echo "$files_to_delete" | head -10

read -p "确认删除吗？(y/N): " confirm

if [[ $confirm == [yY] ]]; then

echo "$files_to_delete" | xargs rm

fi

# 1. 使用更高效的命令

# 慢：cat file | grep pattern

# 快：grep pattern file

# 2. 避免不必要的管道

# 慢：ps aux | grep nginx | awk '{print $2}'

# 快：pgrep nginx

# 3. 监控命令执行时间

time find /large/directory -name "*.log"

# 4. 监控系统资源

# CPU和内存使用

top -p $(pgrep my_process)

# I/O监控

iostat -x 1

# 磁盘使用监控

df -h && du -sh /var/log/*

# 5. 大文件处理优化

# 使用head/tail限制输出

head -1000 large_file.log | grep error

# 使用并行处理

find /path -name "*.log" | xargs -P 4 -I {} grep "error" {}

# 1. 系统负载过高

# 查看负载

uptime

top -c

# 查看进程

ps aux --sort=-%cpu | head -10

ps aux --sort=-%mem | head -10

# 2. 磁盘空间不足

# 查看磁盘使用

df -h

# 查找大文件

find / -size +100M -type f 2>/dev/null | head -20

# 查看目录大小

du -sh /var/log /tmp /home

# 3. 网络连接问题

# 查看网络连接

netstat -tulpn | grep :80

ss -tulpn | grep :80

# 测试连接

ping -c 4 google.com

telnet hostname 80

# 4. 服务启动失败

# 查看服务状态

systemctl status service_name

# 查看日志

journalctl -u service_name -f

tail -f /var/log/service.log

# 5. 权限问题

# 检查文件权限

ls -la /path/to/file

# 检查进程权限

ps aux | grep process_name

# 修复权限

sudo chown -R user:group /path

sudo chmod -R 755 /path