ssh

作用:从某一台服务器登录到另一台服务器,然后在上面进行一些开发.

远程登录服务器

格式:
ssh user@hostname
其中
user : 用户名
hostname: 目标服务器的 ip 地址或者域名
然后输入密码就可以登录了
如果想要断开连接的话,可以向其中输入 exit 或者 ctrl+d
具体如下：

第一次登录服务器时,会提示

The authenticity of host '123.57.47.211 (123.57.47.211)' can't be established.
ECDSA key fingerprint is SHA256:iy237yysfCe013/l+kpDGfEG9xxHxm0dnxnAbJTPpG8.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

直接输入 yes 回车即可,这样就把服务器的信息保存在了 ~/.ssh/known_hosts 文件中

登录某一个特定端口

默认的登录端口是22,但是如果想要登录其他的端口的话, 可以使用 -p 参数
ssh user@username -p 22
当然,首先要做的是在目标服务器上将端口号修改,然后才可以在这里用新的端口号进行登录

配置别名登录

每次输入这个 user@hostname 太麻烦了
可以在 ~/.ssh/config 文件中配置下服务器的相关信息
具体格式如下：

Host server1
    HostName IP地址或域名
    User 用户名

Host server2
    HostName IP地址或域名
    User 用户名

之后,再登录的时候,即可采用别名登录

配置密钥登录

避免每次登录都要输入密码,我们可以配置秘钥登录
1. 创建密钥 ssh-keygen,输入命令之后一路回车即可
2. 将公钥传递给对应的服务器,具体做法是将公钥id_rsa.pub 中的内容复制到目标服务器的 ~/.ssh/authorized_keys 文件里
这个 authorized_keys 中可以存放多个密钥, 用换行隔开即可
具体如下:

进一步简化

可以使用
ssh-copy-id myserver 一键将公钥给添加到别名为 myserver 中

配置好别名登录和免密登录之后,我们就可以一步登录目标服务器啦
如下：

扩展

自动化运维场景

ssh 后面可以跟一些命令,来获取在目标服务器上执行该命令的结果
格式如下:
ssh user@hostname command
具体如下：

scp

作用: 传文件

scp source destination
将 source 路径下的文件复制到 destination 中,如果有重名文件会将原来的文件给覆盖掉

本地和服务器之间的文件传递是双向的, 也就是说 source 既可以是本地路径,也可以是 server路径, destination 同理

• 本地路径就是直接写相对路径或者绝对路径都可
• server 路径 格式如下:服务器别名或者IP地址 :(冒号隔开) 路径(路径可以是绝对路径,也可以是相对于家目录的相对路径)

eg:

复制单个文件

scp source destination
1. 将本地的 input.txt 文件复制到 myserver1 的 /home/acs_3366 路径下(这里用的是绝对路径)

2. 将本地的 result.txt 文件复制到 myserver1 的家目录下(相对路径是相对于家目录的,所以后面啥都不写就是传到家目录下)

3. 将本地的 result.txt 文件复制到 myserver1 的 /home/acs_3366/test, 这里采用的是相对路径,所以直接填一个 test

一次性复制多个文件

scp scp source1 source2 destination
将所有文件的路径一次性写下来即可
这里就是将 myserver1 的 /home/acs_3366/test 下的 input.txt 和 result.txt 两个文件给复制到本地的当前路径下(一个点. 表示当前路径)

复制文件夹

加上一个 -r 参数即可,需要注意的是,这个参数需要加在前面

指定端口号

注意这里是 大写的 P,并且这个参数也需要加在前面

scp -P 22 source1 source2 destination

目标服务器与目标服务器之间传文件

用本地做中转站,也就是先把目标服务器1的文件下载到本地,然后再从本地将文件传递给目标服务器2.
当然两个目标服务器之间也可以互相传文件,但是对授权的要求比较高,可能会造成报错

配置服务器的 vim 和 tmux

用 scp 将本地的 两个相关的配置文件给传递到目标服务器对应的家目录下

scp ~/.vimrc ~/.tmux.conf myserver:

