how do i minimize the amount if/else without losing any functionality?

package main
import "fmt"

var firstUserChoice int
var secondUserChoice int



func main()  {
   fmt.Println("Welcome to GO METER app")
   fmt.Print("1-Milimeter to\n2-Centimeter to\n3-Meter to\n4-Kilometer to\nPlease choose an operation: ")
   fmt.Scanln(&firstUserChoice)
   if firstUserChoice <= 4 {
     secondStage()
   } else {
     fmt.Println("INVALID CHOICE")
     secondStage()
   }
}

// ask user for the second unit
func secondStage() ()  {
  fmt.Print("1-to Milimeter\n2-to Centimeter\n3-to Meter\n4-kilometer to\nPlease choose an operation: ")
  fmt.Scanln(&secondUserChoice)
  if secondUserChoice <= 4 {
    thirdStage()
  } else {
    fmt.Println("INVALID CHOICE")
    thirdStage()
  }
}

func thirdStage()  {
  var number float64
  const mm string = "Milimeters"
  const cm string = "Centimeters"
  const m string = "Meters"
  const km string = "Kilometers"
  fmt.Print("Enter the number you want to convert: ")
  fmt.Scanln(&number)
  switch firstUserChoice {
  case 1:
    if secondUserChoice == 1 {
      fmt.Println(number, mm,"Equals", number, mm)
    }
    if secondUserChoice == 2 {
      fmt.Println(number, mm,"Equals", number/10, cm)
    }
    if secondUserChoice == 3 {
      fmt.Println(number, mm,"Equals", number/1000, m)
    }
    if secondUserChoice == 4 {
      fmt.Println(number, mm,"Equals", number/1000000, km)
    }
  case 2:
    if secondUserChoice == 1 {
      fmt.Println(number, cm,"Equals", number*10, m)
    }
    if secondUserChoice == 2 {
      fmt.Println(number, cm,"Equals", number, cm)
    }
    if secondUserChoice == 3 {
      fmt.Println(number, cm,"Equals", number/100, m)
    }
    if secondUserChoice == 4 {
      fmt.Println(number, cm,"Equals", number/100000, km)
    }
  case 3:
    if secondUserChoice == 1 {
      fmt.Println(number, m,"Equals", number*1000, mm)
    }
    if secondUserChoice == 2 {
      fmt.Println(number, m,"Equals", number*100, cm)
    }
    if secondUserChoice == 3 {
      fmt.Println(number, m,"Equals", number, m)
    }
    if secondUserChoice == 4 {
      fmt.Println(number, m,"Equals", number/1000, km)
    }
  case 4:
    if secondUserChoice == 1 {
      fmt.Println(number, km,"Equals", number*1000000, mm)
    }
    if secondUserChoice == 2 {
      fmt.Println(number, km,"Equals", number*100000, cm)
    }
    if secondUserChoice == 3 {
      fmt.Println(number, km,"Equals", number*1000, mm)
    }
    if secondUserChoice == 4 {
      fmt.Println(number, km,"Equals", number, km)
    }
  }
}

I wrote this program as a tiny exercise, it converts 4 length units to each other but i wrote code for every single possible combination which is not very efficient in my opinion.
However the problem is that I am still very new to the go programming language and i need your generous help with cleaning the dirty code that i recently wrote, how can i turn my dirty code into a more simpler, cleaner and readable by reducing the amount of if/else arguments?
And are there anything i did wrong other than if/else that makes the code more readable

Since it is an exercise you can look at another way to organise this logic. This example does not handle wrong user inputs and has no pretty printing of the result. distance type holds value in lowest unit (mm), similar to how time package does with Duration.

