package main

import (

    "fmt"

)

func main() {

    fmt.Println("Hello World")

}

FROM golang:onbuild

RUN mkdir /app

ADD . /app/

WORKDIR /app

RUN go build -o main .

CMD ["/app/main"]

$ docker build -t example .

Sending build context to Docker daemon  4.096kB

Step 1/6 : FROM golang:onbuild

# Executing 3 build triggers...

Step 1/1 : COPY . /go/src/app

Step 1/1 : RUN go-wrapper download

 ---> Running in eb597cae57ef

+ exec go get -v -d

Step 1/1 : RUN go-wrapper install

 ---> Running in 3cc20f3cc840

+ exec go install -v

app

 ---> 11d942c55dfb

Removing intermediate container 4eca92f17e78

Removing intermediate container eb597cae57ef

Removing intermediate container 3cc20f3cc840

Step 2/6 : RUN mkdir /app

 ---> Running in 1035dea0ce0d

 ---> 9fbe4249fc32

Removing intermediate container 1035dea0ce0d

Step 3/6 : ADD . /app/

 ---> 8950d77f106e

Removing intermediate container d43b4043d9bf

Step 4/6 : WORKDIR /app

 ---> 465bff3b7275

Removing intermediate container d21a6bdc6c31

Step 5/6 : RUN go build -o main .

 ---> Running in 9e1c1b5a0123

 ---> 9e27407b57d4

Removing intermediate container 9e1c1b5a0123

Step 6/6 : CMD /app/main

 ---> Running in 4dbe90267d84

 ---> a8861bcaebad

Removing intermediate container 4dbe90267d84

Successfully built a8861bcaebad

Successfully tagged example:latest

$ docker run -it --rm --name my-example example

Hello World

Can I stop these complaints about my unused variable/import?

The presence of an unused variable may indicate a bug, while unused imports just slow down compilation, an effect that can become substantial as a program accumulates code and programmers over time. For these reasons, Go refuses to compile programs with unused variables or imports, trading short-term convenience for long-term build speed and program clarity.

Still, when developing code, it's common to create these situations temporarily and it can be annoying to have to edit them out before the program will compile.

Some have asked for a compiler option to turn those checks off or at least reduce them to warnings. Such an option has not been added, though, because compiler options should not affect the semantics of the language and because the Go compiler does not report warnings, only errors that prevent compilation.

There are two reasons for having no warnings. First, if it's worth complaining about, it's worth fixing in the code. (And if it's not worth fixing, it's not worth mentioning.) Second, having the compiler generate warnings encourages the implementation to warn about weak cases that can make compilation noisy, masking real errors that should be fixed.

It's easy to address the situation, though. Use the blank identifier to let unused things persist while you're developing.

import "unused"

// This declaration marks the import as used by referencing an
// item from the package.
var _ = unused.Item  // TODO: Delete before committing!

func main() {
    debugData := debug.Profile()
    _ = debugData // Used only during debugging.
    ....
} 

package main

import "fmt"

func main() {

  i := 1

  j := 2

  if i < 0 && j < 2 {

    fmt.Println("-")

  } else {

    fmt.Println("+")

  }

}

func main() {

  if i := 0 ; i < 2 {

    fmt.Println(i)

  } else {

    fmt.Println(i)

  }

}

func main() {

  for i := 1; i < 10; i++ {

    println(i)

  }

}

1

2

3

4

5

6

7

8

9

package main

import "fmt"

func main() {

  i := 1

  for i < 10 {

    fmt.Println(i)

    i++

  }

}

func main() {

  i := 1

  for i < 10 {

    fmt.Println(i++)

  }

}

func main() {

  i := 1

  for i++ < 10 {

    fmt.Println(i)

  }

}

func main() {

  for { }

}

func main() {

  numbers := []int {10, 9, 8}

  for i, number := range numbers {

      println(i, number)

  }

}

  for i := range [1..10] {

      println(i)

  }

package main

import "fmt"

import "reflect"

func main() {

  var x, y = 1, "2"

  fmt.Println(x, y)

  fmt.Println(reflect.TypeOf(x))

  fmt.Println(reflect.TypeOf(y))

  fmt.Println()

  m := 1.2

  fmt.Println(m)

  fmt.Println(reflect.TypeOf(m))

}

package main

import "fmt"

func main() {

   var a = 1

   fmt.Println(a)

   a = 2

   fmt.Println(a)

   b := 10

   fmt.Println(b)

   b = 20

   fmt.Println(b)

   c := "aaaa"

   fmt.Println(c)

   c = "bbbb"

   fmt.Println(c)

}

1

2

10

20

aaaa

bbbb

func main() {

  const x = "1"

  x = "2"

}

package main

import "fmt"

func main() {

   fmt.Println(add(1,2))

   x, y := add(1,2)

   fmt.Println(x, y)

   fmt.Println(minus(2,1))

}

func add(x int, y int) (int, int) {

  return x + y, x - y

}

func minus(x int, y int) (int) {

  return x - y

}

3 -1

3 -1

1

func add(x, y int) (int, int) {

  return x + y, x - y

}

func minus(x, y int) (int) {

  return x - y

}

  multilineLiteral1 := `aa

  ㅁㅁㅁㅁ

  `

  fmt.Println(multilineLiteral1)

aa

  ㅁㅁㅁㅁ

  multilineLiteral2 := "aa  \n" +

  "ㅁㅁㅁ"

  fmt.Println(multilineLiteral2)

aa

ㅁㅁㅁ

multilineLiteral3 := "s \\n

  aaa"

multilineLiteral4 := "s \\n"

+  "aaa"