北海虽赊，扶摇可接

博客同步

Thu, 06 Apr 2023 09:56:48 +0800

# 博客同步

我的博客即将同步至腾讯云开发者社区，
邀请大家一同入驻：
https://cloud.tencent.com/developer/support-plan?invite_code=2qncyxvlio00g

博客同步

Thu, 06 Apr 2023 09:56:48 +0800

# 博客同步

我的博客即将同步至腾讯云开发者社区，
邀请大家一同入驻：
https://cloud.tencent.com/developer/support-plan?invite_code=2qncyxvlio00g

EMC知识总结

Thu, 12 Jan 2023 11:08:00 +0800

# 附录：

附录：家电产品 EMC 标准 / 测试方法汇总
EN/IEC 55014-1：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus - Part 1: Emission 家用电器、电动工具及类似器具的电磁兼容发射骚扰要求

EN/IEC 55014-2：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus Part 2: Immunity 家用电器、电动工具及类似器具的电磁兼容抗扰度要求

EN/IEC 61000-3-2：Electromagnetic compatibility (EMC) Part 3-2: Limits - Limits for harmonic current emissions (equipment input current ≤ 16 A per phase) 低压电气及电子设备发出的谐波电流限值（单项输入电流不大于 16A）

EN/IEC 61000-3-3：Electromagnetic compatibility (EMC) – Part 3-3: Limits – Limitation of voltage changes, voltage fluctuations and flicker in public low-voltage supply systems, for equipment with rated current ≤ 16 A per phase and not subject to conditional connection 输入电流不大于 16A 的低压供电系统电压波动和闪烁测试

EN/IEC 61000-4-2：Electromagnetic compatibility (EMC) Part 4-2: Testing and measurement techniques - Electrostatic discharge immunity test ESD 静电放电抗扰

EN/IEC 61000-4-3：Electromagnetic compatibility (EMC) Part 4-3: Testing and measurement techniques — Radiated, radio-frequency, electromagnetic field immunity test 辐射，射频，电磁场抗扰度

EN/IEC 61000-4-4：Electromagnetic compatibility (EMC) Part 4-4: Testing and measurement techniques - Electrical fast transient/burst immunity test ETF 电瞬变脉冲群抗扰度

EN/IEC 61000-4-5：Electromagnetic compatibility (EMC) - Part 4-5: Testing and measurement techniques - Surge immunity test 浪涌抗扰度

EN/IEC 61000-4-6：Electromagnetic compatibility (EMC) - Part 4-6: Testing and measurement techniques - Immunity to conducted disturbances, induced by radio-frequency fields 射频场引起的传导干扰的抗扰度

EN/IEC 61000-4-11：Electromagnetic compatibility (EMC) Part 4-11: Testing and measurement techniques - Voltage dips, short interruptions and voltage variations immunity tests for equipment with input current up to 16 A per phase 电压暂降，短时中断和电压变化抗扰度

CISPR 14-1：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus - Part 1: Emission 家用电器、电动工具及类似器具的电磁兼容发射骚扰要求

CISPR 14-2：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus Part 2: Immunity 家用电器、电动工具及类似器具的电磁兼容抗扰度要求

CFR title 47 part 15：Radio Frequency Devices 无线电频率设备

ICES-003：Information Technology Equipment (including Digital Apparatus) 信息技术设备（包括数字仪器）

AS/NZS CISPR 14.1：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus - Part 1: Emission 家用电器、电动工具及类似器具的电磁兼容发射骚扰要求

GB 4343.1：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus - Part 1: Emission 家用电器、电动工具及类似器具的电磁兼容发射骚扰要求

GB 4343.2：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus Part 2: Immunity 家用电器、电动工具及类似器具的电磁兼容抗扰度要求

KN 14-1：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus - Part 1: Emission 家用电器、电动工具及类似器具的电磁兼容发射骚扰要求

KN 14-2：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus Part 2: Immunity 家用电器、电动工具及类似器具的电磁兼容抗扰度要求

J55014-1 (H27)：Electromagnetic compatibility - Requirements for household appliances, electric tools and similar apparatus - Part 1: Emission 家用电器、电动工具及类似器具的电磁兼容发射骚扰要求

一篇文章让你彻底掌握 Shell

Thu, 17 Nov 2022 18:16:00 +0800

# 一篇文章让你彻底掌握 Shell

由于 bash 是 Linux 标准默认的 shell 解释器，可以说 bash 是 shell 编程的基础。

本文主要介绍 bash 的语法，对于 linux 指令不做任何介绍。

███████╗██╗  ██╗███████╗██╗     ██╗
██╔════╝██║  ██║██╔════╝██║     ██║
███████╗███████║█████╗  ██║     ██║
╚════██║██╔══██║██╔══╝  ██║     ██║
███████║██║  ██║███████╗███████╗███████╗

# 简介

# 什么是 shell

Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁。
Shell 既是一种命令语言，又是一种程序设计语言。
Shell 是指一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问 Linux 内核的服务。

Ken Thompson 的 sh 是第一种 Unix Shell，Windows Explorer 是一个典型的图形界面 Shell。

# 什么是 shell 脚本

Shell 脚本（shell script），是一种为 shell 编写的脚本程序，一般文件后缀为 .sh 。

业界所说的 shell 通常都是指 shell 脚本，但 shell 和 shell script 是两个不同的概念。

# Shell 环境

Shell 编程跟 java、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

Shell 的解释器种类众多，常见的有：

sh - 即 Bourne Shell。sh 是 Unix 标准默认的 shell。
bash - 即 Bourne Again Shell。bash 是 Linux 标准默认的 shell。
fish - 智能和用户友好的命令行 shell。
xiki - 使 shell 控制台更友好，更强大。
zsh - 功能强大的 shell 与脚本语言。

# 指定脚本解释器

在 shell 脚本， #! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 解释器。 #! 被称作 shebang（也称为 Hashbang ）。

所以，你应该会在 shell 中，见到诸如以下的注释：

指定 sh 解释器

#!/bin/sh

指定 bash 解释器

#!/bin/bash

注意

上面的指定解释器的方式是比较常见的，但有时候，你可能也会看到下面的方式：
#!/usr/bin/env bash
这样做的好处是，系统会自动在 PATH 环境变量中查找你指定的程序（本例中的 bash ）。相比第一种写法，你应该尽量用这种写法，因为程序的路径是不确定的。这样写还有一个好处，操作系统的 PATH 变量有可能被配置为指向程序的另一个版本。比如，安装完新版本的 bash ，我们可能将其路径添加到 PATH 中，来 “隐藏” 老版本。如果直接用 #!/bin/bash ，那么系统会选择老版本的 bash 来执行脚本，如果用 #!/usr/bin/env bash ，则会使用新版本。

# 模式

shell 有交互和非交互两种模式。

# 交互模式

简单来说，你可以将 shell 的交互模式理解为执行命令行。

看到形如下面的东西，说明 shell 处于交互模式下：

user@host:~$

接着，便可以输入一系列 Linux 命令，比如 ls ， grep ， cd ， mkdir ， rm 等等。

# 非交互模式

简单来说，你可以将 shell 的非交互模式理解为执行 shell 脚本。

在非交互模式下，shell 从文件或者管道中读取命令并执行。

当 shell 解释器执行完文件中的最后一个命令，shell 进程终止，并回到父进程。

可以使用下面的命令让 shell 以非交互模式运行：

	sh /path/to/script.sh
	bash /path/to/script.sh
	source /path/to/script.sh
	./path/to/script.sh

上面的例子中， script.sh 是一个包含 shell 解释器可以识别并执行的命令的普通文本文件， sh 和 bash 是 shell 解释器程序。你可以使用任何喜欢的编辑器创建 script.sh （vim，nano，Sublime Text, Atom 等等）。

其中， source /path/to/script.sh 和 ./path/to/script.sh 是等价的。

除此之外，你还可以通过 chmod 命令给文件添加可执行的权限，来直接执行脚本文件：

	chmod +x /path/to/script.sh #使脚本具有执行权限
	/path/to/test.sh

这种方式要求脚本文件的第一行必须指明运行该脚本的程序，比如：

💻 『示例源码』

	#!/usr/bin/env bash
	echo "Hello, world!"

上面的例子中，我们使用了一个很有用的命令 echo 来输出字符串到屏幕上。

# 基本语法

# 解释器

前面虽然两次提到了 #! ，但是本着重要的事情说三遍的精神，这里再强调一遍：

在 shell 脚本， #! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 解释器。 #! 被称作 shebang（也称为 Hashbang ）。

#! 决定了脚本可以像一个独立的可执行文件一样执行，而不用在终端之前输入 sh , bash , python , php 等。

	# 以下两种方式都可以指定 shell 解释器为 bash，第二种方式更好
	#!/bin/bash
	#!/usr/bin/env bash

# 注释

注释可以说明你的代码是什么作用，以及为什么这样写。

shell 语法中，注释是特殊的语句，会被 shell 解释器忽略。

单行注释 - 以 # 开头，到行尾结束。
多行注释 - 以 :<<EOF 开头，到 EOF 结束。

💻 『示例源码』

	#--------------------------------------------
	# shell 注释示例
	# author：zp
	#--------------------------------------------

	# echo ' 这是单行注释'

	########## 这是分割线 ##########

	:<<EOF
	echo '这是多行注释'
	echo '这是多行注释'
	echo '这是多行注释'
	EOF

# echo

echo 用于字符串的输出。

输出普通字符串：

	echo "hello, world"
	# Output: hello, world

输出含变量的字符串：

	echo "hello, \"zp\""
	# Output: hello, "zp"

输出含变量的字符串：

	name=zp
	echo "hello, \"${name}\""
	# Output: hello, "zp"

输出含换行符的字符串：

	# 输出含换行符的字符串
	echo "YES\nNO"
	# Output: YES\nNO

	echo -e "YES\nNO" # -e 开启转义
	# Output:
	# YES
	# NO

输出含不换行符的字符串：

	echo "YES"
	echo "NO"
	# Output:
	# YES
	# NO

	echo -e "YES\c" # -e 开启转义 \c 不换行
	echo "NO"
	# Output:
	# YESNO

输出重定向至文件

echo "test" > test.txt

输出执行结果

	echo `pwd`
	# Output:(当前目录路径)

💻 『示例源码』

	#!/usr/bin/env bash

	# 输出普通字符串
	echo "hello, world"
	# Output: hello, world

	# 输出含变量的字符串
	echo "hello, \"zp\""
	# Output: hello, "zp"

	# 输出含变量的字符串
	name=zp
	echo "hello, \"${name}\""
	# Output: hello, "zp"

	# 输出含换行符的字符串
	echo "YES\nNO"
	# Output: YES\nNO
	echo -e "YES\nNO" # -e 开启转义
	# Output:
	# YES
	# NO

	# 输出含不换行符的字符串
	echo "YES"
	echo "NO"
	# Output:
	# YES
	# NO

	echo -e "YES\c" # -e 开启转义 \c 不换行
	echo "NO"
	# Output:
	# YESNO

	# 输出内容定向至文件
	echo "test" > test.txt

	# 输出执行结果
	echo `pwd`
	# Output:(当前目录路径)

# printf

printf 用于格式化输出字符串。

默认，printf 不会像 echo 一样自动添加换行符，如果需要换行可以手动添加 \n 。

💻 『示例源码』

	# 单引号
	printf '%d %s\n' 1 "abc"
	# Output:1 abc

	# 双引号
	printf "%d %s\n" 1 "abc"
	# Output:1 abc

	# 无引号
	printf %s abcdef
	# Output: abcdef (并不会换行)

	# 格式只指定了一个参数，但多出的参数仍然会按照该格式输出
	printf "%s\n" abc def
	# Output:
	# abc
	# def

	printf "%s %s %s\n" a b c d e f g h i j
	# Output:
	# a b c
	# d e f
	# g h i
	# j

	# 如果没有参数，那么 % s 用 NULL 代替，% d 用 0 代替
	printf "%s and %d \n"
	# Output:
	# and 0

	# 格式化输出
	printf "%-10s %-8s %-4s\n" 姓名性别体重kg
	printf "%-10s %-8s %-4.2f\n" 郭靖男 66.1234
	printf "%-10s %-8s %-4.2f\n" 杨过男 48.6543
	printf "%-10s %-8s %-4.2f\n" 郭芙女 47.9876
	# Output:
	# 姓名性别体重 kg
	# 郭靖男 66.12
	# 杨过男 48.65
	# 郭芙女 47.99

# printf 的转义符

序列	说明
`\a`	警告字符，通常为 ASCII 的 BEL 字符
`\b`	后退
`\c`	抑制（不显示）输出结果中任何结尾的换行字符（只在 % b 格式指示符控制下的参数字符串中有效），而且，任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符，都被忽略
`\f`	换页（formfeed）
`\n`	换行
`\r`	回车（Carriage return）
`\t`	水平制表符
`\v`	垂直制表符
`\\`	一个字面上的反斜杠字符
`\ddd`	表示 1 到 3 位数八进制值的字符。仅在格式字符串中有效
`\0ddd`	表示 1 到 3 位的八进制值字符

# 变量

跟许多程序设计语言一样，你可以在 bash 中创建变量。

Bash 中没有数据类型，bash 中的变量可以保存一个数字、一个字符、一个字符串等等。同时无需提前声明变量，给变量赋值会直接创建变量。

# 变量命名原则

命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。
中间不能有空格，可以使用下划线（_）。
不能使用标点符号。
不能使用 bash 里的关键字（可用 help 命令查看保留关键字）。

# 声明变量

访问变量的语法形式为： ${var} 和 $var 。

变量名外面的花括号是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界，所以推荐加花括号。

	word="hello"
	echo ${word}
	# Output: hello

# 只读变量

使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。

	rword="hello"
	echo ${rword}
	readonly rword
	# rword="bye" # 如果放开注释，执行时会报错

# 删除变量

使用 unset 命令可以删除变量。变量被删除后不能再次使用。unset 命令不能删除只读变量。

	dword="hello" # 声明变量
	echo ${dword} # 输出变量值
	# Output: hello

	unset dword # 删除变量
	echo ${dword}
	# Output: （空）

# 变量类型

局部变量 - 局部变量是仅在某个脚本内部有效的变量。它们不能被其他的程序和脚本访问。
环境变量 - 环境变量是对当前 shell 会话内所有的程序或脚本都可见的变量。创建它们跟创建局部变量类似，但使用的是 export 关键字，shell 脚本也可以定义环境变量。

常见的环境变量：

变量	描述
`$HOME`	当前用户的用户目录
`$PATH`	用分号分隔的目录列表，shell 会到这些目录中查找命令
`$PWD`	当前工作目录
`$RANDOM`	0 到 32767 之间的整数
`$UID`	数值类型，当前用户的用户 ID
`$PS1`	主要系统输入提示符
`$PS2`	次要系统输入提示符

这里有一张更全面的 Bash 环境变量列表。

💻 『示例源码』

	#!/usr/bin/env bash

	################### 声明变量 ###################
	name="world"
	echo "hello ${name}"
	# Output: hello world

	################### 输出变量 ###################
	folder=$(pwd)
	echo "current path: ${folder}"

	################### 只读变量 ###################
	rword="hello"
	echo ${rword}
	# Output: hello
	readonly rword
	# rword="bye" # 如果放开注释，执行时会报错

	################### 删除变量 ###################
	dword="hello" # 声明变量
	echo ${dword} # 输出变量值
	# Output: hello

	unset dword # 删除变量
	echo ${dword}
	# Output: （空）

	################### 系统变量 ###################
	echo "UID:$UID"
	echo LOGNAME:$LOGNAME
	echo User:$USER
	echo HOME:$HOME
	echo PATH:$PATH
	echo HOSTNAME:$HOSTNAME
	echo SHELL:$SHELL
	echo LANG:$LANG

	################### 自定义变量 ###################
	days=10
	user="admin"
	echo "$user logged in $days days age"
	days=5
	user="root"
	echo "$user logged in $days days age"
	# Output:
	# admin logged in 10 days age
	# root logged in 5 days age

	################### 从变量读取列表 ###################
	colors="Red Yellow Blue"
	colors=$colors" White Black"

	for color in $colors
	do
	echo " $color"
	done

# 字符串

# 单引号和双引号

shell 字符串可以用单引号 '' ，也可以用双引号 “” ，也可以不用引号。

单引号的特点
- 单引号里不识别变量
- 单引号里不能出现单独的单引号（使用转义符也不行），但可成对出现，作为字符串拼接使用。
双引号的特点
- 双引号里识别变量
- 双引号里可以出现转义字符

综上，推荐使用双引号。

# 拼接字符串

	# 使用单引号拼接
	name1='white'
	str1='hello, '${name1}''
	str2='hello, ${name1}'
	echo ${str1}_${str2}
	# Output:
	# hello, white_hello, ${name1}

	# 使用双引号拼接
	name2="black"
	str3="hello, "${name2}""
	str4="hello, ${name2}"
	echo ${str3}_${str4}
	# Output:
	# hello, black_hello, black

