@(#)e4 8.1 (Berkeley) 06/08/93
Exercise 5:
Experiment with the substitute command. See what happens if you substitute for some word on a line with several occurrences of that word. For example, do this:
1 a the other side of the coin \*. s/the/on the/p
2 You will get
1 on the other side of the coin
2 A substitute command changes only the first occurrence of the first string. You can change all occurrences by adding a g (for ``global'') to the s command, like this:
1 s/ . . . / . . . /gp
2 Try other characters instead of slashes to delimit the two sets of characters in the s command - anything should work except blanks or tabs.
(If you get funny results using any of the characters
1 ^ \*. $ [ * \e &
2 read the section on ``Special Characters''.)
Context searching - ``/ . . . /''With the substitute command mastered, you can move on to another highly important idea of .ul ed - context searching.
Suppose you have the original three line text in the buffer:
1 Now is the time for all good men to come to the aid of their party.
2 Suppose you want to find the line that contains T their so you can change it to T the . Now with only three lines in the buffer, it's pretty easy to keep track of what line the word T their is on. But if the buffer contained several hundred lines, and you'd been making changes, deleting and rearranging lines, and so on, you would no longer really know what this line number would be. Context searching is simply a method of specifying the desired line, regardless of what its number is, by specifying some context on it.
The way to say ``search for a line that contains this particular string of characters'' is to type
1 /string of characters we want to find/
2 For example, the .ul ed command
1 /their/
2 is a context search which is sufficient to find the desired line - it will locate the next occurrence of the characters between slashes (``their''). It also sets dot to that line and prints the line for verification:
1 to come to the aid of their party.
2 ``Next occurrence'' means that .ul ed starts looking for the string at line .+1 , searches to the end of the buffer, then continues at line 1 and searches to line dot. (That is, the search ``wraps around'' from $ to 1.) It scans all the lines in the buffer until it either finds the desired line or gets back to dot again. If the given string of characters can't be found in any line, .ul ed types the error message
1 ?
2 Otherwise it prints the line it found.
You can do both the search for the desired line .ul and a substitution all at once, like this:
2 which will yield
1 to come to the aid of the party.
2 There were three parts to that last command: context search for the desired line, make the substitution, print the line.
The expression /their/ is a context search expression. In their simplest form, all context search expressions are like this - a string of characters surrounded by slashes. Context searches are interchangeable with line numbers, so they can be used by themselves to find and print a desired line, or as line numbers for some other command, like s . They were used both ways in the examples above.
Suppose the buffer contains the three familiar lines
1 Now is the time for all good men to come to the aid of their party.
2 Then the .ul ed line numbers
1 /Now/+1 /good/ /party/-1
2 are all context search expressions, and they all refer to the same line (line 2). To make a change in line 2, you could say
2 or
2 or
2 The choice is dictated only by convenience. You could print all three lines by, for instance
1 /Now/,/party/p
2 or
1 /Now/,/Now/+2p
2 or by any number of similar combinations. The first one of these might be better if you don't know how many lines are involved. (Of course, if there were only three lines in the buffer, you'd use
1 1,$p
2 but not if there were several hundred.)
The basic rule is: a context search expression is .ul the same as a line number, so it can be used wherever a line number is needed.
Exercise 6:Experiment with context searching. Try a body of text with several occurrences of the same string of characters, and scan through it using the same context search.
Try using context searches as line numbers for the substitute, print and delete commands. (They can also be used with r , w , and a .)
Try context searching using ?text? instead of /text/ . This scans lines in the buffer in reverse order rather than normal. This is sometimes useful if you go too far while looking for some string of characters - it's an easy way to back up.
(If you get funny results with any of the characters
1 ^ \*. $ [ * \e &
2 read the section on ``Special Characters''.)
.ul Ed provides a shorthand for repeating a context search for the same string. For example, the .ul ed line number
1 /string/
2 will find the next occurrence of string . It often happens that this is not the desired line, so the search must be repeated. This can be done by typing merely
1 //
2 This shorthand stands for ``the most recently used context search expression.'' It can also be used as the first string of the substitute command, as in
1 /string1/s//string2/
2 which will find the next occurrence of string1 and replace it by string2 . This can save a lot of typing. Similarly
1 ??
2 means ``scan backwards for the same expression.''