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

Merge remote-tracking branch 'LCTT/master'

Browse Source
This commit is contained in:
Xingyu Wang 2019-07-08 23:11:39 +08:00
commit bc71ef66b1
3 changed files with 326 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
translated/tech/20190501 Looking into Linux modules.md → published/20190501 Looking into Linux modules.md
View File

@ -1,30 +1,30 @@
[#]: collector: (lujun9972)
[#]: translator: (LazyWolfLin)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-11075-1.html)
[#]: subject: (Looking into Linux modules)
[#]: via: (https://www.networkworld.com/article/3391362/looking-into-linux-modules.html#tk.rss_all)
[#]: via: (https://www.networkworld.com/article/3391362/looking-into-linux-modules.html)
[#]: author: (Sandra Henry-Stocker https://www.networkworld.com/author/Sandra-Henry_Stocker/)
深入学习 Linux 内核模块
======
lsmod 命令能够告诉你当前系统上加载了哪些内核模块，以及关于使用它们的一些有趣的细节。
> lsmod 命令能够告诉你当前系统上加载了哪些内核模块，以及关于使用它们的一些有趣的细节。
![Rob Oo \(CC BY 2.0\)][1]
### 什么是 Linux 内核模块？
内核模块是根据需要加载到内核中或从内核中卸载的代码块，因此无需重启就可以扩展内核的功能。事实上，除非用户使用类似 **lsmod** 这样的命令来查询模块信息，否则用户不太可能知道内核发生的任何变化。
内核模块是可以根据需要加载到内核中或从内核中卸载的代码块，因此无需重启就可以扩展内核的功能。事实上，除非用户使用类似 `lsmod` 这样的命令来查询模块信息，否则用户不太可能知道内核发生的任何变化。
需要知道的重要一点是，在你的 Linux 系统上总会有*很多*可用的模块，并且如果你想深入了解细节，那么可以获得很多细节。
需要知道的重要一点是，在你的 Linux 系统上总会有*很多*可用的模块，并且如果你可以深入其中了解到很多细节。
lsmod 的主要用途之一是在系统不能正常工作时检查模块。然而，大多数情况下，模块会根据需要加载的，而且用户不需要知道它们如何运作。
**[ 扩展阅读：[必知的 Linux 命令][2] ]**
`lsmod` 的主要用途之一是在系统不能正常工作时检查模块。然而，大多数情况下，模块会根据需要加载的，而且用户不需要知道它们如何运作。
### 显示内核模块
显示内核模块最简单的方法是使用 **lsmod** 命令。虽然这个命令包含了很多细节，但输出却是非常用户友好。
显示内核模块最简单的方法是使用 `lsmod` 命令。虽然这个命令包含了很多细节，但输出却是非常用户友好。
```
$ lsmod
@ -105,11 +105,9 @@ floppy 81920 0
在上面的输出中：
* “Module”显示每个模块的名称
* “Size”显示每个模块的大小（并不是它们使占的内存大小）
* “Used by”显示每个模块的被使用的计数和使用它们的模块
* `Module` 显示每个模块的名称
* `Size` 显示每个模块的大小（并不是它们占的内存大小）
* `Used by` 显示每个模块被使用的次数和使用它们的模块
显然，这里有*很多*模块。加载的模块数量取决于你的系统和版本以及正在运行的内容。我们可以这样计数：
@ -127,20 +125,18 @@ $ modprobe -c | wc -l
### 与内核模块相关的其他命令
Linux 提供了几条用于罗列，加载及卸载，测试，以及检查模块状态的命令。
* depmod —— 生成 modules.dep 和映射文件
* insmod —— 一个往 Linux 内核插入模块的程序
* lsmod —— 显示 Linux 内核中模块状态
* modinfo —— 显示 Linux 内核模块信息
* modprobe —— 添加或移除 Linux 内核模块
* rmmod —— 一个从 Linux 内核移除模块的程序
Linux 提供了几条用于罗列、加载及卸载、测试，以及检查模块状态的命令。
* `depmod` —— 生成 `modules.dep` 和映射文件
* `insmod` —— 一个往 Linux 内核插入模块的程序
* `lsmod` —— 显示 Linux 内核中模块状态
* `modinfo` —— 显示 Linux 内核模块信息
* `modprobe` —— 添加或移除 Linux 内核模块
* `rmmod` —— 一个从 Linux 内核移除模块的程序
### 显示内置的内核模块
正如前文所说，**lsmod** 命令是显示内核模块最方便的命令。然而，也有其他方式可以显示它们。modules.builtin 文件中列出了所有构建在内核中的模块，并被 modprobe 命令尝试添加文件中的模块时使用。注意，以下命令中的 **$(uname -r)** 提供了内核版本的名称。
正如前文所说，`lsmod` 命令是显示内核模块最方便的命令。然而，也有其他方式可以显示它们。`modules.builtin` 文件中列出了所有构建在内核中的模块，在 `modprobe` 命令尝试添加文件中的模块时会使用它。注意，以下命令中的 `$(uname -r)` 提供了内核版本的名称。
```
$ more /lib/modules/$(uname -r)/modules.builtin | head -10
@ -156,7 +152,7 @@ kernel/fs/configfs/configfs.ko
kernel/fs/crypto/fscrypto.ko
```
你可以使用 **modinfo** 获得一个模块的更多细节，虽然没有对模块提供的服务的简单说明。下面输出内容中省略了冗长的签名。
你可以使用 `modinfo` 获得一个模块的更多细节，虽然没有对模块提供的服务的简单说明。下面输出内容中省略了冗长的签名。
```
$ modinfo floppy | head -16
@ -178,7 +174,7 @@ sig_key:
sig_hashalgo: md4
```
你可以使用 **modprobe** 命令加载或卸载模块。使用下面这条命令，你可以找到特定模块关联的内核对象：
你可以使用 `modprobe` 命令加载或卸载模块。使用下面这条命令，你可以找到特定模块关联的内核对象：
```
$ find /lib/modules/$(uname -r) -name floppy*
@ -191,22 +187,18 @@ $ find /lib/modules/$(uname -r) -name floppy*
$ sudo modprobe floppy
```
### 总结一下
### 总结
很明显，内核模块的加载和卸载非常重要。它使得 Linux 系统比使用通用内核运行时更加灵活和高效。这同样意味着你可以进行重大更改而无需重启，例如添加硬件。
**[ 两分钟学 Linux：[在这些两分钟视频教程中掌握大量 Linux 命令][3] ]**
在 [Facebook][4] 和 [LinkedIn][5] 上关注我们并添加评论。
--------------------------------------------------------------------------------
via: https://www.networkworld.com/article/3391362/looking-into-linux-modules.html#tk.rss_all
via: https://www.networkworld.com/article/3391362/looking-into-linux-modules.html
作者：[Sandra Henry-Stocker][a]
选题：[lujun9972][b]
译者：[LazyWolfLin](https://github.com/LazyWolfLin)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

94
sources/talk/20190604 Why Emacs.md Normal file
View File

@ -0,0 +1,94 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Why Emacs)
[#]: via: (https://saurabhkukade.github.io/Why-Emacs/)
[#]: author: (Saurabh Kukade http://saurabhkukade.github.io/)
Why Emacs
======
![Image of Emacs][1]
> “Emacs outshines all other editing software in approximately the same way that the noonday sun does the stars. It is not just bigger and brighter; it simply makes everything else vanish.”
> -Neal Stephenson, “In the Beginning was the Command Line”
### Introduction
This is my first blog post about Emacs. I want to discuss step by step customization of Emacs for beginner. If you’re new to Emacs then you are in the right place, if you’re already familiar with Emacs then that is even better, I assure you that we will get to know many new things in here.
Before getting into how to customize Emacs and what are the exciting features of Emacs I want to write about “why Emacs”.
### Why Emacs?
This was first question crossed my mind when one wise man asked me to try Emacs instead of VIM. Well, I am not writing this article to discuss a battle between two editors VIM and Emacs. That is a another story for another day. But Why Emacs? Well here are some things that justifies that Emacs is powerful and highly customizable.
### 41 Years!
Initial release year of Emacs is 1976 that means Emacs is standing and adapting changes from last 41 years.
41 years of time for a software is huge and that makes Emacs is one of the best Software Engineering product.
### Lisp (Emacs Lisp)
If you are lisp programmer (lisper) then I don’t need to explain you. But for those who don’t know Lisp and its dialects like Scheme, Clojure then Lisp (and all dialects of Lips) is powerful programming language and it stands different from other languages because of its unique property of “Homoiconicity”.
As Emacs is implemented in C and Emacs Lisp (Emacs Lisp is a dialect of the Lisp programming language) it makes Emacs what is because,
* The simple syntax of Lisp, together with the powerful editing features made possible by that simple syntax, add up to a more convenient programming system than is practical with other languages. Lisp and extensible editors are made for each other.
* The simplicity of Lisp syntax makes intelligent editing operations easier to implement, while the complexity of other languages discourages their users from implementing similar operations for them.
### Highly Customizable
To any programmer, tools gives power and convenience for reading, writing and managing a code.
Hence, if a tool is programmatic-ally customizable then that makes it even more powerful.
Emacs has above property and in fact is itself one of best tool known for its flexibility and easy customization. Emacs provides basic commands and key configuration for editing a text. This commands and key-configuration are editable and extensible.
Beside basic configuration, Emacs is not biased towards any specific language for customization. One can customize Emacs for any programming language or extend easily existing customization.
Emacs provides the consistent environment for multiple programming languages, email, organizer (via org-mode), a shell/interpreter, note taking, and document writing.
For customizing you don’t need to learn Emacs-lisp from scratch. You can use existing packages available and that’s it. Installing and managing packages in Emacs is easy, Emacs has in-built package manager for it.
Customization is very portable, one just need to place a file or directory containing personal customization file(s) in the right place and it’s done for getting personal customization to new place. ## Huge platform Support
Emacs supports Lisp, Ruby, Python, PHP, Java, Erlang, JavaScript, C, C++, Prolog, Tcl, AWK, PostScript, Clojure, Scala, Perl, Haskell, Elixir all of these languages and more like mysql, pgsql etc. Because of the powerful Lisp core, Emacs is easy to extend to add support for new languages if need to.
Also one can use the built-in IRC client ERC along with BitlBee to connect to your favorite chat services, or use the Jabber package to hop on any XMPP service.
### Org-mode
No matter if you are programmer or not. Org mode is for everyone. Org mode lets you to plan projects and organize schedule. It can be also use for publish notes and documents to different formats, like LaTeX->pdf, html, and markdown.
In fact, Org-mode is so awesome enough that many non-Emacs users started learn Emacs.
### Final note
There are number of reason to argue that Emacs is cool and awesome to use. But I just wanted you to give glimpse of why to try Emacs. In the upcoming post I will be writing step by step information to customize Emacs from scratch to awesome IDE.
Thank you!
Please don’t forget to comment your thoughts and suggestions below.
--------------------------------------------------------------------------------
via: https://saurabhkukade.github.io/Why-Emacs/
作者：[Saurabh Kukade][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://saurabhkukade.github.io/
[b]: https://github.com/lujun9972
[1]: https://saurabhkukade.github.io/img/emacs.jpeg

205
sources/tech/20190612 Why --1-, -7-, -11--.map(parseInt) returns -1, NaN, 3- in Javascript.md Normal file
View File

@ -0,0 +1,205 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Why ['1', '7', '11'].map(parseInt) returns [1, NaN, 3] in Javascript)
[#]: via: (https://medium.com/dailyjs/parseint-mystery-7c4368ef7b21)
[#]: author: (Eric Tong https://medium.com/@erictongs)
Why ['1', '7', '11'].map(parseInt) returns [1, NaN, 3] in Javascript
======
![][1]![][2]???
**Javascript is weird.** Don’t believe me? Try converting an array of strings into integers using map and parseInt. Fire up your console (F12 on Chrome), paste in the following, and press enter (or run the pen below).
```
['1', '7', '11'].map(parseInt);
```
Instead of giving us an array of integers `[1, 7, 11]`, we end up with `[1, NaN, 3]`. What? To find out what on earth is going on, we’ll first have to talk about some Javascript concepts. If you’d like a TLDR, I’ve included a quick summary at the end of this story.
### Truthiness & Falsiness
Here’s a simple if-else statement in Javascript:
```
if (true) {
// this always runs
} else {
// this never runs
}
```
In this case, the condition of the if-else statement is true, so the if-block is always executed and the else-block is ignored. This is a trivial example because true is a boolean. What if we put a non-boolean as the condition?
```
if ("hello world") {
// will this run?
console.log("Condition is truthy");
} else {
// or this?
console.log("Condition is falsy");
}
```
Try running this code in your developer’s console (F12 on Chrome). You should find that the if-block runs. This is because the string object `"hello world"` is truthy.
Every Javascript object is either **truthy** or **falsy**. When placed in a boolean context, such as an if-else statement, objects are treated as true or false based on their truthiness. So which objects are truthy and which are falsy? Here’s a simple rule to follow:
**All values are truthy except for:** `false` **,** `0` **,** `""` **(empty string),** `null` **,** `undefined` **, and** `NaN` **.**
Confusingly, this means that the string `"false"`, the string `"0"`, an empty object `{}`, and an empty array `[]` are all truthy. You can double check this by passing an object into the Boolean function (e.g. `Boolean("0");`).
For our purposes, it is enough to remember that `0` is falsy.
### Radix
```
0 1 2 3 4 5 6 7 8 9 10
```
When we count from zero to nine, we have different symbols for each of the numbers (0–9). However, once we reach ten, we need two different symbols (1 and 0) to represent the number. This is because our decimal counting system has a radix (or base) of ten.
Radix is the smallest number which can only be represented by more than one symbol. **Different counting systems have different radixes, and so, the same digits can refer to different numbers in counting systems.**
```
DECIMAL BINARY HEXADECIMAL
RADIX=10 RADIX=2 RADIX=16
0 0 0
1 1 1
2 10
2
3
11 3
4 100 4
5 101 5
6 110 6
7 111 7
8 1000 8
9 1001 9
10 1010 A
11 1011 B
12 1100 C
13 1101 D
14 1110 E
15 1111 F
16 10000 10
17 10001
11
```
For example, looking at the table above, we see that the same digits 11 can mean different numbers in different counting systems. If the radix is 2, then it refers to the number 3. If the radix is 16, then it refers to the number 17.
You may have noticed that in our example, parseInt returned 3 when the input is 11, which corresponds to the Binary column in the table above.
### Function arguments
Functions in Javascript can be called with any number of arguments, even if they do not equal the number of declared function parameters. Missing arguments are treated as undefined and extra arguments are ignored (but stored in the array-like [arguments object][3]).
```
function foo(x, y) {
console.log(x);
console.log(y);
}
foo(1, 2); // logs 1, 2
foo(1); // logs 1, undefined
foo(1, 2, 3); // logs 1, 2
```
### map()
We’re almost there!
Map is a method in the Array prototype that returns a new array of the results of passing each element of the original array into a function. For example, the following code multiplies each element in the array by 3:
```
function multiplyBy3(x) {
return x * 3;
}
const result = [1, 2, 3, 4, 5].map(multiplyBy3);console.log(result); // logs [3, 6, 9, 12, 15];
```
Now, let’s say I want to log each element using `map()` (with no return statements). I should be able to pass `console.log` as an argument into `map()`… right?
```
[1, 2, 3, 4, 5].map(console.log);
```
![][4]![][5]
Something very strange is going on. Instead of logging just the value, each `console.log` call also logged the index and full array.
```
[1, 2, 3, 4, 5].map(console.log);// The above is equivalent to[1, 2, 3, 4, 5].map(
(val, index, array) => console.log(val, index, array)
);
// and not equivalent to[1, 2, 3, 4, 5].map(
val => console.log(val)
);
```
When a function is passed into `map()`, for each iteration, **three arguments are passed into the function** : `currentValue`, `currentIndex`, and the full `array`. That is why three entries are logged for each iteration.
We now have all the pieces we need to solve this mystery.
### Bringing it together
ParseInt takes two arguments: `string` and `radix`. If the radix provided is falsy, then by default, radix is set to 10.
```
parseInt('11'); => 11
parseInt('11', 2); => 3
parseInt('11', 16); => 17
parseInt('11', undefined); => 11 (radix is falsy)
parseInt('11', 0); => 11 (radix is falsy)
```
Now let’s run our example step-by-step.
```
['1', '7', '11'].map(parseInt); => [1, NaN, 3]// First iteration: val = '1', index = 0, array = ['1', '7', '11']parseInt('1', 0, ['1', '7', '11']); => 1
```
Since 0 is falsy, the radix is set to the default value 10. `parseInt()` only takes two arguments, so the third argument `['1', '7', '11']` is ignored. The string `'1'` in radix 10 refers to the number 1.
```
// Second iteration: val = '7', index = 1, array = ['1', '7', '11']parseInt('7', 1, ['1', '7', '11']); => NaN
```
In a radix 1 system, the symbol `'7'` does not exist. As with the first iteration, the last argument is ignored. So, `parseInt()` returns `NaN`.
```
// Third iteration: val = '11', index = 2, array = ['1', '7', '11']parseInt('11', 2, ['1', '7', '11']); => 3
```
In a radix 2 (binary) system, the symbol `'11'` refers to the number 3. The last argument is ignored.
### Summary (TLDR)
`['1', '7', '11'].map(parseInt)` doesn’t work as intended because `map` passes three arguments into `parseInt()` on each iteration. The second argument `index` is passed into parseInt as a `radix` parameter. So, each string in the array is parsed using a different radix. `'7'` is parsed as radix 1, which is `NaN`, `'11'` is parsed as radix 2, which is 3. `'1'` is parsed as the default radix 10, because its index 0 is falsy.
And so, the following code will work as intended:
```
['1', '7', '11'].map(numStr => parseInt(numStr));
```
--------------------------------------------------------------------------------
via: https://medium.com/dailyjs/parseint-mystery-7c4368ef7b21
作者：[Eric Tong][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://medium.com/@erictongs
[b]: https://github.com/lujun9972
[1]: https://miro.medium.com/max/60/1*uq5ZTlw6HLRRqbHaPYYL0g.png?q=20
[2]: https://miro.medium.com/max/1400/1*uq5ZTlw6HLRRqbHaPYYL0g.png
[3]: https://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/
[4]: https://miro.medium.com/max/60/1*rbrCQ_aNOft_OjayDtL6xg.png?q=20
[5]: https://miro.medium.com/max/1400/1*rbrCQ_aNOft_OjayDtL6xg.png