分类 技术 下的文章

如何在 Linux 终端中运行一个 Python 程序?像这样,对吗?

python program.py

然而,如果你试图在 Ubuntu(和其他一些发行版)中使用 python 命令,它会抛出一个错误。

command ‘python’ not found, did you mean:
command ‘python3’ from deb python3
command ‘python’ from deb python-is-python3

如果你注意这个错误信息,它说明了很多东西。这里的 python 命令实际上是 python3

如果你不理解,不用担心。我将在这里详细解释。

为什么在 Ubuntu 上没有发现 python 命令?

这是因为 Python 语言不是以 python 的形式安装的,而是以 python3python2 的形式安装的(在一些老的 Ubuntu 版本中)。

在遥远的过去的某个时间点,Python 实际上是作为 python 包/可执行文件提供的。当 Python 发布第二版时,Ubuntu 和其他发行版不得不同时支持 Python 1.x 和 2.x 版本。

因此,他们将较新的 Python 版本命名为 python2,以区分这两个版本。其他应用或库也在其代码中指定 pythonpython2

最终,Python 1 版本被完全停用,但软件包继续被命名为 python2

类似地,当 Python 3 版本发布时,发行版开始同时提供 python2python3 包。

Python 2 不再被支持,Python 3.x 是你在 Ubuntu 上安装的版本。该软件包仍被命名为 python3

总结一下,你已经在 Ubuntu 上安装了 Python。它是以 python3 软件包方式使用的。

那么,当你 在 Ubuntu 上看到 “Python command not found” 的错误 时,你有什么选择?让我来介绍一下。

确保你的系统中已经安装了 Python

它应该已经安装了,但仔细检查一下也无妨。

Ubuntu 18.04 也有 Python 2,但 20.04 及更高版本只有 Python 3。不过,你有哪个版本:

type python python2 python3

正如你在下面的截图中看到的,我的系统上安装了 Python 3 版本。

Checking Python version in Ubuntu

如果你没有安装任何 Python 版本,你可以用以下命令安装 Python 3 版本。

sudo apt install python3

使用 python3 而不是 python

如果对你来说不是太麻烦,在需要的地方使用 python3 命令而不是 python

想检查已安装的 Python 版本吗?请这样输入:

python3 --version

然后你会在输出中得到版本的详细信息:

~$ python3 --version
Python 3.10.4

如果你必须运行一个 Python 程序,请像这样执行它:

python3 program.py

这在大多数情况下应该对你有用。但是,如果你使用的是一些(旧的)Python 应用,期望在其代码中运行 Python 可执行文件,你就会有问题。别担心,你也可以绕过它。

将 python3 链接为 python

你可以在你的 .bashrc 文件中创建一个永久别名,像这样:

alias python='python3'

这样,你可以运行 python 命令,而你的系统运行 python3

这在大多数情况下都会起作用,除非某些程序期望运行 /usr/bin/python。现在,你可以在 /usr/bin/python/usr/bin/python3 之间建立符号链接,但对于 Ubuntu 用户来说,存在一个更简单的选择。

对于 Ubuntu 20.04 和更高版本,如果你安装了 python-is-python3 软件包,你有一个软件包可以自动完成所有链接创建。这也是原始错误信息所提示的。

sudo apt install python-is-python3

install python is python3 ubuntu

你可以看到符号链接已经被创建,你可以使用 python 命令(实际上是运行 python3),没有任何问题。

checking python ubuntu

我希望这能澄清 Ubuntu 中 Python 软件包的问题。如果你有任何问题或建议,请告诉我。


via: https://itsfoss.com/python-not-found-ubuntu/

作者:Abhishek Prakash 选题:lkxed 译者:geekpi 校对:wxy

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

在 Ubuntu 中使用 Docker Compose 安装 Docker 引擎的分步指导。

在这篇文章中,我们将会明白 Docker 是什么,如何 在 Ubuntu 中安装 Docker 引擎 。此外,我们也将会明白如何 安装 Docker Compose ,它是一个定义并运行多容器的 Docker 应用。

我们已经在 Ubuntu 22.04 LTS 中正式的测试了这份指南。然而,它也应该对旧版本如 20.04 LTS 和 18.04 LTS 有效。为了更好的安全性和稳定性,我推荐你使用最新的版本 —— Ubuntu 22.04 LTS 。

什么是 Docker ?

Docker 是一个快捷、轻便的系统级虚拟化技术,开发者和系统管理员可以使用它构建具备所有必要依赖项的应用程序,并将其作为一个包发布。

