遵循几个简单的步骤来保持 Git 仓库的整洁

在合并一个 GibLab 的合并请求（MR）或 GitHub 的拉取请求（PR）后，你通常需要从远程仓库中删掉这个主题分支来保持仓库的整洁。然而，这只会删掉远程仓库的主题分支。本地 Git 仓库也会从例行清理中收益。

要同步本地仓库和远程仓库的信息，可以执行 git prune 命令来删除本地仓库中远程分支的本地引用。

按照以下三个简单的步骤：

1、检出仓库中的核心分支（比如 main 或者 master）：

$ git checkout <central_branch_name>

2、列出所有远程和本地分支：

$ git branch -a

示例输出：

4.10.z
* master
  remotes/mydata/4.9-stage
  remotes/mydata/4.9.z
  remotes/mydata/test-branch

在这个例子中，test-branch 是从远程仓库中删除的主题分支的名字。

3、删除远程分支的本地引用：

首先，列出所有可以从本地仓库中删除的分支：

$ git remote prune origin --dry-run

示例输出：

Pruning origin
URL: [email protected]:myorg/mydata-4.10.git
* [would prune] origin/test-branch

然后，删除远程分支的本地引用：

$ git remote prune origin

示例输出：

Pruning origin
URL: [email protected]:myorg/mydata-4.10.git
* [pruned] origin/test-branch

就是这样！

维护 Git 仓库

保持 Git 仓库的整洁，一开始似乎并不紧急，但是随着仓库规模的增长，删除不必要的数据就变得更为重要。不要让从无用的数据筛选而拖慢你。

经常删除远程分支的本地引用，是维护一个可用的 Git 仓库是一个好方法。

via: https://opensource.com/article/22/8/delete-local-reference-remote-branch-git

作者：Agil Antony 选题：lkxed 译者：Yufei-Yan 校对：wxy

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

使用位字段和掩码是不用数据结构组合数据的常用方法。

假设你在用 C 语言写一个国际象棋游戏。追踪棋盘上棋子的一种方法是定义一个结构，该结构定义了棋盘上每个可能的棋子及其颜色，因此每个格子都包含该结构中的一个元素。例如，你可以将结构定义成下面这样：

struct chess_pc {
   int piece;
   int is_black;
}

有了这个数据结构，你的程序就会知道每个格子里是什么棋子及棋子的颜色。你可以快速识别出棋子是兵、车、马、象、后还是王，以及棋子是黑还是白。但是，有一种更直接的方法来跟踪这些信息，同时只用更少的数据和内存。与为棋盘上的每个方格存储两个 int 值的结构不同，我们可以存储单个 int 值，并使用二进制位字段和掩码来标识每个方格中的棋子和颜色。

比特和二进制

当使用位字段表示数据时，我们最好像计算机一样思考。让我们从列出可能的棋子开始，并为每个棋子分配一个数字。让我们进入下一个步骤，用二进制表示这个数字，也就是按照计算机追踪它的方式。记住，二进制数是由比特组成的，比特要么是 0，要么是 1。

• 00000000: 空（0）
• 00000001: 兵（1）
• 00000010: 车（2）
• 00000011: 马（3）
• 00000100: 象（4）
• 00000101: 后（5）
• 00000110: 王（6）

要列出一个棋盘上的所有棋子，我们只需要三个比特从右到左依次代表值 1、2 和 4。例如，数字 6 是二进制的 110。6 的二进制表示中的其他所有位都是 0。

一个聪明一点的方法：我们可以使用那些额外的总是为零的比特来跟踪一个棋子是黑还是白。我们可以使用数字 8（二进制 00001000）来表示棋子是否为黑色。如果这一位是 1，则代表该棋子是黑色；如果是 0，则代表该棋子是白色。这被称为位字段，稍后我们可以使用二进制掩码将其取出。

用位字段存储数据

要编写一个使用位字段和掩码的国际象棋程序，我们可以从以下定义开始：

/* 棋子 */

#define EMPTY 0   // 空
#define PAWN 1    // 兵
#define ROOK 2    // 车
#define KNIGHT 3  // 马
#define BISHOP 4  // 象
#define QUEEN 5   // 后
#define KING 6    // 王

/* 棋色 */

#define BLACK 8   // 黑
#define WHITE 0   // 白

/* 掩码 */

#define PIECE 7

当你为一个棋格赋值时，比如初始化棋盘，你可以赋一个 int 类型的值来跟踪棋子及其颜色。例如，要在棋盘的 0,0 位置存储棋子黑车，你可以使用下面的代码：

  int board[8][8];
