// bufio 包实现了带缓存的 I/O 操作
// 它封装一个 io.Reader 或 io.Writer 对象
// 使其具有缓存和一些文本读写功能

------------------------------------------------------------

// bufio.go

------------------------------------------------------------

[html] view plaincopy
  1. type Reader struct {
  2. buf          []byte
  3. rd           io.Reader // reader provided by the client
  4. r, w         int       // buf read and write positions
  5. err          error
  6. lastByte     int
  7. lastRuneSize int
  8. }

// NewReaderSize 将 rd 封装成一个拥有 size 大小缓存的 bufio.Reader 对象
// 如果 rd 的基类型就是 bufio.Reader 类型,而且拥有足够的缓存
// 则直接将 rd 转换为基类型并返回
func NewReaderSize(rd io.Reader, size int) *Reader

// NewReader 相当于 NewReaderSize(rd, 4096)
func NewReader(rd io.Reader) *Reader

------------------------------------------------------------

// Peek 返回缓存的一个切片,该切片引用缓存中前 n 字节数据
// 该操作不会将数据读出,只是引用
// 引用的数据在下一次读取操作之前是有效的
// 如果引用的数据长度小于 n,则返回一个错误信息
// 如果 n 大于缓存的总大小,则返回 ErrBufferFull
// 通过 Peek 的返回值,可以修改缓存中的数据
// 但是不能修改底层 io.Reader 中的数据

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABCDEFG")
  3. br := bufio.NewReader(s)
  4. b, _ := br.Peek(5)
  5. fmt.Printf("%s\n", b)
  6. // ABCDE
  7. b[0] = 'a'
  8. b, _ = br.Peek(5)
  9. fmt.Printf("%s\n", b)
  10. // aBCDE
  11. }

------------------------------------------------------------

// Read 从 b 中读出数据到 p 中,返回读出的字节数
// 如果 p 的大小 >= 缓存的总大小,而且缓存不为空
// 则只能读出缓存中的数据,不会从底层 io.Reader 中提取数据
// 如果 p 的大小 >= 缓存的总大小,而且缓存为空
// 则直接从底层 io.Reader 向 p 中读出数据,不经过缓存
// 只有当 b 中无可读数据时,才返回 (0, io.EOF)
func (b *Reader) Read(p []byte) (n int, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")
  3. br := bufio.NewReader(s)
  4. b := make([]byte, 20)
  5. n, err := br.Read(b)
  6. fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)
  7. // ABCDEFGHIJKLMNOPQRST 20 <nil>
  8. n, err = br.Read(b)
  9. fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)
  10. // UVWXYZ1234567890 16 <nil>
  11. n, err = br.Read(b)
  12. fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)
  13. // 0 EOF
  14. }

------------------------------------------------------------

// ReadByte 从 b 中读出一个字节并返回
// 如果 b 中无可读数据,则返回一个错误
func (b *Reader) ReadByte() (c byte, err error)

// UnreadByte 撤消最后一次读出的字节
// 只有最后读出的字节可以被撤消
// 无论任何操作,只要有内容被读出,就可以用 UnreadByte 撤消一个字节
func (b *Reader) UnreadByte() error

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABCDEFG")
  3. br := bufio.NewReader(s)
  4. c, _ := br.ReadByte()
  5. fmt.Printf("%c\n", c)
  6. // A
  7. c, _ = br.ReadByte()
  8. fmt.Printf("%c\n", c)
  9. // B
  10. br.UnreadByte()
  11. c, _ = br.ReadByte()
  12. fmt.Printf("%c\n", c)
  13. // B
  14. }

------------------------------------------------------------

// ReadRune 从 b 中读出一个 UTF8 编码的字符并返回
// 同时返回该字符的 UTF8 编码长度
// 如果 UTF8 序列无法解码出一个正确的 Unicode 字符
// 则只读出 b 中的一个字节,并返回 U+FFFD 字符,size 返回 1
func (b *Reader) ReadRune() (r rune, size int, err error)

