diff --git a/README b/README index 90003fd..f6377ce 100644 --- a/README +++ b/README @@ -8,81 +8,83 @@ be saved to and loaded from a file (or any io.Reader/Writer) to recover from downtime quickly. == Installation - goinstall github.com/pmylund/go-cache + +goinstall github.com/pmylund/go-cache == Usage - import "github.com/pmylund/go-cache" - // Create a cache with a default expiration time of 5 minutes, and which - // purges expired items every 30 seconds - c := cache.New(5*time.Minute, 30*time.Second) +import "github.com/pmylund/go-cache" - // Set the value of the key "foo" to "bar", with the default expiration time - c.Set("foo", "bar", 0) +// Create a cache with a default expiration time of 5 minutes, and which +// purges expired items every 30 seconds +c := cache.New(5*time.Minute, 30*time.Second) - // Set the value of the key "baz" to "yes", with no expiration time - // (the item won't be removed until it is re-set, or removed using - // c.Delete("baz") - c.Set("baz", "yes", -1) +// Set the value of the key "foo" to "bar", with the default expiration time +c.Set("foo", "bar", 0) - // Get the string associated with the key "foo" from the cache - foo, found := c.Get("foo") - if found { - fmt.Println(foo) - } +// Set the value of the key "baz" to "yes", with no expiration time +// (the item won't be removed until it is re-set, or removed using +// c.Delete("baz") +c.Set("baz", "yes", -1) - // 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)) - } +// Get the string associated with the key "foo" from the cache +foo, found := c.Get("foo") +if found { + fmt.Println(foo) +} - // 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 +// 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)) +} - // Want performance? Store pointers! - c.Set("foo", &MyStruct, 0) - if x, found := c.Get("foo"); found { - foo := x.(*MyStruct) - ... - } +// 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 - // If you store a reference type like a pointer, slice, map or channel, you - // do not need to run Set if you modify the underlying data. The cached - // reference points to the same memory, so if you modify a struct whose - // pointer you've stored in the cache, retrieving that pointer with Get will - // point you to the same data: - foo := &MyStruct{Num: 1} - c.Set("foo", foo, 0) - ... - x, _ := c.Get("foo") - foo := x.(*MyStruct) - fmt.Println(foo.Num) - ... - foo.Num++ - ... - x, _ := c.Get("foo") - foo := x.(*MyStruct) - foo.Println(foo.Num) +// Want performance? Store pointers! +c.Set("foo", &MyStruct, 0) +if x, found := c.Get("foo"); found { + foo := x.(*MyStruct) + ... +} - // will print: - 1 - 2 +// If you store a reference type like a pointer, slice, map or channel, you +// do not need to run Set if you modify the underlying data. The cached +// reference points to the same memory, so if you modify a struct whose +// pointer you've stored in the cache, retrieving that pointer with Get will +// point you to the same data: +foo := &MyStruct{Num: 1} +c.Set("foo", foo, 0) +... +x, _ := c.Get("foo") +foo := x.(*MyStruct) +fmt.Println(foo.Num) +... +foo.Num++ +... +x, _ := c.Get("foo") +foo := x.(*MyStruct) +foo.Println(foo.Num) + +// will print: +1 +2 == Reference