Go编程：面向21世纪的应用开发

需积分: 9 62 浏览量更新于2024-07-25 收藏 7.02MB PDF 举报

"Go for the 21st Century" 《Go for the 21st Century》是一本关于Go语言编程的书籍，属于Addison-Wesley的开发者图书馆系列。该系列致力于为实践经验丰富的程序员提供最新编程语言和技术的权威参考和教程。作者Mark Summerfield是一位精通Go语言的专家，他以其出色的信息组织和呈现能力，为其他程序员提供了实用的学习资料。本书旨在帮助读者掌握Go语言，以适应21世纪的应用程序开发需求。Go语言，也称为Golang，是由Google设计的一种静态类型的、编译型的、垃圾回收的、并发型的、具有C风格语法的编程语言。Go语言的设计目标是提高开发效率，简化系统级编程，并提供高效的并发支持。在书中，作者详细介绍了Go语言的基础知识，包括语法特性、类型系统、函数、包、接口、错误处理、反射、内存管理以及并发编程模型（如goroutines和channels）。此外，还涵盖了Go语言的工具链，如编译器、测试框架和构建系统，以及如何编写高质量的Go代码和参与开源项目。 Go语言的一些关键特点包括： 1. **简洁的语法**：Go语言的语法简单明了，减少了学习曲线，同时保持了强大的功能。 2. **并发原语**：通过goroutines和channels，Go语言提供了轻量级线程和同步机制，使得编写高效并发程序变得容易。 3. **垃圾回收**：自动的内存管理减轻了程序员的负担，避免了常见的内存泄漏问题。 4. **内置的类型系统**：Go语言拥有静态类型，支持结构体和接口，允许灵活的面向对象编程。 5. **高效的编译速度**：Go的编译速度相对较快，使得快速迭代和部署成为可能。开发者图书馆系列涵盖了广泛的IT主题，包括开源编程语言、数据库、Linux编程、微软技术、Java、Web开发、社交网络平台、Mac/iPhone编程和Android编程。访问developers-library.com可以查看完整的产品列表。无论你是初识Go语言，还是希望提升你的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 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页未读，继续阅读

csdddn

粉丝: 12
资源: 208

Go编程：面向21世纪的应用开发

A.Girls.Guide.To.21St.Century.Sex.7of8.TVRip.Xvid-Darmeth.srt

Jist.Works.Best.Jobs.for.the.21st.Century.3rd.Ed.eBook-DDU.pdf

B. Grechuk. Theorems of the 21st Century. Volume 1

The Computer for the 21st Century.pdf

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

Statistical Thinking for the 21st Century.pdf

Security_for_the_21st_Century.pdf

Hechinger, F. M. (1992). Fateful choices: Healthy youth for the 21st century. New York: Hill and Wang, 225 pp., [dollar]18.50

twentieth.century.america.a.brief.history

The Computer for the 21st Century

最新资源