对照 Ruby 学 Go (Part 2)： Go 类型
转载自: http://zonov.me/golang-for-rubyists-part-2-go-type-system/ 已获原作者授权
原标题: Golang for Rubyists. Part 2. Go type system
Hello, my dear Golang newcomers. I feel so excited when I start writing this post! This is because I learn in the meantime. If when I’m writing about Ruby or JS I’m mostly describing my experience, probably with some additions of new findings I’ve got during the preparation, however in this particular case I’m learning together with you.And today’s post will be about types and logical structures of Go. Let’s start!
Did you ever work with statically typed languages? I had some experience. F.e. Swift lang I really enjoyed, including their strong type system with optional values, also when I wrote an app using Clojure I didn’t have much pain with their strong dynamic typing. However, on my daily base, I’m usually enjoying (am I?) the Ruby’s and JS’ Duck type system. On the opposite side in Go you have quite a strong typing, so let’s start with smth small.
Variables assignment
In my previous post I used such a construction (ok, it was a bit different, but still):
hello, world := "Hello", "World"
The other way to write this would be:
var hello string = "Hello"
var world string = "World"Furthermore, you can also write var hello = "Hello" and it will grasp the type, so it’s not only `:=`’s feature.
In all the examples above we defined variables together with its assignment. What you can also do is to split this up. F.e.
package main
import "fmt"
func main() {
var someString string
someString = "hello"
fmt.Println(someString)
} In this example, as you may see, we split up the variable definition and the value assignment. Since it’s a variable, we can do this. Now do a couple of experiments:
1. Try to change the first line in function to be const someString string. Then try to run it go run hello.go. Ta-daam, compilation error. If you define a constant, you should instantly assign it. And it makes a lot of sense by me.
2. Now change your code to be:
package main
import "fmt"
func main() {
var someString string
someString = 123
fmt.Println(someString)
} Types in Golang
Ok, let’s be cool with it. In general, Go has following type categories: Numbers, Strings, Lists, Booleans.
Booleans
For Booleans no surprises (just the type name is not boolean, but bool), they are just a standard booleans, like true/false with usual boolean algebra rules. Also as in Ruby and JS you have the bang operator, which inverts the variable. You can also use two bangs for double inversion.
someString := true
fmt.Println(!someString)
// will return you a falseUnfortunately this kind of structure, which we all like:
someString := "something"
fmt.Println(!someString) String
The next convenient type, String. You already have got familiar with it in the previous post.
Make your code to look like this:
package main
import "fmt"
func main() {
doubleQuotedString := "Hello, \nWorld!"
backticksQuotedString := `Hello, \nWorld!`
singleQuotedChar := 'H'
fmt.Println(doubleQuotedString)
fmt.Println(backticksQuotedString)
fmt.Println(singleQuotedChar)
} There is no proper string interpolation in Golang, so it can be bothersome to deal with it, however there is a way, but we will talk about it in another post.
Numbers
Next type family is Numbers. As usual, it has float and integers. And if in Ruby you just have a generic type and interpreter decides by itself, which type to use, in Golang you should specify it by yourself. And the possible types are:
Integers
int8, int16, int32, int64, uint8, uint16, uint32, uint64
Numbers in these types, as you may understand, represent bits amount, and the prefix ‘u’ on some of them means that it can not be negative (unsigned). If you will try to pass a negative number to your uint variable, it will throw an error constant -10 overflows uint32
Floats
float32, float64. Nothing new here, numbers represent the same. Also as in any other language, numbers with floating points are not round, so this code won’t give you 0.9:
var x float32 = 1.1
var y float32 = 0.2
fmt.Println(x - y) Lists
Lists are a big topic to discuss, so in this post I will cover it’s types and the basic difference, and let’s start with the most (as you would expect) familiar one.Arrays
An array is a fixed size ordered homogeneous list. This sentence says for itself. The first thing to know is that once you set up an array size, you cannot change it. The second thing is that if you say that your array consists of numbers, you could not put there any strings. More of that, if you say that your array consists of int32, you cannot put e.g. int64 into it. Already scared? Let’s see some examples.
package main
import "fmt"
func main() {
var x [10]int
fmt.Println(x)
}If you run this program, it will print [0 0 0 0 0 0 0 0 0 0]. Now let’s scoff at it and try to feed if with something wrong:
package main
import "fmt"
func main() {
var x [10]int
var number int64 = 42
x[3] = number
fmt.Println(x)
}The other way to assign an array is also together with its value:
x := [3]int{5, 6, 7}Slices
They are actually much more common in the Golang world due to their flexibility. They are still homogeneous, but instead of being fixed in size, they are changeable. Here is a simple snippet:
package main
import "fmt"
func main() {
nums := []int{2, 3, 11, 13}
nums = append(nums, 0, 1)
var s []int = nums[3:len(nums)]
fmt.Println(s)
}Maps
Maps are almost the same as Ruby’s Hashes. Just with one difference. Can you guess, what is the difference? Yeah, u rrright, they are statically typed!
package main
import "fmt"
func main() {
population := make(map[string]int)
population["Berlin"] = 3500000
population["Munich"] = 1500000
fmt.Println(population)
}