// UnreadRune 撤消最后一次读出的 Unicode 字符
// 如果最后一次执行的不是 ReadRune 操作,则返回一个错误
// 因此,UnreadRune 比 UnreadByte 更严格
func (b *Reader) UnreadRune() error

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("你好,世界!")
  3. br := bufio.NewReader(s)
  4. c, size, _ := br.ReadRune()
  5. fmt.Printf("%c %v\n", c, size)
  6. // 你 3
  7. c, size, _ = br.ReadRune()
  8. fmt.Printf("%c %v\n", c, size)
  9. // 好 3
  10. br.UnreadRune()
  11. c, size, _ = br.ReadRune()
  12. fmt.Printf("%c %v\n", c, size)
  13. // 好 3
  14. }

------------------------------------------------------------

// Buffered 返回缓存中数据的长度

[html] view plaincopy
  1. func (b *Reader) Buffered() int
  2. func main() {
  3. s := strings.NewReader("你好,世界!")
  4. br := bufio.NewReader(s)
  5. fmt.Println(br.Buffered())
  6. // 0
  7. br.Peek(1)
  8. fmt.Println(br.Buffered())
  9. // 18
  10. }

------------------------------------------------------------

// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据的切片
// 该操作会读出数据,返回的切片是已读出数据的引用
// 切片中的数据在下一次读取操作之前是有效的
//
// 如果 ReadSlice 在找到 delim 之前遇到错误
// 则读出缓存中的所有数据并返回,同时返回遇到的错误(通常是 io.EOF)
// 如果在整个缓存中都找不到 delim,则 err 返回 ErrBufferFull
// 如果 ReadSlice 能找到 delim,则 err 始终返回 nil
//
// 因为返回的切片中的数据有可能被下一次读写操作修改
// 因此大多数操作应该使用 ReadBytes 或 ReadString,它们返回的不是数据引用
func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABC DEF GHI JKL")
  3. br := bufio.NewReader(s)
  4. w, _ := br.ReadSlice(' ')
  5. fmt.Printf("%q\n", w)
  6. // "ABC "
  7. w, _ = br.ReadSlice(' ')
  8. fmt.Printf("%q\n", w)
  9. // "DEF "
  10. w, _ = br.ReadSlice(' ')
  11. fmt.Printf("%q\n", w)
  12. // "GHI "
  13. }

------------------------------------------------------------

// ReadLine 是一个低级的原始的行读取操作
// 大多数情况下,应该使用 ReadBytes('\n') 或 ReadString('\n')
// 或者使用一个 Scanner
//
// ReadLine 通过调用 ReadSlice 方法实现,返回的也是缓存的切片
// ReadLine 尝试返回一个单行数据,不包括行尾标记(\n 或 \r\n)
// 如果在缓存中找不到行尾标记,则设置 isPrefix 为 true,表示查找未完成
// 同时读出缓存中的数据并作为切片返回
// 只有在当前缓存中找到行尾标记,才将 isPrefix 设置为 false,表示查找完成
// 可以多次调用 ReadLine 来读出一行
// 返回的数据在下一次读取操作之前是有效的
// 如果 ReadLine 无法获取任何数据,则返回一个错误信息(通常是 io.EOF)
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABC\nDEF\r\nGHI\r\nJKL")
  3. br := bufio.NewReader(s)
  4. w, isPrefix, _ := br.ReadLine()
  5. fmt.Printf("%q %v\n", w, isPrefix)
  6. // "ABC" false
  7. w, isPrefix, _ = br.ReadLine()
  8. fmt.Printf("%q %v\n", w, isPrefix)
  9. // "DEF" false
  10. w, isPrefix, _ = br.ReadLine()
  11. fmt.Printf("%q %v\n", w, isPrefix)
  12. // "GHI" false
  13. }

------------------------------------------------------------

// ReadBytes 在 b 中查找 delim 并读出 delim 及其之前的所有数据
// 如果 ReadBytes 在找到 delim 之前遇到错误
// 则返回遇到错误之前的所有数据,同时返回遇到的错误(通常是 io.EOF)
// 只有当 ReadBytes 找不到 delim 时,err 才不为 nil
// 对于简单的用途,使用 Scanner 可能更方便
func (b *Reader) ReadBytes(delim byte) (line []byte, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABC DEF GHI JKL")
  3. br := bufio.NewReader(s)
  4. w, _ := br.ReadBytes(' ')
  5. fmt.Printf("%q\n", w)
  6. // "ABC "
  7. w, _ = br.ReadBytes(' ')
  8. fmt.Printf("%q\n", w)
  9. // "DEF "
  10. w, _ = br.ReadBytes(' ')
  11. fmt.Printf("%q\n", w)
  12. // "GHI "
  13. }

