zhe.ink 在线工具箱

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-Japan

Go语言教程之边写边学：基础练习：常用字符串函数（3）

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"))
}

输出：

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]

Go语言教程之边写边学：基础练习：常用字符串函数（2）

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", ""))
}

输出：

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下标
}

输出：

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
3

Go语言教程之边写边学：基础练习：常用字符串函数（1）

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
}

输出：

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", " "))
}

输出：

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 Beach

Go语言教程之边写边学：基础练习：如何使用WaitGroup将main函数的执行延迟到所有goroutines完成后

如果将WaitGroup结构添加到代码中，它可能会延迟main函数的执行，直到所有goroutine完成后。简单来说，它允许您设置一些必需的迭代，以便在允许应用程序继续之前从goroutine获得完整的响应。
Done递减WaitGroup计数器，直到WaitGroup计数器为零。

示例代码：

package main

import (
	"fmt"
	"time"
	"sync"
)	

type testConcurrency struct {
	min int
	max int
	country string
}

func printCountry(test *testConcurrency, groupTest *sync.WaitGroup) {	
	for i :=test.max ; i>test.min; i-- {	
			time.Sleep(1*time.Millisecond)			
			fmt.Println(test.country)
	}

	fmt.Println()
	groupTest.Done()	
}

func  main() {
	groupTest := new(sync.WaitGroup)
	
	japan := new(testConcurrency)
	china := new(testConcurrency)
	india := new(testConcurrency)

	japan.country = "Japan"
	japan.min = 0
	japan.max = 5

	china.country = "China"
	china.min = 0
	china.max = 5

	india.country = "India"
	india.min = 0
	india.max = 5

	go printCountry(japan, groupTest)
	go printCountry(china, groupTest)
	go printCountry(india, groupTest)

	groupTest.Add(3)
	groupTest.Wait()
}

输出：

Japan
India
China
India
Japan
China
Japan
India
China
India
Japan
China
Japan

India

China

Go语言教程之边写边学：Golang中的反射：Reflect包的Make相关函数

MakeSlice函数为指定的切片类型、长度和容量创建一个新的零初始化切片值。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var str []string
	var strType reflect.Value = reflect.ValueOf(&str)
	newSlice := reflect.MakeSlice(reflect.Indirect(strType).Type(), 10, 15)

	fmt.Println("Kind :", newSlice.Kind())
	fmt.Println("Length :", newSlice.Len())
	fmt.Println("Capacity :", newSlice.Cap())
}

输出：

Kind : slice
Length : 10
Capacity : 15

MakeMap将创建一个具有指定类型的新映射。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var str map[string]string
	var strType reflect.Value = reflect.ValueOf(&str)
	newMap := reflect.MakeMap(reflect.Indirect(strType).Type())

	fmt.Println("Kind :", newMap.Kind())
}

输出：

Kind : map

MakeChan创建一个具有指定类型和缓冲区大小的新通道。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var str chan string
	var strType reflect.Value = reflect.ValueOf(&str)
	newChannel := reflect.MakeChan(reflect.Indirect(strType).Type(), 512)

	fmt.Println("Kind :", newChannel.Kind())
	fmt.Println("Capacity :", newChannel.Cap())
}

输出：

Kind : chan
Capacity : 512

MakeFunc函数用于获取包装函数fn的给定Type的新函数。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type Sum func(int64, int64) int64

func main() {
	t := reflect.TypeOf(Sum(nil))
	mul := reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
		a := args[0].Int()
		b := args[1].Int()
		return []reflect.Value{reflect.ValueOf(a + b)}
	})
	fn, ok := mul.Interface().(Sum)
	if !ok {
		return
	}
	fmt.Println(fn(5, 6))
}

输出：

Go语言教程之边写边学：Golang中的反射：Reflect包的Field相关函数

NumField函数

返回给定结构中的字段数。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type T struct {
	A int
	B string
	C float64
	D bool
}

func main() {
	t := T{10, "ABCD", 15.20, true}
	typeT := reflect.TypeOf(t)
	fmt.Println(typeT.NumField()) // 4
}

field函数

Field函数用于访问结构字段的名称和类型。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type T struct {
	A int
	B string
	C float64
	D bool
}

func main() {
	t := T{10, "ABCD", 15.20, true}
	typeT := reflect.TypeOf(t)

	for i := 0; i < typeT.NumField(); i++ {
		field := typeT.Field(i)
		fmt.Println(field.Name, field.Type)
	}
}

