请从github下载配套代码： https://github.com/shuningzhang/learn_golang

上一篇文章我们给了一个入门程序，接下来我们介绍在Go语言中的数据类型和表达式相关的内容。由于本文是简介性的文章，因此并不会事无巨细的介绍所有内容，只是能够让读者达到理解基本概念，并能够使用的程度，更为深入的学习还需要其它材料。

数据类型与变量

同任何其它编程语言一样，Go语言支持多种类型的数据。从大的分类上面Go语言支持布尔类型、数字类型、字符串和派生类型等几种。

变量是存储数据的存储空间的别名，通过变量开发人员可以方便的访问内存空间，也就是访问其中存储的数据。Go语言的变量是类型相关的，也就是定义变量时需要指定变量的类型，不同类型的变量占用的内存空间是不同的。

下面我们通过一个具体的示例说明数据类型和变量。

package main 

import "fmt"

func main() { 

    /* 下面一行定义一个int8类型的变量，也称为声明
     * 变量。 可以看出声明方式由3部分构成，关键字
     * var，变量名var_name和变量类型int8。Go语言的
     * 变量声明方式与C或者Java等语言的方式不太一
     * 样，刚开始学可能觉得有些怪，但并非Go语言独创。*/
    var var_name int8

    /* 变量的赋值，也就是让变量的内容变为某个值。 */
    var_name = 5

    /* 定义一个16位的整型数，第二行进行2个变量运
     * 算。 由于变量的类型不一样，因此需要进行强制
     * 类型转换。 */
    var var_name_x int16
    var_name_x = 11 + int16(var_name)
	
    /* 上面介绍的都是数字型的数据类型，除了上面的
     * 类型外，还有int32，int64，uint8，uint16，
     * uint32，uint64等类型，这些表示的是整型数。
     * 而以uint头的表示无符号整型数。 */

    fmt.Println(var_name_x)
	
    /* 除了整型数外，还有浮点型数，浮点型数就是我们
     * 日常说的小数 */
    var float_name float32
    float_name = 1.2
	
    fmt.Println(float_name)
    /* 浮点型数包括32位和64位两种，也就是float32和float64。 */
	
    /* 下面介绍的类型是字符串类型。 */
    var str_name string
    str_name = "test"
    fmt.Println(str_name)
	
    /* 变量可以在声明的时候直接初始化。 */
    var int_name int16 = 12
    fmt.Println(int_name)
	
    /* 可以同时声明多个变量，如下是定义3个都为
     * int32类型的变量，并进行初始化，初始化并非
     * 强制要求的 */
    var int_name_1, int_name_2, int_name_3 int32 = 1, 2, 3 
    fmt.Println(int_name_1, int_name_2, int_name_3)
	
    /* 可以不声明变量类型，这样编译器会自动选择类型 */
    var int_name_4 = 160
	
    /* 下面是最简单的变量声明方式，可以将var关键字省略 */
    int_name_5 := 170
    fmt.Println(int_name_4, int_name_5)
	
    /* 最后说明一下，变量名可以字母、下划线和数字，但只能以非数字开头。*/
	
}

当然，这里介绍了有限的几种数据类型，但在后面的使用中基本上够用了。

运算符和表达式

程序大部分都是进行运算的，了解了变量的这些类型，我们看一下Go语言如何进行计算。Go语言的计算包括常规的加减乘除、关系运算、位运算和逻辑运算。这些运算与其它语言的运算并没有任何本质的差异，运算符也基本一致。

运算符，所谓运算符就是进行运算的符号，比如+、-、*和/等，分别表示加减乘除。而>则用于计算两个值的大小关系。

表达式是运算符和数字或者变量的组合，用于进行一系列的计算，最后会计算出一个结果。表达式中各个运算符之间有优先级，基本遵循数学运算的规则。

package main 
import "fmt"
func main() { 
        var int_name_1, int_name_2, int_name_3 int32 = 1, 2, 3
	var int_name_4 int32 = 0

	/* Go语言支持常见的算术云算法，包括加减乘除和取模等 */
	int_name_4 = int_name_1 + int_name_2
	int_name_4 = int_name_1 - int_name_2
	int_name_4 = int_name_1 * int_name_2
	int_name_4 = int_name_1 / int_name_2
	int_name_4 = int_name_1 % int_name_2 /*取模*/

	int_name_3 ++ //自增
	int_name_3 --

	fmt.Println(int_name_1, int_name_2, int_name_3, int_name_4)

	/* 关系运算，也就是判断2个变量的大小关系，如果满足条件则返回真（true），否则返回假（false） */
	var a bool

	/* 举个简单的例子，计算1是否大于2，如果大于则返回true，否则返回false。结果是显然的 */
	a = 1 > 2 
	fmt.Println(a)

	a = 1 < 2
	a = 1 >= 2
	a = 1 <= 2
	a = 1 == 2 //相等判断
	a = 1 != 2 //不等判断

	/* 逻辑运算，也称为布尔运算，判断一个或者多个值或者变量的逻辑关系 */
	var b = bool

	b = 1 && 1 //与运算
	b = 1 || 1 //或运算
	b = !1 //非运算
	fmt.Println(b)

	/* 除了上述运算外，还有位运算，分别用& | ^表示按位与、或和异或运算。本文不在赘述。 */	

}

运算符的优先级

我们在一个表达式中不可能只用一个云算法，同时运用多个运算符的情况是经常存在的。因此Go语言中定义了在同时出现多个运算符是的等级。等级越高，则表示该运算符会优先执行。优先顺序依次为：

1. ^ !
2. • / % << >> & &^
3. • • | ^
4. == != < <= >= >
5. <-
6. &&
7. ||

同一级别的从左向右执行。另外，括弧优先级是最高的，也就是括弧中的内容会优先执行，下面是例程：

package main
import "fmt"
func main() {
     var a int = 20
     var b int = 10
     var c int = 15
     var d int = 5
     var e int;

     e = (a + b) * c / d; // ( 30 * 15 ) / 5
     fmt.Printf("(a + b) * c / d 的值为 : %d", e );

     e = ((a + b) * c) / d; // (30 * 15 ) / 5
     fmt.Printf("((a + b) * c) / d 的值为 : %d" , e );

     e = (a + b) * (c / d); // (30) * (15/5)
     fmt.Printf("(a + b) * (c / d) 的值为 : %d", e );

     e = a + (b * c) / d; // 20 + (150/5)
     fmt.Printf("a + (b * c) / d 的值为 : %d" , e ); 
}

好了，今天先到这，学完本文基本上清楚了在程序设计中如何进行运算。后面我们再介绍函数的概念。