..
  board[0][0] = BLACK | ROOK;

| 是二进制“或”（OR）操作符，这意味着计算机将合并两个数字的比特。对于每个比特的位置，如果任意一个数字的比特为 1，该位置比特的结果也是 1。BLACK 的值（8，即二进制下的 00001000）和 ROOK 的值（2，即二进制下的 00000010）的二进制或结果是二进制下的 00001010，即 10：

    00001000 = 8
 OR 00000010 = 2
    ________
    00001010 = 10

类似地，要在棋盘的 6,0 位置存储一个白色兵，你可以这样做：

  board[6][0] = WHITE | PAWN;

这样存储的值就是 WHITE（0）和 PAWN（1）的二进制或的结果，也即是 1。

    00000000 = 0
 OR 00000001 = 1
    ________
    00000001 = 1

用掩码获取数据

在下棋过程中，程序需要知道棋格中的棋子和它的颜色。我们可以使用二进制掩码来分离这部分。

举个例子，程序可能需要知道棋局中棋盘上特定棋格的内容，例如位于 board[5][3] 的数组元素。这个是什么棋子，是黑的还是白的？为了识别棋子，使用二进制“与”（AND）操作符将元素的值与掩码 PIECE 结合起来：

  int board[8][8];
  int piece;
..
  piece = board[5][3] & PIECE;

二进制“与”（AND）操作符（&）将两个二进制值结合，这样对于任意位，如果两个数字中的那个位都是 1，那么结果也是 1。例如，如果 board[5][3] 的值是 11（二进制下的 00001011），那么 11 和 掩码 PIECE（7，二进制下的 00000111）二进制与的结果为二进制下的 00000011，也即 3。这代表马，马的值是 3。

    00001011 = 11
AND 00000111 = 7
    ________
    00000011 = 3

解析棋子的颜色是一个简单的事情，只需要将棋子的值与 BLACK 位字段进行二进制与操作。比如，你可以写一个名为 is_black 的函数来确定棋子是黑还是白：

int
is_black(int piece)
{
  return (piece & BLACK);
}

之所以可以这样，是因为 BLACK 的值为 8（二进制下的 00001000）。在 C 语言中，任何非零值都被视为 True，零总是 False。所以如果 5,3 处的棋子是黑色的，则 is_black(board[5][3]) 返回 True 值（8）；如果是白色的，则返回 False 值（0）。

位字段

使用位字段和掩码是不使用结构组合数据的常用方法。它们值得被程序员收藏到“工具包”中。虽然数据结构对于需要跟踪相关数据的有序编程是一种有价值的工具，但是使用单独的元素来跟踪单个的开或闭值（例如棋子的颜色）的效率较低。在这些情况下，可以考虑使用位字段和掩码来更高效地组合数据。

via: https://opensource.com/article/21/8/binary-bit-fields-masks

作者：Jim Hall 选题：lujun9972 译者：FYJNEVERFOLLOWS 校对：wxy

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

学习为什么 Python 中的可观测性很重要，以及如何在你的软件开发生命周期中实现它。

你写的应用会执行很多代码，而且是以一种基本上看不到的方式执行。所以你是怎么知道：

• 代码是否在运行？
• 是不是在正常工作？
• 谁在使用它，如何使用？

可观测性是一种能力，可以通过查看数据来告诉你，你的代码在做什么。在这篇文章中，主要关注的问题是分布式系统中的服务器代码。并不是说客户端应用代码的可观测性不重要，只是说客户端往往不是用 Python 写的。也不是说可观测性对数据科学不重要，而是在数据科学领域的可观测性工具（大多是 Juptyter 和快速反馈）是不同的。

为什么可观测性很重要

所以，为什么可观测性重要呢？在软件开发生命周期（SDLC）中，可观测性是一个关键的部分。

交付一个应用不是结束，这只是一个新周期的开始。在这个周期中，第一个阶段是确认这个新版本运行正常。否则的话，很有可能需要回滚。哪些功能正常运行？哪些功能有细微的错误？你需要知道发生了什么，才能知道接下来要怎么做。这些东西有时候会以奇怪的方式不能正常运行。不管是天灾，还是底层基础设施的问题，或者应用进入了一种奇怪的状态，这些东西可能在任何时间以任何理由停止工作。

在标准 SDLC 之外，你需要知道一切都在运行中。如果没有，有办法知道是怎么不能运行的，这是非常关键的。

反馈

可观测性的第一部分是获得反馈。当代码给出它正在做什么的信息时，反馈可以在很多方面提供帮助。在模拟环境或测试环境中，反馈有助于发现问题，更重要的是，以更快的方式对它们进行分类。这可以改善在验证步骤中的工具和交流。

