DEV Community: Shubham Chadokar

The fastest way to concatenate strings in Golang

Shubham Chadokar — Tue, 30 Apr 2024 16:43:36 +0000

As a developer, we should be aware of all the available ways to implement a solution. This gives us the edge to implement a solution as per the needs.

In this short tutorial, you will learn multiple ways to concatenate a string and which is the fastest.

We will add benchmark testing, to analyse the performance of the function. The results may vary for you due to the machine.

Using Plus (+) Operator

The plus operator is not only used for integers and float but it can be used to concatenate strings, provided the operants are of string type.

// file: main.go
package main

import "fmt"

func main() {
    fmt.Println(plusOperator())
}

func plusOperator() string {
    s1 := "practice"
    s2 := "go"

    return (s1 + s2)
}

Benchmark Test

// file: main_test.go
package main

import "testing"

func BenchmarkPlusOperator(b *testing.B) {
    for i := 0; i < b.N; i++ {
        plusOperator()
    }
}

Output

~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkPlusOperator-11     118339720            10.23 ns/op
PASS
ok

Using Append (+=) Operator

The append operator appends one string to another.

// file: main.go
package main

func main {
...

func appendOperator() string {
    s1 := "practice"
    s2 := "go"

    s1 += s2
    return s2
}

Benchmark Test

// file: main_test.go
package main

import "testing"

func BenchmarkAppendOperator(b *testing.B) {
    for i := 0; i < b.N; i++ {
        appendOperator()
    }
}

Output

~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkAppendOperator-11   64080028             17.60 ns/op
PASS
ok

Using Sprintf function

The fmt.Sprintf function is available in fmt package. This should be only used when you have to format a string of different data types or in a certain format.

// file: main.go
package main

func main() {
...

func sprintf() string {
    s1 := "practice"
    s2 := "go"

    return fmt.Sprintf("%s%s", s1, s2)
}

Benchmark Test

// file: main_test.go
package main

import "testing"

func BenchmarkSprintfOperator(b *testing.B) {
    for i := 0; i < b.N; i++ {
        sprintf()
    }
}

Output

~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkSprintfOperator-11     16939860          70.79 ns/op
PASS
ok

Using strings.Builder

The strings.Builder method appends the bytes of s1 and s2 strings to the str bytes.

// file: main.go
package main

func main() {
...

func stringBuilder() string {
    s1 := "practice"
    s2 := "go"

    var str strings.Builder
    str.WriteString(s1)
    str.WriteString(s2)

    return str.String()
}

Benchmark Test

// file: main_test.go
package main

import "testing"

func BenchmarkStringsBuilderOperator(b *testing.B) {
    for i := 0; i < b.N; i++ {
        stringsBuilder()
    }
}

Output

~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkStringsBuilderOperator-11   42873091    26.40 ns/op
PASS
ok

Final Test

Lets run all the benchmark tests together.

Output

BenchmarkPlusOperator-11                115559880 10.13 ns/op
BenchmarkAppendOperator-11              62112871  17.74 ns/op
BenchmarkSprintfOperator-11             16762341  72.46 ns/op
BenchmarkStringsBuilderOperator-11      45078675  26.17 ns/op

Conclusion

The + operator is the fastest way to concatenate strings and fmt.Sprintf is the slowest.

  <----------------Fastest--------------------
  +  >  +=  >  strings.Builder  >  fmt.Sprintf
  ----------------Slowest-------------------->

You can also watch this tutorial

You can connect with me at:
Dev.to
YouTube Channel
Personal Blog
Linkedin
Twitter

Read and Write files in Golang

Shubham Chadokar — Sat, 27 Apr 2024 17:01:48 +0000

In this tutorial, we will learn how to read, write, and append to a file using Golang.

The built-in os package provides reading and writing files. Earlier it used to be handled by io/ioutil package.

A file must have correct file permissions to perform respective operations.

Following are the file modes(permissions) codes that we will need in the tutorial.



0000     no permissions
0700     read, write, & execute only for the owner
0770     read, write, & execute for owner and group
0777     read, write, & execute for owner, group and others
0111     execute
0222     write
0333     write & execute
0444     read
0555     read & execute
0666     read & write
0740     owner can read, write, & execute; group can only read; others have no permissions

You can also watch this tutorial on YouTube.

youtube.com

Write file in golang

The os.Writefile function accepts the filename or full path with extension if any, data or content in []byte format and file permission code.

Syntax



func WriteFile(name string, data []byte, perm os.FileMode) error

The below code will create a new file if it doesn't exist and write or it will override with new content to the existing file.
The 0777 file mode gives read, write and execution permission.
The data is a string converted to []byte format.



package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    data := []byte("dev.to")
    err := os.WriteFile("test.txt", data, 0777)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("file written successfully.")
}

Read file in golang

The os.ReadFile function accepts the filename or full file path and returns []byte and error.

It will throw an error if the file doesn't exist or the file doesn't have permission to read.

Syntax



func ReadFile(name string) ([]byte, error)



package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    data, err := os.ReadFile("test.txt")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(data))
}

