Emacs/使用 - Arch Linux 中文维基

跳至內容

# Emacs/使用

出自 Arch Linux 中文维基
< Emacs

相關文章

- Emacs
- Emacs/概念
- Emacs/運行
- Emacs/提示與技巧
- Emacs/疑難解答
- Emacs/軟體包
- 文本編輯器
- Vim

本文介紹 Emacs 的基礎使用。

閱讀本文前，請先閱讀 Emacs/概念。

## 進入 Emacs

本文或本章節可能需要合併到Emacs/運行。

附註： 內容有重複。（在 Talk:Emacs/使用 中討論）

調用 Emacs 的通常方法是使用 shell 命令 `emacs`。在 GUI 終端上運行 Unix shell 的終端窗口中，可以使用 `emacs &` 在後台運行 Emacs；這樣，Emacs 就不會占用終端窗口，因此你可以用它來運行其他 shell 命令。

Emacs 啟動時，初始幀會顯示一個名為 *GNU Emacs* 的特殊緩衝區。這個啟動界面包含 Emacs 的相關信息，以及對初學者有用的常用任務連結。例如，激活 Emacs Tutorial 連結可打開 Emacs 教程；其作用與 `C-h t`（`help-with-tutorial`）命令相同。要激活連結，可以將點移動到該連結上並鍵入 `RET`，或者用 `mouse-1`（滑鼠左鍵）單擊該連結。

使用命令行參數，可以讓 Emacs 在啟動時立即訪問一個或多個文件。例如，`emacs 文本.txt` 啟動 Emacs 時，緩衝區會顯示文件文本.txt 的內容。這一功能主要是為了與其他文本編輯器兼容，因為其他編輯器是為了從 shell 啟動進行短時間編輯而設計的。如果以這種方式調用 Emacs，初始幀會被分成兩個窗口，一個顯示指定文件，另一個顯示啟動屏幕。

一般來說，每次編輯文件都重新啟動 Emacs 既不必要又浪費。建議使用 Emacs 的方法是在登錄後只啟動一次，並在同一個 Emacs 會話中完成所有編輯工作。如果這樣使用 Emacs，Emacs 會話就會積累一些有價值的上下文，如 kill ring、寄存器、撤銷歷史和標記環數據，這些都會使編輯更加方便。本文稍後將介紹這些功能。

要在 Emacs 運行時從其他程序編輯文件，可以使用 emacsclient 輔助程序在現有的 Emacs 會話中打開文件。

Emacs 還接受其他命令行參數，這些參數會告訴它加載某些 Lisp 文件、在何處放置初始框架等。參見 Emacs 調用的命令行參數。

如果變量 `inhibit-startup-screen` 不為零，則 Emacs 不顯示啟動屏幕。在這種情況下，如果在命令行中指定了一個或多個文件，Emacs 會簡單地顯示這些文件；否則，它會顯示一個名為 `*scratch*` 的緩衝區，該緩衝區可用於交互式地評估 Emacs Lisp 表達式。你可以使用自定義工具或編輯初始化文件來設置變量 `inhibit-startup-screen`。

通過將變量 `initial-buffer-choice` 設置為命名文件或目錄的字符串，也可以強制 Emacs 在啟動時顯示文件或目錄。`initial-buffer-choice` 的值也可以是一個函數（無參數），它應該返回一個緩衝區，然後顯示出來。如果 `initial-buffer-choice` 的值不是零，那麼如果你在命令行中指定了任何文件，Emacs 仍會訪問它們，但最初不會顯示它們。

## 退出 Emacs

同 Vim/Neovim、Helix 等編輯器一樣，初學者可能不知如何退出。

C-x C-c
  殺死 Emacs（save-buffers-kill-terminal）。
C-z
  在文本終端上，掛起 Emacs；在圖形顯示屏上，圖標化（或最小化）所選幀（掛起幀）。
系統 shell 內運行 `killall emacs`
  強制終止 Emacs 進程，可以在 Emacs 卡死時使用。

