107.【并发与标准库】(九)

简介: 107.【并发与标准库】

12.标准库builtin ⭐

这个包提供了一些类型声明、变量和常量声明,还有一些便利的函数,这个包不需要导入,这些变量可以直接使用。

(1).常用函数
1.追加
append(): 切片追加
2.长度
len() : 数组/字符串/切片长度
3.控制台打印
print() println()
4.抛出异常
panic() 终止后面的程序
(2).new 函数 和 make 函数 ⭐

new 和 make 区别:

  1. make 只能用来分配初始化类型slice,map,chan的数据;new 可以分配任意类型的数据。
  2. new 分配返回的使指针,即*T; make 返回的是引用, 即T
  3. new 分配的空间被清零; make分配后会进行初始化

new

package main
import "fmt"
func main() {
  b := new(bool)
  fmt.Printf("%T\n", b)
  fmt.Printf("%v\n", *b)
  i := new(int)
  fmt.Printf("%T\n", i)
  fmt.Printf("%v\n", *i)
  s := new(string)
  fmt.Printf("%T\n", s)
  fmt.Printf("%v\n", *s)
}

make

内建函数make(T,args)new(T)的用途不一样,它只用来创建slice,map和channel,并且返回一个初始化的(而不是置零),类型为T的值(而不是*T)。之所以不同,是因为这三个类型的背后引用了使用前必须初始化的数据结构。列如: slice是一个三元描述符,包含一个指向数据 (在数组中)的指针,长度以及容量,在这些项被初始化之前,slic都是nil的,对于slice,map和channel,make初始化这些内部数据结构,并准备好可以的值。

make([]int,10,100) //分配100个容量,长度为10的整型数组
new([]int)//返回一个指向新分配的,被置零的slice结构体的指针,即指向nil的slice指针
package main
import "fmt"
func main() {
  var p *[]int = new([]int)
  fmt.Printf("%v\n", *p)
  ints := make([]int, 10)
  fmt.Printf("%v\n", ints)
}

13. 标准库bytes之常用函数

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

(1).字节切片与字符串的转换

字符串转成byt切片缓存

package main
import (
  "fmt"
  "os"
)
func main() {
  s := "黎鸣先生"
  bytes := []byte(s)
  file, _ := os.OpenFile("a.txt", os.O_RDWR|os.O_APPEND, 775)
  write, _ := file.Write(bytes)
  fmt.Printf("写入的字节数:%v\n", write)
}

(2).字节切片是否包含
package main
import (
  "bytes"
  "fmt"
  "strings"
)
func main() {
  s := "duoke360.com"
  b := []byte(s)
  b1 := []byte("duoke360")
  b2 := []byte("DuoKe360")
  strings.Contains("hello world", "hello")
  b3 := bytes.Contains(b, b1)
  fmt.Printf("%v\n", b3)
  b3 = bytes.Contains(b, b2)
  fmt.Printf("%v\n", b3)
}

(3).统计字节切片的某个字符串的个数
package main
import (
  "bytes"
)
func main() {
  b1 := []byte("helooooooo")
  s1 := []byte("h")
  s2 := []byte("e")
  s3 := []byte("o")
  println(bytes.Count(b1, s1))
  println(bytes.Count(b1, s2))
  println(bytes.Count(b1, s3))
}

(4).对字节切片进行重复输出
package main
import (
  "bytes"
)
func main() {
  b1 := []byte("helooooooo")
  println(string(bytes.Repeat(b1, 1)))
  println(string(bytes.Repeat(b1, 2)))
  println(string(bytes.Repeat(b1, 2)))
}

(5).对字节切片的替换
package main
import (
  "bytes"
)
func main() {
  b1 := []byte("helooooooo")
  old := []byte("o")
  news := []byte("e")
  println(string(bytes.Replace(b1, old, news, 0)))  // 替换0
  println(string(bytes.Replace(b1, old, news, 1))) // 替换1
  println(string(bytes.Replace(b1, old, news, 2))) //替换两个
  println(string(bytes.Replace(b1, old, news, -1)))  //全部替换
}