Append to an existing file

There are 2 ways you can append content to an existing file.

1. Read and Write

In this approach, first read the file, append the content and then write the file.



package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    data, err := os.ReadFile("test.txt")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(data))

    msg := []byte("\nappended message")

    data = append(data, msg...)

    err = os.WriteFile("test.txt", data, 0777)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("file written successfully.")
}

2. Open and write

In this approach, first, open the file with the O_APPEND flag then write the content and close the file.



package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    file, err := os.OpenFile("test.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0777)
    if err != nil {
        log.Fatal(err)
    }

    defer file.Close()

    msg := []byte("\n another appended message")
    _, err = file.Write(msg)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("file appended successfully.")
}

os.O_APPEND - File permission append
os.O_CREATE - Create a new file if it doesn't exist
os.O_WRONLY - Write only

I hope you like this tutorial.
Happy Coding. Please Follow and Subscribe to YouTube.

Best tool to write a technical ebook

Shubham Chadokar — Fri, 05 Jun 2020 06:06:53 +0000

Photo by RetroSupply on Unsplash

What are best tools or editor available to write a technical eBook?
I recently wrote a tech eBook and struggled a lot to find a good editor. In the end, I used the VS Code with some markdown plugin. I wrote the eBook in md format. The result was good but when I was converting it to PDF or ePub format it was bad. Then I used Typora to convert it to PDF format, the result is good compared to VS Code plugin. But it is good only for PDF. Check here.

This question is basically focused for Windows and Linux user.

I am using Pandoc. I am struggling to converting it to epub or other format with proper formatting. Which tool or editor should i use to do this?

For the Mac OS Bear is a great editor.

Is there any other format than markdown, in which code writing is easy as in md?

Please give your suggestions on this.

Please include your approach, what tools you would use to write a tech ebook. 😃

My First eBook

Shubham Chadokar — Mon, 01 Jun 2020 05:27:52 +0000

Hello Everyone,

I like to share, during this covid19 pandemic, I wrote my first eBook 📘. The journey to write the book was awesome. I learned a lot from this like what should be the approach, order of content etc.

I am in the middle of writing the complete article on how I wrote an eBook. I'll include all the tools and approaches I used and yes as it was my first attempt so lots of dos n don'ts 😉.

For now, please have a look on it. It's topic is Playtime with Hyperledger Composer. It is free and available in PDF format.

Link to eBook

It is unfortunate that it deprecated but I still believe, it is a great tool for students to build a project on Blockchain.

I would love to hear your valuable feedback.

Thanks for your time.

Shubham Chadokar
schadokar.dev

Convert String to Int and Int to String in Golang

Shubham Chadokar — Sat, 28 Mar 2020 07:11:01 +0000

Golang standard library has provided 2 functions Atoi and Itoa to convert string to int and int to string respectively.

Originally published on schadokar.dev

These 2 functions placed inside the strconv package.

Package strconv implements conversions to and from string representations of basic data types.

String to Int

The strconv.Atoi function takes a string and returns an int and an error.

func Atoi(s string) (int, error)

It will return type int and type int is system dependent. It is 32 bits on the 32-bit system and 64 bits on the 64-bit system.

💡 Use the term ASCII to Int to remember the func name.

package main

import (
    "fmt"
    "strconv"
)

func main() {

    str := "1234"

    i, err := strconv.Atoi(str)

    if err != nil {
        fmt.Println(err)
    }

    fmt.Printf("Type: %T, Value: %v\n", i, i)

    // convert int to int64
    i64 := int64(i)
    fmt.Printf("Type: %T, Value: %v", i64, i64)
}

Output

Type: int, Value: 1234
Type: int64, Value: 1234

Int to String

The strconv.Itoa takes int as an argument and returns the string.

