Command line arguments in Go
In order to access the command line arguments passed to a Go executable, we work with the "flag" package from the standard Go library. Shown below is an example of passing command line arguments.
go run cla.go KrishnaOr if you have an executable obtained from go build, you can run it as
./cla KrishnaShown below is an example go snippet that accesses the first argument passed & prints it.
package main
import (
"fmt"
"flag"
)
func main() {
//Without the call to Parse(), arguments may not be accessed
flag.Parse()
fmt.Printf("%s\n",flag.Arg(0))
}
Notice that you will have to invoke the call to flag.Parse() without which you will not be able to access the arguments.Reflection support in Go
We take the previous example, add some code for reflection which will help us understand how reflection library may be used. Just some simple example without having to go deep. For that, read this post from the official Go blog.
So what is the type returned by flag.Arg(0) ? We will start from there and go use some functions.
So what is the type returned by flag.Arg(0) ? We will start from there and go use some functions.
package main
import (
"fmt" //regular format package
"flag" //package from command line arguments
"reflect" //package for reflection
)
func main() {
//Without the call to Parse(), arguments may not be accessed
flag.Parse()
fmt.Printf("%s\n",flag.Arg(0))
passed := flag.Arg(0)
//TypeOf actually returns a Type type
fmt.Println("typeof : ",reflect.TypeOf(passed))
//ValueOf actually returns a Value
fmt.Println("valueof : ",reflect.ValueOf(passed))
//Example functions from the Value type
fmt.Println("type: ",reflect.ValueOf(passed).Type())
fmt.Println("kind: ", reflect.ValueOf(passed).Kind())
fmt.Println("interface:", reflect.ValueOf(passed).Interface())
}
Big Integer & Set Bits
In the future post, I would like to implement a Bloom filter in Go but for that I will need to know how to do the following:
- Create a big number and set some bit "x" to 1 or 0.
- Accept a string, convert it to byte array, then hash the byte array.
To support the above, I wanted to see how simple big numbers would work. I am only looking enough to support my purpose.
Big Numbers (multi-precision numbers) are supported using "math/big" package in Go library. Shown below is an example code that does that.
package main import ( "fmt" "math/big"
"unsafe"
)
func main() {
//create a new big integer
filter := big.NewInt(0)
fmt.Println("filter value: ",filter)
//accessing the sizeof from unsafe package
fmt.Println("size of : ",unsafe.Sizeof(filter))
//example of how to cast uintptr to int
filter.SetBit(filter,int(unsafe.Sizeof(filter)*8)-1,1)
fmt.Println("filter after setbit last to 1 : ",filter)
}
The above example shows a few things:
- Creating an instance of big.Int using the NewInt() call.
- Accessing the size of the big.Int using unsafe package exported SizeOf() function
- SizeOf() returns uintptr and we convert that to integer - that is a good example of casting
- How to set bit on the big.Int using SetBit
Working with Hash functions
Example below demonstrates the following
- how to convert a string to a byte array
- how to use FNV Hash from the standard Go library
package main
import (
"fmt"
"hash/fnv"
)
func main() {
//Create a hash fnv function
hash := fnv.New32()
name := "Krishna"
//converting string to byte array
namebytes := []byte(name)
fmt.Println("hash reset : ",hash.Sum32())
hash.Write(namebytes)
fmt.Println("hash of Krishna : ",hash.Sum32())
hash.Reset() //resets the hash
fmt.Println("hash reset : ",hash.Sum32())
//write again
hash.Write(namebytes)
fmt.Println("hash of Krishna : ", hash.Sum32())
}
Hash libraries in the Go "hash" package implements the Hash interface. The implementations in the standard Go library as of this time are adler32, crc32, crc64, fnv-1/fnv-1a. The above example creates an instance of FNV hash, writes a byte array to it and then gets the value through Sum32() call. You can "forget" what is written to it by Reset() function which will allow you to reuse the hash instance.I am newly learning Go and along the way sharing some things that I learnt. If you know of a better way to accomplish what I have shared here, please feel free to comment.
