2018年10月

节省跨多个主机安装文件和脚本的时间和精力。

自20多年前我开始使用 Linux 以来,我已经使用过基于 rpm 的软件包管理器在 Red Hat 和 Fedora Linux 系统上安装软件。我使用过 rpm 程序本身,还有 yumdnf ,用于在我的 Linux 主机上安装和更新软件包,dnfyum 的一个近亲。 yumdnf 工具是 rpm 实用程序的包装器,它提供了其他功能,例如查找和安装包依赖项的功能。

多年来,我创建了许多 Bash 脚本,其中一些脚本具有单独的配置文件,我希望在大多数新计算机和虚拟机上安装这些脚本。这也能解决安装所有这些软件包需要花费大量时间的难题,因此我决定通过创建一个 rpm 软件包来自动执行该过程,我可以将其复制到目标主机并将所有这些文件安装在适当的位置。虽然 rpm 工具以前用于构建 rpm 包,但该功能已被删除,并且创建了一个新工具来构建新的 rpm。

当我开始这个项目时,我发现很少有关于创建 rpm 包的信息,但我找到了一本书,名为《Maximum RPM》,这本书才帮我弄明白了。这本书现在已经过时了,我发现的绝大多数信息都是如此。它也已经绝版,用过的副本也需要花费数百美元。Maximum RPM 的在线版本是免费提供的,并保持最新。该 RPM 网站还有其他网站的链接,这些网站上有很多关于 rpm 的文档。其他的信息往往是简短的,显然都是假设你已经对该过程有了很多了解。

此外,我发现的每个文档都假定代码需要在开发环境中从源代码编译。我不是开发人员。我是一个系统管理员,我们系统管理员有不同的需求,因为我们不需要或者我们不应该为了管理任务而去编译代码;我们应该使用 shell 脚本。所以我们没有源代码,因为它需要被编译成二进制可执行文件。我们拥有的源代码也应该是可执行的。

在大多数情况下,此项目应作为非 root 用户执行。 rpm 包永远不应该由 root 用户构建,而只能由非特权普通用户构建。我将指出哪些部分应该以 root 身份执行,哪些部分应由非 root,非特权用户执行。

准备

首先,打开一个终端会话,然后 su 到 root 用户。 请务必使用 - 选项以确保启用完整的 root 环境。 我不认为系统管理员应该使用 sudo 来执行任何管理任务。 在我的个人博客文章中可以找出为什么:真正的系统管理员不要使用 sudo

[student@testvm1 ~]$ su -
Password:
[root@testvm1 ~]#

创建可用于此项目的普通用户 student,并为该用户设置密码。

[root@testvm1 ~]# useradd -c "Student User" student
[root@testvm1 ~]# passwd student
Changing password for user student.
New password: <Enter the password>
Retype new password: <Enter the password>
passwd: all authentication tokens updated successfully.
[root@testvm1 ~]#

构建 rpm 包需要 rpm-build 包,该包可能尚未安装。 现在以 root 身份安装它。 请注意,此命令还将安装多个依赖项。 数量可能会有所不同,具体取决于主机上已安装的软件包; 它在我的测试虚拟机上总共安装了 17 个软件包,这是非常小的。

dnf install -y rpm-build

除非另有明确指示,否则本项目的剩余部分应以普通用户用户 student 来执行。 打开另一个终端会话并使用 su 切换到该用户以执行其余步骤。 使用以下命令从 GitHub 下载我准备好的开发目录结构 utils.tar 这个 tar 包 tarball (LCTT 译注:tarball 是以 tar 命令来打包和压缩的文件的统称):

wget https://github.com/opensourceway/how-to-rpm/raw/master/utils.tar

此 tar 包包含将由最终 rpm 程序安装的所有文件和 Bash 脚本。 还有一个完整的 spec 文件,你可以使用它来构建 rpm。 我们将详细介绍 spec 文件的每个部分。

作为普通学生 student,使用你的家目录作为当前工作目录(pwd),解压缩 tar 包。

[student@testvm1 ~]$ cd ; tar -xvf utils.tar

使用 tree 命令验证 ~/development 的目录结构和包含的文件,如下所示:

[student@testvm1 ~]$ tree development/
development/
├── license
│   ├── Copyright.and.GPL.Notice.txt
│   └── GPL_LICENSE.txt
├── scripts
│   ├── create_motd
│   ├── die
│   ├── mymotd
│   └── sysdata
└── spec
    └── utils.spec

3 directories, 7 files
[student@testvm1 ~]$

mymotd 脚本创建一个发送到标准输出的“当日消息”数据流。 create_motd 脚本运行 mymotd 脚本并将输出重定向到 /etc/motd 文件。 此文件用于向使用 SSH 远程登录的用户显示每日消息。

die 脚本是我自己的脚本,它将 kill 命令包装在一些代码中,这些代码可以找到与指定字符串匹配的运行程序并将其终止。 它使用 kill -9 来确保 kill 命令一定会执行。

sysdata 脚本可以显示有关计算机硬件,还有已安装的 Linux 版本,所有已安装的软件包以及硬盘驱动器元数据等数万行数据。 我用它来记录某个时间点的主机状态。 我以后可以用它作为参考。 我曾经这样做是为了维护我为客户安装的主机记录。

你可能需要将这些文件和目录的所有权更改为 student:student 。 如有必要,使用以下命令执行此操作:

chown -R student:student development

此文件树中的大多数文件和目录将通过你在此项目期间创建的 rpm 包安装在 Fedora 系统上。

创建构建目录结构

rpmbuild 命令需要非常特定的目录结构。 你必须自己创建此目录结构,因为没有提供自动方式。 在家目录中创建以下目录结构:

~ ─ rpmbuild
    ├── RPMS
    │   └── noarch
    ├── SOURCES
    ├── SPECS
    └── SRPMS

我们不会创建 rpmbuild/RPMS/X86_64 目录,因为它是特定于体系结构编译的 64 位二进制文件。 我们有 shell 脚本,不是特定于体系结构的。 实际上,我们也不会使用 SRPMS 目录,它将包含编译器的源文件。

检查 spec 文件

每个 spec 文件都有许多部分,其中一些部分可能会被忽视或省略,取决于 rpm 构建的具体情况。 这个特定的 spec 文件不是工作所需的最小文件的示例,但它是一个包含不需要编译的文件的中等复杂 spec 文件的很好例子。 如果需要编译,它将在 %build 部分中执行,该部分在此 spec 文件中省略掉了,因为它不是必需的。

前言