func Itoa(i int) string

Example:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num := 322020

    str := strconv.Itoa(num)

    fmt.Printf("Type: %T, Value: %v", str, str)
}

Output

Type: string, Value: 322020

Building an offline To-Do App with React

Shubham Chadokar — Wed, 04 Mar 2020 04:25:47 +0000

In this tutorial, we will create a to-do list app in reactjs. We will use browser local storage to save the tasks, which will keep the tasks even after we close the browser. In the end, we will host this application on Github pages.

The complete tutorial is originally published on codesource.io.

How to use Swapper in Golang?

Shubham Chadokar — Tue, 03 Mar 2020 14:41:31 +0000

Swapper is a function defined in the reflect package. This function takes a slice and returns a swap function. This swap function takes 2 indexes as arguments and swaps the values at index position in the slice.

Originally published on schadokar.dev

Function Definition

func Swapper(slice interface{}) func(i, j int)

Let's try

package main

import (
    "fmt"
    "reflect"
)

func main() {
    s := []int{1, 2, 3}
    fmt.Printf("Before swap: %v\n", s)

    swapF := reflect.Swapper(s)

    swapF(0, 1)

    fmt.Printf("After 1 swap: %v\n", s)

    swapF(0, 2)

    fmt.Printf("After 2 swap: %v\n", s)
}

Try it

Output

Before swap: [1 2 3]
After 1 swap: [2 1 3]
After 2 swap: [3 1 2]

Swapper panics if the provided interface is not a slice.

panic: reflect: call of Swapper on <Type> Value

Reverse a slice using Swapper

Swap first element with last element, the second element with second last and so on.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    s := []int{1, 2, 3, 4, 5, 6, 7}

    fmt.Printf("Before swap: %v\n", s)

    swapF := reflect.Swapper(s)

    for i := 0; i < len(s)/2; i++ {
        swapF(i, len(s)-1-i)
    }

    fmt.Printf("After swap: %v\n", s)
}

Try it

Output

Before swap: [1 2 3 4 5 6 7]
After swap: [7 6 5 4 3 2 1]

Use Swapper in Bubble sort

package main

import (
    "fmt"
    "reflect"
)

func main() {
    s := []int{1, 2, 6, 3, 8, 0, 7, 9, 5, 4}

    fmt.Printf("Before swapper: %v\n", s)

    swapF := reflect.Swapper(s)

    for i := 0; i < len(s)-1; i++ {
        for j := i + 1; j < len(s); j++ {
            if s[i] > s[j] {
                swapF(i, j)
            }
        }
    }

    fmt.Printf("After swapper: %v\n", s)
}

Output

Before swapper: [1 2 6 3 8 0 7 9 5 4]
After swapper: [0 1 2 3 4 5 6 7 8 9]

Build a CRUD application in Golang with PostgreSQL

Shubham Chadokar — Mon, 02 Mar 2020 10:55:24 +0000

The tutorial is published on codesource.io

How to join multiple strings in golang?

Shubham Chadokar — Fri, 28 Feb 2020 04:35:55 +0000

There are multiple ways to join or concat strings in the golang.

Let's start with the easy one.

Originally published at https://schadokar.dev.

Using the + operator 🔧

package main

import (
    "fmt"
)

func main() {
    str1 := "Hello"
    // there is a space before World
    str2 := " World!"

    fmt.Println(str1 + str2)
}

Output

Hello World!

Using Sprint, Sprintf, Sprintln 🛠

The fmt package has Sprint, Sprintf and Sprintln function which can format the strings using the default or custom formats.

All the Sprint function are variadic functions.

Variadic functions can be called with any number of trailing arguments.

Sprint

Sprint formats using the default formats and returns the resulting string.

Sprint accepts an empty interface. It means it can take n elements of any type.

If no element of type string is passed then the resulting string will add a Space between the elements.

package main

import (
    "fmt"
)

func main() {
    num := 26

    str := "Feb"

    boolean := true

    withStr := fmt.Sprint(num, str, boolean)

    fmt.Println("With string: ", withStr)

    withOutStr := fmt.Sprint(num, boolean)

    fmt.Println("Without string: ", withOutStr)
}

Output

With string:  26Febtrue
Without string:  26 true

Sprintf

Sprintf formats according to a format specifier and returns the resulting string.

Format Specifiers

%v  the value in a default format
%s  the uninterpreted bytes of the string or slice

