Need help with go-cache?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

patrickmn
4.8K Stars 602 Forks MIT License 163 Commits 51 Opened issues

Description

An in-memory key:value store/cache (similar to Memcached) library for Go, suitable for single-machine applications.

Services available

!
?

Need anything else?

Contributors list

# 20,048
Shell
Haskell
nix
ghcjs
150 commits
# 49,084
Go
lambda
product...
gRPC
1 commit
# 255,686
Go
1 commit
# 15,253
C
Perl
Rails
tesla
1 commit
# 30,226
Go
swagger...
Kuberne...
elm
1 commit
# 67,672
Go
Shell
sns
sqs
1 commit
# 71,001
Go
Shell
golang
csrf
1 commit

go-cache

go-cache is an in-memory key:value store/cache similar to memcached that is suitable for applications running on a single machine. Its major advantage is that, being essentially a thread-safe

map[string]interface{}
with expiration times, it doesn't need to serialize or transmit its contents over the network.

Any object can be stored, for a given duration or forever, and the cache can be safely used by multiple goroutines.

Although go-cache isn't meant to be used as a persistent datastore, the entire cache can be saved to and loaded from a file (using

c.Items()
to retrieve the items map to serialize, and
NewFrom()
to create a cache from a deserialized one) to recover from downtime quickly. (See the docs for
NewFrom()
for caveats.)

Installation

go get github.com/patrickmn/go-cache

Usage

import (
    "fmt"
    "github.com/patrickmn/go-cache"
    "time"
)

func main() { // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 10 minutes c := cache.New(5time.Minute, 10time.Minute)

// Set the value of the key "foo" to "bar", with the default expiration time
c.Set("foo", "bar", cache.DefaultExpiration)

// Set the value of the key "baz" to 42, with no expiration time
// (the item won't be removed until it is re-set, or removed using
// c.Delete("baz")
c.Set("baz", 42, cache.NoExpiration)

// Get the string associated with the key "foo" from the cache
foo, found := c.Get("foo")
if found {
    fmt.Println(foo)
}

// Since Go is statically typed, and cache values can be anything, type
// assertion is needed when values are being passed to functions that don't
// take arbitrary types, (i.e. interface{}). The simplest way to do this for
// values which will only be used once--e.g. for passing to another
// function--is:
foo, found := c.Get("foo")
if found {
    MyFunction(foo.(string))
}

// This gets tedious if the value is used several times in the same function.
// You might do either of the following instead:
if x, found := c.Get("foo"); found {
    foo := x.(string)
    // ...
}
// or
var foo string
if x, found := c.Get("foo"); found {
    foo = x.(string)
}
// ...
// foo can then be passed around freely as a string

// Want performance? Store pointers!
c.Set("foo", &MyStruct, cache.DefaultExpiration)
if x, found := c.Get("foo"); found {
    foo := x.(*MyStruct)
        // ...
}

}

Reference

godoc
or http://godoc.org/github.com/patrickmn/go-cache

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.