------------------------------------------------------------

// ReadString 功能同 ReadBytes,只不过返回的是一个字符串
func (b *Reader) ReadString(delim byte) (line string, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABC DEF GHI JKL")
  3. br := bufio.NewReader(s)
  4. w, _ := br.ReadString(' ')
  5. fmt.Printf("%q\n", w)
  6. // "ABC "
  7. w, _ = br.ReadString(' ')
  8. fmt.Printf("%q\n", w)
  9. // "DEF "
  10. w, _ = br.ReadString(' ')
  11. fmt.Printf("%q\n", w)
  12. // "GHI "
  13. }

------------------------------------------------------------

// WriteTo 实现了 io.WriterTo 接口
func (b *Reader) WriteTo(w io.Writer) (n int64, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABCEFG")
  3. br := bufio.NewReader(s)
  4. b := bytes.NewBuffer(make([]byte, 0))
  5. br.WriteTo(b)
  6. fmt.Printf("%s\n", b)
  7. // ABCEFG
  8. }

------------------------------------------------------------

func (b *Reader) Reset(r io.Reader)

reset丢弃任何的缓存数据,丛植所有状态并且将缓存读切换到r

[html] view plaincopy
  1. package main
  2. import (
  3. "bufio"
  4. "fmt"
  5. "strings"
  6. )
  7. func main() {
  8. s := strings.NewReader("ABCEFG")
  9. str := strings.NewReader("123455")
  10. br := bufio.NewReader(s)
  11. b, _ := br.ReadString('\n')
  12. fmt.Println(b)     //ABCEFG
  13. br.Reset(str)
  14. b, _ = br.ReadString('\n')
  15. fmt.Println(b)     //123455
  16. }

------------------------------------------------------------

------------------------------------------------------------

// Writer 实现了带缓存的 io.Writer 对象
// 如果在向 Writer 中写入数据的过程中遇到错误
// 则 Writer 不会再接受任何数据
// 而且后续的写入操作都将返回错误信息
type Writer struct {

   err   error
   buf  []byte
   n     int
   wr   io.Writer

}

// NewWriterSize 将 wr 封装成一个拥有 size 大小缓存的 bufio.Writer 对象
// 如果 wr 的基类型就是 bufio.Writer 类型,而且拥有足够的缓存
// 则直接将 wr 转换为基类型并返回
func NewWriterSize(wr io.Writer, size int) *Writer

// NewWriter 相当于 NewWriterSize(wr, 4096)
func NewWriter(wr io.Writer) *Writer

------------------------------------------------------------

// Flush 将缓存中的数据提交到底层的 io.Writer 中
func (b *Writer) Flush() error

// Available 返回缓存中的可以空间
func (b *Writer) Available() int

// Buffered 返回缓存中未提交的数据长度
func (b *Writer) Buffered() int

// Write 将 p 中的数据写入 b 中,返回写入的字节数
// 如果写入的字节数小于 p 的长度,则返回一个错误信息
func (b *Writer) Write(p []byte) (nn int, err error)

// WriteString 同 Write,只不过写入的是字符串
func (b *Writer) WriteString(s string) (int, error)

[html] view plaincopy
  1. func main() {
  2. b := bytes.NewBuffer(make([]byte, 0))
  3. bw := bufio.NewWriter(b)
  4. fmt.Println(bw.Available()) // 4096
  5. fmt.Println(bw.Buffered())  // 0
  6. bw.WriteString("ABCDEFGH")
  7. fmt.Println(bw.Available()) // 4088
  8. fmt.Println(bw.Buffered())  // 8
  9. fmt.Printf("%q\n", b)       // ""
  10. bw.Flush()
  11. fmt.Println(bw.Available()) // 4096
  12. fmt.Println(bw.Buffered())  // 0
  13. fmt.Printf("%q\n", b)       // "ABCEFG"
  14. }

------------------------------------------------------------

// WriteByte 向 b 中写入一个字节
func (b *Writer) WriteByte(c byte) error

// WriteRune 向 b 中写入 r 的 UTF8 编码
// 返回 r 的编码长度
func (b *Writer) WriteRune(r rune) (size int, err error)

