The ed Text Editor

A few hints on the program (Ver 1.0)

Running ed

• ed -E = open ed and use extended regular expressions instead of POSIX ones
• ed -p[string] = use [string] as the command-mode prompt
• ed -r = restricted mode: ed cannot edit outside current directory nor run shell commands
• ed -s = suppresses diagnostic messages, the "!" marker after executing shell commands, and byte counts for reads/writes
• ed -v = starts ed with error/diagnostic messages turned on. Messages can be turned off with the "H" command
• Options can be combined. It's possible to run "ed -Ervp*" for example.

Input Mode

• (n)a = append text below numbered/current line
• (n)c = change line(s). The lines are deleted (and stored in the cut buffer) and ed put into insert mode to accept replacement text.
• (n)i = insert text above numbered/current line
• . = a period on a line by itself takes ed out of insert mode and returns it to command mode.
• Prior to hitting <return>, a line being entered can be modified by using the backspace key
• If the line entered wraps down to the next line, using the backspace key *will* erase text on the "line" above. However, changes won't be apparent because the cursor stops at the beginning of whatever line it's on and won't move up.
• The entire line being entered can be erased by hitting <Ctrl+u>

Command Mode

The generic command structure is: [address[,addresss]] command [parameters or destination address]

One concept to grasp when using ed is that of the current line or current address. It's the default address in the buffer on which commands work if no address is supplied. It changes constantly. The current address is initially set to the last line of a file read into the buffer. And generally, it's then set to the address of the last line (or the last of a range of lines) that's been changed by a command. Typing ".=" will give you the line number of the current address. You can also type "n" by itself to see both the number AND the text of the current address.

The address of 0 is always the first line of the buffer. The command 0a appends *before* first line, making whatever text is input the new first line.

(n,n) sets a range of numbers upon which to act. (n;n) sets the range from the current line to line n. In both cases, if only the first n is given, the second address is set equal to n. If only the second n is given, the range (1,n) is assumed; for (;n), the range of (current line, n) is assumed.

Regular expressions can also be used to set ranges. For example, "8,/foo/p" will print every line between line 8 and the first line containing "foo." Regular expressions can be used for *both* ends of a range. "/begin/,/end/d" will delete all lines beginning with the first match of "begin" and stop at the first match of "end."

Line address symbols:

• . = current address
• $ = last line in buffer
• n = line number
• +n = the nth next line
• -n = the nth previous line
• + = the next line
• - = the previous line
• , (by itself) = the entire buffer
• % (by itself) = the entire buffer
• ; (by itself) = from the current line to the end of the buffer
• '[a-z] = the line previously marked
• k[a-z] sets a mark for ed to go to using the above " ' " command
• Lines that are marked using the "k" command remain marked no matter what happens to the lines above and below them. In essence, marking a line gives it a permanent "line number" that doesn't change, even if the other line numbers in the document do.

Text-related commands:

• (n)d = delete line(s). Deleted text is stored in the cut buffer.
• (n,n)j = joins the two mentioned lines into one line, without inserting a space in the middle of the join. The original lines are copied to the cut buffer.
• (n)l = list lines to include showing non-printing characters and spaces at the line ends; line ends are marked with a "$"
• (n)m(n) = move line(s) to after destination address
• (n)n = print lines, showing line numbers
• (n)p = print the line(s) to the screen
• (n)t(n) = copies the marked line(s) to the line after the destination address
• u = undo previous change. Only the most recent change can be undone; there is no "multi-undo."
• (n)x = copies contents of cut buffer into document after addressed line
• (n)y = yanks (copies) of line(s) into cut buffer
• Printing commands can be combined: "nl" will both number a line and show the end-of-line.
• Just about every command can be followed by a p (print), n (number) or l (list) to show the changes just made.
• /[term] = search forward for [term].
• // = repeat last search
• ?[term] = search backward for [term]
• ?? = repeat last search
• .= (That is, period, equal sign) = the number of the current line.

File- and program-handling commands:

• e [file] = edit [file] and/or set default filename to [file] for writing. While you can't edit multiple files simultaneously, you *can* switch between files without having to leave the ed program, by typing e [new filename]. Be sure to save any changes before switching between files.
• E [file] = edit file WITHOUT warning about unwritten changes. Typing E while inside an edited file will undo *all* unsaved changes and write the file to disk.
• f [file] = sets the working filename to [file]. Typing "f" by itself will list the current filename. (Good if you've edited multiple files and want to know which one you're currently in.)
• You can't invoke ed [filename] if [filename] doesn't yet exist, because it's an empty buffer. However, once inside ed you can set a filename for saving either by typing e [filename] or by typing f [filename] while in command mode.
• h = print information on the last error
• H = toggle on/off the printing of error messages
• P = toggle command-mode prompt on/off
• q = quits ed. The program will warn if there are unsaved changes in the buffer.
• Q = quit without saving changes
• r [file] or [!command] = read the contents of [file] or the results of [!command] into the current buffer
• w [file] or [!command] = write the buffer to [file] or the standard input of [!command]
• (n,n)W [file] = append line(s) to end of [file]
• wq [file] = write to [file] then quit
• (n)zN = scroll N lines in file from line (n).
• !command = execute a shell command
• If you've done a lot of editing, typing "!clear" clears the screen via the shell, giving you a fresh "page" to work upon.
• <ctrl+c> will abort the current command

Regular Expressions

Regular expressions are the heart of the ed editor. Ed, after all, was the basis for sed and grep; and to this day the diff command is still capable of outputting an ed script that will change one file into another--a holdover from pre-sed days.

Regular expressions are a study unto themselves. Whole books have been written about them. If you don't know what a regex is or how they work, a good place to start is the man page for the grep command or 'info ed.'

• g/re/ = print all lines containing [regular expression]
• The g/re/ command will accept any legal ed command as its parameter, making it very powerful. For example, "g/^$/d" will remove all blank lines from a file. Multiple commands can be "stacked" using a \ (slash character) at the end of every line except the last. For example, g/read/s/read/READ/\ s/READ/READING/\ s/READING/WATCH TV/ would replace all the words "read" in a document first with "READ," then "READING," and then "WATCH TV."
• G/re/ = does the same thing as the g command but allows for interactive editing of each matched line.
• s/re/replacement = substitute [replacement] for [regular expression]
• s/re/replacement/g,COUNT,p,n,l = substitute [regular expression] with [replacement]. This can be done g [globally = all matches on a line] or COUNT [only the COUNT-th match]. p,n,l are the print, number, and list commands.
• (n)s (by itself) = repeat the last substitution on the same line. Accepts the g and COUNT suffixes.
• v/re/ = match every line which *does not* contain the [regular expression]. The v command has the same abilities and options as the g command.
• V/re/ = does the same as the v command, but allows for interactive editing of each matched line.
• /re/ = next line that matches [regular expression]
• ?re? = previous line that matches [regular expression]
• ;/re/ = search from current address down to next [regular expression]
• ;?re? = search from current address up to [regular expression]
• & = matches the last text entered in a replacement command or the last command/series of editing commands in G/V commands. For example, s/read/&ing/ will change "read" to "reading." Or, after using G/read/ and entering "s/read/wear/", typing & will re-run the same substitution on the next match.
• The % sign within the substitution portion of a s or g command will re-run the same substitution on a *different* match.

Further information:

• Typing 'info ed' on the command line
• Ken Thompson's video on the ed editor
• ed(1) conference A twitter thread of ed tips and tricks.