27kb左右的单文件,无第三方依赖

bytes包提供了对字节切片进行读写操作的一系列函数
字节切片处理的函数比較多,分为基本处理函数,比較函数,后缀检查函数,索引函数,切割函数,
大写和小写处理函数和子切片处理函数等.

地址:

1.字节切片基本处理函数api

和scheme比起来,表达能力上区别不大,只是少了些函数,不过提供接口让使用者注册后端函数,本身运行可以生成前端函数;适用于运作时需要实时逻辑控制的情况。

1.1Contains()函数

//Contains()函数的功能是检查字节切片b是否包括子切片subslice,假设包括返回true,否则返回false.
func Contains(b,subslice []bytes) bool
package main

import "github.com/hydra13142/lisp"

func main() {
    lisp := lisp.NewLisp()
    lisp.Extend()
    lisp.Eval(`
        (define
            (quicksort s)
            (each
                (define
                    (end l)
                    (cond
                        ((atom l)
                            1
                        )
                        ((atom (cdr l))
                            1
                        )
                        (1 0)
                    )
                )
                (define
                    (above a b c)
                    (cond
                        ((atom b)
                            c
                        )
                        ((<= a (car b))
                            (above
                                a
                                (cdr b)
                                (cons (car b) c)
                            )
                        )
                        (1
                            (above a (cdr b) c)
                        )
                    )
                )
                (define
                    (below a b c)
                    (cond
                        ((atom b)
                            c
                        )
                        ((> a (car b))
                            (below
                                a
                                (cdr b)
                                (cons (car b) c)
                            )
                        )
                        (1
                            (below a (cdr b) c)
                        )
                    )
                )
                (define
                    (sort s)
                    (cond
                        ((end s)
                            s
                        )
                        (1
                            (each
                                (define n (car s))
                                (+
                                    (sort (below n (cdr s) '()))
                                    (cons n (sort (above n (cdr s) '())))
                                )
                            )
                        )
                    )
                )
                (sort s)
            )
        )`)
    lisp.Eval(`
        (define
            (fbnq n)
            (cond
                ((<= n 1)
                    1
                )
                (1
                    (+
                        (fbnq (- n 1))
                        (fbnq (- n 2))
                    )
                )
            )
        )`)
    lisp.Eval(`
        (define
            (reverse s)
            (each
                (define
                    (rev s c)
                    (cond
                        ((atom s)
                            c
                        )
                        (1
                            (rev
                                (cdr s)
                                (cons (car s) c)
                            )
                        )
                    )
                )
                (rev s '())
            )
        )`)
    lisp.Eval(`
        (define
            (map s f)
            (each
                (define
                    (rev s c)
                    (cond
                        ((atom s)
                            c
                        )
                        (1
                            (rev
                                (cdr s)
                                (cons (f (car s)) c)
                            )
                        )
                    )
                )
                (reverse (rev s '()))
            )
        )`)
    lisp.Eval(`
        (println
            (map
                (quicksort '(1 4 2 8 5 7 3 9 0 6))
                fbnq
            )
        )`)
}
//该片段来自于http://outofmemory.cn

1.2Count()函数

//Count()函数的功能是计算字节切片sep在字节切片s中非重叠显示的个数.
func Count(s,sep[]byte) int

1.3Repeat()函数

//Repeat()函数的功能是把切片b复制count个,然后合成一个新的字节切片返回.
func Repeat(b[]byte,count int) []byte

1.4Replace()函数

/*Replace()函数的功能是返回字节切片s的一个副本,并把前n个不重叠的
子切片old替换为new;假设n<0,则不限制替换的数量.參数n为替换的次数*/
func Replace(s,old,new []byte,n int) []byte

1.5Runes()函数

//Runes()函数的功能是把s转换为UTF-8编码的字节序列,并返回相应的Unicode切片.
func Runes(s []byte) []rune

1.6Join()函数

