Go编程实战：构建21世纪的应用程序

需积分: 9 91 浏览量更新于2024-07-20 收藏 4.76MB PDF 举报

"Programming in Go: 创建21世纪的应用程序" 《Programming in Go》是一本针对Go语言的实战指南，由Go编程先驱Mark Summerfield撰写，旨在帮助读者掌握利用Go编写高效并发软件的技巧，充分利用现代多核硬件的潜力。本书既适合作为初学者的教程，也作为高级开发者的语言参考，全面介绍了Go语言的关键特性、语法和标准库。作者通过对比不同编程模式，阐述了Go如何在并发性、多核硬件支持以及程序员友好性方面优于传统语言。书中特别强调了Go的独特创新，如无锁通道并发模型和类型安全的鸭子类型面向对象编程方式。主要内容包括： 1. 如何快速获取和安装Go环境，构建和运行Go程序。 2. 探索Go的语法、特性及其丰富的标准库。 3. 编程基础：布尔值、表达式、数值类型以及字符串的创建、比较、索引、切片和格式化。 4. 学习Go内置的高效集合类型——切片和映射，理解它们的工作原理和使用场景。 5. Go作为过程式编程语言的使用，以及它在函数式编程中的应用。 6. Go语言不寻常且灵活的面向对象特性，展示其不同于其他语言的面向接口设计。 7. 掌握Go的并发编程模型，包括goroutines和channels，学习如何编写细粒度的并发程序。 8. 文件操作：读写二进制、文本、JSON和XML文件，理解I/O操作的最佳实践。 9. 进行包的导入与使用，包括标准库、自定义包和第三方包。 10. 创建、文档化、单元测试和基准测试自定义包，以确保代码质量。此外，每章都包含可运行的代码示例，鼓励读者进行实验和学习，以加深理解和提高技能。完整的程序和包示例提供了实际应用场景，同时还有练习题供读者巩固所学。《Programming in Go》是一本深入浅出的Go语言教程，无论你是初学者还是经验丰富的开发者，都能从中受益，提升在21世纪的编程能力。

ptg7913109

Tables

2.1.

Go’s Keywords ..............................................

2.2.

Go’s Predeﬁned Identiﬁers ..................................

2.3.

Boolean and Comparison Operators ..........................

2.4.

Arithmetic Operators Applicable to All Built-In Numbers ......

2.5.

Go’s Integer Types and Ranges ..............................

2.6.

Arithmetic Operators Applicable Only to Built-In Integer Types

2.7.

Go’s Floating-Point Types ....................................

2.8.

The Math Package’s Constants and Functions #1 ..............

2.9.

The Math Package’s Constants and Functions #2 ..............

2.10.

The Math Package’s Constants and Functions #3 ..............

2.11.

The Complex Math Package’s Functions ......................

3.1.

Go’s String and Character Escapes ..........................

3.2.

String Operations ..........................................

3.3.

The Fmt Package’s Print Functions ..........................

3.4.

The Fmt Package’s Verbs ....................................

3.5.

The Fmt Package’s Verb Modiﬁers ............................

3.6.

The Strings Package’s Functions #1 ..........................

108

3.7.

The Strings Package’s Functions #2 ..........................

109

3.8.

The Strconv Package’s Functions #1 ..........................

114

3.9.

The Strconv Package’s Functions #2 ..........................

115

3.10.

The Utf8 Package’s Functions ................................

118

3.11.

The Unicode Package’s Functions ............................

119

3.12.

The Regexp Package’s Functions ............................

121

3.13.

The Regexp Package’s Escape Sequences ....................

121

3.14.

The Regexp Package’s Character Classes ....................

122

3.15.

The Regexp Package’s Zero-Width Assertions ................

122

3.16.

The Regexp Package’s Quantiﬁers ............................

123

3.17.

The Regexp Package’s Flags and Groups ......................

123

3.18.

The

regexp.Regexp Type’s Methods #1 ......................

124