当进行 金丝雀部署 canary deployment 或更改特性标志时，你需要知道是否要继续，还是等更长时间，或者回滚，反馈就显得很重要了。

监控

有时候你怀疑有些东西不太对。也许是一个依赖服务有问题，或者是社交网站爆出了大量你的网站的问题。也许在相关的系统中有复杂的操作，然后你想确保你的系统能完美处理。在这些情况下，你就想把可观测性系统的数据整合到控制面板上。

当写一个应用的时候，这些控制面板需要是设计标准的一部分。只有当你的应用能把数据共享给这些控制面板，它们才会把这些数据显示出来。

警报

看控制面板超过 15 分钟就像看着油漆变干一样。任何人都不应该遭受这种折磨。对于这种任务，我们要有报警系统。报警系统将可观测性数据与预期数据进行对比，当它们不匹配的时候就发出通知。完全深入研究时间管理超出了本文的范围。然而，从两方面来说，可观测应用是 报警友好的 alert-friendly ：

• 它们有足够多，足够好的数据，发出的警报才是高质量的。
• 警报有足够的数据，或者接收者可以很容易的得到数据，这样有助于找到源头。

高质量警报有三个特点：

• 较少的错报：如果有警报，那一定是有问题了。
• 较少的漏报：如果有问题，那一定有警报触发。
• 及时性：警报会迅速发出以减少恢复时间。

这三个特点是互相有冲突的。你可以通过提高监测的标准来减少错误警报，代价是增加了漏报。你也可以通过降低监测的门槛来减少漏报，代价是增加错报。通过收集更多数据，你也可以同时减少错报和漏报，而代价是降低了及时性。

同时改善这三个参数就更难了。这就要求高质量的可观测性数据。更高质量的数据可以同时改善这三个特点。

日志

有的人喜欢嘲笑用打印来调试的方法。但是，在一个大多数软件都不在你本机运行的世界里，你所能做的只有打印调试。日志记录就是打印调试的一种形式。尽管它有很多缺点，但 Python 日志库提供了标准化的日志记录。更重要的是，它意味着你可以通过这些库去记录日志。

应用程序要负责配置日志的记录方式。讽刺地是，在应用程序对配置日志负责了多年以后，现在越来越不是这样了。在现代容器 编排 orchestration 环境中，现代应用程序记录标准错误和标准输出，并且信任 编排 orchestration 系统可以合理的处理日志。

然而，你不应该依赖库，或者说，其他任何地方。如果你想让操作的人知道发生了什么，使用日志，而不是打印。

日志级别

日志记录的一个最重要功能就是 日志级别。不同的日志级别可以让你合理的过滤并分流日志。但是这只有在日志级别保持一致的情况下才能做到。最后，你应该在整个应用程序中保持日志级别的一致性。

选择不兼容语义的库可以通过在应用层面的适当配置来追溯修复，这只需要通过使用 Python 中最重要的通用风格做到：getLogger(__name-_)。

大多数合理的库都会遵循这个约定。 过滤器 Filters 可以在日志对象发出之前就地修改它们。你可以给处理程序附加一个过滤器，这个处理程序会根据名称修改消息，使其具有合适的级别。

import logging
LOGGER=logging.getLogger(__name__)

考虑到这一点，你现在必须明确日志级别的语义。这其中有很多选项，但是下面这些是我的最爱：

• Error：发送一个即时警告。应用程序处于一个需要操作人员引起注意的状态。（这意味着包含 Critical 和 Error）
• Warning：我喜欢把这些称作“工作时间警报”。这种情况下，应该有人在一个工作日内关注一下。
• Info：这是在正常工作流程中发出的。如果怀疑有问题的时候，这个是用来帮助人们了解应用程序在做什么的。
• Debug：默认情况下，这个不应该在生产环境中出现。在模拟环境或开发环境下，可以发出来，也可以不发。如果需要更多的信息，在生产环境也可以特地被打开。

任何情况下都不要在日志中包含 个人身份信息 Personal Identifiable Information （PII）或密码。无论日志级别是什么，都是如此，比如级别更改，激活调试级别等等。日志聚合系统很少是 PII 安全 PII-safe 的，特别是随着 PII 法规的不断发展（HIPAA、GDPR 等等）。

日志聚合

现代系统几乎都是分布式的。 冗余 redundancy 、 扩展性 scaling ，有时是 管辖权 jurisdictional 需要更多的水平分布。微服务意味着垂直分布。登录到每个机器去查看日志已经是不现实的了。出于合理的控制原因，允许开发人员登录到机器中会给予他们更多的权限，这不是个好主意。

