Go程序语言设计 (艾伦 A. A. 多诺万著)

第1章入门 (已看)

　　1.1 hello,world

package main
 
import "fmt"
 
func main(){
    fmt.Println("Hello,World")
}

Hello,World

$go run HelloWorld.go

$go build HelloWorld.go

　　1.2 命令行参数

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

echo1

package main
 
import (
    "fmt"
    "os"
)
 
func main(){
    s,sep:="",""
    :] {
        s += sep + arg
        sep = " "
    }
    fmt.Println(s)
}

echo2

　　1.3 找出重复行

　　1.4 GIF动画

　　1.5 获取一个URL

　　1.6 并发获取多个URL

　　1.7 一个Web服务器

　　1.8 其他内容

第2章程序结构 (已看)

　　2.1 名称

　　2.2 声明

　　2.3 变量

　　　　2.3.1 短变量声明

　　　　2.3.2 指针

　　　　2.3.3 new函数

　　　　2.3.4 变量的生命周期

　　2.4 赋值

　　　　2.4.1 多重赋值

　　　　2.4.2 可赋值性

　　2.5 类型声明

　　2.6 包和文件

　　　　2.6.1 导入

　　　　2.6.2 包初始化

　　2.7 作用域

第3章基本数据 (已看)

　　3.1 整数

　　3.2 浮点数

package main
 
import (
    "fmt"
    "math"
)
 
const (
    width,height = ,
    cells =
    xyrange = 30.0
    xyscale = width//xyrange
    zscale = height * 0.4
    angle = math.Pi /
)
 
var sin30,cos30 = math.Sin(angle),math.Cos(angle)
 
func main(){
    fmt.Printf("<svg xmlns = 'http://www.w3.org/2000svg' " +
        "style='stroke:grey;fill:white;stroke-width:0.7' " +
        "width='%d' height='%d'>",width,height)
 
    ; i < cells; i++ {
        ;j < cells;j++ {
            ax,ay := corner(i+,j)
            bx,by := corner(i,j)
            cx,cy := corner(i,j+)
            dx,dy := corner(i+,j+)
            fmt.Printf("<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n",
                ax,ay,bx,by,cx,cy,dx,dy)
        }
    }
    fmt.Println("</svg>")
}
 
func corner(i,j int)(float64,float64) {
    x := xyrange * (float64(i)/cells-0.5)
    y := xyrange * (float64(j)/cells-0.5)
 
    z := f(x,y)
    sx := width/ + (x-y)*cos30*xyscale
    sy := height/ + (x+y)*sin30*xyscale - z*zscale
    return sx,sy
}
 
func f(x,y float64) float64 {
    r := math.Hypot(x,y)
    return math.Sin(r)
}

surface

　　3.3 复数

package main
 
import (
    "image"
    "image/color"
    "image/png"
    "math/cmplx"
    "os"
)
 
func main(){
    const (
        xmin,ymin,xmax,ymax = -,-,+,+
        width,height = ,
    )
 
    img := image.NewRGBA(image.Rect(,,width,height))
    ;py < height;py++ {
        y := float64(py)/height*(ymax-ymin)
        ;px < width;px++ {
            x := float64(px)/width*(xmax-xmin) + xmin
            z := complex(x,y)
 
            img.Set(px,py,mandelbrot(z))
        }
    }
    png.Encode(os.Stdout,img)
}
 
func mandelbrot(z complex128) color.Color {
 
    var v complex128
    );n < iterations;n++ {
        v = v*v + z
         {
             - contrast*n}
        }
    }
    return color.Black
}

mandelbrot

　　3.4 布尔值

　　3.5 字符串

　　　　3.5.1 字符串字面量

　　　　3.5.2 Unicode

　　　　3.5.3 UTF-8

　　　　3.5.4 字符串和字节slice

package main
 
import (
    "fmt"
    "bytes"
)
 
func intsToString(values []int) string {
    var buf bytes.Buffer
    buf.WriteByte('[')
    for i,v := range values {
         {
            buf.WriteString(", ")
        }
        fmt.Fprintf(&buf,"%d",v)
    }
    buf.WriteByte(']')
    return buf.String()
}
 
func main() {
    fmt.Println(intsToString([],,}))
}

printints

　　　　3.5.5 字符串和数字的相互转换

　　3.6 常量

　　　　3.6.1 常量生成器iota

　　　　3.6.2 无类型常量