3.19.

The

regexp.Regexp Type’s Methods #2 ......................

125

4.1.

Slice Operations ............................................

151

ptg7913109

Introduction

The purpose of this book is to teach solid idiomatic Go programming using

all the features the language provides, as well as the most commonly used Go

packages from Go’s standard library. The book is also designed to serve as a

useful reference once the language is learned. To meet both of these goals the

book is quite comprehensive and tries to cover every topic in just one place—and

with forward and backward cross-references throughout.

Go is quite C-like in spirit, being a small and efﬁcient language with convenient

low-level facilities such as pointers. Yet Go also offers many features associated

with high- or very high-level languages,such as Unicode strings,powerful built-

in data structures, duck typing, garbage collection, and high-level concurrency

support that uses communication rather than shared data and locks. Go also

has a large and wide-ranging standard library.

The reader is assumed to have programming experience in a mainstream pro-

gramming language such as C, C

,Java, Python, or similar, although all of Go’s

unique features and idioms are illustrated with complete runnable examples

that are fully explained in the text.

To successfully learn any programming language it is necessary to write pro-

grams in that language. To this end the book’s approach is wholly practical,and

readers are encouraged to experiment with the examples, try the exercises, and

write their own programs to get hands-on experience. As with all my previous

books, the quoted code snippets are of “live code”; that is, the code was auto-

matically extracted from

.go

source ﬁles and directly embedded in the PDF that

went to the publisher—so there are no cut and paste errors, and the code works.

Wherever possible, small but complete programs and packages are used as ex-

amples to provide realistic use cases. The examples,exercises, and solutions are

available online at

www.qtrac.eu/gobook.html

The book’s key aim is to teach the Go language, and although many of the

standard Go packages are used, not all of them are. This is not a problem, since

reading the book will provide enough Go knowledge for readers to be able to

make use of any of the standard packages, or any third-party Go package, and

of course, be able to create their own packages.

Why Go?

The Go programming language began as an internal Google project in 2007. The

original design wasby Robert Griesemer and Unix luminaries Rob Pike and Ken

Thompson. On November 10, 2009, Go was publicly unveiled under a liberal

ptg7913109

2 Introduction

open source license. Go is being developed by a team at Google which includes

the original designers plus Russ Cox, Andrew Gerrand, Ian Lance Taylor, and

many others. Go has an open development model and many developers from

around the world contribute to it, with some so trusted and respected that they

have the same commit privileges as the Googlers. In addition, many third-party

