Tech Articles
Understanding Buffered Channels in Go
Buffered channels enable asynchronous goroutine communication and improve concurrency but require careful buffer sizing.
Understanding @ in Rust: Best Practices and Use Cases
A deep dive into Rust’s @ symbol for efficient and expressive pattern matching.
JSON, YAML, TOML, or XML? The Best Choice for 2025
JSON, YAML, TOML, and XML each have their own unique advantages and applicable scenarios. JSON stands out in Web API data transmission and lightweight configuration due to its conciseness and wide support; YAML is an ideal choice for configuration files and data serialization with its high readability and concise syntax; TOML has emerged in the configuration of emerging technologies and simple data storage; XML plays an irreplaceable role in the fields of enterprise-level application integration and document markup. In actual projects, developers should, according to specific requirements, comprehensively consider the characteristics of data formats, application scenarios, and compatibility with existing systems, and select the most suitable data format to achieve efficient data management and application development.
Functional Programming in Go: Concepts and Applications
Go enables functional programming with first-class functions, closures, and functional libraries.
Implementing Sets in Golang: A Practical Guide
Go’s map type provides an efficient way to implement sets, with third-party libraries adding more features.
Golang String Comparison: A Comprehensive Guide
Different Golang methods exist for efficient and case-insensitive string comparison.
Sorting Arrays in Go: A Practical Guide
Sorting in Go requires using the `sort` package, which works with slices, not arrays.
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.