参数和选项（arguments & options）

一条命令通常由三个部分组成：命令、选项和参数。命令很好理解，比如：whoami、curl 或是 node 等等这些都是命令。在使用命令时可能需要告诉它各种执行细节，这就是选项和参数的作用，它们根据命令不同具有不同的可选性，某些命令可能不需要参数，某些命令可能没有选项（虽然不常见，但这是允许的）。

选项

选项通常用于修改命令的行为或提供额外的信息。选项使用一个或两个短线（-）开头，许多选项需要一个额外的值跟着它们。单短线的短选项格式，可以使用一个空格在选项和值之间隔开或是不隔开，不过更推荐使用空格隔开；如果是双短线的长选项格式，则必须使用一个空格在选项和值之间隔开（有时也用 =，具体使用请查阅使用命令的相关文档）。此外不需要任何额外值的短选项可以彼此紧挨着使用。

参数

一条命令可以有多个参数，用于标识信息的来源或目的地，对位置比较敏感，比如：mv source.txt destination.txt。参数一般是需要操作的内容，可能是一个文件路径、一段文本或是标准输入流。

Tips：在类 Unix 操作系统中，有些命令可以使用一个短线代替文件名，这将会使其处理来自标准输入的数据或将数据发送到标准输出。

使用语法说明

当你第一次接触某个命令，想快速获取它的用法时，通常可以使用 --help 或 -h 此类选项查看一些简短的用法说明。下面这些语法说明会帮助你快速理解选项和参数的可选性：

• 尖括号（<key>）代表必需参数，例如：ping <destination>
• 方括号（[key]）代表可选参数，例如：mkdir [OPTION] <dirname>
• 省略号（...）代表可重复参数，例如：cp <source1> [source2...] <dest>
• 竖线（|）代表可选择参数，例如：ip [OPTION] OBJECT { SUBCOMMAND | help }

上述这些符号只是辅助理解如何使用命令的，在终端中实际使用这些命令时不需要再次按照参数的可选性增加这些符号，尖括号所包裹的参数在不容易混淆的情况下可能不会额外标记。

重定向和管道（redirect & pipe）

标准输入输出流（Standard Input/Output Streams，简称标准 I/O 流）是程序与外界交互的基础。标准 I/O 流主要包括标准输入流（stdin）、标准输出流（stdout）和标准错误流（stderr），分别可以用文件描述符 0、1 和 2 来指代。在 Unix 命令行中，我们经常使用重定向和管道来管理这些输入输出流，以便更高效地处理数据和信息。

重定向

重定向的语法非常简单，使用 < 代表重定向输入，使用 > 代表重定向输出。通过重定向输入可以将文件内容作为标准输入流传递给程序，重定向输出则是将程序的标准输出流写入到文件，如果执行一个命令同时需要重定向输入和输出的话，看起来会是这样：command < input > output。重定向输入实际上等价于 0< input，同样的重定向输出实际上等价于 1> output。使用 > 将会将标准输出流重定向到一个文件，如果文件存在则会覆盖原内容，也可以使用 >> 将标准输出流重定向并追加到指定文件。

某些情况下，我们可能需要把标准错误、标准输出一并记录并处理，那这时就需要重定向这些标准流。例如，我需要将标准错误重定向至标准输出，就需要这样：command 2>&1，如果是将标准输出重定向到标准错误，则是这样：command 1>&2。

管道

在处理数据时，管道也是非常强大和常用的工具，使用 | 将左边命令的标准输出连接到右边命令的标准输入，可以将多个命令组合在一起。多条指令使用管道依次传递看起来会使这样：command1 | command2 | command3。管道允许实时处理数据流，命令可以即时地处理输入流的部分内容，而不必等到整个输入流完全生成。默认情况下，标准错误将不会被通过管道传递，它们将会合并并直接输出到终端上，你可以使用重定向标准错误到标准输出来改变这一行为。

返回值（exit code）

与常见的 True False 布尔值返回结果不一样，在命令行中成功都应该返回 0，而其他的返回代码都可能代表着错误或失败，通常来说每个命令都会定义自己的错误码，如果你执行的命令出现了错误可以使用 echo $? 获取到错误码，这在写自动化脚本检测失败时会很有用。

结合 && 和 || 运算符就可以根据命令的执行结果决定后续的操作，例如在 command1 && command2 命令中，如果 command1 执行成功（exit code 等于 0）则执行 command2；反之在 command1 || command2 中，如果 command1 执行失败（exit code 不等于 0）则执行 command2。

配置文件（config）

通常这些命令的全局配置文件都在 /etc 或是 /usr/local/etc 目录中，用户自定义的配置文件通常在 /home/<username>/.<something>rc 此类的文件中。至于 rc 后缀的起源众说纷纭，我们约定成俗，见到 rc 一般当作配置文件都没什么问题。当然，每条命令也可以有自己的配置文件格式，例如：curl 的配置文件通常是按行写各种选项，而 wget 的配置文件则像是一个个的键值对。

环境变量（environment variable）

环境变量是一种在操作系统中用来存储信息的机制，它们包含了系统运行时所需的各种信息，如路径、默认参数、语言设置等。每个环境变量都有一个名称和一个对应的值。通常来说定义环境变量应当全大写，设置环境变量可以采用多种方法，可以根据需要在命令行中临时设置或者在系统中永久生效。

某些命令行程序也会读取项目中会的 .env 或是其他环境变量文件，也会有像是 NODE_ENV=development vite build 此类直接在命令前定义的环境变量的情况，这种情况环境变量不会被记录仅在当前命令中有效。

我们还可以在终端中直接 export 一个环境变量，这样定义的环境变量将仅在当前会话中可用，重启终端或退出登录等操作都会使其失效。比如这样：

export NODE_ENV=development
vite build

如果你想持久化的定义一个环境变量可以将它在 .zshrc 或是 .bashrc 等终端配置文件中 export，在启动该终端时自动添加这些环境变量。例如：

export PATH="/usr/local/go/bin:$PATH"

小测

结语

相信你读完这篇文章对命令行再也没有那么恐惧了，大多数参数与选项设计得都很合理且便于记忆，稍加使用一段时间你将会发现命令实在是太酷了！