输出：

A int
B string 
C float64
D bool

FieldByIndex函数

FieldByIndex函数用于获取index对应的嵌套字段

package main

import (
	"fmt"
	"reflect"
)

type First struct {
	A int
	B string
	C float64
}

type Second struct {
	First
	D bool
}

func main() {
	s := Second{First: First{10, "ABCD", 15.20}, D: true}
	t := reflect.TypeOf(s)

	fmt.Printf("%#v\n", t.FieldByIndex([]int{0}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 0}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 1}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 2}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{1}))
}

输出：

reflect.StructField{Name:"First", PkgPath:"", Type:(*reflect.rtype)(0x4bda40), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:true}
reflect.StructField{Name:"A", PkgPath:"", Type:(*reflect.rtype)(0x4ad800), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:false} 
reflect.StructField{Name:"B", PkgPath:"", Type:(*reflect.rtype)(0x4adf80), Tag:"", Offset:0x8, Index:[]int{1}, Anonymous:false} 
reflect.StructField{Name:"C", PkgPath:"", Type:(*reflect.rtype)(0x4ad400), Tag:"", Offset:0x18, Index:[]int{2}, Anonymous:false}
reflect.StructField{Name:"D", PkgPath:"", Type:(*reflect.rtype)(0x4ad200), Tag:"", Offset:0x20, Index:[]int{1}, Anonymous:false

FieldByName函数

FieldByName函数用于通过给定的字段名称获取和设置结构字段值。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type T struct {
	A int
	B string
	C float64
}

func main() {
	s := T{10, "ABCD", 15.20}
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("A"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("B"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("C"))

	reflect.ValueOf(&s).Elem().FieldByName("A").SetInt(50)
	reflect.ValueOf(&s).Elem().FieldByName("B").SetString("Test")
	reflect.ValueOf(&s).Elem().FieldByName("C").SetFloat(5.5)

	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("A"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("B"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("C"))
}

输出：

10
ABCD
15.2
50  
Test
5.5

Go语言教程之边写边学：Golang中的反射：Reflect包的ValueOf函数

ValueOf函数来创建一个reflect。表示变量值的Value实例。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	v1 := []int{1, 2, 3, 4, 5}
	fmt.Println(reflect.ValueOf(v1))

	v2 := "Hello World"
	fmt.Println(reflect.ValueOf(v2))

	v3 := 1000
	fmt.Println(reflect.ValueOf(v3))
	fmt.Println(reflect.ValueOf(&v3))

	v4 := map[string]int{"mobile": 10, "laptop": 5}
	fmt.Println(reflect.ValueOf(v4))

	v5 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(reflect.ValueOf(v5))

	v6 := true
	fmt.Println(reflect.ValueOf(v6))
}

输出：

[1 2 3 4 5]
Hello World
1000
0xc0000a00b8
map[laptop:5 mobile:10]
[1 2 3 4 5]
true

Go语言教程之边写边学：Golang中的反射：Reflect包的TypeOf函数

TypeOf函数返回reflect类型的值，即传递给TypeOf函数的变量的类型。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	v1 := []int{1, 2, 3, 4, 5}
	fmt.Println(reflect.TypeOf(v1))

	v2 := "Hello World"
	fmt.Println(reflect.TypeOf(v2))

	v3 := 1000
	fmt.Println(reflect.TypeOf(v3))

	v4 := map[string]int{"mobile": 10, "laptop": 5}
	fmt.Println(reflect.TypeOf(v4))

	v5 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(reflect.TypeOf(v5))

	v6 := true
	fmt.Println(reflect.TypeOf(v6))
}

输出：

[]int
string        
int
map[string]int
[5]int        
bool

Go语言教程之边写边学：Golang中的反射：Reflect包的swapper函数

Swapper函数用于交换所提供切片中的元素。您也可以以巧妙的方式使用此功能来反转或排序切片。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	theList := []int{1, 2, 3, 4, 5}
	swap := reflect.Swapper(theList)
	fmt.Printf("Original Slice :%v\n", theList)

	// 按下标交换元素swap(1, 3)
	fmt.Printf("After Swap :%v\n", theList)

	// 反转slice元素for i := 0; i < len(theList)/2; i++ {
		swap(i, len(theList)-1-i)
	}
	fmt.Printf("After Reverse :%v\n", theList)
}

