Korn Shell实例编程指南

　　学习如何用脚本建立变量、数组和函数，以及解释正规表达式。了解如何操作处理器与高效执行协处理器。控制你脚本的逻辑流程。使用过滤器分离详细的数据。通过调试和错误跟踪诊断你的脚本并使其防弹。明了如何使用面向对象的常规功能疏通你的代码。纵观Korn Shell 93，它在网站的个人应用上具有简便性。本书作者还指出和Korn Shell早期版本不兼容的地方。

暂缺《Korn Shell实例编程指南》作者简介

第1章  环境                  
     1. 1  什么是shell                  
     1. 2  什么是shell脚本                  
     1. 3  对#!/bin/ksh的解释                  
     1. 3. 1  文件属性                  
     1. 3. 2  目录                  
     1. 3. 3  chmod                  
     1. 4  umask                  
     1. 5  注释                  
     1. 6  . profile脚本                  
     1. 7  别名(aliases)                  
     1. 8  ksh环境选项                  
     1. 9  变量                  
     1. 9. 1  Shell变量                  
     1. 9. 2  内置变量                  
     1. 9. 3  环境变量                  
     1. 10  环境文件                  
     1. 11  历史文件                  
     第2章  进程控制                  
     2. 1  怎样运行一个脚本                  
     2. 2  任务和进程                  
     2. 2. 1  启动进程                  
     2. 2. 2  终止进程                  
     2. 2. 3  后台                  
     2. 2. 4  前台                  
     2. 3  信号                  
     2. 3. Ctrl键信号                  
     2. 3. 2  ps                  
     2. 3. 3  KILL                  
     2. 4  nohup命令                  
     2. 5  安排任务                  
     2. 5. 1  cron                  
     2. 5. 2  at                  
     第3章  变量                  
     3. 1  区分大小写                  
     3. 2  有效字符                  
     3. 3  标量                  
     3. 3. 1  访问                  
     3. 3. 2  赋值                  
     3. 3. 3  typeset命令                  
     3. 3. 4  四种常见错误                  
     3. 4  数组                  
     3. 4. 1  声明                  
     3. 4. 2  赋值—－两种方法                  
     3. 4. 3  访问——两种方法                  
     3. 5  只读                  
     3. 6　释放变量                  
 　　第4章　正规表达式                  
     4. 1  正规表达式与通配符                  
     4. 2  字符集                  
     4. 3  模式匹配                  
     4. 3. 1  匹配行首                  
     4. 3. 2  匹配行尾                  
     4. 4  元字符(metacharacter)                  
     4. 5  反向参照                  
     第5章  引用                  
     5. 1  转义字符                  
     5. 1. 1  不使用转义字符的*                  
     5. 1. 2  使用转义字符的*                  
     5. 1. 3  在不同的目录中不使用转义字符的*                  
     5. 1. 4  使用带有两个转义字符的*                  
     5. 2  引用选项集                  
     5. 2. 1  单引号                  
     5. 2. 2  双引号                  
     5. 3  续行                  
     5. 4  命令替换——两种方法                  
     5. 5  参数替换                  
     5. 6  数学替换                  
     数学表达式                  
     第6章  流控制                  
     6. 1  if语句                  
     6. 1. 1  退出状态                  
     6. 1. 2  ((和[[命令                  
     6. 1. 3  条件语句所用的选项                  
     6. 1. 4  if语句中的命令                  
     6. 1. 5  使用＆＆或｜｜将if语句写在一行上                  
     6. 2　复合if语句                  
     嵌套if语句                  
     6. 3  case条件                  
     6. 4  循环结构                  
     6. 4. 1  while循环                  
     6. 4. 2  untiI循环                  
     6. 4. 3  for循环                  
     6. 4. 4  select循环                  
     6. 5  循环相关命令                  
     6. 6  循环实例                  
     第7章  数据操作                  
     7. 1  函数                  
     7. 1. 1  命令行函数                  
     7. 1. 2  查看函数                  
     7. 1. 3  函数参数与命令行参数                  
     7. 1. 4  函数返回值(整数)                  
     7. 1. 5  函数返回值(字符串)                  
     7. 2  函数详述                  
     7. 2. 1  局部变量                  
     7. 2. 2  全局变量                  
     7. 2. 3  按地址传递参数                  
     7. 2. 4  面向对象的discipline函数                  
     7. 2. 5  递归函数                  
     7. 2. 6  使用自动加载函数                  
     7. 2. 7  内置函数                  
     7. 3  数学操作                  
     7. 4  过滤器                  
     7. 5  检验文件(testing files)                  
     7. 5. 1  检验字符串                  
     7. 5. 2  比较字符型函数                  
     7. 5. 3  比较数字                  
     7. 5. 4  复合条件                  
 　　第8章　信息传递                  
     8. 1　命令行参数                  
     8. 2  用户输入                  
     8. 3  重定向                  
     8. 4  协进程                  
 　　第9章  文件和目录的操作                  
     9. 1  路径                  
     9. 2　文件描述符                      
     9. 3  特殊文件                      
     9. 4  链接                      
     9. 5  目录                      
     9. 6  隐含文件                  
     9. 7  属性                  
     9. 8  权限                  
     9. 9  文件命名                  
     9. 10  访问文件                  
     9. 11  过滤器                  
     9. 12　使用临时文件                  
 　　第10章　输出控制                  
     10. 1  echo输出                  
     10. 2  printf                  
     10. 3  输出重定向                  
     10. 3. 1  子shell输出重定向                  
     10. 3. 2  循环输出重定向                  
     10. 4  多输出重定向                  
     10. 5  管道与重定向                  
     10. 6  stderr重定向                  
     10. 7  本地文档(here document)                  
     第11章  故障诊断                  
     11. 1  语法的检查                  
     11. 2  命令翻译顺序                  
     11. 3  verbose模式                  
     11. 4  执行跟踪                  
     11. 5  调试陷阱                  
     第12章  陷阱                  
     12. 1  定义和使用陷阱                  
     12. 2  注释                  
     12. 3  脚本帮助                  
     12. 4  怎样使你的脚本“防弹”                  
     第13章  综合实例                  
     13. 1  sys_check脚本                  
     13. 2  第一个sys_check的运行                  
     13. 3  第二个sys_check的运行                  
     13. 4  sys_check的数字版本                  
     附录A　实用命令                  
 　　附录B　vi教程