go的uint64转换成java的哪种类型

Golang 和java/c不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换。

闻喜网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作，到程序开发，运营维护。创新互联从2013年开始到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

基本语法

表达式T（v））将值v 转换为类型T

T∶就是数据类型，比如int32，int64，float32等等

v∶ 就是需要转换的变量

var i int = 100

var b float64 = float64(i)

var c int64 = int64(b)

fmt.Printf("b=%f,c=%d",b,c)

b=100.000000,c=100

登录后复制

细节说明

1）Go中，数据类型的转换可以是从表示范围小-表示范围大，也可以范围大一范围小

2） 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化!

3） 在转换中，比如将 int64 转成int8，编译时不会报错，只是转换的结果是按溢出处理，和

我们希望的结果不一样。（在转换的时候需要注意范围）

var a int64 = 10000000

var b int8 = int8(a)

fmt.Printf("%d",b)

-128

登录后复制

可以看到在转换的时候，一定要保证转换大数据要是对方可以接受的范围。

n1类型是int32，那么➕20整个就是int32类型，可是n2是int64，这样就会编译错误。

题二n4是12 + 127溢出超过了范围，运行的时候按照溢出处理。n3是直接编译不通过，128已经超过了int8类型的范围

基本数据类型和string的转换

字符串格式化

Go语言用于控制文本输出常用的标准库是fmt

fmt中主要用于输出的函数有:

Print: 输出到控制台,不接受任何格式化操作

Println: 输出到控制台并换行

Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出别的类型）

Sprintf：格式化并返回一个字符串而不带任何输出

Fprintf：来格式化并输出到 io.Writers 而不是 os.Stdout

整数类型

格 式 描 述

%b 整型以二进制方式显示

%o 整型以八进制方式显示

%d 整型以十进制方式显示

%x 整型以十六进制方式显示

%X 整型以十六进制、字母大写方式显示

%c 相应Unicode码点所表示的字符

%U Unicode 字符, Unicode格式：123，等同于 "U+007B"

浮点数

格 式 描 述

%e 科学计数法，例如 -1234.456e+78

%E 科学计数法，例如 -1234.456E+78

%f 有小数点而无指数，例如 123.456

%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出

%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出

布尔

格 式 描 述

%t true 或 false

字符串

格 式 描 述

%s 字符串或切片的无解译字节

%q 双引号围绕的字符串，由Go语法安全地转义

%x 十六进制，小写字母，每字节两个字符

%X 十六进制，大写字母，每字节两个字符

指针

格 式 描 述

%p 十六进制表示，前缀 0x

var num1 int64 = 99

var num2 float64 = 23.99

var b bool = true

var mychar byte = 'h'

str1 := fmt.Sprintf("%d",num1)

str2 := fmt.Sprintf("%f",num2)

bool1 := fmt.Sprintf("%t",b)

mychar1 := fmt.Sprintf("%c",mychar)

fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)

string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h

登录后复制



使用strconv包 基本类型 - string类型

num1 := 99

str1 := strconv.FormatInt(int64(num1),10)

fmt.Printf("%T,%v",str1,str1)

num2 := 99.99

str2 := strconv.FormatFloat(num2,'f',10,64)

fmt.Printf("%T,%v\n",str2,str2)

登录后复制

strconv包提供了字符串与简单数据类型之间的类型转换功能，可以将简单类型转换为字符串，也可以将字符串转换为其它简单类型

string和int转换

int转string的方法是: Itoa()

str := strconv.Itoa(100)

fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

登录后复制

2.string转int的方法是:

i, err := strconv.Atoi("100")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

并不是所有string都能转化为int, 所以可能会报错:

i, err := strconv.Atoi("100x")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

使用strconv包 string转其他类型

strconv包提供的Parse类函数用于将字符串转化为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

1.转bool

b, err := strconv.ParseBool("true")

fmt.Println(b, err)

登录后复制

2.转float

f1, err := strconv.ParseFloat("3.1", 32)

fmt.Println(f1, err)

f2, err := strconv.ParseFloat("3.1", 64)

fmt.Println(f2, err)

登录后复制

由于浮点数的小数部分 并不是所有小数都能在计算机中精确的表示, 这就造成了浮点数精度问题, 比如下面

var n float64 = 0

for i := 0; i 1000; i++ {

n += .01

}

fmt.Println(n)

关于浮点数精度问题: c计算机不都是0101吗，你有想过计算机是怎么表示的小数吗, 简单理解就是:

将其整数部分与小树部分分开, 比如5.25

对于整数部分 5 ，我们使用"不断除以2取余数"的方法，得到 101

对于小数部分 .25 ，我们使用"不断乘以2取整数"的方法，得到 .01

听说有一个包可以解决这个问题: github.com/shopspring/decimal

3.转int

func ParseInt(s string, base int, bitSize int) (i int64, err error)

base: 进制，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析

bitSize: 多少位，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8

fmt.Println(bInt8(-1)) // 0000 0001(原码) - 1111 1110(反码) - 1111 1111

// Parse 二进制字符串

i, err := strconv.ParseInt("11111111", 2, 16)

fmt.Println(i, err)

// Parse 十进制字符串

i, err = strconv.ParseInt("255", 10, 16)

fmt.Println(i, err)

// Parse 十六进制字符串

i, err = strconv.ParseInt("4E2D", 16, 16)

fmt.Println(i, err)

4.转uint

func ParseUint(s string, base int, bitSize int) (uint64, error)

用法和转int一样, 只是转换后的数据类型是uint64

u, err := strconv.ParseUint("11111111", 2, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("255", 10, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("4E2D", 16, 16)

fmt.Println(u, err)

其他类型转string

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

fmt.Println(strconv.FormatBool(true))

// 问题又来了

fmt.Println(strconv.FormatInt(255, 2))

fmt.Println(strconv.FormatInt(255, 10))

fmt.Println(strconv.FormatInt(255, 16))

fmt.Println(strconv.FormatUint(255, 2))

fmt.Println(strconv.FormatUint(255, 10))

fmt.Println(strconv.FormatUint(255, 16))

fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。

prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

Go语言输出打印--排坑

一.几种公共方法

1)Print:   输出到控制台(不接受任何格式化，它等价于对每一个操作数都应用 %v)

print 在golang中 是属于输出到标准错误流中并打印,官方不建议写程序时候用它。可以再debug时候用

2)Println: 输出到控制台并换行

3)Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出整形变量和整形等）

4)Sprintf：格式化并返回一个字符串而不带任何输出

5)Fprintf：来格式化并输出到 io.Writers 而不是 os.Stdout

二.带占位符输出--网址：    

和python差不多的道理，这里简单补充

v     值的默认格式

%+v   添加字段名(如结构体)

%#v　 相应值的Go语法表示 

%T    相应值的类型的Go语法表示 

%%    字面上的百分号，并非值的占位符

%c     相应Unicode码点所表示的字符 

%x     十六进制表示，字母形式为小写 a-f

%X     十六进制表示，字母形式为大写 A-F

%U     Unicode格式：U+1234，等同于 "U+%04X"

golang怎么通过数据流直接生成excel上传至oss