殺死 Emacs 意味著終止 Emacs 程序。為此，請鍵入 `C-x C-c`（`save-buffers-kill-terminal`）。使用兩個字符的鍵序是為了防止意外鍵入。如果輸入 `C-x C-c` 時有任何修改過的文件訪問緩衝區，Emacs 會首先保存這些緩衝區。如果沒有全部保存，則會再次請求確認，因為未保存的更改將丟失。如果有子進程仍在運行，Emacs 也會要求確認，因為殺死 Emacs 也會殺死這些子進程。

如果將 Emacs 用作伺服器，`C-x C-c` 的行為會比較特殊。如果你在客戶端框架中輸入它，它會關閉客戶端連接。請參閱將 Emacs 用作伺服器。

Emacs 可以選擇在殺死會話時記錄某些會話信息，例如當時正在訪問的文件。下次啟動 Emacs 時就可以使用這些信息。請參閱保存 Emacs 會話。

如果變量 `confirm-kill-emacs` 的值不是零，`C-x C-c` 會假定其值是一個謂詞函數，並調用該函數。如果函數調用的結果不是零，會話就會被殺死，否則 Emacs 會繼續運行。用來作為 `confirm-kill-emacs` 值的一個方便的函數是 `yes-or-no-p` 函數。`confirm-kill-emacs` 的默認值為 nil。

如果變量 `confirm-kill-processes` 的值為 nil，則 `C-x C-c` 在殺死 Emacs 啟動的子進程之前不會請求確認。默認值為 t。

要進一步自定義 Emacs 退出時發生的情況，請參閱《GNU Emacs Lisp 參考手冊》中的殺死 Emacs。

要在不提示保存的情況下殺死 Emacs，請鍵入 `M-x kill-emacs`。

`C-z` 運行命令 `suspend-frame`。在圖形顯示屏上，該命令會最小化（或圖標化）所選的 Emacs 框架，使其隱藏起來，以便稍後恢復（具體如何隱藏取決於窗口系統）。在文本終端上，`C-z` 命令會暫停 Emacs，暫時停止程序並將控制權交還給父進程（通常是 shell）；在大多數 shell 中，暫停 Emacs 後可以使用 shell 命令 `%emacs` 恢復 Emacs。

文本終端通常會偵聽某些特殊字符，其含義是殺死或暫停正在運行的程序。在 Emacs 中，這種終端功能是關閉的。在 Emacs 中，`C-z` 和 `C-x C-c` 作為按鍵的含義是受多個作業系統中使用 `C-z` 和 `C-c` 作為停止或殺死程序的字符的啟發，但這是它們與作業系統的唯一關係。你可以自定義這些鍵來運行你選擇的任何命令。

## 基本編輯命令

在此，我們將講解如何輸入文本、進行修改並將文本保存到文件中的基礎知識。如果您對這些內容不熟悉，建議您首先運行 Emacs 邊做邊學教程，鍵入 `C-h t`（`help-with-tutorial`）。

### 插入文本

您可以通過鍵入相關鍵來插入普通圖形字符（如 "a"、"B"、"3" 和 "="）。這樣就可以將字符添加到點的緩衝區中。插入後，點將向前移動，因此點將保持在插入文本之後。參見點。

