Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/efureev/cache
cache in memory
https://github.com/efureev/cache
cache memory
Last synced: about 6 hours ago
JSON representation
cache in memory
- Host: GitHub
- URL: https://github.com/efureev/cache
- Owner: efureev
- License: mit
- Created: 2018-05-25T07:06:04.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2019-09-19T10:02:34.000Z (about 5 years ago)
- Last Synced: 2024-06-21T03:03:20.781Z (5 months ago)
- Topics: cache, memory
- Language: Go
- Size: 18.6 KB
- Stars: 1
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://app.codacy.com/app/efureev/cache?utm_source=github.com&utm_medium=referral&utm_content=efureev/cache&utm_campaign=Badge_Grade_Dashboard)
[](https://travis-ci.org/efureev/cache)
[](https://codeclimate.com/github/efureev/cache/maintainability)
[](https://codeclimate.com/github/efureev/cache/test_coverage)
[](https://goreportcard.com/report/github.com/efureev/cache)
[](https://codecov.io/gh/efureev/cache)
# cache
cache is an in-memory key:value store/cache 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.
### Installation
`go get -u github.com/efureev/cache/v2`
### Usage
```go
package main
import (
"fmt"
"github.com/efureev/cache/v2"
"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(5*time.Minute, 10*time.Minute)
// Set the value of the key "foo" to "bar", with the default expiration time
c.Set("foo", "bar", cache.DefaultExpiration)
c.Set(333, "bar", cache.DefaultExpiration)
pnt = true
c.Set(&pnt, "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(333, 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(bar.(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)
// ...
}
}
```