输出：

Original Slice :[1 2 3 4 5]
After  Swap :[1 4 3 2 5]
After Reverse :[5 2 3 4 1]

Go语言教程之边写边学：Golang中的反射：Reflect包的DeepEqual函数

无论x和y是否"深度相等"，DeepEqual都返回True或False。当数组值的相应元素深度相等时，数组值深度相等。如果结构值的对应字段(导出和未导出)非常相等，则它们非常相等。切片值在以下情况下非常相等(它们都是nil或都是非nil，它们具有相同的长度，并且它们指向同一基础数组的相同初始条目)。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type mobile struct {
	price float64
	color string
}

func main() {
	// DeepEqual is used to check two slices are equal or not
	s1 := []string{"A", "B", "C", "D", "E"}
	s2 := []string{"D", "E", "F"}
	result := reflect.DeepEqual(s1, s2)
	fmt.Println(result)

	// DeepEqual is used to check two arrays are equal or not
	n1 := [5]int{1, 2, 3, 4, 5}
	n2 := [5]int{1, 2, 3, 4, 5}
	result = reflect.DeepEqual(n1, n2)
	fmt.Println(result)

	// DeepEqual is used to check two structures are equal or not
	m1 := mobile{500.50, "red"}
	m2 := mobile{400.50, "black"}
	result = reflect.DeepEqual(m1, m2)
	fmt.Println(result)
}

输出：

false
true 
false

Go语言教程之边写边学：Golang中的反射：Reflect 包的copy函数

Go中的反射是元编程的一种形式。反射允许我们在运行时检查类型。它还提供了在运行时检查、修改和创建变量、函数和结构的功能。Go reflect包为您提供了在运行时检查和操作对象的功能。对于开发人员来说，反射是一个非常强大的工具，它扩展了任何编程语言的视野。类型、种类和值是用于查找信息的三个重要反射部分。

copy函数将源的内容复制到目标中，直到目标被填满或源已用尽。它返回复制的元素数。目标和源必须具有Slice或Array类型，并且目标和源必须具有相同的元素类型。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	destination := reflect.ValueOf([]string{"A", "B", "C"})
	source := reflect.ValueOf([]string{"D", "E", "F"})

	// Copy() function is used and it returns the number of elements copied
	counter := reflect.Copy(destination, source)
	fmt.Println(counter)

	fmt.Println(source)
	fmt.Println(destination)
}

输出：

3
[D E F]
[D E F]

laravel中使用自定义助手函数

创建函数库：app/Helpers/ArrayHelper.php

<?php

if (!function_exists('flatten')) {
    function flatten(array &$list): array
    {
        $flat = [];

        while ($e = array_pop($list)) {
            if (is_array($e)) {
                array_push($list, array_values($e));
            } else {
                $flat[] = $e;
            }
        }

        return $flat;
    }
}

2. 设置自动加载

"autoload": {

  "psr-4": {

      "App\\": "app/",

      "Database\\Factories\\": "database/factories/",

      "Database\\Seeders\\": "database/seeders/"

  },

     "files": [


      "app/helpers.php"

  ]

},

3. 运行自动加载命令

composer dump-autoload

javascript面试题：解释一下JavaScript中的高阶函数(Higher-order Function)是什么，以及它在JavaScript中的应用。

高阶函数在JavaScript中指的是可以接受一个或多个函数作为参数，并/或返回一个函数的函数。这些高阶函数可以是任何类型的函数，包括匿名函数、箭头函数、或者任何你习惯使用的函数。

高阶函数在JavaScript中的应用非常广泛，它们可以用于封装代码、提高代码的可读性和可维护性、创建函数工厂和函数生成器等等。以下是一些具体的应用示例：

函数组合：你可以使用高阶函数将多个函数组合在一起。例如，你可以创建一个函数，这个函数接受几个函数作为参数，并返回一个新的函数，这个新的函数将这些输入函数组合在一起。

javascriptfunction combine(fn1, fn2, fn3) {
    return function(arg1, arg2, arg3) {
        return fn1(fn2(fn3(arg1), arg2), arg3);
    }
}

函数映射和过滤：在处理数组时，高阶函数可以非常有用。例如，你可以使用高阶函数来实现数组的映射(map)、过滤(filter)和reduce等操作。

javascript// map
const numbers = [1, 2, 3, 4, 5];
const double = numbers.map(x => x * 2); // [2, 4, 6, 8, 10]

