Learning Go. 2nd Edition

Kup polskie wydanie:

Spis treści książki

• Preface
  • Who Should Read This Book
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments for the 2nd Edition
  • Acknowledgments for the 1st Edition
• 1. Setting Up Your Go Environment
  • Installing the Go Tools
    • Troubleshooting Your Go Installation
    • Go Tooling
  • Your First Go Program
    • Making a Go Module
    • go build
    • go fmt
    • go vet
  • Choose Your Tools
    • Visual Studio Code
    • GoLand
    • The Go Playground
  • Makefiles
  • The Go Compatibility Promise
  • Staying Up-to-Date
  • Exercises
  • Wrapping Up
• 2. Predeclared Types and Declarations
  • The Predeclared Types
    • The Zero Value
    • Literals
    • Booleans
    • Numeric Types
      • Integer types
      • The special integer types
      • Choosing which integer to use
      • Integer operators
      • Floating-point types
      • Complex types (youre probably not going to use these)
    • A Taste of Strings and Runes
    • Explicit Type Conversion
    • Literals Are Untyped
  • var Versus :=
  • Using const
  • Typed and Untyped Constants
  • Unused Variables
  • Naming Variables and Constants
  • Exercises
  • Wrapping Up
• 3. Composite Types
  • ArraysToo Rigid to Use Directly
  • Slices
    • len
    • append
    • Capacity
    • make
    • Emptying a Slice
    • Declaring Your Slice
    • Slicing Slices
    • copy
    • Converting Arrays to Slices
    • Converting Slices to Arrays
  • Strings and Runes and Bytes
  • Maps
    • Reading and Writing a Map
    • The comma ok Idiom
    • Deleting from Maps
    • Emptying a Map
    • Comparing Maps
    • Using Maps as Sets
  • Structs
    • Anonymous Structs
    • Comparing and Converting Structs
  • Exercises
  • Wrapping Up
• 4. Blocks, Shadows, and Control Structures
  • Blocks
  • Shadowing Variables
  • if   
  • for, Four Ways
    • The Complete for Statement
    • The Condition-Only for Statement
    • The Infinite for Statement
    • break and continue
    • The for-range Statement
      • Iterating over maps
      • Iterating over strings
      • The for-range value is a copy
    • Labeling Your for Statements
    • Choosing the Right for Statement
  • switch
    • Blank Switches
    • Choosing Between if and switch
  • gotoYes, goto
  • Exercises
  • Wrapping Up
• 5. Functions
  • Declaring and Calling Functions
    • Simulating Named and Optional Parameters
    • Variadic Input Parameters and Slices
    • Multiple Return Values
    • Multiple Return Values Are Multiple Values
    • Ignoring Returned Values
    • Named Return Values
    • Blank ReturnsNever Use These!
  • Functions Are Values
    • Function Type Declarations
    • Anonymous Functions
  • Closures
    • Passing Functions as Parameters
    • Returning Functions from Functions
  • defer
  • Go Is Call by Value
  • Exercises
  • Wrapping Up
• 6. Pointers
  • A Quick Pointer Primer
  • Dont Fear the Pointers
  • Pointers Indicate Mutable Parameters
  • Pointers Are a Last Resort
  • Pointer Passing Performance
  • The Zero Value Versus No Value
  • The Difference Between Maps and Slices
  • Slices as Buffers
  • Reducing the Garbage Collectors Workload
  • Tuning the Garbage Collector
  • Exercises
  • Wrapping Up
• 7. Types, Methods, and Interfaces
  • Types in Go
  • Methods
    • Pointer Receivers and Value Receivers
    • Code Your Methods for nil Instances
    • Methods Are Functions Too
    • Functions Versus Methods
    • Type Declarations Arent Inheritance
    • Types Are Executable Documentation
  • iota Is for EnumerationsSometimes
  • Use Embedding for Composition
  • Embedding Is Not Inheritance
  • A Quick Lesson on Interfaces
  • Interfaces Are Type-Safe Duck Typing
  • Embedding and Interfaces
  • Accept Interfaces, Return Structs
  • Interfaces and nil
  • Interfaces Are Comparable
  • The Empty Interface Says Nothing
  • Type Assertions and Type Switches
  • Use Type Assertions and Type Switches Sparingly
  • Function Types Are a Bridge to Interfaces
  • Implicit Interfaces Make Dependency Injection Easier
  • Wire
  • Go Isnt Particularly Object-Oriented (and Thats Great)
  • Exercises
  • Wrapping Up
• 8. Generics
  • Generics Reduce Repetitive Code and Increase Type Safety
  • Introducing Generics in Go
  • Generic Functions Abstract Algorithms
  • Generics and Interfaces
  • Use Type Terms to Specify Operators
  • Type Inference and Generics
  • Type Elements Limit Constants
  • Combining Generic Functions with Generic Data Structures
  • More on comparable
  • Things That Are Left Out
  • Idiomatic Go and Generics
  • Adding Generics to the Standard Library
  • Future Features Unlocked
  • Exercises
  • Wrapping Up