[html] view plaincopy
  1. func main() {
  2. b := bytes.NewBuffer(make([]byte, 0))
  3. bw := bufio.NewWriter(b)
  4. bw.WriteByte('H')
  5. bw.WriteByte('e')
  6. bw.WriteByte('l')
  7. bw.WriteByte('l')
  8. bw.WriteByte('o')
  9. bw.WriteByte(' ')
  10. bw.WriteRune('世')
  11. bw.WriteRune('界')
  12. bw.WriteRune('!')
  13. bw.Flush()
  14. fmt.Println(b) // Hello 世界!
  15. }

------------------------------------------------------------

// ReadFrom 实现了 io.ReaderFrom 接口
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)

[html] view plaincopy
  1. func main() {
  2. b := bytes.NewBuffer(make([]byte, 0))
  3. s := strings.NewReader("Hello 世界!")
  4. bw := bufio.NewWriter(b)
  5. bw.ReadFrom(s)
  6. //bw.Flush()            //ReadFrom无需使用Flush,其自己已经写入.
  7. fmt.Println(b) // Hello 世界!
  8. }

------------------------------------------------------------

func (b *Writer) Reset(w io.Writer)

Reset丢弃任何没有写入的缓存数据,清除任何错误并且重新将b指定它的输出结果指向w

[html] view plaincopy
  1. package main
  2. import (
  3. "bufio"
  4. "bytes"
  5. "fmt"
  6. )
  7. func main() {
  8. b := bytes.NewBuffer(make([]byte, 0))
  9. bw := bufio.NewWriter(b)
  10. bw.WriteString("123")
  11. c := bytes.NewBuffer(make([]byte, 0))
  12. bw.Reset(c)
  13. bw.WriteString("456")
  14. bw.Flush()
  15. fmt.Println(b)       //输出为空
  16. fmt.Println(c)  //输出456
  17. }

------------------------------------------------------------

// ReadWriter 集成了 bufio.Reader 和 bufio.Writer
// 它实现了 io.ReadWriter 接口

[html] view plaincopy
  1. type ReadWriter struct {
  2. *Reader
  3. *Writer
  4. }

// NewReadWriter 封装 r 和 w 为一个 bufio.ReadWriter 对象
func NewReadWriter(r *Reader, w *Writer) *ReadWriter

[html] view plaincopy
  1. package main
  2. import (
  3. "bufio"
  4. "bytes"
  5. "fmt"
  6. "strings"
  7. )
  8. func main() {
  9. b := bytes.NewBuffer(make([]byte, 0))
  10. bw := bufio.NewWriter(b)
  11. s := strings.NewReader("123")
  12. br := bufio.NewReader(s)
  13. rw := bufio.NewReadWriter(br, bw)
  14. p, _ := rw.ReadString('\n')
  15. fmt.Println(string(p))              //123
  16. rw.WriteString("asdf")
  17. rw.Flush()
  18. fmt.Println(b)                          //asdf
  19. }

------------------------------------------------------------

// scan.go

------------------------------------------------------------

// Scanner 提供了一个方便的接口来读取数据,例如读取一个多行文本
// 连续调用 Scan 方法将扫描数据中的“指定部分”,跳过各个“指定部分”之间的数据
// Scanner 使用了缓存,所以“指定部分”的长度不能超出缓存的长度
// Scanner 需要一个 SplitFunc 类型的“切分函数”来确定“指定部分”的格式
// 本包中提供的“切分函数”有“行切分函数”、“字节切分函数”、“UTF8字符编码切分函数”
// 和“单词切分函数”,用户也可以自定义“切分函数”
// 默认的“切分函数”为“行切分函数”,用于获取数据中的一行数据(不包括行尾符)
//
// 扫描在遇到下面的情况时会停止:
// 1、数据扫描完毕,遇到 io.EOF
// 2、遇到读写错误
// 3、“指定部分”的长度超过了缓存的长度
// 如果要对数据进行更多的控制,比如的错误处理或扫描更大的“指定部分”或顺序扫描
// 则应该使用 bufio.Reader

type Scanner struct {r            io.Reader // The reader provided by the client.split        SplitFunc // The function to split the tokens.maxTokenSize int       // Maximum size of a token; modified by tests.token        []byte    // Last token returned by split.buf          []byte    // Buffer used as argument to split.start        int       // First non-processed byte in buf.end          int       // End of data in buf.err          error     // Sticky error.
}

