go编写第一个go程序

1.编写第一个go程序

首先说明下go语言的语言结构：

go语言是由package包组织的，包类似于其他语言的模块或库。每个程序的开始都用package声明，package+包的名字。

package后面用import导入包。必须要导入包程序才能编译。

import后面跟组成程序的元素，函数，变量等。

函数的声明：func关键字，函数名，[函数列表]，[返回值列表]，大括号内的函数体

package main  /*每个go应用程序都包含一个名为main的包*/ 

import "fmt"  /*fmt包实现了格式化IO的函数*。 用来格式化输出和扫描输入/

func main() {
  fmt.Println("hello,world")  /*println是fmt的基本输出函数，输出一个或多个用空格分隔的值，结尾使用一个换行符*/
}

2.声明变量

var indentifier type

var indentifier1, indentifier2 type

变量没有赋值：对于数字类型是0，布尔值是false, 字符串是“”， 对于接口和引用类型（slice, 指针，map，通道，函数）是nil

：= 用于短变量声明

    var a string="louise"  
    fmt.Print(a)
    var b, c int= 1 , 2
    fmt.Println(b , c)
i,j := 0,1 //声明变量并初始化
i,j=j,1 //交换i和j的值

以下几种声明变量的方式是等价的

s := ""     //通常在一个函数内部使用，不适合包级别的变量
var s string  
var s ="" //少用
var s string ="" //类型一致的情况下是冗余的，类型不一样需要使用

变量可以通过调用返回多个值的函数进行初始化

var f,err=os.Open(name)

3.常量

const indentifier [type] =value

const c_name1, c_name2=value1, value2

itoa:初始为0，const每新增一行常量将计数一次

    const(
        a=iota //0
        b     //1
        c      //2
        d="hi" //hi
        e     //hi
        f=100  //100
        g       //100
        h=iota  //7
        i      //8
        )
    fmt.Print(a,b,c,d,e,f,g,h,i)

4.变量存储地址和指针变量

不是所有的值都有地址但是所有的变量都有。使用指针可以在无须知道变量名字的情况下，间接读取或更新变量的值。

例如：var x int  

&x获取一个指向整型变量的指针，它的类型是整型指针（*int）

指针指向的变量写成*p

指针类型的零值是nil. 如果p !=nil 结果是true说明p指向一个变量。两个指针当且仅当指向同一个变量或者两者都是nil的情况下才相等。

    x : =1
    p : =&x   //p指向x或说p包含x的地址
    fmt.Println(*p) //1
    *p=2   //重新赋值给p指向的变量
    fmt.Println(x) //2

 

var a int = 4
var b int32
var c float32
var ptr *int    //声明变量ptr *int 类型:整型指针 
fmt.Printf("%T\n",a) //int 
fmt.Printf("%T\n",b) //int32 
fmt.Printf("%T\n",c) //float32
ptr=&a //&a返回变量存储地址  ptr指向变量a
fmt.Printf("%d\n",a) //4 
fmt.Printf("%d\n",*ptr) //4

 ##返回指针地址

package main

import "fmt"

func main() {
    var p = f()
    fmt.Println(p)
}
func f() *int{
        v := 1
        return  &v //0xc00000a0b0
}

##传递自增的指针指向的变量

package main

import "fmt"

func main() {
    v :=1
    incre(&v)
    fmt.Println(incre(&v))   //3 ?
}
func incre(p *int) int{
        *p++
        return  *p 
}

 5.new函数

内置new函数。表达式new(type)创建一个未命名的类型变量，初始化为类型的零值，并返回地址。

import "fmt"

func main() {
   p:=new(int)   //创建一个*int类型的变量，int指针类型的变量,返回地址。相当于未命名的变量var, 声明int指针类型，返回地址。p=&var
   fmt.Println(*p)  //0 没有赋值数字类的默认是0
}

 

package main

import (
    "fmt"
    "os"
)

//func main()  {
//    var s, sep string
//    for i :=1; i < len(os.Args);i++{   //:=短变量声明，声明一个或多个变量，并根据初始化的值给予合适的类型
//        s += sep + os.Args[i]
//        sep=" "
//    }
//    fmt.Println(s)
//}
func main()  {
    s, sep := "",""
    for _, arg := range  os.Args[1:] {    //空标识符。用在语法需要变量名但是逻辑不需要
        s += sep +arg
        sep=""
    }
    fmt.Println(s)
}