所有的日志都应该被发到一个聚合器。有一些商业的方案，你可以配置一个 ELK 栈，或者也可以使用其他的数据库（SQL 或则 no-SQL）。作为一个真正的低技术解决方案，你可以将日志写入文件，然后将它们发送到对象存储中。有很多解决方案，但是最重要的事情是选择一个，并且将所有东西聚合到一起。

记录查询

在将所有东西记录到一个地方后，会有很多日志。具体的聚合器可以定义如何写查询，但是无论是通过从存储中搜索还是写 NoSQL 查询，记录查询以匹配源和细节都是很有用的。

指标抓取

指标抓取 Metric Scraping 是一个 服务器拉取 server pull 模型。指标服务器定时和应用程序连接，并且拉取指标。

最后，这意味着服务器需要连接和找到所有相关的应用服务器。

以 Prometheus 为标准

如果你的指标聚合器是 Prometheus，那么 Prometheus 格式做为一个 端点 endpoint 是很有用的。但是，即使聚合器不是 Prometheus，也是很有用的。几乎所有的系统都包含与 Prometheus 端点兼容的 垫片 shim

使用客户端 Python 库给你的应用程序加一个 Prometheus 垫片，这将使它能够被大多数的指标聚合器所抓取。当 Prometheus 发现一个服务器，它就期望找到一个指标端点。这经常是应用程序路由的一部分，通常在 /metrics 路径下。不管 Web 应用的平台是什么，如果你能在一个端点下运行一个定制类型的定制字节流，Prometheus 就可以将它抓取。

对于大多数流行的框架，总有一个中间件插件或者类似的东西收集指标，如延迟和错误率。通常这还不够。你需要收集定制的应用数据：比如，每个端点的缓存 命中/缺失 hit/miss 率，数据库延迟，等等。

使用计数器

Prometheus 支持多个数据类型。一个重要且巧妙的类型就是计数器。计数器总是在前进 —— 但有一点需要注意。

当应用重置，计数器会归零。计数器中的这些“ 历时 epochs ”通过将计数器“创建时间”作为元数据发送来管理。Prometheus 知道不去比较两个不同 历时 epochs 的计数器。

使用仪表值

仪表值会简单很多：它们测量瞬时值。用它们来测量会上下起伏的数据：比如，分配的总内存大小，缓存大小，等等。

使用枚举值

枚举值对于整个应用程序的状态是很有用的，尽管它们可以以更精细的方式被收集。比如，你正使用一个 功能门控 feature-gating 框架，一个有多个状态（比如，使用中、关闭、 屏蔽 shadowing 等）的功能，也许使用枚举会更有用。

分析

分析不同于指标，因为它们要对应连续的事件。比如，在网络服务器中，事件是一个外部请求及其产生的工作。特别是，在事件完成之前事件分析是不能被发送的。

事件包含特定的指标：延迟，数量，以及可能产生的对其他服务请求的细节，等等。

结构化日志

现在一个可能的选择是将日志结构化。发送事件只发送带有正确格式的有效 载荷 payload 的日志。这个数据可以从日志聚合器请求，然后解析，并且放入一个合适的系统，这样可以对它的可见性。

错误追踪

你可以使用日志来追踪错误，也可以用分析来追踪错误。但是一个专门的错误系统还是值得的。一个为错误而优化的系统可以发送更多的错误，因为错误毕竟还是罕见的。这样它就可以发送正确的数据，并且用这些数据，它能做更多智能的事情。Python 中的错误追踪系统通常和一般的异常处理关联，然后收集数据，并且把它发到一个专门的错误聚合器。

使用 Sentry

很多情况下，自己运行 Sentry 是正确的做法。当错误发生时，就说明有些东西就出问题了。可靠地删除敏感数据是不可能的，因为一定有会出现敏感数据被发送到不应该的地方。

通常，这种工作量并不会很大：异常并不常出现。最后，这个系统并不需要很高的质量，也不需要高可靠性的备份。昨天的错误应该已经修复了，希望如此，如果没有，你还会发现的！

快速、安全、可重复：三者都要

可观测的系统开发起来更快，因为它们可以给你提供反馈。它们运行起来也更安全，因为当出问题的时候，它们也会更早的让你知道。最后，因为有反馈回路，可观测性也有助于围绕它构建可重复的过程。可观测性可以让你了解你的应用程序。而更了解它们，就胜利了一半。

磨刀不误砍柴功

构建所有的可观测层是一件困难的事情。总会让人感觉是在浪费的工作，或者更像是“可以有，但是不急”。