Check all the available format specifier in the fmt package.

You can use the Sprintf function to create the connection string of the DB.

For example we will create a Postgres Connection URL.

Connection URL format: postgres://username:password@hostname/databasename

package main

import (
    "fmt"
)

func main() {

    dbname := "testdb"

    username := "admin"

    password := "test1234"

    hostname := "localhost"

    connectionURL := fmt.Sprintf("postgres://%s:%s@%v/%v", username, password, hostname, dbname)

    fmt.Println(connectionURL)
}

Output

postgres://admin:test1234@localhost/testdb

Sprintln

Sprintln formats the elements or arguments using the default formats. Spaces are added between the elements and a new line is added in the end.

package main

import (
    "fmt"
)

func main() {

    str1 := "Hello"
    str2 := "Gophers!"

    msg := fmt.Sprintln(str1, str2)

    fmt.Println(msg)
}

Output

Hello Gophers!

Using the Join function 🔩

The golang standard library has provided a Join function in the strings package.

The Join function takes an array of strings and a separator to join them.

func Join(elems []string, sep string) string

The example has an array of weekdays. The Join function will return a string of weekdays separated by ,.

Using Join you can convert an array of string to a string.

package main

import (
    "fmt"
    "strings"
)

func main() {
    weekdays := []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"}
    // there is a space after comma
    fmt.Println(strings.Join(weekdays, ", "))
}

Output

Monday, Tuesday, Wednesday, Thursday, Friday

Store Hyperledger Fabric certificates and keys in CouchDB

Shubham Chadokar — Sun, 09 Feb 2020 07:05:17 +0000

Photo by Micah Williams on Unsplash

Hyperledger Fabric is all about permissions. These permissions are provided in the form of certificates and keys. In broad term, it is known as Identities.

Originally published at https://schadokar.dev.

When an application interacts with the Hyperledger Fabric Network, it uses this identity to authenticate itself. Fabric network validates the identity and authorizes the application to interact.

In short, identities are very important and if you don't save them properly, then it may turn into a headache. 😩

Where can I store the Identities? 💼

In Hyperledger Fabric, this storage is known as Wallet.

There are three types of wallet:

File System: This is a simple folder. A local storage wallet. It is a good default choice for wallets. In fabric-samples/balance-transfer, the file system is the default wallet. When you run the balance-transfer it creates a fabric-client-kv-orgName folder and saves all the identities in it. This configuration is defined in the orgname.yaml link.
In-Memory: A wallet in application storage. Use this type of wallet when your application is running in a constrained environment without access to a file system; typically a web browser. It’s worth remembering that this type of wallet is volatile; identities will be lost after the application ends normally or crashes. - Documentation
CouchDB: Using couchdb as a wallet. This option is best for production.

In this tutorial, we will configure the CouchDB as the Wallet. 👨🏻‍💻

For the demonstration, I am using Fabric Node SDK and fabric/samples/balance-transfer.

The wallet uses 2 stores to save the certificates and keys:

1. State Store:

The state store is used to store the certificates of the enrolled identity. It stores the basic information of the identity:

{
  "name": "test",
  "mspid": "org1",
  "roles": null,
  "affiliation": "",
  "enrollmentSecret": "<ENROLLMENT_SECRET>",
  "enrollment": {
    "signingIdentity": "<PRIVATE_KEY_NAME>",
    "identity": {
      "certificate": "<SIGN_CERT>"
    }
  }
}

❗️ Note: The signingIdentity is the pointer or the address of the private and public key stored in the crypto-store.

2. Crypto Store:

The crypto store is used to store the public and private key of the identity.

To configure the couchdb as wallet:

Step 1

Import the CouchDBKeyValueStore library, which is provided by the Node SDK.

const CDBKVS = require("fabric-client/lib/impl/CouchDBKeyValueStore.js");

Do read the CouchDBKeyValueStore.js it is worth reading.

Step 2

Set the state store.

let stateStore = await new CDBKVS({
  url: "https://<USERNAME>:<PASSWORD>@<URL>",
  name: "<DB_NAME>"
});

const Client = require("fabric-client");

const client = Client.loadFromConfig("path of network.yaml");

client.setStateStore(stateStore);

<USERNAME> is the username of the couchdb.
<PASSWORD> is the password of the couchdb.
<URL> is the couchdb URL.
<DB_NAME> (OPTIONAL) is the dbname to use as state store. The default dbname is userdb. It creates the DB if it doesn't exist.

