You'll get your Mac news here from now on...

Help TMO Grow

Subscriber Login

Advertising Info


The Mac Observer Express Daily Newsletter


More Info

Site Navigation

Home
News
Tips
Columns & Editorials
Reviews
Reports
Archives
Search
Forums
Links
Mac Links
Software
Reports
Contact

Mac OS X Command Line 101
by Richard Burton


Command Line Text Editing Basics
Part XII of this series...
July 26th, 2002

This method answers the purpose for which it was devised; it saves lazy editors from working and stupid editors from thinking.
-
A.E. Housman, "The Editing of Manilus"

This series is designed to help you learn more about the Mac OS X command line. If you have any questions about what you read here, check out the earlier columns, write back in the comments below, or join us in the Hardcore X! forum.

So far we have done quite a bit with manipulating files and examining information on them: their contents, properties, and so on. However, we have not yet discussed creating a file from scratch. True, we have shown how to create a file by redirecting Standard Output, and while this is powerful, it is not always the most convenient way to create all files. To do this, we need to know how to use an editor, so we will now learn the basics of vi.

Now before we start, the emacs users must pipe down and quit lobbing rotten vegetables at the stage. For those of you who are new to Unix and the command line, the vi vs. emacs debate may have been the closest thing to a holy war that the Unix community has ever seen. Each side's adherents extol the virtue of their respective editor of choice and some feel the need to denigrate the other. This is complete eyewash, of course, as each editor has its virtues. I've chosen vi for four reasons. First, it isn't as intimidating for a newcomer; emacs has a plethora of commands, while vi requires less to learn up front and doesn't present options that could be confusing to a newbie. Second, there are some Unix systems which still don't come with emacs or is not installed by the sysadmin, while vi is ubiquitous; this is hard to believe, but true. Third, Ye Editor probably wouldn't pay me the same huge commission for all the articles that would be required to cover emacs. And fourth, I am using vi to write these columns as an example of what can be done from the command line. Besides, we all know that vi people are superior humans, so phblt! to the emacs lusers.

vi is based on the venerable ex editor, which is now more or less the Unix equivalent of the horse and buggy; it gets you there, but not what you want to use unless you must. Still, ex did have its points, and vi will let you run those useful ex commands; more on that later. vi has the advantage of being, get this, a full screen editor which lets you look at more than one line at a time. This seems like no big deal, but when vi premiered, it was amazing. (Or so I'm told; I haven't been computing that long.) And in the grand tradition of Unix utilities, vi makes simple things simple and complex things possible.

To create a file with vi, simply type:

    vi filename
    
In this column, we will step through some of the basics so you can get started with vi. At the command line, type:
    vi testfile
    
This should clear your terminal screen and give you something that looks like:
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    testfile: new file: line 1
    
You may be wondering what's with all the tildes (~). Remember that vi is a full screen editor. However, when you give it the name of a file that doesn't exist, or a file with only a few lines, you can have more lines on the screen than lines in the file. To denote this, vi will indicate "this is beyond the end of the file, pal" with a tilde at the beginning of a line on the screen.

vi has two modes: a command mode and an input mode. When it starts, you are in command mode. To enter input mode (i.e. to insert text), just type the letter "i" and start typing. In your terminal, type and "i" and add the following. (Don't worry if you mistype something, I'll show you how to replace things in a bit.)

    Now is the time for all good men (and women, of course) to
    come to the aid of the party. 
    
     
    We're out of ice cream.
    
     
    This is a very long line, with more than the eighty characters that you will nor
    mally see on the terminal. Notice how it wrapped around?
    
     
    Work is the curse of the drinking classes. - Oscar Wilde
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    
    
When you have finished typing, hit the ESCAPE key (upper left of the keyboard) to go back to command mode; your cursor should be over the 'e' in Wilde. In fact, if you are in vi and you can't remember whether you are in command mode or input mode, hitting ESCAPE will always take you out of input mode; if you are already in command mode, you hear an error beep, but no harm is done.

You may well have made mistakes when typing that. After all, we're only human. Well, you are. One of the easiest way to reverse anything you wanted to do is with the undo command, "u". This will put things back to the way they were before your previous change. (Moving around does not count as a change.) This simple little command has saved my bacon more than once; keep it in mind.

If you are in command mode, you can move one space left, right, up, or down using the arrow keys. Yes, it's obvious and it should go without saying; that's why I said it. Back in the day, however, you couldn't count on having these keys on your keyboard or having them mapped the right way. In old Unix utilities, "h", "j", "k", and "l" do this: "h" for left, "j" for down, "k" for up, and "l" for right. (Anyone who plays nethack will find that familiar.) In fact, I half-recommend you use these letters; if you ever wind up on another Unix box, the keyboard may have the arrows set up a bit differently and you'll need to use hjkl. Take a few second to move around and get familiar with them.

