该包为IO操作原语提供了基本的接口，它包装了IO操作原语的实现（例如os包中的类型）。除非特别说明，调用者不能假设接口中的方法可以被并行调用。

const (
        SeekStart   = 0 // 相对于文件的起始位置进行Seek
        SeekCurrent = 1 // 相对于当前读取位置进行Seek
        SeekEnd     = 2 // 相对于尾部进行Seek
)

// 错误定义
// 由Read函数返回，表示没有更多可读的数据。用于优雅的结束文件读取（读到尾部了）
var EOF = errors.New("EOF")
// 在关闭的管道上进行读写
var ErrClosedPipe = errors.New("io: read/write on closed pipe")
var ErrNoProgress = errors.New("multiple Read calls return no data or error")、
// 当提供的缓冲区不够存放读取到的数据时
var ErrShortBuffer = errors.New("short buffer")
// 当写操作所要求的字节数不足时
var ErrShortWrite = errors.New("short write")
// 在读取固定长度的块或者数据结构时，没有到预期的结尾位置即发生EOF
var ErrUnexpectedEOF = errors.New("unexpected EOF")

func Copy(dst Writer, src Reader) (written int64, err error)

sr := strings.NewReader("Read after me, please!\n")
n, err := io.Copy(os.Stderr, sr)
if err == nil {
    fmt.Printf("%v bytes read.\n", n)
}

func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)

func CopyN(dst Writer, src Reader, n int64) (written int64, err error)

func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)

r := bytes.NewReader([]byte{0, 1, 2, 3, 4, 5, 7, 8, 9})
buf := make([]byte, 5)
io.ReadAtLeast(r, buf, 3)
fmt.Printf("%v", buf)  // [0 1 2 3 4] 读满了切片容量 

func ReadFull(r Reader, buf []byte) (n int, err error)

func WriteString(w Writer, s string) (n int, err error)

type ByteReader interface {
    ReadByte() (byte, error)
}

type ByteScanner interface {
    ByteReader
    // 导致下一次ReadByte返回和上一次ReadByte一样的内容
    UnreadByte() error
} 

type ByteWriter interface {
    WriteByte(c byte) error
} 

type Closer interface {
    // 此接口包装基本的Close方法
    Close() error
}

type LimitedReader struct {
    R Reader // 此结构使用的Reader
    N int64  // 最大读取字节数。每次调用R后等会更新N，来反应还可以读取多少字节
}

func (l *LimitedReader) Read(p []byte) (n int, err error)

func Pipe() (*PipeReader, *PipeWriter)

type PipeReader struct {}

// 关闭管道的读端，后续写端的写操作会返回ErrClosedPipe
func (r *PipeReader) Close() error
// 关闭管道的读端，后续写端的写操作会返回该方法提供的err
func (r *PipeReader) CloseWithError(err error) error
// 读取数据
func (r *PipeReader) Read(data []byte) (n int, err error)

type PipeWriter struct {}

func (w *PipeWriter) Close() error
func (w *PipeWriter) CloseWithError(err error) error
func (w *PipeWriter) Write(data []byte) (n int, err error) 

func MultiReader(readers ...Reader) Reader

r1 := strings.NewReader("Hello")             
r2 := strings.NewReader(" World")            
rm := io.MultiReader(r1, r2)                 
buf := make([]byte, 20)                      
io.ReadFull(rm, buf)                         
fmt.Printf("%v", string(buf)) // Hello World

func TeeReader(r Reader, w Writer) Reader

type ReaderAt interface {
    ReadAt(p []byte, off int64) (n int, err error)
}

type ReaderFrom interface {
    ReadFrom(r Reader) (n int64, err error)
}

func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader

iotype SectionReader struct {
}
// 读取
func (s *SectionReader) Read(p []byte) (n int, err error)
// 从指定位置开始读取
func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error)
// Seek到指定位置
func (s *SectionReader) Seek(offset int64, whence int) (int64, error)
返回节段中包含的字节数
func (s *SectionReader) Size() int64