参考文档

• https://en.wikipedia.org/wiki/Command-line_interface
• https://en.wikipedia.org/wiki/Redirection_(computing)
• https://en.wikipedia.org/wiki/Pipeline_(Unix)
• https://everything.curl.dev/cmdline/configfile.html
• https://www.gnu.org/software/wget/manual/wget.html#Sample-Wgetrc
• https://cn.vitejs.dev/guide/env-and-mode.html#env-variables

Photo by Nathan da Silva on Unsplash

Windows 命令行是 Windows PC 上最强大的实用程序之一。有了它，你可以直接与操作系统交互，并做很多图形用户界面（GUI）中不能实现的事情。

在本文中，我将向你展示可以在 Windows 命令行上使用的 40 个命令，这些命令可以增强你作为 Windows 用户的信心。

注意：在使用我将向你展示的命令时，你必须小心。这是因为某些命令可能会对你的 Windows PC 产生持久的负面或正面影响，直到你重置电脑。

此外，其中一些命令要求你以管理员身份打开命令提示符。

Windows 命令行命令

powershell start cmd -v runAs – 以管理员身份运行命令提示符

输入此命令以管理员身份打开另一个命令提示符窗口：

driverquery – 列出所有已安装的驱动程序

访问所有驱动程序很重要，因为它们通常会导致问题。

这就是这个命令的作用——它甚至会显示你在设备管理器中找不到的驱动程序。

chdir or cd – 将当前工作目录更改为指定目录

systeminfo – 显示你的 PC 的详细信息

如果你想查看有关你的系统的更多详细信息，你不会在 GUI 中看到，可以用这个命令。

set – 显示你的 PC 的环境变量

prompt – 更改输入命令前显示的默认文本

默认情况下，命令提示符会显示你的用户帐户的 C 盘路径。

你可以使用 prompt 命令通过语法 prompt_name $G 更改该默认文本：

注意：如果你不将 $G 附加到命令中，你将不会在文本前面获得大于符号。

clip – 将项目复制到剪贴板

例如，dir | clip 将当前工作目录的所有内容复制到剪贴板。

你可以输入 clip /? 并按 ENTER 以查看如何使用它。

assoc – 列出程序及其关联的扩展

title – 使用格式 title window-title-name 更改命令提示符窗口标题

fc – 比较两个相似的文件

如果你是程序员或写作者，并且想快速查看两个文件之间的不同之处，你可以输入此命令，然后输入两个文件的完整路径。例如 fc “file-1-path” “file-2-path”。

cipher – 擦除可用空间并加密数据

在 PC 上，你和其他用户仍然可以访问已删除的文件。因此，从技术上讲，它们不会在后台被删除。

你可以使用 cipher 命令擦除驱动器并加密此类文件。

netstat -an – 显示打开的端口、它们的 IP 地址和状态

ping – 显示网站 IP 地址，让你知道传输数据和获取响应需要多长时间

color – 更改命令提示符的文本颜色

输入 color attr 以查看可以更改为的颜色：

输入 color 2 将终端的颜色更改为绿色：

for /f "skip=9 tokens=1,2 delims=:" %i in ('netsh wlan show profiles') do @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear – 显示所有 Wi-Fi 密码

ipconfig – 显示有关 PC IP 地址和连接的信息

此命令还具有扩展名，例如 ipconfig /release、ipconfig /renew 和 ipconfig /flushdns，你可以使用它们来解决网络连接问题。

sfc – 系统文件检查器

此命令扫描你的计算机以查找损坏的文件并进行修复。可用于运行扫描的命令扩展名为 /scannow。

powercfg – 控制可配置的电源设置

你可以使用此命令及其多个扩展名来显示有关 PC 电源状态的信息。

你可以输入 powercfg help 来显示这些扩展。

例如，你可以使用 powercfg /energy 生成电池健康报告。

powercfg /energy 命令将生成一个包含报告的 HTML 文件。你可以在 C:\Windows\system32\energy-report.html 中找到 HTML 文件。

dir – 列出目录中的项目

del – 删除文件

attrib +h +s +r folder_name – 隐藏文件夹

你可以通过在命令行中直接输入 attrib +h +s +r folder_name 然后按 ENTER 来隐藏文件夹。

要再次显示该文件夹，请执行命令 -attrib -h -s -r folder_name。

start website-address – 从命令行登录网站

tree – 显示当前目录或指定驱动器的树

ver – 显示操作系统的版本

tasklist – 显示打开的程序

你可以使用以下命令对任务管理器执行相同的操作：

下一个命令向你展示如何关闭打开的任务。

taskkill – 终止正在运行的任务

要终止任务，请运行 taskkill /IM "task.exe" /F。例如，taskkill /IM "chrome.exe" /F：

date – 显示和更改当前日期

time – 显示和更改当前时间

vol – 显示当前驱动器的序列号和标签信息

dism – 运行部署镜像服务管理工具

CTRL + C – 停止执行命令

-help – 提供其他命令的指南

例如，powercfg -help 显示如何使用 powercfg 命令。

echo – 显示自定义消息或来自脚本或文件的消息

你还可以使用 echo 命令通过 echo file-content > filename.extension 创建文件。

mkdir – 创建文件夹

rmdir – 删除文件夹

注意：该文件夹必须为空，此命令才能工作。

more – 显示更多信息或文件内容

move – 将文件或文件夹移动到指定文件夹

ren – 使用语法 ren filename.extension new-name.extension 重命名文件

cls – 清除命令行

如果你输入多个命令并且命令行被阻塞，你可以使用 cls 清除所有条目及其输出。

exit – 关闭命令行

shutdown – 关闭、重新启动、休眠计算机

你可以从命令行关闭、重新启动和休眠你的 PC。

在命令行中输入 shutdown，以便查看可用于执行操作的扩展。例如，shutdown /r 将重新启动你的计算机。

总结

本文向你展示了一些很多人不知道的命令，你可以使用这些命令来访问 Windows PC 上的隐藏功能。

你在使用这些命令时应该小心，因为它们会对你的操作系统产生持久的影响。

