catalog

  • WIndows与Unix基本命令
  • Bat文件
    • 规范
    • 注释
  • Windows-CMD
    • 介绍
    • 管道`|`, 重定向`> <`
    • 相对位置
    • fc
    • 创建文件
    • 删除文件/文件夹
    • 创建文件夹
    • 输出文件内容
    • 中文乱码 CHCP
  • vim
    • 缩进
    • 查找
    • 显示行号
    • 删除
    • 视图跳转
    • 复制
    • Deprecated
  • tmux
    • 复制粘贴
    • tmux
    • ctrl d
    • ctrl a, d
    • tmux a
    • tmux a, s
    • tmux a, shift 5
    • tmux a, shift "
    • tmux a, z
    • Deprecated
  • Sh脚本文件
    • 创建一个sh文件
    • 命名行参数
  • linux命令
    • 查看文件信息
    • sh文件示例
    • `expr`四则运算
    • 注释
    • 声明字符串常量
      • 访问
      • 长度
    • `$()` 将(标准输出)重定向到(常量)
    • 字符串切割
    • linux命令 与 shell命令
    • echo 标准输出
    • sort排序
    • 输出文件内容
    • 写入并覆盖文件
    • 读出文件并写入另一个文件
    • (命令行参数) 和 (标准输入), 管道
    • `> 和 >>` 将(标准输出)重定向到(文件)
    • `<` 将(文件) 流入 (标准输入)
    • `xargs` 将(标准输入)重定向到(命名行参数)
    • 管道`|` 将 (标准输出) 重定向 (标准输入)
    • 查找文件/目录
    • 查找文件内容
    • 历史命令
    • 下载工具
    • sh文件
    • 选中、复制、粘贴
    • source引入头文件
    • 重定向
    • 函数
    • for/while循环/continue
    • #! /bin/bash
    • chmod
    • 条件if
    • expr
      • length
      • 四则运算
      • 比较
    • 字符串、变量
      • 只读变量
      • 全局变量
    • 打印
    • 取字符串/数组 的长度
    • 脚本参数
    • 进程id
    • 获取（命令）返回值
    • 数组
  • linux文件系统
  • 命令
    • 进程
    • ctrl + c/d
    • seq
    • read/echo
    • data
    • bash
    • touch
    • ls
    • cp
    • mkdir
    • mv
    • cat
    • rm
    • history
    • tmux
    • vim
  • Linux命令
    • rm
    • file
    • arch
    • 管道
    • 环境变量
      • 修改环境变量
      • PATH环境变量
    • LD_LIBRARY_PATH
    • C_INCLUDE_PATH, CPLUS_INCLUDE_PATH
    • PYTHONPATH
    • JAVA_HOME, CLASSPATH
  • 常用命令
    • top
    • df
    • free
    • du
    • ps
    • kill
    • netstat
    • w
    • ping
    • ls
    • chmod
    • find
    • grep
    • ag
    • wc
    • tree
    • xargs
    • more
    • head, tail
    • history
    • md5sum
    • tar
    • sudo
    • apt-get
    • pip

WIndows与Unix基本命令

分类Windows 系统Unix 系统
文件列表dirls
切换目录cdcd
建立目录mdmkdir
删除目录rdrmdir
比较文件fcdiff
复制文件copycp
移动文件movemv
文件改名renmv
删除文件delrm

Bat文件

规范

开头写成: @echo off, 就像sh文件的开头#! /bin/bash

echo off是: 下面的命令, 不展示在命令行中;
@在一个命令前: 该命令不展示在命令行

注释

:: hhh

Windows-CMD

介绍

Windows 自带的命令行界面有两个。

  • “命令提示符”（cmd）是其中较为古老的一个，功能也相对简单。
  • PowerShell 是较新的一个命令行界面，自带的功能丰富，但相对臃肿。

两个界面都可以在开始菜单中找到。

管道|, 重定向> <

详见 下面的Linux, 一样的

相对位置

Windows下, 与 Linux, 在处理绝对位置时, 是非常非常不同的!!!

Linux下, 需要是: ./a.exe

而在Windows下, 必须是: a.exe, 不可以加./

因此: 在Linux下是: system( "./go.exe"), 而在Windows下必须是: system( "go.exe")

fc

fc a.out b.out 比较两个文件的差异

创建文件

echo > a.txt

删除文件/文件夹

del a.txt
del dir

创建文件夹

mkdir dir

输出文件内容

type a.txt

中文乱码 CHCP

数据，存在计算机上的二进制，是已经确定了！！！
（毕竟，一个exe已经生成了）

关键是，如何去解析 这些（二进制）！！！ 以什么编码方式，去解析。

CHCP  // 获取当前代码页

CHCP 65001		' utf-8 '
CHCP 936		' gb2312 '

vim

缩进

按v选中一些行后, ( 按shift + >是向右缩进) ( 按shift + <是向左缩进)

查找

/abc 查看所有的含abc的位置

显示行号

:set nu 显示行号

:set nonu 不显示行号

删除

ggdG 删除

视图跳转

x G: 视图回到 (第x行)

G: 视图到 (最后一行)

x 回车: 视图往下移动 (x行)

page up 或 page down: 视图移动

复制

选中: v

复制: 按v进入选中模式, 然后选中后, 按y

粘贴: p粘贴

剪切一行: dd剪切一行

