从整数转换为其二进制表示形式

The strconv package has FormatInt, which accepts an int64 and lets you specify the base.

n := int64(123)


fmt.Println(strconv.FormatInt(n, 2)) // 1111011

DEMO: http://play.golang.org/p/leGVAELMhv

http://golang.org/pkg/strconv/#FormatInt

func FormatInt(i int64, base int) string

FormatInt returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' for digit values >= 10.

See also the fmt package:

n := int64(123)
fmt.Printf("%b", n)  // 1111011

Building on the answer provided by @Mark

Although the OP asked how to print an integer, I often want to look at more then 64 bits worth of data, without my eyes boggling:

/* --- Credit to Dave C in the comments --- */
package main


import (
"bytes"
"fmt"
)


func main() {
fmt.Printf("<%s>\n", fmtBits([]byte{0xDE, 0xAD, 0xBE, 0xEF, 0xF0, 0x0D, 0xDE, 0xAD, 0xBE, 0xEF, 0xF0, 0x0D}))


// OUTPUT:
// <11011110 10101101 10111110 11101111 11110000 00001101 11011110 10101101 10111110 11101111 11110000 00001101>
}


func fmtBits(data []byte) []byte {
var buf bytes.Buffer
for _, b := range data {
fmt.Fprintf(&buf, "%08b ", b)
}
buf.Truncate(buf.Len() - 1) // To remove extra space
return buf.Bytes()
}

This code works on big integers *big.Int :

x := big.NewInt(123)
s := fmt.Sprintf("%b", x)
// s == "1111011"

because *big.Int implements the fmt.Formatter interface.

Taken from https://stackoverflow.com/a/23317788/871134

Unsafe pointers must be used to correctly represent negative numbers in binary format.

package main


import (
"fmt"
"strconv"
"unsafe"
)


func bInt(n int64) string {
return strconv.FormatUint(*(*uint64)(unsafe.Pointer(&n)), 2)
}


func main() {
fmt.Println(bInt(-1))
}

https://play.golang.org/p/GxXjjWMyC4x

package main


import . "fmt"


func main(){
Printf("%d == %08b\n",0,0)
Printf("%d == %08b\n",1,1)
Printf("%d == %08b\n",2,2)
Printf("%d == %08b\n",3,3)
Printf("%d == %08b\n",4,4)
Printf("%d == %08b\n",5,5)
}

results in:

0 == 00000000
1 == 00000001
2 == 00000010
3 == 00000011
4 == 00000100
5 == 00000101

An alternate way for the accepted answer would be to simply do

s := fmt.Sprintf("%b", 123)
fmt.Println(s)                 // 1111011

For a more rich representation you can use the unsafe package(strongly discouraged) as

a := int64(123)
byteSliceRev := *(*[8]byte)(unsafe.Pointer(&a))
byteSlice := make([]byte, 8)
for i := 0; i < 8; i++ {
byteSlice[i] = byteSliceRev[7 - i]
}
fmt.Printf("%b\n", byteSlice)

This works for negative integers too.

Many above answers do not work if you use negative decimals.

Here is the simplest answer. Also works with negative decimals.

var a int64 = -1
fmt.Printf("%b\n", uint64(a)) // 11111.... (not -1)

(Go playground link)

You can also use fmt.Sprintf instead of fmt.Printf if you want a string variable.

This way, you can convert negative decimal into bitwise representation using two's complement (without - sign), not into mathematical binary representation (using - sign). (As I commented in Soslan's answer.)

(Soslan and Vaibhav's answers also work with negative numbers, using the unsafe package.)