s := strings.Split("", "") fmt.Println(s, len(s)) s = strings.Split("abc,abc", "") fmt.Println(s, len(s)) s = strings.Split("", ",") fmt.Println(s, len(s)) s = strings.Split("abc,abc", ",") fmt.Println(s, len(s)) s = strings.Split("abc,abc", "|") fmt.Println(s, len(s)) fmt.Println(len("")) fmt.Println(len([]string{""})) str := "" fmt.Println(str[0]...阅读全文
1 go语言数组简介 数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。 在Go语言中数组是一个值类型（value type）。是真真实实的数组，而不是一个指向数组内存起始位置的指针，也不能和同类型的指针进行转化，这一点严重不同于C语言。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。 2 数组定义 定义方式如下 var arr [n]type n表示数组长度，type表示数组存储类型。 在Go语言中，...阅读全文
string 不能直接和byte数组转换string可以和byte的切片转换1,string 转为[]bytevar str string = "test"var data []byte = []byte(str)2,byte转为stringvar data [10]byte byte[0] = 'T'byte[1] = 'E'var str string = string(data[:]...阅读全文
Go语言的语法很灵活，以下展示了创建并初始化数组的多种方式： //数组初始化的各种方式 func arraySliceTest0201() { //创建数组(声明长度) var array1 = [5]int{1, 2, 3} fmt.Printf("array1--- type:%T \n", array1) rangeIntPrint(array1[:]) //创建数组(不声明长度) var array2 = [...]int{6, 7, 8} fmt.Printf("array2--- type:%T \n", array2) rangeIntPrint(array2[:]) //创建数组切片 var array3 = []int{9, 10, 11, 12} fmt.Printf("...阅读全文
//x数组，i：x数组的起始下标 y数组，j：y数组的起始下标 //说明：x和y数组都是有序的数组 func merge(x []int, i int, y []int, j int) []int { xlen := len(x)//x数组的长度 ylen := len(y)//y数组的长度 z := make([]int, xlen+ylen)//创建一个大小为xlen+ylen的数组切片 k := 0//数组切片z的下标 for i if x[i] < y[j] {//把小数放在数组切片z里 z[k] = x[i] i++ } else { z[k] = y[j] j++ } k++ } for i != xlen {//把x到xlen-1的数据也存入z中 z[k] = x[i] k++...阅读全文
package main import ( "encoding/json" "fmt" "os" ) type ConfigStruct struct { Host string `json:"host"` Port int `json:"port"` AnalyticsFile string `json:"analytics_file"` StaticFileVersion int `json:"static_file_version"` StaticDir string `json:"static_dir"` TemplatesDir string `json:"templates_dir"` SerTcpSocketHost string `json:"serTcpSocketHost...阅读全文
cap()函数返回的是数组切片分配的空间大小。//http://www.cnblogs.com/osfipin/. package main import "fmt" func main() { mySlice := make([]int, 5, 10) fmt.Println("len(mySlice):", len(mySlice)) fmt.Println("cap(mySlice):", cap(mySlice)) } 该程序的输出结果为： len(mySlice): 5 cap(mySlice): 1...阅读全文
package main import( "fmt" "sort" ) func RemoveDuplicatesAndEmpty(a []string) (ret []string){ a_len := len(a) for i:=0; i < a_len; i++{ if (i > 0 && a[i-1] == a[i]) || len(a[i])==0{ continue; } ret = append(ret, a[i]) } return } func main(){ a := []string{"hello", "", "world", "yes", "hello", "nihao", "shijie", "hello", "yes", "nihao","good"} sort....阅读全文
有几个数组指针需要打印 由于长度不一样 如 a:=[3]int{1,2,3} 想再fmt.Println(&a) 这样是打印不出来a的地址的 请问如何不用中间变量直接打印a的地址...阅读全文
append属于内置函数，用于 slice 的元素添加操作。slice 在操作时需要注意：slice 底层指向一个数据，相当于一个 view。因此在做 append 操作时必须要注意当底层数组无法容纳新增元素时，append会分配一个更大数组来容纳 slice，从而导致 slice 指向的底层数组变化。观察以下代码： ia := [...]int{1,2,3,4,5} ia2 := ia[1:3] ia2 = append(ia2,6,7,8,9) fmt.Println(ia,ia2) 打印的结果为：[1 2 3 4 5] [2 3 6 7 8 9]因为原始的 ia 数组无法容纳之后的 6，7，8，9，因此append直接分配了一个新的底层数组。观察以下代码： ia := [...]int...阅读全文
Golang 的数组指针和指针数组听上去有点乱不太好理解 但是自己动手敲一下 就一眼可以看出区别了 package main import "fmt" func main(){ x,y := 1, 2 var arr = [...]int{5:2} //数组指针 var pf *[6]int = &arr //指针数组 pfArr := [...]*int{&x,&y} fmt.Println(pf) fmt.Println(pfArr) } 可以看出代码中 数组指针 pf 的值得到的是一个指向arr 地址的一个指针 而指针数组 pfArr 则是一个数组内的元素全是指针类型 一下是打印出来的结果 &[0 0 0 0 0 2] [0xc04204a080 0xc04204a088...阅读全文
概念：指同一系列同一类型数据的集合。声明方法如下：[32]byte //长度为32的数组[2*N] struct { x, y int32} //复杂类型的数组[1000]*float64 //指针数组[3][5]int //二维数组[2][2][2]float64 //等同于[2]([2]([2]float64))获取数组长度：arrLength := len(arr)遍历数组方法如下：方法一：for i:=0; i
go语言的数组与c语言的数据有一点不太一样的地方，go语言的赋值是值拷贝 package main import "fmt" func main() { var ages [4]int = [4]int{1, 2, 3, 5} var b = ages b[0]++ fmt.Println(ages) fmt.Println(b) } 输出的结果是： [1 2 3 5] [2 2 3 5] 要想使ages改变时，b也跟着改变可以使用指针 package main import "fmt" func main() { var ages [4]int = [4]int{1, 2, 3, 5} var b = &ages b[0]++ fmt.Println(ages) fmt.Println(...阅读全文
数组与切片的概念在其它语言中也有，之前我是没有搞明白他们之间的关系的。今天做了下总结 区别：数组是值类型，切片是引用类型，在使用的时候有区别。 如果用一个数组A创建新数组B的时候，需要将A中的所有元素全部复制一遍过去。如果是切片的话，就会指向原来的数据。 数组赋值拷贝见下面例子 func main() { var a [10]int = [10]int{1, 2, 3} b := a b[0] = 2 fmt.Printf("%d,%d", (int)(a[0]), (int)(b[0])) } 输出的结果 1,2 创建过程也不同: 数组的创建使用 = []type{}创建，初始数据为0。 ...阅读全文
声明一个结构数组： var s[2]struct{name string, age int} 然后要怎样初始化和赋值呢...阅读全文
声明&初始化 数组 数据是一个固定长度的数据类型，用户存储一段具有<<相同类型>>的元素的<<连续快>>。数据存储的类型可以使内置类型。整形 字符串 或某种机构类型 占用内存方式为<<连续分配>>。由于内存连续，CPU能把正在使用的数据缓存更久的时间。并且因为内存连续所以索引很容易计算，可以快速迭代数组中所有的元素。 初始化&声明 声明数组： 指定内部存储的数据类型、需要存储的数据数量（长度）、 //声明一个包含5个整形元素的数组 var array [5] int 数组规则:一旦声明之后元素类型&数组长度不能更改 声明完成之后进行初始化数组会把数组中的元素全部初始化成元素类型所对应的零值。整形对应的零值为0。 数组字面量 数组字面量是一种快速创建并初始化数组的方式。数组字面量允许声明数组里...阅读全文
package main import ( "fmt" ) func main() { s := []interface{}{1, 2, 3, 4, 5, 6, 7, 8} HERE: for k, v := range s { if v == 4 || v == 6 || v == 7 { // temp := s[k+1:] fmt.Println("k", k) temp := make([]interface{}, 0) for _, v := range s[k+1:] { temp = append(temp, v) } fmt.Println("temp1", temp) s = append(s[:k], "(") fmt.Println(s) s = append(s, [...阅读全文
Go语言实现将[]string转化为[]byte 假设你想实现Go语言的string数组到byte数组的转化。演示函数如下所示： func convertStringsToBytes(){ stringContent := []string{"通知中心","perfect!"} byteContent := "\x00"+ strings.Join(stringContent, "\x02\x00") // x20 = space and x00 = null fmt.Println([]byte(byteContent)) fmt.Println(string([]byte(byteContent))) } 完整代码： package main import ( "fmt" "string...阅读全文
package main import ( "fmt" ) func main() { a := []int{1,2,3,4} fmt.Println("a:",len(a), cap(a), a) b := [10]int{1,2,3,4} fmt.Println("b:",len(b), cap(b), b) c := make([]int, 4, 10) fmt.Println("c:",len(c), cap(c),c) d := b[:5] fmt.Println("d:",len(d), cap(d),d) e := append(d,5) //append后d的容量不变 e[0] = 100//没超出底层数组的容量，因此e和d都指向同一个数组，修改e会影响d fmt.Print...阅读全文
数组乱序 方法1.sliceOutOfOrder 选定随机数r 将下标r和下边i交换，i– ，就是和当前最后一位交换 方法2.rand.Perm(数组长度) 将原数组下标按照随机出来的数据赋值给另一数组 package main import "fmt" import "math/rand" import "time" var ( rr = rand.New(rand.NewSource(time.Now().UnixNano())) a1 = [2]int{} a2 = [10]int{} ) func main() { a := []int{0, 1} for i := 0; i < 10000; i++ { randslice() //fmt.Println(rr.Intn(10)) ...阅读全文
１，Int2Byte 把int的每个字节取出来放入byte数组中，存储采用Littledian2,Byte2Int 把byte Slice 中的每个字节取出来， 按Littledian端拼成一个intfunc Int2Byte(data int)(ret []byte){ var len uintptr = unsafe.Sizeof(data) ret = make([]byte, len) var tmp int = 0xff var index uint = 0 for index=0; index
/*640*60，创建于2013-5-24*/ var cpro_id = "u1290382"; go语言里边的字符串处理和PHP还有java 的处理是不一样的，首先申明字符串和修改字符串 [php] package main import "fmt" var name string //申明一个字符串 var emptyname string = "" //申明一个空字符串 func main() { //申明多个字符串并且赋值 a, b, v := "hello", "word", "widuu" fmt.Println(a, b, v) //转换字符串的内容，先转换a的类型为[]byte c := []byte(a) //赋值 c[0] = ‘n’ //在转换成字符串类型，其实我们发...阅读全文
数组Array 定义数组的格式：var package main import ( "fmt" ) func main() { //数组的长度也是类型的一部分，因此具有不同长度的数组为不同类型 var a [2]int //定义长度为2的int型数组。 var b [1]int //长度为1的int型数组 b = a fmt.Println(b)//此时编译时不通过的 } 数组的长度也是类型的一部分，因此具有不同长度的数组为不同类型 package main import ( "fmt" ) func main() { a := [20]int{19: 1} //长度为20的int型数组，索引位为19的赋值为1 b := [...]int{0: 1, 1: 2, 2: 3} //3个点代表不...阅读全文
结论：GoLang里对slice一定要谨慎使用append操作。cap未变化时，slice是对数组的引用，并且append会修改被引用数组的值。append操作导致cap变化后，会复制被引用的数组，然后切断引用关系。 代码和注释如下： package main import ( "fmt" ) func main() { array := []int{10, 11, 12, 13, 14} slice := array[0:4] // slice是对array的引用 fmt.Println("array: ", array) // array: [20 21 12 13 14] fmt.Println("slice: cap=", cap(slice), ", value=", slice)...阅读全文
go语言之整形和字节数组的转换 //整形转换成字节 func IntToBytes(n int) []byte { tmp := int32(n) bytesBuffer := bytes.NewBuffer([]byte{}) binary.Write(bytesBuffer, binary.BigEndian, tmp) return bytesBuffer.Bytes() } //字节转换成整形 func BytesToInt(b []byte) int { bytesBuffer := bytes.NewBuffer(b) var tmp int32 bin...阅读全文
声明数组 简单声明数组 //声明一个2个元素的数组，名字为shuzu1,因为是int型数组，所以初值为0，即[0,0] var shuzu1 [2]int //声明一个2个元素的数组，名字为shuzu2，并同时赋初值，{}里为空，说明没有赋初值，等同于上面 shuzu2 := [2]int{} 声明数组并同时赋初值 //声明一个2个元素的数组，名字为shuzu3, shuzu3_1, shuzu3_2，并同时赋初值，结果均为[1,2] shuzu3 := [2]int{1,2} //{}里的冒号左边是下标，右边是值 shuzu3_1 := [2]int{0:1,1:2} shuzu3_2 := [2]int{1:2,0:1} 声明数组并同时赋初值,并自动计算长度 //不指定数组长度，自动计算...阅读全文
/*640*60，创建于2013-5-24*/ var cpro_id = "u1290382"; 1.申明一个数组 var a[2] int 或者 a:=[2]int{1,2} 2.数组索引 数组就是索引的来建立如下图 我们再来一个测试 3.go语言可以自动计算数组的长度，譬如你知道数组有几个可以如下申明 [php] a:=[…]int{1,2,3,45} [/php] 4.指针数组 [php] a:=[3]int{1,2,3} var p * [3]int = &a //这种是指针数组 我们看到可以直接输出指向数组的指针 x , y :=1 ,3 a := […]*int{&x ,&y} str.Println(a) //输出这样[0xc080000068 0xc080000070]的地...阅读全文
在Go语言中，当多维数组直接作为函数实参进行参数传递的时候，会有很大的限制性，比如除第一维数组的其他维数需要显式给出等；此时可以使用多维切片来作为参数传递： type s1 []int type s2 []s1 剑指offer一书面试题3： 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列按照从上到下的顺序排序。完成一个函数，输入二维数组和要查找的数，判断该数是否存在于二维数组中。 代码： package main import ( "errors" "fmt" "os" ) type s1 []int type s2 []s1 var searchErr error = errors.New("search error") func main() { a := s2{ s1{1...阅读全文
```go const maxSize = 100 //SqQueue 结构体定义 type SqQueue struct { data [maxSize]interface{} front int rear int } //New 新建空队列 func New() *SqQueue { return &SqQueue{ front: 0, rear: 0, } } // Length 队列长度 func (q *SqQueue) Length() interface{} { return (q.rear - q.front + maxSize) % maxSize } // Enqueue 入队 func (q *SqQueue) Enqueue(e interface{}) error ...阅读全文
package main import ( "fmt" ) func Merge() { a := []int{3,6,9, 4,5,45} z := merge2(a, 0, 2, 5, 6) fmt.Printf("%#v\n", z) } //x数组，下标p,q,r 元素个数m。x[p]~x[q]及x[q+1]~x[r]已按递增排序 func merge2(x []int, p, q, r, m int) []int { z := make([]int, m) k := 0 a := q b := q + 1 for p if x[p] z[k] = x[p] p++ } else { z[k] = x[b] b++ } k++ } for p != a+1 { z[k] = x[p]...阅读全文
请问golang有无内置的array diff 函数，比较 两个函数A1， A2, 返回 A1中有，A2中没有的数组？有朋友写过版本没有？直接一个个比较效率不高，有没有比较好的算法共享下？不甚感...阅读全文
我们常常因为传入的参数不确定而头疼不已，golang 为我们提供了接入多值参数用于解决这个问题。但是一般我们直接写已知代码即所有的值都知道一个一个塞进去就好了，但是绝大部分我们是得到用户的大量输入想通过循环传入，但是这样发现无法使用这个多值参数的功能。其实底层实现将多个参数视为传入的一个不定长数组。那么我们就有想法了：既然底层使用数组，那我们传入数组是否可以，结论是不可以的，或者这样说比较合理：数组不能直接传入，需要辅助多参数标识来指明，具体让我们看以下一个简单的测试： func TestMultiParam(t *testing.T) { valueArray := []string{"1", "2", "3", "4", "5"} result := valueArray[0: 3] t...阅读全文
一般select的channel都是预先确定的如何使用select来监听运行时才确定长度的channel数组呢？各位遇到这种情况是如何解决的...阅读全文
package main import ( "fmt" ) type TestStruct struct { aa string name string } type Object interface{} func main() { array := []Object{} a := TestStruct{} a.aa = "aaaa" a.name = "name" array = append(array, 1) array = append(array, a) for index, value := range array { fmt.Printf("arr[%d]=%d \n", index, value) } ...阅读全文
我比较喜欢先给出代码，然后得出结论 数组 1 package main 2 3 import ( 4 "fmt" 5 ) 6 7 func main() { 8 arr := [...]int{1, 2, 3} 9 //打印初始的指针 10 fmt.Printf("the pointer is : %p \n", &arr) 11 printPointer(arr) 12 } 13 14 func printPointer(any interface{}) { 15 fmt.Printf("the pointer is : %p \n", &any) 16 } 结果 1 the pointer is : 0xc082008580 2 the pointer is : 0xc0820001d0...阅读全文
本来想写一篇关于golang io的笔记，但是在学习io之前必须了解array, slice, string概念，因此将在下篇写golang io. array: 数组的长度是该数组类型的一部分，例如var buffer [256]byte 的类型是[256]byte, len(buffer)总是返回256. slice: 一个slice描述一个数组中连续的一部分，例如var slice = buffer[100:250]。slice也可以从slice产生，如var slice2 = slice[5:10]，其中slice的type是[]byte。slice并不真正存储数据，它只是包含一个指向数据的pointer，你可以把它当成这样的一个结构： type sliceHeader struct...阅读全文
一次偶然的机会看见了睡眠排序，很有意思的一种排序算法，可以说是对我们熟悉的正规排序的一种挑战，是思想上的突破，有点像脑筋急转弯。使用睡眠排序算法，只能按照从小到大的顺序排列。打印数组中的数据时，按照其大小sleep，这样，数越大sleep的时间也就越长。所有的数同时进入sleep状态，数比较小的会提前打印出来。近期使用的都是GO语言，对其并发也有了些许理解，所以，使用go语言来实现这种排序，是很不错的选择。 // test project main.go package main import ( "fmt" "time" ) var flag bool var container chan bool var count int func main() { flag = true conta...阅读全文
1，数组的特性 数组是线性表结构，从而内存空间是连续的且有着相同类型的数据。 正是由于是线性结构的特性才支持随机访问，时间复杂度为o(1)。 通过公式a[i]_address = base_address + i * data_type_size计算得到数组元素地址。 但是其插入、删除操作比较低效，因为会涉及到数据的迁移问题。以上就是数组的基本特性，下面我们看一下golang中数组相关知识。 2，声明及初始化 2.1，直接声明不显示初始化 var arr []type 数组声明之后编译器会做初始化操作，用数组值类型的零值进行初始化。 2.2，用一组值初始化数组 var arr [3]type = []type{1, 2, 3} 2.3，在数组字面值中，如果在数组的长度位置出现的是“...”省...阅读全文
1.有时候想一个函数中传入的参数很可能是不定的，除了可以使用: func funcname(...interface{}){ } 2.也可以将许多参数放进一个数组中，然后作为参数传入函数（或许会觉得这样有点多此一举，但是很可能存在历史遗留问题）： func funcname(args []interface{}){ fmt.Print(args...) //args...是将一个数组按顺序变成不定参数传入，这个还真的挺好用的 } $(function () { $('pre.prettyprint code').each(function () { var lines = $(this).text().split('\n').length; var $numbering = $('
golang和java中byte取值范围不一样 o(╯□╰)o，这里是个坑 golang定义如下 // byte is an alias for uint8 and is equivalent to uint8 in all ways. It is // used, by convention, to distinguish byte values from 8-bit unsigned // integer values. type byte byte java定义如下 public final class Byte extends Number implements Comparable { public static final byte MIN_VALUE = -128; publi...阅读全文
对于GO的数组和切片的初步了解， 切边是数组的一个指针，切片的初始化有三种：一种是通过make，即 slice := make([]int,5,10) 另一种是通过：=指向一个已经存在的数组。即 slice := []int {1,2,3,4,5,6} 切片的切片不可初始化超过原始切片的cap值，比如： sliceA := make([]int,5,10) sliceB := sliceA[:11] 这个是不行的，11超过了sliceA的cap值（10），会报运行时异常。 对切片的append，如果超过切片的cap值，编译器会扩充切片cap至原始切片cap+扩展后的切片len...阅读全文
1 数组类型 1）创建数组array 创建数组时候，必须定义数组长度。 数组不能改变长度。 数组元素默认初始化为0. var 数组变量 [N]类型 var arr [10]int arr := [10]int{1,2,3} //创建数组并初始化部分元素 arr := [...]int{1,2,3} //根据初始化元素个数创建数组 2）创建二位数组 声明了一个二维数组，该数组以两个数组作为元素，其中每个数组中又有4个int类型的元素 doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}} easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}} //内外类型一样，二维数组可省略...阅读全文
``` {{ range $k := [100]int{} }} {{$k}} {{end}} ``` 这样出错，不能再template里创建数组吗？ 如果 传递 进去 就可以： ``` {{ range $k := .arr }} {{$k}} {{end}} ``` 顺便再问个问题。。 golang 有没有方便创建长数组的方法？ 大约是下面这样的： ``` []int{100到200} ``...阅读全文
``` package main import "fmt" func removeDup(a []int)[]int { i := 0 for j := 1; j < len(a); j ++ { if a[i] != a[j] { i ++ a[i] = a[j] } } return a[:i+1] } func main() { a := []int{1,1,2,2,3,3,4,5} fmt.Println(removeDup(a)) // [1 2 3 4 5] } ``...阅读全文
hi 大家好 在服务端通过websocket收到一串uint8数组： [3,1,"checkin",{"ver":"2.4.7","sid":"","proxies":[]}] 前端用的是js的 `JSON.stringify([messageType, ackId, name, data])` 发送的消息，messageType是3，ackid为1, name为checkin，data为 `{"ver":"2.4.7","sid":"","proxies":[]}` 在服务端我想解析出messageType，ackid，checkin，和data中的各个域(如ver, sid, proxies) 查看了go websocket接口和开源的websocket实现都没...阅读全文
package main import ( "fmt" "reflect" ) func Map(slice interface{}, fn func(a interface{}) interface{}) interface{} { val := reflect.ValueOf(slice) out := reflect.MakeSlice(reflect.TypeOf(slice), val.Len(), val.Cap()) for i := 0; i < val.Len(); i++ { out.Index(i).Set( reflect.ValueOf(fn(val.Index(i).Interface())), ) } return out.Interface() } func ...阅读全文
golang package stack import ( "errors" ) type Stack []interface{} func(stack *Stack) Push(v interface{}) { *stack = append(*stack, v) } func(stack *Stack) Pop() (interface{}, error){ if len(*stack) == 0 { return nil, errors.New("stack empty") } v := (*stack)[len(*stack) - 1] *stack = (*stack)[:len(*stack) - 1] return v, nil } func(stack *Stack) Top...阅读全文
欢迎star，fork，push： https://github.com/smtc/goda...阅读全文