Now, using hjkl can get the job done, but they can be tiresome, particularly if you have to traverse a whole line. Fortunately, there are some shortcuts to promote the virtue of laziness. First, vi will let you run almost any command repeatedly by prepending a number to it. (These commands are said to 'take a count' in the vernacular; I don't know if that's an official term.) Go all the way back to the beginning of the first line. Say you want to move eight characters to the right. Instead of typing "l" eight times, you can simply type "8l" to do the same thing. Try this; it should take your cursor to the "h" in "the". "3j" will then take you to the "t" in "out".

Also, notice the line that starts "This is a very long ..." Assuming that you didn't hit RETURN after the 'nor' in 'normally', vi wrapped the line on the screen, but it still considers it one line. Trying using "j" and "k" to move up and down through the line. You originally typed this as one line, so vi stores it internally as one line. That's why you may see the cursor moving through what seems to be more than one line on one "j" or "k".

In addition, there are other handy movement commands. A "0" (zero, not a capital 'o') will take you to the beginning of your current line; a "$" will take you to the end. A "w" will advance you to the beginning of the next word; and yes, "3w" will advance you three words. Likewise, the "b" will move you back one word; "2b" will take you back two. And if you want to advance to the end of a word, use the "e" command, which also can take a count.

So now we can fly around our test file with the greatest of ease. However, we still need to change things. If you forgot a letter, you can of course use the "i" command to insert it. (Don't forget the ESCAPE.) The "x" command will delete the character under the cursor. "x" also takes a count, like the movement commands. "5x" will delete the character under the cursor, plus the next four (for a total of five). "r" will replace the character under the cursor with the next character you type. Let's say you typed 'them' when you meant to type 'then'. You can just place your cursor over the 'm', then type rn and the word is fixed. Now, having said that, I must warn you. "r" takes a count, but it may not do what you think. If you type 3rn the next three characters will all be replaced with 'n'. If you would like to replace, say, 'and' with 'but', use the "R" command. It will overwrite characters as long as you type; to escape from this form of input mode, you should, of course, hit ESCAPE.

Two other commands deserve attention: the delete and change commands. Delete, "d", has two forms. You can use it to delete a word, "dw", or to delete a whole line, "dd". Both of these forms can take a count, as can both forms of the change command, "c". To change a word, use "cw"; to change a whole line, use "cc". And as you can probably guess, once you are done typing in the change, you hit ESCAPE to get back to command mode.

With these commands, you can now get to anywhere in your file and correct any errors you made. Why don't you go ahead and do this? It will give you some nice practice, so even if you did type it properly, add a couple of mistakes, then change them back. Remember: ESCAPE takes you out of insert mode and into command mode. So toddle along; we'll wait.

.
.
.

Ah, back so soon? [HIDES ADULT BEVERAGE] Splendid. Capital. Now there is one thing we must do: save the file. vi offers many different ways to do this, depending on just what you want to do. If you want to save the file and leave vi, the "ZZ" command will do just that. However, if you want to continue editing after saving the file, just type ":w" while in command mode. If you wish to quit without saving your changes, use the ":q" command. (For those who are wondering, typing a colon while in command mode will allow you to enter an ex command. The reasoning here, I think, is that ex provided good commands to do some things already, whether the editor was a line editor like ex or a full-screen editor like vi, so vi just lets the commands it could inherit from ex work without vi's author(s) having to rewrite code.)

So, there you have the basics of vi. That isn't everything, of course. In the next column, we'll examine vi in more depth.

You are encouraged to send Richard your comments, or to post them below.


Most Recent Mac OS X Command Line 101 Columns

Command Line History & Editing Your Commands
November 22nd

Pico: An Easy To Use Command Line Editor
November 1st

Understanding The "grep" Command In Mac OS X
October 4th

Command Line History & Editing Your Commands
September 6th

Mac OS X Command Line 101 Archives

Back to The Mac Observer For More Mac News!


Richard Burton is a longtime Unix programmer and a handsome brute. He spends his spare time yelling at the television during Colts and Pacers games, writing politically incorrect short stories, and trying to shoot the neighbor's cat (not really) nesting in his garage. He can be seen running roughshod over the TMO forums under the alias tbone1.



Today's Mac Headlines

[Podcast]Podcast - Apple Weekly Report #135: Apple Lawsuits, Banned iPhone Ad, Green MacBook Ad

We also offer Today's News On One Page!

Yesterday's News

 

[Podcast]Podcast - Mac Geek Gab #178: Batch Permission Changes, Encrypting Follow-up, Re-Enabling AirPort, and GigE speeds

We also offer Yesterday's News On One Page!

Mac Products Guide
New Arrivals
New and updated products added to the Guide.

Hot Deals
Great prices on hot selling Mac products from your favorite Macintosh resellers.

Special Offers
Promotions and offers direct from Macintosh developers and magazines.

Software
Browse the software section for over 17,000 Macintosh applications and software titles.

Hardware
Over 4,000 peripherals and accessories such as cameras, printers, scanners, keyboards, mice and more.

© All information presented on this site is copyrighted by The Mac Observer except where otherwise noted. No portion of this site may be copied without express written consent. Other sites are invited to link to any aspect of this site provided that all content is presented in its original form and is not placed within another .