之后再做这个可以吗？也许吧，但是不应该。正确的构建可观测性可以加速后面所有阶段的开发：测试、监控，甚至是培训新人。在一个和科技行业一样动荡的行业，减少培训新人的工作量绝对是值得的。

事实上，可观测性很重要，所以尽早把它写出来，然后就可以在整个过程中进行维护。反过来，它也会帮你维护你的软件。

via: https://opensource.com/article/21/11/observability-python

作者：Moshe Zadka 选题：lujun9972 译者：MCGA 校对：wxy

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

本文将帮助你设计一个基于 Web 的应用程序，使用 Node-RED 为地铁站的汽车提供一个自动智能停车系统。

Web 应用程序是在 Web 服务器上运行的软件。终端用户通过 Web 浏览器访问 Web 应用程序。Web 应用程序使用客户端—服务器（C/S）架构进行编程，该架构是用户（客户端）通过远程服务器（可能由第三方托管）提供服务。Web API（应用程序编程接口）在整个 Web 上是可用的，用户可以通过 HTTP 协议访问该接口，如图 1 所示。

本文将演示如何为地铁设计一个基于 Web 的汽车自动智能停车系统。 它是使用开源的 Node-RED 设计。该系统使用模板节点创建了一个交互式的、时尚的用户登录表单，用 HTML 和 CSS 编码以获取车主的详细信息，从而实现停车系统的自动化。我们可以在图 2 和图 3 看到登录表单和提交表单的流程图。

使用的节点如下：

地铁智能停车节点流程设计

Node-RED 由 node-red 命令激活。访问网址 http://127.0.0.1:1880/ 可以看到 Node-RED 用户界面流程浏览器已经启用，可以认为 Node-RED 设置已完成，可以正常工作了。

按照下面给出的步骤创建登录表单和提交表单。

登录表单

1、在节点画布中，拖放 http 输入 http in 节点，这会为创建 Web 服务创建一个 HTTP 访问点。

2、将 http 输入 http in 节点连接到 函数 function 节点。函数节点有助于编写 JavaScript 函数处理节点接收到的消息。

3、将 函数 function 节点连接到 模板 template 节点，模板节点基于提供的模板创建一个 Web API。

4、将 模板 template 节点连接到 http 响应 http response 节点，它将响应 http 输入 http in 节点的请求。

提交表单

1、拖放 http 输入 http in 节点并将其连接到 json 节点，json 节点将数据转换为 JSON 字符串进行通信。

2、将 http 输入 http in 节点连接到 调试 debug 节点，调试节点的调试监控器会输出结果。

3、将 json 节点放置并连接到 函数 function 节点，将后者连接到 http 响应 http response 节点。

创建完整流程后，单击 Node-RED 窗口右上角的 部署 Deploy 按钮。访问 http://127.0.0.1:1880/ui/ 这个链接查看用户界面。

输入链接然后单击 提交 Submit 后，该链接会跳转到下一页，你可以在该页面阅读所有新闻。

Node-RED 工作流程

在单个 Node-RED 流程中，你可以创建登录表单和提交表单，如图 4 和图 5 所示。

现在我们将配置节点属性。

登录表单

编辑 http 输入 http in 属性：

• 方法 method 选择 “Get”
• 网址 URL 设为 /MetroStation
• 名称 name 配置为 “ 智能停车系统 Smart Parking ”。

（LCTT 译注：下文 http 响应节点的名称为 Smart parking，p 字母小写，为了区分，此处中文翻译成智能停车系统。）

注意：URL 可以使用任何用户定义的本地变量。

现在选择 函数 function 节点，编辑函数节点属性：输入代码 msg.url = project ，并配置代码 名称 name 字段为 “ 项目提交 Project Submission ”。

在 模板 template 节点的属性窗口，为登录表单配置相应的 HTML 代码，并将代码 名称 name 命名为 “ 显示面板 Display panel ”。在此流程使用了 Mustache 模板格式（LCTT 译注：Mustache 是胡子的意思，因为它的嵌入标记 {{ }} 非常像胡子）。Mustache 是一个简单的 Web 模板系统，被描述为无逻辑的模板引擎。Mustache 没有任何显式的控制流语句，例如 if 和 else 条件和 for 循环。可以通过使用块标签处理列表和lambdas 来实现循环和条件评估。

配置编辑 http 响应 http response 节点的属性， 名称 name 设为 “ 智能停车 Smart parking ”（图 9） 。

提交表单

在 http 输入 http in 节点的编辑属性窗口， 方法 method 选择 “POST” ， 网址 URL 设为 /project。

