golang

1、下载：根据操作系统和计算架构选择合适的安装包，操作系统类型有linux、mac、windows等，计算架构分为32位的386计算架构和64位的amd64计算架构 2、安装：推荐安装到 /usr/local #sudo tar -xzvf go1.12.7.linux-amd64.tar.gz -C /usr/local 3、配置： 在 /etc/profile 或者用户目录下的 .profile 文件中配置环境变量。区别是在 /etc/profile 下配置对所有用户起作用， .profile 中配置只对当前用户起作用。我在 /etc/profile 中配置的执行 sudo vim /etc/profile 命令，在文件的最后一行加入如下内容： export GOROOT=/usr/local/go export GOPATH=/home/mi/mygopath export GOBIN=$GOPATH/bin export PATH=$PATH:$GOROOT/bin:$GOPATH/bin ---------------------------------------------- 解释： （1）GOROOT设置golang的安装位置，我们解压到了/usr/local/目录，该目录下的go/文件夹一定是go的环境的根目录，就是打开go目录后别再有一个go/目录。 （2

Golang 支持交叉编译，在一个windows平台可以生成linux或Mac系统下的可执行文件。 Mac 下编译 Linux 和 Windows 64位可执行程序 CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build main.go Linux 下编译 Mac 和 Windows 64位可执行程序 CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build main.go CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build main.go Windows 下编译 Mac 和 Linux 64位可执行程序 SET CGO_ENABLED=0 SET GOOS=darwin SET GOARCH=amd64 go build main.go SET CGO_ENABLED=0 SET GOOS=linux SET GOARCH=amd64 go build main.go GOOS：目标平台的 操作系统 （darwin、freebsd、linux、windows） GOARCH：目标平台的体系 架构 （386、amd64、arm） 交叉编译不支持

