shell编程菜鸟教程

‘壹’ Shell的简单编程

$cat test.sh
#!/bin/bash
if [ -c $1 ];then
echo "$1是字符设备文件"
else test -e $1 || echo "This file is not exist"
fi
if test -d $2;then
echo "$2是目录文件"
for file in `ls $2/*.c`
do
ls -l $file
done
else test -e $2 || echo "This file is not exist"
fi
$./test.sh ddd.c test
test是目录文件
-rw-rw-r--. 1 flycat flycat 0 1月 1 21:20 test/aaa.c
-rw-rw-r--. 1 flycat flycat 0 1月 1 21:20 test/bbb.c
-rw-rw-r--. 1 flycat flycat 0 1月 1 21:20 test/ccc.c

‘贰’ 求更好的shell脚本初学者的教程（免费的）并且求各位大拿给初学者点建议。

其实shell脚本非常简单，以前chianitlab曾经录制过linux教学视频，包含了一些shell变成方面的知识，不过我认为还是太基础了。我建议你还是看书，先看《Shell脚本学习指南》《实战LINUX+SHELL编程与服务器管理》有了一些shell的基础，在看《高级Bash脚本编程指南》，写shell脚本一定会涉及到sed、awk、正则表达式，然后在看《sed and awk》《精通正则表达式》。

‘叁’ shell一个简单的编程，我是shell的初学者

新建一个文件比如test.sh(后缀名不是必须)，里面写入下边的内容：

#!/bin/sh
echo"HelloWorld"

然后给他一个可执行的权限chmod a+x test.sh

执行 ./test.sh

‘肆’ 编写shell脚本的基本步骤是什么

shell脚本只是命令操作的集合。就是把你手动交互输入的命令放在一个文件里，自动依次执行。

步骤大约如下：
1. 在行首指定shell脚本的解析器，如 #!/bin/bash
2. 接着依次每行输入shell的操作命令
3. 输入完毕后，给文件设置可执行权限并运行。

‘伍’ 简单的shell编程

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>

#define BUFFERSIZE 80

extern char *get_current_dir_name(void);
extern char *getenv(const char *name);
extern pid_t waitpid(pid_t pid, int *status, int options);

char buffer[BUFFERSIZE+1];