// filter
const even = numbers.filter(x => x % 2 === 0); // [2, 4]

函数柯里化：柯里化是一种处理高阶函数的编程技术，它允许你将一个多参数的函数转换成一系列单参数的函数。这在处理异步操作时特别有用。

javascriptfunction curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } else {
            return function(...args2) {
                return curried.apply(this, args.concat(args2));
            }
        }
    };
}

以上只是高阶函数在JavaScript中的一些基本应用。实际上，高阶函数的使用范围远比这些广泛，它们是函数式编程的重要组成部分，也是JavaScript这个多范式语言的重要特性之一。

Go语言教程之边写边学：导入导出：如何从另一个包调用函数？

此示例旨在详细演示函数的各种调用。您将学习如何在主包中创建和调用自定义包函数。您还可以使用别名从另一个包调用自定义包的函数。

以下是我们应用程序的目录结构。

├── employee
│   ├── go.mod
│   ├── main.go
│   └── basic
│       └── basic.go
│       └── gross
│       	└── gross.go

进入employee目录并运行以下命令以创建名为 employee 的go模块。

go mod init employee

上面的命令将创建一个名为go.mod的文件。

要使用自定义包，我们必须先导入它。导入路径是附加在包的子目录和包名称上的模块名称。在我们的示例中，模块名称为 employee，包 basic 位于 employee 文件夹下的basic文件夹中。此外，包裹gross位于basic文件夹下的gross文件夹中。

因此，行导入"employee/basic"将导入basic包，而"employee/basic/gross"将导入gross包

# employee\main.go
package main

import (
	b "employee/basic"
	"employee/basic/gross"

	"fmt"
)

func main() {
	b.Basic = 10000
	fmt.Println(gross.GrossSalary())
}

我们将basic包别名为 b。我们调用gross包的GrossSalary函数，并将值分配给basic包的Basic变量。

在basic文件夹中创建一个文件basic.go。basic文件夹中的文件应以行package basic开头，因为它属于basic包。

# employee\basic\basic.go
package basic

var hra int = 5
var tax int = 2
var Basic int

func Calculation() (allowance int, deduction int) {
	allowance = (Basic * hra) / 100
	deduction = (Basic * tax) / 100
	return
}

在 gross 文件夹中创建一个文件gross.go。gross文件夹中的文件应以行package gross开头，因为它属于gross包。

# employee\basic\gross\gross.go
package gross

import (
	b "employee/basic"
)

func GrossSalary() int {
	a, t := b.Calculation()
	return ((b.Basic + a) - t)
}

函数GrossSalary调用函数basic包的Calculation。我们将basic包别名为 b。

employee>go run main.go

如果运行该程序，将获得以下输出。

Go语言教程之边写边学：延迟调用函数

延迟函数调用

Go有一个名为defer的特殊语句，它计划在函数完成后运行函数调用。请考虑以下示例：

package main
import "fmt"
func first() {
	fmt.Println("First")
}
func second() {
	fmt.Println("Second")
}
func main() {
	defer second()
	first()
}

此程序打印“first”，然后打印“second”。

defer 语句通常与配对操作（如打开和关闭、连接和断开连接或锁定和解锁）一起使用，以确保在所有情况下释放资源，无论控制流多么复杂。释放资源的defer语句的正确位置是在成功获取资源后立即进行。

下面是打开文件并对其执行读/写操作的示例。在此示例中，通常有一些地方您希望提前返回。

没有延迟

func ReadWrite() bool {
	file.Open("file")

	if failureX {
	file.Close()
	return false
	}
	if failureY {
	file.Close()
	return false
	}
	file.Close()
	return true
}

这里重复了很多代码。为了克服这一点，Go有延迟语句。上面的代码可以重写如下。这使得函数更具可读性，更短，并将关闭放在打开旁边。

延迟调用

func ReadWrite() bool {
file.Open("file")
defer file.Close()

if failureX {
return false
}

if failureY {
return false
}

return true
}

这具有多种优点：

它将我们的关闭呼叫保持在打开呼叫附近，因此更容易理解。
如果我们的函数有多个返回语句（可能一个在if中，一个在另一个中），则Close将发生在它们之前。
即使发生运行时崩溃，也会运行延迟函数。
延迟函数按LIFO顺序执行，因此上面的代码打印：4 3 2 1 0。
您可以将多个函数放在“延迟列表”上，就像这个例子一样。