这是 spec 文件中唯一没有标签的部分。 它包含运行命令 rpm -qi [Package Name] 时看到的大部分信息。 每个数据都是一行,由标签和标签值的文本数据组成。

###############################################################################
# Spec file for utils
################################################################################
# Configured to be built by user student or other non-root user
################################################################################
#
Summary: Utility scripts for testing RPM creation
Name: utils
Version: 1.0.0
Release: 1
License: GPL
URL: http://www.both.org
Group: System
Packager: David Both
Requires: bash
Requires: screen
Requires: mc
Requires: dmidecode
BuildRoot: ~/rpmbuild/

# Build with the following syntax:
# rpmbuild --target noarch -bb utils.spec

rpmbuild 程序会忽略注释行。我总是喜欢在本节中添加注释,其中包含创建包所需的 rpmbuild 命令的确切语法。

Summary 标签是包的简短描述。

NameVersionRelease 标签用于创建 rpm 文件的名称,如 utils-1.00-1.rpm。通过增加发行版号码和版本号,你可以创建 rpm 包去更新旧版本的。

License 标签定义了发布包的许可证。我总是使用 GPL 的一个变体。指定许可证对于澄清包中包含的软件是开源的这一事实非常重要。这也是我将 LicenseGPL 语句包含在将要安装的文件中的原因。

URL 通常是项目或项目所有者的网页。在这种情况下,它是我的个人网页。

Group 标签很有趣,通常用于 GUI 应用程序。 Group 标签的值决定了应用程序菜单中的哪一组图标将包含此包中可执行文件的图标。与 Icon 标签(我们此处未使用)一起使用时,Group 标签允许在应用程序菜单结构中添加用于启动程序的图标和所需信息。

Packager 标签用于指定负责维护和创建包的人员或组织。

Requires 语句定义此 rpm 包的依赖项。每个都是包名。如果其中一个指定的软件包不存在,DNF 安装实用程序将尝试在 /etc/yum.repos.d 中定义的某个已定义的存储库中找到它,如果存在则安装它。如果 DNF 找不到一个或多个所需的包,它将抛出一个错误,指出哪些包丢失并终止。

BuildRoot 行指定顶级目录,rpmbuild 工具将在其中找到 spec 文件,并在构建包时在其中创建临时目录。完成的包将存储在我们之前指定的 noarch 子目录中。

注释显示了构建此程序包的命令语法,包括定义了目标体系结构的 –target noarch 选项。因为这些是 Bash 脚本,所以它们与特定的 CPU 架构无关。如果省略此选项,则构建将选用正在执行构建的 CPU 的体系结构。

rpmbuild 程序可以针对许多不同的体系结构,并且使用 --target 选项允许我们在不同的体系结构主机上构建特定体系结构的包,其具有与执行构建的体系结构不同的体系结构。所以我可以在 x86\_64 主机上构建一个用于 i686 架构的软件包,反之亦然。

如果你有自己的网站,请将打包者的名称更改为你自己的网站。