Docker 与其他如 VMWare 、Xen 、以及 VirtualBox 等工具的虚拟化方式不同,每个虚拟机不需要单独的客户操作系统。

所有的 Docker 容器有效地共享同一个主机系统内核。每个容器都在同一个操作系统中的隔离用户空间中运行。

Docker 容器可以在任何 Linux 版本上运行。比如说你使用 Fedora ,我用 Ubuntu 。我们能相互开发、共享并分发 Docker 镜像。

你无需担心操作系统、软件以及自定义设置,任何事都不用担心。只要我们的主机安装了 Docker ,就能持续开发。简言之,Docker 能够在任何地方运行!

前文中你读到了两个词:Docker 镜像Docker 容器 ,或许你在想它们的区别。

通俗地说,Docker 镜像是一个描述容器应该如何表现的文件,而 Docker 容器是 Docker 镜像的运行(或停止)状态。

希望你能够理解 Docker 的基础概念。更多细节,你可以参考文章末尾的 Docker 官方指导手册。

Docker 依赖项

为了安装并配置 Docker ,你的系统必须满足下列最低要求:

  1. 64 位 Linux 或 Windows 系统
  2. 如果使用 Linux ,内核版本必须不低于 3.10
  3. 能够使用 sudo 权限的用户
  4. 在你系统 BIOS 上启用了 VT(虚拟化技术)支持 on your system BIOS(参考: 如何查看 CPU 支持 虚拟化技术(VT)
  5. 你的系统应该联网

在 Linux ,在终端上运行以下命令验证内核以及架构详细信息:

$ uname -a

输出样例:

Linux Ubuntu22CT 5.15.35-3-pve #1 SMP PVE 5.15.35-6 (Fri, 17 Jun 2022 13:42:35 +0200) x86_64 x86_64 x86_64 GNU/Linux

正如上面你看到的那样,我的 Ubuntu 系统内核版本是 5.15.35-3-pve 并且系统架构是 64 位x86\_64 x86\_64 x86\_64 GNU/Linux)。

注意: 这里,我在 Proxmox 中使用 Ubuntu 22.04 容器。这是你看到上方内核版本中有 “pve” 字符的原因。如果你正在使用 Ubuntu 实体(或者虚拟)机,你将看到系统版本为 5.15.35-3-generic

内核版本需要不低于最低要求的版本,并且是 64 位机器。这样不会有任何问题,我们能顺利安装并使用 Docker 。

请注意你使用哪一个 Ubuntu 系统不重要。并且你使用 Ubuntu 桌面或服务器版本,亦或者其他 Ubuntu 变种如 Lubuntu 、Kubuntu 、Xubuntu ,都不重要。

只要你的系统内核版本不低于 3.10 ,并且是 64 位系统,Docker 都会正常运行。

在 Ubuntu 22.04 LTS 中安装 Docker

首先,更新你的 Ubuntu 系统。

1、更新 Ubuntu

打开终端,依次运行下列命令:

$ sudo apt update
$ sudo apt upgrade
$ sudo apt full-upgrade

2、添加 Docker 库

首先,安装必要的证书并允许 apt 包管理器使用以下命令通过 HTTPS 使用存储库:

$ sudo apt install apt-transport-https ca-certificates curl software-properties-common gnupg lsb-release

然后,运行下列命令添加 Docker 的官方 GPG 密钥:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

添加 Docker 官方库:

$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

使用命令更新 Ubuntu 源列表:

$ sudo apt update

3、安装 Docker

最后,运行下列命令在 Ubuntu 22.04 LTS 服务器中安装最新 Docker CE:

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Install Docker In Ubuntu

当然你也可以安装其他版本 Docker 。运行下列命令检查可以安装的 Docker 版本:

$ apt-cache madison docker-ce

输出样例:

docker-ce | 5:20.10.17~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.16~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.15~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.14~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.13~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages

你可以挑选上面列表中的任何版本进行安装。例如,安装 5:20.10.16~ 3-0 ~ubuntu-jammy 这个版本,运行:

$ sudo apt install docker-ce=5:20.10.16~3-0~ubuntu-jammy docker-ce-cli=5:20.10.16~3-0~ubuntu-jammy containerd.io

安装完成后,运行如下命令验证 Docker 服务是否在运行:

$ systemctl status docker

你会看到类似下面的输出:

* docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2022-06-27 13:07:43 UTC; 3min 4s ago
TriggeredBy: * docker.socket
       Docs: https://docs.docker.com
   Main PID: 2208 (dockerd)
      Tasks: 8
     Memory: 29.6M
        CPU: 126ms
     CGroup: /system.slice/docker.service
             `-2208 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.071453522Z" level=info msg="ccResolverWrapper: sending update to cc: {[{unix:>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.071459974Z" level=info msg="ClientConn switching balancer to \"pick_first\"" >
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.130989294Z" level=info msg="Loading containers: start."
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.187439756Z" level=info msg="Default bridge (docker0) is assigned with an IP a>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.235966874Z" level=info msg="Loading containers: done."
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.240149866Z" level=warning msg="Not using native diff for overlay2, this may c>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.240281966Z" level=info msg="Docker daemon" commit=a89b842 graphdriver(s)=over>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.240386856Z" level=info msg="Daemon has completed initialization"
Jun 27 13:07:43 Ubuntu22CT systemd[1]: Started Docker Application Container Engine.
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.276336600Z" level=info msg="API listen on /run/docker.sock"

好极了!Docker 服务已启动并运行!

如果没有运行,运行以下命令运行 Docker 服务:

$ sudo systemctl start docker

使 Docker 服务在每次重启时自动启动:

$ sudo systemctl enable docker

可以使用以下命令查看已安装的 Docker 版本:

$ sudo docker version

输出样例:

Client: Docker Engine - Community
  Version:           20.10.17
  API version:       1.41
  Go version:        go1.17.11
  Git commit:        100c701
  Built:             Mon Jun  6 23:02:46 2022
  OS/Arch:           linux/amd64
  Context:           default
  Experimental:      true

Server: Docker Engine - Community
  Engine:
    Version:          20.10.17
    API version:      1.41 (minimum version 1.12)
    Go version:       go1.17.11
    Git commit:       a89b842
  Built:            Mon Jun  6 23:00:51 2022
    OS/Arch:          linux/amd64
    Experimental:     false
  containerd:
    Version:          1.6.6
    GitCommit:        10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
  runc:
    Version:          1.1.2
    GitCommit:        v1.1.2-0-ga916309
  docker-init:
    Version:          0.19.0
    GitCommit:        de40ad0

Check Docker Version

4、测试 Docker

让我们继续,测试 Docker 是否运行正常:

运行:

$ sudo docker run hello-world

上述命令会下载一个 Docker 测试镜像,并在容器内执行一个 “hello\_world” 样例程序。

如果你看到类似下方的输出,那么祝贺你!Docker 正常运行在你的 Ubuntu 系统中了。

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete 
Digest: sha256:13e367d31ae85359f42d637adf6da428f76d75dc9afeb3c21faea0d976f5c651
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Run Hello World Docker Container

很好!可以使用 Docker 了。

5、作为非 root 用户运行 Docker (选做)

默认情况下,Docker 守护进程绑定到 Unix 套接字而不是 TCP 端口。由于 Unix 套接字由 root 用户拥有,Docker 守护程序将仅以 root 用户身份运行。因此,普通用户无法执行大多数 Docker 命令。

如果你想要在 Linux 中作为非 root 用户运行 Docker ,参考下方链接:

我个人不这样做也不推荐你这么做。如果你不会在互联网上暴露你的系统,那没问题。然而,不要在生产系统中以非 root 用户身份运行 Docker 。

在 Ubuntu 中安装 Docker Compose

Docker Compose 是一个可用于定义和运行多容器 Docker 应用程序的工具。使用 Compose,你可以使用 Compose 文件来配置应用程序的服务。然后,使用单个命令,你可以从配置中创建和启动所有服务。

下列任何方式都可以安装 Docker Compose 。

方式 1、使用二进制文件安装 Docker Compose

这里 下载最新 Docker Compose 。

当我在写这篇文章时,最新版本是 2.6.1

运行下列命令安装最新稳定的 Docker Compose 文件:

$ sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

如果有更新版本,只需要将上述命令中的 v2.6.1 替换为最新的版本号即可。请不要忘记数字前的 "v"

最后,使用下列命令赋予二进制文件可执行权限:

$ sudo chmod +x /usr/local/bin/docker-compose

运行下列命令检查安装的 Docker Compose 版本:

$ docker-compose version
Docker Compose version v2.6.1

方式 2、使用 Pip 安装 Docker Compose

或许,我们可以使用 Pip 安装 Docker Compose 。Pip 是 Python 包管理器,用来安装使用 Python 编写的应用程序。

参考下列链接安装 Pip 。

安装 Pip 后,运行以下命令安装 Docker Compose。下列命令对于所有 Linux 发行版都是相同的!

$ pip install docker-compose

安装 Docker Compose 后,使用下列命令检查版本:

$ docker-compose --version

你将会看到类似下方的输出:

docker-compose version 2.6.1, build 8a1c60f6

恭喜你!我们已经成功安装了 Docker 社区版和 Docker Compose 。

安装了 Docker,然后呢?查看本系列的下一篇文章,了解 Docker 基础知识。

要在基于 RPM 的系统(例如 RHEL、Fedora、CentOS、AlmaLinux、Rocky Linux 和 openSUSE)中安装 Docker,请参考以下链接。

总结

在这篇教程中,我们讨论了 Docker 是什么,如何在 Ubuntu 22.04 LTS Jammy Jellyfish 中安装 Docker 。然后学习了如何通过运行 hello-world Docker 镜像测试 Docker 是否成功安装。最后,我们通过使用两种不同的方式安装 Docker Compose 作为本教程的结尾。

资料


via: https://ostechnix.com/install-docker-ubuntu/

作者:sk 选题:lkxed 译者:Donkey 校对: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.chello.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中国 荣誉推出

在本指南中,我们将解释在 Arch Linux 中安装漂亮的深度桌面(DDE)所需的步骤。

指南的第一部分解释了安装 Arch 基本系统的步骤。第二部分是在 Arch Linux 的基础上安装完整的深度桌面。

什么是深度桌面(DDE)?

深度操作系统 是一个基于 Debian 稳定分支的、功能丰富且漂亮的桌面环境。深度桌面环境(DDE)是深度操作系统自主开发的桌面环境。它由它自己的 dde-kwin 窗口管理器驱动。深度桌面带有漂亮的停靠区和许多预装的深度原生的应用程序。

这个令人眼花缭乱的桌面环境 可在 Arch 仓库中找到;这篇文章介绍了如何在 Arch Linux 中安装深度桌面。

本指南安装深度桌面环境 20.1。然而,其他版本的步骤也应该是类似的。

第一部分:安装 Arch Linux

如果你已经安装了 Arch Linux,你可以跳过这一步,直接进入安装深度桌面部分。

要快速安装基本的 Arch Linux,请按照以下步骤进行。你也可以访问 本指南 了解以双启动或在虚拟机上安装 Arch Linux 的完整教程。

下载 Arch Linux

从下面的链接下载 Arch Linux 的 .iso 文件。这里有磁力链和 BT 链接。一旦你下载好了,就把 ISO 写入 U 盘。然后从该驱动器启动。

下载 Arch Linux

如果你打算通过 GNOME Boxesvirt-manager 将其安装为虚拟机镜像 —— 那么你不需要将其写入 U 盘。

启动和配置分区

从 Arch Linux ISO 启动后,你必须运行一系列的命令来安装基本系统。

首先,运行下面的命令,找出设备的标识符。

fdisk -l

fdisk -l 之前的分区

然后用此设备标识符,运行下面的命令,开始对你的磁盘进行分区。请确保根据你的系统而修改下面的 /dev/sda 参数。

cfdisk /dev/sda

在下一个提示中选择 label type = dos

选择可用空间,并从底部选择 “NEW” 选项。在这个例子中,我将创建三个分区,如下所示:

/dev/sda1 - 1G - for /boot
/dev/sda2 - 5G - for root
/dev/sda3 - 1G - for swap

cfdisk

在下一个屏幕中,提供启动分区(/boot)的大小(在这个例子中,我给出了 1GB)。选择它作为主分区。

对 5GB 大小的主根分区(/)重复同样的步骤。

改变交换分区的类型

用同样的步骤创建一个大小为 1G 的交换分区(你可以根据你的需要改变大小)。创建交换分区后,确保在底部选择类型,并将其标记为 “Linux Swap/Solaris” 选项的交换分区。

cfdisk 的最终分区列表

完成后,用底部的 “Write” 选项将变化写到磁盘上。确保你在写之前做一个备份,因为这是你系统中的一个永久性的改变。

在你继续之前,运行下面的命令来检查。在这个例子中,你可以看到,列出了三个分区。

fdisk -l

fdisk 中的最终分区列表

依次运行下面的命令,在上面新创建的分区中格式化并创建一个 ext4 文件系统。确保你根据你的需要改变 /dev/sda1/dev/sda2 参数。

mkfs.ext4 /dev/sda1
mkfs.ext4 /dev/sda2
mkswap /dev/sda3
swapon /dev/sda3

完成后,挂载系统并创建必要的目录。

mount /dev/sda2 /mnt
mkdir /mnt/boot /mnt/var /mnt/home
mount /dev/sda1 /mnt/boot

同样,确保你根据你的系统改变 /dev/sda1/dev/sda2/dev/sda3 参数。

准备文件系统

安装基本系统

我希望你已经连接到互联网了。如果没有,请尝试使用 USB 网卡或有线网络连接,Arch 安装程序会自动配置和检测。如果你没有可用的有线连接,请按照本指南使用 Arch Linux 安装程序配置无线 Wi-Fi 网络。

依次运行下面的命令,将基本系统安装到挂载的分区中。下载的大小约为 400MB。

pacman -Syy
pacstrap /mnt base base-devel linux linux-firmware nano dhcpcd net-tools grub

安装基本系统

一旦完成,生成一个文件系统表,没有这个表你就无法启动系统。

genfstab -U /mnt >> /mnt/etc/fstab

配置基本系统

依次按照下面的命令来配置基本系统。这包括设置你的地区和语言,添加一个登录用户,以及设置互联网。

arch-chroot /mnt
nano /etc/locale.gen

去掉开头的 #,取消对你选择的语言环境的注释。在本指南中,我选择了 en_US.UTF-8 UTF-8。按 CTRL+O、回车和 CTRL+X 退出 nano。

改变语言环境

使用以下方法生成语言环境数据。

locale-gen

使用下面的命令设置语言。

echo LANG=en_US.UTF-8 > /etc/locale.conf
export LANG=en_US.UTF-8

设置本地时区。

ln -s /usr/share/zoneinfo/America/New_York /etc/localtime

同样,你可以根据你的需要来选择它们。你可以通过以下命令列出本地时区。

ls /usr/share/zoneinfo
ls /usr/share/zoneinfo/America

依次使用下面的命令设置硬件时钟、创建主机名并启用互联网的 DHCP。你可以根据你的想法把 debugpoint-pc 改为任何主机名。

hwclock --systohc --utc
echo debugpoint-pc > /etc/hostname
systemctl enable dhcpcd

下一步是设置 root 用户的密码、创建一个管理员用户,并将该用户添加到 sudoers 文件中。

按照下面的命令依次进行。确保根据你的需要将用户名debugpoint 改为其他名称。

passwd rootuseradd -m -g users -G wheel -s /bin/bash debugpointpasswd debugpoint

创建用户

打开 sudoers 文件,添加以下几行。

nano /etc/sudoers

添加下面几行。由于你已经创建了 root 用户,该条目应该已经有了。

root ALL=(ALL) ALL
debugpoint ALL=(ALL) ALL

更新 sudoers 文件

安装 GRUB,建立初始的 Ramdisk 环境,并使用下面的命令卸载系统。

grub-install /dev/sda
grub-mkconfig -o /boot/grub/grub.cfg
mkinitcpio -p linux
exit

配置 GRUB

然后重新启动你的系统。

umount /mnt/boot
umount /mnt
reboot

现在你已经成功地安装了 Arch Linux 基本系统。现在是安装完整的深度桌面的时候了。

第二部分:在 Arch Linux 中安装深度桌面

重新启动后,从 GRUB 中选择 Arch Linux。在 Arch Linux 的提示符下,开始依次运行以下命令。这些命令安装 Xorg 服务器、Lightdm 显示管理器和深度桌面组件。

对于所有的命令,使用默认的包版本,即在询问时按回车。

安装 Xorg 和显示管理器。大约安装大小为 80 MB。

sudo pacman -S --need xorg lightdm

安装额外的组件和应用程序(约 550 MB)。

sudo pacman -S --need deepin deepin-extra

安装完成后,通过修改 Lightdm 配置文件启用深度欢迎页。按照下面的命令。

nano /etc/lightdm/lightdm.conf

并添加下面这一行。保存该文件(CTRL+OCTRL+X)。

greeter-session=lightdm-deepin-greeter

在 Lightdm 登录页中添加深度欢迎欢迎页

现在是时候把显示管理器和网络管理器作为服务启用了。这样,下次登录时,它们就可以由 systemd 自动运行。

systemctl enable lightdm
systemctl enable NetworkManager

启用 Lightdm 和网络

使用 reboot 命令重新启动系统。

reboot

如果一切顺利,你应该看到深度桌面的登录提示。使用你刚刚在上面的步骤中创建的凭证登录。你应该会看到最新的深度桌面环境。

Arch Linux 中的深度 20.1 登录屏幕

Arch Linux中的深度桌面 20.1

总结

我希望这个指南能帮助你在 Arch Linux 中安装深度桌面。虽然它不是我的日常环境,我觉得深度的桌面在本质上有些慢。可能是因为有太多的颜色渲染和动画,而且尽管它是建立在 Qt 上的,但没有为深度桌面进行适当的优化。


via: https://www.debugpoint.com/deepin-arch-linux-install-20/

作者:Arindam 选题:lkxed 译者:wxy 校对:wxy

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

我对 终端 Terminal 是怎么回事困惑了很久。

但在上个星期,我使用 xterm.js 在浏览器中显示了一个交互式终端,我终于想到要问一个相当基本的问题:当你在终端中按下键盘上的一个键(比如 Delete,或 Escape,或 a),发送了哪些字节?

像往常一样,我们将通过做一些实验来回答这个问题,看看会发生什么 : )

远程终端是非常古老的技术

首先,我想说的是,用 xterm.js 在浏览器中显示一个终端可能看起来像一个新事物,但它真的不是。在 70 年代,计算机很昂贵。因此,一个机构的许多员工会共用一台电脑,每个人都可以有自己的 “终端” 来连接该电脑。

例如,这里有一张 70 年代或 80 年代的 VT100 终端的照片。这看起来像是一台计算机(它有点大!),但它不是 —— 它只是显示实际计算机发送的任何信息。

https://creativecommons.org/licenses/by/2.0, via Wikimedia Commons">DEC VT100终端

当然,在 70 年代,他们并没有使用 Websocket 来做这个,但来回发送的信息的方式和当时差不多。

(照片中的终端是来自西雅图的 活电脑博物馆 Living Computer Museum ,我曾经去过那里,并在一个非常老的 Unix 系统上用 ed 编写了 FizzBuzz,所以我有可能真的用过那台机器或它的一个兄弟姐妹!我真的希望活电脑博物馆能再次开放,能玩到老式电脑是非常酷的。)

发送了什么信息?

很明显,如果你想连接到一个远程计算机(用 ssh 或使用 xterm.js 和 Websocket,或其他任何方式),那么需要在客户端和服务器之间发送一些信息。

具体来说:

客户端 需要发送用户输入的键盘信息(如 ls -l)。 服务器 需要告诉客户端在屏幕上显示什么。

让我们看看一个真正的程序,它在浏览器中运行一个远程终端,看看有哪些信息会被来回发送!

我们将使用 goterm 来进行实验

我在 GitHub 上发现了这个叫做 goterm 的小程序,它运行一个 Go 服务器,可以让你在浏览器中使用 xterm.js 与终端进行交互。这个程序非常不安全,但它很简单,很适合学习。

复刻了它,使它能与最新的 xterm.js 一起工作,因为它最后一次更新是在 6 年前。然后,我添加了一些日志语句,以打印出每次通过 WebSocket 发送/接收的字节数。

让我们来看看在几个不同的终端交互过程中的发送和接收情况吧!

示例:ls

首先,让我们运行 ls。下面是我在 xterm.js 终端上看到的情况:

~:/play$ ls
file
~:/play$

以下是发送和接收的内容:(在我的代码中,我记录了每次客户端发送的字节:sent: [bytes],每次它从服务器接收的字节:recv: [bytes]

sent: "l"
recv: "l"
sent: "s"
recv: "s"
sent: "\r"
recv: "
\x1b[?2004l\r"
recv: "file
"
recv: "\x1b[~:/play$ "

我在这个输出中注意到 3 件事:

  1. 回显:客户端发送 l,然后立即收到一个 l 发送回来。我想这里的意思是,客户端真的很笨 —— 它不知道当我输入l 时,我想让 l 被回显到屏幕上。它必须由服务器进程明确地告诉它来显示它。
  2. 换行:当我按下回车键时,它发送了一个 \r'(回车)符号,而不是\n'(换行)。
  3. 转义序列:\x1b 是 ASCII 转义字符,所以 \x1b[?2004h 是告诉终端显示什么或其他东西。我想这是一个颜色序列,但我不确定。我们稍后会详细讨论转义序列。

好了,现在我们来做一些稍微复杂的事情。

示例:Ctrl+C

接下来,让我们看看当我们用 Ctrl+C 中断一个进程时会发生什么。下面是我在终端中看到的情况:

~:/play$ cat
^C
~:/play$

而这里是客户端发送和接收的内容。

sent: "c"
recv: "c"
sent: "a"
recv: "a"
sent: "t"
recv: "t"
sent: "\r"
recv: "
\x1b[?2004l\r"
sent: "\x03"
recv: "^C"
recv: "
"
recv: "\x1b[?2004h"
recv: "~:/play$ "

当我按下 Ctrl+C 时,客户端发送了 \x03。如果我查 ASCII 表,\x03 是 “文本结束”,这似乎很合理。我认为这真的很酷,因为我一直对 Ctrl+C 的工作原理有点困惑 —— 很高兴知道它只是在发送一个 \x03 字符。

我相信当我们按 Ctrl+C 时,cat 被中断的原因是服务器端的 Linux 内核收到这个 \x03 字符,识别出它意味着 “中断”,然后发送一个 SIGINT 到拥有伪终端的进程组。所以它是在内核而不是在用户空间处理的。

示例:Ctrl+D

让我们试试完全相同的事情,只是用 Ctrl+D。下面是我在终端看到的情况:

~:/play$ cat
~:/play$

而这里是发送和接收的内容:

sent: "c"
recv: "c"
sent: "a"
recv: "a"
sent: "t"
recv: "t"
sent: "\r"
recv: "
\x1b[?2004l\r"
sent: "\x04"
recv: "\x1b[?2004h"
recv: "~:/play$ "

它与 Ctrl+C 非常相似,只是发送 \x04 而不是 \x03。很好!\x04 对应于 ASCII “传输结束”。

Ctrl + 其它字母呢?

接下来我开始好奇 —— 如果我发送 Ctrl+e,会发送什么字节?

事实证明,这只是该字母在字母表中的编号,像这样。

  • Ctrl+a => 1
  • Ctrl+b => 2
  • Ctrl+c => 3
  • Ctrl+d => 4
  • ...
  • Ctrl+z => 26

另外,Ctrl+Shift+b 的作用与 Ctrl+b 完全相同(它写的是0x2)。

键盘上的其他键呢?下面是它们的映射情况:

  • Tab -> 0x9(与 Ctrl+I 相同,因为 I 是第 9 个字母)
  • Escape -> \x1b
  • Backspace -> \x7f
  • Home -> \x1b[H
  • End -> \x1b[F
  • Print Screen -> \x1b\x5b\x31\x3b\x35\x41
  • Insert -> \x1b\x5b\x32\x7e
  • Delete -> \x1b\x5b\x33\x7e
  • 我的 Meta 键完全没有作用

Alt 呢?根据我的实验(和一些搜索),似乎 AltEscape 在字面上是一样的,只是按 Alt 本身不会向终端发送任何字符,而按 Escape 本身会。所以:

  • alt + d => \x1bd(其他每个字母都一样)
  • alt + shift + d => \x1bD(其他每个字母都一样)
  • 诸如此类

让我们再看一个例子!

示例:nano

下面是我运行文本编辑器 nano 时发送和接收的内容:

recv: "\r\x1b[~:/play$ "
sent: "n" [[]byte{0x6e}]
recv: "n"
sent: "a" [[]byte{0x61}]
recv: "a"
sent: "n" [[]byte{0x6e}]
recv: "n"
sent: "o" [[]byte{0x6f}]
recv: "o"
sent: "\r" [[]byte{0xd}]
recv: "
\x1b[?2004l\r"
recv: "\x1b[?2004h"
recv: "\x1b[?1049h\x1b[22;0;0t\x1b[1;16r\x1b(B\x1b[m\x1b[4l\x1b[?7h\x1b[39;49m\x1b[?1h\x1b=\x1b[?1h\x1b=\x1b[?25l"
recv: "\x1b[39;49m\x1b(B\x1b[m\x1b[H\x1b[2J"
recv: "\x1b(B\x1b[0;7m  GNU nano 6.2 \x1b[44bNew Buffer \x1b[53b \x1b[1;123H\x1b(B\x1b[m\x1b[14;38H\x1b(B\x1b[0;7m[ Welcome to nano.  For basic help, type Ctrl+G. ]\x1b(B\x1b[m\r\x1b[15d\x1b(B\x1b[0;7m^G\x1b(B\x1b[m Help\x1b[15;16H\x1b(B\x1b[0;7m^O\x1b(B\x1b[m Write Out   \x1b(B\x1b[0;7m^W\x1b(B\x1b[m Where Is    \x1b(B\x1b[0;7m^K\x1b(B\x1b[m Cut\x1b[15;61H"

你可以看到一些来自用户界面的文字,如 “GNU nano 6.2”,而这些 \x1b[27m 的东西是转义序列。让我们来谈谈转义序列吧!

ANSI 转义序列

上面这些 nano 发给客户端的 \x1b[ 东西被称为“转义序列”或 “转义代码”。这是因为它们都是以 “转义”字符 \x1b 开头。它们可以改变光标的位置,使文本变成粗体或下划线,改变颜色,等等。维基百科介绍了一些历史,如果你有兴趣的话可以去看看。

举个简单的例子:如果你在终端运行

echo -e '\e[0;31mhi\e[0m there'

它将打印出 “hi there”,其中 “hi” 是红色的,“there” 是黑色的。本页 有一些关于颜色和格式化的转义代码的例子。

我认为有几个不同的转义代码标准,但我的理解是,人们在 Unix 上使用的最常见的转义代码集来自 VT100(博客文章顶部图片中的那个老终端),在过去的 40 年里没有真正改变。

转义代码是为什么你的终端会被搞乱的原因,如果你 cat 一些二进制数据到你的屏幕上 —— 通常你会不小心打印出一堆随机的转义代码,这将搞乱你的终端 —— 如果你 cat 足够多的二进制数据到你的终端,那里一定会有一个 0x1b 的字节。

可以手动输入转义序列吗?

在前面几节中,我们谈到了 Home 键是如何映射到 \x1b[H 的。这 3 个字节是 Escape + [ + H(因为 Escape\x1b)。

如果我在 xterm.js 终端手动键入 Escape ,然后是 [,然后是 H,我就会出现在行的开头,与我按下 Home 完全一样。

我注意到这在我的电脑上的 Fish shell 中不起作用 —— 如果我键入 Escape,然后输入 [,它只是打印出 [,而不是让我继续转义序列。我问了我的朋友 Jesse,他写过 一堆 Rust 终端代码,Jesse 告诉我,很多程序为转义代码实现了一个 超时 —— 如果你在某个最小的时间内没有按下另一个键,它就会决定它实际上不再是一个转义代码了。

显然,这在 Fish shell 中可以用 fish_escape_delay_ms 来配置,所以我运行了 set fish_escape_delay_ms 1000,然后我就能用手输入转义代码了。工作的很好!

终端编码有点奇怪

我想在这里暂停一下,我觉得你按下的键被映射到字节的方式是非常奇怪的。比如,如果我们今天从头开始设计按键的编码方式,我们可能不会把它设置成这样:

  • Ctrl + aCtrl + Shift + a 做的事情完全一样。
  • AltEscape 是一样的
  • 控制序列(如颜色/移动光标)使用与 Escape 键相同的字节,因此你需要依靠时间来确定它是一个控制序列还是用户只是想按 Escape

但所有这些都是在 70 年代或 80 年代或什么时候设计的,然后需要永远保持不变,以便向后兼容,所以这就是我们得到的东西 :smiley:

改变窗口大小

在终端中,并不是所有你能做的事情都是通过来回发送字节发生的。例如,当终端被调整大小时,我们必须以不同的方式告诉 Linux 窗口大小已经改变。

下面是 goterm 中用来做这件事的 Go 代码的样子:

syscall.Syscall(
    syscall.SYS_IOCTL,
    tty.Fd(),
    syscall.TIOCSWINSZ,
    uintptr(unsafe.Pointer(&resizeMessage)),
)

这是在使用 ioctl 系统调用。我对 ioctl 的理解是,它是一个系统调用,用于处理其他系统调用没有涉及到的一些随机的东西,通常与 IO 有关,我猜。

syscall.TIOCSWINSZ 是一个整数常数,它告诉 ioctl 我们希望它在本例中做哪件事(改变终端的窗口大小)。

这也是 xterm 的工作方式。

在这篇文章中,我们一直在讨论远程终端,即客户端和服务器在不同的计算机上。但实际上,如果你使用像 xterm 这样的终端模拟器,所有这些工作方式都是完全一样的,只是很难注意到,因为这些字节并不是通过网络连接发送的。

文章到此结束啦

关于终端,肯定还有很多东西要了解(我们可以讨论更多关于颜色,或者原始与熟化模式,或者 Unicode 支持,或者 Linux 伪终端界面),但我将在这里停止,因为现在是晚上 10 点,这篇文章有点长,而且我认为我的大脑今天无法处理更多关于终端的新信息。

感谢 Jesse Luehrs 回答了我关于终端的十亿个问题,所有的错误都是我的 :smiley:


via: https://jvns.ca/blog/2022/07/20/pseudoterminals/

作者:Julia Evans 选题:lujun9972 译者:wxy 校对:wxy

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