// SplitFunc 用来定义“切分函数”类型
// data 是要扫描的数据
// atEOF 标记底层 io.Reader 中的数据是否已经读完
// advance 返回 data 中已处理的数据长度
// token 返回找到的“指定部分”
// err 返回错误信息
// 如果在 data 中无法找到一个完整的“指定部分”
// 则 SplitFunc 返回 (0, nil) 来告诉 Scanner
// 向缓存中填充更多数据,然后再次扫描
//
// 如果返回的 err 是非 nil 值,扫描将被终止,并返回错误信息
//
// 如果 data 为空,则“切分函数”将不被调用
// 意思是在 SplitFunc 中不必考虑 data 为空的情况
//
// SplitFunc 的作用很简单,从 data 中找出你感兴趣的数据,然后返回
// 并告诉调用者,data 中有多少数据你已经处理过了
type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

// NewScanner 创建一个 Scanner 来扫描 r
// 默认切分函数为 ScanLines
func NewScanner(r io.Reader) *Scanner

// Err 返回扫描过程中遇到的非 EOF 错误
// 供用户调用,以便获取错误信息
func (s *Scanner) Err() error

------------------------------------------------------------

// Bytes 将最后一次扫描出的“指定部分”作为一个切片返回(引用传递)
// 下一次的 Scan 操作会覆盖本次返回的结果
func (s *Scanner) Bytes() []byte

// Text 将最后一次扫描出的“指定部分”作为字符串返回(值传递)
func (s *Scanner) Text() string

------------------------------------------------------------

// Scan 在 Scanner 的数据中扫描“指定部分”
// 找到后,用户可以通过 Bytes 或 Text 方法来取出“指定部分”
// 如果扫描过程中遇到错误,则终止扫描,并返回 false
func (s *Scanner) Scan() bool

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABC\nDEF\r\nGHI\nJKL")
  3. bs := bufio.NewScanner(s)
  4. for bs.Scan() {
  5. fmt.Printf("%s %v\n", bs.Bytes(), bs.Text())
  6. }
  7. // ABC ABC
  8. // DEF DEF
  9. // GHI GHI
  10. // JKL JKL
  11. }

------------------------------------------------------------

// Split 用于设置 Scanner 的“切分函数”
// 这个函数必须在调用 Scan 前执行
func (s *Scanner) Split(split SplitFunc)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("ABC DEF GHI JKL")
  3. bs := bufio.NewScanner(s)
  4. bs.Split(bufio.ScanWords)
  5. for bs.Scan() {
  6. fmt.Println(bs.Text())
  7. }
  8. // ABC
  9. // DEF
  10. // GHI
  11. // JKL
  12. }

------------------------------------------------------------

// ScanBytes 是一个“切分函数”
// 用来找出 data 中的单个字节并返回
func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("Hello 世界!")
  3. bs := bufio.NewScanner(s)
  4. bs.Split(bufio.ScanBytes)
  5. for bs.Scan() {
  6. fmt.Printf("%s ", bs.Text())
  7. }
  8. }

------------------------------------------------------------

// ScanRunes 是一个“切分函数”
// 用来找出 data 中的单个 UTF8 字符的编码并返回
// 如果 UTF8 解码出错,则返回的 U+FFFD 会被做为 "\xef\xbf\xbd" 返回
// 这使得用户无法区分“真正的U+FFFD字符”和“解码错误的返回值”
func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)

[html] view plaincopy
  1. func main() {
  2. s := strings.NewReader("Hello 世界!")
  3. bs := bufio.NewScanner(s)
  4. bs.Split(bufio.ScanRunes)
  5. for bs.Scan() {
  6. fmt.Printf("%s ", bs.Text())
  7. } // H e l l o 世 界 !
  8. }

------------------------------------------------------------

// ScanLines 是一个“切分函数”
// 用来找出 data 中的单行数据并返回(包括空行)
// 行尾标记可能是 \n 或 \r\n(返回值不包括行尾标记)
func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)

------------------------------------------------------------

// ScanWords 是一个“切分函数”
// 用来找出 data 中的单词
// 单词以空白字符分隔,空白字符由 unicode.IsSpace 定义
func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)

