fmt格式化输出

package main

/*
--通用部分
%v 按值的本来值输出
%+v 在%v基础上，对结构体字段名和值进行展开
%#v 输出Go语言语法格式的值
%T 输出Go言语法格式的类型和值
%% 输出%本体

--布尔值
%t

--整数
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%c ASCCI字符
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示

换行使用\n
*/

import (
"container/list"
"fmt"
"math"
"strings"
"strconv"
)

//验证字符串格式化输出，Println,Printf,Sprintf
/*
Sprintf 根据于格式说明符进行格式化并返回其结果字符串--重在返回值
Println 使用其操作数的默认格式进行格式化并写入到标准输出。 其操作数之间总是添加空格，
且总在最后追加一个换行符。它返回写入的字节数以及任何遇到的错误。
Printf 根据于格式说明符进行格式化并写入到标准输出。 它返回写入的字节数以及任何遇到的写入错误。
*/

//ip从十进制字符串转换华为二进制字符串
func ipTransfer(ip string) string{
var ip_str string
ip_array:=strings.Split(ip,".")
//fmt.Println(ip_array)

for i:=0;i<len(ip_array);i++{
strip:=ip_array[i]
//fmt.Printf("%T",intip)
//字符串转化整数
inip,err:=strconv.Atoi(strip)
if err==nil {
binip:=fmt.Sprintf("%b",inip)
if i==0 {
ip_str+=binip
}else{
ip_str+="."+binip
}
}

}
return ip_str
}
//二进制字符串转化为十进制字符串
func bintoten(bip string) string{
stack := list.New()
var sum int
var stnum, conum float64 = 0, 2
for _, c := range bip {
// 入栈 type rune
stack.PushBack(c)
}

//length := stack.Len()
//fmt.Printf("栈的当前容量是 %d\n", length)

// 出栈
for e := stack.Back(); e != nil; e = e.Prev() {
// rune是int32的别名
v := e.Value.(int32)
sum += int(v-48) * int(math.Pow(conum, stnum))
stnum++
}
//fmt.Printf("二进制转化为十进制结果是 %T:%d\n", sum,sum)
//转化为数字形式的字符串
strip:=strconv.Itoa(sum)
return strip

}
//ip从2进制字符串转换华为10制字符串
func bipTransfer(ip string) string{
var ip_str string
ip_array:=strings.Split(ip,".")
for i:=0;i<len(ip_array);i++{
strip:=ip_array[i]
//字符串开始转化十进字符串
inip:=bintoten(strip)
if i==0 {
ip_str+=inip
}else{
ip_str+="."+inip

}
}
return ip_str
}

func main(){
var a int =90
var b =10
c:="hello word"
var d interface{}
//默认一个结构体示例
e:=&struct{
Name string
Age int
}{
Name:"张三",
Age:23,
}
var g=d
// println 打印，默认原有换行输出
fmt.Println("a,b,c分别为：",a,b,c)
fmt.Println("2a,2b,2c分别为：",a,2*b,c)

// printf 打印，字符串格式化输出
fmt.Println("a,b,c分别为：",a,b,c)
fmt.Println("2a,2b,2c分别为：",a,2*b,c)

//%Tprintf格式化输出变量类型
fmt.Printf("a 的数据类型为：%T\n",a)
fmt.Printf("d 的数据类型为：%T\n",d)

//%v按默认值输出，带s把格式化结果进行其返回值，不带s格式化后输出终端
fmt.Printf("a 的值为：%v\n",a)
fmt.Printf("c 的值为：%v\n",c)
fmt.Printf("d 的值为：%v\n",d)
yzw:=fmt.Sprintf("d 的值为：%v\n",c)
fmt.Println(yzw)

//+v在%v基础上，对结构体字段名和值进行展开
fmt.Printf("e的值为：%v\n",e)
fmt.Printf("e的值为：%+v\n",e)

//%#v输出Go语言语法格式的值
fmt.Printf("a的值为：%#v\n",a)
fmt.Printf("e的值为：%#v\n",e)
fmt.Printf("g的值为：%#v\n",g)

//%% 代表输出%本体,例如%%89，实际输出%89
fmt.Printf("b的%%10值为：%.2f\n",float32(b)*0.01)

//%输出布尔值
var f bool
fmt.Printf("f的数据类型为：%T\n",f)
fmt.Printf("f的数值为：%t\n",f)

//%d十进制,变量部分与前面%d一一对应
//重点
fmt.Printf("a+b的运算过程为：%d+%d=%d\n",a,b,a+b)
fmt.Printf("a-b的运算过程为：%d-%d=%d\n",a,b,a-b)

//%b二进制,只能十进制整数才能转化转化为二进制
//默认都是十进制整数
var in1 int=19
fmt.Printf("%v转化成二进制后为：%b\n",in1,in1)

//案例十进制字符串ip转化为二进制字符串ip
ip:="192.168.5.234"
fmt.Printf("%v转化成二进制后的ip为：%v\n",ip,ipTransfer(ip))

//%b二进制转化成10进制
//当前二进制只能先用字符换表示，无法通过其他形式表示
//然后通过上面的办法bintoten转化成是十进制
bip:="11000000.10101000.101.11101010"
fmt.Printf("%v转化成10进制后的ip为：%v\n",bip,bipTransfer(bip))

//%o 八进制，
//%x 整型以十六进制方式显示
//%X 整型以十六进制、字母大写方式显示
var se int32 = 1047483647 //初始化一个32位整型
se2:=int16(se) //数据类型转化16位整型,发生数值截断
se3:=int8(se) //数据类型转化8位整型,发生数值截断
//输出16进制，10进制
fmt.Printf("输出变量se的16进制为：0x%x,10进制为：%d\n",se,se)
fmt.Printf("输出变量se2的16进制为：0x%x,10进制为：%d\n",se2,se2)
fmt.Printf("输出变量se3的8进制为：0x%o,10进制为：%d\n",se3,se3)

//float浮点型
pi:=3.141592653
fmt.Printf("输出变pi1的默认：%v,默认精度及默认宽度：%f\n",pi,pi)
fmt.Printf("输出变pi1的默认：%v,2位小数精度及默认宽度：%.2f\n",pi,pi)
fmt.Printf("输出变pi1的默认：%v,1位小数精度及4位宽度：%4.1f\n",pi,pi)

//遍历Acssil字符,还是用%c,使用下表取acssil
content:="狙击start 1 2 3 !"
for i:=0;i<len(content);i++{
fmt.Printf("content的第%d个ASCII字符内容为：原样输出:%v,asssil字符输出:%c,二进制输出:%b,十进制输出:%d\n",i,content[i],content[i],content[i],content[i])
}

//遍历字符,按unicode,还是%c,使用for range 取unicode
for key,value:= range content{
fmt.Printf("content的第%d个Unicode字符内容为：原样输出:%v,Unicode字符输出:%c,二进制输出:%b,十进制输出:%d\n",key,value,value,value,value)
}

//遍历字符,按unicode,使用%U,字符串内容会变成U+3100这样
for key,value:= range content{
fmt.Printf("content的第%d个Unicode字符内容为：原样输出:%v,Unicode字符输出:%U,二进制输出:%b,十进制输出:%d\n",key,value,value,value,value)
}

//指针，十六进制地址值
var pointln int=18
point:=&pointln
fmt.Printf("原变量存储的值：%v;对应指针变量的值(16进制地址)：%p,指针变量的类型%T,指针变量的指向值:%d\n",pointln,point,point,*point)


}