document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-02-03 23:40:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/LCTT/TranslateProject into translating

Browse Source
This commit is contained in:
geekpi 2022-05-25 08:42:51 +08:00
commit 8e2dd569e5
11 changed files with 1081 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
published/20210211 31 open source text editors you need to try.md Normal file
View File

@ -0,0 +1,163 @@
[#]: collector: (lujun9972)
[#]: translator: (CoWave-Fall)
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-14632-1.html)
[#]: subject: (31 open source text editors you need to try)
[#]: via: (https://opensource.com/article/21/2/open-source-text-editors)
[#]: author: (Seth Kenlon https://opensource.com/users/seth)
值得尝试的 30 个开源文本编辑器
======
> 正在寻找新的文本编辑器？这里有 31 个编辑器可供尝试。
![](https://img.linux.net.cn/data/attachment/album/202205/24/184603krbzynnnikz8b0nc.jpg)
计算机是基于文本的，因此你使用它们做的事情越多，你可能就越需要文本编辑应用程序。你在文本编辑器上花费的时间越多，你就越有可能对你使用的编辑器提出更多的要求。
如果你正在寻找一个好的文本编辑器，你会发现 Linux 可以提供很多。无论你是想在终端、桌面还是在云端工作，你都可以试一试。你可以每天一款编辑器，连续着试一个月（或每月试一个，能够试三年）。坚持不懈，你终将找到适合你的完美的编辑器。
### Vim 类编辑器
![][2]
* [Vi][3] 通常随着 Linux 各发行版、BSD、Solaris 和 macOS 一起安装。它是典型的 Unix 文本编辑器，具有编辑模式和超高效的单键快捷键的独特组合。最初的 Vi 编辑器由 Bill Joy 编写（他也是 C shell 的作者）。Vi 的现代版本，尤其是 Vim，增加了许多特性，包括多级撤消、在插入模式下更好的导航、行折叠、语法高亮、插件支持等等。但它需要学习如何使用（它甚至有自己的教程程序，`vimtutor`）。
* [Kakoune][4] 是一个受 Vim 启发的应用程序，它具有熟悉的简约界面、短键盘快捷键以及独立的编辑和插入模式。乍一看，它的外观和感觉很像 Vi，但它在设计和功能上有自己独特的风格。 它有一个小彩蛋：具有 Clippy 界面的实现。
### emacs 编辑器
![][5]
* 从最初的免费 emacs 开始，发展到发起了自由软件运动的 GNU 项目的第一批官方应用程序，[GNU Emacs][6] 是一个广受欢迎的文本编辑器。它非常适合系统管理员、开发人员和日常用户的使用，具有大量功能和近乎无穷无尽的扩展。一旦你开始使用 emacs，你可能会发现很难想出一个理由来关闭它，因为它能做的事情非常多！
* 如果你喜欢 emacs，但觉得 GNU Emacs 过于臃肿，那么你可以试试 [Jove][7]。Jove 是一个基于终端的 emacs 编辑器。它很容易使用，但是如果你是使用 emacs 编辑器家族的新手，那么 Jove 也是很容易学习的，这要归功于 `teajove` 命令。
* 另一个轻量级的 emacs 编辑器是 [Jed][8]。它的工作流程基于宏。它与其他编辑器的不同之处在于它使用了 [S-Lang][9]，这是一种类似 C 的脚本语言，它为使用 C 而不是使用 Lisp 的开发人员提供了扩展的机会。
### 交互式编辑器
![][10]
* [GNU nano][11] 对基于终端的文本编辑采取了大胆的立场：它提供了一个菜单。是的，这个不起眼的编辑器从 GUI 编辑器那里得到了提示，它告诉用户他们需要按哪个键来执行特定的功能。这是一种令人耳目一新的用户体验，所以难怪 nano 被设置为“用户友好”发行版的默认编辑器，而不是 Vi。
* [JOE][12] 基于一个名为 WordStar 的旧文本编辑应用程序。如果你不熟悉 Wordstar，JOE 也可以模仿 Emacs 或 GNU nano。默认情况下，它是介于 Emacs 或 Vi 等相对神秘的编辑器和 GNU Nano 永远显示的冗长信息之间的一个很好的折衷方案（例如，它告诉你如何激活屏幕帮助显示，但默认情况下不启用）。
* [e3][13] 是一个优秀的小型文本编辑器，具有五个内置的键盘快捷键方案，用来模拟 Emacs、Vi、nano、NEdit 和 WordStar。换句话说，无论你习惯使用哪种基于终端的编辑器，你都可能对 e3 感到宾至如归。
### ed 及像 ed 一样的编辑器
* [POSIX][15] 和 Open Group 定义了基于 Unix 的操作系统的标准，[ed][14] 行编辑器是它的一部分。它安装在你遇到的几乎所有 Linux 或 Unix 系统上。它小巧、简洁、一流。
* 基于 ed，[Sed][16] 流编辑器因其功能和语法而广受欢迎。大多数 Linux 用户在搜索如何最简单、最快捷的更新配置文件中的行的方法时，至少会遇到一个 `sed` 命令，但它值得仔细研究一下。Sed 是一个强大的命令，包含许多有用的子命令。更好地了解了它，你可能会发现自己打开文本编辑器应用程序的频率要低得多。
* 你并不总是需要文本编辑器来编辑文本。[heredoc][17]（或 Here Doc）系统可在任何 POSIX 终端中使用，允许你直接在打开的终端中输入文本，然后将输入的内容通过管道传输到文本文件中。这不是最强大的编辑体验，但它用途广泛且始终可用。
### 极简风格的编辑器
![][18]
如果你认为一个好的文本编辑器就是一个文字处理器（除了没有所有的处理功能）的话，你可能正在寻找这些经典编辑器。这些编辑器可让你以最少的干扰和最少的帮助写作和编辑文本。它们提供的功能通常以标记文本、Markdown 或代码为中心。有些名称遵循某种模式：
* [Gedit][19] 来自 GNOME 团队；
* [medit][20] 有经典的 GNOME 手感；
* [Xedit][21] 仅使用最基本的 X11 库；
* [jEdit][22] 适用于 Java 爱好者。
KDE 用户也有类似的：
* [Kate][23] 是一款低调的编辑器，拥有你需要的几乎所有功能；
* [KWrite][24] 在看似简单易用的界面中隐藏了大量有用的功能。
还有一些适用于其他平台：
* [Pe][26] 适用于 Haiku OS（90 年代那个古怪的孩子 BeOS 的转世）；
* [FeatherPad][27] 是适用于 Linux 的基本编辑器，但对 macOS 和 Haiku 有一些支持。如果你是一名希望移植代码的 Qt 黑客，请务必看一看！
### 集成开发环境（IDE）
![][28]
文本编辑器和集成开发环境（IDE）有很多相同之处。后者实际上只是前者加上许多为特定代码而添加的功能。如果你经常使用 IDE，你可能会在扩展管理器中发现一个 XML 或 Markdown 编辑器：
* [NetBeans][29] 是一个方便 Java 用户的文本编辑器。
* [Eclipse][30] 提供了一个强大的编辑套件，其中包含许多扩展，可为你提供所需的工具。
### 云端编辑器
![][31]
在云端工作？当然，你也可以在那里进行编辑。
* [Etherpad][32] 是在网上运行的文本编辑器应用程序。有独立免费的实例供你使用，或者你也可以设置自己的实例。
* [Nextcloud][33] 拥有蓬勃发展的应用场景，包括内置文本编辑器和具有实时预览功能的第三方 Markdown 编辑器。
### 较新的编辑器
![][34]
每个人都会有让文本编辑器变得更完美的想法。因此，几乎每年都会发布新的编辑器。有些以一种新的、令人兴奋的方式重新实现经典的旧想法，有些对用户体验有独特的看法，还有些则专注于特定的需求。
* [Atom][35] 是来自 GitHub 的多功能的现代文本编辑器，具有许多扩展和 Git 集成。
* [Brackets][36] 是 Adobe 为 Web 开发人员提供的编辑器。
* [Focuswriter][37] 旨在通过无干扰的全屏模式、可选的打字机音效和精美的配置选项等有用功能帮助你专注于写作。
* [Howl][38] 是一个基于 Lua 和 Moonscript 的渐进式动态编辑器。
* [Norka][39] 和 [KJots][40] 模仿笔记本，每个文档代表“活页夹”中的“页面”。你可以通过导出功能从笔记本中取出单个页面。
### 自己制作编辑器
![][41]
俗话说得好：既然可以编写自己的应用程序，为什么要使用别人的（虽然其实没有这句俗语）？虽然 Linux 有超过 30 个常用的文本编辑器，但是再说一次，开源的一部分乐趣在于能够亲手进行实验。
如果你正在寻找学习编程的理由，那么制作自己的文本编辑器是一个很好的入门方法。你可以在大约 100 行代码中实现基础功能，并且你使用它的次数越多，你可能就越会受到启发，进而去学习更多知识，从而进行改进。准备好开始了吗？来吧，去 [创建你自己的文本编辑器][42]。
--------------------------------------------------------------------------------
via: https://opensource.com/article/21/2/open-source-text-editors
作者：[Seth Kenlon][a]
选题：[lujun9972][b]
译者：[CoWave-Fall](https://github.com/CoWave-Fall)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/seth
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/button_push_open_keyboard_file_organize.png?itok=KlAsk1gx (open source button on keyboard)
[2]: https://opensource.com/sites/default/files/kakoune-screenshot.png
[3]: https://opensource.com/article/20/12/vi-text-editor
[4]: https://opensource.com/article/20/12/kakoune
[5]: https://opensource.com/sites/default/files/jed.png
[6]: https://opensource.com/article/20/12/emacs
[7]: https://opensource.com/article/20/12/jove-emacs
[8]: https://opensource.com/article/20/12/jed
[9]: https://www.jedsoft.org/slang
[10]: https://opensource.com/sites/default/files/uploads/nano-31_days-nano-opensource.png
[11]: https://opensource.com/article/20/12/gnu-nano
[12]: https://opensource.com/article/20/12/31-days-text-editors-joe
[13]: https://opensource.com/article/20/12/e3-linux
[14]: https://opensource.com/article/20/12/gnu-ed
[15]: https://opensource.com/article/19/7/what-posix-richard-stallman-explains
[16]: https://opensource.com/article/20/12/sed
[17]: https://opensource.com/article/20/12/heredoc
[18]: https://opensource.com/sites/default/files/uploads/gedit-31_days_gedit-opensource.jpg
[19]: https://opensource.com/article/20/12/gedit
[20]: https://opensource.com/article/20/12/medit
[21]: https://opensource.com/article/20/12/xedit
[22]: https://opensource.com/article/20/12/jedit
[23]: https://opensource.com/article/20/12/kate-text-editor
[24]: https://opensource.com/article/20/12/kwrite-kde-plasma
[25]: https://opensource.com/article/20/12/notepad-text-editor
[26]: https://opensource.com/article/20/12/31-days-text-editors-pe
[27]: https://opensource.com/article/20/12/featherpad
[28]: https://opensource.com/sites/default/files/uploads/eclipse-31_days-eclipse-opensource.png
[29]: https://opensource.com/article/20/12/netbeans
[30]: https://opensource.com/article/20/12/eclipse
[31]: https://opensource.com/sites/default/files/uploads/etherpad_0.jpg
[32]: https://opensource.com/article/20/12/etherpad
[33]: https://opensource.com/article/20/12/31-days-text-editors-nextcloud-markdown-editor
[34]: https://opensource.com/sites/default/files/uploads/atom-31_days-atom-opensource.png
[35]: https://opensource.com/article/20/12/atom
[36]: https://opensource.com/article/20/12/brackets
[37]: https://opensource.com/article/20/12/focuswriter
[38]: https://opensource.com/article/20/12/howl
[39]: https://opensource.com/article/20/12/norka
[40]: https://opensource.com/article/20/12/kjots
[41]: https://opensource.com/sites/default/files/uploads/this-time-its-personal-31_days_yourself-opensource.png
[42]: https://opensource.com/article/20/12/31-days-text-editors-one-you-write-yourself

71
translated/tech/20220516 Structured Data Processing with Spark SQL.md → published/20220516 Structured Data Processing with Spark SQL.md
View File

@ -3,47 +3,41 @@
[#]: author: "Phani Kiran https://www.opensourceforu.com/author/phani-kiran/"
[#]: collector: "lkxed"
[#]: translator: "geekpi"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
[#]: reviewer: "wxy"
[#]: publisher: "wxy"
[#]: url: "https://linux.cn/article-14631-1.html"
用 Spark SQL 进行结构化数据处理
======
Spark SQL 是 Spark 生态系统中处理结构化格式数据的模块。它在内部使用 Spark Core API 进行处理，但对用户的使用进行了抽象。这篇文章深入浅出，告诉你 Spark SQL 3.x 的新内容。
![][1]
> Spark SQL 是 Spark 生态系统中处理结构化格式数据的模块。它在内部使用 Spark Core API 进行处理，但对用户的使用进行了抽象。这篇文章深入浅出地告诉你 Spark SQL 3.x 的新内容。
有了 Spark SQL，用户还可以编写 SQL 风格的查询。这对于精通结构化查询语言或 SQL 的广大用户群体来说，基本上是很有帮助的。用户也将能够在结构化数据上编写交互式和临时性的查询。Spark SQL 弥补了弹性分布式数据集（RDD）和关系表之间的差距。RDD 是 Spark 的基本数据结构。它将数据作为分布式对象存储在适合并行处理的节点集群中。RDD 很适合底层处理，但在运行时很难调试，程序员不能自动推断 schema。另外，RDD 没有内置的优化功能。Spark SQL 提供了 DataFrames 和数据集来解决这些问题。
![](https://img.linux.net.cn/data/attachment/album/202205/24/093036xaf6kaz1auaf4a7s.jpg)
Spark SQL 可以使用现有的 Hive 元存储、SerDes 和 UDFs。它可以使用 JDBC/ODBC 连接到现有的 BI 工具。
有了 Spark SQL，用户可以编写 SQL 风格的查询。这对于精通结构化查询语言或 SQL 的广大用户群体来说，基本上是很有帮助的。用户也将能够在结构化数据上编写交互式和临时性的查询。Spark SQL 弥补了<ruby>弹性分布式数据集<rt>resilient distributed data sets</rt></ruby>（RDD）和关系表之间的差距。RDD 是 Spark 的基本数据结构。它将数据作为分布式对象存储在适合并行处理的节点集群中。RDD 很适合底层处理，但在运行时很难调试，程序员不能自动推断<ruby>模式<rt>schema</rt></ruby>。另外，RDD 没有内置的优化功能。Spark SQL 提供了<ruby>数据帧<rt>DataFrame</rt></ruby>和数据集来解决这些问题。
Spark SQL 可以使用现有的 Hive 元存储、SerDes 和 UDF。它可以使用 JDBC/ODBC 连接到现有的 BI 工具。
### 数据源
大数据处理通常需要处理不同的文件类型和数据源（关系型和非关系型）的能力。Spark SQL 支持一个统一的 DataFrame 接口来处理不同类型的源，如下所示。
大数据处理通常需要处理不同的文件类型和数据源（关系型和非关系型）的能力。Spark SQL 支持一个统一的数据帧接口来处理不同类型的源，如下所示。
*文件：*
* 文件：
* CSV
* Text
* JSON
* XML
* JDBC/ODBC：
* MySQL
* Oracle
* Postgres
* 带模式的文件：
* AVRO
* Parquet
* Hive 表：
* Spark SQL 也支持读写存储在 Apache Hive 中的数据。
* CSV
* Text
* JSON
* XML
*JDBC/ODBC：*
* MySQL
* Oracle
* Postgres
*带 schema 的文件：*
* AVRO
* Parquet
*Hive 表：*
* Spark SQL 也支持读写存储在 Apache Hive 中的数据。
通过 DataFrame，用户可以无缝地读取这些多样化的数据源，并对其进行转换/连接。
通过数据帧，用户可以无缝地读取这些多样化的数据源，并对其进行转换/连接。
### Spark SQL 3.x 的新内容
@ -67,19 +61,19 @@ AQE 可以通过设置 SQL 配置来启用，如下所示（Spark 3.0 中默认
spark.conf.set(“spark.sql.adaptive.enabled”,true)
```
#### 动态合并 shuffle 分区
#### 动态合并“洗牌”分区
Spark 在 shuffle 操作后确定最佳的分区数量。在 AQE 中，Spark 使用默认的分区数，即 200 个。这可以通过配置来启用。
Spark 在“<ruby>洗牌<rt>shuffle</rt></ruby>”操作后确定最佳的分区数量。在 AQE 中，Spark 使用默认的分区数，即 200 个。这可以通过配置来启用。
```
spark.conf.set(“spark.sql.adaptive.coalescePartitions.enabled”,true)
```
#### 动态切换 join 策略
#### 动态切换连接策略
广播哈希是最好的连接操作。如果其中一个数据集很小，Spark 可以动态地切换到广播 join，而不是在网络上 shuffe 大量的数据。
广播哈希是最好的连接操作。如果其中一个数据集很小，Spark 可以动态地切换到广播连接，而不是在网络上“洗牌”大量的数据。
#### 动态优化倾斜 join
#### 动态优化倾斜连接
如果数据分布不均匀，数据会出现倾斜，会有一些大的分区。这些分区占用了大量的时间。Spark 3.x 通过将大分区分割成多个小分区来进行优化。这可以通过设置来启用：
@ -91,16 +85,15 @@ spark.conf.set(“spark.sql.adaptive.skewJoin.enabled”,true)
### 其他改进措施
此外，Spark SQL 3.x还支持以下内容。
#### 动态分区修剪
3.x 将只读取基于其中一个表的值的相关分区。这消除了解析大表的需要。
#### Join 提示
#### 连接提示
如果用户对数据有了解，这允许用户指定要使用的 join 策略。这增强了查询的执行过程。
如果用户对数据有了解，这允许用户指定要使用的连接策略。这增强了查询的执行过程。
#### 兼容 ANSI SQL
@ -119,7 +112,7 @@ via: https://www.opensourceforu.com/2022/05/structured-data-processing-with-spar
作者：[Phani Kiran][a]
选题：[lkxed][b]
译者：[geekpi](https://github.com/geekpi)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

51
translated/news/20220518 ONLYOFFICE 7.1 Release Adds ARM Compatibility, a New PDF Viewer, and More Features.md → published/20220518 ONLYOFFICE 7.1 Release Adds ARM Compatibility, a New PDF Viewer, and More Features.md
View File

@ -3,33 +3,32 @@
[#]: author: "Jacob Crume https://news.itsfoss.com/author/jacob/"
[#]: collector: "lkxed"
[#]: translator: "PeterPan0106"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
[#]: reviewer: "wxy"
[#]: publisher: "wxy"
[#]: url: "https://linux.cn/article-14630-1.html"
ONLYOFFICE 7.1 发布，新增针对 ARM 的支持、新的 PDF 查看器还有更多新特性
ONLYOFFICE 7.1 发布，新增针对 ARM 的支持、新的 PDF 查看器
======
ONLYOFFICE Docs 7.1 带来了期待已久的针对文档、电子表格以及演示文稿编辑器的更新。终于对 ARM 的支持更是画龙点睛之笔。
> ONLYOFFICE Docs 7.1 带来了期待已久的针对文档、电子表格以及演示文稿编辑器的更新。对 ARM 的支持更是画龙点睛之笔。
![onlyoffice 7.1][1]
ONLYOFFICE ，被认为是 [最佳的微软 Office 替代品][2] 之一，刚刚发布了最新的 7.1 版本更新。
ONLYOFFICE，被认为是 [最佳的微软 Office 替代品][2] 之一，刚刚发布了最新的 7.1 版本更新。
或许你不了解， ONLYOFFICE 可以在自托管的服务器（例如 Nextcloud ）或者桌面上在线使用。
或许你不了解，ONLYOFFICE 可以在自托管的服务器（例如 Nextcloud）或者桌面上在线使用。
这个版本最为激动人心的变化就是初步支持了基于ARM的设备，例如树莓派。
这个版本最为激动人心的变化就是初步支持了基于 ARM 的设备，例如树莓派。
接下来请让我们一起看看有什么新的变化。
### ONLYOFFICE 7.1 ： 新变化
[<img src="https://i.ytimg.com/vi/5-ervHAemZc/hqdefault.jpg" alt="ONLYOFFICE Docs 7.1: PDF viewer, animations, print preview in spreadsheets">][3]
[![ONLYOFFICE Docs 7.1: PDF viewer, animations, print preview in spreadsheets][4]][3]
![][4]
除了对 ARM 的支持，ONLYOFFICE 7.1 还提供了如下新功能：
除了对 ARM 的支持， ONLYOFFICE 7.1 还提供了如下新功能：
* 一个全新的 PDF 、 XPS 和 DjVu 文件查看器
* 一个全新的 PDF、XPS 和 DjVu 文件查看器
* 更方便和可定制的图形选项
* 电子表格打印预览
* 演示文稿中的动画
@ -37,19 +36,19 @@ ONLYOFFICE ，被认为是 [最佳的微软 Office 替代品][2] 之一，刚刚
#### ARM 兼容
树莓派这样的基于ARM的设备正变得越来越热门，许多人已经期待了许久 ONLYOFFICE 对 ARM 架构的支持。
树莓派这样的基于 ARM 的设备正变得越来越热门，许多人已经期待了许久 ONLYOFFICE 对 ARM 架构的支持。
随着7.1版本的发布， ONLYOFFICE Docs 现在可以在所有 ARM64 设备上运行。由于 ARM 设备的效率和安全性的提高，我认为这将对 ONLYOFFICE 的未来产生很大的促进作用。
随着 7.1 版本的发布，ONLYOFFICE Docs 现在可以在所有 ARM64 设备上运行。由于 ARM 设备的效率和安全性的提高，我认为这将对 ONLYOFFICE 的未来产生很大的促进作用。
#### 全新的 PDF 、 XPS 和 DjVu 文件查看器
#### 全新的 PDF、XPS 和 DjVu 文件查看器
![onlyoffice][5]
这是许多其他办公软件多年来的一个关键功能。从 ONLYOFFICE 7.1 开始，用户现在可以更方便地使用文档编辑器来查看 PDF 、 XPS 和 DjVu 文件。
这是许多其他办公软件多年来的一个关键功能。从 ONLYOFFICE 7.1 开始，用户现在可以更方便地使用文档编辑器来查看 PDF、XPS 和 DjVu 文件。
新的视图选项卡为用户提供了一个页面缩略图视图和一个导航栏，其视图更为紧凑和简化。
此外，用户现在还可以将PDF文件转换为 DOCX 文件，以便对其进行编辑。因此，我们不用再额外打开其他软件进行处理了，这将显著优化现有的工作流并消除瓶颈。
此外，用户现在还可以将 PDF 文件转换为 DOCX 文件，以便对其进行编辑。因此，我们不用再额外打开其他软件进行处理了，这将显著优化现有的工作流并消除瓶颈。
#### 选择和编辑图形更加方便
@ -69,7 +68,7 @@ ONLYOFFICE ，被认为是 [最佳的微软 Office 替代品][2] 之一，刚刚
我相信每个人都发生过由于一个简单的错误而导致打印出现问题的情况。此前其他程序早已经解决了这个问题，但在 ONLYOFFICE 电子表格编辑器中一直没有这个功能。
新版本终于引入了 "打印预览"，这将会显著改善上述的情况。
新版本终于引入了“打印预览”，这将会显著改善上述的情况。
这并不算什么十分新颖的更新，只是说它补齐了短板并且可以节省纸张和打印耗材。
@ -85,13 +84,13 @@ ONLYOFFICE 7.1 演示文稿编辑器现在支持各种动画，以及便捷地
SmartArt 是一种在文档、演示文稿和电子表格中便捷地制作自定义图形的工具。然而，它一直是微软办公软件的一个功能。虽然其他各种应用程序对该格式有不同程度的支持，但它们并不能与微软 Office 相媲美。
幸运的是， ONLYOFFICE 7.1 现在完全支持这种格式，并且没有任何乱码，仿佛原生的一般。用户将不再需要和以前一样在将 SmartArt 图形转换为普通图形和数字，便于无缝切换。
幸运的是，ONLYOFFICE 7.1 现在完全支持这种格式，并且没有任何乱码，仿佛原生的一般。用户将不再需要和以前一样在将 SmartArt 图形转换为普通图形和数字，便于无缝切换。
### 其他变化
ONLYOFFICE 7.1 的其他重要改进包括：
* 新的客户端语言--加利西亚语和阿塞拜疆语
* 新的客户端语言：加利西亚语和阿塞拜疆语
* 在受密码保护的文件中，能够在输入密码的同时查看密码
* OFORM 文件支持缩放选项
* 能够按用户组过滤评论
@ -103,11 +102,11 @@ ONLYOFFICE 7.1 的其他重要改进包括：
* 公式工具提示
* 新的货币格式支持
若想了解全部新特性，请见 [发布日志][9].
若想了解全部新特性，请见 [发布日志][9]。
### 下载 ONLYOFFICE 7.1
总的来说， ONLYOFFICE 7.1 是一个兼容ARM并且功能更为丰富的版本。
总的来说，ONLYOFFICE 7.1 是一个兼容 ARM 并且功能更为丰富的版本。
所有版本（企业版、开发版者、社区版）都有更新。
@ -115,7 +114,7 @@ ONLYOFFICE 7.1 的其他重要改进包括：
下载页面同时列出了安装的官方指南。
[获取 ONLYOFFICE 7.1 ][10]
> **[获取 ONLYOFFICE 7.1][10]**
*你是否已经尝试了新版本呢？*
@ -126,7 +125,7 @@ via: https://news.itsfoss.com/onlyoffice-7-1-release/
作者：[Jacob Crume][a]
选题：[lkxed][b]
译者：[PeterPan0106](https://github.com/PeterPan0106)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
@ -135,7 +134,7 @@ via: https://news.itsfoss.com/onlyoffice-7-1-release/
[1]: https://news.itsfoss.com/wp-content/uploads/2022/05/onlyoffice-7-1.jpg
[2]: https://itsfoss.com/best-free-open-source-alternatives-microsoft-office/
[3]: https://youtu.be/5-ervHAemZc
[4]: https://youtu.be/5-ervHAemZc
[4]: https://i.ytimg.com/vi/5-ervHAemZc/hqdefault.jpg
[5]: https://news.itsfoss.com/wp-content/uploads/2022/05/ONLYOFFICE-viewer.png
[6]: https://news.itsfoss.com/wp-content/uploads/2022/05/ONLYOFFICE-shapes.png
[7]: https://news.itsfoss.com/wp-content/uploads/2022/05/ONLYOFFICE-Print-Preview.png

4
sources/news/20220523 Linux Kernel 5.18 Released with Graphics Driver Changes and New Hardware Support.md
View File

@ -2,7 +2,7 @@
[#]: via: "https://news.itsfoss.com/linux-kernel-5-18-release/"
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: translator: "PeterPan0106"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
@ -105,7 +105,7 @@ via: https://news.itsfoss.com/linux-kernel-5-18-release/
作者：[Ankush Das][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
译者：[PeterPan0106](https://github.com/PeterPan0106)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

60
sources/news/20220524 Woah! Broadcom Could Acquire VMware for $60 Billion.md Normal file
View File

@ -0,0 +1,60 @@
[#]: subject: "Woah! Broadcom Could Acquire VMware for $60 Billion"
[#]: via: "https://news.itsfoss.com/broadcom-vmware-deal/"
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Woah! Broadcom Could Acquire VMware for $60 Billion
======
Broadcom’s interested to acquire VMware for $60 billion, making it one of the biggest tech deals in 2022.
![broadcom][1]
Broadcom, a semiconductor chip company, is infamous among desktop Linux users for the incompatibility issues with its wireless adapter/card and drivers.
And, it is now planning to get into the cloud computing market by acquiring one of the biggest players in the industry, i.e., **VMware**.
VMware is not an open-source company, but it offers some open-source tools and Linux support for its virtualization software.
In this case, **The Wall Street Journal** [reports][2] that Broadcom and VMware can potentially announce this acquisition later this week on Thursday.
### Broadcom to Enter the Cloud Computing Market
[Broadcom][3] should be a familiar name to Linux users when we talk about wireless network chips and their drivers.
And, with the $60 billion deal for [VMware][4], they could expand their take on the industry through VMware’s reach in the cloud computing sector.
So, their decision also influences the talk about the acquisition by Broadcom.
Hence, it is safe to say that the deal may or may not go through if the discussions fall apart.
And, for the payment to succeed, the report also mentions that Broadcom plans to take help of banks for a $40 billion debt package.
Considering that the report mentions the final price is still up for discussion, the $60 billion value can change (but something around it).
### Wrapping Up
You can keep an eye on VMware’s shares and Broadcom Inc if you are someone who is interested in getting involved in the market.
What do you think about Broadcom acquiring VMware? Do you think it’s going to go through with Dell involved with a major stake in the company? Feel free to share your thoughts in the comments below.
--------------------------------------------------------------------------------
via: https://news.itsfoss.com/broadcom-vmware-deal/
作者：[Ankush Das][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://news.itsfoss.com/author/ankush/
[b]: https://github.com/lkxed
[1]: https://news.itsfoss.com/wp-content/uploads/2022/05/broadcom-vmware-acquisition.jpg
[2]: https://www.wsj.com/articles/broadcom-discussing-paying-around-140-a-share-for-vmware-people-say-11653334946
[3]: https://www.broadcom.com/
[4]: https://www.vmware.com/i

187
sources/tech/20220524 12 essential Linux commands for beginners.md Normal file
View File

@ -0,0 +1,187 @@
[#]: subject: "12 essential Linux commands for beginners"
[#]: via: "https://opensource.com/article/22/5/essential-linux-commands"
[#]: author: "Don Watkins https://opensource.com/users/don-watkins"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
12 essential Linux commands for beginners
======
I recommend these commands to anyone who is getting started with Linux.
![Command line prompt][1]
Image by: Opensource.com
When operating on the Linux command line, it is easy to get disoriented, which can have disastrous consequences. I once issued a remove command before realizing that I'd moved the boot directory of my computer. I learned to use the `pwd` command to know exactly which part of the file system I was in (and these days, there are command projects, like [trashy and trash-cli][2], that serve as intermediates when removing files).
When I was new to Linux, I had a cheat sheet that hung over my desk to help me remember those commands as I managed my Linux servers. It was called the *101 commands for Linux* cheat sheet. As I became more familiar with these commands, I became more proficient with server administration.
Here are 12 Linux commands I find most useful.
### 1. Print working directory (pwd)
The `pwd` command prints your working directory. In other words, it outputs the path of the directory you are currently working in. There are two options: `--logical` to display your location with any symlinks and `--physical` to display your location after resolving any symlinks.
### 2. Make directory (mkdir)
Making directories is easy with the `mkdir` command. The following command creates a directory called `example` unless `example` already exists:
```
$ mkdir example
```
You can make directories within directories:
```
$ mkdir -p example/one/two
```
If directories `example` and `one` already exist, only directory `two` is created. If none of them exist, then three nested directories are created.
### 3. List (ls)
Coming from MS-DOS, I was used to listing files with the `dir` command. I don't recall working on Linux at the time, although today, `dir` is in the GNU Core Utilities package. Most people use the `ls` command to display the files, along with all their properties, are in a directory. The `ls` command has many options, including `-l` to view a long listing of files, displaying the file owner and permissions.
### 4. Change directory (cd)
It is often necessary to change directories. That's the `cd` command's function. For instance, this example takes you from your home directory into the `Documents` directory:
```
$ cd Documents
```
You can quickly change to your home directory with `cd ~` or just `cd` on most systems. You can use `cd ..` to move up a level.
### 5. Remove a file (rm)
Removing files is inherently dangerous. Traditionally, the Linux terminal has no Trash or Bin like the desktop does, so many terminal users have the bad habit of permanently removing data they believe they no longer need. There's no "un-remove" command, though, so this habit can be problematic should you accidentally delete a directory containing important data.
A Linux system provides `rm` and `shred` for data removal. To delete file `example.txt`, type the following:
```
$ rm example.txt
```
However, it's much safer to install a trash command, such as [trashy][3] or [trash-cli][4]. Then you can send files to a staging area before deleting them forever:
```
$ trash example.txt
```
### 6. Copy a file (cp)
Copy files with the `cp` command. The syntax is copy *from-here* *to-there*. Here's an example:
```
$ cp file1.txt newfile1.txt
```
You can copy entire directories, too:
```
$ cp -r dir1 newdirectory
```
### 7. Move and rename a file (mv)
Renaming and moving a file is functionally the same process. When you move a file, you take a file from one directory and put it into a new one. When renaming a file, you take a file from one directory and put it back into the same directory or a different directory, but with a new name. Either way, you use the `mv` command:
```
$ mv file1.txt file_001.txt
```
### 8. Create an empty file (touch)
Easily create an empty file with the `touch` command:
```
$ touch one.txt
$ touch two.txt
$ touch three.md
```
### 9. Change permissions (chmod)
Change the permissions of a file with the `chmod` command. One of the most common uses of `chmod` is making a file executable:
```
$ chmod +x myfile
```
This example is how you give a file permission to be executed as a command. This is particularly handy for scripts. Try this simple exercise:
```
$ echo 'echo Hello $USER' > hello.sh
$ chmod +x hello.sh
$ ./hello.sh
Hello, Don
```
### 10. Escalate privileges (sudo)
While administering your system, it may be necessary to act as the super user (also called root). This is where the `sudo` (or *super user do*) command comes in. Assuming you're trying to do something that your computer alerts you that only an administrator (or root) user can do, just preface it with the command `sudo` :
```
$ touch /etc/os-release && echo "Success"
touch: cannot touch '/etc/os-release': Permission denied
$ sudo touch /etc/os-release && echo "Success"
Success
```
### 11. Shut down (poweroff)
The `poweroff` command does exactly what it sounds like: it powers your computer down. It requires `sudo` to succeed.
There are actually many ways to shut down your computer and some variations on the process. For instance, the `shutdown` command allows you to power down your computer after an arbitrary amount of time, such as 60 seconds:
```
$ sudo shutdown -h 60
```
Or immediately:
```
$ sudo shutdown -h now
```
You can also restart your computer with `sudo shutdown -r now` or just `reboot`.
### 12. Read the manual (man)
The `man` command could be the most important command of all. It gets you to the documentation for each of the commands on your Linux system. For instance, to read more about `mkdir` :
```
$ man mkdir
```
A related command is `info`, which provides a different set of manuals (as long as they're available) usually written more verbosely than the often terse man pages.
### What's your favorite Linux command?
There are many more commands on a Linux system—hundreds! What's your favorite command, the one you find yourself using time and time again?
--------------------------------------------------------------------------------
via: https://opensource.com/article/22/5/essential-linux-commands
作者：[Don Watkins][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/don-watkins
[b]: https://github.com/lkxed
[1]: https://opensource.com/sites/default/files/lead-images/command_line_prompt.png
[2]: https://www.redhat.com/sysadmin/recover-file-deletion-linux
[3]: https://gitlab.com/trashy/trashy
[4]: https://github.com/andreafrancia/trash-cli

232
sources/tech/20220524 Build a Quarkus reactive application using Kubernetes Secrets.md Normal file
View File

@ -0,0 +1,232 @@
[#]: subject: "Build a Quarkus reactive application using Kubernetes Secrets"
[#]: via: "https://opensource.com/article/22/5/quarkus-kubernetes-secrets"
[#]: author: "Daniel Oh https://opensource.com/users/daniel-oh"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Build a Quarkus reactive application using Kubernetes Secrets
======
Follow security policies while developing applications for the cloud by using Kubernetes Secrets.
![Improve your DevOps security game with Ansible Vault][1]
Image by: Opensource.com
Many organizations have security policies in place that dictate how to store sensitive information. When you're developing applications for the cloud, you're probably expected to follow those policies, and to do that you often have to externalize your data storage. Kubernetes has a built-in system to access external secrets, and learning to use that is key to a safe cloud-native app.
In this article, I'm going to demonstrate how to build a Quarkus reactive application with externalized sensitive information—for instance, a password or token—using [Kubernetes Secrets][2]. A secret is a good example of how cloud platforms can secure applications by removing sensitive data from your static code. Note that you can find a solution to this tutorial [in this GitHub repository][3].
### 1. Scaffold a new reactive Quarkus project
Use the Quarkus command-line interface (CLI) to scaffold a new project. If you haven't already installed the Quarkus CLI, follow these [instructions][5] according to your operating system.
Run the following Quarkus CLI in your project directory to add `kubernetes-config`, `resteasy-reactive`, and `openshift` extensions:
```
$ quarkus create app quarkus-secret-example \
-x resteasy-reactive,kubernetes-config,openshift
```
The output should look like this:
```
Looking for the newly published extensions in registry.quarkus.io
selected extensions:
- io.quarkus:quarkus-kubernetes-config
- io.quarkus:quarkus-resteasy-reactive
- io.quarkus:quarkus-openshift
applying codestarts...
📚  java
🔨  maven
📦  quarkus
📝  config-properties
🔧  dockerfiles
🔧  maven-wrapper
🚀  resteasy-reactive-codestart
-----------
[SUCCESS] ✅  quarkus project has been successfully generated in:
--> /tmp/quarkus-secret-example
-----------
Navigate into this directory and get started: quarkus dev
```
### 2. Create a Secret in Kubernetes
To manage the Kubernetes Secrets, you have three options:
* Using kubectl
* Using Configuration File
* Node [Kustomize][6]
Use the `kubectl` command to create a new database credential (a username and password). Run the following command:
```
$ kubectl create secret generic db-credentials \                                                                      
 --from-literal=username=admin \
 --from-literal=password=secret
```
If you haven't already installed a Kubernetes cluster locally, or you have no remote cluster, you can sign in to the [developer sandbox][7], a no-cost sandbox environment for Red Hat OpenShift and CodeReady Workspaces.
You can confirm that the Secret is created properly by using the following command:
```
$ kubectl get secret/db-credentials -o yaml
```
The output should look like this:
```
apiVersion: v1
data:
  password: c2VjcmV0
  username: YWRtaW4=
kind: Secret
metadata:
  creationTimestamp: "2022-05-02T13:46:18Z"
  name: db-credentials
  namespace: doh-dev
  resourceVersion: "1190920736"
  uid: 936abd44-1097-4c1f-a9d8-8008a01c0add
type: Opaque
```
The username and password are encoded by default.
### 3. Create a new RESTful API to access the Secret
Now you can add a new RESTful (for Representational State Transfer) API to print out the username and password stored in the Kubernetes Secret. Quarkus enables developers to refer to the secret as a normal configuration using a `@ConfigureProperty` annotation.
Open a `GreetingResource.java` file in `src/main/java/org/acme`. Then, add the following method and configurations:
```
@ConfigProperty(name = "username")
    String username;
    @ConfigProperty(name = "password")
    String password;
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("/securty")
    public Map securty() {
        HashMap<String, String> map = new HashMap<>();
        map.put("db.username", username);
        map.put("db.password", password);
        return map;
    }
```
Save the file.
### 4. Set the configurations for Kubernetes deployment
Open the `application.properties` file in the `src/main/resources` directory. Add the following configuration for the Kubernetes deployment. In the tutorial, I'll demonstrate using the developer sandbox, so the configurations tie to the OpenShift cluster.
If you want to deploy it to the Kubernetes cluster, you can package the application via Docker container directly. Then, you need to push the container image to an external container registry (for example, Docker Hub, quay.io, or Google container registry).
```
# Kubernetes Deployment
quarkus.kubernetes.deploy=true
quarkus.kubernetes.deployment-target=openshift
openshift.expose=true
quarkus.openshift.build-strategy=docker
quarkus.kubernetes-client.trust-certs=true
# Kubernetes Secret
quarkus.kubernetes-config.secrets.enabled=true
quarkus.kubernetes-config.secrets=db-credentials
```
Save the file.
### 5. Build and deploy the application to Kubernetes
To build and deploy the reactive application, you can also use the following Quarkus CLI:
```
$ quarkus build
```
This command triggers the application build to generate a `fast-jar` file. Then the application `Jar` file is containerized using a Dockerfile, which was already generated in the `src/main/docker` directory when you created the project. Finally, the application image is pushed into the integrated container registry inside the OpenShift cluster.
The output should end with a `BUILD SUCCESS` message.
When you deploy the application to the developer sandbox or normal OpenShift cluster, you can find the application in the Topology view in the Developer perspective, as shown in the figure below.
![A screenshot of Red Hat OpenShift Dedicated. In the left sidebar menu Topology is highlighted, and in the main screen there is a Quarkus icon][8]
Image by: (Daniel Oh, CC BY-SA 4.0)
### 6. Verify the sensitive information
To verify that your Quarkus application can refer to the sensitive information from the Kubernetes Secret, get the route URL using the following `kubectl` command:
```
$ kubectl get route
```
The output is similar to this:
```
NAME                     HOST/PORT                                                               PATH   SERVICES                 PORT   TERMINATION   WILDCARD
quarkus-secret-example   quarkus-secret-example-doh-dev.apps.sandbox.x8i5.p1.openshiftapps.com          quarkus-secret-example   8080                 None
```
Use the [curl command][9] to access the RESTful API:
```
$ curl http://YOUR_ROUTE_URL/hello/security
```
The output:
```
{db.password=secret, db.username=admin}
```
Awesome! The above `username` and `password` are the same as those you stored in the `db-credentials` secret.
### Where to learn more
This guide has shown how Quarkus enables developers to externalize sensitive information using Kubernetes Secrets. Find additional resources to develop cloud-native microservices using Quarkus on Kubernetes here:
* [7 guides for developing applications on the cloud with Quarkus][10]
* [Extend Kubernetes service discovery with Stork and Quarkus][11]
* [Deploy Quarkus applications to Kubernetes using a Helm chart][12]
You can also watch this step-by-step [tutorial video][13] on how to manage Kubernetes Secrets with Quarkus.
--------------------------------------------------------------------------------
via: https://opensource.com/article/22/5/quarkus-kubernetes-secrets
作者：[Daniel Oh][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/daniel-oh
[b]: https://github.com/lkxed
[1]: https://opensource.com/sites/default/files/lead-images/rh_003601_05_mech_osyearbook2016_security_cc.png
[2]: https://kubernetes.io/docs/concepts/configuration/secret/
[3]: https://github.com/danieloh30/quarkus-secret-example.git
[4]: https://enterprisersproject.com/article/2019/8/kubernetes-secrets-explained-plain-english?intcmp=7013a000002qLH8AAM
[5]: https://quarkus.io/guides/cli-tooling#installing-the-cli
[6]: https://kustomize.io/
[7]: https://developers.redhat.com/developer-sandbox/get-started
[8]: https://opensource.com/sites/default/files/2022-05/quarkus.png
[9]: https://opensource.com/article/20/5/curl-cheat-sheet
[10]: https://opensource.com/article/22/4/developing-applications-cloud-quarkus
[11]: https://opensource.com/article/22/4/kubernetes-service-discovery-stork-quarkus
[12]: https://opensource.com/article/21/10/quarkus-helm-chart
[13]: https://youtu.be/ak9R9-E_0_k

130
sources/tech/20220524 Collision- Linux App to Verify ISO and Other Files.md Normal file
View File

@ -0,0 +1,130 @@
[#]: subject: "Collision: Linux App to Verify ISO and Other Files"
[#]: via: "https://www.debugpoint.com/2022/05/collision/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Collision: Linux App to Verify ISO and Other Files
======
The tutorial outlines the features and usage guide of Collision. It is a GUI-based, easy-to-use utility that lets you verify files using cryptographic hash functions.
### Why do you need to verify files?
Everyone downloads files every day over the internet. But many users never bother to verify their integrity or authenticity. That means whether the file is legitimate and not tampered with by any malicious codes.
Take an example of any [Linux Distributions][1]‘ ISO files which come as standard installer images. All popular distribution makers also provide a hash file alongside the ISO file. Using that file, you can easily compare the hash value of your downloaded file. And you can rest assured that your file is correct and not corrupted by any means.
Moreover, if you download a large file over an unstable internet connection, the file may get corrupted. IN those scenarios also, it helps to verify.
### Collision – Features and How to Use
The app – [Collision][2] uses Cryptographic Hash Functions to help you verify files. The cryptographic hash functions are popular algorithms that generate the file data into a fixed-length data stream via several encryption algorithms. The most popular ones are MD5, SHA-1, SHA-256 and SHA-512. All of these are supported by the Collision app.
In addition to that, Collision also presents a neat user interface which is simple and easy to use for every Linux user. Here’s how it looks.
![Collision – First Screen][3]
Firstly, it has two primary features. a) upload a file to get the checksum or hash values and b) compare the checksum with the uploaded file.
For example, if you have a simple file, you can upload it via the “Open a File” button or “Open” for re-uploading another file.
As you can see in the below image, the text file has the below checksum for various hash functions. Now you can share the file over the internet/with anyone, along with the checksum values for verification.
![Hash values of a test file][4]
Moreover, if someone tampers with the file (even with a single byte) or the file gets corrupted during distribution, then the hash value changes entirely.
Secondly, if you want to verify the integrity of a file you have downloaded, go to the Verify tab. Then upload the file and enter the hash value of the uploaded file you received.
If it matches, you should see a green tick showing its authenticity.
![Collision verifies a sample file with SHA-256][5]
In addition, here is another example where I have modified the test file and kept the values as same. This use case clearly states that it’s not valid for this file.
![Collision showing that a file is not valid][6]
#### An important note
It is worth mentioning here that the hash methods don’t verify the file meta attributes such as modify time, modify date, etc. If someone tampers any file and reverts it to its original content, the hash methods would term it a valid file.
Now, let’s see a typical example of validating an ISO file.
### Example of Using Collision to verify a sample ISO file of Ubuntu Linux
I am sure you download many ISO files while using Linux in general. So to illustrate, I have downloaded the popular Ubuntu ISO server image from the official Ubuntu download page.
![Ubuntu server ISO file and checksums][7]
The SHA256SUMS file has the below checksum value for the installer, as shown above.
![SHA-256 value of Ubuntu server ISO image][8]
After you download, open the Collision application and upload the ISO file via the Verify tab. Then copy the SHA-256 value and paste it to the checksum box on the left.
You should see that the file is authentic if you have correctly downloaded and followed the steps.
![Ubuntu server ISO image verified][9]
### How to Install Collision
The Collision app installation is effortless using Flatpak. You need to [set up Flatpak][10] for your Linux Distributions and click on the below link to install Collision.
[Install Collision via Flathub][11]
After installation, you should find it via the application menu of your distro.
### Is there another way to verify files without any app?
Yes, there are some built-in utilities available in all Linux distributions, which you can also use to verify the files and their integrity using the terminal.
The following terminal utilities can be used to determine the hash of any file. They are installed by default in all distros, and you can even use them for your shell script to automate.
```
md5sum <file name>
```
```
sha1sum <file name>
```
```
sha256sum <file name>
```
Using the above utilities, you can find out the hash value. But you need to compare them to verify manually.
![Verify files via command-line utilities][12]
### Closing Notes
I hope this guide helps you verify your files using the Collision GTK app. It is straightforward to use. Moreover, you can use the command line methods to verify any files you want when you are in the terminal. Also, it’s a best practice to always check for file integrity wherever possible.
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/05/collision/
作者：[Arindam][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.debugpoint.com/author/admin1/
[b]: https://github.com/lkxed
[1]: https://www.debugpoint.com/category/distributions
[2]: https://collision.geopjr.dev/
[3]: https://www.debugpoint.com/wp-content/uploads/2022/05/Collision-First-Screen.jpg
[4]: https://www.debugpoint.com/wp-content/uploads/2022/05/Hash-values-of-a-test-file.jpg
[5]: https://www.debugpoint.com/wp-content/uploads/2022/05/Collision-verifies-a-sample-file-with-SHA-256.jpg
[6]: https://www.debugpoint.com/wp-content/uploads/2022/05/Collision-showing-that-a-file-is-not-valid.jpg
[7]: https://www.debugpoint.com/wp-content/uploads/2022/05/Ubuntu-server-ISO-file-and-checksums.jpg
[8]: https://www.debugpoint.com/wp-content/uploads/2022/05/SHA-256-valud-of-Ubuntu-server-ISO-image.jpg
[9]: https://www.debugpoint.com/wp-content/uploads/2022/05/Ubuntu-server-ISO-image-verified.jpg
[10]: https://flatpak.org/setup/
[11]: https://dl.flathub.org/repo/appstream/dev.geopjr.Collision.flatpakref
[12]: https://www.debugpoint.com/wp-content/uploads/2022/05/Verify-files-via-command-line-utilities.jpg

234
sources/tech/20220524 pdfgrep- Use Grep Like Search on PDF Files in Linux Command Line.md Normal file
View File

@ -0,0 +1,234 @@
[#]: subject: "pdfgrep: Use Grep Like Search on PDF Files in Linux Command Line"
[#]: via: "https://itsfoss.com/pdfgrep/"
[#]: author: "Pratham Patel https://itsfoss.com/author/pratham/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
pdfgrep: Use Grep Like Search on PDF Files in Linux Command Line
======
Even if you use the Linux command line moderately, you must have come across the [grep command][1].
Grep is used to search for a pattern in a text file. It can do crazy powerful things, like search for new lines, search for lines where there are no uppercase characters, search for lines where the initial character is a number, and much, much more. Check out some [common grep command examples][2] if you are interested.
But grep works only on plain text files. It won’t work on PDF files because they are binary files.
This is where pdfgrep comes into the picture. It works like grep for PDF files. Let us have a look at that.
### Meet pdfgrep: grep like regex search for PDF files
[pdfgrep][3] tries to be compatible with GNU Grep, where it makes sense. Several of your favorite grep options are supported (such as -r, -i, -n or -c). You can use to search for text inside the contents of PDF files.
Though it doesn’t come pre-installed like grep, it is available in the repositories of most Linux distributions.
You can use your distribution’s [package manager][4] to install this awesome tool.
For users of Ubuntu and Debian-based distributions, use the apt command:
```
sudo apt install pdfgrep
```
For Red Hat and Fedora, you can use the dnf command:
```
sudo dnf install pdfgrep
```
Btw, do you run Arch? You can [use the pacman command][5]:
```
sudo pacman -S pdfgrep
```
### Using pdfgrep command
Now that pdfgrep is installed let me show you how to use it in most common scenarios.
If you have any experience with grep, then most of the options will feel familiar to you.
To demonstrate, I will be using [The Linux Command Line][6] PDF book, written by William Shotts. It’s one of the [few Linux books that are legally available for free][7].
The syntax for pdfgrep is as follows:
```
pdfgrep [PATTERN] [FILE.pdf]
```
#### Normal search
Let’s try doing a basic search for the text ‘xdg’ in the PDF file.
```
pdfgrep xdg TLCL-19.01.pdf
```
![simple search using pdfgrep][8]
This resulted in only one match… But a match nonetheless!
#### Case insensitive search
Most of the time, the term ‘xdg’ is used with capitalized alphabetical characters. So, let’s try doing a case-insensitive search. For a case insensitive search, I will use the –ignore-case option.
You can also use the shorter alternative, which is -i.
```
pdfgrep --ignore-case xdg TLCL-19.01.pdf
```
![case insensitive search using pdfgrep][9]
As you can see, I got more matches after turning on case insensitive searching.
#### Get a count of all matches
Sometimes, the user wants to know how many matches were found of the word. Let’s see how many times the word ‘Linux’ is mentioned (with case insensitive matching).
The option to use in this scenario is –count (or -c for short).
```
pdfgrep --ignore-case linux TLCL-19.01.pdf --count
```
![getting a count of matches using pdfgrep][10]
Woah! Linux was mentioned 1200 times in this book… That was unexpected.
#### Show page number
Regular text files are giant monolithic files. There are no pages. But a PDF file has pages. So, you can see where the pattern was found and on which page. Use the –page-number option to show the page number where the pattern was matched. You can also use the `-n` option as a shorter alternative.
Let us see how it works with an example. I want to see the pages where the word ‘awk’ matches. I added a space at the end of the pattern to prevent matching with words like ‘awkward’, getting unintentional matches would be *awkward*. Instead of escaping space with a backslash, you can also enclose it in single quotes ‘awk ‘.
```
pdfgrep --page-number --ignore-case awk\ TLCL-19.01.pdf
```
![show which pattern was found on which page using pdfgrep][11]
The word ‘awk’ was found twice on page number 333, once on page 515 and once again on page 543 in the PDF file.
#### Show match count per page
Do you want to know how many matches were found on which page instead of showing the matches themselves? If you said yes, well it is your lucky day!
Using the –page-count option does exactly that. As a shorter alternative, you use the -p option. When you provide this option to pdfgrep, it is assumed that you requested `-n` as well.
Let’s take a look at how the output looks. For this example, I will see where the [ln command][12] is used in the book.
```
pdfgrep --page-count ln\ TLCL-19.01.pdf
```
![show which page has how many matches using pdfgrep][13]
The output is in the form of ‘page number: matches’. This means, on page number 4, the command (or rather “pattern”) was found only once. But on page number 57, pdfgrep found 4 matches.
#### Get some context
When the number of matches found is quite big, it is nice to have some context. For that, pdfgrep provides some options.
* –after-context NUM: Print NUM of lines that come after the matching lines (or use `-A`)
* –before-context NUM: Print NUM of lines that are before the matching lines (or use `-B`)
* –context NUM: Print NUM of lines that are before and come after the matching lines (or use `-C`)
Let’s find ‘XDG’ in the PDF file, but this time, with a little more context ( ͡❛ ͜ʖ ͡❛)
**Context after matches**
Using the –after-context option along with a number, I can see which lines come after the line(s) that match. Below is an example of how it looks.
```
pdfgrep --after-context 2 XDG TLCL-19.01.pdf
```
![using '--after-context' option in pdfgrep][14]
**Context before matches**
Same thing can be done for scenarios when you need to know what lines are present before the line that matches. In that case, use the –before-context option, along with a number. Below is an example demonstrating usage of this option.
```
pdfgrep --before-context 2 XDG TLCL-19.01.pdf
```
![using '--before-context' option in pdfgrep][15]
**Context around matches**
If you want to see which lines are present before and come after the line that matched, use the –context option and also provide a number. Below is an example.
```
pdfgrep --context 2 XDG TLCL-19.01.pdf
```
![using '--context' option in pdfgrep][16]
#### Caching
A PDF file consists of images as well as text. When you have a large PDF file, it might take some time to skip other media, extract text and then “grep” it. Doing it often and waiting every time can get frustrating.
For that reason, the –cache option exists. It caches the rendered text to speed up grep-ing. This is especially noticeable on large files.
```
pdfgrep --cache --ignore-case grep TLCL-19.01.pdf
```
![getting faster results using the '--cache' option][17]
While not the be-all and end-all, I carried out a search 4 times. Twice with cache enable and twice without cache enable. To show the speed difference, I used the time command. Look closely at the time indicated by ‘real’ value.
As you can see, the commands that include –cache option were completed faster than the ones that didn’t include it.
Additionally, I suppressed the output using the –quiet option for faster completion.
#### Password protected PDF files
Yes, pdfgrep supports grep-ing even password-protected files. All you have to do is use the –password option, followed by the password.
I do not have a password-protected file to demonstrate with, but you can use this option in the following manner:
```
pdfgrep --password [PASSWORD] [PATTERN] [FILE.pdf]
```
### Conclusion
pdfgrep is a very handy tool if you are dealing with PDF files and want the functionality of ‘grep’, but for PDF files. A reason why I like pdfgrep is that it tries to be compatible with GNU Grep.
Give it a try and let me know what you think of pdfgrep.
--------------------------------------------------------------------------------
via: https://itsfoss.com/pdfgrep/
作者：[Pratham Patel][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/pratham/
[b]: https://github.com/lkxed
[1]: https://linuxhandbook.com/what-is-grep/
[2]: https://linuxhandbook.com/grep-command-examples/
[3]: https://pdfgrep.org/
[4]: https://itsfoss.com/package-manager/
[5]: https://itsfoss.com/pacman-command/
[6]: https://www.linuxcommand.org/tlcl.php
[7]: https://itsfoss.com/learn-linux-for-free/
[8]: https://itsfoss.com/wp-content/uploads/2022/05/01_pdfgrep_normal_search-1-800x308.webp
[9]: https://itsfoss.com/wp-content/uploads/2022/05/02_pdfgrep_case_insensitive-800x413.webp
[10]: https://itsfoss.com/wp-content/uploads/2022/05/03_pdfgrep_count-800x353.webp
[11]: https://itsfoss.com/wp-content/uploads/2022/05/04_pdfgrep_page_number-800x346.webp
[12]: https://linuxhandbook.com/ln-command/
[13]: https://itsfoss.com/wp-content/uploads/2022/05/05_pdfgrep_pg_count-800x280.webp
[14]: https://itsfoss.com/wp-content/uploads/2022/05/06_pdfgrep_after_context-800x340.webp
[15]: https://itsfoss.com/wp-content/uploads/2022/05/07_pdfgrep_before_context-800x356.webp
[16]: https://itsfoss.com/wp-content/uploads/2022/05/08_pdfgrep_context-800x453.webp
[17]: https://itsfoss.com/wp-content/uploads/2022/05/09_pdfgrep_cache-800x575.webp

181
translated/tech/20210211 31 open source text editors you need to try.md
View File

@ -1,181 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (CoWave-Fall)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (31 open source text editors you need to try)
[#]: via: (https://opensource.com/article/21/2/open-source-text-editors)
[#]: author: (Seth Kenlon https://opensource.com/users/seth)
您可以尝试的 31 个开源文本编辑器
======
正在寻找新的文本编辑器？ 这里有 31 个选项可供您考虑。
![open source button on keyboard][1]
计算机是基于文本的，因此您使用它们做的事情越多，您可能就越需要文本编辑应用程序。 您在文本编辑器上花费的时间越多，您就越有可能对您您使用的编辑器提出更多的要求。
如果您正在寻找一个好的文本编辑器，您会发现 Linux 可以提供很多。 无论您是想在终端、桌面还是在云端工作，您都可以试一试。您可以每天一款编辑器，连续着试一个月（或每月试一个，能够试三年）。坚持不懈，您终将找到适合您的完美的编辑器。
### 与 Vim 相似的编辑器
![][2]
* [Vi][3] 通常随着 Linux 各发行版、BSD、Solaris 和 macOS 一起安装。 它是典型的 Unix 文本编辑器，具有编辑模式和超高效的单键快捷键二者的独特组合。 最初的 Vi 编辑器由 Bill Joy 编写（他也是 C shell 的作者）。 Vi 的现代版本，尤其是 Vim，增加了许多特性，包括多级撤消、在插入模式下更好的导航、折叠行、语法高亮、插件支持等等。但它需要学习如何使用（它甚至有自己的教程程序，vimtutor）。
* [Kakoune][4] 是一个受 Vim 启发的应用程序，它具有熟悉的简约界面、短键盘快捷键以及独立的编辑和插入模式。 乍一看，它的外观和感觉很像 Vi，但它在设计和功能上有自己独特的风格。 它有一个小彩蛋：具有 Clippy 接口的实现。
### emacs 编辑器
![][5]
* 从最初的免费 emacs 开始，发展到 GNU 项目（自由软件运动的发起者）的第一批官方应用程序，[GNU Emacs][6] 是一个广受欢迎的文本编辑器。 它非常适合系统管理员、开发人员和日常用户的使用，具有大量功能和近乎无穷无尽的扩展。 一旦您开始使用 Emacs，您可能会发现很难想出一个理由来关闭它，因为它能做的事情非常多！
* 如果您喜欢 Emacs 但觉得 GNU Emacs 过于臃肿，那么您可以试试 [Jove][7]。 Jove 是一个基于终端的 emacs 编辑器。 它很容易使用，但是如果您是使用 emacs 一类编辑器的新手，那么 Jove 也是很容易学习的，这要归功于 teajove 命令。
* 另一个轻量级的 emacs 编辑器是 [Jed][8]。它的工作流程基于宏。 它与其他编辑器的不同之处在于它使用了 [S-Lang][9]，这是一种类似 C 的脚本语言，它为使用 C 而不是使用 Lisp 的开发人员提供了可扩展的选项。
### 交互式编辑器
![][10]
* [GNU nano][11] 对基于终端的文本编辑采取了大胆的立场：它提供了一个菜单。是的，这个不起眼的编辑器从 GUI 编辑器那里得到了提示，它告诉用户他们需要按哪个键来执行特定的功能。这是一种令人耳目一新的用户体验，所以难怪 nano 被设置为“用户友好”发行版的默认编辑器，而不是 Vi。
* [JOE][12] 基于一个名为 WordStar 的旧文本编辑应用程序。如果您不熟悉 Wordstar，JOE 也可以模仿 Emacs 或 GNU nano。默认情况下，它是介于 Emacs 或 Vi 等相对神秘的编辑器和 GNU Nano 永远在线的冗长信息之间的一个很好的折衷方案（例如，它告诉您如何激活屏幕帮助显示，但默认情况下不启用）。
* [e3][13] 是一个优秀的小型文本编辑器，具有五个内置的键盘快捷键方案来模拟 Emacs、Vi、nano、NEdit 和 WordStar。换句话说，无论您习惯使用哪种基于终端的编辑器，您都可能对 e3 感到宾至如归。
### ed 和更多像 ed 一样的编辑器
* [ed][14] 行编辑器是 [POSIX][15] 和 Open Group 对基于 Unix 的操作系统的标准定义的一部分。它安装在您遇到的几乎所有 Linux 或 Unix 系统上。它小巧、简洁、一流。
* 基于 ed，[Sed][16] 流编辑器因其功能和语法而广受欢迎。大多数 Linux 用户在搜索更新配置文件中的行的最简单和最快的方法时至少会学习一个 sed 命令，但值得仔细研究一下。 Sed 是一个强大的命令，包含许多有用的子命令。更好地了解它，您可能会发现自己打开文本编辑器应用程序的频率要低得多。
* 您并不总是需要文本编辑器来编辑文本。 [heredoc][17]（或 Here Doc）系统可在任何 POSIX 终端中使用，允许您直接在打开的终端中输入文本，然后将输入的内容通过管道传输到文本文件中。这不是最强大的编辑体验，但它用途广泛且始终可用。
### 极简风格的编辑器
![][18]
如果您对一个好的文本编辑器的想法是一个文字处理器（除了没有所有的处理功能）的话，您可能正在寻找这些经典。这些编辑器可让您以最少的干扰和最少的帮助写作和编辑文本。它们提供的功能通常以标记、Markdown 或代码为中心。有些名称遵循某种模式：
* [Gedit][19] 来自 GNOME 团队；
* [medit][20] 有经典的 GNOME 手感；
* [Xedit][21] 仅使用最基本的 X11 库；
* [jEdit][22] 适用于 Java 爱好者。
KDE 用户也类似：
* [Kate][23] 是一款低调的编辑器，拥有您需要的几乎所有功能；
* [KWrite][24] 在看似简单易用的界面中隐藏了大量有用的功能。
还有一些适用于其他平台：
* [Notepad++][25] 是一种流行的 Windows 应用程序，而 Notepadqq 对 Linux 采用了类似的方法；
* [Pe][26] 适用于 Haiku OS（90 年代那个古怪的孩子 BeOS 的转世）；
* [FeatherPad][27] 是适用于 Linux 的基本编辑器，但对 macOS 和 Haiku 有一些支持。如果您是一名希望移植代码的 Qt 骇客，请务必看一看！
### 集成开发环境（IDE）
![][28]
文本编辑器和集成开发环境 (IDE) 之间存在相当大的相同之处。 后者实际上只是前者加上许多对于特定代码的添加的功能。 如果您经常使用 IDE，您可能会在扩展管理器中发现一个 XML 或 Markdown 编辑器：
* [NetBeans][29] 是一个方便 Java 用户的文本编辑器。
* [Eclipse][30] 提供了一个强大的编辑套件，其中包含许多扩展，可为您提供所需的工具。
### 云端编辑器
![][31]
在云端写作？ 当然，您也可以在那里写。
* [Etherpad][32] 是在网上运行的文本编辑器应用程序。 有独立免费的实例供您使用，或者您也·可以设置自己的实例。
* [Nextcloud][33] 拥有蓬勃发展的应用场景，包括内置文本编辑器和具有实时预览功能的第三方 Markdown 编辑器。
### 较新的编辑器
![][34]
每个人都会有让文本编辑器变得更完美的想法。 因此，几乎每年都会发布新的编辑器。 有些以一种新的、令人兴奋的方式重新实现经典的旧想法，有些对用户体验有独特的看法，还有些则专注于特定的需求。
* [Atom][35] 是来自 GitHub 的多功能的现代文本编辑器，具有许多扩展和 Git 集成。
* [Brackets][36] 是 Adobe 为 Web 开发人员提供的编辑器。
* [Focuswriter][37] 旨在通过无干扰全屏模式、可选的打字机音效和精美的配置选项等有用功能帮助您专注于写作。
* [Howl][38] 是一个基于 Lua 和 Moonscript 的渐进式动态编辑器。
* [Norka][39] 和 [KJots][40] 模仿笔记本，每个文档代表“活页夹”中的“页面”。 您可以通过导出功能从笔记本中取出单个页面。
### 自己制作编辑器
![][41]
俗话说得好：既然可以编写自己的应用程序，为什么要使用别人的（虽然其实没有这句俗语）？虽然 Linux 有超过 30 个常用的文本编辑器，但是再说一次，开源的一部分乐趣在于能够亲手进行实验。
如果您正在寻找学习编程的理由，那么制作自己的文本编辑器是一个很好的入门方法。 您可以在大约 100 行代码中实现基础知识，并且您使用它的次数越多，您可能就越会受到启发，进而去学习更多内容，从而进行改进。 准备好开始了吗？ 来吧，去[创建您自己的文本编辑器][42]。
--------------------------------------------------------------------------------
via: https://opensource.com/article/21/2/open-source-text-editors
作者：[Seth Kenlon][a]
选题：[lujun9972][b]
译者：[CoWave-Fall](https://github.com/CoWave-Fall)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/seth
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/button_push_open_keyboard_file_organize.png?itok=KlAsk1gx (open source button on keyboard)
[2]: https://opensource.com/sites/default/files/kakoune-screenshot.png
[3]: https://opensource.com/article/20/12/vi-text-editor
[4]: https://opensource.com/article/20/12/kakoune
[5]: https://opensource.com/sites/default/files/jed.png
[6]: https://opensource.com/article/20/12/emacs
[7]: https://opensource.com/article/20/12/jove-emacs
[8]: https://opensource.com/article/20/12/jed
[9]: https://www.jedsoft.org/slang
[10]: https://opensource.com/sites/default/files/uploads/nano-31_days-nano-opensource.png
[11]: https://opensource.com/article/20/12/gnu-nano
[12]: https://opensource.com/article/20/12/31-days-text-editors-joe
[13]: https://opensource.com/article/20/12/e3-linux
[14]: https://opensource.com/article/20/12/gnu-ed
[15]: https://opensource.com/article/19/7/what-posix-richard-stallman-explains
[16]: https://opensource.com/article/20/12/sed
[17]: https://opensource.com/article/20/12/heredoc
[18]: https://opensource.com/sites/default/files/uploads/gedit-31_days_gedit-opensource.jpg
[19]: https://opensource.com/article/20/12/gedit
[20]: https://opensource.com/article/20/12/medit
[21]: https://opensource.com/article/20/12/xedit
[22]: https://opensource.com/article/20/12/jedit
[23]: https://opensource.com/article/20/12/kate-text-editor
[24]: https://opensource.com/article/20/12/kwrite-kde-plasma
[25]: https://opensource.com/article/20/12/notepad-text-editor
[26]: https://opensource.com/article/20/12/31-days-text-editors-pe
[27]: https://opensource.com/article/20/12/featherpad
[28]: https://opensource.com/sites/default/files/uploads/eclipse-31_days-eclipse-opensource.png
[29]: https://opensource.com/article/20/12/netbeans
[30]: https://opensource.com/article/20/12/eclipse
[31]: https://opensource.com/sites/default/files/uploads/etherpad_0.jpg
[32]: https://opensource.com/article/20/12/etherpad
[33]: https://opensource.com/article/20/12/31-days-text-editors-nextcloud-markdown-editor
[34]: https://opensource.com/sites/default/files/uploads/atom-31_days-atom-opensource.png
[35]: https://opensource.com/article/20/12/atom
[36]: https://opensource.com/article/20/12/brackets
[37]: https://opensource.com/article/20/12/focuswriter
[38]: https://opensource.com/article/20/12/howl
[39]: https://opensource.com/article/20/12/norka
[40]: https://opensource.com/article/20/12/kjots
[41]: https://opensource.com/sites/default/files/uploads/this-time-its-personal-31_days_yourself-opensource.png
[42]: https://opensource.com/article/20/12/31-days-text-editors-one-you-write-yourself

32
translated/tech/20220512 5 reasons to use sudo on Linux.md
View File

@ -3,24 +3,24 @@
[#]: author: "Seth Kenlon https://opensource.com/users/seth"
[#]: collector: "lkxed"
[#]: translator: "MjSeven"
[#]: reviewer: " "
[#]: reviewer: "turbokernel"
[#]: publisher: " "
[#]: url: " "
在 Linux 上使用 sudo 命令的 5 个理由
======
以下是切换到 Linux sudo 命令的五个安全原因。下载 sudo 备忘录获取更多技巧。
以下是切换到 Linux sudo 命令的五个安全原因。下载 sudo 参考手册获取更多技巧。
![命令行提示符][1]
Image by: Opensource.com
在传统的 Unix 和类 Unix 系统上，新系统中存在的第一个也是唯一一个用户是 **root**。使用 root 账户登录并创建“普通”用户。在初始交互之后，你应该以普通用户身份登录。
在传统的 Unix 和类 Unix 系统上，新系统中存在的第一同时也是唯一的用户是 **root**。使用 root 账户登录并创建“普通”用户。在初始化之后，你应该以普通用户身份登录。
以普通用户身份运行系统是一种自我施加的限制，可以防止你犯愚蠢的错误。例如，作为普通用户，你不能删除定义网络接口的配置文件或意外覆盖用户和组列表。作为普通用户，你无法犯这些错误，因为你无权访问这些重要文件。当然，作为系统的实际所有者，你始终可以使用 `su` 命令成为超级用户（root）并做任何你想做的事情，但对于日常任务，你应该使用普通账户。
以普通用户身份使用系统是一种自我施加的限制，可以防止愚蠢的错误。例如，作为普通用户，你不能删除定义网络接口的配置文件或意外覆盖用户和组列表。作为普通用户，因为你无权访问这些重要文件。当然所以你无法犯这些错误，作为系统的实际所有者，你始终可以通过 `su` 命令切换为超级用户（root）并做你想做的任何事情，但对于日常工作，你应该使用普通账户。
几十年来，`su` 运行良好，但随后出现了 `sudo` 命令。
对于长期的超级用户来说，`sudo` 命令乍一看似乎是多余的。在某些方面，它感觉很像 `su` 命令。例如：
对于日常使用超级用户来说，`sudo` 命令乍一看似乎是多余的。在某些方面，它感觉很像 `su` 命令。例如：
```
$ su root
@ -35,37 +35,37 @@ $ sudo dnf install -y cowsay
<enter passphrase>
```
它们的作用几乎完全相同。然而大多数发行版推荐使用 `sudo` 而不是 `su`，而且大多数发行版已经完全取消了 root 账户。让 Linux 变得愚蠢是一个阴谋吗？
它们的作用几乎完全相同。但是大多数发行版推荐使用 `sudo` 而不是 `su`，甚至大多数发行版已经完全取消了 root 账户。让 Linux 变得愚蠢是一个阴谋吗？
事实上，并非如此。`sudo` 使 Linux 比以往任何时候都更加灵活和可配置，并且没有损失功能，还有[几个显著的优点][2]。
事实并非如此。`sudo` 使 Linux 比以往任何时候都更加灵活和可配置，并且没有损失功能，还有[几个显著的优点][2]。
### 为什么在 Linux 上 sudo 比 root 更好？
以下是你应该使用 `sudo` 而不是 `su` 的五个原因。
以下是你应该使用 `sudo` 替换 `su` 的五个原因。
### 1. Root 是确认的对象
### 1. Root 是被攻击确认的对象
我使用 [Firewalls][3]、[fail2ban][4] 和 [SSH 密钥][5]的常用组合来防止一些针对服务器不必要的访问。在我理解 `sudo` 的价值之前，我对日志中的暴力攻击感到恐惧。自动尝试以 root 身份登录是最常见的，这是有充分理由的。
有足够知识尝试入侵的攻击者应该也知道，在广泛使用 `sudo` 之前，基本上每个 Unix 和 Linux 都有一个 root 账户。这样攻击者就会少一种猜测。因为登录名总是正确的，只要它是 root 就行，所以攻击者只需要一个有效的密码。
有一定入侵常识的攻击者应该知道，在广泛使用 `sudo` 之前，基本上每个 Unix 和 Linux 都有一个 root 账户。这样攻击者就会少一种猜测。因为登录名总是正确的，只要它是 root 就行，所以攻击者只需要一个有效的密码。
删除 root 账户可提供大量保护。如果没有 root，服务器就没有确认的登录账户。攻击者必须猜测登录名以及密码。这不是两次猜测，而是两个必须同时正确的猜测。
### 2. Root 是最终的攻击媒介
在失败访问日志中，root 是很常见的，因为它可能是最强大的用户。如果你要设置一个脚本强行进入他人的服务器，为什么要浪费时间尝试以一个只有部分权限的普通用户进入呢？只有最强大的用户才有意义。
在错误访问日志中，root 是很常见的，因为它可是最强大的用户。如果你要设置一个脚本强行进入他人的服务器，为什么要浪费时间尝试以受限的普通用户进入呢？只有最强大的用户才有意义。
Root 既是唯一已知的用户名，又是最强大的用户账户。因此，root 基本上使尝试暴力破解其他任何东西变得毫无意义。
### 3. 可选择的权限
`su` 命令要么全有要么全没有。如果你有 `su root` 的密码，你就可以变成超级用户。如果你没有 `su` 的密码，那么你就没有任何管理员权限。这个模型的问题在于，系统管理员必须在将主密钥移交系统或保留密钥和对系统的所有控制权之间做出选择。这并不总是你想要的，[有时候你只是想授权。][6]
`su` 命令要么全有要么全没有。如果你有 `su root` 的密码，你就可以变成超级用户。如果你没有 `su` 的密码，那么你就没有任何管理员权限。这个模型的问题在于，系统管理员必须在将 root 密钥移交系统或保留密钥和对系统的所有权之间做出选择。这并不总是你想要的，[有时候你只是想授权。][6]
例如，假设你想授予用户以 root 身份运行特定应用程序的权限，但你不想为用户提供 root 密码。通过编辑 `sudo` 配置，你可以允许指定用户，或属于指定 Unix 组的任何用户运行特定命令。`sudo` 命令需要用户的现有密码，而不是你的密码，当然也不是 root 密码。
### 4.超时
使用 `sudo` 运行命令时，经过身份验证的用户的权限会提升 5 分钟。在此期间，他们可以运行管理员授予他们运行权限的任何命令。
使用 `sudo` 运行命令后，通过身份验证的用户的权限会提升 5 分钟。在此期间，他们可以运行任何管理员授权的命令。
5 分钟后，认证缓存被清空，下次使用 `sudo` 再次提示输入密码。超时可防止用户意外执行某些操作（例如，不小心搜索 shell 历史记录或多次按下**向上**箭头）。如果第一个用户离开办工桌而没有锁定计算机屏幕，它还可以确保另一个用户不能运行这些命令。
@ -79,9 +79,9 @@ Shell 历史功能可以作为一个用户所做事情的日志。如果你需
### 学习 sudo 其他功能
除了本文列举的一些功能，`sudo` 命令还有很多新功能，包括已有的或正在开发中的。因为 `sudo` 通常是你配置一次然后就忘记的东西，或者只在新管理员加入团队时才配置的东西，所以很难记住它的细微差别。
除了本文列举的一些功能，`sudo` 命令还有很多\已有的或正在开发中的新功能。因为 `sudo` 通常是你配置一次然后就忘记的东西，或者只在新管理员加入团队时才配置的东西，所以很难记住它的细微差别。
下载 [sudo 备忘录][8]，在你最需要的时候把它当作一个有用的指导书。
下载 [sudo 参考手册][8]，在你最需要的时候把它当作一个有用的指导书。
--------------------------------------------------------------------------------
@ -90,7 +90,7 @@ via: https://opensource.com/article/22/5/use-sudo-linux
作者：[Seth Kenlon][a]
选题：[lkxed][b]
译者：[MjSeven](https://github.com/MjSeven)
校对：[校对者ID](https://github.com/校对者ID)
校对：[turbokernel](https://github.com/turbokernel)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出