第4章复合数据类型 (已看)

　　4.1 数组

package main
 
import (
    "fmt"
    "crypto/sha256"
)
 
type Currency int
 
const (
    USD Currency = iota
    EUR
    GBP
    RMB
)
 
func main(){
 
    ]int
    fmt.Println(a[])
    fmt.Println(a[len(a)-])
 
    for i,v := range a {
        fmt.Printf("%d %d\n",i,v)
    }
 
    for _,v := range a {
        fmt.Printf("%d\n",v)
    }
 
    c1 := sha256.Sum256([]byte("x"))
    c2 := sha256.Sum256([]byte("X"))
 
    fmt.Printf("%x\n%x\n%t\n%T\n",c1,c2,c1 == c2,c1)
}

sha256

　　4.2 slice

package main
 
import "fmt"
 
func reverse(s []int){
    ,len(s)-;i < j;i,j = i+,j- {
        s[i],s[j] = s[j],s[i]
    }
}
 
func main(){
    a := [...],,,,,}
    reverse(a[:])
    fmt.Println(a)
}

rev

　　　　4.2.1 append函数

package main
 
import "fmt"
 
func AppendInt(x []int,y int) []int {
    var z []int
    zlen := len(x) +
    if zlen <= cap(x) {
        z = x[:zlen]
    } else {
        zcap := zlen
        *len(x) {
            zcap =  * len(x)
        }
        z = make([]int,zlen,zcap)
        copy(z,x)
    }
    z[len(x)] = y
    return z
}
 
func main(){
    var x,y []int
    ;i < ;i++ {
        y = AppendInt(x,i)
        fmt.Printf("%d cap=%d\t%v\n",i,cap(y),y)
        x = y
    }
}

append

　　　　4.2.2 slice就地修改

　　4.3 map

package main
 
import (
    "bufio"
    "os"
    "fmt"
)
 
func main() {
    seen := make(map[string]bool)
    input := bufio.NewScanner(os.Stdin)
 
    for input.Scan() {
        line := input.Text()
        if !seen[line] {
            seen[line] = true
            fmt.Println(line)
        }
    }
 
    if err := input.Err();err != nil {
        fmt.Fprintf(os.Stderr,"dedup: %v\n",err)
        os.Exit()
    }
}

dedup

package main
 
import (
    "bufio"
    "fmt"
    "io"
    "os"
    "unicode"
    "unicode/utf8"
)
 
func main() {
    counts := make(map[rune]int)
    ]int
    invalid := 
 
    in := bufio.NewReader(os.Stdin)
    for {
        r,n,err := in.ReadRune()
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Fprintf(os.Stderr,"charcount: %v\n",err)
            os.Exit()
        }
         {
            invalid++
            continue
        }
        counts[r]++
        utflen[n]++
    }
    fmt.Printf("rune\tcount\n")
    for c,n := range counts {
        fmt.Printf("%q\t%d\n",c,n)
    }
    fmt.Print("\nlen\tcount\n")
    for i,n := range utflen {
         {
            fmt.Printf("%d\t%d\n",i,n)
        }
    }
     {
        fmt.Printf("\n%d invalid UTF-8 characters\n",invalid)
    }
}

charcount

var graph = make(map[string]map[string]bool)
 
func addEdge(from,to string) {
    edges := graph[from]
    if edges == nil {
        edges = make(map[string]bool)
        graph[from] = edges
    }
    edges[to] = true
}
 
func hasEdge(from,to string) bool {
    return graph[from][to]
}

graph　　

　　4.4 结构体

　　　　4.4.1 结构体字面量

　　　　4.4.2 结构体比较

　　　　4.4.3 结构体嵌套和匿名成员

package main
 
import "fmt"
 
type Point struct {
    X,Y int
}
 
type Circle struct {
    Point
    Radius int
}
 
type Wheel struct {
    Circle
    Spokes int
}
 
func main() {
    ,},},}
 
    fmt.Printf("%#v\n",w)
    w.X =
    fmt.Printf("%#v\n",w)
}

embed

　　4.5 JSON

　　4.6 文本和HTML模板

第5章函数 (已看)

　　5.1 函数声明

package main
 
import "fmt"
 
func add(x int,y int) int { return x+y }
func sub(x,y int) (z int) { z = x-y; return }
func first(x int,_ int) int { return x }
func zero( }
 
