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

【玩转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-22 13:00:01 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 08:00:01 Goopand

Go 语言 入门教程

1. 概述 Go 是一个开源的编程语言,它能让构造简单、可靠且高效的软件变得容易。Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发,后来还加入了Ian Lance Taylor, Russ Cox等人,并最终于2009年11月开源,在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的,并且拥有一个活跃的社区。 2. 优缺点 2.1 优点 开源 编译性语言, 运行高速 语法简洁 并行处理封装 内存管理、数组安全 2.2 缺点 作为编译性语言调试不如脚本方便 在数据分析上没有脚本适用 对底层的控制没有基础语言灵活 3. 用途 常应用于搭载 Web 服务器,存储集群或类似用途的巨型中央服务器的系统编程语言。对于高性...阅读全文

博文 2018-08-03 14:34:51 物干焯

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-26 20:00:48 vikings_1001

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

博文 2014-10-04 19:26:25 zongjh

Go 语言的优点,缺点和令人厌恶的设计

这是关于 「[Go是一门设计糟糕的编程语言 (Go is not good)](https://github.com/ksimka/go-is-not-good)」 系列的另一篇文章。Go 确实有一些很棒的特性,所以我在这篇文章中展示了它的优点。但是总体而言,当超过 API 或者网络服务器(这也是它的设计所在)的范畴,用 Go 处理商业领域的逻辑时,我感觉它用起来麻烦而且痛苦。就算在网络编程方面,Go 的设计和实现也存在诸多问题,这使它看上去简单实际则暗藏危险。 写这篇文章的动机是因为我最近重新开始用 Go 写一个业余项目。在以前的工作中我广泛的使用了 Go 为 SaaS 服务编写网络代理(包括 http 和原始的 tcp)。网络编程的部分是相当令人愉快的(我也正在探索这门语言),但随之而来...阅读全文

博文 2018-05-06 22:44:53 Donng

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-28 03:00:00 osfipin

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

博文 2015-06-17 23:01:47 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 是完全不同的类...阅读全文

博文 2016-01-31 05:00:00 yangyangye

Golang中Slice的append详解

在Golang语言中,数据类型不多,但是够用,开发项目过程中,Slice属于最常用的数据结构之一,对其原理理解不清楚,很容易会遗留bug,笔者查询了很多博客资料,对Slice的append原理进行一个总结,如果有写的不清楚不明白之处,请多多包涵,并予以指正。 package main import "fmt" func main(){ s := []int{5} s = append(s,7) fmt.Println("cap(s) =", cap(s), "ptr(s) =", &s[0]) s = append(s,9) fmt.Println("cap(s) =", cap(s), "ptr(s) =", &s[0]) x := append(s, 11) fmt.Println("c...阅读全文

博文 2017-09-05 07:34:51 tomorrowwu

Go 系列教程 —— 11. 数组和切片

欢迎来到 [Golang 系列教程](/subject/2)的第 11 章。在本章教程中,我们将讨论 Go 语言中的数组和切片。 ## 数组 数组是同一类型元素的集合。例如,整数集合 5,8,9,79,76 形成一个数组。Go 语言中不允许混合不同类型的元素,例如包含字符串和整数的数组。(译者注:当然,如果是 interface{} 类型数组,可以包含任意类型) ### 数组的声明 一个数组的表示形式为 `n[T]`。`n` 表示数组中元素的数量,`T` 代表每个元素的类型。元素的数量 `n` 也是该类型的一部分(稍后我们将详细讨论这一点)。 可以使用不同的方式来声明数组,让我们一个一个的来看。 ```go package main import ( "fmt" ) func main() ...阅读全文

博文 2018-01-07 20:41:48 Dingo1991

数组与切片

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

golang数据类型-slice(切片)

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

博文 2015-06-17 20:17:41 JesseYoung

Go 系列教程 —— 18. 接口(一)

欢迎来到 [Golang 系列教程](/subject/2)的第 18 个教程。接口共有两个教程,这是我们接口的第一个教程。 ### 什么是接口? 在面向对象的领域里,接口一般这样定义:**接口定义一个对象的行为**。接口只指定了对象应该做什么,至于如何实现这个行为(即实现细节),则由对象本身去确定。 在 Go 语言中,接口就是方法签名(Method Signature)的集合。当一个类型定义了接口中的所有方法,我们称它实现了该接口。这与面向对象编程(OOP)的说法很类似。**接口指定了一个类型应该具有的方法,并由该类型决定如何实现这些方法**。 例如,`WashingMachine` 是一个含有 `Cleaning()` 和 `Drying()` 两个方法的接口。任何定义了 `Cleani...阅读全文

博文 2018-01-22 20:09:55 heyulong

Go 语言“可变参数函数”终极指南

![Variadic Funcs](https://raw.githubusercontent.com/studygolang/gctt-images/master/variadic-func/title.png) ### 什么是可变参数函数? 可变参数函数即其参数数量是可变的 —— 0 个或多个。声明可变参数函数的方式是在其参数类型前带上省略符(三个点)前缀。 >译者注:“可变参数函数”在一些翻译中也称“变长函数”,本篇译文中采用“可变参数函数“ ![what is variadic func](https://raw.githubusercontent.com/studygolang/gctt-images/master/variadic-func/what_is_variadic_fu...阅读全文

博文 2017-12-16 13:11:49 shockw4ver

golang 数组和切片初始化方式

一、数组初始化方式 var [length]Type var array [5]int //这种方式,只是初始化,不带初始化值,数组长度,已经定义好, 但是其实初始化的值,已经有了并且是该类型的最小值(bool false),int 0, string ' ' 其他,自行验证 var [N]Type{value1, value2, ... , valueN} var array = [5]int{1, 2, 3, 4, 5} // 这种方式,既初始化变量,又带了初始化值,数组长度已经定义好 var [...]Type{value1, value2, ... , valueN} var array = [...]int{1, 2, 3, 4, 5} // 这种方式,既初始化变量,也是带了初始值...阅读全文

博文 2018-08-29 13:34:57 Tim_SSS

Go 系列教程 —— 35. 读取文件

![reading files](https://raw.githubusercontent.com/studygolang/gctt-images/master/golang-series/golang-read-files.png) 欢迎来到 [Golang 系列教程](https://studygolang.com/subject/2)的第 35 篇。 文件读取是所有编程语言中最常见的操作之一。本教程我们会学习如何使用 Go 读取文件。 本教程分为如下小节。 - 将整个文件读取到内存 - 使用绝对文件路径 - 使用命令行标记来传递文件路径 - 将文件绑定在二进制文件中 - 分块读取文件 - 逐行读取文件 ## 将整个文件读取到内存 将整个文件读取到内存是最基本的文件操作之一。这需要使用...阅读全文

博文 2018-09-04 23:19:49 heyulong

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-26 05:00:00 wenlovingliu

Go 系列教程 —— 12. 可变参数函数

欢迎来到 [Golang 系列教程](/subject/2)第 12 章。 ## 什么是可变参数函数 可变参数函数是一种参数个数可变的函数。 ## 语法 如果函数最后一个参数被记作 `...T ` ,这时函数可以接受任意个 `T` 类型参数作为最后一个参数。 请注意只有函数的最后一个参数才允许是可变的。 ## 通过一些例子理解可变参数函数如何工作 你是否曾经想过 append 函数是如何将任意个参数值加入到切片中的。这样 append 函数可以接受不同数量的参数。 ```go func append(slice []Type, elems ...Type) []Type ``` 上面是 append 函数的定义。在定义中 elems 是可变参数。这样 append 函数可以接受可变化的参数。...阅读全文

博文 2018-01-14 19:54:51 polaris

Golang 切片与函数参数“陷阱”

线性结构是计算机最常用的数据结构之一。无论是数组(arrary)还是链表(list),在编程中不可或缺。golang也有数组,不同于别的语言,golang还提供了切片(slice)。切片比数组有更好的灵活性,具有某些动态特性。然而切片又不像动态语言的列表(Python list)。不明白切片的基本实现,写程序的时候容易掉“坑”里。 slice参数 本来写一个堆排序,使用了golang的slice来做堆,可是发现在pop数据的时候,切片不改变。进而引发了golang函数切片的参数,是传值还是传引用呢?我们知道slice相比array是引用类型。那么直觉上告诉我们如果函数修改了参数的切片,那么外层的切片变量也会变啦。 func main() { slice := []int{0, 1, 2, 3...阅读全文

博文 2017-05-26 11:59:23 人世间

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 20:00:06 mChenys

Go 系列教程 —— 15. 指针

欢迎来到 [Golang 系列教程](/subject/2)的第 15 个教程。 ### 什么是指针? 指针是一种存储变量内存地址(Memory Address)的变量。 ![指针示意图](https://raw.githubusercontent.com/studygolang/gctt-images/master/golang-series/pointer-explained.png "指针示意图") 如上图所示,变量 `b` 的值为 `156`,而 `b` 的内存地址为 `0x1040a124`。变量 `a` 存储了 `b` 的地址。我们就称 `a` 指向了 `b`。 ### 指针的声明 指针变量的类型为 **`*T`**,该指针指向一个 **T** 类型的变量。 接下来我们写点代码。...阅读全文

博文 2018-01-22 17:37:19 heyulong

golang string转换数组

在golang中, 有数组和切片两种类型. 切片是引用类型,而数组是值类型. 如果想在函数中传入数组的指针参数, 则必须指定数组的数量, 如 func stringToRuneArr(s string, arr *[5]rune) 如果去掉 arr *[5]rune 中的5, 则指参数变成了切片类型, 数组的指针就传不进去了, 编译会报错, 那么难道一定要写死数组的长度吗? 这样也太不优雅. 经过一番搜索, 发现其实方法很简单, 就是把函数的参数改为切片, 然后传数组的切片进去. 因为切片是引用类型, 实际在函数中的修改是对应的原来的数组, 这样就达到了修改数组的目的, 只要修改不超出数组的长度,就没有问题. 代码例子如下: func StringToRuneArr(s string, ar...阅读全文

博文 2018-07-25 11:30:02 elonlee

Go 系列教程 —— 14. 字符串

欢迎阅读 [Golang 系列教程](/subject/2)第 14 部分。 由于和其他语言相比,字符串在 Go 语言中有着自己特殊的实现,因此在这里需要被特别提出来。 ## 什么是字符串? Go 语言中的字符串是一个字节切片。把内容放在双引号""之间,我们可以创建一个字符串。让我们来看一个创建并打印字符串的简单示例。 ```go package main import ( "fmt" ) func main() { name := "Hello World" fmt.Println(name) } ``` [在线运行程序](https://play.golang.org/p/o9OVDgEMU0) 上面的程序将会输出 `Hello World`。 Go 中的字符串是兼容 Unicode 编...阅读全文

博文 2018-01-22 16:53:54 jliu666

Go 系列教程 —— 33. 函数是一等公民(头等函数)

![custom errors](https://raw.githubusercontent.com/studygolang/gctt-images/master/golang-series/first-class-functions-golang.png) 欢迎来到 [Golang 系列教程](https://studygolang.com/subject/2)的第 33 篇。 ## 什么是头等函数? **支持头等函数(First Class Function)的编程语言,可以把函数赋值给变量,也可以把函数作为其它函数的参数或者返回值。Go 语言支持头等函数的机制**。 本教程我们会讨论头等函数的语法和用例。 ## 匿名函数 我们来编写一个简单的示例,把[函数](https://study...阅读全文

博文 2018-04-13 21:35:15 heyulong

golang make()的第三个参数

学习了一段时间golang,大概可以用golang做一些小东西了,于是回顾了一下一些基础的东西。golang分配内存有一个make函数,该函数第一个参数是类型,第二个参数是分配的空间,第三个参数是预留分配空间,前两个参数都很好理解,但我对第三个参数却一脸懵逼,例如a:=make([]int, 5, 10), len(a)输出结果是5,cap(a)输出结果是10,然后我对a[4]进行赋值发现是可以得,但对a[5]进行赋值发现报错了,于是郁闷这个预留分配的空间要怎么使用呢,于是google了一下发现原来预留的空间需要重新切片才可以使用,于是做一下记录,代码如下。 package main import "fmt" func main(){ a := make([]int, 10, 20) fmt...阅读全文

博文 2017-08-25 03:03:20 zzmx

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 11:00:08 shawncheer

go语言坑之for range

go只提供了一种循环方式,即for循环,在使用时可以像c那样使用,也可以通过for range方式遍历容器类型如数组、切片和映射。但是在使用for range时,如果使用不当,就会出现一些问题,导致程序运行行为不如预期。比如,下面的示例程序将遍历一个切片,并将切片的值当成映射的键和值存入,切片类型是一个int型,映射的类型是键为int型,值为*int,即值是一个地址。 package main import "fmt" func main() { slice := []int{0, 1, 2, 3} myMap := make(map[int]*int) for index, value := range slice { myMap[index] = &value } fmt.Println...阅读全文

博文 2017-04-13 07:18:17 songleo

Go 系列教程 —— 28. 多态

欢迎来到 [Golang 系列教程](https://studygolang.com/subject/2)的第 28 篇。 Go 通过[接口](https://studygolang.com/articles/12266)来实现多态。我们已经讨论过,在 Go 语言中,我们是隐式地实现接口。一个类型如果定义了接口所声明的全部[方法](https://studygolang.com/articles/12264),那它就实现了该接口。现在我们来看看,利用接口,Go 是如何实现多态的。 ## 使用接口实现多态 一个类型如果定义了接口的所有方法,那它就隐式地实现了该接口。 **所有实现了接口的类型,都可以把它的值保存在一个接口类型的变量中。在 Go 中,我们使用接口的这种特性来实现多态**。 通过一...阅读全文

博文 2018-03-25 21:47:13 heyulong

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 11:00:12 u010087712

Go中map的创建和初始化

// code_014_map_usage project main.go package main import ( "fmt" ) func main() { /*Go语言中的map(映射,字典)是一种内置的数据结构,它是一个无序的key-value对的集合。 1)键的约束: 在一个map里所有的键都是唯一的,而且必须是支持==和!=操作符的类型 2)切片、函数以及包含切片的结构类型这些类型由于具有引用语义,不能作为映射的键 err, invalid map key type []string 3)map值: 可以是任意类型,没有限制。 4)键值的数据类型: map里所有键的数据类型必须是相同的,值也必须如何,但键和值的数据类型可以不相同。 5)注意:map是无序的,我们无法决定它的返回...阅读全文

博文 2018-10-05 01:35:15 ck_god

Go 系列教程 —— 27. 组合取代继承

欢迎来到 [Golang 系列教程](https://studygolang.com/subject/2)的第 27 篇。 Go 不支持继承,但它支持组合(Composition)。组合一般定义为“合并在一起”。汽车就是一个关于组合的例子:一辆汽车由车轮、引擎和其他各种部件组合在一起。 ## 通过嵌套结构体进行组合 在 Go 中,通过在结构体内嵌套结构体,可以实现组合。 组合的典型例子就是博客帖子。每一个博客的帖子都有标题、内容和作者信息。使用组合可以很好地表示它们。通过学习本教程后面的内容,我们会知道如何实现组合。 我们首先创建一个 `author` 结构体。 ```go package main import ( "fmt" ) type author struct { firstNam...阅读全文

博文 2018-03-25 21:42:49 heyulong

Go 系列教程 —— 29. Defer

欢迎来到 [Golang 系列教程](https://studygolang.com/subject/2)的第 29 篇。 ## 什么是 defer? `defer` 语句的用途是:含有 `defer` 语句的函数,会在该函数将要返回之前,调用另一个函数。这个定义可能看起来很复杂,我们通过一个示例就很容易明白了。 ## 示例 ```go package main import ( "fmt" ) func finished() { fmt.Println("Finished finding largest") } func largest(nums []int) { defer finished() fmt.Println("Started finding largest") max := ...阅读全文

博文 2018-03-30 23:05:21 heyulong

Golang基础篇之数据结构-栈

本篇通过实现一个自定义的栈,来学习Go语言的自定义类型及其方法首先栈的概念不用多说,它是一种支持从顶端插入或删除的线性表,废话少说上代码。在GOPATH下新建stack目录,栈的所有实现在stack.go文件之中。首先需要一个能够保存数据的结构体 type Stack []interfice {} 这里声明Stack为空接口类型的切片(Go语言之中的切片可以理解为一个长度可变的数组)。由于Go语言所有类型都实现了空接口,因此任意类型的值都可以存储在Stack之中。接下来,由于Stack的底层数据类型是一个切片,我们可以为其实现Len()和Cap()方法用来获取其长度和容量(Go语言之中首字母大写的方法为包外可访问的,类似于Java或者C++之中类的public方法)。 func (stack...阅读全文

博文 2017-07-25 17:06:35 码码码码

(Go)不要使用append插入元素

标题好像有点唬人哦…. 起因是我在给Slice做Insert函数,给几个版本封装时做了一些性能测试。结果出人意料! import ( "fmt" "reflect" "time" ) func copyInsert(slice interface{}, pos int, value interface{}) interface{} { v := reflect.ValueOf(slice) v = reflect.Append(v, reflect.ValueOf(value)) reflect.Copy(v.Slice(pos+1, v.Len()), v.Slice(pos, v.Len())) v.Index(pos).Set(reflect.ValueOf(value)) retur...阅读全文

博文 2016-11-22 04:00:05 Begosu

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 22:00:06 cqbmax

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

博文 2015-06-17 23:05:44 zistxym

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

博文 2015-05-12 21:00:03 chai2010

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 17:00:02 webyh

Golang中range的使用方法及注意事项

一、用法range类似迭代器,可以遍历数组,字符串,map等等,对象的不同,返回的结果也不同。 12345678910111213141516171819package mainimport "fmt"func main(){ //数组的遍历 a := [3]int {1, 2, 3} for i, n := range a{ fmt.Println(i, n) } //切片的遍历 b := []int{2, 3, 4} for i, n := range b{ fmt.Println(i, n) } //map的遍历 c := map[string]int{"Hello":1, "World":2} for k, v := range c{ fmt.Println(k, v) }} 结果:...阅读全文

博文 2018-05-17 09:25:56 马谦的博客

GOLANG 1.9 语言规范

简介 本文是GO语言的使用手册。对于更多的信息,请前往 golang.org。 GO 语言是一门通用的系统编程语言。它是一种强类型语言,支持自动垃圾收集,并且对语言层面对并发编程进行了支持。GO 程序以包的形式进行组织,对程序间的依赖关系进行高效的管理。当前实现方式使用传统的编译/链接模型生成二进制可执行文件。 GO语言语法紧凑且规范,故而便于如集成开发环境这样的自动化工具对其进行分析。 标识符 语法使用扩展的巴科斯范式(EBNF)描述: Production = production_name "=" [ Expression ] "." . Expression = Alternative { "|" Alternative } Alternative = Term { Term } ....阅读全文

博文 2017-09-02 07:32:15 u013148156

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

博文 2014-10-04 19:27:29 咖啡伴侣

深入理解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-05 08:24:15 aqsmoke

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 08:00:00 vaptu

Go bytes包

Go bytes包 bytes包基本方法的使用 package main import ( "bytes" ) func writeUInt16(buff []byte, data uint16) { for i := 0; i < 2; i++ { buff[i] = byte(data >> uint(i*8)) } } func spilt(r rune) bool { if r == 'c' { return true } return false } func main() { println("hello world") buff1 := make([]byte, 2) // 创建一个切片 writeUInt16(buff1, uint16(12)) buff2 := make(...阅读全文

博文 2017-02-10 08:00:40 xxggy

Go 语言 bufio 包介绍

[原文链接](https://medium.com/golangspec/introduction-to-bufio-package-in-golang-ad7d1877f762) [bufio](https://golang.org/pkg/bufio/) 用来帮助处理 [I/O 缓存](https://www.quora.com/In-C-what-does-buffering-I-O-or-buffered-I-O-mean/answer/Robert-Love-1)。 我们将通过一些示例来熟悉其为我们提供的:Reader, Writer and Scanner 等一系列功能 ## bufio.Writer 多次进行小量的写操作会影响程序性能。每一次写操作最终都会体现为系统层调用,频繁...阅读全文

博文 2017-12-04 08:18:54 jliu666

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() 方法获取长度。切片提供了计算容...阅读全文

博文 2015-08-14 15:00:01 直冲