Image MagicK 是一个强大的图象处理工具包。它提供了几个非常方便的命令行命令: display, animate,import, montage,mogrify,identify等，可以进行图象的显示，缩放，旋转，调色，加框，加注释等，还能制作GIF动画，图象索引，能自动生成图象.

1. 制作索引图和动画

   !/bin/bash
   montage -bordercolor red -borderwidth 3 -label "%f" -tile 5x3 *.JPG montage.jpg
   mogrify -format gif *.JPG
   display montage.jpg
   animate *.JPG

2. 缩放 convert -sample 80x40 input.jpg output.jpg #注意：缩放后图像保持原来的长宽比例 convert -sample 25%x25% input.jpg output.jpg
3. 为当前目录的所有图像生成缩略图

   for img in `ls *.jpg`
    do
      convert -sample 25%x25% $img thumb-$img
    done

4. 获取文件信息 libtiff

   tiffinfo filename.tiff
   pnginfo filename.png

5. 可以使用 ImageMagick 的 identify

   identify -verbose sample.png 
    identify -format "%wx%h" sample.png

6. 旋转图像

   convert -rotate 90 input.jpg output.jpg

7. 更改文件类型

   convert input.jpg output.png

8. 为图像增加注释文字

   convert -font helvetica -fill white -pointsize 36 \
    -draw 'text 10,50 "Floriade 2002, Canberra, Australia"' \
    floriade.jpg comment.jpg 
   convert -font fonts/1900805.ttf -fill white -pointsize 36 \
    -draw 'text 10,475 "stillhq.com"' \
    floriade.jpg stillhq.jpg

9. 特殊效果

   convert -charcoal 2 input.jpg output.jpg #炭笔
   convert -colorize 255 input.jpg output.jpg #着色 可以指定三种颜色 red/green/blue
   convert -implode 4 input.jpg output.jpg  #内爆效果
   convert -solarize 42 input.jpg output.jpg #曝光，模拟胶片曝光
   convert -spread 5 input.jpg output.jpg  #随机移动，参数是位移大小

10. 一次执行多个操作

    convert -sample 25%x25% -spread 4  -charcoal 4 input.jpg output.jpg

topImageMagick FAQ 摘要

1. 如何让animate在显示图片的过程保持窗口的标题不变

   animate -title "My Image Sequence" images.

2. import抓得的图片与X服务器上显示的不一致怎么办？

   import -descend image.miff

3. 如何动画显示YUV 图片序列?

   animate -geometry 352x240 -scene 0-71 yuv3:frame%d

4. 如果只看一个RGB图片的红色通道(red channel)?

   display -gamma 1.0,0.0,0.0 image.miff

5. 如何改变PostScript默认纸张大小?
   要改变默认的612x792大小，修改magick/image.h中的PSPageGeometry的值并重编译.
6. 如何自左至右无边无框无文字半三幅画连接在一起？

   convert +append image1.ppm image2.ppm image3.ppm side_by_side.miff
    # 或
   convert -size 350x500 xc:black composite.miff
   composite -geometry +0+0 composite.miff image1.gif composite.miff
   composite -geometry +100+0 composite.miff image2.gif composite.miff
   composite -geometry +0+300 composite.miff image3.gif composite.miff
   composite -geometry +0+375 composite.miff image4.gif composite.miff

7. 如何生成gif动画?

   convert -delay 20 frame*.gif animation.gif
   convert -delay 20 frame1.gif -delay 10 frame2.gif -delay 5 frame3.gif animation.gif
   convert frame1.gif -page +50+100 frame2.gif -page +0+100 frame3.gif animation.gif
   convert -loop 50 frame*.gif animation.gif
   convert +adjoin images.* frames%d.gif

8. 如果完整的显示PostScript图片？

   display -page letter image.ps

9. 什么是图片目录？如何使用它们?

   #图片目录（visual image directory ，VID）的创建：
      montage *.jpg directory.vid
      convert 'vid:*.jpg' directory.vid
   #显示图片目录
      display directory.vid
      display vid:movie.mpg

10. 如果带框架保存一个窗口?

    xwininfo -frame
    import -frame -window ID window.miff

11. 图片以单一颜色（a solid color）显示，是怎么回事？ 图片被破坏，或含有值为0的matte层，试着:

    display +matte image.miff

12. 出现 "???? library is not available ..."是怎么回事? 没安装相关的函数库。参见安装说明。
13. 如何查看图片不光滑层(matte channel)的值？

    convert image.tiff image.matte
    display -size 640x480 gray:image.matte

14. 运行"Convert in.gif out.png" 时显示 "Invalid Parameter - out. 你运行的convert是windows的分区类型转换程序。
15. 如何在图片增加斜角?

    #对图片边缘的处理共分四类。
     1）增加有色边
    convert -bordercolor red -border 25x25 image.jpg image.gif
     2）加亮或变暗图片边缘，以增强3D效果
    convert -raise 25 image.jpg image.gif
     3）在图片周围增加装饰性框架。
    convert -mattecolor gray -frame 25x25 image.jpg image.gif
     4）在图片边缘增加升、降斜角
    convert -mattecolor gray -frame 25x25+0+25 image.jpg image.gif
    convert -mattecolor gray -frame 25x25+25+0 image.jpg image.gif

16. 用窗口管理器运行display失败了，怎么办? 用下列命令之一来确认display运行在一个交互环境中：

    display logo:Untitled
    display < /dev/console

17. 将PostScript文件转换为其它格式时，如何改善文字的外观？

    convert -density 288 -geometry 25% image.ps image.gif

18. 如何用2－3英寸高的文字注释一个图片? 先检查有无可缩放字体： xlsfonts -fn '*-0-0-0-0-*'　有则：

    convert -font '-*-helvetica-*-*-*--300-300-*-*-*-*-iso8859-1' \
            -fill green -draw 'text 50,300 Magick' image.gif annotated.gif
    # If you have the FreeType support built into ImageMagick,
    # just increase your pointsize and/or density:
    convert -font Helvetica -pointsize 100 -density 300 ...

19. 如何将gif文件分析为一系列的单个图片？

    convert animation.gif frame%02d.gif

20. 用NetScape显示的图片，如何去掉周围的背景色？ convert +page alpha.gif beta.gif
21. 如何用web安全的颜色（Web safe colors）创建GIF或PNG图片？

    convert -map netscape: alpha.gif beta.gif

22. 为何Adobe Acrobat 2.1不能读ImageMagick's制作的PDF? 用 Acrobat 3.0或以上版本，来阅读这种经zip压缩的pdf，或制作PDF时不进行压缩。

    convert +compress images.tiff image.pdf

23. 如何在图片上增加一个不光滑层(matte channel)?

    convert image.gif -matte temp.miff
    composite -compose CopyOpacity mask.xbm temp.miff transparent.gif

24. 在NT环境下如何用convert在图片上写字？

    convert -font Arial -fill blue -draw "text 10,10 'your text here'" d:\test.tif png:d:\test.png
    convert.exe -pointsize 18 -draw "text 0,0 "This is my text!"" C:\blank.gif c:\text.gif

25. 为何GIF文件比期望的大? 需要在编译源码时加 --enable-lzw 参数，来打开LZW压缩功能。
26. 为何JPEG文件比期望的大? 可能嵌入Exif或IPTC等"profiles", 或者含有没压缩的thumbnails. 可以用命令行参数 +profile ""或相关的API来将它们去掉。 "或相关的API来将它们去掉。
27. 如何从图片文件中抽取第一张图片？

    convert "Image.gif[0]" first.gif

28. 如何创建一张空白图片？

    convert -size 800x600 xc:"#ddddff" ltblue.ppm
    convert -size 800x600 null:white white.ppm
    convert in.png -threshold 100% black.ppm  #<--与in.png同大小

29. 为何GIF文件比期望的大? 需要在编译源码时加 --enable-lzw 参数，来打开LZW压缩功能。
30. 为何JPEG文件比期望的大? 可能嵌入Exif或IPTC等"profiles", 或者含有没压缩的thumbnails. 可以用命令行参数 +profile "

top使用笔记