如果你发现这些命令有帮助，请与你的朋友和家人分享这篇文章。

如果你知道其他我没有列出的有用命令，请在 Twitter 上告诉我。我将添加它并提及你作为来源。

大家好！在这篇文章中，我们将好好看看命令行（也被称为 CLI、控制台、终端或 shell）。

命令行是我们作为开发者和一般的计算机用户所拥有的最有用和最有效的工具之一。但是，当你开始使用它时，可能会觉得它有点复杂。

在这篇文章中，我将尽力简单解释构成命令行界面的各个部分，以及它如何工作的基本原理，这样你就可以开始使用它来完成你的日常任务。

开始吧！=D

目录

• 控制台、终端、命令行（CLI）和 shell 之间的区别
  • 控制台
  • 终端
  • shell
  • 命令行（CLI）
• 为什么我要关心终端
• 不同的 shell
  • 一点历史——Posix
  • 怎么知道我在运行哪个 shell
  • 哪个 shell 更好
    • 关于自定义
• 最常用且最有用的命令
  • Git 命令
• 我们的第一个脚本
• 总结

控制台、终端、命令行（CLI）和 shell 之间的区别

我认为一个好的开始是准确了解什么是命令行。

在提到这一点时，你可能听说过终端、控制台、命令行、CLI 和 shell 这些术语。人们经常交替使用这些词，但事实是它们实际上是不同的东西。

区分它们并不一定是很重要的知识，但它将有助于澄清事情。因此，让我们简单地解释一下每一个。

控制台

控制台（console）是允许你与计算机互动的物理设备。

通俗地说，它就是你的电脑屏幕、键盘和鼠标。作为一个用户，你通过控制台与计算机进行互动。

终端

终端是一个文本输入和输出环境。它是作为一个包装器（wrapper） 的程序，允许我们输入计算机处理的命令。

用简单来说，它是一个“窗口”，你在其中输入计算机将处理的实际命令。

请记住，终端是一个程序，就像其他任何程序一样。和其他程序一样，你可以随意安装和卸载它。也可以在你的电脑中安装许多终端，随时运行你想运行的终端。

所有的操作系统都安装了一个默认的终端，但有很多选择，每个都有自己的功能和特点。

shell

shell 是一个程序，作为命令行解释器。它处理命令并输出结果。它解释和处理用户输入的命令。

与终端（terminal）一样，shell 是所有操作系统中默认的程序，但也可以由用户自己安装和卸载。

不同的 shell 也有不同的语法和特点。也可以在你的电脑上安装许多 shell，并在你想的时候运行每个 shell。

在大多数 Linux 和 Mac 操作系统中，默认的 shell 是 Bash。而在 Windows 中则是 Powershell。其他一些常见的 shell 的例子是 Zsh 和 Fish。

shells 也可以作为编程语言来工作，在这个意义上，我们可以用它们建立脚本（scripts），使我们的计算机执行某种任务。脚本只不过是一系列指令（命令），我们可以将其保存在文件中，然后在我们想执行的时候执行。

我们将在本文的后面看一下脚本的内容。现在只要记住，shell 是你的计算机用来理解和执行你的命令的程序，你也可以用它来编写任务。

还要记住，终端是 shell 运行的程序。但这两个程序是独立的。这意味着，我可以让任何 shell 在任何终端上运行。在这个意义上，两个程序之间没有依赖性。

命令行（CLI）

CLI 是一个界面，我们在其中输入命令供计算机处理。用简单来说，它是一个空间，你在其中输入计算机将处理的命令。

这实际上与终端（terminal）是一样的，在我看来，这些术语可以互换使用。

这里要提到的一件有趣的事情是，大多数操作系统都有两种不同类型的界面：

• CLI，它将命令作为输入，以使计算机执行任务。
• 另一个是 GUI（图形用户界面），用户可以看到屏幕上的东西并点击它们，计算机将通过执行相应的任务对这些事件作出反应。

为什么我要关心终端

我们刚刚提到，大多数操作系统都有一个图形用户界面。因此，如果我们可以在屏幕上看到东西，并点击来做我们想做的事情，你可能会想，为什么你要学习这个复杂的终端（terminal）/cli/shell 呢？

第一个原因是，对于许多任务来说，它只是更有效率。我们稍后会看到一些例子，但是有很多任务在 GUI 中需要在不同的窗口中进行多次点击。但在 CLI 上，这些任务可以用一个命令来执行。

从这个意义上说，熟悉命令行将帮助你节省时间，能够更快地执行你的任务。

第二个原因是，通过使用命令，你可以轻松地自动化任务。如前所述，我们可以用我们的 shell 建立脚本，然后在我们想要的时候执行这些脚本。在处理那些我们不想重复做的重复性任务时，这非常有用。

仅举一些例子，我们可以建立一个脚本，为我们创建一个新的在线 repo，或者为我们在云服务商上创建一个特定的基础设施，或者执行一个更简单的任务，如每小时改变我们的屏幕墙纸。

脚本是一种节省重复性任务时间的好方法。

第三个原因是，有时 CLI 将是我们能够与计算机互动的唯一方式。例如，当你需要与云平台服务器互动时。在大多数情况下，你不会有一个 GUI，只有一个 CLI 来运行命令。

因此，熟练掌握 CLI 将使你能够在所有情况下与计算机互动。

最后一个原因是它看起来很酷、很有趣。你不会看到电影中的黑客在他们的电脑上点击，对吗？

不同的 shell

在深入研究你可以在终端运行的实际命令之前，我认为认识不同类型的 shell 以及如何识别你目前正在运行的 shell 很重要。

不同的 shell 有不同的语法和功能，所以要知道到底要输入什么命令，你首先要知道你在运行什么 shell。

一点历史——Posix

对于 shells，有一个通用的标准，叫作 Posix。

Posix 之于 shell 与 ECMAScript 之于 JavaScript 非常相似。它是一个标准，规定了所有 shell 应该遵守的某些特性和功能。

这个标准是在 20 世纪 80 年代建立的，目前大多数 shell 都是根据这个标准开发的。这就是为什么大多数 shell 共享类似的语法和类似的特征。