Client is the interface between the user and the fabric network.

Step 3

Set the crypto store.

const cryptoSuite = Client.newCryptoSuite();

let cryptoKS = Client.newCryptoKeyStore(CDBKVS, {
  url: "https://<USERNAME>:<PASSWORD>@<URL>",
  name: "<DB_NAME>"
});

cryptoSuite.setCryptoKeyStore(cryptoKS);

client.setCryptoSuite(cryptoSuite);

You have to update the client according to the above steps to make it use the couchdb.

In the next section, we'll implement the above steps in the balance-transfer fabric sample.

Implementation of CouchDB in Balance Transfer

I am using the balance transfer fabric sample as a reference.

I am assuming that you know how to run the balance transfer.

Start the balance transfer network

Follow the balance transfer instructions to start the network.

It will start the network with:

2 CAs
A SOLO Orderer
4 peers (2 peers per Org)

Start a couchdb for the wallet

This step is optional if you're using the cloud based couchdb.

Docker-based Couchdb

docker run --name couch-userdb -e COUCHDB_USER=admin -e COUCHDB_PASSWORD=password -p 5984:5984 -d couchdb

Above command will pull the docker image of the couchdb from the docker hub if it doesn't exist.

CouchDB Details:

Container Name: couch-userdb
CouchDB Username: admin
CouchDB Password: password
URL: localhost:5984

The CouchDB connection URL is

https://<USERNAME>:<PASSWORD>@<URL>

https://admin:password@localhost:5984

Update the client in the balance-transfer

Open the app/helper.js and update the getClientForOrg.

In the below code, we just replaced await client.initCredentialStores(); with the above couchdb config steps.

The changes we made,

Line 13: Import the CouchDBKeyValueStore. Step 1 from above.
Line 31-52: Set the state store and crypto store. Step 2 & 3.

There is a minor change in the above code.

// Client variable is used as hfc
var hfc = require("fabric-client");

// Instead of Client
const Client = require("fabric-client");

It is not necessary that db(dbname) of state store and crypto store is the same. Both the stores can have their separate dbs. It depends on the requirement. You can have state store and crypto store db as orgName-state-store and orgName-crypto-store respectively.

Each organization must have their state-store and crypto-store db, else it will throw the Authentication Error.

Error: fabric-ca request register failed with errors [[{"code":20,"message":"Authentication failure"}]]

Register a new user in the balance transfer

Once you register a user, you can check the state-store and crypto-store using the couchdb apis.

For Example: Register a user

I used the below arguments to register a user. For org1, I used the same db org1db for both state-store and crypto-store.

Name: alice
Org: org1
DBNAME: org1db
CouchDB URL: http://admin:password@localhost:5369

Open the browser, go to http://localhost:5369/org1db/_all_docs. It returns all the docs saved in the org1db.

The indexes 0, 1, 2 are the certificates of the admin.

The index 3 is the alice certificate stored in the state-store.

The indexes 4-5 are the alice's public and private keys stored in the crypto-store.

Go to http://localhost:5369/org1db/alice.
It returns all the details of the alice stored in the state store.

Check the signingIdentity.

"signingIdentity":"d37a97a8c2377c21537801ec1a929d81905ae57963a2f6c8ba0308931a7fc791"

Now, check the id of the indexes 4 & 5 in the above image. Both are same.

If you remember, signingIdentity field is a reference of the private and public keys of the identity stored in the crypto store.

Conclusion

CouchDB wallet is a great choice for a production use case. You can try with other dbs but in that case, you have to write the library accordingly like CouchDBKeyValueStore.js.

Below are the references I found helpful.

If you find any resource which you think can be added here, don't feel shy to share. 😉

References 📌

Use Environment Variable in your next Golang Project

Shubham Chadokar — Thu, 16 Jan 2020 14:23:47 +0000

When it comes to creating a production-grade application, using the environment variable in the application is de facto.

This post was originally posted on my personal blog 🖊️ schadokar.dev.

Why should we use the environment variable?

Suppose you have an application with many features and each feature need to access the Database. You configured all the DB information like DBURL, DBNAME, USERNAME and PASSWORD in each feature.

There are a few major disadvantages to this approach, there can be many.

