go embed open和readFile有什么不同 go off和explode

转载

mob64ca13ff28f1 2024-08-06 11:35:23

文章标签 Go 服务器 i++ 字符串 文章分类 机器学习人工智能

基础知识

hello world
无限循环
slice
echo 将参数输出

echo1.go
echo2.go

几种声明字符串变量的方式
从文件中统计重复行
gif 动画
fetch 获取

fetch 从URL获取的内容
fetchall 从多个url获取的内容
fetchall₂ 从文件中的url获取的内容

一个 web 服务器

server1.go 返回请求路径
server2.go 一个迷你回声和计数服务器
server3.go 处理程序回显HTTP 请求
server4.go 同过网页显示 lissajous 图形

控制流
实现 Stringer interface
bytecounter
geometry
fib 函数
数据类型

basic type
aggregate type
reference type
interface type

基础知识

作者： Robert Griesemer, Rob Pike, Ken Thompson.

基础架构语言

特被适合构建基础设施类软件如网络服务器，以及程序员使用的工具和系统等。通用语言。

CSP Communicating Sequential Process, 通信顺序进程。

hello world

package main

import "fmt"

func main() {
        fmt.Println('hello world!')
}

go run helloworld.go
go build helloworld.go
./helloworld

名为main的包比较特殊，他用来定义一个独立的可执行程序，而不是库。在main 包中，函数main 总是程序开始执行的地方。

无限循环

for {

}

slice

索引使用半开区间，即包含第一个索引，不包含最后一个索引。 slice s[m:n] ,其中 0<<m <<n << len(s) 包含 n - m 个元素。

echo 将参数输出

echo1.go

package main

import (
        "fmt"
        "os"
)

func main(){
        var s, sep string
        for  i := 1; i< len(os.Args); i++ {
                s += sep + os.Args[i]
                sep = " "
        }
        fmt.Println(s)
}

如果变量没有明确的初始化，它将隐式地初始化这个类型的空值。例如，对于数字初始化是0, 对于字符串是空字符串。 += 是一个赋值操作符

echo2.go

package main

import (
        "fmt"
        "os"
)

func main () {
        s, sep := "", ""
        for _, arg := range os.Args[1:] {
                s += sep + arg
                sep = " "
        }
        fmt.Println(s)
}

空标识符，可以用在任何语法需要变量名但是程序逻辑不需要的地方。例如丢弃每次迭代产生的无用的索引。

几种声明字符串变量的方式

s := "" //短变量的声明方式更加简洁
var s string
var s = ""
var s string = ""

map 存储一个键值对集合。map里的键的迭代顺序不是固定的。通常是随机的，每次运行都不一致。这是有意设计的，以防止程序依赖某种特定的序列。
函数以及其他包级别的实体可以以任意次序声明，比如函数调用可以出现在声明之前。

从文件中统计重复行

dup3

// 统计文件中不重复的行的个数
package main

import (
        "fmt"
        "io/ioutil"
        "os"
        "strings"
)

func main() {
        counts := make(map[string]int)
        for _, filename := range os.Args[1:] {
                data, err := ioutil.ReadFile(filename)
                fmt.Println(filename)

                if err != nil {
                        fmt.Fprintf(os.Stderr, "dup3: %v\n", err)
                        continue
                }
                for _, line := range strings.Split(string(data), "\n"){
                        counts[line]++
                }
        }
        for line, n := range counts {
                if n > 1 {
                        fmt.Printf("%d\t%s\n", n, line)
                }
        }

}

gif 动画

lissajous 产生随机里萨如图形的gif

// lissajous 产生随机里萨如图形的GIF 动画
package main

import (
        "image"
        "image/color"
        "image/gif"
        "io"
        "log"
        "math"
        "math/rand"
        "net/http"
        "os"
        "time"
)

var palette = []color.Color{color.White, color.Black}

const (
        whiteIndex = 0
        blackIndex = 1
)

