golang type enum

Restu Wahyu Saputra answered on July 4, 2021 Popularity 6/10 Helpfulness 3/10

answer golang type enum

related enum in golang

related golang enum type

golang type enum

Comment

package main

import "fmt"

// using type
type RoleAllowed string

const (
	admin RoleAllowed = "admin"
	user  RoleAllowed = "user"
)

// using specific type data
const (
	supercar   string = "lamborgini"
	classiccar string = "camaro ss"
)

func main() {
    // access enum like this
	fmt.Println(classiccar)
}

Popularity 6/10 Helpfulness 3/10 Language go

Source: Grepper

Tags: go

Link to this answer
Share Copy Link

Contributed on Oct 27 2021

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

Closely Related Answers

enum in golang

Comment

type ByteSize float64

const (
	_           = iota // ignore first value by assigning to blank identifier
	KB ByteSize = 1 << (10 * iota)
	MB
	GB
	TB
	PB
	EB
	ZB
	YB
)

// String changes the default print
func (b ByteSize) String() string {
	switch {
	case b >= YB:
		return fmt.Sprintf("%.2fYB", b/YB)
	case b >= ZB:
		return fmt.Sprintf("%.2fZB", b/ZB)
	case b >= EB:
		return fmt.Sprintf("%.2fEB", b/EB)
	case b >= PB:
		return fmt.Sprintf("%.2fPB", b/PB)
	case b >= TB:
		return fmt.Sprintf("%.2fTB", b/TB)
	case b >= GB:
		return fmt.Sprintf("%.2fGB", b/GB)
	case b >= MB:
		return fmt.Sprintf("%.2fMB", b/MB)
	case b >= KB:
		return fmt.Sprintf("%.2fKB", b/KB)
	}
	return fmt.Sprintf("%.2fB", b)
}

func main() {
  fmt.Println(ByteSize(1e13))	// output: 9.09TB
}

/**
Constant and Enum in Golang:
	- They are created at compile time, even when defined as 
      locals in functions, and can only be numbers, 
      characters (runes), strings or booleans.
	- Because of the compile-time restriction, the expressions 
      that define them must be constant expressions, evaluatable
      by the compiler. For instance, 1<<3 is a constant expression,
      while math.Sin(math.Pi/4) is not because the function call 
      to math.Sin needs to happen at run time.
	- In Go, enumerated constants are created using the iota 
      enumerator.
	- Since iota can be part of an expression and expressions 
      can be implicitly repeated, it is easy to build intricate
      sets of values.
**/

Popularity 10/10 Helpfulness 4/10 Language go

Source: Grepper

Tags: go g

Link to this answer
Share Copy Link

Contributed on Jul 04 2021

gopher072

0 Answers Avg Quality 2/10

golang enum type

Comment

package main

import "fmt"

type CustomType int

func (enum CustomType) Enum(index CustomType, data []string) string {
	return data[index]
}

func main() {

	// example one created enum type
	const (
		Admin = iota
		User
		Staff
	)

	var RolesEnum CustomType = Admin | User | Staff
	data := []string{"Admin", "User", "Staff"}

	fmt.Printf("enum version one %#v \n", RolesEnum.Enum(RolesEnum&Admin, data))

	// example two created enum type
	var EnumStatusList = struct {
		Completed string
		Rejected  string
		Error     string
	}{
		Completed: "Completed",
		Rejected:  "Rejected",
		Error:     "Error",
	}

	fmt.Printf("enum version two %#v \n", EnumStatusList.Completed)
	
   // example three created enum type
	const (
		Kucing = "Kucing"
		Gajah  = "Gajah"
		Biawak = "Biawak"
	)
	
     fmt.Printf("enum version three %#v \n", Kucing)
}

Popularity 8/10 Helpfulness 3/10 Language go

Source: Grepper

Tags: go

Link to this answer
Share Copy Link

Contributed on Apr 17 2022

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang type enum

Contents

More Related Answers

golang type enum

Closely Related Answers

enum in golang

golang enum type

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.