Posted on 2007-10-25 23:53
Raylong 阅读(3747)
评论(10) 编辑 收藏 所属分类:
Java语法总结 
Java语法总结 - 线程
一提到线程好像是件很麻烦很复杂的事，事实上确实如此，涉及到线程的编程是很讲究技巧的。这就需要我们变换思维方式，了解线程机制的比较通用的技巧，写出高效的、不依赖于某个JVM实现的程序来。毕竟仅仅就Java而言，各个虚拟机的实现是不同的。学习线程时，最令我印象深刻的就是那种不确定性、没有保障性，各个线程的运行完全是以不可预料的方式和速度推进，有的一个程序运行了N次，其结果差异性很大。
1、什么是线程？线程是彼此互相独立的、能独立运行的子任务，并且每个线程都有自己的调用栈。所谓的多任务是通过周期性地将CPU时间片切换到不同的子任务，虽然从微观上看来，单核的CPU上同时只运行一个子任务，但是从宏观来看，每个子任务似乎是同时连续运行的。（但是JAVA的线程不是按时间片分配的，在本文的最后引用了一段网友翻译的JAVA原著中对线程的理解。）
2、在java中，线程指两个不同的内容：一是java.lang.Thread类的一个对象；另外也可以指线程的执行。线程对象和其他的对象一样，在堆上创建、运行、死亡。但不同之处是线程的执行是一个轻量级的进程，有它自己的调用栈。
可以这样想，每个调用栈都对应一个线程，每个线程又对应一个调用栈。
我们运行java程序时有一个入口函数main()函数，它对应的线程被称为主线程。一个新线程一旦被创建，就产生一个新调用栈，从原主线程中脱离，也就是与主线程并发执行。
4、当提到线程时，很少是有保障的。我们必须了解到什么是有保障的操作，什么是无保障的操作，以便设计的程序在各种jvm上都能很好地工作。比如，在某些jvm实现中，把java线程映射为本地操作系统的线程。这是java核心的一部分。
5、线程的创建。
创建线程有两种方式：
A、继承java.lang.Thread类。
class ThreadTest extends Thread{
public void run() {
System.out.println ("someting run here！");
}
public void run(String s){
System.out.println ("string in run is " + s);
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
tt.start();
tt.run("it won't auto run!");
}
}
输出的结果比较有趣：
string in run is it won't auto run!
someting run here！
注意输出的顺序：好像与我们想象的顺序相反了！为什么呢？
一旦调用start()方法，必须给JVM点时间，让它配置进程。而在它配置完成之前，重载的run(String s)方法被调用了，结果反而先输出了“string in run is it won't auto run!”，这时tt线程完成了配置，输出了“someting run here！”。
这个结论是比较容易验证的：
修改上面的程序，在tt.start();后面加上语句for (int i = 0; i<10000; i++); 这样主线程开始执行运算量比较大的for循环了，只有执行完for循环才能运行后面的tt.run("it won't auto run!");语句。此时，tt线程和主线程并行执行了，已经有足够的时间完成线程的配置！因此先到一步！修改后的程序运行结果如下：
someting run here！
string in run is it won't auto run!
注意：这种输出结果的顺序是没有保障的！不要依赖这种结论！
没有参数的run()方法是自动被调用的，而带参数的run()是被重载的，必须显式调用。
这种方式的限制是：这种方式很简单，但不是个好的方案。如果继承了Thread类，那么就不能继承其他的类了，java是单继承结构的，应该把继承的机会留给别的类。除非因为你有线程特有的更多的操作。
Thread类中有许多管理线程的方法，包括创建、启动和暂停它们。所有的操作都是从run()方法开始，并且在run()方法内编写需要在独立线程内执行的代码。run()方法可以调用其他方法，但是执行的线程总是通过调用run()。
B、实现java.lang.Runnable接口。
class ThreadTest implements Runnable {
public void run() {
System.out.println ("someting run here");
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.start();
t2.start();
//new Thread(tt).start();
}
}
比第一种方法复杂一点，为了使代码被独立的线程运行，还需要一个Thread对象。这样就把线程相关的代码和线程要执行的代码分离开来。
另一种方式是：参数形式的匿名内部类创建方式，也是比较常见的。
class ThreadTest{
public static void main (String[] args) {
Thread t = new Thread(new Runnable(){
public void run(){
System.out.println ("anonymous thread");
}
});
t.start();
}
}
如果你对此方式的声明不感冒，请参看本人总结的内部类。
第一种方式使用无参构造函数创建线程，则当线程开始工作时，它将调用自己的run()方法。
第二种方式使用带参数的构造函数创建线程，因为你要告诉这个新线程使用你的run()方法，而不是它自己的。
如上例，可以把一个目标赋给多个线程，这意味着几个执行线程将运行完全相同的作业。
6、什么时候线程是活的？
在调用start()方法开始执行线程之前，线程的状态还不是活的。测试程序如下：
class ThreadTest implements Runnable {
public void run() {
System.out.println ("someting run here");
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
Thread t1 = new Thread(tt);
System.out.println (t1.isAlive());
t1.start();
System.out.println (t1.isAlive());
}
}
结果输出：
false
true
isAlive方法是确定一个线程是否已经启动，而且还没完成run()方法内代码的最好方法。
7、启动新线程。
线程的启动要调用start()方法，只有这样才能创建新的调用栈。而直接调用run()方法的话，就不会创建新的调用栈，也就不会创建新的线程，run()方法就与普通的方法没什么两样了！
8、给线程起个有意义的名字。
没有该线程命名的话，线程会有一个默认的名字，格式是：“Thread-”加上线程的序号，如：Thread-0
这看起来可读性不好，不能从名字分辨出该线程具有什么功能。下面是给线程命名的方式。
第一种：用setName()函数
第二种：选用带线程命名的构造器
class ThreadTest implements Runnable{
public void run(){
System.out.println (Thread.currentThread().getName());
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
//Thread t = new Thread (tt,"eat apple");
Thread t = new Thread (tt);
t.setName("eat apple");
t.start();
}
}
9、“没有保障”的多线程的运行。下面的代码可能令人印象深刻。
class ThreadTest implements Runnable{
public void run(){
System.out.println (Thread.currentThread().getName());
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
Thread[] ts =new Thread[10];
for (int i =0; i < ts.length; i++)
ts[i] = new Thread(tt);
for (Thread t : ts)
t.start();
}
}
在我的电脑上运行的结果是：
Thread-0
Thread-1
Thread-3
Thread-5
Thread-2
Thread-7
Thread-4
Thread-9
Thread-6
Thread-8
而且每次运行的结果都是不同的！继续引用前面的话，一旦涉及到线程，其运行多半是没有保障。这个保障是指线程的运行完全是由调度程序控制的，我们没法控制它的执行顺序，持续时间也没有保障，有着不可预料的结果。
10、线程的状态。
A、新状态。
实例化Thread对象，但没有调用start()方法时的状态。
ThreadTest tt = new ThreadTest();
或者Thread t = new Thread (tt);
此时虽然创建了Thread对象，如前所述，但是它们不是活的，不能通过isAlive()测试。
B、就绪状态。
线程有资格运行，但调度程序还没有把它选为运行线程所处的状态。也就是具备了运行的条件，一旦被选中马上就能运行。
也是调用start()方法后但没运行的状态。此时虽然没在运行，但是被认为是活的，能通过isAlive()测试。而且在线程运行之后、或者被阻塞、等待或者睡眠状态回来之后，线程首先进入就绪状态。
C、运行状态。
从就绪状态池（注意不是队列，是池）中选择一个为当前执行进程时，该线程所处的状态。
D、等待、阻塞、睡眠状态。
这三种状态有一个共同点：线程依然是活的，但是缺少运行的条件，一旦具备了条就就可以转为就绪状态（不能直接转为运行状态）。另外，suspend()和stop()方法已经被废弃了，比较危险，不要再用了。
E、死亡状态。
一个线程的run()方法运行结束，那么该线程完成其历史使命，它的栈结构将解散，也就是死亡了。但是它仍然是一个Thread对象，我们仍可以引用它，就像其他对象一样！它也不会被垃圾回收器回收了，因为对该对象的引用仍然存在。
如此说来，即使run()方法运行结束线程也没有死啊！事实是，一旦线程死去，它就永远不能重新启动了，也就是说，不能再用start()方法让它运行起来！如果强来的话会抛出IllegalThreadStateException异常。如：
t.start();
t.start();
放弃吧，人工呼吸或者心脏起搏器都无济于事……线程也属于一次性用品。
11、阻止线程运行。
A、睡眠。sleep()方法
让线程睡眠的理由很多，比如：认为该线程运行得太快，需要减缓一下，以便和其他线程协调；查询当时的股票价格，每睡5分钟查询一次，可以节省带宽，而且即时性要求也不那么高。
用Thread的静态方法可以实现Thread.sleep(5*60*1000); 睡上5分钟吧。sleep的参数是毫秒。但是要注意sleep()方法会抛出检查异常InterruptedException，对于检查异常，我们要么声明，要么使用处理程序。
try {
Thread.sleep(20000);
}
catch (InterruptedException ie) {
ie.printStackTrace();
}
既然有了sleep()方法，我们是不是可以控制线程的执行顺序了！每个线程执行完毕都睡上一觉？这样就能控制线程的运行顺序了，下面是书上的一个例子：
class ThreadTest implements Runnable{
public void run(){
for (int i = 1; i<4; i++){
System.out.println (Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException ie) { }
}
}
public static void main (String[] args) {
ThreadTest tt = new ThreadTest();
Thread t0 = new Thread(tt,"Thread 0");
Thread t1 = new Thread(tt,"Thread 1");
Thread t2 = new Thread(tt,"Thread 2");
t0.start();
t1.start();
t2.start();
}
}
并且给出了结果：
Thread 0
Thread 1
Thread 2
Thread 0
Thread 1
Thread 2
Thread 0
Thread 1
Thread 2
也就是Thread 0 Thread 1 Thread 2 按照这个顺序交替出现，作者指出虽然结果和我们预料的似乎相同，但是这个结果是不可靠的。果然被我的双核电脑验证了：
Thread 0
Thread 1
Thread 2
Thread 2
Thread 0
Thread 1
Thread 1
Thread 0
Thread 2
看来线程真的很不可靠啊。但是尽管如此，sleep()方法仍然是保证所有线程都有运行机会的最好方法。至少它保证了一个线程进入运行之后不会一直到运行完位置。
时间的精确性。再强调一下，线程醒来之后不会进入运行状态，而是进入就绪状态。因此sleep()中指定的时间不是线程不运行的精确时间！不能依赖sleep()方法提供十分精确的定时。我们可以看到很多应用程序用sleep()作为定时器，而且没什么不好的，确实如此，但是我们一定要知道sleep()不能保证线程醒来就能马上进入运行状态，是不精确的。
sleep()方法是一个静态的方法，它所指的是当前正在执行的线程休眠一个毫秒数。看到某些书上的Thread.currentThread().sleep(1000); ，其实是不必要的。Thread.sleep(1000);就可以了。类似于getName()方法不是静态方法，它必须针对具体某个线程对象，这时用取得当前线程的方法Thread.currentThread().getName();
B、线程优先级和让步。
线程的优先级。在大多数jvm实现中调度程序使用基于线程优先级的抢先调度机制。如果一个线程进入可运行状态，并且它比池中的任何其他线程和当前运行的进程的具有更高的优先级，则优先级较低的线程进入可运行状态，最高优先级的线程被选择去执行。
于是就有了这样的结论：当前运行线程的优先级通常不会比池中任何线程的优先级低。但是并不是所有的jvm的调度都这样，因此一定不能依赖于线程优先级来保证程序的正确操作，这仍然是没有保障的，要把线程优先级用作一种提高程序效率的方法，并且这种方法也不能依赖优先级的操作。
另外一个没有保障的操作是：当前运行的线程与池中的线程，或者池中的线程具有相同的优先级时，JVM的调度实现会选择它喜欢的线程。也许是选择一个去运行，直至其完成；或者用分配时间片的方式，为每个线程提供均等的机会。
优先级用正整数设置，通常为1-10，JVM从不会改变一个线程的优先级。默认情况下，优先级是5。Thread类具有三个定义线程优先级范围的静态最终常量：Thread.MIN_PRIORITY （为1） Thread.NORM_PRIORITY （为5） Thread.MAX_PRIORITY （为10）
静态Thread.yield()方法。
它的作用是让当前运行的线程回到可运行状态，以便让具有同等优先级的其他线程运行。用yield()方法的目的是让同等优先级的线程能适当地轮转。但是，并不能保证达到此效果！因为，即使当前变成可运行状态，可是还有可能再次被JVM选中！也就是连任。
非静态join()方法。
让一个线程加入到另一个线程的尾部。让B线程加入A线程，意味着在A线程运行完成之前，B线程不会进入可运行状态。
Thread t = new Thread();
t.start();
t.join;
这段代码的意思是取得当前的线程，把它加入到t线程的尾部，等t线程运行完毕之后，原线程继续运行。书中的例子在我的电脑里效果很糟糕，看不出什么效果来。也许是CPU太快了，而且是双核的；也许是JDK1.6的原因？
12、没总结完。线程这部分很重要，内容也很多，看太快容易消化不良，偶要慢慢地消化掉……
附： java原著中对线程的解释。
e文原文：
Thread Scheduling
In Java technology,threads are usually preemptive,but not necessarily Time-sliced(the process of giving each thread an equal amount of CPU time).It is common mistake to believe that "preemptive" is a fancy word for "does time-slicing".
For the runtime on a Solaris Operating Environment platform,Java technology does not preempt threads of the same priority.However,the runtime on Microsoft Windows platforms uses time-slicing,so it preempts threads of the same priority and even threads of higher priority.Preemption is not guaranteed;however,most JVM implementations result in behavior that appears to be strictly preemptive.Across JVM implementations,there is no absolute guarantee of preemption or time-slicing.The only guarantees lie in the coder’s use of wait and sleep.
The model of a preemptive scheduler is that many threads might be runnable,but only one thread is actually running.This thread continues to run until it ceases to be runnable or another thread of higher priority becomes runnable.In the latter case,the lower priority thread is preempted by the thread of higher priority,which gets a chance to run instead.
A thread might cease to runnable (that is,because blocked) for a variety of reasons.The thread’s code can execute a Thread.sleep() call,deliberately asking the thread to pause for a fixed period of time.The thread might have to wait to access a resource and cannot continue until that resource become available.
All thread that are runnable are kept in pools according to priority.When a blocked thread becomes runnable,it is placed back into the appropriate runnable pool.Threads from the highest priority nonempty pool are given CPU time.
The last sentence is worded loosed because:
(1) In most JVM implementations,priorities seem to work in a preemptive manner,although there is no guarantee that priorities have any meaning at all;
(2) Microsoft Window’s values affect thread behavior so that it is possible that a Java Priority 4 thread might be running,in spite of the fact that a runnable Java Priority 5 thread is waiting for the CPU.
In reality,many JVMs implement pool as queues,but this is not guaranteed hehavior.
热心网友翻译的版本：
在java技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的cpu时间的进程）。一个经常犯的错误是认为“抢占”就是“分配时间片”。
在Solaris平台上的运行环境中，相同优先级的线程不能相互抢占对方的cpu时间。但是，在使用时间片的windows平台运行环境中，可以抢占相同甚至更高优先级的线程的cpu时间。抢占并不是绝对的，可是大多数的JVM的实现结果在行为上表现出了严格的抢占。纵观JVM的实现，并没有绝对的抢占或是时间片，而是依赖于编码者对wait和sleep这两个方法的使用。
抢占式调度模型就是许多线程属于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态）或是另一个具有更高优先级的线程变成可运行状态。在后一种情况下，底优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。
线程可以因为各种各样的原因终止并进入可运行状态（因为堵塞）。例如，线程的代码可以在适当时候执行Thread.sleep()方法，故意让线程中止；线程可能为了访问资源而不得不等待直到该资源可用为止。
所有可运行的线程根据优先级保持在不同的池中。一旦被堵塞的线程进入可运行状态，它将会被放回适当的可运行池中。非空最高优先级的池中的线程将获得cpu时间。
最后一个句子是不精确的，因为：
（1）在大多数的JVM实现中，虽然不能保证说优先级有任何意义，但优先级看起来象是用抢占方式工作。
（2）微软windows的评价影响线程的行为，以至尽管一个处于可运行状态的优先级为5的java线程正在等待cpu时间，但是一个优先级为4的java线程却可能正在运行。
实际上，许多JVM用队列来实现池，但没有保证行为。
posted @
2008-11-21 18:01 xzc 阅读(189) |
评论 (0) |
编辑 收藏
- 摘要：本文通过java代码启动多个java子进程。必如在Java中通过Runtime中的exec方法执行java classname。如果执行成功，这个方法返回一个Process对象，如果执行失败，将抛出一个IOException错误。
- 标签：Java 多进程 模式 分析
-
一般我们在java中运行其它类中的方法时，无论是静态调用，还是动态调用，都是在当前的进程中执行的，也就是说，只有一个java虚拟机实例在运行。而有的时候，我们需要通过java代码启动多个java子进程。这样做虽然占用了一些系统资源，但会使程序更加稳定，因为新启动的程序是在不同的虚拟机进程中运行的，如果有一个进程发生异常，并不影响其它的子进程。
在Java中我们可以使用两种方法来实现这种要求。最简单的方法就是通过Runtime中的exec方法执行java classname。如果执行成功，这个方法返回一个Process对象，如果执行失败，将抛出一个IOException错误。下面让我们来看一个简单的例子。
// Test1.java文件
import java.io.*;
public class Test
{
public static void main(String[] args)
{
FileOutputStream fOut = new FileOutputStream("c:\\Test1.txt");
fOut.close();
System.out.println("被调用成功!");
}
}
// Test_Exec.java
public class Test_Exec
{
public static void main(String[] args)
{
Runtime run = Runtime.getRuntime();
Process p = run.exec("java test1");
}
}
|
通过java Test_Exec运行程序后，发现在C盘多了个Test1.txt文件，但在控制台中并未出现“被调用成功!”的输出信息。因此可以断定，Test已经被执行成功，但因为某种原因，Test的输出信息未在Test_Exec的控制台中输出。这个原因也很简单，因为使用exec建立的是Test_Exec的子进程，这个子进程并没有自己的控制台，因此，它并不会输出任何信息。
如果要输出子进程的输出信息，可以通过Process中的getInputStream得到子进程的输出流(在子进程中输出，在父进程中就是输入)，然后将子进程中的输出流从父进程的控制台输出。具体的实现代码如下如示：
// Test_Exec_Out.java
import java.io.*;
public class Test_Exec_Out
{
public static void main(String[] args)
{
Runtime run = Runtime.getRuntime();
Process p = run.exec("java test1");
BufferedInputStream in = new BufferedInputStream(p.getInputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String s;
while ((s = br.readLine()) != null)
System.out.println(s);
}
}
|
从上面的代码可以看出，在Test_Exec_Out.java中通过按行读取子进程的输出信息，然后在Test_Exec_Out中按每行进行输出。上面讨论的是如何得到子进程的输出信息。那么，除了输出信息，还有输入信息。既然子进程没有自己的控制台，那么输入信息也得由父进程提供。我们可以通过Process的getOutputStream方法来为子进程提供输入信息(即由父进程向子进程输入信息，而不是由控制台输入信息)。我们可以看看如下的代码：
// Test2.java文件
import java.io.*;
public class Test
{
public static void main(String[] args)
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("由父进程输入的信息：" + br.readLine());
}
}
// Test_Exec_In.java
import java.io.*;
public class Test_Exec_In
{
public static void main(String[] args)
{
Runtime run = Runtime.getRuntime();
Process p = run.exec("java test2");
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(p.getOutputStream()));
bw.write("向子进程输出信息");
bw.flush();
bw.close(); // 必须得关闭流，否则无法向子进程中输入信息
// System.in.read();
}
}
|
从以上代码可以看出，Test1得到由Test_Exec_In发过来的信息，并将其输出。当你不加bw.flash()和bw.close()时，信息将无法到达子进程，也就是说子进程进入阻塞状态，但由于父进程已经退出了，因此，子进程也跟着退出了。如果要证明这一点，可以在最后加上System.in.read()，然后通过任务管理器(在windows下)查看java进程，你会发现如果加上bw.flush()和bw.close()，只有一个java进程存在，如果去掉它们，就有两个java进程存在。这是因为，如果将信息传给Test2，在得到信息后，Test2就退出了。
在这里有一点需要说明一下，exec的执行是异步的，并不会因为执行的某个程序阻塞而停止执行下面的代码。因此，可以在运行test2后，仍可以执行下面的代码。
exec方法经过了多次的重载。上面使用的只是它的一种重载。它还可以将命令和参数分开，如exec(“java.test2”)可以写成exec(“java”, “test2”)。exec还可以通过指定的环境变量运行不同配置的java虚拟机。
除了使用Runtime的exec方法建立子进程外，还可以通过ProcessBuilder建立子进程。ProcessBuilder的使用方法如下：
// Test_Exec_Out.java
import java.io.*;
public class Test_Exec_Out
{
public static void main(String[] args)
{
ProcessBuilder pb = new ProcessBuilder("java", "test1");
Process p = pb.start();
… …
}
}
|
在建立子进程上，ProcessBuilder和Runtime类似，不同的ProcessBuilder使用start()方法启动子进程，而Runtime使用exec方法启动子进程。得到Process后，它们的操作就完全一样的。
ProcessBuilder和Runtime一样，也可设置可执行文件的环境信息、工作目录等。下面的例子描述了如何使用ProcessBuilder设置这些信息。
ProcessBuilder pb = new ProcessBuilder("Command", "arg2", "arg2", ''');
// 设置环境变量
Map<String, String> env = pb.environment();
env.put("key1", "value1");
env.remove("key2");
env.put("key2", env.get("key1") + "_test");
pb.directory("..\abcd"); // 设置工作目录
Process p = pb.start(); // 建立子进程
|
posted @
2008-11-17 19:56 xzc 阅读(670) |
评论 (3) |
编辑 收藏1.基本概念的理解
绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(URL和物理路径)例如：
C:xyz est.txt 代表了test.txt文件的绝对路径。http://www.sun.com/index.htm也代表了一个URL绝对路径。
相对路径：相对与某个基准目录的路径。包含Web的相对路径（HTML中的相对目录），例如：在
Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表示。例如："./" 代表当前目录,"../"代表上级目录。这种类似的表示，也是属于相对路径。
另外关于URI，URL,URN等内容，请参考RFC相关文档标准。
RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
(http://www.ietf.org/rfc/rfc2396.txt)
2.关于JSP/Servlet中的相对路径和绝对路径。
2.1服务器端的地址
服务器端的相对地址指的是相对于你的web应用的地址，这个地址是在服务器端解析的（不同于html和javascript中的相对地址，他们是由客户端浏览器解析的）也就是说这时候在jsp和servlet中的相对地址应该是相对于你的web应用，即相对于http: //192.168.0.1/webapp/的。
其用到的地方有：
forward：servlet中的request.getRequestDispatcher(address);这个address是在服务器端解析的，所以，你要forward到a.jsp应该这么写：request.getRequestDispatcher(“/user/a.jsp”)这个/ 相对于当前的web应用webapp，其绝对地址就是：http://192.168.0.1/webapp/user/a.jsp。 sendRedirect：在jsp中<%response.sendRedirect("/rtccp/user/a.jsp");%>
2.22、客户端的地址
所有的html页面中的相对地址都是相对于服务器根目录(http://192.168.0.1/)的，而不是(跟目录下的该Web应用的目录) http://192.168.0.1/webapp/的。 Html中的form表单的action属性的地址应该是相对于服务器根目录(http://192.168.0.1/)的，所以，如果提交到a.jsp 为：action＝"/webapp/user/a.jsp"或action="<%=request.getContextPath()% >"/user/a.jsp；
提交到servlet为actiom＝"/webapp/handleservlet" Javascript也是在客户端解析的，所以其相对路径和form表单一样。
因此，一般情况下，在JSP/HTML页面等引用的CSS,Javascript.Action等属性前面最好都加上
<%=request.getContextPath()%>,以确保所引用的文件都属于Web应用中的目录。另外，应该尽量避免使用类似".","./","../../"等类似的相对该文件位置的相对路径，这样当文件移动时，很容易出问题。
3. JSP/Servlet中获得当前应用的相对路径和绝对路径
3.1 JSP中获得当前应用的相对路径和绝对路径
根目录所对应的绝对路径:request.getRequestURI()
文件的绝对路径 :application.getRealPath(request.getRequestURI());
当前web应用的绝对路径 :application.getRealPath("/");
取得请求文件的上层目录:new File(application.getRealPath(request.getRequestURI())).getParent()
3.2 Servlet中获得当前应用的相对路径和绝对路径
根目录所对应的绝对路径:request.getServletPath();
文件的绝对路径 :request.getSession().getServletContext().getRealPath
(request.getRequestURI())
当前web应用的绝对路径 :servletConfig.getServletContext().getRealPath("/");
(ServletContext对象获得几种方式：
javax.servlet.http.HttpSession.getServletContext()
javax.servlet.jsp.PageContext.getServletContext()
javax.servlet.ServletConfig.getServletContext()
)
4.java 的Class中获得相对路径，绝对路径的方法
4.1单独的Java类中获得绝对路径
根据java.io.File的Doc文挡，可知:
默认情况下new File("/")代表的目录为：System.getProperty("user.dir")。
一下程序获得执行类的当前路径
- package org.cheng.file;
-
- import java.io.File;
-
- public class FileTest {
- public static void main(String[] args) throws Exception {
- System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));
-
- System.out.println(FileTest.class.getClassLoader().getResource(""));
-
- System.out.println(ClassLoader.getSystemResource(""));
- System.out.println(FileTest.class.getResource(""));
- System.out.println(FileTest.class.getResource("/"));
- Class
- System.out.println(new File("/").getAbsolutePath());
- System.out.println(System.getProperty("user.dir"));
- }
- }
4.2服务器中的Java类获得当前路径（来自网络）
(1).Weblogic
WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:eaweblogic700.....
那么，你的文件根路径就是c:.
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:yourconfigyourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放
在yourwebappyourconfigyourconf.properties，
这样使用：
new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。
(2).Tomcat
在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin
(3).Resin
不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下
(4).如何读相对路径哪？
在Java文件中getResource或getResourceAsStream均可
例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web
发布根路径下WEB-INF/classes
默认使用该方法的路径是：WEB-INF/classes。已经在Tomcat中测试。
5.读取文件时的相对路径，避免硬编码和绝对路径的使用。（来自网络）
5.1 采用Spring的DI机制获得文件，避免硬编码。
参考下面的连接内容：
http://www.javajia.net/viewtopic.php?p=90213&
5.2 配置文件的读取
参考下面的连接内容：
http://dev.csdn.net/develop/article/39/39681.shtm
5.3 通过虚拟路径或相对路径读取一个xml文件，避免硬编码
参考下面的连接内容：
http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8
6.Java中文件的常用操作（复制，移动，删除，创建等）（来自网络）
常用 java File 操作类
http://www.easydone.cn/014/200604022353065155.htm
Java文件操作大全（JSP中）
http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html
java文件操作详解（Java中文网）
http://www.51cto.com/html/2005/1108/10947.htm
JAVA 如何创建删除修改复制目录及文件
http://www.gamvan.com/developer/java/2005/2/264.html
总结：
通过上面内容的使用，可以解决在Web应用服务器端，移动文件，查找文件，复制
删除文件等操作，同时对服务器的相对地址，绝对地址概念更加清晰。
建议参考URI,的RFC标准文挡。同时对Java.io.File. Java.net.URI.等内容了解透彻
对其他方面的理解可以更加深入和透彻。
posted @
2008-11-11 11:54 xzc 阅读(631) |
评论 (0) |
编辑 收藏
<%@ page contentType="text/html;charset=GBK"%>
<%@ page import="java.io.*" %>
<%
// 得到文件名字和路径
String filename = request.getParameter("filename");
String filepath = request.getSession().getServletContext().getgetRealPath("/download/excel/");
//String filepath = request.getRealPath("/download/excel/");
//读到流中
InputStream inputStream = new FileInputStream(filepath+"/"+filename);
//设置输出的格式
response.reset();
response.setContentType("bin");
response.addHeader("Content-Disposition","attachment;filename=\"" + filename + "\"");
//循环取出流中的数据
byte[] bytes = new byte[1000];
int len = inputStream.read(bytes);
while (len > 0){
response.getOutputStream().write(bytes,0,len);
len = inputStream.read(bytes);
}
inputStream.close();
%>
posted @
2008-11-03 17:58 xzc 阅读(369) |
评论 (0) |
编辑 收藏
摘要: Dom4j的使用(全而好的文章)
关键字: dom4j
Dom4j 使用简介
作者：冰云 icecloud(AT)sina.com
时间：2003.12.15
版权声明：
本文由冰云完成，首发于CSDN，未经许可，不得使用于任何...
阅读全文
posted @
2008-10-31 11:33 xzc 阅读(418) |
评论 (0) |
编辑 收藏
最近不少Web技术圈内的朋友在讨论协议方面的事情，有的说web开发者应该熟悉web相关的协议，有的则说不用很了解。个人认为这要分层次来看待这个问题，对于一个新手或者刚入门的web开发人员而言，研究协议方面的东西可能会使得web开发失去趣味性、抹煞学习积极性，这类人应该更多的了解基本的Web技术使用。而对于在该行业工作多年的老鸟来说，协议相关的内容、标准相关内容应该尽量多些的了解，因为只有这样才能使得经手的web系统更加优秀（安全、漂亮、快速、兼容性好、体验好……）。本文我们来说一下MIME 协议的一个扩展Content-disposition。
我们在开发web系统时有时会有以下需求：
- 希望某类或者某已知MIME 类型的文件（比如：*.gif;*.txt;*.htm）能够在访问时弹出“文件下载”对话框
- 希望以原始文件名（上传时的文件名,例如：山东省政府1024号文件.doc）提供下载，但服务器上保存的地址却是其他文件名（如：12519810948091234_asdf.doc)
- 希望某文件直接在浏览器上显示而不是弹出文件下载对话框
- ……………………
要解决上述需求就可以使用Content-disposition来解决。第一个需求的解决办法是
Response.AddHeader "content-disposition","attachment; filename=fname.ext"
将上述需求进行归我给出如下例子代码：
public static void ToDownload(string serverfilpath,string filename)
{
FileStream fileStream = new FileStream(serverfilpath, FileMode.Open);
long fileSize = fileStream.Length;
HttpContext.Current.Response.ContentType = "application/octet-stream";
HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + UTF_FileName(filename) + "\";");
////attachment --- 作为附件下载
////inline --- 在线打开
HttpContext.Current.Response.AddHeader("Content-Length", fileSize.ToString());
byte[] fileBuffer = new byte[fileSize];
fileStream.Read(fileBuffer, 0, (int)fileSize);
HttpContext.Current.Response.BinaryWrite(fileBuffer);
fileStream.Close();
HttpContext.Current.Response.End();
}
public static void ToOpen(string serverfilpath, string filename)
{
FileStream fileStream = new FileStream(serverfilpath, FileMode.Open);
long fileSize = fileStream.Length;
HttpContext.Current.Response.ContentType = "application/octet-stream";
HttpContext.Current.Response.AddHeader("Content-Disposition", "inline; filename=\"" + UTF_FileName(filename) + "\";");
HttpContext.Current.Response.AddHeader("Content-Length", fileSize.ToString());
byte[] fileBuffer = new byte[fileSize];
fileStream.Read(fileBuffer, 0, (int)fileSize);
HttpContext.Current.Response.BinaryWrite(fileBuffer);
fileStream.Close();
HttpContext.Current.Response.End();
}
private static string UTF_FileName(string filename)
{
return HttpUtility.UrlEncode(filename, System.Text.Encoding.UTF8);
}
简单的对上述代码做一下解析，ToDownload方法为将一个服务器上的文件（serverfilpath为服务器上的物理地址），以某文件名(filename)在浏览器上弹出“文件下载”对话框，而ToOpen是将服务器上的某文件以某文件名在浏览器中显示/打开的。注意其中我使用了UTF_FileName方法，该方法很简单，主要为了解决包含非英文/数字名称的问题，比如说文件名为“衣明志.doc”，使用该方法客户端就不会出现乱码了。
需要注意以下几个问题：
- Content-disposition是MIME协议的扩展，由于多方面的安全性考虑没有被标准化，所以可能某些浏览器不支持，比如说IE4.01
- 我们可以使用程序来使用它，也可以在web服务器（比如IIS）上使用它，只需要在http header上做相应的设置即可
可参看以下几篇文档：
posted @
2008-10-30 16:07 xzc 阅读(353) |
评论 (0) |
编辑 收藏
摘要:
/**
* 取得字符串的字节长度
*/
代码
function strlen(str)
{
var i;
var&...
阅读全文
posted @
2008-09-03 15:01 xzc 阅读(333) |
评论 (1) |
编辑 收藏
在程序中，文本文件经常用来存储标准的ASCII码文本，比如英文、加减乘除等号这些运算符号。文本文件也可能用于存储一些其他非ASCII字符，如基于GBK的简体中文，基于GIG5的繁体中文等等。在存储这些字符时需要正确指定文件的编码格式；而在读取这些文本文件时，有时候就需要自动判定文件的编码格式。
按照给定的字符集存储文本文件时，在文件的最开头的三个字节中就有可能存储着编码信息，所以，基本的原理就是只要读出文件前三个字节，判定这些字节的值，就可以得知其编码的格式。其实，如果项目运行的平台就是中文操作系统，如果这些文本文件在项目内产生，即开发人员可以控制文本的编码格式，只要判定两种常见的编码就可以了：GBK和UTF-8。由于中文Windows默认的编码是GBK，所以一般只要判定UTF-8编码格式。
对于UTF-8编码格式的文本文件，其前3个字节的值就是-17、-69、-65，所以，判定是否是UTF-8编码格式的代码片段如下：
- java.io.File f=new java.io.File("待判定的文本文件名");
- try{
- java.io.InputStream ios=new java.io.FileInputStream(f);
- byte[] b=new byte[3];
- ios.read(b);
- ios.close();
- if(b[0]==-17&&b[1]==-69&&b[2]==-65)
- System.out.println(f.getName()+"编码为UTF-8");
- else System.out.println(f.getName()+"可能是GBK");
- }catch(Exception e){
- e.printStackTrace();
- }
java.io.File f=new java.io.File("待判定的文本文件名");
try{
java.io.InputStream ios=new java.io.FileInputStream(f);
byte[] b=new byte[3];
ios.read(b);
ios.close();
if(b[0]==-17&&b[1]==-69&&b[2]==-65)
System.out.println(f.getName()+"编码为UTF-8");
else System.out.println(f.getName()+"可能是GBK");
}catch(Exception e){
e.printStackTrace();
}
上述代码只是简单判定了是否是UTF-8格式编码的文本文件，如果项目对要判定的
文本文件编码不可控（比如用户上传的一些HTML、XML等文本），可以采用一个现成的开源项目：cpdetector，它所在的网址是：
http://cpdetector.sourceforge.net/。它的类库很小，只有500K左右，利用该类库判定文本文件的代码如下：
-
-
-
-
-
-
-
- cpdetector.io.CodepageDetectorProxy detector =
- cpdetector.io.CodepageDetectorProxy.getInstance();
-
-
-
-
- detector.add(new cpdetector.io.ParsingDetector(false));
-
-
-
-
-
- detector.add(cpdetector.io.JChardetFacade.getInstance());
-
- detector.add(cpdetector.io.ASCIIDetector.getInstance());
-
- detector.add(cpdetector.io.UnicodeDetector.getInstance());
- java.nio.charset.Charset charset = null;
- File f=new File("待测的文本文件名");
- try {
- charset = detector.detectCodepage(f.toURL());
- } catch (Exception ex) {ex.printStackTrace();}
- if(charset!=null){
- System.out.println(f.getName()+"编码是："+charset.name());
- }else
- System.out.println(f.getName()+"未知");
/*------------------------------------------------------------------------
detector是探测器，它把探测任务交给具体的探测实现类的实例完成。
cpDetector内置了一些常用的探测实现类，这些探测实现类的实例可以通过add方法
加进来，如ParsingDetector、 JChardetFacade、ASCIIDetector、UnicodeDetector。
detector按照“谁最先返回非空的探测结果，就以该结果为准”的原则返回探测到的
字符集编码。
--------------------------------------------------------------------------*/
cpdetector.io.CodepageDetectorProxy detector =
cpdetector.io.CodepageDetectorProxy.getInstance();
/*-------------------------------------------------------------------------
ParsingDetector可用于检查HTML、XML等文件或字符流的编码,构造方法中的参数用于
指示是否显示探测过程的详细信息，为false不显示。
---------------------------------------------------------------------------*/
detector.add(new cpdetector.io.ParsingDetector(false));
/*--------------------------------------------------------------------------
JChardetFacade封装了由Mozilla组织提供的JChardet，它可以完成大多数文件的编码
测定。所以，一般有了这个探测器就可满足大多数项目的要求，如果你还不放心，可以
再多加几个探测器，比如下面的ASCIIDetector、UnicodeDetector等。
---------------------------------------------------------------------------*/
detector.add(cpdetector.io.JChardetFacade.getInstance());
//ASCIIDetector用于ASCII编码测定
detector.add(cpdetector.io.ASCIIDetector.getInstance());
//UnicodeDetector用于Unicode家族编码的测定
detector.add(cpdetector.io.UnicodeDetector.getInstance());
java.nio.charset.Charset charset = null;
File f=new File("待测的文本文件名");
try {
charset = detector.detectCodepage(f.toURL());
} catch (Exception ex) {ex.printStackTrace();}
if(charset!=null){
System.out.println(f.getName()+"编码是："+charset.name());
}else
System.out.println(f.getName()+"未知");
上面代码中的detector不仅可以用于探测文件的编码，也可以探测任意输入的文本流的编码，方法是调用其重载形式：
- charset=detector.detectCodepage(待测的文本输入流,测量该流所需的读入字节数);
charset=detector.detectCodepage(待测的文本输入流,测量该流所需的读入字节数);
上面的字节数由程序员指定，字节数越多，判定越准确，当然时间也花得越长。要注意，字节数的指定不能超过文本流的最大长度。
判定文件编码的具体应用举例：
属性文件(.properties)是Java程序中的常用文本存储方式，象STRUTS框架就是利用属性文件存储程序中的字符串资源。它的内容如下所示：
#注释语句
属性名=属性值
读入属性文件的一般方法是：
- FileInputStream ios=new FileInputStream("属性文件名");
- Properties prop=new Properties();
- prop.load(ios);
- ios.close();
FileInputStream ios=new FileInputStream("属性文件名");
Properties prop=new Properties();
prop.load(ios);
ios.close();
利用java.io.Properties的load方法读入属性文件虽然方便，但如果属性文件中有中文，在读入之后就会发现出现乱码现象。发生这个原因是load方法使用字节流读入文本，在读入后需要将字节流编码成为字符串，而它使用的编码是“iso-8859-1”,这个字符集是ASCII码字符集，不支持中文编码，所以这时需要使用显式的转码:
- String value=prop.getProperty("属性名");
- String encValue=new String(value.getBytes("iso-8859-1"),"属性文件的实际编码");
String value=prop.getProperty("属性名");
String encValue=new String(value.getBytes("iso-8859-1"),"属性文件的实际编码");
在上面的代码中，属性文件的实际编码就可以利用上面的方法获得。当然，象这种属性文件是项目内部的，我们可以控制属性文件的编码格式，比如约定采用Windows内定的GBK，就直接利用"gbk"来转码，如果约定采用UTF-8，也可以是使用"UTF-8"直接转码。如果想灵活一些，做到自动探测编码，就可利用上面介绍的方法测定属性文件的编码，从而方便开发人员的工作。
posted @
2008-06-16 14:44 xzc 阅读(806) |
评论 (1) |
编辑 收藏第一章 目录及文件操作命令
1.1 ls
[语法]： ls [-RadCxmlnogrtucpFbqisf1] [目录或文件......]
[说明]： ls 命令列出指定目录下的文件，缺省目录为当前目录 ./，缺省输出顺序为纵向按字符顺序排列。
-R 递归地列出每个子目录的内容
-a 列出所有文件，包括第一个字符为“.”的隐藏文件
-d 若后面参数是目录，则只列出目录名而不列出目录内容，常与-l选项连
用以显示目录状态。
-C 输出时多列显示
-x 横向按字符顺序排列
-m 输出按流式格式横向排列，文件名之间用逗号(，)分隔
-l 长列表输出，显示文件详细信息，每行一个文件，从左至右依次是：
文件存取模式 链接数 文件主 文件组 文件字节数 上次修改时间
其中文件存取模式用10个字母表示，从左至右的意义如下：
第一个字母表示文件种类，可以是以下几种情况：
d 为目录文件
l 为链接
b 为块文件
c 为字符型文件
p 为命名管道（FIFO)
- 为普通文件
后面9个字母分别表示文件主、同组用户、其他用户对文件的权力，用r表示可读，w 表示可写，x 表示可执行。如果是设备文件，则在文件字节数处显示：主设备 从设备。
-n 与-l选项相同，只是文件主用数字(即UID)显示，文件组用数字
(即GID)表示
-o 与-l选项相同，只是不显示文件组
-g 与-l选项相同，只是不显示文件主
-r 逆序排列
-t 按时间顺序排列而非按名字
-u 显示时间时使用上次访问时间而非上次修改时间
-c 显示时间时使用上次修改i节点时间而非上次修改时间
-p 若所列文件是目录文件，则在其后显示斜杠(/)
-F 在目录文件后加’/’，在可执行文件后加’*’
-b 文件名中若有非打印字符，则用八进制显示该字符
-q 文件名中的打印字符用’?’表示
-i 显示节点号
-s 显示文件长度时使用块长度而非字节长度
-f 将后面的参数解释为目录并列出其中的每一项
-1 每行仅列一项
[例子]:
ls 列出当前目录下的文件
ls -al /bin 以长列表的形式列出目录 /bin 下的所有文件，包括隐藏文件
1.2 pwd
[语法]: pwd
[说明]： 本命令用于显示当前的工作目录
[例子]:
pwd 显示出当前的工作目录
1.3 cd
[语法]: cd [目录]
[说明]：本命令用于改变当前的工作目录，无参数时使用环境变量$HOME 作为其参数，$HOME 一般为注册时进入的路径。
[例子]：
cd 回到注册进入时的目录
cd /tmp 进入 /tmp 目录
cd ../ 进入上级目录
1.4 mkdir
[语法]: mkdir [-m 模式] [-p] 目录名
[说明]: 本命令用于建立目录，目录的存取模式由掩码（umask)决定，要求对其父目录具有写权限，目录的UID和GID为实际UID和GID
-m 按指定存取模式建立目录
-p 建立目录时建立其所有不存在的父目录
[例子]:
mkdir tmp 在当前目录下建立子目录 tmp
mkdir -m 777 /tmp/abc 用所有用户可读可写可执行的存取模式
建立目录 /tmp/aaa ，存取模式参看命令 chmod
mkdir -p /tmp/a/b/c 建立目录 /tmp/a/b/c ，若不存在目录 /tmp/a
及/tmp/a/b 则建立之
1.5 rmdir
[语法]: rmdir [-p] [-s] 目录名
[说明]: 本命令用于删除目录
-p 删除所有已经为空的父目录
-s 当使用-p 选项时，出现错误不提示
[例子]:
rmdir /tmp/abc 删除目录 /tmp/abc
rmdir -p /tmp/a/b/c 删除目录 /tmp/a/b/c ，若目录 /tmp/a /b
及/tmp/a 空，则删除
1.6 cat
[语法]: cat [-u] [-s] [-v[-t] [-e]] 文件...
[说明]: 显示和连接一个或多个文件至标准输出
-u 无缓冲的输出(缺省为有缓冲输出)
-s 对不存在的文件不作提示
-v 显示出文件中的非打印字符，控制字符显示成^n ，n为八进制数字，
其他非打印字符显示成M-x ， x 为该字符低7位的8进制数值
-t 在使用-v 选项时，将制表符（tab） 显示成 ^I，将换页符
（formfeed）显示成 ^ L
-e 在使用-v 选项时，在每一行的行尾显示 $
[例子]:
cat file 显示文件
cat -s -v -e file1 file2 file3 逐个显示文件 file1 file2 file3
1.7 head
[语法]: head [-n] [文件 ...]
[说明]: 将文件的头n 行显示输出,缺省值为 10 行，显示多个文件时，在每个文件的前面加上 ==> 文件名 <==
[例子]：
head -9999 file1 file2 显示文件 file1 和 file2 的头 9999 行
1.8 more
[语法]: more [-cdflrsuw] [－ 行数] [+ 行数] [+ / 模式 ] [ 文件 ... ]
[说明]: 将文件显示在终端上，每次一屏，在左下部显示 －－more－－，若是从文件读出而非从管道，则在后面显示百分比，表示已显示的部分，按回车键则上滚一行，按空格键则上滚一屏，未显示完时可以使用more 命令中的子命令。
-c 显示文件之前先清屏
-d 当输错命令时显示错误信息而不是响铃(bell)
-f 不折叠显示长的行
-l 不将分页控制符(CTRL D)当作页结束
-r 一般情况下，more 不显示控制符，本选项使more 显示控制符，
例如，将 (CTRL C) 显示成 ^ C
-s 将多个空行转换成一个空行显示
-u 禁止产生下划线序列
-w 一般情况下 more 显示完后立即推出，本选项在显示完后作提
示，敲任意键后推出
-n 行数 指定每屏显示的行数
+ 行号 从指定行号开始显示
+/模式 在文件中搜索指定模式，从模式出现行的上两行开始显示 文件未显示完时，可以使用more 命令中的子命令，命令中除了! 和 / 以外均不回显，也不用敲回车，当命令破坏 more 提示行时，可用退格键恢复提示行。在以下子命令操作中，i 表示数字，缺省值为 1。
i 空格 上滚一屏多 i 行
i 回车 上滚 i 行
i CTRL+D i 缺省时上滚 11 行，否则上滚 i 行
id i 缺省时上滚 11 行，否则上滚 i 行
iz i 缺省时上滚一屏，否则定义每屏为 i 行
is 跳过 i 行后显示一屏
if 跳过 i 屏后显示一屏
i CTRL+B 跳回 i 屏后显示一屏
b 跳回 一屏后显示一屏
q 或 Q 推出 more
= 显示当前行号
v 从当前行开始编辑当前文件编辑器由环境变量
$EDITOR定义
h 显示帮助信息
i / 模式 向前搜索，直至模式的第 i 次出现 ， 从该行的上 两行开始显示一屏
in 向前搜索，直至上一模式的第 i 次出现 ， 从该行 的上两行开始显示一屏
单引号 回到上次搜索的出发点，若无搜索则回到开始位置
! 命令 激活一个sh 去执行指定的命令
i ： n 跳到后面第 i 个文件，若不存在则跳到最后一个文件
：f 显示当前文件名和行号
：q 或 ：Q 推出 more
. (点) 重复上次命令
[ 例子]:
more -c +50 file 清屏后，从第50行开始显示文件 file
more -s -w file1 file2 file3 显示文件 file1 file2 file3
1.9 cp
[语法]: cp [ -p ] [ -r ] 文件 1 [ 文件 2 ...] 目标
[说明]: 将文件1(文件2 ...)拷贝到目标上，目标不能与文件同名， 若目标是文件名，则拷贝的文件只能有一个，若目标是目录， 则拷贝的文件可以有多个，若目标文件不存在，则建立这个文件，若存在，则覆盖其以前的内容，若目标是目录，则将文件拷贝到这个目录下。
- i 在覆盖已存在文件时作提示，若回答 y 则覆盖，其他则中止
- p 不仅拷贝文件内容，还有修改时间，存取模式，存取控制表， 但不拷贝
UID 及 GID
- r 若文件名为目录，则拷贝目录下所有文件及子目录和它们的文件，此时
目标必须为目录
[例子]:
cp file1 file2 将文件 file1 拷贝到文件 file2
cp file1 file2 /tmp 将文件 file1 和文件 file2 拷贝到目录 /tmp 下
cp -r /tmp /mytmp 将目录 /tmp 下所有文件及其子目录拷贝至目录/mytmp
1.10 mv
[语法]: mv [-f] [-i] 文件1 [文件2...] 目标
[说明]: 将文件移动至目标，若目标是文件名，则相当于文件改名
- i 在覆盖已存在文件时作提示，若回答 y 则覆盖，其他则中止
- f 覆盖前不作任何提示
[例子]:
mv file1 file2 将文件 file1 改名为 file2
mv file1 file2 /tmp 将文件 file1 和文件 file2 移动到目录 /tmp 下
1.11 rm
[语法]: rm [-f] [-i] 文件...
或 rm -r [-f] [-i] 目录名... [文件]
[说明]: 用来删除文件或目录
- f 删除文件时不作提示
- r 递归地删除目录及其所有子目录
- i 删除文件之前先作提示
[例子]:
rm file1 删除文件 file1
rm -i /tmp/* 删除目录 /tmp 下的所有文件
rm -r /mytmp 递归地删除目录 /mytmp
1.12 chmod
[语法]: chmod [-R] 模式 文件...
或 chmod [ugoa] {+|-|=} [rwxst] 文件...
[说明]: 改变文件的存取模式，存取模式可表示为数字或符号串，例如：
chmod nnnn file ， n为0-7的数字，意义如下:
4000 运行时可改变UID
2000 运行时可改变GID
1000 置粘着位
0400 文件主可读
0200 文件主可写
0100 文件主可执行
0040 同组用户可读
0020 同组用户可写
0010 同组用户可执行
0004 其他用户可读
0002 其他用户可写
0001 其他用户可执行
nnnn 就是上列数字相加得到的，例如 chmod 0777 file 是指将文件 file 存取权限置为所有用户可读可写可执行。
-R 递归地改变所有子目录下所有文件的存取模式
u 文件主
g 同组用户
o 其他用户
a 所有用户
+ 增加后列权限
- 取消后列权限
= 置成后列权限
r 可读
w 可写
x 可执行
s 运行时可置UID
t 运行时可置GID
[例子]:
chmod 0666 file1 file2 将文件 file1 及 file2 置为所有用户可读可写
chmod u+x file 对文件 file 增加文件主可执行权限
chmod o-rwx 对文件file 取消其他用户的所有权限
1.13 chown
[语法]: chown [-R] 文件主 文件...
[说明]: 文件的UID表示文件的文件主，文件主可用数字表示， 也可用一个有效的用户名表示，此命令改变一个文件的UID，仅当此文件的文件主或超级用户可使用。
-R 递归地改变所有子目录下所有文件的存取模式
[例子]:
chown mary file 将文件 file 的文件主改为 mary
chown 150 file 将文件 file 的UID改为150
1.14 chgrp
[语法]: chgrp [-R] 文件组 文件...
[说明]： 文件的GID表示文件的文件组，文件组可用数字表示， 也可用一个有效的组名表示，此命令改变一个文件的GID，可参看chown。
-R 递归地改变所有子目录下所有文件的存取模式
[例子]:
chgrp group file 将文件 file 的文件组改为 group
1.15 cmp
[语法]: cmp [-l] [-s] 文件1 文件2
[说明]: 比较两个文件，若文件1 为 - ，则使用标准输入， 两个文件相同则无提示，不同则显示出现第一个不同时的字符数和行号。
-l 显示每个不同处的字节数(10进制)和不同的字节(8进制)
-s 不作任何提示，只返回码
[例子]:
cmp file1 file2 比较文件 file1 和 file2
cmp -l file1 file2 比较文件file1 和 file2 的每处不同
1.16 diff
[语法]: diff [-be] 文件1 文件2
[说明]: 本命令比较两个文本文件，将不同的行列出来
-b 将一串空格或TAB转换成一个空格或TAB
-e 生成一个编辑角本，作为ex或ed的输入可将文件1转换成文件2
[例子]:
diff file1 file2
diff -b file1 file2
diff -e file1 file2 >edscript
1.17 wc
[语法]: wc [-lwc] 文件...
[说明]: 统计文件的行、字、字符数，若无指定文件，则统计标准输入
-l 只统计行数
-w 只统计字数
-c 只统计字符数
[例子]:
wc -l file1 file2 统计文件file1和file2 的行数
1.18 split
[语法]: split [-n] [ 文件 [名字]]
[说明]: split 将指定大文件分解为若干个小文件，每个文件长度为n行(n 缺省时为1000)，第一个小文件名为指定的名字后跟aa，直至zz，名字缺省值为x，若未指定大文件名，则使用标准输入
[例子]:
split -500 largefile little
将文件largefile 每500行写入一个文件，第一个文件名为littleaa
1.19 touch
[语法]: touch [-amc] [mmddhhmm[yy]] 文件...
[说明]: 将指定文件的访问时间和修改时间改变，若指定文件不存在则创建之，若无指定时间，则使用当前时间，返回值是未成功改变时间的文件个数，包括不存在而又未能创建的文件。
-a 只改变访问时间
-m 只改变修改时间
-c 若文件不存在，不创建它且不作提示
mmddhhmm[yy] 两位表示 月日时分[年]
[例子]:
touch file
更新文件file的时间
touch 0701000097 HongKong
将文件HongKong的时间改为97年7月1日0时0分
1.20 file
[语法]: file [-f 文件名文件] 文件...
[说明]: file 对指定文件进行测试，尽量猜测出文件类型并显示出来
-f 文件名文件 文件名文件是一个包含了文件名的文本文件， -f 选项测试
文件名文件中所列出的文件
[例子]:
file * 显示当前目录下所有文件的类型
1.21 pack
[语法]: pack 文件...
[说明]: pack 将指定文件转储为压缩格式，文件名后加 .z ， 文件存取模式，访问时间，修改时间等均不变
[例子]:
pack largefile 将largefile 压缩后转储为largefile.z
1.22 pcat 显示压缩文件
[语法]: pcat 文件...
[说明]: pcat 显示输出压缩文件
[例子]:
pcat largefile.z 显示压缩前的largefile
pcat largefile.z > oldfile 显示压缩前的laregfile，并将其重定向到
文件oldfile中
1.23 unpack
[语法]: unpack 文件...
[说明]: 将压缩后的文件解压后转储为压缩前的格式
[例子]:
unpack largefile.z 将压缩文件largefile.z解压后转储为largefile
1.24 find
[语法]: find 路径名... 表达式
[说明]: find 命令递归地遍历指定路径下的每个文件和子目录，看该文件是否能使表达式值为真，以下 n 代表一个十进制整数，+n 代表打印 n ， -n 代表小于 n ，下面是合法表达式说明：
-name 模式 文件名与模式匹配则为真，(\ 为转意符)
-perm [-]八进制数 文件存取模式与八进制数相同则为真若有- 选项，则文件存
取模式含有八进制数规定模式即为真
-size n[c] 文件块长度为 n 则真(一块为512字节)，若
有c 选项，则文件字节长度为 n 则真
-atime n 若文件的最近访问时间为 n 天前则为真，
find 命令将改变其访问的目录的访问时间
-mtime n 若文件的最近修改时间为 n 天前则为真
-ctime n 若文件状态为 n 天前改变则为真
-exec 命令 { }\; 若命令返回值为0则真，{ }内为命令参数，
此命令必须以 \; 为结束
-ok 命令 { }\; 与 exec 相同，只是在命令执行前先提示，若
回答 y 则执行命令
-print 显示输出使表达式为真的文件名
-newer 文件 若文件的访问时间比newer 指定的文件新则真
-depth 先下降到搜索目录的子目录，然后才至其自身
-mount 仅查找包含指定目录的文件系统
-local 文件在当前文件系统时为真
-type c 文件类型为 c 则真，c 取值可为 b(块文件) c (字符文件)
d(目录) l (符号链接) p (命名管道) f (普通文件)
\( 表达式 \) 表达式为真则真
-links n 文件链接数为 n 时为真
-user 用户 当文件属于用户时为真，用户可用数字表示UID
-nouser 当文件不属于 /etc/passwd 中的一个用户时为真
-group 文件组 当文件属于文件组时为真，文件组可用数字表示GID
-nogroup 当文件不属于 /etc/group 中的一个组时为真
-fstype 类型 当文件所属文件系统类型为指定类型时真
-inum n 当文件 i 节点号为 n 时为真
-prune 当目录名与模式匹配时，不再搜索其子目录
可以用逻辑操作符将简单表达式连接成复杂表达式
逻辑操作符有 ! 表示非操作， -o 表示或操作，两个表达式并列则表示
与操作
[例子]:
find / -name find* -print
从根目录开始搜索文件名如 find* 的文件并显示之
find ./ -exec sleep{1}\; -print
每秒显示一个当前目录下的文件
find $HOME \(-name a.out -o -name '*.o' \) -atime +7 -exec rm {} \;
从$HOME目录开始搜索，删除所有文件名为a.out 或 *.o 且访问时间在7天前的文件
1.25 grep
[语法]: grep [选项] 模式 [文件...]
[说明]: 在指定的文件中搜索模式，并显示所有包含模式的行，模式是一个正规表达式，在使用正规表达式时，最好将其引在单引号(') 中，若指定文件为缺省，则使用标准输入，正规表达式可以是：
. 匹配任意一个字符
* 匹配0个或多个*前的字符
^ 匹配行开头
$ 匹配行结尾
[] 匹配[ ]中的任意一个字符，[]中可用 - 表示范围，
例如[a-z]表示字母a 至z 中的任意一个
\ 转意字符
命令中的选项为：
-b 显示块号
-c 仅显示各指定文件中包含模式的总行数
-i 模式中字母不区分大小写
-h 不将包含模式的文件名显示在该行上
-l 仅显示包含模式的文件名
-n 显示模式所在行的行号
-s 指定文件若不存在或不可读，不提示错误信息
-v 显示所有不包含模式的行
[例子]:
grep 'good' * 在所有文件中搜索含有字符串 good 的行
grep '^myline' mytext 在文件mytext中搜索行首出现myline字符串的行
1.26 vi
[语法]：vi [-wn] [-R] 文件...
[说明]: vi 是一个基于行编辑器 ex 上的全屏幕编辑器，可以在vi 中使用 ex，ed的全部命令，vi选项中 -wn 指将编辑窗口大小置为n行，-R 为将编辑的文件置为只读模式， vi 工作模式分为命令模式和输入模式，一般情况下在命令模式下，可敲入vi命令，进入输入模式下时可以编辑要编辑的文本，命令 a A i I o O c C s S R 可进入输入模式，在输入模式下按 ESC 键可推出输入模式，回到命令模式，在命令模式中敲入： 命令，则可进入ex方式，在屏幕底部出现提示符 ： ，此时可使用任意ex命令，屏幕底行也用来作/ ? ! 命令的提示行，大多数命令可以在其前面加数字，表示命令执行的重复次数，下面简单介绍一下vi 的命令集，^ 表示(CTRL)键
^B 退回前一页，前面加数字表示重复次数，每次换页时
保留上一页的两行
^D 在命令模式下，表示下滚屏幕的一半，在输入模式下，表示回退至
左边的自动缩进处
^E 显示屏幕底线之下的一行
^F 前进一页，前面加数字表示重复次数，每次换页时
保留上一页的两行
^G 显示当前文件名，当前行号和文件总行数，并用百分号当前行在
整个文件中的位置
^H(退格) 在命令模式下，光标左移一格；在输入模式下，删去前面的字符
^I(TAB) 在输入模式下，产生一串空格
^J(LF) 光标下移一行
^L 刷新屏幕，即将屏幕重新显示
^M(回车) 在命令模式下，光标移动至下行开头
在输入模式下，开辟一新行
^N 光标下移一行
^P 光标上移一行
^Q 在输入模式下，将其后的非打印字符作为正文插入
^R 刷新屏幕
^U 屏幕上滚一半，前面加数字时表示上滚的行数，此数字对
以后的^D ^U 命令有效
^V 在输入模式下，将其后的非打印字符作为正文插入
^W 在输入模式下，使光标回退一个字
^Y 显示屏幕底线之上的一行
^Z 暂停编辑，退回上层Shell
^[(ESC) 退出输入模式，回到命令模式
! 暂时退出编辑，执行Shell命令
(双引号) 用于标志有名缓冲区，编号缓冲区1-9用于保存被删去的正文，字
母名缓冲区a-z供用户存放自定义的正文
$ 将光标移动到当前行尾，前加数字则表示前移行数，如2$表示移动
到下一行行尾
% 将光标移动到配对的小括号()或大括号{}上去
( 退回句子开头
) 前移到句子开头
- 退到上一行第一个非空格字符
. 重复上一次改变缓冲区内容的命令
/ 模式 向前搜索模式，将光标移动到模式出现处，模式是一个正规
表达式，(参看 grep)
： 在屏幕底部提示：，其后可使用ex命令
? 功能同 / ，但方向是向前查找
[[ 光标回退至前一节分界处
\ 转意符
]] 光标前移至节分界处
^(不是CTRL) 光标移至当前行第一个非空字符上
' 连续两个''表示将光标移至其移动前的位置，'后跟字母表示光标字
母标记的行首(参看 m 命令)
A 在行尾插入正文，进入输入模式
B 光标回退一个字
C 替换光标后的内容
D 删除光标后的内容
E 光标前移到字尾
F 字符 在当前行向左查找指定字符
G 光标移动到其前面数字指定的行，若未指定则移动到最后一行
H 光标移动到屏幕顶行，若前面有数字，则移动到屏幕上该数字
指定的行
I 在行开头插入正文
J 连接两行，若前面有数字则连接数字指定的行
L 光标移动到屏幕底行，若前面有数字，则移动到屏幕底线往上数该
数字指定的行
M 光标移动到屏幕中线
N 使用模式查找/或?时，重复找下一个匹配的模式，但方向与上次相
反，其功能同 n ，但方向相反
O 在当前行上开辟一新行
P 将上次被删除的正文插入光标前面，可在其前面加缓冲区编号，编
号1-9用于保存被删去的正文，字母名缓冲区a-z供用户存放自定
义的正文
Q 从vi 推出进入ex命令状态
R 替换字符串
S 替换整行
T 字符 向左查找字符
U 将当前行恢复至第一次修改前的状态
W 光标移至下一个字首
X 删除光标前的字符
Y 将当前行存入无名缓冲区，前面加数字表示存入的行数，也可用有
名缓冲区来保存，以后可用命令p或P将其取出
ZZ 存盘退出vi
a 光标后插入正文
b 光标回退至上一个字首
cw 替换当前字
c) 替换当前句子
dw 删除一个字
dd 删除一行
e 光标移到下一个字末
f 字符 在当前行向前查找字符
h 光标左移一格
i 在光标前插入正文
j 光标下移一行
k 光标上移一行
l 光标右移一格
m 字母 用字母标记当前行，以后可用 '字母使光标移动到当前行，
(参看'命令)
n 重复上次 / 或 ? 命令
o 在当前行下开辟一新行
p 将用户缓冲区内容放到光标位置(参看P命令)
r 替换当前字符
s 用一串字符替换当前字符
t 字符 光标移动至字符前
u 取消上次操作
w 光标移至下一字首
x 删除当前字符
yw 将当前字存入无名缓冲区，前面可加x，表示存入名字为x的有名
缓冲区(x为a-z)，也可加数字表示存入的字数，以后可用P或p命
令取出
yy 将当前行存入无名缓冲区，用法参看yw
{ 光标移动至前一段开头
| 光标移至行首，若前面加数字，则移到数字指定行的行首
} 光标移至下一段开头
在：提示符下，常用命令如下:
：w 当前文件存盘
：w! 强制存盘
：w 文件 将内容写入指定文件
：w! 文件 强制写入指定文件
：x，y w 文件 将 x至 y 行写入指定文件中
：r 文件 将文件读到光标位置
：r ! 命令 将系统命令的输出读到光标位置
：q 退出编辑
：q! 强制退出
：x 与命令ZZ相同
：e 文件名 编辑另一文件
：e ! 重新编辑文件，放弃任何改变
：sh 执行sh，结束后回到编辑
：! 命令 执行命令后回到编辑
：n 编辑下一文件
：n 文件表 重新定义待编辑文件表
：set 设置 vi 的选项，例如 set nu 表示每行前显示行号，在选项前
加no则表示清除该选项，例如 set nonu 表示每行前不显示行
号，下面是一些常用的选项:
ai 自动缩进
aw 编辑下一文件前自动存盘
ic 查找字符串时不区分大小写
nu 每行前显示行号
sm 输入)及}时显示与之配对的( 或 {
slow 插入时延迟屏幕刷新
ws 使查找能绕过文件尾从头进行
wa 写文件之前不作对文件的检查
第二章 设备管理
2.1 stty
[语法]: stty [-a] [-g] [选项]
[说明]: 本命令设置终端，无参数时报告终端设置，本命令功能十分强大，应谨慎使用，下面仅介绍部分常用功能
-a 显示当前终端所有设置
-g 以能作为 stty 命令参数的方式显示终端设置
以下是终端常用设置，在设置前加-表示清除设置:
1．控制方式
ispeed 0 110 300 600 1200 1800 2400 4800 9600 19200 38400
本命令设置终端输入波特率，若为0则使用缺省波特率。
例如 stty ispeed 9600
ospeed 0 110 300 600 1200 1800 2400 4800 9600 19200 38400
本命令设置终端输出波特率，参看 ispeed。
2．输入方式
ingbrk(-ignbrk) 忽略(不忽略)中断(BREAK)
brkint(-brkint) 设置(清除)信号INTR为中断信号
inlcr(-inlcr) 将换行转换(不转换)成回车
icrnl( -icrnl) 将回车转换(不转换)成换行
igncr(-ignrc) 忽略(不忽略)回车
iuclc( -iuclc) 将大写字母转换(不转换)成小写字母
3．输出方式
olcut(-olcut) 将小写字母转换(不转换)为大写字母
onlcr(-onlcr) 输出时将换行符转换(不转换)为回车换行
ocrnl(-ocrnl) 输出时将回车符转换(不转换)为换行符
4．本地方式
echo (-echo) 设置(清除)回显
stwrap(-stwrap) 截断(不截断)大于79个字符的行
echoctl(-echoctr) 将控制键回显为^
2.2 tty
[语法]: tty
[说明]: 显示出终端的设备名
[例子]:
tty
2.3 lp
[语法]: lp 文件...
[说明]: 将文件送打印机打印
[例子]:
lp myfile 将文件myfile 送打印机输出
2.4 lpstat
[语法]: lpstat [选项] [打印任务号]
[说明]: 显示打印机状态，选项的意义如下：
-a [打印机表] 显示打印机表中指定的打印机可否接收打印请求
-c [打印机类名] 显示打印机种类及在该打印机种类下的成员
-d 显示系统预设的打印机
-p [打印机表] 显示打印机表中打印机状态
-r 显示lp 请求程序表( lp request scheduler)
-s 打印系统统计表
-t 打印所有状态信息
-u [用户] 显示由用户发出的打印请求
-v [打印机名表] 显示每个打印机名称，是对应于该打印机设备文件的路径名
[例子]:
lpstat -t 打印所有状态信息
2.5 cancel
[语法]: cancel 打印任务号
cancel 打印机名
cancel -u 用户名 [打印机]
[说明]: 本命令可按打印机名，打印任务，用户来取消打印任务
[例子]:
cancel -u mary 取消用户 mary 的所有打印请求
2.6 enable
[语法]: enable 打印机表
[说明]: 本命令可激活一个或多个打印机
2.7 disable
[语法]: disable [-cw] 打印机表
[说明]: 使一个或多个打印机不能打印
-c 立即取消正在打印的打印请求
-w 等正在打印的内容打完后，才禁止打印机
2.8 sync
[语法]: sync
[说明]: 将磁盘缓冲区内容写回磁盘
2.9 mount
[语法]: mount [-r] 设备 目录
[说明]: 将设备安装到目录下
-r 以只读方式安装
2.10 umount
[语法]: umount 设备
[说明]: 将已安装的文件系统卸下
2.11 tar
[语法]: tar -c[vwfbL] [设备] [块] 文件...
tar -r[vwfbL] [设备] [块] 文件...
tar -t[vfL] [设备] [文件...]
tar -u[vwfbL] [设备] [块] 文件...
tar -x[lmovwfL] [设备] [文件...]
[说明]: 将多个文件归档，命令中各参数的意义为：
r 附加方式归档
x 抽取文件
t 显示文件
u 附加方式归档，同时删除旧版文件
c 建立新档案文件
v 显示所处理的文件名
w 处理文件前，要求用户确认
f 文件名 使用指定文件名作为档案文件
bn 每次读写 n 块，缺省值为1，最大值为20
m 将新的文件修改时间设为获取时的时间
o 获取出来的文件以下达tar指令的UID和GID存储
[例子]:
tar cvf file.tar *
tar tvf file.tar
2.12 df
[语法]: df [-t] [文件系统]
[说明]: 显示剩余 i 节点和块数，使用 -t 选项，还显示总块数和 i 节点数
[例子]: df -t
2.13 du
[语法]: du [-ars] [目录]
[说明]: 显示磁盘空间专用情况
-r 提供无法打开的文件信息
-s 仅显示指定目录所占空间的总和
-a 显示文件大小及目录总空间，其后可根文件名作参数
第三章 进程管理
3.1 sleep
[语法]: sleep 时间
[说明]: 挂起参数指定的秒数
3.2 ps
[语法]: ps [ -efl] [ -t 终端表] [ -u 用户表] [ -g 组表]
[说明]: 显示出有关进程的状态
-e 显示出现在正在运行的所有进程
-f 显示所有信息
-l 产生一个长列表
-t 显示指定终端进程
-u 显示指定用户进程
-g 显示指定组进程
3.3 at
[语法]: at [-f 命令文件] [-m] [-q 队列] -t 时间
[说明]: at命令由cron管理，在未来一个指定的时间内执行一组命令，命令可以从指定文件读入，也可从键盘读入，从键盘读入时以EOF结束，(通常为CTRL D)
-f 从指定命令文件中读入命令
-m 命令执行完后给用户发邮件
-q 将命令放入指定队列
-t 指定时间 指定的时间格式为 [[CC]YY]MMDDhhmm[.ss]，CC表示
年的前两位，YY表示年的后两位，MM表示月，DD表示日，hh表
示时，mm表示分，ss表示秒
3.4 kill
[语法]: kill -信号 进程号
[说明]: kill 将信号传递给指定进程，信号意义如下：
1 暂停(hangup)
2 中断(interrupt)
3 退出(quit)
4 非法指令(illeqgal instruction)
5 跟踪中断(trace trap)
6 Abort
7 EMT 指令(Emulation trap)
8 浮点格式异常(floating point exception)
9 kill(不可忽略)
10 通道错误(bus error)
11 不合法内存段
12 错误的系统调用参数
13 写入不可读的连通管道
14 alarm clock
15 软件结束信号
16 用户定义信号一
17 用户定义信号二
[例子]:
kill -9 444 杀死进程号为 444 的进程
第四章 系统管理和用户管理
4.1 who
[语法]: who
who am i
[说明]: 列出现在系统中的用户，who am i 显示自己
4.2 whodo
[语法]: whodo [-h] [-l] [用户]
[说明]: 显示系统中用户及进程，若指定用户，则只列出该用户的信息
-h 不显示头部信息
-l 长列表格式输出
4.3 passwd
[语法]: passwd [用户]
[说明]: 修改密码，指定用户则修改指定用户密码
4.4 logname
[语法]: logname
[说明]: 取得当前用户注册名
4.5 su
[语法]: su [- ] [用户名]
[说明]: su 命令使当前用户成为指定用户，若无指定，则成为超级用户，但必须输入该用户的密码，-选项表示用该用户的注册环境成为该用户
4.6 time
[语法]: time 命令
[说明]: 执行命令，并在执行完后显示其运行的时间
4.7 date
[语法]: date
date mmddhhmm[yy]
[说明]: date 无参数时用于显示系统时间，修改时间时参数形式为
月日时分[年]
4.8 shutdown
[语法]: shutdown [-y] [-gn] [-in]
[说明]: UNIX 系统必须先关闭系统，再关电源
-y 对提示的所有问题都回答 y
-gn 给其他用户n 秒的时间退出，缺省值为60秒
-in 系统退到第n种方式，方式如下：
0 关机
1 单用户模式
2 多用户模式
3 网络下的多用户模式
6 关机并重新启动
4.9 fsck
[语法]: fsck [-y]
[说明]: 本命令用于检查和修复文件系统，当文件系统出现混乱时，可使用本命令，-y选项表示对所有提问都回答YES
第五章 通信和邮件
5.1 wall
[语法]: wall
[说明]: 向所有用户广播通知信息，常用于警告所有用户
5.2 mesg
[语法]: mesg [-n] [-y]
[说明]: mesg 用 -n 参数则禁止其他用户用 write 发消息，用 -y 参数则允许接收消息，若无参数则报告现在的状况
5.3 write
[语法]: write 用户 终端
[说明]: write 与指定的终端上的用户直接对话，直到接收到文件结束符
[例子]:
write mary console
5.4 mailx
[语法]: mailx [选项] [名字]
[说明]: 本命令用于发送和接收邮件，名字是收信人的用户名，本命令有许多内部命令，选项说明如下：
-e 检查是否有邮件，若有则返回0
-f 文件名 从文件中读取邮件而非从邮箱中
-H 只显示信件标题
-s 标题 设定标题为指定标题
[命令说明]
. 当前信件
n 第 n 封信
^ 第一封未被处理的信
$ 最后一封信
* 所有的信
n-m 第n 封至第m封信
用户 由指定用户发出的信
/ 字符串 标题中包含字符串的信
：c 满足指定类型c的信，类型可为
d 已删除的信
n 信传送的信
o 旧信件
r 已读过的信
u 未读过的信
p 一次显示多封信
t 显示某封信的前若干行
si 显示信件字符数
h 显示信件标题
d 删除信件
u 恢复信件
s [信件表] 文件名
将信件存入指定文件中
q 退出
r 回信
~e 编辑信件
~r 文件 从文件中读取信件
[例子]:
mailx mary < myletter
第六章 Shell 编程
shell 不但是 Unix 的用户交互界面，还是一门程序设计语言，系统注册进入时就会执行一个shell命令文件 .profile ，下面对shell中的常用命令作简单介绍。
$n shell 程序命令行中的第n 个参数，n为0-9，当n 为0时表示命令名
$# 命令行中参数的个数
$$ 本shell 命令的进程号
$! 最后一个后台进程的代号
$* 所有命令行参数
$@ 与$*相似，但其值不同
$HOME 注册时进入的目录
$PATH 命令的搜索目录
$PS1 系统第一个提示符，一般为$
$PS2 系统第二个提示符，一般为>
shift [n] 将命令行参数往左移一位，但$0不变
变量名=字符串 将字符串赋予变量名，以后可用$变量名引用该变量
export 变量名表 将变量名表所列变量传递给子进程
read 变量名表 从标准输入读字符串，传给指定变量
echo 变量名表 将变量名表指定的变量显示到标准输出
set 显示设置变量
env 显示目前所有变量
if 条件执行，语法是： if 条件
then 指令
fi
case 分支执行，语法是： case 字符串变量 in
值1) 指令...
值2) 指令...
...
esac
while 条件为真时循环，语法是：
while 条件
do
指令...
done
until 条件为假时循环，语法是：
until 条件
do
指令...
done
for 变量在表中时循环，语法是：
for 变量名 in 字组表
do
指令...
done
break 从循环中退出，语法：
break n
n 表示跳出循环的层数
continue 继续循环，语法：
continue n
n 表示退到包含continue 语句的第n 层继续循环
exit 退出shell
func shell内部可定义函数，语法： func 函数名()
{
指令...
}
expr 将其后的串解释为表达式并计算其值，运算符前后需有空格
trap 捕获信号，语法 trap n ，捕获信号 n (信号说明参见kill)
test 条件测试，语法 test [选项] 参数
选项 -f 文件 若文件存在且可读则真
-w 文件 若文件存在且可写则真
-x 文件 若文件存在且可执行则真
-f 文件 若文件存在且为普通文件则真
-d 文件 若文件存在且为目录文件则真
-p 文件 若文件存在且为fifo文件则真
-s 文件 若文件存在且不空则真
-z 串 若串长度为0则真
-n 串 若串长度不为0则真
串 若串不是空串则真
串1=串2 若串1等于串2则真
串1!=串2 若串1不等于串2则真
n1 -eq n2 若n1与n2数值相当则真
n1 -ne n2 若n1与n2数值不相当则真
n1 -lt n2 若n1小于n2则真
n1 -le n2 若n1小于等于n2则真
n1 -gt n2 若n1大于n2则真
n1 -ge n2 若n1大于等于n2则真
可用 与 -a 或 -o 非 ! 将条件表达式连接起来
第七章 数学计算命令
[语法]: bc [-c] [-l] [文件...]
[说明]: bc是一个交互式的高精度计算工具，采用类似于C语言的语法，能够从指定文件指定文件中读出命令执行，然后再进入交互式执行，事实上，bc是dc的预编译器，它自动激活dc，将语句经预编译后传递给dc，退出bc的命令是quit，bc中的ibase，obase，scale分别表示输入基数，输出基数，小数点右边的位数。
-c bc 只编译，而不将编译结果送dc，将其送到标准输出上
-l 预定义一个数学函数库，可在bc中使用以下函数
s(x) sine
c(x) cosine
e(x) exponential
l(x) log
a(x) arctangent
j(n，x) Bessel
[例子]:
bc -l 进入bc
scale=10 将小数位定为10位
e(1) 计算e的小数点后10位
quit 退出bc
附录 UNIX 常用命令简单说明
UNIX 命令大多数可用联机帮助手册 man 获得帮助，下面是常用命令及简单说明，可供用户快速查找使用。
命令 功能简述
acctcom 等于进程记帐文件
accton 启动或中止记帐进程
adb 汇编语言调试工具
admin 创建和管理SCCS文件
ar 档案文件和库文件管理程序
as 汇编器
asa 回车控制
at 在指定时间执行程序
awk 模式搜索和处理语言
banner 制作标题
basename 生成文件基本名(无前。后缀)
batch 命令的延迟执行
bc 计算器
bdiff 大型文件比较
bfs 大文件搜索
break 退出循环
cal 打印日历表
calendar 打印日历表
cancel 取消打印任务
case 分支语句
cb C语言整理程序
cd 改变当前目录
cc C语言编译器
cdc SCCS实用程序
cflow 生成C语言流程图
checkeq 数学公式排版命令
chgrp 改变文件组
chmod 改变文件存取模式
chown 改变文件主
chroot 改变根目录
cksum 显示校验和
clri 清除指定的I节点
cmp 文件比较
col 过滤反向换行
comb SCCS实用程序
comm 显示两个排序文件的公共行
command 执行简单命令
continue 进入下一循环
cp 复制文件
cpio 复制文件档案
cpp C语言预处理程序
crash 检查系统内存映象
create 建立临时文件
cref 生成交叉引用表
cron 在指定时间执行一组命令
crontab 为命令cron 准备crontab文件
crypt 加密/解密
csplit 将一个文件分解
ct 远程终端注册
ctags 创建供vi使用的标识符
cu 呼叫另一UNIX系统
cut 断开一文件中所选择的字段
cxref 生成C程序交叉访问表
date 打印和设置时间
dc 桌面计算器
dd 转换和复制文件
delta SCCS实用程序
deroff 去掉排版格式
devnm 标识设备名
df 显示可用磁盘空间
diff 显示两个文件的差异
diff3 显示三个文件的差异
dircmp 目录比较
dis 反汇编程序
du 显示对磁盘的占用情况
dump 对指定文件备份
echo 回显指定参数
ed 行编辑器
edit 文本编辑器
egrep 在文件中查找指定模式
env 设置命令执行环境
eqn 数学公式排版命令
eval 执行指定命令
ex 行编辑器
exec 执行指定命令
exit 进程中止
expand 使表格占满行宽
export 将变量传递给子程序
expr 计算表达式值
factor 因式分解
false 返回FALSE
fgrep 在文件中查找指定模式
file 确定文件类型
find 查找符号条件的文件
fmt 安排简单的文本格式
fold 折行
for 循环语句
fsck 文件系统检查和修复
fsdb 文件系统调试程序
fumount 强制性拆协指定资源
function 函数说明
fuser 列出使用文件的进程
fwtmp 产生记帐记录
get SCCS实用程序
getconf 查找配置参数
getopt 获得命令中的选择项
getopts 获得命令中的选择项
getty 设置终端类型、模式、行律等
grep 在文件中查找指定模式
head 打印文件的头若干行
hexdump 按十六进制转储文件
id 显示用户号
if 条件语句
init UNIX 初启进程
install 安装一个文件到文件系统
ipcrm 删除IPC队列
ipcs 显示IPC状态
join 连接两个文件（关系操作〕
kill 中止指定进程
killall 中止所有活动进程
labelit 给文件系统提供标号
ld 目标文件链接编辑器
lex 词法分析程序
line 读一行
link 连接文件
lint C程序检查程序
ln 链接文件
local 建立局部变量
logger 显示注册信息
login 注册
logname 获取注册名
look 在排序文件中查找某行
lorder 查找目标库的次序关系
lp 打印文件
lpr 打印文件
lpstat 显示打印队列状态
ls 目录列表
mail 发送或接收电子邮件
mailx 发送、接收或处理电子邮件
make 执行有选择的编译
makekey 生成加密码
man 显示命令用法
mesg 接收或取消对话方式
mkdir 建立目录
mkfifo 建立FIFO文件
mkfs 建立文件系统
mknod 建立文件系统的I节点
mount 安装文件系统
mv 移动文件
mvdir 移动目录
ncheck 按节点号生成节点名清单
neqn 数学公式排版命令
newgrp 把用户加入到新组
news 打印消息
nice 改变命令执行优先级
nl 给文件加行号
nm 显示目标文件符号表
nohup 忽略挂起或退出执行命令
nroff 文本文件排版
od 按八进制转储文件
pack 压缩文件
passwd 改变口令
paste 文件合并
pax 可移植档案管理程序
pcat 显示压缩格式文件
pg 分屏显示
pr 按打印格式显示文件
pstat 报告系统信息
pwck 口令文件校验程序
pwd 显示当前工作目录
quot 检查文件系统所有权
ratfor 转换成标准FORTRANC程序
read 从标准输入读一行
readonly 标记变量为只读
red 文本编辑器
regcmp 正规表达式编辑
restor 文件系统恢复程序
restore 文件系统恢复程序
return 返回语句
rev 颠倒文件中每行字符次序
rm 删除文件
rmdel SCCS使用程序
rmdir 删除目录
rsh(net) 远程SHELL
rsh(sec) 受限SHELL
runacct 运行日常记帐程序
sact SCCS实用程序
sag 打印系统活动图
sar 报告系统活动
sccsdiff SCCS实用程序
sdb 符号调试器
sdiff 并列显示两个文件的差别
sed 流编辑器
sendto 发送邮件
set 设置选项或参数
setmnt 建立文件系统安装表
sh SHELL解释器
shift 命令行参数移位
shl SHELL层（layer)管理程序
shutdown 关机
size 显示目标文件长度
sleep 挂起进程一段时间
sort 文件排序和合并
spell 拼写错误检查程序
spellin 拼写错误检查
spellout 拼写错误检查
spline 按平滑曲线输出数据
split 分解一个文件
strings 在目标文件中寻找可打印字符
strip 删除符号表
stty 设置终端模式
su 改变用户
sum 显示文件校验和及块数
sync 更新磁盘
tabs 设置制表符
tbl 表格排版
tee 在管道上建立多通路
tic 终端数据库编译程序
time 打印执行命令所花时间
tiemx 报告命令所花时间及活动
touch 更新文件时间
tput 恢复终端或查询数据库
tr 转换字符
trap 捕获信号
troff 文本文件排版
true 返回TRUE
tsort 拓扑排序
tty 显示终端设备名
umask 设置文件掩码
umount 拆卸文件系统
uname 显示系统名
unget SCCS实用程序
uniq 删除文件中重复行
units 度量单位转换
unlink 删除文件
unpack 将压缩文件还原
until 循环语句
update 更新磁盘
val SCCS实用程序
vc SCCS实用程序
vi 全屏幕编辑器
volcopy 文件系统的文字拷贝
wait 等待所有字进程结束
while 循环语句
who 显示谁在使用系统
whodo 显示哪些用户在做什么
write 和另一用户直接对话
xargs 建立参数表并执行命令
yacc 语法分析程序生成器
posted @
2008-06-13 23:16 xzc 阅读(834) |
评论 (2) |
编辑 收藏时间：2006-02-10 00:55:40 类别：其他, 技术 RSS 2.0 引用
1.登录工作站
1.1 透过 PC 登录工作站
执行格式：telnet hostname (在 dos 下执行)
telnet ip-address
Example:
telnet doc telnet 140.122.77.120
注: 可利用指令 arp hostname 或 arp domain_name 查询 ip_address
1.2 登录步骤
login : _______ > 输入 username
password : _______ > 输入密码
1.3 登出步骤
% logout
或 % exit
或 %
1.4 更改帐号密码
% yppasswd > 执行后将会出现下列信息
Changing NIS password for user on ice.
Old password: ______ > 输入旧密码
New password: ______ > 输入新密码(最好6-8字，英文字母与数字混合)
Retype new password: ______ > 再输入一次密码
1.5 在线帮助指令说明
执行格式： man command-name
Example: % man ls
1.6 进入远端电脑系统
执行格式：rlogin hostname [-1 username]
Example:
%rlogin doc
remote login 进入工作站 doc 中。
%rlogin doc -l user
使用 user 帐号进入工作站 doc 中。
执行格式：telnet hostname 或 telnet IP address
Example:
%telnet doc or %telnet 140.109.20.251
2. 文件或目录处理
2.1 列出文件或目录下之文件名称
执行格式： ls [-atFlgR] [name] ( name 可为文件名或目录名称。)
Example :
ls 列出目前目录下之文件名。
ls –a 列出包含以.起始的隐藏档所有文件名。
ls –t 依照文件最后修改时间之顺序，依序列出文件名。
ls –F 列出目前目录下之文件名及其类型。"/" 结尾表示为目录名称，
"*" 结尾表示为执行档，"@" 结尾表示为 symblic link。
ls –l 列出目录下所有文件之许可权、拥有者、文件大小、修改时间及名称。
ls –lg 同上，并显示出文件之拥有者群组名称。
ls –R 显示出目录下，以及其所有子目录之文件名。( recursive listing )
2.2 目录之缩写：
～ 使用者 login 时的 working directory ( 起始目录 )
～username 指定某位 user 的 working directory ( 起始目录 )
.. 目前的工作目录 ( current working directory )
.. 目前目录的上一层目录 ( parent of working directory)
2.3 改变工作目录位置
执行格式：cd [name] ：name 可为目录名称、路径或目录缩写。
Example:
cd 改变目录位置，至使用者 login 时的 working directory (起始目录)。
cd dir1 改变目录位置，至 dir1 之目录位置下。
cd ~user 改变目录位置，至使用者的 working directory (起始目录)。
cd .. 改变目录位置，至目前目录的上层( 即 parent of working directory)
cd ../user 改变目录位置，至相对路径 user 之目录位置下。
cd /../.. 改变目录位置，至绝对路径( Full path ) 之目录位置下。
2.4 复制文件
执行格式: cp [-r] source destination
Example:
cp file1 file2 将文件 file1 复制成 file2
cp file1 dir1 将文件 file1 复制到目录 dir1 下，文件名仍为 file1。
cp /tmp/file1 将目录 /tmp 下的文件 file1 复制到现行目录下，文件名仍为 file1。
cp /tmp/file1 file2 将目录 /tmp 下的文件 file1 复制到现行目录下，文件名为 file2
cp -r dir1 dir2 (recursive copy) 复制整个目录。
若目录 dir2 不存在，则将目录 dir1，及其所有文件和子目录，复制到目录 dir2 下，新目录名称为 dir1。若目录 dir2 不存在，则将dir1，及其所有文件和子目录，复制为目录 dir2。
2.5 移动或更改文件、目录名称
执行格式： mv source destination
Example:
mv file1 file2 将文件 file1，更改文件名为 file2。
mv file1 dir1 将文件 file1，移到目录 dir1下，文件名仍为 file1。
mv dir1 dir2 若目录 dir2 不存在，则将目录 dir1，及其所有文件和子目录，移到目录 dir2 下，新目录名称为 dir1。若目录 dir2 不存在，则将dir1，及其所有文件和子目录，更改为目录 dir2。
2.6 建立新目录
执行格式： mkdir directory-name
Exmaple ：
mkdir dir1 建立一新目录 dir1。
2.7 删除目录
执行格式： rmdir directory-name 或 rm directory-name
Example ：
rmdir dir1 删除目录 dir1，但 dir1 下必须没有文件存在，否则无法删除。
rm -r dir1 删除目录 dir1，及其下所有文件及子目录。
2.8 删除文件
执行格式： rm filename (filename 可为文件名，或文件名缩写符号。)
Example ：
rm file1 删除文件名为 file1 之文件。
rm file? 删除文件名中有五个字符，前四个字符为file 之所有文件。
rm f* 删除文件名中，以 f 为字首之所有文件。
2.9 文件名的缩写符号
? 代表文件名称中之单一字符。
* 代表文件名称中之一字串。
2.10 列出目前所在之目录位置
执行格式： pwd
2.11 查看文件内容
执行格式： cat filename
Example ：
cat file1 以连续显示方式，查看文件名 file1 之内容。
执行格式： more filename 或 cat filename | more
Example ：
more file1 以分页方式，查看文件名 file1 之内容。
cat file1 | more 同上。
2.12 查看目录所占磁盘容量
执行格式: du [-s] directory
Example :
du dir1 显示目录 dir1 的总容量及其次目录的容量(以 k byte 为容量)。
du -s dir1 显示目录 dir1 的总容量。
2.13 查看自己的 disk quota 使用状况
disk quota : 工作站磁盘空间的使用限额。
执行格式: quota -v
Example :
quota -v 将会显示下列信息
Filesystem usage quota limit timeleft files quota limit timelef.
/home/ice/u01 9344 8192 12288 1.9 days 160 0 0
栏位解说:
usage : 目前的磁盘用量。
quota : 你的磁盘使用额度。当你的 usage 超过 quota 时，虽然可以继续使用，但是必须七天之内降到 quota 以下，否则即使用量没有超 limit(最高限额)，也无法再写入或复制任何文件。
limit : 最高使用额度。当你的 usage 达到 limit 时，无法再写入或复制任何文件。
3. 文件传输
3.1 拷贝文件或目录至远端工作站
执行格式： rcp [-r] source hostnome:destination
source 可为文件名、目录名或路径，hostnome 为工作站站名，destination 为路径名称.
Example ：
rcp file1 doc:/home/user
将文件 file1，拷贝到工作站 doc 路径 /home/user 之目录下。
rcp -r dir1 doc:/home/user
将目录 dir1，拷贝到工作站 doc 路径/home/user 之目录下。
3.2 自远端工作站，拷贝文件或目录
执行格式： rcp [-r] hostname:source destination
( hostname 为工作站名，source 为路径名，destination 可为文件名、目录名或路径 )。
Example ：
rcp doc:/home/user/file1 file2
将工作站 doc 中，位于 /home/user 目录下之目录 dir1，拷贝到目前工作站之目录下，目录名称仍为 dir1。
rcp -r doc:/home/user/dir1 .
将工作站 iis1 中，位于 /home/user 目录下之目录 dir1，拷贝到目前工作站之目录下目录名称仍为 dir1。
3.3 本地工作站与远端工作站之间文件传输
( 必须拥有远端工作站之帐号及密码，才可进行传输工作 )
执行格式： ftp hostname or ftp ip_address
Example ：
ftp doc 与远端工作站 doc ，进行文件传输
Name (doc:user-name) : 输入帐号
Password (doc:user-name): 输入密码
ftp> help 列出 ftp 文件传输，可使用之任何命令。
ftp> !ls 列出本地工作站，目前目录下之所有文件名。
ftp> !pwd 列出本地工作站，目前所在之工作目录位置。
ftp> ls 列出远端工作站目前目录下之所有文件名。
ftp> dir 列出远端工作站目前目录下之所有文件名(略同于 UNIX 的 ls -l 指令).
ftp> dir . |more 同上，但每页会暂停(可能不适用 Unix 以外的 ftp)。
ftp> pwd 列出远端工作站目前所在之目录位置。
ftp> cd dir1 更改远端工作站之工作目录位置至 dir1 之下。
ftp> get file1 将远端工作站之文件 file1 ，拷贝到本地工作站中。
ftp> put file2 将本地工作站之文件 file2 ，拷贝到远端工作站中。
ftp> mget *.c 将远端工作站中，副文件名为 c 之所有文件，拷贝到本地工作站中。
ftp> mput *.txt 将本地工作站中，副文件名为 txt 之所有文件，拷贝远端工作站中。
ftp> prompt 切换交谈式指令(使用 mput/mget 时不用每个文件皆询问yes/no)。
ftp> quit 结束 ftp 工作。
ftp> bye 结束 ftp 工作。
注: 从PC与工作站间的文件传输也可透过在 PC端的 FTP指令进行文件传输，指令用法与上所述大致相同。
4. 文件模式之设定
4.1 改变文件或目录之读、写、执行之允许权
执行格式：chmod [-R] mode name
( name 可为文件名或目录名;mode可为 3 个 8 位元之数字，或利用ls -l 命令，列出文件或目录之读、写、执行允许权之文字缩写。)
mode : rwx rwx rwx r:read w:write x:execute
user group other
缩写 : (u) (g) (o)
Example :
%chmod 755 dir1
将目录dir1，设定成任何使用者，皆有读取及执行之权利，但只有拥有者可做修改。
%chmod 700 file1
将文件file1，设定只有拥有者可以读、写和执行。
%chmod o+x file2
将文件file2，增加拥有者可以执行之权利。
%chmod g+x file3
将文件file3，增加群组使用者可执行之权利。
%chmod o-r file4
将文件file4，除去其它使用者可读取之权利。
4.2 改变文件或目录之拥有权
执行格式：chown [-R] username name ( name 可为文件名或目录名。)
Example ：
%chown user file1
将文件 file1 之拥有权，改为使用者 user 所有。
%chown -R user dir1
将目录 dir1，及其下所有文件和子目录之拥有权，改为使用者 user 所有。
4.3 检查自己所属之群组名称
执行格式：groups
4.4 改变文件或目录之群组拥有权
执行格式：chgrp [-R] groupname name ( name 可为文件名或目录名 )
Example :
%chgrp vlsi file1
将文件 file1 之群组拥有权，改为 vlsi 群组。
%chgrp -R image dir1
将目录dir1，及其下所有文件和子目录，改为 image 群组。
4.5 改变文件或目录之最后修改时间
执行格式：touch name ( name 可为文件或目录名称。)
4.6 文件之连结
同一文件，可拥有一个以上之名称，可将文件做数个连结。
执行格式：ln oldname newname ( Hard link )
Example ：
ln file1 file2 将名称 file2，连结至文件 file1。
执行格式：ln -s oldname newname ( Symblick link )
Example ：
ln -s file3 file4 将名称 file4，连结至文件file3。
4.7 文件之字串找寻
执行格式：grep string file
Example ：
grep abc file1
寻找文件file1中，列出字串 abc 所在之整行文字内容。
4.8 找寻文件或命令之路径
执行格式：whereis command ( 显示命令之路径。)
执行格式：which command ( 显示命令之路径，及使用者所定义之别名。)
执行格式：whatis command ( 显示命令功能之摘要。)
执行格式：find search-path -name filename -print
( 搜寻指定路径下，某文件之路径 。)
Example ：
%find / -name file1 -print ( 自根目录下，寻找文件名为 file1 之路径。.
4.9 比较文件或目录之内容
执行格式：diff [-r] name1 name2 ( name1 name2 可同时为文件名，或目录名称。)
Example :
%diff file1 file2
比较文件 file1 与 file2 内，各行之不同处。
%diff -r dir1 dir2
比较目录 dir1 与 dir2 内，各文件之不同处。
4.10 文件打印输出
使用者可用 .login 档中之 setenv PRINTER，来设定打印资料时的打印机名。
printername :sp1 或 sp2
Example ：
%setenv PRINTER sp2 设定自 sp2 打印资料。
4.11 一般文件之打印
执行格式：lpr [-Pprinter-name] filename
%lpr file1 或 lpr -Psp2 file1
自 sp2，打印文件 file1。
执行格式：enscript [-Pprinter-name] filename
%enscript file3 或 enscript -Psp1 file3
自 sp1 打印文件 file3。
4.12 troff 文件之打印
执行格式：ptroff [-Pprinter-name] [-man][-ms] filename
%ptroff -man /usr/local/man/man1/ptroff.1
以 troff 格式，自 Apple laser writer 打印 ptroff 命令之使用说明。
%ptroff -Psp2 -man /usr/man/man1/lpr1
以 troff 格式，自 sp2 打印 lpr 命令之使用说明。
5. 打印机控制命令
5.1 检查打印机状态，及打印工作顺序编号和使用者名称
执行格式：lpq [-Pprinter -name]
%lpq 或 lpq -Psp1
检查 sp1 打印机之状态。
5.2 删除打印机内之打印工作 (使用者仅可删除自己的打印工作 )
执行格式：lprm [-Pprinter -name] username 或 job number
%lprm user 或 lprm -Psp1 user
删除 sp1 中，使用者 user 的打印工作，此时使用者名称必须为 user。
%lprm -Psp2 456
删除 sp2 编号为 456 之打印工作。
6. Job 之控制
UNIX O.S.,可于 foregrourd 及 background 同时处理多个 process。
一般使用者执行命令时，皆是在 foreground 交谈式地执行 process，亦可将 process置于 background 中，以非交谈式来执行 process。
6.1 查看系统之 process
执行格式：ps [-aux]
Example:
%ps 或 ps –x (查看系统中，属于自己的 process。)
%ps –au (查看系统中，所有使用者的 process。)
%ps –aux (查看系统中，包含系统内部，及所有使用者的 process。)
6.2 结束或终止 process
执行格式：kill [-9] PID ( PID 为利用 ps 命令所查出之 process ID。)
Example:
%kill 456 或 kill -9 456
终止 process ID 为 456 之 process。
6.3 在 background 执行 process 的方式
执行格式：command & (于 command 后面加入一 "&" 符号即可。)
Example:
%cc file1.c &
将编译 file1.c 文件之工作，置于 background 执行。
执行格式：按下 "Control Z" 键，暂停正在执行的 process。键入 "bg" 命令，将所暂停的 process，置入 background 中继续执行。
Example:
%cc file2.c
^Z
Stopped
%bg
6.4 查看正在 background 中执行的 process
执行格式：jobs
6.5 结束或终止在 background 中的 process
执行格式：kill %n
(n 为利用 "jobs" 命令，所查看出的 background job 编号)
Example:
%kill % 终止在 background 中的第一个 job。
%kill %2 终止在 background 中的第二个 job。
7. shell varialbe
7.1 查看 shell variable 之设定值
执行格式：set 查看所有 shell variable 之设定值。
%set
执行格式：echo $variable-name 显示指定的 shell variable 之设定值。
%echo $PRINTER
sp1
7.2 设定 shell variable
执行格式：set var value
Example:
%set termvt100
设定 shell variable "term" 为 VT100 终端机之型式。
7.3 删除 shell variable
执行格式：unset var
Example:
%unset PRINTER
删除 shell variable "PRINTER" 之设定值。
8. environment variable
8.1 查看 environment variable 之设定值
执行格式：setenv 查看所有 environment variable 之设定值。
Example: %setenv
执行格式：echo $NAME 显示指定的 environment variable "NAME" 之设定值。
Example:
%echo $PRINTER
显示 environment variable "PRINTER" 打印机名称之设定值。
8.2 设定 environment variable
执行格式：setenv NAME word
Example:
%setenv PRINTER sp1
设定 environment variable "PRINTER" 打印机名称为 sp1。
8.3 删除 environment variable
执行格式：unsetenv NAME
Example:
%unsetenv PRINTER
删除 environment variable "PRINTER" 打印机名称之设定值。
9. alias
9.1 查看所定义的命令之 alias
执行格式： alias 查看自己目前定义之所有命令，及所对应之 alias 名称。
执行格式： alias name 查看指定之 alias 名称所定义之命令。
Example:
%alias dir (查看别名 dir 所定义之命令)
ls -atl
9.2 定义命令之 alias
执行格式： alias name \'command line\'
Example:
% alias dir \'ls -l\'
将命令 "ls - l" 定义别名为 dir。
9.3 删除所定义之 alias
执行格式： unalias name
Example:
%unalias dir (删除别名为 dir 之定义。)
%unalias * (删除所有别名之设定。)
10. history
10.1 设定命令记录表之长度
执行格式： set history n
Example:
%set history 40
设定命令记录表之长度为 40 (可记载执行过之前面 40 个命令)。
10.2查看命令记录表之内容
执行格式： history
10.3 使用命令记录表
执行格式： !!
Example: %!! (重复执行前一个命令)
执行格式： !n ( n 为命令记录表之命令编号。)
Example: %!5 ( 执行命令记录表中第五个命令。)
执行格式： !string ( 重复前面执行过以 string 为起始字符之命令。)
Example: %!cat ( 重复前面执行过，以 cat 为起始字符之命令。)
10.4 显示前一个命令之内容
执行格式： !!：p
10.5 更改前一命令之内容并执行之
执行格式： ^oldstring ^newstring
将前一命令中 oldstring 的部份，改成 newstring，并执行之。
Example:
%find . -name file1.c -print
^file1.c^core
%find . -name core -print
注：文件 core 为执行程序或命令发生错误时，系统所产生的文件。作为侦错(debug)之，因其所占空间极大，通常将之删除。
11. 资料之压缩
为了避免不常用的文件或资料，占用太大的磁盘空间，请使用者将之压缩。欲使用压缩过的文件或资料前，将之反压缩，即可还原成原来之资料型式。凡是经过压缩处理之文件，会在文件名后面附加 " .Z " 之字符，表示此为一压缩文件。
11.1 压缩资料
执行格式：compress filename 压缩文件
执行格式：compressdir directory-name 压缩目录
11.2 解压缩还原资料
执行格式：uncompress filename 反压缩文件
执行格式：uncompressdir directory-name 反压缩目录
12. pipe-line 之使用
执行格式：command1 | command2
将 command1 执行结果，送到 command2 做为 command2 的输入。
Example:
%ls -Rl | more
以分页方式，列出目前目录下所有文件，及子目录之名称。
%cat file1 | more
以分页方式，列出文件 file1 之内容。
13. I/O control
13.1 标准输入之控制
执行格式：command-line < file
将 file 做为 command-line 之输入。
Example:
%mail -s "mail test" user@iis.sinica.edu.tw < file1
将文件 file1 当做信件之内容，Subject 名称为 mail test,送给收信人。
13.2 标准输出之控制
执行格式：command > filename
将 command 之执行结果，送至指定的 filename 中。
Example: %ls -l > list
将执行 "ls -l" 命令之结果，写入文件 list 中。
执行格式：command >! filename
同上，若 filename 之文件已经存在，则强迫 overwrite。
Example: %ls -lg >! list
将执行 "ls - lg" 命令之结果，强迫写入文件 list 中。
执行格式：command >& filename
将 command 执行时，屏幕上所产生的任何信息，写入指定的 filename 中。
Example: %cc file1.c >& error
将编译 file1.c 文件时，所产生之任何信息，写入文件 error 中。
执行格式：command >> filename
将 command 执行结果，附加(append)到指定的 filename 中。
Example: %ls - lag >> list
将执行 "ls - lag" 命令之结果，附加(append)到文件 list 中。
执行格式：command >>& filename
将 command 执行时，屏幕上所产生的任何信息，附加于指定的 filename中。
Example: %cc file2.c >>& error
将编译 file2.c 文件时，屏幕所产生之任何信息，附加于文件 error 中。
14. 查看系统中的使用者
执行格式： who 或 finger
执行格式： w
执行格式： finger username or finger username@domainname
15. 改变自己的 username 进入其他使用者的帐号，拥有其使用权利。
执行格式： su username
Example:
%su user 进入使用者 user 之帐号
passwrod: 输入使用者 user 之密码
16. 查看 username
执行格式： whoami 查看 login 时，自己的 username。
执行格式： whoami 查看目前的 username。若已执行过 "su"命令tch user)，则显示出此 user 之 username。
17. 查看目前本地所有工作站的使用者
执行格式: rusers
> 结束
18. 与某工作站上的使用者交谈
执行格式: talk username@hostname 或 talk username@ip_address
Example:
1. 可先利用 rusers 指令查看网路上的使用者
2. 假设自己的帐号是 u84987 ，在工作站 indian 上使用，现在想要与 doc 上的u84123 交谈。
%talk u84123@doc > 此时屏幕上将会出现等待画面
在对方(u84123)屏幕上将会出现下列信息
Message from Talk_Daemon@Local_host_name at xx:xx
talk: connection requested by u84987@indian
talk: respond with: talk u84987@indian
此时对方(u84123) 必须执行 talk u84987@indian 即可互相交谈。最后可按结束。
19. 检查远端电脑系统是否正常
执行格式：ping hostname 或 ping IP-Address
Example:
%ping doc
20. 电子邮件(E-mail)的使用简介
20.1将文件当做 E-mail 的内容送出
执行格式：mail -s "Subject-string" username@address < filename
%mail -s "program" user < file.c
将 file.c 当做 mail 的内容，送至 user, subject name 为 program。
20.2 传送 E-mail 给本地使用者
执行格式：mail username
%mail user
20.3 传送 E-mail 至 外地
执行格式： mail username@receiver-address
Example
%mail paul@gate.sinica.edu.tw
Subject : mail test
:
:
键入信文内容
:
:
按下 "Control D" 键或 " . " 键结束信文。
连按两次 "Control C" 键，则中断工作，不送此信件。
Cc:
( Carbon copy : 复制一份信文，给其他的收信人 )
20.4 检查所传送之 E-mail 是否送出，或滞留于本所之邮件伺服站中
执行格式：/usr/lib/sendmail -bp
( 若屏幕显示为 "Mail queue is empty" 之信息，表示 mail 已送出。
若为其它错误信息，表示 E-mail 因故尚未送出。)
20.5 读取信件
执行格式: mail
常用指令如下:
cd [directory] chdir to directory or home if none given
d [message list] delete messages
h print out active message headers
m [user list] mail to specific users
n goto and type next message
p [message list] print messages
q quit, saving unresolved messages in mbox
r [message list] reply to sender (only) of messages
R [message list] reply to sender and all recipients of messages
s [message list] file append messages to file
t [message list] type messages (same as print)
u [message list] undelete messages
v [message list] edit messages with display editor
w [message list] file append messages to file, without from line
x quit, do not change system mailbox
z [-] display next [previous] page of headers
! shell escape
21.文件编辑器 vi 之使用方法简介
vi、celvis(cvi) 是在工作站上被广大使用的中英文编辑软体。对初学者而言，常因其特殊的使用方法，而不得其门而入；对已经在使用 vi 的使用者来说，也常见因对 vi 的不熟悉或不够了解，而无法发挥出 vi 强大的编辑能力，以下将介绍 vi 之使用方法简介。
21.1本文内容大纲
进入 vi
离开 vi
输入模式
如何进入输入模式
如何离开输入模式
指令模式
光标的移动
视窗的移动
删除、复制及修改指令介绍(delete、change、yank)
删除与修改(delete、replace)
移动与复制(delete/put、yank/put)
指令重复
取消前一动作(undo)
字串搜寻
资料的连接与分行
环境的设定
ex 指令
其它方面
中文编辑
恢复编辑时被中断的文件
编辑多个文件
vi 是 visual editor 的缩写，是 UNIX 所提供的编辑器之一。它提供使用者一个视窗的编辑环境，在此视窗下，使用者可编辑所要的文件。
21.2 进入vi
直接执行 vi编辑程序即可：
%vi test
此刻屏幕上会出现 vi 的编辑视窗，同时 vi 会将文件复制一份至记忆体中的缓冲区 (buffer) 。 vi会保留在磁盘中的文件不变，而先对缓冲区的文件作编辑，编辑完成后，使用者可决定是否要取代原来旧有的文件。
--------------------------------------------------------------------------------
-- 作者：itvue
-- 发布时间：2005-5-11 10:17:42
--
21.3 离开vi
若在输入模式下，则先利用《ESC》进入指令模式，而后即可选用下列指令
离开vi。
：q! 离开vi，并放弃刚在缓冲区内编辑的内容。
：wq 将缓冲区内的资料写入磁盘中，并离开vi。
：ZZ 同wq。
：x 同wq。
：w 将缓冲区内的资料写入磁盘中，但并不离开vi。
：q 离开vi，若文件被修改过，则会被要求确认是否放弃修改的内容。
此指令可与：w 配合使用。
21.4 vi 的操作模式
vi 提供两种操作模式：输入模式(insert mode)和指令模式(command mode)。当使用者进入 vi 后，即处在指令模式下，此刻键入之任何字符皆被视为指令。在此模式下可进行删除、修改等动作。若要输入资料，则需进入输入模式。
21.5 输入模式
如何进入输入模式
l a (append) 由光标之后加入资料。
l A 由该行之末加入资料。
l i (insert) 由光标之前加入资料。
l I 由该行之首加入资料。
l o (open) 新增一行于该行之下供输入资料之用。
l 新增一行于该行之上供输入资料之用。
如何离开输入模式
l 《ESC》 结束输入模式。
21.6 指令模式
光标之移动
l h 向左移一个字符。
l J 向上移一个字符。
l K 向下移一个字符。
l L 向右移一个字符。
l 移至该行之首
l $ 移至该行之末。
l ^ 移至该行的第一个字符处。
l H 移至视窗的第一列。
l M 移至视窗的中间那列。
l L 移至视窗的最后一列。
l G 移至该文件的最后一列。
l + 移至下一列的第一个字符处。
l - 移至上一列的第一个字符处。
l ( 移至该句之首。 (注一)
l ) 移至该句之末。
l { 移至该段落之首。 (注二)
l } 移至该段落之末。
l nG 移至该文件的第 n 列。
l n+ 移至光标所在位置之后的第 n 列。
l 移至光标所在位置之前的第 n 列。
l 会显示该行之行号、文件名称、文件中最末行之行号、光标所在行号占总行号之百分比。
注一：句子(sentence)在vi中是指以『！』、『.』或『？』结束的一串字。
注二：段落(paragraph)在vi中是指以空白行隔开的文字。
21.7 视窗的移动
l 视窗往下卷一页。
l 视窗往上卷一页。
l 视窗往下卷半页。
l 视窗往上卷半页。
l 视窗往下卷一行。
l 视窗往上卷一行。
21.8 删除、复制及修改指令介绍 (此单元较少使用)
d(delete)、c(change)和y(yank)这一类的指令在 vi 中的指令格式为：
Operator + Scope command
(运算子) (范围)
运算子：
l d 删除指令。删除资料，但会将删除资料复制到记忆体缓冲区。
l y 将资料(字组、行列、句子或段落)复制到缓冲区。
l p 放置(put)指令，与 d 和 y 配和使用。可将最后delete或yank的资料放置于光标所在位置之行列下。
l c 修改(change)指令，类似delete与insert的组和。删除一个字组、句子等之资料，并插入新键资料。
范围：
l e 由光标所在位置至该字串的最后一个字符。
l w 由光标所在位置至下一个字串的第一个字符。
l b 由光标所在位置至前一个字串的第一个字符。
l $ 由光标所在位置至该行的最后一个字符。
l 由光标所在位置至该行的第一个字符。
l ) 由光标所在位置至下一个句子的第一个字符。
l ( 由光标所在位置至该句子的第一个字符。
l { 由光标所在位置至该段落的最后一个字符。
l } 由光标所在位置至该段落的第一个字符。
整行动作：
l dd 删除整行。
l D 以行为单位，删除光标后之所有字符。
l cc 修改整行的内容。
l yy yank整行，使光标所在该行复制到记忆体缓冲区。
21.9 删除与修改
l x 删除光标所在该字符。
l X 删除光标所在之前一字符。
l dd 删除光标所在该行。
l r 用接于此指令之后的字符取代(replace)光标所在字符。如： ra 将光标所在字符以 a 取代之。
l R 进入取代状态，直到《ESC》为止。
l s 删除光标所在之字符，并进入输入模式直到《ESC》。
l S 删除光标所在之该行资料，并进入输入模式直到《ESC》。
21.10 移动与复制
利用 delete 及 put 指令可完成资料移动之目的。
利用 yank 及 put 指令可完成资料复制之目的。
yank 和 delete 可将指定的资料复制到记忆体缓冲区，而藉由 put 指令可将缓冲区内的资料复制到屏幕上。
例：
移动一行 .在该行执行 dd
.光标移至目的地
.执行 p
复制一行 .在该行执行 yy
.光标移至目的地
.执行 p
21.11 指令重复
在指令模式中，可在指令前面加入一数字 n，则此指令动作会重复执行 n次。
例：
删除10行 .10dd
复制10行 .10yy
指标往下移10行 .10j
21.12 取消前一动作(Undo)
即复原执行上一指令前的内容。
u 恢复最后一个指令之前的结果。
U 恢复光标该行之所有改变。
21.13 搜寻
在vi中可搜寻某一字串，使光标移至该处。
/字串 往光标之后寻找该字串。
?字串 往光标之前寻找该字串。
n 往下继续寻找下一个相同的字串。
N 往上继续寻找下一个相同的字串。
21.14资料的连接
J 句子的连接。将光标所在之下一行连接至光标该行的后面。
若某行资料太长亦可将其分成两行，只要将光标移至分开点，进入输入模式 (可利用 a、i等指令)再按《Enter》即可。
21.15 环境的设定
：set nu 设定资料的行号。
：set nonu 取消行号设定。
：set ai 自动内缩。
：set noai 取消自动内缩。
自动内缩(automatic indentation)
在编辑文件或程序时，有时会遇到需要内缩的状况，『：set ai』即提供自动内缩的功能，用下例解释之：
.vi test
.(进入编辑视窗后)
this is the test for auto indent
《Tab》start indent ← ：set ai (设自动内缩)
《Tab》data
《Tab》data
《Tab》data ← ：set noai (取消自动内缩)
the end of auto indent.
.注： 可删除《Tab》字符。
21.16 ex指令
读写资料
：w 将缓冲区的资料写入磁盘中。
：10,20w test 将第10行至第20行的资料写入test文件。
：10,20w>>test 将第10行至第20行的资料加在test文件之后。
：r test 将test文件的资料读入编辑缓冲区的最后。
删除、复制及移动
：10,20d 删除第10行至第20行的资料。
：10d 删除第10行的资料。
：%d 删除整个编辑缓冲区。
：10,20co30 将第10行至第20行的资料复制至第30行之后。
：10,20mo30 将第10行至第20行的资料移动至第30行之后。
字串搜寻与取代
s(substitute)指令可搜寻某行列范围。g(global)指令则可搜寻整个编辑缓冲区的资料。
s指令以第一个满足该条件的字串为其取代的对象，若该行有数个满足该条件的字串，也仅能取代第一个，若想取代所有的字串则需加上g参数。
：1,$s/old/new/g 将文件中所有的『old』改成『new』。
：10,20s/^/ / 将第10行至第20行资料的最前面插入5个空白。
：%s/old/new/g 将编辑缓冲区中所有的『old』改成『new』。
21.17 恢复编辑时被中断的文件
在编辑过程中，若系统当掉或连线中断，而缓冲区的资料并还未被写回磁盘时，当再度回到系统，执行下列指令即可回复中断前的文件内容。
%vi -r filename
21.18 编辑多个文件
vi亦提供同时编辑多个文件的功能，方法如下：
%vi file1 file2 ...
当第一个文件编修完成后，可利用『：w』将该缓冲区存档，而后再利用 『：n』载入下一个文件。
posted @
2008-06-13 23:13 xzc 阅读(413) |
评论 (0) |
编辑 收藏