package main
import "fmt"
func main() {
	for i := 0; i < 5; i++ {
		defer fmt.Printf("%d ", i)
	}
}

Go语言教程之边写边学：可变参数函数

可变参数函数

可变参数函数是接受可变数量的参数的函数。在 Golang 中，可以传递与函数签名中引用的相同类型的不同数量的参数。要声明可变参数函数，最后一个参数的类型前面有一个省略号“...”，这表明可以使用任意数量的此类参数调用该函数。当您不知道传递给函数的参数数量时，这种类型的函数很有用，最好的例子是fmt包的内置Println函数，它是一个可变参数函数。

从可变参数函数的所有参数中选择单个参数

该程序演示了在 Golang 中使用可变参数函数。可变参数函数是接受可变数量的特定类型参数的函数。

在此程序中，函数 variadicExample 采用字符串类型的可变参数，由类型名称前的 ... 指示。这意味着该函数可以接受任意数量的字符串参数。

在 main 函数中，我们调用具有四个字符串参数的 variadicExample：“红色”、“蓝色”、“绿色”和“黄色”。这些参数作为字符串切片传递给variadicExample函数的s参数。

package main

import "fmt"

func main() {
	variadicExample("red", "blue", "green", "yellow")
}

func variadicExample(s ...string) {
	fmt.Println(s[0])
	fmt.Println(s[3])
}

输出

red
yellow

因为我们正在访问 s 切片的第一个和第四个元素。请注意，如果我们向variadicExample传递的参数少于四个，程序仍将正常运行而不会出错，但是尝试访问超出切片长度的索引将导致运行时错误。

将多个字符串参数传递给可变参数函数

该程序演示了在 Go 中使用可变参数函数，该函数允许函数接受相同类型的可变数量的参数。

在此示例中，函数variadicExample()定义为接受字符串类型的可变参数。这意味着它可以接受任意数量的字符串参数。main()函数使用不同数量的字符串参数多次调用variadicExample()。

对variadicExample()的第一次调用是在没有任何参数的情况下进行的，这是允许的，因为函数被定义为接受零个或多个字符串参数。

第二次、第三次和第四次调用将不同数量的字符串参数传递给variadicExample()。在每种情况下，该函数都使用fmt.Println()打印 s 参数的内容。

package main

import "fmt"

func main() {
	
	variadicExample()
	variadicExample("red", "blue")
	variadicExample("red", "blue", "green")
	variadicExample("red", "blue", "green", "yellow")
}

func variadicExample(s ...string) {
	fmt.Println(s)
}

输出

[]
[red blue]
[red blue green]
[red blue green yellow]

对variadicExample()的第一次调用打印一个空切片，因为没有传递任何参数。后续调用将打印s参数的内容，该参数包含传递给函数的所有字符串参数。

具有可变参数函数参数和指定参数的函数

package main

import "fmt"

func main() {
	fmt.Println(calculation("Rectangle", 20, 30))
	fmt.Println(calculation("Square", 20))
}

func calculation(str string, y ...int) int {

	area := 1

	for _, val := range y {
		if str == "Rectangle" {
			area *= val
		} else if str == "Square" {
			area = val * val
		}
	}
	return area
}

输出

600
400

在可变参数函数中传递不同类型的参数

在下面的示例中，函数签名接受任意数量的切片类型的参数。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	variadicExample(1, "red", true, 10.5, []string{"foo", "bar", "baz"},
		map[string]int{"apple": 23, "tomato": 13})
}

func variadicExample(i ...interface{}) {
	for _, v := range i {
		fmt.Println(v, "--", reflect.ValueOf(v).Kind())
	}
}

输出

1 -- int
red -- string
true -- bool
10.5 -- float64
[foo bar baz] -- slice
map[apple:23 tomato:13] -- map

Go语言教程之边写边学：函数

函数是程序中存在的一组语句，用于执行特定任务。在高级别上，函数接受输入并返回输出。

函数允许您将常用的代码块提取到单个组件中。

一个最流行的Go函数是main()，它在每个独立的Go程序中都有使用。

创建函数

声明以func关键字开头，后跟希望函数具有的名称、一对括号()，然后是包含函数代码的块。

下面的示例具有一个名为SimpleFunction的函数。它不带任何参数，也不返回任何值。

package main

import "fmt"

// SimpleFunction prints a message
func SimpleFunction() {
	fmt.Println("Hello World")
}