r := bytes.NewReader([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
s := io.NewSectionReader(r, 2, 3)
buf := make([]byte, 10)
s.Read(buf)
fmt.Printf("%v", buf) // [2 3 4 0 0 0 0 0 0 0] 最多读取3字节

s = io.NewSectionReader(r, 0, 10)
s.ReadAt(buf, 5)
fmt.Printf("%v", buf) // [5 6 7 8 9 0 0 0 0 0] 

type RuneReader interface {
    ReadRune() (r rune, size int, err error)
}

该包实现带缓冲的IO功能。执行很多碎小的写操作会影响性能，因为每次写操作都对应了系统调用，过多的系统调用会加重CPU负担。类似磁盘这样的设备，处理块对齐的数据时性能更好，因此有必要为IO提供缓冲功能。

简单的示例： 

// 实现一个仿冒Writer，它能够打印写出的字节数量
type Writer int

func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("Bytes write: %v\n", len(p))
    return len(p), nil
}
func main() {
    w := new(Writer)
    w.Write([]byte{1}) // 一字节无缓冲写出
    w.Write([]byte{2})

    // 创建带缓冲的Writer，缓冲区大小5字节
    bw := bufio.NewWriterSize(w, 5)
    bw.Write([]byte{1, 2, 3}) // 不会写出，因为缓冲区没有满
    bw.Write([]byte{4, 5, 6}) // 写出，输出5
    fmt.Printf("Available size of buffer: %v", bw.Available())
    bw.Flush() // 写出，输出1
}

r := strings.NewReader("既然选择了远方，就应该风雨兼程")
br := bufio.NewReaderSize(r, 18)
rune, size, err := br.ReadRune()
if err == nil {
    fmt.Printf("Character: %c, Size: %v\n", rune, size) // Character: 既, Size: 3
}
buf := make([]byte, 18)
br.Read(buf)
fmt.Printf("String: %v", string(buf)) // String: 然选择了远
br.Discard(6)
rune, _, _ = br.ReadRune()
fmt.Printf("%c", rune) // 就

func main() {
    // 扫描器可以方便进行扫描，例如逐行读取、逐字符读取
    bs := bufio.NewScanner(strings.NewReader("既然选择了远方，就应该风雨兼程"))
    // 每读取一个字符即停止
    bs.Split(bufio.ScanRunes)
    for bs.Scan() {
        // 以字符串形式返回读取到的内容
        fmt.Print(bs.Text())
    }
}

包含一些工具函数

// 读取全部内容
bytes, err := ioutil.ReadAll(strings.NewReader("Hello darkness my old friend"))
if err == nil {
    fmt.Printf("%c", bytes)
}

// 读取目录的全部条目
infos, err := ioutil.ReadDir("/etc/mysql")
for _, info := range infos {
    // 打印目录中的内容
    fmt.Println(info.Name())
}

// 读取文件的内容并返回
const FNAME = "/etc/mysql/my.cnf"
content, _ := ioutil.ReadFile(FNAME)
// 写入文件内容
ioutil.WriteFile(FNAME, content, 0777)

// 创建临时文件和目录
dirName, _ := ioutil.TempDir("", "go")
fmt.Println(dirName) // 输出目录/tmp/go154074736，注意随机后缀

该包提供类似C语言风格的printf、scanf

fmt.Printf("%f",12.22) // 12.220000

// 打开并得到os.File对象
f, err := os.Open("/etc/rc.local")

// 关闭文件
defer f.Close()

# 读取最多5字节到缓冲
b1 := make([]byte, 5)
# 返回实际读取的字节数
n1, err := f.Read(b1)

// 寻道到第6字节处，第二参数：0相对于文件头，1 相对于当前位置，2相对于文件尾
o2, err := f.Seek(6, 0)
b2 := make([]byte, 2) 
n2, err := f.Read(b2)

// Rewind
f.Seek(0, 0)

r4 := bufio.NewReader(f)
// 向前偷窥
b4, err := r4.Peek(5)

The post Go语言IO编程 appeared first on 绿色记忆.

在Python2中，类型

str

unicode

字符串可以使用单引号、双引号、三引号包围， 三引号中的字符串原样保留，可以方便的编写多行文本。

字符串的引号开始前，可以增加

u

r

Python没有单独的字符类型，字符只是长度为1的字符串

在Python语言中，字符串属于（不可变）序列，支持有限的切片操作：

s = "一二三四五六七"
# 取子串，起始索引包含，结束索引不包含
assert s[1:3] == '二三'
assert s[-3:] == '五六七'
i = 3
assert s[:i] + s[i:] == s

# 带步进的切片，默认1，即下一个元素的索引比上一个大1
assert s[1:4:1] == '二三四'
assert s[1:4:2] == '二四'
assert s[1:4:3] == '二'
# 负数的步进，下面这个用于生成倒序的串
assert s[::-1] == '七六五四三二一'
assert s[4:1:-1] == '五四三'

在Python中，此操作符可以用于成员关系测试，或者迭代：

s = '01234567'
assert '3' in s
for c in s: print(c)

适用于任意切片的运算符还包括

+

*

assert '123' + '4567' == '1234567'
assert '123' * 3 == '123123123'

很多内置函数、方法可以用于操控字符串： 

s = "01234567"
# 计算序列长度
assert len(s) == 8
# 获取序列元素的最小值
assert min(s) == '0'
# 获取序列元素的最大值
assert max(s) == '7'

# 查找，获得子串的索引，两个方法类似，但是index()在无法子串不存在时抛出ValueError
assert s.index('67') == 6
assert s.find('67') == 6
# 查找，子串判断
assert s.startswith('012') and s.endswith('4567')
# 替换，注意字符串是不可变的，因此返回的是副本
assert s.replace('3', 'x') == "012x4567"
# 分割
assert s.split('3') == ['012', '4567']
# 连接
assert ','.join(['1', '2', '3']) == '1,2,3'
# 对齐和填充
assert s.ljust(10, '0') == '0123456700'
# 去除空白，左侧
assert s.lstrip('0') == '1234567'
# 特性检查：is*()方法
assert s.isalnum()  # 是否仅包含字母数字

Python支持两种风格的字符串格式化操作，包括旧式的

%

format()

可以使用

%

s % d

'%s %s' % ('one', 'two') 
'%(k1)s %(k2)s' % {'k1':'one','k2':'two'}

格式模板由普通字符、转换说明符组成，转换说明符以%开头，具体含义如下：

在字符%与上表列出的转换字符之间，可以按顺序出现以下修饰符：

a = 42
b = 13.142783 c = "hello"
d = {'x':13, 'y':l.54321, 'z':'world'} 
e = 5628398123741234

r = "a is %d" % a                     # r = "a is 42"
r = "%10d %f" %(a,b)                  # r = "        42 13.142783"    整数宽度10，右对齐
r = "%+010d %E" %(a,b)                # r = "+000000042 1.314278E+01" 整数宽度10，右对齐，不足补0
r = "%(x)-10d %(y)0.3g" % d           # r = "13          1.54"        从字典d里取出值并对其执行转换
r = "%0.4s %s" %(c, d['z'])           # r = "hell world"              第一个字符串最大打印长度为4
r = "%*.*f" % (5,3,b)                 # r = "13.143"                  元组的前两项作为格式字符串的组成部分

#注意，格式化字符串与字典一起使用，行为类似于字符串插值：
p = {'age' : 28, 'name' : 'Alex'}
r = "%(name)s's age is %(age)d" % p   # r = "Alex's age is 28"

通过调用作为模板的字符串的format()是Python新式的格式化机制。模板由普通字符和占位符组成，可以使用

{place:format_spec}

1. place，位置，可以是数字表示的位置参数、标识符表示的命名参数。默认情况下Python使用

   __format__()

    得到对象的文本表示，要改变此行为，可以扩展place为

   place!type

    形式。其中type可以取值s、r、a，分别调用

   __str__()

    、

   __repr__()

    和

   ascii()

    完成文本转换，a仅在Python3中被支持
2. format_spec，格式说明符，形式为：

   [[fill]align][sign][#][0][width][,][.precision][type]

    ，各字段说明如下：

<

>

=

^

+

-

0b

0o

0x

代码示例：

# ###  参数占位符  ###
# 位置参数
'{0}, {1}, {2}'.format('a', 'b', 'c')  # 'a, b, c'
'{2}, {1}, {0}'.format('a', 'b', 'c')  # 'c, b, a'
'{}, {}, {}'.format('a', 'b', 'c')  # 'a, b, c' 要求2.7+
'Hello {0}'.format('Alex') == 'Hello Alex'
# 命名参数
'Coordinates: {latitude}, {longitude}'.format(latitude = '37.24N', longitude = '-115.81W')
'Hello {name}'.format(name = 'Alex') == 'Hello Alex'
# 访问对象属性
person = lambda: None
person.greeting = 'Hello'
person.name = 'Alex'
assert '{0.greeting} {0.name}'.format(person) == 'Hello Alex'
# 访问序列的元素
coord = (3, 5)
'X: {0[0]};  Y: {0[1]}'.format(coord)

# ###  格式控制  ###
# 对齐和填充
'{:>30}'.format('right aligned')  # '                 right aligned'
'{:*^30}'.format('centered')  # '***********centered***********'
# 浮点数
'{:+f}; {:+f}'.format(3.14, -6.02)  # '+3.140000; -6.020000'
# 千分位
'{:,}'.format(1234567890)  # '1,234,567,890'

# 格式化时间
import datetime
d = datetime.datetime(2010, 7, 4, 12, 15, 58)
'{:%Y-%m-%d %H:%M:%S}'.format(d)  # '2010-07-04 12:15:58'

re模块可以用于正则表达式的处理。

r'[abcde]'

r'a-zA-Z'

r'[^0-9]'

MatchObject

group()

'Hello(?=World)'

World

Hello

'def'

'abc'

r'(?<=abc)def'

r'[0-9]'

r'[^0-9]'

r'[\t\n\r\f\v]

r'[^\t\n\r\f\v]

import re
#获取字符串中与模式匹配的所有不重叠值，包括空匹配
#如果模式包含分组，将返回与分组匹配的文本列表，如果包含多个分组，则前述列表的每一项都是一个元组
#finditer与之类似，但是返回的是MatchObject的迭代器
#(\D+)(\d+) 结果：[('a', '0'), ('b', '12'), ('c', '345'), ('d', '6789')]
#(\D+)\d+   结果：['a', 'b', 'c', 'd']
#\D+\d+     结果：['a0', 'b12', 'c345', 'd6789']
m = re.findall(r'\D+\d+', 'a0b12c345d6789', re.IGNORECASE)  # 由于正则式特殊字符很多，故一般使用“原始字符串”
print m

r = re.compile(r'\D+\d+', re.IGNORECASE)       #编译得到一个正则式对象
#search()、match()返回MatcherObject对象


s = 'Iggle Piggle and Makka    Pakka are in the night garden'
# match、search等方法返回MatchObject：
# group(n)：返回匹配中第n个分组，如果n==0或者为空，返回整个匹配


# match函数从字符串起始处搜索正则式的匹配，找不到返回None
# 贪婪匹配
print re.match( r'.*ggle', s , re.IGNORECASE ).group()  # Iggle Piggle
# 非贪婪匹配
m = re.match( r'.*?(ggle)', s , re.IGNORECASE )
print m.group()  # Iggle
print m.group( 1 )  # ggle 返回匹配中的第一个分组

# search函数与match类似，但是不限定匹配从字符串首部开始
print re.search( r'.akka', s , re.IGNORECASE ).group()  # Makka

# sub(pattern, repl, string, count, flags) 函数用于字符串替换
# pattern 匹配模式 repl替换文本或回调 string被处理字符串 count需要处理的匹配个数
# 这里使用基于序号的分组，()界定了分组范围，分组可以嵌套：
# (M(\w+))是第一个分组，(\w+)是第二个分组，(P\2)是第三个分组
# repl可以指定转移字符，\g<name>用于引用匹配的正则式分组
print re.sub( r'(M(\w+))\s+(P\2)', '\g<1> \g<3>', s )  # 去掉Makka    Pakka之间多于的空格
# 命名分组，使用(?P<GRP_NAME>)定义命名分组，使用(?P=GRP_NAME)引用命名分组
print re.sub( r'(M(?P<grp1>\w+))\s+(P(?P=grp1))', 'M\g<grp1> \g<3>', s )
# repl还可以是函数
print re.sub( r'(M(?P<grp1>\w+))\s+(P(?P=grp1))', lambda match : match.group().upper(), s )

原因：进行字符串格式化时，如果%后面的参数时元组，那么必须对所有元组成员进行格式化，也就是说，前面的占位符数量要和元组长度一致。

The post 使用Python进行文本处理 appeared first on 绿色记忆.

字符集（Charset）、代码页（Code page）、编码方式（Encoding）这三个术语常常描述一件事情——如何把字符存储为二进制形式（字节）。

严格的讲，字符集是字符的集合，编码方式则用于确定某个字符集中的字符如何编码（为字节），但是对于ASCII、GB 2312、Big5、GBK、GB 18030之类的遗留方案来说一种字符集只有一种编码方式，这导致某些时候术语字符集、编码方式被混用。而Unicode是严格区分字符集、编码的，Unicode字符集有 UTF-8、UTF-16、UTF-32等多种编码方式。

微软称当前Locale对应的字符集为ANSI，和ASCII没有关系，对于简体中文的Windows操作系统，ANSI通常就是GBK。

进行文本处理时，编码方式常常是令人头疼的问题。相比起其它语言，C/C++的编码方式问题比较复杂。造成这种复杂性的原因包括：

1. 对于编码方式缺乏统一规范，依赖于编译器、操作系统
2. 构建出的二进制可执行文件丢失字符串（char*）编码方式信息

使用C/C++处理字符串时，要注意四个层面的字符集（表格出现的字符集可以理解为编码方式）：

LC_ALL

LC_*

LANG

char* str = "你好"

strlen()

wchar_t

printf()

printf()

wprintf()

setlocale(LC_ALL,"C");

setlocale(LC_CTYPE, "")

rem 显示当前代码页（和字符集是类似的概念）
CHCP
rem 936是简体中文代码页，最初和GB2312一样，后来包含大部分的GBK字符
Active code page: 936
rem 切换为UTF-8代码页
CHCP 65001

该头文件主要提供两类重要的函数：

1. 字符类别测试
2. 字符大小转换

该库提供的函数中都以int类型为参数，并返回一个int类型的值。实参类型应该隐式/显式转换为int类型

函数列表如下：

int isalnum(int c)

int isalpha(int c)

int iscntrl(int c)

int isdigit(int c)

int isgraph(int c)

int islower(int c)

int isupper(int c)

int isprint(int c)

int ispunct(int c)

int isspace(int c)

int isxdigit(int c)

int tolower(int c)

int toupper(int c)

memchr()

/**
 * 扫描s所指内存的前n个字节，来寻找c出现的第一个位置
 * c和s所指内存的字节，均被解释为unsigned char
 * 返回指向匹配字节的指针，如果找不到返回NULL，rawmemchr()在找不到的情况下返回值未定义
 */
void *memchr(const void *s, int c, size_t n);  // 正向搜索
// 下面两个是GNU扩展
void *memrchr(const void *s, int c, size_t n); // 反向搜索
void *rawmemchr(const void *s, int c); // 正向搜索，不限制字节数

const char *mem = "0123456789";
char *p3 = (char *) memchr( mem, '3', strlen( mem ));
assert( p3 - mem == 3 );

memcmp()

/**
 * 比较s1、s2两块内存区域的前n个字节
 * 当s1小于、等于、大于s2时分别返回负数、0、正数
 */
int memcmp(const void *s1, const void *s2, size_t n);

char *s1 = "abcdew";
char *s2 = "abcdez";
assert( memcmp( s1, s2, strlen( s1 ) - 1 ) == 0 );
assert( memcmp( s1, s2, strlen( s1 )) < 0 );

memcpy()

/**
 * 从src拷贝n个字节到dest
 * 返回指向dest的指针
 */
void *memcpy( void *dest, const void *src, size_t n );

memmove()

/**
 * 类似于memcpy，效果上相当于把src先拷贝到临时内存中，然后覆盖到dest
 */
void *memmove(void *dest, const void *src, size_t n);

memset()

void *memset(void *s, int c, size_t n); 

strcat()

/**
 * 将src附加到dest后面，覆盖dest结尾的\0，并在连接后再次添加一个\0
 * 两个字符串不得重叠，并且dest必须由足够的空间来存放结果，如果dest空间不足则程序的行为无法预测
 */
char *strcat( char *dest, const char *src );

/**
 * 连接两字符串，与strcat类似，但是：
 *     最多使用src的n个字节
 *     如果src大于n字节，则它不需要以\0结束
 */
char *strncat( char *dest, const char *src, size_t n );

char *dest = malloc( 100 );
strcat( dest, "Hello" );
strcat( dest, " World" );
assert( strcmp( dest, "Hello World" ) == 0 ); 

strchr()

// 返回s中第一个c的指针，如果找不到返回NULL
char *strchr(const char *s, int c);
// 返回s中最后一个c的指针
char *strrchr(const char *s, int c);
// 与strchr()类似，但是在找不到的时候，返回s结尾的\n的指针而不是NULL
char *strchrnul(const char *s, int c);

strcmp()

//比较s1、s2，在s1小于、等于、大于s2时分别返回负数、0、正数
int strcmp( const char *s1, const char *s2 );
//比较s1、s2的前n个字节
int strncmp( const char *s1, const char *s2, size_t n );

strcoll()

LC_COLLATE

int strcoll(const char *s1, const char *s2);

strcpy()

/**
 * 拷贝src，包含结尾的\0，到dest。dest必须足够大，两个字符串不得重叠
 *
 */
char *strcpy( char *dest, const char *src );
// 类似，但是最多拷贝n字节，注意，该函数可能导致结尾的\0丢失
char *strncpy( char *dest, const char *src, size_t n );

strspn()

/**
 * 搜索s，直到出现不在accept中的字节
 * 返回从头开始，一直处于accept中的字符的个数
 */
size_t strspn( const char *s, const char *accept );
/**
 * 搜索s，知道出现在reject中的字节
 * 返回从头开始，第一个在reject中的字节之前的字节总数
 */
size_t strcspn( const char *s, const char *reject );

assert( strspn( "54213zyx", "1234567890" ) == 5 );

strerror()

printf( strerror( 2 ));//No such file or directory

strlen()

assert( strlen( "nh" ) == 2 );
assert( strlen( "你好" ) == 6 ); 

strpbrk()

/**
 * 搜索s，直到出现accept中的任何一个字节
 * 返回第一个accept中的字节，如果找不到返回NULL
 */
char *strpbrk( const char *s, const char *accept );

strstr()

/**
 * 返回haystack中第一次出现needle的、needle的起始字节的指针，结尾的\0不参与比较
 * 如果子串找不到返回NULL
 */
char *strstr(const char *haystack, const char *needle);
// GNU扩展，与上面类似，但是不区分大小写
char *strcasestr(const char *haystack, const char *needle);

strtok()

/**
 * 第一次调用时，传递待分割的字符串到str，后续分割同一字符串的操作，必须传递NULL给str
 * delim是一系列作为分隔符的字节，后续调用可以改变delim
 * 每次调用的返回值是指向分割得到的子串的指针，没有更多的记号时返回NULL
 */
char *strtok( char *str, const char *delim );
/**
 * strtok()的可重入版本
 * saveptr是供函数内部使用的一个指针，保存分隔上下文
 */
char *strtok_r( char *str, const char *delim, char **saveptr );

char str[] = "123:456,789....0";
char *token;
char *ctx = str;
while ( token = strtok_r( ctx, ":,.", &ctx )) {
    printf( "%s|", token );
}
//打印123|456|789|0| 可以看到....中间的不作为子串

strxfrm()

/**
 * 拷贝src的n个字节到数组dest中，返回拷贝后的字符串的长度
 * 如果返回值大于等于n则dest数组的内容是不确定的
 */
size_t strxfrm( char *dest, const char *src, size_t n );

char *source = "1234567890";
char des[100];
size_t len = strxfrm( des, source, 50 );
assert( len == 10 && strcmp( des, source ) == 0 );
memset( des, 0, 100 );
len = strxfrm( des, source, 5 );
assert( len == 10 && strcmp( des, "12345" ) == 0 );

所谓宽字符，是指使用多个字节表示的字符。宽字符类型具有固定宽度，但是宽度取决于平台（编译器），这意味着使用宽字符会导致可移植性问题。宽字符在Linux系统中使用的不多。

在2011年的C和C++标准中固定宽度的字符类型

char16_t

char32_t

btowc()

/**
 * 执行单字节字符到宽字符的转换
 * @param c 单字节字符
 * @return 转换c所代表的字符的宽字符表示
 *         如果c为EOF或者不是有效单字节字符，返回WEOF
 */
wint_t btowc( int c ); 

mbtowc()

mbrtowc()

/**
 * 从多字节序列s中抽取出一个宽字符，该函数最多检查s的n个字节，并把转换后得到的宽
 * 字符存放在*pwc中，返回从s中消费掉的字节数。该函数在内部维护一个偏移状态（Shift state）导致其线程不安全
 * 
 * 该函数需要知道s的编码方式，这是由当前Locale的LC_CTYPE目录决定的，因此调用该函
 * 数前你可能需要调用setlocale来设置多字节使用的编码方式
 */
int mbtowc( wchar_t *pwc, const char *s, size_t n );

setlocale( LC_ALL, "" );
char *str = "你好，世界";
wchar_t wc = 0;
// MB_CUR_MAX 当前Locale下多字节字符占据的最大字节数
int len = mblen( str, MB_CUR_MAX);
str += mbtowc( &wc, str, len * strlen( str ));
wprintf( L"%lc \n", wc ); //你
str += mbtowc( &wc, str, len * strlen( str ));
wprintf( L"%lc \n", wc ); //好

wctob()

wctomb()

/**
 * 转换宽字符wc为多字节序列，存放到s中，程序员必须保证s至少由MB_CUR_MAX字节
 * 如果s非NULL，返回写入到s中的字节数
 * 如果s为NULL，该函数重置内部的Shift state为初始状态，并返回
 * 零（如果多字节编码方式是无状态的）或非零
 */
int wctomb(char *s, wchar_t wc);

setlocale( LC_ALL, "" );
char buf[64];
char *str = buf;
str += wctomb( str, L'你' );
str += wctomb( str, L'好' );
printf( "%s", buf ); //你好

wprintf()

//下面三个函数和对应单字节字符的版本功能类似
int fwprintf( FILE *stream, const wchar_t *format, ... );
int wprintf( const wchar_t *format, ... );
int swprintf( wchar_t *s, size_t n, const wchar_t *format, ... ); 

vwprintf()

//下面三个函数与上面类似，但是使用列表而不是变长参数
int vwprintf( const wchar_t *format, va_list arg );
int vfwprintf( FILE *stream, const wchar_t *format, va_list arg );
int vswprintf( wchar_t *s, size_t n, const wchar_t *format, va_list arg );

wscanf()

//下面三个函数和对应单字节字符的版本功能类似
int fwscanf( FILE *stream, const wchar_t *format, ... );
int wscanf( const wchar_t *format, ... );
int swscanf( const wchar_t *s, const wchar_t *format, ... );

iswalnum()

//测试在当前Locale下，字符是否字母或者数字
int iswalnum( wint_t wc );

iswalpha()

//测试在当前Locale下，字符是否字母
int iswalpha( wint_t wc ); 

iswxdigit()

//测试在当前Locale下，字符是否属于十六进制字符
int iswxdigit( wint_t wc ); 

iswcntrl()

//测试在当前Locale下，字符是否为控制字符
int iswcntrl( wint_t wc );

iswgraph()

//测试在当前Locale下，字符是否为可见
int iswgraph( wint_t wc );

iswprint()

//测试在当前Locale下，字符是否为可打印字符
int iswprint( wint_t wc ); 

iswspace()

//测试在当前Locale下，字符是否为空白字符
int iswspace( wint_t wc );

iswupper()

iswlower()

//是否大小写判断
int iswupper( wint_t wc );
int iswlower( wint_t wc );

towupper()

towlower()

//转换为大小写
wint_t towupper( wint_t wc );
wint_t towlower( wint_t wc );

fgetwc()

//从文件流中读取下一个宽字符
wint_t fgetwc( FILE *stream );

//与上面类似，但是作为宏实现
wint_t getwc(FILE *stream);

getwchar()

//从标准输入读取一个宽字符
wint_t getwchar(void);

fputwc()

//写入一个宽字符到文件流
wint_t fputwc( wchar_t wc, FILE *stream );

//与上面类似，但是作为宏实现
wint_t putwc(wchar_t wc, FILE *stream);

putwchar()

//写入一个宽字符到标准输出
wint_t putwchar( wchar_t wc );

fgetws()

//从文件流中读取宽字符串
wchar_t *fgetws( wchar_t *ws, int n, FILE *stream );

fputws()

//写入宽字符串到文件流
int fputws( const wchar_t *ws, FILE *stream ); 

fwide()

/**
 * 修改流为面向字节/面向宽字符
 * @param stream 目标流
 * @param mode 1尝试修改为面向宽字符；-1尝试修改为面向字节；0不变
 */
int fwide( FILE *stream, int mode );

wcscat()

//连接两个宽字符串
wchar_t *wcscat( wchar_t *ws1, const wchar_t *ws2 );

wcsncat()

//连接ws2的最多n个字符到ws1，不包括\0字符
wchar_t *wcsncat( wchar_t *ws1, const wchar_t *ws2, size_t n );

wcschr()

/**
 * 搜索字符串，返回字符在串中第一次出现
 * @param ws 字符串
 * @param wc 搜索的字符
 * @return 第一次出现的字符的指针，或者NULL
 */
wchar_t *wcschr( const wchar_t *ws, wchar_t wc );

//返回字符在串中的最后一次出现
wchar_t *wcsrchr( const wchar_t *ws, wchar_t wc );

wcspbrk()

//得到第一个出现在ws1中的任何ws2中的字符
wchar_t *wcspbrk( const wchar_t *ws1, const wchar_t *ws2 );

wcscmp()

/**
 * 比较两个宽字符串，如果ws1大于ws2，返回正数；等于则返回0；小于返回负数
 * 非零返回值说明了两者的差异
 */
int wcscmp( const wchar_t *ws1, const wchar_t *ws2 );

wcscpy()

//将字符串ws2拷贝到ws1，如果两个串存在字符重叠，则行为未定义
wchar_t *wcscpy( wchar_t *ws1, const wchar_t *ws2 );

//将字符串ws2的最多n个字符拷贝到ws1，如果出现字符重叠，则行为未定义
wchar_t *wcsncpy( wchar_t *ws1, const wchar_t *ws2, size_t n );

wcsftime()

//将日期时间转换为宽字符串
size_t wcsftime( wchar_t *wcs, size_t maxsize, const wchar_t *format, const struct tm *timptr );

wcslen()

//得到宽字符串的长度，不包括结尾的0字符，结果是字符的个数，而不是字节数
size_t wcslen( const wchar_t *ws );

wcsstr()

//搜索子串的第一次出现，如果找不到返回NULL，如果ws2是空串，那么直接返回ws1
wchar_t *wcsstr( const wchar_t *ws1, const wchar_t *ws2 );

//类似上面的宏版本
wchar_t *wcswcs( const wchar_t *ws1, const wchar_t *ws2 );

wcstok()

//根据分隔符，分隔宽字符串
wchar_t *wcstok( wchar_t *ws1, const wchar_t *ws2, wchar_t **ptr );

wmemchr()

//在长度为n字符的ws中寻找第一次出现的wc
wchar_t *wmemchr( const wchar_t *ws, wchar_t wc, size_t n );

wmemcmp()

//比较两个字符串的前n个字符
int wmemcmp( const wchar_t *ws1, const wchar_t *ws2, size_t n );

wmemcpy()

//把ws2的前n个字符拷贝到ws1，返回ws1
wchar_t *wmemcpy( wchar_t *ws1, const wchar_t *ws2, size_t n ); 

wmemset()

//设置ws的前n个字符为wc
wchar_t *wmemset( wchar_t *ws, wchar_t wc, size_t n ); 

stdio.h中定义了一系列用于格式化输出的函数，包括：

#include <stdio.h>
/**
 * 将format指定的格式使用后续参数填充后，打印到标准输出
 */
int printf( const char *format, ... );
/**
 * 将format指定的格式使用后续参数填充后，打印到流stream
 */
int fprintf( FILE *stream, const char *format, ... );
/**
 * 将format指定的格式使用后续参数填充后，打印到str指定的缓冲区
 */
int sprintf( char *str, const char *format, ... );
//类似上面，但是最多打印size字节
int snprintf( char *str, size_t size, const char *format, ... );

#include <stdarg.h>
// 类似上面，但是使用使用va_list而不是变长参数列表
int vprintf( const char *format, va_list ap );
int vfprintf( FILE *stream, const char *format, va_list ap );
int vsprintf( char *str, const char *format, va_list ap );
int vsnprintf( char *str, size_t size, const char *format, va_list ap );

此外，对应的还有格式化输入的函数：

#include <stdio.h>

int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *str, const char *format, ...);

#include <stdarg.h>

int vscanf(const char *format, va_list ap);
int vsscanf(const char *str, const char *format, va_list ap);
int vfscanf(FILE *stream, const char *format, va_list ap);

这些函数的宽字符版本在wchar.h中声明。

上述所有函数中的format遵守一致的规范。format由普通字符和若干转换规则（conversion specifications）组成。后者导致列表中下一个参数被转换并打印。转换规则的语法为：

%[#0- +'][宽度][.精度][长度限定符][转换符]

其中：

可用的转换符如下表：

C标准库的功能非常有限，并且比较难用或存在性能问题，很多情况下需要使用第三方库。

SDS是一个简单的动态字符串库，原本是Redis内部的组件。它在内部维护一个基于堆的缓冲区，避免受到C标准库的限制，SDS兼容普通的C字符串函数。

典型的C动态字符串库是基于下面的结构实现的：

struct DynamicString {
    char *buf;
    size_t len;
    //其它字段
};

SDS没有遵循这一模式，它由头部+二进制安全的C风格字符串+NULL字符构成。SDS的结构导致它具有一些缺点和优点。

SDS的很多函数会可能返回一个新字符串，而不是修改原有字符串，所以很多SDS API必须这样使用：

s = sdscat(s,"more data");

如果忘记把返回值赋值给原先的变量可能导致BUG。

进一步讲，如果你在多个地方引用同一个SDS，调用上述函数后必须赋值所有引用。

你可以直接对SDS变量使用C标准库函数，例如：

printf("%s\n", sds);
//其它库一般是这样：
printf("%s\n", str->buf);
//或者这样：
printf("%s\n", getStringPointer(str));

索引方式访问单个字符也是支持的：

printf("%c %c\n", sds[0], sds[1]);

sdsnew()

sdsnewlen()

sdsempty()

sdsdup()

/**
 * 创建一个动态字符串，初始值从init的前initlen中取得
 */
sds sdsnewlen( const void *init, size_t initlen );
/**
 * 创建一个动态字符串，初始值由init指定，init必须由\0结束
 */
sds sdsnew( const char *init );
/**
 * 创建一个空白的动态字符串
 */
sds sdsempty( void );
/**
 * 从s复制一个新的动态字符串
 */
sds sdsdup( const sds s );

sdslen()

size_t sdslen(const sds s);

sdsfree()

void sdsfree(sds s);

sdscat()

sdscatlen()

sdscatsds()

/**
 * 将缓冲区t的前len个字节连接到动态字符串中，返回（可能是）新的动态字符串
 */
sds sdscatlen( sds s, const void *t, size_t len );
/**
 * 将字符串连接到s，返回（可能是）新的动态字符串
 */
sds sdscat( sds s, const char *t );
/**
 * 将动态字符串t连接到s，返回（可能是）新的动态字符串
 */
sds sdscatsds(sds s, const sds t);

sds hello = sdsnew( "Hello " );
sds world = sdsnew( "World" );
hello = sdscatsds( hello, world );
sdsfree( world );

sdsgrowzero()

// 如果s的长度大于等于len什么都不做，否则扩充到len长并使用0填充
sds sdsgrowzero(sds s, size_t len);

sdscatprintf()

/**
 * 根据fmt和后续参数进行字符串格式化，然后连接到动态字符串s中
 */
sds sdscatprintf(sds s, const char *fmt, ...);

sdscatprintf(sdsempty(), "%s %s", "Hello", "Alex");

sdsfromlonglong()

sds sdsfromlonglong(long long value);

sds num = sdsfromlonglong( 9460500000000 );
assert( 0 == strcmp( "9460500000000", num ));

sdstrim()

/**
 * 修剪动态字符串s，清除左侧或者右侧的、存在于cset中的字符
 */
void sdstrim( sds s, const char *cset );

sds str = sdsnew( "\n\nHello World   " );
sdstrim( str, "\n " );
assert( strcmp( "Hello World", str ) == 0 );

sdsrange()

/**
 * 修改动态字符串s，保留从start到end的部分，end包含在内
 */
void sdsrange( sds s, int start, int end );

sdscpy()

sdscpylen()

strcpy()

/**
 * 拷贝t到动态字符串s中
 */
sds sdscpy( sds s, const char *t );
/**
 * 拷贝t的前len个字节到动态字符串s中
 */
sds sdscpylen(sds s, const char *t, size_t len);

scscatrepr()

sds sdscatrepr(sds s, const char *p, size_t len);

//示例：
sds s = sdsempty();
char q[10];
q[0] = 'A';q[1] = 1;q[2] = 20;q[4] = '\t';q[3] = '\n';
s = sdscatrepr(s,q,10);
printf( s ); //输出："A\x01\x14\n\t\x7f\x00\x00\x00\x00"

sdssplitlen()

sdsfreesplitres()

/**
 * s的前len个字节用来被分割，sep的前len字节用作分隔符，count用于返回子串的数量
 */
sds *sdssplitlen( const char *s, int len, const char *sep, int seplen, int *count );
// 销毁子串资源
void sdsfreesplitres( sds *tokens, int count );

char *str = "1986,.1989.,2014";
int count;
sds *substrs = sdssplitlen( str, strlen( str ), ",.", 2, &count );
for ( int i = 0; i < count; ++i ) {
    sds substr = *( substrs + i );
    printf( "%s\n", substr );
    //打印：
    //1986
    //1989.,2014
}
sdsfreesplitres( substrs, count );

sdsjoin()

sdsjoinsds()

/**
 * 使用sep中的前seplen个字符作为分隔符，连接长度为argc的字符串数组
 */
sds sdsjoin( char **argv, int argc, char *sep, size_t seplen );
//类似上面
sds sdsjoinsds( sds *argv, int argc, const char *sep, size_t seplen );

char *strs[3] = { "foo", "bar", "zap" };
printf( sdsjoin( strs, 3, "-" )); //打印：foo-bar-zap

sdsRemoveFreeSpace()

sds sdsRemoveFreeSpace(sds s);

sdsAllocSize()

size_t sdsAllocSize(sds s); 

sdsupdatelen()

void sdsupdatelen( sds s );

// 举例
sds s = sdsnew( "foobar" );
s[2] = '\0';
assert( sdslen( s ) == 6 );
sdsupdatelen(s);
// 更新逻辑长度后，sds的长度与C字符串长度一致
assert( sdslen( s ) == 2 );

上面这些函数，但凡返回sds的，在内存溢出的情况下一律会返回空指针。 

SDS头部由下面的数据结构表示：

struct sdshdr {
    int len;    // 保存动态字符串的长度
    int free;   // 保存缓冲区空闲字节数，这些空闲字节可以容纳更多的字符
    char buf[]; // 未声明长度的数组，因此它实际上指向free后面的那个字节，这很重要
};

结构中的buf字段是一个flexible array member，它是C99引入的特性——位于结构体最后的无长度的数组。该数组的指针指向紧跟着结构体的内存，下面的示例代码可以验证这一点：

typedef struct {
    int len;
    char buf[];
} head;

int main() {
    void *mem = malloc( 1024 );
    head *h = mem;
    char *str = mem + sizeof( head );
    str[0] = 'A'; str[1] = 'B';
    printf( h->buf ); // 打印AB
    return 0;
}

要创建一个SDS，只需要在堆上分配不小于sdshdr长度+字符串长度的内存即可。但是为了避免每次操控都导致新的内存分配，SDS总是预分配一些额外的内存。SDS的预分配算法是：当每次进行内存分配时，实际分配的内存是最小需求量的2倍。内存分配的最大量由宏

SDS_MAX_PREALLOC

如果你需要在多个数据结构中共享SDS动态字符串，应当将SDS封装在具有引用计数的结构体中，避免编程错误导致的内存泄漏： 

struct ds {
    int refcount;
    sds str;
}

你应当提供增加、减少引用计数的函数：

1. 每当其它数据结构引用ds或者将ds赋值给变量时，都应当增加引用计数
2. 每当引用移除时，减少计数，计数为0时，自动销毁SDS字符串

在Redis中，为了增强性能使用了SDS提供的一些低级API。使用

sdsIncrLen()

sdsMakeRoomFor()

oldlen = sdslen(s);
s = sdsMakeRoomFor(s, BUFFER_SIZE);
nread = read(fd, s+oldlen, BUFFER_SIZE); // 系统调用
sdsIncrLen(s, nread);  

The post 使用C语言进行文本处理 appeared first on 绿色记忆.

在Linux系统中，作为/bin/sh的标准Shell是GNU工具集中的bash（GNU Bourne-Again Shell），大多数Linux发行版中/bin/sh是指向/bin/bash的一个链接。

Bash编程中，可以通过PID文件进行简单的单例控制——仅仅同时仅仅允许脚本的单个实例在运行：

#!/usr/bin/env bash
PIDFILE=/var/run/gmem-sync.pid
if [ -f $PIDFILE ]
then
  # PID文件存在
  PID=$(cat $PIDFILE)
  ps -p $PID > /dev/null 2>&1
  if [ $? -eq 0 ]
  then
    # PID文件指定的进程存在
    echo "Job is already running"
    exit 1
  else
    # PID文件指定的进程不存在
    echo $$ > $PIDFILE
    if [ $? -ne 0 ]
    then
      echo "Could not create PID file"
      exit 1
    fi
  fi
else
  echo $$ > $PIDFILE
  if [ $? -ne 0 ]
  then
    echo "Could not create PID file"
    exit 1
  fi
fi

# 这里编写主逻辑


# 完毕后删除PID文件
rm $PIDFILE

# 以独占锁（-x）打开gmem-sync.pid文件，并执行-c指定的命令
# -n 如果无法获得独占锁，立即静默的退出，退出状态非0
flock -xn /var/run/gmem-sync.pid -c /usr/local/bin/gmem-sync.sh

我们可以对终端输出的字符颜色、背景色等参数进行设置，实现方式是转义序列。这个控制实际上与Bash语言无关，其它语言在输出时也可以使用。

转义序列以ESC字符开头，对应八进制的\033。控制代码格式为：

\033[显示方式;前景色;背景色;动作m;

注意：显示方式、前景色、背景色都是可选的，而且顺序可以颠倒。示例：

# 恢复系统默认设置
\033[0m
# 设置蓝色背景、白色前景、光标闪烁
\033[44;37;5m

在脚本中使用色彩控制的例子：

echo -e "\033[44mDumping Gmem database on hk.gmem.cc ...\033[0m"

可以利用初始化脚本函数（Init Script Functions）来输出系统日志：

echo hello; echo there
if [ -x "$filename" ]; then # 注意分号后面的空格

case "$variable" in
    abc) echo "\$variable = abc" ;;
    xyz) echo "\$variable = xyz" ;;
esac

let "t2 = ((a = 9, 15 / 3))" #设置t2=15/3，a=9

if condition
then : #什么都不做
else 
    take-some-action
fi
: >> target_file #如果不存在，则创建文件

echo \"{These,words,are,quoted}\"
#打印："These" "words" "are" "quoted"
cat {file1,file2,file3} > combined_file
#将三个文件的内容连接合并到combined_file
cp file22.{txt,backup}
#复制file22.txt为file22.backup

echo {a..z} 
#打印 a b c d e f g h i j k l m n o p q r s t u v w x y z
echo {0..3} 
#打印 0 1 2 3
base64_charset=( {A..Z} {a..z} {0..9} + / = )
#初始化一个数组

#!/bin/bash
File=/etc/fstab
{
    read line1
    read line2
} < $File
echo "第一行:"
echo "$line1"
echo
echo "第二行:"
echo "$line2"
{
    echo "$line1"
} > $File
exit 0

a=3
b=7
echo $[$a+$b] # 10
echo $[$a*$b] # 21

#将a赋值为8
a=(( 5 + 3 ));
#双圆括号也是一种在Bash 中允许使用C 风格的变量处理的机制，注意下面赋值的空格
(( a = 23 ))
(( a++ ))
(( a-- ))
(( t = a<45?7:11 )) # C 风格的3元操作

veg1=carrots
veg2=tomatoes
if [[ "$veg1" < "$veg2" ]]
then :
else :
fi

#打印所有.lst文件，并排序和删除重复行
cat *.lst | sort | uniq

变量的名称是作为其值的占位符，获取其值的操作称为变量替换——使用$前缀执行。在以下情况下，不需要$前缀：变量声明、变量赋值、read、uset、export、((算术表达式))、或者作为代表信号的特殊情况下。在双引号中还是会发生变量替换，这被叫做部分引用，或叫弱引用；在单引号中就不会发生变量替换，这叫做全引用，也叫强引用。

$是${}的简写形式。

未初始化的变量的值为null。使用这样的变量可能出现问题，但是进行算术运算是允许的，相当于0

a=879
echo "The value of \"a\" is $a."
let a=16+5 #使用let赋值
#在for循环中赋值
for a in 7 8 9 11
do
    echo -n "$a "
done
#在read 命令状态中赋值
echo -n "Enter \"a\" "
read a
echo "The value of \"a\" is now $a."
#把echo 命令的结果传给变量a
a=`ls -l`
echo $a #注意，ls命令输出的空白符，包括换行，均消失
echo "$a" #空白符保留
# 命令替换的另外一种形式
a=$(cat /ect/redhat-release)

# 命令替换嵌套，$()形式嵌套了``形式
pid=$(ps `jcmd | awk '{print $1}' ` | grep passport | awk '{print $1}' | head -1)

Bash不区分变量的类型，在本质上所有变量均是字符串。但是在特定上下文下，又作为数字看待。

局部变量：只有在代码块或者函数中可见

环境变量：Shell启动时，创建自己的环境，并影响所有子Shell

位置参数：$0, $1, $2, $3...，其中$0代表脚本文件的名字1-9代表参数${10}代表第10个参数，等等。$*、$@表示所有位置参数的数组。使用shift可以左移参数

#!/bin/bash

# 解析传递给此脚本的参数
# -o 指定短参数，单字符，多个参数连续写在一起，结尾:
# -l 指定长参数，多个参数使用逗号分隔，结尾:
# 此命令修改$@，$N的含义可能发生改变，命令的非选项部分，最好放在前面
getopt -o lc: --long latest,chart:  -- "$@" > /dev/null

LATEST=false
CHART=""

echo '$1'=$1
echo '$2'=$2
echo '$3'=$3
echo '$4'=$4
echo '$5'=$5

while true; do
  case "$1" in
    -l | --latest ) LATEST=true; shift ;;
    -c | --chart )    CHART=$2; shift; shift ;;
    -- ) shift; break ;;
    * ) break ;;
  esac