在 JSON 节点的编辑窗口， 操作 Action 设为 “ JSON字符串与对象互转 Convert between JSON String & Object ”，参考图 11。

函数 function 节点的配置如图 12 所示。

在 http 响应 http response 节点，编辑属性 名称 name 为 “ 已提交项目 Project Submitted ”。

注意：添加带有评论的评论节点作为 “登录表单” 和 “提交表单”。

用户界面的控制面板

当用户单击 提交 Submit ，给出的数据将显示在用户界面和调试节点。如果单击 重置 Reset ，详细信息将被清除，允许用户输入新的详细信息（图15）。

地铁停车费率通过超链接提供，收费表在用户界面显示。因此，汽车智能停车系统通过适当的超链接实现自动化，展示地铁站的停车费。该自动化系统的最终输出可以在 Node-RED 控制面板的用户界面和调试监控器调取和展示。

via: https://www.opensourceforu.com/2022/06/build-a-smart-parking-system-for-a-metro-station/

作者：Dr Maheswari R. 选题：lkxed 译者：Maisie-x 校对：wxy

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

请下载我们的电子书获得在 Linux 和 FreeDOS 上 C 语言编程的提示和技巧。

有许多关于为什么 C 语言能够经久不衰的说法。或许是因为它语法简单明了。又或许是因为它常被认为是实用的语言，因为它不基于其他高级语言，可以在任何平台上编译运行。C 显然是一种强大的语言，并且我认为它经久不衰与它作为其他技术的基础的方式相关。这里有 5 项我喜爱的基于 C 语言的技术，希望它们能够帮助你更多的了解 C 语言。

1、GObject 和 GTK

C 语言不是面向对象编程的语言。它没有 class 关键字。 一些人用 C++ 进行面向对象编程，但是还有一些人坚持用 C 和 GObject 库。GObject 库为 C 语言提供了一个 class 结构体，GTK 项目以提供可通过 C 访问的工具包而闻名。没有 GTK ，就没有 GIMP （GTK 就是为此开发的）、GNOME 和其他成千上百流行的开源应用。

了解更多

GObject 和 GTK 是使用 C 开始进行 GUI 编程的绝佳方式。它们“装备精良”，可以让你用 C 语言进行图形应用的编程，因为开发者为你做了许多“繁重工作”。他们定义了类和数据类型，创建了工具包，你所要做的就是将所有东西放在一起。

2、Ncurses

如果 GTK 超过了你的需求，你或许认为一个 终端用户界面 terminal user interface （TUI）更适合你。Ncurses 库可以在终端创建“小部件”，创建一种在终端窗口上绘制图形的应用程序。你可以使用方向键控制界面，选择按钮和元素，就像不用鼠标来使用 GUI 应用一样。

了解更多

利用 Ncurses 库使用 C 语言写一个 猜数字 游戏。

3、Lua 和 Moonscript

Lua 是一种脚本语言，它可以使用内置的 C API 访问 C 语言库。它十分精巧、快捷以及简单，拥有约 30 个函数和少量内置库。你可以使用 Lua 进行系统自动化、游戏修改和脚本编写、使用 LÖVE 之类的前端进行游戏开发，或者使用 GTK 进行一般应用程序开发（例如 Howl 文本编辑器）。

了解更多

Lua 十分好的一点是你可以从它开始学习掌握基本的编程理念，然后当你有足够勇气直面基础编程语言时，再探索它的 C 语言 API 。另一方面，如果你只会 Lua ，那也没事儿。Lua 有很多的 外部库 ，使其成为各种开发方式的绝佳选择。

4、Cython

Lua 不是唯一带有 C 接口的编程语言。Cython 是一种编译器和编程语言，旨在使为 Python 编写 C 扩展就像编写 Python 代码一样容易。本质上，你可以编写 Python 并最终得到 C 语言程序。最简单的示例：

print("hello world")

创建一个 setup.py 脚本:

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("hello.pyx")
)

运行该 setup 脚本:

$ python3 ./setup.py

最后你会在同一个目录中得到一个 hello.c 和 hello.cpython-39-x86_64-linux-gnu.so 文件。

了解更多

Cython 是 Python 的一个超集，支持 C 语言的函数和数据类型。它不可能帮你直接学习 C 语言，但它为希望学习 C 代码并将其集成到 Python 中的 Python 开发人员开辟了新的可能性。

5、FreeDOS