描述部分(%description

spec 文件的 %description 部分包含 rpm 包的描述。 它可以很短,也可以包含许多信息。 我们的 %description 部分相当简洁。

%description
A collection of utility scripts for testing RPM creation.

准备部分(%prep

%prep 部分是在构建过程中执行的第一个脚本。 在安装程序包期间不会执行此脚本。

这个脚本只是一个 Bash shell 脚本。 它准备构建目录,根据需要创建用于构建的目录,并将相应的文件复制到各自的目录中。 这将包括作为构建的一部分的完整编译所需的源代码。

$RPM_BUILD_ROOT 目录表示已安装系统的根目录。 在 $RPM_BUILD_ROOT 目录中创建的目录是真实文件系统中的绝对路径,例如 /user/local/share/utils/usr/local/bin 等。

对于我们的包,我们没有预编译源,因为我们的所有程序都是 Bash 脚本。 因此,我们只需将这些脚本和其他文件复制到已安装系统的目录中。

%prep
################################################################################
# Create the build tree and copy the files from the development directories    #
# into the build tree.                                                         #
################################################################################
echo "BUILDROOT = $RPM_BUILD_ROOT"
mkdir -p $RPM_BUILD_ROOT/usr/local/bin/
mkdir -p $RPM_BUILD_ROOT/usr/local/share/utils

cp /home/student/development/utils/scripts/* $RPM_BUILD_ROOT/usr/local/bin
cp /home/student/development/utils/license/* $RPM_BUILD_ROOT/usr/local/share/utils
cp /home/student/development/utils/spec/* $RPM_BUILD_ROOT/usr/local/share/utils

exit

请注意,本节末尾的 exit 语句是必需的。

文件部分(%files

spec 文件的 %files 这一部分定义了要安装的文件及其在目录树中的位置。 它还指定了要安装的每个文件的文件属性(%attr)以及所有者和组所有者。 文件权限和所有权是可选的,但我建议明确设置它们以消除这些属性在安装时不正确或不明确的任何可能性。 如果目录尚不存在,则会在安装期间根据需要创建目录。

%files
%attr(0744, root, root) /usr/local/bin/*
%attr(0644, root, root) /usr/local/share/utils/*

安装前(%pre

在我们的实验室项目的 spec 文件中,此部分为空。 这应该放置那些需要 rpm 中的文件安装前执行的脚本。

安装后(%post

spec 文件的这一部分是另一个 Bash 脚本。 这个在文件安装后运行。 此部分几乎可以是你需要或想要的任何内容,包括创建文件、运行系统命令以及重新启动服务以在进行配置更改后重新初始化它们。 我们的 rpm 包的 %post 脚本执行其中一些任务。

%post
################################################################################
# Set up MOTD scripts                                                          #
################################################################################
cd /etc
# Save the old MOTD if it exists
if [ -e motd ]
then
   cp motd motd.orig
fi
# If not there already, Add link to create_motd to cron.daily
cd /etc/cron.daily
if [ ! -e create_motd ]
then
   ln -s /usr/local/bin/create_motd
fi
# create the MOTD for the first time
/usr/local/bin/mymotd > /etc/motd

此脚本中包含的注释应明确其用途。

卸载后(%postun

此部分包含将在卸载 rpm 软件包后运行的脚本。 使用 rpmdnf 删除包会删除文件部分中列出的所有文件,但它不会删除安装后部分创建的文件或链接,因此我们需要在本节中处理。

此脚本通常由清理任务组成,只是清除以前由 rpm 安装的文件,但 rpm 本身无法完成清除。 对于我们的包,它包括删除 %post 脚本创建的链接并恢复 motd 文件的已保存原件。

%postun
# remove installed files and links
rm /etc/cron.daily/create_motd

# Restore the original MOTD if it was backed up
if [ -e /etc/motd.orig ]
then
   mv -f /etc/motd.orig /etc/motd
fi

清理(%clean

这个 Bash 脚本在 rpm 构建过程之后开始清理。 下面 %clean 部分中的两行删除了 rpm-build 命令创建的构建目录。 在许多情况下,可能还需要额外的清理。

%clean
rm -rf $RPM_BUILD_ROOT/usr/local/bin
rm -rf $RPM_BUILD_ROOT/usr/local/share/utils

变更日志(%changelog

此可选的文本部分包含 rpm 及其包含的文件的变更列表。最新的变更记录在本部分顶部。

%changelog
* Wed Aug 29 2018 Your Name <[email protected]>
  - The original package includes several useful scripts. it is
    primarily intended to be used to illustrate the process of
    building an RPM.

使用你自己的姓名和电子邮件地址替换标题行中的数据。

构建 rpm

spec 文件必须位于 rpmbuild 目录树的 SPECS 目录中。 我发现最简单的方法是创建一个指向该目录中实际 spec 文件的链接,以便可以在开发目录中对其进行编辑,而无需将其复制到 SPECS 目录。 将 SPECS 目录设为当前工作目录,然后创建链接。

cd ~/rpmbuild/SPECS/
ln -s ~/development/spec/utils.spec

运行以下命令以构建 rpm。 如果没有错误发生,只需要花一点时间来创建 rpm。

rpmbuild --target noarch -bb utils.spec

检查 ~/rpmbuild/RPMS/noarch 目录以验证新的 rpm 是否存在。

[student@testvm1 ~]$ cd rpmbuild/RPMS/noarch/
[student@testvm1 noarch]$ ll
total 24
-rw-rw-r--. 1 student student 24364 Aug 30 10:00 utils-1.0.0-1.noarch.rpm
[student@testvm1 noarch]$

测试 rpm

以 root 用户身份安装 rpm 以验证它是否正确安装并且文件是否安装在正确的目录中。 rpm 的确切名称将取决于你在前言部分中标签的值,但如果你使用了示例中的值,则 rpm 名称将如下面的示例命令所示:

[root@testvm1 ~]# cd /home/student/rpmbuild/RPMS/noarch/
[root@testvm1 noarch]# ll
total 24
-rw-rw-r--. 1 student student 24364 Aug 30 10:00 utils-1.0.0-1.noarch.rpm
[root@testvm1 noarch]# rpm -ivh utils-1.0.0-1.noarch.rpm
Preparing...                          ################################# [100%]
Updating / installing...
   1:utils-1.0.0-1                    ################################# [100%]

检查 /usr/local/bin 以确保新文件存在。 你还应验证是否已创建 /etc/cron.daily 中的 create_motd 链接。

使用 rpm -q --changelog utils 命令查看更改日志。 使用 rpm -ql utils 命令(在 ql 中为小写 L )查看程序包安装的文件。

[root@testvm1 noarch]# rpm -q --changelog utils
* Wed Aug 29 2018 Your Name <[email protected]>
- The original package includes several useful scripts. it is
    primarily intended to be used to illustrate the process of
    building an RPM.

[root@testvm1 noarch]# rpm -ql utils
/usr/local/bin/create_motd
/usr/local/bin/die
/usr/local/bin/mymotd
/usr/local/bin/sysdata
/usr/local/share/utils/Copyright.and.GPL.Notice.txt
/usr/local/share/utils/GPL_LICENSE.txt
/usr/local/share/utils/utils.spec
[root@testvm1 noarch]#

删除包。

rpm -e utils

试验

现在,你将更改 spec 文件以要求一个不存在的包。 这将模拟无法满足的依赖关系。 在现有依赖行下立即添加以下行:

Requires: badrequire

构建包并尝试安装它。 显示什么消息?

我们使用 rpm 命令来安装和删除 utils 包。 尝试使用 yumdnf 安装软件包。 你必须与程序包位于同一目录中,或指定程序包的完整路径才能使其正常工作。

总结

在这篇对创建 rpm 包的基础知识的概览中,我们没有涉及很多标签和很多部分。 下面列出的资源可以提供更多信息。 构建 rpm 包并不困难;你只需要正确的信息。 我希望这对你有所帮助——我花了几个月的时间来自己解决问题。

我们没有涵盖源代码构建,但如果你是开发人员,那么从这一点开始应该是一个简单的步骤。

创建 rpm 包是另一种成为懒惰系统管理员的好方法,可以节省时间和精力。 它提供了一种简单的方法来分发和安装那些我们作为系统管理员需要在许多主机上安装的脚本和其他文件。

资料

  • Edward C. Baily,《Maximum RPM》,Sams 出版于 2000 年,ISBN 0-672-31105-4
  • Edward C. Baily,《Maximum RPM》,更新在线版本
  • RPM 文档:此网页列出了 rpm 的大多数可用在线文档。 它包括许多其他网站的链接和有关 rpm 的信息。

via: https://opensource.com/article/18/9/how-build-rpm-packages

作者:David Both 选题:lujun9972 译者:Flowsnow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

你所需了解的容器如何工作的知识。

现在人们严重过度使用了“容器”这个术语。另外,对不同的人来说,它可能会有不同的含义,这取决于上下文。

传统的 Linux 容器只是系统上普通的进程。一组进程与另外一组进程是相互隔离的,实现方法包括:资源限制(控制组 [cgoups])、Linux 安全限制(文件权限,基于 Capability 的安全模块、SELinux、AppArmor、seccomp 等)还有名字空间(进程 ID、网络、挂载等)。

如果你启动一台现代 Linux 操作系统,使用 cat /proc/PID/cgroup 命令就可以看到该进程是属于一个控制组的。还可以从 /proc/PID/status 文件中查看进程的 Capability 信息,从 /proc/self/attr/current 文件中查看进程的 SELinux 标签信息,从 /proc/PID/ns 目录下的文件查看进程所属的名字空间。因此,如果把容器定义为带有资源限制、Linux 安全限制和名字空间的进程,那么按照这个定义,Linux 操作系统上的每一个进程都在一个容器里。因此我们常说 Linux 就是容器,容器就是 Linux。而容器运行时是这样一种工具,它调整上述资源限制、安全限制和名字空间,并启动容器。

Docker 引入了容器镜像的概念,镜像是一个普通的 TAR 包文件,包含了:

  • rootfs(容器的根文件系统):一个目录,看起来像是操作系统的普通根目录(/),例如,一个包含 /usr, /var, /home 等的目录。
  • JSON 文件(容器的配置):定义了如何运行 rootfs;例如,当容器启动的时候要在 rootfs 里运行什么命令(CMD)或者入口(ENTRYPOINT),给容器定义什么样的环境变量(ENV),容器的工作目录(WORKDIR)是哪个,以及其他一些设置。

Docker 把 rootfs 和 JSON 配置文件打包成基础镜像。你可以在这个基础之上,给 rootfs 安装更多东西,创建新的 JSON 配置文件,然后把相对于原始镜像的不同内容打包到新的镜像。这种方法创建出来的是分层的镜像

开放容器计划 Open Container Initiative (OCI)标准组织最终把容器镜像的格式标准化了,也就是 镜像规范 OCI Image Specification (OCI)。

用来创建容器镜像的工具被称为容器镜像构建器。有时候容器引擎做这件事情,不过可以用一些独立的工具来构建容器镜像。

Docker 把这些容器镜像(tar 包)托管到 web 服务中,并开发了一种协议来支持从 web 拉取镜像,这个 web 服务就叫 容器仓库 container registry

容器引擎是能从镜像仓库拉取镜像并装载到容器存储上的程序。容器引擎还能启动容器运行时(见下图)。

容器存储一般是 写入时复制 copy-on-write (COW)的分层文件系统。从容器仓库拉取一个镜像时,其中的 rootfs 首先被解压到磁盘。如果这个镜像是多层的,那么每一层都会被下载到 COW 文件系统的不同分层。 COW 文件系统保证了镜像的每一层独立存储,这最大化了多个分层镜像之间的文件共享程度。容器引擎通常支持多种容器存储类型,包括 overlaydevicemapperbtrfsaufszfs

容器引擎将容器镜像下载到容器存储中之后,需要创建一份容器运行时配置,这份配置是用户/调用者的输入和镜像配置的合并。例如,容器的调用者可能会调整安全设置,添加额外的环境变量或者挂载一些卷到容器中。

容器运行时配置的格式,和解压出来的 rootfs 也都被开放容器计划 OCI 标准组织做了标准化,称为 OCI 运行时规范

最终,容器引擎启动了一个容器运行时来读取运行时配置,修改 Linux 控制组、安全限制和名字空间,并执行容器命令来创建容器的 PID 1 进程。至此,容器引擎已经可以把容器的标准输入/标准输出转给调用方,并控制容器了(例如,stopstartattach)。

值得一提的是,现在出现了很多新的容器运行时,它们使用 Linux 的不同特性来隔离容器。可以使用 KVM 技术来隔离容器(想想迷你虚拟机),或者使用其他虚拟机监视器策略(例如拦截所有从容器内的进程发起的系统调用)。既然我们有了标准的运行时规范,这些工具都能被相同的容器引擎来启动。即使在 Windows 系统下,也可以使用 OCI 运行时规范来启动 Windows 容器。

容器编排器是一个更高层次的概念。它是在多个不同的节点上协调容器执行的工具。容器编排工具通过和容器引擎的通信来管理容器。编排器控制容器引擎做容器的启动和容器间的网络连接,它能够监控容器,在负载变高的时候进行容器扩容。


via: https://opensource.com/article/18/8/sysadmins-guide-containers

作者:Daniel J Walsh 选题:lujun9972 译者:belitex 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在过去的几个月里,我一直在使用 React 和 React-Native。我已经发布了两个作为产品的应用, Kiven Aa(React)和 Pollen Chat(React Native)。当我开始学习 React 时,我找了一些不仅仅是教我如何用 React 写应用的东西(一个博客,一个视频,一个课程,等等),我也想让它帮我做好面试准备。

我发现的大部分资料都集中在某一单一方面上。所以,这篇文章针对的是那些希望理论与实践完美结合的观众。我会告诉你一些理论,以便你了解幕后发生的事情,然后我会向你展示如何编写一些 React.js 代码。

如果你更喜欢视频形式,我在 YouTube 上传了整个课程,请去看看。

让我们开始……

React.js 是一个用于构建用户界面的 JavaScript 库

你可以构建各种单页应用程序。例如,你希望在用户界面上实时显示变化的聊天软件和电子商务门户。

一切都是组件

React 应用由组件组成,数量繁多且互相嵌套。你或许会问:”可什么是组件呢?“

组件是可重用的代码段,它定义了某些功能在 UI 上的外观和行为。 比如,按钮就是一个组件。

让我们看看下面的计算器,当你尝试计算 2 + 2 = 4 -1 = 3(简单的数学题)时,你会在 Google 上看到这个计算器。

红色标记表示组件

如上图所示,这个计算器有很多区域,比如展示窗口和数字键盘。所有这些都可以是许多单独的组件或一个巨大的组件。这取决于在 React 中分解和抽象出事物的程度。你为所有这些组件分别编写代码,然后合并这些组件到一个容器中,而这个容器又是一个 React 组件。这样你就可以创建可重用的组件,最终的应用将是一组协同工作的单独组件。

以下是一个你践行了以上原则并可以用 React 编写计算器的方法。

<Calculator>
  <DisplayWindow />
  <NumPad>
    <Key number={1}/>
    <Key number={2}/>
    .
    .
    .
    <Key number={9}/>
  </NumPad>
</Calculator>

没错!它看起来像HTML代码,然而并不是。我们将在后面的部分中详细探讨它。

设置我们的 Playground

这篇教程专注于 React 的基础部分。它没有偏向 Web 或 React Native(开发移动应用)。所以,我们会用一个在线编辑器,这样可以在学习 React 能做什么之前避免 web 或 native 的具体配置。

我已经为读者在 codepen.io 设置好了开发环境。只需点开该链接并且阅读 HTML 和 JavaScript 中的所有注释。

控制组件

我们已经了解到 React 应用是各种组件的集合,结构为嵌套树。因此,我们需要某种机制来将数据从一个组件传递到另一个组件。

进入 “props”

我们可以使用 props 对象将任意数据传递给我们的组件。 React 中的每个组件都会获取 props 对象。在学习如何使用 props 之前,让我们学习函数式组件。

a) 函数式组件

在 React 中,一个函数式组件通过 props 对象使用你传递给它的任意数据。它返回一个对象,该对象描述了 React 应渲染的 UI。函数式组件也称为无状态组件。

让我们编写第一个函数式组件。

function Hello(props) {
  return <div>{props.name}</div>
}

就这么简单。我们只是将 props 作为参数传递给了一个普通的 JavaScript 函数并且有返回值。嗯?返回了什么?那个 <div>{props.name}</div>。它是 JSX(JavaScript Extended)。我们将在后面的部分中详细了解它。

上面这个函数将在浏览器中渲染出以下 HTML。

<!-- If the "props" object is: {name: 'rajat'} -->
<div>
  rajat
</div>
阅读以下有关 JSX 的部分,这一部分解释了如何从我们的 JSX 代码中得到这段 HTML 。

如何在 React 应用中使用这个函数式组件? 很高兴你问了! 它就像下面这么简单。

<Hello name='rajat' age={26}/>

属性 name 在上面的代码中变成了 Hello 组件里的 props.name ,属性 age 变成了 props.age

记住! 你可以将一个 React 组件嵌套在其他 React 组件中。

让我们在 codepen playground 使用 Hello 组件。用我们的 Hello 组件替换 ReactDOM.render() 中的 div,并在底部窗口中查看更改。

function Hello(props) {
  return <div>{props.name}</div>
}

ReactDOM.render(<Hello name="rajat"/>, document.getElementById('root'));
但是如果你的组件有一些内部状态怎么办?例如,像下面的计数器组件一样,它有一个内部计数变量,它在 +- 键按下时发生变化。

具有内部状态的 React 组件

b) 基于类的组件

基于类的组件有一个额外属性 state ,你可以用它存放组件的私有数据。我们可以用 class 表示法重写我们的 Hello 。由于这些组件具有状态,因此这些组件也称为有状态组件。

class Counter extends React.Component {
  // this method should be present in your component
  render() {
    return (
      <div>
        {this.props.name}
      </div>
    );
  }
}

我们继承了 React 库的 React.Component 类以在 React 中创建基于类的组件。在这里了解更多有关 JavaScript 类的东西。

render() 方法必须存在于你的类中,因为 React 会查找此方法,用以了解它应在屏幕上渲染的 UI。为了使用这种内部状态,我们首先要在组件

要使用这种内部状态,我们首先必须按以下方式初始化组件类的构造函数中的状态对象。

class Counter extends React.Component {
  constructor() {
    super();
    
    // define the internal state of the component
    this.state = {name: 'rajat'}
  }
  
  render() {
    return (
      <div>
        {this.state.name}
      </div>
    );
  }
}

// Usage:
// In your react app: <Counter />

类似地,可以使用 this.props 对象在我们基于类的组件内访问 props

要设置 state,请使用 React.ComponentsetState()。 在本教程的最后一部分中,我们将看到一个这样的例子。

提示:永远不要在 render() 函数中调用 setState(),因为 setState 会导致组件重新渲染,这将导致无限循环。

基于类的组件具有可选属性 “state”。

除了 state 以外,基于类的组件有一些声明周期方法比如 componentWillMount()。你可以利用这些去做初始化 state这样的事, 可是那将超出这篇文章的范畴。

JSX

JSX 是 JavaScript Extended 的缩写,它是一种编写 React 组件的方法。使用 JSX,你可以在类 XML 标签中获得 JavaScript 的全部力量。

你把 JavaScript 表达式放在 {} 里。下面是一些有效的 JSX 例子。

 <button disabled={true}>Press me!</button>
 <button disabled={true}>Press me {3+1} times!</button>;
 <div className='container'><Hello /></div>

它的工作方式是你编写 JSX 来描述你的 UI 应该是什么样子。像 Babel 这样的转码器将这些代码转换为一堆 React.createElement() 调用。然后,React 库使用这些 React.createElement() 调用来构造 DOM 元素的树状结构。对于 React 的网页视图或 React Native 的 Native 视图,它将保存在内存中。

React 接着会计算它如何在展示给用户的 UI 的内存中有效地模仿这个树。此过程称为 reconciliation。完成计算后,React 会对屏幕上的真正 UI 进行更改。

React 如何将你的 JSX 转化为描述应用 UI 的树。

你可以使用 Babel 的在线 REPL 查看当你写一些 JSX 的时候,React 的真正输出。

使用Babel REPL 转换 JSX 为普通 JavaScript

由于 JSX 只是 React.createElement() 调用的语法糖,因此可以在没有 JSX 的情况下使用 React。

现在我们了解了所有的概念,所以我们已经准备好编写我们之前看到之前的 GIF 图中的计数器组件。

代码如下,我希望你已经知道了如何在我们的 playground 上渲染它。

class Counter extends React.Component {
  constructor(props) {
    super(props);
    
    this.state = {count: this.props.start || 0}
    
    // the following bindings are necessary to make `this` work in the callback
    this.inc = this.inc.bind(this);
    this.dec = this.dec.bind(this);
  }
  
  inc() {
    this.setState({
      count: this.state.count + 1
    });
  }
  
  dec() {
    this.setState({
      count: this.state.count - 1
    });
  }
  
  render() {
    return (
      <div>
        <button onClick={this.inc}>+</button>
        <button onClick={this.dec}>-</button>
        <div>{this.state.count}</div>
      </div>
    );
  }
}

以下是关于上述代码的一些重点。

  1. JSX 使用 驼峰命名 ,所以 button 的 属性是 onClick,不是我们在HTML中用的 onclick
  2. 绑定 this 是必要的,以便在回调时工作。 请参阅上面代码中的第8行和第9行。

最终的交互式代码位于此处

有了这个,我们已经到了 React 速成课程的结束。我希望我已经阐明了 React 如何工作,以及如何使用 React 来构建更大的应用程序,使用更小和可重用的组件。


via: https://medium.freecodecamp.org/rock-solid-react-js-foundations-a-beginners-guide-c45c93f5a923

作者:Rajat Saxena 译者:GraveAccent 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Python 现在越来越火,已经迅速扩张到包括 DevOps、数据科学、Web 开发、信息安全等各个领域当中。

然而,相比起 Python 扩张的速度,Python 代码的运行速度就显得有点逊色了。

在代码运行速度方面,Java、C、C++、C# 和 Python 要如何进行比较呢?并没有一个放之四海而皆准的标准,因为具体结果很大程度上取决于运行的程序类型,而 语言基准测试 Computer Language Benchmarks Games 可以作为衡量的一个方面

根据我这些年来进行语言基准测试的经验来看,Python 比很多语言运行起来都要慢。无论是使用 JIT 编译器的 C#、Java,还是使用 AOT 编译器的 C、C++,又或者是 JavaScript 这些解释型语言,Python 都比它们运行得慢

注意:对于文中的 “Python” ,一般指 CPython 这个官方的实现。当然我也会在本文中提到其它语言的 Python 实现。

我要回答的是这个问题:对于一个类似的程序,Python 要比其它语言慢 2 到 10 倍不等,这其中的原因是什么?又有没有改善的方法呢?

主流的说法有这些:

  • “是 全局解释器锁 Global Interpreter Lock (GIL)的原因”
  • “是因为 Python 是解释型语言而不是编译型语言”
  • “是因为 Python 是一种动态类型的语言”

哪一个才是是影响 Python 运行效率的主要原因呢?

是全局解释器锁的原因吗?

现在很多计算机都配备了具有多个核的 CPU ,有时甚至还会有多个处理器。为了更充分利用它们的处理能力,操作系统定义了一个称为线程的低级结构。某一个进程(例如 Chrome 浏览器)可以建立多个线程,在系统内执行不同的操作。在这种情况下,CPU 密集型进程就可以跨核心分担负载了,这样的做法可以大大提高应用程序的运行效率。

例如在我写这篇文章时,我的 Chrome 浏览器打开了 44 个线程。需要提及的是,基于 POSIX 的操作系统(例如 Mac OS、Linux)和 Windows 操作系统的线程结构、API 都是不同的,因此操作系统还负责对各个线程的调度。

如果你还没有写过多线程执行的代码,你就需要了解一下线程锁的概念了。多线程进程比单线程进程更为复杂,是因为需要使用线程锁来确保同一个内存地址中的数据不会被多个线程同时访问或更改。

CPython 解释器在创建变量时,首先会分配内存,然后对该变量的引用进行计数,这称为 引用计数 reference counting 。如果变量的引用数变为 0,这个变量就会从内存中释放掉。这就是在 for 循环代码块内创建临时变量不会增加内存消耗的原因。

而当多个线程内共享一个变量时,CPython 锁定引用计数的关键就在于使用了 GIL,它会谨慎地控制线程的执行情况,无论同时存在多少个线程,解释器每次只允许一个线程进行操作。

这会对 Python 程序的性能有什么影响?

如果你的程序只有单线程、单进程,代码的速度和性能不会受到全局解释器锁的影响。

但如果你通过在单进程中使用多线程实现并发,并且是 IO 密集型(例如网络 IO 或磁盘 IO)的线程,GIL 竞争的效果就很明显了。

由 David Beazley 提供的 GIL 竞争情况图http://dabeaz.blogspot.com/2010/01/python-gil-visualized.html

对于一个 web 应用(例如 Django),同时还使用了 WSGI,那么对这个 web 应用的每一个请求都运行一个单独的 Python 解释器,而且每个请求只有一个锁。同时因为 Python 解释器的启动比较慢,某些 WSGI 实现还具有“守护进程模式”,可以使 Python 进程一直就绪

其它的 Python 解释器表现如何?

PyPy 也是一种带有 GIL 的解释器,但通常比 CPython 要快 3 倍以上。

Jython 则是一种没有 GIL 的解释器,这是因为 Jython 中的 Python 线程使用 Java 线程来实现,并且由 JVM 内存管理系统来进行管理。

JavaScript 在这方面又是怎样做的呢?

所有的 Javascript 引擎使用的都是 mark-and-sweep 垃圾收集算法,而 GIL 使用的则是 CPython 的内存管理算法。

JavaScript 没有 GIL,而且它是单线程的,也不需要用到 GIL, JavaScript 的事件循环和 Promise/Callback 模式实现了以异步编程的方式代替并发。在 Python 当中也有一个类似的 asyncio 事件循环。

是因为 Python 是解释型语言吗?

我经常会听到这个说法,但是这过于粗陋地简化了 Python 所实际做的工作了。其实当终端上执行 python myscript.py 之后,CPython 会对代码进行一系列的读取、语法分析、解析、编译、解释和执行的操作。

如果你对这一系列过程感兴趣,也可以阅读一下我之前的文章:在 6 分钟内修改 Python 语言

.pyc 文件的创建是这个过程的重点。在代码编译阶段,Python 3 会将字节码序列写入 __pycache__/ 下的文件中,而 Python 2 则会将字节码序列写入当前目录的 .pyc 文件中。对于你编写的脚本、导入的所有代码以及第三方模块都是如此。

因此,绝大多数情况下(除非你的代码是一次性的……),Python 都会解释字节码并本地执行。与 Java、C#.NET 相比:

Java 代码会被编译为“中间语言”,由 Java 虚拟机读取字节码,并将其即时编译为机器码。.NET CIL 也是如此,.NET CLR(Common-Language-Runtime)将字节码即时编译为机器码。

既然 Python 像 Java 和 C# 那样都使用虚拟机或某种字节码,为什么 Python 在基准测试中仍然比 Java 和 C# 慢得多呢?首要原因是,.NET 和 Java 都是 JIT 编译的。

即时 Just-in-time (JIT)编译需要一种中间语言,以便将代码拆分为多个块(或多个帧)。而 提前 ahead of time (AOT)编译器则需要确保 CPU 在任何交互发生之前理解每一行代码。

JIT 本身不会使执行速度加快,因为它执行的仍然是同样的字节码序列。但是 JIT 会允许在运行时进行优化。一个优秀的 JIT 优化器会分析出程序的哪些部分会被多次执行,这就是程序中的“热点”,然后优化器会将这些代码替换为更有效率的版本以实现优化。

这就意味着如果你的程序是多次重复相同的操作时,有可能会被优化器优化得更快。而且,Java 和 C# 是强类型语言,因此优化器对代码的判断可以更为准确。

PyPy 使用了明显快于 CPython 的 JIT。更详细的结果可以在这篇性能基准测试文章中看到:哪一个 Python 版本最快?

那为什么 CPython 不使用 JIT 呢?

JIT 也不是完美的,它的一个显著缺点就在于启动时间。 CPython 的启动时间已经相对比较慢,而 PyPy 比 CPython 启动还要慢 2 到 3 倍。Java 虚拟机启动速度也是出了名的慢。.NET CLR 则通过在系统启动时启动来优化体验,而 CLR 的开发者也是在 CLR 上开发该操作系统。

因此如果你有个长时间运行的单一 Python 进程,JIT 就比较有意义了,因为代码里有“热点”可以优化。

不过,CPython 是个通用的实现。设想如果使用 Python 开发命令行程序,但每次调用 CLI 时都必须等待 JIT 缓慢启动,这种体验就相当不好了。

CPython 试图用于各种使用情况。有可能实现将 JIT 插入到 CPython 中,但这个改进工作的进度基本处于停滞不前的状态。

如果你想充分发挥 JIT 的优势,请使用 PyPy。

是因为 Python 是一种动态类型的语言吗?

在 C、C++、Java、C#、Go 这些静态类型语言中,必须在声明变量时指定变量的类型。而在动态类型语言中,虽然也有类型的概念,但变量的类型是可改变的。

a = 1
a = "foo"

在上面这个示例里,Python 将变量 a 一开始存储整数类型变量的内存空间释放了,并创建了一个新的存储字符串类型的内存空间,并且和原来的变量同名。

静态类型语言这样的设计并不是为了为难你,而是为了方便 CPU 运行而这样设计的。因为最终都需要将所有操作都对应为简单的二进制操作,因此必须将对象、类型这些高级的数据结构转换为低级数据结构。

Python 也实现了这样的转换,但用户看不到这些转换,也不需要关心这些转换。

不用必须声明类型并不是为了使 Python 运行慢,Python 的设计是让用户可以让各种东西变得动态:可以在运行时更改对象上的方法,也可以在运行时动态添加底层系统调用到值的声明上,几乎可以做到任何事。

但也正是这种设计使得 Python 的优化异常的难。

为了证明我的观点,我使用了一个 Mac OS 上的系统调用跟踪工具 DTrace。CPython 发布版本中没有内置 DTrace,因此必须重新对 CPython 进行编译。以下以 Python 3.6.6 为例:

wget https://github.com/python/cpython/archive/v3.6.6.zip
unzip v3.6.6.zip
cd v3.6.6
./configure --with-dtrace
make

这样 python.exe 将使用 DTrace 追踪所有代码。Paul Ross 也作过关于 DTrace 的闪电演讲。你可以下载 Python 的 DTrace 启动文件来查看函数调用、执行时间、CPU 时间、系统调用,以及各种其它的内容。

sudo dtrace -s toolkit/<tracer>.d -c ‘../cpython/python.exe script.py’

py_callflow 追踪器显示了程序里调用的所有函数。

那么,Python 的动态类型会让它变慢吗?

  • 类型比较和类型转换消耗的资源是比较多的,每次读取、写入或引用变量时都会检查变量的类型
  • Python 的动态程度让它难以被优化,因此很多 Python 的替代品能够如此快都是为了提升速度而在灵活性方面作出了妥协
  • Cython 结合了 C 的静态类型和 Python 来优化已知类型的代码,它可以将性能提升 84 倍

总结

由于 Python 是一种动态、多功能的语言,因此运行起来会相对缓慢。对于不同的实际需求,可以使用各种不同的优化或替代方案。

例如可以使用异步,引入分析工具或使用多种解释器来优化 Python 程序。

对于不要求启动时间且代码可以充分利用 JIT 的程序,可以考虑使用 PyPy。

而对于看重性能并且静态类型变量较多的程序,不妨使用 Cython

延伸阅读

Jake VDP 的优秀文章(略微过时) https://jakevdp.github.io/blog/2014/05/09/why-python-is-slow/

Dave Beazley 关于 GIL 的演讲 http://www.dabeaz.com/python/GIL.pdf

JIT 编译器的那些事 https://hacks.mozilla.org/2017/02/a-crash-course-in-just-in-time-jit-compilers/


via: https://hackernoon.com/why-is-python-so-slow-e5074b6fe55b

作者:Anthony Shaw 选题:oska874 译者:HankChow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

这些最有用的命令可以让你了解安装在你的 Debian 类的 Linux 系统上的包的情况。

你有没有想过你的 Linux 系统上安装了几千个软件包? 是的,我说的是“千”。 即使是相当一般的 Linux 系统也可能安装了上千个软件包。 有很多方法可以获得这些包到底是什么包的详细信息。

首先,要在基于 Debian 的发行版(如 Ubuntu)上快速得到已安装的软件包数量,请使用 apt list --installed, 如下:

$ apt list --installed | wc -l
2067

这个数字实际上多了一个,因为输出中包含了 “Listing …” 作为它的第一行。 这个命令会更准确:

$ apt list --installed | grep -v "^Listing" | wc -l
2066

要获得所有这些包的详细信息,请按以下方式浏览列表:

$ apt list --installed | more
Listing...
a11y-profile-manager-indicator/xenial,now 0.1.10-0ubuntu3 amd64 [installed]
account-plugin-aim/xenial,now 3.12.11-0ubuntu3 amd64 [installed]
account-plugin-facebook/xenial,xenial,now 0.12+16.04.20160126-0ubuntu1 all [installed]
account-plugin-flickr/xenial,xenial,now 0.12+16.04.20160126-0ubuntu1 all [installed]
account-plugin-google/xenial,xenial,now 0.12+16.04.20160126-0ubuntu1 all [installed]
account-plugin-jabber/xenial,now 3.12.11-0ubuntu3 amd64 [installed]
account-plugin-salut/xenial,now 3.12.11-0ubuntu3 amd64 [installed]

这需要观察很多细节 —— 特别是让你的眼睛在所有 2000 多个文件中徘徊。 它包含包名称、版本等,以及更多但并不是以最易于我们人类解析的显示信息。 dpkg-query 使得描述更容易理解,但这些描述会塞满你的命令窗口,除非窗口非常宽。 因此,为了让此篇文章更容易阅读,下面的数据显示已经分成了左右两侧。

左侧:

$ dpkg-query -l | more
Desired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name                                                 Version                                      
+++-==============================================-=================================-
ii  a11y-profile-manager-indicator                 0.1.10-0ubuntu3                              
ii  account-plugin-aim                             3.12.11-0ubuntu3                             
ii  account-plugin-facebook                        0.12+16.04.20160126-0ubuntu1                 
ii  account-plugin-flickr                          0.12+16.04.20160126-0ubuntu1                 
ii  account-plugin-google                          0.12+16.04.20160126-0ubuntu1                 
ii  account-plugin-jabber                          3.12.11-0ubuntu3                             
ii  account-plugin-salut                           3.12.11-0ubuntu3                             
ii  account-plugin-twitter                         0.12+16.04.20160126-0ubuntu1                 
rc  account-plugin-windows-live                    0.11+14.04.20140409.1-0ubuntu2               

右侧:

Architecture Description
============-=====================================================================
amd64        Accessibility Profile Manager - Unity desktop indicator
amd64        Messaging account plugin for AIM
all          GNOME Control Center account plugin for single signon - facebook
all          GNOME Control Center account plugin for single signon - flickr
all          GNOME Control Center account plugin for single signon
amd64        Messaging account plugin for Jabber/XMPP
amd64        Messaging account plugin for Local XMPP (Salut)
all          GNOME Control Center account plugin for single signon - twitter
all          GNOME Control Center account plugin for single signon - windows live

每行开头的 iirc 名称(见上文“左侧”)是包状态指示符。 第一个字母表示包的预期状态:

  • u – 未知
  • i – 安装
  • r – 移除/反安装
  • p – 清除(也包括配置文件)
  • h – 保留

第二个代表包的当前状态:

  • n – 未安装
  • i – 已安装
  • c – 配置文件(只安装了配置文件)
  • U – 未打包
  • F – 半配置(出于某些原因配置失败)
  • h – 半安装(出于某些原因配置失败)
  • W – 等待触发(该包等待另外一个包的触发器)
  • t – 待定触发(该包被触发)

在通常的双字符字段末尾添加的 R 表示需要重新安装。 你可能永远不会碰到这些。

快速查看整体包状态的一种简单方法是计算在不同状态中包含的包的数量:

$ dpkg-query -l | tail -n +6 | awk '{print $1}' | sort | uniq -c
 2066 ii
 134 rc

我从上面的 dpkg-query 输出中排除了前五行,因为这些是标题行,会混淆输出。

这两行基本上告诉我们,在这个系统上,应该安装了 2066 个软件包,而 134 个其他的软件包已被删除,但留下了配置文件。 你始终可以使用以下命令删除程序包的剩余配置文件:

$ sudo dpkg --purge xfont-mathml

请注意,如果程序包二进制文件和配置文件都已经安装了,则上面的命令将两者都删除。


via: https://www.networkworld.com/article/3242808/linux/peeking-into-your-linux-packages.html

作者:Sandra Henry-Stocker 译者:Flowsnow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

你编写或维护过有意义的 bash 脚本吗?如果回答是,那么你可能希望它们以标准且健壮的方式接收命令行参数。Fedora 最近得到了一个很好的附加组件,它可以帮助你生成更好的脚本。不用担心,它不会花费你很多时间或精力。

为什么需要 Argbash?

Bash 是一种解释性的命令行语言,没有标准库。因此,如果你编写 bash 脚本并希望命令行界面符合 POSIXGNU CLI 标准,那么你一般只有两种选择:

  1. 直接编写为脚本量身定制的参数解析功能(可使用内置的 getopts)。
  2. 使用外部 bash 模块。

第一个选项看起来非常愚蠢,因为正确实现接口并非易事。但是,从 Stack OverflowBash Hackers wiki 的各种站点上,它却被认为是最佳选择。

第二个选项看起来更聪明,但使用模块有它自己的问题。最大的问题是你必须将其代码与脚本捆绑在一起。这可能意味着:

  • 要么,你将库作为单独的文件分发
  • 或者,在脚本的开头包含库代码

有两个文件而不是一个是愚蠢的;但采用一个文件的话,会让一堆上千行的复杂代码污染了你的脚本。

这是 Argbash 项目诞生的主要原因。Argbash 是一个代码生成器,它为你的脚本生成一个量身定制的解析库。与其他 bash 模块的通用代码不同,它生成你的脚本所需的最少代码。此外,如果你不需要 100% 符合那些 CLI 标准的话,你可以生成更简单的代码。

示例

分析

假设你要实现一个脚本,它可以在终端窗口中绘制条形图,你可以通过重复一个字符选定的次数来做到这一点。这意味着你需要从命令行获取以下信息:

  • 哪个字符是组成该行的元素。如果未指定,使用破折号 -。 在命令行上,这是个单值定位参数 character,其默认值为 -。(LCTT 译注:定位参数是指确定位置的参数,此处 character 需是命令行的第一个参数)
  • 直线的长度。如果未指定,会选择 80。 这是一个单值可选参数 length,默认值为 80
  • Verbose 模式(用于调试)。 这是一个布尔型参数 verbose,默认情况下关闭。

由于脚本的主体非常简单,因此本文主要关注从命令行获取用户的输入到合适的脚本变量。Argbash 生成的代码会将参数解析结果保存到 shell 变量 _arg_character_arg_length_arg_verbose 当中。

执行

接下来,你还需要 argbash-initargbash bash 脚本,它们是 argbash 包的一部分。因此,运行以下命令:

sudo dnf install argbash

然后,使用 argbash-init 来为 argbash 生成模板,它会生成可执行脚本。你需要三个参数:一个名为 character 的定位参数,一个可选的 length 参数以及一个可选的布尔 verbose。将这些传递给 argbash-init,然后将输出传递给 argbash : `argbash-init --pos character --opt length --opt-bool verbose script-template.sh
argbash script-template.sh -o script
./script`

看到帮助信息了吗?看起来该脚本不知道字符参数的默认选项。因此,看一下 Argbash API,然后通过编辑脚本的模板部分来解决问题:

# ...
# ARG_OPTIONAL_SINGLE([length],[l],[Length of the line],[80])
# ARG_OPTIONAL_BOOLEAN([verbose],[V],[Debug mode])
# ARG_POSITIONAL_SINGLE([character],[The element of the line],[-])
# ARG_HELP([The line drawer])
# ...

Argbash 非常智能,它试图让每个生成的脚本都成为自己的模板,这意味着你不需要存储源模版以供进一步使用,你也不要丢掉生成的 bash 脚本。现在,尝试重新生成如你所预期的下一个线条绘图脚本:

argbash script -o script
./script

如你所见,一切正常。剩下要做的唯一事情就是完成线条绘图功能。

结论

你可能会发现包含解析代码的部分很长,但考虑到它允许你以 ./script.sh x -Vl50 的方式调用,并且能像 ./script -V -l 50 x 一样工作。确实需要一些代码才能做到这一点。

但是,通过调用 argbash-init 并将参数 -mode 设置为 minimal,你可以平衡生成的代码复杂度和解析能力,而转向更简单的代码。这个选项将脚本的大小减少了大约 20 行,这相当于生成的解析代码大小减少了大约 25%。另一方面,full 模式使脚本更加智能。

如果你想要检查生成的代码,请给 argbash 提供参数 -commented,它会将注释放入解析代码中,从而揭示各个部分背后的意图。与其他参数解析库相比较,如 shflags, argsparsebash-modules/arguments,你将看到 Argbash 强大的简单性。如果出现了严重的错误,你需要快速修复解析功能中的一个故障,Argbash 也允许你这样做。

由于你很有可能是 Fedora 用户,因此你可以享受从官方仓库安装命令行 Argbash 的便利。不过,也有一个在线解析代码生成器服务可以使用。此外,如果你在服务器上使用 Docker 工作,你可以试试 Argbash Docker 镜像

这样你可以让你的脚本具有令用户满意的命令行界面。Argbash 随时为你提供帮助,你只需付出很少的努力。


via: https://fedoramagazine.org/improve-bash-scripts-argbash/

作者:Matěj Týč 译者:MjSeven 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出