reklama - zainteresowany?

Head First Go - Helion

Head First Go
ebook
Autor: Jay McGavren
ISBN: 978-14-919-6950-2
stron: 560, Format: ebook
Data wydania: 2019-04-04
Księgarnia: Helion

Cena książki: 186,15 zł (poprzednio: 216,45 zł)
Oszczędzasz: 14% (-30,30 zł)

Dodaj do koszyka Head First Go

Go represents an attempt to improve on some weaknesses of traditional compiled programming languages. It de-emphasizes or removes error-prone language structures like class inheritance and exception handling. It features great concurrency support and automatic memory management (garbage collection).

Existing Go books tend to be highly technical in nature, teaching all aspects of the language regardless of their relevance to beginners. This book, rather than talking about the features of Go in abstract terms, features simple, clear examples that demonstrate Go in action, and diagrams to explain difficult concepts.

This book will not only teach developers basic language features, it will get them comfortable consulting error output, documentation, and search engines to find solutions to problems. It will teach all the conventions and techniques that employers expect an entry-level Go developer to know.

Dodaj do koszyka Head First Go

 

Osoby które kupowały "Head First Go", wybierały także:

  • Windows Media Center. Domowe centrum rozrywki
  • Ruby on Rails. Ćwiczenia
  • DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker
  • Przywództwo w Å›wiecie VUCA. Jak być skutecznym liderem w niepewnym Å›rodowisku
  • Scrum. O zwinnym zarzÄ…dzaniu projektami. Wydanie II rozszerzone

Dodaj do koszyka Head First Go

Spis treści