func main() {
    fmt.Printf("%T\n",add)
    fmt.Printf("%T\n",sub)
    fmt.Printf("%T\n",first)
    fmt.Printf("%T\n",zero)
}

funcTest

　　5.2 递归

　　5.3 多返回值

　　5.4 错误

　　　　5.4.1 错误处理策略

　　　　5.4.2 文件结束标识

　　5.5 函数变量

package main
 
import "fmt"
 
func square(n int) int { return n*n }
func negative(n int) int { return -n }
func product(m,n int) int { return m*n }
 
func main() {
    f := square
    fmt.Println(f())
    fmt.Printf("%T\n",f)
 
    f = negative
    fmt.Println(f())
    fmt.Printf("%T\n",f)
 
}

funcVarTest

　　5.6 匿名函数

package main
 
import "fmt"
 
func squares() func() int {
    var x int
    return func() int {
        x++
        return x * x
    }
}
 
func main() {
    f := squares()
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
}

squares

　　5.7 变长函数

package main
 
import "fmt"
 
func sum(vals ...int) int {
    total :=
    for _,val := range vals {
        total += val
    }
    return total
}
 
func main() {
    fmt.Println(sum())
    fmt.Println(sum())
    fmt.Println(sum(,,,))
}

sum

　　5.8 延迟函数调用

　　5.9 宕机

　　5.10 恢复

第6章方法 (已看)

　　6.1 方法声明

package main
 
import "math"
import "fmt"
 
type Point struct{ X,Y float64 }
 
func Distance(p,q Point) float64 {
    return math.Hypot(q.X - p.X,q.Y - p.Y)
}
 
func (p Point) Distance(q Point) float64 {
    return math.Hypot(q.X - p.X,q.Y - p.Y)
}
 
func main() {
    p := Point{,}
    q := Point{,}
 
    fmt.Println(Distance(p,q))
    fmt.Println(p.Distance(q))
}

geometry

　　6.2 指针接收者的方法

　　6.3 通过结构体内嵌组成类型

　　6.4 方法变量与表达式

p := Point{,}
q := Point{,}
 
distanceFromP := p.Distance
fmt.Println(distanceFromP(q))
var orgin Point
fmt.Println(distanceFromP(origin))
 
scaleP := p.ScaleBy
scaleP()
scaleP()
scaleP()

geometryTest1

　　6.5 示例:位向量

　　6.6 封装

第7章接口

　　7.1 接口即约定

　　7.2 接口类型

package io
 
type Reader interface {
    Read(p []byte) (n int,err error)
}
 
type Closer interface {
    Close() error
}
 
type ReadWriter interface {
    Reader
    Writer
}
 
type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}
 
type ReadWriter interface {
    Read(p []byte) (n int,err error)
    Write(p []byte) (n int,err error)
}
 
type ReadWriter interface {
    Read(p []byte) (n int,err error)
    Writer
}

interfaceType

　　7.3 实现接口

　　7.4 使用flag.Value来解析参数

　　7.5 接口值

　　7.6 使用sort.Interface来排序

　　7.7 http.Handle接口

　　7.8 error接口

　　7.9 示例:表达式求值器

　　7.10 类型断言

　　7.11 使用类型断言来识别错误

　　7.12 通过接口类型断言来查询特性

　　7.13 类型分支

　　7.14 示例:基于标记的XML解析

　　7.15 一些建议

第8章 goroutine和通道

　　8.1 goroutine

　　8.2 示例:并发时钟服务器

　　8.3 示例:并发回声服务器

　　8.4 通道

　　　　8.4.1 无缓冲通道

　　　　8.4.2 管道

　　　　8.4.3 单向通道类型

　　　　8.4.4 缓冲通道

　　8.5 并行循环

　　8.6 示例:并发的Web爬虫

　　8.7 使用select多路复用

　　8.8 示例:并发目录遍历

　　8.9 取消

　　8.10 示例:聊天服务器

第9章使用共享变量实现并发

　　9.1 竞态

　　9.2 互斥锁:sync.Mutex

　　9.3 读写互斥锁:sync.RWMutex

　　9.4 内存同步

　　9.5 延迟初始化:sync.Once

　　9.6 竞态检测器

　　9.7 示例:并发非阻塞缓存

　　9.8 goroutine与线程

　　　　9.8.1 可增长的栈

　　　　9.8.2 goroutine调度

　　　　9.8.3 GOMAXPROCS