要結束一行並開始新一行，鍵入 `RET`（換行）。(`RET` 鍵在鍵盤上可能標有 Return、Enter 或有趣的向左箭頭，但在本手冊中我們將其稱為 `RET`，中國人常稱其回車）。該命令在緩衝區中插入一個換行符，然後根據主要模式縮進。如果點位於行尾，效果是在其後創建一個新的空行並縮進新行；如果點位於行中間，則在該位置分行。要關閉自動縮進功能，可以禁用 "Electric Indent" 模式（請參閱 "縮進的便利功能"），或者鍵入 C-j，只插入新行，而不進行任何自動縮進。

正如我們在本手冊後面所解釋的，你可以通過開啟次要模式來改變 Emacs 處理文本插入的方式。例如，名為 "Auto Fill" 的次要模式會在行太長時自動分行。名為 "Overwrite" 模式的次要模式會使插入的字符替換（覆蓋）現有文本，而不是將其推到右邊。請參閱次要模式。

只有圖形字符可以通過鍵入相關的按鍵來插入；其他按鍵作為編輯命令，不會自行插入。例如，默認情況下 DEL 運行 delete-backward-char 命令（某些模式將其綁定到不同的命令）；但它不會插入字面意義上的 "DEL "字符（ASCII 字符代碼 127）。

要插入一個非圖形字符或鍵盤不支持的字符，首先要輸入 C-q（quoted-insert）來引用該字符。使用 C-q 有兩種方法：

- C-q 後接任何非圖形字符（甚至是 C-g）都會插入該字符。例如，C-q DEL 插入一個字面意義上的 "DEL" 字符。
- C-q 後跟一串八進制數字，插入指定八進制字符代碼的字符。您可以使用任意八進制數字；任何非數字都會終止序列。如果終止字符是 RET，則 RET 僅用於終止序列。任何其他非數字都會終止序列，然後作為正常輸入，如 C-q 1 0 1 B 插入 "AB"。

  在普通的非二進制覆寫模式下，八進制序列的使用是禁用的，這樣可以方便地插入一個數字，而不是用它來覆寫。

要使用十進制或十六進制代替八進制，可將變量 read-quoted-char-radix 設置為 10 或 16。如果弧度為 16，字母 a 至 f 就會像數字一樣作為字符代碼的一部分。大小寫將被忽略。

通過以 C-x 8 開頭的命令，可以插入一些常見的 Unicode 字符。例如，C-x 8 [ 插入"'"，它是 Unicode 代碼點 U+2018 左單引號標記，有時也稱為左單引號 "彎引號 "或 "捲曲引號"。同樣，C-x 8 ]、C-x 8 { 和 C-x 8 } 分別插入"'"、""和""。此外，Alt 鍵的作用類似於 C-x 8（除非後面有 RET）；例如，A-[ 的作用類似於 C-x 8 [ 並插入。要查看哪些字符具有 C-x 8 速記功能，請鍵入 C-x 8 C-h。

或者，也可以使用 C-x 8 RET（插入-字符）命令。該命令使用微型緩衝區提示輸入字符的 Unicode 名稱或碼位。如果輸入的是名稱，命令將提供補全（參見補全）。如果輸入碼位，應為十六進制數（Unicode 的約定），或具有指定弧度的數字，例如 #o23072（八進制）；參見《Emacs Lisp 參考手冊》中的整數基礎知識。然後，命令將相應的字符插入緩衝區。

例如，以下命令都插入了相同的字符：

    C-x 8 RET left single quotation mark RET
    C-x 8 RET left sin TAB RET
    C-x 8 RET 2018 RET
    C-x 8 [
    A-[  (if the Alt key works)
    `    (in Electric Quote mode)

C-q 或 C-x 8 ...的數字參數指定插入字符的份數（參見數字參數）。

作為 C-x 8 的替代方法，可以通過鍵入 C-u C-x \ iso-transl RET 選擇相應的暫存輸入法，然後通過鍵入 C-x \ [ 臨時激活該暫存輸入法，將插入相同的字符 ' （參見暫存輸入法）。

此外，在某些情況下，如果輸入使用重音符號和撇號的引號 "like this"，即使沒有 C-x 8 命令，也會轉換為使用單引號的 "like this "形式。同樣，使用雙重音符號和撇號鍵入引號 "like this"，也會轉換為使用雙引號的 "like this "形式。參見引號。

### 更改點的位置

除了插入字符外，還必須知道如何移動點（請參閱 "點"）。鍵盤命令 C-f、C-b、C-n 和 C-p 可分別向右、向左、向下和向上移動點。您也可以使用大多數鍵盤上的方向鍵移動點： 不過，許多 Emacs 用戶發現，使用方向鍵比使用控制鍵要慢，因為你需要將手移到鍵盤上這些鍵所在的區域。

你也可以點擊滑鼠左鍵，將點移動到所點擊的位置。Emacs 還提供了多種額外的鍵盤命令，可以以更複雜的方式移動點。

C-f
  Move forward one character (forward-char).
RIGHT
  This command (right-char) behaves like C-f, except when point is in a right-to-left paragraph (see Bidirectional Editing).
C-b
  Move backward one character (backward-char).
LEFT
  This command (left-char) behaves like C-b, except if the current paragraph is right-to-left (see Bidirectional Editing).
C-n
DOWN
  Move down one screen line (next-line). This command attempts to keep the horizontal position unchanged, so if you start in the middle of one line, you move to the middle of the next.
C-p
UP
  Move up one screen line (previous-line). This command preserves position within the line, like C-n.
C-a
Home
  Move to the beginning of the line (move-beginning-of-line).
C-e
End
  Move to the end of the line (move-end-of-line).
M-f
  Move forward one word (forward-word). See Words.
C-RIGHT
M-RIGHT
  This command (right-word) behaves like M-f, except it moves backward by one word if the current paragraph is right-to-left. See Bidirectional Editing.
M-b
  Move backward one word (backward-word). See Words.
C-LEFT
M-LEFT
  This command (left-word) behaves like M-b, except it moves forward by one word if the current paragraph is right-to-left. See Bidirectional Editing.
M-r
  Without moving the text on the screen, reposition point on the left margin of the center-most text line of the window; on subsequent consecutive invocations, move point to the left margin of the top-most line, the bottom-most line, and so forth, in cyclic order (move-to-window-line-top-bottom).
  A numeric argument says which screen line to place point on, counting downward from the top of the window (zero means the top line). A negative argument counts lines up from the bottom (−1 means the bottom line). See Numeric Arguments, for more information on numeric arguments.
M-<
  Move to the top of the buffer (beginning-of-buffer). With numeric argument n, move to n/10 of the way from the top. On graphical displays, C-HOME does the same.
M->
  Move to the end of the buffer (end-of-buffer). On graphical displays, C-END does the same.
C-v
PageDown
next
  Scroll the display one screen forward, and move point onscreen if necessary (scroll-up-command). See Scrolling.
M-v
PageUp
prior
  Scroll one screen backward, and move point onscreen if necessary (scroll-down-command). See Scrolling.
M-g c
  Read a number n and move point to buffer position n. Position 1 is the beginning of the buffer. If point is on or just after a number in the buffer, that is the default for n. Just type RET in the minibuffer to use it. You can also specify n by giving M-g c a numeric prefix argument.
M-g M-g
M-g g
  Read a number n and move point to the beginning of line number n (goto-line). Line 1 is the beginning of the buffer. If point is on or just after a number in the buffer, that is the default for n. Just type RET in the minibuffer to use it. You can also specify n by giving M-g M-g a numeric prefix argument. See Creating and Selecting Buffers, for the behavior of M-g M-g when you give it a plain prefix argument. Alternatively, you can use the command goto-line-relative to move point to the line relative to the accessible portion of the narrowed buffer.
  goto-line has its own history list (see Minibuffer History). You can have either a single list shared between all buffers (the default) or a separate list for each buffer, by customizing the user option goto-line-history-local.
M-g TAB
  Read a number n and move to column n in the current line. Column 0 is the leftmost column. If called with a prefix argument, move to the column number specified by the argument’s numeric value.
C-x C-n
  Use the current column of point as the semipermanent goal column (set-goal-column) in the current buffer. When a semipermanent goal column is in effect, C-n, C-p, <prior> and <next> always try to move to this column, or as close as possible to it, after moving vertically. The goal column remains in effect until canceled.
C-u C-x C-n
  Cancel the goal column. Henceforth, C-n and C-p try to preserve the horizontal position, as usual.

When a line of text in the buffer is longer than the width of the window, Emacs usually displays it on two or more screen lines, a.k.a. visual lines. For convenience, C-n and C-p move point by screen lines, as do the equivalent keys down and up. You can force these commands to move according to logical lines (i.e., according to the text lines in the buffer) by setting the variable line-move-visual to nil; if a logical line occupies multiple screen lines, the cursor then skips over the additional screen lines. For details, see Continuation Lines. See Variables, for how to set variables such as line-move-visual.

Unlike C-n and C-p, most of the Emacs commands that work on lines work on logical lines. For instance, C-a (move-beginning-of-line) and C-e (move-end-of-line) respectively move to the beginning and end of the logical line. Whenever we encounter commands that work on screen lines, such as C-n and C-p, we will point these out.

When line-move-visual is nil, you can also set the variable track-eol to a non-nil value. Then C-n and C-p, when starting at the end of the logical line, move to the end of the next logical line. Normally, track-eol is nil.

C-n normally stops at the end of the buffer when you use it on the last line in the buffer. However, if you set the variable next-line-add-newlines to a non-nil value, C-n on the last line of a buffer creates an additional line at the end and moves down into it.

### 擦除文本

DEL
BACKSPACE
  Delete the character before point, or the region if it is active (delete-backward-char).
Delete
  Delete the character or grapheme cluster after point, or the region if it is active (delete-forward-char).
C-d
  Delete the character after point (delete-char).
C-k
  Kill to the end of the line (kill-line).
M-d
  Kill forward to the end of the next word (kill-word).
M-DEL
M-BACKSPACE
  Kill back to the beginning of the previous word (backward-kill-word).

The DEL (delete-backward-char) command removes the character before point, moving the cursor and the characters after it backwards. If point was at the beginning of a line, this deletes the preceding newline, joining this line to the previous one.

If, however, the region is active, DEL instead deletes the text in the region. See The Mark and the Region, for a description of the region.

On most keyboards, DEL is labeled BACKSPACE, but we refer to it as DEL in this manual. (Do not confuse DEL with the Delete key; we will discuss Delete momentarily.) On some text terminals, Emacs may not recognize the DEL key properly. See If DEL Fails to Delete, if you encounter this problem.

The Delete (delete-forward-char) command deletes in the opposite direction: it deletes the character after point, i.e., the character under the cursor. If point was at the end of a line, this joins the following line onto this one. Like DEL, it deletes the text in the region if the region is active (see The Mark and the Region). If the character after point is composed with following characters and displayed as a single display unit, a so-called grapheme cluster representing the entire sequence, Delete deletes the entire sequence in one go. This is in contrast to DEL which always deletes a single character, even if the character is composed.

C-d (delete-char) deletes the character after point, similar to Delete, but regardless of whether the region is active.

See Deletion, for more detailed information about the above deletion commands.

C-k (kill-line) erases (kills) a line at a time. If you type C-k at the beginning or middle of a line, it kills all the text up to the end of the line. If you type C-k at the end of a line, it joins that line with the following line.

See Killing and Moving Text, for more information about C-k and related commands.

### 撤銷更改

C-/
C-x u
C-_
  Undo one entry of the undo records—usually, one command worth (undo). (The first key might be unavailable on text-mode displays.)

Emacs records a list of changes made in the buffer text, so you can undo recent changes. This is done using the undo command, which is bound to C-/ (as well as C-x u and C-_). Normally, this command undoes the last change, moving point back to where it was before the change. The undo command applies only to changes in the buffer; you can’t use it to undo cursor motion.

On a terminal that supports the Control modifier on all other keys, the easiest way to invoke undo is with C-/, since that doesn’t need the Shift modifier. On terminals which allow only the ASCII control characters, C-/ does not exist, but for many of them C-/ still works because it actually sends C-_ to Emacs, while many others allow you to omit the Shift modifier when you type C-_ (in effect pressing C--), making that the most convenient way to invoke undo.

Although each editing command usually makes a separate entry in the undo records, very simple commands may be grouped together. Sometimes, an entry may cover just part of a complex command.

If you repeat C-/ (or its aliases), each repetition undoes another, earlier change, back to the limit of the undo information available. If all recorded changes have already been undone, the undo command displays an error message and does nothing.

To learn more about the undo command, see Undo.

### 文件

Text that you insert in an Emacs buffer lasts only as long as the Emacs session. To keep any text permanently, you must put it in a file.

Suppose there is a file named test.emacs in your home directory. To begin editing this file in Emacs, type

    C-x C-f test.emacs RET

Here the file name is given as an argument to the command C-x C-f (find-file). That command uses the minibuffer to read the argument, and you type RET to terminate the argument (see The Minibuffer).

Emacs obeys this command by visiting the file: it creates a buffer, copies the contents of the file into the buffer, and then displays the buffer for editing. If you alter the text, you can save the new text in the file by typing C-x C-s (save-buffer). This copies the altered buffer contents back into the file test.emacs, making them permanent. Until you save, the changed text exists only inside Emacs, and the file test.emacs is unaltered.

To create a file, just visit it with C-x C-f as if it already existed. This creates an empty buffer, in which you can insert the text you want to put in the file. Emacs actually creates the file the first time you save this buffer with C-x C-s.

To learn more about using files in Emacs, see File Handling.

### 幫助

If you forget what a key does, you can find out by typing C-h k (describe-key), followed by the key of interest; for example, C-h k C-n tells you what C-n does.

The prefix key C-h stands for 「help」. The key F1 serves as an alias for C-h. Apart from C-h k, there are many other help commands providing different kinds of help.

See Help, for details.

### 空白行

Here are special commands and techniques for inserting and deleting blank lines.

C-o
  Insert a blank line after the cursor (open-line).
C-x C-o
  Delete all but one of many consecutive blank lines (delete-blank-lines).

We have seen how RET (newline) starts a new line of text. However, it may be easier to see what you are doing if you first make a blank line and then insert the desired text into it. This is easy to do using the key C-o (open-line), which inserts a newline after point but leaves point in front of the newline. After C-o, type the text for the new line.

You can make several blank lines by typing C-o several times, or by giving it a numeric argument specifying how many blank lines to make. See Numeric Arguments, for how. If you have a fill prefix, the C-o command inserts the fill prefix on the new line, if typed at the beginning of a line. See The Fill Prefix.

The easy way to get rid of extra blank lines is with the command C-x C-o (delete-blank-lines). If point lies within a run of several blank lines, C-x C-o deletes all but one of them. If point is on a single blank line, C-x C-o deletes it. If point is on a nonblank line, C-x C-o deletes all following blank lines, if any exists.

### 延續線

Sometimes, a line of text in the buffer—a logical line—is too long to fit in the window, and Emacs displays it as two or more screen lines, or visual lines. This is called line wrapping or continuation, and the long logical line is called a continued line. On a graphical display, Emacs indicates line wrapping with small bent arrows in the left and right window fringes. On a text terminal, Emacs indicates line wrapping by displaying a 『\』 character at the right margin.

Most commands that act on lines act on logical lines, not screen lines. For instance, C-k kills a logical line. As described earlier, C-n (next-line) and C-p (previous-line) are special exceptions: they move point down and up, respectively, by one screen line (see Changing the Location of Point).

Emacs can optionally truncate long logical lines instead of continuing them. This means that every logical line occupies a single screen line; if it is longer than the width of the window, the rest of the line is not displayed. On a graphical display, a truncated line is indicated by a small straight arrow in the right fringe; on a text terminal, it is indicated by a 『$』 character in the right margin. See Line Truncation.

By default, continued lines are wrapped at the right window edge. Since the wrapping may occur in the middle of a word, continued lines can be difficult to read. The usual solution is to break your lines before they get too long, by inserting newlines. If you prefer, you can make Emacs insert a newline automatically when a line gets too long, by using Auto Fill mode. See Filling Text.

Sometimes, you may need to edit files containing many long logical lines, and it may not be practical to break them all up by adding newlines. In that case, you can use Visual Line mode, which enables word wrapping: instead of wrapping long lines exactly at the right window edge, Emacs wraps them at the word boundaries (i.e., space or tab characters) nearest to the right window edge. Visual Line mode also redefines editing commands such as C-a, C-n, and C-k to operate on screen lines rather than logical lines. See Visual Line Mode.

### 光標位置信息

Here are commands to get information about the size and position of parts of the buffer, and to count words and lines.

M-x what-line
  Display the line number of point.
M-x line-number-mode
M-x column-number-mode
  Toggle automatic display of the current line number or column number. See Optional Mode Line Features. If you want to have a line number displayed before each line, see Customization of Display.
M-=
  Display the number of lines, sentences, words, and characters that are present in the region (count-words-region). See The Mark and the Region, for information about the region.
M-x count-words
  Display the number of lines, sentences, words, and characters that are present in the buffer. If the region is active (see The Mark and the Region), display the numbers for the region instead.
C-x =
  Display the character code of character after point, character position of point, and column of point (what-cursor-position).
M-x hl-line-mode
  Enable or disable highlighting of the current line. See Displaying the Cursor.
M-x size-indication-mode
  Toggle automatic display of the size of the buffer. See Optional Mode Line Features.

M-x what-line displays the current line number in the echo area. This command is usually redundant because the current line number is shown in the mode line (see The Mode Line). However, if you narrow the buffer, the mode line shows the line number relative to the accessible portion (see Narrowing). By contrast, what-line displays both the line number relative to the narrowed region and the line number relative to the whole buffer.

M-= (count-words-region) displays a message reporting the number of lines, sentences, words, and characters in the region (see The Mark and the Region, for an explanation of the region). With a prefix argument, C-u M-=, the command displays a count for the entire buffer.

The command M-x count-words does the same job, but with a different calling convention. It displays a count for the region if the region is active, and for the buffer otherwise.

The command C-x = (what-cursor-position) shows information about the current cursor position and the buffer contents at that position. It displays a line in the echo area that looks like this:

    Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53

After 『Char:』, this shows the character in the buffer at point. The text inside the parenthesis shows the corresponding decimal, octal and hex character codes; for more information about how C-x = displays character information, see Introduction to International Character Sets. After 『point=』 is the position of point as a character count (the first character in the buffer is position 1, the second character is position 2, and so on). The number after that is the total number of characters in the buffer, and the number in parenthesis expresses the position as a percentage of the total. After 『column=』 is the horizontal position of point, in columns counting from the left edge of the window.

If the user option what-cursor-show-names is non-nil, the name of the character, as defined by the Unicode Character Database, is shown as well. The part in parentheses would then become:

    (99, #o143, #x63, LATIN SMALL LETTER C)

If the buffer has been narrowed, making some of the text at the beginning and the end temporarily inaccessible, C-x = displays additional text describing the currently accessible range. For example, it might display this:

    Char: C (67, #o103, #x43) point=252 of 889 (28%) <231-599> column=0

where the two extra numbers give the smallest and largest character position that point is allowed to assume. The characters between those two positions are the accessible ones. See Narrowing.

Related, but different feature is display-line-numbers-mode (see Customization of Display).

### 數值參數

In the terminology of mathematics and computing, argument means 「data provided to a function or operation」. You can give any Emacs command a numeric argument (also called a prefix argument). Some commands interpret the argument as a repetition count. For example, giving C-f an argument of ten causes it to move point forward by ten characters instead of one. With these commands, no argument is equivalent to an argument of one, and negative arguments cause them to move or act in the opposite direction.

The easiest way to specify a numeric argument is to type a digit and/or a minus sign while holding down the Meta key. For example,

    M-5 C-n

moves down five lines. The keys M-1, M-2, and so on, as well as M--, are bound to commands (digit-argument and negative-argument) that set up an argument for the next command. M-- without digits normally means −1.

If you enter more than one digit, you need not hold down the Meta key for the second and subsequent digits. Thus, to move down fifty lines, type

    M-5 0 C-n

Note that this does not insert five copies of 『0』 and move down one line, as you might expect—the 『0』 is treated as part of the prefix argument.

(What if you do want to insert five copies of 『0』? Type M-5 C-u 0. Here, C-u terminates the prefix argument, so that the next keystroke begins the command that you want to execute. Note that this meaning of C-u applies only to this case. For the usual role of C-u, see below.)

Instead of typing M-1, M-2, and so on, another way to specify a numeric argument is to type C-u (universal-argument) followed by some digits, or (for a negative argument) a minus sign followed by digits. A minus sign without digits normally means −1.

C-u alone has the special meaning of 「four times」: it multiplies the argument for the next command by four. C-u C-u multiplies it by sixteen. Thus, C-u C-u C-f moves forward sixteen characters. Other useful combinations are C-u C-n, C-u C-u C-n (move down a good fraction of a screen), C-u C-u C-o (make sixteen blank lines), and C-u C-k (kill four lines).

You can use a numeric argument before a self-inserting character to insert multiple copies of it. This is straightforward when the character is not a digit; for example, C-u 6 4 a inserts 64 copies of the character 『a』. But this does not work for inserting digits; C-u 6 4 1 specifies an argument of 641. You can separate the argument from the digit to insert with another C-u; for example, C-u 6 4 C-u 1 does insert 64 copies of the character 『1』.

Some commands care whether there is an argument, but ignore its value. For example, the command M-q (fill-paragraph) fills text; with an argument, it justifies the text as well. (See Filling Text, for more information on M-q.) For these commands, it is enough to specify the argument with a single C-u.

Some commands use the value of the argument as a repeat count but do something special when there is no argument. For example, the command C-k (kill-line) with argument n kills n lines, including their terminating newlines. But C-k with no argument is special: it kills the text up to the next newline, or, if point is right at the end of the line, it kills the newline itself. Thus, two C-k commands with no arguments can kill a nonblank line, just like C-k with an argument of one. (See Killing and Moving Text, for more information on C-k.)

A few commands treat a plain C-u differently from an ordinary argument. A few others may treat an argument of just a minus sign differently from an argument of −1. These unusual cases are described when they come up; they exist to make an individual command more convenient, and they are documented in that command’s documentation string.

We use the term prefix argument to emphasize that you type such arguments before the command, and to distinguish them from minibuffer arguments (see The Minibuffer), which are entered after invoking the command.

On graphical displays, C-0, C-1, etc. act the same as M-0, M-1, etc.

### 重複命令

Many simple commands, such as those invoked with a single key or with M-x command-name RET, can be repeated by invoking them with a numeric argument that serves as a repeat count (see Numeric Arguments). However, if the command you want to repeat prompts for input, or uses a numeric argument in another way, that method won’t work.

The command C-x z (repeat) provides another way to repeat an Emacs command many times. This command repeats the previous Emacs command, whatever that was. Repeating a command uses the same arguments that were used before; it does not read new arguments each time.

To repeat the command more than once, type additional z’s: each z repeats the command one more time. Repetition ends when you type a character other than z or press a mouse button.

For example, suppose you type C-u 2 0 C-d to delete 20 characters. You can repeat that command (including its argument) three additional times, to delete a total of 80 characters, by typing C-x z z z. The first C-x z repeats the command once, and each subsequent z repeats it once again.

You can also activate repeat-mode which allows repeating commands bound to sequences of two or more keys by typing a single character. For example, after typing C-x u (undo, see Undo) to undo the most recent edits, you can undo many more edits by typing u u u…. Similarly, type C-x o o o… instead of C-x o C-x o C-x o… to switch to the window several windows away. This works by entering a transient repeating mode after you type the full key sequence that invokes the command; the single-key shortcuts are shown in the echo area.

Only some commands support repetition in repeat-mode; type M-x describe-repeat-maps RET to see which ones.

The single-character shortcuts enabled by the transient repeating mode do not need to be identical: for example, after typing C-x {, either { or } or ^ or v, or any series that mixes these characters in any order, will resize the selected window in respective ways. Similarly, after M-g n or M-g p, typing any sequence of n and/or p in any mix will repeat next-error and previous-error to navigate in a *compilation* or *grep* buffer (see Compilation Mode).

Typing any key other than those defined to repeat the previous command exits the transient repeating mode, and then the key you typed is executed normally. You can also define a key which will exit the transient repeating mode without executing the key which caused the exit. To this end, customize the user option repeat-exit-key to name a key; one natural value is RET. Finally, it’s possible to break the repetition chain automatically after some amount of idle time: customize the user option repeat-exit-timeout to specify the idle time in seconds after which this transient repetition mode will be turned off automatically.

分類：​

- Emacs

隱藏分類：​

- 使用「模板:合併」標記的頁面或章節

Emacs/使用
新增話題