(6).查看文本中有几个汉字
package main
import (
  "bytes"
  "fmt"
)
func main() {
  s := []byte("你好世界")
  runes := bytes.Runes(s)
  fmt.Printf("转换前字符串的长度:%v\n", len(s))
  fmt.Printf("转后前字符串的长度:%v\n", len(runes))
}

(7).字节切片间的链接
package main
import (
  "bytes"
)
func main() {
  s2 := [][]byte{[]byte("你好"), []byte("世界")}
  s4 := []byte(",")
  println(string(bytes.Join(s2, s4)))
  s3 := []byte("#")
  println(string(bytes.Join(s2, s3)))
}

14.标准库bytes之Reader

Reader实现了 io.Reader、io.ReaderAt、io.WriterTo、io.Seeker、io.ByteScaaner、io.RuneScanner等接口,Reader是只读的,可以seek。

(1).常用方法
package main
import (
  "bytes"
  "fmt"
)
func main() {
  date := "123456789"
  // 通过[]byte创建Reader
  re := bytes.NewReader([]byte(date))
  // 返回来读取部分的长度
  fmt.Println("长度为: ", re.Len())
  //返回底层数据总长度
  println("底层数据长度: ", re.Size())
  println("---------")
  buf := make([]byte, 2)
  for {
    // 读取数据
    read, err := re.Read(buf) // read,就是指有多少字节数
    if err != nil {
      break
    }
    println(string(buf[:read])) //进行读取的操作
  }
  println("--------")
  //设置偏移量,因为上面的操作已经修改了读取位置等信息
  re.Seek(0, 0) // 重新定位,定位到开头  ----- 如果不重新定位的话,会接着上面的buf继续读取
  for true {
    // 一个字节一个字节的读取
    b, err := re.ReadByte()
    if err != nil {
      break
    }
    println(string(b))
  }
  println("-----")
  re.Seek(0, 0)
  off := int64(0) // 为0
  for true {
    // 指定偏移量读取
    at, err := re.ReadAt(buf, off) //   每次读取两个
    if err != nil {
      break
    }
    off += int64(at) //
    println(off, string(buf[:at]))
  }
}
相关文章
|
缓存 Go C语言
107.【并发与标准库】(七)
107.【并发与标准库】
51 0
|
缓存 Go
107.【并发与标准库】(二)
107.【并发与标准库】
47 0
|
2月前
|
Go 调度
Goroutine:Go语言的轻量级并发机制
【8月更文挑战第31天】
34 0
|
3月前
|
安全 Go
Go语言map并发安全,互斥锁和读写锁谁更优?
Go并发编程中,`sync.Mutex`提供独占访问,适合读写操作均衡或写操作频繁的场景;`sync.RWMutex`允许多个读取者并行,适用于读多写少的情况。明智选择锁可提升程序性能和稳定性。示例展示了如何在操作map时使用这两种锁。
52 0
|
3月前
|
安全 Go 开发者
Go语言map并发安全使用的正确姿势
在Go并发编程中,由于普通map不是线程安全的,多goroutine访问可能导致数据竞态。为保证安全,可使用`sync.Mutex`封装map或使用从Go 1.9开始提供的`sync.Map`。前者通过加锁手动同步,后者内置并发控制,适用于多goroutine共享。选择哪种取决于具体场景和性能需求。
52 0
107.【并发与标准库】(三)
107.【并发与标准库】
49 0
|
存储
107.【并发与标准库】(四)
107.【并发与标准库】
49 0
|
XML JSON Go
107.【并发与标准库】(十)
107.【并发与标准库】
38 0
|
5月前
|
Go 调度 计算机视觉
并发与并行:Go语言中的异曲同工
并发与并行:Go语言中的异曲同工
47 0