复习个小技巧：
如何把 acterminal 中的文件的内容整到本地
1. cat 文件,将文件的内容全部显示出来
2. 在开头点一下
3. 按住 shift,在结尾再点一下 就做到了内容全选
4. ctrl + insert 复制, shift + insert 粘贴

也可以通过这个技巧把 acterminal中的配置文件内容整出来,保存到本地,然后配置到我们自己的服务器上面去

变量赋值两边不要有空格啊

#! /bin/bash
input_file=$1                                                                                                                            sson_3/homework_4$ 
output_file=$2

# 输入重定向
read n < $input_file
sum=0
for((i=1; i<=$n; i++))
do
    sqr=`expr $i \* $i`
    sum=`expr ${sum} + ${sqr}`
done

# 输出重定向
echo  $sum > $output_file

救命，
用 Java 我都不一定会写
现在还要让我用 shell 写

#! /bin/bash

read n
read m

for ((i = 1; i <= n; i ++ ))
do
    st[$i]=0
done

dfs() {
    if [ $1 -eq $n ]
    then
        m=`expr $m - 1`
        if [ $m -eq 0 ] 
        then
            echo ${path[@]}
            return 0
        fi
        return 1
    fi  

    local j=0
    for ((j = 1; j <= n; j ++ ))
    do  
        if [ ${st[$j]} -eq 0 ] 
        then
            path[$1]=$j
            st[$j]=1

            if dfs `expr $1 + 1`
            then
                return 0
            fi

            st[$j]=0
        fi
    done

    return 1
}


dfs 0

一开始居然想用递归给算出来
我傻逼了
数组 + 循环+ expr 指令

//这里填你的代码^^
//注意代码要放在两组三个点之间，才可以正确显示代码高亮哦~
#! /bin/bash
## 数组加循环
read n
a[0]=1
a[1]=1
for((i=2; i<=n; i++))
do
    x=$(expr $i - 1)
    y=$(expr $i - 2)
    a[$i]=$(expr ${a[$x]} + ${a[$y]})
done
echo ${a[$n]}

一开始用的是函数
func + return
然后将函数的返回值作为那啥
但是过不了
于是转了