func main() {
        rand.Seed(time.Now().UTC().UnixNano())
        if len(os.Args) > 1 && os.Args[1] == "web" {
                handler := func(w http.ResponseWriter, r *http.Request) {
                        lissajous(w)
                }
                http.HandleFunc("/", handler)
                log.Fatal(http.ListenAndServe("localhost:8000", nil))
                return
        }
        lissajous(os.Stdout)
}

func lissajous(out io.Writer) {
        const (
                cycles  = 5
                res     = 0.001
                size    = 100
                nframes = 64
                delay   = 8
        )
        freq := rand.Float64() * 3.0
        anim := gif.GIF{LoopCount: nframes}
        phase := 0.0
        for i := 0; i < nframes; i++ {
                rect := image.Rect(0, 0, 2*size+1, 2*size+1)
                img := image.NewPaletted(rect, palette)
                for t := 0.0; t < cycles*2*math.Pi; t += res {
                        x := math.Sin(t)
                        y := math.Sin(t*freq + phase)
                        img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex)
                }
                phase += 0.1
                anim.Delay = append(anim.Delay, delay)
                anim.Image = append(anim.Image, img)
        }
        gif.EncodeAll(out, &anim)
}

fetch 获取

fetch 从URL获取的内容

// fetch 输出从URL 获取到的内容。
package main

import (
        "fmt"
        "io/ioutil"
        "net/http"
        "os"
)

func main() {
        for _, url := range os.Args[1:] {
                resp, err := http.Get(url)
                if err != nil {
                        fmt.Fprintf(os.Stderr, "fetch: %v \n", err)
                        os.Exit(1)
                }
                b, err := ioutil.ReadAll(resp.Body)
                resp.Body.Close()
                if err != nil {
                        fmt.Fprintf(os.Stderr, "fetch: reading %s : %v\n", url, err)
                        os.Exit(1)
                }
                fmt.Printf("%s", b)
        }
}

fetchall 从多个url获取的内容

//fetchall 并法获取URL 并报告他们的时间和大小
package main

import (
        "fmt"
        "io"
        "io/ioutil"
        "net/http"
        "os"
        "time"
)

