Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Go Standard Library Cookbook

By : Radomír Sohlich

1 (1)

Go Standard Library Cookbook

1 (1)

By: Radomír Sohlich

Overview of this book

Google's Golang will be the next talk of the town, with amazing features and a powerful library. This book will gear you up for using golang by taking you through recipes that will teach you how to leverage the standard library to implement a particular solution. This will enable Go developers to take advantage of using a rock-solid standard library instead of third-party frameworks. The book begins by exploring the functionalities available for interaction between the environment and the operating system. We will explore common string operations, date/time manipulations, and numerical problems. We'll then move on to working with the database, accessing the filesystem, and performing I/O operations. From a networking perspective, we will touch on client and server-side solutions. The basics of concurrency are also covered, before we wrap up with a few tips and tricks. By the end of the book, you will have a good overview of the features of the Golang standard library and what you can achieve with them. Ultimately, you will be proficient in implementing solutions with powerful standard libraries.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

Interacting with the Environment

Interacting with the Environment

Introduction

Retrieving the Golang version

Accessing program arguments

Creating a program interface with the flag package

Getting and setting environment variables with default values

Retrieving the current working directory

Getting the current process PID

Handling operating system signals

Calling an external process

Retrieving child process information

Reading/writing from the child process

Shutting down the application gracefully

File configuration with functional options

Strings and Things

Strings and Things

Introduction

Finding the substring in a string

Breaking the string into words

Joining the string slice with a separator

Concatenating a string with writer

Aligning text with tabwriter

Replacing part of the string

Finding the substring in text by the regex pattern

Decoding a string from the non-Unicode charset

Controlling case

Parsing comma-separated data

Managing whitespace in a string

Indenting a text document

Dealing with Numbers

Dealing with Numbers

Introduction

Converting strings to numbers

Comparing floating-point numbers

Rounding floating-point numbers

Floating-point arithmetics

Formatting numbers

Converting between binary, octal, decimal, and hexadecimal

Formatting with the correct plurals

Generating random numbers

Operating complex numbers

Converting between degrees and radians

Taking logarithms

Generating checksums

Once Upon a Time

Once Upon a Time

Introduction

Finding today's date

Formatting date to string

Parsing the string into date

Converting dates to epoch and vice versa

Retrieving time units from the date

Date arithmetics

Finding the difference between two dates

Converting between time zones

Running the code block periodically

Waiting a certain amount of time

Timeout long-running operations

Serializing the time and date

In and Out

In and Out

Introduction

Reading standard input

Writing standard output and error

Opening a file by name

Reading the file into a string

Reading/writing a different charset

Seeking a position within a file

Reading and writing binary data

Writing to multiple writers at once

Piping between writer and reader

Serializing objects to binary format

Reading and writing ZIP files

Parsing a large XML file effectively

Extracting data from an incomplete JSON array

Discovering the Filesystem

Discovering the Filesystem

Introduction

Getting file information

Creating temporary files

Writing the file

Writing the file from multiple goroutines

Listing a directory

Changing file permissions

Creating files and directories

Filtering file listings

Comparing two files

Resolving the user home directory

Connecting the Network

Connecting the Network

Introduction

Resolving local IP addresses

Connecting to the remote server

Resolving the domain by IP address and vice versa

Connecting to the HTTP server

Parsing and building a URL

Creating an HTTP request

Reading and writing HTTP headers

Handling HTTP redirects

Consuming the RESTful API

Sending a simple email

Calling the JSON-RPC service

Working with Databases

Working with Databases

Introduction

Connecting the database

Validating the connection

Executing statements

Operations with prepared statements

Canceling the pending query

Reading query result metadata

Retrieving data from a query result

Parsing the query result into a map

Handling transactions

Executing stored procedures and functions

Come to the Server Side

Come to the Server Side

Introduction

Creating the TCP server

Creating the UDP server

Handling multiple clients

Creating the HTTP Server

Handling HTTP requests

Creating HTTP middleware layer

Serving static files

Serving content generated with templates

Handling redirects

Handling cookies

Gracefully shutdown the HTTP server

Serving secured HTTP content

Resolving form variables

Fun with Concurrency

Fun with Concurrency

Introduction

Synchronizing access to a resource with Mutex

Creating map for concurrent access

Running a code block only once

Pooling resources across multiple goroutines

Synchronizing goroutines with WaitGroup

Getting the fastest result from multiple sources

Propagating errors with errgroup

Tips and Tricks

Tips and Tricks

Introduction

Logging customization

Testing the code

Benchmarking the code

Creating subtests

Testing the HTTP handler

Accessing tags via reflection

Sorting slices

Breaking HTTP handlers into groups

Utilizing HTTP/2 server push

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Comparing floating-point numbers

Because of how floating-point numbers are represented, there can be inconsistencies while comparing two numbers that appear to be identical. Unlike integers, IEEE floating-point numbers are only approximated. The need to convert the numbers to a form the computer can store in binary leads to minor precision or round-off deviations. For example, a value of 1.3 could be represented as 1.29999999999. The comparison could be done with some tolerance. To compare numbers with arbitrary precision, the big package is here.

How to do it...

Open the console and create the folder chapter03/recipe02.
Navigate to the directory.
Create the tolerance.go file with the following content:

        package main...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Go Standard Library Cookbook

Search

Your notes and bookmarks