Go packages are available from the Go Dashboard (

godashboard.appspot.com/

project

Go is the most exciting new mainstream language to appear in at least 15

years and is the ﬁrst such language that is aimed squarely at 21st century

computers—and their programmers.

Go is designed to scale efﬁciently so that it can be used to build very big appli-

cations—and to compile even a large program in mere seconds on a single com-

puter. The lightning-fast compilation speed is made possible to a small extent

because the language is easy to parse, but mostly because of its dependency

management. If ﬁle

app.go

depends on ﬁle

pkg1.go

, which in turn depends on

pkg2.go

, in a conventional compiled language

app.go

would need both

pkg1.go

’s

and

pkg2.go

’s object ﬁles. But in Go, everything that

pkg2.go

exports is cached

pkg1.go

’s object ﬁle, so

pkg1.go

’s object ﬁle alone is sufﬁcient to build

app.go

For just three ﬁles this hardly matters, but it results in huge speedups for large

applications with lots of dependencies.

Since Go programs are so fast to build, it is practical to use them in situations

where scripting languages are normally used (see the sidebar “Go Shebang

Scripts”,

➤

10). Furthermore, Go can be used to build web applications using

Google’s App Engine.

Go uses a very clean and easy-to-understand syntax that avoids the complexity

and verbosity of older languages like C

(ﬁrst released in 1983) or Java (ﬁrst

released in 1995). And Go is a strongly statically typed language, something

which many programmers regard as essential for writing large programs. Yet

Go’s typing is not burdensome due to Go’s short “declare and initialize” variable

declaration syntax (where the compiler deduces the type so it doesn’t have to be

written explicitly), and because Go supports a powerful and convenient version

of duck typing.

Languages like C and C

require programmers to do a vast amount of book-

keeping when it comes to memory management—bookkeeping that could be

done by the computer itself, especially for concurrent programs where keeping

track can be ﬁendishly complicated. In recent years C

has greatly improved

in this area with various “smart” pointers,but is only just catching up with Java

with regard to its threading library. Java relieves the programmer from the

burden of memory management by using a garbage collector. C has only third-

party threading libraries, although C

now has a standard threading library.

However, writing concurrent programs in C, C

, or Java requires considerable

ptg7913109

Introduction 3

bookkeeping by programmers to make sure they lock and unlock resources at

the right times.

The Go compiler and runtime system takes care of the tedious bookkeeping. For

memory management Go has a garbage collector, so there’s no need for smart

pointers or for manually freeing memory. And for concurrency, Go provides a

form of CSP (Communicating Sequential Processes) based on the ideas of com-

puter scientist C. A. R. Hoare, that means that many concurrent Go programs

don’t need to do any locking at all. Furthermore, Go uses goroutines—very

lightweight processes which can be created in vast numbers that are automati-

cally load-balanced across the available processors and cores—to provide much

more ﬁne-grained concurrency than older languages’ thread-based approach-

es. In fact, Go’s concurrency support is so simple and natural to use that when

porting single-threaded programs to Go it often happens that opportunities for

using concurrency arise that lead to improved runtimes and better utilization of

machine resources.

Go is a pragmatic language that favors efﬁciency and programmer convenience

over purity. For example, Go’s built-in types and user-deﬁned types are not the

same, since the former can be highly optimized in ways the latter can’t be. Go

also provides two fundamental built-in collection types: slices (for all practical

purposes these are references to variable-length arrays) and maps (key–value

dictionaries or hashes). These collection types are highly efﬁcient and serve

most purposes extremely well. However, Go supports pointers (it is a fully com-

piled language—there’s no virtual machine getting in the way of performance),

so it is possible to create sophisticated custom types, such as balanced binary

trees, with ease.

While C supports only procedural programming and Java forces programmers

to program everything in an object-oriented way, Go allows programmers to use

the paradigm best suited to the problem. Go can be used as a purely procedural

language, but also has excellent support for object-oriented programming. As

we will see, though, Go’s approach to object orientation is radically different

from, say, C

, Java, or Python—and is easier to use and much more ﬂexible

than earlier forms.

Like C, Go lacks generics (templates in C

-speak); however, in practice the

other facilities that Go provides in many cases obviate the need for generics.

Go does not use a preprocessor or include ﬁles (which is another reason why it

compiles so fast), so there is no need to duplicate function signatures as there is

in C and C

. And with no preprocessor, a program’s semantics cannot change

behind a Go programmer’s back as it can with careless #deﬁnes in C and C

Arguably, C

, Objective-C, and Java have all attempted to be better Cs (the

latter indirectly as a better C

).Go can also be seen as an attempt to be a better

C, even though Go’sclean,light syntax is reminiscent of Python—and Go’sslices

and maps are very similar to Python’s lists and dicts. However, Go is closer in

剩余492页未读，继续阅读

renzhewh

粉丝: 39
资源: 100

Go编程实战：构建21世纪的应用程序

Learning Functional Programming in Go epub

Go语言程序设计(programming in go)中文 高清完整.pdf版

Go语言程序设计(中文)-Programming in Go Creating Applications for the 21st Century.pdf

go lang chan

no required module provides package hell.go: go.mod file not found in current directory or any parent directory; see 'go help modules'

golang推荐书籍

golang的中文学习资料

go语言写一个编程语言

please introdoce golang

最新资源

Go语言程序设计(programming in go)中文高清完整.pdf版