Read a File with io/ioutil

package main

import (

// import os modules if filename pass as parameters

// ReadFile function open the file
func ReadFile() {

	fmt.Printf("\n\nReading a file with ioutil.ReadFile \n")
	// embedded filename into the source code but alternative it can be dynamic
	// by pass the filename as parameters/arguments during execution of program
	// using the OS modules and argv methods
	fileName := "sample.txt"
	// alternative solution here....
	// add import of os module or IDE automatically add for us
	// uncomment the line below and comment the above line.
	// fileNameViaArgv := os.Args[1]
	data, err := ioutil.ReadFile("sample.txt")
	// uncomment the line below and comment the above line using alternative solution
	// dataArgv, err := ioutil.ReadFile(fileNameViaArgv)
	if err != nil {
		log.Panicf("ioutil.ReadFile return nil when failed reading data from file: %s", err)
	fmt.Printf("\nFile Name: %s", fileName)
	fmt.Printf("\nSize: %d bytes", len(data))
	fmt.Printf("\nData: %s", data)
	// uncomment this if you using OS modules as alternative solution
	/* fmt.Printf("\nFile Name: %s", fileNameViaArgv)
	fmt.Printf("\nSize: %d bytes", len(dataArgv))
	fmt.Printf("\nData: %s", dataArgv) */

func main() {

// ReadFile reads the file named by filename and returns the contents.
// A successful call returns err == nil, not err == EOF. Because ReadFile
// reads the whole file, it does not treat an EOF from Read as an error
// to be reported.
func ReadFile(filename string) ([]byte, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, err
	defer f.Close()
	// It's a good but not certain bet that FileInfo will tell us exactly how much to
	// read, so let's try it but be prepared for the answer to be wrong.
	var n int64 = bytes.MinRead

	if fi, err := f.Stat(); err == nil {
		// As initial capacity for readAll, use Size + a little extra in case Size
		// is zero, and to avoid another allocation after Read has filled the
		// buffer. The readAll call will read into its allocated internal buffer
		// cheaply. If the size was wrong, we'll either waste some space off the end
		// or reallocate as needed, but in the overwhelmingly common case we'll get
		// it just right.
		if size := fi.Size() + bytes.MinRead; size > n {
			n = size
	return readAll(f, n)