lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format and remove en/02.2.md spaces

Browse Source
This commit is contained in:
vCaesar
2017-06-30 23:47:27 +08:00
parent 9aea3b796f
commit 7c350f5876
2 changed files with 161 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
en/01.4.md
View File

@@ -115,12 +115,12 @@ First, download the version of [Sublime](http://www.sublimetext.com/) suitable f
Applicable to Sublime Text 3：
```Go
import urllib.request,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib.request.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read())
import urllib.request,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib.request.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read())
```
Applicable to Sublime Text 2：
```Go
import urllib2,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();os.makedirs(ipp)ifnotos.path.exists(ipp)elseNone;urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read());print('Please restart Sublime Text to finish installation')
import urllib2,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();os.makedirs(ipp)ifnotos.path.exists(ipp)elseNone;urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read());print('Please restart Sublime Text to finish installation')
```
Restart Sublime Text when the installation has finished. You should then find a `Package Control` option in the "Preferences" menu.

318
en/02.2.md
View File

@@ -8,58 +8,58 @@ There are many forms of syntax that can be used to define variables in Go.
The keyword `var` is the basic form to define variables, notice that Go puts the variable type `after` the variable name.
```Go
// define a variable with name “variableName” and type "type"
var variableName type
// define a variable with name “variableName” and type "type"
var variableName type
```
Define multiple variables.
```Go
// define three variables which types are "type"
var vname1, vname2, vname3 type
// define three variables which types are "type"
var vname1, vname2, vname3 type
```
Define a variable with initial value.
```Go
// define a variable with name “variableName”, type "type" and value "value"
var variableName type = value
// define a variable with name “variableName”, type "type" and value "value"
var variableName type = value
```
Define multiple variables with initial values.
```Go
/*
/*
Define three variables with type "type", and initialize their values.
vname1 is v1, vname2 is v2, vname3 is v3
*/
var vname1, vname2, vname3 type = v1, v2, v3
*/
var vname1, vname2, vname3 type = v1, v2, v3
```
Do you think that it's too tedious to define variables use the way above? Don't worry, because the Go team has also found
this to be a problem. Therefore if you want to define variables with initial values, we can just omit the variable type,
so the code will look like this instead:
```Go
/*
/*
Define three variables without type "type", and initialize their values.
vname1 is v1，vname2 is v2，vname3 is v3
*/
var vname1, vname2, vname3 = v1, v2, v3
*/
var vname1, vname2, vname3 = v1, v2, v3
```
Well, I know this is still not simple enough for you. Let's see how we fix it.
```Go
/*
/*
Define three variables without type "type" and without keyword "var", and initialize their values.
vname1 is v1，vname2 is v2，vname3 is v3
*/
vname1, vname2, vname3 := v1, v2, v3
*/
vname1, vname2, vname3 := v1, v2, v3
```
Now it looks much better. Use `:=` to replace `var` and `type`, this is called a brief statement. But wait, it has one limitation: this form can only be used inside of functions. You will get compile errors if you try to use it outside of function bodies. Therefore, we usually use `var` to define global variables.
`_` (blank) is a special variable name. Any value that is given to it will be ignored. For example, we give `35` to `b`, and discard `34`.( ***This example just show you how it works. It looks useless here because we often use this symbol when we get function return values.*** )
```Go
_, b := 34, 35
_, b := 34, 35
```
If you don't use variables that you've defined in your program, the compiler will give you compilation errors. Try to compile the following code and see what happens.
```Go
package main
package main
func main() {
var i int
}
func main() {
var i int
}
```
## Constants
@@ -67,16 +67,16 @@ So-called constants are the values that are determined during compile time and y
Define constants as follows.
```Go
const constantName = value
// you can assign type of constants if it's necessary
const Pi float32 = 3.1415926
const constantName = value
// you can assign type of constants if it's necessary
const Pi float32 = 3.1415926
```
More examples.
```Go
const Pi = 3.1415926
const i = 10000
const MaxThread = 10
const prefix = "astaxie_"
const Pi = 3.1415926
const i = 10000
const MaxThread = 10
const prefix = "astaxie_"
```
## Elementary types
@@ -89,9 +89,9 @@ var isActive bool // global variable
var enabled, disabled = true, false // omit type of variables
func test() {
var available bool // local variable
valid := false // brief statement of variable
available = true // assign value to variable
var available bool // local variable
valid := false // brief statement of variable
available = true // assign value to variable
}
```
### Numerical types
@@ -100,11 +100,11 @@ Integer types include both signed and unsigned integer types. Go has `int` and `
One important thing you should know that you cannot assign values between these types, this operation will cause compile errors.
```Go
var a int8
var a int8
var b int32
var b int32
c := a + b
c := a + b
```
Although int32 has a longer length than int8, and has the same type as int, you cannot assign values between them. ( ***c will be asserted as type `int` here*** )
@@ -112,52 +112,52 @@ Float types have the `float32` and `float64` types and no type called `float`. T
That's all? No! Go supports complex numbers as well. `complex128` (with a 64-bit real and 64-bit imaginary part) is the default type, if you need a smaller type, there is one called `complex64` (with a 32-bit real and 32-bit imaginary part). Its form is `RE+IMi`, where `RE` is real part and `IM` is imaginary part, the last `i` is the imaginary number. There is a example of complex number.
```Go
var c complex64 = 5+5i
//output: (5+5i)
fmt.Printf("Value is: %v", c)
var c complex64 = 5+5i
//output: (5+5i)
fmt.Printf("Value is: %v", c)
```
### String
We just talked about how Go uses the UTF-8 character set. Strings are represented by double quotes `""` or backticks ``` `` ```.
```Go
// sample code
var frenchHello string // basic form to define string
var emptyString string = "" // define a string with empty string
func test() {
// sample code
var frenchHello string // basic form to define string
var emptyString string = "" // define a string with empty string
func test() {
no, yes, maybe := "no", "yes", "maybe" // brief statement
japaneseHello := "Ohaiou"
frenchHello = "Bonjour" // basic form of assign values
}
}
```
It's impossible to change string values by index. You will get errors when you compile the following code.
```Go
var s string = "hello"
s[0] = 'c'
var s string = "hello"
s[0] = 'c'
```
What if I really want to change just one character in a string? Try the following code.
```Go
s := "hello"
c := []byte(s) // convert string to []byte type
c[0] = 'c'
s2 := string(c) // convert back to string type
fmt.Printf("%s\n", s2)
s := "hello"
c := []byte(s) // convert string to []byte type
c[0] = 'c'
s2 := string(c) // convert back to string type
fmt.Printf("%s\n", s2)
```
You use the `+` operator to combine two strings.
```Go
s := "hello,"
m := " world"
a := s + m
fmt.Printf("%s\n", a)
s := "hello,"
m := " world"
a := s + m
fmt.Printf("%s\n", a)
```
and also.
```Go
s := "hello"
s = "c" + s[1:] // you cannot change string values by index, but you can get values instead.
fmt.Printf("%s\n", s)
s := "hello"
s = "c" + s[1:] // you cannot change string values by index, but you can get values instead.
fmt.Printf("%s\n", s)
```
What if I want to have a multiple-line string?
```Go
m := `hello
m := `hello
world`
```
``` ` ``` will not escape any characters in a string.
@@ -166,10 +166,10 @@ What if I want to have a multiple-line string?
Go has one `error` type for purpose of dealing with error messages. There is also a package called `errors` to handle errors.
```Go
err := errors.New("emit macho dwarf: elf header corrupted")
if err != nil {
err := errors.New("emit macho dwarf: elf header corrupted")
if err != nil {
fmt.Print(err)
}
}
```
### Underlying data structure
@@ -187,35 +187,35 @@ If you want to define multiple constants, variables or import packages, you can
Basic form.
```Go
import "fmt"
import "os"
import "fmt"
import "os"
const i = 100
const pi = 3.1415
const prefix = "Go_"
const i = 100
const pi = 3.1415
const prefix = "Go_"
var i int
var pi float32
var prefix string
var i int
var pi float32
var prefix string
```
Group form.
```Go
import(
import(
"fmt"
"os"
)
)
const(
const(
i = 100
pi = 3.1415
prefix = "Go_"
)
)
var(
var(
i int
pi float32
prefix string
)
)
```
Unless you assign the value of constant is `iota`, the first value of constant in the group `const()` will be `0`. If following constants don't assign values explicitly, their values will be the same as the last one. If the value of last constant is `iota`, the values of following constants which are not assigned are `iota` also.
@@ -223,19 +223,19 @@ Unless you assign the value of constant is `iota`, the first value of constant i
Go has one keyword called `iota`, this keyword is to make `enum`, it begins with `0`, increased by `1`.
```Go
const(
const(
x = iota // x == 0
y = iota // y == 1
z = iota // z == 2
w // If there is no expression after the constants name, it uses the last expression,
//so it's saying w = iota implicitly. Therefore w == 3, and y and z both can omit "= iota" as well.
)
)
const v = iota // once iota meets keyword `const`, it resets to `0`, so v = 0.
const (
e, f, g = iota, iota, iota // e=0,f=0,g=0 values of iota are same in one line.
)
const v = iota // once iota meets keyword `const`, it resets to `0`, so v = 0.
const (
e, f, g = iota, iota, iota // e=0,f=0,g=0 values of iota are same in one line.
)
```
### Some rules
@@ -250,37 +250,37 @@ The reason that Go is concise because it has some default behaviors.
`array` is an array obviously, we define one as follows.
```Go
var arr [n]type
var arr [n]type
```
in `[n]type`, `n` is the length of the array, `type` is the type of its elements. Like other languages, we use `[]` to get or set element values within arrays.
```Go
var arr [10]int // an array of type [10]int
arr[0] = 42 // array is 0-based
arr[1] = 13 // assign value to element
fmt.Printf("The first element is %d\n", arr[0])
// get element value, it returns 42
fmt.Printf("The last element is %d\n", arr[9])
//it returns default value of 10th element in this array, which is 0 in this case.
var arr [10]int // an array of type [10]int
arr[0] = 42 // array is 0-based
arr[1] = 13 // assign value to element
fmt.Printf("The first element is %d\n", arr[0])
// get element value, it returns 42
fmt.Printf("The last element is %d\n", arr[9])
//it returns default value of 10th element in this array, which is 0 in this case.
```
Because length is a part of the array type, `[3]int` and `[4]int` are different types, so we cannot change the length of arrays. When you use arrays as arguments, functions get their copies instead of references! If you want to use references, you may want to use `slice`. We'll talk about later.
It's possible to use `:=` when you define arrays.
```Go
a := [3]int{1, 2, 3} // define an int array with 3 elements
a := [3]int{1, 2, 3} // define an int array with 3 elements
b := [10]int{1, 2, 3}
// define a int array with 10 elements, of which the first three are assigned.
//The rest of them use the default value 0.
b := [10]int{1, 2, 3}
// define a int array with 10 elements, of which the first three are assigned.
//The rest of them use the default value 0.
c := [...]int{4, 5, 6} // use `…` to replace the length parameter and Go will calculate it for you.
c := [...]int{4, 5, 6} // use `…` to replace the length parameter and Go will calculate it for you.
```
You may want to use arrays as arrays' elements. Let's see how to do this.
```Go
// define a two-dimensional array with 2 elements, and each element has 4 elements.
doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
// define a two-dimensional array with 2 elements, and each element has 4 elements.
doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
// The declaration can be written more concisely as follows.
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
// The declaration can be written more concisely as follows.
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
```
Array underlying data structure.
@@ -294,30 +294,30 @@ In many situations, the array type is not a good choice -for instance when we do
`slice` is not really a `dynamic array`. It's a reference type. `slice` points to an underlying `array` whose declaration is similar to `array`, but doesn't need length.
```Go
// just like defining an array, but this time, we exclude the length.
var fslice []int
// just like defining an array, but this time, we exclude the length.
var fslice []int
```
Then we define a `slice`, and initialize its data.
```Go
slice := []byte {'a', 'b', 'c', 'd'}
slice := []byte {'a', 'b', 'c', 'd'}
```
`slice` can redefine existing slices or arrays. `slice` uses `array[i:j]` to slice, where `i` is
the start index and `j` is end index, but notice that `array[j]` will not be sliced since the length
of the slice is `j-i`.
```Go
// define an array with 10 elements whose types are bytes
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// define an array with 10 elements whose types are bytes
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// define two slices with type []byte
var a, b []byte
// define two slices with type []byte
var a, b []byte
// 'a' points to elements from 3rd to 5th in array ar.
a = ar[2:5]
// now 'a' has elements ar[2],ar[3] and ar[4]
// 'a' points to elements from 3rd to 5th in array ar.
a = ar[2:5]
// now 'a' has elements ar[2],ar[3] and ar[4]
// 'b' is another slice of array ar
b = ar[3:5]
// now 'b' has elements ar[3] and ar[4]
// 'b' is another slice of array ar
b = ar[3:5]
// now 'b' has elements ar[3] and ar[4]
```
Notice the differences between `slice` and `array` when you define them. We use `[…]` to let Go
calculate length but use `[]` to define slice only.
@@ -336,22 +336,22 @@ slice has some convenient operations.
More examples pertaining to `slice`
```Go
// define an array
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// define two slices
var aSlice, bSlice []byte
// define an array
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// define two slices
var aSlice, bSlice []byte
// some convenient operations
aSlice = array[:3] // equals to aSlice = array[0:3] aSlice has elements a,b,c
aSlice = array[5:] // equals to aSlice = array[5:10] aSlice has elements f,g,h,i,j
aSlice = array[:] // equals to aSlice = array[0:10] aSlice has all elements
// some convenient operations
aSlice = array[:3] // equals to aSlice = array[0:3] aSlice has elements a,b,c
aSlice = array[5:] // equals to aSlice = array[5:10] aSlice has elements f,g,h,i,j
aSlice = array[:] // equals to aSlice = array[0:10] aSlice has all elements
// slice from slice
aSlice = array[3:7] // aSlice has elements d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice contains aSlice[1], aSlice[2], so it has elements e,f
bSlice = aSlice[:3] // bSlice contains aSlice[0], aSlice[1], aSlice[2], so it has d,e,f
bSlice = aSlice[0:5] // slice could be expanded in range of cap, now bSlice contains d,e,f,g,h
bSlice = aSlice[:] // bSlice has same elements as aSlice does, which are d,e,f,g
// slice from slice
aSlice = array[3:7] // aSlice has elements d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice contains aSlice[1], aSlice[2], so it has elements e,f
bSlice = aSlice[:3] // bSlice contains aSlice[0], aSlice[1], aSlice[2], so it has d,e,f
bSlice = aSlice[0:5] // slice could be expanded in range of cap, now bSlice contains d,e,f,g,h
bSlice = aSlice[:] // bSlice has same elements as aSlice does, which are d,e,f,g
```
`slice` is a reference type, so any changes will affect other variables pointing to the same slice or array.
For instance, in the case of `aSlice` and `bSlice` above, if you change the value of an element in `aSlice`,
@@ -363,8 +363,8 @@ For instance, in the case of `aSlice` and `bSlice` above, if you change the valu
- The length of `slice`.
- Capacity, the length from start index to end index of `slice`.
```Go
Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Slice_a := Array_a[2:5]
Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Slice_a := Array_a[2:5]
```
The underlying data structure of the code above as follows.
@@ -391,16 +391,16 @@ Let's see some code. The 'set' and 'get' values in `map` are similar to `slice`,
of type 'int' while `map` can use much more than that: for example `int`, `string`, or whatever you want. Also, they are
all able to use `==` and `!=` to compare values.
```Go
// use string as the key type, int as the value type, and `make` initialize it.
var numbers map[string] int
// another way to define map
numbers := make(map[string]int)
numbers["one"] = 1 // assign value by key
numbers["ten"] = 10
numbers["three"] = 3
// use string as the key type, int as the value type, and `make` initialize it.
var numbers map[string] int
// another way to define map
numbers := make(map[string]int)
numbers["one"] = 1 // assign value by key
numbers["ten"] = 10
numbers["three"] = 3
fmt.Println("The third number is: ", numbers["three"]) // get values
// It prints: The third number is: 3
fmt.Println("The third number is: ", numbers["three"]) // get values
// It prints: The third number is: 3
```
Some notes when you use map.
@@ -413,26 +413,26 @@ You can use form `key:val` to initialize map's values, and `map` has built-in me
Use `delete` to delete an element in `map`.
```Go
// Initialize a map
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
// map has two return values. For the second return value, if the key doesn't
//exist，'ok' returns false. It returns true otherwise.
csharpRating, ok := rating["C#"]
if ok {
// Initialize a map
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
// map has two return values. For the second return value, if the key doesn't
//exist，'ok' returns false. It returns true otherwise.
csharpRating, ok := rating["C#"]
if ok {
fmt.Println("C# is in the map and its rating is ", csharpRating)
} else {
} else {
fmt.Println("We have no rating associated with C# in the map")
}
}
delete(rating, "C") // delete element with key "c"
delete(rating, "C") // delete element with key "c"
```
As I said above, `map` is a reference type. If two `map`s point to same underlying data,
any change will affect both of them.
```Go
m := make(map[string]string)
m["Hello"] = "Bonjour"
m1 := m
m1["Hello"] = "Salut" // now the value of m["hello"] is Salut
m := make(map[string]string)
m["Hello"] = "Bonjour"
m1 := m
m1["Hello"] = "Salut" // now the value of m["hello"] is Salut
```
### make, new
@@ -460,17 +460,17 @@ Figure 2.5 Underlying memory allocation of make and new
Zero-value does not mean empty value. It's the value that variables default to in most cases. Here is a list of some zero-values.
```Go
int 0
int8 0
int32 0
int64 0
uint 0x0
rune 0 // the actual type of rune is int32
byte 0x0 // the actual type of byte is uint8
float32 0 // length is 4 byte
float64 0 //length is 8 byte
bool false
string ""
int 0
int8 0
int32 0
int64 0
uint 0x0
rune 0 // the actual type of rune is int32
byte 0x0 // the actual type of byte is uint8
float32 0 // length is 4 byte
float64 0 //length is 8 byte
bool false
string ""
```
## Links