• 9. Errors
  • How to Handle Errors: The Basics
  • Use Strings for Simple Errors
  • Sentinel Errors
  • Errors Are Values
  • Wrapping Errors
  • Wrapping Multiple Errors
  • Is and As
  • Wrapping Errors with defer
  • panic and recover
  • Getting a Stack Trace from an Error
  • Exercises
  • Wrapping Up
• 10. Modules, Packages, and Imports
  • Repositories, Modules, and Packages
  • Using go.mod
    • Use the go Directive to Manage Go Build Versions
    • The require Directive
  • Building Packages
    • Importing and Exporting
    • Creating and Accessing a Package
    • Naming Packages
    • Overriding a Packages Name
    • Documenting Your Code with Go Doc Comments
    • Using the internal Package
    • Avoiding Circular Dependencies
    • Organizing Your Module
    • Gracefully Renaming and Reorganizing Your API
    • Avoiding the init Function if Possible
  • Working with Modules
    • Importing Third-Party Code
    • Working with Versions
    • Minimal Version Selection
    • Updating to Compatible Versions
    • Updating to Incompatible Versions
    • Vendoring
    • Using pkg.go.dev
  • Publishing Your Module
  • Versioning Your Module
    • Overriding Dependencies
    • Retracting a Version of Your Module
    • Using Workspaces to Modify Modules Simultaneously
  • Module Proxy Servers
    • Specifying a Proxy Server
    • Using Private Repositories
  • Additional Details
  • Exercises
  • Wrapping Up
• 11. Go Tooling
  • Using go run to Try Out Small Programs
  • Adding Third-Party Tools with go install
  • Improving Import Formatting with goimports
  • Using Code-Quality Scanners
    • staticcheck
    • revive
    • golangci-lint
  • Using govulncheck to Scan for Vulnerable Dependencies
  • Embedding Content into Your Program
  • Embedding Hidden Files
  • Using go generate
  • Working with go generate and Makefiles
  • Reading the Build Info Inside a Go Binary
  • Building Go Binaries for Other Platforms
  • Using Build Tags
  • Testing Versions of Go
  • Using go help to Learn More About Go Tooling
  • Exercises
  • Wrapping Up
• 12. Concurrency in Go
  • When to Use Concurrency
  • Goroutines
  • Channels
    • Reading, Writing, and Buffering
    • Using for-range and Channels
    • Closing a Channel
    • Understanding How Channels Behave
  • select
  • Concurrency Practices and Patterns
    • Keep Your APIs Concurrency-Free
    • Goroutines, for Loops, and Varying Variables
    • Always Clean Up Your Goroutines
    • Use the Context to Terminate Goroutines
    • Know When to Use Buffered and Unbuffered Channels
    • Implement Backpressure
    • Turn Off a case in a select
    • Time Out Code
    • Use WaitGroups
    • Run Code Exactly Once
    • Put Your Concurrent Tools Together
  • When to Use Mutexes Instead of Channels
  • AtomicsYou Probably Dont Need These
  • Where to Learn More About Concurrency
  • Exercises
  • Wrapping Up
• 13. The Standard Library
  • io and Friends
  • time
    • Monotonic Time
    • Timers and Timeouts
  • encoding/json
    • Using Struct Tags to Add Metadata
    • Unmarshaling and Marshaling
    • JSON, Readers, and Writers
    • Encoding and Decoding JSON Streams
    • Custom JSON Parsing
  • net/http
    • The Client
    • The Server
      • Middleware
      • Use third-party modules to enhance the server
    • ResponseController
  • Structured Logging
  • Exercises
  • Wrapping Up
• 14. The Context
  • What Is the Context?
  • Values
  • Cancellation
  • Contexts with Deadlines
  • Context Cancellation in Your Own Code
  • Exercises
  • Wrapping Up
• 15. Writing Tests
  • Understanding the Basics of Testing
    • Reporting Test Failures
    • Setting Up and Tearing Down
    • Testing with Environment Variables
    • Storing Sample Test Data
    • Caching Test Results
    • Testing Your Public API
    • Using go-cmp to Compare Test Results
  • Running Table Tests
  • Running Tests Concurrently
  • Checking Your Code Coverage
  • Fuzzing
  • Using Benchmarks
  • Using Stubs in Go
  • Using httptest
  • Using Integration Tests and Build Tags
  • Finding Concurrency Problems with the Data Race Detector
  • Exercises
  • Wrapping Up
• 16. Here Be Dragons: Reflect, Unsafe, and Cgo
  • Reflection Lets You Work with Types at Runtime
    • Types, Kinds, and Values
      • Types and kinds
      • Values
    • Make New Values
    • Use Reflection to Check If an Interfaces Value Is nil
    • Use Reflection to Write a Data Marshaler
    • Build Functions with Reflection to Automate Repetitive Tasks
    • You Can Build Structs with Reflection, but Dont
    • Reflection Cant Make Methods
    • Use Reflection Only if Its Worthwhile
  • unsafe Is Unsafe
    • Using Sizeof and Offsetof
    • Using unsafe to Convert External Binary Data
    • Accessing Unexported Fields
    • Using unsafe Tools
  • Cgo Is for Integration, Not Performance
  • Exercises
  • Wrapping Up
• Index

pokaż cały spis treści

ukryj recenzje