{"id":3375,"date":"2026-10-09T00:33:58","date_gmt":"2026-10-08T16:33:58","guid":{"rendered":"http:\/\/www.globalreach-sbi.com\/blog\/?p=3375"},"modified":"2026-10-09T00:33:58","modified_gmt":"2026-10-08T16:33:58","slug":"how-to-filter-a-list-in-go-472f-665b36","status":"publish","type":"post","link":"http:\/\/www.globalreach-sbi.com\/blog\/2026\/10\/09\/how-to-filter-a-list-in-go-472f-665b36\/","title":{"rendered":"How to filter a list in Go?"},"content":{"rendered":"

If you\u2019ve ever spent time sifting through messy, unstructured data to pull out exactly what you need, you know how critical a good filtering system is. For someone like me\u2014who\u2019s spent a decade running a company that designs and manufactures industrial filtration systems for manufacturing and processing plants\u2014filtering isn\u2019t just a tech buzzword. It\u2019s a habit I apply to everything, from sorting inventory in our warehouse to debugging Go code that powers our internal inventory and sales tracking tools. Filter<\/a><\/p>\n

<\/p>\n

A few years back, when our engineering team was rebuilding our in-house system to track filter shipments, material stock, and client orders, we settled on Go (Golang) for its speed, simplicity, and ability to handle concurrent tasks\u2014perfect for keeping up with hundreds of daily orders and parts requests. Early on, though, we ran into a mess: we had lists of filter types, order statuses, and part numbers, and our initial filtering code was clunky, slow, and hard to maintain. That experience taught me that filtering in Go isn\u2019t just about writing a function\u2014it\u2019s about choosing the right approach for what you\u2019re filtering, whether that\u2019s a list of industrial filter elements or a slice of structs in your code.<\/p>\n

Let\u2019s walk through what we learned, using real examples from our codebase, and tie it all back to how we apply this same logic to the filters we ship to clients every day.<\/p>\n

First, Know What You\u2019re Filtering (And Why It Matters)<\/h3>\n

Before you write a line of code, stop and ask: what\u2019s in the list I\u2019m working with? For our code, most of the lists we filter are slices of structs. For example, we have a FilterPart<\/code> struct that looks like this (simplified for clarity):<\/p>\n

type FilterPart struct {\n    ID          string  \/\/ Unique part number, e.g., "HEPA-0042"\n    Type        string  \/\/ Filter type: "HEPA", "Activated Carbon", "Pleated"\n    Application string  \/\/ Where it\u2019s used: "HVAC", "Oil Processing", "Water Treatment"\n    InStock     bool    \/\/ Whether we have it in our warehouse\n    Quantity    int     \/\/ Number of units available\n}\n<\/code><\/pre>\n
When we need to pull a list of HEPA filters for an HVAC client, or parts that are in stock for same-day shipping, we\u2019re filtering slices of these structs. The same way, when a client comes to us with a request for a filter that works for their water treatment system, we\u2019re filtering our product catalog to find exactly what fits.<\/p>\n
The key here: if you try to force a one-size-fits-all filter approach, you\u2019ll end up with code that\u2019s hard to read or filters data incorrectly. For small lists, a simple function works great; for larger datasets, you\u2019ll want something that\u2019s efficient and parallelizable.<\/p>\n
The Basic Filter: Simple Slice Iteration (For Small Lists)<\/h3>\n
When our system was new, our first filter function for FilterPart<\/code> looked like this. We needed to get all in-stock HEPA filters for HVAC applications:<\/p>\n
func FilterInStockHepaForHVAC(parts []FilterPart) []FilterPart {\n    var filtered []FilterPart\n    for _, part := range parts {\n        if part.Type == "HEPA" && part.Application == "HVAC" && part.InStock {\n            filtered = append(filtered, part)\n        }\n    }\n    return filtered\n}\n<\/code><\/pre>\n
This works for small lists\u2014say, a slice of 50 or 100 parts. We used this for our internal team\u2019s quick searches, since it\u2019s straightforward, easy to write, and doesn\u2019t require any extra libraries. Think of this like checking a box of loose filter elements to pull out the ones that fit a specific spec: you go one by one, pick out the right ones, and put them in a new pile.<\/p>\n
But we quickly hit a problem: when we needed to filter for other criteria\u2014like out-of-stock activated carbon filters for oil processing\u2014we\u2019d have to write almost identical functions, just changing the condition. That\u2019s redundant, and when you\u2019re managing 10,000+ parts, it\u2019s easy to make a typo (like mixing up "Oil" and "oil" in the condition, which would leave out valid parts).<\/p>\n
This is the lesson here for basic iteration: use it for small, infrequent filters, but don\u2019t rely on it for everything. If you find yourself writing the same loop over and over, it\u2019s time to abstract the logic.<\/p>\n
The Flexible Filter: Reusable Generic Functions (For Go 1.18+)<\/h3>\n
Go 1.18 introduced generics, which changed the game for filtering. Generics let you write a single filter function that works with any data type, not just FilterPart<\/code>. That meant we could stop writing custom functions for every filter criteria and build a reusable tool that works for our parts structs, our order slices, even our inventory logs.<\/p>\n
Here\u2019s a generic filter function we built, which accepts any slice and a condition function that defines what to keep:<\/p>\n
func Filter[T any](list []T, condition func(T) bool) []T {\n    var filtered []T\n    for _, item := range list {\n        if condition(item) {\n            filtered = append(filtered, item)\n        }\n    }\n    return filtered\n}\n<\/code><\/pre>\n
That\u2019s it. Now, to get our in-stock HEPA HVAC filters, we just pass the list of parts and a condition function:<\/p>\n
parts := []FilterPart{\/* our full list of parts *\/}\nfilteredParts := Filter(parts, func(p FilterPart) bool {\n    return p.Type == "HEPA" && p.Application == "HVAC" && p.InStock\n})\n<\/code><\/pre>\n
And if we need to pull out activated carbon filters for water treatment that are low in stock (less than 5 units), it\u2019s just as easy:<\/p>\n
lowStockCarbonWater := Filter(parts, func(p FilterPart) bool {\n    return p.Type == "Activated Carbon" && p.Application == "Water Treatment" && p.Quantity < 5\n})\n<\/code><\/pre>\n
This is exactly how we run our product catalog searches now. The same way we can adapt a single filtering process to sort through different filter materials for different clients, this generic function adapts to any data we need to filter. It\u2019s clean, reduces code duplication, and is easy to update\u2014if we need to add a new criteria (like a Material<\/code> field or a LeadTime<\/code>), we just adjust the condition function, not the filter itself.<\/p>\n
One thing to note: when we first tested this, we worried about performance for large slices. But for our use case\u2014filtering slices up to 10,000 items\u2014this generic function is just as fast as writing a custom loop. It\u2019s not the fastest approach for massive datasets (like 100k+ items), but for most business applications, it\u2019s perfect.<\/p>\n
For Large Datasets: Parallel Filtering (When Speed Matters)<\/h3>\n
Last year, when our inventory grew to over 50,000 parts, we noticed that filtering the entire list was starting to take a few seconds\u2014too slow for our team when they\u2019re pulling parts for time-sensitive orders, like emergency filter replacements for a hospital\u2019s HVAC system. That\u2019s when we added parallel filtering to our toolkit, leveraging Go\u2019s built-in concurrency to split the work across multiple goroutines.<\/p>\n
Parallel filtering works by splitting the original slice into chunks, filtering each chunk at the same time, then combining the results. Here\u2019s a simplified version of the function we use:<\/p>\n
func ParallelFilter[T any](list []T, condition func(T) bool, chunkSize int) []T {\n    \/\/ If the list is small, just use the basic filter to avoid overhead\n    if len(list) <= chunkSize {\n        return Filter(list, condition)\n    }\n\n    \/\/ Split the list into chunks\n    chunks := make([][]T, 0, (len(list)+chunkSize-1)\/chunkSize)\n    for i := 0; i < len(list); i += chunkSize {\n        end := i + chunkSize\n        if end > len(list) {\n            end = len(list)\n        }\n        chunks = append(chunks, list[i:end])\n    }\n\n    \/\/ Filter each chunk in parallel\n    var results [][]T\n    sem := make(chan struct{}, runtime.NumCPU()) \/\/ Limit to number of CPU cores to avoid overloading\n    var wg sync.WaitGroup\n\n    for _, chunk := range chunks {\n        sem <- struct{}{}\n        wg.Add(1)\n        go func(c []T) {\n            defer wg.Done()\n            chunkResult := Filter(c, condition)\n            results = append(results, chunkResult)\n            <-sem\n        }(chunk)\n    }\n\n    wg.Wait()\n\n    \/\/ Combine all results into a single slice\n    var filtered []T\n    for _, res := range results {\n        filtered = append(filtered, res...)\n    }\n\n    return filtered\n}\n<\/code><\/pre>\n
We set the chunk size to 1,000 and limit goroutines to the number of CPU cores on our servers, so we don\u2019t use more memory than necessary. The result? Filtering 50,000 parts now takes less than 200 milliseconds\u2014fast enough for our team to get parts to clients same-day, even for emergency requests.<\/p>\n
This is similar to how we handle large orders for our industrial clients: we split the order picking list across multiple warehouse teams (the goroutines), each picking a portion, then combine the picks to get the order out fast. The logic applies to both software and our core business\u2014working smarter, not harder, when dealing with large sets of data or inventory.<\/p>\n
Common Pitfalls We Avoided (The Hard Way)<\/h3>\n
Over the years, we\u2019ve messed up a few filtering approaches, so let\u2019s share what we learned so you don\u2019t make the same mistakes.<\/p>\n
First, ignoring data type consistency<\/strong>. Early on, we had a filter condition that checked p.Type == "hepa"<\/code> (lowercase) instead of "HEPA"<\/code> (uppercase), and we missed 20% of our HEPA filters. That\u2019s like a warehouse worker writing down "hepa" on a pick list instead of the part code, and ending up with the wrong filters for a client. Always make sure your conditions match the data exactly\u2014add logging if you\u2019re filtering strings to catch typos or formatting differences.<\/p>\n
Second, using filtering for operations that don\u2019t need it<\/strong>. Don\u2019t filter a list if you just need a single item\u2014use Find()<\/code> instead, which stops iterating as soon as it finds a match. For example, if you need the ID for a specific filter part, there\u2019s no reason to iterate through the entire list and keep all matching items. It\u2019s the difference between picking one specific filter element from a shelf versus dumping the whole box on the table to sift through.<\/p>\n
Third, over-optimizing too early<\/strong>. We spent months trying to make our parallel filter even faster, only to realize that 90% of our filters are on small lists, and the generic function works perfectly. Don\u2019t add concurrency until you actually need it\u2014premature optimization leads to messy, hard-to-debug code, just like buying a high-end industrial filter for a small office that only needs a basic air filter.<\/p>\n
How This Ties Back to Who We Are<\/h3>\n
At the end of the day, filtering in Go is just like designing and manufacturing the filters we sell: it\u2019s about precision, flexibility, and meeting the exact needs of the user. When we build a HEPA filter for a hospital, it\u2019s not a one-size-fits-all part\u2014we design it to fit their specific HVAC system, meet their air quality standards, and work reliably even during peak demand. When we build a filter function in Go, it\u2019s not just code\u2014it\u2019s built to fit our data, adapt as our business grows, and work when we need it most.<\/p>\n
<\/p>\n
If you\u2019re someone who needs reliable, high-performance filters for your operations, whether that\u2019s industrial filtration systems, water treatment components, or air quality solutions, we\u2019ve got you covered. Our team works closely with clients to customize filters for their specific needs, just like how we customize our Go filtering functions for our internal tools.<\/p>\n
Filtration Equipment<\/a> If you\u2019re looking to upgrade your filtration systems or need reliable parts for your projects, we\u2019d love to chat. Reach out to our team to discuss your requirements, and we\u2019ll help you find the right solutions for your business.<\/p>\n
References<\/h3>\n
    \n
  1. Go 1.18 Release Notes: Generics. The Go Programming Language, 2022.<\/li>\n
  2. Donovan, A. A. A., & Kernighan, B. W. The Go Programming Language. Addison-Wesley, 2015.<\/li>\n
  3. Go sync Package Documentation: Goroutines and Channels. The Go Programming Language, n.d.<\/li>\n
  4. Effective Go: Common Mistakes and Best Practices. The Go Programming Language, n.d.<\/li>\n<\/ol>\n
    \n
    Xinxiang Deshengwei Filtration and Purification Equipment Co., Ltd.<\/a>
    As one of the most experienced filter suppliers in China, we also support customized service. We warmly welcome you to buy bulk high quality filter made in China here from our factory. If you have any enquiry about cooperation, please feel free to email us.
    Address: No.5 Daoqing Road, Hongqi District, Xinxiang City, Henan Province, China.
    E-mail: rushufeng@dswgl.com
    WebSite:     https:\/\/www.dswfiltration.com\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
    If you\u2019ve ever spent time sifting through messy, unstructured data to pull out exactly what you … How to filter a list in Go?<\/span>Read more<\/a><\/p>\n","protected":false},"author":910,"featured_media":3375,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[3338],"class_list":["post-3375","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-industry","tag-filter-4cf6-672a2b"],"_links":{"self":[{"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/posts\/3375","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/users\/910"}],"replies":[{"embeddable":true,"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/comments?post=3375"}],"version-history":[{"count":0,"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/posts\/3375\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/posts\/3375"}],"wp:attachment":[{"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/media?parent=3375"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/categories?post=3375"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.globalreach-sbi.com\/blog\/wp-json\/wp\/v2\/tags?post=3375"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}