![discord](data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewbox="0 0 64 64" width="64" height="64" fill-rule="evenodd"><g fill="%23ffffff"><path d="M0,0H64V64H0ZM0 0v64h64V0zm36.903 18.5a29.6 29.6 0 0 1 7.374 2.269c4.045 5.914 6.055 12.585 5.313 20.283a29.6 29.6 0 0 1-9.05 4.537 21.7 21.7 0 0 1-1.936-3.12 19.3 19.3 0 0 0 3.055-1.46 11 11 0 0 1-.747-.562 21.25 21.25 0 0 1-18.082 0c-.242.186-.492.377-.748.562a19 19 0 0 0 3.05 1.457 22 22 0 0 1-1.937 3.123 29.7 29.7 0 0 1-9.043-4.54c-.633-6.638.632-13.37 5.299-20.275a29.8 29.8 0 0 1 7.38-2.274q.522.935.944 1.92a27.5 27.5 0 0 1 8.183 0q.422-.985.945-1.92m-10.97 18.467c-1.762 0-3.218-1.6-3.218-3.568s1.405-3.581 3.213-3.581c1.807 0 3.252 1.614 3.222 3.581-.031 1.968-1.42 3.568-3.216 3.568m11.875 0c-1.765 0-3.216-1.6-3.216-3.568s1.406-3.581 3.216-3.581 3.244 1.614 3.213 3.581c-.03 1.968-1.417 3.568-3.213 3.568" /></g><g fill="%235865F2"><path d="M0 0v64h64V0zm36.903 18.5a29.6 29.6 0 0 1 7.374 2.269c4.045 5.914 6.055 12.585 5.313 20.283a29.6 29.6 0 0 1-9.05 4.537 21.7 21.7 0 0 1-1.936-3.12 19.3 19.3 0 0 0 3.055-1.46 11 11 0 0 1-.747-.562 21.25 21.25 0 0 1-18.082 0c-.242.186-.492.377-.748.562a19 19 0 0 0 3.05 1.457 22 22 0 0 1-1.937 3.123 29.7 29.7 0 0 1-9.043-4.54c-.633-6.638.632-13.37 5.299-20.275a29.8 29.8 0 0 1 7.38-2.274q.522.935.944 1.92a27.5 27.5 0 0 1 8.183 0q.422-.985.945-1.92m-10.97 18.467c-1.762 0-3.218-1.6-3.218-3.568s1.405-3.581 3.213-3.581c1.807 0 3.252 1.614 3.222 3.581-.031 1.968-1.42 3.568-3.216 3.568m11.875 0c-1.765 0-3.216-1.6-3.216-3.568s1.406-3.581 3.216-3.581 3.244 1.614 3.213 3.581c-.03 1.968-1.417 3.568-3.213 3.568" /></g></svg>){kind=small}
Articles
Understanding and Using the `append` Function in Go
Go's `append` function resizes slices dynamically and requires reassignment.
Understanding the `select` Statement in Go
Go's `select` statement enables efficient, non-blocking handling of multiple channels.
Go Concurrency Synchronization: Learn It All at Once
In the Go language programming system, goroutine, as a lightweight thread, provides powerful support for the efficient implementation of concurrent operations due to its significant advantages of low resource consumption and low switching costs. However, how to effectively control these concurrently running goroutines has become an important issue that developers need to face.
Go Dependency Injection Explained: From Zero to Hero
The initial version of the code is not easy to test because it writes data to a place that cannot be controlled. Guided by the tests, we refactor the code. By injecting dependencies, we can control the direction of data writing, which brings many benefits:
Simplifying HTTP Requests in Go with Resty
Resty simplifies HTTP requests in Go with a concise API, auto-unmarshalling, and advanced features.
Using PostgreSQL in Go: A Comprehensive Guide
Connecting Go with PostgreSQL enables efficient database interactions using `database/sql`.
Understanding `make` and Map Initialization (like `make map`) in Go
Understanding `make`, `new`, and map literals ensures proper map initialization in Go.
Deep Dive into Rust Lifetimes: Borrow Checking and Memory Management
Understanding Rust lifetimes and how they ensure memory safety.
Understanding `fallthrough` in Go's `switch` Statements
`fallthrough` in Go’s `switch` allows explicit case continuation but must be used cautiously.
Extracting Substrings in Go
Extract substrings in Go using slices, `strings` functions, or `strings.Builder` for efficiency.
How to Use `time.Sleep` in Go
`time.Sleep` pauses execution for a defined duration in Go.
Understanding derive in Rust: Automating Trait Implementations
An overview of Rust's derive attribute, its usage, benefits, and limitations in automating trait implementations.
Go Web Scraping: HTML Parsing from Zero to Hero
The above examples extract the movie names and link information from the IMDb popular movies page. In actual use, you can adjust the selectors and processing logic according to your needs.
How to Print the Type of a Variable in Go
Methods to print and check variable types in Go using `fmt`, `reflect`, and type switches.
Efficient String Concatenation in Go
Best Go string concatenation methods: `strings.Builder`, `bytes.Buffer`, and `strings.Join`.
Understanding How to Close Channels in Golang
Properly closing channels ensures safe and efficient communication in Go concurrency.
Ternary Operator in Go: Why It’s Missing and Alternative Approaches
Go omits the ternary operator, favoring clarity through `if-else` and helper functions.
How to Split Strings in Go
Explores different ways to split strings in Go, from simple delimiters to regex-based methods.
Testing Regular Expressions in Go: A Guide to Pattern Matching and Text Processing
A practical guide to using Go's `regexp` package for text pattern matching and manipulation.
Reading a File Line by Line in Go
Use `bufio.Scanner` for efficient and error-handled line-by-line file reading.
Merging Maps in Go: A Comprehensive Guide
Different ways to merge maps in Go, including `maps.Copy` and manual iteration.
How to Delete a File in Golang
Golang provides `os.Remove` and `os.RemoveAll` for deleting files and directories, with error handling being essential.
Understanding Golang: Array vs. Slice
Golang slices are dynamic, efficient, and preferred over fixed-size arrays.
Implementing Singleton Pattern in Go
Different methods for safe and efficient singleton implementation in Go.
How to Determine if a String Starts with a Substring in Go
Use `strings.HasPrefix` or slicing to check string prefixes in Go.
Handling Optional Parameters in Golang
Golang lacks native optional parameters but offers alternatives like variadic parameters, structs, and functional options.
Checking If a Key Exists in a Go Map
Use the "comma ok" idiom to efficiently check key existence in Go maps.
String Interpolation in Go: Current Methods and Community Discussions
Go lacks native string interpolation but offers `fmt.Sprintf` as an alternative, sparking community debate.
How to Convert Between `int64` and `string` in Golang
Efficiently convert between `int64` and `string` in Golang using `strconv` and `fmt.Sprintf`.
How to Pretty Print JSON in Go
Formatting JSON in Go using `json.MarshalIndent`, `json.Indent`, and `json.Encoder`.
Converting Byte Array to String in Go
Efficiently converting between `[]byte` and `string` in Go requires balancing safety and performance.
Mastering Rust’s Result Enum for Error Handling
Mastering Rust’s Result type for safer and cleaner error handling.
Why Do Your URLs Suck?
URL design is the facade project of the API architecture, and it is necessary to find a balance between technical implementation and user experience. By following the three principles of simplicity, semanticization, and compatibility, and combining mature mapping mechanisms and excellent case practices, a URL system that conforms to engineering specifications and has commercial value can be constructed. With the development of the API economy in the future, URL design will carry more business semantics and become an important bridge connecting the system and users.
Understanding Floating-Point Numbers in Go
Floating-point numbers in Go can cause precision issues; use `float64` or `decimal` for accuracy.
Logging in Go: Practices and Libraries
Go offers built-in and third-party logging solutions; choose based on features and performance needs.
Managing Concurrent Tasks in Go with `errgroup`
Efficiently manage Go concurrency with `errgroup`'s error handling and context cancellation.
Understanding Struct Embedding in Go
Go struct embedding enables flexible composition and method promotion for better code reuse.
Understanding the `go build` Command in Go
The `go build` command compiles Go programs with support for cross-compilation and customization.
Understanding Golang's `sync.WaitGroup`
Golang's `sync.WaitGroup` efficiently synchronizes goroutines using `Add`, `Done`, and `Wait`.
How to Convert JSON to a Go Struct
Convert JSON to Go structs using `json.Unmarshal`, struct tags, and nested struct definitions.
Understanding Inheritance in Golang
Golang uses struct embedding and interfaces instead of traditional inheritance for code reuse and polymorphism.
Understanding Environment Variables in Golang
Manage environment variables in Golang using `os` functions and `.env` files for flexible configurations.
How to Convert a String to Bytes in Golang
String-to-byte conversion in Go is easy but requires performance considerations for large strings.
Is Golang Object-Oriented?
Go supports object-oriented principles but replaces inheritance with composition and interfaces.
Exploring Golang's Validation Libraries
Comparison of `validator` and `ozzo-validation` for Golang data validation.
Simplifying Testing in Go with Testify
Testify enhances Go testing with better assertions, mocking, and structured test suites.
Understanding Maximum Integer Values in Go
Understanding Go integer limits helps prevent overflow and ensures robust code.
Deep Copy in Golang: Techniques and Best Practices
Deep copying in Go prevents unintended data sharing by handling reference types explicitly.
Golang Proverbs: Guiding Principles for Go Developers
Golang proverbs guide developers to write efficient, maintainable, and idiomatic Go code.
Understanding File Globbing in Go
Go’s `filepath.Glob` simplifies file pattern matching, but for advanced globbing, use third-party packages.