Head First Go eBook -- spis treści

  • Table of Contents (the real thing)
  • how to use this book: Intro
    • Who is this book for?
      • Who should probably back away from this book?
    • We know what youre thinking
    • We know what your brain is thinking
    • Metacognition: thinking about thinking
    • Heres what WE did
    • Heres what YOU can do to bend your brain into submission
    • Read me
      • It helps if youve done a little programming in some other language.
      • We dont cover every type, function, and package ever created.
      • The activities are NOT optional.
      • The redundancy is intentional and important.
      • The code examples are as lean as possible.
    • Acknowledgments
    • OReilly Online Learning
  • 1. lets get going: Syntax Basics
    • Ready, set, Go!
    • The Go Playground
    • What does it all mean?
      • The typical Go file layout
    • there are no Dumb Questions
    • What if something goes wrong?
    • Breaking Stuff is Educational!
    • Calling functions
    • The Println function
    • Using functions from other packages
    • Function return values
    • Pool Puzzle
    • A Go program template
    • Strings
    • Runes
    • Booleans
    • Numbers
    • Math operations and comparisons
    • Types
    • Declaring variables
    • Zero values
    • Code Magnets
    • Short variable declarations
    • Breaking Stuff is Educational!
    • Naming rules
    • Conversions
    • Installing Go on your computer
    • Compiling Go code
    • Go tools
    • Try out code quickly with go run
    • Your Go Toolbox
    • Pool Puzzle Solution
    • Code Magnets Solution
  • 2. which code runs next?: Conditionals and Loops
    • Calling methods
    • Making the grade
    • Comments
    • Getting a grade from the user
    • Multiple return values from a function or method
    • Option 1: Ignore the error return value with the blank identifier
    • Option 2: Handle the error
    • Conditionals
    • there are no Dumb Questions
    • Logging a fatal error, conditionally
    • Code Magnets
    • Avoid shadowing names
    • Converting strings to numbers
    • Blocks
    • Blocks and variable scope
    • Weve finished the grading program!
    • Only one variable in a short variable declaration has to be new
    • Lets build a game
    • Package names vs. import paths
    • Generating a random number
    • Getting an integer from the keyboard
    • Comparing the guess to the target
    • Loops
    • Init and post statements are optional
    • Loops and scope
    • Breaking Stuff is Educational!
    • Using a loop in our guessing game
    • Skipping parts of a loop with continue and break
    • Breaking out of our guessing loop
    • Revealing the target
    • The finishing touches
    • Congratulations, your game is complete!
    • Your Go Toolbox
    • Code Magnets Solution
  • 3. call me: Functions
    • Some repetitive code
    • Formatting output with Printf and Sprintf
    • Formatting verbs
    • Formatting value widths
    • Formatting fractional number widths
    • Using Printf in our paint calculator
    • Declaring functions
    • Declaring function parameters
    • Using functions in our paint calculator
    • Functions and variable scope
    • Function return values
    • Using a return value in our paint calculator
    • Breaking Stuff is Educational!
    • The paintNeeded function needs error handling
    • Error values
    • Declaring multiple return values
    • Using multiple return values with our paintNeeded function
    • Always handle errors!
    • Breaking Stuff is Educational!
    • Pool Puzzle
    • Function parameters receive copies of the arguments
    • Pointers
    • Pointer types
    • Getting or changing the value at a pointer
    • Code Magnets
    • Using pointers with functions
    • Fixing our double function using pointers
    • Your Go Toolbox
    • Pool Puzzle Solution
    • Code Magnets Solution
  • 4. bundles of code: Packages
    • Different programs, same function
    • Sharing code between programs using packages
    • The Go workspace directory holds package code
    • there are no Dumb Questions
    • Creating a new package
    • Importing our package into a program
    • Packages use the same file layout
    • Breaking Stuff is Educational!
    • Pool Puzzle
    • Package naming conventions
    • Package qualifiers
    • Moving our shared code to a package
    • Constants
    • Nested package directories and import paths
    • Installing program executables with go install
    • Changing workspaces with the GOPATH environment variable
    • Setting GOPATH
      • On Mac or Linux systems:
      • On Windows systems:
    • Publishing packages
    • Downloading and installing packages with go get
    • Reading package documentation with go doc
    • Documenting your packages with doc comments
    • Viewing documentation in a web browser
    • Serving HTML documentation to yourself with godoc
    • The godoc server includes YOUR packages!
    • Your Go Toolbox
    • Pool Puzzle Solution
  • 5. on the list: Arrays
    • Arrays hold collections of values
    • Zero values in arrays
    • Array literals
    • Functions in the fmt package know how to handle arrays
    • Accessing array elements within a loop
    • Checking array length with the len function
    • Looping over arrays safely with for...range
    • Using the blank identifier with for...range loops
    • Getting the sum of the numbers in an array
    • Getting the average of the numbers in an array
    • Pool Puzzle
    • Reading a text file
    • Reading a text file into an array
    • Updating our average program to read a text file
    • Our program can only process three values!
    • Your Go Toolbox
    • Pool Puzzle Solution
  • 6. appending issue: Slices
    • Slices
    • Slice literals
    • Pool Puzzle
    • The slice operator
    • Underlying arrays
    • Change the underlying array, change the slice
    • Add onto a slice with the append function
    • Slices and zero values
    • Reading additional file lines using slices and append
    • Trying our improved program
    • Returning a nil slice in the event of an error
    • Command-line arguments
    • Getting command-line arguments from the os.Args slice
    • The slice operator can be used on other slices
    • Updating our program to use command-line arguments
    • Variadic functions
    • Using variadic functions
    • Code Magnets
    • Using a variadic function to calculate averages
    • Passing slices to variadic functions
    • Slices have saved the day!
    • Your Go Toolbox
    • Pool Puzzle Solution
    • Code Magnets Solution
  • 7. labeling data: Maps
    • Counting votes
    • Reading names from a file
    • Counting names the hard way, with slices
    • Maps
    • Map literals
    • Zero values within maps
    • The zero value for a map variable is nil
    • How to tell zero values apart from assigned values
    • Removing key/value pairs with the delete function
    • Updating our vote counting program to use maps
    • Using for...range loops with maps
    • The for...range loop handles maps in random order!
    • Updating our vote counting program with a for...range loop
    • The vote counting program is complete!
    • Code Magnets
    • Your Go Toolbox
    • Code Magnets Solution
  • 8. building storage: Structs
    • Slices and maps hold values of ONE type
    • Structs are built out of values of MANY types
    • Access struct fields using the dot operator
    • Storing subscriber data in a struct
    • Defined types and structs
    • Using a defined type for magazine subscribers
    • Using defined types with functions
    • Code Magnets
    • Modifying a struct using a function
    • Accessing struct fields through a pointer
    • there are no Dumb Questions
    • Pass large structs using pointers
    • Moving our struct type to a different package
    • A defined types name must be capitalized to be exported
    • Struct field names must be capitalized to be exported
    • Struct literals
    • Pool Puzzle
    • Creating an Employee struct type
    • Creating an Address struct type
    • Adding a struct as a field on another type
    • Setting up a struct within another struct
    • Anonymous struct fields
    • Embedding structs
    • Our defined types are complete!
    • Your Go Toolbox
    • Code Magnets Solution
    • Pool Puzzle Solution
  • 9. youre my type: Defined Types
    • Type errors in real life
    • Defined types with underlying basic types
    • Defined types and operators
    • Pool Puzzle
    • Converting between types using functions
    • there are no Dumb Questions
    • Fixing our function name conflict using methods
    • Defining methods
    • The receiver parameter is (pretty much) just another parameter
    • there are no Dumb Questions
    • A method is (pretty much) just like a function
    • Pointer receiver parameters
    • Breaking Stuff is Educational!
    • Converting Liters and Milliliters to Gallons using methods
    • Converting Gallons to Liters and Milliliters using methods
    • Your Go Toolbox
    • Pool Puzzle Solution
  • 10. keep it to yourself: Encapsulation and Embedding
    • Creating a Date struct type
    • People are setting the Date struct field to invalid values!
    • Setter methods
    • Setter methods need pointer receivers
    • Adding the remaining setter methods
    • Adding validation to the setter methods
    • The fields can still be set to invalid values!
    • Moving the Date type to another package
    • Making Date fields unexported
    • Accessing unexported fields through exported methods
    • Getter methods
    • Encapsulation
    • there are no Dumb Questions
    • Embedding the Date type in an Event type
    • Unexported fields dont get promoted
    • Exported methods get promoted just like fields
    • Encapsulating the Event Title field
    • Promoted methods live alongside the outer types methods
    • Our calendar package is complete!
    • Your Go Toolbox
  • 11. what can you do?: Interfaces
    • Two different types that have the same methods
    • A method parameter that can only accept one type
    • Interfaces
    • Defining a type that satisfies an interface
    • Concrete types, interface types
    • Assign any type that satisfies the interface
    • You can only call methods defined as part of the interface
    • Breaking Stuff is Educational!
    • Fixing our playList function using an interface
    • there are no Dumb Questions
    • Type assertions
    • Type assertion failures
    • Avoiding panics when type assertions fail
    • Testing TapePlayers and TapeRecorders using type assertions
    • Pool Puzzle
    • The error interface
    • there are no Dumb Questions
    • The Stringer interface
    • The empty interface
    • Your Go Toolbox
    • Pool Puzzle Solution
  • 12. back on your feet: Recovering from Failure
    • Reading numbers from a file, revisited
    • Any errors will prevent the file from being closed!
    • Deferring function calls
    • Recovering from errors using deferred function calls
    • Ensuring files get closed using deferred function calls
    • Code Magnets
    • there are no Dumb Questions
    • Listing the files in a directory
    • Listing the files in subdirectories (will be trickier)
    • Recursive function calls
    • Recursively listing directory contents
    • Error handling in a recursive function
    • Starting a panic
    • Stack traces
    • Deferred calls completed before crash
    • Using panic with scanDirectory
    • When to panic
    • The recover function
    • The panic value is returned from recover
    • Recovering from panics in scanDirectory
    • Reinstating a panic
    • there are no Dumb Questions
    • Your Go Toolbox
    • Code Magnets Solution
  • 13. sharing work: Goroutines and Channels
    • Retrieving web pages
    • Multitasking
    • Concurrency using goroutines
    • Using goroutines
    • Using goroutines with our responseSize function
    • We dont directly control when goroutines run
    • Code Magnets
    • Go statements cant be used with return values
    • Sending and receiving values with channels
    • Synchronizing goroutines with channels
    • Observing goroutine synchronization
    • Breaking Stuff is Educational!
    • Fixing our web page size program with channels
    • Updating our channel to carry a struct
    • Your Go Toolbox
    • Code Magnets Solution
  • 14. code quality assurance: Automated Testing
    • Automated tests find your bugs before someone else does
    • A function we should have had automated tests for
    • Weve introduced a bug!
    • Writing tests
    • Running tests with the go test command
    • Testing our actual return values
    • More detailed test failure messages with the Errorf method
    • Test helper functions
    • Getting the tests to pass
    • Test-driven development
    • Another bug to fix
    • there are no Dumb Questions
    • Code Magnets
    • Running specific sets of tests
    • Table-driven tests
    • Fixing panicking code using a test
    • Your Go Toolbox
    • Code Magnets Solution
  • 15. responding to requests: Web Apps
    • Writing web apps in Go
    • Browsers, requests, servers, and responses
    • A simple web app
    • Your computer is talking to itself
    • there are no Dumb Questions
    • Our simple web app, explained
    • Resource paths
    • Responding differently for different resource paths
    • First-class functions
    • Passing functions to other functions
    • Functions as types
    • Pool Puzzle
    • Whats next
    • Your Go Toolbox
    • Pool Puzzle Solution
  • 16. a pattern to follow: HTML Templates
    • A guestbook app
    • Functions to handle a request and check errors
    • Setting up a project directory and trying the app
    • Making a signature list in HTML
    • Making our app respond with HTML
    • The text/template package
    • Using the io.Writer interface with a templates Execute method
    • ResponseWriters and os.Stdout both satisfy io.Writer
    • Inserting data into templates using actions
    • Making parts of a template optional with if actions
    • Repeating parts of a template with range actions
    • Inserting struct fields into a template with actions
    • Reading a slice of signatures in from a file
    • there are no Dumb Questions
    • A struct to hold the signatures and signature count
    • Updating our template to include our signatures
    • there are no Dumb Questions
    • Letting users add data with HTML forms
    • Responding with the HTML form
    • Form submission requests
    • Path and HTTP method for form submissions
    • Getting values of form fields from the request
    • Saving the form data
    • HTTP redirects
    • Lets try it all out!
    • Our complete app code
    • Your Go Toolbox
  • 17. Congratulations!: You made it to the end.
  • 18. This isnt goodbye
  • A. understanding os.openfile: Opening Files
    • Understanding os.OpenFile
    • Passing flag constants to os.OpenFile
    • Binary notation
    • Bitwise operators
    • The bitwise AND operator
    • The bitwise OR operator
    • Using bitwise OR on the os package constants
    • Using bitwise OR to fix our os.OpenFile options
    • Unix-style file permissions
    • Representing permissions with the os.FileMode type
    • Octal notation
    • Converting octal values to FileMode values
    • Calls to os.OpenFile, explained
    • there are no Dumb Questions
  • B. six things we didnt cover: Leftovers
    • #1 Initialization statements for if
    • #2 The switch statement
    • there are no Dumb Questions
    • #3 More basic types
    • #4 More about runes
    • #5 Buffered channels
    • #6 Further reading
  • Index

Dodaj do koszyka Head First Go

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2024 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.