1. 把matlab中画出的多幅图作成GIF动画

   for i in `ls *.jpg`; do convert -trim -resize 350x305 $i crop.$i; done
    convert -delay 10 -loop 3 crop.frame*.jpg string.gif
    rm crop.frame*.jpg

2. 生成png格式的email地址

   convert -size 185x19 null:white email.png
   convert -font monospace -fill black -pointsize 16  -draw 'text 4,14 "youremail@yourdomain"' email.png email.png 
   convert -font monospace -fill blue -pointsize 16  -draw 'text 3,13 "youremail@yourdomain"' email.png email.png

Chapter 1. Introduction

Unix: #!/usr/bin/perl -w or   #!/usr/bin/env perl (use -w because we like warnings)
windows: #!perl

Chapter 2. Scalar Data
Scalar data: undef, double(integer is actually doubles), string
List   data: list of scalar element. refer to Chapter 3.

undef data: it's another kind of scalar data. if you use a var without definition, it contains undef value, not string or doubles
eg.
$blank = $fred[142_857]; will try to get the 142_857th var which is not defined and an undef data tyep value is returned to $blank
undef value are widely used to represent "no ordinary value to return". eg. <STDIN> return undef if reaching the EOF. so we'll omit many such cases in the following note.
we can use defined(xxx) function to return true for defined value and false for undef value in condition test.

double begins with:
0(Octal base8)
0x(Hex base16)
0b(Bin base2)

string's char can be like:
\0.. char in octal
\x.. char in hex

string should be used with '' or ""
'': only \ can be used to escape sth.
"": \, $ and @ can be used. (@ is used to lead array, but unfortunately % is not allowed to lead hashes)

special operator:
"hello"."world" = "helloworld"
"fred"x3 = "fredfredfred"
5x4 = "5555"

how to use warnings:
(1) -w added to the perl command
(2) use warnings;
how to use diagnostics(warings with long message):
(1) use diagnostics;
(2) -Mdiagnostics added to the perl command

