A Hash computes a seeded hash of a byte sequence.
The zero Hash is a valid Hash ready to use.
A zero Hash chooses a random seed for itself during
the first call to a Reset, Write, Seed, Sum64, or Seed method.
For control over the seed, use SetSeed.
The computed hash values depend only on the initial seed and
the sequence of bytes provided to the Hash object, not on the way
in which the bytes are provided. For example, the three sequences
h.WriteByte('f'); h.WriteByte('o'); h.WriteByte('o')
all have the same effect.
Hashes are intended to be collision-resistant, even for situations
where an adversary controls the byte sequences being hashed.
A Hash is not safe for concurrent use by multiple goroutines, but a Seed is.
If multiple goroutines must compute the same seeded hash,
each can declare its own Hash and call SetSeed with a common Seed.
BlockSize returns h's block size.
Reset discards all bytes added to h.
(The seed remains the same.)
Seed returns h's seed value.
SetSeed sets h to use seed, which must have been returned by MakeSeed
or by another Hash's Seed method.
Two Hash objects with the same seed behave identically.
Two Hash objects with different seeds will very likely behave differently.
Any bytes added to h before this call will be discarded.
Size returns h's hash value size, 8 bytes.
Sum appends the hash's current 64-bit value to b.
It exists for implementing hash.Hash.
For direct calls, it is more efficient to use Sum64.
Sum64 returns h's current 64-bit value, which depends on
h's seed and the sequence of bytes added to h since the
last call to Reset or SetSeed.
All bits of the Sum64 result are close to uniformly and
independently distributed, so it can be safely reduced
by using bit masking, shifting, or modular arithmetic.
Write adds b to the sequence of bytes hashed by h.
It always writes all of b and never fails; the count and error result are for implementing io.Writer.
WriteByte adds b to the sequence of bytes hashed by h.
It never fails; the error result is for implementing io.ByteWriter.
WriteString adds the bytes of s to the sequence of bytes hashed by h.
It always writes all of s and never fails; the count and error result are for implementing io.StringWriter.
*T : hash.Hash
*T : hash.Hash64
*T : io.ByteWriter
*T : io.StringWriter
*T : io.Writer
A Seed is a random value that selects the specific hash function
computed by a Hash. If two Hashes use the same Seeds, they
will compute the same hash values for any given input.
If two Hashes use different Seeds, they are very likely to compute
distinct hash values for any given input.
A Seed must be initialized by calling MakeSeed.
The zero seed is uninitialized and not valid for use with Hash's SetSeed method.
Each Seed value is local to a single process and cannot be serialized
or otherwise recreated in a different process.
func MakeSeed() Seed
func (*Hash).Seed() Seed
func (*Hash).SetSeed(seed Seed)
The pages are generated with Goldsv0.1.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project and developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.