　　　　9.8.4 goroutine没有标识

第10章包和go工具 (已看)

　　10.1 引言

　　10.2 导入路径

　　10.3 包的声明

　　10.4 导入声明

　　10.5 空导入

　　10.6 包及其命名

　　10.7 go工具

　　　　10.7.1 工作空间的组织

　　　　10.7.2 包的下载

　　　　10.7.3 包的构建

　　　　10.7.4 包的文档化

　　　　10.7.5 内部包

　　　　10.7.6 包的查询

第11章测试

　　11.1 go test工具

　　11.2 Test函数

　　　　11.2.1 随机测试

　　　　11.2.2 测试命令

　　　　11.2.3 白盒测试

　　　　11.2.4 外部测试包

　　　　11.2.5 编写有效测试

　　　　11.2.6 避免脆弱的测试

　　11.3 覆盖率

　　11.4 Benchmark函数

　　11.5 性能剖析

　　11.6 Example函数

第12章反射

　　12.1 为什么使用反射

　　12.2 reflect.Type和reflect.Value

package main
 
import (
    "fmt"
    "reflect"
    "os"
    "io"
)
 
func main() {
    t := reflect.TypeOf()
    fmt.Println(t.String())
    fmt.Println(t)
    fmt.Printf()
 
    v := reflect.ValueOf()
    fmt.Println(v)
    fmt.Printf("%v\n",v)
    fmt.Println(v.String())
 
    t1 := v.Type()
    fmt.Println(t1.String())
 
    v1 := reflect.ValueOf()
    fmt.Println(v1)
    x := v.Interface()
    fmt.Println(x)
    i := x.(int)
    fmt.Printf("%d\n",i)
 
    var w io.Writer = os.Stdout
    fmt.Println(reflect.TypeOf(w))
 
}

reflectTest1

package main
 
import (
    "reflect"
    "strconv"
    "fmt"
    "time"
)
 
func Any(value interface{}) string {
    return formatAtom(reflect.ValueOf(value))
}
 
func formatAtom(v reflect.Value) string {
    switch v.Kind() {
    case reflect.Invalid:
        return "invalid"
    case reflect.Int,reflect.Int8,reflect.Int16,reflect.Int32,reflect.Int64:
        )
    case reflect.Uint,reflect.Uint8,reflect.Uint16,reflect.Uint32,reflect.Uint64,reflect.Uintptr:
        )
    case reflect.Bool:
        return strconv.FormatBool(v.Bool())
    case reflect.String:
        return strconv.Quote(v.String())
    case reflect.Chan,reflect.Func,reflect.Ptr,reflect.Slice,reflect.Map:
        )
    default:
        return v.Type().String() + " value"
    }
}
 
func main() {
 
     * time.Nanosecond
    fmt.Println(Any(x))
    fmt.Println(Any(d))
    fmt.Println(Any([]int64{x}))
    fmt.Println(Any([]time.Duration{d}))
}

format

　　12.3 Display:一个递归的值显示器

　　12.4 示例:编码S表达式

　　12.5 使用reflect.Value来设置值

　　12.6 示例:解码S表达式

　　12.7 访问结构体字段标签

　　12.8 显示类型的方法

　　12.9 注意事项

第13章低级编程

　　13.1 unsafe.Sizeof,Alignof和Offsetof

　　13.2 unsfae.Pointer

　　13.3 示例:深度相等

　　13.4 使用cgo调用c代码

　　13.5 关于安全的注意事项

Go程序语言设计 (艾伦 A. A. 多诺万著)的更多相关文章

