go 数据类型和操作符

文件名&关键字&标识符

   1. 所有go源码以 .go结尾

   2. 标识符以字母或者下划线开头，大小写敏感：add, Add, _add

       _是特殊标识符，用来忽略结果

   3. 保留关键字

   

 

Go程序基本结构

package main
import “fmt”
func main() {
    fmt.Println(“hello, world”)
}

//1. 任何一个代码文件隶属于一个包
//2. import 关键字，引用其他包
//3. golang可执行程序，package main，并且有且只有一个main入口函数
//4. 包中函数调用：
        a. 同一个包中函数，直接调用
        b. 不同包中函数，通过 包名.函数名 进行调用
//5. 包访问控制规则        
        大写意味着这个函数/变量是可导出的
        小写意味着这个函数/变量是私有的，包外部不能访问

函数声明和注释

1. 函数声明： func   函数名字 (参数列表) (返回值列表）{}
func add() {}
func add(a int , b int) int {}
func add(a int , b int) (int, int) {}
2. 注释，两种注释，单行注释: // 和多行注释  /* */

 

常量和变量

常量

1. 常量使用const 修饰，代表永远是只读的，不能修改
2. const 只能修饰boolean，number（int相关类型、浮点类型、complex）和string
3. 语法：const identifier [type] = value，其中type可以省略 

const b string = "hello world"
const b = "helloworld"
const a = 10
const res = getValue()   //错误示例

const(
  a = 0
  b = 1
  c = 2
)

const(
　a = iota
  b    //1
  c    //2
)

 

变量

语法：var identifier type

var (
a int            //默认为0
b string      //默认为””
c bool        //默认为false
d = 8
e = “hello world”
)

值类型和引用类型

1 值类型：变量直接存储值，内存通常在栈中分配

    基本数据类型int、float、bool、string以及数组和struct
2 引用类型：变量存储的是一个地址，这个地址存储最终的值。内存通常在堆上分配。通过GC回收。

　指针、slice、map、chan等都是引用类型

变量作用域

在函数内部声明的变量叫做局部变量，生命周期仅限于函数内部
在函数外部声明的变量叫做全局变量，生命周期作用于整个包，如果是大写的，则作用于整个程序。

数据类型和操作符

 1 bool类型，只能存true和false
           var a bool

           var a bool = true

           var a = true

 2 相关操作符 ! && ||

 3 数字类型，主要有int、int8、int16、int32、int64、uint8、uint16、uint32、uint64、float32、float64

 4 类型转换，type(variable），比如：var a int=8;  var b int32=int32(a)

 

package main
func main() {
    var a int
    var b int32
    a = 15
    b = a + a // compiler error
    b = int32(a+a)
    b = b + 5 // ok: 5 is a constant
} 

 5 逻辑操作符： == 、!=、<、<=、>和 >=

　　数学操作符：+、-、*、/等等

 6 字符类型：var a byte

var a byte = 'c'

7 字符串类型： var str string

8 字符串表示两种方式： 1）双引号 2）`` （反引号）

var str2 = `hello \n \n \n
this is a test string
This is a test string too·`

#string到int  
int,err:=strconv.Atoi(string)  
#string到int64  
int64, err := strconv.ParseInt(string, 10, 64)  
#int到string  
string:=strconv.Itoa(int)  
#int64到string  
string:=strconv.FormatInt(int64,10)

几个例子

 

// main
package main

import (
    "fmt"
)

func is_prime(num int) bool {
    if num == 1 {
        return false
    }
    for i := 2; i < num; i++ {
        if num%i == 0 {
            return false
        }
    }
    return true
}

func main() {

    var count int
    for i := 100; i <= 200; i++ {
        if is_prime(i) {
            count++
            fmt.Println(i)
        }
    }
    fmt.Println("totally prime number: ", count)
}

// main
package main

import (
    "fmt"
    "strconv"
)

func is_narcissistic(num int) bool {
    num_str := strconv.Itoa(num)
    length := len(num_str)
    var sum int
    for i := 0; i < length; i++ {
        tmp, _ := strconv.Atoi(num_str[i : i+1])
        //fmt.Println(tmp)
        sum += tmp * tmp * tmp

    }

    if sum == num {
        return true
    }
    return false
}

func main() {
    var count int
    for i := 100; i < 1000; i++ {
        if is_narcissistic(i) {
            count++
            fmt.Println(i)
        }
    }
    fmt.Println("total number: ", count)
}

// main
package main

import (
    "fmt"
)

func factorial(num int) int {
    var result = 1
    for i := 1; i <= num; i++ {
        result *= i
    }
    return result
}

func factorial_sum(num int) int {
    var sum int
    for i := 1; i <= num; i++ {
        sum += factorial(i)
    }
    return sum
}

func main() {
    res := factorial_sum(3)
    fmt.Println(res)
}

8.1   strings和strconv使用

strings.HasPrefix(s string, prefix string) bool：判断字符串s是否以prefix开头 。
strings.HasSuffix(s string, suffix string) bool：判断字符串s是否以suffix结尾

// main
package main

import (
    "fmt"
    "strings"
)

func urlProcess(url string) string {
    result := strings.HasPrefix(url, "http://")
    if !result {
        url = fmt.Sprintf("http://%s", url)
    }
    return url
}

func pathProcess(path string) string {
    result := strings.HasSuffix(path, "/")
    if !result {
        path = fmt.Sprintf("%s/", path)
    }
    return path
}

func main() {
    var (
        url  string
        path string
    )
    fmt.Scanf("%s%s", &url, &path)

    fmt.Println(urlProcess(url))
    fmt.Println(pathProcess(path))
}

strings.Index(s string, str string) int：判断str在s中首次出现的位置，如果没有出现，则返回-1
strings.LastIndex(s string, str string) int：判断str在s中最后出现的位置，如果没有出现，则返回-1

strings.Replace(str string, old string, new string, n int)：字符串替换
strings.Count(str string, substr string)int：字符串计数
strings.Repeat(str string, count int)string：重复count次str
strings.ToLower(str string)string：转为小
strings.ToUpper(str string)string：转为大写

strings.TrimSpace(str string)：去掉字符串首尾空白字符
strings.Trim(str string, cut string)：去掉字符串首尾cut字符
strings.TrimLeft(str string, cut string)：去掉字符串首cut字符
strings.TrimRight(str string, cut string)：去掉字符串首cut字符
strings.Field(str string)：返回str空格分隔的所有子串的slice
strings.Split(str string, split string)：返回str split分隔的所有子串的slice

strings.Join(s1 []string, sep string)：用sep把s1中的所有元素链接起来
strings.Itoa(i int)：把一个整数i转成字符串
strings.Atoi(str string)(int, error)：把一个字符串转成整数

 

9 时间 和日期类型

9.1. time包
9.2. time.Time类型，用来表示时间
9.3. 获取当前时间， now := time.Now()
9.4. time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()
9.5. 格式化，fmt.Printf(“%02d/%02d%02d %02d:%02d:%02d”, now.Year()…)

9.6 . time.Duration用来表示纳秒

9.7. 一些常量：
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)

9.8. 格式化：
now := time.Now()
fmt.Println(now.Format(“02/1/2006 15:04”))
fmt.Println(now.Format(“2006/1/02 15:04”))
fmt.Println(now.Format(“2006/1/02”))

// main
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Format("2006/01/02 15:04:00"))
}

 

10 指针类型

10.1. 普通类型，变量存的就是值，也叫值类型
10.2. 获取变量的地址，用&，比如： var a int, 获取a的地址：&a
10.3. 指针类型，变量存的是一个地址，这个地址存的才是值
10.4. 获取指针类型所指向的值，使用：*，比如：var *p int, 使用*p获取p指向的值