Go 语言内置的运算符有:
1.算术运算符:+ - * / % ++ --
2.关系运算符:== != > < >= <=
3.逻辑运算符:&& || !
4.位运算符:& | ^ << >> 将其先转换为二进制数,在根据如下表规则

p    q    p & q    p | q    p ^ q
0    0      0        0        0
0    1      0        1        1
1    1      1        1        0
1    0      0        1        1

如假定 A = 60; B = 13; 其二进制数转换为:

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
A<<2 =240 二进制为 1111 0000 左移n位就是乘以2的n次方。
A>>2 =15  二进制为 0000 1111 右移n位就是除以2的n次方。 

5.赋值运算符

    1.=     2.+=     3.-=     4.*=     5./=     6.%=    
    7.<<=    左移后赋值    C <<= 2 等于 C = C << 2
    8.>>=    右移后赋值    C >>= 2 等于 C = C >> 2
    9.&=    按位与后赋值    C &= 2 等于 C = C & 2
    10.^=    按位异或后赋值    C ^= 2 等于 C = C ^ 2
    11.|=    按位或后赋值    C |= 2 等于 C = C | 2

6.其他运算符

&    返回变量存储地址    实例&a:将给出变量的实际地址。
*    指针变量。        实例*a:是一个指针变量

7.运算符优先级
有些运算符拥有较高的优先级,二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级,由上至下代表优先级由高到低:

优先级    运算符
  7        ^ !
  6    * / % << >> & &^
  5      + - | ^
  4    == != < <= >= >
  3         <-
  2         &&
  1         ||

当然,你可以通过使用括号来临时提升某个表达式的整体运算优先级。

Go 语言条件语句

if
if...else
if 嵌套语句 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句 switch 语句用于基于不同条件执行不同动作。
select 语句 select 语句类似于 switch 语句,但是select会随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。

Go 语言循环语句

for 循环 重复执行语句块
循环嵌套 在 for 循环中嵌套一个或多个 for 循环

循环控制语句
break 语句 经常用于中断当前 for 循环或跳出 switch 语句
continue 语句 跳过当前循环的剩余语句,然后继续进行下一轮循环。
goto 语句 将控制转移到被标记的语句。

循环判断的例子输出 1-100 素数:

package main
import "fmt"

func main() {
    var a, b int
    for a = 2; a <= 100; a++ {
        for b = 2; b <= (a / b); b++ {
            if a%b == 0 {
                break
            }
        }
        if b > (a / b) {
            fmt.Printf("%dt是素数n", a)
        }
    }
}

Go 语言函数

Go 语言函数定义格式如下:

func function_name( [parameter list 参赛列表] ) [return_types 返回类型] {
   函数体
}

函数参数
函数如果使用参数,该变量可称为函数的形参。
形参就像定义在函数体内的局部变量。
调用函数,可以通过两种方式来传递参数:

传递类型 描述
值传递:值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
引用传递 :引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。
默认情况下,Go 语言使用的是值传递,即在调用过程中不会影响到实际参数。

函数用法
函数作为值 函数定义后可作为值来使用
闭包 闭包是匿名函数,可在动态编程中使用
方法 方法就是一个包含了接受者的函数

Go 语言变量作用域

Go 语言中变量可以在三个地方声明:

函数内定义的变量称为局部变量
函数外定义的变量称为全局变量
函数定义中的变量称为形式参数

package main

import "fmt"

/* 声明全局变量 */
var a int = 20

func main() {
    /* main 函数中声明局部变量 */
    var a int = 10
    var b int = 20
    var c int = 0

    fmt.Printf("main()函数中 a = %dn", a)
    c = sum(a, b)
    fmt.Printf("main()函数中 a = %dn", a)
    fmt.Printf("main()函数中 c = %dn", c)
}

/* 函数定义-两数相加 */
func sum(a, b int) int {
    a = a + 1
    fmt.Printf("sum() 函数中 a = %dn", a)
    fmt.Printf("sum() 函数中 b = %dn", b)
    return a + b
}


/*main()函数中 a = 10
sum() 函数中 a = 11
sum() 函数中 b = 20
main()函数中 a = 10
main()函数中 c = 31*/


Go 语言数组

初始化数组
以下演示了数组初始化:

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

本文固定链接: http://www.js-code.com/c/c_61861.html