import java.io.*; import jxl.*; … … … … try { //构建Workbook对象, 只读Workbook对象 //直接从本地文件创建Workbook //从输入流创建Workbook InputStream is = new FileInputStream(sourcefile); jxl.Workbook rwb = Workbook.getWorkbook(is); } catch (Exception e) { e.printStackTrace(); } 一旦创建了Workbook，我们就可以通过它来访问Excel Sheet(术语：工作表)。参考下面的代码片段： //获取第一张Sheet表 Sheet rs = rwb.getSheet(0); 我们既可能通过Sheet的名称来访问它，也可以通过下标来访问它。如果通过下标来访问的话，要注意的一点是下标从0开始，就像数组一样。 一旦得到了Sheet，我们就可以通过它来访问Excel Cell(术语：单元格)。参考下面的代码片段： //获取第一行，第一列的值 Cell c00 = rs.getCell(0, 0); String strc00 = c00.getContents(); //获取第一行，第二列的值 Cell c10 = rs.getCell(1, 0); String strc10 = c10.getContents(); //获取第二行，第二列的值 Cell c11 = rs.getCell(1, 1); String strc11 = c11.getContents(); System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType()); System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType()); System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType()); 如果仅仅是取得Cell的值，我们可以方便地通过getContents()方法，它可以将任何类型的Cell值都作为一个字符串返回。示例代码中Cell(0, 0)是文本型，Cell(1, 0)是数字型，Cell(1,1)是日期型，通过getContents()，三种类型的返回值都是字符型。 如果有需要知道Cell内容的确切类型，API也提供了一系列的方法。参考下面的代码片段： String strc00 = null; double strc10 = 0.00; Date strc11 = null; Cell c00 = rs.getCell(0, 0); Cell c10 = rs.getCell(1, 0); Cell c11 = rs.getCell(1, 1); if(c00.getType() == CellType.LABEL) { LabelCell labelc00 = (LabelCell)c00; strc00 = labelc00.getString(); } if(c10.getType() == CellType.NUMBER) { NmberCell numc10 = (NumberCell)c10; strc10 = numc10.getValue(); } if(c11.getType() == CellType.DATE) { DateCell datec11 = (DateCell)c11; strc11 = datec11.getDate(); } System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType()); System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType()); System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType()); 在得到Cell对象后，通过getType()方法可以获得该单元格的类型，然后与API提供的基本类型相匹配，强制转换成相应的类型，最后调用相应的取值方法getXXX()，就可以得到确定类型的值。API提供了以下基本类型，与Excel的数据格式相对应，如下图所示： 每种类型的具体意义，请参见Java Excel API Document。 当你完成对Excel电子表格数据的处理后，一定要使用close()方法来关闭先前创建的对象，以释放读取数据表的过程中所占用的内存空间，在读取大量数据时显得尤为重要。参考如下代码片段： //操作完成时，关闭对象，释放占用的内存空间 rwb.close(); Java Excel API提供了许多访问Excel数据表的方法，在这里我只简要地介绍几个常用的方法，其它的方法请参考附录中的Java Excel API Document。 • Workbook类提供的方法 1. int getNumberOfSheets() 获得工作薄（Workbook）中工作表（Sheet）的个数，示例： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); int sheets = rwb.getNumberOfSheets(); 2. Sheet[] getSheets() 返回工作薄（Workbook）中工作表（Sheet）对象数组，示例： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); Sheet[] sheets = rwb.getSheets(); 3. String getVersion() 返回正在使用的API的版本号，好像是没什么太大的作用。 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); String apiVersion = rwb.getVersion(); • Sheet接口提供的方法 1. String getName() 获取Sheet的名称，示例： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); String sheetName = rs.getName(); 2. int getColumns() 获取Sheet表中所包含的总列数，示例： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); int rsColumns = rs.getColumns(); 3. Cell[] getColumn(int column) 获取某一列的所有单元格，返回的是单元格对象数组，示例： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); Cell[] cell = rs.getColumn(0); 4. int getRows() 获取Sheet表中所包含的总行数，示例： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); int rsRows = rs.getRows(); 5. Cell[] getRow(int row) 获取某一行的所有单元格，返回的是单元格对象数组，示例子： jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); Cell[] cell = rs.getRow(0); 6. Cell getCell(int column, int row) 获取指定单元格的对象引用，需要注意的是它的两个参数，第一个是列数，第二个是行数，这与通常的行、列组合有些不同。 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); Cell cell = rs.getCell(0, 0); 生成新的Excel工作薄 下面的代码主要是向大家介绍如何生成简单的Excel工作表，在这里单元格的内容是不带任何修饰的(如：字体，颜色等等)，所有的内容都作为字符串写入。(完整代码见ExcelWriting.java) 与读取Excel工作表相似，首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象，这里要注意的是，只能通过API提供的工厂方法来创建Workbook，而不能使用WritableWorkbook的构造函数，因为类WritableWorkbook的构造函数为protected类型。示例代码片段如下： import java.io.*; import jxl.*; import jxl.write.*; … … … … try { //构建Workbook对象, 只读Workbook对象 //Method 1：创建可写入的Excel工作薄 jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile)); //Method 2：将WritableWorkbook直接写入到输出流 /* OutputStream os = new FileOutputStream(targetfile); jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(os); */ } catch (Exception e) { e.printStackTrace(); } API提供了两种方式来处理可写入的输出流，一种是直接生成本地文件，如果文件名不带全路径的话，缺省的文件会定位在当前目录，如果文件名带有全路径的话，则生成的Excel文件则会定位在相应的目录；另外一种是将Excel对象直接写入到输出流，例如：用户通过浏览器来访问Web服务器，如果HTTP头设置正确的话，浏览器自动调用客户端的Excel应用程序，来显示动态生成的Excel电子表格。 接下来就是要创建工作表，创建工作表的方法与创建工作薄的方法几乎一样，同样是通过工厂模式方法获得相应的对象，该方法需要两个参数，一个是工作表的名称，另一个是工作表在工作薄中的位置，参考下面的代码片段： //创建Excel工作表 jxl.write.WritableSheet ws = wwb.createSheet("Test Sheet 1", 0); "这锅也支好了，材料也准备齐全了，可以开始下锅了！"，现在要做的只是实例化API所提供的Excel基本数据类型，并将它们添加到工作表中就可以了，参考下面的代码片段： //1.添加Label对象 jxl.write.Label labelC = new jxl.write.Label(0, 0, "This is a Label cell"); ws.addCell(labelC); //添加带有字型Formatting的对象 jxl.write.WritableFont wf = new jxl.write.WritableFont(WritableFont.TIMES, 18, WritableFont.BOLD, true); jxl.write.WritableCellFormat wcfF = new jxl.write.WritableCellFormat(wf); jxl.write.Label labelCF = new jxl.write.Label(1, 0, "This is a Label Cell", wcfF); ws.addCell(labelCF); //添加带有字体颜色Formatting的对象 jxl.write.WritableFont wfc = new jxl.write.WritableFont(WritableFont.ARIAL, 10, WritableFont.NO_BOLD, false, UnderlineStyle.NO_UNDERLINE, jxl.format.Colour.RED); jxl.write.WritableCellFormat wcfFC = new jxl.write.WritableCellFormat(wfc); jxl.write.Label labelCFC = new jxl.write.Label(1, 0, "This is a Label Cell", wcfFC); ws.addCell(labelCF); //2.添加Number对象 jxl.write.Number labelN = new jxl.write.Number(0, 1, 3.1415926); ws.addCell(labelN); //添加带有formatting的Number对象 jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##"); jxl.write.WritableCellFormat wcfN = new jxl.write.WritableCellFormat(nf); jxl.write.Number labelNF = new jxl.write.Number(1, 1, 3.1415926, wcfN); ws.addCell(labelNF); //3.添加Boolean对象 jxl.write.Boolean labelB = new jxl.write.Boolean(0, 2, false); ws.addCell(labelB); //4.添加DateTime对象 jxl.write.DateTime labelDT = new jxl.write.DateTime(0, 3, new java.util.Date()); ws.addCell(labelDT); //添加带有formatting的DateFormat对象 jxl.write.DateFormat df = new jxl.write.DateFormat("dd MM yyyy hh:mm:ss"); jxl.write.WritableCellFormat wcfDF = new jxl.write.WritableCellFormat(df); jxl.write.DateTime labelDTF = new jxl.write.DateTime(1, 3, new java.util.Date(), wcfDF); ws.addCell(labelDTF); 这里有两点大家要引起大家的注意。第一点，在构造单元格时，单元格在工作表中的位置就已经确定了。一旦创建后，单元格的位置是不能够变更的，尽管单元格的内容是可以改变的。第二点，单元格的定位是按照下面这样的规律(column, row)，而且下标都是从0开始，例如，A1被存储在(0, 0)，B1被存储在(1, 0)。 最后，不要忘记关闭打开的Excel工作薄对象，以释放占用的内存，参见下面的代码片段： //写入Exel工作表 wwb.write(); //关闭Excel工作薄对象 wwb.close(); 这可能与读取Excel文件的操作有少少不同，在关闭Excel对象之前，你必须要先调用write()方法，因为先前的操作都是存储在缓存中的，所以要通过该方法将操作的内容保存在文件中。如果你先关闭了Excel对象，那么只能得到一张空的工作薄了。 拷贝、更新Excel工作薄 接下来简要介绍一下如何更新一个已经存在的工作薄，主要是下面二步操作，第一步是构造只读的Excel工作薄，第二步是利用已经创建的Excel工作薄创建新的可写入的Excel工作薄，参考下面的代码片段：(完整代码见ExcelModifying.java) //创建只读的Excel工作薄的对象 jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(sourcefile)); //创建可写入的Excel工作薄对象 jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile), rw); //读取第一张工作表 jxl.write.WritableSheet ws = wwb.getSheet(0); //获得第一个单元格对象 jxl.write.WritableCell wc = ws.getWritableCell(0, 0); //判断单元格的类型, 做出相应的转化 if(wc.getType() == CellType.LABEL) { Label l = (Label)wc; l.setString("The value has been modified."); } //写入Excel对象 wwb.write(); //关闭可写入的Excel对象 wwb.close(); //关闭只读的Excel对象 rw.close(); 之所以使用这种方式构建Excel对象，完全是因为效率的原因，因为上面的示例才是API的主要应用。为了提高性能，在读取工作表时，与数据相关的一些输出信息，所有的格式信息，如：字体、颜色等等，是不被处理的，因为我们的目的是获得行数据的值，既使没有了修饰，也不会对行数据的值产生什么影响。唯一的不利之处就是，在内存中会同时保存两个同样的工作表，这样当工作表体积比较大时，会占用相当大的内存，但现在好像内存的大小并不是什么关键因素了。 一旦获得了可写入的工作表对象，我们就可以对单元格对象进行更新的操作了，在这里我们不必调用API提供的add()方法，因为单元格已经于工作表当中，所以我们只需要调用相应的setXXX()方法，就可以完成更新的操作了。 尽单元格原有的格式化修饰是不能去掉的，我们还是可以将新的单元格修饰加上去，以使单元格的内容以不同的形式表现。 新生成的工作表对象是可写入的，我们除了更新原有的单元格外，还可以添加新的单元格到工作表中，这与示例2的操作是完全一样的。 最后，不要忘记调用write()方法，将更新的内容写入到文件中，然后关闭工作薄对象，这里有两个工作薄对象要关闭，一个是只读的，另外一个是可写入的。 小结 本文只是对Java Excel API中常用的方法作了介绍，要想更详尽地了解API，请大家参考API文档，或源代码。Java Excel API是一个开放源码项目，请大家关注它的最新进展，有兴趣的朋友也可以申请加入这个项目，或者是提出宝贵的意见。

基础知识 - Golang 中的格式化输入输出

【格式化输出】

// 格式化输出：将 arg 列表中的 arg 转换为字符串输出

// 使用动词 v 格式化 arg 列表，非字符串元素之间添加空格

Print(arg列表)

// 使用动词 v 格式化 arg 列表，所有元素之间添加空格，结尾添加换行符

Println(arg列表)

// 使用格式字符串格式化 arg 列表

Printf(格式字符串, arg列表)

// Print 类函数会返回已处理的 arg 数量和遇到的错误信息。

【格式字符串】

格式字符串由普通字符和占位符组成，例如：

"abc%+ #8.3[3]vdef"

其中 abc 和 def 是普通字符，其它部分是占位符，占位符以 % 开头（注：%% 将被转义为一个普通的 % 符号，这个不算开头），以动词结尾，格式如下：

%[旗标][宽度][.精度][arg索引]动词

方括号中的内容可以省略。

【旗标】

旗标有以下几种：

空格：对于数值类型的正数，保留一个空白的符号位（其它用法在动词部分说明）。

0 ：用 0 进行宽度填充而不用空格，对于数值类型，符号将被移到所有 0 的前面。

其中 "0" 和 "-" 不能同时使用，优先使用 "-" 而忽略 "0"。

【宽度和精度】

“宽度”和“精度”都可以写成以下三种形式：

数值 | * | arg索引*

其中“数值”表示使用指定的数值作为宽度值或精度值，“ ”表示使用当前正在处理的 arg 的值作为宽度值或精度值，如果这样的话，要格式化的 arg 将自动跳转到下一个。“arg索引 ”表示使用指定 arg 的值作为宽度值或精度值，如果这样的话，要格式化的 arg 将自动跳转到指定 arg 的下一个。

宽度值：用于设置最小宽度。

精度值：对于浮点型，用于控制小数位数，对于字符串或字节数组，用于控制字符数量（不是字节数量）。

对于浮点型而言，动词 g/G 的精度值比较特殊，在适当的情况下，g/G 会设置总有效数字，而不是小数位数。

【arg 索引】

“arg索引”由中括号和 arg 序号组成（就像上面示例中的 [3]），用于指定当前要处理的 arg 的序号，序号从 1 开始：

'[' + arg序号 + ']'

【动词】

“动词”不能省略，不同的数据类型支持的动词不一样。

[通用动词]

v：默认格式，不同类型的默认格式如下：

布尔型：t

整　型：d

浮点型：g

复数型：g

字符串：s

通　道：p

指　针：p

无符号整型：x

T：输出 arg 的类型而不是值（使用 Go 语法格式）。

[布尔型]

t：输出 true 或 false 字符串。

[整型]

b/o/d：输出 2/8/10 进制格式

x/X ：输出 16 进制格式（小写/大写）

c ：输出数值所表示的 Unicode 字符

q ：输出数值所表示的 Unicode 字符（带单引号）。对于无法显示的字符，将输出其转义字符。

U ：输出 Unicode 码点（例如 U+1234，等同于字符串 "U+%04X" 的显示结果）

对于 o/x/X：

如果使用 "#" 旗标，则会添加前导 0 或 0x。

对于 U：

如果使用 "#" 旗标，则会在 Unicode 码点后面添加相应的 '字符'（前提是该字符必须可显示）

[浮点型和复数型]

b ：科学计数法（以 2 为底）

e/E：科学计数法（以 10 为底，小写 e/大写 E）

f/F：普通小数格式（两者无区别）

g/G：大指数（指数 = 6）使用 %e/%E，其它情况使用 %f/%F

[字符串或字节切片]

s ：普通字符串

q ：双引号引起来的 Go 语法字符串

x/X：十六进制编码（小写/大写，以字节为元素进行编码，而不是字符）

对于 q：

如果使用了 "+" 旗标，则将所有非 ASCII 字符都进行转义处理。

如果使用了 "#" 旗标，则输出反引号引起来的字符串（前提是

字符串中不包含任何制表符以外的控制字符，否则忽略 # 旗标）

对于 x/X：

如果使用了 " " 旗标，则在每个元素之间添加空格。

如果使用了 "#" 旗标，则在十六进制格式之前添加 0x 前缀。

[指针类型]

p ：带 0x 前缀的十六进制地址值。

[符合类型]

复合类型将使用不同的格式输出，格式如下：

结　构　体：{字段1 字段2 ...}

数组或切片：[元素0 元素1 ...]

映　射：map[键1:值1 键2:值2 ...]

指向符合元素的指针：{}, [], map[]

复合类型本身没有动词，动词将应用到复合类型的元素上。

结构体可以使用 "+v" 同时输出字段名。

【注意】

1、如果 arg 是一个反射值，则该 arg 将被它所持有的具体值所取代。

2、如果 arg 实现了 Formatter 接口，将调用它的 Format 方法完成格式化。

3、如果 v 动词使用了 # 旗标（%#v），并且 arg 实现了 GoStringer 接口，将调用它的 GoString 方法完成格式化。

如果格式化操作指定了字符串相关的动词（比如 %s、%q、%v、%x、%X），接下来的两条规则将适用：

4。如果 arg 实现了 error 接口，将调用它的 Error 方法完成格式化。

5。如果 arg 实现了 string 接口，将调用它的 String 方法完成格式化。

在实现格式化相关接口的时候，要避免无限递归的情况，比如：

type X string

func (x X) String() string {

return Sprintf("%s", x)

}

在格式化之前，要先转换数据类型，这样就可以避免无限递归：

func (x X) String() string {

return Sprintf("%s", string(x))

}

无限递归也可能发生在自引用数据类型上面，比如一个切片的元素引用了切片自身。这种情况比较罕见，比如：

a := make([]interface{}, 1)

a[0] = a

fmt.Println(a)

【格式化输入】

// 格式化输入：从输入端读取字符串（以空白分隔的值的序列），

// 并解析为具体的值存入相应的 arg 中，arg 必须是变量地址。

// 字符串中的连续空白视为单个空白，换行符根据不同情况处理。

// \r\n 被当做 \n 处理。

// 以动词 v 解析字符串，换行视为空白

Scan(arg列表)

// 以动词 v 解析字符串，换行结束解析

Scanln(arg列表)

// 根据格式字符串中指定的格式解析字符串

// 格式字符串中的换行符必须和输入端的换行符相匹配。

Scanf(格式字符串, arg列表)

// Scan 类函数会返回已处理的 arg 数量和遇到的错误信息。

【格式字符串】

格式字符串类似于 Printf 中的格式字符串，但下面的动词和旗标例外：

p ：无效

T ：无效

e/E/f/F/g/G：功能相同，都是扫描浮点数或复数

s/v ：对字符串而言，扫描一个被空白分隔的子串

对于整型 arg 而言，v 动词可以扫描带有前导 0 或 0x 的八进制或十六进制数值。

宽度被用来指定最大扫描宽度（不会跨越空格），精度不被支持。

如果 arg 实现了 Scanner 接口，将调用它的 Scan 方法扫描相应数据。只有基础类型和实现了 Scanner 接口的类型可以使用 Scan 类方法进行扫描。

【注意】

连续调用 FScan 可能会丢失数据，因为 FScan 中使用了 UnreadRune 对读取的数据进行撤销，而参数 io.Reader 只有 Read 方法，不支持撤销。比如：

标题名称：go语言控制它输出表格库 go语言输出hello word
当前URL：http://azwzsj.com/article/ddodcgg.html