了解更多 C 语言的最好方式是编写 C 代码，没有什么比写你可以真正使用的代码更令人激动的了。FreeDOS 项目是 DOS 的开源实现， 而 DOS 是 Windows 的前身。或许你已经用过 FreeDOS 了，或者作为运行 BIOS 更新程序的便捷开源方法，或者在模拟器中玩经典的计算机游戏。你可以用 FreeDOS 做更多事情。它是学习 C 语言的理想平台，其中包含一系列工具，鼓励你编写自己的命令和简单（或不那么简单，如果你愿意）的应用程序。当然你可以在任何系统上写 C 代码，但是 FreeDOS 的便利可能会让你感到耳目一新。天空有极限，但即使在地面上，你也可以用 C 做一些非常有趣的事情。

下载电子书

你可以从我们编写的新 电子书 中学到更多 C 语言，并在我们的电子书中了解有关 FreeDOS 上 C 语言的更多信息。这些是编程文章的集合，可帮助你学习 C 语言，并演示如何以有用的方式用 C 写一些代码。

下载电子书

via: https://opensource.com/article/22/7/learn-c-linux

作者：Alan Smithee 选题：lkxed 译者：Donkey 校对：wxy

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

使用我在 Linux 上制作的这个 C 程序在旅途中聆听你喜爱的歌曲。

我最近在 Linux 中编写了一个 C 程序，从我广泛的 MP3 库中创建一个较小的随机 MP3 文件选集。该程序会遍历一个包含我的 MP3 库的目录，然后创建一个包含随机的、较小的歌曲选集的目录。然后我将这些 MP3 文件复制到我的智能手机上，以便随时随地收听。

瑞典是一个人口稀少的国家，有许多农村地区没有完整的手机覆盖。这就是在智能手机上拥有 MP3 文件的原因之一。另一个原因是我并不总是有钱购买流媒体服务，所以我喜欢拥有自己喜欢的歌曲的副本。

你可以从它的 Git 仓库 下载我的应用。我专门为 Linux 编写了它，部分原因是在 Linux 上很容易找到经过良好测试的文件 I/O 例程。多年前，我尝试使用专有的 C 库在 Windows 上编写相同的程序，但在尝试文件复制时遇到了困难。Linux 使用户可以轻松直接地访问文件系统。

本着开源的精神，我没费多少力气就找到了 Linux 的文件 I/O 代码来激发我的灵感。我还发现了一些启发了我的分配内存的代码。我编写了随机数生成的代码。

该程序的工作方式如下所述：

1. 询问源目录和目标目录。
2. 询问存放 MP3 文件的目录下的文件个数。
3. 搜索你希望复制的收藏的百分比（从 1.0% 到 88.0%）。如果你有 1000 个文件的集合，并希望从你的集合中复制 125 个文件而不是 120 个文件，你也可以输入 12.5% 之类的数字。我将上限设置为 88%，因为复制超过 88% 的库将基本生成与你的基础库相似的库。当然，代码是开源的，因此你可以根据自己的喜好自由修改。
4. 使用指针和 malloc 分配内存。一些操作需要内存，包括代表音乐收藏中文件的字符串列表。还有一个列表来保存随机生成的数字。
5. 生成所有文件范围内的随机数列表（例如，如果集合有 1000 个文件，则为 1 到 1000）。
6. 复制文件。

其中一些部分比其他部分更简单，但代码只有大约 100 行：

#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h> /* include necessary header files */
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

#define BUF_SIZE 4096 /* use buffer of 4096 bytes */
#define OUTPUT_MODE 0700 /*protect output file */
#define MAX_STR_LEN 256

