Go语言中文网 为您找到相关结果 140

【玩转Golang】slice切片的操作——切片的追加、删除、插入等

一、一般操作 1,声明变量,go自动初始化为nil,长度:0,地址:0,nil func main(){ var ss []string; fmt.Printf("length:%v \taddr:%p \tisnil:%v",len(ss),ss, ss==nil) } --- Running... length:0 addr:0x0 isnil:true Success: process exited with code 0. 2,切片的追加,删除,插入操作 func main(){ var ss []string; fmt.Printf("[ local print ]\t:\t length:%v\taddr:%p\tisnil:%v\n",len(ss),ss, ss==nil) ...阅读全文

博文 2015-01-20 06:13 dajianshi

Go学习笔记之:for循环

for循环是Go语言唯一的循环结构。这里有三个基本的for循环类型。 package main import "fmt" func main() { // 最基本的一种,单一条件循环 // 这个可以代替其他语言的while循环 i := 1 for i <= 3 { fmt.Println(i) i = i + 1 } // 经典的循环条件初始化/条件判断/循环后条件变化 for j := 7; j <= 9; j++ { fmt.Println(j) } // 无条件的for循环是死循环,除非你使用break跳出循环或者 // 使用return从函数返回 for { fmt.Println("loop") break } } 输出结果 1 2 3 7 8 9 loop 在后面的例子中,你将...阅读全文

博文 2014-11-26 00:21 Goopand

数组与切片

数组与切片的概念在其它语言中也有,之前我是没有搞明白他们之间的关系的。今天做了下总结 区别:数组是值类型,切片是引用类型,在使用的时候有区别。 如果用一个数组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。 ...阅读全文

go语言实现两个数组合并(merge)

//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++...阅读全文

博文 2013-12-02 17:57 zongjh

GoLang学习 -- array(数组)和slice(切片)

在使用golang过程当中,经常会用到数组类型。可在查看golang官方文档中发现,在golang语言当中,除了存在数组类型之外,还存在有切片类型。这个切片类型在其他语言都没有出现过,那么这个切片类型到底是一种什么类型呢?切片和数组又有什么区别? 下面就谈谈在golang中数组和切片的故事。 首先我们看一下数组: golang中的数组是一种由固定长度和固定对象类型所组成的数据类型。例如下面: var a [4]int a[0] = 1 i := a[0] // i == 1 a是一个拥有4个int类型元素的数组。当a一旦被声明之后,元素个数就被固定了下来,在a这个变量的生命周期之内,元素个数不会发生变化。而此时a的类型就是[4]int,如果同时存在一个b变量,为[5]int。即便两个变量仅仅...阅读全文

博文 2015-09-17 11:10 vikings_1001

go语言常用函数:copy

数组切片内容复制 用于将内容从一个数组切片复制到另一个数组切片。如果加入的两个数组切片不一样大,就会按其中较小的那个数组切片的元素个数进行复制。 slice1 := []int{1, 2, 3, 4, 5} slice2 := []int{5, 4, 3} copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中 copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置 //http://www.cnblogs.com/osfipin...阅读全文

博文 2015-07-27 17:27 osfipin

go 数组和数组切片比较

一、数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列。 (1)数组的创建。 数组有3种创建方式:[length]Type 、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN} 如下: 复制代码 代码如下: func test5() { var iarray1 [5]int32 var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5} iarray3 := [5]int32{1, 2, 3, 4, 5} iarray4 := [5]int32{6, 7, 8, 9, 10} iarray5 := [...]int32{11, 12...阅读全文

博文 2015-05-21 10:55 wenlovingliu

Go语言创建、初始化数组的各种方式

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("...阅读全文

博文 2014-03-18 15:10 books1958

go 切片:用法和本质

文: http://golang.org/doc/articles/slices_usage_and_internals.html中文: http://zh-golang.appsp0t.com/doc/articles/slices_usage_and_internals.html Go的切片类型为处理同类型数据序列提供一个方便而高效的方式。切片有些类似于其他语言中的数组,但是有一些不同寻常的特性。本文将深入切片的本质,并讲解它的用法。 数组 Go的切片是在数组之上的抽象数据类型,因此在了解切片之前必须要要理解数组。 数组类型由指定和长度和元素类型定义。例如,[4]int 类型表示一个四个整数的序列。数组的长度是固定的,长度是数组类型的一部分(int[4] 和 [5]int 是完全不同的类...阅读全文

博文 2015-12-24 16:21 yangyangye

golang数据类型-slice(切片)

slice介绍 数组的长度在定义之后无法再次修改;数组是值类型,每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。在初始定义数组时,我们并不知道需要多大的数组,因此我们就需要“动态数组”。在Go里面这种数据结构叫slice,slice并不是真正意义上的动态数组,而是一个引用类型。slice总是指向一个底层array,slice的声明也可以像array一样,只是不需要长度,它是可变长的,可以随时往slice里面加数据。 初看起来,数组切片就像一个指向数组的指针,实际上它拥有自己的数据结构,而不仅仅是个指针。数组切片的数据结构可以抽象为以下3个变量: 1.一个指向原生数组的指针(point):指向数组中slice指定的开始位置; 2.数组切片中的元素个数(len):即sli...阅读全文

博文 2014-06-23 16:03 JesseYoung

golang slice Append

s2 := append(s1, *) 切片s1上记录的切片信息复制给s2,1.如果s1指向的底层array长度不够,append的过程会发生如下操作:内存中不仅新开辟一块区域存储append后的切片信息,而且需要新开辟一块区域存储底层array(复制原来的array至这块新array中),最后再append新数据进新array中,这样,s2指向新array。2.如果s1指向的底层array长度够,s2和s1指向同一个array,append的结果是内存中新开辟一个区域存储新切片信息。开辟一块区域存储底层array 使用下面的策略:1.如果 增加的 len < s的cap 则 新s的cap*22.如果 增加的 len > s的cap 则 新s的cap = 老cap + 增加数据的 le...阅读全文

博文 2013-12-29 12:32 咖啡伴侣

Go语言学习(十)bytes包处理字节切片

bytes包提供了对字节切片进行读写操作的一系列函数 字节切片处理的函数比较多,分为基本处理函数,比较函数,后缀检查函数,索引函数,分割函数, 大小写处理函数和子切片处理函数等. 1.字节切片基本处理函数api 1.1Contains()函数 //Contains()函数的功能是检查字节切片b是否包含子切片subslice,如果包含返回true,否则返回false. func Contains(b,subslice []bytes) bool 1.2Count()函数 //Count()函数的功能是计算字节切片sep在字节切片s中非重叠显示的个数. func Count(s,sep[]byte) int 1.3Repeat()函数 //Repeat()函数的功能是把切片b复制count个,然...阅读全文

博文 2016-04-02 17:04 mChenys

golang bytes buffer代码剖析

//上数据结构,bytes Buffer type Buffer struct { buf []byte // byte切片 off int // 从&buf[off]地址读数据, 从&buf[len(buf)]地址写数据 runeBytes [utf8.UTFMax]byte // avoid allocation of slice on each WriteByte or Rune bootstrap [64]byte // memory to hold first slice; helps small buffers (Printf) avoid allocation. lastRead readOp // last read operation, so that Unread* ca...阅读全文

博文 2015-10-25 16:04 webyh

Go语言中不同类型切片之间的相互转换

将 []T 切片转换为 []byte 类似C语言中将其他类型的数组转换为char数组: func ByteSlice(slice interface{}) (data []byte) { sv := reflect.ValueOf(slice) if sv.Kind() != reflect.Slice { panic(fmt.Sprintf("ByteSlice called with non-slice value of type %T", slice)) } h := (*reflect.SliceHeader)((unsafe.Pointer(&data))) h.Cap = sv.Cap() * int(sv.Type().Elem().Size()) h.Len = sv.Len...阅读全文

博文 2014-05-20 15:16 chai2010

深入理解golang — 数组(array)、切片(slice)、map

我比较喜欢先给出代码,然后得出结论 数组 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...阅读全文

博文 2014-10-04 19:26:16 aqsmoke

go语言测试----切片删除

package main import ( "fmt" "math/rand" //"time" ) func main() { vect := make([]int, 100000) for i, _ := range vect { vect[i] = i } for i := 0; i < 10; i++ { k := rand.Intn(100000) //这里有可能会有重复的值,但我们假定有10个不同的值 vect[k] = -1 } for i, v := range vect { if v == -1 { //当V=-1时,假定是不需要的数据 vect = append(vect[:i], vect[i+1:]...) } } //测试一下 for i, v := range v...阅读全文

博文 2013-12-06 17:28 zistxym

go语言数组的拷贝

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(...阅读全文

博文 2016-03-17 10:26 u010087712

Go语言学习八:切片(slice)和范围(range)

// Go 语言切片是对数组的抽象。切片的单词来源于可以对其他数组和切片进行片段截取 // Go 数组的长度不可改变,在特定场景中这样的集合就不太适用, // Go中提供了一种灵活,功能强悍的内置类型切片("动态数组"), // 与数组相比切片的长度是不固定的,可以追加元素, // 在追加时可能使切片的容量增大。 package main import "fmt" func main() { // 切片的长度和容量 var numbers = make([]int, 3, 5) //用make创建切片 printSlice(numbers) // 空(nil)切片 // 切片在未初始化时默认是nil,长度是0,容量也是0 var numbers1 []int printSlice(numbe...阅读全文

博文 2016-03-31 10:05 shawncheer

Go语言4-数组、切片及map

1、数组 数组长度定义后不可修改,通过内置函数len()来获取数组元素个数 1)类型 //长度为32的byte数组,每个元素为一个字节 [32]byte //长度为2*N的复杂类型数组 [2*N] struct{x,y int32} //长度100的指针数组 [100]*float64 //二维数组,等同于[2]([3]int) [2][3]int //三维数组 [2][2][2]float64 2)定义 //定义一个长度为5的数组,默认会使用int类型的零值(0)进行初始化 arr := [5]int{} //与上面一句作用一样 var arr [5]int = [5]int{} //定义一个长度为5的数组,其中arr[0]将被初始化为1,其余依旧是0 arr := [5]int{1} /...阅读全文

博文 2015-06-09 22:21 zjl103

Go 语言切片(Slice)

定义切片 你可以声明一个未指定大小的数组来定义切片: var identifier []type 切片不需要说明长度。 或使用make()函数来创建切片: var slice1 []type = make([]type, len)也可以简写为slice1 := make([]type, len) 也可以指定容量,其中capacity为可选参数。 make([]T, length, capacity) 这里 len 是数组的长度并且也是切片的初始长度。 当leng增长,超出 capacity(容量)是,容量自动会扩大至两倍 空(nil)切片:一个切片在未初始化之前默认为 nil,长度为 0 len() 和 cap() 函数 切片是可索引的,并且可以由 len() 方法获取长度。切片提供了计算容...阅读全文

指向切片的指针取切片中的值得问题

package main import ( "fmt" ) func main() { //指向切片的指针 var p = new([]int) *p = append(*p, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0) for i, v := range *p { fmt.Println(i, v) } fmt.Println(len(*p)) fmt.Println(p[9]) } 上述代码的最后一句无法输出,我想问下,如果是指向数组的话,最后一句代码是可以输出的,而对于指向切片的指针,该怎...阅读全文

rune

在Go当中 string底层是用byte数组存的,并且是不可以改变的。 例如 s:="Go编程" fmt.Println(len(s)) 输出结果应该是8因为中文字符是用3个字节存的。 len(string(rune('编')))的结果是3 如果想要获得我们想要的情况的话,需要先转换为rune切片再使用内置的len函数 fmt.Println(len([]rune(s))) 结果就是4了。 所以用string存储unicode的话,如果有中文,按下标是访问不到的,因为你只能得到一个byte。 要想访问中文的话,还是要用rune切片,这样就能按下表访问...阅读全文

go语言常用函数

append append:在切片末尾添加元素并返回结果。append函数原型:func append(slice []T, elements...T) 。其中T表示任意类型。 示例1: 1 arr1 := []int{1, 2, 3} 2 arr2 := append(arr1, 4, 5, 6) 3 fmt.Println(arr2) // 输出:1,2,3,4,5,6 append不仅能在切片末尾添加普通元素,还能在切片末尾添加切片。 1 arr1 := []int{1, 2, 3} 2 arr2 := []int{4, 5, 6} 3 arr3 := append(arr1, arr2...) // 此处必须要有 ... 否则编译器会报类型错误 4 fmt.Println(arr3)...阅读全文

博文 2015-06-11 11:20 hezhixiong

Go语言基础变量定义及初始化

package main import "fmt" func main(){ //变量定义 var v1 int var v2 string var v3 [10] int //数组 var v4 [] int //数组切片 var v5 struct{ f int } var v6 *int //指针 var v7 map[string] int //key 为string value为int的map var v8 func (a int) int //变量初始化 var var1 int = 10 var var2 = 10 var var3 := 10 fmt.Println("变量初始化") fmt.Printf("var1=%d, var2=%d, var3=%d\n", var1...阅读全文

博文 2015-03-16 23:19 qifeng1991

Go by Example: Slices

切片是Go语言的关键类型之一,它提供了比数组更加强大的队列相关接口。 package main import "fmt" func main() { // 和数组不同的是,切片的类型仅由它所包含的元素决定。 // 使用内置函数make可以创建一个长度不为零的切片。 // 下面创建了一个长度为3,存储字符串的切片, // 切片元素默认为零值,对于字符串就是""。 s := make([]string, 3) fmt.Println("emp:", s) // 和数组一样可以使用index来设置元素值或获取元素值 s[0] = "a" s[1] = "b" s[2] = "c" fmt.Println("set:", s) fmt.Println("get:",...阅读全文

博文 2014-12-01 22:23 codemanship

学习Golang语言(4):类型--字符串

学习Golang语言(4):类型--字符串 --- 跟着“码术”一起学习Golang语言,今天继续讲解Golang中的类型。今天讲解的是字符串。 **数值类型** 补充上一章节没有指出的地方: Golang还定义了三种依赖系统的类型:int、unint和uintptr。因为在32位系统和64位系统上用来表示这些类型的位数是不同的。 **字符串** Golang中另一个重要的内建类型是string。 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的,而Go的字符串不同,它是由字节组成的。 Go语言的字符串的字节使用UTF-8编码标识Unicode文本。 字...阅读全文

Go语言的切片

package main import ( "fmt" ) func main() { arr := [...]string{"go", "python", "java", "c++", "c"} fmt.Println("arr value ", arr) fmt.Println("------------------------") slice1 := arr[1:3] fmt.Println("slice1 now is ", slice1) fmt.Println("len of slice1 is ", len(slice1), ",cap of sclie1 is ", cap(slice1)) fmt.Println("------------------------") sl...阅读全文

博文 2015-01-11 11:10 itfanr

[心凉半截]怎么到处都是陷阱?golang,我总觉得好危险。

``` package main import ( "fmt" "sort" ) type Score struct { score int } func main() { slc := []Score{Score{10}, Score{9}, Score{7}, Score{6}, Score{5}, Score{4}, Score{3}, Score{2}, Score{1}, Score{0}} temp := append(slc, Score{12}) fmt.Println("temp 1:", temp) fmt.Println("slc 1:", slc) // 输出: //temp 1: [{10} {9}...阅读全文

Go语言切片的用法和本质

Go 切片:用法和本质 原文链接 http://blog.golang.org/go-slices-usage-and-internals 引言 Go的切片类型为处理同类型数据序列提供一个方便而高效的方式。 切片有些类似于其他语言中的数组,但是有一些不同寻常的特性。 本文将深入切片的本质,并讲解它的用法。 数组 Go的切片是在数组之上的抽象数据类型,因此在了解切片之前必须要先理解数组。 数组类型定义了长度和元素类型。例如, [4]int 类型表示一个四个整数的数组。 数组的长度是固定的,长度是数组类型的一部分( [4]int 和 [5]int 是完全不同的类型)。 数组可以以常规的索引方式访问,表达式 s[n] 访问数组的第 n 个元素。 var a [4]int a[0] = 1 i :=...阅读全文

博文 2016-04-13 21:17 cqbmax

go的数组和切片

对于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...阅读全文

博文 2014-10-10 16:33 canzyq

切片数组指针???切片指针数组???

``` func MyToString(my []*my) string { info := make([]string, 0, 5) for _, data := range (orderManage) { info.append(info, data.name) info.append(info, data.class) info.append(info, data.adde) } return string(info) } //其中my是我自己定义的类型,函数功能是:将[]*my里面的数据转化为string类型。 ``` Qes:...阅读全文

学习Golang语言(5):类型--数组

学习Golang语言(5):类型--数组 --- 之前的章节我们学习了Golang的基本数据类型。接下来我们要学习Golang内置的高级类型:数组、切片和字典。 **数组(array)** Go语言的数组是一个定长的序列,数组包含的元素的类型相同。多维数组可以简单的使用自身为数组的元素来创建。 数组的元素使用操作符[]来索引,索引号从0开始。因此数组第一个元素为:array[0],最后一个元素为array[len(array)-1]。数组是可以更改的,可以使用array[index]放在赋值操作符左侧完成设置index位置的元素内容。 数组使用以下语法创建: ``` [length]type; [N]type(value1,value...阅读全文

golang实现Ringbuf

Ring buffer算法优点:高内存使用率,在缓冲buffer内存模型中,不太容易发生内存越界、悬空指针等 bug ,出了问题也容易在内存级别分析调试。做出来的系统容易保持健壮。 package main import ( "bytes" "fmt" ) type Ringbuf struct { buf []byte start, size int } func New(size int) *Ringbuf { return &Ringbuf{make([]byte, size), 0, 0} } func (r *Ringbuf) Write(b []byte) { for len(b) > 0 { start := (r.start + r.size) % len(r.buf) n ...阅读全文

博文 2015-10-20 22:36 webyh

Go学习笔记之:切片

切片是Go语言的关键类型之一,它提供了比数组更多的功能。 示例1: package main import "fmt" func main() { // 和数组不同的是,切片的长度是可变的。 // 我们可以使用内置函数make来创建一个长度不为零的切片 // 这里我们创建了一个长度为3,存储字符串的切片,切片元素 // 默认为零值,对于字符串就是""。 s := make([]string, 3) fmt.Println("emp:", s) // 可以使用和数组一样的方法来设置元素值或获取元素值 s[0] = "a" s[1] = "b" s[2] = "c" fmt.Println("set:", s) fmt.Println("get:", s[2]) // 可以用内置函数len获取切...阅读全文

博文 2014-11-25 23:30 Goopand

GO中的“泛型”?

Golang不支持一般的类似Java中的标记式泛型。很多人因此而十分不满,认为没有泛型增加了很多工作量。而目前由于泛型支持的复杂性,Golang的设计和实现者并没有把这个泛型支持作为紧急需要增加的特性。但是,如果真的没有泛型,就一定不行了么?答案当然是否定的。没有泛型也可以,而且我觉得代码更简单,直接,有趣(个人观点,勿喷)。 我们这里打算以一些例子来讲解Golang中如何处理这个问题。 首先,我们看一个冒泡排序的问题。针对整型数组切片的排序。 package main import ( "fmt" ) func bubbleSort(array []int) { for i := 0; i < len(array); i++ { for j := 0; j < len(array)-i-1...阅读全文

博文 2017-01-11 16:00:00 vaptu

go-map

package main import "fmt" /** 声明 var m map[int]string var b a := 赋值 map[int]string{} map[int]string{1: "a", 2: "b", 4: "c"} make(map[int]string) */ func main() { var m map[int]string m = map[int]string{} fmt.Println(m) var n map[int]string n = make(map[int]string) fmt.Println(n) var b = make(map[int]string) fmt.Println(b) a := make(map[int]string) ...阅读全文

博文 2016-08-14 10:27 u013210620

空结构体struct{}解析

本篇文章转自David的"The empty struct"一文,原文地址链接是http://dave.cheney.net/2014/03/25/the-empty-struct 。欢迎大家访问[我的博客](http://zuozuohao.github.io/),代码可以在[@Zuozuohao](https://github.com/Zuozuohao/GolangGOFPatterns)下载。 **Introduction** 这篇文章详细介绍了我最喜欢的Go数据类型,空结构体--struct{}。 空结构体是没有位段的结构体,以下是空结构体的一些例子: ``` type Q struct{} var q struct{} ``` 但是如果一个就结...阅读全文

控制 Golang 切片的增长

如果你是Golang 新手,并对它的数组(切片)不太了解,你可能想从这里开始this introduction。 如今,当我们谈论数组时,开发者可能会谈论数组的两种行为之一:一种是静态的(或称为固定数组),另一种是动态的。静态数组的固定长度在定义的时候被初始化完成。动态数组(一般地)用一个静态数组定义,但是当需要的时候,能够增长其长度。那么这是如何实现呢?当你要在动态数组中添加一项条目时,如果数组下面的固定长度已经满了,它会创建一个更大的数组并且将数据拷并到并覆盖更大的数组中。 这种增长和拷贝可能似乎及其地慢,但是动态数组通常使用一种动态分配多余空间的增长算法。这种简单的算法将会增加原来数组的一倍大小。所以当我们试图插入在一个容量为10的数组中插入第11条条目时,我们最终会得到一个新数组容量...阅读全文

博文 2016-07-07 09:21:45 caotj72, 刺猬bear, 无若, sheepbao

学习for循环的小问题,恳请老师指点一下

```go 1:sum := 0 2:for i := 0; i < 10; i++ { 3:sum += i 4:} //这行以上好理解,我能懂 5:list := []string{"aaa", "bbb", "ccc"} //请问1,这里list的值是切片么?好像不是数组。 6:for _,v := range list{ //请问2,这_,与range配合起到啥作用?这个程序好像是死循环啊 7:fmt.Print("%s", v) 8:} //(右边是原文注释)这里使用了一个range,key和value分别是int和string类型,key是序号,从0开始,value是值 ``` 这是我学习时遇到的一个例子注释是我的疑问。请路过的老师扶一把,谢谢...阅读全文

我的Golang全接触

满打满算, 从好友推荐Golang至发文时, 使用Golang已经有1年多了. 这种时间对于C/C++ Java这些老者来说, 简直是菜鸟级别的经验 但作为新生代语言的特点就是实战. Golang这一年里, 已经为项目提供了稳定的服务器和强大的扩展能力, 与客户端的Unity3D里的C#一样, 都是强大, 极致开发效率代表的优秀开发语言. 用途篇 Golang到底拿来做啥? 我需要么? 高效(性能,开发)的服务器语言. 包括Web, 游戏, App 编写桌面级UI暂不是很适合 我需要把现在的C++, Python, Erlang等服务器改成Golang么? 性能有瓶颈, 开发效率低, 有钱有时间的话, 完全可以 评价篇 听过太多的人对Golang的评价, 大概分为这么几类: C/C++性能党...阅读全文

Go的可比性

package main import "fmt" type Album struct { music []string } func main() { a1 := Album{music: []string{"music", "music2"}} a2 := Album{music: []string{"music", "music2"}} fmt.Println(a1 == a2) } 上面这段程序无法编译,报错: invalid operation: a1 == a2 (struct containing []string cannot be compared) 是因为结构体内的切片不具有比较性。 切片类型、字典类型、函数类型的值是不具有可比性的...阅读全文

博文 2015-01-24 16:55 itfanr

go语言细节

数组与字符串为值类型,切片、映射、通道为值类型,赋值需注意。 1 package main 2 3 import ( 4 "fmt" 5 ) 6 7 func main() { 8 //数组 9 a1 := [3]int{1, 2, 3} 10 a2 := a1 11 a2[0] = 2 12 fmt.Println(a1) //print: 1 2 3 13 fmt.Println(a2) //print: 2 2 3 14 // 字符串 15 s1 := "123" 16 s2 := s1 17 s2 = "223" 18 fmt.Println(s1) //print 123 19 fmt.Println(s2) //print 223 20 // 切片 21 slice1 := []...阅读全文

博文 2015-11-23 09:52 --xiaoyao--

go 速学 - 07 - Slice

目录 切片 Slice 概念 创建 Slice 定义切片 指定范围创建切片 使用 make 创建切片 len和 cap 遍历 Reslice Append 概念 使用 Copy 摘要 切片和数组的区别,创建切片,指定范围,make,遍历,reslice,append,copy 切片 Slice 概念 切片本身不是数组,而是指向底层的数组,关联数组的局部或全部 切片是引用类型 创建切片时索引不能超过数组的大小,否则会报异常 创建 Slice 定义切片 定义时不用指定长度(指定长度或使用 “…” 表示的是数组) //切片 var s []int fmt.Println(s) //[] //数组 var arr [5]int fmt.Println(arr) //[0 0 0 0 0] 指定范围创...阅读全文

【时速云线上分享】第十一期:Radio Dream流媒体直播平台基于Docker的应用

以下整理自第十一期技术分享内容,由 时速云 史鑫磊 分享。 首先介绍一下背景,Radio Dream项目是一个开源项目,前身为五雷轰顶网络电台,这个项目是我个人逐渐打磨了将近两年,最开始是因为猫扑网络电台停播,我个人是猫扑电台的老听众,很舍不得这个平台,后来想想,干脆自己做一个网络电台,就是因为这些想法催生了这个项目的成立。 说完背景开始聊聊这个电台的架构,我们从流媒体协议选型到架构实现等多个方面拆分的讲解这个平台实现方法,另外时速云镜像仓库里Radio Dream的镜像demo,总体来说这套系统部署起来还是十分复杂,虽然对系统要求极其低,单核心CPU,128M内存,20GB左右的硬盘就能跑起来,但是从最开始的架构设计我就打算做成一个集群化的方案,方便动态扩容,服务更多用户,...阅读全文

golang中不定参数与数组切片的区别

package main import "fmt" func main() { myfunc1(88, 42, 12, 56) //传递不定数量的参数 myfunc2([]int{88, 42, 12, 56}) //传递一个数组切片 } func myfunc1(args ...int) { //接受不定数量的参数,这些参数的类型全部是int for _, arg := range args { fmt.Println(arg) } } func myfunc2(args []int) { //传递一个数组切片 for _, arg := range args { fmt.Println(arg) } } 参考资料: 《Go语言编程》 2.5.3 不定参...阅读全文

切片:用法和本质[翻译]

文: http://golang.org/doc/articles/slices_usage_and_internals.html 中文: http://zh-golang.appsp0t.com/doc/articles/slices_usage_and_internals.html Go的切片类型为处理同类型数据序列提供一个方便而高效的方式。切片有些类似于其他语言中的数组,但是有一些不同寻常的特性。本文将深入切片的本质,并讲解它的用法。 数组 Go的切片是在数组之上的抽象数据类型,因此在了解切片之前必须要要理解数组。 数组类型由指定和长度和元素类型定义。例如,[4]int 类型表示一个四个整数的序列。数组的长度是固定的,长度是数组类型的一部分(int[4] 和 [5]int 是完全不同的...阅读全文

博文 2013-04-04 10:50 chai2010