非对称加密示意图： 在此可以看到，非对称加密是通过两个密钥（公钥-私钥）来实现对数据的加密和解密的。公钥用于加密，私钥用于解密。 RSA公钥和私钥生成： package main import ( "crypto/rsa" "crypto/rand" "fmt" "crypto/x509" "encoding/pem" "os" "flag" ) func RSAKeyGen(bits int) error { privatekey, err := rsa.GenerateKey(rand.Reader, bits) if err != nil { fmt.Println("私钥文件生成失败") } fmt.Println("私钥为：", privatekey) derStream := x509.MarshalPKCS1PrivateKey(privatekey) block := &pem.Block{ Type:"RSA Private key", Bytes: derStream, } privatefile, err := os.Create("myprivatekey.pem") defer privatefile.Close() err = pem.Encode(privatefile, block) if err != nil { fmt.Println(err

数据类型-基础数据类型 Go 语言中包含的数据类型有以下几种： 基础类型 布尔型 bool : 值只可以是常量 true 或者 false 字符串 string : 由一串固定长度的字符连接起来的字符序列 整数 有符号整数 int : 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽 int8 : 有符号 8 位整型 (-128 到 127) int16 : 有符号 16 位整型 (-32768 到 32767) int32 : 有符号 32 位整型 (-2147483648 到 2147483647) int64 : 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) 无符号整数 uint : 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽 uint8 : 无符号 8 位整型 (0 到 255) uint16 : 无符号 16 位整型 (0 到 65535) uint32 : 无符号 32 位整型 (0 到 4294967295) uint64 : 无符号 64 位整型 (0 到 18446744073709551615) 特殊整型 uintptr : 无符号整型，用于存放一个指针。在32位系统上通常为32位宽，在64位系统上则为64位宽 byte : uint8 的别名

package main import "fmt" // 这里是一个函数，接受两个 `int` 并且以 `int` 返回它们的和 func plus(a int, b int) int { // Go 需要明确的返回，不会自动返回最 // 后一个表达式的值 return a + b } // 当多个连续的参数为同样类型时，最多可以仅声明最后一个参数类型 // 而忽略之前相同类型参数的类型声明。 func plusPlus(a, b, c int) int { return a + b + c } func main() { // 通过 `name(args)` 来调用函数， res := plus(1, 2) fmt.Println("1+2 =", res) res = plusPlus(1, 2, 3) fmt.Println("1+2+3 =", res) } 　　Go 函数有很多其他的特性。其中一个就是多值返回 package main import "fmt" // `(int, int)` 在这个函数中标志着这个函数返回 2 个 `int`。 func vals() (int, int) { return 3, 7 } func main() { // 这里我们通过_多赋值_操作来使用这两个不同的返回值。 a, b := vals() fmt.Println(a)

package main import "fmt" // 这里的 `person` 结构体包含了 `name` 和 `age` 两个字段。 type person struct { name string age int } func main() { // 使用这个语法创建新的结构体元素。 fmt.Println(person{"Bob", 20}) // 你可以在初始化一个结构体元素时指定字段名字。 fmt.Println(person{name: "Alice", age: 30}) // 省略的字段将被初始化为零值。 fmt.Println(person{name: "Fred"}) // `&` 前缀生成一个结构体指针。 fmt.Println(&person{name: "Ann", age: 40}) // 使用`.`来访问结构体字段。 s := person{name: "Sean", age: 50} fmt.Println(s.name) // 也可以对结构体指针使用`.` - 指针会被自动解引用。 sp := &s fmt.Println(sp.age) // 结构体是可变(mutable)的。 sp.age = 51 fmt.Println(sp.age) } 　　 来源： https://www.cnblogs.com/saryli/p/12165300

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> 本文由云+社区发表 导言 几乎每一个C++开发人员，都被面试过有关于函数参数是值传递还是引用传递的问题，其实不止于C++，任何一个语言中，我们都需要关心函数在参数传递时的行为。在golang中存在着map、channel和slice这三种内建数据类型，它们极大的方便着我们的日常coding。然而，当这三种数据结构作为参数传递的时的行为是如何呢？本文将从这三个内建结构展开，来介绍golang中参数传递的一些细节问题。 背景 首先，我们直接的来看一个简短的示例，下面几段代码的输出是什么呢？ //demo1 package main import "fmt" func test_string(s string){ fmt.Printf("inner: %v, %v\n",s, &s) s = "b" fmt.Printf("inner: %v, %v\n",s, &s) } func main() { s := "a" fmt.Printf("outer: %v, %v\n",s, &s) test_string(s) fmt.Printf("outer: %v, %v\n",s, &s) } 上文的代码段，尝试在函数test_string()内部修改一个字符串的数值，通过运行结果，我们可以清楚的看到函数test

array package main import "fmt" func main() { // 这里我们创建了一个数组 `a` 来存放刚好 5 个 `int`。 // 元素的类型和长度都是数组类型的一部分。数组默认是 // 零值的，对于 `int` 数组来说也就是 `0`。 var a [5]int fmt.Println("emp:", a) // 我们可以使用 `array[index] = value` 语法来设置数组 // 指定位置的值，或者用 `array[index]` 得到值。 a[4] = 100 fmt.Println("set:", a) fmt.Println("get:", a[4]) // 使用内置函数 `len` 返回数组的长度。 fmt.Println("len:", len(a)) // 使用这个语法在一行内声明并初始化一个数组。 b := [5]int{1, 2, 3, 4, 5} fmt.Println("dcl:", b) // 数组类型是一维的，但是你可以组合 // 构造多维的数据结构。 var twoD [2][3]int for i := 0; i < 2; i++ { for j := 0; j < 3; j++ { twoD[i][j] = i + j } } fmt.Println("2d: ", twoD) } 在使用 fmt

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> Count (s string, str string) int 计算字符串str在s中的非重叠个数。如果str为空串则返回s中的字符（非字节）个数+1。 Index (s string, str string) int 返回子串str在字符串s中第一次出现的位置。如果找不到则返回-1；如果str为空，则返回0。 LastIndex (s string, str string) int 返回子串str在字符串s中最后一次出现的位置。如果找不到则返回-1；如果str为空则返回字符串s的长度。 IndexRune (s string, r rune) int 返回字符r在字符串s中第一次出现的位置。如果找不到则返回-1。 IndexAny (s string, str string) int 返回字符串str中的任何一个字符在字符串s中第一次出现的位置。如果找不到或str为空则返回-1 LastIndexAny (s string, str string) int 返回字符串str中的任何一个字符在字符串s中最后一次出现的位置。如果找不到或str为空则返回-1。 Contains (s string, str string) bool 判断字符串s中是否包含个子串str。包含或者str为空则返回true。

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> Go语言的三大特点： 1.静态类型、编译型的开源语言。静态+编译，这两个特点就标志着go语言对程序运行速度的追求。(当然大大高于 动态类型、解释型编程语言) 2.脚本化的语法；支持多种编程范式（支持 函数式编程 和 面向对象编程） 3.原生的、强大的并发编程支持。 go语言的语法里面本身存在某种方式或者方法，能够把一些代码片段，并发地提交给CPU执行。值得注意的是，原生的支持 和 通过（第三方）函数库支持是有明显的区别的。 这意味着两个advantages： 这就意味了利用go语言能够更容易地开发出并发程序，降低了开发成本和维护成本 并发程序得益于go语言实现内部的调度算法，并发程序能够更好地执行。 但是，缺点，你懂的： 1. go语言的语法糖没有python和ruby那么多，但是本人觉得完全可以接受。 2. go语言的运行效率现在还不及c，但是已经超过了C++和Java。（打住，我不想变成语言帝，也不想和人撕B）。并且，从go1.5开始，google开始用go语言来重构go编译器，因此，在编译速度上1.5的编译速度要大大低于用c语言实现的前一代（即go1.4）版本编译器编译效率。虽然在后续go1.6版本有所提升，但是与1.4的编译效率还是存在差距。不过，听说1.7的编译效率会大大提升