package main
import (
"fmt"
)
type unit byte
const (
mm unit = 0
cm unit = 1
m  unit = 2
km unit = 3
inputUnitsMsg = "1-Milimeter to\n2-Centimeter to\n3-Meter to\n4-Kilometer to\nPlease choose an operation: "
inputAmountMsg = "Enter the number you want to convert: "
)
type unitWithAmount [4]int
type distance int
func newUnitWithAmount(u unit, amount int) unitWithAmount {
var out [4]int
out[u] = amount
return out
}
func newDistance(uwa unitWithAmount) distance {
return distance(uwa[mm] + uwa[cm]*10 + uwa[m]*1000 + uwa[km]*1000000)
}
func (d distance) convert(u unit) int {
switch u {
case mm:
return d.mm()
case cm:
return d.cm()
case m:
return d.m()
case km:
return d.km()
}
return -1
}
func (d distance) mm() int {
return int(d)
}
func (d distance) cm() int {
return int(d) / 10
}
func (d distance) m() int {
return int(d) / 1000
}
func (d distance) km() int {
return int(d) / 1000000
}
func main() {
var from, to, amount int
fmt.Println("Welcome to GO METER app")
fmt.Print(inputUnitsMsg)
fmt.Scanln(&from)
fmt.Print(inputUnitsMsg)
fmt.Scanln(&to)
fmt.Print(inputAmountMsg)
fmt.Scanln(&amount)
// user input to slice index
from--
to--
// unit with amount which we want to convert
uwa := newUnitWithAmount(unit(from), amount)
// to what unit we are converting
u := unit(to)
d := newDistance(uwa)
fmt.Println(d.convert(u))
}

There are many improvements that we can do to this program.

1. Do not use global variables. They make the code harder to understand and untestable.

2. Give meaningful names to the functions, names that describe what the functions do. Currently they describe when they are called, which is quite opaque (secondStage, thirdStage).

3. Return errors and exit non-zero in case of errors.

4. Think about the UI (the User Interface). Can we make it better? Maybe making it better will also make the code more readable. Currently we have, for example:

Welcome to GO METER app
1-Milimeter to
2-Centimeter to
3-Meter to
4-Kilometer to
Please choose an operation: 1              // 1
1-to Milimeter
2-to Centimeter
3-to Meter
4-kilometer to
Please choose an operation: 4              // 2
Enter the number you want to convert: 3    // 3
3 Milimeters Equals 3e-06 Kilometers

The user has to enter a number and hit enter 3 times (marked above as comments). Of these 3 data entries, 2 numbers are actually to choose what to do and one number is the real input.

If we think about what is the goal of the program, the same can be obtained in a more straightforward way, like the conversion you get from a textual Google query: 3 mm to km will answer 3e-6. We will simplify this query removing the to, thus keeping: 3 mm km.

For the same request as above, we would get something like:

Welcome to GO METER app
Usage: <N> <from-unit> <to-unit>
Where <N> is a number and <from-unit>, <to-unit> are one of mm, cm, m, km.
-> 3 mm km
0.000003 km

5. How to simplify the logic?

The insight is that we can use a lookup table:

// To convert <n> <from-unit> to <to-unit>:
// q := n * fromUnit.UtoM * toUnit.MtoU
var units = map[string]struct {
	UtoM float64 // unit to meter
	MtoU float64 // meter to unit
}{
	"mm": {1e-3, 1e+3},
	"cm": {1e-2, 1e+2},
	"m":  {1, 1},
	"km": {1e+3, 1e-3},
}

Putting all this together, with full error handling:

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

// This looks like a global variable, but we actually treat it as a constant lookup table.
// To convert <n> <from-unit> to <to-unit>:
// q := n * fromUnit.UtoM * toUnit.MtoU
var units = map[string]struct {
	UtoM float64 // unit to meter
	MtoU float64 // meter to unit
}{
	"mm": {1e-3, 1e+3},
	"cm": {1e-2, 1e+2},
	"m":  {1, 1},
	"km": {1e+3, 1e-3},
}

func main() {
	if err := drive(); err != nil {
		fmt.Println("gometer: error:", err)
		os.Exit(1)
	}
}

func drive() error {
	fmt.Println("Welcome to GO METER app")
	fmt.Println("Usage: <N> <from-unit> <to-unit>")
	fmt.Println("Where <N> is a number and <from-unit>, <to-unit> are one of mm, cm, m, km.")
	fmt.Print("-> ")

	var line string

	rd := bufio.NewReader(os.Stdin)
	line, err := rd.ReadString('\n')
	if err != nil {
		return fmt.Errorf("reading input: %s", err)
	}

	// input line:   "3 mm km"
	// tokens index:  0 1  2
	tokens := strings.Fields(line)

	if len(tokens) != 3 {
		return fmt.Errorf("got %d tokens; want 3 (%q)", len(tokens), tokens)
	}

	n, err := strconv.ParseFloat(tokens[0], 64)
	if err != nil {
		return fmt.Errorf("invalid number %q: %s", tokens[0], err)
	}

	fromUnitToken := tokens[1]
	toUnitToken := tokens[2]

	fromUnit, ok := units[fromUnitToken]
	if !ok {
		return fmt.Errorf("invalid from-unit %q", fromUnitToken)
	}
	toUnit, ok := units[toUnitToken]
	if !ok {
		return fmt.Errorf("invalid to-unit %q", toUnitToken)
	}

	q := n * fromUnit.UtoM * toUnit.MtoU

	fmt.Printf("%f %s\n", q, toUnitToken)
	return nil
}