Join函数的功能是用字节切片sep把s中的每一个字节切片连成一个字节切片并返回.
func Join(s [][]byte,sep[]byte) []byte

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Contains
    b := []byte("mChenys") //字符串强转为byte切片
    sublice1 := []byte("m")
    sublice2 := []byte("M")
    fmt.Println(bytes.Contains(b,sublice1))//true
    fmt.Println(bytes.Contains(b,sublice2))//false

    //Count
    s := []byte("hahaahaaa")
    sep1 := []byte("hah")
    sep2 := []byte("aa")
    sep3 := []byte("a")
    fmt.Println(bytes.Count(s,sep1))//1
    fmt.Println(bytes.Count(s,sep2))//2
    fmt.Println(bytes.Count(s,sep3))//6

    //Repeat
    b = []byte("ha")
    fmt.Println(string(bytes.Repeat(b,1)))//ha
    fmt.Println(string(bytes.Repeat(b,2)))//haha

    //Replace
    s = []byte("hello,world")
    old := []byte("o")
    news := []byte("ee")
    fmt.Println(string(bytes.Replace(s,old,news,0)))//hello,world
    fmt.Println(string(bytes.Replace(s,old,news,1)))//hellee,world
    fmt.Println(string(bytes.Replace(s,old,news,2)))//hellee,weerld
    fmt.Println(string(bytes.Replace(s,old,news,-1)))//hellee,weerld

    //Runes
    s = []byte("你好世界")
    r := bytes.Runes(s)
    fmt.Println("转换前字符串的长度: ",len(s))//12
    fmt.Println("转换后字符串的长度: ",len(r))//4

    //Join
    s := [][]byte{[]byte("你好"),[]byte("世界")}
    sep1 := []byte(",")
    fmt.Println(string(bytes.Join(s,sep1)))//你好,世界
    sep2 := []byte("#")
    fmt.Println(string(bytes.Join(s,sep2)))//你好#世界
}

2.字节切片比較函数

2.1Compare()函数

/*Compare()函数的功能是依据字节的值比較字节切片a和b的大小,假设a=b,返回0,
假设a>b返回1,假设a<b返回-1.*/
func Compare(a,b[]byte) int

2.2Equal()函数

/*Equal()函数的功能是用来比較2个字节切片是否相等,假设參数为nil,则等同于
空的字节切片,假设a=b,则返回true,否则返回false.区分大写和小写*/
func Equal(a,b[]byte) bool

2.3EqualFold()函数

/*EqualFold()函数的功能是把s和t转换成UTF-8字符串进行比較,
而且忽略大写和小写,假设s=t,返回true,否则,返回false.*/
func EqualFold(s,t[]byte) bool

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Compare
    a := []byte("abc")
    b := []byte("a")
    fmt.Println(bytes.Compare(a,b))//1 
    b =[]byte("abcd")
    fmt.Println(bytes.Compare(a,b))//-1
    b =[]byte("abC")
    fmt.Println(bytes.Compare(a,b))//1  小写字母大于大写字母
    b =[]byte("b")
    fmt.Println(bytes.Compare(a,b))//-1 从第一个字节開始比較,假设同样再比較长度

    //Equal
    a = []byte("abc")
    b = []byte("ABC")
    fmt.Println(bytes.Equal(a,b))//false
    fmt.Println(bytes.Equal(a,nil))//false
    b = []byte("abc")
    fmt.Println(bytes.Equal(a,b))//true

    //EqualFold
    a = []byte("abc")
    b = []byte("ABC")
    fmt.Println(bytes.EqualFold(a,b))//true

}

3.字节切片前后缀检查

3.1HasPrefix()函数

//HasPrefix()函数的功能是检查字节切片s的前缀是否为prefix,假设是返回true,假设不是返回false.
func HasPrefix(s,prefix[]byte) bool

3.2HashSuffix()函数

//HashSuffix()函数的功能是检查字节切片s的后缀是否为suffix,假设是返回true,否则返回false.
func HashSuffix(s,suffix[]byte) bool

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //HasPrefix
    s := []byte("mChenys")
    prefix := []byte("m")
    fmt.Println(bytes.HasPrefix(s,prefix))//true
    prefix = []byte("men")
    fmt.Println(bytes.HasPrefix(s,prefix))//false

    //HashSuffix
    suffix := []byte("ys")
    fmt.Println(bytes.HasSuffix(s,suffix))//true

}