怎么知道我在运行哪个 shell

要知道你当前运行的是什么 shell，只需打开你的终端并输入echo $0。这将打印出当前运行的程序名称，在这种情况下，它就是实际的 shell。

哪个 shell 更好

大多数 shell 之间没有很大的区别。由于它们大多符合相同的标准，你会发现它们中的大多数工作都是类似的。

不过，你可能想知道一些细微的差别：

• 如前所述，Bash 是使用最广泛的，在 Mac 和 Linux 上默认安装。
• Zsh* 与 Bash 非常相似，但它是在 Bash 之后创建的，并且比它有一些不错的改进。如果你想更详细地了解它的区别，这里有一篇很酷的文章是关于 zsh 的。
• Fish 是另一个常用的 shell，它有一些不错的内置功能和配置，如自动完成和语法高亮。关于 Fish 的问题是，它不是 Posix 兼容，而 Bash 和 Zsh 是。这意味着你能在 Bash 和 Zsh 上运行的一些命令不能在 Fish 上运行，反之亦然。这使得 Fish 脚本与 Bash 和 Zsh 相比对大多数计算机的兼容性较差。
• 还有一些其他的 shell，比如 Ash 或 Dash（命名只是让一切变得更加混乱，我知道......），它们是 Posix shell 的精简版本。这意味着它们只提供 Posix 所需要的功能，而没有其他的。而 Bash 和 Zsh 增加了比 Posix 要求更多的功能。

事实上，shells 增加了更多的功能，使它们更容易、更友好地进行交互，但执行脚本和命令的速度较慢。

因此，一种常见的做法是使用 Bash 或 Zsh 这样的 增强型 shell 进行一般的交互，而使用 Ash 或 Dash 这样的剥离型 shell 来执行脚本。

当我们在后面讨论脚本时，我们将看到如何定义什么 shell 来执行一个给定的脚本。

如果你对这些 shell 之间更详细的比较感兴趣，这里有一个视频，解释得非常清楚。

如果必须推荐一个 shell，我会推荐 bash，因为它是最标准和最常用的一个。这意味着你能够将你的知识转化为大多数环境。

但是，事实上，大多数 shell 之间并没有很大的区别。所以在任何情况下，你都可以尝试几种，看看你最喜欢哪一种。:)

关于自定义

我刚刚提到，Fish 有内置的配置，比如自动完成和语法高亮。这在 Fish 中是内置的，但在 Bash 或 Zsh 中你也可以配置这些功能。

关键是 shells 是可定制的。你可以编辑程序如何工作，你有哪些命令，你的提示符显示什么信息，等等。

我们不会在这里看到详细的定制选项，但要知道，当你在你的计算机上安装 shell 时，你的系统上将会创建某些文件，以后你可以编辑这些文件来定制你的程序。

此外，网上有许多插件，允许你以更容易的方式定制你的外壳。你只需安装它们并获得该插件提供的功能。一些例子是 OhMyZsh 和 Starship。

这些定制选项对终端也是如此。

因此，你不仅有许多 shell 和终端（terminal）选项可供选择--你还为每个 shell 和终端有许多配置选项。

如果你刚开始使用，所有这些信息可能会让你感到有点不知所措。但只要知道有许多选项可用，而且每个选项也可以被定制。

最常用且最有用的命令

现在我们对 CLI 的工作方式有了一个基础，让我们深入了解一下最有用的命令，你可以开始在你的日常工作中使用。

请记住，这些例子将基于我目前的配置（Linux 操作系统上的 Bash）。但无论如何，大多数命令应该适用于大多数配置。

• Echo 在终端打印出我们传递给它的任何参数。

echo Hello freeCodeCamp! // Output: Hello freeCodeCamp!

• pwd 代表打印工作目录，它打印出我们目前在计算机中的位置或目录。

pwd // Output: /home/German

• ls 向你展示你当前所在的目录的内容。它将向你展示你当前目录中的文件和其他目录。

例如，这里我在最近工作的一个 React 项目目录上：

ls // Output:
node_modules  package.json  package-lock.json  public  README.md  src

如果你将此命令传递给标志或参数 -a，它还将向您显示隐藏的文件或目录，像 .git or .gitignore 文件。

ls -a // Output:
.   .env  .gitignore    package.json       public     src
..  .git  node_modules  package-lock.json  README.md

• cd 是 Change directory 的缩写，它将把你从你的当前目录带到另一个目录。

在我的 home 目录下，我可以输入cd Desktop，它将把我带到桌面目录。

如果我想上升一个目录，也就是说，去包含当前目录的目录，我可以输入cd ..。

如果你只输入cd，它将直接带你到你的 home 目录。

• mkdir 代表制作目录，它将为你创建一个新的目录。你必须把目录名称参数传给命令。

如果我想创建一个名为 "Test "的新目录，我将输入mkdir test。

• rmdir 代表删除目录，它就是这样做的。它和 mkdir 一样需要目录名参数：rmdir test。

• touch 允许你在当前目录下创建一个空文件。作为参数，它需要文件名，如touch test.txt。

• rm允许你删除文件，与 rmdir 允许你删除目录的方式相同。 rm test.txt

• cp 允许你复制文件或目录。这个命令需要两个参数：第一个是你想复制的文件或目录，第二个是你复制的目的地（你想把文件/目录复制到哪里）。

如果我想在同一目录下复制我的 txt 文件，我可以输入以下内容：

cp test.txt testCopy.txt

看，目录没有改变，因为在目的地中我输入了新的文件名。

如果我想把文件复制到一个不同的目录，但保持相同的文件名，我可以输入这个：

cp test.txt ./testFolder/

而如果我想复制到一个不同的文件夹，改变字段名，当然可以这样输入：

cp test.txt ./testFolder/testCopy.txt

• mv 是移动的简称，它让我们把一个文件或目录从一个地方移动到另一个地方。也就是说，在一个新的目录中创建它，并在前一个目录中删除它（就像你通过剪切和粘贴所做的一样）。

同样，这个命令需要两个参数，即我们想要移动的文件或目录和目的地。