main()
{
char *path, *arg[10], *input;
int li_inputlen, is_bj, is_back, i, j, k, pid, status;
char lc_char;

while (1){
/* initiations */
is_bj = 0; /*redirection flag*/
is_back = 0; /*background*/

/* shell prompt */
path = get_current_dir_name();
printf("%s>$",path);

/*开始获取输入*/
li_inputlen = 0;
lc_char = getchar();
while (lc_char !='\n'){
if(li_inputlen < BUFFERSIZE)
buffer[li_inputlen++] = lc_char;
lc_char = getchar();
}

/*命令超长处理*/
if (li_inputlen >= BUFFERSIZE){
printf("Your command is too long! Please re-enter your command!\n");
li_inputlen = 0; /*reset */
continue;
}
else
buffer[li_inputlen] = '\0';/*加上串结束符号，形成字串*/

/*将命令从缓存拷贝到input中*/
input = (char *) malloc(sizeof(char) * (li_inputlen+1));
strcpy(input,buffer);

/* 获取命令和参数并保存在arg中*/
for (i = 0,j = 0,k = 0;i <= li_inputlen;i++){
/*管道和重定向单独处理*/
if (input[i] == '<' || input[i] == '>' || input[i] =='|'){
if (input[i] == '|')
pipel(input,li_inputlen);
else
redirect(input,li_inputlen);
is_bj = 1;
break;
}
/*处理空格、TAB和结束符。不用处理‘\n'，大家如果仔细分析前面的获取输入的程序的话，
*不难发现回车符并没有写入buffer*/
if (input[i] == ' ' || input[i] =='\t' || input[i] == '\0'){
if (j == 0) /*这个条件可以略去连在一起的多个空格或者tab*/
continue;
else{
buffer[j++] = '\0';
arg[k] = (char *) malloc(sizeof(char)*j);
/*将指令或参数从缓存拷贝到arg中*/
strcpy(arg[k],buffer);
j = 0; /*准备取下一个参数*/
k++;
}
}
else{
/*如果字串最后是‘&'，则置后台运行标记为1*/
if (input[i] == '&' && input[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = input[i];
}
}

free(input);/*释放空间*/

/*如果输入的指令是leave则退出while，即退出程序*/
if (strcmp(arg[0],"leave") == 0 ){
printf("bye-bye\n");
break;
}
/*如果输入的指令是about则显示作者信息，同时结束本条命令的解析过程*/
if (strcmp(arg[0]," about") == 0 ){
printf("right by shike，[email protected]\n");
continue;
}

if (is_bj == 0){ /*非管道、重定向指令*/
/*在使用xxec执行命令的时候，最后的参数必须是NULL指针，
*所以将最后一个参数置成空值*/
arg[k] = (char *) 0;
/*判断指令arg[0]是否存在*/
if (is_fileexist(arg[0]) == -1 ){
printf("This command is not found?!\n");
for(i=0;i<k;i++)
free(arg[i]);
continue;
}

/* fork a sub-process to run the execution file */
if ((pid = fork()) ==0) /*子进程*/
execv(buffer,arg);
else /*父进程*/
if (is_back == 0) /*并非后台执行指令*/
waitpid(pid,&status,0);

/*释放申请的空间*/
for (i=0;i<k;i++)
free(arg[i]);
}
}
}

int is_fileexist(char *comm)
{
char *path,*p;
int i;

i = 0;
/*使用getenv函数来获取系统环境变量，用参数PATH表示获取路径*/
path = getenv("PATH");
p = path;
while (*p != '\0'){
/*路径列表使用‘:’来分隔路径*/
if (*p != ':')
buffer[i++] = *p;
else{
buffer[i++] = '/';
buffer[i] = '\0';
/*将指令和路径合成，形成pathname，并使用access函数来判断该文件是否存在*/
strcat(buffer,comm);

if (access(buffer,F_OK) == 0) /*文件被找到*/
return 0;
else
/*继续寻找其它路径*/
i = 0;
}
p++;
}
/*搜索完所有路径，依然没有找到则返回-1*/
return -1;
}

int redirect(char *in,int len)
{
char *argv[30],*filename[2];
pid_t pid;
int i,j,k,fd_in,fd_out,is_in = -1,is_out = -1,num = 0;
int is_back = 0,status=0;

/*这里是重定向的命令解析过程，其中filename用于存放重定向文件，
*is_in, is_out分别是输入重定向标记和输出重定向标记*/
for (i = 0,j = 0,k = 0;i <= len;i++){
if (in[i]==' '||in[i]=='\t'||in[i]=='\0'||in[i] =='<'||in[i]=='>'){
if (in[i] == '>' || in[i] == '<'){
/*重定向指令最多'<'，'>'各出现一次，因此num最大为2，
*否则认为命令输入错误*/
if (num < 3){
num ++;
if (in[i] == '<')
is_in = num - 1;
else
is_out = num - 1;

/*处理命令和重定向符号相连的情况，比如ls>a*/
if (j > 0 && num == 1) {
buffer[j++] = '\0';
argv[k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[k],buffer);
k++;
j = 0;
}
}
else{
printf("The format is error!\n");
return -1;
}
}
if (j == 0)
continue;
else{
buffer[j++] = '\0';
/*尚未遇到重定向符号，字符串是命令或参数*/
if (num == 0){
argv[k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[k],buffer);
k++;
}
/*是重定向后符号的字符串，是文件名*/
else{
filename[status] = (char *) malloc(sizeof(char)*j);
strcpy(filename[status++],buffer);
}
j = 0; /*initate*/
}
}
else{
if (in[i] == '&' && in[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = in[i];
}
}

argv[k] = (char *) 0;

if (is_fileexist(argv[0]) == -1 ){
printf("This command is not founded!\n");
for(i=0;i<k;i++)
free(argv[i]);
return 0;
}

if ((pid = fork()) ==0){
/*存在输出重定向*/
if (is_out != -1)
if((fd_out=open(filename[is_out],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1){
printf("Open out %s Error\n",filename[is_out]);
return -1;
}

/*存在输入重定向*/
if (is_in != -1)
if((fd_in=open(filename[is_in],O_RDONLY,S_IRUSR|S_IWUSR))==-1){
printf("Open in %s Error\n",filename[is_out]);
return -1;
}

if (is_out != -1)
/*使用p2函数将标准输出重定向到fd_out上，p2(int oldfd,int newfd)实现的
*是把oldfd所指的文件描述符复制到newfd。若newfd为一已打开的文件描述词，
*则newfd所指的文件会先被关闭，p2复制的文件描述词与原来的文件描述词
*共享各种文件状态*/
if(p2(fd_out,STDOUT_FILENO)==-1){
printf("Redirect Standard Out Error\n");
exit(1);
}

if (is_in != -1)
if(p2(fd_in,STDIN_FILENO)==-1){
printf("Redirect Standard Out Error\n");
exit(1);
}
execv(buffer,argv);
}
else
if (is_back == 0) /*run on the TOP*/
waitpid(pid,&status,0);

for (i=0;i<k;i++)
free(argv[i]);

if (is_in != -1){
free(filename[is_in]);
close(fd_in);
}
if (is_out != -1){
free(filename[is_out]);
close(fd_out);
}
return 0;
}

int pipel(char *input,int len)
{
char *argv[2][30];
int i,j,k,count,is_back = 0;
int li_comm = 0,fd[2],fpip[2];
char lc_char,lc_end[1];
pid_t child1,child2;

/*管道的命令解析过程*/
for (i = 0,j = 0,k = 0;i <= len;i++){
if (input[i]== ' ' || input[i] == '\t' || input[i] == '\0' || input[i] == '|'){
if (input[i] == '|' ) /*管道符号*/
{
if (j > 0)
{
buffer[j++] = '\0';
/*因为管道连接的是两个指令，所以用二维数组指针来存放命令和参数，
*li_comm是表示第几个指令*/
argv[li_comm][k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[li_comm][k++],buffer);
}
argv[li_comm][k++] = (char *) 0;
/*遇到管道符，第一个指令完毕，开始准备接受第二个指令*/
li_comm++;
count = k;
k=0;j=0;
}
if (j == 0)
continue;
else
{
buffer[j++] = '\0';
argv[li_comm][k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[li_comm][k],buffer);
k++;
}
j = 0; /*initate*/
}
else{
if (input[i] == '&' && input[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = input[i];
}
}
argv[li_comm][k++] = (char *) 0;

if (is_fileexist(argv[0][0]) == -1 ){
printf("This first command is not found!\n");
for(i=0;i<count;i++)
free(argv[0][i]);
return 0;
}
/*指令解析结束*/

/*建立管道*/
if (pipe(fd) == -1 ){
printf("open pipe error!\n");
return -1;
}

/*创建第一个子进程执行管道符前的指令，并将输出写到管道*/
if ((child1 = fork()) ==0){
/*关闭读端*/
close(fd[0]);
if (fd[1] != STDOUT_FILENO){
/*将标准输出重定向到管道的写入端，这样该子进程的输出就写入了管道*/
if (p2(fd[1],STDOUT_FILENO) == -1){
printf("Redirect Standard Out Error\n");
return -1;
}
/*关闭写入端*/
close(fd[1]);
}
execv(buffer,argv[0]);
}
else{ /*父进程*/
/*先要等待写入管道的进程结束*/
waitpid(child1,&li_comm,0);
/*然后我们必须写入一个结束标记，告诉读管道进程数据到这里就完了*/
lc_end[0] = 0x1a;
write(fd[1],lc_end,1);
close(fd[1]);

if (is_fileexist(argv[1][0]) == -1 ){
printf("This command is not founded!\n");
for(i=0;i<k;i++)
free(argv[1][i]);
return 0;
}

/*创建第二个进程执行管道符后的指令，并从管道读输入流 */
if ((child2 = fork()) == 0){
if (fd[0] != STDIN_FILENO){
/*将标准输入重定向到管道读入端*/
if(p2(fd[0],STDIN_FILENO) == -1){
printf("Redirect Standard In Error!\n");
return -1;
}
close(fd[0]);
}
execv(buffer,argv[1]);
}
else /*父进程*/
if (is_back == 0)
waitpid(child2,NULL,0);
}
for (i=0;i<count;i++)
free(argv[0][i]);
for (i=0;i<k;i++)
free(argv[1][i]);
return 0;
}

以前写的，好像一些细节不一样，不明白的地方，发邮件给我，[email protected]

‘陆’ shell编程

1,可以自己看很简单的。
2，你输入 cd ~/,到你的默认目录
cd /到根目录
如果有 name文件 cd /na 按TAB实现自动补全

alias clr="clear"

clr 就实现清屏了

4， cat -n filenam 实现行号显示

‘柒’ 菜鸟入门问题：shell 与“终端”是什么

Shell是系统的用户界面，提供了用户与内核进行交互操作的一种接口。它接收用户输入的命令并把它送入内核去执行。
实际上Shell是一个命令解释器，它解释由用户输入的命令并且把它们送到内核。不仅如此，Shell有自己的编程语言用于对命令的编辑，它允许用户编写由shell命令组成的程序。Shell编程语言具有普通编程语言的很多特点，比如它也有循环结构和分支控制结构等，用这种编程语言编写的Shell程序与其他应用程序具有同样的效果。
Linux提供了像Microsoft Windows那样的可视的命令输入界面(也就是你说的终端)，Window是图形用户界面（GUI）。它提供了很多窗口管理器。
你的理解虽然不是很规范，但在你目前的阶段，完全可以这么理解！

‘捌’ Shell编程的基本概述

shell 提供了与操作系统通信的方式。此通信以交互的方式（来自键盘的输入立即操作）或作为一个 shell 脚本执行。shell 脚本是 shell 和操作系统命令的序列，它存储在文件中。
当登录到系统中时，系统定位要执行的 shell 的名称。在它执行之后，shell 显示一个命令提示符。普通用户的此提示符通常是一个 $（美元符）。当提示符下输入命令并按下 Enter 键时，shell 对命令进行求值，并尝试执行它。取决于命令说明，shell 将命令输出写到屏幕或重定向到输出。然后它返回命令提示符，并等待您输入另一个命令。
命令行是输入所在的行。它包含 shell 提示符。每行的基本格式如下：
$ 命令参数（一个或多个）
shell 视命令行的第一个字（直到第一个空白空格）为命令，所有后继字为自变量。
在Windows环境下，不论是使用Visual C++还是Delphi或是其他一些软件开发工具开发的应用程序，尽管存在着差别，但有一点是相同的：都是运行于Windows操作系统之下的。在程序开发过程中也经常要在自己的应用程序中加入一些Windows系统本身就有的功能，比如文件的拷贝、删除、查找以及运行程序等等。而这些功能在Windows操作系统下都是具备的，显然如果能直接从系统中调用这些功能将不仅仅减少程序的大小和开发人员的工作量，而且由于是直接通过操作系统来完成这些功能，将会大大减小这部分程序出现异常错误的概率。Windows系统虽说也存在不少错误，但常用功能的错误还是比较少的，而且通过补丁程序可以更低限度减少系统错误，因此程序员可以将调试检错的注意力放在应用程序的其他地方，对于调用系统功能这部分代码则可以不必投入太大的精力去调试，因为这部分调试的工作在操作系统发布的时候就已经由微软做好了。本文通过外壳编程，实现了搜寻文件、运行程序、控制工具条、最大最小化窗口的功能。

‘玖’ 如何系统地学习Shell编程

步骤/方法
数据库管理系统（DBMSes）
诸如PostgreSQL、 Oracle、Microsoft SQL Server，以及Informix这种专业、耐用的数据库管理系统通过存储过程或存储函数提供了脚本功能。最受广泛认可的语言选项也许是Microsoft SQL Server和Sybase所使用的TransactSQL，以及Oracle所使用的PL/SQL。 PostgreSQL提供了一个名为PL/pgSQL的类PL/SQL的程序扩展到SQL里，但它也提供了包括PL/Perl、PL/Python、PL/Ruby和 PL/Tcl在内的其他语言的选择范围。
这种编程机会虽然限定于一组特定的问题领域，但如果你是一名DBA（数据库管理员）或你的工作涉及数据库开发报告，将会亲身体验到这是非常有用的。
插件
许多新的电脑游戏提供了编写和加载插件的功能。例如，“魔兽世界（World of Warcraft）”提供了一个使用Lua脚本语言的插件系统。随着Firefox声名鹊起和广泛使用，现代网页浏览器往往也提供灵活的插件系统；在最简单的情况下，Firefox的插件都是用JavaScript编写的。开放源码的浏览器在插件开发方面往往比封闭源代码的浏览器更具吸引力，并且Chromium浏览器的插件系统，很可能成为插件开发者们的第二大目标，这是因为谷歌Chrome浏览器高调的营销策略以及不设限的许可证（permissive licensing）政策。
其他许多应用程序具有插件和扩展系统，可以提供充分的机会来培养这些迅速发展的编码技能，甚至包括一些终端仿真器（terminal emulators）和基于控制台的文本编辑器，如Vim。（透露一点好消息：我贡献了一点代码到urlpicker项目。）
实践问题
您可以尝试解决代码任务中的通用清单所提供的问题，代码任务是特别为了给程序员提供实习机会而专业设计的。欧拉（Project Euler）是一个比较流行的、不论编程语言的项目，包括“一系列具有挑战性的数学/计算机编程问题”。欧拉项目收集了上百个问题，这些问题一般从易到难，足以让你忙碌很长一段时间。
其他例子包括RubyQuiz，它多年来一直在ruby-talk的邮件列表中广受欢迎。另外还有CodeKata，它是Dave Thomas的一个规模较小、寿命较短的项目。Dave Thomas是《The Pragmatic Programmer（程序员修炼之道）》一书的合着者之一。
这些选项不适合用作自我激励型探索性学习的任务，因为它们会让人挠破头皮，但如果发现其中的乐趣，它们可以和其它方法一样用于编程实践教育。
智能手机（Smartphones）
应用程序开发行业中最大的新热潮是智能手机的应用程序。这种装置通常需要开发人员使用一种可将装置的功能发挥到极至的特定语言作为应用平台，至少要以官方认可的方式进行。
智能手机开发体系的一个新兴产业正在崛起，即允许开发人员用非智能手机平台原生的其它语言编写自己的代码，然后转化为原生语言的应用程序。 因为不需要学习任何特定的智能手机平台的官方应用程序开发语言，Web应用程序也沾了光，成为智能手机应用程序开发的一种方法。选择语言甚于平台的另一个方案是使用像诺基亚的N900这样的设备，它运行Debian发行的Linux系统，可以运行的软件范围很宽——包括很多不是为智能手机设计的软件。
侧重于多种方法开发智能手机应用程序的书籍和在线教程纷纷出现，特别是Android和iPhone的设备。一些第三方框架将可以从HTML + JavaScript 到 Ruby 或 Python编写的代码“编译”为多种平台的“本地”应用程序，有时不仅包括智能电话平台，而且包括桌面系统。对这种情况也许最令人兴奋的是，这些框架和相关的IDE不倾向于试图解决所有的编程问题，这与同样出色的编程方式的主要框架，如Visual Studio和.NET框架有所不同。这使得人们有可能通过缩小选项至一个易于管理的问题领域来显着地简化开发过程。其结果是软件开发风格令初学者感到非常易于接受。
不足之处是，在学习如何编程时，你可能很难每天都编写新的智能手机应用程序。但是，如果您的智能手机的操作系统是类Unix系统（如N900的），同样的小工具开发项目在工作站和服务器中都非常有用。
电子表格
如果使用了附带强大宏系统的电子表格程序，你将拥有一个快速的方法来阅读其他人（或物）代码，并编写自己的代码。首先，将你执行次数多、通常需要采取数个繁琐步骤的任务记录成一个宏。接下来，打开宏的源代码，阅读并进行编辑，使之更适合于一般用途。这是一个非常有限的方法，不会带来多大的长进，但可能会帮助你上路，自然地喜欢上简单的脚本代码。
使用此类脚本的最常见的电子表格程序可能是微软Excel。Excel所使用的VBA是一种贫乏的语言，但是如果你在日常工作中大量使用Excel，这可能是无论如何你都该掌握的一种技能。OpenOffice.org使用了类似的宏系统，使用方法大致相同，LibreOffice也像微软Office一样，提供了学习代码的机会。
在任何情况下，编写程序的门坎都比编写简单的命令行shell脚本代码稍高，因为菜单选项和按钮需要点击才能启用。入门的成本类似于用市场上的一种主要IDE开始一个新项目，但是一个大幅缩水的“项目”。这会是一个不错的主意，可以确保这不仅仅是在日常开发环境中编写脚本的机会，甚至是加以利用就会很有帮助的。
Unix
如果你定期使用一些类UNIX系统，在寻找锻炼初期编程技能的方式时就具有巨大的优势。UNIX在简单脚本自动化方面提供了比任何其他家庭通用操作系统的更多的使用机会，这要感谢平台上管理脚本的极大灵活性。在最不复杂的情况下，一个管理脚本可能只不过是将一系列shell命令保存到一个文件中。在此基础上，可以利用简单的循环和条件结构、输入输出处理、文件读写、计划任务来进行扩展。
通过编写简单shell脚本爽过一把后，花一段时间来学习如何用Perl、Python和Ruby编写管理脚本对任何一个Unix系统管理员都是值得的。在Unix环境使用这些语言的关键技能包括通过UNIX管道和重定向访问文本流，处理命令行选项，读写文件，使用正则表达式搜索和操作文本。管理员也想知道编程的公共基础知识，比如处理输出，循环（或在某些情况下递归），以明确界定的标准为基础，通过使用条件判断结构编程来作出决策。
编写Unix命令行工具是一块沃土，有许多机会将脚本语言的巨大能力用于编程。由于管理脚本开发的灵活性和简约性要求，编写工具的范围可以从一些有用工具的最简例子到强大的服务器进程，甚至大规模并行任务自动化，负载平衡，启发式过滤，和一些其他有趣的问题解决作业，这些问题激起了世界上最好的程序员的兴趣。
虽然几乎所有通用操作系统都具有一些使用管理脚本的能力，其中相当一部分用途比较窄，另一些操作系统则比较均衡。Unix在管理脚本的适用条件方面高人一等，因为诸如主要Linux发行版和BSD Unix系统等Unix类系统共享相同的基本运行环境设计，他们都可以从管理脚本和脚本平台之间的可移植性中受益 - 只要你按可移植性要求来写这些脚本（如通过使用sh或Perl而不是bash，选择系统标准sysctl值而不是数据源的proc文件系统）。
这些工作也适用于除开非常高级，动态，解释型语言之外的其它语言。C，C++，Haskell，Objective-C，Objective Caml，以及大量其他选项正好合适各类简单Unix工具的编写任务。对于其中的许多语言，即使要完成像小型管理工具的这样简单的工程项目，也必须学会更广泛的技能，这一要求比Perl，Ruby和Bourne shell的这样的语言高。但这些任务与GUI应用程序开发、系统编程、其它经常使用（特别是在其他平台上的）的任务比起来，其艰巨性对编程初学者来说要小得多。
实际上，鉴于Unix哲学多年来提供了大量常用工具，这些工具严格分工（大部分），并工作良好，类UNIX环境对编程新手的价值中有一部分是充分利用Unix命令行环境力量，鼓励用户像程序员那样去思考，而非观众。
Web网页
这是一个危险的建议，通过玩JavaScript来学习编程。这不是因为JavaScript是一种不好的语言，而是因为追求动态用户体验的缘故，网页已经被不加限制地滥用JavaSciprt弄得乱七八糟，因而在网页上放纵程序员新手可能会被认为是不负责任的。在网页中JavaScript也有一些积极用法，而且可以让新手们对编写在浏览器中运行的桌面应用程序的想法愈来愈感兴趣，这给了我们在程序员职业生涯中尽早开始学习JavaScript的很多理由。
事实上，JavaScript是一种最常见的、单独的客户端网页脚本，这也意味着JavaScript可能是最简单的语言，通过阅读别人的代码就能学习。找到具有客户端动态元素的任何网页，然后右键单击并选择查看页面源代码的选项，你就会发现它布满了JavaScript的散落片段。对于更复杂的动态页面，（X）HTML的网页甚至可能引用一个纯代码的单独.js文件。
在把代码上传到公共访问的Web服务器前要细心检查；确保它是好的。如果你想让更多的有用脚本以本地方式来启动，浏览器扩展性可以让你将任意脚本应用到你查看的网页上——而且只适用于你个人的浏览体验。Firefox的Greasemonkey是一个例子。

‘拾’ shell编程的基本步骤

额。。。这个问题。。不知道你要问的步骤具体指什么？是指编写脚本的步骤还是想问学习shell进行编程？

1.一般脚本的第一句是“#!/bin/sh”，是指此脚本使用/bin/sh来解释执行；

2.然后，就是开始编写这个脚本的代码了：为什么要编写这个脚本，目的是什么，就会有什么样的算法啊代码命令等等的；

3.代码写完了，就是调试了