6. We are not done yet! The following enhancements are left as an exercise to the reader.

6.1 Do we really need to ask the user anything? If not, then the program should accept the user input from the command-line, not from a prompt. The command-line is accessible with os.Args.

6.2 If yes, then the program should loop (a sort of basic calculator), instead of exiting after the first conversion. The idiomatic way to loop on interactive input is to use bufio.Scanner. See for example https://yourbasic.org/golang/read-file-line-by-line/. By the way, everything on https://yourbasic.org is very good.

7. Testing. Think how you can test (in the sense: write tests, not manual tests) this code. A good starting point is https://quii.gitbook.io/learn-go-with-tests/

8. Becoming proficient with Go in general. I suggest the Go track at https://exercism.org/

You can use an array or a map, here's an example with an array:

type args struct {
	number        float64
	km, m, cm, mm string
}

var choiceArray = [5][5]func(args){
	1: {
		1: func(a args) { fmt.Println(a.number, a.mm, "Equals", a.number, a.mm) },
		2: func(a args) { fmt.Println(a.number, a.mm, "Equals", a.number/10, a.cm) },
		3: func(a args) { fmt.Println(a.number, a.mm, "Equals", a.number/1000, a.m) },
		4: func(a args) { fmt.Println(a.number, a.mm, "Equals", a.number/1000000, a.km) },
	},
	2: {
		1: func(a args) { fmt.Println(a.number, a.cm, "Equals", a.number*10, a.m) },
		2: func(a args) { fmt.Println(a.number, a.cm, "Equals", a.number, a.cm) },
		3: func(a args) { fmt.Println(a.number, a.cm, "Equals", a.number/100, a.m) },
		4: func(a args) { fmt.Println(a.number, a.cm, "Equals", a.number/100000, a.km) },
	},
	3: {
		1: func(a args) { fmt.Println(a.number, a.m, "Equals", a.number*1000, a.mm) },
		2: func(a args) { fmt.Println(a.number, a.m, "Equals", a.number*100, a.cm) },
		3: func(a args) { fmt.Println(a.number, a.m, "Equals", a.number, a.m) },
		4: func(a args) { fmt.Println(a.number, a.m, "Equals", a.number/1000, a.km) },
	},
	4: {
		1: func(a args) { fmt.Println(a.number, a.km, "Equals", a.number*1000000, a.mm) },
		2: func(a args) { fmt.Println(a.number, a.km, "Equals", a.number*100000, a.cm) },
		3: func(a args) { fmt.Println(a.number, a.km, "Equals", a.number*1000, a.mm) },
		4: func(a args) { fmt.Println(a.number, a.km, "Equals", a.number, a.km) },
	},
}

func thirdStage() {
	a := args{
		mm: "Milimeters",
		cm: "Centimeters",
		m:  "Meters",
		km: "Kilometers",
	}

	fmt.Print("Enter the number you want to convert: ")
	fmt.Scanln(&a.number)
	
    choiceArray[firstUserChoice][secondUserChoice](a)
}

You can use any sort of combined values for switch, including non-integer, e.g.

package main

import (
	"fmt"
)

func main() {
	first := 2
	second := 1

	v1 := fmt.Sprintf("%d.%d", first, second)
	switch v1 {
	case "1.1":
		fmt.Println("case 1.1")
	case "1.2":
		fmt.Println("case 1.2")
	case "2.1":
		fmt.Println("case 2.1")
	case "2.2":
		fmt.Println("case 2.2")
	default:
		fmt.Println("default")
	}
	
	v2 := 10*(first-1) + second
	switch v2 {
	case 1:
		fmt.Println("case 1/1")
	case 2:
		fmt.Println("case 1/2")
	case 11:
		fmt.Println("case 2/1")
	case 12:
		fmt.Println("case 2/2")
	default:
		fmt.Println("default")
	}
}