done

echo LATEST=$LATEST
echo CHART=$CHART

调用上述脚本的示例：

./push.sh  --latest --chart ngress gmem digital
# $1=--latest
# $2=--chart
# $3=ngress
# $4=gmem
# $5=digital
# LATEST=true
# CHART=ngress

./push.sh  --latest  gmem digital
# $1=--latest
# $2=gmem 注意非参数的位置改变
# $3=digital
# $4=
# $5=
# LATEST=true
# CHART=

例如：eval var1=\$$var2

declare 或者typeset 内建命令(这两个命令是完全一样的)允许指定变量的具体类型

引号可以保护字符串的字面值，避免特殊字符被重新解释，或者被Shell扩展

grep '[Ff]irst' *.txt #基于正则式搜索*.txt文件的内容

处理一个或者多个命令的输出，并字面的（literally）将其赋予另外一个上下文（设置变量、作为另外一个命令的参数、甚至生成for循环的列表）。命令替换的典型的语法是反引用包围的命令。命令替换以subshell形式调用

script_name=`basename $0`
echo "The name of this script is $script_name."

textfile_listing=`ls *.txt`
#命令替换的可选语法：textfile_listing=$(ls *.txt)
echo $textfile_listing

#把文件内容赋值给变量
variable1=`<file1`
variable2=`cat file2`
#命令替换可能导致单词分隔
COMMAND `echo a b` #COMMAND有两个参数a、b
COMMAND "`echo a b`" #一个参数 "a b"
COMMAND `echo` #没有参数
COMMAND "`echo`" #一个空参数

