cache is LRU-based cache package written in vanilla Go - with no package dependency. LRU stands for Least Recently Used and it is one of the famous cache replacement algorithm. It replaces newly added data with the least recently used one.
- Written in Vanilla Go, with no dependencies.
- Safe for concurrent use.
- Supports any data type for keys and values.
- Supports time expiration.
go get github.com/gozeloglu/cache
Here, there is an example usage of the package.
You can import like this.
import "github.com/gozeloglu/cache"Then, you need to create a cache variable with New() function. It takes one parameter to specify cache capacity.
cache.Add("foo", "bar", 0) // Without expiration time
cache.Add("key", "value", time.Hour * 2) // With expiration timeval, found := cache.Get("foo")
if !found {
fmt.Println("key does not exist. val is nil.")
}
fmt.Println(val)keys := cache.Keys()
for _, k := range keys {
fmt.Println(k)
}found := cache.Contains("foo")
if found {
val, _ := cache.Peek("foo")
cache.Remove("foo")
}k, v, ok := cache.RemoveOldest()
if ok {
fmt.Printf("Oldest key-value pair removed: %s-%s", k, v)
}cache.Resize(20) // Capacity will be 20newItem, err := cache.UpdateVal("foo", "foobar") // Cache data order is also updated
if err != nil {
fmt.Printf("New item key and value is %s-%s", newItem.Key, newItem.Val)
}
newItem, err := c.UpdateExpirationDate("foo", time.Hour * 4) // Cache data order is also updated
if err != nil {
fmt.Printf("%v", newItem.Expiration)
}
err = c.Replace("foo", "fuzz") // Change value of the key without updating cache access order
if err != nil {
fmt.Printf(err.Error())
}You can run the tests with the following command.
go test .
You can get the code coverage information with the following command:
go test -coverIf you want to generate a graphical coverage report, you can run the following command:
go tool cover -html=coverage.outA browser tab will be opened and you will be able to see the graphical report. It shows not tracked, not covered, and covered line on the source code.