You can also consider taking common actions out of conditions, i.e.

if firstUserChoice <= 4 {
secondStage()
} else {
fmt.Println("INVALID CHOICE")
secondStage()
}

becoming

if firstUserChoice > 4 {
fmt.Println("INVALID CHOICE")
}
secondStage()

As stated by mkopriva you can use array and map.

Enum can be added for improving readability.

package main

import (
  "fmt"
  "os"
)

const (
  mm int = iota + 1
  cm
  m
  km
)

var mapping_length = map[int]string{
  mm : "Milimeters",
  cm : "Centimeters",
  m  : "Meters",
  km : "Kilometers",
}

// var choicesArray = [][]func(float64)(float64) {
//  mm: {
//    mm: func(num float64) float64 {
//      return num
//    },
//    cm: func(num float64) float64 {
//      return num / 10
//    },
//    m: func(num float64) float64 {
//      return num / 1000
//    },
//    km: func(num float64) float64 {
//      return num / 1000000
//    },
//  },
//  cm: {
//    mm: func(num float64) float64 {
//      return num * 10
//    },
//    cm: func(num float64) float64 {
//      return num
//    },
//    m: func(num float64) float64 {
//      return num / 100
//    },
//    km: func(num float64) float64 {
//      return num / 100000
//    },
//  },
//  m: {
//    mm: func(num float64) float64 {
//      return num * 1000
//    },
//    cm: func(num float64) float64 {
//      return num * 100
//    },
//    m: func(num float64) float64 {
//      return num
//    },
//    km: func(num float64) float64 {
//      return num / 1000
//    },
//  },
//  km: {
//    mm: func(num float64) float64 {
//      return num * 1000000
//    },
//    cm: func(num float64) float64 {
//      return num * 100000
//    },
//    m: func(num float64) float64 {
//      return num * 1000
//    },
//    km: func(num float64) float64 {
//      return num
//    },
//  },
// }

var choicesMap = map[int]map[int]func(float64)(float64) {
 mm: {
   mm: func(num float64) float64 {
     return num
   },
   cm: func(num float64) float64 {
     return num / 10
   },
   m: func(num float64) float64 {
     return num / 1000
   },
   km: func(num float64) float64 {
     return num / 1000000
   },
 },
 cm: {
   mm: func(num float64) float64 {
     return num * 10
   },
   cm: func(num float64) float64 {
     return num
   },
   m: func(num float64) float64 {
     return num / 100
   },
   km: func(num float64) float64 {
     return num / 100000
   },
 },
 m: {
   mm: func(num float64) float64 {
     return num * 1000
   },
   cm: func(num float64) float64 {
     return num * 100
   },
   m: func(num float64) float64 {
     return num
   },
   km: func(num float64) float64 {
     return num / 1000
   },
 },
 km: {
   mm: func(num float64) float64 {
     return num * 1000000
   },
   cm: func(num float64) float64 {
     return num * 100000
   },
   m: func(num float64) float64 {
     return num * 1000
   },
   km: func(num float64) float64 {
     return num
   },
 },
}

func getChoice() int {
	fmt.Print("1: Milimeter to\n2: Centimeter to\n3: Meter to\n4: Kilometer to\nPlease choose an operation: ")
  var userChoice int
  fmt.Scanln(&userChoice)
  return userChoice
}

func main()  {
   fmt.Println("Welcome to GO METER app")

   var firstUserChoice = getChoice()
   if firstUserChoice > 4 {
     fmt.Println("INVALID CHOICE")
     os.Exit(0)
   }

   var secondUserChoice = getChoice()
   if secondUserChoice > 4 {
     fmt.Println("INVALID CHOICE")
     os.Exit(0)
   }

   var number float64
   fmt.Print("Enter the number you want to convert: ")
   fmt.Scanln(&number)

   // Array
   // var result = choicesArray[firstUserChoice][secondUserChoice](number)
   // Map
   var result = choicesMap[firstUserChoice][secondUserChoice](number)

   fmt.Println(number, mapping_length[firstUserChoice], "Equals", result, mapping_length[secondUserChoice])
}