mv test.txt ./testFolder/

如果我们愿意，也可以在同一命令中改变文件的名称：

mv test.txt ./testFolder/testCopy.txt

• head允许你直接从终端查看文件或管道数据的开始部分。

head test.txt // Output:
this is the beginning of my test file

• tail 的工作原理是一样的，但它会向你显示文件的结尾部分内容。

tail test.txt // Output:

this is the end of my test file

• --help/ 标志可用于大多数命令，它将返回如何使用该命令的信息。

cd --help // output:
cd: cd [-L|[-P [-e]] [-@]] [dir]
Change the shell working directory.

将当前目录改为 DIR。默认的 DIR 是 HOME shell 变量的值。

变量 CDPATH 定义了包含 DIR 的目录的搜索路径。CDPATH 中的备选目录名由冒号:分隔。

如果 DIR 以...开头，则空目录名与当前目录相同。

• 以类似的方式，man 命令将返回任何特定命令的信息。

    man cp // output:

    CP(1)                            User Commands                           CP(1)

    NAME
           cp - copy files and directories

    SYNOPSIS
           cp [OPTION]... [-T] SOURCE DEST
           cp [OPTION]... SOURCE... DIRECTORY
           cp [OPTION]... -t DIRECTORY SOURCE...

    DESCRIPTION
           Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.

           Mandatory  arguments  to  long  options are mandatory for short options
           too.

           -a, --archive
                  same as -dR --preserve=all

           --attributes-only
                  don't copy the file data, just the attributes
    ...

你甚至可以输入 "man bash"，这将返回一个关于这个 shell 的所有知识的详细手册。;)

• code 将打开你的默认代码编辑器。如果你单独输入这个命令，它只是打开你最近打开的文件/目录的编辑器。

你也可以通过传递参数来打开一个指定的文件：code test.txt。

或者通过传递新的文件名来打开一个新的文件： code thisIsAJsFile.js.

• edit 将在你的默认命令行文本编辑器上打开文本文件（如果你是在 Mac 或 Linux 上，可能是 Nano 或 Vim）。

如果你打开了你的文件，然后无法退出你的编辑器，首先看一下这个：

然后输入 :q! 并回车。（译者注：q 是 quit 的缩写）

这个备忘录很有趣，因为每个人一开始都在为使用 CLI 文本编辑器而挣扎，因为大多数操作（比如退出编辑器）都是通过键盘快捷键完成的。使用这些编辑器是另外一个话题，如果你有兴趣了解更多，就去找教程吧。;)

• ctrl+c 允许你退出终端正在运行的当前进程。例如，如果你正在用npx create-react-app创建一个 react 应用，并想在某个时候取消构建，只要按下组合键 ctrl+c，它就会停止。

• 从终端复制文本可以用 ctrl+shift+c 来完成，粘贴可以用 ctrl+shift+v 来完成。

• clear 将清除你的终端上的所有内容。

• exit 将关闭你的终端，（这不是一个命令，但它也很酷）ctrl+alt+t 将为你打开一个新终端。

• 通过按上、下方向键你可以浏览你之前输入的命令。

• 按下 tab，你将得到基于你到目前为止所写的命令的自动补全。按下两次tab，你会得到基于你到目前为止所写命令的建议。

例如，如果我输入 edit test 并按下两次 tab，我就会得到 testFolder/ test.txt。如果我写edit test.并按下 tab，我的文本会自动补全为edit test.txt。

Git 命令

除了在文件系统中工作和安装/卸载东西，作为一个开发者在终端最常使用可能是 Git 和线上仓库的交互。

从终端做这些事情比到处点击更有效率，所以让我们看看最有用的 git 命令吧。

git init将为你创建一个新的本地版本库。

git init // output:
Initialized empty Git repository in /home/German/Desktop/testFolder/.git/