复制代码
:set paste进入复制模式, 复制完后: : set nopaste

Deprecated

`ggdG` 剪切所有内容

gg=G    ' 格式化代码 '

u      ' 撤销 '

v      ' 然后, 按方向键, 进行文本的选中 '

y	' 复制 所选中的内容.   y是yank复制    (无法复制出来, 即仅限于vim里)'
yy  ' 复制一行 '

p   ' 粘贴   paste '

:set paste   ' 当你要shift+insert, 往vim里 粘贴进一些文本时, 要设置这个模式; 否则你的文本, 和他原来的格式 不一样 '

:set nopaste  ' 绝大多数下, 都是使用这个模式 (默认vim也是这个模式); 只有当你要粘贴时, 设置paste, 粘贴完毕, 就设置回去nopaste '

/abc '查找 找所有`abc`字符串（按“回车”后，按`n` 可以进行迭代） '

解释paste模式

	int x;
	a
b

当你在;的后面, 按下回车时, 你肯定是希望光标在a 处 这就是nopaste模式, 即他会自动给你缩进

但是, 当你要粘贴文本时, 你肯定不希望, 在你文本中的 每个’\n’后面, 都新加一个tab缩进. 即让文本按照本来的样子来粘贴, 这就是paste模式

tmux

复制粘贴

ctrl a, [ 进入(复制模式), (然后你点击左键, 按住, 一旦松开, 就表示复制了)

ctrl a, ] 粘贴

(只在tmux里有效), 在外界不可以; (在外界, 使用ctrl+v也不行, 即, 他和本机电脑的粘贴板无关, 但ctrl insert会进入电脑粘贴板)

tmux

如果是在(非tmux)模式下, 则开始一个新的tmux

ctrl d

如果是在(tmux)模式下, 则 (退出) 并 (删除) 该tmux

ctrl a, d

如果是在(tmux)模式下, 则 (退出) 并 (挂起) 该tmux

tmux a

如果是在(非tmux)模式下, 则 进入 (被挂起了的) tmux

tmux a, s

如果是在(tmux)模式下, 则 展示所有的tmux目录

tmux a, shift 5

如果是在(tmux)模式下, 则 在(右侧) 产生一个 新的分屏tmux

tmux a, shift "

如果是在(tmux)模式下, 则 在(下侧) 产生一个 新的分屏tmux

tmux a, z

如果是在(tmux)模式下, 将当前的分屏tmux, 全屏展示 或 取消全屏展示

Deprecated

tmux  ' 打开一个新的tmux '
tmux a   ' 打开之前挂起的tmux (即恢复你之前的那些分屏状态) '

ctrl + a, shift + 5   ' 左右分屏 '
ctrl + a, shift + "   ' 上下分屏 (注意, 是引号键)'

ctrl + a, 方向键   ' 切换视图 '

ctrl + d   ' 删除tmux, 退出; '
ctrl + a, d  ' 挂起tmux, 退出;   [ctrl+d, a]是保存tmux 退出, 然后[tmux a]是恢复之前的tmux状态 '
'比如你当前有很多的分屏, 你想要保存下来, 明天继续 '

ctrl + a, s   ' 查看所有挂起的tmux  (即被ctrl+d的) '
然后, 选中某个, 按x y  ' 删除某个tmux;     按下x, 下面命令行会提示 是否删除'

ctrl + a, z   ' 全屏/取消全屏 '

直接鼠标左击选中(复制)
ctrl + a, ]    ' 粘贴,  但只能在tmux里粘贴 '

按住shift选中, ctrl+insert ' 也会选中其他tmux, 最好提前给ctrl+a,z 全屏'
shift + insert  ' 粘贴 '

Sh脚本文件

以下的内容, 不仅适用于Sh文件, 也可以直接在shell里直接录入
其实是一样的, 因为sh文件里的内容, 就是在shell里执行的

创建一个sh文件

  • 第一步
    在文件里开头输入: #! /bin/bash
    一个sh文件, 必须开头写上这句话; 注释, 也不可以写在第一行
    否则, 你执行./xx.sh时, 没有 (自动补全)的功能
  • 第二步
    对该文件chmod +x xx.sh 给予(执行权限), 否则./xx.sh执行不了

命名行参数

当执行脚本时: ./xx.sh aa bb cc

在sh文件里面, 通过${1}就得到第一个命名行参数 aa;
${0}是: ./xx.sh, 即对应的下标为: 0 1 2 3

即, 可以看做是: 有名称为0 1 2 3 ...的 常量

通过$#, 可以得到 (最大的下标值), 即上面的3

linux命令

查看文件信息

ldd main.exe 查看这个程序, 链接了哪些DLL

        ntdll.dll => /c/WINDOWS/SYSTEM32/ntdll.dll (0x7ff9462f0000)
        KERNEL32.DLL => /c/WINDOWS/System32/KERNEL32.DLL (0x7ff944490000)
        KERNELBASE.dll => /c/WINDOWS/System32/KERNELBASE.dll (0x7ff944050000)
        msvcrt.dll => /c/WINDOWS/System32/msvcrt.dll (0x7ff944850000)
        libstdc++-6.dll => /mingw64/bin/libstdc++-6.dll (0x62860000)
        libgcc_s_seh-1.dll => /mingw64/bin/libgcc_s_seh-1.dll (0x63240000)
        libwinpthread-1.dll => /mingw64/bin/libwinpthread-1.dll (0x64940000)

