golang type declaration

Go Type Declaration

In Go, type declarations are used to define new types or aliases for existing types. The type declaration syntax in Go is as follows:

type TypeName underlyingType
  • TypeName: This is the name of the new type being declared.
  • underlyingType: This is the existing type that the new type is based on.

Here are some explanations for each step involved in a Go type declaration:

  1. Start with the type keyword.
  2. Specify the name of the new type using an identifier.
  3. Use the underlyingType to define the type that the new type is based on. The underlyingType can be any valid Go type, including built-in types, user-defined types, or even interfaces.

Here's an example of a Go type declaration:

type Age int

In this example, a new type Age is declared, which is based on the underlying type int. This allows you to use the Age type instead of int in your code, providing better type safety and expressiveness.

It's important to note that type declarations in Go create new distinct types, even if they are based on the same underlying type. This means that you cannot assign values of one type to another, even if their underlying types are the same. You would need to explicitly convert between the types.

For example:

type Age int

func main() {
    var myAge Age = 25
    var myInt int = int(myAge) // Explicit conversion required

In the above example, we declare a variable myAge of type Age and assign it a value of 25. We then declare another variable myInt of type int and assign it the value of myAge after explicitly converting it to int.

Type declarations in Go are useful for creating more descriptive and self-explanatory code by introducing meaningful names for types based on their usage or domain-specific context.