Go语言入门指南：21世纪应用开发必备

5星 · 超过95%的资源需积分: 9 80 浏览量更新于2024-07-25 收藏 7.02MB PDF 举报

"《Go语言编程入门指南》是Addison-Wesley出版社'开发者图书馆'系列的一部分，该系列专为实践中的程序员提供最新编程语言和技术的优质参考和教程。本书由经验丰富的技术专家Mark Summerfield撰写，他以其卓越的组织和呈现信息的能力，确保了内容对其他程序员极具实用价值。 '开发者图书馆'系列覆盖广泛，不仅包括开源编程语言、数据库（如Go语言），还有Linux编程、微软技术、Java、Web开发、社交网络平台、Mac和iPhone应用开发以及Android编程等领域，反映了21世纪软件开发的多元化需求。这个系列旨在帮助开发者跟上技术的步伐，满足他们在日常工作中不断变化的需求。《Programming in Go》特别针对Go语言进行了深入浅出的讲解，Go语言因其简洁的语法、高效的性能和现代化的特性，成为近年来备受关注的编程语言之一。它特别适合初学者，因为书中不仅介绍了Go的基础概念，如结构体、接口、并发编程等，还会引导读者掌握如何构建高效、可维护的21世纪应用程序。对于那些想要踏入Go语言世界或进一步提升技能的程序员来说，这本书不仅是学习资源，也是一个宝贵的工具箱，提供了实际项目中的实践经验以及对Go语言生态系统深入理解的机会。此外，通过访问developer's-library.com，开发者可以查看完整的系列列表，了解更多的编程技术和资源。《Programming in Go》是初学者和进阶者在Go语言学习旅程中的重要参考资料，它以清晰的指导和实用的教学方法，助力读者在这个快速发展的领域取得成功。"

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 was by Robert Griesemer and Unix luminariesRob 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’s slices

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

剩余492页未读，继续阅读

nullpointer

粉丝: 15
资源: 3

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 - Golang - An Introduction to Programming in Go

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

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

Programming in Go-带书签目录超清文字版.pdf

Learning Functional Programming in Go-Packt Publishing(2017).pdf

Programming.in.Go epub

Cloud Native Programming with Golang

最新资源

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