![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ae5 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 13.edadv|
Return to ae5 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 13.edadv |
1.1 root 1: .\" @(#)ae5 6.1 (Berkeley) 5/22/86
2: .\"
3: .NH
4: CUT AND PASTE WITH UNIX COMMANDS
5: .PP
6: One editing area in which non-programmers
7: seem not very confident
8: is in what might be called
9: `cut and paste' operations _
10: changing the name of a file,
11: making a copy of a file somewhere else,
12: moving a few lines from one place to another in a file,
13: inserting one file in the middle of another,
14: splitting a file into pieces,
15: and
16: splicing two or more files together.
17: .PP
18: Yet most of these operations are actually quite easy,
19: if you keep your wits about you
20: and go cautiously.
21: The next several sections talk about cut and paste.
22: We will begin with the
23: .UX
24: commands
25: for moving entire files around,
26: then discuss
27: .UL ed
28: commands
29: for operating on pieces of files.
30: .SH
31: Changing the Name of a File
32: .PP
33: You have a file named
34: `memo'
35: and you want it to be called
36: `paper'
37: instead.
38: How is it done?
39: .PP
40: The
41: .UX
42: program that renames files
43: is called
44: .UL mv
45: (for `move');
46: it `moves' the file from one name to another, like this:
47: .P1
48: mv memo paper
49: .P2
50: That's all there is to it:
51: .UL mv
52: from the old name to the new name.
53: .P1
54: mv oldname newname
55: .P2
56: Warning: if there is already a file around with the new name,
57: its present contents will be
58: silently
59: clobbered
60: by the information from the other file.
61: The one exception is that you can't move a file
62: to itself _
63: .P1
64: mv x x
65: .P2
66: is illegal.
67: .SH
68: Making a Copy of a File
69: .PP
70: Sometimes what you want is a copy of a file _
71: an entirely fresh version.
72: This might be because you want to work on a file, and
73: yet save a copy in case something gets fouled up,
74: or just because you're paranoid.
75: .PP
76: In any case, the way to do it is with the
77: .UL cp
78: command.
79: .UL cp \& (
80: stands for `copy';
81: the
82: .UC UNIX
83: system
84: is big on short command names,
85: which are appreciated by heavy users,
86: but sometimes a strain for novices.)
87: Suppose you have a file called
88: `good'
89: and
90: you want to save a copy before you make some
91: dramatic editing changes.
92: Choose a name _
93: `savegood'
94: might be acceptable _ then type
95: .P1
96: cp good savegood
97: .P2
98: This copies
99: `good'
100: onto
101: `savegood',
102: and you now have two identical copies of the file
103: `good'.
104: (If
105: `savegood'
106: previously contained something,
107: it gets overwritten.)
108: .PP
109: Now if you decide at some time that you want to get
110: back to the original state of
111: `good',
112: you can say
113: .P1
114: mv savegood good
115: .P2
116: (if you're not interested in
117: `savegood'
118: any more), or
119: .P1
120: cp savegood good
121: .P2
122: if you still want to retain a safe copy.
123: .PP
124: In summary,
125: .UL mv
126: just renames a file;
127: .UL cp
128: makes a duplicate copy.
129: Both of them clobber the `target' file
130: if it already exists, so you had better
131: be sure that's what you want to do
132: .ul
133: before
134: you do it.
135: .SH
136: Removing a File
137: .PP
138: If you decide you are really done with a file
139: forever, you can remove it
140: with the
141: .UL rm
142: command:
143: .P1
144: rm savegood
145: .P2
146: throws away (irrevocably) the file called
147: `savegood'.
148: .SH
149: Putting Two or More Files Together
150: .PP
151: The next step is the familiar one of collecting two or more
152: files into one big one.
153: This will be needed, for example,
154: when the author of a paper
155: decides that several sections need to be combined
156: into one.
157: There are several ways to do it,
158: of which the cleanest, once you get used to it,
159: is a program called
160: .UL cat .
161: (Not
162: .ul
163: all
164: .UC UNIX
165: programs have two-letter names.)
166: .UL cat
167: is short for
168: `concatenate', which is exactly
169: what we want to do.
170: .PP
171: Suppose the job is to combine the files
172: `file1'
173: and
174: `file2'
175: into a single file called
176: `bigfile'.
177: If you say
178: .P1
179: cat file
180: .P2
181: the contents of
182: `file'
183: will get printed on your terminal.
184: If you say
185: .P1
186: cat file1 file2
187: .P2
188: the contents of
189: `file1'
190: and then the contents of
191: `file2'
192: will
193: .ul
194: both
195: be printed on your terminal,
196: in that order.
197: So
198: .UL cat
199: combines the files, all right,
200: but it's not much help to print them on the terminal _
201: we want them in
202: `bigfile'.
203: .PP
204: Fortunately, there is a way.
205: You can tell
206: the system
207: that instead of printing on your terminal,
208: you want the same information put in a file.
209: The way to do it is to add to the command line
210: the character
211: .UL >
212: and the name of the file
213: where you want the output to go.
214: Then you can say
215: .P1
216: cat file1 file2 >bigfile
217: .P2
218: and the job is done.
219: (As with
220: .UL cp
221: and
222: .UL mv ,
223: you're putting something into
224: `bigfile',
225: and anything that was already there is destroyed.)
226: .PP
227: This ability to
228: `capture' the output of a program
229: is one of the most useful aspects of
230: the
231: .UC UNIX
232: system.
233: Fortunately it's not limited to the
234: .UL cat
235: program _
236: you can use it with
237: .ul
238: any
239: program that prints on your terminal.
240: We'll see some more uses for it in a moment.
241: .PP
242: Naturally, you can combine several files,
243: not just two:
244: .P1
245: cat file1 file2 file3 ... >bigfile
246: .P2
247: collects a whole bunch.
248: .PP
249: Question:
250: is there any difference between
251: .P1
252: cp good savegood
253: .P2
254: and
255: .P1
256: cat good >savegood
257: .P2
258: Answer: for most purposes, no.
259: You might reasonably ask why there are two programs
260: in that case,
261: since
262: .UL cat
263: is obviously all you need.
264: The answer is that
265: .UL cp
266: can do some other things as well,
267: which you can investigate for yourself
268: by reading the manual.
269: For now we'll stick to simple usages.
270: .SH
271: Adding Something to the End of a File
272: .PP
273: Sometimes you want to add one file to the end of another.
274: We have enough building blocks now that you can do it;
275: in fact before reading further it would be valuable
276: if you figured out how.
277: To be specific,
278: how would you use
279: .UL cp ,
280: .UL mv
281: and/or
282: .UL cat
283: to add the file
284: `good1'
285: to the end of the file
286: `good'?
287: .PP
288: You could try
289: .P1
290: cat good good1 >temp
291: mv temp good
292: .P2
293: which is probably most direct.
294: You should also understand why
295: .P1
296: cat good good1 >good
297: .P2
298: doesn't work.
299: (Don't practice with a good `good'!)
300: .PP
301: The easy way is to use a variant of
302: .UL > ,
303: called
304: .UL >> .
305: In fact,
306: .UL >>
307: is identical to
308: .UL >
309: except that instead of clobbering the old file,
310: it simply tacks stuff on at the end.
311: Thus you could say
312: .P1
313: cat good1 >>good
314: .P2
315: and
316: `good1'
317: is added to the end of
318: `good'.
319: (And if
320: `good'
321: didn't exist,
322: this makes a copy of
323: `good1'
324: called
325: `good'.)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.