Security Issue:
- You're entering all the information in the code. Now, all the unauthorized person also have access to the DB.
- If you're using code versioning tool like git then the details of your DB will go public once you push the code.
Code Management:
- If you are changing a single variable then you have to change in all the features. There is a high possibility that you'll miss one or two. 😌 been there
- You can categorize the environment variables like PROD, DEV, or TEST. Just prefix the variable with the environment.

In the start, it might look like some extra work, but this will reward you a lot in your project.

⚠️ Just don't forget to include your environment files in the .gitignore.⚠️

It is time for some action. 🔨

What are we going to do in this tutorial?

In this tutorial, we will access environment variables in 3 different ways.

You can use according to your requirement.

os package
godotenv package
viper package

Create a Project

Create a project go-env-ways outside the $GOPATH.

Initialize the module

Open the terminal inside the project root directory, and run the below command.

go mod init go-env-ways

This module will keep a record of all the packages and their version used in the project. It is similar to package.json in nodejs.

Let's start with the easiest one, using os package.

os Package

Golang provides os package, an easy way to configure and access the environment variable.

To set the environment variable,

os.Setenv(key, value)

To get the environment variable,

value := os.Getenv(key)

Create a new file main.go inside the project.

package main

import (
  "fmt"
  "os"
)

// use os package to get the env variable which is already set
func envVariable(key string) string {

  // set env variable using os package
  os.Setenv(key, "gopher")

  // return the env variable using os package
  return os.Getenv(key)
}

func main() {
    // os package
  value := envVariable("name")

  fmt.Printf("os package: %s = %s \n", "name", value)
}

Run the below command to check.

go run main.go

// Output
os package: name = gopher

GoDotEnv Package

The easiest way to load the .env file is using godotenv package.

Install

Open the terminal in the project root directory.

go get github.com/joho/godotenv

// Load the .env file in the current directory
godotenv.Load()

// or

godotenv.Load(".env")

Load method can load multiple env files at once. This also supports yaml. For more information check out the documentation.

Create a new .env file in the project root directory.

STRONGEST_AVENGER=Thor

Update the main.go.

package main

import (

    ...
    // Import godotenv
  "github.com/joho/godotenv"
)


// use godot package to load/read the .env file and
// return the value of the key
func goDotEnvVariable(key string) string {

  // load .env file
  err := godotenv.Load(".env")

  if err != nil {
    log.Fatalf("Error loading .env file")
  }

  return os.Getenv(key)
}

func main() {
    // os package
    ... 

  // godotenv package
  dotenv := goDotEnvVariable("STRONGEST_AVENGER")

  fmt.Printf("godotenv : %s = %s \n", "STRONGEST_AVENGER", dotenv)
}

Open the terminal and run the main.go.

go run main.go

// Output
os package: name = gopher

godotenv : STRONGEST_AVENGER = Thor

Just add the code at the end of the os package in the main function.

Viper Package

Viper is one of the most popular packages in the golang community. Many Go projects are built using Viper including Hugo, Docker Notary, Mercury.

Viper is a complete configuration solution for Go applications including 12-Factor apps. It is designed to work within an application and can handle all types of configuration needs and formats. Reading from JSON, TOML, YAML, HCL, envfile and Java properties config files

For more information read the official documentation of viper

Install

Open the terminal in the project root directory.

go get github.com/spf13/viper

To set the config file and path

viper.SetConfigFile(".env")

To read the config file

viper.ReadInConfig()

To get the value from the config file using key

viper.Get(key)

Update the main.go.

import (
  "fmt"
  "log"
  "os"

  "github.com/joho/godotenv"
  "github.com/spf13/viper"
)

// use viper package to read .env file
// return the value of the key
func viperEnvVariable(key string) string {

  // SetConfigFile explicitly defines the path, name and extension of the config file.
  // Viper will use this and not check any of the config paths.
  // .env - It will search for the .env file in the current directory
  viper.SetConfigFile(".env")

  // Find and read the config file
  err := viper.ReadInConfig()

  if err != nil {
    log.Fatalf("Error while reading config file %s", err)
  }

  // viper.Get() returns an empty interface{}
  // to get the underlying type of the key,
  // we have to do the type assertion, we know the underlying value is string
  // if we type assert to other type it will throw an error
  value, ok := viper.Get(key).(string)

  // If the type is a string then ok will be true
  // ok will make sure the program not break
  if !ok {
    log.Fatalf("Invalid type assertion")
  }

  return value
}