# 获取字符串长度

	text="12345"
	echo ${#text}
	# Output:
	# 5

# 截取子字符串

	text="12345"
	echo ${text:2:2}
	# Output:
	# 34

从第 3 个字符开始，截取 2 个字符

# 查找子字符串

	#!/usr/bin/env bash

	text="hello"
	echo `expr index "${text}" ll`

	# Execute: ./str-demo5.sh
	# Output:
	# 3

查找 ll 子字符在 hello 字符串中的起始位置。

💻 『示例源码』

	#!/usr/bin/env bash

	################### 使用单引号拼接字符串 ###################
	name1='white'
	str1='hello, '${name1}''
	str2='hello, ${name1}'
	echo ${str1}_${str2}
	# Output:
	# hello, white_hello, ${name1}

	################### 使用双引号拼接字符串 ###################
	name2="black"
	str3="hello, "${name2}""
	str4="hello, ${name2}"
	echo ${str3}_${str4}
	# Output:
	# hello, black_hello, black

	################### 获取字符串长度 ###################
	text="12345"
	echo "${text} length is: ${#text}"
	# Output:
	# 12345 length is: 5

	# 获取子字符串
	text="12345"
	echo ${text:2:2}
	# Output:
	# 34

	################### 查找子字符串 ###################
	text="hello"
	echo `expr index "${text}" ll`
	# Output:
	# 3

	################### 判断字符串中是否包含子字符串 ###################
	result=$(echo "${str}" \| grep "feature/")
	if [[ "$result" != "" ]]; then
	echo "feature/ 是 ${str} 的子字符串"
	else
	echo "feature/ 不是 ${str} 的子字符串"
	fi

	################### 截取关键字左边内容 ###################
	full_branch="feature/1.0.0"
	branch=`echo ${full_branch#feature/}`
	echo "branch is ${branch}"

	################### 截取关键字右边内容 ###################
	full_version="0.0.1-SNAPSHOT"
	version=`echo ${full_version%-SNAPSHOT}`
	echo "version is ${version}"

	################### 字符串分割成数组 ###################
	str="0.0.0.1"
	OLD_IFS="$IFS"
	IFS="."
	array=( ${str} )
	IFS="$OLD_IFS"
	size=${#array[*]}
	lastIndex=`expr ${size} - 1`
	echo "数组长度：${size}"
	echo "最后一个数组元素：${array[${lastIndex}]}"
	for item in ${array[@]}
	do
	echo "$item"
	done

	################### 判断字符串是否为空 ###################
	#-n 判断长度是否非零
	#-z 判断长度是否为零

	str=testing
	str2=''
	if [[ -n "$str" ]]
	then
	echo "The string $str is not empty"
	else
	echo "The string $str is empty"
	fi

	if [[ -n "$str2" ]]
	then
	echo "The string $str2 is not empty"
	else
	echo "The string $str2 is empty"
	fi

	# Output:
	# The string testing is not empty
	# The string is empty

	################### 字符串比较 ###################
	str=hello
	str2=world
	if [[ $str = "hello" ]]; then
	echo "str equals hello"
	else
	echo "str not equals hello"
	fi

	if [[ $str2 = "hello" ]]; then
	echo "str2 equals hello"
	else
	echo "str2 not equals hello"
	fi

# 数组

bash 只支持一维数组。

数组下标从 0 开始，下标可以是整数或算术表达式，其值应大于或等于 0。

# 创建数组

	# 创建数组的不同方式
	nums=([2]=2 [0]=0 [1]=1)
	colors=(red yellow "dark blue")

# 访问数组元素

访问数组的单个元素：

	echo ${nums[1]}
	# Output: 1

访问数组的所有元素：

	echo ${colors[*]}
	# Output: red yellow dark blue

	echo ${colors[@]}
	# Output: red yellow dark blue

上面两行有很重要（也很微妙）的区别：

为了将数组中每个元素单独一行输出，我们用 printf 命令：

	printf "+ %s\n" ${colors[*]}
	# Output:
	# + red
	# + yellow
	# + dark
	# + blue

为什么 dark 和 blue 各占了一行？尝试用引号包起来：

	printf "+ %s\n" "${colors[*]}"
	# Output:
	# + red yellow dark blue

现在所有的元素都在一行输出 —— 这不是我们想要的！让我们试试 ${colors[@]}

	printf "+ %s\n" "${colors[@]}"
	# Output:
	# + red
	# + yellow
	# + dark blue

在引号内， ${colors[@]} 将数组中的每个元素扩展为一个单独的参数；数组元素中的空格得以保留。

访问数组的部分元素：

	echo ${nums[@]:0:2}
	# Output:
	# 0 1

在上面的例子中， ${array[@]} 扩展为整个数组， :0:2 取出了数组中从 0 开始，长度为 2 的元素。

# 访问数组长度

	echo ${#nums[*]}
	# Output:
	# 3

# 向数组中添加元素

向数组中添加元素也非常简单：

	colors=(white "${colors[@]}" green black)
	echo ${colors[@]}
	# Output:
	# white red yellow dark blue green black

上面的例子中， ${colors[@]} 扩展为整个数组，并被置换到复合赋值语句中，接着，对数组 colors 的赋值覆盖了它原来的值。

# 从数组中删除元素

用 unset 命令来从数组中删除一个元素：

	unset nums[0]
	echo ${nums[@]}
	# Output:
	# 1 2

💻 『示例源码』

	#!/usr/bin/env bash

	################### 创建数组 ###################
	nums=( [ 2 ] = 2 [ 0 ] = 0 [ 1 ] = 1 )
	colors=( red yellow "dark blue" )

	################### 访问数组的单个元素 ###################
	echo ${nums[1]}
	# Output: 1

	################### 访问数组的所有元素 ###################
	echo ${colors[*]}
	# Output: red yellow dark blue

	echo ${colors[@]}
	# Output: red yellow dark blue

	printf "+ %s\n" ${colors[*]}
	# Output:
	# + red
	# + yellow
	# + dark
	# + blue

	printf "+ %s\n" "${colors[*]}"
	# Output:
	# + red yellow dark blue

	printf "+ %s\n" "${colors[@]}"
	# Output:
	# + red
	# + yellow
	# + dark blue

	################### 访问数组的部分元素 ###################
	echo ${nums[@]:0:2}
	# Output:
	# 0 1

	################### 获取数组长度 ###################
	echo ${#nums[*]}
	# Output:
	# 3

	################### 向数组中添加元素 ###################
	colors=( white "${colors[@]}" green black )
	echo ${colors[@]}
	# Output:
	# white red yellow dark blue green black

	################### 从数组中删除元素 ###################
	unset nums[ 0 ]
	echo ${nums[@]}
	# Output:
	# 1 2

# 运算符

# 算术运算符

下表列出了常用的算术运算符，假定变量 x 为 10，变量 y 为 20：

运算符	说明	举例
+	加法	`expr $x + $y` 结果为 30。
-	减法	`expr $x - $y` 结果为 -10。
*	乘法	`expr $x * $y` 结果为 200。
/	除法	`expr $y / $x` 结果为 2。
%	取余	`expr $y % $x` 结果为 0。
=	赋值	`x=$y` 将把变量 y 的值赋给 x。
==	相等。用于比较两个数字，相同则返回 true。	`[ $x == $y ]` 返回 false。
!=	不相等。用于比较两个数字，不相同则返回 true。	`[ $x != $y ]` 返回 true。

** 注意：** 条件表达式要放在方括号之间，并且要有空格，例如: [$x==$y] 是错误的，必须写成 [ $x == $y ] 。

💻 『示例源码』

	x=10
	y=20

	echo "x=${x}, y=${y}"

	val=`expr ${x} + ${y}`
	echo "${x} + ${y} = $val"

	val=`expr ${x} - ${y}`
	echo "${x} - ${y} = $val"

	val=`expr ${x} \* ${y}`
	echo "${x} * ${y} = $val"

	val=`expr ${y} / ${x}`
	echo "${y} / ${x} = $val"

	val=`expr ${y} % ${x}`
	echo "${y} % ${x} = $val"

	if [[ ${x} == ${y} ]]
	then
	echo "${x} = ${y}"
	fi
	if [[ ${x} != ${y} ]]
	then
	echo "${x} != ${y}"
	fi

	# Output:
	# x=10, y=20
	# 10 + 20 = 30
	# 10 - 20 = -10
	# 10 * 20 = 200
	# 20 / 10 = 2
	# 20 % 10 = 0
	# 10 != 20

# 关系运算符

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

下表列出了常用的关系运算符，假定变量 x 为 10，变量 y 为 20：

运算符	说明	举例
`-eq`	检测两个数是否相等，相等返回 true。	`[ $a -eq $b ]` 返回 false。
`-ne`	检测两个数是否相等，不相等返回 true。	`[ $a -ne $b ]` 返回 true。
`-gt`	检测左边的数是否大于右边的，如果是，则返回 true。	`[ $a -gt $b ]` 返回 false。
`-lt`	检测左边的数是否小于右边的，如果是，则返回 true。	`[ $a -lt $b ]` 返回 true。
`-ge`	检测左边的数是否大于等于右边的，如果是，则返回 true。	`[ $a -ge $b ]` 返回 false。
`-le`	检测左边的数是否小于等于右边的，如果是，则返回 true。	`[ $a -le $b ]` 返回 true。

💻 『示例源码』

	x=10
	y=20

	echo "x=${x}, y=${y}"

	if [[ ${x} -eq ${y} ]]; then
	echo "${x} -eq ${y} : x 等于 y"
	else
	echo "${x} -eq ${y}: x 不等于 y"
	fi

	if [[ ${x} -ne ${y} ]]; then
	echo "${x} -ne ${y}: x 不等于 y"
	else
	echo "${x} -ne ${y}: x 等于 y"
	fi

	if [[ ${x} -gt ${y} ]]; then
	echo "${x} -gt ${y}: x 大于 y"
	else
	echo "${x} -gt ${y}: x 不大于 y"
	fi

	if [[ ${x} -lt ${y} ]]; then
	echo "${x} -lt ${y}: x 小于 y"
	else
	echo "${x} -lt ${y}: x 不小于 y"
	fi

	if [[ ${x} -ge ${y} ]]; then
	echo "${x} -ge ${y}: x 大于或等于 y"
	else
	echo "${x} -ge ${y}: x 小于 y"
	fi

	if [[ ${x} -le ${y} ]]; then
	echo "${x} -le ${y}: x 小于或等于 y"
	else
	echo "${x} -le ${y}: x 大于 y"
	fi

	# Output:
	# x=10, y=20
	# 10 -eq 20: x 不等于 y
	# 10 -ne 20: x 不等于 y
	# 10 -gt 20: x 不大于 y
	# 10 -lt 20: x 小于 y
	# 10 -ge 20: x 小于 y
	# 10 -le 20: x 小于或等于 y

# 布尔运算符

下表列出了常用的布尔运算符，假定变量 x 为 10，变量 y 为 20：

运算符	说明	举例
`!`	非运算，表达式为 true 则返回 false，否则返回 true。	`[ ! false ]` 返回 true。
`-o`	或运算，有一个表达式为 true 则返回 true。	`[ $a -lt 20 -o $b -gt 100 ]` 返回 true。
`-a`	与运算，两个表达式都为 true 才返回 true。	`[ $a -lt 20 -a $b -gt 100 ]` 返回 false。

💻 『示例源码』

	x=10
	y=20

	echo "x=${x}, y=${y}"

	if [[ ${x} != ${y} ]]; then
	echo "${x} != ${y} : x 不等于 y"
	else
	echo "${x} != ${y}: x 等于 y"
	fi

	if [[ ${x} -lt 100 && ${y} -gt 15 ]]; then
	echo "${x} 小于 100 且 ${y} 大于 15 : 返回 true"
	else
	echo "${x} 小于 100 且 ${y} 大于 15 : 返回 false"
	fi

	if [[ ${x} -lt 100 \|\| ${y} -gt 100 ]]; then
	echo "${x} 小于 100 或 ${y} 大于 100 : 返回 true"
	else
	echo "${x} 小于 100 或 ${y} 大于 100 : 返回 false"
	fi

	if [[ ${x} -lt 5 \|\| ${y} -gt 100 ]]; then
	echo "${x} 小于 5 或 ${y} 大于 100 : 返回 true"
	else
	echo "${x} 小于 5 或 ${y} 大于 100 : 返回 false"
	fi

	# Output:
	# x=10, y=20
	# 10 != 20 : x 不等于 y
	# 10 小于 100 且 20 大于 15 : 返回 true
	# 10 小于 100 或 20 大于 100 : 返回 true
	# 10 小于 5 或 20 大于 100 : 返回 false

# 逻辑运算符

以下介绍 Shell 的逻辑运算符，假定变量 x 为 10，变量 y 为 20:

运算符	说明	举例
`&&`	逻辑的 AND	`[[ ${x} -lt 100 && ${y} -gt 100 ]]` 返回 false
`\| \|`	逻辑的 OR	`[[ ${x} -lt 100 \| \| ${y} -gt 100 ]]` 返回 true

💻 『示例源码』

	x=10
	y=20

	echo "x=${x}, y=${y}"

	if [[ ${x} -lt 100 && ${y} -gt 100 ]]
	then
	echo "${x} -lt 100 && ${y} -gt 100 返回 true"
	else
	echo "${x} -lt 100 && ${y} -gt 100 返回 false"
	fi

	if [[ ${x} -lt 100 \|\| ${y} -gt 100 ]]
	then
	echo "${x} -lt 100 \|\| ${y} -gt 100 返回 true"
	else
	echo "${x} -lt 100 \|\| ${y} -gt 100 返回 false"
	fi

	# Output:
	# x=10, y=20
	# 10 -lt 100 && 20 -gt 100 返回 false
	# 10 -lt 100 \|\| 20 -gt 100 返回 true

# 字符串运算符

下表列出了常用的字符串运算符，假定变量 a 为 "abc"，变量 b 为 "efg"：

运算符	说明	举例
`=`	检测两个字符串是否相等，相等返回 true。	`[ $a = $b ]` 返回 false。
`!=`	检测两个字符串是否相等，不相等返回 true。	`[ $a != $b ]` 返回 true。
`-z`	检测字符串长度是否为 0，为 0 返回 true。	`[ -z $a ]` 返回 false。
`-n`	检测字符串长度是否为 0，不为 0 返回 true。	`[ -n $a ]` 返回 true。
`str`	检测字符串是否为空，不为空返回 true。	`[ $a ]` 返回 true。

💻 『示例源码』

	x="abc"
	y="xyz"


	echo "x=${x}, y=${y}"

	if [[ ${x} = ${y} ]]; then
	echo "${x} = ${y} : x 等于 y"
	else
	echo "${x} = ${y}: x 不等于 y"
	fi

	if [[ ${x} != ${y} ]]; then
	echo "${x} != ${y} : x 不等于 y"
	else
	echo "${x} != ${y}: x 等于 y"
	fi

	if [[ -z ${x} ]]; then
	echo "-z ${x} : 字符串长度为 0"
	else
	echo "-z ${x} : 字符串长度不为 0"
	fi

	if [[ -n "${x}" ]]; then
	echo "-n ${x} : 字符串长度不为 0"
	else
	echo "-n ${x} : 字符串长度为 0"
	fi

	if [[ ${x} ]]; then
	echo "${x} : 字符串不为空"
	else
	echo "${x} : 字符串为空"
	fi

	# Output:
	# x=abc, y=xyz
	# abc = xyz: x 不等于 y
	# abc != xyz : x 不等于 y
	# -z abc : 字符串长度不为 0
	# -n abc : 字符串长度不为 0
	# abc : 字符串不为空

# 文件测试运算符

文件测试运算符用于检测 Unix 文件的各种属性。

属性检测描述如下：

操作符	说明	举例
-b file	检测文件是否是块设备文件，如果是，则返回 true。	`[ -b $file ]` 返回 false。
-c file	检测文件是否是字符设备文件，如果是，则返回 true。	`[ -c $file ]` 返回 false。
-d file	检测文件是否是目录，如果是，则返回 true。	`[ -d $file ]` 返回 false。
-f file	检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。	`[ -f $file ]` 返回 true。
-g file	检测文件是否设置了 SGID 位，如果是，则返回 true。	`[ -g $file ]` 返回 false。
-k file	检测文件是否设置了粘着位 (Sticky Bit)，如果是，则返回 true。	`[ -k $file ]` 返回 false。
-p file	检测文件是否是有名管道，如果是，则返回 true。	`[ -p $file ]` 返回 false。
-u file	检测文件是否设置了 SUID 位，如果是，则返回 true。	`[ -u $file ]` 返回 false。
-r file	检测文件是否可读，如果是，则返回 true。	`[ -r $file ]` 返回 true。
-w file	检测文件是否可写，如果是，则返回 true。	`[ -w $file ]` 返回 true。
-x file	检测文件是否可执行，如果是，则返回 true。	`[ -x $file ]` 返回 true。
-s file	检测文件是否为空（文件大小是否大于 0），不为空返回 true。	`[ -s $file ]` 返回 true。
-e file	检测文件（包括目录）是否存在，如果是，则返回 true。	`[ -e $file ]` 返回 true。

💻 『示例源码』

	file="/etc/hosts"

	if [[ -r ${file} ]]; then
	echo "${file} 文件可读"
	else
	echo "${file} 文件不可读"
	fi
	if [[ -w ${file} ]]; then
	echo "${file} 文件可写"
	else
	echo "${file} 文件不可写"
	fi
	if [[ -x ${file} ]]; then
	echo "${file} 文件可执行"
	else
	echo "${file} 文件不可执行"
	fi
	if [[ -f ${file} ]]; then
	echo "${file} 文件为普通文件"
	else
	echo "${file} 文件为特殊文件"
	fi
	if [[ -d ${file} ]]; then
	echo "${file} 文件是个目录"
	else
	echo "${file} 文件不是个目录"
	fi
	if [[ -s ${file} ]]; then
	echo "${file} 文件不为空"
	else
	echo "${file} 文件为空"
	fi
	if [[ -e ${file} ]]; then
	echo "${file} 文件存在"
	else
	echo "${file} 文件不存在"
	fi

	# Output:(根据文件的实际情况，输出结果可能不同)
	# /etc/hosts 文件可读
	# /etc/hosts 文件可写
	# /etc/hosts 文件不可执行
	# /etc/hosts 文件为普通文件
	# /etc/hosts 文件不是个目录
	# /etc/hosts 文件不为空
	# /etc/hosts 文件存在

# 控制语句

# 条件语句

跟其它程序设计语言一样，Bash 中的条件语句让我们可以决定一个操作是否被执行。结果取决于一个包在 [[ ]] 里的表达式。

由 [[ ]] （ sh 中是 [ ] ）包起来的表达式被称作 检测命令 或基元。这些表达式帮助我们检测一个条件的结果。这里可以找到有关 bash 中单双中括号区别的答案。

共有两个不同的条件表达式： if 和 case 。

# `if`

（1） if 语句

if 在使用上跟其它语言相同。如果中括号里的表达式为真，那么 then 和 fi 之间的代码会被执行。 fi 标志着条件代码块的结束。

	# 写成一行
	if [[ 1 -eq 1 ]]; then echo "1 -eq 1 result is: true"; fi
	# Output: 1 -eq 1 result is: true

	# 写成多行
	if [[ "abc" -eq "abc" ]]
	then
	echo ""abc" -eq "abc" result is: true"
	fi
	# Output: abc -eq abc result is: true

（2） if else 语句

同样，我们可以使用 if..else 语句，例如：

	if [[ 2 -ne 1 ]]; then
	echo "true"
	else
	echo "false"
	fi
	# Output: true

（3） if elif else 语句

有些时候， if..else 不能满足我们的要求。别忘了 if..elif..else ，使用起来也很方便。

💻 『示例源码』

	x=10
	y=20
	if [[ ${x} > ${y} ]]; then
	echo "${x} > ${y}"
	elif [[ ${x} < ${y} ]]; then
	echo "${x} < ${y}"
	else
	echo "${x} = ${y}"
	fi
	# Output: 10 < 20

# `case`

如果你需要面对很多情况，分别要采取不同的措施，那么使用 case 会比嵌套的 if 更有用。使用 case 来解决复杂的条件判断，看起来像下面这样：

💻 『示例源码』

	exec
	case ${oper} in
	"+")
	val=`expr ${x} + ${y}`
	echo "${x} + ${y} = ${val}"
	;;
	"-")
	val=`expr ${x} - ${y}`
	echo "${x} - ${y} = ${val}"
	;;
	"*")
	val=`expr ${x} \* ${y}`
	echo "${x} * ${y} = ${val}"
	;;
	"/")
	val=`expr ${x} / ${y}`
	echo "${x} / ${y} = ${val}"
	;;
	*)
	echo "Unknown oper!"
	;;
	esac

每种情况都是匹配了某个模式的表达式。 | 用来分割多个模式， ) 用来结束一个模式序列。第一个匹配上的模式对应的命令将会被执行。 * 代表任何不匹配以上给定模式的模式。命令块儿之间要用 ;; 分隔。

# 循环语句

循环其实不足为奇。跟其它程序设计语言一样，bash 中的循环也是只要控制条件为真就一直迭代执行的代码块。

Bash 中有四种循环： for ， while ， until 和 select 。

# `for` 循环

for 与它在 C 语言中的姊妹非常像。看起来是这样：

	for arg in elem1 elem2 ... elemN
	do
	### 语句
	done

在每次循环的过程中， arg 依次被赋值为从 elem1 到 elemN 。这些值还可以是通配符或者大括号扩展。

当然，我们还可以把 for 循环写在一行，但这要求 do 之前要有一个分号，就像下面这样：

for i in {1..5}; do echo $i; done

还有，如果你觉得 for..in..do 对你来说有点奇怪，那么你也可以像 C 语言那样使用 for ，比如：

	for (( i = 0; i < 10; i++ )); do
	echo $i
	done

当我们想对一个目录下的所有文件做同样的操作时， for 就很方便了。举个例子，如果我们想把所有的 .bash 文件移动到 script 文件夹中，并给它们可执行权限，我们的脚本可以这样写：