func main() {
	SimpleFunction()
}

Hello World

使用参数的简单函数

信息可以通过参数传递给函数。参数就像一个变量。

参数在函数名称之后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。

下面的示例有一个函数，其中包含两个 int 类型的参数。当调用add()函数时，我们传递两个整数值，例如（20,30）。

package main

import "fmt"

// Function accepting arguments
func add(x int, y int) {
	total := 0
	total = x + y
	fmt.Println(total)
}

func main() {
	// Passing arguments
	add(20, 30)
}

输出

如果名称以大写字母开头的函数将导出到其他包。如果函数名称以小写字母开头，则不会将其导出到其他包，但可以在同一包中调用此函数。

具有返回值的简单函数

在此示例中，add()函数接受两个整数的输入，并返回一个名称为 total 的整数值。

请注意，当返回值声明为函数签名的一部分时，需要 return 语句。

package main

import "fmt"

// Function with int as return type
func add(x int, y int) int {
	total := 0
	total = x + y
	return total
}

func main() {
	// Accepting return value in varaible
	sum := add(20, 30)
	fmt.Println(sum)
}

输入和返回值的类型必须与函数签名匹配。如果我们修改上面的程序并在参数中传递一些字符串值，那么程序将抛出一个异常。

声明函数的返回值

Golang允许您命名函数的返回值。我们还可以通过定义变量来命名返回值，这里在函数声明中为函数返回的值定义了整数类型的变量总数。

package main

import "fmt"

func rectangle(l int, b int) (area int) {
	var parameter int
	parameter = 2 * (l + b)
	fmt.Println("Parameter: ", parameter)

	area = l * b
	return // Return statement without specify variable name
}

func main() {
	fmt.Println("Area: ", rectangle(20, 30))
}

输出

Parameter:  100
Area:  600

由于函数声明为返回int类型的值，因此执行流中的最后一个逻辑语句必须是返回所声明类型的值的return语句。

返回多个值的函数

Golang 中的函数可以返回多个值，这在许多实际场景中是一个有用的功能。

此示例声明一个具有两个返回值的函数，并从 main 函数调用它。

package main

import "fmt"

func rectangle(l int, b int) (area int, parameter int) {
	parameter = 2 * (l + b)
	area = l * b
	return // Return statement without specify variable name
}

func main() {
	var a, p int
	a, p = rectangle(20, 30)
	fmt.Println("Area:", a)
	fmt.Println("Parameter:", p)
}

函数的命名约定

名称必须以字母开头，并且可以包含任意数量的其他字母和数字。
函数名称不能以数字开头。
函数名称不能包含空格。
如果名称以大写字母开头的函数将导出到其他包。如果函数名称以小写字母开头，则不会将其导出到其他包，但可以在同一包中调用此函数。
如果名称由多个单词组成，则第一个单词之后的每个单词都应大写，如下所示：empName，EmpAddress等。
函数名称区分大小写（CAR、Car 和 CAR 是三个不同的变量）。

将引用传递给函数

将变量的引用传递给函数，并在函数主体内使用取消引用修改变量的值。

package main

import "fmt"

func update(a *int, t *string) {
	*a = *a + 5      // defrencing pointer address
	*t = *t + " Doe" // defrencing pointer address
	return
}

func main() {
	var age = 20
	var text = "John"
	fmt.Println("Before:", text, age)

	update(&age, &text)

	fmt.Println("After :", text, age)
}

输出

Before: John 20
After : John Doe 25

匿名函数

匿名函数是声明的函数，没有任何命名标识符来引用它。匿名函数可以接受输入和返回输出，就像标准函数一样。

为变量赋值函数。

package main

import "fmt"

var (
	area = func(l int, b int) int {
		return l * b
	}
)

func main() {
	fmt.Println(area(20, 30))
}

将参数传递给匿名函数。

package main

import "fmt"

func main() {
	func(l int, b int) {
		fmt.Println(l * b)
	}(20, 30)
}

函数定义为接受参数和返回值。

package main

import "fmt"

func main() {
	fmt.Printf(
		"100 (°F) = %.2f (°C)\n",
		func(f float64) float64 {
			return (f - 32.0) * (5.0 / 9.0)
		}(100),
	)
}

匿名函数可用于包含不需要命名的功能，并且可能用于短期使用。

闭包功能