go详解bufio包相关推荐

  1. 详解xlwings包,用Python代替Excel VBA

    详解xlwings包,用Python代替Excel VBA <代替VBA! 用Python轻松实现Excel编程>demo 主要内容 Python语法基础 Excel对象模型:OpenPy ...

  2. 详解程序包管理RPM

    一.定义 RPM是RPM Package Manager(RPM软件包管理器)的缩写,这一文件格式名称虽然打上了RedHat的标志,但是其原始设计理念是开放式的,现在包括OpenLinux.S.u.S ...

  3. pythonpackage详解_Python详解之包管理:__init__.py

    Python中的Module是比较重要的概念.常见的情况是,事先写好一个.py文件,在另一个文件中需要import时,将事先写好的.py文件拷贝到当前目录,或者是在sys.path中增加事先写好的.p ...

  4. [转]详解HTTP包

    一.超文本传输协议及HTTP包     HTTP协议用于在Internet上发送和接收消息.HTTP协议是一种请求-应答式的协议--客户端发送一个请求,服务器返回该请求的应答,所有的请求与应答都是HT ...

  5. windows smb更改端口_SMB协议(使用说明+过程详解+抓包分析)

    一.SMB概述 SMB(ServerMessage Block)通信协议是微软(Microsoft)和英特尔(Intel)在1987年制定的协议,主要是作为Microsoft网络的通讯协议.SMB 是 ...

  6. 汉诺塔详解(包看包会)

    CSDN的大佬已经解释了很多了,由我这个菜鸟反复理解后得到的一些心得的分享 先看题: 汉诺塔: 汉诺塔(又称河内塔)问题是源于印度一个古老传说的益智玩具.大梵天创造世界的时候做了三根金刚石柱子,在一根 ...

  7. 13. 软件包详解,rpm包的查找,安装,升级,卸载,验证等所有操作

    本小节会详细介绍linux中的软件包管理,涉及软件包的定义/安装/卸载/依赖等操作.以及会详细演示rpm这个非常重要命令的使用. 文章目录 前言 软件包 源码包 二进制包 源码包 VS二进制包 依赖性 ...

  8. 详解jar包的启动命令

    通常我们在启动SpringBoot项目的的jar包时,会使用以下命令 nohup java -jar xxxx.jar >log.log 2>&1 & 整条命令由linux ...

  9. go详解strings包

    // Count 计算字符串 sep 在 s 中的非重叠个数 // 如果 sep 为空字符串,则返回 s 中的字符(非字节)个数 + 1 // 使用 Rabin-Karp 算法实现 [html] vi ...

最新文章

  1. VS2010中重命名项目
  2. 【机器学习入门笔记8:TensorFlow运算实质】20190216
  3. 基于asp.net + easyui框架,一步步学习easyui-datagrid——界面(一)
  4. Python---二分法查找
  5. yii2 调用未定义函数_Python 函数(三) 使用规则
  6. bzoj3550: [ONTAK2010]Vacation1283: 序列
  7. 感恩节(美食火鸡大餐)PNG免扣素材 总有一款你用得上
  8. win7 apache+php+mysql_win7下手动配置apache+php+mysql记
  9. 2018-2019-2 20175215 实验五《网络编程与安全》实验报告
  10. 蓝桥杯2019真题-完全二叉树的权值
  11. 批标准化 tf.keras.layers.BatchNormalization 参数解析与应用分析
  12. Linux 文件类型!
  13. 全自动与半自动手表的区别_半自动和全自动的区别在哪里?
  14. X96 MAX变砖后usb烧录修复(by quqi99)
  15. Matlab机器学习入门(一)
  16. 浅析new一个对象的过程
  17. 找不到系统指定路径的解决思路
  18. win10电脑连接手机热点时所出现的问题。
  19. Android studio飞机大战游戏分析-月末总结
  20. 计算机多媒体理论知识,计算机多媒体技术论文

热门文章

  1. gradle打包web jar_Gradle构建SpringBoot并打包可运行的jar配置
  2. 计算机系统-理论-运行时堆栈/栈顶
  3. SQLite3扩展C API
  4. c语言case后接printf,C编程中switch。case 问题
  5. 避免踩坑:易盾安全老司机起底Android九大漏洞,附解决建议
  6. 利用HUtool读取Excel内容
  7. smarty模板基础2 缓存文件
  8. iOS开发之oc(二十)--Foundation(5)NSDictionary
  9. qmake常用语法三
  10. WPF后台自定义文字带背景的选择状态按钮