int main(void) {
  DIR *d;
  struct dirent *dir;
  char strTemp[256], srcFile[256],
  dstFile[256], srcDir[256], dstDir[256];
  char **ptrFileLst;

  char buffer[BUF_SIZE];
  int nrOfStrs=-1, srcFileDesc,
  dstFileDesc, readByteCount,
  writeByteCount, numFiles;
  int indPtrFileAcc, q;

  float nrFilesCopy;
  // vars for generatingRandNumList
  int i, k, curRanNum, curLstInd,
  numFound, numsToGen, largNumRange;
  int *numLst;

  float procFilesCopy;
  printf("Enter name of source Directory\n");
  scanf("%s", srcDir);
  printf("Enter name of destionation Directory\n");
  scanf("%s", dstDir);
  printf("How many files does the directory with mp3 files contain?\n");
  scanf("%d", &numFiles);
  printf("What percent of the files do you wish to make a random selection of\n");
  printf("enter a number between 1 and 88\n");
  scanf("%f", &procFilesCopy);

  // allocate memory for filesList, list of random numbers
  ptrFileLst= (char**) malloc(numFiles * sizeof(char*));

  for (i = 0; i < numFiles; i++) {
    ptrFileLst[i] = (char*)malloc(MAX_STR_LEN * sizeof(char));
  }
  
  largNumRange = numFiles;
  nrFilesCopy = (procFilesCopy / 100) * numFiles;

  numsToGen = (int)((procFilesCopy / 100) * numFiles);
  printf("nrFilesCopy=%f", nrFilesCopy);
  printf("NumsToGen=%d", numsToGen);
  numLst = malloc(numsToGen * sizeof(int));
  srand(time(0));

  numLst[0] = rand() % largNumRange + 1;
  numFound=0;
  do { 
    curRanNum = (int)rand() % largNumRange + 1;
    if (numLst[0] == curRanNum) {
      numFound=1; 
    }
  } while(numFound == 1);

  numLst[1] = curRanNum;
  getchar();
  curLstInd = 1;
  i = 0;
  while(1) {
    do {
      numFound = 0;
      curRanNum = (int)rand() % largNumRange + 1;
      for (int k = 0; k <= curLstInd; k++){
        if (numLst[k] == curRanNum)
        numFound = 1;
      }
    } while(numFound == 1);
    numLst[curLstInd+1] = curRanNum;
    curLstInd++;
    i++;
    // numsToGen=Total numbers to generate minus two
    // already generated by the code above this loop
    if (i == (numsToGen-2))
      break;
    }

    d = opendir(srcDir);
    if (d) {
      while ( (dir = readdir(d)) != NULL ) {
      strcpy(strTemp, dir->d_name);

      if (strTemp[0] != '.') {
        nrOfStrs++;
        strcpy(ptrFileLst[nrOfStrs], strTemp);
      } 
    }
    closedir(d); 
  }

  for (q = 0; q <= curLstInd; q++) {
    indPtrFileAcc = numLst[q];
    strcpy(srcFile, srcDir);
    strcat(srcFile, "/");
    strcat(srcFile, ptrFileLst[indPtrFileAcc]);
    strcpy(dstFile, dstDir);
    strcat(dstFile, "/");
    strcat(dstFile, ptrFileLst[indPtrFileAcc]);
    
    srcFileDesc = open(srcFile, O_RDONLY);
    dstFileDesc = creat(dstFile, OUTPUT_MODE);

    while(1) {
      readByteCount = read(srcFileDesc, buffer, BUF_SIZE);
      if (readByteCount <= 0) 
        break;
      
      writeByteCount = write(dstFileDesc, buffer, readByteCount);
      if(writeByteCount <= 0)
        exit(4);
    }

    //close the files 
    close(srcFileDesc);
    close(dstFileDesc); 
  }
}

这段代码可能是最复杂的：

while(1) {
  readByteCount = read(srcFileDesc, buffer, BUF_SIZE);
  if (readByteCount <= 0) 
    break;

  writeByteCount = write(dstFileDesc, buffer, readByteCount);
  if (writeByteCount <= 0)
      exit(4); 
}

这将从指定的文件中读取多个字节（readByteCount）到字符缓冲区中。该函数的第一个参数是文件名（srcFileDesc）。第二个参数是一个指向字符缓冲区的指针，这之前在程序中声明过。该函数的最后一个参数是缓冲区的大小。

程序返回读取的字节数（在本例中为 4 个字节）。如果返回的数字为 0 或更少，则第一个 if 子句会跳出循环。

如果读取字节数为 0，则所有写入完成，循环中断以写入下一个文件。如果读取的字节数小于 0，则发生错误并退出程序。

当读取 4 个字节时，它会写入它们。write 函数接受三个参数。第一个是要写入的文件，第二个是字符缓冲区，第三个是要写入的字节数（4 个字节） .该函数返回写入的字节数。

如果写入了 0 个字节，则发生了写入错误，因此第二个 if 子句退出程序。

while 循环读取并复制文件，一次 4 个字节，直到文件被复制。复制完成后，你可以将随机生成的 mp3 文件的目录复制到你的智能手机。

复制和写入例程相当有效，因为它们使用 Linux 中的文件系统调用。

改进代码

该程序很简单，可以在用户界面和灵活性方面进行改进。例如，你可以实现一个计算源目录中文件数量的函数，这样你就不必手动输入它。你可以添加选项，这样你就可以非交互地传递百分比和路径。但是代码做了我需要它做的事情，它是 C 编程语言简单效率的演示。

via: https://opensource.com/article/22/7/c-linux-mp3

作者：Rikard Grossman-Nielsen 选题：lkxed 译者：geekpi 校对：wxy

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