Go语言编程权威指南：Programming in Go

需积分: 10 115 浏览量更新于2024-07-23 1 收藏 6.47MB PDF 举报

"Programming in Go英文版 - Mark Summerfield 著" 《Programming in Go》是Mark Summerfield撰写的一本关于Go语言的权威入门教程，它针对想要学习和掌握Go语言的程序员提供了详尽且深入的指导。这本书属于Addison-Wesley的Developer’s Library系列，该系列书籍由经验丰富的技术实践者编写，他们擅长将复杂的技术信息以易于理解的方式呈现，以满足其他程序员在实际工作中学习新技术的需求。 Developer’s Library系列涵盖了广泛的编程主题，包括开源编程语言、数据库、Linux编程、微软技术、Java，以及Web开发、社交网络平台、Mac/iPhone编程、Android编程等多个领域。这个系列的书籍旨在提供全面且实用的产品选择，帮助开发者不断提升技能，适应快速发展的技术环境。《Programming in Go》这本书具体探讨了如何使用Go语言创建21世纪的应用程序。Go语言，又称为Golang，是由Google设计的一种静态类型、编译型、并发型且具有垃圾回收功能的系统级编程语言。它旨在提高开发者的生产力，提供高效的并发机制，并简化程序设计。在书中，Mark Summerfield详细讲解了Go语言的关键特性，如： 1. **语法和结构**：Go语言的简洁语法，如C语言般的直观，以及它独特的类型系统，包括接口和结构体。 2. **并发编程**：Go语言通过goroutines和channels提供了轻量级线程和通信机制，使得并发编程变得简单而高效。 3. **包和模块管理**：介绍Go的包组织方式，以及随着Go 1.11引入的模块系统，帮助开发者理解和管理依赖关系。 4. **错误处理**：Go语言的错误处理机制，包括返回错误值和 panic/recover 模式。 5. **标准库**：探讨Go的标准库，包括网络编程、文件I/O、JSON处理等关键领域。 6. **测试和调试**：介绍Go语言内置的测试框架和调试工具，以提升代码质量。 7. **性能优化**：讨论如何利用Go语言的特性进行性能调优，例如内存管理和CPU使用率优化。通过阅读本书，读者不仅可以了解Go语言的基本概念和核心机制，还能学习到如何利用Go来构建高性能、可扩展的现代应用程序。无论你是初学者还是有经验的程序员，这本书都将是你掌握Go语言不可或缺的参考资料。

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

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 luminariesRob Pike and Ken

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

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

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’s clean, 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

剩余100页未读，继续阅读

lxdong007

粉丝: 14
资源: 6

Go语言编程权威指南：Programming in Go

"基于go语言的驾照考试管理系统设计与实现

Go编程语言phrasebook：创建21世纪的应用程序

深入探索Go语言：基于Casa do Code的编程入门研究

Programming.in.Go epub

Programming.in.D.Tutorial.and.Reference.1515074609

Shell.Programming.in.Unix.Linux.and.OS.X.4th.Ed

[Excel.2007.Power.Programming.with.VBA].Excel.2007.Power.Programming.with.VBA.part1

For.Dummies.Go.Programming.Language.For.Dummies.pdf

The.Go.Programming.Language.0134190440.epub

Go.Programming.Blueprints.2nd

最新资源