VAR=$(command)

ERROR=$(cat file1.txt nofile.txt 2>&1 > /dev/null)

VAR=$(cat file1.txt nofile.txt 2>&1) 

算数扩展提供了强大的整数算术操作机制。

z=`expr $z + 3`
z=$(($z+3))       #双括号，注意不要和命令替换混淆
z=$((z+3))        #双括号中，变量解引用可有可无
let z=z+3
let "z += 3"      #引号允许在变量赋值语句中使用空格 

#下面3种方式均可得到字符串长度
stringZ=abcABC123ABCabc
echo ${#stringZ} # 15
echo `expr length $stringZ` # 15
echo `expr "$stringZ" : '.*'` # 15

expr match "$string" '$substring'    #$substring 是一个正则表达式
expr "$string" : '$substring'        #$substring 是一个正则表达式
#举例
echo `expr match "$stringZ" 'abc[A-Z]*.2'`

#                注意：不要加引号
                 # 前缀匹配              # 后缀匹配
if [[ "$line" == flannel* || "$line" == *$K8S_VERSION ]]; then
  echo $line
fi 

expr index $string $substring    #匹配到子串的第一个字符的位置
#举例
stringZ=abcABC123ABCabc
echo `expr index "$stringZ" C12`   #6

#在string中从位置$position 开始提取子串
#如果$string 为"*"或"@",那么将提取从位置$position 开始的位置参数
${string:position} 

#在string中从位置$position 开始提取$length 长度的子串
${string:position:length}

#举例
stringZ=abcABC123ABCabc
echo ${stringZ:0}     # abcABC123ABCabc
echo ${stringZ:1}     # bcABC123ABCabc
echo ${stringZ:7}     # 23ABCabc
echo ${stringZ:7:3}   # 23A
echo ${stringZ:(-4)}  # Cabc
echo ${*:2}           # Echo 出第2个和后边所有的位置参数
echo ${@:2}           # 与前边相同
echo ${*:2:3}         # 从第2个开始,Echo后边3个位置参数
if [ "${1:0:1}" = '-' ]; then echo " $1 is a option"; fi

#在string中从位置$position开始提取$length 长度的子串
expr substr $string $position $length 
#举例
stringZ=abcABC123ABCabc
echo `expr substr $stringZ 1 2` # ab
echo `expr substr $stringZ 4 3` # ABC

#从$string 的开始位置提取$substring,$substring 是一个正则表达式
expr match "$string" '\($substring\)'
expr "$string" : '\($substring\)'
#举例
stringZ=abcABC123ABCabc
echo `expr match "$stringZ" '\(.[b-c]*[A-Z]..[0-9]\)'` # abcABC1

#从$string 的左边截掉第一个匹配的$substring
${string#substring}
#从$string 的左边截掉最后一个匹配的$substring
${string##substring}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ#a*C} # 123ABCabc   截掉'a'和'C'之间最近的匹配
echo ${stringZ##a*C} # abc        截掉'a'和'C'之间最远的匹配

#从$string 的右边截掉第一个匹配的$substring
${string%substring}
#从$string 的右边截掉最后一个匹配的$substring
${string%%substring}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ%b*c}  # abcABC123ABCa 从$stringZ 的后边开始截掉'b'和'c'之间的最近的匹配

#使用$replacement 来替换第一个匹配的$substring
${string/substring/replacement}
#使用$replacement 来替换所有匹配的$substring
${string//substring/replacement}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ/abc/xyz}  # xyzABC123ABCabc
echo ${stringZ//abc/xyz} # xyzABC123ABCxyz

#如果$substring 匹配$string 的开头部分,那么就用$replacement 来替换$substring
${string/#substring/replacement}
#如果$substring 匹配$string 的结尾部分,那么就用$replacement 来替换$substring
${string/%substring/replacement}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ/#abc/XYZ} # XYZABC123ABCabc
echo ${stringZ/%abc/XYZ} # abcABC123ABCXYZ

exit 命令被用来结束脚本，返回一个值来传给父进程，如果没有exit，则最后执行的命令的exit状态被返回。

每个命令都会返回一个 exit 状态(有时候也叫return 状态)，成功返回0，如果返回一个非0 值，通常情况下都会被认为是一个错误码。

变量：$?用于读取退出码。

一个

if/then

内建命令

[

test

Bash 2.02以后，关键字

[[...]]

[[ $a -lt $b ]]

((...))

let...

[[]]

[]

test EXPRESSION

test

[ EXPRESSION ]

[ ]

[ OPTION

EXPRESSION的语法如下：

# 空白表达式为假


# 如果表达式为真，通过测试（结果为真）
( EXPRESSION )

# 如果表达式为假，通过测试
! EXPRESSION

# 逻辑与
EXPRESSION1 -a EXPRESSION2

# 逻辑或
EXPRESSION1 -o EXPRESSION2

# 字符串长度不为零，通过测试
-n STRING

# 如果字符串长度为零，通过测试
-z STRING

# 字符串比较、文件测试、数字比较见下文

[ "$1" = 'mysqld' -a -n "$CLUSTER_INIT" ]   # 如果第一个参数为mysqld，并且变量CLUSTER_INIT不为空

(( 0 && 1 ))                                # 逻辑与，$?为1
let "num = (( 0 && 1 ))"                    # num的值为0，故$?为1
(( 200 || 11 ))                             # 逻辑或，$? # 0
let "num = (( 200 || 11 ))"                 # num的值为1，故$?为0
(( 200 | 11 ))                              # 按位或，$?为0     
   
# 注意，本行不会打印var变量，因为算术扩展的退出状态不是一个错误码                                  
var=-2 && (( var+=2 )) && echo $var     

# 测试任何命令    
if grep -q Bash file                        
    then echo "At least one Bash in file"
fi
# []或者[[]]测试时，必须与内部表达式之间保留一个空格

# 如果在同一行上边写多个子句，必须使用; 来分隔（注意后面的空格）
if [ ! -x "$filename" ]; then :               #空命令:不执行任何动作
else if [0]; then :
elif [1]; then :                            #elif是else if的简写
fi

# 测试上一个命令的退出码
if [[ $? -eq 0 ]] ; then echo 'Successful'; fi
if [[ $? -eq 0 ]] ; then
    echo 'Succeeded'
    echo 'OK'
else
    echo 'Failed'
fi

# 测试第四个参数是否存在
if [ -z "$4" ] ; then
   echo "Argument 4 not exist"
fi

# 所有内容集中在单行编写的例子
if [[ $? -eq 0 ]]; then echo FOUND; fi
# 使用逻辑与/或
if [[ 1 -eq 1 && 2 eq 2 ]]; then : fi
if [[ 1 -eq 1 ]] || [[ 2 -eq 1 ]]; then : fi

if [ condition1 ]
then
    if [ condition2 ]
    then
    do-something # 这里只有在condition1 和condition2 都可用的时候才行.
    fi
fi

case "$variable" in
"$condition1")         #测试行都以右小括号)结尾
    command...
;;                     #条件块都以两个分号结尾
"$condition1")
    command...
;;
esac
#举例
read Keypress
case "$Keypress" in
[[:lower:]] ) echo "Lowercase letter";;
[[:upper:]] ) echo "Uppercase letter";;
[0-9] )       echo "Digit";;
* )           echo "Punctuation, whitespace, or other";;
esac

#for循环
for arg in [list]
do
    command(s)...
done

默认的分隔符是whitespace，也就是每当遇到分隔符，就会产生新的arg。要修改分隔符为换行，在循环前添加：

IFS=$'\n'

LIMIT=10
for ((a=1, b=1; a <= LIMIT ; a++, b++))
do
    echo -n "$a "
done

# 无限循环
for (( ; ; ))

while [condition]
do
    command...
done

((a = 1))
while (( a <= LIMIT ))
do
    echo -n "$a "
    ((a += 1)) # let "a+=1"
done

until [condition-is-true]
do
    command...
done 

# 无限循环1
while :

# 无限循环2
while true

# 遍历范围
var0=0
LIMIT=10
while [ "$var0" -lt "$LIMIT" ]
do
    echo -n "$var0 "
    var0=`expr $var0 + 1` 
    # var0=$(($var0+1))
    # var0=$((var0 + 1))
    # let "var0 += 1"
done

可以使用管道：

ip route | while read -r route; do
  dest=$(echo $route | awk '{print $1}')
  if [[ "$dest" != *"/"* ]]; then
    continue
  fi
done

注意，某些命令结尾没有\n，这会导致遍历的时候最后一行被略过，需要这样：

{ yourcmd; echo; } | while read -r line; do echo $line; done

# 遍历文件的每一行，注意，echo确保文件不以换行符结尾的情况下，最后一行不丢失
{ cat images.txt; echo; } | while read -r line; do
  if [[ "$src" == "" ]]; then
    continue
  fi
done

使用管道时，while运行在subshell中，缺点是无法修改变量，可以使用Here String规避：

declare -A tgt_service_versions
while read -r line; do
  comp=$(echo "$line" | yq r - '.service_name')
  version=$(echo "$line" | yq r - '.tmplgrp_version')
  tgt_service_versions[$comp]=$version
done <<< "$(yq r global.yaml ".vars.services")"

# 遍历字符串列表，注意，如果字符串加引号，作为整体看待
for planet in Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune Pluto
do
    echo $planet # Each planet on a separate line.
done

# 遍历字符串列表，使用变量
FILES="/usr/sbin/accept
/usr/sbin/pwck
/usr/sbin/chroot
/usr/bin/fakefile
/sbin/badblocks
/sbin/ypbind"
for file in $FILES
do
    if [ ! -e "$file" ]
        break
        continue 1   # 控制循环的行为，数字用于跳出或继续N层循环
    fi
done

# 遍历文件列表。如果列表中包含通配符*?，则会扩展文件名，即file globbing
#   *所有文件
#   [jx]* 所有j或者x开头的文件
for file in *; do ...
for cfg in config/*; do
    if
done

# 遍历参数数组。如果忽略列表，则操作$@
for a
do
    echo -n "$a "
done 

一个内建命令通常与一个系统命令同名，但是Bash 在内部重新实现了这些命令

declare [-aAfFgilnrtux] [-p] [name[=value] ...]

local [option] [name[=value] ...]

eval arg1 ... [argN]

# 方括号内的是作业号
# Running表示正在运行的作业， 它会打印到标准输出
[1]- Running ping www.baidu.com &
# +表示当前作业，如果fg、bg不指定参数，则针对当前作业
# Stopped表示挂起的作业，但是进程并没有退出
[2]+  Stopped                 ping www.163.com
# -表示如果当前作业退出，则它会变成当前作业
[3]-  Stopped                 ping www.qq.com

参见：Linux命令知识集锦

command --args << EOF
...
#注意在这里会发生变量替换，因此需要必要的转义
\$PWD is $PWD
...
...
EOF

# 将Here Document写入到文件
cat << EOF  > /path/to/file
drill.exec: {
  cluster-id: "$CLUSTER_ID",
  zk.connect: "$ZK_CONNECT"
}
EOF

下面两种语法都可以：

cat - <<'EOF'
$KNOWN
EOF
# 输出 $KNOWN

cat - <<\EOF
$KNOWN
EOF

可以看作是Here Document的stripped-down形式。字符串被展开，并逐个喂给命令的stdin：

COMMAND <<< $WORD

示例：

if grep -q "txt" <<< "$VAR"
then
   echo "$VAR contains the substring sequence \"txt\""
fi

String="This is a string of words."
# 将字符串中的每个字符写入为数组元素
read -r -a Words <<< "$String" 

Linux中，有三个文件：stdin、stdout、stderr总是处于打开状态的。这些文件或者任何打开的文件，可以被重定向。所谓重定向，就是捕获来自文件、命令、程序、脚本甚至代码块的输出（output），并将其作为其它文件、命令、程序或者脚本的输入。

#重定向输出到文件，如果不存在，则创建，否则覆盖
ls -lR > dir-tree.list
: > filename     #将文件的内容清空，如果不存在则创建

#重定向输出到文件，如果不存在，则创建，否则附加到文件结尾
ls -lR >> dir-tree.list

1>filename       #把标准输出重定向到文件
2>filename       #把标准错误重定向到文件
&>filename       #把标准输出、错误同时重定向到文件

LOGFILE=script.log
echo "命令的输出被重定向到文件描述符" 1>$LOGFILE
echo "命令的错误被重附加到文件描述符" 2>>$LOGFILE

2>&1             #把标准错误重定向到标准输出
i>&j             #重定向文件描述符i到文件描述符j
>&j              #重定向默认文件描述符（1，stdout）到j

0< FILENAME      #从文件读取输入

[j]<>filename    #打开文件进行读写，并分配文件描述符j
exec 3<> File    #打开File，并分配3位文件描述符
read -n 4 <&3    #从文件描述符3读入4字符
echo -n . >&3    #输出一个小数点到文件描述符3
exec 3>&-        #关闭文件描述符3

n<&-             #关闭输入文件描述符n
0<&-, <&-        #关闭标准输入
n>&-             #关闭输出文件描述符n
1>&-, >&-        #关闭标准输出

while [ "$name" != Smith ]
do
    read name
    echo $name
    let "count += 1"
done <"$Filename"#重定向代码块的输入

Subshell指Shell发动的子进程。一般的，外部命令会发动子Shell，而内置命令则不会，此外，括号包含的命令列表发动Subshell：

( command1; command2; command3; ... )

#Subshell可用于构建专用运行环境
COMMAND1
COMMAND2
COMMAND3
(
    IFS=:
    PATH=/bin
    unset TERMINFO
    set -C
    shift 5
    COMMAND4
    COMMAND5
    exit 3 #这里只会退出Subshell
)

 Subshell中的变量，在代码块以外无法访问，相当于局部变量。

在受限模式下运行的Shell，一些命令被禁用：

1. 使用cd改变当前目录
2. 修改环境变量$PATH, $SHELL, $BASH_ENV,  $ENV
3. 读取或者改变$SHELLOPTS
4. 重定向输出
5. 调用包含/符号的命令
6. 调用exec命令来替换Shell的进程
7. 解除受限模式
8. 其它一些命令

使用set -r、set --restricted开启脚本受限模式。

进程替换把一些进程的输出作为其它进程的输入来使用。命令格式如下（使用括号包围），注意没有空格：

>(command_list)
<(command_list)

函数语法：

function function_name {
    command...
}
#第二种语法支持C-Style
function_name () {
    if [ -z "$1" ] #$1表示第一个参数
    then
        echo "-Parameter #1 is zero length.-"
    else
        echo "-Param #1 is \"$1\".-"
    fi
}
#调用函数
function_name 
function_name $arg1 $arg2  #传参，只支持传值方式，可以使用间接引用来传引用
#支持函数嵌套
f1 ()
{
    f2 () # nested
    {
        echo "Function \"f2\", inside \"f1\"."
    }
}

 函数的退出：函数返回一个值，称为exit status，这与命令退出码类似。可以使用return语句指定返回值，否则，最后一条命令的退出码作为返回值。

Bash别名可以简单的看作一个键盘快捷方式：

alias ll="ls -l"

and list：如果前一个命令的退出码为0，则继续执行后面的命令

command-1 && command-2 && command-3 && ... command-n

 or list：如果前一个命令退出码味非0，则继续执行后面的命令

command-1 || command-2 || command-3 || ... command-n

较新版本的Bash支持一维数组，数组元素以

variable[xx]

${element[xx]}

area[11]=23
area[13]=37
area[51]=UFOs

echo ${area[11]}
area[5]=`expr ${area[11]} + ${area[13]}`

area2=( zero one two three four )
area3=([17]=seventeen [24]=twenty-four)
base64_charset=( {A..Z} {a..z} {0..9} + / = )

没有下标的索引点，不会占用元素个数：

adobe=([0]='Flash' [2]='Flex' [4]='Photoshop')
echo ${#adobe[@]}
# 打印 3 

可以使用表达式：

${array[@]}

# 声明一个数组，它的元素来自DOCKER数组的所有成员 +
#                                    run字面之 +
#                                         docker_run_opts数组的所有成员 +
#                                                                KUBE_BUILD_IMAGE 变量
local -ra docker_cmd=("${DOCKER[@]}" run "${docker_run_opts[@]}" "${KUBE_BUILD_IMAGE}")

通过扩展操作，可以连接两个数组：

adobe=('Flash' 'Flex' 'Photoshop' 'Dreamweaver' 'Premiere')
adobe2=('Fireworks' 'Illustrator')
adobe3=(${adobe[@]} ${adobe2[@]}) 

adobe=('Flash' 'Flex' 'Photoshop' 'Dreamweaver' 'Premiere')
echo ${adobe[@]:1:3}
# 打印 Flex Photoshop Dreamweaver
echo ${adobe[@]:3}
# 打印 Dreamweaver Premiere

names=(`cat 'names.txt'`)

adobe=('Flash' 'Flex' 'Photoshop' 'Dreamweaver' 'Premiere')

for item in ${adobe[@]};do
	echo $item
done

len=${#adobe[@]}
for ((i=0;i<$len;i++));do
	echo ${adobe[$i]}
done 

关联数组也就是字典/映射，声明语法：

declare -A archMap=(
  [x86_64]=amd64
  [aarch64]=arm64
)

${#filetypes[*]}
${#filetypes[@]}

archMap[arm64]=aarch64 

arch=x86_64
${archMap[$arch]}

# 使用*，并且整个表达式用双引号包围，则结果是一个字符串
${!filetypes[*]}
# 使用@，并且整个表达式用双引号包围，则结果是一个数组
${!filetypes[@]}

# 使用*，并且整个表达式用双引号包围，则结果是一个字符串
"${filetypes[*]}"
# 使用@，并且整个表达式用双引号包围，则结果是一个数组
${filetypes[@]}

for key in "${!filetypes[@]}"; do 
  echo ${filetypes[$key]}
done

Unix、Linux的文件系统中，通常都有这两个特殊用途的子目录。

包含设备文件（device files），包括环回文件（loopback devices，例如/dev/loop0。所谓环回文件是一种虚拟机制，可以将一个普通文件作为块设备访问）。此目录下还包含若干常用的伪设备：/dev/null, /dev/zero,/dev/urandom, /dev/sda1, /dev/udp,/dev/tcp。

/dev/null：相当于一个黑洞，可以用于忽略输出：

#忽略命令的输出
cat $filename >/dev/null
#忽略命令的错误
rm $badname 2>/dev/null

#从中无法读取到任何东西，可以用于清空文件内容
cat /dev/null > /var/log/messages

 /dev/zero：该设备制造二进制0，主要用于生成交换文件

当在/dev/tcp/$host/$port这样的伪设备上执行命令时，Bash会打开一个TCP连接：

#从time.nist.gov获取时间
cat /dev/tcp/www.net.cn/80
echo -e "GET / HTTP/1.0\n" >&5
cat <&5

该目录中的文件是当前系统中正在运行的系统和内核进程的镜像，包含了运行时和统计信息。可以获取CPU、内存、电池等多种组件的信息。

关于Linux信号相关的知识，参考Linux信号、进程和会话

注意：如果存在正在运行的子进程，Bash默认会忽略发送给父进程的信号。

当你在终端窗口按下Ctrl + C或者Break键后，正常情况下应用程序会立即停止。但是你可以在脚本中指定信号处理函数。其格式为：

# arg默认为 - 表示捕获到信号时，需要执行的命令
trap [-lp] [[arg] sigspec ...]

示例用法：

# 列出信号名称和编号的对应关系
trap -l

# 接收到HUP INT PIPE QUIT TERM这几种信号时，执行exit 1命令
trap "exit 1" HUP INT PIPE QUIT TERM

# 也可以指定函数来处理信号
sighdl() {
}
trap sighdl SIGTERM

# 重置信号的默认处理逻辑
trap 1 2

# 忽略信号
trap '' 1

当进程收到信号后，在同一线程中发生以下事件序列：

1. 当前进程正在进行的内置命令（不产生子进程）立即退出
2. 程序转到trap指定的信号处理脚本执行
3. 执行完毕后，到被中断的命令的下一行执行

例如下面的脚本：

trap "echo TRAPED" HUP INT PIPE QUIT TERM
while true; do :; done

当按下Ctrl + C后，信号处理脚本运行，但是然后会继续循环，程序无法停止。下面的代码则可以正常工作：

sighdl() {
    echo TRAPED
    TERM_FLAG=1
}
trap sighdl HUP INT PIPE QUIT TERM

while [ "$TERM_FLAG" != "1" ] ; do :; done 

设置选项

set -o errexit

set -e

要捕获这个信号，你需要选项

set -o errexit -o errtrace

set -eE

# 出错时清理后台进程
trap 'kill $(jobs -p)' ERR

# 分割字符串 1,2,3,4,5,6,7,8,9,10
# IFS指定基于什么符号拆分，这里是逗号
IFS=',' read -ra ARRAY <<< `seq -s ',' 10`
for i in "${ARRAY[@]}"; do
    # 遍历分割后的子串
    echo $i 
done

可以使用Glob：

if [[ $line = *"Server startup in"* ]]; then ...

#!/bin/bash
shopt -s globstar
for file in ./*.go ./**/*.go ; do
	echo $file
done

./*

./**/*

exec 2> /var/log/on-startup.log   # 将当前脚本的标准错误重定向到文件
exec 1>&2                         # 将当前脚本的标准输出重定向到标准错误
set -x

echo >&2 "ERROR: "

如果你读取标准输入，并且循环处理：

while read p; do
  cmd $p
done < input.file

当循环体中的命令cmd也会读取标准输入时，上述循环会立即退出。

解决办法：

for p in `cat input.file`
do
  cmd $p
done

报错信息：Permission denied

解决办法：

sudo sh -c "echo '' > $LOG"

如果在管道的某个命令中需要退出处理，你需要显式的关闭管道中的其它命令（Subshell），简单的例子：

tail -f /usr/local/$TOMCAT_PATH/logs/catalina.out | while read line
do
    if [[ $line = *"Server startup in"*  ]]; then
          # 找到管道前面的命令tail，并杀死
          TAIL_PID=`ps --ppid $PID  | grep tail | awk '{print $1}'`
          echo "Killing subprocess $TAIL_PID"
          kill -9 $TAIL_PID
          exit 0
    fi
done

如果管道由很多命令组成，可以将它们放置到同一进程组中，然后向进程组发送信号，一起终结它们：

# 项目的命令启用Job控制，导致后台进程运行在独立的进程组
set -m

tail -Fn0 /tmp/report | while :
do 
    echo "pre"
    # 向后台进程组发送信号，使其中的所有进程终结
    sh -c 'PGID=$( ps -o pgid= $$ | tr -d \  ); kill -TERM -$PGID'
    echo "past"
done &  # 在后台运行
wait    # 等待上述后台任务退出 

pushd `dirname $0` > /dev/null
SCRIPT_DIR=`pwd`
popd > /dev/null

单引号字符串默认是禁止转义的，如果其中包含成对的单引号本身，会自动被忽略。

echo '''a'''    # a

 如果其中包含的单引号不成对，属于语法错误。如果要在单引号字符串中使用单引号本身，可以：

echo  $'\'a\''

即，在字符串前面加上特殊符号$，即可启用ANSI C风格的转义

#跨行编写的多行字符串变量
mls="
line 1
line 2
line 3
"

#echo的默认行为是把换行符修改为空格输出
echo $mls
#输出：line 1 line 2 line 3

#目标变量外面加上引号，则可避免此默认行为
echo "$mls"
#输出：
#
#line 1
#line 2
#line 3
#
#可以看到，首尾有空白行，这分别是第一个"后的空白行，以及line3后面的空白行

#行尾加上反斜杠，可以把相邻的两行作为单行看待：
mls="\
line 1
line 2
line 3\
"
#再执行echo "$mls"，就不会有空白行了：
#line 1
#line 2
#line 3

mls="\
line 1
line 2\n
line 3\
"
#默认的，反斜杠转义是不被echo命令启用的，除非指定-e
#执行echo -e  "$mls"，会发现\n被转义为换行输出:
#line 1
#line 2

#line 3

#可以使用 $'\n' 把新行添加到变量尾部
mls="$mls"$'\n'"line 4"

#使用Here Document捕获多行文本到变量
read -d '' mls << EOF
line 1git-study-note
line 2
line 3
EOF
#首尾不会出现空行
echo "$mls"

The post Bash学习笔记 appeared first on 绿色记忆.