zhe.ink此技术通过使用索引从列表的开头移动到末尾来传递元素列表。检查每个元素，如果它与搜索项不匹配，则检查下一个项。
示例代码：
package main
import "fmt"
func linearsearch(datalist []int, key int) bool {
for _, item := range datalist {
if item == key {
return true
}
}
return false
}
func main() {
items := []int{95,78,46,58,45,86,99,251,320}
fmt.Println(linearsearch(items,58))
}输出：
true
示例代码：传递指针方式
package main
import "fmt"
func linearsearch(datalist *[]int, key int) bool {
for i := 0; i < len(*datalist); i++ {
if (*datalist)[i] == key {
return true
}
}
return false
}
func main() {
items := []int{95, 78, 46, 58, 45, 86, 99, 251, 320}
fmt.Println(linearsearch(&items, 58))
}输出：
true实现Go接口是隐式完成的。在Go中，无需通过指定任何关键字将接口显式实现到具体类型中。若要将接口实现为具体类型，只需为方法提供与接口类型中定义的签名相同的签名即可。
接口类型是用关键字interface定义的。接口定义了一组方法(方法集)，但这些方法不包含代码：它们没有实现(它们是抽象的)。方法集是类型必须具有的方法列表，以便实现接口。此外，接口不能包含变量。
声明接口：
type catalog interface {
shipping() float64
tax() float64
}实现接口：
以下源代码将可配置类型显示为接口类型目录的实现。可配置类型被定义为具有接收方方法、运输和税费的结构。这一事实自动将可配置限定为目录的实现：
package main
import "fmt"
type catalog interface {
shipping() float64
tax() float64
}
type configurable struct {
name string
price, qty float64
}
func (c *configurable) tax() float64{
return c.price * c.qty * 0.05
}
func (c *configurable) shipping() float64{
return c.qty * 5
}
func main() {
tshirt := configurable{}
tshirt.price = 250
tshirt.qty = 2
fmt.Println("Shipping Charge: ", tshirt.shipping())
fmt.Println("Tax: ", tshirt.tax())
}输出：
Shipping Charge: 10
Tax: 25
使用Go接口进行子类型化：
示例代码：
package main
import "fmt"
type catalog interface {
shipping() float64
tax() float64
}
type configurable struct {
name string
price, qty float64
}
func (c *configurable) tax() float64{
return c.price * c.qty * 0.05
}
func (c *configurable) shipping() float64{
return c.qty * 5
}
type download struct{
name string
price, qty float64
}
func (d *download) tax() float64{
return d.price * d.qty * 0.07
}
type simple struct {
name string
price, qty float64
}
func (s *simple) tax() float64{
return s.price * s.qty * 0.03
}
func (s *simple) shipping() float64{
return s.qty * 3
}
func main() {
tshirt := configurable{}
tshirt.price = 250
tshirt.qty = 2
fmt.Println("Configurable Product")
fmt.Println("Shipping Charge: ", tshirt.shipping())
fmt.Println("Tax: ", tshirt.tax())
mobile := simple{"Samsung S-7",10,25}
fmt.Println("\nSimple Product")
fmt.Println("Shipping Charge: ", mobile.shipping())
fmt.Println("Tax: ", mobile.tax())
book := download{"Python in 24 Hours",19,1}
fmt.Println("\nDownloadable Product")
fmt.Println("Tax: ", book.tax())
}输出：
Configurable Product
Shipping Charge: 10
Tax: 25
Simple Product
Shipping Charge: 75
Tax: 7.5
Downloadable Product
Tax: 1.33
实现多个接口给：
在GO中，接口的隐式机制允许同时满足多个接口类型。这可以通过将给定类型的方法集与每个接口类型的方法相交来实现。让我们重新实现前面的代码。已创建新的界面折扣。如下图所示：
package main
import "fmt"
type catalog interface {
shipping() float64
tax() float64
}
type discount interface{
offer() float64
}
type configurable struct {
name string
price, qty float64
}
func (c *configurable) tax() float64{
return c.price * c.qty * 0.05
}
func (c *configurable) shipping() float64{
return c.qty * 5
}
func (c *configurable) offer() float64{
return c.price * 0.15
}
type download struct{
name string
price, qty float64
}
func (d *download) tax() float64{
return d.price * d.qty * 0.10
}
type simple struct {
name string
price, qty float64
}
func (s *simple) tax() float64{
return s.price * s.qty * 0.03
}
func (s *simple) shipping() float64{
return s.qty * 3
}
func (s *simple) offer() float64{
return s.price * 0.10
}
func main() {
tshirt := configurable{}
tshirt.price = 250
tshirt.qty = 2
fmt.Println("Configurable Product")
fmt.Println("Shipping Charge: ", tshirt.shipping())
fmt.Println("Tax: ", tshirt.tax())
fmt.Println("Discount: ", tshirt.offer())
mobile := simple{"Samsung S-7",3000,2}
fmt.Println("\nSimple Product")
fmt.Println(mobile.name)
fmt.Println("Shipping Charge: ", mobile.shipping())
fmt.Println("Tax: ", mobile.tax())
fmt.Println("Discount: ", mobile.offer())
book := download{"Python in 24 Hours",50,1}
fmt.Println("\nDownloadable Product")
fmt.Println(book.name)
fmt.Println("Tax: ", book.tax())
}输出：
Configurable Product
Shipping Charge: 10
Tax: 25
Discount: 37.5
Simple Product
Samsung S-7
Shipping Charge: 6
Tax: 180
Discount: 300
Downloadable Product
Python in 24 Hours
Tax: 5
接口嵌入：
在GO中，接口类型也支持类型嵌入(类似于struct类型)。这使您可以灵活地以最大化类型重用的方式构建类型。
继续目录示例，声明了一个结构可配置，其中嵌入了类型折扣和礼品包。在这里，您可以创建更具体的目录界面类型。由于giftpack和discount类型是目录接口的实现，因此可配置类型也是目录接口的实现。在类型折扣和礼品包类型中定义的所有字段和方法也可在可配置类型中使用。
示例代码：
package main
import "fmt"
type discount interface{
offer() float64
}
type giftpack interface{
available() string
}
type catalog interface {
discount
giftpack
shipping() float64
tax() float64
}
type configurable struct {
name string
price, qty float64
}
func (c *configurable) tax() float64{
return c.price * c.qty * 0.05
}
func (c *configurable) shipping() float64{
return c.qty * 5
}
func (c *configurable) offer() float64{
return c.price * 0.15
}
func (c *configurable) available() string{
if c.price > 1000{
return "Gift Pack Available"
}
return "Gift Pack not Available"
}
type download struct{
name string
price, qty float64
}
func (d *download) tax() float64{
return d.price * d.qty * 0.10
}
func (d *download) available() string{
if d.price > 500{
return "Gift Pack Available"
}
return "Gift Pack not Available"
}
type simple struct {
name string
price, qty float64
}
func (s *simple) tax() float64{
return s.price * s.qty * 0.03
}
func (s *simple) shipping() float64{
return s.qty * 3
}
func (s *simple) offer() float64{
return s.price * 0.10
}
func main() {
tshirt := configurable{}
tshirt.price = 1550
tshirt.qty = 2
fmt.Println("Configurable Product")
fmt.Println("Shipping Charge: ", tshirt.shipping())
fmt.Println("Tax: ", tshirt.tax())
fmt.Println("Discount: ", tshirt.offer())
fmt.Println(tshirt.available())
mobile := simple{"Samsung S-7",3000,2}
fmt.Println("\nSimple Product")
fmt.Println(mobile.name)
fmt.Println("Shipping Charge: ", mobile.shipping())
fmt.Println("Tax: ", mobile.tax())
fmt.Println("Discount: ", mobile.offer())
book := download{"Python in 24 Hours",50,1}
fmt.Println("\nDownloadable Product")
fmt.Println(book.name)
fmt.Println("Tax: ", book.tax())
fmt.Println(book.available())
}输出：
Configurable Product
Shipping Charge: 10
Tax: 155
Discount: 232.5
Gift Pack Available
Simple Product
Samsung S-7
Shipping Charge: 6
Tax: 180
Discount: 300
Downloadable Product
Python in 24 Hours
Tax: 5
Gift Pack not AvailableGo中的方法：
方法的定义与任何其他Go函数一样。当Go函数在有限范围内定义或附加特定类型时，它被称为方法。方法提供了一种向用户定义类型添加行为的方法。方法实际上是包含一个额外参数的函数，该参数在关键字func和函数名称之间声明。
在Go中，方法是一种特殊的函数，它作用于某种类型的变量，称为接收器，它是放置在方法名称之前的额外参数，用于指定方法附加到的目标类型。接收器类型可以是任何东西，而不仅仅是结构类型：任何类型都可以有方法，甚至是函数类型或int、bool、string或数组的别名类型。
方法的一般格式为：
func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }
接收器在 ( ) 中指定，在func关键字之后的方法名称之前。
下面是非结构类型的方法示例：
关键字func和函数名称之间的参数称为接收器，并将函数绑定到指定的类型。当函数具有接收器时，该函数称为方法。
Go中有两种类型的接收器：值接收器和指针接收器。在上面的程序中，tentimes方法使用值接收器声明。multiply接收器被声明为int类型的值。使用值接收器声明方法时，该方法将始终针对用于进行方法调用的值的副本进行操作。
mul变量初始化为multiply类型。因此，当我们调用tentimes方法时，可以使用mul.tentimes() 访问tentimes方法，mul的值是调用的接收器值，tentimes方法正在该值的副本上运行。
package main
import "fmt"
type multiply int
func (m multiply) tentimes() int {
return int(m * 10)
}
func main() {
var num int
fmt.Print("Enter any positive integer: ")
fmt.Scanln(&num)
mul:= multiply(num)
fmt.Println("Ten times of a given number is: ",mul.tentimes())
}输出：
Enter any positive integer: 5
Ten times of a given number is: 50
下面是一个程序，它通过receiver参数(称为类型的方法集)显示附加到类型的方法数的实现。
package main
import "fmt"
type salary float64
func (s salary) total() total {
return total(s)
}
type total float64
func (t total) hra() hra {
t += t * 0.3 // 30% HRA Addition
return hra(t)
}
func (t total) salary() salary {
t -=t * 0.10 // 10% Tax Deduction
return salary(t)
}
type hra float64
func (h hra) basic() basic {
h += h * 0.3 // 30% HRA Addition
return basic(h)
}
func (h hra) total() total {
return total(h)
}
type basic float64
func (b basic) total() total {
return total(b)
}
func main() {
fmt.Println("Salary calculation for First Employee:")
sal1 := basic(9000.00)
fmt.Println(sal1.total())
fmt.Println(sal1.total().hra().total())
fmt.Println(sal1.total().hra().total().salary())
fmt.Println("\nSalary calculation for Second Employee:")
sal2 := basic(5000.00)
fmt.Println(sal2.total())
fmt.Println(sal2.total().salary())
}输出：
Salary calculation for First Employee:
9000
11700
10530
Salary calculation for Second Employee:
5000
4500
方法重载：
方法重载是可能的，具有相同名称的方法可以存在于2种不同的接收器类型上，Receiver参数可以作为基类型的值或指针传递。指针接收器参数在Go中应用广泛。
示例代码：
package main
import "fmt"
type multiply int
type addition int
func (m *multiply) twice() {
*m = multiply(*m * 2)
}
func (a *addition) twice() {
*a = addition(*a + *a)
}
func main() {
var mul multiply = 15
mul.twice()
fmt.Println(mul)
var add addition = 15
add.twice()
fmt.Println(add)
}输出：
30
30
使用指针接收器声明方法的示例。
在main() 中，我们自己不必弄清楚是否在指针上调用方法，Go为我们做到了这一点。mul1是一个值，mul2是一个指针，但方法调用工作得很好。
package main
import "fmt"
type multiply struct {
num int
}
func (m *multiply) twice(n int) {
m.num = n*2
}
func (m multiply) display() int{
return m.num
}
func main() {
fmt.Println("Call by value")
var mul1 multiply // mul1值类型mul1.twice(10)
fmt.Println(mul1.display())
fmt.Println("Call by pointer")
mul2 := new(multiply) // mul2指针类型mul2.twice(10)
fmt.Println(mul2.display())
}输出：
Call by value
20
Call by pointer
20
Go中的对象：
在Go中，没有类类型作为对象基础的概念。Go中的任何数据类型都可以用作对象。Go中的struct类型可以接收一组方法来定义其行为。GO中不存在称为类或对象的特殊类型。Go中的strct类型与其他编程语言中通常称为对象的东西相吻合。Go支持通常归因于面向对象编程的大多数概念。
在包和可扩展类型系统等概念的帮助下，Go的核心支持物理和逻辑模块化;因此，我们能够在Go中实现模块化和封装。
新声明的名称类型不会继承其基础类型的所有属性，并且类型系统会以不同的方式处理。因此，GO不支持通过继承进行多态性。但是，可以使用结构体或接口等类型通过组合来创建对象并表达其多态关系。
让我们从下面的简单例子开始，来演示如何将结构类型用作可以实现多态组合的对象。
示例代码：
package main
import "fmt"
type gadgets uint8
const (
Camera gadgets = iota
Bluetooth
Media
Storage
VideoCalling
Multitasking
Messaging
)
type mobile struct {
make string
model string
}
type smartphone struct {
gadgets gadgets
}
func (s *smartphone) launch() {
fmt.Println ("New Smartphone Launched:")
}
type android struct {
mobile
smartphone
waterproof string
}
func (a *android) samsung() {
fmt.Printf("%s %s\n",
a.make, a.model)
}
type iphone struct {
mobile
smartphone
sensor int
}
func (i *iphone) apple() {
fmt.Printf("%s %s\n",
i.make, i.model)
}
func main() {
t := &android {}
t.make ="Samsung"
t.model ="Galaxy J7 Prime"
t.gadgets = Camera+Bluetooth+Media+Storage+VideoCalling+Multitasking+Messaging
t.launch()
t.samsung()
}输出：
New Smartphone Launched:
Samsung Galaxy J7 Prime在上面的程序中，使用组合继承原则，利用结构类型支持的类型嵌入机制实现多态性。在这里，每种类型都是独立的，并且被认为与所有其他类型不同。上面的程序表明，iphone和android类型是通过子类型关系的移动的。
然而，被调用的t.launch() 方法，无论是iphone还是android，都不是名为launch() 的方法的接收器。launch() 方法是为智能手机类型定义的。由于智能手机类型嵌入在iphone和android类型中，因此launch() 方法在范围内被提升到这些封闭类型，因此可以访问。
Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：
Title函数：
Title函数将每个单词的第一个字符转换为大写。
func Title(s string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Title("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
fmt.Println(strings.Title("BAVARIA HESSE BRANDENBURG SAARLAND"))
fmt.Println(strings.Title("towns and cities"))
}输出：
Germany Is A Western European Country With A Landscape Of Forests, Rivers, Mountain Ranges And North Sea Beaches.
BAVARIA HESSE BRANDENBURG SAARLAND
Towns And Cities
ToTitle函数：
ToTitle函数将每个单词的所有字符转换为大写。
func ToTitle(s string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.ToTitle("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
fmt.Println(strings.ToTitle("BAVARIA HESSE BRANDENBURG SAARLAND"))
fmt.Println(strings.ToTitle("towns and cities"))
}输出：
GERMANY IS A WESTERN EUROPEAN COUNTRY WITH A LANDSCAPE OF FORESTS, RIVERS, MOUNTAIN RANGES AND NORTH SEA BEACHES.
BAVARIA HESSE BRANDENBURG SAARLAND
TOWNS AND CITIES
ToLower函数：
ToLower函数将每个单词的所有字符转换为小写。
func ToLower(s string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.ToLower("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
fmt.Println(strings.ToLower("BAVARIA HESSE BRANDENBURG SAARLAND"))
fmt.Println(strings.ToLower("towns and cities"))
}输出：
germany is a western european country with a landscape of forests, rivers, mountain ranges and north sea beaches.
bavaria hesse brandenburg saarland
towns and cities
ToUpper函数：
ToUpper函数将每个单词的所有字符转换为大写。
func ToUpper(s string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.ToUpper("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
fmt.Println(strings.ToUpper("BAVARIA HESSE BRANDENBURG SAARLAND"))
fmt.Println(strings.ToUpper("towns and cities"))
}输出：
GERMANY IS A WESTERN EUROPEAN COUNTRY WITH A LANDSCAPE OF FORESTS, RIVERS, MOUNTAIN RANGES AND NORTH SEA BEACHES.
BAVARIA HESSE BRANDENBURG SAARLAND
TOWNS AND CITIES
Trim函数：区分大小写
Trim函数从字符串s的两边删除预定义的字符cutset。
func Trim(s string, cutset string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Trim("0120 2510", "0"))
fmt.Println(strings.Trim("abcd axyz", "a"))
fmt.Println(strings.Trim("abcd axyz", "A"))
fmt.Println(strings.Trim("! Abcd dcbA !", "A"))
fmt.Println(strings.Trim("! Abcd dcbA !", "!"))
fmt.Println(strings.Trim(" Abcd dcbA ", " "))
}输出：
120 251
bcd axyz
abcd axyz
! Abcd dcbA !
Abcd dcbA
Abcd dcbA
TrimLeft函数：区分大小写
TrimLeft函数仅从字符串s的左侧删除预定义字符剪切集。
func TrimLeft(s string, cutset string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.TrimLeft("0120 2510", "0"))
fmt.Println(strings.TrimLeft("abcd axyz", "a"))
fmt.Println(strings.TrimLeft("abcd axyz", "A"))
fmt.Println(strings.TrimLeft("! Abcd dcbA !", "A"))
fmt.Println(strings.TrimLeft("! Abcd dcbA !", "!"))
fmt.Println(strings.TrimLeft(" Abcd dcbA ", " "))
}输出：
120 2510
bcd axyz
abcd axyz
! Abcd dcbA !
Abcd dcbA !
Abcd dcbA
TrimRight函数：区分大小写
TrimRight函数仅从字符串s的右侧删除预定义的字符剪切集。
func TrimRight(s string, cutset string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.TrimRight("0120 2510", "0"))
fmt.Println(strings.TrimRight("abcd axyz", "a"))
fmt.Println(strings.TrimRight("abcd axyz", "A"))
fmt.Println(strings.TrimRight("! Abcd dcbA !", "A"))
fmt.Println(strings.TrimRight("! Abcd dcbA !", "!"))
fmt.Println(strings.TrimRight(" Abcd dcbA ", " "))
}输出：
0120 251
abcd axyz
abcd axyz
! Abcd dcbA !
! Abcd dcbA
Abcd dcbA
TrimSpace函数：
TrimSpace函数从字符串的两边删除空格和其他预定义字符。
"\t" - 制表符 "\n" - 换行
符 "\x0B" - 垂直制表符 "\r" - 回车符
" " - 普通空格
func TrimSpace(s string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.TrimSpace(" New Zealand is a country in the southwestern Pacific Ocean "))
fmt.Println(strings.TrimSpace(" \t\n New Zealand is a country in the southwestern Pacific Ocean \t\n "))
fmt.Println(strings.TrimSpace(" \t\n\r\x0BNew Zealand is a country in the southwestern Pacific Ocean\t\n "))
}输出：
New Zealand is a country in the southwestern Pacific Ocean
New Zealand is a country in the southwestern Pacific Ocean
New Zealand is a country in the southwestern Pacific Ocean
TrimPrefix函数：区分大小写
TrimPrefix函数从S字符串的开头删除前缀字符串。如果S不以前缀开头，则返回S不变。
func TrimPrefix(S string, prefix string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
var s string
s = "Australia Canada Japan"
s = strings.TrimPrefix(s, "Australia")
s = strings.TrimSpace(s)
fmt.Println(s)
s = "Australia Canada Japan"
s = strings.TrimPrefix(s, "australia")
fmt.Println(s)
s = "\nAustralia-Canada-Japan"
s = strings.TrimPrefix(s, "\n")
fmt.Println(s)
s = "\tAustralia-Canada-Japan"
s = strings.TrimPrefix(s, "\t")
fmt.Println(s)
}输出：
Canada Japan
Australia Canada Japan
Australia-Canada-Japan
Australia-Canada-JapanGolang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：
Join函数：
Join() 函数从切片的元素返回一个字符串。Join将字符串Slice的元素连接起来以创建单个字符串。分隔符字符串sep指定在生成的字符串中的切片元素之间放置的内容。
func Join(stringSlice []string, sep string) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
// Slice of strings
textString := []string{"Australia", "Japan", "Canada"}
fmt.Println(strings.Join(textString, "-"))
// Slice of strings
textNum := []string{"1", "2", "3", "4", "5"}
fmt.Println(strings.Join(textNum,""))
}输出：
Australia-Japan-Canada
12345
LastIndex函数：区分大小写
LastIndex函数允许在字符串中搜索特定的特定文本/字符/字符串。它返回字符串中最后一个实例text/character/strin的索引。如果找到，则返回从0开始的特定位置。如果未找到，则返回 -1。
func LastIndex(s, sep string) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.LastIndex("japanese", "a")) // position j=0,a=1,p=2,a=3
fmt.Println(strings.LastIndex("japanese", "A"))
fmt.Println(strings.LastIndex("Australia Australian", "lia"))
fmt.Println(strings.LastIndex("AUSTRALIA AUSTRALIAN", "lia"))
fmt.Println(strings.LastIndex("1234567890 1234567890", "0"))
fmt.Println(strings.LastIndex("1234567890 1234567890", "00"))
fmt.Println(strings.LastIndex("1234567890 1234567890", "123"))
}输出：
3
-1
16
-1
20
-1
11
Repeat函数：
Repeat函数将字符串重复指定次数，并返回一个由字符串s的计数副本组成的新字符串。Count指定字符串将重复的次数。必须大于或等于0。
func Repeat(s string, count int) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
textString := "Japan"
repString := strings.Repeat(textString, 5)
fmt.Println(repString)
textString = " A " // char with space on both side
repString = strings.Repeat(textString,5)
fmt.Println(repString) // Repeat space also
fmt.Println("ba" + strings.Repeat("na", 2))
fmt.Println("111" + strings.Repeat("22", 2))
fmt.Println("111" + strings.Repeat(" ",2))
}输出：
JapanJapanJapanJapanJapan
A A A A A
banana
1112222
111
Replace函数：区分大小写
Replace函数将字符串中的某些字符替换为其他一些字符。n指定要在字符串中替换的字符数。如果n小于0，则对替换次数没有限制。
func Replace(s, old, new string, n int) string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", 0))
fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", 1))
fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", 2))
fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", -1))
fmt.Println(strings.Replace("1234534232132", "1", "0", -1))
// case-sensitive
fmt.Println(strings.Replace("Australia Japan Canada Indiana", "AN", "anese", -1))
}输出：
Australia Japan Canada Indiana
Australia Japanese Canada Indiana
Australia Japanese Caneseada Indiana
Australia Japanese Caneseada Indianesea
0234534232032
Australia Japan Canada Indiana
Split函数：区分大小写
Split函数将字符串分解为切片。将String拆分为由sep分隔的所有子字符串，并返回这些分隔符之间的子字符串切片。
func Split(S string, sep string) []string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
strSlice := strings.Split("a,b,c", ",")
fmt.Println(strSlice,"\n")
strSlice = strings.Split("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ")
for _, v := range strSlice {
fmt.Println(v)
}
strSlice = strings.Split("abacadaeaf","a")
fmt.Println("\n",strSlice)
strSlice = strings.Split("abacadaeaf","A")
fmt.Println("\n",strSlice)
strSlice = strings.Split("123023403450456056706780789","0")
fmt.Println("\n",strSlice)
strSlice = strings.Split("123023403450456056706780789",",")
fmt.Println("\n",strSlice)
}输出：
[a b c]
Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.
[ b c d e f]
[abacadaeaf]
[123 234 345 456 567 678 789]
[123023403450456056706780789]
SplitN函数：区分大小写
SplitN函数将字符串分解为切片。SplitN将String拆分为由sep分隔的所有子字符串，并在这些分隔符之间返回子字符串的切片。n确定要返回的子字符串数。
n小于0：最多n个子字符串;最后一个子字符串将是未拆分的余数。
n等于0：结果为nil(零个子字符串)
n大于0：所有子字符串
func SplitN(s, sep string, n int) []string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
strSlice := strings.SplitN("a,b,c", ",",0)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitN("a,b,c", ",",1)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitN("a,b,c", ",",2)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitN("a,b,c", ",",3)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitN("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ",-1)
for _, v := range strSlice {
fmt.Println(v)
}
strSlice = strings.SplitN("123023403450456056706780789","0",5)
fmt.Println("\n",strSlice)
}输出：
[]
[a,b,c]
[a b,c]
[a b c]
Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.
[123 234 345 456 56706780789]
SplitAfter函数：区分大小写
SplitAfter函数将字符串分解为切片。SplitAfter按sep分割后，在分割的字符串中保留sep。如ab1cd1，用1分割后结果是[ab1, cd1]。
func SplitAfter(S String, sep string) []string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
strSlice := strings.SplitAfter("a,b,c", ",")
fmt.Println(strSlice,"\n")
strSlice = strings.SplitAfter("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ")
for _, v := range strSlice {
fmt.Println(v)
}
strSlice = strings.SplitAfter("abacadaeaf","a")
fmt.Println("\n",strSlice)
strSlice = strings.SplitAfter("abacadaeaf","A")
fmt.Println("\n",strSlice)
strSlice = strings.SplitAfter("123023403450456056706780789","0")
fmt.Println("\n",strSlice)
strSlice = strings.SplitAfter("123023403450456056706780789",",")
fmt.Println("\n",strSlice)
}输出：
[a, b, c]
Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.
[a ba ca da ea f]
[abacadaeaf]
[1230 2340 3450 4560 5670 6780 789]
[123023403450456056706780789]
SplitAfterN函数：区分大小写
SplitAfterN函数将字符串分解为切片。SplitAfterN在每个sep实例之后将String s切成子字符串，并返回这些子字符串的切片。n确定要返回的子字符串数。
n小于0：最多n个子字符串;最后一个子字符串将是未拆分的余数。
n等于0：结果为nil(零个子字符串)
n大于0：所有子字符串
func SplitAfterN(string s, sep string, n int) []string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
strSlice := strings.SplitAfterN("a,b,c", ",",0)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitAfterN("a,b,c", ",",1)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitAfterN("a,b,c", ",",2)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitAfterN("a,b,c", ",",3)
fmt.Println(strSlice,"\n")
strSlice = strings.SplitAfterN("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ",-1)
for _, v := range strSlice {
fmt.Println(v)
}
strSlice = strings.SplitAfterN("123023403450456056706780789","0",5)
fmt.Println("\n",strSlice)
}输出：
[]
[a,b,c]
[a, b,c]
[a, b, c]
Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.
[1230 2340 3450 4560 56706780789]Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：
HasPrefix函数：
HasPrefix函数检查字符串s是否以指定的字符串开头。如果字符串S以前缀string开头，则返回true，否则返回false。
func HasPrefix(s, prefix string) bool示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.HasPrefix("Australia", "Aus"))
fmt.Println(strings.HasPrefix("Australia", "aus"))
fmt.Println(strings.HasPrefix("Australia", "Jap"))
fmt.Println(strings.HasPrefix("Australia", ""))
}输出：
true
false
false
true
HasSuffix函数：
HasSuffix函数检查字符串s是否以指定的字符串结尾。如果字符串S以后缀string结尾，则返回true，否则返回false。
func HasSuffix(s, prefix string) bool示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.HasSuffix("Australia", "lia"))
fmt.Println(strings.HasSuffix("Australia", "A"))
fmt.Println(strings.HasSuffix("Australia", "LIA"))
fmt.Println(strings.HasSuffix("123456", "456"))
fmt.Println(strings.HasSuffix("Australia", ""))
}输出：
true
false
false
true
true
Index函数：
Index函数允许在字符串中搜索特定文本。它只需匹配字符串中的特定文本即可工作。如果找到，则返回从0开始的特定位置。如果未找到，则返回 -1。
func Index(s, sep string) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Index("Australia", "Aus"))
fmt.Println(strings.Index("Australia", "aus"))
fmt.Println(strings.Index("Australia", "A"))
fmt.Println(strings.Index("Australia", "a"))
fmt.Println(strings.Index("Australia", "Jap"))
fmt.Println(strings.Index("Japan-124", "-"))
fmt.Println(strings.Index("Japan-124", ""))
}输出：
0
-1
0
5
-1
5
0
IndexAny函数：
IndexAny函数从string[left] 中的chars[right] 返回任何Unicode码位的第一个实例的索引。它只需匹配字符串中的特定文本即可工作。如果找到，则返回从0开始的特定位置。如果未找到，则返回 -1。
func IndexAny(s, chars string) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.IndexAny("australia", "japan")) // 字母a下标fmt.Println(strings.IndexAny("japan", "pen")) // 字母p下标fmt.Println(strings.IndexAny("mobile", "one")) // 字母o下标fmt.Println(strings.IndexAny("123456789", "4")) // 数字4下标fmt.Println(strings.IndexAny("123456789", "0")) // 数字0下标
}输出：
0
2
1
3
-1
IndexByte函数：
IndexByte函数返回字符串中字符的第一个实例的索引。如果找到，则返回从0开始的特定位置。如果未找到，则返回 -1。
func IndexByte(s string, c byte) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
var s,t,u byte
t = 'l'
fmt.Println(strings.IndexByte("australia",t))
fmt.Println(strings.IndexByte("LONDON",t))
fmt.Println(strings.IndexByte("JAPAN",t))
s = 1
fmt.Println(strings.IndexByte("5221-JAPAN",s))
u = '1'
fmt.Println(strings.IndexByte("5221-JAPAN",u))
}输出：
6
-1
-1
-1
3
IndexRune函数：
IndexRune函数以字符串形式返回Unicode码位r的第一个实例的索引。如果找到，则返回从0开始的特定位置。如果未找到，则返回 -1。在下面的示例中，s，t和u变量类型声明为rune。
func IndexRune(s string, r rune) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
var s,t,u rune
t = 'l'
fmt.Println(strings.IndexRune("australia",t))
fmt.Println(strings.IndexRune("LONDON",t))
fmt.Println(strings.IndexRune("JAPAN",t))
s = 1
fmt.Println(strings.IndexRune("5221-JAPAN",s))
u = '1'
fmt.Println(strings.IndexRune("5221-JAPAN",u))
}输出：
6
-1
-1
-1
3Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：
Compare函数：区分大小写
您可以使用Compare() 比较两个字符串。它返回大于零、小于零或等于零的输出。如果字符串1大于字符串2，则返回大于零。如果字符串1小于字符串2，则返回小于零。如果字符串相等，则返回零。
func Compare(a, b string) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Compare("A", "B")) // A < B
fmt.Println(strings.Compare("B", "A")) // B > A
fmt.Println(strings.Compare("Japan", "Australia")) // J > A
fmt.Println(strings.Compare("Australia", "Japan")) // A < J
fmt.Println(strings.Compare("Germany", "Germany")) // G == G
fmt.Println(strings.Compare("Germany", "GERMANY")) // GERMANY > Germany
fmt.Println(strings.Compare("", ""))
fmt.Println(strings.Compare("", " ")) // Space is less
}输出：
-1
1
1
-1
0
1
0
-1
Contains函数：区分大小写
您可以使用Contains() 搜索字符串中的特定文本/字符串/字符。它返回true或false的输出。如果在字符串2中找到字符串1，则返回true。如果在字符串2中找不到字符串1，则返回false。
func Contains(s, substr string) bool示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.ContainsAny("Australia", "a"))
fmt.Println(strings.ContainsAny("Australia", "r & a"))
fmt.Println(strings.ContainsAny("JAPAN", "j"))
fmt.Println(strings.ContainsAny("JAPAN", "J"))
fmt.Println(strings.ContainsAny("JAPAN", "JAPAN"))
fmt.Println(strings.ContainsAny("JAPAN", "japan"))
fmt.Println(strings.ContainsAny("Shell-12541", "1"))
// Contains vs ContainsAny
fmt.Println(strings.ContainsAny("Shell-12541", "1-2")) // true
fmt.Println(strings.Contains("Shell-12541", "1-2")) // false
}输出：
true
true
false
true
true
false
true
true
false
Count函数：区分大小写
此函数计算字符串中字符/字符串/文本的非重叠实例数。
func Count(s, sep string) int示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Count("Australia", "a"))
fmt.Println(strings.Count("Australia", "A"))
fmt.Println(strings.Count("Australia", "M"))
fmt.Println(strings.Count("Japanese", "Japan")) // 1
fmt.Println(strings.Count("Japan", "Japanese")) // 0
fmt.Println(strings.Count("Shell-25152", "-25"))
fmt.Println(strings.Count("Shell-25152", "-21"))
fmt.Println(strings.Count("test", "")) // length of string + 1
fmt.Println(strings.Count("test", " "))
}输出：
2
1
0
1
0
1
0
5
0
EqualFold函数：不区分大小写
使用EqualFold，您可以检查两个字符串是否相等。如果两个字符串相等，则返回输出true，如果两个字符串不相等，则返回false。
func EqualFold(s, t string) bool示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.EqualFold("Australia", "AUSTRALIA"))
fmt.Println(strings.EqualFold("Australia", "aUSTRALIA"))
fmt.Println(strings.EqualFold("Australia", "Australia"))
fmt.Println(strings.EqualFold("Australia", "Aus"))
fmt.Println(strings.EqualFold("Australia", "Australia & Japan"))
fmt.Println(strings.EqualFold("JAPAN-1254", "japan-1254"))
fmt.Println(strings.EqualFold(" ", " ")) // single space both side
fmt.Println(strings.EqualFold(" ", " ")) // double space right side
}输出：
true
true
true
false
false
false
true
true
false
Fields函数：
Fields函数将一个或多个连续空格字符的每个实例周围的字符串分解为一个Array。
func Fields(s string) []string示例代码：
package main
import (
"fmt"
"strings"
)
func main() {
testString := "Australia is a country and continent surrounded by the Indian and Pacific oceans."
testArray := strings.Fields(testString)
for _, v := range testArray {
fmt.Println(v)
}
}输出：
Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans
FieldsFunc函数
FieldsFunc函数在每次运行满足f(c) 的Unicode码位c时断开字符串s，并返回s切片数组。您可以使用此函数按每个数字点或特殊字符拆分字符串。查看以下两个FieldsFunc示例：
func FieldsFunc(s string, f func(rune) bool) []string示例代码：
package main
import (
"fmt"
"strings"
"unicode"
)
func main() {
// 是否为unicode字母x := func(c rune) bool {
return !unicode.IsLetter(c)
}
strArray := strings.FieldsFunc(`Australia major cities – Sydney, Brisbane,
Melbourne, Perth, Adelaide – are coastal`,x)
for _, v := range strArray {
fmt.Println(v)
}
fmt.Println("\n*按数字分割***\n")
y := func(c rune) bool {
return unicode.IsNumber(c)
}
testArray := strings.FieldsFunc(`1 Sydney Opera House.2 Great Barrier Reef.3 Uluru-Kata Tjuta National Park.4 Sydney Harbour Bridge.5 Blue Mountains National Park.6 Melbourne.7 Bondi Beach`,y)
for _, w := range testArray {
fmt.Println(w)
}
}输出：
Australia
major
cities
Sydney
Brisbane
Melbourne
Perth
Adelaide
are
coastal
*按数字分割***
Sydney Opera House.
Great Barrier Reef.
Uluru-Kata Tjuta National Park.
Sydney Harbour Bridge.
Blue Mountains National Park.
Melbourne.
Bondi Beachcarbon在其他语言中也有相关库，它可以帮助使Golang中的日期/时间处理变得更加容易和语义化，从而使我们的代码变得更具可读性和可维护性。
安装：
go get github.com/uniplaces/carbon示例代码：
package main
import (
"fmt"
"github.com/uniplaces/carbon"
)
func main() {
fmt.Printf("Right now is %s\n", carbon.Now().DateTimeString())
today, _ := carbon.NowInLocation("Europe/London")
fmt.Printf("Right now in London is %s\n", today)
fmt.Printf("\n#######################################\n")
fmt.Printf("Tomorrow is %s\n", carbon.Now().AddDay())
fmt.Printf("Yesterday is %s\n", carbon.Now().SubDay())
fmt.Printf("After 5 Days %s\n", carbon.Now().AddDays(5))
fmt.Printf("Before 5 Days %s\n", carbon.Now().SubDays(5))
fmt.Printf("\n#######################################\n")
fmt.Printf("Next Month is %s\n", carbon.Now().AddMonth())
fmt.Printf("Last Month is %s\n", carbon.Now().SubMonth())
fmt.Printf("\n#######################################\n")
fmt.Printf("Next week is %s\n", carbon.Now().AddWeek())
fmt.Printf("Last week is %s\n", carbon.Now().SubWeek())
fmt.Printf("\n#######################################\n")
fmt.Printf("Next Year %s\n", carbon.Now().AddYear())
fmt.Printf("Last Year %s\n", carbon.Now().SubYear())
fmt.Printf("After 5 Years %s\n", carbon.Now().AddYears(5))
fmt.Printf("Before 5 Years %s\n", carbon.Now().SubYears(5))
fmt.Printf("\n#######################################\n")
fmt.Printf("Next Hour %s\n", carbon.Now().AddHour())
fmt.Printf("Last Hour %s\n", carbon.Now().SubHour())
fmt.Printf("After 5 Mins %s\n", carbon.Now().AddMinutes(5))
fmt.Printf("Before 5 Mins %s\n", carbon.Now().SubMinutes(5))
fmt.Printf("\n#######################################\n")
fmt.Printf("Weekday? %t\n", carbon.Now().IsWeekday())
fmt.Printf("Weekend? %t\n", carbon.Now().IsWeekend())
fmt.Printf("LeapYear? %t\n", carbon.Now().IsLeapYear())
fmt.Printf("Past? %t\n", carbon.Now().IsPast())
fmt.Printf("Future? %t\n", carbon.Now().IsFuture())
fmt.Printf("\n#######################################\n")
fmt.Printf("Start of day: %s\n", today.StartOfDay())
fmt.Printf("End of day: %s\n", today.EndOfDay())
fmt.Printf("Start of month: %s\n", today.StartOfMonth())
fmt.Printf("End of month: %s\n", today.EndOfMonth())
fmt.Printf("Start of year: %s\n", today.StartOfYear())
fmt.Printf("End of year: %s\n", today.EndOfYear())
fmt.Printf("Start of week: %s\n", today.StartOfWeek())
fmt.Printf("End of week: %s\n", today.EndOfWeek())
}输出：
Right now is 2017-08-27 22:38:07
Right now in London is 2017-08-27 18:08:07
#######################################
Tomorrow is 2017-08-28 22:38:07
Yesterday is 2017-08-26 22:38:07
After 5 Days 2017-09-01 22:38:07
Before 5 Days 2017-08-22 22:38:07
#######################################
Next Month is 2017-09-27 22:38:07
Last Month is 2017-07-27 22:38:07
#######################################
Next week is 2017-09-03 22:38:07
Last week is 2017-08-20 22:38:07
#######################################
Next Year 2018-08-27 22:38:07
Last Year 2016-08-27 22:38:07
After 5 Years 2022-08-27 22:38:07
Before 5 Years 2012-08-27 22:38:07
#######################################
Next Hour 2017-08-27 23:38:07
Last Hour 2017-08-27 21:38:07
After 5 Mins 2017-08-27 22:43:07
Before 5 Mins 2017-08-27 22:33:07
#######################################
Weekday? false
Weekend? true
LeapYear? false
Past? false
Future? false
#######################################
Start of day: 2017-08-27 00:00:00
End of day: 2017-08-27 23:59:59
Start of month: 2017-08-01 00:00:00
End of month: 2017-08-31 23:59:59
Start of year: 2017-01-01 00:00:00
End of year: 2017-12-31 23:59:59
Start of week: 2017-08-21 00:00:00
End of week: 2017-09-03 23:59:59跨地区的开发中需要把一个时区的时间转化为其他时区的时间，以下是相关示例。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
t, err := time.Parse("2006 01 02 15 04", "2015 11 11 16 50")
if err != nil {
fmt.Println(err)
}
fmt.Println(t)
loc, err := time.LoadLocation("America/Los_Angeles")
if err != nil {
fmt.Println(err)
}
fmt.Println(loc)
t = t.In(loc)
fmt.Println(t.Format(time.RFC822))
loc, err = time.LoadLocation("Singapore")
if err != nil {
fmt.Println(err)
}
fmt.Println(loc)
t = t.In(loc)
fmt.Println(t.Format(time.RFC822))
loc, err = time.LoadLocation("US/Hawaii")
if err != nil {
fmt.Println(err)
}
fmt.Println(loc)
t = t.In(loc)
fmt.Println(t.Format(time.RFC822))
loc, err = time.LoadLocation("EST")
if err != nil {
fmt.Println(err)
}
fmt.Println(loc)
t = t.In(loc)
fmt.Println(t.Format(time.RFC822))
loc, err = time.LoadLocation("MST")
if err != nil {
fmt.Println(err)
}
fmt.Println(loc)
t = t.In(loc)
fmt.Println(t.Format(time.RFC822))
}输出：
2015-11-11 16:50:00 +0000 UTC
America/Los_Angeles
11 Nov 15 08:50 PST
Singapore
12 Nov 15 00:50 SGT
US/Hawaii
11 Nov 15 06:50 HST
EST
11 Nov 15 11:50 EST
MST
11 Nov 15 09:50 MST下面的程序使用解析函数从当前日期和时间获取年、月、日、小时、分钟和秒。Clock函数用于返回时间T指定的一天内的小时、分钟和秒。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
currentTime := time.Now()
fmt.Println("\n######################################\n")
fmt.Println(currentTime.Format("2006-01-02 15:04:05"))
fmt.Println("\n######################################\n")
timeStampString := currentTime.Format("2006-01-02 15:04:05")
layOut := "2006-01-02 15:04:05"
timeStamp, err := time.Parse(layOut, timeStampString)
if err != nil {
fmt.Println(err)
}
hr, min, sec := timeStamp.Clock()
fmt.Println("Year :", currentTime.Year())
fmt.Println("Month :", currentTime.Month())
fmt.Println("Day :", currentTime.Day())
fmt.Println("Hour :", hr)
fmt.Println("Min :", min)
fmt.Println("Sec :", sec)
fmt.Println("\n######################################\n")
year, month, day := time.Now().Date()
fmt.Println("Year :", year)
fmt.Println("Month :", month)
fmt.Println("Day :", day)
fmt.Println("\n######################################\n")
t := time.Now()
y := t.Year()
mon := t.Month()
d := t.Day()
h := t.Hour()
m := t.Minute()
s := t.Second()
n := t.Nanosecond()
fmt.Println("Year :",y)
fmt.Println("Month :",mon)
fmt.Println("Day :",d)
fmt.Println("Hour :",h)
fmt.Println("Minute :",m)
fmt.Println("Second :",s)
fmt.Println("Nanosec:",n)
}输出：
######################################
2017-08-27 18:11:54
######################################
Year : 2017
Month : August
Day : 27
Hour : 18
Min : 11
Sec : 54
######################################
Year : 2017
Month : August
Day : 27
######################################
Year : 2017
Month : August
Day : 27
Hour : 18
Minute : 11
Second : 54
Nanosec: 319513100在日常开发中我们需要展示各类不同需求的时间格式，以下是通常使用的时间格式输出方式。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
currentTime := time.Now()
fmt.Println("Current Time in String: ", currentTime.String())
fmt.Println("MM-DD-YYYY : ", currentTime.Format("01-02-2006"))
fmt.Println("YYYY-MM-DD : ", currentTime.Format("2006-01-02"))
fmt.Println("YYYY.MM.DD : ", currentTime.Format("2006.01.02 15:04:05"))
fmt.Println("YYYY#MM#DD {Special Character} : ", currentTime.Format("2006#01#02"))
fmt.Println("YYYY-MM-DD hh:mm:ss : ", currentTime.Format("2006-01-02 15:04:05"))
fmt.Println("Time with MicroSeconds: ", currentTime.Format("2006-01-02 15:04:05.000000"))
fmt.Println("Time with NanoSeconds: ", currentTime.Format("2006-01-02 15:04:05.000000000"))
fmt.Println("ShortNum Month : ", currentTime.Format("2006-1-02"))
fmt.Println("LongMonth : ", currentTime.Format("2006-January-02"))
fmt.Println("ShortMonth : ", currentTime.Format("2006-Jan-02"))
fmt.Println("ShortYear : ", currentTime.Format("06-Jan-02"))
fmt.Println("LongWeekDay : ", currentTime.Format("2006-01-02 15:04:05 Monday"))
fmt.Println("ShortWeek Day : ", currentTime.Format("2006-01-02 Mon"))
fmt.Println("ShortDay : ", currentTime.Format("Mon 2006-01-2"))
fmt.Println("Short Hour Minute Second: ", currentTime.Format("2006-01-02 3:4:5"))
fmt.Println("Short Hour Minute Second: ", currentTime.Format("2006-01-02 3:4:5 PM"))
fmt.Println("Short Hour Minute Second: ", currentTime.Format("2006-01-02 3:4:5 pm"))
}输出：
Current Time in String: 2017-07-04 00:47:20.1424751 +0530 IST
MM-DD-YYYY : 07-04-2017
YYYY-MM-DD : 2017-07-04
YYYY.MM.DD : 2017.07.04 00:47:20
YYYY#MM#DD {Special Character} : 2017#07#04
YYYY-MM-DD hh:mm:ss : 2017-07-04 00:47:20
Time with MicroSeconds: 2017-07-04 00:47:20.142475
Time with NanoSeconds: 2017-07-04 00:47:20.142475100
ShortNum Month : 2017-7-04
LongMonth : 2017-July-04
ShortMonth : 2017-Jul-04
ShortYear : 17-Jul-04
LongWeekDay : 2017-07-04 00:47:20 Tuesday
ShortWeek Day : 2017-07-04 Tue
ShortDay : Tue 2017-07-4
Short Hour Minute Second: 2017-07-04 12:47:20
Short Hour Minute Second: 2017-07-04 12:47:20 AM
Short Hour Minute Second: 2017-07-04 12:47:20 am以下是从当前时间减去指定的日期或时间，与增加时的方法相同，AddDate用于计算日期，Add用于计算时间，只不过减去时用的是负数。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println("Today:", now)
after := now.AddDate(-1, 0, 0)
fmt.Println("Subtract 1 Year:", after)
after = now.AddDate(0, -1, 0)
fmt.Println("Subtract 1 Month:", after)
after = now.AddDate(0, 0, -1)
fmt.Println("Subtract 1 Day:", after)
after = now.AddDate(-2, -2, -5)
fmt.Println("Subtract multiple values:", after)
after = now.Add(-10*time.Minute)
fmt.Println("Subtract 10 Minutes:", after)
after = now.Add(-10*time.Second)
fmt.Println("Subtract 10 Second:", after)
after = now.Add(-10*time.Hour)
fmt.Println("Subtract 10 Hour:", after)
after = now.Add(-10*time.Millisecond)
fmt.Println("Subtract 10 Millisecond:", after)
after = now.Add(-10*time.Microsecond)
fmt.Println("Subtract 10 Microsecond:", after)
after = now.Add(-10*time.Nanosecond)
fmt.Println("Subtract 10 Nanosecond:", after)
}输出：
Today: 2017-08-27 12:21:17.8379942 +0530 IST
Subtract 1 Year: 2016-08-27 12:21:17.8379942 +0530 IST
Subtract 1 Month: 2017-07-27 12:21:17.8379942 +0530 IST
Subtract 1 Day: 2017-08-26 12:21:17.8379942 +0530 IST
Subtract multiple values: 2015-06-22 12:21:17.8379942 +0530 IST
Subtract 10 Minutes: 2017-08-27 12:11:17.8379942 +0530 IST
Subtract 10 Second: 2017-08-27 12:21:07.8379942 +0530 IST
Subtract 10 Hour: 2017-08-27 02:21:17.8379942 +0530 IST
Subtract 10 Millisecond: 2017-08-27 12:21:17.8279942 +0530 IST
Subtract 10 Microsecond: 2017-08-27 12:21:17.8379842 +0530 IST
Subtract 10 Nanosecond: 2017-08-27 12:21:17.83799419 +0530 IST以下是在golang中进行常规时间计算的方法。AddDate用于日期计算，Add用于时间计算。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println("\nToday:", now)
after := now.AddDate(1, 0, 0)
fmt.Println("\nAdd 1 Year:", after)
after = now.AddDate(0, 1, 0)
fmt.Println("\nAdd 1 Month:", after)
after = now.AddDate(0, 0, 1)
fmt.Println("\nAdd 1 Day:", after)
after = now.AddDate(2, 2, 5)
fmt.Println("\nAdd multiple values:", after)
after = now.Add(10*time.Minute)
fmt.Println("\nAdd 10 Minutes:", after)
after = now.Add(10*time.Second)
fmt.Println("\nAdd 10 Second:", after)
after = now.Add(10*time.Hour)
fmt.Println("\nAdd 10 Hour:", after)
after = now.Add(10*time.Millisecond)
fmt.Println("\nAdd 10 Millisecond:", after)
after = now.Add(10*time.Microsecond)
fmt.Println("\nAdd 10 Microsecond:", after)
after = now.Add(10*time.Nanosecond)
fmt.Println("\nAdd 10 Nanosecond:", after)
}输出：
Today: 2017-08-27 11:17:54.1224628 +0530 IST
Add 1 Year: 2018-08-27 11:17:54.1224628 +0530 IST
Add 1 Month: 2017-09-27 11:17:54.1224628 +0530 IST
Add 1 Day: 2017-08-28 11:17:54.1224628 +0530 IST
Add multiple values: 2019-11-01 11:17:54.1224628 +0530 IST
Add 10 Minutes: 2017-08-27 11:27:54.1224628 +0530 IST
Add 10 Second: 2017-08-27 11:18:04.1224628 +0530 IST
Add 10 Hour: 2017-08-27 21:17:54.1224628 +0530 IST
Add 10 Millisecond: 2017-08-27 11:17:54.1324628 +0530 IST
Add 10 Microsecond: 2017-08-27 11:17:54.1224728 +0530 IST
Add 10 Nanosecond: 2017-08-27 11:17:54.12246281 +0530 IST以下是计算两个时间之间之差的方法，具体到天，时，分，秒。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
loc, _ := time.LoadLocation("UTC")
now := time.Now().In(loc)
fmt.Println("\nToday : ", loc, " Time : ", now)
pastDate := time.Date(2015, time.May, 21, 23, 10, 52, 211, time.UTC)
fmt.Println("\n\nPast : ", loc, " Time : ", pastDate) //
fmt.Printf("###############################################################\n")
diff := now.Sub(pastDate)
hrs := int(diff.Hours())
fmt.Printf("Diffrence in Hours : %d Hours\n", hrs)
mins := int(diff.Minutes())
fmt.Printf("Diffrence in Minutes : %d Minutes\n", mins)
second := int(diff.Seconds())
fmt.Printf("Diffrence in Seconds : %d Seconds\n", second)
days := int(diff.Hours() / 24)
fmt.Printf("Diffrence in days : %d days\n", days)
fmt.Printf("###############################################################\n\n\n")
futureDate := time.Date(2019, time.May, 21, 23, 10, 52, 211, time.UTC)
fmt.Println("Future : ", loc, " Time : ", futureDate) //
fmt.Printf("###############################################################\n")
diff = futureDate.Sub(now)
hrs = int(diff.Hours())
fmt.Printf("Diffrence in Hours : %d Hours\n", hrs)
mins = int(diff.Minutes())
fmt.Printf("Diffrence in Minutes : %d Minutes\n", mins)
second = int(diff.Seconds())
fmt.Printf("Diffrence in Seconds : %d Seconds\n", second)
days = int(diff.Hours() / 24)
fmt.Printf("Diffrence in days : %d days\n", days)
}输出：
Today : UTC Time : 2017-08-27 05:15:53.7106215 +0000 UTC
Past : UTC Time : 2015-05-21 23:10:52.000000211 +0000 UTC
###############################################################
Diffrence in Hours : 19878 Hours
Diffrence in Minutes : 1192685 Minutes
Diffrence in Seconds : 71561101 Seconds
Diffrence in days : 828 days
###############################################################
Future : UTC Time : 2019-05-21 23:10:52.000000211 +0000 UTC
###############################################################
Diffrence in Hours : 15185 Hours
Diffrence in Minutes : 911154 Minutes
Diffrence in Seconds : 54669298 Seconds
Diffrence in days : 632 days示例代码：
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
z, _ := t.Zone()
fmt.Println("ZONE : ", z, " Time : ", t) // local time
location, err := time.LoadLocation("EST")
if err != nil {
fmt.Println(err)
}
fmt.Println("ZONE : ", location, " Time : ", t.In(location)) // EST
loc, _ := time.LoadLocation("UTC")
now := time.Now().In(loc)
fmt.Println("ZONE : ", loc, " Time : ", now) // UTC
loc, _ = time.LoadLocation("MST")
now = time.Now().In(loc)
fmt.Println("ZONE : ", loc, " Time : ", now) // MST
}输出：
ZONE : IST Time : 2017-08-26 22:12:31.3763932 +0530 IST
ZONE : EST Time : 2017-08-26 11:42:31.3763932 -0500 EST
ZONE : UTC Time : 2017-08-26 16:42:31.3773933 +0000 UTC
ZONE : MST Time : 2017-08-26 09:42:31.3783934 -0700 MSTWeekday返回t指定的星期几。YearDay返回t指定的一年中的某一天，非闰年的范围为 [1,365]，闰年的范围为 [1,366]。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now() // 2024 01 03
fmt.Println(t.YearDay())
fmt.Println(t.Weekday())
// 年度，第几周year, week := t.ISOWeek()
fmt.Printf("year: %v\n", year)
// Prints the week number
fmt.Printf("week: %d\n", week)
}输出：
3
Wednesday
year: 2024
week: 1首先，需要配置时区，然后根据时区转换时间，LoadLocation返回具有给定名称的Location。
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
fmt.Println("Location : ", t.Location(), " Time : ", t) // local time
location, err := time.LoadLocation("America/New_York")
if err != nil {
fmt.Println(err)
}
fmt.Println("Location : ", location, " Time : ", t.In(location)) // America/New_York
loc, _ := time.LoadLocation("Asia/Shanghai")
now := time.Now().In(loc)
fmt.Println("Location : ", loc, " Time : ", now) // Asia/Shanghai
}输出：
Location : Local Time : 2017-08-26 21:04:56.1874497 +0530 IST
Location : America/New_York Time : 2017-08-26 11:34:56.1874497 -0400 EDT
Location : Asia/Shanghai Time : 2017-08-26 23:34:56.1884498 +0800 CST截至2023年，以下是使用Go语言时要遵循的一些最佳实践：
- 遵循官方Go风格指南：官方Go风格指南概述了一组格式化Go代码、命名约定和其他最佳实践的指南。遵循这些准则可使其他开发人员更轻松地阅读和理解您的代码。
- 使用gofmt格式化代码：gofmt是一个根据官方Go风格指南自动格式化Go代码的工具。建议在将代码提交到版本控制之前使用gofmt来格式化代码。
- 编写清晰简洁的代码：编写易于阅读和理解的代码。使用描述性变量和函数名称，避免使用不必要的代码或过于复杂的逻辑。
- 使用go模块管理依赖项：Go模块提供了一种管理Go项目中依赖项的方法。它们使指定项目所依赖的外部包版本变得容易，并确保这些依赖项在不同环境中保持一致。
- 为代码编写测试：编写测试是Go开发的重要组成部分。测试有助于确保代码正常工作，并且可以在进行更改时捕获回归。
- 正确使用错误处理：Go使用显式错误处理来处理代码中的错误。通过检查错误并在适当的时候返回错误来确保正确处理错误。
- 避免使用全局变量：全局变量会使推理程序的状态变得困难。相反，使用依赖项注入在函数和包之间传递变量。
- 使用通道进行并发：Go的并发模型是围绕通道构建的。使用通道在goroutines之间进行通信，并同步对共享资源的访问。
- 必要时优化性能：Go是一种快速语言，但有时仍需要性能优化。使用分析工具识别性能瓶颈，并在必要时优化代码。
- 代码注释：编写清晰简洁的文档有助于其他开发人员了解如何使用代码。使用注释和godoc样式的文档来注释您的代码。
Go中的并发性是程序同时执行多个任务的能力。Go通过goroutines提供对并发的内置支持，goroutines是由Go运行时管理的轻量级线程。Goroutines允许您并发执行任务，而无需直接管理线程。Go中的并发性被设计为高效且可扩展，使其非常适合构建高性能和分布式系统。凭借对并发的支持，Go使开发人员能够编写能够充分利用现代硬件并更有效地利用系统资源的程序。
并发性是Go的主要特性之一。以下是在Go中使用并发的一些最佳实践：
- 使用goroutines代替线程：Goroutines是由Go运行时管理的轻量级线程，这使得它们比传统线程更高效。使用它们可以并发执行任务并提高性能。
- 使用通道在goroutines之间进行通信：通道是Go中goroutines之间通信的主要方式。使用它们在并发操作之间安全地传递数据。
- 避免在goroutine之间共享可变数据：为了避免竞争条件和其他同步问题，请尽量避免在goroutines之间共享可变数据。相反，请根据需要使用通道传递数据副本。
- 使用同步包进行同步：同步包提供同步基元，如互斥锁和等待组，可用于协调对共享资源的访问。
- 使用select语句协调通道操作：select语句允许您等待多个通道操作一次完成，使其成为协调并发操作的强大工具。
- 使用上下文包管理长时间运行的操作：上下文包提供了一种管理长时间运行的操作并在必要时取消它们的方法。使用它可避免无限期地阻塞通道或其他操作。
通过遵循这些最佳实践，您可以编写高效、安全且易于维护的并发代码。
bufio软件包Scanner适用于从文件中按行或单词读取文本。以下源代码片段显示了从下面的纯文本文件中逐行读取文本。
示例代码：
package main
import (
"bufio"
"fmt"
"log"
"os"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatalf("failed opening file: %s", err)
}
scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanLines)
var txtlines []string
for scanner.Scan() {
txtlines = append(txtlines, scanner.Text())
}
file.Close()
for _, eachline := range txtlines {
fmt.Println(eachline)
}
}输出：
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Nunc a mi dapibus, faucibus mauris eu, fermentum ligula.
Donec in mauris ut justo eleifend dapibus.
Donec eu erat sit amet velit auctor tempus id eget mauris.
苏公网安备
32050902101537号