闭包是匿名函数的特例。闭包是匿名函数，用于访问在函数主体外部定义的变量。

访问主体外部定义的变量的匿名函数。

package main

import "fmt"

func main() {
	l := 20
	b := 30

	func() {
		var area int
		area = l * b
		fmt.Println(area)
	}()
}

在函数体内的循环的每次迭代中访问变量的匿名函数。

package main

import "fmt"

func main() {
	for i := 10.0; i < 100; i += 10.0 {
		rad := func() float64 {
			return i * 39.370
		}()
		fmt.Printf("%.2f Meter = %.2f Inch\n", i, rad)
	}
}

高阶函数

高阶函数是接收函数作为参数或返回函数作为输出的函数。

高阶函数是对其他函数进行操作的函数，方法是将它们作为参数或返回它们。

将函数作为参数传递给其他函数

package main

import "fmt"

func sum(x, y int) int {
	return x + y
}
func partialSum(x int) func(int) int {
	return func(y int) int {
		return sum(x, y)
	}
}
func main() {
	partial := partialSum(3)
	fmt.Println(partial(7))
}

输出

在上面的程序中，partialSum函数返回一个sum函数，该函数接受两个int参数并返回一个int参数。

从其他函数返回函数

package main

import "fmt"

func squareSum(x int) func(int) func(int) int {
	return func(y int) func(int) int {
		return func(z int) int {
			return x*x + y*y + z*z
		}
	}
}
func main() {
	// 5*5 + 6*6 + 7*7
	fmt.Println(squareSum(5)(6)(7))
}

输出

在上面的程序中，squareSum函数签名指定该函数返回两个函数和一个整数值。

用户定义函数类型

Golang还支持定义我们自己的函数类型。

上述程序的修改版本，功能类型如下：

package main

import "fmt"

type First func(int) int
type Second func(int) First

func squareSum(x int) Second {
	return func(y int) First {
		return func(z int) int {
			return x*x + y*y + z*z
		}
	}
}

func main() {
	// 5*5 + 6*6 + 7*7
	fmt.Println(squareSum(5)(6)(7))
}

为了安全php应该禁止那些函数和做哪些配置

为了安全，PHP应该禁止以下函数：

eval()：执行用户提供的代码。
exec()：执行系统命令。
system()：执行系统命令。
passthru()：执行系统命令并返回输出。
shell_exec()：执行系统命令并返回输出。
popen()：打开一个管道，用于执行系统命令。
proc_open()：打开一个管道，用于执行系统命令。
proc_get_status()：获取进程状态。
proc_terminate()：终止进程。
escapeshellcmd()：转义字符，用于安全地传递给系统命令。
escapeshellarg()：转义字符，用于安全地传递给系统命令。
ini_set()：设置或获取PHP配置选项。
register_globals()：将HTTP请求变量注册到全局作用域。
magic_quotes_gpc()：自动转义HTML字符。

此外，还应该进行以下配置：

设置 open_basedir 选项，限制PHP只能操作指定目录下的文件。
设置 allow_url_include 选项为 off，禁止远程文件包含。
设置 allow_url_fopen 选项为 off，禁止远程文件打开。
设置 display_errors 选项为 off，禁止错误回显。
设置 log_errors 选项为 on，将错误记录到日志文件。
设置 session.cookie_httponly 选项为 1，禁止JavaScript读取session cookie。
设置 session.cookie_secure 选项为 1，仅在HTTPS连接下发送session cookie。

这些配置和禁止的函数可以帮助防止PHP应用程序受到攻击。

以下是一些额外的安全建议：

使用强密码和密码策略。
定期更新PHP和其他软件。
安装防火墙和入侵检测系统。
监控系统日志，以寻找异常活动。

通过采取这些措施，可以帮助提高PHP应用程序的安全性。

php中__construct中先执行父类__construct的方法

parent::__construct()方法是调用父类的构造函数的方法。

示例代码：

phpclass ParentClass {
    public function __construct() {
        echo "父类的构造函数被执行";
    }
}

class ChildClass extends ParentClass {
    public function __construct() {
        parent::__construct(); // 调用父类的构造函数
        echo "子类的构造函数被执行";
    }
}

$child = new ChildClass(); // 输出：父类的构造函数被执行 子类的构造函数被执行

农历

五行

冲煞

彭祖

方位

宜

忌

吉神

凶神

极简任务管理 help

+ 0 0 0

Task Idea Collect