💻 『示例源码』

	DIR=/home/zp
	for FILE in ${DIR}/*.sh; do
	mv "$FILE" "${DIR}/scripts"
	done
	# 将 /home/zp 目录下所有 sh 文件拷贝到 /home/zp/scripts

# `while` 循环

while 循环检测一个条件，只要这个条件为真，就执行一段命令。被检测的条件跟 if..then 中使用的基元并无二异。因此一个 while 循环看起来会是这样：

	while [[ condition ]]
	do
	### 语句
	done

跟 for 循环一样，如果我们把 do 和被检测的条件写到一行，那么必须要在 do 之前加一个分号。

💻 『示例源码』

	### 0 到 9 之间每个数的平方
	x=0
	while [[ ${x} -lt 10 ]]; do
	echo $((x * x))
	x=$((x + 1))
	done
	# Output:
	# 0
	# 1
	# 4
	# 9
	# 16
	# 25
	# 36
	# 49
	# 64
	# 81

# `until` 循环

until 循环跟 while 循环正好相反。它跟 while 一样也需要检测一个测试条件，但不同的是，只要该条件为假就一直执行循环：

💻 『示例源码』

	x=0
	until [[ ${x} -ge 5 ]]; do
	echo ${x}
	x=`expr ${x} + 1`
	done
	# Output:
	# 0
	# 1
	# 2
	# 3
	# 4

# `select` 循环

select 循环帮助我们组织一个用户菜单。它的语法几乎跟 for 循环一致：

	select answer in elem1 elem2 ... elemN
	do
	### 语句
	done

select 会打印 elem1..elemN 以及它们的序列号到屏幕上，之后会提示用户输入。通常看到的是 $? （ PS3 变量）。用户的选择结果会被保存到 answer 中。如果 answer 是一个在 1..N 之间的数字，那么 语句 会被执行，紧接着会进行下一次迭代 —— 如果不想这样的话我们可以使用 break 语句。

💻 『示例源码』

	#!/usr/bin/env bash

	PS3="Choose the package manager: "
	select ITEM in bower npm gem pip
	do
	echo -n "Enter the package name: " && read PACKAGE
	case ${ITEM} in
	bower) bower install ${PACKAGE} ;;
	npm) npm install ${PACKAGE} ;;
	gem) gem install ${PACKAGE} ;;
	pip) pip install ${PACKAGE} ;;
	esac
	break # 避免无限循环
	done

这个例子，先询问用户他想使用什么包管理器。接着，又询问了想安装什么包，最后执行安装操作。

运行这个脚本，会得到如下输出：

	$ ./my_script
	1) bower
	2) npm
	3) gem
	4) pip
	Choose the package manager: 2
	Enter the package name: gitbook-cli

# `break` 和 `continue`

如果想提前结束一个循环或跳过某次循环执行，可以使用 shell 的 break 和 continue 语句来实现。它们可以在任何循环中使用。

break 语句用来提前结束当前循环。

continue 语句用来跳过某次迭代。

💻 『示例源码』

	# 查找 10 以内第一个能整除 2 和 3 的正整数
	i=1
	while [[ ${i} -lt 10 ]]; do
	if [[ $((i % 3)) -eq 0 ]] && [[ $((i % 2)) -eq 0 ]]; then
	echo ${i}
	break;
	fi
	i=`expr ${i} + 1`
	done
	# Output: 6

💻 『示例源码』

	# 打印 10 以内的奇数
	for (( i = 0; i < 10; i ++ )); do
	if [[ $((i % 2)) -eq 0 ]]; then
	continue;
	fi
	echo ${i}
	done
	# Output:
	# 1
	# 3
	# 5
	# 7
	# 9

# 函数

bash 函数定义语法如下：

	[ function ] funname [()] {
	action;
	[return int;]
	}

💡 说明：

函数定义时， function 关键字可有可无。

函数返回值 - return 返回函数返回值，返回值类型只能为整数（0-255）。如果不加 return 语句，shell 默认将以最后一条命令的运行结果，作为函数返回值。

函数返回值在调用该函数后通过 $? 来获得。

所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至 shell 解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。

💻 『示例源码』

	#!/usr/bin/env bash

	calc(){
	PS3="choose the oper: "
	select oper in + - \* / # 生成操作符选择菜单
	do
	echo -n "enter first num: " && read x # 读取输入参数
	echo -n "enter second num: " && read y # 读取输入参数
	exec
	case ${oper} in
	"+")
	return $((${x} + ${y}))
	;;
	"-")
	return $((${x} - ${y}))
	;;
	"*")
	return $((${x} * ${y}))
	;;
	"/")
	return $((${x} / ${y}))
	;;
	*)
	echo "${oper} is not support!"
	return 0
	;;
	esac
	break
	done
	}
	calc
	echo "the result is: $?" # $? 获取 calc 函数返回值

执行结果：

	$ ./function-demo.sh
	1) +
	2) -
	3) *
	4) /
	choose the oper: 3
	enter first num: 10
	enter second num: 10
	the result is: 100

# 位置参数

位置参数是在调用一个函数并传给它参数时创建的变量。

位置参数变量表：

变量	描述
`$0`	脚本名称
`$1 … $9`	第 1 个到第 9 个参数列表
`${10} … ${N}`	第 10 个到 N 个参数列表
`$*` or `$@`	除了 `$0` 外的所有位置参数
`$#`	不包括 `$0` 在内的位置参数的个数
`$FUNCNAME`	函数名称（仅在函数内部有值）

💻 『示例源码』

	#!/usr/bin/env bash

	x=0
	if [[ -n $1 ]]; then
	echo "第一个参数为：$1"
	x=$1
	else
	echo "第一个参数为空"
	fi

	y=0
	if [[ -n $2 ]]; then
	echo "第二个参数为：$2"
	y=$2
	else
	echo "第二个参数为空"
	fi

	paramsFunction(){
	echo "函数第一个入参：$1"
	echo "函数第二个入参：$2"
	}
	paramsFunction ${x} ${y}

执行结果：

	$ ./function-demo2.sh
	第一个参数为空
	第二个参数为空
	函数第一个入参：0
	函数第二个入参：0

	$ ./function-demo2.sh 10 20
	第一个参数为：10
	第二个参数为：20
	函数第一个入参：10
	函数第二个入参：20

执行 ./variable-demo4.sh hello world ，然后在脚本中通过 $1 、 $2 ... 读取第 1 个参数、第 2 个参数。。。

# 函数处理参数

另外，还有几个特殊字符用来处理参数：

参数处理	说明
`$#`	返回参数个数
`$*`	返回所有参数
`$$`	脚本运行的当前进程 ID 号
`$!`	后台运行的最后一个进程的 ID 号
`$@`	返回所有参数
`$-`	返回 Shell 使用的当前选项，与 set 命令功能相同。
`$?`	函数返回值

💻 『示例源码』

	runner() {
	return 0
	}

	name=zp
	paramsFunction(){
	echo "函数第一个入参：$1"
	echo "函数第二个入参：$2"
	echo "传递到脚本的参数个数：$#"
	echo "所有参数："
	printf "+ %s\n" "$*"
	echo "脚本运行的当前进程 ID 号：$$"
	echo "后台运行的最后一个进程的 ID 号：$!"
	echo "所有参数："
	printf "+ %s\n" "$@"
	echo "Shell 使用的当前选项：$-"
	runner
	echo "runner 函数的返回值：$?"
	}
	paramsFunction 1 "abc" "hello, \"zp\""
	# Output:
	# 函数第一个入参：1
	# 函数第二个入参：abc
	# 传递到脚本的参数个数：3
	# 所有参数：
	# + 1 abc hello, "zp"
	# 脚本运行的当前进程 ID 号：26400
	# 后台运行的最后一个进程的 ID 号：
	# 所有参数：
	# + 1
	# + abc
	# + hello, "zp"
	# Shell 使用的当前选项：hB
	# runner 函数的返回值：0

# Shell 扩展

扩展发生在一行命令被分成一个个的 记号（tokens） 之后。换言之，扩展是一种执行数学运算的机制，还可以用来保存命令的执行结果，等等。

感兴趣的话可以阅读关于 shell 扩展的更多细节。

# 大括号扩展

大括号扩展让生成任意的字符串成为可能。它跟 文件名扩展 很类似，举个例子：

echo beg{i,a,u}n ### begin began begun

大括号扩展还可以用来创建一个可被循环迭代的区间。

	echo {0..5} ### 0 1 2 3 4 5
	echo {00..8..2} ### 00 02 04 06 08

# 命令置换

命令置换允许我们对一个命令求值，并将其值置换到另一个命令或者变量赋值表达式中。当一个命令被 `` 或 $() 包围时，命令置换将会执行。举个例子：

	now=`date +%T`
	### or
	now=$(date +%T)

	echo $now ### 19:08:26

# 算数扩展

在 bash 中，执行算数运算是非常方便的。算数表达式必须包在 $(( )) 中。算数扩展的格式为：

	result=$(( ((10 + 5*3) - 7) / 2 ))
	echo $result ### 9

在算数表达式中，使用变量无需带上 $ 前缀：

	x=4
	y=7
	echo $(( x + y )) ### 11
	echo $(( ++x + y++ )) ### 12
	echo $(( x + y )) ### 13

# 单引号和双引号

单引号和双引号之间有很重要的区别。在双引号中，变量引用或者命令置换是会被展开的。在单引号中是不会的。举个例子：

	echo "Your home: $HOME" ### Your home: /Users/<username>
	echo 'Your home: $HOME' ### Your home: $HOME

当局部变量和环境变量包含空格时，它们在引号中的扩展要格外注意。随便举个例子，假如我们用 echo 来输出用户的输入：

	INPUT="A string with strange whitespace."
	echo $INPUT ### A string with strange whitespace.
	echo "$INPUT" ### A string with strange whitespace.

调用第一个 echo 时给了它 5 个单独的参数 —— $INPUT 被分成了单独的词， echo 在每个词之间打印了一个空格。第二种情况，调用 echo 时只给了它一个参数（整个 $INPUT 的值，包括其中的空格）。

来看一个更严肃的例子：

	FILE="Favorite Things.txt"
	cat $FILE ### 尝试输出两个文件: `Favorite` 和 `Things.txt`
	cat "$FILE" ### 输出一个文件: `Favorite Things.txt`

尽管这个问题可以通过把 FILE 重命名成 Favorite-Things.txt 来解决，但是，假如这个值来自某个环境变量，来自一个位置参数，或者来自其它命令（ find , cat , 等等）呢。因此，如果输入可能包含空格，务必要用引号把表达式包起来。

# 流和重定向

Bash 有很强大的工具来处理程序之间的协同工作。使用流，我们能将一个程序的输出发送到另一个程序或文件，因此，我们能方便地记录日志或做一些其它我们想做的事。

管道给了我们创建传送带的机会，控制程序的执行成为可能。

学习如何使用这些强大的、高级的工具是非常非常重要的。

# 输入、输出流

Bash 接收输入，并以字符序列或 字符流 的形式产生输出。这些流能被重定向到文件或另一个流中。

有三个文件描述符：

代码	描述符	描述
`0`	`stdin`	标准输入
`1`	`stdout`	标准输出
`2`	`stderr`	标准错误输出

# 重定向

重定向让我们可以控制一个命令的输入来自哪里，输出结果到什么地方。这些运算符在控制流的重定向时会被用到：

Operator	Description
`>`	重定向输出
`&>`	重定向输出和错误输出
`&>>`	以附加的形式重定向输出和错误输出
`<`	重定向输入
`<<`	Here 文档语法
`<<<`	Here 字符串

以下是一些使用重定向的例子：

	### ls 的结果将会被写到 list.txt 中
	ls -l > list.txt

	### 将输出附加到 list.txt 中
	ls -a >> list.txt

	### 所有的错误信息会被写到 errors.txt 中
	grep da * 2> errors.txt

	### 从 errors.txt 中读取输入
	less < errors.txt

# `/dev/null` 文件

如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：

$ command > /dev/null

/dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到 "禁止输出" 的效果。

如果希望屏蔽 stdout 和 stderr，可以这样写：

$ command > /dev/null 2>&1

# Debug

shell 提供了用于 debug 脚本的工具。

如果想采用 debug 模式运行某脚本，可以在其 shebang 中使用一个特殊的选项：

#!/bin/bash options

options 是一些可以改变 shell 行为的选项。下表是一些可能对你有用的选项：

Short	Name	Description
`-f`	noglob	禁止文件名展开（globbing）
`-i`	interactive	让脚本以交互模式运行
`-n`	noexec	读取命令，但不执行（语法检查）
`-t`	—	执行完第一条命令后退出
`-v`	verbose	在执行每条命令前，向 `stderr` 输出该命令
`-x`	xtrace	在执行每条命令前，向 `stderr` 输出该命令以及该命令的扩展参数

举个例子，如果我们在脚本中指定了 -x 例如：

	#!/bin/bash -x

	for (( i = 0; i < 3; i++ )); do
	echo $i
	done

这会向 stdout 打印出变量的值和一些其它有用的信息：

	$ ./my_script
	+ (( i = 0 ))
	+ (( i < 3 ))
	+ echo 0
	0
	+ (( i++ ))
	+ (( i < 3 ))
	+ echo 1
	1
	+ (( i++ ))
	+ (( i < 3 ))
	+ echo 2
	2
	+ (( i++ ))
	+ (( i < 3 ))

有时我们值需要 debug 脚本的一部分。这种情况下，使用 set 命令会很方便。这个命令可以启用或禁用选项。使用 - 启用选项， + 禁用选项：

💻 『示例源码』

	# 开启 debug
	set -x
	for (( i = 0; i < 3; i++ )); do
	printf ${i}
	done
	# 关闭 debug
	set +x
	# Output:
	# + (( i = 0 ))
	# + (( i < 3 ))
	# + printf 0
	# 0+ (( i++ ))
	# + (( i < 3 ))
	# + printf 1
	# 1+ (( i++ ))
	# + (( i < 3 ))
	# + printf 2
	# 2+ (( i++ ))
	# + (( i < 3 ))
	# + set +x

	for i in {1..5}; do printf ${i}; done
	printf "\n"
	# Output: 12345

# 参考资料

awesome-shell - shell 资源列表
awesome-bash - bash 资源列表
bash-handbook
bash-guide - bash 基本用法指南
bash-it - 为你日常使用、开发以及维护 shell 脚本和自定义命令提供了一个可靠的框架
dotfiles.github.io - 上面有 bash 和其它 shell 的各种 dotfiles 集合以及 shell 框架的链接
Runoob Shell 教程
shellcheck - 一个静态 shell 脚本分析工具，本质上是 bash／sh／zsh 的 lint。

最后，Stack Overflow 上 bash 标签下有很多你可以学习的问题，当你遇到问题时，也是一个提问的好地方。

《华为是怎样对待供应商的》

Wed, 12 Oct 2022 10:45:48 +0800

# 解读《华为是怎样对待供应商的》

# 采购杠杆

按物料族进行采购运作的目的是在全球范围内利用华为的采购杠杆。
这个应该很好理解：
即使是华为，其一个产品使用某个器件的量是有限的。他们有些项目的发货量也是非常小的。
但是其项目比较多、多个项目都使用同一种物料，所产生的累加在一起的数量，也是让供应商非常兴奋的数量。
从开发者的角度，在器件选型的时候，应该是考虑其他项目、其他产品已经在使用自己所需要的物料了，尽量考虑已经采购和使用的物料。
这个情况，在很多开发规模不大的公司很容易出现问题，大家按照自己的认知和想法随意选择新型号的器件。导致：
a、重复设计，相同功能的电路重复设计多次。
b、技术不能得到积累，多个人、多个产品相互之间复用的电路、模块太少，每次开发都是新的人力投入；相互之间的电路不能够得到借鉴。
c、相同的功能，选用不同的器件，造成大量的库存，大量的浪费。

所以，华为采取了以下几个措施，进行规避以上问题：
a、新器件不允许轻易的引入，需要经过复杂的评审，重复论证其必要性。新引入一个器件的成本按照 10 万美金进行评估其综合成本。
b、电路设计要求：归一化、简洁度
归一化：减少器件种类，作为一个专门的措施，在项目流程中对电路进行审视。
简洁度：器件管脚数量 / 器件的个数，用于考核是否使用了大量不必要的阻容等器件。
c、CBB 共用基础模块（Common Building Blocks, CBB）指那些可以在不同产品、系统之间共用的零部件、模块、技术及其他相关的设计成果。由于部门之间共享已有成果的程度很低，随着产品种类的不断增长，零部件、支持系统、供应商也在持续增长，这将导致一系列问题。事实上，不同产品、系统之间，存在许多可以共用的零部件、模块和技术，如果产品在开发中尽可能多地采用了这些成熟的共用基础模块和技术，无疑这一产品的质量、进度和成本会得到很好的控制和保证，产品开发中的技术分险也将大为降低。因此，通过产品重整，建立 CBB 数据库，实现技术、模块、子系统、零部件在不同产品之间的重用和共享，可以缩短产品开发周期、降低产品成本。 CBB 策略的实施需要组织结构和衡量标准的保证。
CBB 电路：指不同设计平台，不同项目之间共用的电路模块、PCB 布局、走线及其它相关的设计成果，CBB 电路分为原理图模块和 PCB 模块两部分。

有一次，任正非开会，问一名副总裁：“你的产品有百分之多少是自己开发的呀？

” 这位副总裁非常骄傲的说：“我们的产品，有 80% 都是自己开发的，20% 是公司现有模块”。任正非非常生气，骂他：“你这个老农民”。

又问另一个副总裁:“你的产品有百分之多少是自己开发的呀？”

这位副总裁说：“我们的产品 60% 是自己开发的，40% 是公司现有的模块。” 任正非点点头：“你是农民企业家。”（开始学会整合资源了。）

又问另一个副总裁:“你的产品有百分之多少是自己开发的呀？”

这位副总裁说:” 我们的产品 40% 是自己开发的，60% 是公司现有模块。” 任总非常高兴：“你才是真正的企业家。”

华为早期的螺钉就有 2000 多种。为什么呢？研发人员讲究” 创新”。他设计一个直角螺钉，我就设计一个卯角的，另外一个哥们看我设计卯角的，他就设计一个弯角的，反正和你们的都不一样，体现自己的独特性。这种创新有没有必要呢？答案显然不是。因此，华为后期通过对 CBB 共享模块进行梳理，发现只需要 200 多种螺钉。由于设计人员无谓的 “创新”，导致公司物料编码很多，很多物料采购量有很少，一是增加了采购部门的工作量，另一方面，由于我们采购的很少，因此，采购的议价就没有优势，导致很多物料的采购价格偏高。

IBM 数据表明，如果公司建立规范化的 CBB 共享平台，在产品设计过程中尽量选用平台库中的部件和物料，料号减少了 30%，供应商从 5000 多家减少到 1200 多家，共享的开发费用从 2% 增加到 20%，减少 50 亿美元的库存成本，每年节约持有成本 5 亿美元，节约劳动节约了研发成本和制造成本，还保证了产品的质量，可以说是一个一劳永逸的战略部署。

华为在 2017、2016 年芯片的采购额度在 140 亿美金左右，世界排名第五。

单位：百万美元。BBK = 步步高。

所谓 “客大欺店”：华为因为其采购的体量足够大，只要运作的好，可以足够的主动权去控制供应链的价格。
在利用上面的一些步骤，可以足以让某一型号的物料形成海量的采购，让芯片的价格最终跟沙子一样。

杠杆也有撬不动的时候
有些器件，由于芯片厂家的技术壁垒，导致独家供货，使得即使华为这样的厂家也没有了议价权：
例如：Intel、三星、高通等厂家。

三星自主生产的尖端电子件，除了给自家用外，还向其它厂商供货，再看看华为公司，今年从韩国供应链采购金额就高达 5.3 万亿韩元，约 311 亿人民币！
华为公司一年从韩国采购的产品价值就达到了公司营收的 1/5 左右了。

而且采购之时还要看三星 SK Hynix 等韩国公司的脸色，倘若搞的他们不开心还会出现限供或不供的局面。就拿三星屏来说，三星把最好的屏都留给自己用，过时或自己觉得不好的东西才给你！早期国产手机中兴 Vivo 金立等众多厂商由于手机屏货源紧张而到处奔波，寻求上游厂商支持，试图从这些屏厂商中获得足够量的显示屏。除了手机屏还是闪存内存等等一系列尖端产品，你都要绞尽脑汁与上游厂商搞好关系，才能在后序生产中保证配件货源的稳定！

当单一器件不具备可以替代性，所以华为会针对这种独家供货采取很多手段：
1、扶持一家竞争对手，例如针对 Intel，会做一些针对 AMD 的性能测试、验证、甚至产品开发；针对 Intel，或研发和使用多核 ARM 的服务器，哪怕生态不成熟，哪怕困难重重，但是也需要提早做好准备，避免类似特朗普封杀中兴的事件。
2、自研芯片逐步解决供货的问题。
3、针对低附加值行业，尽早指定芯片布局，形成高端玩法，当设备不赚钱的时候，靠销售芯片，或者依托芯片本身的技术壁垒，形成高附加值的护城河。
例如，安防、wifi、光网络、手机、无线基站。都通过芯片布局，形成壁垒和优势。这种布局，一是长期积累的芯片设计能力，二是投入大，本身从资本层面就已经形成了保护。

# 华为 92 家供应商

供应商	总部	供应产品及业务
英特尔	美国	计算和存储等
恩智浦	荷兰	NFC 芯片及音频放大器等
灝讯	瑞士	射频连接器和光学连接元件
赛灵思	美国	FPGA 芯片及视频编码器
美满	美国	存储、网络和无线连接解决方案
富士康	中国台湾	代工
生益电子	中国大陆	PCB (印刷线路板〉
中利集团	中国大陆	线缆
富士通	曰本	硬盘驱动器、大移动硬盘等
沪士电子	中国大陆	PCB 产品
美光	美国	存储产品
广濑	曰本	连接器及相关组件
比亚迪	中国大陆	手机结构件、组装、电池、充电器等
村田	日本	滤波器和 MLCC 等
索尼	日本	手机摄像头及相关模组
大立光电	中国台湾	手机镜头
高通	美国	调制调解芯片
亚德诺	美国	模拟与数字倍号处理
康沃	美国	数据保护解决方案
安费诺	美国	连接器及线缆
立讯精密	中国大陆	连接器
欣兴电子	中国台湾	电路板 PC8、集成电辂载板
莫仕	美国	连接器与线缆
耐克森	法国	线缆
京东方	中国大陆	显示屏
阳天电子	中国大陆	温控设备、通信整机、TOP 级的结构件等
中航光电	中国大陆	线缆与连接器物料
甲骨文	美国	软件
住友电工	曰本	光通佶信器件
安森美	美国	光学防抖、自动对焦、可调谐射頻器件、摄像机和充电器的电源管理集成屯路解决方案以及保护器件等
中远海运集团	中国大陆	货物运鍮
顺丰速通	中国大陆	货物运输
中国外运	中国大陆	货物运输
新能源科技有限公司	中国香港	电池类产品
舜宇光学	中国大陆	摄像头模组
天马	中国大陆	屏幕
SK 海力士	韩国	内存
罗德与施瓦茨	德国	从产品开发到产线无缝衔接的 NB-loT 测试方案
是徳科技	美国	SG 技术的测试
美国国际集团	美国	保险、金融、投资及资产管理等服务
思博沦	美国	验证测试业务
红帽	美国	开期软件和技术
SUSE	德国	Linux
晶技股份	中国台湾	石英英荡器及表面声波振荡器
东芝存储	曰本	从硬盘 (HDD)、固态混合硬盘 SSHD 和固态硬盘 SSD 到 NAND 闪存的各种存储技术
希捷	美国	高速硬盘以及闪存等解决方案
西部数椐	美国	创新的存储技术和硬盘产品
光迅科技	中国大陆	光模块
迅达科技	美国	PCB 及相关产品
新思科技	美国	人工智能手机芯片以及软件安全评估
华工科技	中国大陆	5G 光模块
长飞	中国大陆	光纤光缆
意法半导体	瑞士	MCU、MEMS 传感器及 NB-IoT 开发板
思佳迅	美国	射频芯片
微软	美国	翻译技术
深南电路	中国大陆	无线通讯基站用 PCB 在内的各类产品
新飞通	美国	光通讯产品
Qorvo	美国	RF 解决方案
古河电工	曰本	光纤、电线电缆
瑞声科技	中国大陆	声学器件
联恩电子	曰本	光纤接入产品和视频编码器芯片
Sumicem	曰本	UNbO3 调制器
歌尔股份	中国大陆	声学精密零组件和智能硬件
华通电脑	中国台湾	PCB
三菱电机	曰本	电机产品
三星	韩国	OLED 辟幕及内存 / 闪存产品
南亚科技	中国台湾	存储芯片
赛普拉斯	美国	传感器 (三轴加速度计> 、BST 电容控制器等
高意	美国	光电产品
Inphl	美国	半导体组件和光学子系统
松下	曰本	电子材料、电子元器件、电池、汽车电子设备、工厂和工业自动化设备及方案等
航嘉	中国大陆	消费电源核心
旺宏电子	中国台湾	高端 NOR Flash
华勒通讯	中国大陆	0DM
台积电	中国台湾	晶圆代工
核达中远通	中国大陆	电源及相关祖件
风河	美国	VxWorks 嫌作系统
亨通光电	中国大陆	通信产品及系统解决方案
曰月光集团	中国台湾	封测业务
联发科	中国台湾	低端手机芯片
蓝思科技	中国大陆	玻璃前盖、后盖、摄像头、TP、装饰件等
中芯国际	中国大陆	生产电源管理芯片
伟创力	新加坡	组装业务
罗森伯格	德国	无线射频和光纤通信技术
伯恩光学	中国香港	玻璃盖板
Lumeotum	美国	光学元件
菲尼萨	美国	光器件
铿腾电子	美国	EDA 软件
博通	美国	WIFI+BT 模块、定位中枢芯片、射频天线开关等
德州仪器	美国	DSP 和模拟芯片
英飞凌	德国

《Git知识点整理》

Wed, 12 Oct 2022 10:45:48 +0800

# 1. Git 基本概念。

repository
config
init
clone
fetch
pull
commit
push
branch
head
tag
merge
conflict
diff
log
show
status

# 2. Git 工作空间和文件状态

# (1). 工作空间

左侧为工作区，右侧为版本库。

工作区（ Working Directory ）就是在电脑里能看到的目录，比如 learngit 文件夹就是一个工作区。
版本库（ Repository ）工作区有一个隐藏目录 .git ，是 Git 的版本库。

在版本库中标记为 index 的区域为暂存区，标记为 master 的是 Git 为我们自动创建的第一个分支，代表的是目录树。此时 HEAD 实际是指向 master 分支的一个 “游标”，所以图示的命令中出现 HEAD 的地方可以用 master 来替换。图中的 objects 标识的区域为 git 的对象库，实际位于 .git/objects 目录下。

当对工作区修改（或新增）的文件执行 git add 命令时，暂存区的目录树会被更新，同时工作区修改（或新增）的文件内容会被写入到对象库中的一个新的对象中，而该对象的 id 被记录在暂存区的文件索引中。
当执行提交操作 git commit 时，暂存区的目录树会写到版本库（对象库）中，master 分支会做相应的更新，即 master 最新指向的目录树就是提交时原暂存区的目录树。
当执行 git reset HEAD 命令时，暂存区的目录树会被重写，会被 master 分支指向的目录树所替换，但是工作区不受影响。
当执行 git rm --cached 命令时，会直接从暂存区删除文件，工作区则不做出改变。
当执行 git checkout . 或 git checkout -- 命令时，会用暂存区全部的文件或指定的文件替换工作区的文件。这个操作很危险，会清楚工作区中未添加到暂存区的改动。
当执行 git checkout HEAD . 或 git checkout HEAD 命令时，会用 HEAD 指向的 master 分支中的全部或部分文件替换暂存区和工作区中的文件。这个命令也是极度危险的。因为不但会清楚工作区中未提交的改动，也会清楚暂存区中未提交的改动。

# (1). 文件状态

Git 有三种状态，你的文件可能处于其中之一：已提交 ( committed )、已修改 ( modified ) 和已暂存 ( staged )。

# 3. Git 配置系统级、全局、当前仓库用户名、邮箱的命令

系统级、全局、当前仓库选项分别是：仓库 - system、-global、-local (或默认不填)

	git config --global user.name "Jerry Mouse"
	git config --global user.email "jerry@yiibai.com"

列出 Git 设置

	git config --list
	git config -l

# 4. Git fetch 和 pull 的区别

git fetch ：相当于是从远程获取最新版本到本地，不会自动 merge.
git pull ：相当于是从远程获取最新版本并 merge 到本地.

# (1). git fetch 示例：

	Git fetch origin master
	git log -p master..origin/master
	git merge origin/master

以上命令的含义：

首先从远程的 origin 的 master 主分支下载最新的版本到 origin/master 分支上
然后比较本地的 master 分支和 origin/master 分支的差别
最后进行合并
上述过程其实可以用以下更清晰的方式来进行：

# (1). git pull 示例：

git pull origin master

上述命令其实相当于 git fetch 和 git merge 。在实际使用中， git fetch 更安全一些，因为在 merge 前，我们可以查看更新情况，然后再决定是否合并。

# 5. Git reset 和 revert 的却别

git revert 是用一次新的 commit 来回滚之前的 commit， git reset 是直接删除指定的 commit。
在回滚这一操作上看，效果差不多。但是在日后继续 merge 以前的老版本时有区别。因为 git revert 是用一次逆向的 commit “中和” 之前的提交，因此日后合并老的 branch 时，导致这部分改变不会再次出现，但是 git reset 是之间把某些 commit 在某个 branch 上删除，因而和老的 branch 再次 merge 时，这些被回滚的 commit 应该还会被引入。
git reset 是把 HEAD 向后移动了一下，而 git revert 是 HEAD 继续前进，只是新的 commit 的内容和要 revert 的内容正好相反，能够抵消要被 revert 的内容。
git revert 与 git reset 最大的不同是，git revert 仅仅是撤销某次提交。

另外，说一下 git revert ， git reset –hard 和 –soft 的区别

git reset –mixed id : 是将 git 的 HEAD 变了（也就是提交记录变了），但文件并没有改变，（也就是 working tree 并没有改变）。
git reset –soft id : 实际上，是 git reset –mixed id 后，又做了一次 git add 。
git reset –herd id : 是将 git 的 HEAD 变了，文件也变了。

# 6. Git merge 和 reabse 的相同点和不同点

merge 是合并的意思， rebase 是复位基底的意思，相同点都是用来合并分支的。

不同点:

merge 操作会生成一个新的节点，之前的提交分开显示。而 rebase 操作不会生成新的节点，是将两个分支融合成一个线性的提交。
解决冲突时。merge 操作遇到冲突的时候，当前 merge 不能继续进行下去。手动修改冲突内容后，add 修改，commit 就可以了。而 rebase 操作的话，会中断 rebase, 同时会提示去解决冲突。解决冲突后，将修改 add 后执行 git rebase –continue 继续操作，或者 git rebase –skip 忽略冲突。
git pull 和 git pull --rebase 区别： git pull 做了两个操作分别是 "获取" 和 "合并"。所以加了 rebase 就是以 rebase 的方式进行合并分支，默认为 merge。

总结：选择 merge 还是 rebase？

merge 是一个合并操作，会将两个分支的修改合并在一起，默认操作的情况下会提交合并中修改的内容
merge 的提交历史忠实地记录了实际发生过什么，关注点在真实的提交历史上面
rebase 并没有进行合并操作，只是提取了当前分支的修改，将其复制在了目标分支的最新提交后面
rebase 的提交历史反映了项目过程中发生了什么，关注点在开发过程上面
merge 与 rebase 都是非常强大的分支整合命令，没有优劣之分，使用哪一个应由项目和团队的开发需求决定
merge 和 rebase 还有很多强大的选项，可以使用 git help <command> 查看

# 7. Git stash 是什么？它的相关使用方式命令

git stash: 备份当前的工作区的内容，从最近的一次提交中读取相关内容，让工作区保证和上次提交的内容一致。同时，将当前的工作区内容保存到 Git 栈中。
git stash pop: 从 Git 栈中读取最近一次保存的内容，恢复工作区的相关内容。由于可能存在多个 Stash 的内容，所以用栈来管理，pop 会从最近的一个 stash 中读取内容并恢复。
git stash pop --index stash@{0}: 恢复编号为 0 的进度的工作区和暂存区。
git stash apply stash@{1} 以将你指定版本号为 stash@{1} 的工作取出来
git stash drop [<stash>] 删除某一个进度，默认删除最新进度
git stash list: 显示 Git 栈内的所有备份，可以利用这个列表来决定从那个地方恢复。
git stash clear: 清空 Git 栈。此时使用 gitg 等图形化工具会发现，原来 stash 的哪些节点都消失了

	# 恢复工作进度
	git stash pop [--index] [<stash>]
	--index 参数：不仅恢复工作区，还恢复暂存区
	<stash> 指定恢复某一个具体进度。如果没有这个参数，默认恢复最新进度

	# 这是 git stash 保存进度的完整命令形式
	git stash [save message] [-k\|--no-keep-index] [--patch]
	-k和--no-keep-index指定保存进度后，是否重置暂存区
	--patch 会显示工作区和HEAD的差异,通过编辑差异文件，排除不需要保存的内容。和git add -p命令类似

	使用save可以对进度添加备注
	# git stash save "这是保存的进度"

# 8. Git 只从暂存区删除，从工作空间删除的命令分别是什么？

	git rm --cached

	git rm
	git commit

# 9. Git 标签的使用

	# 列出现有的标签
	git tag

	# 打标签
	git tag -a v1.01 -m "Relase version 1.01"

	# 查看相应标签的版本信息
	git show v1.4

-a 选项，创建一个含附注类型的标签
-m 选项，指定了对应的标签说明

# 9. Git 分支的使用

	# 查看本地分支
	git branch

	# 查看远程分支
	git branch -r

	# 创建本地分支 (注意新分支创建后不会自动切换为当前分支)
	git branch [name]

	# 切换分支
	git checkout [name]

	# 创建新分支并立即切换到新分支
	git checkout -b [name]

	# 强制删除一个分支
	git branch -D [name]

	# 合并分支 (将名称为 [name] 的分支与当前分支合并)
	git merge [name]

	# 查看各个分支最后提交信息
	git br -v

	# 查看已经被合并到当前分支的分支
	git br --merged

	# 查看尚未被合并到当前分支的分支
	git br --no-merged

# 10. 介绍 Git 冲突处理经验，以及 merge 和 rebase 中的 ours 和 theirs 的差别。

merge 和 rebase 对于 ours 和 theirs 的定义是完全相反的。在 merge 时，ours 指代的是当前分支，theirs 代表需要被合并的分支。而在 rebase 过程中，ours 指向了修改参考分支，theirs 却是当前分支。因为 rebase 隐含了一个 git checkout upstream 的过程，将 HEAD 从 local 分支变成了 upstream 分支。git 会在 rebase 结束后撤销这个改变，但它已经不可避免地影响了冲突的状态，使 rebase 中 ours 和 theirs 的定义与 merge 截然相反。因此，在使用 ours 与 theirs 时请格外小心。

# 11. Git 远程操作相关

# (1). clone

git clone <版本库的网址>
git clone <版本库的网址> < 本地目录名 >

	# 克隆 jQuery 的版本库
	git clone https://github.com/jquery/jquery.git

	git clone -o jQuery https://github.com/jquery/jquery.git

# (2). remote

	# 列出所有远程主机
	git remote

	# 使用 - v 选项，可以参看远程主机的网址
	git remote -v

	# 可以查看该主机的详细信息
	git remote show <主机名>

	# 添加远程主机
	git remote add <主机名> <网址>

	# 删除远程主机
	git remote rm <主机名>

	# 修改远程主机名称
	git remote rename <原主机名> <新主机名>

# (3). fetch

	# 取回所有分支 (branch) 的更新到本地
	git fetch <远程主机名>

	# 取回某的特定分支的更新
	git fetch <远程主机名> <分支名>

	# 取回 origin 主机的 master 分支的更新
	git fetch origin master

	# 所取回的更新，在本地主机上要用” 远程主机名 / 分支名” 的形式读取。比如 origin 主机的 master，就要用 origin/master 读取。可以使用 git merge 命令或者 git rebase 命令，在本地分支上合并远程分支
	git merge origin/master
	git rebase origin/master

# (4). pull

git pull <远程主机名> < 远程分支名 >:< 本地分支名 >

	# 取回 origin 主机的 next 分支，与本地的 master 分支合并
	git pull origin next:master

	# 如果远程分支是与当前分支合并，则冒号后面的部分可以省略。
	git pull origin next

	# 上面的命令实质上等同于先做 git fetch，再做 git merge。
	git fetch origin
	git merge origin/next

	# 合并需要采用 rebase 模式
	git pull --rebase <远程主机名> <远程分支名>:<本地分支名>

# (5). push

git push <远程主机名> < 本地分支名 >:< 远程分支名 >

注意：分支推送顺序的写法是 "<来源地>:< 目的地 >"，所以 git pull 是 "< 远程分支 >:< 本地分支 >"，而 git push 是 "< 本地分支 >:< 远程分支 >"。

如果省略远程分支名，则表示将本地分支推送与之存在” 追踪关系” 的远程分支 (通常两者同名)，如果该远程分支不存在，则会被新建。
如果省略本地分支名，则表示删除指定的远程分支，因为这等同于推送一个空的本地分支到远程分支。

	# 将本地的 master 分支推送到 origin 主机的 master 分支。如果后者不存在，则会被新建
	git push origin master

	# 省略了本地分支，以下等同，删除 origin 主机的 master 分支
	git push origin :master
	git push origin --delete master

	# 如果当前分支与远程分支之间存在追踪关系，则本地分支和远程分支都可以省略
	git push origin

	# 如果当前分支只有一个追踪分支，那么主机名都可以省略。
	git push

	# 如果当前分支与多个主机存在追踪关系，则可以使用 - u 选项指定一个默认主机，这样后面就可以不加任何参数使用 git push
	git push -u origin master

	# 不管是否存在对应的远程分支，将本地的所有分支都推送到远程主机
	git push --all origin

	# 强制推送
	git push --force origin

	# git push 不会推送标签 (tag)，除非使用–tags 选项
	git push origin --tags

# 12. Git Flow 使用简介

就像代码需要代码规范一样，代码管理同样需要一个清晰的流程和规范。三种广泛使用的工作流程：

Git flow
Github flow
Gitlab flow

三种工作流程，有一个共同点：都采用 "功能驱动式开发"（Feature-driven development，简称 FDD）。它指的是，需求是开发的起点，先有需求再有功能分支（feature branch）或者补丁分支（hotfix branch）。完成开发后，该分支就合并到主分支，然后被删除。最早诞生、并得到广泛采用的一种工作流程，就是 Git flow。

它最主要的特点有两个。首先，项目存在两个长期分支，分别是：主分支 master、开发分支 develop。其次，项目存在三种短期分支，分别是：功能分支（feature branch）、补丁分支（hotfix branch）、预发分支（release branch），一旦完成开发，它们就会被合并进 develop 或 master，然后被删除。

# (1). Git Flow 流程图

# (2). Git Flow 常用的分支

Production 分支。也就是我们经常使用的 Master 分支，这个分支最近发布到生产环境的代码，最近发布的 Release，这个分支只能从其他分支合并，不能在这个分支直接修改。
Develop 分支。这个分支是我们是我们的主开发分支，包含所有要发布到下一个 Release 的代码，这个主要合并与其他分支，比如 Feature 分支。
Feature 分支。这个分支主要是用来开发一个新的功能，一旦开发完成，我们合并回 Develop 分支进入下一个 Release。
Release 分支。当你需要一个发布一个新 Release 的时候，我们基于 Develop 分支创建一个 Release 分支，完成 Release 后，我们合并到 Master 和 Develop 分支。
Hotfix 分支。当我们在 Production 发现新的 Bug 时候，我们需要创建一个 Hotfix, 完成 Hotfix 后，我们合并回 Master 和 Develop 分支，所以 Hotfix 的改动会进入下一个 Release。

# (3). Git Flow 代码示例

# a. 创建 develop 分支

	git branch develop
	git push -u origin develop

# b. 开始新 Feature 开发

	git checkout -b some-feature develop
	# Optionally, push branch to origin:
	git push -u origin some-feature

	# 做一些改动
	git status
	git add some-file
	git commit

# c. 完成 Feature

	git pull origin develop
	git checkout develop
	git merge --no-ff some-feature
	git push origin develop

	git branch -d some-feature

	# If you pushed branch to origin:
	git push origin --delete some-feature

# d. 开始 Relase

	git checkout -b release-0.1.0 develop

	# Optional: Bump version number, commit
	# Prepare release, commit

# e. 完成 Release

	git checkout master
	git merge --no-ff release-0.1.0
	git push

	git checkout develop
	git merge --no-ff release-0.1.0
	git push

	git branch -d release-0.1.0

	# If you pushed branch to origin:
	git push origin --delete release-0.1.0

	git tag -a v0.1.0 master
	git push --tags

# f. 开始 Hotfix

git checkout -b hotfix-0.1.1 master

# g. 完成 Hotfix

	git checkout master
	git merge --no-ff hotfix-0.1.1
	git push

	git checkout develop
	git merge --no-ff hotfix-0.1.1
	git push

	git branch -d hotfix-0.1.1

	git tag -a v0.1.1 master
	git push --tags

话术

Mon, 11 Jul 2022 09:12:29 +0800

# 话术

# 职场 “黑话”

# 二字动词

复盘，赋能，加持，沉淀，倒逼，落地，串联，协同，反哺，兼容，包装，重组，履约，响应，量化，布局，联动，细分，梳理，输出，加速，共建，支撑，融合，聚合，集成，对标，聚焦，抓手，拆解，抽象，摸索，提炼，打通，打透，吃透，迁移，分发，分装，辐射，围绕，复用，渗透，扩展，开拓，皮实，共创，共建，解耦，集成，对齐，拉齐，对焦，给到，拿到，死磕

# 三字名词

感知度，方法论，组合拳，引爆点，点线面，精细化，差异化，平台化，结构化，影响力，耦合性，便捷性，一致性，端到端，短平快，护城河，体验感，颗粒度

# 四字名词

生命周期，价值转化，强化认知，资源倾斜，完善逻辑，抽离透传，复用打法，商业模式，快速响应，定性定量，关键路径，去中心化，结果导向，垂直领域，归因分析，体验度量，信息屏障，资源整合

# 术语应用

比如原来你提问：这个问题你准备怎么解决？

现在的你可以说：你这个问题的底层逻辑是什么？顶层设计在哪？最终交付价值是什么？过程的抓手在哪？如何保证回答闭环？你比别人的亮点在哪？优势在哪？你的思考和沉淀是什么？这个问题换成我来问是否会不一样？在这之前，有自己的思考和沉淀吗？这些问题的颗粒度是怎样拆分的，能作为爆点，引发回答者对问题关键路径的探索吗？别人回答了，你能反哺赋能他们，共建团队意识生态吗？只会问而不会解决，你有自己独有的价值吗？

比如你之前只会一脸懵逼的看着他，愣着不敢说话，现在你可以这么回复他：

我们这款产品底层逻辑是打通信息屏障，创建行业新生态。顶层设计是聚焦用户感知赛道，通过差异化和颗粒度达到引爆点。交付价值是在垂直领域采用复用打法达成持久收益。抽离透传归因分析作为抓手为产品赋能，体验度量作为闭环的评判标准。亮点是载体，优势是链路。思考整个生命周期，完善逻辑考虑资源倾斜。方法论是组合拳达到平台化标准。

# 模板

# yes and 法则

当别人提出一个观点，自己不认同时，我们往往会说，yes，but，这样别人会觉得 “那就这样吧，你说什么就是什么吧” 的想法，无法形成有效的沟通。

yes-and 的原则首先是要接纳，而不是全身都是刺，即当别人提出观点的时候还没仔细思考就先给予否定，尤其当对方不认可攻击你时，很多人立马想到的就是反击。

然后关键是这里的 and，这里的 and 并不是转折或反驳，而是并且或附加的内容，可以巧妙地避免意见不同甚至冲突，所以 yes-and 不仅仅是做事方式，也是一种特别好的沟通方式，让对方感受很舒服。

【示例】

男朋友特别喜欢爬山，有一天男朋友邀请女生去爬山，女生说了下面的一段话 "我不爱爬上，但是我特别好奇你到山顶后看到的风景，你能爬上去之后能给我拍几样张照片吗？专门为我拍的，然后你下来以后，我在哪个咖啡馆等你，你跟我讲讲此次的经历！"

可以听出来，这位女生并不爱爬山，也没有勉强自己去迎合新的男朋友，而是肯定了男朋友的爱好，并且在此基础上创造了新的情景来继续他们的交流！

# PREP 模型

PREP 模型用于表达观点。

PREP 四个英文字母分别代表：Point，观点；Reason，理由；Example，案例；Point，再次讲观点。这是最经典的表达结构。

整个 PREP 结构的关键是，开始就要讲出你的观点，点明主题；后面再举出理由来论证观点；案例部分，最好讲自己的经历或故事来解释，这样听众比较容易听懂；最后再重复和强调一下你的观点。

# SCQ-A 模型

SCQ-A 模型用于提出问题，请求帮助。

situation：阐述背景
conflict：阐述冲突
question：为了解决冲突，你提出要解决的问题
answer：你的看法

【示例】

老板，最近竞争对手上任了新的 CEO，做了一系列措施，比如下调了产品的价格，增大推广和营销，导致现在我们的很多市场被对方蚕食了。

我们现在该如何调整应应对当前的情况，保持市场上的领导位置。

目前我的看法就是优化目前的营销渠道，全面包围对手。

# FFC 赞美法则

所谓 FFC 赞美法，就是指在赞美人的时候，先用自己的语言来表达感受（Feel），然后再进一步通过陈述事实（Fact）来论证自己的感受，最后再通过比较（Compare），来加深对对方的认可，这样对方会感觉特别好。

# 让对方服从你行为的经典话术

这个话术一般来讲模板是这样的：是.. 还是.../ 是否 / 要不要，xxx 好处是这样。

这里的关键是尽量不让用户思考，提供非 A 即 B 的选项，说某个选项的好处，从而让对方服从你。

比如麦当劳、肯德基有 3 个经典话术，进行快推式产品营销：

您是否要加一包薯条，这样可以凑成一个套餐，节省 2 元？（实际上多消费 5 元）
您要不要加 3 元把可乐换成大杯，可以多一半哦？
您要不要加 10 元买个玩具给小朋友呢？

# 沟通中的万能表达模型 - 观察 + 感受 + 需求 + 请求

观察：即你观察的客观事实是什么？注意这里要是事实才行
感受：通过观察之后，你心情感受是怎样的？
需求：你内心希望要解决的问题是什么？
请求：向对方请求你的需求需要得到满足

# FFA 法则

Fact—— 事实
Feeling—— 感受
Action—— 行动

最近一段团队不少新人加入，整体运营效率下降了 30%。（事实）我感觉主要是业务知识传递有些跟不上。（感受）接下来的一周，我会安排老员工一对一辅导每位新人。（行动）

# 实战

别人求你办事，如果你说：“这事儿不太好办”，那么资源置换就来了。

不好办说明能办，但需要附加条件，懂的人自然知道接下来应该怎么办。

拒绝借钱：“你知道的，我最近 XX，也没钱。”

遇到借钱，只要你平时不太露富，就好用。

朋友管你借钱，用 “你知道的” 直接把皮球踢回去，再给个具体理由，比如买了什么东西、投入基金股票里了，随便什么都行。

只要把对方放在知道你没钱的位置上，他就不好再开下一句口，一般会主动结束对话。

表示体贴，但不想真的去接客户，先打电话沟通：“约的地方有点远，需要我去接您吗？”

绝大部分人遇到这样的问句，本能反应是不用，你的目的就达到了。

不过如果真遇到要你接的，这人多半有点矫情，以后相处要注意多恭维一下。

经典汇报话术 1：“老板，我们团队做了 A、B 两版方案，各有优势，您给提提意见，看选哪个好。”

该话术利用了沉锚效应，抛出了二者选其一的锚，避开全部拒绝的选项，引导领导 “选一个”、“提意见”，减小被全部驳回的风险。

经典汇报话术 2：“领导，我是这么想的，XXX。第一，X；第二，X；第三，X。”

我们的大脑被训练得听到 “第一、第二” 就默认为其中有条理、有逻辑，不管其中是不是真的严丝合缝地支撑你的观点。善用一二三做汇报，领导会觉得你准备得很充分，考虑周全。

遇到问题请求领导帮忙：“经过了解，现在碰到了一些情况，我的解决办法是 XX，您看还有没有什么更好的办法。”

不要直接说自己解决不了，让领导想办法。不管自己提出的办法多平庸，都一定要提。

请求他人帮忙：“能请你帮我打印一下文件吗，因为我一会儿真有事。”、“不好意思，能插一下队吗，因为我真的着急。”

善用 “因为所以”，“因为所以” 是十几年语文教学留给我们的条件反射，不管多离奇的理由，听到的时候都会默认有道理。

聊天想聊下去：揪住对方句子里的关键词 + 延伸过往彼此交流过的信息。

例 1

朋友：“今天又加班，烦死了。”

你：“怎么又加班啊，又是上回让你加班的那个领导吗？”

例 2

闺蜜：“我爱豆塌房子了！”

你：“哪个爱豆？上回你说的 XXX？我去！”

聊天不想继续聊下去：重复关键词 + 感叹词。重点！不要扩展任何有效信息。

例 1

朋友：“今天又加班，烦死了”

你：“怎么又加班啊，唉，这叫啥事啊，我无语。”

例 2

闺蜜：“我爱豆又塌房子了！”

你：“又塌房子！我去，也太那个了，绝了！”

领导说：“辛苦了。”

你：“从中学到很多，很有收获。”

敏而好学、不居功，领导更喜欢这样的下属。

给领导的节日问候：尊称 + 感谢 + 互动 + 祝福

尊称放在前面，引起注意。互动要具体、细节，才有记忆点。

XX，过年好！
感谢您一直的关照，从您身上学到很多。

上次 XX，您说 XXX 我一直记得，受益匪浅。

又到新的一年，祝您和家人新年快乐！

改变一个人的想法：认同立场，替换观点。

无论任何人，观点不是不可改变的，但立场很难动摇。

比如你的预算交上去，被砍了很大一块，你能做的不是抱怨老板抠门，而是认同老板砍预算是为了控制成本，开公司是为了赚钱的，这就是老板该有的立场。

所以，如果你不想自己的预算被砍掉，只有你能向老板展示，你做的方案能为他赚更多钱，老板就不会不同意。

# 工作汇报

实情	话术
新项目玩砸了	进行了积极的试错，吸收了宝贵的经验。
数据不好看	有较大的增长空间
啥也没干	稳定发展
接下来，我依旧打算啥也不干	保持现有成绩，稳定成果
数据稍微好看一点	取得了较大增长

# 沟通

当你觉得对方特别啰嗦，又不好意思打断对方谈话

直接给对方说的话下定义，作评判。例如：“好的”、“那确实不错”、“的确是这样”、“嗯，你说的对” 等等。

对方会瞬间失去表达欲望。

当你接到你不想做的任务时

我仔细看了一下这个需求，我这里可能存在 XXX XXX XXX 方面的短板
“领导，我仔细看了一下这个需求，我这里可能存在 XXX XXX XXX 方面的短板”
“想要推进这件事情的话，我可能需要 XXX XXX XXX 方面的支持”

好的可能：领导感觉你是认真经过调研，分析了可行性，确实你不太适合，他表示会再考虑考虑

坏的可能：你还是得做，但是这句话的意思已经很明确了：我可是给你说清楚了啊，这件事办砸了，你可不能赖我

当我想刺探什么秘密的时候，我会先说一个结论，然后看对方的反应

“我们公司下个月要发奖金你知道对吧，想好怎么花了么？”
- “卧槽你这消息灵通啊”—— 真的要发
- “你听谁说的”—— 不知道真假，但是可以继续测
这个时候我会再补一句：“我能得到这个消息，说明肯定有人放风给我”
- “胡扯，没有这个规划”—— 下个月不发奖金
- “你每天花花肠子怎么这么多”—— 没有明确的回应这个问题，我的猜测 80% 是真实的

临时要交什么汇报，或者做工作总结的时候，不要紧张

【你日常都在做什么】+【这件事的目的是什么】+【你在做这件事的时候有什么困难】+【怎么把这件事做的更好】

比如：

我最近在更新我的知乎账号，坚持回答问题，这是为了能够积累更多的粉丝数，获得更多的认同，也培养自己输出的习惯

但是我发现我的阅读量上去了，但是点赞量还没有起来

所以我决定在写到这一段的时候给读者老爷们磕个头求个赞，哐哐哐

想要说服别人的时候

注意两点：

先肯定对方的想法
尽量不要出现比较主观的用语，如：“我觉得”、“照我看”、“我认为”

【示例】我仔细听了你的诉求，很有道理，这个需求是可以理解的。但是，我们换个角度想一想：......。而且，我还听别人说：.....。所以，不妨折中一下：.....。你觉得这样如何呢？

当别人给你布置杂活的时候

我们要死扣细节，不停问细节：

“你说的这件事大概什么时候需要？”
“这个时间点具体到几点？”
“我是微信给你还是邮箱给你？”
“那需要我先给一个计划，你帮我看看合适不合适么？”
......

一个杂活而已，你不停地追问细节，会极大地增加你们之间的沟通成本，让对方崩溃，从此再也不想给你安排杂活。

# 参考资料

复杂度分析

Sun, 20 Mar 2022 23:25:17 +0800

# 复杂度分析

# 为什么需要复杂度分析

衡量算法的优劣，有两种评估方式：事前估计和后期测试。

后期测试有性能测试、基准测试（Benchmark）等手段。

但是，后期测试有以下限制：

测试结果非常依赖测试环境。如：不同机型、不同编译器版本、不同硬件配置等等，都会影响测试结果。
测试结果受数据规模的影响很大。

所以，需要一种方法，可以不受环境或数据规模的影响，粗略地估计算法的执行效率。这种方法就是复杂度分析。

# 时间复杂度分析

# 大 O 表示法

假设问题的规模为 n，则程序的时间复杂度表示为 T(n) 。代码的执行时间 T (n) 与每行代码的执行次数 n 成正比。

当 n 增大时，T (n) 也随之增大，想要准确估计其变化比较困难。所以，可以采用大 O 时间复杂度来粗略估计其复杂度，其表达式为： T(n) = O(f(n)) 。

大 O 表示法实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

# 时间复杂度分析的要点

只关注循环执行次数最多的一段代码
加法法则：总复杂度等于量级最大的那段代码的复杂度
乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

# 最好、最坏和平均情况

最好情况时间复杂度（best case time complexity）：在最理想的情况下，执行代码的时间复杂度。例如：在最理想的情况下，要查找的变量 x 正好是数组的第一个元素，此时最好情况时间复杂度为 1。
最坏情况时间复杂度（worst case time complexity）：在最糟糕的情况下，执行代码的时间复杂度。例如：在最理想的情况下，要查找的变量 x 正好是数组的最后个元素，此时最好情况时间复杂度为 n。
平均情况时间复杂度（average case time complexity）：平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。

# 时间复杂度分析示例

【示例】从 1 累加到 100 的时间复杂度是多少？

	int sum = 0;
	int N = 100;
	for (int i = 1; i <= N; i++) {
	sum = sum + i;
	}

时间复杂度计算：显然，这段代码执行了 100 次加法，其时间复杂度和 N 的大小完全一致

T(n) = O(n)

【示例】嵌套循环的时间复杂度是多少？

	int M = 10;
	int N = 20;
	for (int i = 1; i < M; i++) {
	for (int j = 1; j < N; j++) {
	System.out.println("i = " + i + ", j = " + j);
	}
	}

时间复杂度计算：

T(n) = (M-1)(N-1) = O(M*N) ≈ O(N^2)

【示例】递归函数的时间复杂度是多少？思考一下斐波那契数列 f(n) = f(n-1) + f(n-2) 的时间复杂度是多少？

T(n) = O(2^N)

# 空间复杂度分析

时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。

类比一下，空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。

# 复杂度量级

复杂度有以下量级：

O(1) ：常数复杂度
O(log n) ：对数复杂度
O(n) ：线性复杂度
O(nlog n) ：线性对数阶复杂度
O(n^2) ：平方复杂度
O(n^3) ：立方复杂度
O(n^k) ：K 次方复杂度
O(2^n) ：指数复杂度
O(n!) ：阶乘复杂度

在数据量比较小的时候，复杂度量级差异并不明显；但是，随着数据规模大小的变化，差异会逐渐突出。

O(1) 复杂度示例：

	int num = 100;
	System.out.println("num = " + num);

O(log n) 对数复杂度示例：

	int max = 100;
	for (int i = 1; i < max; i = i * 2) {
	System.out.println("i = " + i);
	}

O(n) 复杂度示例：

	int max = 100;
	for (int i = 1; i < max; i++) {
	System.out.println("i = " + i);
	}

O(n^2) 复杂度示例：

	int M = 10;
	int N = 20;
	for (int i = 1; i < M; i++) {
	for (int j = 1; j < N; j++) {
	System.out.println("i = " + i + ", j = " + j);
	}
	}

O(k^n) 复杂度示例：

	int max = 10;
	for (int i = 1; i <= Math.pow(2, max); i++) {
	System.out.println("i = " + i);
	}

# 常见数据结构的复杂度

# 参考资料

数据结构与算法之美

代码工程规范

Sat, 18 Dec 2021 19:26:20 +0800

# 代码工程规范

软件项目开发规范。

# 项目结构

以下为项目根目录下的文件和目录的组织结构：

# 目录

codes - 代码目录。
configurations - 配置目录。一般存放项目相关的配置文件。如 maven 的 settings.xml，nginx 的 nginx.conf 等。
demos - 示例目录。
docs - 文档目录。
libs - 第三方库文件。
scripts - 脚本目录。一般存放用于启动、构建项目的可执行脚本文件。
packages - 打包文件目录。Java 项目中可能是 jar、war 等；前端项目中可能是 zip、rar 等；电子书项目中可能是 pdf 等。

# 文件

.gitignore - git 忽略规则。
.gitattributes - git 属性规则。
.editorconfig - 编辑器书写规则。
README.md - 项目说明文件。
LICENSE - 开源协议。如果项目是开源文件，需要添加。

# 命名规则

# 目录名

目录名必须使用半角字符，不得使用全角字符。这也意味着，中文不能用于文件名。

目录名建议只使用小写字母，不使用大写字母。

不佳： Test
正确： test

目录名可以使用数字，但不应该是首字符。

不佳： 1-demo
正确： demo1

目录名包含多个单词时，单词之间建议使用半角的连词线（ - ）分隔。

不佳： common_demo
正确： common-demo

# 文件名

文档的文件名不得含有空格。

文件名必须使用半角字符，不得使用全角字符。这也意味着，中文不能用于文件名。

错误： 名词解释.md
正确： glossary.md

文件名建议只使用小写字母，不使用大写字母。

错误：TroubleShooting.md
正确：troubleshooting.md

为了醒目，某些说明文件的文件名，可以使用大写字母，比如 README 、 LICENSE 。

一些约定俗成的习惯可以保持传统写法，如：Java 的文件名一般使用驼峰命名法，且首字母大写；配置文件 applicationContext.xml ；React 中的 JSX 组件文件名一般使用驼峰命名法，且首字母大写等。

文件名包含多个单词时，单词之间建议使用半角的连词线（ - ）分隔。

不佳：advanced_usage.md
正确：advanced-usage.md

# Java 日志规范

这里基于阿里巴巴 Java 开发手册日志规约章节，结合自己的开发经验做了一些增删和调整。

【强制】应用中不可直接使用日志系统（Log4j、Logback）中的 API，而应依赖使用日志框架 SLF4J 中的 API，使用门面模式的日志框架，有利于维护和各个类的日志处理方式统一。

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	private static final Logger logger = LoggerFactory.getLogger(Abc.class);

【强制】日志文件推荐至少保存 30 天，因为有些异常具备以 “周” 为频次发生的特点。
【强制】应用中的扩展日志（如打点、临时监控、访问日志等）命名方式： appName_logType_logName.log 。logType: 日志类型，推荐分类有 stats/desc/monitor/visit 等；logName: 日志描述。这种命名的好处：通过文件名就可知道日志文件属于什么应用，什么类型，什么目的，也有利于归类查找。

正例：mppserver 应用中单独监控时区转换异常，如： mppserver_monitor_timeZoneConvert.log

说明：推荐对日志进行分类，如将错误日志和业务日志分开存放，便于开发人员查看，也便于通过日志对系统进行及时监控。

【强制】对 trace/debug/info 级别的日志输出，必须使用条件输出形式或者使用占位符的方式。

说明： logger.debug("Processing trade with id: " + id + " and symbol: " + symbol); 如果日志级别是 warn，上述日志不会打印，但是会执行字符串拼接操作，如果 symbol 是对象，会执行 toString () 方法，浪费了系统资源，执行了上述操作，最终日志却没有打印。

正例：（条件）

if (logger.isDebugEnabled()) {
logger.debug("Processing trade with id: " + id + " and symbol: " + symbol);
}

正例：（占位符）

logger.debug("Processing trade with id: {} and symbol : {} ", id, symbol);

【强制】避免重复打印日志，浪费磁盘空间。务必在 log4j.xml 或 logback.xml 中设置 additivity=false 。

正例：

<logger name="com.taobao.dubbo.config" additivity="false">

【强制】异常信息应该包括两类信息：案发现场信息和异常堆栈信息。如果不处理，那么通过关键字 throws 往上抛出。

正例：logger.error (各类参数或者对象 toString + "_" + e.getMessage (), e);

【强制】日志格式遵循如下格式：

打印出的日志信息如：

2018-03-29 15:06:57.277 [javalib] [main] [TRACE] i.g.dunwu.javalib.log.LogbackDemo#main - 这是一条 trace 日志记录
2018-03-29 15:06:57.282 [javalib] [main] [DEBUG] i.g.dunwu.javalib.log.LogbackDemo#main - 这是一条 debug 日志记录
2018-03-29 15:06:57.282 [javalib] [main] [INFO] i.g.dunwu.javalib.log.LogbackDemo#main - 这是一条 info 日志记录
2018-03-29 15:06:57.282 [javalib] [main] [WARN] i.g.dunwu.javalib.log.LogbackDemo#main - 这是一条 warn 日志记录
2018-03-29 15:06:57.282 [javalib] [main] [ERROR] i.g.dunwu.javalib.log.LogbackDemo#main - 这是一条 error 日志记录

【参考】slf4j 支持的日志级别，按照级别从低到高，分别为： trace < debug < info < warn < error 。

建议只使用 debug < info < warn < error 四个级别。

error 日志级别只记录系统逻辑出错、异常等重要的错误信息。如非必要，请不要在此场景打出 error 级别。
warn 日志级别记录用户输入参数错误的情况，避免用户投诉时，无所适从。
info 日志级别记录业务逻辑中一些重要步骤信息。
debug 日志级别记录一些用于调试的信息。

【参考】有一些第三方框架或库的日志对于排查问题具有一定的帮助，如 Spring、Dubbo、Mybatis 等。这些框架所使用的日志库未必和本项目一样，为了避免出现日志无法输出的问题，请引入对应的桥接 jar 包。

# 参考资料

阿里巴巴 Java 开发手册日志规约章节

个人目录管理规范

Sat, 11 Dec 2021 10:23:22 +0800

# 个人目录管理规范

作为程序员，想必每个人都会有大量的资料、数据。按照条理清晰的目录结构去分类化存储，十分有助于管理文件。

# 目录结构

以下是我个人整理的目录结构：

.
├── Codes           #代码目录
│   ├── Other       #第三方代码目录
│   ├── My          #个人代码目录
│   └── Work        #工作代码目录
├── Data            #数据目录
├── Downloads       #下载文件目录
├── Docs            #文档目录
│   ├── Books       #电子书目录
│   ├── My          #个人文档目录
│   └── Work        #工作文档目录
├── Movies          #视频目录
├── Music           #音乐目录
├── Pictures        #图片目录
├── Public          #共享目录
├── Temp            #临时文件目录
└── Tools           #工具软件目录
    └── Packages    #安装包目录

注：如果您使用的操作系统是 Mac 这种可以为目录或文件添加 tag 的操作系统，那么您可以根据自己的喜好更细致化的管理。

# 2. 文件管理软件

选用便利的文件管理软件，可以让你的文件管理如虎添翼。这里推荐几款经典的文件管理工具。

# 2.1. Clover

Clover 是 Windows Explorer 资源管理器的一个扩展，为其增加类似谷歌 Chrome 浏览器的多标签页功能。

# 2.2. Everything

Everything 可以立即在 windows 系统中找到制定名称的文件和文件夹。

# 2.3. Wox

Wox 是一款简单易用的 Windows 启动器。可以把它视为 windows 版的 Alfred。

# 2.4. Q-dir

Q-dir 是轻量的文件管理器，特点鲜明，各种布局视图切换灵活，默认四个小窗口组成一个大窗口，操作快捷。

技术文档规范

Sat, 11 Dec 2021 10:23:22 +0800

# 技术文档规范

文档采用 Markdown 语法书写。

📚 「参考」Markdown 语法可以参考：

https://github.com/guodongxiaren/README

https://github.com/tchapi/markdown-cheatsheet

# 1. 标题

# 1.1. 标题层级

标题分为四级。

一级标题：文章的标题
二级标题：文章内容的大标题
三级标题：二级标题下一级的标题
四级标题：三级标题下一级的标题

# 1.2. 标题原则

一篇文章中应该尽力避免同名标题。
一级标题下，不能直接出现三级标题。
标题要避免孤立编号（即同级标题只有一个）。
下级标题不重复上一级标题的内容。
谨慎使用四级标题，尽量避免出现，保持层级的简单和防止出现过于复杂的章节。如果三级标题下有并列性的内容，建议只使用项目列表（Item list）。

# 2. 文本

# 2.1. 字间距

全角中文字符与半角英文字符之间，应有一个半角空格。

反例：本文介绍如何快速启动Windows系统。

正例：本文介绍如何快速启动 Windows 系统。

全角中文字符与半角阿拉伯数字之间，有没有半角空格都可，但必须保证风格统一，不能两种风格混杂。

正例：2011年5月15日，我订购了5台笔记本电脑与10台平板电脑。

正例：2011 年 5 月 15 日，我订购了 5 台笔记本电脑与 10 台平板电脑。

半角的百分号，视同阿拉伯数字。

英文单位若不翻译，单位前的阿拉伯数字与单位间不留空格。

反例：一部容量为 16 GB 的智能手机

正例：一部容量为 16GB 的智能手机

半角英文字符和半角阿拉伯数字，与全角标点符号之间不留空格。

反例：他的电脑是 MacBook Air 。

正例：他的电脑是 MacBook Air。

# 2.2. 句子

避免使用长句。一个句子建议不超过 100 字或者正文的 3 行。
尽量使用简单句和并列句，避免使用复合句。

# 2.3. 写作风格

尽量不使用被动语态，改为使用主动语态。

反例：假如此软件尚未被安装，

正例：假如尚未安装这个软件，

不使用非正式的语言风格。

反例：Lady Gaga 的演唱会真是酷毙了，从没看过这么给力的表演！！！

正例：无法参加本次活动，我深感遗憾。

用对 “的”、“地”、“得”。

她露出了开心的笑容。
（形容词＋的＋名词）

她开心地笑了。
（副词＋地＋动词）

她笑得很开心。
（动词＋得＋副词）

使用代词时（比如 “其”、“该”、“此”、“这” 等词），必须明确指代的内容，保证只有一个含义。

反例：从管理系统可以监视中继系统和受其直接控制的分配系统。

正例：从管理系统可以监视两个系统：中继系统和受中继系统直接控制的分配系统。

名词前不要使用过多的形容词。

反例：此设备的使用必须在接受过本公司举办的正式的设备培训的技师的指导下进行。

正例：此设备必须在技师的指导下使用，且指导技师必须接受过由本公司举办的正式设备培训。

单个句子的长度尽量保持在 20 个字以内；20 ～ 29 个字的句子，可以接受；30 ～ 39 个字的句子，语义必须明确，才能接受；多于 40 个字的句子，在任何情况下都不能接受。

反例：本产品适用于从由一台服务器进行动作控制的单一节点结构到由多台服务器进行动作控制的并行处理程序结构等多种体系结构。

正例：本产品适用于多种体系结构。无论是由一台服务器（单一节点结构），还是由多台服务器（并行处理结构）进行动作控制，均可以使用本产品。

同样一个意思，尽量使用肯定句表达，不使用否定句表达。

反例：请确认没有接通装置的电源。

正例：请确认装置的电源已关闭。

避免使用双重否定句。

反例：没有删除权限的用户，不能删除此文件。

正例：用户必须拥有删除权限，才能删除此文件。

# 2.4. 英文处理

英文原文如果使用了复数形式，翻译成中文时，应该将其还原为单数形式。

英文：⋯information stored in random access memory (RAMs)⋯

中文：……存储在随机存取存储器（RAM）里的信息……

外文缩写可以使用半角圆点 ( . ) 表示缩写。

U.S.A.
Apple, Inc.

表示中文时，英文省略号（ ⋯ ）应改为中文省略号（ …… ）。

英文：5 minutes later⋯

中文：5 分钟过去了⋯⋯

英文书名或电影名改用中文表达时，双引号应改为书名号。

英文：He published an article entitled "The Future of the Aviation".

中文：他发表了一篇名为《航空业的未来》的文章。

第一次出现英文词汇时，在括号中给出中文标注。此后再次出现时，直接使用英文缩写即可。

IOC（International Olympic Committee，国际奥林匹克委员会）。这样定义后，便可以直接使用“IOC”了。

专有名词中每个词第一个字母均应大写，非专有名词则不需要大写。

“American Association of Physicists in Medicine”（美国医学物理学家协会）是专有名词，需要大写。

“online transaction processing”（在线事务处理）不是专有名词，不应大写。

# 3. 段落

# 3.1. 段落原则

一个段落只能有一个主题，或一个中心句子。
段落的中心句子放在段首，对全段内容进行概述。后面陈述的句子为核心句服务。
一个段落的长度不能超过七行，最佳段落长度小于等于四行。
段落的句子语气要使用陈述和肯定语气，避免使用感叹语气。
段落之间使用一个空行隔开。
段落开头不要留出空白字符。

# 3.2. 引用

引用第三方内容时，应注明出处。

One man’s constant is another man’s variable. — Alan Perlis

如果是全篇转载，请在全文开头显著位置注明作者和出处，并链接至原文。

本文转载自 WikiQuote

使用外部图片时，必须在图片下方或文末标明来源。

本文部分图片来自 Wikipedia

# 3.3. 强调

一些特殊的强调内容可以按照如下方式书写：

🔔 『注意』

💡 『提示』

📚 『参考』

# 4. 数值

# 4.1. 半角数字

数字一律使用半角形式，不得使用全角形式。

反例： 这件商品的价格是１０００元。

正例： 这件商品的价格是 1000 元。

# 4.2. 千分号

数值为千位以上，应添加千分号（半角逗号）。

XXX 公司的实收资本为 RMB1,258,000。

对于 4 ～ 6 位的数值，千分号是选用的，比如 1000 和 1,000 都可以接受。对于 7 位及以上的数值，千分号是必须的。

多位小数要从小数点后从左向右添加千分号，比如 4.234,345 。

# 4.3. 货币

货币应为阿拉伯数字，并在数字前写出货币符号，或在数字后写出货币中文名称。

$1,000
1,000 美元

# 4.4. 数值范围

表示数值范围时，用 ～ 连接。参见《标点符号》一节的 “连接号” 部分。

带有单位或百分号时，两个数字都要加上单位或百分号，不能只加后面一个。

反例：132～234kg
正例：132kg～234kg

反例：67～89%
正例：67%～89%

# 4.5. 变化程度的表示法

数字的增加要使用 “增加了”、“增加到”。“了” 表示增量，“到” 表示定量。

增加到过去的两倍
（过去为一，现在为二）

增加了两倍
（过去为一，现在为三）

数字的减少要使用 “降低了”、“降低到”。“了” 表示增量，“到” 表示定量。

降低到百分之八十
（定额是一百，现在是八十）

降低了百分之八十
（原来是一百，现在是二十）

不能用 “降低 N 倍” 或 “减少 N 倍” 的表示法，要用 “降低百分之几” 或 “减少百分之几”。因为减少（或降低）一倍表示数值原来为一百，现在等于零。

# 5. 符号

# 5.1. 符号原则

中文语句的标点符号，均应该采取全角符号，这样可以保证视觉的一致。
如果整句为英文，则该句使用英文 / 半角标点。
句号、问号、叹号、逗号、顿号、分号和冒号不得出现在一行之首。

# 5.2. 句号

中文语句中的结尾处应该用全角句号（ 。 ）。

句子末尾用括号加注时，句号应在括号之外。

反例：关于文件的输出，请参照第 1.3 节（见第 26 页。）

正例：关于文件的输出，请参照第 1.3 节（见第 26 页）。

# 5.3. 逗号

逗号 ， 表示句子内部的一般性停顿。

注意避免 “一逗到底”，即整个段落除了结尾，全部停顿都使用逗号。

# 5.4. 顿号

句子内部的并列词，应该用全角顿号 ( 、 ) 分隔，而不用逗号，即使并列词是英语也是如此。

反例：我最欣赏的科技公司有 Google, Facebook, 腾讯, 阿里和百度等。

正例：我最欣赏的科技公司有 Google、Facebook、腾讯、阿里和百度等。

英文句子中，并列词语之间使用半角逗号（ , ）分隔。

例句：Microsoft Office includes Word, Excel, PowerPoint, Outlook and other components.

# 5.5. 分号

分号 ； 表示复句内部并列分句之间的停顿。

# 5.6. 引号

引用时，应该使用全角双引号（ “ ” ），注意前后双引号不同。

例句：许多人都认为客户服务的核心是“友好”和“专业”。

引号里面还要用引号时，外面一层用双引号，里面一层用单引号（ ‘ ’ ），注意前后单引号不同。

例句：鲍勃解释道：“我要放音乐，可萨利说，‘不行！’。”

# 5.7. 圆括号

补充说明时，使用全角圆括号 （） ，括号前后不加空格。

例句：请确认所有的连接（电缆和接插件）均安装牢固。

# 5.8. 冒号

全角冒号（ ： ）常用在需要解释的词语后边，引出解释和说明。

例句：请确认以下几项内容：时间、地点、活动名称，以及来宾数量。

表示时间时，应使用半角冒号（ : ）。

例句：早上 8:00

# 5.9. 省略号

省略号 …… 表示语句未完、或者语气的不连续。它占两个汉字空间、包含六个省略点，不要使用 。。。 或 ... 等非标准形式。

省略号不应与 “等” 这个词一起使用。

反例：我们为会餐准备了香蕉、苹果、梨…等各色水果。

正例：我们为会餐准备了各色水果，有香蕉、苹果、梨……

正例：我们为会餐准备了香蕉、苹果、梨等各色水果。

# 5.10. 感叹号

应该使用平静的语气叙述，尽量避免使用感叹号 ！ 。

不得多个感叹号连用，比如 ！！ 和 !!! 。

# 5.11. 破折号

破折号 ———— 一般用于做进一步解释。破折号应占两个汉字的位置。

例句：直觉————尽管它并不总是可靠的————告诉我，这事可能出了些问题。

# 5.12. 连接号

连接号用于连接两个类似的词。

以下场合应该使用直线连接号（ - ），占一个半角字符的位置。

两个名词的复合
图表编号

例句：氧化-还原反应

例句：图 1-1

以下场合应该使用波浪连接号（ ～ ），占一个全角字符的位置。

数值范围（例如日期、时间或数字）

例句：2009 年～2011 年

注意，波浪连接号前后两个值都应该加上单位。

波浪连接号也可以用汉字 “至” 代替。

例句：周围温度：-20°C 至 -10°C

# 6. 结构

# 6.1. 目录结构

技术手册目录结构是一部完整的书，建议采用下面的结构。

简介（Introduction） - [必选][目录 | 文件] 提供对产品和文档本身的总体的、扼要的说明
入门篇（Quickstart） - [可选][文件] 如何最快速地使用产品
基础篇（Basics） - [必选][目录] 又称” 使用篇 “，提供初级的使用教程
- 环境准备（Prerequisite） - [可选][文件] 软件使用需要满足的前置条件
- 安装（Installation） - [可选][文件] 软件的安装方法
- 配置（Configuration） - [可选][目录 | 文件] 软件的配置
- 特性（Feature） - [必选][目录 | 文件] 软件的功能特性
进阶篇（Advanced） - [可选][目录] 又称” 开发篇 “，提供中高级的开发教程
- 原理（Principle） - [可选][目录 | 文件] 软件的原理
- 设计（Design） - [可选][目录 | 文件] 软件的设计，如：架构、设计思想等
实战篇（Action） - [可选][目录] 提供一些具有实战意义的示例说明
API（API） - [可选][目录 | 文件] 软件 API 的逐一介绍
常见问题（FAQ） - [可选][目录 | 文件] 常见问题解答
附录（Appendix） - [可选][目录] 不属于教程本身、但对阅读教程有帮助的内容
- 命令（Command） - [可选][目录] 命令
- 资源（Resource） - [必选][文件] 资源
- 术语（Glossary） - [可选][文件] 名词解释
- 技巧（Recipe） - [可选][文件] 最佳实践
- 版本（Changelog） - [可选][文件] 版本说明
- 反馈（Feedback） - [可选][文件] 反馈方式

下面是两个真实范例，可参考。

Redux 手册
Atom 手册

# 6.2. 文件名

文档的文件名不得含有空格。

文件名必须使用半角字符，不得使用全角字符。这也意味着，中文不能用于文件名。

反例： 名词解释.md

正例： glossary.md

文件名建议只使用小写字母，不使用大写字母。

反例：TroubleShooting.md

正例：troubleshooting.md

为了醒目，某些说明文件的文件名，可以使用大写字母，比如 README 、 LICENSE 。

文件名包含多个单词时，单词之间建议使用半角的连词线（ - ）分隔。

反例：advanced_usage.md

正例：advanced-usage.md

# 7. Emoji

在 markdown 文档中，普遍会使用 emoji，帮助理解内容。但是，如果滥用 emoji，可能会适得其反。

这里，将一些比较约定俗成的 emoji 表情使用场景列举一下：

💡 提示 - [推荐]
🔔 注意、警告 - [推荐]
⭕ 正确 - [推荐]
❌ 错误 - [推荐]
❓ 问题 - [推荐]
⛔ 禁止 - [推荐]
🚧 未完待续、有待补充 - [推荐]
📚 参考、参考资料 - [可选]
⌨ 源码 - [可选]

# 8. 参考

产品手册中文写作规范，by 华为
写作规范和格式规范，by DaoCloud
技术写作技巧在日汉翻译中的应用，by 刘方
简体中文规范指南，by lengoo
文档风格指南，by LeanCloud
豌豆荚文案风格指南，by 豌豆荚
中文文案排版指北，by sparanoid
中文排版需求，by W3C
为什么文件名要小写？, by 阮一峰

嵌入式编程技巧项目启动说明书

Mon, 01 Nov 2021 20:45:48 +0800

# <center><font size=12><b > 嵌入式编程技巧项目启动说明书 </b></font></center>

文档状态	文档标志	01 - 项目启动说明书.md	审核人
[√] 草稿	当前版本	v0.1	审核日期
[ ] 正式发布	作者	将狼才鲸	批准人
[ ] 正在修改	完成日期	2020-03-23	批准日期

版本 / 状态	作者	参与者	起止日期	修订说明	批准人

<center> 项目组成员 </center>

项目负责人	将狼才鲸
产品经理
项目经理
需求团队
设计团队
开发团队
测试团队
配置管理人员
质量保证人员

# 负一、项目简介

附加章节。本章是项目和产品初步说明和构想，最终的产品信息在后续的《产品定义说明书》中确定。

# -1.1 产品说明

功能：嵌入式实用示例代码展示
编辑 / 编译环境：Ubuntu Linux、Windows
运行环境：Ubuntu Linux、硬件仿真器：SkyEye/ARMulator/Softgun/RealBoard/QEMU/Protenus/Keil/RTSM、目标开发板
使用语言：C、C++、汇编等
控制：Console 控制台、Ncurses 基于文本的用户界面、QT、Web
接口：API、私有通讯协议
用途：展示嵌入式编程技巧、架构、模块
目标群体：入门嵌入式编程的人员、工作中查找技术实现的人员
要求：文档齐全、从易到难、有目录索引、模块独立不耦合、以实用为准

# -1.2 项目背景

因为UP主想自己从头到尾做一个项目。
一是记录自己的经验，方便以后工作中要用到时回来查看抄代码；
二是做出东西时能不断给自己成就感，打发晚上和周末漫长的时间；
三是如果能帮助到任何人也是很美好的一件事。

# 〇、项目流程

本章是附加章节，主要介绍一个项目的完整生命周期所需要的操作步骤，进行一下项目管理知识普及，实际的《项目启动说明书》从第一章开始。

# 0.1 项目启动阶段

项目启动由项目负责人或者启动过程组成员负责，项目启动的初始原因可能是负责人的灵感、负责人发现商机、产品更新迭代、竞争对手推出新品等等。
项目启动以项目启动会的召开为标志，在项目启动会召开之前需要准备以下材料：
输出文档：《项目启动说明书》
项目启动说明书中包含以下章节：

产品定义	需求计划	项目计划	人员配置	规章制度	风险预估
产品描述	调研计划	实施计划	项目负责人	项目管理	骨干人员流动
主要功能	调研问卷数据采集表	时间安排里程碑计划进度检查	产品经理	项目开发流程	团队氛围涣散
产品特色	调研记录	开发计划	项目经理	需求变更流程	进度延后
实施的意义	调研总结	资源预算成本计划	客户代表	版本控制章程	质量不达标
提交产物完成标记成果展望	系统分析	交付物计划	开发团队	保密制度	成本超支
约束条件支持的操作系统接口	可行性分析	沟通计划	测试团队	Bug 追踪流程	需求频繁变更
目标用户	竞品分析	质量控制计划	人员与职责	奖惩制度	目标及需求不明确
项目范围使用场景项目目标	商业价值	风险控制计划	组织结构		人员技能不足
项目背景	规格说明书	用户培训计划			市场萎缩
	成本要求				竞品增加

《项目启动说明书》

# 0.2 需求分析阶段

需求定义	竞品分析	市场调研	商业价值
功能子功能接口	公司背景	用户需求	项目价值
性能需求	用户数量	功能满意度	社会价值
可靠性需求	融资进展	功能接受度	用户价值
响应时间	特色功能	用户访谈
可扩展性	交互分析	利润导向
数据流图	用户评论	市场的问题
运行环境设计约束		市场的机会

《需求规格说明书》

# 0.3 概要设计阶段

系统架构	系统框图	架构
系统分析评审	系统流程图	顺序执行
概要设计说明书	开发系统	时间片切分
系统框架	目标系统	模块路由
稳定性		状态机
远程升级
安全性

《概要设计说明书》

# 0.4 详细设计阶段

详细设计文档	模块设计文档	单元测试文档
接口说明	函数功能接口	单元测试用例
API 接口函数说明	数据结构
通讯协议	全局变量
模块划分	文件读写
	错误输出模块

# 0.5 开发

系统原型、《编码规范》、代码管理规范、设计文档规范、交叉审核
分支管理、bug追踪、进度报告、版本号说明、CICD自动测试自动发布
系统分析文档

# 0.6 测试

《测试大纲》、测试计划、测试报告、问题清单、测试用例、产品集成测试
功能测试、压力测试、性能测试（提供性能参数）、抗干扰测试

# 0.7 交付 / 发布

用户说明、产品说明、项目总结、系统管理手册、安装配置手册、用户操作手册
用户培训计划、用户培训教程、系统上线报告、问题清单、项目验收报告、项目总结报告

# 0.8 售后与升级

用户体验调查、缺陷追踪

# 一、产品定义

==== 产品定义
一款展示嵌入式软件编程规范和技巧的源码库，可以在 Ubuntu 主机 / 硬件仿真器 / 实际开发板运行的软件系统，包含从简答单个训练用例到复杂软件系统的全套开发文档和源码，可读、可仿真、可运行。
逐步展示嵌入式软件 C 语言编程技巧：编程规范、注释规范、源文件管理、编译控制、版本命名、模块编写、驱动编写、应用编写、协议设计、网络编程、系统架构、模块设计、接口设计、人机交互、单元测试、算法优化、版本管理……

# 二、需求计划

==== 需求定义
一键确定主机性能确定主机环境确定编译工具确定测试环境（字符串菜单 qt web 文档在线查看） boot 选择区分有无 MMU

# 三、项目计划

==== 一些准则
要做的功能都是自己会做的，不需要太多学习
作出的东西都是有实际作用复杂的工程不替换一开始简单的功能，让人可以从最简单的开始慢慢接触
成品至少包含嵌入式中每一个方向。命名：模块名 + 系统名 + 芯片名 + 板级，所有设备上线探测，
代码有不加宏定义的版本，有加宏定义的版本
首先要是自己都会的，然后所有的东西都有实际用处，其次要循序渐进各步骤的代码都有，搜索 arm 模拟器，51protenus 单片机模拟器，确定使用仿真平台。目的是使用所有能仿真的外设，做网络通讯产品控制别人的传感器执行器。有多少玩就能相互控制多少人的设备。所有的例程都应用在仿真器中，但是也要保证能稍作修改就能跑到实际硬件中。目的是所有跑起来的程序都有相互通信的可能。可以连一个网站，可以查找哪些设备在线，专门用来受理不同主机的网络请求，使两台设备相互通讯。第一阶段把编程规范说清楚就行。出一个 git 使用教程，实例解说。
（画出组织结构图）

# 四、人员配置

# 五、规章制度

==== 沟通方案
微信群、邮件、gitee 留言、钉钉工时打卡
==== 项目管理：禅道
代码管理：gitee
==== 项目开发流程
文档、表格、流程图、时序图、甘特图：markdown 思维导图（脑图）：XMind
瀑布开发、敏捷开发
部门管理与项目管理分开
源码文件夹划分

# 六、风险预估

《常用shell命令整理之操作文件和目录3》

Tue, 12 Oct 2021 10:45:48 +0800

# 1. hostname - 查看主机名

hostname 命令用于查看系统的主机名，或是修改系统的主机名。

hostname 的常用命令如下：

	# 显示系统的当前主机名
	hostname

	# 修改你系统的主机名
	hostname blinkfox-system

	# 使用 -F 选项，从指定的文件中读取主机名
	hostname -F /root/hostname.txt

# 2. uptime - 查看系统运行时间

uptime 命令用于打印系统的运行时间等信息。使用如下：

uptime

# 3. w、who - 列出登录的用户

w 命令用于显示登录用户及他们当前运行的进程。输入的内容格式如下：

	w

	# 打印如下
	22:42 up 18 days, 1 hr, 2 users, load averages: 1.23 1.79 1.75
	USER TTY FROM LOGIN@ IDLE WHAT
	blinkfox console - 日19 6days -
	blinkfox s000 - 五23 - w

who 命令有与 w 命令类似的用途，但它的功能比 w 命令更强大一些。语法格式如下：

who [OPTION]... [FILE | ARG1 ARG2]

who 常用命令如下：

	# 显示当前登录的所有用户信息
	who

	# 显示系统的启动时间
	who -b

	# 显示系统登录进程
	who -l

	# 显示与当前标准输入关联的用户信息
	who -m

	# 显示系统的运行级别
	who -r

	# 显示所有登录用户的用户名和登录用户数
	who -q

# 4. uname - 查看系统信息

uname 命令用于打印内核名称和版本、主机名等系统信息。命令的语法如下所示：

uname [OPTION]...

常用使用方式如下：

	# 只打印内核的名称
	uname

	# 使用 -n 选项，只打印系统的主机名
	uname -n

	# 使用 -r 选项，打印内核版本信息
	uname -r

	# 使用 -m 选项，打印系统的硬件名称
	uname -m

	# 使用 -p 选项，打印系统的处理器类型信息
	uname -p

	# 使用 -i 选项，打印系统的硬件平台信息
	uname -i

	# 使用 -a 选项，打印上述所有示例中的信息
	uname -a

# 5. date - 显示和设置系统日期和时间

date 命令用于以多种格式显示日期和时间，或设置系统的日期和时间。 date 命令的语法如下所示：

	date [OPTION]... [+FORMAT]
	date [-u\|--utc\|--universal] [MMDDhhmm[[CC]YY][.ss]]

常用使用命令如下：

	# 以默认格式显示系统的当前日期时间
	date

	# 格式化当前日期
	date +"%Y-%m-%d"

	# 格式化输出昨天的日期
	date -d "1 day ago" +"%Y-%m-%d"

	# 2 秒后格式化输出
	date -d "2 second" +"%Y-%m-%d %H:%M.%S"

	# 普通格式化转出
	date -d "2009-12-12" +"%Y/%m/%d %H:%M.%S"

	# apache 格式转换
	date -d "Dec 5, 2009 12:00:37 AM" +"%Y-%m-%d %H:%M.%S"

	# 日期加减操作
	date +%Y%m%d #显示前天年月日
	date -d "+1 day" +%Y%m%d #显示前一天的日期
	date -d "-1 day" +%Y%m%d #显示后一天的日期
	date -d "-1 month" +%Y%m%d #显示上一月的日期
	date -d "+1 month" +%Y%m%d #显示下一月的日期
	date -d "-1 year" +%Y%m%d #显示前一年的日期
	date -d "+1 year" +%Y%m%d #显示下一年的日期

	# 设定时间
	date -s # 设置当前时间，只有 root 权限才能设置，其他只能查看
	date -s 20160816 # 设置成 20160816，这样会把具体时间设置成空 00:00:00
	date -s 01:01:01 # 设置具体时间，不会对日期做更改
	date -s "01:01:01 2012-05-23" # 这样可以设置全部时间
	date -s "01:01:01 20120523" # 这样可以设置全部时间
	date -s "2012-05-23 01:01:01" # 这样可以设置全部时间
	date -s "20120523 01:01:01" # 这样可以设置全部时间

# 6. id - 显示用户属性

id 命令用于打印输出用户 uid 、 gid 、用户名和组名等用户身份信息。 id 命令的语法如下所示：

id [OPTION]... [USERNAME]

常见使用命令如下：

	# 输出当前用户的 uid、用户名、gid、组名及用户属于的群组信息
	id

	# 使用 -u 选项，输出用户的 uid
	id -u

	#-u 选项和 -n 选项结合使用，输出账户的用户名
	id -un

	# 使用 -g 选项，输出帐号当前起作用的 gid
	id -g

	# -g 与 -n 选项结合使用，输出帐号当前起作用的用户组名
	id -gn

	# 使用 -G 选项，输出帐号所属的所有群组 id
	id -G root

	# -G 与 -n 选项结合使用，输出账号所属的所有群组的名称
	id -Gn root

《常用shell命令整理之操作文件和目录2》

Tue, 12 Oct 2021 10:45:48 +0800

# 1. ls - 列出文件名和目录

ls 命令是 Linux 中最常用的命令之一，其作用就是列出文件名和目录。在命令行提示符下，直接输入 ls 命令，不带任何选项，将列出当前目录下所有文件和目录，但不会显示详细的信息，比如，文件类型、大小、修改日期和时间、权限等。

以下便是 ls 命令及其选项的作用说明：

	# 仅列出当前目录下所有文件和目录
	ls

	# 每行显示一条记录，每条记录包括文件类型、大小、修改日期和时间、权限等
	ls -l

	# 将文件大小显示符合人类阅读习惯的格式
	ls -lh

	# 将使用不同的特殊字符归类不同的文件类型
	ls -F

	# 以长列表格式列出某个目录的信息
	ls -ld /var/log

	# 将递归地列出子目录的内容
	ls -R /etc/sysconfig/

	# 以长列表格式按文件或目录的修改时间倒序地列出文件和目录
	ls -ltr

	# 以长列表格式按文件大小顺序列出文件和目录
	ls -ls

	# 列出包括隐藏文件或目录在内的所有文件和目录，包括 “.”（当前目录）和 “..”（父目录）
	ls -a
	B
	# 列出包括隐藏文件或目录在内的所有文件和目录，不包括 “.”（当前目录）和 “..”（父目录）
	ls -A

	输出的内容类似于-l选项，指示显示uid和gid，替代显示所有者和用户组
	ls -n

# 2. cat - 连接显示文件内容

cat 命令也是 Linux 系统中最常用的命令之一。 cat 命令让我们可以看看文件的内容、连接文件、创建一个或多个文件和重定向输出到终端或文件。

cat 命令的语法如下所示：

cat [OPTION] [FILE]...

cat 常用命令如下：

	# 使用 cat 命令查看文件 /etc/group 的内容
	cat /etc/group

	# 显示多个文件的内容
	cat /etc/redhat-release /etc/issue

	# -n 选项，可以显示文件内容的行号
	cat -n /etc/fstab

	# -b 选项和 -n 选项类似，但只标识非空白行的行号
	cat -b /etc/fstab

	# -e 选项，将在每一行的结尾显示 “$” 字符
	cat -e /etc/fstab

当你只输入 cat 命令，而没有任何参数时，它只是接收标准输入的内容并在标准输出中显示。所以你在输入一行内容并回车后，会在接下来的一行显示相同的内容。你也可以重定向标准输出到一个新文件。

# 3.less、more - 分屏显示文件

more 命令在你使用小的 xterm 窗口时，或是想不使用文本编辑器而只是简单地阅读一个文件时是很有用的。more 命令是一个用于一次翻阅一整屏文件的过滤器。

	# 查看一个文件，自动清空屏幕并显示文件开头部分
	more /etc/inittab

	# 指定一次显示 num 行
	more -num /etc/inittab

与 more 命令相比，我个人更喜欢 less 命令来查看文件。 less 命令与 more 命令类似，但 less 命令向前和向后翻页都支持，而且 less 命令不需要在查看前加载整个文件，即 less 命令查看文件更快速。

less 常用命令参数如下：

	-b <缓冲区大小> 设置缓冲区的大小
	-e 当文件显示结束后，自动离开
	-f 强迫打开特殊文件，例如外围设备代号、目录和二进制文件
	-g 只标志最后搜索的关键词
	-i 忽略搜索时的大小写
	-m 显示类似more命令的百分比
	-N 显示每行的行号
	-o <文件名> 将less 输出的内容在指定文件中保存起来
	-Q 不使用警告音
	-s 显示连续空行为一行
	-S 行过长时间将超出部分舍弃
	-x <数字> 将“tab”键显示为规定的数字空格
	/字符串：向下搜索“字符串”的功能
	?字符串：向上搜索“字符串”的功能
	n：重复前一个搜索（与 / 或 ? 有关）
	N：反向重复前一个搜索（与 / 或 ? 有关）
	b 向后翻一页
	d 向后翻半页
	h 显示帮助界面
	Q 退出less 命令
	u 向前滚动半页
	y 向前滚动一行
	空格键滚动一行
	回车键滚动一页
	[pagedown]：向下翻动一页
	[pageup]：向上翻动一页

# 4.head - 显示文件头部

head 命令用于打印指定输入的开头部分内容。默认情况下，打印每个指定输入的前 10 行内容。

使用 -n 选项可以指定打印文件的前 N 行：

	# 指定打印文件的前 5 行
	head -n 5 /etc/inittab
	（或）head -5 /etc/inittab

	# 打印文件的前 N 个字节的数据
	head -c 10 /etc/inittab

# 5.tail - 显示文件尾部

tail 命令和 head 命令相反，它打印指定输入的结尾部分的内容。默认情况下，它打印指定输入的最后 10 行内容。

使用 -n 选项可以指定打印文件的最后 N 行：

	# 指定打印文件的后 10 行
	tail -n 10 /etc/inittab
	tail -10 /etc/inittab

	# 即时打印文件中新写入的行
	tail -f /var/log/messages

	# --retry 选项表示持续尝试打开某个文件，当你想打开一个稍后才会创建或即使不可用的文件
	tail -f /tmp/debug.log --retry

# 6.file - 查看文件类型

file 命令用于接收一个文件作为参数并执行某些测试，已确定正确的文件类型。

	# 查看文件类型
	file /etc/inittab

	# 可以 MIME 类型的格式显示文件类型的信息
	file -i /etc/inittab

	# 使用 - N 选项，输出的队列可以以在文件名之后无空白填充的形式显示
	file -N *

# 7.wc - 查看文件统计信息

wc 命令用于查看文件的行数、单词数和字符数等信息。语法类似如下所示：

	wc filename
	X Y Z /etc/inittab

其中 X 表示行数，Y 表示单词数，Z 表示字节数，filename 表示文件名。

	# -l 选项，可以只统计文件的行数信息
	wc -l /etc/inittab

	# -w 选项，可以只统计文件的单词数信息
	wc -w /etc/inittab

	# -c 选项，可以只统计文件的字节数信息
	wc -c /etc/inittab

	# -L 选项，可以只统计文件中最长的行的长度
	wc -L /etc/inittab

# 8.find - 查找文件或目录

find 命令用于根据你指定的参数搜索和定位文件和目录的列表。 find 命令可以在多种情况下使用，比如你可以通过权限、用户、用户组、文件类型、日期、大小和其他可能的条件来查找文件。

find 命令常用使用和说明如下：

	# 查找指定目录下的某个文件
	find /etc/ -name inittab

	# 在当前目录下查找名称为 inittab 的文件
	find . -name inittab

	# 在当前目录下，文件不区分大小写是 example 的所有文件
	find . -iname example

	# 找出当前目录下所有以 sh 结尾的文件
	find . -type f -name "*.sh"

	# 找出当前目录下，文件权限是 777 的所有文件
	find . -type f -perm 777

	# 找出当前目录下，文件权限不是 777 的所有文件
	find . -type f ! -perm 777

	# 找出当前目录下所有只读文件
	find . -type f ! -perm /a+w

	# 找出你帐号主目录下的所有可执行文件
	find ~ -type f -perm /a+w

	# 找出 /tmp 目录下的.log 文件并将其删除：
	find /tmp/ -type f -name "*.log" -exec rm -f {} \;

	# 找出当前目录下的所有空文件
	find . -type f -empty

	# 找出当前目录下的所有空目录
	find . -type d -empty

	# 找出 /tmp 目录下的所有隐藏文件
	find /tmp/ -type f -name ".*"

	# 找出 /tmp 目录下，所有者是 root 的文件和目录
	find /tmp/ -user root

	# 找出 /tmp 目录下，用户组是 developer 的文件和目录
	find /tmp/ -group root

	# 找出你账号的主目录下，3 天前修改的文件
	find ~ -type f -mtime 3

	# 找出你账号的主目录下，30 天以前修改的所有文件
	find ~ -type f -mtime +30

	# 找出你账号的主目录下，3 天以内修改的所有文件
	find ~ -type f -mtime -3

	# 找出你账号的主目录下，30 天以前，60 天以内修改的所有文件
	find ~ -type f -mtime +30 -mtime -60

	# 找出 /etc 目录下，一小时以内变更过的文件
	find /etc -type f -cmin -60

	# 找出 /etc 目录下，一小时以内访问过的文件
	find /etc -type f -amin -60

	# 找出你账号主目录下，大小是 50MB 的所有文件
	find ~ -type f -size 50MB

	# 找出你账号主目录下，大于 50MB 小于 100MB 的所有文件
	find ~ -type f -size +50MB -size -100MB

	# 找出你账号主目录下，大于 100MB 的文件并将其删除
	find ~ -type f -size +100MB -exec rm -rf {} \;

《常用shell命令整理之操作文件和目录4》

Tue, 12 Oct 2021 10:45:48 +0800

# 1. sort - 文本排序

sort 命令用于将文本文件的行排序。默认情况下， sort 命令是按照字符串的字母顺序排序。

sort 的常用命令如下：

	# 将文本内容按字母顺序排序
	sort example.txt

	# 使用 -u 选项，移除所有重复行后排序
	sort -u example.txt

	# 使用 -n 选项，将令数字按数值的大小排序
	sort -n example.txt

	# 使用 -r 选项，以倒序方式排序
	sort -n -r example.txt

	# 同时将 file1、file2 的内容排序
	sort file1 file2

# 2.uniq - 文本去重

uniq 命令用于移除或发现文件中重复的条目。

	# 它将移除文件中重复的行并显示单一行
	uniq example.txt

	# 可以统计重复行出现的次数
	uniq -c example.txt

	# 使用 -d 选项，只显示文件中有重复的行并只显示一次
	uniq -d example.txt

	# 使用 -D 选项，显示文件中所有重复的行
	uniq -D example.txt

	# 使用 -u 选项，只显示文件中不重复的行
	uniq -u example.txt

	# 使用 -w 选项，限制 uniq 命令只比较每行的前 3 个字符是否重复
	uniq -w 3 example.txt

	# 使用 -s 选项，避免 uniq 命令比较每行的前 3 个字符，只比较后面的字符是否重复
	uniq -s 3 example.txt

	# 使用 -f 选项，避免 uniq 命令比较第一列的内容，只比较后面的字符是否重复
	uniq -f 1 example.txt

# 3.tr - 替换或删除字符

tr 命令主要用于删除文件中控制字符或进行字符转换。使用 tr 时要转换两个字符串：字符串 1 用于查询，字符串 2 用于处理各种转换。 tr 刚执行时，字符串 1 中的字符被映射到字符串 2 中的字符，然后转换操作开始。

tr 命令的语法如下所示：

tr [OPTION]... SET1 [SET2]

常用命令示例：

	# 若要将大括号转换为小括号
	tr '{}' '()' < textfile > newfile

	# 若要将大括号转换成方括号
	tr '{}' '\[]' < textfile > newfile

	# 若要将小写字符转换成大写，请输入：
	tr 'a-z' 'A-Z' < textfile > newfile

	# 若要创建一个文件中的单词列表
	tr -cs '[:lower:][:upper:]' '[\n*]' < textfile > newfile

	# 若要从某个文件中删除所有空字符
	tr -d '\0' < textfile > newfile

	# 若要用单独的换行替换每一序列的一个或多个换行，请输入：
	tr -s '\n' < textfile > newfile

	# 要以单个 “#” 字符替换 <space> 字符类中的每个字符序列
	tr -s '[:space:]' '[#*]'

# 4.grep - 查找字符串

grep 命令用于搜索文本或指定的文件中与指定的字符串或模式相匹配的行。默认情况下， grep 命令只显示匹配的行。

grep 命令的语法如下所示：

	grep [OPTION]... PATTERN [FILE]...
	grep [OPTION]... [-e PATTERN \| -f FILE] [FILE]...

	# `grep` 命令查找文件 /etc/passwd 中帐号 blinkfox 的信息
	grep blinkfox /etc/passwd

	# 使用 -i 选项，强制 grep 命令忽略搜索关键字的大小写
	grep -i blinkfox /etc/passwd

	# 使用 -r 选项，可以递归搜索指定目录下的所有文件
	grep -r blinkfox /etc/

	# 使用 -w 选项，只匹配包含指定单词的行
	grep -w blinkfox /etc/

	# 使用 -c 选项，报告文件或文本中模式被匹配的次数
	grep -c blinkfox /etc/passwd

	# 使用 -n 选项，显示每一个匹配的行的行号
	grep -n blinkfox /etc/passwd

	# 使用 -v 选项，可以输出除匹配指定模式的行以外的其他所有行
	grep -v blinkfox /etc/passwd

	# 使用 --color 选项，在输出中将匹配的字符串以彩色的形式标出
	grep --color blinkfox /etc/passwd

# 5.diff - 比较两个文件

diff 命令用于比较两个文件，并找出它们之间的不同。 diff 命令的语法如下所示：

diff [OPTION]... from-file to-file

常用使用方式如下：

	# 比较两个文件
	diff nsswitch.conf nsswitch.conf.org

	# 使用 -w 选项，比较时忽略空格
	diff -w nsswitch.conf nsswitch.conf.org

	# 使用 -y 选项，以并排的格式输出两个文件的比较结果
	diff -y nsswitch.conf nsswitch.conf.org

	使用 -c 选项，以上下对比的格式输出两个文件的比较结果
	diff -c nsswitch.conf nsswitch.conf.org

《常用shell命令整理之操作文件和目录1》

Sun, 10 Oct 2021 10:45:48 +0800

# 1. touch - 创建文件

touch 命令就可用于创建、变更和修改文件的时间戳。它是 Linux 操作系统的标准程序。 touch 命令又如下选项：

	-a: 只改变访问时间
	-c: 不创建任何文件
	-m: 只改变修改时间
	-r: 使用指定文件的时间替代当前时间
	-t: 使用 [[CC]YY]MMDDhhmm[.ss] 替代当前时间

touch 命令的常见用法如下：

	# 创建一个名为 effyl 的新空文件
	touch effyl

	# 同时创建名称分别为 effyl myeffyl lueffyl 的三个文件
	touch effyl myeffyl lueffyl

	# 使用 -a 选项，可以改变或更新文件的最新访问时间，如果文件 effyl 不存在，则新创建一个
	touch -a effyl

	# 使用 -c 选项，可以避免创建一个新文件，并用当前时间更新文件的时间戳
	touch -c effyl

	# 使用 -m 选项，可以只改变文件的修改时间，而访问时间不变
	touch -m effyl

	# 使用 -c 和 -t 选项，来明确设置文件的时间
	touch -c -t YYMMDDHHMM filename

	# 如果想使用文件 myeffyl 的时间戳更新文件 effyl 的时间戳，可以使用 -r 选项
	touch -r myeffyl effyl

# 2.mkdir - 创建目录

mkdir 命令用于创建一个新目录。最基本的 mkdir 命令的使用方法如下所示：

	# 在当前目录下创建一个给定的目录名
	mkdir <dirname>

	# 在 backup 中的相对路径创建一个名为 old 的目录
	mkdir backup/old

	# 在 backup 中的绝对路径中创建一个名为 old 的目录
	mkdir /home/blinkfox/backup/old

	# 使用 -p 选项，会自动创建所有还不存在的父目录
	mkdir -p backup/old

	# 使用 -m 选项，可以设置将要创建目录的权限
	# 如：创建一个任何人都有读写访问权限的目录
	mkdir -p -m 777 backup/old

# 3.cp - 复制文件或目录

cp 命令用于将文件从一个地方复制到另一个地方。原来的文件保持不变，新文件可能保持原名或用一个不同的名字。

使用 cp 命令复制文件和目录的语法有以下几种：

	# 复制源文件到目标文件
	cp [OPTION] SOURCE DEST

	# 复制一个或多个源文件到一个目录
	cp [OPTION] SOURCE... DIRECTORY

	# 同上
	cp [OPTION] -t DIRECTORY SOURCE...

常用使用示例如下：

	# 在当前目录下，创建一个文件 file.txt 的副本，取名为 newfile.txt
	cp file.txt newfile.txt

	# 复制当前目录下的 file.txt 文件到 /tmp 目录下
	cp file.txt /tmp

	# 复制当前目录下的所有文件到 /tmp 目录下
	cp * /tmp

	# 使用 -p 选项，可以使复制一个文件到新文件时，保留源文件的所有者、权限等信息
	cp -p filename /path/to/new/location/myfile

	# 使用 -R 或 -r 选项，恶意递归地复制一个目录
	# 即将一个目录及其下的所有文件和子目录都复制到另一个目录
	cp -R * /home/blinkfox/backup

# 4.ln - 链接文件或目录

ln 命令用于创建软链接或硬链接。使用 -s 选项，可以创建一个软链接：

	# 在目录 lib 下创建一个软链接 library.so，链接到 /home/blinkfox/src/library.so
	ln -s /home/blinkfox/src/library.so /home/blinkfox/lib

	# 创建目录的软链接
	ln -s /home/blinkfox/src source

# 5. mv - 移动文件或目录

mv 命令用于将文件和目录从一个位置移到另外一个位置。除了移动文件， mv 命令还可用于修改文件或目录的名字。

mv 命令的基本语法如下所示：

mv SOURCE... DIRECTORY

常用命令如下：

	# 将当前目录下的文件 source.txt 移到目录 /tmp 下
	mv source.txt /tmp

	# 将目录 dir1、dir2 移到目录 dir_dist 下
	mv dir1 dir2 dir_dist

	# 将当前目录下的 old.txt 文件更名为 new.txt
	mv old.txt new.txt

	# 使用 -i 选项，在重写覆盖目标文件或目录之前给出提示信息
	mv -i old.txt new.txt

	# 将当前目录下的所有文件移动到目录 /tmp 下
	mv * /tmp/

	# 使用 -i 选项，从 dir1 中移动那些在目标目录中不存在的文件到目标目录
	mv -u dir1/* dir2/

# 6.rm - 删除文件或目录

rm 命令用于删除指定的文件和目录。其语法如下所示：

rm [OPTIONS]... FILE...

rm 的常用命令如下：

	# 删除当前目录下的文件 file1.txt、file2.txt、file3.txt
	rm file1.txt file2.txt file3.txt

	# 删除当前目录下的所有文件
	rm *

	# 删除你当前帐号主目录下的 temp 目录中的所有文件
	rm ~/temp/*

	# 使用 -i 选项，可以在删除每个文件或目录前提示用户确认
	rm -i *

	# 删除当前目录下所有以 ".doc" 结尾的文件
	rm *.doc

	# 删除当前目录下所有文件名中包含 "movie" 字符串的文件
	rm movie

	# 删除当前目录下所有以 "a" 开头的文件
	rm a*

	# 删除当前目录下整个文件名（包括扩展名）只有 3 个字符的所有文件
	rm ???

	# 删除当前目录下文件扩展名有两个字符的所有文件
	rm *.??

	# 删除当前目录下文件名中含有字母 a 或 b 或 c 的所有文件
	rm [abc]

	# 删除当前目录下文件名中包含 0~9 的所有文件
	rm [0-9]

	# 删除当前目录下文件扩展名是字母 c 或 h 的所有文件
	rm *.[ch]

	# 删除 /tmp 目录下的所有文件及其子目录
	rm -rf /tmp/*

-f 删除前不提示用户确认，并忽略不存在的文件

-r 递归地删除目录及其下的内容

《软件工程之美》笔记

Mon, 12 Jul 2021 13:20:31 +0800

# 《软件工程之美》笔记

# 到底应该怎样理解软件工程？

软件产品危机：软件产品质量低劣、软件维护工作量大、成本不断上升、进度不可控、程序人员无限度地增加。

软件工程，它是为研究和克服软件危机而生。

软件工程的本质：用工程化方法去规范软件开发，让项目可以按时完成、成本可控、质量有保证。

软件工程的核心：是围绕软件项目开发，对开发过程的组织，对方法的运用，对工具的使用。

软件工程 = 过程 + 方法 + 工具。

# 工程思维：把每件事都当作一个项目来推进

有目的、有计划、有步骤地解决问题的方法就是工程方法。

工程方法通常会分成六个阶段：想法、概念、计划、设计、开发和发布。

** 想法：** 想法阶段通常是想要解决问题。最开始问题通常是模糊的，所以需要清晰地定义好问题，研究其可行性，检查是否有可行的解决方案。
** 概念：** 概念阶段就是用图纸、草图、模型等方式，提出一些概念性的解决方案。这些方案可能有多个，最终会确定一个解决方案。
** 计划：** 计划阶段是关于如何实施的计划，通常会包含人员、任务、任务持续时间、任务的依赖关系，以及完成项目所需要的预算。
** 设计：** 设计阶段就是要针对产品需求，将解决方案进一步细化，设计整体架构和划分功能模块，作为分工合作和开发实施的一个依据和参考。
** 开发：** 开发阶段就是根据设计方案，将解决方案构建实施。开发阶段通常是一个迭代的过程，这个阶段通常会有构建、测试、调试和重新设计的迭代。
** 发布：** 将最终结果包括文档发布。

# 瀑布模型：像工厂流水线一样把软件开发分层化

瀑布模型把整个项目过程分成了六个主要阶段：

问题的定义及规划：这个阶段是需求方和开发方共同确定软件开发目标，同时还要做可行性研究，以确定项目可行。这个阶段会产生需求文档和可行性研究报告。
需求分析：对需求方提出的所有需求，进行详细的分析。这个阶段一般需要和客户反复确认，以保证能充分理解客户需求。最终会形成需求分析文档。
软件设计：根据需求分析的结果，对整个软件系统进行抽象和设计，如系统框架设计，数据库设计等等。最后会形成架构设计文档。
程序编码：将架构设计和界面设计的结果转换成计算机能运行的程序代码。
软件测试：在编码完成后，对可运行的结果对照需求分析文档进行严密的测试。如果测试发现问题，需要修复。最终测试完成后，形成测试报告。
运行维护：在软件开发完成，正式运行投入使用。后续需要继续维护，修复错误和增加功能。交付时需要提供使用说明文档。

# 瀑布模型之外，还有哪些开发模型？

# 快速原型模型

快速原型模型，就是为了要解决客户的需求不明确和需求多变的问题。

先迅速建造一个可以运行的软件原型，然后收集用户反馈，再反复修改确认，使开发出的软件能真正反映用户需求，这种开发模型就叫快速原型模型，也叫原型模型。

原型模型因为能快速修改，所以能快速对用户的反馈和变更作出响应，同时原型模型注重和客户的沟通，所以最终开发出来的软件能够真正反映用户的需求。

但这种快速原型开发往往是以牺牲质量为代价的。

# 增量模型

增量模型是把待开发的软件系统模块化，然后在每个小模块的开发过程中，应用一个小瀑布模型，对这个模块进行需求分析、设计、编码和测试。相对瀑布模型而言，增量模型周期更短，不需要一次性把整个软件产品交付给客户，而是分批次交付。

因为增量模型的根基是模块化，所以，** 如果系统不能模块化，那么将很难采用增量模型的模式来开发。** 另外，对模块的划分很抽象，这本身对于系统架构的水平是要求很高的。

基于这样的特点，增量模型主要适用于：需求比较清楚，能模块化的软件系统，并且可以按模块分批次交付。

# 迭代模型

迭代模型每次只设计和实现产品的一部分，然后逐步完成更多功能。每次设计和实现一个阶段叫做一个迭代。

在迭代模型中，整个项目被拆分成一系列小的迭代。通常一个迭代的时间都是固定的，不会太长，例如 2-4 周。每次迭代只实现一部分功能，做能在这个周期内完成的功能。

在一个迭代中都会包括需求分析、设计、实现和测试，类似于一个小瀑布模型。迭代结束时要完成一个可以运行的交付版本。

增量模型是按照功能模块来拆分；而迭代模型则是按照时间来拆分，看单位时间内能完成多少功能。

# V 模型

V 模型适合外包项目。V 模型本质上还是瀑布模型，只不过它是更重视对每个阶段验收测试的过程模型。

针对从需求定义一直到编码阶段，每个阶段都有对应的测试验收。

# 螺旋模型

如果你现在要做一个风险很高的项目，客户可能随时不给你钱了。这种情况下，如果采用传统瀑布模型，无疑风险很高，可能做完的时候才发现客户给不了钱，损失就很大了！

这种情况，基于增量模型或者迭代模型进行开发，就可以有效降低风险。你需要注意的是，在每次交付的时候，要同时做一个风险评估，如果风险过大就不继续后续开发了，及时止损。

这种强调风险，以风险驱动的方式完善项目的开发模型就是螺旋模型。

# 敏捷开发到底是想解决什么问题？

敏捷开发是一套价值观和原则。

瀑布模型面向的是过程，而敏捷开发面向的是人。

# 大厂都在用哪些敏捷方法？（上）

# 一切工作任务围绕 Ticket 开展

每一个任务的状态都可以被跟踪起来：什么时候开始做的，谁在做，做完没有。
整个团队在做什么一目了然。
Ticket 和敏捷开发中的 Backlog（任务清单）正好结合起来，通过 Ticket 可以收集管理整个项目的 Backlog 和当前 Sprint（迭代）的 Backlog。

# 基于 Git 和 CI 的开发流程

Git 本来只是源代码管理工具，但是其强大的分支管理和灵活的权限控制，结合一定的开发流程，却可以帮助你很好的控制代码质量。

# 站立会议

每个人轮流介绍一下，昨天干了什么事情，今天计划做什么事情，工作上有没有障碍无法推进。有问题，记录到 “问题停车场”。
检查最近的 Ticket，甄别一下优先级。有需要讨论的先收集到问题停车场。
针对未讨论的问题展开讨论，能在会议时间内解决的问题，就马上解决，不能解决的会后再私下讨论或者再组织会议。

# 大厂都在用哪些敏捷方法？（下）

在分工上：

产品经理：写需求设计文档，将需求整理成 Ticket，随时和项目成员沟通确认需求；
开发人员：每天从看板上按照优先级从高到低领取 Ticket，完成日常开发任务；
测试人员：测试已经部署到测试环境的程序，如果发现 Bug，提交 Ticket；
项目经理：保障日常工作流程正常执行，让团队成员可以专注工作，提供必要的帮助，解决问题。

如何完成需求和修复 Bug？

日常工作，是围绕 Ticket 来开展的。所有的需求、Bug、任务都作为 Ticket 提交到项目的 Backlog，每个 Sprint 的任务都以看板的形式展现出来。

每个人手头事情忙完后，就可以去看板上的 “To Do” 栏，按照优先级从高到低选取新的 Ticket。选取后移动到 “In Progress” 栏。

每周一部署生产环境

# 参考资料

软件工程之美

《软件工程》笔记

Mon, 12 Jul 2021 13:20:31 +0800

# 《软件工程之美》笔记

# 到底应该怎样理解软件工程？

软件产品危机：软件产品质量低劣、软件维护工作量大、成本不断上升、进度不可控、程序人员无限度地增加。

软件工程，它是为研究和克服软件危机而生。

软件工程的本质：用工程化方法去规范软件开发，让项目可以按时完成、成本可控、质量有保证。

软件工程的核心：是围绕软件项目开发，对开发过程的组织，对方法的运用，对工具的使用。

软件工程 = 过程 + 方法 + 工具。

# 工程思维：把每件事都当作一个项目来推进

有目的、有计划、有步骤地解决问题的方法就是工程方法。

工程方法通常会分成六个阶段：想法、概念、计划、设计、开发和发布。

** 想法：** 想法阶段通常是想要解决问题。最开始问题通常是模糊的，所以需要清晰地定义好问题，研究其可行性，检查是否有可行的解决方案。
** 概念：** 概念阶段就是用图纸、草图、模型等方式，提出一些概念性的解决方案。这些方案可能有多个，最终会确定一个解决方案。
** 计划：** 计划阶段是关于如何实施的计划，通常会包含人员、任务、任务持续时间、任务的依赖关系，以及完成项目所需要的预算。
** 设计：** 设计阶段就是要针对产品需求，将解决方案进一步细化，设计整体架构和划分功能模块，作为分工合作和开发实施的一个依据和参考。
** 开发：** 开发阶段就是根据设计方案，将解决方案构建实施。开发阶段通常是一个迭代的过程，这个阶段通常会有构建、测试、调试和重新设计的迭代。
** 发布：** 将最终结果包括文档发布。

# 瀑布模型：像工厂流水线一样把软件开发分层化

瀑布模型把整个项目过程分成了六个主要阶段：

问题的定义及规划：这个阶段是需求方和开发方共同确定软件开发目标，同时还要做可行性研究，以确定项目可行。这个阶段会产生需求文档和可行性研究报告。
需求分析：对需求方提出的所有需求，进行详细的分析。这个阶段一般需要和客户反复确认，以保证能充分理解客户需求。最终会形成需求分析文档。
软件设计：根据需求分析的结果，对整个软件系统进行抽象和设计，如系统框架设计，数据库设计等等。最后会形成架构设计文档。
程序编码：将架构设计和界面设计的结果转换成计算机能运行的程序代码。
软件测试：在编码完成后，对可运行的结果对照需求分析文档进行严密的测试。如果测试发现问题，需要修复。最终测试完成后，形成测试报告。
运行维护：在软件开发完成，正式运行投入使用。后续需要继续维护，修复错误和增加功能。交付时需要提供使用说明文档。

# 瀑布模型之外，还有哪些开发模型？

# 快速原型模型

快速原型模型，就是为了要解决客户的需求不明确和需求多变的问题。

但这种快速原型开发往往是以牺牲质量为代价的。

# 增量模型

基于这样的特点，增量模型主要适用于：需求比较清楚，能模块化的软件系统，并且可以按模块分批次交付。

# 迭代模型

迭代模型每次只设计和实现产品的一部分，然后逐步完成更多功能。每次设计和实现一个阶段叫做一个迭代。

在一个迭代中都会包括需求分析、设计、实现和测试，类似于一个小瀑布模型。迭代结束时要完成一个可以运行的交付版本。

增量模型是按照功能模块来拆分；而迭代模型则是按照时间来拆分，看单位时间内能完成多少功能。

# V 模型

V 模型适合外包项目。V 模型本质上还是瀑布模型，只不过它是更重视对每个阶段验收测试的过程模型。

针对从需求定义一直到编码阶段，每个阶段都有对应的测试验收。

# 螺旋模型

这种强调风险，以风险驱动的方式完善项目的开发模型就是螺旋模型。

# 敏捷开发到底是想解决什么问题？

敏捷开发是一套价值观和原则。

瀑布模型面向的是过程，而敏捷开发面向的是人。

# 大厂都在用哪些敏捷方法？（上）

# 一切工作任务围绕 Ticket 开展

每一个任务的状态都可以被跟踪起来：什么时候开始做的，谁在做，做完没有。
整个团队在做什么一目了然。
Ticket 和敏捷开发中的 Backlog（任务清单）正好结合起来，通过 Ticket 可以收集管理整个项目的 Backlog 和当前 Sprint（迭代）的 Backlog。

# 基于 Git 和 CI 的开发流程

Git 本来只是源代码管理工具，但是其强大的分支管理和灵活的权限控制，结合一定的开发流程，却可以帮助你很好的控制代码质量。

# 站立会议

每个人轮流介绍一下，昨天干了什么事情，今天计划做什么事情，工作上有没有障碍无法推进。有问题，记录到 “问题停车场”。
检查最近的 Ticket，甄别一下优先级。有需要讨论的先收集到问题停车场。
针对未讨论的问题展开讨论，能在会议时间内解决的问题，就马上解决，不能解决的会后再私下讨论或者再组织会议。

# 大厂都在用哪些敏捷方法？（下）

在分工上：

产品经理：写需求设计文档，将需求整理成 Ticket，随时和项目成员沟通确认需求；
开发人员：每天从看板上按照优先级从高到低领取 Ticket，完成日常开发任务；
测试人员：测试已经部署到测试环境的程序，如果发现 Bug，提交 Ticket；
项目经理：保障日常工作流程正常执行，让团队成员可以专注工作，提供必要的帮助，解决问题。

如何完成需求和修复 Bug？

日常工作，是围绕 Ticket 来开展的。所有的需求、Bug、任务都作为 Ticket 提交到项目的 Backlog，每个 Sprint 的任务都以看板的形式展现出来。

每个人手头事情忙完后，就可以去看板上的 “To Do” 栏，按照优先级从高到低选取新的 Ticket。选取后移动到 “In Progress” 栏。

每周一部署生产环境

# 参考资料

软件工程之美

《硬件设计经验谈》

Sat, 10 Jul 2021 10:00:00 +0800

# 1. 充分了解各方的设计需求，确定合适的解决方案

启动一个硬件开发项目，原始的推动力会来自于很多方面，比如市场的需要，基于整个系统架构的需要，应用软件部门的功能实现需要，提高系统某方面能力的需要等等，所以作为一个硬件系统的设计者，要主动的去了解各个方面的需求，并且综合起来，提出最合适的硬件解决方案。比如 A 项目的原始推动力来自于公司内部的一个高层软件小组，他们在实际当中发现原有的处理器板 IP 转发能力不能满足要求，从而对于系统的配置和使用都会造成很大的不便，所以他们提出了对新硬件的需求。根据这个目标，硬件方案中就针对性的选用了两个高性能网络处理器，然后还需要深入的和软件设计者交流，以确定内存大小，内部结构，对外接口和调试接口的数量及类型等等细节，比如软件人员喜欢将控制信令通路和数据通路完全分开来，这样在确定内部数据走向的时候要慎重考虑。项目开始之初是需要召开很多的讨论会议的，应该尽量邀请所有相关部门来参与，好处有三个，第一可以充分了解大家的需要，以免在系统设计上遗漏重要的功能，第二是可以让各个部门了解这个项目的情况，提早做好时间和人员上协作的准备，第三是从感情方面讲，在设计之初各个部门就参与了进来，这个项目就变成了大家共同的一个心血结晶，会得到大家的呵护和良好合作，对完成工作是很有帮助的。

# 2. 原理图设计中要注意的问题

原理图设计中要有 “拿来主义”，现在的芯片厂家一般都可以提供参考设计的原理图，所以要尽量的借助这些资源，在充分理解参考设计的基础上，做一些自己的发挥。当主要的芯片选定以后，最关键的外围设计包括了电源，时钟和芯片间的互连。

电源是保证硬件系统正常工作的基础，设计中要详细的分析：系统能够提供的电源输入；单板需要产生的电源输出；各个电源需要提供的电流大小；电源电路效率；各个电源能够允许的波动范围；整个电源系统需要的上电顺序等等。比如 A 项目中的网络处理器需要 1.25V 作为核心电压，要求精度在＋5%- －3% 之间，电流需要 12A 左右，根据这些要求，设计中采用 5V 的电源输入，利用 Linear 的开关电源控制器和 IR 的 MOSFET 搭建了合适的电源供应电路，精度要求决定了输出电容的 ESR 选择，并且为防止电流过大造成的电压跌落，加入了远端反馈的功能。
时钟电路的实现要考虑到目标电路的抖动等要求，A 项目中用到了 GE 的 PHY 器件，刚开始的时候使用一个内部带锁相环的零延时时钟分配芯片提供 100MHz 时钟，结果 GE 链路上出现了丢包，后来换成简单的时钟 Buffer 器件就解决了丢包问题，分析起来就是内部的锁相环引入了抖动。
芯片之间的互连要保证数据的无误传输，在这方面，高速的差分信号线具有速率高，好布线，信号完整性好等特点，A 项目中的多芯片间互连均采用了高速差分信号线，在调试和测试中没有出现问题。

# 3.PCB 设计中要注意的问题

PCB 设计中要做到目的明确，对于重要的信号线要非常严格的要求布线的长度和处理地环路，而对于低速和不重要的信号线就可以放在稍低的布线优先级上。重要的部分包括：电源的分割；内存的时钟线，控制线和数据线的长度要求；高速差分线的布线等等。
针对 DDR memory 这个部分的布线是非常关键的，要考虑到控制线和地址线的拓扑分布，数据线和时钟线的长度差别控制等方面，在实现的过程中，根据芯片的数据手册和实际的工作频率可以得出具体的布线规则要求，比如同一组内的数据线长度相差不能超过多少个 mil，每个通路之间的长度相差不能超过多少个 mil 等等。当这些要求确定后就可以明确要求 PCB 设计人员来实现了，如果设计中所有的重要布线要求都明确了，可以转换成整体的布线约束，利用 CAD 中的自动布线工具软件来实现 PCB 设计，这也是在高速 PCB 设计中的一个发展趋势。

# 4. 检查和调试

当准备调试一块板的时候，一定要先认真的做好目视检查，检查在焊接的过程中是否有可见的短路和管脚搭锡等故障，检查是否有元器件型号放置错误，第一脚放置错误，漏装配等问题，然后用万用表测量各个电源到地的电阻，以检查是否有短路，这个好习惯可以避免贸然上电后损坏单板。调试的过程中要有平和的心态，遇见问题是非常正常的，要做的就是多做比较和分析，逐步的排除可能的原因，要坚信 “凡事都是有办法解决的” 和 “问题出现一定有它的原因”，这样最后一定能调试成功。

# 5. 一些总结的话

现在从技术的角度来说，每个设计最终都可以做出来，但是一个项目的成功与否，不仅仅取决于技术上的实现，还与完成的时间，产品的质量，团队的配合密切相关，所以良好的团队协作，透明坦诚的项目沟通，精细周密的研发安排，充裕的物料和人员安排，这样才能保证一个项目的成功。

一个好的硬件工程师实际上就是一个项目经理，他 / 她需要从外界交流获取对自己设计的需求，然后汇总，分析成具体的硬件实现。还要跟众多的芯片和方案供应商联系，从中挑选出合适的方案，当原理图完成后，他 / 她要组织同事来进行配合评审和检查，还要和 CAD 工程师一起工作来完成 PCB 的设计。与此同时，还要准备好 BOM 清单，开始采购和准备物料，联系加工厂家完成板的贴装。在调试的过程中他 / 她要组织好软件工程师来一起攻关调试，配合测试工程师一起解决测试中发现的问题，等到产品推出到现场，如果出现问题，还需要做到及时的支持。所以做一个硬件设计人员要锻炼出良好的沟通能力，面对压力的调节能力，同一时间处理多个事务的协调和决断能力和良好平和的心态等等。

还有细心和认真，因为硬件设计上的一个小疏忽往往就会造成非常大的经济损失，比如以前碰到一块板在 PCB 设计完备出制造文件的时候误操作造成了电源层和地层连在了一起，PCB 板制造完毕后又没有检查直接上生产线贴装，到测试的时候才发现短路问题，但是元器件已经都焊接到板上了，结果造成了几十万的损失。所以细心和认真的检查，负责任的测试，不懈的学习和积累，才能使得一个硬件设计人员持续不断的进步，而后术业有所小成。

《职场求生攻略》

Sun, 13 Jun 2021 20:56:48 +0800

# 《职场求生攻略》笔记

# 学会如何工作，和学习技术同等重要

以利益为视角，以换位思考为手段。

# 优先级：工作中那么多事情，我要如何安排优先级？

# 基于工作性质安排优先级

工作可以划分为：

业务拓展：需求分析、设计、开发都属于这范畴。

安全问题：安全无小事。要高度重视安全问题。

线上问题：直接影响用户体验和权益。要第一优先级去处理。

# 基于合作安排优先级

事情如果没有明显的轻重缓急，优先做那些会阻塞别人工作的事情。

# 做事情本身的优先级

我们做事情的时候，如果能把其中的每一步都想清楚，理清依赖关系，安排得井井有条，这就已经事半功倍了。

# 沟通：邮件那么重要，你还在轻视邮件吗？

# 邮件的特性

异步交流：邮件是一种异步交流的方式，双方有足够的时间准备邮件内容。
无法修改：邮件内容无法修改，这是邮件可靠的基石。
方便扩散：邮件有邮件组，可以很方便地把相关人员加进来，并且保留邮件历史记录。

# 邮件是公司内部的合同

场景 1：设计确认（邮件的 “确认” 功能）

场景 2：优先级（邮件的 “证据链” 功能）

场景 3：大促（邮件的 “沟通协调” 功能）

场景 4：新业务接入（邮件的 “防遗忘” 功能）

场景 5：技术升级和 Bug 修复（邮件的 “广而告之” 功能）

# 邮件的魅力

我们都是普通人，普通人没有 “背锅” 的压力，就没有持久的把事情做好的动力。

北海虽赊，扶摇可接

博客同步

# 博客同步

博客同步

# 博客同步

EMC知识总结

# 附录：

一篇文章让你彻底掌握 Shell

# 一篇文章让你彻底掌握 Shell

# 简介

# 什么是 shell

# 什么是 shell 脚本

# Shell 环境

# 指定脚本解释器

# 模式

# 交互模式

# 非交互模式

# 基本语法

# 解释器

# 注释

# echo

# printf

# printf 的转义符

# 变量

# 变量命名原则

# 声明变量

# 只读变量

# 删除变量

# 变量类型

# 字符串

# 单引号和双引号

# 拼接字符串

# 获取字符串长度

# 截取子字符串

# 查找子字符串

# 数组

# 创建数组

# 访问数组元素

# 访问数组长度

# 向数组中添加元素

# 从数组中删除元素

# 运算符

# 算术运算符

# 关系运算符

# 布尔运算符

# 逻辑运算符

# 字符串运算符

# 文件测试运算符

# 控制语句

# 条件语句

# if

# case

# 循环语句

# for 循环

# while 循环

# until 循环

# select 循环

# break 和 continue

# 函数

# 位置参数

# 函数处理参数

# Shell 扩展

# 大括号扩展

# 命令置换

# 算数扩展

# 单引号和双引号

# 流和重定向

# 输入、输出流

# 重定向

# /dev/null 文件

# Debug

# 参考资料

《华为是怎样对待供应商的》

# 解读《华为是怎样对待供应商的》

# 采购杠杆

# 华为 92 家供应商

《Git知识点整理》

# 1. Git 基本概念。

# 2. Git 工作空间和文件状态

# (1). 工作空间

# `if`

# `case`

# `for` 循环

# `while` 循环

# `until` 循环

# `select` 循环

# `break` 和 `continue`

# `/dev/null` 文件