精华内容
下载资源
问答
  • go语言字符串格式化

    2017-08-15 09:22:01
    Go语言字符串格式化提供了良好的支持。下面通过代码展示字符串的格式化。 package main import "fmt" import "os" type point struct { x, y int } func main() { // Go提供了几种打印格式,用来格式化一般...

    Go语言对字符串格式化提供了良好的支持。下面通过代码展示字符串的格式化。

    package main
    
    import "fmt"
    import "os"
    
    type point struct {
        x, y int
    }
    
    func main() {
    
        // Go提供了几种打印格式,用来格式化一般的Go值,例如
        // 下面的%v打印了一个point结构体的对象的值
        p := point{1, 2}
        fmt.Printf("%v\n", p)
    
        // 如果所格式化的值是一个结构体对象,那么`%+v`的格式化输出
        // 将包括结构体的成员名称和值
        fmt.Printf("%+v\n", p)
    
        // `%#v`格式化输出将输出一个值的Go语法表示方式。
        fmt.Printf("%#v\n", p)
    
        // 使用`%T`来输出一个值的数据类型
        fmt.Printf("%T\n", p)
    
        // 格式化布尔型变量
        fmt.Printf("%t\n", true)
    
        // 有很多的方式可以格式化整型,使用`%d`是一种
        // 标准的以10进制来输出整型的方式
        fmt.Printf("%d\n", 123)
    
        // 这种方式输出整型的二进制表示方式
        fmt.Printf("%b\n", 14)
    
        // 这里打印出该整型数值所对应的字符
        fmt.Printf("%c\n", 33)
    
        // 使用`%x`输出一个值的16进制表示方式
        fmt.Printf("%x\n", 456)
    
        // 浮点型数值也有几种格式化方法。最基本的一种是`%f`
        fmt.Printf("%f\n", 78.9)
    
        // `%e`和`%E`使用科学计数法来输出整型
        fmt.Printf("%e\n", 123400000.0)
        fmt.Printf("%E\n", 123400000.0)
    
        // 使用`%s`输出基本的字符串
        fmt.Printf("%s\n", "\"string\"")
    
        // 输出像Go源码中那样带双引号的字符串,需使用`%q`
        fmt.Printf("%q\n", "\"string\"")
    
        // `%x`以16进制输出字符串,每个字符串的字节用两个字符输出
        fmt.Printf("%x\n", "hex this")
    
        // 使用`%p`输出一个指针的值
        fmt.Printf("%p\n", &p)
    
        // 当输出数字的时候,经常需要去控制输出的宽度和精度。
        // 可以使用一个位于%后面的数字来控制输出的宽度,默认
        // 情况下输出是右对齐的,左边加上空格
        fmt.Printf("|%6d|%6d|\n", 12, 345)
    
        // 你也可以指定浮点数的输出宽度,同时你还可以指定浮点数
        // 的输出精度
        fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
    
        // To left-justify, use the `-` flag.
        fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
    
        // 你也可以指定输出字符串的宽度来保证它们输出对齐。默认
        // 情况下,输出是右对齐的
        fmt.Printf("|%6s|%6s|\n", "foo", "b")
    
        // 为了使用左对齐你可以在宽度之前加上`-`号
        fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
    
        // `Printf`函数的输出是输出到命令行`os.Stdout`的,你
        // 可以用`Sprintf`来将格式化后的字符串赋值给一个变量
        s := fmt.Sprintf("a %s", "string")
        fmt.Println(s)
    
        // 你也可以使用`Fprintf`来将格式化后的值输出到`io.Writers`
        fmt.Fprintf(os.Stderr, "an %s\n", "error")
    }

    运行结果

    {1 2}
    {x:1 y:2}
    main.point{x:1, y:2}
    main.point
    true
    123
    1110
    !
    1c8
    78.900000
    1.234000e+08
    1.234000E+08
    "string"
    "\"string\""
    6865782074686973
    0x103a10c0
    |    12|   345|
    |  1.20|  3.45|
    |1.20  |3.45  |
    |   foo|     b|
    |foo   |b     |
    a string
    an error
    转自:http://blog.csdn.net/fer_ba/article/details/38293157
    参考:http://blog.csdn.net/liuxinmingcode/article/details/50448278
    展开全文
  •  格式化样式:字符串形式,格式化动词以%开头。  参数列表:多个参数以逗号分隔,个数必须与格式化样式中的个数一一对应,否则运行时会报错  在GO语言中,格式化的命名延续C语言的风格: var progress = 2 ...

    一,格式化在逻辑中非常常用。使用格式化函数,要注意写法:

      fmt.Sprintf(格式化样式, 参数列表…)

        格式化样式:字符串形式,格式化动词以%开头。

        参数列表:多个参数以逗号分隔,个数必须与格式化样式中的个数一一对应,否则运行时会报错

      在GO语言中,格式化的命名延续C语言的风格:

    var progress = 2
    var target = 8
    // 两参数格式化
    title := fmt.Sprintf("已采集%d个药草, 还需要%d个完成任务", progress, target)
    fmt.Println(title)
    pi := 3.14159
    // 按数值本身的格式输出
    variant := fmt.Sprintf("%v %v %v", "月球基地", pi, true)
    fmt.Println(variant)
    // 匿名结构体声明, 并赋予初值
    profile := &struct {
        Name string
        HP   int
    }{
        Name: "rat",
        HP:   150,
    }
    fmt.Printf("使用'%%+v' %+v\n", profile)
    fmt.Printf("使用'%%#v' %#v\n", profile)
    fmt.Printf("使用'%%T' %T\n", profile)
    
    /*
    已采集2个药草, 还需要8个完成任务
    "月球基地" 3.14159 true
    使用'%+v' &{Name:rat HP:150}
    使用'%#v' &struct { Name string; HP int }{Name:"rat", HP:150}
    使用'%T' *struct { Name string; HP int }C语言中, 使用%d代表整型参数
    */
    

      字符串格式化常用的动词和功能:

      

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

        

    转载于:https://www.cnblogs.com/laogao123/p/10895479.html

    展开全文
  • Go语言格式化字符串

    2017-10-26 22:54:00
    %s: 普通字符串 %q: 引号包含字符串 %x, %o, %b: 十六进制,8进制,2进制 %t: bool值 %d decimal integer %v any value in a natural format %T: type of any value %% literal percent sign 转载于:...

    %s: 普通字符串

    %q: 引号包含字符串

    %x, %o, %b: 十六进制,8进制,2进制

    %t: bool值

    %d decimal integer

    %v any value in a natural format

    %T: type of any value

    %% literal percent sign

    转载于:https://www.cnblogs.com/mkxzy/p/7740045.html

    展开全文
  • GO 语言中,我们可以使用 strings 标准库对字符串进行一系列操作,strings 标准库在日常的编程过程中是十分常用的,这里向大家介绍strings标准库的使用,希望对你有帮助。 一、字符串切割 1. 字符串前后端字符...

    在 GO 语言中,我们可以使用 strings 标准库对字符串进行一系列操作,strings 标准库在日常的编程过程中是十分常用的,这里向大家介绍strings标准库的使用,希望对你有帮助。

    一、字符串切割

    1. 字符串前后端字符清理

    // 返回将s前后端所有cutset包含的utf-8码值都去掉的字符串。
    func Trim(s string, cutset string) string
    // 返回将s前后端所有空白(unicode.IsSpace指定)都去掉的字符串。
    func TrimSpace(s string) string
    // 返回将s前端所有cutset包含的utf-8码值都去掉的字符串。
    func TrimLeft(s string, cutset string) string
    // 返回将s后端所有cutset包含的utf-8码值都去掉的字符串。
    func TrimRight(s string, cutset string) string
    // 返回去除s可能的前缀prefix的字符串。
    func TrimPrefix(s, prefix string) string
    // 返回去除s可能的后缀suffix的字符串。
    func TrimSuffix(s, suffix string) string
    

    2. 分割字符

    // 返回将字符串按照空白(unicode.IsSpace确定,可以是一到多个连续的空白字符)分割的多个字符串。
    // 如果字符串全部是空白或者是空字符串的话,会返回空切片。
    func Fields(s string) []string
    // 用去掉s中出现的sep的方式进行分割,会分割到结尾,并返回生成的所有片段组成的切片(每一个sep都会进行一次切割,即使两个sep相邻,也会进行两次切割)。
    // 如果sep为空字符,Split会将s切分成每一个unicode码值一个字符串。
    func Split(s, sep string) []string
    

    二、字符串查找

    1. 子串sep在字符串s中第一次出现的位置,不存在则返回-1

    func Index(s, sep string) int
    

    2. 字符c在s中第一次出现的位置,不存在则返回-1

    func IndexByte(s string, c byte) int
    

    3. unicode码值r在s中第一次出现的位置,不存在则返回-1

    func IndexRune(s string, r rune) int
    

    4. 字符串chars中的任一utf-8码值在s中第一次出现的位置,如果不存在或者chars为空字符串则返回-1

    func IndexAny(s, chars string) int
    

    5. s中第一个满足函数f的位置i(该处的utf-8码值r满足f®==true),不存在则返回-1

    func IndexFunc(s string, f func(rune) bool) int
    

    6. 子串sep在字符串s中最后一次出现的位置,不存在则返回-1

    func LastIndex(s, sep string) int
    

    7. 字符串chars中的任一utf-8码值在s中最后一次出现的位置,如不存在或者chars为空字符串则返回-1

    func LastIndexAny(s, chars string) int
    

    8. s中最后一个满足函数f的unicode码值的位置i,不存在则返回-1

    func LastIndexFunc(s string, f func(rune) bool) int
    

    三、字符串转换

    1. 大小写转换

    // 返回s中每个单词的首字母都改为标题格式的字符串拷贝,相当于首字母大写
    func Title(s string) string
    // 返回将所有字母都转为对应的小写版本的拷贝。
    func ToLower(s string) string
    // 返回将所有字母都转为对应的大写版本的拷贝。
    func ToUpper(s string) string
    // 返回将所有字母都转为对应的标题版本的拷贝,会将所有字母大写
    func ToTitle(s string) string
    

    2. 字符串替换

    // 返回将s中前n个不重叠old子串都替换为new的新字符串,如果n<0会替换所有old子串。
    func Replace(s, old, new string, n int) string
    // 将s的每一个unicode码值r都替换为mapping(r),返回这些新码值组成的字符串拷贝。
    // 如果mapping返回一个负值,将会丢弃该码值而不会被替换。(返回值中对应位置将没有码值)
    func Map(mapping func(rune) rune, s string) string
    

    四、 字符串连接

    1. 返回count个s串联的字符串

    func Repeat(s string, count int) string
    

    2. 将一系列字符串连接为一个字符串,之间用sep来分隔

    func Join(a []string, sep string) string
    

    五、其他功能

    1. 判断字符串s是否包含utf-8码值r

    func ContainsRune(s string, r rune) bool
    

    2. 判断字符串s是否包含字符串chars中的任一字符

    func ContainsAny(s, chars string) bool
    

    3. 返回字符串s中有几个不重复的sep子串

    func Count(s, sep string) int
    

    六、 常见案例

    1. 删除字符串末尾的换行符

    package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
    	str := `Hello World
    
    `
    	fmt.Println(str)
    	// 方法一
    	fmt.Println(strings.TrimRight(str, "\n"))
    	// 方法二
    	fmt.Println(strings.TrimSpace(str))
    	// 方法三
    	fmt.Println(strings.Trim(str, "\n"))
    	// 方法四
    	fmt.Println(strings.Replace(str, "\n", "", -1))
    }
    

    2. 将字符串转换为大写

    package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
    	str := `Hello World`
    	// 方法一
    	fmt.Println(strings.ToTitle(str))
    	// 方法二
    	fmt.Println(strings.ToUpper(str))
    }
    

    3. 以冒号为分隔符,切割字符串

    package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
    	str := `root:x:0:0:root:/root:/bin/bash`
    	// 方法一
    	fmt.Println(strings.Split(str, ":"))
    }
    

    4. 替换字符串

    package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
    	str := `    Hello World randow_w1    `
    	// 方法一
    	fmt.Println(strings.Replace(str, "randow_w1", "everyone", -1))
    }
    

    5. 去除字符串两边的空格

    package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
    	str := `    Hello World    `
    	fmt.Println(str)
    	// 方法一
    	fmt.Println(strings.Trim(str, " "))
    	// 方法二
    	fmt.Println(strings.TrimSpace(str))
    	// 方法三
    	fmt.Println(strings.TrimRight(str, " ")) // 去除右边空格
    	// 方法四
    	fmt.Println(strings.TrimLeft(str, " ")) // 去除左边空格
    }
    

    6. 将切片以空格为连接符组成一个字符串

    package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
    	books := []string{"Math", "Chinese", "Science", "English"}
    	// 方法一
    	fmt.Println(strings.Join(books, " "))
    }
    
    展开全文
  • Go语言 字符串

    2014-10-29 00:18:00
    在所有编程语言中都涉及... 需要注意的是在Go字符串是有UTF-8编码的,请注意保存文件时将文件编码格式改成UTF-8(特别是在windows下)。 初始 var str string //声明一个字符串 str = "laoYu" //赋值 ch :=...
  • package main import ( "fmt" "time" ) func main() { fmt.Println(time.Now().Format("2006年01月02日 15点04分05秒")) fmt.Println(time.Now().... fmt.Println(time.No...
  • 直接看代码: //字符串输出 var sayHi string = "hello world" fmt.Println(sayHi) // \ 转义 fmt.Println("hello \nworld...// ` 可以将字符串按设定格式输出 fmt.Println(`hello "world`) //浮点类型格式输出 var

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 204
精华内容 81
关键字:

go语言字符串格式化