nm main.exe 查看(符号表所有的全局变量/函数) (由于符号太多, 一般是: nm main.exe | grep xx)
(符号表, 是在exe里的!!! 而符号表很大的, 一般上线的程序, 会将这个符号表 从exe里删除掉)
(比如, exe的大小是54Kb; 删除(符号表)后, exe的大小是: 16Kb)
strip main.exe删除掉(符号表) 此时, exe的大小 就变小了; 再使用(nm main.exe)就没有符号表了

file main.exe 查看(文件信息)

size main.exe 查看程序的各个段

   text    data     bss     dec     hex    filename
   9916    2348    2432   14696    3968    main.exe

sh文件示例

len=$(expr ${#1} - 4)	#4为文件的后缀 ".cpp"
name=${1:0:len}

比如, 你输入的是: a.sh abc.cpp
那么, len == 3, name == abc

expr四则运算

shell不支持直接, 需要借助expr

expr 5 - 3, 等价于: expr "5" - "3"
将结果直接输出到 (标准输出)

var=$(expr 5 - 3) 存到常量里

注释

# hhh

声明字符串常量

data=123

注意, =前后不能有空格

a=123 和 a="123" 是完全一样的!!!

没有(数据类型)的概念, 都是string字符串类型

而且, 这个字符串, 也就是这个常量, 是const的!!! 不能修改

a="123", 然后a[0]='a'这是不正确的!!! 最终a会变成一个(数组)!!! 而不是a23

访问

访问常量: ${a};
(如果你直接写一个a, 他和一个名为a的常量, 没有任何关系!!!)

读取出来的是(原始值), 并不是(字符串)

比如: a="ls /hh/"
然后直接: ${a}, 这相当于: 你在shell里, 执行了一个ls /hh/命令!!!

长度

${#var}, 获取该字符串的长度

$() 将(标准输出)重定向到(常量)

保留你sh文件里, 写了一个ls
那么, 这也就相当于: 你在shell里, 打了一个ls命令, 即输出到了屏幕上

如果你想将 (该命令的输出), 存放到 (变量)里, 而不是 (屏幕);
则$() 可以重定向

str=$(ls): 不会输出到屏幕, 而是存放到了str里

字符串切割

${str:5:2}: 对应str[5, 6]子字符串

linux命令 与 shell命令

ls是 linux命令

echo是 shell命令

echo 标准输出

echo "abc" "def", 等价于: echo "abc def"

echo默认是不开启(转义), 即: echo "b\na", 这个字符串 是4个字符: b \ n a
echo -e "b\na" 开启转义; 这个字符串, 是3个字符: b \n a

sort排序

输入

  • 命令行参数: (文件位置)
    sort a.txt: 将文件里的内容, 按行划分, 然后 按照(字符串规则) sort排序
    sort a.txt b.txt: 将这些文件的所有内容, 按行划分, 然后sort排序
  • 标准输入
    根据(标准输入)的内容, 进行(按行排序)
    echo -e "b\na" | sort, 得到: a b (注意, 必须要-e对echo转义)

find . -type f -name "*.txt" | sort

  • 首先, |前的find, 会找到所有的txt文件
    ./new.txt
./d.txt
./c.txt
./b.txt
./a.txt
./a/zz.txt
  • 然后, 上面的内容, 本来是要到 (标准输出屏幕)的; 通过|, 他变成了 (标准输入) 给了 sort, 最终sort排序后, 给到 (屏幕):
    ./a.txt
./a/zz.txt
./b.txt
./c.txt
./d.txt
./new.txt

输出文件内容

cat a.txt

写入并覆盖文件

echo "abc" > a.txt

读出文件并写入另一个文件

cat a.txt b.txt > c.txt 将a.txt 和 b.txt的内容, 按照顺序即先a.txt, 后b.txt, 拼接到一起, 写入c.txt里

(命令行参数) 和 (标准输入), 管道

所谓 (标准 输入/输出), 其中的标准, 通常是指: (屏幕)

一个命令的 (输入), 分为: (命令行参数) 和 (标准输入)

一个命令, 几乎都支持(命令行参数); 但是, 可能不支持(标准输入)

大多数情况下, 如果(命令行参数)是: 文件位置, 则(标准输入) 就是: 该文件的内容 (说白了, 就是任意的文本)

cat a.txt, 其中的 a.txt 称为: (命令行参数)

(命令行参数):

  • 要么是(显式)调用 cat xx, 这个xx, 就是(命令行参数)
  • 要么是| xargs的(隐式)调用, xxx | xargs cat (假设xxx的屏幕输出是yyy), 则他会变成: cat yyy, 这个yyy, 也是(命令行参数)

(标准输入): 现在还不是特别了解

他只能是(隐式)调用, 通过(管道); 有些命令, 可能并不支持 (标准输入)

比如,wc -l (计算文件的行数): 他的(命令行参数)是: 文件位置
wc -l a.txt (计算a.txt的行数)

那么, 他的(标准输入)是: 文件的内容

(标准输入), 不能(显式)调用!!!
wc -l "abc", 其中"abc"并不是 (标准输入), 这样写, 是错误的;

(标准输入), 只能通过 (管道)的方式;

管道: 将 (标准输出) 转换为 (标准输入)

echo "abc" | xx, 其中, "abc这个内容, 本来是要 输出到 (屏幕的) 即, echo "abc"是个 (标准输出)
现在, 通过|管道, 这个(标准输出) 会成 (下个指令) 的 (标准输入);
xx他就会 接收到 (内容为: abc) 的 (标准输入)

同样, cat a.txt | xx, 其中, xx 会 接收到 (内容为: a.txt文件里的内容) 的 (标准输入)

比如, wc -l这个命令, 他的: (命令行参数是: 文件位置) (标准输入是; 文本)

目的是: 输出当前目录下, 所有的txt文件的 总行数
___1, wc -l *.txt (命名行参数) 的方式
___2, cat *.txt | wc -l (标准输入) 的方式

> 和 >> 将(标准输出)重定向到(文件)

echo "abc" > a.txt , echo的内容, 本来是要往(屏幕)输出的, > 或 >> 将他 (重定向) 到了 (文件)里

  • >是 覆盖方式
  • >>是 追加方式

< 将(文件) 流入 (标准输入)

go.exe < data.in,

go.exe < data.in > go.out, 可以复合

xargs 将(标准输入)重定向到(命名行参数)

我们知道, >符号, 可以 (重定向) 到 (文件)里

但如果我们想 (重定向)到 (命令行参数)呢???

比如, 我们知道, cat命令, 可以接收 (若干个) (文件位置) 的参数, 比如: cat a.txt b.txt c.txt

但如果, 这个参数非常长, 我们不想每次都去 (手动的) 写这个参数, 而是想: 将参数, 写入到文件里,
每次调用cat命令, 就去(文件)里, 去读取 (参数)

比如, 我们写入到config.txt里, 他里面内容是: a.txt b.txt c.txt
我们想要: cat a.txt b.txt c.txt, 即可以写成: cat config.txt | xargs cat

xxx | xargs a b c d 比如, xxx会往(屏幕)输出yyy
那么, 以上命令, 会变成: a yyy b c d

  • 首先, xxx 产生的这个(标准输出yyy), 经过 |后, 会变成: (标准输入)的yyy
  • xargs 再将 (标准输入)的yyy, 变成 (命令行参数)的yyy; 而且这里要注意, 是放到了a的后面

管道| 将 (标准输出) 重定向 (标准输入)

A.exe | B.exe
这会在内存创建一个管道，然后两个程序被同时启动。程序 A 每次要输出被重定向到这个管道中，而这个管道本身不会存储数据（其实有一个很小的缓冲区）。在 B 读取之前，A 的输出操作会被阻塞，等到 B 把数据读入以后，A 的输出才能继续进行。这样优美地解决了上述的问题，没有磁盘 IO 操作，两份代码同时运行，也没有额外消耗很多的内存储存中间结果。

cat data.in | ./a.exe, 相当于: ./a.exe < data.in

查找文件/目录

find . -type f -name "*.js" 找所有的*.js文件

-type f 专指: 文件
-type d 专指: 目录

find . -name '*static*': 所有与static相关的 (文件/目录/…)

如果写成: 'static'是 文件夹, 不包含文件; 因为, 文件肯定有., 所以一定要写*

查找文件内容

ag 'hhh' .

历史命令

ctrl r 进入(搜索模式)

下载工具

Linux系统, 分为2种: (RedHat系列: RedHat, CentOS) (Debian系列: Ubuntu, Debian)

RedHat用的工具是: yum
Debian用的工具是: apt-get

通过: cat /proc/version, 可以查看系统版本
Linux version 5.4.0-110-generic (buildd@ubuntu) (gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1)) #124-Ubuntu SMP Thu Apr 14 19:46:19 UTC 2022

sh文件

linux中常见shell有： sh bash(sh的加强版, 默认)

shell文件里的代码，都可以直接放到你的命令行里执行！！ 一样的，只是写成文件，每次可以自动的执行。

选中、复制、粘贴

在shell里，鼠标操作 或 以往的ctrl+c是 不可以的, 而且是危险的!!!
如果你正在有个任务进行, ctrl+c会中止任务!!!

  • 选中： 按住shift，鼠标左击
  • 复制： ctrl + insert
  • 粘贴: shift + insert

source引入头文件

类似于C语言, 我们提前写好一些 代码, 然后其他的sh 就可以直接的引入. (其实和C语言一样, 就是代码文件的展开)

a.sh:
	var=123

b.sh:
	source /home/acs/a.sh		' source也可以写成: . '
	
	echo ${var}

终端terminal是一个 (大的 bash脚本文件), 我们登陆时, 他会模式先执行( /home/acs/.bashrc)里的所有内容

而这个文件, 他并不是一个.sh文件, 执行权限也没有x.
即./bashrc 这个命令, 是不可行的.

但是, 这个文件里, 都是shell命令!! (比如, 一些ls, dir, ... , 都可以在shell执行的)

此时, 就可以使用 (文件内容展开) 这个功能.

即把该文件的内容, 都展开到 (当前terminal)里, 也就是: ==该文件里的代码, 都执行了一遍!!! ==

比如: a.txt里是: dir
./a.txt 是失败的. (他没有+x权限)
source a.txt 就等价于 (执行了dir), 因为把a.txt里的内容, 展开到当前命令行里

重定向

linux所有进程, 默认都会打开 3个 文件描述符: (stdin 0, 从命令行输入) (stdout 1, 向命令行输出) (stderr 2, 向命令行输出错误)

dir > a.txt          ' 将dir的输出, 以(覆盖方式) 到a.txt里 '

ls >> a.txt      ' 将ls的输出, 以(追加append方式) 到a.txt里 '

read var < a.txt    ' 从a.txt里, (读一行)!!!  因为, read遇到(\n)就结束 '

函数

func(){
	a="abc"
	echo "hello ${a}"
}

func		' 函数的调用, 不用写参数 '

func(){
	a="abc"
	echo ${a}	 

	return 123		' shell里的函数, 返回值是(exit code,在[0,255]之间) '
					' 一般, 0为表示成功(你不写,默认是他) '
	
	'因为, 没有函数返回值这个概念, 所以, 如果要获取返回值, 你可以规则 用他的stdout(即echo) '
}

output=$(func)	' output == "abc" '

ret=$?		' ret == 123 '

for/while循环/continue

for i in 123 abc 456		' 类似于c++的 序列化容器 '
do 
	echo ${i}
done

-----------------

for i in $(ls)		' 命令的输出 '
do
	echo ${i}
done

--------------------

for i in $(seq 1 10)	' 遍历 [1,...,10] '
do
	..
done

----------------

for i in {1..10}  ' 遍历[1,...,10] ;'

for i in {10..1}  ' 遍历[10,9,...,1] '

for i in {a..z}  	' 遍历[a,b,..,z] '

--------------

for ((i=1; i<=10; ++i))		' 遍历 [1,...,10] '
	...	

while read a			' 当你ctrl + d时, 就是文件结束符. 即终止录入 '
do
	echo ${a}
done
	
-------------------------

for ((i=1; i<=10; ++i))
do
	if [ $( expr ${i} % 2 ) -eq 0 ]			' 跳过所有的 偶数 '
	then
		continue
	fi
	echo ${i}
done

#! /bin/bash

开头 必须要写上： #! /bin/bash，这是在指明（使用bash作为 脚本解释器）

chmod

chmod: change mode 改变模式

一个执行文件`a.sh`，需要有（执行的权限）： `chmod +x a.sh`

条件if

if

if [ ${a} -lt ${b} ]
then						' 注意这里有个then, 其实就表示: 如果这个if成立,则... '
	echo "a < b"
else
	echo "a >= b"
fi

取反

if ! [ ${a} -eq ${b} ]		' 取反: ! '
then
	echo ""
if

elif

if [ .. ]
then
	...
elif [...]
then				' 注意格式!! '
	...
else
	...
fi

expr

length

expr length "${var}"，求一个字符串的长度 （加""，是处理 var里有空格的情况）

四则运算

v1=123
v2=456
  
echo ${v1+v2}   ' 输出是出错的！ '

shell是不支持运算的！！

v1=123
v2=456

echo $(expr ${v1} + ${v2})     ' 注意， +的左右 要有空格！！ '

echo $(expr ${v1} - ${v2})     ' -号，左右要有空格！ '   

echo $(expr \( ${v1} + 1 \) \* ${v2})  ' *号要转义(\*)！！  括号也要转义！！ '

比较

v1=123
v2=456

echo $(expr ${v1} '==' ${v2})    ' 判断是否相等 （注意，要用单引号括起来） '

echo $(expr ${v1} '<' ${v2})

字符串、变量

var="abc"
var='abc'
var=abc

三种写法都可以，注意：等号左右，不可以有空格！！
（''写法，不会转义！！ ""写法，会进行转义！）

shell里不存在（数据类型）的概念，即都是“字符串”！！ （但他会自动检测，当需要是整数时，他会自动转换）

shell里的变量, 不存在 (定义)这个含义.
比如你 echo ${a}, 即使他不存在, 也不会报错, 他的值是空的.

空格

var="abc ef"

echo ${var}

这是会报错的！！！
但是，并不是说，var不能存储空格！ 而是，${var}操作 其实就会变成：abc ef！！！

即，其实是形如： echo abc ef，这是报错的！！

所以，在对字符串进行操作时， 最好要加上 ""（可以处理，有空格的情况）

即，echo "${var}"，这就对了

只读变量

var="abc"

readonly var

var只读，不可以修改

全局变量

export var： 所谓“全局”，指的是 “进程”！！ 即，当前进程的 子进程，可以访问到（当前进程里的var）

export var=123: 声明一个全局变量

打印

echo 输出到屏幕

取字符串/数组 的长度

var="abc"

echo ${#var}       ' 会输出： 3 '

脚本参数

echo ${0}
echo ${1}
echo ${2}
echo ${3}

当执行：./a.sh 1 2 3 ，会输出： ./a.sh 1 2 3

当执行：/home/wc/a.sh 1 2 3 ，会输出：/home/wc/a.sh 1 2 3

（即，你命令行是怎么执行的这个sh文件， 就对应几个参数）

echo $#，表示，你传入的（参数个数）输出参数个数（不包括第一个参数） （比如上面命令， 你传入了：1, 2, 3 共3个）

进程id

$$ 当前进程id

获取（命令）返回值

echo $(ls)   等价于 echo `ls`     ' 输出： ls的结果 '

注意，是$()，不是${}

数组

arr=(123 "abc")

以上写法，完全等价于：
arr[0]=123
arr[1]="abc"


--------------------------

获取元素： ${arr[0]}

---------------------------

arr[0]=1
arr[5]=5
arr[10]=10

${arr[*]}   ' 所有元素： 1 5 10 '

${#arr[*]}  ' 数组长度： 3 '

可以发现，shell里的数组，有点像是： map的感觉！！

linux文件系统

bin
常用的 可执行文件的 命令

etc
放配置。比如，代理服务器nginx，他的配置，都是在etc里面。

var
比如，日志log，会放到这里。

lib
比如，C++的头文件，会在这里

home
所有的用户，都会在这里

proc
比如，他里面有一个cpuinfo，存的是（cpu的信息）

命令

进程

top : 动态

ps aux: 静态

kill -9 PID:  杀死一个进程

ctrl + c/d

ctrl + c:  终止(杀死) 进程!!

ctrl + d:  文件结束符 (即read会终止)

seq

seq -3 3     ' 返回: [-3, -2, -1, 0, 1, 2, 3] '

read/echo

read a			' 等价于: cin '   ' 结束符是: ctrl + d '

echo ${a}	    ' cout, 但是, 会自动换行!! '

echo -e "abc \c"    ' -e是开启(转义),  '

echo "a b" > a.txt   ' 以覆盖方式, 重定向 '

data

data   ' 日期 '

bash

在当前的 terminal的基础上，再开一个bash！（新开的bash，是当前bash的 “子进程”！！！）

exit，退出新开的bash（子进程）

touch

touch 1.cpp 创建1.cpp文件

ls

ls | wc -l 所有 (文件 + 文件夹)的 个数

ls -l 所有（文件夹 和 文件）的详细信息

ls -a 包括（隐藏文件）

cp

复制 文件
cp ./dir1/a.txt ./dir2 此时，./dir2有一个a.txt（复制操作）

cp ./dir1/a.txt ./dir2/b.txt 此时，./dir2有一个b.txt（复制 + 重命名操作）

cp a.txt b.txt （把当前目录下的a，复制一份，命名为b）

复制 文件夹
cp ./dir1 ./dir2 -r （把dir1的所有东西，复制到dir2里）

mkdir

mkdir /dir （创建文件夹）

mv

mv a.txt b.txt （重命名操作）

cat

cat a.txt （输出文件内容）

rm

rm *.txt （删除当前目录所有*.txt）

rm * -r （删除当前目录下，所有的 “文件夹 + 文件”）

history

history （展示，所有你使用过的 命令）

tmux

功能：

  • 分屏
  • 允许断开terminal后，继续运行进程
    你在tmux里的命令等，会存到服务器里。 即使你本机terminal关闭或断网了，重新打开terminal，他还是会恢复的！！！

一个tmux里，可以包含有多个session
一个session，可以包含有多个window
一个window，可以包含有多个pane

tmux命令： 新建一个session （其中会包含一个window，window里包含一个pane也就是分屏，pane里包含一个shell对话框）
、、、、如果已经在tmux模式下，则该命令就失效（因为，一个session下 无法再创建一个session）
、、、、（比如，普通shell 和 tmux模式，长相是一样的，如何区分 当前是否是在tmux模式呢？ 就可以输入tmux命令，看他能否创建一个tmux）

在tmux模式里： ctrl+a，然后松开，shift+5 将当前pane，分成左右2个 （分屏）

在tmux模式里： ctrl+a，然后松开，shift+" 将当前pane，分成上下2个 （分屏）

在tmux模式里：ctrl+d 关闭(删除)当前的分屏（如果是最后一个tmux，则退出tmux模式）

ctrl + a，然后，方向键 在多个分屏中，切换

ctrl + a, 然后，d 挂起当前的session
tmux a(ttach) 回到 刚才挂起的session

在tmux里的（任意一个session里）ctrl + a，s 查看并选择所有的session

一般常用的是: tmux 新开一个 tmux a 回到一个tmux里 ctrl d, 关闭

vim

  • （默认模式）

    • 输入i，进入（文本编辑模式）
    • 输入: 或 ? 或 / 进入（命令行模式）
    • G到最后一行， 3G (3, 然后, shift+g)到第3行 （gg = 1G，到第一行），3回车 向下走3行

  • （文本编辑模式）

    • 按esc，进入（命令行模式）

  • （命令行模式 “光标会出现在最下面”）

    • : wq 保存退出
    • /abc 查找 找所有abc字符串（按“回车”后，按n 可以进行迭代）
    • :a,bs/aaa/bbb/g 替换：把第[a - b]行里的 “aaa”字符串，全部换成“bbb”（当a=1, b=$时，表示“全文”）
      、、在该命令最后，加上c（即/gc），则每一次的替换，需要你确定）
    • v 选中
    • d 剪切(删除) dd 剪切当前行
    • y 复制， yy复制一行
    • p 粘贴（在当前光标的“下一个位置” 粘贴：如果复制的是一行 则在下一行粘贴，否则在右侧一个位置。。。奇怪）
    • u 撤销
    • :w保存， :w!强制保存， :q退出，:q!强制退出，:wq保存退出
    • : set paste 设置为粘贴模式（取消 代码自动缩进功能）。 : set nopaste（开启 代码自动缩进）
    • ggdG 删除所有内容
    • 输入: 或 / 或 ?后， 按（上下方向键），可以查看历史的命令
    • 如果一行内容很多，（home是开头，end是末尾）
    • gg=G 全文格式化

当vim在操作文件时，会创建（.swp）的临时文件。（当vim退出后，.swp文件会删除掉）
a.sh -> .a.sh.swp（注意，最前面有个.）

所以，当一个vim打开一个文件时，如果该文件，有.swp文件；则会报错（因为，已经有个进程A打开了该文件）
（此时，有2种方式： 要么关闭进程A，要么删除swp文件）

Linux命令

rm

rm -rf * 删除所有 (非隐藏)的 文件/目录

rm -rf .* 删除所有 (隐藏)的 文件/目录

file

file 查看文件是32位还是64位

file .dll或.exe, 查看 这个dll/exe, 你当初 是使用的: (32位) 还是 (64位) 的编译器 这与你的计算机arch无关

  • PE32+ executable (console) x86-64, for MS Windows 这是64位的
  • PE32 executable (GUI) Intel 80386 (stripped to external PDB), for MS Windows 这是32位的

arch

arch常看计算机体系结构
x86_64: 64位电脑

管道

管道, 有点类似于 文件的重定向.

文件的重定向是: 将前一个命令的stdout, 输入到, 文件里 即左侧是命令, 右侧是文件
echo "abc" > in.txt: 将abc 覆盖到 in.txt里

管道:是将 前一个命令 的stdout输出, 对接到, 下一个命令的 stdin输入, 他的左右两侧, 都是命令

' 当前文件夹下, 有a.txt(内容是: content_a) 和 b.txt(内容是: content_b) '

ls  ' 输出:  a.txt  b.txt '

ls | cat    ' 输出:  a.txt  b.txt   (即, cat接收了 stdin, 类似于: cat "a.txt b.txt") '

ls | xargs cat  ' 输出: content_a  content_b  (xargs cat是: 将stdin, 变成参数!! 即: cat a.txt b.txt) '

find . -name '*.txt'   ' 输出: ./a.txt  ./dir/b.txt  (作用是: 输出当前文件夹下 所有*.txt的相对路径 (包括子文件夹里的)'

xargs cat    ' 将stdin, 变成 参数;  (即, 将cat "a.txt" 变成 cat a.txt) '

wc -l  ' 计算文本的总行数 '

find . -name '*.txt'  |  xargs cat  |  wc -l  ' 计算所有*.txt 的内容的 总行数 '

即, 管道 可以支持串联操作, 即从左到右, 将前一个的stdout, 变成, 后一个的stdin

环境变量

环境变量, 类似于全局变量, 所有进程都能访问到

env命令: 展示所有的 当前用户的 环境变量

PWD=/home/acs/test    ' 我们使用PWD命令, 其实就是输出的这个变量的值 '
SHELL=/bin/bash
LOGNAME=acs    ' 当前登录的 用户名 '
MOTD_SHOWN=pam
HOME=/home/acs
SSH_CLIENT=47.93.242.17 45434 22

set命令: 展示当前shell的 变量

输出某个环境变量的值: echo $PWD

修改环境变量

修改某个环境变量的值: export HOME=/home/acs/test
本来, 家目录~是: /home/acs, 现在的家目录~就修改了
但是, export修改的环境变量, 只是在当前的bash环境下有效. 只是临时的修改 (比如你重启下服务器, 还是原来的值)

如果你想要 持久化的修改, 则需要: 将你的命令, 放到/home/acs/.bashrc里的 最后一行

' .bashrc 文件 '
export PATH=/home/acs/.homework:$PATH
alias tmux='tmux -u'

export HOME=/home/acs/test   ' 新加 '

然后, 记得要执行下这个bash脚本: source .bashrc

当我们每次启动bash, 都会执行下.bashrc文件

虽然你修改了~家目录, 但是, 每次启动服务器 默认打开的目录是: /home/acs/ 即, home下的, 当前用户, 这个目录

PATH环境变量

PATH环境变量, 存的是: 所有的命令(即exe可执行文件) 的 路径.
/home/acs/.homework : /usr/local/sbin : /usr/local/bin 以:号隔开, 都是一些文件夹

比如, 我们的homework命令, 就对应于: /home/acs/.homework/文件夹下, 有一个名为homework的 exe文件

我们使用的命令, 系统会遍历, PATH里的 所有的 路径; 直到找到第一个匹配的 exe文件

LD_LIBRARY_PATH

动态库
当前我们的exe执行时, 用到了 动态库 里的 函数, 他就会去找找个动态文件, 然后执行这个动态文件的 函数

优势

  • 由于, 动态库 是在 我们的exe的 外面, 所以: 我们的exe文件, 会很小
  • 如果我们修改动态库, 则需要编译dll即可, exe文件不用动; 两者是分离的关系

LD_LIBRARY_PATH环境变量, 是用来存dll的目录

当这个环境变量的值, 是空的时; 系统会去默认的的一些目录下, 找.so文件

比如, 系统会去 /usr/local/lib下找.

比如, 我们用到的: -lthrift. 我们的exe 只有几百kb, 非常小; 而使用到的thrift, 是dll 已经编译好的

C_INCLUDE_PATH, CPLUS_INCLUDE_PATH

存放: C C++ 的 头文件

当该环境变量是空的时, 系统也会去 默认的目录下 找

比如/usr/include下, 就会很多 头文件, 比如algorithm cstdio ...

当我们文件里: #include <algorithm>, 系统去一些目录下 找到该头文件, 然后 宏展开, 头文件代码展开 到我们的项目文件中去

PYTHONPATH

python有交互式的 解释器, 比如, 我们在终端 输入ipython3命令, 然后就进入了 python的交互式终端
你输入一个print("abc"), 就可以立刻的得到他的结果. 非常的方便

比如, python里的: import random , 这个random 也是个文件
from match import Match: 即从match/ 文件夹里, 引入, Match.py 文件

PYTHONPATH里: 存python的导入包 的路径

ipython3 比 python3, 更智能化.

比如, ipython3 可以执行tab 代码提示, ls pwd 等命令

JAVA_HOME, CLASSPATH

JAVA_HOME: jdk的目录
CLASSPATH: Java的导入类的路径

常用命令

top

查看 前几个 进程

M: 使用内存排序
P: 使用cpu排序

df

df -h 磁盘使用情况

free

free -h: 内存使用情况

du

du -sh: 查看当前文件夹的 大小

ps

ps aux: 进程

ps aux | grep myApp: 查找与myApp相关的 进程信息

kill

kill -9 123 删除pid进程id为: 123的 进程

netstat

netstat -nt 所有的网络连接

Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0    368 172.17.0.58:22          47.93.242.17:57520      ESTABLISHED

' 我们的本机电脑的浏览器 与 acwing的终端, 的 连接'

比如, 我们的

w

所有登录的 用户.

ping

ping www.baidu 检查下, 当前服务器 是否联网 必须是百度, 有些网站是不允许ping的

ls

ls -a 查看隐藏文件

ls -l 查看文件的详细信息

chmod

d rwx rwx r-x

  • 第一位: d: dir目录 -: 文件 `l: link链接文件(快捷方式)
  • 后面, 每三个为一组, rwx, 如果是-则为不能
  • 第一组: 自己的权限
  • 第二组: 同组的用户
  • 第三组: 其他的用户

chmod [+-][rwx] [filename]: 修改 所有人 (即: 自己 + 同组 + 其他) 的权限

比如: chmod -w a.txt: 让a.txt的 3个w权限, 都变成 -, 即: 一定形如? ?-? ?-? ?-?

chmod 123 a.txt 1是: --x, 2是: -w-, 3是: -wx, 即此时a.txt变成: ? --x -w- -wx

find

find: 是在一个目录下, 找一些文件

find ./ -name '*.txt' 在当前文件夹下, 找所有的txt文件

grep

grep abc 这个命令执行后, 就相当于cin, 你需要你在stdin录入一些文本, 一旦你的文本中, 找到了abc, 他就会标记出来

acs@2dfcd9bf67d7:~/test$ grep 'abc'
aaabbbccc	' 这是我们自己录入的 '
aaaabcccc	' 找到了"abc" '

find ./ -name '*.txt' | xargs cat | grep 'abc'
(查到所有的txt文件的路径) (交给cat的命令行参数, 而不是stdin)(然后cat把这些文件的内容 都给输出给 grep的stdin)
cat起的作用是: 输入文件的内容

ag

ag 'xxx' ./*.txt 查询当前文件夹下, 的所有txt文件的内容中, 含有xxx的行
比使用管道, 更方便

acs@2dfcd9bf67d7:~/test$ ag 'sfa' ./*.txt
dir1/aaa.txt
5:sfasdf

b.txt
3:sfasdf

a.txt
7:sfasdf

wc

wc: 统计 行数, 单词数, 字节数
wc a.txt 单个文件
wc *.txt 多个文件

acs@2dfcd9bf67d7:~/test$ wc a.txt
17 27 75 a.txt      ' 行数, 单词数,  字节数 '

wc也可以接受 stdin, 所以, 他可以和管道配合
find . -name '*.txt' | xargs cat | wc -l 计算所有*.txt 的内容的 总行数 ’

tree

tree -a 可以查看隐藏文件

xargs

将stdin的内容, 变成, 命令行参数

more

cat是输出所有内容

more 也是输出内容, 但他是最多一个屏幕
回车: 下一行 空格: 下一页 b: 上一页 q: 退出

head, tail

head -3 a.txt 文件内容的 前3行

tail -3 a.txt 文件内容的 后3行

ps aux | head -3 只看前3行

history

history: 所有的 历史的 命令

~/.bash_history: 存放所有的 历史的 命令

md5sum

将任意长度的文本 根据MD5, 求哈希值

可以接收命令行参数的文件名, 也可以是stdin

比如, 数据库里 存的用户密码, 一般是一个 哈希值 虽然现在一般不使用MD5的哈希
然后当用户输入密码后, 将密码hash后, 然后去数据库里 查询是否存在

tar

tar -zcvf test.tar.gz test/* 将test/这个文件夹, 压缩

tar -zxvf test.tar.gz 解压缩

sudo

sudo 命令
sudo rm * -rf: 执行前, 会要求你输入密码

apt-get

apt-get install python 安装软件 (一般需要sudo权限)

pip

pip install xxx --user --upgrade 安装软件包

更多推荐

管道,Linux命令,Windows命令,cmd命令,tmux,vim,shell,bash,sh文件,bat文件