LZZ高级程序语言设计之多重for循环
public class Mq { public static void main(String args[]) { System.out.println("到底去还是不去呢?") ...
C语言程序与设计：统计素数并求和
目录 C语言程序与设计:统计素数并求和 1.题目要求 2.分析 3.代码 C语言程序与设计:统计素数并求和 1.题目要求输入两个正整数 m 和 n(1≤m≤n≤500),统计给定整数 m 和 n 区 ...
atitit.编程语言程序语言的工具性和材料性双重性 and 语言无关性本质
atitit.编程语言程序语言的工具性和材料性双重性 and 语言无关性本质 #---语言的工具和材料双重性有的人说语言是个工具,有的人说语言是个材料..实际上语言同时属于两个属性. ...
BT雷人的程序语言
原文:http://cocre.com/?p=1142 酷壳这个世界从来都不会缺少另类的东西,人类自然世界如此,计算机世界也一样.编程语言方面,看过本站<6个变态的C语言Hello Worl ...
6个变态的C语言Hello World程序之雷人的程序语言
以下的六个程序片段主要完毕这些事情: 输出Hello, World 混乱C语言的源码以下的全部程序都能够在GCC下编译通过,仅仅有最后一个须要动用C++的编译器g++才干编程通过. hello1.c ...
《Java从入门到失业》第一章：计算机基础知识（三）：程序语言简介
1.3程序语言简介我们经常会听到一些名词:低级语言.高级语言.编译型.解释型.面向过程.面向对象等.这些到底是啥意思呢?在正式进入Java世界前,笔者也尝试简单的聊一聊这块东西. 1.3.1低级语言 ...
【一月一本技术书】-【Go语言设计与实现】- 9月
Go : 2009.11.10 代表作:Docker.k8s.etcd 模仿C语言,目标:互联网的C语言讲的晦涩难懂....硬板..放弃了好几次才读完.满分10分,打6分. 下个月:Python数据 ...
Java学习笔记13---一个循环程序的设计范例
package welcome; import java.util.Scanner; /* * 一个循环程序的设计范例 * 首先编写仅执行一次的程序(当无循环时) * 循环的设计步骤: * 1.确定程 ...
Java基础-继承-编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数 wheels和车重weight。小车类Car是Vehicle的子类，其中包含的属性有载人数 loader。卡车类Truck是Car类的子类，其中包含的属性有载重量payload。每个类都有构造方法和输出相关数据的方法。最后，写一个测试类来测试这些类的功能。
#29．编写一个Java应用程序,设计一个汽车类Vehicle,包含的属性有车轮个数 wheels和车重weight.小车类Car是Vehicle的子类,其中包含的属性有载人数 loader.卡车类T ...

随机推荐

jdk8-lanbda方法引用和构造引用
1.方法引用概念及实例 1.对象实例方法语法格式: 对象::实例方法名称注意点: 实例方法必须和被实现的接口中定义的方法的参数列表和返回值一致.一般适合于一个方法就实现了的. 2.类::静态方法 ...
Python发送四种格式的post请求的代码样例
x-www-form-urlencoded: path = "/api/v1/topics/update"params={'accesstoken':'d38a77f0-6f29- ...
SQL-40 表中新增一列
题目描述存在actor表,包含如下列信息:CREATE TABLE IF NOT EXISTS actor (actor_id smallint(5) NOT NULL PRIMARY KEY,fi ...
DM浅尝辄止
都是大佬的笔记啊啊啊啊 dialog management 对话状态维护(dialog state tracking, DST) 生成系统决策(dialog policy) 系统行为(dialog a ...
适用于WIFI Hacking的无线网卡推荐
相信很多初次使用Kali Linux来进行无线渗透的小伙伴都曾遇到过一个非常头疼的问题,就是不知道如何选购一款合适的无线网卡.因为Kali Linux并不是所有的网卡都支持,一旦选错了网卡不仅会给我们 ...
POJ 1065 Wooden Sticks （贪心）
There is a pile of n wooden sticks. The length and weight of each stick are known in advance. The st ...
【Python】混合驱动实例
keywords2.txt: get||ie||{urls.txt} get||chrome||http://www.iciba.com main.py: from selenium import w ...
OAuth和OpenID的区别
OAuth关注的是authorization:而OpenID侧重的是authentication.从表面上看,这两个英文单词很容易混淆,但实际上,它们的含义有本质的区别: authorization: ...
[转]ZooKeeper学习第一期---Zookeeper简单介绍
ZooKeeper学习第一期---Zookeeper简单介绍 http://www.cnblogs.com/sunddenly/p/4033574.html 一.分布式协调技术在给大家介绍ZooKe ...
Selenium之ActionChains (二)
今天,为大家介绍的是标题中的三个新方法,以及一个老方法以下方法都需要操作一个名为Keys的包,先来简单认识下 Keys key_down(value,element),key_up(value,el ...

Go程序语言设计 (艾伦 A. A. 多诺万 著)

Go程序语言设计 (艾伦 A. A. 多诺万 著)的更多相关文章

随机推荐

热门专题

Go程序语言设计 (艾伦 A. A. 多诺万著)

Go程序语言设计 (艾伦 A. A. 多诺万著)的更多相关文章