#! /bin/bash
# 判断参数个数是否为 1  不是 1 的话，则进入 if        
if [ $# -ne 1 ]
then
    echo "arguments not valid"                                          
    exit 1
fi                                                              

# 判断文件是否不存在,不存在的话，进入 if 
if [ ! -e "$1" ]
then
    echo "not exist"
    exit 2
fi

# 如果文件存在,则进项下面的判断,
if [ -f "$1" ]
then
    #为普通文件
    echo "regular file"
fi

if [ -d "$1" ]
then
    #为目录
    echo "directory"
fi

if [ -r "$1" ]
then
    # 具有可读权限
    echo "readable"
fi
if [ -w "$1" ]
then
    # 具有可写权限
    echo "writable"
fi

if [ -x "$1" ]
then
    # 具有可执行权限
    echo "executable"
fi

cd homeowrk_0 # 进入作业目录
vim helper.sh # 创建作业脚本
chmod +x helper.sh # 添加可执行权限

脚本内容如下:

#! /bin/bash

# ****** homework_0 *****
homework 1 create 0
dir0=/home/acs/homework/lesson_1/homework_0/
for i in dir_a dir_b dir_c
do
    #echo "file path is "$dir0$i
    mkdir $dir0$i
done

# ****** homework_1 *****
homework 1 create 1
dir1=/home/acs/homework/lesson_1/homework_1/
for i in a.txt b.txt c.txt
do
    #echo "file path is "$dir1$i.bak
    cp ${dir1}${i} ${dir1}${i}.bak
done
# ****** homework_2 *****
homework 1 create 2
dir2=/home/acs/homework/lesson_1/homework_2/
for i in a b c
do
    #echo "file " $dir2${i}_new.txt
    mv $dir2${i}.txt $dir2${i}_new.txt
done

# ****** homework_3 *****
homework 1 create 3
dir3=/home/acs/homework/lesson_1/homework_3/
for i in a.txt b.txt c.txt
do
    #echo "file path is"${dir3}dir_a/${i}
    mv ${dir3}dir_a/${i} ${dir3}dir_b/${i}
done


# ****** homework_4 *****
homework 1 create 4
dir4=/home/acs/homework/lesson_1/homework_4/
for i in a.txt b.txt c.txt
do
    rm ${dir4}${i}
done

# ****** homework_5 *****
homework 1 create 5
dir5=/home/acs/homework/lesson_1/homework_5/
for i in a b c
do
    rm ${dir5}"dir_"${i} -r
done

# ****** homework_6 *****
homework 1 create 6
dir6=/home/acs/homework/lesson_1/homework_6/
mkdir ${dir6}"dir_a"
#echo ${dir6}"task.txt"
#echo ${dir6}"dir_a/done.txt"
mv ${dir6}"task.txt" ${dir6}"dir_a/done.txt"

# ****** homework_7 *****
homework 1 create 7
dir7=/home/acs/homework/lesson_1/homework_7/
for i in 0 1 2
do
    mkdir ${dir7}"dir_"${i}
   #echo "floder" ${dir7}"dir_"${i}
    for j in a b c
    do
        cp ${dir7}${j}".txt"  ${dir7}"dir_"${i}/${j}${i}".txt"
        #echo "file1" ${dir7}${j}".txt file2 "${dir7}"dir_"${i}/${j}${i}".txt"
    done
done

# ****** homework_8 *****
homework 1 create 8
dir8=/home/acs/homework/lesson_1/homework_8/
rm ${dir8}"dir_a/a.txt"
mv ${dir8}"dir_b/b.txt" ${dir8}"dir_b/b_new.txt"
cp ${dir8}"dir_c/c.txt" ${dir8}"dir_c/c.txt.bak"

# ****** homework_9 *****
homework 1 create 9
dir9=/home/acs/homework/lesson_1/homework_9/
rm ${dir9}*.txt

最后一题一开始是
写成了 ${dir9}"*.txt" 发现不起作用,最后还是更改为 ${dir9}*.txt

声明:
这一部分为 Linux 基础课内部内容,根据 y总要求,将原课程的链接给出

循环

前置知识：for while if 中的判断真假是依据 condition 的 exitcode 也就是 0为真,非0表示假

格式1

for.. in .. do.. done
具体格式如下：

for var in var1 var2 var3
do
    语句1
    语句2
done

eg:
这里循环输出了 var1 var2 var3

eg2:
ls 是取 ls 这个命令的 stdout,而 ls 会输出当前目录下的所有文件

eg3:
seq 这个命令用于表示从一个数字到另一个数字之间的所有整数,并且只能表示数字
seq 1 10 表示 1 2 3 4 5 6 7 8 9 10 也可以用 {1..10}
{a..z} 表示 a-z 的 26个字母
这里都是循环输出相关的内容

格式2

和c 很像的 for

for ((expression; condition; expression))
do
    语句1
    语句2
done

eg: 输出 1-10 的数字,

格式3 while do done 循环

while condition
do
    语句1
    语句2
    ...
done

eg: 文件结束符为Ctrl+d，输入文件结束符后read指令返回false,此时循环退出

格式4 until…do…done 循环

当 until 后面的 condition 为真时,结束循环

break 命令

这个命令只能跳出一层循环,而且 break 不会跳出 case 语句
下面这个循环,每接收一个输入,如果这个输入不是文件终止符,
则输出一遍 1-7(到 8 的时候被 break 终止掉了循环)
要想结束外层的 while 循环,可以输入 ctrl+d(文件结束符),也可以直接使用 ctrl+c杀掉该进程

continue 命令

跳出本次循环,和 c++ 里面的一样
eg: 下面的例子会输出 1-10 中所有的奇数,i 为偶数时, 结果为 0 eq 成立, 进入 if
continue 则不会输出当前的值 i

死循环的处理方式

1. 如果AC Terminal可以打开该程序，则输入Ctrl+c即可
2. 先使用top命令找到进程的PID,再输入kill -9 PID即可关掉此进程

函数

bash中的函数返回的是 exit code 取值在 0-255 之间,0 表示正常结束,获取函数的返回值可以用 $?

如果想要获取函数的输出结果,可以先通过 echo 输出到标准输出stdout 中,然后通过 $()或者 两个点(``) 来获取

命令格式

[function] func_name() {  # function关键字可以省略
    语句1
    语句2
    ...
}

eg1:
不写 return 默认返回的就是 0

eg2:
获取函数的 exitcode 和 stdout

函数的局部变量

可以在函数内定义局部变量,作用范围仅在当前函数内.
可以在递归函数中定义局部变量.
格式为: local 变量名=变量值
eg:
1. 第一行为函数内的 name 变量
2. 第二行为函数外调用 name 变量,会发现此时该变量不存在,显示为空.

函数的参数

Q: 如何传入参数?
在调用的地方后面跟着写即可

Q: 如何获取传入的参数?

在函数内,$1表示第一个输入参数,$2表示第二个输入参数,依此类推.
注意：函数内的$0仍然是文件名,而不是函数名.

exit 命令

这个命令可以退出当前进程,并返回 exitcode (用$?获取)
exit 命令可以接受一个整数值作为参数,代表退出状态.如果不指定,默认状态值是 0.
exit 退出状态只能是一个介于 0~255 之间的整数,其中只有 0 表示成功,其它值都表示失败.
eg:

文件重定向

概念:每个进程默认打开3个文件描述符：
stdin 标准输入,从命令行读取数据,文件描述符为0
stdout 标准输出,向命令行输出数据,文件描述符为1
stderr 标准错误输出，向命令行输出数据，文件描述符为2
作用:文件重定向可以将这三个文件重定向到其他文件中.
具体使用：
command > file 将stdout重定向到file中,以覆盖的形式进行
command < file 将stdin重定向到file中
command >> file 将stdout以追加 方式重定向到file中
后面两个用的不多
command n> file 将文件描述符n重定向到file中
* command n>> file将文件描述符n以追加方式重定向到file中
eg1:
command 1>file 其实就是重定向文件的标准输出
eg2:

eg3:

引入外部脚本

类似于c语言中的 include
引入其他文件中的代码

. filename  # 注意点和文件名之间有一个空格
或
source filename

相当于把被引入的文件中的代码全部给搬了过来

eg:

参考

$( )捕获括号内表达式的输出后,就不会在终端再次输出了

安装 redis

原链接如下:在 Linux 服务器上 进行 Redis 安装

shell 语法

声明:
这一部分为 Linux 基础课内部内容,根据 y总要求,将原课程的链接给出

基础知识

如何学习

多动手多练习
不懂的查手册: help +具体命令 就知道了这个命令该怎么用了

shell 脚本能干啥

将重复的操作(主要是针对文件)组织起来,方便复用
常见的有很多种, 默认使用的是 bash

bash 脚本 需要 在开头写一个 #! /bin/bash,指明bash为脚本解释器

如何运行一个 shell 脚本

首先完成 shell 脚本的内容,
再以可执行文件的方式运行(常用)
1. 直接执行的话，需要有可执行权限,查看文件的权限:ls -l test.sh
所以需要为我们的脚本增加可执行权限(r 读权限, w 写权限, x 可执行权限) chmod +x 脚本名.sh.
2. 执行文件:可以在当前路径下执行,可以在绝对路径执行,可以在家目录下执行

也可以用解释器执行

注释

单行注释: #后面的内容就是注释.
多行注释: (其中 EOF 可以换成自定义的字符串,保证头尾相同就可以)

:<<EOF
    第一行注释
    第二行注释
    第三行注释
EOF

变量

shell 中的变量都是字符串,

定义一个变量

注意定义的时候,=两边不能有空格

name1=acwing
name2='acwing'
name3="acwing"

使用定义好的变量

可以使用$, 或者 ${}. {}是可选的，主要为了帮助解释器识别变量边界

只读变量

用 readonly 或者 declare 可以将变量设为只读变量

readonly name
declare -r name  

删除一个变量的值

unset 可以删除变量的值
将某个变量的值删除后,这个变量的值就是一个空字符串

局部变量与全局变量

局部变量不能被子进程访问到,一般我们自己定义的变量都是局部变量
全局变量又称为环境变量,可以被子进程访问到
在命令行输入bash 可以进入一个子进程,同时这个父进程就休眠,在子进程输入 exit 就可以退出子进程,回到父进程

局部变量变为全局变量

export name  # 第一种方法
declare -x name  # 第二种方法

全局变量变为局部变量

export name=yxc  # 定义环境变量
declare +x name  # 改为自定义变量

字符串

定义字符串

定义一个字符串 可以用单引号，也可以用双引号，也可以不用引号(上面定义变量时的图)

单引号与双引号的区别:
单引号中的内容会原样输出,不会执行,不会取变量;
双引号中的内容可以执行,可以取变量;

取字符串长度

${#variable} 

取子串

${variable:0:5} #从0开始取长度为 5 的子串

默认变量

shell 里面会有一些默认的变量

$0 就是 路径+文件名
执行脚本的时候可以向其传递参数
$1 传入的第一个参数
$2 传入的第二个参数
...
$100 传入的第100个参数

还要一些其他的默认变量

$#  传入的参数个数 

$*  由所有参数构成的用空格隔开的字符串，如上例中值为"$1 $2 $3 $4"
$@  每个参数分别用双引号括起来的字符串，如上例中值为"$1" "$2" "$3" "$4"
(一般没差别)

$$  脚本当前运行的进程ID

$?  上一条命令的退出状态(exit code). 0表示正常退出，其他值表示错误

$(command)  返回command这条命令的stdout（可嵌套）
`command`   返回command这条命令的stdout（不可嵌套）

这里要注意 退出状态(exit code) 与标准输出(stdout) 的区别:
exit code 可以看做那个 main 函数的返回值(我们写main函数时,最后一句return 0. 这个 0 就是 exitcode)
stdout 可以看做是我们写的函数中的 cout 输入的内容

$(ls) 就返回了 ls 这条命令的stdout,也就是返回了当前目录下的所有文件

数组

定义数组时不需要指明大小
下标从 0 开始
只支持一维数组
数组中可以存放多个不同类型的值

定义数组

用小括号,数组元素之间的分隔符号是 空格<space>

array =(1 acwing "linux" "shell")
还可以直接定义某个位置的元素的值
array[0]=1
array[1000]=2

读取数组中的元素

${array[index]}

读取整个数组

${array[@]}
${array[*]}

数组的长度

这个数组的长度是实际的数组中的元素个数

${#array[@]}
${#array[*]}

expr 命令

expr 命令用于求表达式的值，格式为：
expr 表达式
expr 是一个命令,命令后的每一项都要用空格隔开. 所以表达式中的每一项也要用<space> 隔开
需要对特殊字符进行转义处理,也是就用 \ 放在特殊符号前,（发现表达式运行错误时,可以试试转义）
对包含空格和其他特殊字符的字符串要用引号括起来
expr 的结果会输出在 stdout 中.(如果为逻辑关系表达式,则结果为真时,stdout输出1,否则输出0)
expr 的 exit code ：如果为逻辑关系表达式,则结果为真时,exit code为0,否则为1.

字符串表达式

1. length STRING: 返回STRING的长度
2. index STRING CHARSET :返回 CHARSET 中任意单个字符在 STRING 中最前面的字符位置,下标从1开始.如果在STRING中完全不存在CHARSET中的字符，则返回0.
3. substr STRING POSITION LENGTH： 返回STRING字符串中从POSITION开始,长度最大为LENGTH的子串.如果POSITION或LENGTH为负数,0或非数值,则返回空字符串.

算术表达式

只支持整数,算术表达式优先级低于字符串表达式,高于逻辑关系表达式.

+ -
加减运算.两端参数会转换为整数,如果转换失败则报错.

* / %
乘,除,取模运算.两端参数会转换为整数,如果转换失败则报错. *这个符号需要转义

() 可以改变优先级,但需要用反斜杠转义

shell 主要是处理文件,管道,字符串的,并不针对数字处理.

逻辑表达式

|
如果第一个参数非空且非0,则返回第一个参数的值,否则返回第二个参数的值,但要求第二个参数的值也是非空或非0,否则返回0. 如果第一个参数是非空或非0时,不会计算第二个参数.(短路原则)

&
如果两个参数都非空且非0,则返回第一个参数,否则返回0. 如果第一个参为0或为空,则不会计算第二个参数.
这里一个 | 就相当于 c++ 中的两个|, 起逻辑表达式的作用,并且逻辑表达式的返回值不仅仅是 0 和 1

< <= = == != >= >
比较两端的参数,如果为true,则返回1,否则返回0.

==是 =的同义词.
“expr” 首先尝试将两端参数转换为整数,并做算术比较,如果转换失败,则按字符集排序规则做字符比较.

() 可以改变优先级，但需要用反斜杠转义

read 命令

可以看做是 cin
read命令用于从标准输入中读取单行数据.
当读到文件结束符时,exit code为1,否则为0. (exit code 来判断的话,0为真,1为假)

参数说明:
-p: 后面可以接提示信息
-t：后面跟秒数，定义输入字符的等待时间，超过等待时间后会自动忽略此命令
但是后面的命令会继续执行

echo 命令

echo 字符串会把这个字符串给输出

格式化输出 printf

用的不多,所以偷个懒.放下 文档

test与[]

逻辑运算符

这里的逻辑运算符是 bash自己有的
之前的 | 和 & 是expr 自己定义的

&& 表示与,
|| 表示或
同样具有具有短路原则：
expr1 && expr2 ：当expr1为假时，直接忽略expr2
expr1 || expr2 ：当expr1为真时，直接忽略expr2
利用短路原则可以实现 if else 的效果
这里的判断的是表达式的返回结果(exit code)
0 为真, 其他为假(与C/C++中的定义相反)

test 命令

主要用于: 判断文件类型以及对变量做比较

test 命令用的是 exitcode 来返回结果

判断文件类型与权限

样例如下

整数间的比较

字符串比较

多重判断

[ ] 符号

[]与test用法几乎一模一样,更常用于if语句中.
另外[[]]是[]的加强版,支持的特性更多
注意事项：

• [] 内的每一项都要用空格隔开
• [] 中括号内的变量，最好用双引号括起来
• 中括号内的常数，最好用单或双引号括起来

if else switch

if then 形式

if confition
then
    语句 1
    语句 2
    ...
fi

if else 格式

if condition
then
    语句1
    语句2
    ...
else
    语句1
    语句2
    ...
fi

多层if-elif-elif-else

if condition
then
    语句1
    语句2
    ...
elif condition
then
    语句1
    语句2
    ...
elif condition
then
    语句1
    语句2
else
    语句1
    语句2
    ...
fi

switch

case…esac形式
类似于C/C++中的switch语句.

case $变量名称 in
    值1)
        语句1
        语句2
        ...
        ;;  # 类似于C/C++中的break
    值2)
        语句1
        语句2
        ...
        ;;
    *)  # 类似于C/C++中的default
        语句1
        语句2
        ...
        ;;
esac

目标:

进入homework_5文件夹，打开problem.txt，并依次执行如下操作：

cd /home/acs/homework/lesson_2/homework_5 进入目标文件夹
[1] 删除第11行第15个字符（包含该字符）至第13行第5个字符（包含该字符）    
 11G 14<space> v 13G 5<space> d
G 跳转到行尾
p 粘贴

这里跳转有两种 :n 或者 nG
选中第11行第15个字符（包含该字符）至第13行第5个字符（包含该字符） 这一段连续的文本的话
就要用 nG