func main() {

    // os package  
    ...

  // godotenv package
  ...

  // viper package read .env
  viperenv := viperEnvVariable("STRONGEST_AVENGER")

  fmt.Printf("viper : %s = %s \n", "STRONGEST_AVENGER", viperenv)
}

Open the terminal and run the main.go.

go run main.go

// Output
os package: name = gopher

godotenv : STRONGEST_AVENGER = Thor

viper : STRONGEST_AVENGER = Thor

Viper is not limited to .env files.

It supports:

setting defaults
reading from JSON, TOML, YAML, HCL, envfile and Java properties config files
live watching and re-reading of config files (optional)
reading from environment variables
reading from remote config systems (etcd or Consul), and watching changes
reading from command line flags
reading from buffer
setting explicit values

Viper can be thought of as a registry for all of your applications configuration needs.

Let's experiment: 💣

Create a new config.yaml file in the project root directory.

I_AM_INEVITABLE: "I am Iron Man"

To set the config filename

viper.SetConfigName("config")

To set the config file path

// Look in the current working directory
viper.AddConfigPath(".")

To read the config file

viper.ReadInConfig()

Update the main.go

// use viper package to load/read the config file or .env file and
// return the value of the key
func viperConfigVariable(key string) string {

  // name of config file (without extension)
  viper.SetConfigName("config")
  // look for config in the working directory
  viper.AddConfigPath(".")

  // Find and read the config file
  err := viper.ReadInConfig()

  if err != nil {
    log.Fatalf("Error while reading config file %s", err)
  }

  // viper.Get() returns an empty interface{}
  // to get the underlying type of the key,
  // we have to do the type assertion, we know the underlying value is string
  // if we type assert to other type it will throw an error
  value, ok := viper.Get(key).(string)

  // If the type is a string then ok will be true
  // ok will make sure the program not break
  if !ok {
    log.Fatalf("Invalid type assertion")
  }

  return value
}

func main() {

  // os package
  ...

  // godotenv package
  ...

  // viper package read .env
  ...

  // viper package read config file
  viperconfig := viperConfigVariable("I_AM_INEVITABLE")  

  fmt.Printf("viper config : %s = %s \n", "I_AM_INEVITABLE", viperconfig)  
}

Open the terminal and run the main.go

go run main.go

// Output
os package: name = gopher

godotenv : STRONGEST_AVENGER = Thor

viper : STRONGEST_AVENGER = Thor

viper config : I_AM_INEVITABLE = I am Iron Man

Conclusion

That's it, now you can explore more of their secrets. If you find something worth sharing don't hesitate.

The complete code is available in the github.

How to create a CLI in golang with cobra

Shubham Chadokar — Tue, 07 Jan 2020 08:38:40 +0000

Ever wanted to create your own cli.

Check out my article published on Medium.

Article Link

Shubham Chadokar

DEV Community: Shubham Chadokar

The fastest way to concatenate strings in Golang

Using Plus (+) Operator

Benchmark Test

Using Append (+=) Operator

Benchmark Test

Using Sprintf function

Benchmark Test

Using strings.Builder

Benchmark Test

Final Test

Conclusion

Read and Write files in Golang

Write file in golang

Syntax

Read file in golang

Syntax

Append to an existing file

1. Read and Write

2. Open and write

Best tool to write a technical ebook

My First eBook

Convert String to Int and Int to String in Golang

String to Int

Int to String

Building an offline To-Do App with React

How to use Swapper in Golang?

Function Definition

Reverse a slice using Swapper

Use Swapper in Bubble sort

Build a CRUD application in Golang with PostgreSQL

How to join multiple strings in golang?

Using the + operator 🔧

Using Sprint, Sprintf, Sprintln 🛠

Sprint

Sprintf

Sprintln

Using the Join function 🔩

Store Hyperledger Fabric certificates and keys in CouchDB

Where can I store the Identities? 💼

1. State Store:

2. Crypto Store:

Step 1

Step 2

Step 3

Implementation of CouchDB in Balance Transfer

Start the balance transfer network

Start a couchdb for the wallet

CouchDB Details:

Update the client in the balance-transfer

Register a new user in the balance transfer

For Example: Register a user

Conclusion

References 📌

Use Environment Variable in your next Golang Project

Why should we use the environment variable?

Security Issue:

Code Management:

What are we going to do in this tutorial?

Create a Project

Initialize the module

os Package

GoDotEnv Package

Install

Viper Package

Install

Viper is not limited to .env files.

Conclusion

How to create a CLI in golang with cobra