func main(){
        start := time.Now()
        ch := make(chan string)
        for _, url := range os.Args[1:] {
                go fetch(url, ch)
        }
        for range os.Args[1:] {
                fmt.Println(<-ch)
        }
        fmt.Printf("%.3fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan <- string) {
        start := time.Now()
        resp, err := http.Get(url)
        if err != nil {
                ch <- fmt.Sprint(err)
                return
        }

        nbytes, err := io.Copy(ioutil.Discard, resp.Body)
        resp.Body.Close()
        if err != nil {
                ch <- fmt.Sprintf("While reading %s: %v", url, err)
                return
        }

        secs := time.Since(start).Seconds()
        ch <- fmt.Sprintf("%.3fs %7d %s", secs, nbytes, url)
}

fetchall₂ 从文件中的url获取的内容

//fetchall 并法获取URL 并报告他们的时间和大小
package main

import (
        "fmt"
        "io"
        "io/ioutil"
        "net/http"
        "os"
        "strings"
        "time"
)

func main() {
        start := time.Now()
        ch := make(chan string)
        filename := os.Args[1]
        data, err := ioutil.ReadFile(filename)
        if err != nil {
                fmt.Fprintf(os.Stderr, "fetchall_2:%v \n", err)
        }

        l_ := strings.Split(string(data), "\n")
        length_ := len(l_)

        for _, line := range l_ {
                go fetch(line, ch)
        }
        for i := 0; i < length_; i++ {
                fmt.Println(<-ch)
        }
        fmt.Printf("%.3fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
        start := time.Now()
        resp, err := http.Get(url)
        if err != nil {
                ch <- fmt.Sprint(err)
                return
        }

        nbytes, err := io.Copy(ioutil.Discard, resp.Body)
        resp.Body.Close()
        if err != nil {
                ch <- fmt.Sprintf("While reading %s: %v", url, err)
                return
        }

        secs := time.Since(start).Seconds()
        ch <- fmt.Sprintf("%.3fs %7d %s", secs, nbytes, url)
}

一个 web 服务器

server1.go 返回请求路径

// server1
package main

import (
        "fmt"
        "log"
        "net/http"
)

func main(){
        http.HandleFunc("/", handler)
        log.Fatal(http.ListenAndServe("localhost:8000",nil))
}

func handler (w http.ResponseWriter, r *http.Request){
        fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}

server2.go 一个迷你回声和计数服务器

//  server2 是一个迷你回声和计数服务器
package main

import (
        "fmt"
        "log"
        "net/http"
        "sync"
)

var mu sync.Mutex
var count int

func main(){
        http.HandleFunc("/", handler)
        http.HandleFunc("/count", counter)
        log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handler (w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        count++
        mu.Unlock()
        fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}

func counter(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        fmt.Fprintf(w, "Count %d\n", count)
        mu.Unlock()
}

server3.go 处理程序回显HTTP 请求

// 处理程序回显 HTTP 请求
package main

import (
        "fmt"
        "net/http"
        "log"
)

func main () {
        http.HandleFunc("/",handler)
        log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handler (w http.ResponseWriter, r *http.Request){
        fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto)
        for k,v := range r.Header {
                fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
        }
        fmt.Fprintf(w, "Host = %q\n", r.Host)
        fmt.Fprintf(w, "RemoteAddr = %q\n", r.RemoteAddr)
        if err := r.ParseForm(); err != nil {
                log.Print(err)
        }
        for k, v := range r.Form {
                fmt.Fprintf(w, "Form[%q] = %q\n", k, v)
        }
}

server4.go 同过网页显示 lissajous 图形

//server4 通过浏览器显示 lissajous 图形
package main

import (
        "image"
        "image/color"
        "image/gif"
        "io"
        "log"
        "time"
        "math"
        "math/rand"
        "net/http"
)

var palette = []color.Color{color.White, color.Black}

const (
        whiteIndex = 0
        blackIndex = 1
)

func main() {
        rand.Seed(time.Now().UTC().UnixNano())
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
                lissajous(w)
        })
        log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func lissajous(out io.Writer) {
        const (
                cycles  = 5
                res     = 0.001
                size    = 100
                nframes = 64
                delay   = 8
        )
        freq := rand.Float64() * 3.0
        anim := gif.GIF{LoopCount: nframes}
        phase := 0.0
        for i := 0; i < nframes; i++ {
                rect := image.Rect(0, 0, 2*size+1, 2*size+1)
                img := image.NewPaletted(rect, palette)
                for t := 0.0; t < cycles*2*math.Pi; t += res {
                        x := math.Sin(t)
                        y := math.Sin(t*freq + phase)
                        img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex)
                }
                phase += 0.1
                anim.Delay = append(anim.Delay, delay)
                anim.Image = append(anim.Image, img)
        }
        gif.EncodeAll(out, &anim)
}

控制流

switch coinflip() {
case "heads":
        heads++
case "tails":
        tails++
default:
        fmt.Println("landed on edge!")
}

case 语句从上到下推演
默认 case 语句可以放在任何地方。
如果没有其他的case 语句符合条件，那么可选的默认case 语句将被执行
switch 语句不需要操作数,它就像一个case 语句列表，每条case 语句都是一个布尔表达式
这种形式称为无标签tagless 选择，它等价于 switch true

func Signum(x int) int {
        switch {
        case x > 0:
                return +1
        default:
                return 0
        case x < 0:
                return 0
        }
}

实现 Stringer interface

// Filename: go.org[*Org Src go.org[ go ]*]
// coding:utf-8
// 
import (
        "fmt"
)

type human struct{
        name string
}

func (h *human) String () string {
        return fmt.Sprint(h.name, h.name)
}

func main () {
        var h = human{name:"liu"}
        fmt.Println("%s" ,&h)
}

bytecounter

// Filename: go.org[*Org Src go.org[ go ]*]
// coding:utf-8
// ch7/bytecounter
import (
        "fmt"
)
type ByteCounter int

// 
func (c *ByteCounter) Write (p [] byte) (int, error) {
        *c += ByteCounter(len(p))
        return len(p), nil
}

func main () {
        var c ByteCounter
        c.Write([]byte("hello"))
        fmt.Println(c)

        c = 0
        name := "Dolly"
        fmt.Fprintf(&c, "hello, %s", name)
        fmt.Println(c)
}

geometry

// Filename: go.org[*Org Src go.org[ go ]*]
// coding:utf-8
// geometry
import (
        "fmt"
        "math"
)

type Point struct { X, Y float64}
// Path 是连接多个点的直线段
type Path []Point

// Distance 方法返回路径的长度
func (path Path) Distance () float64 {
        sum := 0.0
        for i := range path {
                if i > 0 {
                        sum += path[i - 1].Distance(path[i])
                }
        }
        return sum 
}

// 普通的函数
func Distance (p, q Point) float64 {
        return math.Hypot(p.X - q.X, p.Y - q.Y)
}

// Point 类型的方法
func (p *Point) Distance (q Point) float64 {
        return math.Hypot(p.X - q.X, p.Y - q.Y)
}

// 对点的x,y 成比例放大或缩小
func (p *Point) ScaleBy (factor float64) {
        p.X *= factor
        p.Y *= factor
}

// 格式化输出
func (p *Point) String () string{
        return fmt.Sprintf("X: %.2f, Y: %.2f", p.X, p.Y)
}

func main () {
        p := Point{1,2}
        q := Point{4,6}
        fmt.Println(Distance(p,q))
        fmt.Println(p.Distance(q))


        perim := Path{
                {1,1},
                {5,1},
                {5,4},
                {1,1},
        }
        fmt.Println(perim.Distance())

        // 指针接受者的方法
        r := &Point{1, 1}
        r.ScaleBy(10)
        fmt.Println(*r)
        fmt.Println(r)

        p1 := Point{1,2}
        pptr := &p1
        pptr.ScaleBy(10)
        fmt.Println(p1)
        fmt.Println(pptr)

        p2 := Point{1,3}
        (&p2).ScaleBy(10)
        fmt.Println(p2)
        fmt.Println(&p2)

        p3 := Point{1,4}
        p3.ScaleBy(10)
        fmt.Println(p3)
        fmt.Println(&p3)
}

fib 函数

// Filename: go.org[*Org Src go.org[ go ]*<2>]
// coding:utf-8
// fib

import (
        "fmt"
)

// fib
func fib (n int) (x int) {
        x, y := 0, 1
        for i := 1; i < n ; i++ {
                x, y = y, x + y 
        }
        return 
}

func main () {
        fmt.Println(fib(1000000))	
}

数据类型

basic type

基础类型

aggregate type

聚合类型

reference type

引用类型

interface type

接口类型

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：秒杀系统消息队列消息队列秒杀原理

下一篇：每小时有多少数据可视化实时数据可视化

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

go embed open和readFile有什么不同 go off和explode

go embed open和readFile有什么不同 go off和explode

基础知识

hello world

无限循环

slice

echo 将参数输出

echo1.go

echo2.go

几种声明字符串变量的方式

从文件中统计重复行

gif 动画

fetch 获取

fetch 从URL获取的内容

fetchall 从多个url获取的内容

fetchall2 从文件中的url获取的内容

一个 web 服务器

server1.go 返回请求路径

server2.go 一个迷你回声和计数服务器

server3.go 处理程序回显HTTP 请求

server4.go 同过网页显示 lissajous 图形

控制流

实现 Stringer interface

bytecounter

geometry

fib 函数

数据类型

basic type

aggregate type

reference type

interface type

51CTO博客

fetchall₂ 从文件中的url获取的内容