git add 将一个或多个文件添加到暂存区。你可以详细说明要添加到暂存区的特定文件，或者通过输入 git add .` 来添加所有更改的文件。

git commit 将你的修改提交给版本库。提交必须总是必须伴随着-m标志和提交信息。

git commit -m 'This is a test commit' // output:
[master (root-commit) 6101dfe] This is a test commit
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test.js

git status 告诉你，你目前在哪个分支上，以及你是否有修改要提交。

git status  // output:
On branch master
nothing to commit, working tree clean

git clone 允许你克隆（复制）一个仓库到你当前所在的目录。请记住，你既可以克隆远程仓库（GitHub、GitLab 等），也可以克隆本地仓库（那些存储在你电脑中的仓库）。

git clone https://github.com/coccagerman/MazeGenerator.git // output:
Cloning into 'MazeGenerator'...
remote: Enumerating objects: 15, done.
remote: Counting objects: 100% (15/15), done.
remote: Compressing objects: 100% (15/15), done.
remote: Total 15 (delta 1), reused 11 (delta 0), pack-reused 0
Unpacking objects: 100% (15/15), done.

git remote add origin 是用来详细说明你的项目要使用的远程仓库的 URL。如果你想在某个时候改变它，你可以通过使用git remote set-url origin命令来实现。

git remote add origin https://github.com/coccagerman/testRepo.git

请记住，你需要先创建你的远程版本，以便获得其 URL。稍后我们将看到你如何通过一个小脚本从命令行中做到这一点。;)

git remote -v 可以让你列出当前正在使用的远程仓库。

git remote -v // output:
origin https://github.com/coccagerman/testRepo.git (fetch)
origin https://github.com/coccagerman/testRepo.git (push)

git push 将你已提交的修改上传到你的远程 repo。

git push // output:
Counting objects: 2, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (2/2), 266 bytes | 266.00 KiB/s, done.
Total 2 (delta 0), reused 0 (delta 0)

git branch 列出了你的 repo 上的所有可用分支，并告诉你目前在哪个分支上。如果你想创建一个新的分支，你只需把新的分支名称作为参数加入，比如git branch <branch name>。

git branch // output:
* main

git checkout 将你从一个分支移到另一个分支。它把你的目标分支作为 paremeter。

git checkout newBranch // output:
Switched to branch 'newBranch'

git pull 从你的远程仓库拉取（下载）代码，并将其与你的本地仓库相结合（combines）。这在团队工作中特别有用，当许多开发人员在同一个代码库中工作时。在这种情况下，每个开发者都会定期从远程版本库拉取代码，以便在一个包括所有其他开发者所做修改的代码库中工作。

如果你的远程版本中有新的代码，该命令将返回在拉取中被修改的实际文件。如果没有，我们会得到 Already up to date（已经更新)。

git pull // output:
Already up to date.

git diff 允许你查看你当前所在的分支和另一个分支之间的差异。

git diff newBranch // output:
diff --git a/newFileInNewBranch.js b/newFileInNewBranch.js
deleted file mode 100644
index e69de29..0000000

顺便说一下，当比较不同分支或版本之间的差异时，通常会使用 Meld 这样的可视化工具。并不是说你不能在终端中直接看到它，但这个工具对于更清晰的可视化是非常有用的。

git merge 将你当前所在的分支与另一个分支合并（合并）。请记住，所做的修改将只并入你当前所在的分支，而不是另一个分支。

git merge newBranch // output:
Updating f15cf51..3a3d62f
Fast-forward
 newFileInNewBranch.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 newFileInNewBranch.js

git log 列出了你在 repo 中以前做过的所有提交。

git log // output:
commit 3a3d62fe7cea7c09403c048e971a5172459d0948 (HEAD -> main, tag: TestTag, origin/main, newBranch)
Author: German Cocca <german.cocca@avature.net>
Date:   Fri Apr 1 18:48:20 2022 -0300

    Added new file

commit f15cf515dd3ec398210108dce092debf26ff9e12
Author: German Cocca <german.cocca@avature.net>
    ...

--help/ 标志会显示关于某个命令的信息，与 bash 的工作方式完全相同。

git diff --help // output:
GIT-DIFF(1)                       Git Manual                       GIT-DIFF(1)

NAME
       git-diff - Show changes between commits, commit and working tree, etc

SYNOPSIS
       git diff [options] [<commit>] [--] [<path>...]
       git diff [options] --cached [<commit>] [--] [<path>...]
       ...

我们的第一个脚本

现在我们准备进入命令行中真正有趣和很棒的部分，即脚本！

正如我之前提到的，一个脚本只不过是一系列我们可以在任何时候执行的命令或指令。为了解释我们如何编写一个脚本，我们将使用一个简单的例子，让我们通过运行一个命令来创建一个 github repo。 ;)

• 首先要做的是创建一个.sh文件。你可以把它放在任何地方。我把我的文件称为 newGhRepo.sh。

• 然后在你选择的文本/代码编辑器中打开它。

• 在我们的第一行，我们将写下以下内容 #! /bin/sh。

这被称为 shebang，它的作用是声明什么 shell 来运行这个脚本。

还记得我们以前提到过，我们可以用一个给定的 shell 来进行一般的交互，而用另一个给定的 shell 来执行一个脚本吗？那么，shebang 就是决定由哪个 shell 来运行脚本的指令。

如前所述，我们使用一个精简的 shell（也称为 sh shells）来运行脚本，因为它们更有效率（尽管说实话，这种差别可能是难以察觉的，这只是一种个人偏好）。在我的电脑中，我把 dash 作为我的 sh shell。

如果我们想让这个脚本用 bash 运行，那么 shebang 应该是#! /bin/bash。

我们的下一行将是repoName=$1。

这里我们声明了一个名为 repoName 的变量，并将其分配给脚本收到的第一个参数的值。

一个参数是一组在脚本/命令后面输入的字符。就像 cd 命令一样，我们需要指定一个目录参数，以便改变目录（即：cd testFolder）。

我们可以通过使用 $ 符号和预期参数的顺序来识别脚本中的参数。

如果我期望有一个以上的参数，我可以这样写：

paramOne=$1
paramTwo=$2
paramThree=$3
...

所以，我们希望将代码库的名称作为我们脚本的参数。但如果用户忘记输入会怎样？我们需要想一下，所以接下来我们要编写一个条件，不断要求用户输入版本库名称，直到收到该参数。
我们可以这样做：

while [ -z "$repoName" ]
do
   echo 'Provide a repository name'
   read -r -p $'Repository name:' repoName
done

我们可以这样做：

1. 当 repoName 变量未被分配时（while [ -z "$repoName" ]）
2. 将此信息打印到控制台（echo '提供一个版本库名称'）
3. 然后读取用户提供的任何输入，并将输入分配给 repoName 变量（read -r -p $'Repository name:' repoName）

现在我们有了我们的 repo 名称，我们可以像这样创建我们的本地 Git repo：

echo "# $repoName" >> README.md
git init
git add .
git commit -m "First commit"

这就是创建一个 readme 文件，并在第一行写上 repo 名称（echo "# $repoName" >> README.md），然后初始化 git repo 并做第一次提交。

然后，是时候把我们的 repo 上传到 GitHub 了。要做到这一点，我们将利用 GitHub API的优势，使用以下命令：

curl -u coccagerman https://api.github.com/user/repos -d '{"name": "'"$repoName"'", "private":false}'

curl 是一个从服务器传输数据的命令，使用许多支持的协议的其中一种。

接下来我们使用-u标志来声明我们为之创建的用户（-u coccagerman）。

接下来是 GitHub API 提供的 endpoint(https://api.github.com/user/repos)

最后，我们使用-d标志来传递参数给这个命令。在这种情况下，我们要指出版本库的名称（为此我们使用repoName变量），并将private选项设置为false，因为我们希望我们的版本库是公开的。

在 API 中还有很多其他的配置选项，所以查看文档了解更多信息。

运行此命令后，GitHub 会提示我们输入 私人令牌（private token） 进行认证。

如果你还没有私人令牌，你可以在 GitHub 的 Settings > Developer settings > Personal access tokens

酷，我们现在几乎已经完成了！现在我们需要的是我们新创建的 GitHub repo 的 remote URL。

为了得到它，我们将再次使用 curl 和 GitHub API，像这样：

GIT_URL=$(curl -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/coccagerman/"$repoName" | jq -r '.clone_url')

这里我们声明了一个叫做GIT_URL的变量，并将其分配给下面命令返回的任何内容。

-H标志设置了我们请求的头。

然后我们传递 GitHub 的 API endpoint，其中应包含我们的用户名（user name）和 repo名称（https://api.github.com/repos/coccagerman/"$repoName"）。

然后，我们就 piping 了我们请求的返回值。管道化（piping）只是意味着将一个进程的返回值作为另一个进程的输入值。我们可以用|符号来做，比如<process1> | <process2>。

最后我们运行 jq 命令，这是一个处理 JSON 输入的工具。在这里，我们告诉它获得 .clone_url 的值，根据 GitHub API 提供的数据格式，这是我们的远程 Git URL 的位置。

最后一步，我们将主分支重命名为 main，添加我们刚刚获得的远程源码，然后将我们的代码推送到 GitHub 上! =D

git branch -M main
git remote add origin $GIT_URL
git push -u origin main

我们的完整脚本应该看起来像这样：

#! /bin/sh
repoName=$1

while [ -z "$repoName" ]
do
    echo 'Provide a repository name'
    read -r -p $'Repository name:' repoName
done

echo "# $repoName" >> README.md
git init
git add .
git commit -m "First commit"

curl -u <yourUserName> https://api.github.com/user/repos -d '{"name": "'"$repoName"'", "private":false}'

GIT_URL=$(curl -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/<yourUserName>/"$repoName" | jq -r '.clone_url')

git branch -M main
git remote add origin $GIT_URL
git push -u origin main

• 现在是测试我们的脚本的时候了！要执行它，我们可以做两件事。

一种方法是输入 shell 名称，并将文件作为参数传入，比如。dash ../ger/code/projects/scripts/newGhRepo.sh。

另一种是通过运行chmod u+x ../ger/code/projects/scripts/newGhRepo.sh，使文件有可执行权限。

然后你可以通过运行../ger/code/projects/scripts/newGhRepo.sh直接执行该文件。

就是这样了！我们有了脚本，并且它开始运行。每当我们需要一个新的 repo 时，我们就可以从我们所在的任何目录中执行这个脚本。

但这有一点很烦人。我们需要记住脚本目录的确切路径。如果能用一条命令来执行脚本，不管我们在哪个目录下都是一样的，那不是很酷吗？

在这里，bash aliases（别名） 来解决我们的问题。

别名是 bash 提供的一种方法，用于为我们想要运行的确切命令命名。

要创建一个新的别名，我们需要编辑我们系统中的 bash 配置文件。这些文件通常位于主目录中。别名可以在不同的文件中定义（主要是.bashrc或.bash_aliases）。

我的系统上有一个.bash_aliases文件，所以我们来编辑它：

• 在我们的 CLI 中，我们输入cd ~来查看主目录。

• 然后我们可以输入ls -a列出所有文件（包括隐藏的），并检查我们的系统中是否有.bashrc或.bash_aliases文件。

• 我们用我们选择的文本/代码编辑器打开该文件。

• 然后我们这样写我们的新别名：
  alias newghrepo="dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh"

在这里，我声明了别名的名称，以及我将要输入的运行脚本的实际命令（newghrepo）。

在引号之间，定义这个别名要做什么（"dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh")。

请看，我传递的是脚本的绝对路径，这样，无论我的当前目录是什么，这个命令都是一样的。

如果你不知道你的脚本的绝对路径是什么，在你的终端上进入脚本目录，然后输入 readlink -f newGhRepo.sh。这应该可以为你返回完整的路径;)

编辑完成后，我们保存文件，重新启动终端，然后就可以了！现在我们可以通过输入 newghrepo 来运行我们的脚本，无论我们目前在哪个目录下。这比打开浏览器和点击创建我们的 repo 要快得多！=D

我希望这能让你体会到脚本所能带来的优化效果。当然，在你第一次编写、测试和设置脚本的时候，它需要多做一些工作。但在那之后，你就再也不用手动执行这项任务了。;)

总结

当你开始工作时，终端可能感觉是一个令人生畏和复杂的地方。但是，花时间和精力去学习它的内在和延展，肯定是值得的。它能够极大地提高效率。

如果你有兴趣学习更多关于终端和 Bash 的知识，Zach Gollwitzer 在 YouTube 上有 一个很棒的速成系列课程。
他在其他主题上也有很好的教程，如 Node 和 Javascript，所以我推荐你关注他;)

像往常一样，我希望你喜欢这篇文章，并学到一些新东西。如果你愿意，你也可以在 linkedin 或 Twitter 上关注我。

感谢你阅读本文，下一篇见！=D

关于 SVN 和 Git 的比较已经有很多文章说过了，就不再赘述。本文的重点是如何使用常用的 Git 命令进行操作，冷门的就不说了，且比较零散，系统的学习推介廖雪峰的 Git 教程。

声明：下面用户名都为SHERlocked93，请自行修改成自己的用户名

1. 概览

• 工作区 Workspace
• 暂存区 Stage / Index
• 本地仓库 Repository
• 远程仓库 Remote

2. 修改

2.1 暂存修改

操作一览

如果在工作的时候出现了临时需要解决的问题，而你又不希望提交，那么有个stash功能

git stash

在暂存后工作区会回退到最近的一个 commit 的状态，以便开建新分支；比如我们修复 bug 时，我们会通过创建新的 bug 分支进行修复，然后合并，最后删除；

当手头工作没有完成时，先把工作现场git stash一下，然后去修复 bug，修复后，再git stash pop，回到工作现场。

2.2 撤销修改

还未提交到暂存区

当修改还没有被add的时候，可以使用

git checkout -- filename.txt

来丢弃工作区某文件的修改，当然也可以把后面的文件改成*来撤销所有文件的修改。这是用仓库的文件覆盖工作区的文件。

注意这里用的是--，如果没有这个--的话就变成切换分支了。

还未提交到仓库

如果你的修改已经被add到了暂存区，但是还没有被commit，那么可以使用

git reset HEAD filename.txt
git checkout -- filename.txt

首先用reset来把修改撤回到工作区，再使用上面的checkout命令撤回工作区的修改。这里的reset相当于add的反操作。

已经提交到仓库

则可以版本回退

git reset --hard 15zdx2s

这里的--hard表示强制回退，丢弃本地的修改。这个回退比较野蛮，该版本号之后的提交都将不可见。

撤销之前某一个提交

git revert撤销一个提交的同时会创建一个新的提交，这是一个安全的方法，因为它不会重写提交历史。但实现上和reset是完全不同的。它撤销这个提交引入的更改，然后在最后加上一个撤销了更改的新提交，而不是从项目历史中移除这个提交。

git revert 46af7z6

相较于reset ，revert不会改变项目历史，对那些已经发布到共享仓库的提交来说这是一个安全的操作。其次git revert 可以将提交历史中的任何一个提交撤销、而reset会把历史上某个提交及之后所有的提交都移除掉，这太野蛮了。

相比 reset，它不会改变现在的提交历史。因此，revert 可以用在公共分支上，reset 应该用在私有分支上。

合并 commit

如果已经commit了怎么办，如果要撤回目前的commit，可以把它合并到上一个commit中

git rebase -i HEAD~~

在出现的两个提交信息的pick改为fixup

3. 分支操作

3.1 创建/查看/合并分支

操作一览

创建分支

# 创建新分支
git branch bug-fix
# 查看分支，-a查看本地和远程的分支，-r查看远程分支，-l或没有只查看本地
git branch -a
# 切换到刚刚创建的分支
git checkout bug-fix

上面两个步骤可以合并为

# 创建并切换到分支
git checkout -b bug-fix

如果修改一下本地文件之后在这个分支继续培育一个版本之后，怎么去合并到主分支呢？

git add *
git commit -m "some change"
# 切换到主分支
git checkout master
# 合并分支
git merge bug-fix
# 删除分支 (可选)
git branch -d bug-fix

如果 master 分支和新的分支都各自培育了版本，那么自动合并通常会失败，发生冲突conflict，此时需要打开文件解决冲突之后commit一个版本以完成合并

git add *
git commit -m "branch merge"

这里提一下，merge的时候有几个主要模式，--no-ff、fast-forward，其中fast-forward是默认的

1. fast-forward：在 master 开始的新分支前进了几个版本之后如果需要 merge 回来，此时 master 并没有前进，那么这个模式就是把 HEAD 与 master 指针指向新分支上，完成合并。这种情况如果删除分支，则会丢失分支信息，因为在这个过程中并没有创建 commit。
2. --no-ff：关闭默认的fast-forward模式，也就是在 merge 的时候生成一个新的 commit，这样在分支历史上就可以看出分支信息。

3.2 远程仓库操作

操作一览

关于各个分支，哪些需要推送呢？

1. master分支是主分支，因此要时刻与远程同步；
2. dev分支是开发分支，团队所有成员都需要在上面工作，所以也需要与远程同步；
3. bug分支只用于在本地修复 bug，就没必要推到远程了，除非老板要看看你每周到底修复了几个 bug；
4. feature分支是否推到远程，取决于你是否和你的小伙伴合作在上面开发。

直接clone

在 GitHub 上创建一个新的项目之后，比如叫learn-git，那么可以直接clone下来，注意创建的时候不要选择 Initialize this repository with a README，我们要的是一个空的仓库。

git clone https://github.com/SHERlocked93/learn-git.git

这样在本地就直接创建了一个空的文件夹learn-git，当然里面有.git文件夹。
也可以使用 SSH 地址来 clone，速度会快一些，也不用每次推送都输入口令，推介使用这种：

git clone git@github.com:SHERlocked93/learn-git.git

添加一个文件filename.txt之后

git add filename.txt
git commit -m "add filename.txt"
git push -u origin master

这样就把本地新建的文件 push 到了远程仓库

本地与远程建立关联

如果已经有了本地工程文件夹，如何分享到 GitHub 远程仓库呢？当然此时我们已经在 GitHub 上创建了一个新的空白项目，还是叫learn-git，在本地文件夹中

git init
# 关联远程库
git remote add origin git@github.com:SHERlocked93/learn-git.git
git push -u origin master

就可以了，如果你的远程仓库已经有了提交，那么在push之前需要

# 允许不想干库合并
git pull origin master --allow-unrelated-histories
git push -u origin master

先拉取远程分支，注意这里--allow-unrelated-histories允许两个不想干的分支强行合并，再push；这样在 GitHub 的网站上还能看到 commit 记录。

也可以强硬一点直接强行推送

# -f 强行推送
git push -u origin master -f

这样本地仓库就直接把远程仓库覆盖了，且 GitHub 上也看不到历史commit了，如果不想被同事枪击的话，还是推介上一种做法。

同步远程仓库

那么已经 clone 的仓库如果希望同步原仓库新的提交怎么办？

# 从远程分支拉取代码到本地
git pull upstream master
# push到自己的库里
git push  origin master

3.3 多人协作

多人协作的工作模式通常是这样：

1. 首先，可以试图用git push origin <branch-name>推送自己的修改
2. 如果推送失败，则因为远程分支比你的本地更新，需要先用git pull试图合并
3. 如果合并有冲突，则解决冲突，并在本地提交
4. 没有冲突或者解决掉冲突后，再用git push origin <branch-name>推送就能成功

从远程抓取分支，使用git pull，如果有冲突，要先处理冲突，add->commit->push。如果git pull提示 no tracking information，则说明本地分支和远程分支的链接关系没有创建，用命令git branch --set-upstream-to <branch-name> origin/<branch-name>。

4. 标签操作

操作一览

如果要删除远程分支，需要

# 首先删除本地tag，假如tag是v0.9
git tag -d v0.9
# 再从远程删除
git push origin :refs/tags/v0.9

5. 提交格式

type：

• feat: 新特性，添加功能
• fix: 修改 bug
• refactor: 代码重构
• docs: 文档修改
• style: 代码格式修改, 注意不是 css 修改
• test: 测试用例修改
• chore: 其他修改, 比如构建流程, 依赖管理

附件：Git常用命令速查表