4.字节切片位置索引函数

字节切片位置索引函数共同拥有8个,Index(),IndexAny(),IndexByte(),IndexFunc(),IndexRune(),
LastIndex(),LastIndexAny()和LastIndexFunc().

4.1index()函数

//返回sep在s中第一次出现的位置索引(从0開始),假设sep中不在s中则返回-1.
func Index(s,sep []byte) int

4.2IndexAny()函数

/*把s解析为UTF-8编码的字节序列,返回chars中不论什么一个字符在s中第一次
出现的索引位置;假设s中不包括chars中不论什么一个字符,则返回-1.*/
func IndexAny(s []byte,chars string) int

4.3IndexByte()函数

//函数的功能是检查字节c在s中第一次出现的位置索引;假设s中不包括c则返回-1.
func IndexByte(s[]byte,c byte) int

4.4IndexFunc()函数

/*的功能是把s解析为UTF-8字节序列,并返回一个满足f(c)=true的字符c的位置
索引,假设没有满足则返回-1.*/
func IndexFunc(s[]byte,f func(r rune)bool) int

4.5IndexRune()函数

/*功能是把s解析为UTF-8字节序列,并返回rune类型的字符r在s中的位置索引,
假设s中不包括r则返回-1.*/
func IndexRune(s[]byte,r rune) int

4.6LastIndex()函数

//的功能是返回sep在s中最后一次出现的位置索引,假设s中不包括sep,则返回-1
func LastIndex(s,sep[]byte) int

4.7LastIndexAny()函数

/*的功能是把s解析为UTF-8字节序列,返回chars中不论什么一个字符在s中最后
出现的位置索引,假设chars为空或者s中不包括chars中的随意字符,则返回-1*/
func LastIndexAny(s[]byte,chars string) int

4.8LastIndexFunc()函数

/*功能是把s解析成UTF-8字节序列,返回满足f(s)=true的字符c在s中最后
一次出现的位置索引,假设没有找到则返回-1.*/
func LastIndexFunc(s[]byte,f func(r rune)bool) int

[实例]

package main

import(
    "fmt"
    "bytes"
)
func main(){
    //Index
    a := []byte("aaaaa")
    fmt.Println(bytes.Index(a,[]byte("a")))//0
    fmt.Println(bytes.Index(a,[]byte("aa")))//0
    fmt.Println(bytes.Index(a,[]byte("b")))//-1

    //IndexAny
    fmt.Println(bytes.IndexAny(a,"a"))//0
    fmt.Println(bytes.IndexAny(a,"aa"))//0

    //IndexByte
    s := []byte("google")
    var ch byte = 'g'
    fmt.Println(bytes.IndexByte(s,ch))//0

    //IndexFunc,能够接收匿名函数
    fmt.Println(bytes.IndexFunc(s,func (a rune)bool{
        if a == 'o'{
            return true
        }else{
            return false
        }
    }))//1

    //IndexRune
    fmt.Println(bytes.IndexRune(s,'e'))//5
    fmt.Println(bytes.IndexRune(s,'a'))//-1

    //LastIndex
    fmt.Println(bytes.LastIndex(s,[]byte("g")))//3
    fmt.Println(bytes.LastIndex(s,[]byte("e")))//5
    fmt.Println(bytes.LastIndex(s,[]byte("o")))//2

    //LastIndexAny
    fmt.Println(bytes.LastIndexAny(s,"gle"))//5
    fmt.Println(bytes.LastIndexAny(s,"l"))//4
    fmt.Println(bytes.LastIndexAny(s,"ge"))//5

    //LastIndexFunc
    fmt.Println(bytes.LastIndexFunc(s,func(r rune)bool{
        if r=='g'{
            return true
        }else {
            return false
        }
    }))//3
}
网站地图xml地图