always use $ ahead of a variable !! (don't confuse it with shell var usage)

print:
(1) use , to seperate params:
print "the answer is", 6*7, ".\n";
(2) use ${} to keep clear:
print "fred ate ${what}s.\n"   or you can
print "fred ate $what"."s.\n"

unlike shell, single var need not "" to avoid empty string error

comparasion operator is opposite to shell:
doubles: == != < > <= >=
strings: eq ne lt gt le ge

boolean:
double: 0 false others true
string: '' false others true
others: convert them to double or string first

input:
just $line=<STDIN>; then you get the line including the '\n' in $line

chomp:
remove the last '\n' of a string
it's very useful because it's simplicity. and it's often used after $line=<STDIN> to
get rid of the last '\n'

Chapter 3 Lists and Arrays
List are list of scalar values(right value), Array is simply an variable to hold the list(left value)
ie. List are just collection of variables to represent collection of values. we can use ($fred, $barney) to represent the two variables as a whole. so you can do some operations on them as a whole. eg. assignment to them can be done like this: ($fred, $barney)=(1,2); so essentially list has nothing to do with array. But array use list internally to hold data.
And any place where scalar value is used, list can be used!!

we can use list to exchange two vars:
($fred, $barney)=($barney, $fred);

to use array, you don't need to define it, just use it! it will extend itself on need.
do it like this: (we use $ to refer an element, @ to refer the whole array)
$rocks[0]='haha';
$rocks[99]='schist'; (the var $#rocks indicate the last element index, ie. 99)
@rocks=(1,2,3,4,5,6);
@rocks=(1..10);
@rocks=("bedrock", "slate", "lava"); equals @rocks=qw(bedrock slate lava);
(qw can help us to avoid the "", it can use () !! ## // etc... to enclose values)
@home=(@rocks, "mother", "father");

pop, push, shift, unshift -- the faster way to resize the array.(compared with index)
We use them if possible instead of index !!!!!
@array=(1..10);
@m = pop @array;   #(1..9)
push @array,10;    #(1..10)
@n = shift @array; #(2..10)
unshift @array,1; #(1..10)

use foreach to iterate list(array) like this:
we iterate list, so () is needed after the $loopvar.
foreach $loopvar (@array) {
# do sth
}
foreach $loopvar ("bed", "room", "chair")) {
# do sth
}
foreach $loopvar (qw(bed room chair)) {
# do sth
}
but we always omit $loopvar, because the system defined $_ will play the role. and functions like print will by default use $_ if you just type print;
foreach (@array) {
print "$_";
}

reverse and sort: -- if you don't assigned it to left value, nothing happened !!
we can use them to do operation on a list/array:
@fred = reverse @fred;
@fred = sort @fred;

the most important section of this book: -- you must get used to it!!!
expression(like variable, function)'s value is dependent on what is expected, ie: scalar value or list value.
it may sound strange to C programmers because the function's return value is also dependent on what is expected. eg:
@list = @people # a list
$n = @people    # people list's elements count is assigned to $n !! very useful !!!
@backwards=reverse qw(yabba dabba doo); # a list is reversed and asigned
$backwards=reverse qw(yabba dabba doo); # a list is reversed and catenated to a string which is assigned to backwards.

<STDIN> can be used in list value context:
@lines = <STDIN>; # every line will be treated as an element and EOF will end the reading. CTL+D on Unix or CTL+Z on Windows leads to EOF.
chomp(@lines=<STDIN>); can also be used.

Chapter 4 Subroutines
-------- below is a perl script of quick reference to usage of subroutines ---------
#!perl
use strict;
# we always use strict to be strict to our potential errors.
# if use strict is used, global var is not allowed !!! always use my() before your vars

sub saysth {          
# my must be used if local var are to be defined. and () must be used if more than one vars.
# @_ is the predefined var for params list whose index starts from index 0.
# this line is very common to assign params to meaningful names, and use them later instead of @_.
# and $_[] is used to access @_'s elements if you want to use @_ directly.
# NOTICE: the $_[] has nothing to do with the $_(which is widely used, eg. the loop var of foreach)
my ($father, $son) = @_;
print $father, $_[0]; # the two var are the same
print $son, $_[1];     # the two var are the same

# this is the scalar context, so we assign @_'s elements count to arg_count
my $arg_count = @_;    # always use my to define local variables ! we seldom need global ones.
print "$arg_count\n";

# use wantarray fun to test where we return to scalar or list context.
# but if no proper value can be returned , we simply use "return" to automatically
# return undef in scalar context and null list in list context
if (wantarray) {
   (1..10);      # we always omit return if this is the last sentence to execute.
}else {
   return 5;     # strict programmers like to use return.
}
}

my @cows = &saysth;
my $sheep = &saysth;

print "@cows\n";
print "$sheep\n";

-------- endof perl script --------

NOTE: about ()
sth you must know: fun(a, b, c); is the same as what we see in C language. but we often omit (), ie. fun a, b, c;

Chapter 5 Input and Output
1. how to input
we use:
while (<STDIN>) {
chomp($_);
print "I saw $_";
}
instead of
while (defined(my $line=<STDIN>)) {
chomp($line);
print "I saw $line";
}
because it's complicated,
instead of
foreach (<STDIN>) {
print "I saw $_";
}
because foreach requires a list value, which cause <STDIN> to hold the whole input until EOF is encountered,
and then enter the foreach loop which will cause bad performance in reading large files !!!

NOTE: <STDIN> may return a scalar of a list too.

2. how to act like unix tool behavior:
(1) file arg can be replaced with -
(2) perl script can be used in pipe condition
eg. "cat file1.txt file2.txt" can be replaced with "cat -" (or just cat) if you prefer STDIN
we use:
while (<>) {
chomp;
print "It was $_ that I saw!\n";
}
instead of
while (define(my $line = <>)) {
chomp($line);
print "It was $line that I saw!\n"
}
because it's complicated,
NOTE: <> may return a scalar of a list too.

3. @ARGV
the cmd line args array which we can use "shift" or "foreach" to iterate
eg.
my $arg1 = shift @ARGV;

4. output the array:
my @array=qw(sheep cow chick);
print @array; # sheepcowchick
print "@array" # sheep cow chick

5. cat and sort
print <>;        # <> return a list. and print display it.
print sort <>;   # the unix sort function

6. weird print:
print (2+3)*4; # only 5 is printed. because if there's () behind print, print will be used as a function. it will only print the result in () and return , saying 1.
so do it like this:
print ((2+3)*4);

NOTE: if () is given, print only print the result in (). if not given, print will print all the stuff following itself, ie. treat them all as a list value.

7. printf:
the same as C printf.
eg.
printf ("%12.3f\n", 6*7+2/3); # width is 12, right alignment, allow 3 digit after the dot of float

except:
(1)%g is provided to automatically select float, int or exp
(2)%% can be used to print "%". not \% !!!!! \% won't work :(
(3)print array:
printf "The items are:\n".("%10s\n" x @items), @items;
# the first @items is in the scalar context and return the size of the array.
# the second @items is in the list context and return the list of the array.

8. the filehandle
6 predefined: STDIN, STDOUT, STDERR, DATA, ARGV, ARGVOUT
(1) open file for read,write,append:
open CONFIG, "<dino.txt";    # open dino.txt for read, CONFIG is the filehandler
open BEDROCK, ">fred.txt";   # open fred.txt for write, BEDROCK is the filehandler
open LOG, ">>logfile.txt";   # open logfile.txt for appending, LOG is the filehandler
(2) close file:
just "close filehandle;"
(3) check open error:
if (!open LOG, ">>logfile.txt") {
die "open logfile.txt error: $!";
    # we use $! to get what perror give us, ie. system error info
# if we dont use the linux system API, omit the $! here.
}
or you can use a var to hold the return value:
my $success = open LOG, ">>logfile.txt";
if (!$success) {
die "...";
}
or we can just use "warn" to warn users without exit.
(4) read from/write to filehandler (predefined or user-defined filehandler)
read:
if (!open PASSWD, "/etc/passwd") {
die "how did you get logged in?($!)";
}
while(<PASSWD>){
chomp;
#...
}
write: use print or printf
print LOG "Captain's log, stardate 3.14159\n";
printf LOG "%d percent complete.\n", $done/$total *100;
or look more like c:
printf (LOG "%d percent complete.\n", $done/$total *100);
(5) how to make the default output to other filehandle other than STDOUT ?
select PASSWD; # select can be only used to choose which filehandler to output
# do sth dirty
select STDOUT; # set it back
(6) how to direct STDERR etc. to files instead of let user use > in command line ?
just reopen them:
if (!open stderr, ">>/home/barney/.error_log") {
die "Can't open error log for append:$!"
}
now, every stderr message will be sent to .error_log

Chapter 6 Hashes
example makes every clear:
--------
#!perl
use strict;

my %stupid_hash = ("she",20,                 # we can create a hash table like this
       "me", 21);
my %silly_hash = ("she"=>20, "me"=>21);      # we can also create a hash table like this using => instead of ,
$silly_hash{"we"} = "41";                    # we can create a new "key-value" pair like this

print %silly_hash,"\n";          # result is "she20we41me21", in which we can see that the sequence
            # is based on the actual storing structure not the input sequence
            # and % is not special in " " !
my @hash_array = %silly_hash;      # we can also do assignment from hash to list(array).
print "@hash_array\n";

my %clever_hash = reverse %silly_hash;         # now values become the keys !
my @keys = keys %silly_hash;             # only get the keys list
my @values = values %silly_hash;       # only get the values list
my $count = keys %silly_hash;             # here the keys are in scalar context which return the count of keys
print %clever_hash, "\n@keys\n@values\n$count\n";

# method 1 for iteration:
# the each function will return a list contains only the current pair. when there's no more pairs,
# the each will return empty list to ($key, $value) which will cause $key and $value to be undef.
# but the key points here is: the empty list in while() scalar context will return 0 to indicate
# the element is has. so the while will quit. (in condition, like C, 0 indicates false)
while((my $key, my $value) = each %silly_hash) {     # each is only used in while in actual use.
print "$key => $value\n";
}

# method 2 for iteration:
# if you want to sort what the %silly_hash returns, use sort which return a list.
# then use foreach to iterate the list.
foreach my $key (sort keys %silly_hash) {
my $value = $silly_hash{$key};
print "$key=>$value\n";
}

# use exists to test where a key exists.
if (exists $silly_hash{"she"}) {
print "she exists!\n";
}

# delete a key=>value pair
delete $silly_hash{"she"};
print %silly_hash;
---------

Chapter 7 In the World of Regular Expressions
compared with Chapter 8&9, this chapter tell us the general RE patterns.
special points: (in addition to common sense)
(1) /./ dosen't match the new line char
(2) how to match any string including null string:
/(fred)*/ matches any string including null string.(because * can match 0 fred, which means every string)
(3) /fred (and|or) barney/ matches fred and barney, fred or barney.
(4) abbr.: [0-9] => \d    [A-Za-z0-9_] => \w    [\f\t\n\r ] => \s
so we often see \w+ \s+ etc ...
(5) abbr2: [^\d] => \D    [^\w] => \W     [^\s] => \S
(6) [\000-\177]+ matches every 7 bits ASCII char string
[\dA-Fa-f]+ matches any hex numbers
(7) how to match any char including new line char:
[\d\D] which means any digit and any non digit, ie. any chars
(8) to bound sth:
bound is the "visual char" which dosen't really exist in string.
^ head
$ tail(including \n)
\b bound of a word(\w) (every word has two bounds. actually \< \> is more common in general RE)
eg.
/\bhunt/ matches hunt, hunting, not anthunt.
/\bhunt\b/ matches hunt, not any other words.
\B is the opposite of \b which means not a bound.
(9) how many times:
eg.
/(fred){5,15}/
/(fred){5,}/    # equal or more than 5 times
/\w{9}/
(10) backreferences:
NOTICE: \n refer to the n th () before it. here we add {2} after \1 to match the "theretherethere"
eg.
$_="Hello theretherethere, neighbor";
if (/(t\w{4})\1{2}/) {
print "words were $1";
}

Chapter 8 & 9 Matching & Processing with Regular Expressions
this chapter tell us the especial perl style expression to use RE to process text.
these symbols are only for use in perl, like /i to ignore case.
1. m//
you can use m{} m<> ... but we often use m//. actually, // is the abbr of m//.
the m// return true of false, so we can use it directly in condition test.
NOTICE: if we choose // to enclose the RE, we must use \ to escape / in RE if we wanna match /.
(1) basic usage:
$_="Hello kitty!";
if (/kitty/) {
print "found!\n";
}
(2) useful flags:
/i: ignore case
if (/Kitty/i) {
print "found!\n";
}
/s: to let . to include \n
if (/Barney.*Fred/s) {
print "found!\n"
}
/x: to let you use space and comment
you may wanna know this topic if you wanna you RE more readable.
(3) "matching variable":
() in perl has special usage except grouping REs. we can use $1 ~ $n to refer to them after matching completes, which is very powerful.
NOTICE: VERY IMPORTANT!!! use it only when you know that the matching will succeed, otherwise the "matching variables" will remain the value as that of last time successful matching.
eg.
$_="Hello there, neighbor";
if (/(\S+) (\S+), (\S+)/) {
print "words were $1 $2 $3\n";
}
(4) slow "matching variable":
these 3 vars cause other perl RE processing slow. but if convenience is what you want,use them.
int the following case, $& is the matching part, $` is anything before that, $' is anything after that. so if you put these 3 vars together, you get the whole string.
eg.
if ("Hello there, neighbor" =~ /\S(\w+),/) {
print "That was ($`)($&)($')";
}
(5) the "binding operator" =~ can help us to use self-defined var instead of $_:
NOTICE: =~ return true of false which can be used in conditon testing.
eg.
my $str = "I dream of betty rubble.";
if ($str =~ /\brub/) {
print "Aye, there's the rub.\n";
}

2. s/A/B/
return a bool value. true for successfully replace. false for failure.
NOTICE: A is a Regular Pattern, and B is a normal string(so don't need escape char like \ in B)
(1) basic:
---- use $_ -----
$_ = "cow is not sheep!";
s/cow/dog/;
print "$_\n";
---- use local var ----
my $filename =~ s/cow/dog/; # the =~ here also returns true for matching, false for no matching
print "$filename\n"
(2) common replace and insertion:
$_="green scaly dinosaur";
s/(\w+) (\w+)/$2,$1/; # replace eg. result "scaly, green dinosaur"
s/^/huge, /;           # insert at the beginning. result "huge, scaly, green dinosaur"
s/$/ child/;           # insert at the end. result "huge, scaly, green dinosaur child"
s/\w+$/($`!)$&/;       # example of using $` and $& (possibly $' to do insertion)
s/\s+/ /g;             # use g to do global replacement. here we shrink spaces.
(3) case swith:
$_="I saw Barney with Fred.";
s/(fred|barney)/\U$1\E/gi; # result "I saw BARNEY with FRED.";
# here we use \U to make $1 in upper case. use \E to indicate the end of conversion.
we can also use \L to make them in lower case. use \u to make only the first char in upper case and \l to make the first char in lower case.
(4) use bake file:
$^I=".bak"; # if we set $^I, s/// will do real change, and bake the old file as *.bak
while(<>) {
s/^Author:.*/Author: Randal/;
s/^Phone:.*\n//;
s/^Date:.*/Date: $date/;
print;
}

3. split and join
my $x="4,6,8,10,12";
my @values = split /:/, $x; # the string in // can be regular patterns. now we get @values as list (4,6,8,10,12);
my $z = join "-", @values; # now we get $z as a scalor "4-6-8-10-12"

4. useful m// in list context:
we often use m// in list context to return the matching strings list!! (or we can say, to extract what we want out of the target string. it's simpler than $1,$2,...):
eg.
my($first, $second, $third) = /(\S+) (\S+), (\S+)/; # now we get the 3 matching strings in these 3 my vars
my @words = /[a-z]+/ig; # now we get all matching in @words. (notice: we use g here)
my %last_name = /(\w+)\s+(\w+)/g; # we use hash to store every pair of matching.

5. don't be too greedy:
use ? after + * {3,8} ? to try to be not greedy (ie. don't try to match the maximum string)
eg. we want to remove all the paired <BOLD></BOLD>, but keep what between them:
   I thought you said Fred and <BOLD>Velma</BOLD>,not <BOLD>Wilma</BOLD>
if we use s/<BOLD>(.*)</BOLD>/$1/g, the result is not what expected.
so we use s/<BOLD>(.*?)</BOLD>/$1/g, the result is what we want.

6. command line:
(1) behave like sed:
ls | perl -e 'while(<>){s/try/cow/;print;}'
ls | perl -p -e 's/try/cow;' # we use -p to replace the while(<>), which make it more like sed.
(2) behave like sed -n:
ls | perl -n -e 'print if s/try/cow;'

7. use () only for grouping, not var --- use ?:
/(?:bronto)?saurus (steak|burger)/
# here we add ?: before bronto, because the bronoto here is just for grouping sths togther(here we only use bronoto) to use ?. we don't want (bronto) to be $1.

Chapter 10 More Control Structure
don't need to know. recognizing them when meeting them is enough.

Chapter 11 Perl Modules
1. basic usage:
just type "using modules_name;", then you can use the function or objects names imported.
(1) use File::Basename;        # import all names from File::Basename. eg. you can use "dirname" function now.
(2) use File::Basename qw/ /; # don't import functions names. you can only use these functions using full name, eg "File::Basename::dirname". this allow you to use your own function with the same name.

2. modules introduced in this Chapter
(1) File::Basename
extract parts from a path name, the frequently used functions are dirname and basename
eg.
use File::Basename;
print "Please enter a filename:";
chomp(my $name = <STDIN>);
my $dirname = dirname $name;
my $basename = basename $name;
(2) File::Spec
this module is frequently used to deal with file system related differences. for example: we don't need to care about using \ or / to seperate path parts. so if you need to write plateform-independent code, use File::Spec
eg.
use File::Spec;
...
my $new_name = File::Spec->catfile($dirname, $basename);
rename($old_name, $new_name)
or warn "Can't rename '$old_name' to '$new_name': $!";
(3) DBI
the DBI module is used to deal with DB operations. the interface is uniform.

Chapter 12 File Tests
this chapter introduce some useful functions to abtain file info
1. file tests:
these test flags return bool(true/false) or file info(eg. file size)
eg. return type is bool
if -r $filename {
...
}

eg. return type is size
my $size = -s "hello.pl";
print $size;

eg. multiple flags
if (-r $file and -w $file) {
...
}
(refer to P180 for all test flags)

2. stat and lstat:
we use them to abtain inode info about the file( lstat for link file)
eg.
my($dev, $ino, $mode, $nlink, $uid, $gid, $rdev,
   $size, $atime, $mtime, $ctime, $blksize, $blocks)
= stat($filename);

3. time
we use time to get current timestamp, use localtime to convert timestamp to human readable localtime, and use gmtime to convert timestamp to human readable Universal Time(Greenwich Mean Time).
my $timestamp = time;
my $date = localtime $timestamp; # scalar context: Fri Jul 24 15:43:40 2009
my ($sec, $min, $hour, $day, $mon, $year, $wday, $yday, $isdst)
= localtime $timestamp;         # list context
(notice: if using localtime and gmtime without params, they use the current timestamp by default.)

4. Bitwise Operators:
&, |, ^, <<, >>, ~   they are the same as C.

Chapter 13 Directory Operations
this Chapter just tell us: perl supplies many Unix API functions(most of them is with the same name!!)
so we don't need to check them one by one. If we need an operation, just use the Unix API/command
name to look up in the perldoc.
eg.
1. chdir "/etc" or die "cannot chdir to /etc: $!";
2. shell globbing:
foreach $arg (@ARGV) {
print "one arg is $arg\n";
}
the result of running "./perl_script *.pm " in shell line:
one arg is barney.pm
one arg is dino.pm
one arg is fred.pm
one arg is wilma.pm
3. perl globbing:
use "glob" operator:
eg.
# use space to seperate patterns. here we seperate .*(.files) and * (all other files)
my @all_files_including_dot = glob ".* *"; # without dir, .* and * refer to files in current path.
my @all_files_including_dot = <.* *>;       # <> is another syntax to do perl globbing
4. rename
foreach my $file (glob "*.old") {
my $newfile = $file;
$newfile =~ s/\.old$/.new/;
if (-e $newfile) {
   warn "cannot rename $file to $newfile: $newfile exist\n";
}elsif (rename $file, $newfile) {
   #success, do nothing
}else {
   warn "rename $file to $newfile failed: $!\n";
}
}
5. $$ is the PID
my $temp_dir = "/tmp/scratch_$$";
6. other functions:
mkdir "fred", 0755 or warn "cannot make fred dir: $!"
opendir, readdir, closedir
File::Find (like unix find command) --- very good!!! if you want to do recursive dir work.
unlink, rmdir, rmtree (eg. unlink glob "*.o";)
link, symlink
chmod 0755, "fred"
chown $user,$group,glob "*.o"
utime ( it's used to change timestamp of file, access, modification time)

Chapter 14 Strings and Sorting
perl supplies us with some string manipulating functions to ease the string operation instead of Regular Expression.
1. Strings manipulation:
my $where1 = index($stuff, "wor");
my $where2 = index($stuff, "wor", $where1+1);
my $last_slash = rindex("/etc/passwd", "/");    # value is 4
my $part = substr($string, $init_position, $length);
my $out = substr("string", -3, 2);    # value is "in"
substr("$string", 0, 5) = "Goodbye"   # cool! the substr can be replaced like this.
substr($string, -20) =~ s/fred/barney/g;   # use substr to restrict the RE to work in the last 20 chars
my $date_tag = sprintf "%4d/%02d/%02d %2d:%02d:%02d", $yr, $mo, $da, $h, $m, $s;
my $money = sprintf "%.2f", 2.49997;

good example:
# this line uses loop and regular expression to add , between every 3 digits, cool!!
1 while $number =~ s/^(-?\d+)(\d\d\d)/$1,$2/;

2. Sorting:
before we simply use "sort" function, here we talk about the advance use of "sort".
usage:
sort fun @list
here fun is the function you define yourself which takes the same effect as "function object" in C++ STL algorithm method.
this book give 2 example to illustrate the use of advanced sort. They are "sorting a hash by value" (we can just sort keys in normal use), and "sorting by multiple keys"

Chapter 15 Smart Matching and given-when
1. Smart Matching:
It's too powerful! because if you use ~~, the perl will decide how to compare the left and the right operands.
In the condition of comparing each items in hash or list to a pattern, etc. it will save your effert by typing just one line!!!!
look for the table 15-1 in P224 to see how to use ~~
eg.
(1) array comparasion:
use 5.010;
say "The arrays have the same elements!" if @names1 ~~ @names2; # traditionally we have to use a loop to compare.
(2) finding hash key matching RE:
use 5.010;
say "I found a key matching 'Fred'" if %names ~~ /Fred/;   # traditionally we have to use a loop to compare.

2. given-when -- the C switch equivalent:
it's more powerful than switch, because you can do any comparison in the when block.
NOTICE: break is implicitly added. so if you want to "fall down", add "continue" manually.
eg.
use 5.010;
given( $ARGV[0] ) {
when( /fred/i )    { say 'Name has fred in it'; continue;}    # RE
when( 'Fred' )    { say 'Name is Fred'}       # string
when( ! 'Fred' )    { say 'Name is not Fred'}         # use !
when( $_ ~~ /^Fred/ ) { say 'Name is Fred'}                      # $_ is explicitly used
when( $_ > 10 )       { say 'Number is less than 10'}          # > is used
when( sub($_) )       { say 'Number is cool!'}        # we can use sub here
when( 1 == 1 )        { say 'I don't see a Fred'}        # we can use anything here
default            { say "I don't see a Fred"}
}

3. foreach-when:
this structure is used when there are many items to be processed by given-when.
eg.
use 5.010;
foreach ( @names ) { # don't use a named variable!
when( /fred/i ) { say 'Name has fred in it'; continue }
when( /^Fred/ ) { say 'Name starts with Fred'; continue }
when( 'Fred' ) { say 'Name is Fred'; }
default    { say "I don't see a Fred" }
}

Chapter 16 Process Management
1. system
it create a child process and then wait for its ending.(if we add & after command, the father won't wait)
the "system" function in perl has two version:
(1) the single argument version:
system $command_line;   # shell is automatically called to process $command_line.
eg.
! system "rm -rf files_to_delete" or die "something went wrong";
(2) the multiple argument version:
system "/bin/sh", "-c", $command_line;   # the command "/bin/sh" is called by system with arguments.
(this version doesn't call shell automatically, it just call the first argument which is a command)

2. exec
use the command to replace the current process.
eg.
exec "date";
die "date couldn't run: $!";

3. environment variables:
actually, when we envoke perl from shell, the PATH and other env vars are inherited by perl.
the vars are stored in %ENV hash.
we can change it before we launch new process to affect the child.
eg.
$ENV{'PATH'} = "/home/rootbeer/bin:$ENV{'PATH'}";
delete $ENV{'IFS'};
my $make_result = system "make";

4. using Backquotes:
NOTICE: `` in perl will return scalar or list according to the enviroment!!!
foreach (`who`) {
my($user, $tty, $date) = /(\S+)\s+(\S+)\s+(.*)/;
$ttys{$user} .= "$tty at $date\n";
}

5. the popen equivalent:
it's very useful to do piping between perl and system command!!!!
just use command as the file name, adding | after or before it.
then we get two running process with pipe relationship.
eg.
open DATE, "date|" or die "cannot pipe from date: $!";
open MAIL, "|mail merlyn" or die "cannot pipe to mail: $!";

remember to close it after reading or writing.

6. dirty things:
if you want to use raw fork and signal, check this section

Chapter 17. Some Advanced Perl Techniques
1. trapping errors with eval
the "eval" is used to trap(or register) fatal errors.
the difference is:
if you use eval, the program will continue to run when fatal errors happens.
I found it no use for me.

2. grep items from a list:
syntax:
the first param is a {} which contain a bool expression which returns true or false.
the second param is a list.
if {} return true, the item will be included.
eg.
my @odd_numbers = grep { $_ % 2 } 1..1000;          # get odd numbers from list
my @matching_lines = grep { /\bfred\b/i } <FILE>; # get lines containing fred from file

3. transform items from a list to another list:
we use map to do change to every item and store them in a new list.
the syntax is much the same as the grep.
eg. here the function &big_money is used to change a item
my @data = (4.75, 1.5, 2, 1234, 6.9456, 12345678.9, 29.95);
my @formatted_data = map { &big_money($_) } @data;

4. slices: -- powerful sub list !!!
the 3 kinds of slices below are all list.
(1) split slices:
before we use split to split a line into several fields storing in a list.
but actually we just wanna one or some fields of the string, we can simply add [ ] after the split:
eg.
my($card_num, $count) = (split /:/)[1, 5]; # here we get the 1st and the 5th item
(2) array slices:
we just wanna to refer to some fields of a array:
eg.
my @numbers = ( @names )[9, 0, 2, 1, 0];   # we can omit the () here: @names[9, 0, 2, 1, 0];
@names[2, 3] = ("cow", "sheep");
(3) hash slices:
eg.
my @three_scores = @score{ qw/ barney fred dino/ };
NOTICE: hash slice is a list! so we use @ here to indicate we have a list

Appendix B. Beyond the LIama
this part tells us what else can perl do! very exciting.
1. Some Important Modules
CGI Cwd Fatal File::Basename File::Copy File::Spec Image::Size Net::SMTP POSIX Sys::Hostname Text::Wrap Time::Local DBI Getopt::Long Getopt::Std
2. the rest:
so many field!

sub usage
{
print "$!";
print "Usage: read the code yourself:)";
exit(0);
}

# here we define variables and initializations. variables without initialization has "undefined" values.
my $o_help;
my $o_name = "sheep";
my $o_age = 10;
my @o_lib;
my %o_pair;
Getopt::Long::Configure(qw/no_auto_abbrev/); # we don't need abbrevation(eg. --hel for --help)
GetOptions('help|h' => \$o_help,             # use | to supply alternative option names
     'name=s' => \$o_name,             # is = is used ,the option must has value. s indicate string
     'age=i' => \$o_age,               # is expected while i indicate integer is expected.
        'lib=s' => \@o_lib,               # use array if you have "--lib lib1 --lib lib2 --lib lib3"
        'pair=s' => \%o_pair) or &usage(); # use hash if you have "--pair sheep=10 --pair cow=20

if (defined($o_help)) {                      # if user doesn't supply "help" option, the variable is undefined
print "o_help: $o_help\n";
}
if (defined($o_name)) {
print "o_name: $o_name\n";
}
if (defined($o_age)) {
print "o_age: $o_age\n";
}
if (defined(@o_lib)) {
print "o_lib: @o_lib\n";
}
if (defined(%o_pair)) {
print "o_pair: ", %o_pair, "\n";
}

2. how to print Usage: -- using Here Documents:
"here documents" is to prepare command/text lines needed at a time which're used by shell to feed the application one line each time the app needs input.
so it can be used to automatically interact with the interactive application.
eg.
sub usage
{
print(<<"USAGE");   # I can't believe print can use Here Document!!!
tellme Version:0.1, Copyright (C) 2009 ThomsonReuters.
the analysis result is stored in internal result_table.
the options given below is designed to print the table in various way.
and the default behavior is to output all kinds of tables.

Usage: tellme.pl <options>
--help
    show this usage.
--raw-table
    output the raw internal result_table.
--idn-non-enum-fields-table1 | -a
    output all IDN's fields which are defined as non-enum type.
--idn-non-enum-fields-table2 | -b
    output all IDN's fields which are defined in DB..xsd file as enum type,
but redefined in FieldType.xsd file as non-enum type.
--idn-equals-db-enum-table1 | -c
    output all IDN's enum fields which have the same fields as db's.
--idn-equals-db-enum-table2 | -d
    the simple version of --idn-equals-db-enum-table1.
--idn-unequals-db-enum-table1 | -e
    output all IDN's enum fields which have different fields as db's.
--idn-unequals-db-enum-table2 | -f
    the simple version of --idn-unequals-db-enum-table1.
--idn-enum-not-found-in-db    | -g
    output the IDN's enum fields which can not be found in db.
--verbose
    output the header line.
USAGE
exit(0);
}

3. complex type - using hash and array
--- general rule: ---
(1) we can use "${}[]" to access elements of complex type:
eg. $hash{$key}[$i] # hash of array
$hash{$key}{key2}    # hash of hash
(2) use @{} and %{} to indicate the content in {} is array or hash:
then you can use it as an array or hash name to refer to its elements use [] or {} as usual.
eg. we cat use them when list or hash is expected (eg. after "foreach"):
foreach my $value (@{$hash{$key}}) ... # @{} indicates $hash{$key} is an array
foreach my $key (keys %{$HoH{$login}}) ... # %{} indicates $HoH{$login} is a hash

--- use hash of hash: ---
eg. processing the /etc/passwd file
(1) create hash of hash:
my ( $login, $p, $uid, $gid, $gecos, $dir, $s );
my %HoH = ();
my $file = '/etc/passwd';
open( PASSWD, "< $file" ) or die "Can't open $file : $!";
while( <PASSWD> ) {
   ( $login, $p, $uid, $gid, $gecos, $dir, $s ) = split( ':' );

   $HoH{ $login }{ 'uid' } = $uid;
   $HoH{ $login }{ 'gid' } = $gid;
   $HoH{ $login }{ 'dir' } = $dir;
}
close PASSWD;

yes, we have other style:
$HoH{$login} = {     # NOTICE: { } must be used instead of () !!!!
"uid" => $uid,
"gid" => $gid,
"dir" => $dir
};
(2) access hash of hash:
method 1: you know the column name of sub hash.
    foreach my $login ( keys %HoH ) {
        $uid = $HoH{$login}{"uid"};    
        $gid = $HoH{$login}{"gid"};
   $dir = $HoH{$login}{"dir"};
        print "uid: $uid, gid: $gid, dir, $dir.\n";
    }
method 2: you know nothing about the keys.
foreach my $login (keys %HoH) {
   foreach my $key (keys %{$HoH{$login}}) {
    print "$hash{$login}{$key}\n";
   }
}

--- use hash of array ---
(1) create hash of array:
my %hash;
$hash{"one"} = [1, 2, 3];    # we use [] instead of () to construct list here !!!!
$hash{"two"} = ["cow", "cat", "sheep"];
(2) access hash of array:
method 1: you use foreach to access the array members.
foreach my $key (keys %hash) {
foreach my $value (@{$hash{$key}}) {
   print "$value\n";
}
}
method 2: you wanna use index to access the array members.
foreach my $key (keys %hash) {
for (my $i = 0; $i < @{$hash{$key}}; $i++) {
   print $hash{$key}[$i]."\n";
}
}

--- use array of array ---
(1) create array of array:
## we can use push or = to assign sub array into the array.
## NOTICE: we use [] instead of () to construct list here !!!!
push @result_table, [ $key, "-", $value_count, "-" ];
$result_table[1] = [ 1, 2, 3, 4 ];
my @AoA = (
[ "fred", "barney" ],
[ "george", "jane", "elroy" ],
[ "homer", "marge", "bart" ],
);
for $i ( 1 .. 10 ) {
@tmp = somefunc($i);
$AoA[$i] = [ @tmp ];
}
(2) access array of array:
method 1: use foreach to access the subarrays:
foreach my $sub_array (@array) {
foreach my $value (@{$sub_array}) {
   print "$value\n";
}
}
method 2: use index to access members:
for (my $i = 0; $i < @array; $i++) {
for (my $j = 0; $j < @{$array[$i]}; $j++) {
   print "$array[$i][$j]\n";
}
}
method 3: mixture of foreach and index
foreach my $sub_array (@array) {
for (my $j = 0; $j < @{$sub_array}; $j++) {
   print "@{$sub_array}[$j]\n";
}
}

4. loop control:
last = break;
next = continue;
redo = goto front;

5. popular function error check styles:
guild: $! seems always holds error msg for functions and system commands.It will remains the same if no more errors happen in the following function calling like error in POSIX C. $? only holds command return codes, but it will change in each function call to hold return code. and $@ only holds msg for fatal errors, ie. some functions or operations will cause your program to exit without giving you the chance to handle. In this case, only eval block can stop your program from exiting and store the error msg in $@. The mkpath below is an example. NOTICE: $@ only has msg for fatal errors(errors that cause your program to exit without giving you the ability to handle)
(1) "if + $!" or "or + $!"
if (! chdir "/etc") { # the function will return true if successfully returned.
die "cannot chdir to /etc: $!";
}
chdir "/etc" or die "cannot chdir to /etc: $!";
(2) $? contains the recent `` system() or pipe 's return status code (the number)
$result = `ls`;
print "return code: $?" if $?;
(3) eval + $@
my $path = "Yaf:/cow/sheep/cat/"; # incorrect path name
eval {
mkpath($path,0,0755);
};
print "mkpath error: $@" if $@;

6. platform-independent file/folder operations:
(1) to create embeded directories:
use File::Path;
my $path = "cow/sheep/cat/"; # create dirs under current dir
eval {
mkpath($path,0,0755);
};
print "mkpath error: $@" if $@;
(2) use File::Basename and File::Spec to cover :\ \ or / issues:
don't deal with :\ \ or / things yourself in file path processing, use functions provided by File::Basename and File::Spec module to cover all related issues.
(3) use File::Copy to copy files
copy("name_age.txt", "name.txt") or die "cannot copy: $!\n";

7. text process related:
(1) upper, lower case:
uc() to uppercase
lc() to lowercase

8. m//g will do match many times !!
eg.
my %last_name = /(\w+)\s+(\w+)/g;    # store every pair of matching.
while( $line =~ /\(/g ) { $left++; } # find the count of '(' in current line

9. use modules:
if you put modules under Y:\lib\, say GPC\MLS\COMMON.pm, you should invoke perl like this:
perl -IY:\lib\ script.pl,
and in script.pl you should write like this:
use GPC::MLS::COMMON;

<< 基本用法 >>
生成和打补丁：(记忆方式和cp,ln类似，从dir生成dir2，需要名为dir1-to-dir2.patch的补丁文件)
diff -uNr dir1 dir2 > dir1-to-dir2.patch # 对目录下所有文件生成补丁
patch -p0 < dir1-to-dir2.patch # patch时在dir1,dir2所在目录下
patch -p1 < ../dir1-to-dir2.patch # patch时在dir1所在目录下(p0和p1就这区别)
patch -p1 -R < ../dir1-to-dir2.patch # patch时在dir1所在目录下(p0和p1就这区别)，将变为file2的file1，再变回来

diff -uN file1 file2 > file1-to-file2.patch # 对文件打补丁
patch -p0 < dir1-to-dir2.patch # patch时在dir1,dir2所在目录下
patch -p0 -R < dir1-to-dir2.patch # patch时在dir1,dir2所在目录下，将变为file2的file1，再变回来

说明：
其中 -u 表示生成补丁文件的格式，那个文件格式很好懂得，-表示准备去掉的行，+表示准备加上的行，其实就说明了两个文件间的差异。它和vimdiff不一样，vimdiff是在两个窗口中对比那一行，而diff的-u输出是patch文件中用-和+，上下来看。而且用diff比vim的好处是，可以一次性递归列出所有文件的所有要改的地方。其实在比如codereview的时候，很方便。-r表示递归。-N加上把，不太懂。patch时候，-R表示把变为file2的file1再变回来。
另外，patch时候，加个--dry-run的话，就能够只显示将要patch的文件，而不会真正patch.
<< 只用diff找出两个文件夹下独有的文件名 >>
diff -r dir1 dir2 |grep Only
<< 只用diff找出两个文件夹下独有的文件名，和内容不同的文件 >>
diff -rq dir1 dir2   # -q 只说明两个文件不同，不显示差异

(2)cmp: 简单diff，只显示第一处不同的地方
(3)comm: 打印三列: 文件1独有的，文件2独有的，两文件共有的行

------------ 小工具 ------------
(1)basename & dirname：将文件名和路径名从全路径中抽取出来。
(2)split: 用于分割大文件
(3)md5sum
(4)shred: 用于乱涂一个文件。即你想删除一个文件，但是如果直接用rm来删，会使得别人容易从硬盘恢复，所以先用shred搞乱。
(5)mktemp: 用于在某目录下生成唯一的文件，mktemp /tmp/hah.XXXXXX 注意，XXXXXX你可以随便添加多少个X，它会被mktemp转换为唯一的字符串

------------ 编码 -------------
(1)uuencode,uudecode: 在二进制和ASCII码间相互转换
(2)mimencode,mmencode: 同上，针对的是多媒体文件

4. 通信工具
(1)host,dig 从DNS服务器获取信息，典型的如DNS查找(域名->IP)和反向查找(IP->域名)等功能。
比如反向：
dig www.google.com 你会看见google的ip地址, dig -x googleip地址 你会看见google域名，在最后，你会看到SERVER就是你本次查询的服务器。
(nslookup已经过时了，因为它没有dig灵活)
(2)... 好多命令，以后研究

5. 终端控制命令
(1)... 好多命令，以后研究

6. 数学命令
(1)... 好多命令，以后研究

7. 更多命令
(1)jot,seq
(2)...


第13章 系统管理命令
---------- 用户和组 ------------
(1)groups: 后跟用户名，列出用户所属的所有组
(2)chown,chgrp: 改变文件的用户或组
(3)id: 后跟用户名，列出用户的uid，gid，所属组等信息
(4)who: 打印所有终端上目前的登录信息
(5)w: 等于who加终端上跑的进程，包括tty的和pts的
(6)logname: 当你su后，whoami显示是root，但是logname还是你自己
(7)last: 显示登录过的用户，最近登录的排在最前面，包括当前还活跃的。
(8)gpasswd: gpasswd -a <user> <group_name>为组添加用户，换为-d就是从组里删除用户
(9)useradd,userdel,groupadd,groupdel 参数比较easy
(10)pgrep,pkill:  pgrep -u fengyi -t pts/1 可以找出fengyi用户在终端pts/1上的所有进程！！ 输出是纯粹的pid号，如果你加-l，就一块列出进程名。如果参数中你给了进程名，就只列出那个进程的pid，但是如果你加了-u和-t指定用户名和终端，则可能找不到匹配的呵呵。 注意，-u后面跟的是effective uid，如果要跟real uid，用-U。 另外，pkill和pgrep参数一样，不同的是，它不是列出那些进程号，而是给那些进程发送你规定的信号！！ 这个可方便了，比如杀死所有的某种进程。

---------- 终端相关 ------------
(1)wall: 向所有终端发信息
(2)dmesg: 打印系统启动的信息
(3)好多，暂时不研究
---------- 信息和统计 -----------
(1)lsof: 列出opened files，以及打开它的命令，用户等信息
(2)strace: 后接可执行文件名，列出该命令的含有的系统调用。
(3)free: 列出memory,cache和swap的信息
(4)stat: 列出一个文件的n多信息，相当于ls能得到的所有信息的汇总
(5)vmstat: 列出虚拟内存的信息
(6)uptime: 列出系统从启动为止到现在的时间
(7)readelf,ldd：读取二进制文件信息
(8)好多，暂时不研究
----------- 系统日志 ------------
(1)logger: 就是syslog的命令版。注意要指定facility和priority
(2)
----------- 任务管理 ------------
(1)pidof: pidof接程序名，列出所有运行它的进程PID。
(2)
----------- 系统控制和启动 ----------
(1)init... 暂时不研究
------------ 网络 ---------------
------------ 文件系统 -------------
----------- 备份 -------------
----------- 系统资源 ----------
----------- 模块 ------------
----------- 其他 ------------

at命令用法：“at -f shell文件 时间” 就会在时间执行shell文件。如果不用 -f 引出文件，那么就 “at 时间”，然后at会提示你输入命令，每一行输入你想执行的命令即可。完了，按Ctl-D输入结束。用 atq 可以查看等待执行的任务。用atrm可以删除某一任务。 比较郁闷的是，在ubuntu9.04上，只有一些命令可以被at执行，比如touch，但是mplayer却不行？ 但是在ubuntu8.10上，什么命令都可以跑。另外注意，at有配置文件在 /etc/at.allow 和 /etc/at.deny，一般不用管，但是需要控制用户使用at的权限时，就要用了。





第14章 命令替代
这一章意思就是，一个变量值，可以用``或$()来从命令获取。这里唯一值得提的是：while for if等同样是命令，里面需要含有echo语句，如下：
variable1=`for i in 1 2 3 4 5
do
echo −n "$i"               # The 'echo' command is critical
done`                         #+ to command substitution.
echo "variable1 = $variable1" # variable1 = 12345


第15章 算术运算
在前面已经说了，这里重复一下，有三种，$(())，let 和 expr。其中$(())以前我爱用，let用得少，但确实好用，expr用的少。

第16章 I/O重定向
这一章已经比较熟了，只有一些要说明如下：
&>filename 表示重定向0和1两个都到filename.

打开文件，读写导致位置移动！！！虽然没有seek，tell
echo 1234567890 > File # Write string to "File".
exec 3<> File          # Open "File" and assign fd 3 to it.
read −n 4 <&3          # Read only 4 characters.
echo −n . >&3          # Write a decimal point there.
exec 3>&−              # Close fd 3.
cat File               # ==> 1234.67890
说明：这里的两个exec是用于打开和关闭文件，相当于open和close，打开时为之赋予你需要的描述符，这里是3，关闭时也是关闭3。里面的read会导致游标移动，使得echo（想当于write）写出的位置发生变化。（这里的两个exec不会导致shell被替换掉，无语）。更多的关于关闭文件描述符的介绍，见P251。

多个重定向的书写顺序：
ls -z 2>&1 >>cow.txt 这个试图把-z这个错误选项的错误信息输出到cow.txt，但是不成功，还是打印到了终端上，这是因为，这里的逻辑是：被依赖的写前面。显然，这里是2>1>cow.txt，这里有两个管道，一是2>1，二是1>cow.txt，前者依赖于后者，所以，需要你把后者写前面。这样就对了：ls -z >>cow.txt 2>&1

exec的作用：
(1)打开和关闭文件：上面已经说了
(2)重定向本shell中的描述符：典型应用是，不必要为每个read或其他从stdin输入的命令都做重定向到文件，而是在前面用一次exec即可。这样方便对文件的处理。对于echo等输出命令，也是同理的。比如对read来说，可以这样：
exec 6<&0        #dup 0 到6，6用做0的临时存储地
exec < data-file #重定向0到文件
...              #各种read或其他命令来处理文件，典型的用法是不断read，来提取文件每一行，然后用sed/awk处理。但这里其实我们在上面的while循环中已经做了对while的重定向了，即在while/for/until/if等的最后（比如done后）加个< filename 即可以达到类似的目的，已经可以达到取出每一行，然后来处理。（插一句，函数居然也可以被重定向！可能因为他们都是代码块的缘故）
exec 0<&6 6<&−   #把6 dup回来到0，并关闭6
(3)代替本shell，执行一个命令，就是一般用法。


第17章 here文档
here文档，就是型如下面的文档：
#!/bin/bash
interactive−program <<LimitString
command #1
command #2
...
LimitString

作用是将一系列命令喂给interactive-program。这行为是shell的行为，即如果你写interactive-program < limitString，shell会以为你的输入来自limitString文件，但是如果你写 << limitString，shell就会以为你要开始喂命令了，并将limitString理解为命令的结束标志，这样，你就可以不断写命令了，一行一行的，直到你写了limitString敲个回车，这时，shell才把你的命令给interactive-program，当然你写的有空格就有空格，每一行都有换行，把这整体给program.然后就看program怎么理解这些输入了，一般的program是一次读一行型的，所以正好可以！（这里“命令”的意思，不一定是命令，也可能是一般的输入等待处理，比如你用 cat << cow 试试）

典型例子：登录ftp服务器，并打印目录信息：注意用到变量:
cmd=ls
ftp -n openware.byr.edu.cn << endofcmd
user anonymous anonymous
$cmd
bye
endofcmd
但是，如果endofcmd被加了引号，那么里面的所有的特殊字符都无效了。
cmd=ls
ftp -n openware.byr.edu.cn << 'endofcmd'
user anonymous anonymous
$cmd     #这里实际是无效的，ftp服务器会收到"$cmd"而已，而不是ls
bye
endofcmd

函数也被当成上面的interactive-program一样来用！！！

最后，作者提到，对于太复杂的东西，还是用expect来做更easy。
其实以前我是用管道来做的，效果一样。管道的左边是一个函数或者shell脚本即可，右边是ftp等交互式命令。

第18章 纯属搞笑




五、高级主题
第19章 正则表达式
1. 正则式RegularExpressions(RE)：
用于sed，awk，egrep(好多对于grep不适用)，其实挺简单，记住如下这些即可应付大多数场合，要提醒的是，以下以awk为准，其中有些元字符在sed，egrep中要用的话，得加\来转义，如+

把\D加进去，看看上次百度笔试后晚上下的文档，补充一下！！！！！！！！！！！！！！！！！！！！！！！！


(1) 基本RE：
.任何一个字符，除了newline
*和前面的连用，表示出现0次或多次
^$匹配空白行
[xyz]    匹配x,y或者z
[c-n]    匹配c-n范围内的所有字符
[B-Pk-y] 匹配B-P和k-y范围内的所有字符
[a-z0-9] 匹配小写字符或者数字
[^b-d]   匹配b-d范围以外的字符
\<the\> 匹配the单个单词，不包括them之类的
(2) 扩展RE：
?和前面的连用，表示出现0次或1次
+和前面的连用，表示出现1次或多次
\{5\}和前面的连用，表示出现5次
(re1|re2|re3)表示或者是re1，或者是re2，或者是re3，即()里写正则式组
(3) POSIX RE:
[:alnum:] This is equivalent to [A−Za−z0−9].
[:alpha:] This is equivalent to [A−Za−z].
[:blank:] matches a space or a tab.
[:cntrl:] matches control characters.
[:digit:] matches (decimal) digits. This is equivalent to [0−9].
[:graph:] (graphic printable characters). Matches characters in the range of ASCII 33 − 126. This is the same as [:print:], below, but excluding the space character.
[:print:] (printable characters). Matches characters in the range of ASCII 32 − 126. This is the same as [:graph:], above, but adding the space character.
[:space:] matches whitespace characters (space and horizontal tab).
[:lower:] This is equivalent to [a−z].
[:upper:] This is equivalent to [A−Z].
[:xdigit:] matches hexadecimal digits. This is equivalent to [0−9A−Fa−f].
不过，使用的时候，要再加个[]，如grep [[:digit:]] test.file

2. globbing：shell不理解正则式，它只是做通配符的扩展
通配符如下：
*0个或多个任意字符。
?1个任意字符，提醒的是*和?不再和前面的连用，而是单独使用。
[^abc]用法同正则式
{通配符1,通配符2,通配符3} 这等于RE中的() 注意，这里,两边没有空格，且至少要放入两个通配符，或者{通配符1,}式，即有,号
如：ls -l|egrep '(cow\.|hehe\.)' 等于 ls -l {cow.*,hehe.*}

shell的有两个要点提示如下：
(1)匹配什么就要写全，比如c，只能匹配到c，而 c*，匹配不到 bc，这点和RE不一样，RE只需要含有要匹配的字符串的一部分即可。
(2)单独的*不能匹配以.开头的文件。除了借助egrep，sed，awk来找外，可以这样：
ls {.[^.]*,..?*} 这表示匹配.abc，或者..dd之类的文件。


第20章 子shell
在上面介绍wait的时候，已经写了用子shell来做并行计算了。这里清晰一个概念：
用()括起来的子shell执行码，如果不加&的话，和普通执行的区别是：原shell会启动一个子shell来执行这段代码，所以你可以随意改东西，比如环境变量等！！注意的是，同启动一个子进行来执行命令一样，原shell会等待子shell结束后再执行。所以，你要并行计算的话，就加&吧。

第21章 限制的shell
当你用set -r时，就把shell置于了restricted状态，在这个状态下，一些命令如cd，一些操作，如重定向是不起作用的，具体不起作用的东西见P279列出的。
目的是防止可能的damage to system

第22章 进程替代
就和命令替代一样，意思是将进程的输出赋值给一个变量，语法上见P281

第23章 函数
下面第一个最常用：
function_name () {
command...
return(可选，如果不写，返回的就是最后一个命令的退出码)
}
或者
function_name ()
{
command...
return
}
或者
function function_name {
command...
return
}

然后用名字直接调用即可，如 function_name arg1 arg2
参数的话，在函数里用$1,$2来引用即可，()里不需要写什么
另外，为了得到返回的东西（不是函数return的），方法是在函数里直接写变量，这个变量默认就是全局的，然后在函数外面直接得到之即可。

但是，局部的变量呢，必须要用local声明，如local var=20。局部变量的好处是，使得递归成为可能。

另外，注意，函数这种代码块，也可以用管道和<，>来操作。


第24章 Aliases
easy阿

第25章 List Constructs
这一章讲的是用 cmd1 && cmd2 && cmd3 ... 和 cmd1 || cmd2 || cmd3 ... 来替代if/then, case之类的。简单的还可以用这个，复杂的真不好看。
规则是:
cmd1如果为假，就不会走 cmd1 && cmd2 && cmd3 中的cmd2和cmd3
cmd1如果为真，就不会走 cmd1 || cmd2 || cmd3 中的cmd2和cmd3

第26章 数组
还是别看了，太多了，见前面提到的基本的即可。
注意的是，为了实现一些本该用C实现的算法，在shell里用数组往往更容易。

第27章 基本文件
1. startup file
/etc/profile        Bourne模式的shell，如bash的设置文件
/etc/bashrc         Bash的设置文件
$HOME/.bash_profile 是/etc/profile的本地版
$HOME/.bashrc       是/etc/bashrc的本地版
上面，只有/etc/profile 是在非login shell（如gnome-terminal）中无效的。其他的在login shell和非login shell中都有效。
2. logout file
$HOME/.bash_logout 用户从login shell退出的时候被执行

第28章 /dev和/proc
这一章也就是大概提了下：
1. /dev
/dev/loop0 称为loopback设备，以前曾经把一个文件，mount到/tmp下，就是先在文件中创建文件系统，再借助/dev/loop0，具体查阅以前文档。
/dev/null, /dev/zero,具体见29章. /dev/urandom 上面已经介绍了。

2. /proc
(1) 一大堆文件
cat /proc/devices
cat /proc/interrupts
cat /proc/partitions
cat /proc/loadavg
cat /proc/filesystems
cat /proc/version
cat /proc/cpuinfo
(2) 进程特定文件夹
在proc下有许多数字文件夹，每个文件夹都是一个进程PID。
里面有这个进程的信息文件，主要感兴趣的文件有下面四个：
stat/status 含有进程的统计信息，用数字表示，但是这每个数字的意思我还不清楚
cmdline 含有这个进程被invoke时给的参数
exe     这是一个指向执行文件的链接，用ls -l可得知可执行文件的位置。

书上给了两个例子，一是通过进程号查找进程的启动程序的目录，通过/proc/pid/exe，很easy。另一个是通过进程名，先用ps ax得到进程号，然后再同样查找/proc。


第29章 /dev/null 和 /dev/zero
/dev/null 这个就是黑洞，写了就被丢弃，读是读不出来的。所以，除了常见的重定向外，其实还可以把它链接到任何你不想存的文件。比如一个程序喜欢把你认为无用的东西写到一个文件，导致占用空间，那你可以把这个文件删掉，再链接/dev/null到这个文件。

/dev/zero 用于初始化文件为全0（数字0），包括初始化设备。典型的应用是初始化一个swap文件为全0。然后swap才能被swapon。典型的是用 dd if=/dev/zero of=... 来从/dev/zero中取出你需要个数的0。


第30章 Debugging
好吧，不看了... 不过这一章介绍了trap的用法。

第31章 bash Options
这一章 介绍了通过set设置的bash选项，以及如果影响脚本。

第32章 Gotchas
把保留字赋给变量，比如把case这个赋给变量？？不看了...

第33章 脚本风格
打点...

第34章 Miscellany
各种小主题...

第35章 Bash,version 2
介绍了version 2特性

第36章 Endnotes
over...