document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2024-12-26 21:30:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10900 from MjSeven/master

Browse Source 
20181018 Understanding Linux Links- Part 1.md 翻译完毕
This commit is contained in:
Xingyu.Wang 2018-10-26 23:06:38 +08:00 committed by GitHub
commit 39de0f647e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 123 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
sources/tech/20181018 Understanding Linux Links- Part 1.md
View File

@ -1,135 +0,0 @@
Translating by MjSeven
Understanding Linux Links: Part 1
======
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/linux-link-498708.jpg?itok=DyVEcEsc)
Along with `cp` and `mv`, both of which we talked about at length in [the previous installment of this series][1], links are another way of putting files and directories where you want them to be. The advantage is that links let you have one file or directory show up in several places at the same time.
As noted previously, at the physical disk level, things like files and directories don't really exist. A filesystem conjures them up for our human convenience. But at the disk level, there is something called a _partition table_ , which lives at the beginning of every partition, and then the data scattered over the rest of the disk.
Although there are different types of partition tables, the ones at the beginning of a partition containing your data will map where each directory and file starts and ends. The partition table acts like an index: When you load a file from your disk, your operating system looks up the entry on the table and the table says where the file starts on the disk and where it finishes. The disk header moves to the start point, reads the data until it reaches the end point and, hey presto: here's your file.
### Hard Links
A hard link is simply an entry in the partition table that points to an area on a disk that **has already been assigned to a file**. In other words, a hard link points to data that has already been indexed by another entry. Let's see how this works.
Open a terminal, create a directory for tests and move into it:
```
mkdir test_dir
cd test_dir
```
Create a file by [touching][1] it:
```
touch test.txt
```
For extra excitement (?), open _test.txt_ in a text editor and add some a few words into it.
Now make a hard link by executing:
```
ln test.txt hardlink_test.txt
```
Run `ls`, and you'll see your directory now contains two files... Or so it would seem. As you read before, really what you are seeing is two names for the exact same file: _hardlink_test.txt_ contains the same content, has not filled any more space in the disk (try with a large file to test this), and shares the same inode as _test.txt_ :
```
$ ls -li *test*
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 hardlink_test.txt
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 test.txt
```
_ls_ 's `-i` option shows the _inode number_ of a file. The _inode_ is the chunk of information in the partition table that contains the location of the file or directory on the disk, the last time it was modified, and other data. If two files share the same inode, they are, to all practical effects, the same file, regardless of where they are located in the directory tree.
### Fluffy Links
Soft links, also known as _symlinks_ , are different: a soft link is really an independent file, it has its own inode and its own little slot on the disk. But it only contains a snippet of data that points the operating system to another file or directory.
You can create a soft link using `ln` with the `-s` option:
```
ln -s test.txt softlink_test.txt
```
This will create the soft link _softlink_test.txt_ to _test.txt_ in the current directory.
By running `ls -li` again, you can see the difference between the two different kinds of links:
```
$ ls -li
total 8
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 hardlink_test.txt
16515855 lrwxrwxrwx 1 paul paul 8 oct 12 09:50 softlink_test.txt -> test.txt
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 test.txt
```
_hardlink_test.txt_ and _test.txt_ contain some text and take up the same space *literally*. They also share the same inode number. Meanwhile, _softlink_test.txt_ occupies much less and has a different inode number, marking it as a different file altogether. Using the _ls_ 's `-l` option also shows the file or directory your soft link points to.
### Why Use Links?
They are good for **applications that come with their own environment**. It often happens that your Linux distro does not come with the latest version of an application you need. Take the case of the fabulous [Blender 3D][2] design software. Blender allows you to create 3D still images as well as animated films and who wouldn't to have that on their machine? The problem is that the current version of Blender is always at least one version ahead of that found in any distribution.
Fortunately, [Blender provides downloads][3] that run out of the box. These packages come, apart from with the program itself, a complex framework of libraries and dependencies that Blender needs to work. All these bits and piece come within their own hierarchy of directories.
Every time you want to run Blender, you could `cd` into the folder you downloaded it to and run:
```
./blender
```
But that is inconvenient. It would be better if you could run the `blender` command from anywhere in your file system, as well as from your desktop command launchers.
The way to do that is to link the _blender_ executable into a _bin/_ directory. On many systems, you can make the `blender` command available from anywhere in the file system by linking to it like this:
```
ln -s /path/to/blender_directory/blender /home/<username>/bin
```
Another case in which you will need links is for **software that needs outdated libraries**. If you list your _/usr/lib_ directory with `ls -l,` you will see a lot of soft-linked files fly by. Take a closer look, and you will see that the links usually have similar names to the original files they are linking to. You may see _libblah_ linking to _libblah.so.2_ , and then, you may even notice that _libblah.so.2_ links in turn to _libblah.so.2.1.0_ , the original file.
This is because applications often require older versions of alibrary than what is installed. The problem is that, even if the more modern versions are still compatible with the older versions (and usually they are), the program will bork if it doesn't find the version it is looking for. To solve this problem distributions often create links so that the picky application believes it has found the older version, when, in reality, it has only found a link and ends up using the more up to date version of the library.
Somewhat related is what happens with **programs you compile yourself from the source code**. Programs you compile yourself often end up installed under _/usr/local_ : the program itself ends up in _/usr/local/bin_ and it looks for the libraries it needs _/_ in the _/usr/local/lib_ directory. But say that your new program needs _libblah_ , but _libblah_ lives in _/usr/lib_ and that's where all your other programs look for it. You can link it to _/usr/local/lib_ by doing:
```
ln -s /usr/lib/libblah /usr/local/lib
```
Or, if you prefer, by `cd`ing into _/usr/local/lib_...
```
cd /usr/local/lib
```
... and then linking with:
```
ln -s ../lib/libblah
```
There are dozens more cases in which linking proves useful, and you will undoubtedly discover them as you become more proficient in using Linux, but these are the most common. Next time, we’ll look at some linking quirks you need to be aware of.
Learn more about Linux through the free ["Introduction to Linux" ][4]course from The Linux Foundation and edX.
--------------------------------------------------------------------------------
via: https://www.linux.com/blog/intro-to-linux/2018/10/linux-links-part-1
作者：[Paul Brown][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.linux.com/users/bro66
[b]: https://github.com/lujun9972
[1]: https://www.linux.com/blog/2018/8/linux-beginners-moving-things-around
[2]: https://www.blender.org/
[3]: https://www.blender.org/download/
[4]: https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux

123
translated/tech/20181018 Understanding Linux Links- Part 1.md Normal file
View File

@ -0,0 +1,123 @@
理解 Linux 链接：第一部分
======
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/linux-link-498708.jpg?itok=DyVEcEsc)
除了 `cp` 和 `mv` 这两个我们在[本系列的前一部分][1]中详细讨论过的，链接是另一种方式可以将文件和目录放在你希它们放在的位置。它的优点是可以让你同时在多个位置显示一个文件或目录。
如前所述，在物理磁盘这个级别上，文件和目录之类的东西并不真正存在。文件系统为了方便人类使用，将它们虚构出来。但在磁盘级别上，有一个名为 _partition table_（分区表）的东西，它位于每个分区的开头，然后数据分散在磁盘的其余部分。
虽然有不同类型的分区表，但是在分区开头的表包含的数据将映射每个目录和文件的开始和结束位置。分区表的就像一个索引：当从磁盘加载文件时，操作系统会查找表中的条目，分区表会告诉文件在磁盘上的起始位置和结束位置。然后磁盘头移动到起点，读取数据，直到它到达终点，最后告诉 presto：这就是你的文件。
### 硬链接
硬链接只是分区表中的一个条目，它指向磁盘上的某个区域，表示该区域**已经被分配给文件**。换句话说，硬链接指向已经被另一个条目索引的数据。让我们看看它是如何工作的。
打开终端，创建一个实验目录并进入：
```
mkdir test_dir
cd test_dir
```
使用 [touch][1] 创建一个文件：
```
touch test.txt
```
为了获得更多的体验（？），在文本编辑器中打开 _test.txt_ 并添加一些单词。
现在通过执行以下命令来建立硬链接：
```
ln test.txt hardlink_test.txt
```
运行 `ls`，你会看到你的目录现在包含两个文件，或者看起来如此。正如你之前读到的那样，你真正看到的是完全相同的文件的两个名称： _hardlink\_test.txt_ 包含相同的内容，没有填充磁盘中的任何更多空间（尝试使用大文件来测试），并与 _test.txt_ 使用相同的 inode：
```
$ ls -li *test*
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 hardlink_test.txt
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 test.txt
```
_ls_ 的 `-i` 选项显示一个文件的 _inode 数值_。_inode_ 是分区表中的信息块，它包含磁盘上文件或目录的位置，上次修改的时间以及其它数据。如果两个文件使用相同的 inode，那么无论它们在目录树中的位置如何，它们在实际效果上都是相同的文件。
### 软链接
软链接，也称为 _symlinks_（系统链接），它是不同的：软链接实际上是一个独立的文件，它有自己的 inode 和它自己在磁盘上的小插槽。但它只包含一小段数据，将操作系统指向另一个文件或目录。
你可以使用 `ln` 的 `-s` 选项来创建一个软链接：
```
ln -s test.txt softlink_test.txt
```
这将在当前目录中创建软链接 _softlink\_test.txt_，它指向 _test.txt_。
再次执行 `ls -li`，你可以看到两种链接的不同之处：
```
$ ls -li
total 8
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 hardlink_test.txt
16515855 lrwxrwxrwx 1 paul paul 8 oct 12 09:50 softlink_test.txt -> test.txt
16515846 -rw-r--r-- 2 paul paul 14 oct 12 09:50 test.txt
```
_hardlink\_test.txt_ 和 _test.txt_ 包含一些文本并占据相同的空格*字面*。它们使用相同的 inode 数值。与此同时，_softlink\_test.txt_ 占用少得多，并且具有不同的 inode 数值，将其标记为完全不同的文件。使用 _ls_ 的 `-l` 选项还会显示软链接指向的文件或目录。
### 为什么要用链接？
它们适用于**带有自己环境的应用程序**。你的 Linux 发行版通常不会附带你需要应用程序的最新版本。以优秀的 [Blender 3D][2] 设计软件为例，Blender 允许你创建 3D 静态图像以及动画电影，人人都想在自己的机器上拥有它。问题是，当前版本的 Blender 至少比任何发行版中的自带的高一个版本。
幸运的是，[Blender 提供下载][3]开箱即用。除了程序本身之外，这些软件包还包含了 Blender 需要运行的复杂的库和依赖框架。所有这些数据和块都在它们自己的目录层次中。
每次你想运行 Blender，你都可以 `cd` 到你下载它的文件夹并运行：
```
./blender
```
但这很不方便。如果你可以从文件系统的任何地方，比如桌面命令启动器中运行 `blender` 命令会更好。
这样做的方法是将 _blender_ 可执行文件链接到 _bin/_ 目录。在许多系统上，你可以通过将其链接到文件系统中的任何位置来使 `blender` 命令可用，就像这样。
```
ln -s /path/to/blender_directory/blender /home/<username>/bin
```
你需要链接的另一个情况是**软件需要过时的库**。如果你用 `ls -l` 列出你的 _/usr/lib_ 目录，你会看到许多软链接文件飞过。仔细看看，你会看到软链接通常与它们链接到的原始文件具有相似的名称。你可能会看到 _libblah_ 链接到 _libblah.so.2_，你甚至可能会注意到 _libblah.so.2_ 依次链接到原始文件 _libblah.so.2.1.0_。
这是因为应用程序通常需要安装比已安装版本更老的库。问题是，即使新版本仍然与旧版本（通常是）兼容，如果程序找不到它正在寻找的版本，程序将会出现问题。为了解决这个问题，发行版通常会创建链接，以便挑剔的应用程序相信它找到了旧版本，实际上它只找到了一个链接并最终使用了更新的库版本。
有些是和**你自己从源代码编译的程序**相关。你自己编译的程序通常最终安装在 _/usr/local_ 下，程序本身最终在 _/usr/local/bin_ 中，它在 _/usr/local/bin_ 目录中查找它需要的库。但假设你的新程序需要 _libblah_，但 _libblah_ 在 _/usr/lib_ 中，这就是所有其它程序都会寻找到它的地方。你可以通过执行以下操作将其链接到 _/usr/local/lib_：
```
ln -s /usr/lib/libblah /usr/local/lib
```
或者如果你愿意，可以 `cd` 到 _/usr/local/lib_：
```
cd /usr/local/lib
```
然后使用链接：
```
ln -s ../lib/libblah
```
还有几十个案例证明软链接是有用的，当你使用 Linux 更熟练时，你肯定会发现它们，但这些是最常见的。下一次，我们将看一些你需要注意的链接怪异。
通过 Linux 基金会和 edX 的免费 ["Linux 简介"][4]课程了解有关 Linux 的更多信息。
--------------------------------------------------------------------------------
via: https://www.linux.com/blog/intro-to-linux/2018/10/linux-links-part-1
作者：[Paul Brown][a]
选题：[lujun9972][b]
译者：[MjSeven](https://github.com/MjSeven)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.linux.com/users/bro66
[b]: https://github.com/lujun9972
[1]: https://www.linux.com/blog/2018/8/linux-beginners-moving-things-around
[2]: https://www.blender.org/
[3]: https://www.blender.org/download/
[4]: https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux