go 入门_go入门 - CSDN
精华内容
参与话题
  • Go语言入门之——基本了解

    千次阅读 2018-08-15 10:22:43
    Go语言基础 一、简介 (2)golang语言特性 2.1. 垃圾回收 内存自动回收,再也不需要开发人员管理内存 开发人员专注业务实现,降低了心智负担 只需要new分配内存,不需要释放 2.2. goroute天然并发 从语言...

    Go语言基础

    一、简介

    (1)什么是go语言?

    2007年,受够了C++煎熬的Google首席软件工程师Rob Pike纠集Robert Griesemer和Ken Thompson两位牛人,决定创造一种新语言来取代C++, 这就是Golang。出现在21世纪的GO语言,虽然不能如愿对C++取而代之,但是其近C的执行性能和近解析型语言的开发效率以及近乎于完美的编译速度,已经风靡全球。特别是在云项目中,大部分都使用了Golang来开发,不得不说,Golang早已深入人心。而对于一个没有历史负担的新项目,Golang或许就是个不二的选择。

    被称为GO语言之父的Rob Pike说,你是否同意GO语言,取决于你是认可少就是多,还是少就是少(Less is more or less is less)。Rob Pike以一种非常朴素的方式,概括了GO语言的整个设计哲学–将简单、实用体现得淋漓尽致。

    很多人将GO语言称为21世纪的C语言,因为GO不仅拥有C的简洁和性能,而且还很好的提供了21世纪互联网环境下服务端开发的各种实用特性,让开发者在语言级别就可以方便的得到自己想要的东西。

    • 1.1、发展历史

      2007年9月,Rob Pike在Google分布式编译平台上进行C++编译,在漫长的等待过程中,他和Robert Griesemer探讨了程序设计语言的一些关键性问题,他们认为,简化编程语言相比于在臃肿的语言上不断增加新特性,会是更大的进步。随后他们在编译结束之前说服了身边的Ken Thompson,觉得有必要为此做一些事情。几天后,他们发起了一个叫Golang的项目,将它作为自由时间的实验项目。

    2008年5月 Google发现了GO语言的巨大潜力,得到了Google的全力支持,这些人开始全职投入GO语言的设计和开发。

    2009年11月 GO语言第一个版本发布。2012年3月 第一个正式版本Go1.0发布。

    2015年8月 go1.5发布,这个版本被认为是历史性的。完全移除C语言部分,使用GO编译GO,少量代码使用汇编实现。另外,他们请来了内存管理方面的权威专家Rick Hudson,对GC进行了重新设计,支持并发GC,解决了一直以来广为诟病的GC时延(STW)问题。并且在此后的版本中,又对GC做了更进一步的优化。到go1.8时,相同业务场景下的GC时延已经可以从go1.1的数秒,控制在1ms以内。GC问题的解决,可以说GO语言在服务端开发方面,几乎抹平了所有的弱点。

    在GO语言的版本迭代过程中,语言特性基本上没有太大的变化,基本上维持在GO1.1的基准上,并且官方承诺,新版本对老版本下开发的代码完全兼容。事实上,GO开发团队在新增语言特性上显得非常谨慎,而在稳定性、编译速度、执行效率以及GC性能等方面进行了持续不断的优化。

    (2)golang语言特性

    • 2.1. 垃圾回收

      • 内存自动回收,再也不需要开发人员管理内存
      • 开发人员专注业务实现,降低了心智负担
      • 只需要new分配内存,不需要释放
    • 2.2. goroute天然并发

      • 从语言层面支持并发,非常简单

      使用一个go则在编译时会自动开启一个线程来执行后面的命令/函数/方法,不用像python需要先调用thread模块来开启线程

      • goroute,轻量级线程,创建成千上万个goroute成为可能
      • 基于CSP(Communicating Sequential Process)模型实现
    • 2.3. goroute线程之间的数据通信——管道

      使用go可以创建一个轻量级的goroute线程,线程之间如何通信,共享数据呢?答案是:使用管道来进行通信。管道需要定义并创建后,才能使用

      定义一个管道:

      var my_pipe chan int
      //my_pipe为管道名,chan为管道关键字表示定义的是一个管道,int表示管道内存储的数据类型

      创建一个管道:

      my_pipe = make(chan int,10)
      //make关键字表示开辟一个内存空间,第一个参数表示创建一个管道,10表示管道能存储的数据类型个数,如果超出则阻塞

      定义和创建可以合并写

      my_pipe := make(chan int,10)

      管道的定义和使用范例:

      //goroute线程之间使用管道进行数据通信
      
      func main() {
      go pi_pie()
      }
      
      func pi_pie() {
        pipe := make(chan int, 10) //make关键字创建一个管道(关键字chan),管道内装int类型的数据,并且管道大小能装10个数字,超过则阻塞
        pipe <- 10                 //向管道内放入数据
        pipe <- 9
        pipe <- 9
        pipe <- 7
        pipe <- 6
        var p1 int
        p1 = <-pipe //从管道取出数据
        fmt.Println(p1)
        fmt.Println(len(pipe))
      }
    • 2.4. 多返回值

      go的函数可以有多个返回值

      “`
      func main() {
      x,y:=p_fun(10,80)
      // x,_ := p_fun(10,80) 多返回值函数时,只要一个返回值
      fmt.Println(x,y)
      }

      //多返回值函数
      func p_fun(a int,b int) (int,int) { //函数传入2个整型参数,返回2个值,都为int类型
      sum := a+b
      avg := (a+b)/2
      return sum,avg
      }

    • 2.5. go的“包”的概念

      • 1.和python一样,把相同功能的代码放到一个目录,称之为包
      • 2.包可以被其他包引用
      • 3.main包是用来生成可执行文件,每个程序只有一个main包
      • 4.包的主要用途是提高代码的可复用性
      • 5.包的引用

      go在首行使用“package <包名>”来声明自己所在的包(主程序包为main包,也可以自定义包名),“import”引入其他的包,go自带的系统包所在的路径已经在“GOROOT”环境变量中设置好了
      可以使用“import”直接引入,而自己定义的包: package <包名> 在import导入时则需要相对路径:第三方包默认在“GOROOT”和“GOPATH”环境变量所在的路径下的src目录下寻找


      Go的package不支持使用“../”方式的相对路径,都是从$GOPATH/src下一层一层找的

    • 2.6. go文件编码规范

      使用gofmt <go文件>使go文件内的代码更规范(缩进等格式更规范),使用gofmt -w <go文件>将原来的go文件修改的更规范

    二、环境搭建

    环境搭建参考网址:https://blog.csdn.net/fearless11/article/details/70543932

    (1)开发环境搭建

    • 1.1 安装Go环境

      • 打开网址https://golang.org/dl/
      • 根据操作系统选择对应的安装包
      • 点击安装包进行安装(linux直接解压)
      • 设置环境变量(linux)

        1. export GOROOT=$PATH:/path/to/go/ #go的家目录

        2. export PATH=PATH:GOROOT/bin/ #go执行命令路径

        3. export GOPATH=/home/user/project/go #项目路径

      • 设置环境变量(window)

      参考:https://blog.csdn.net/fearless11/article/details/70543932

    • 1.2 开发环境搭建(IDE为VScode)

      • 打开网址:https://code.visualstudio.com/
      • 根据操作系统选择对应的安装包
      • 根据操作系统选择对应的安装包
      • 根据操作系统选择对应的安装包
      • 调试工具delve安装

        1. mac: brew install go-delve/delve/delve

        2. linux&windows: go get -u github.com/derekparker/delve/cmd/dlv #请确保已经安装了git

          1. 其他安装方式参考网址:https://github.com/derekparker/delve/tree/master/Documentation/installation
      • 注意事项: VScode开发的项目路径与环境变量 ==“GOPATH”== 的路径要一致,如 $GOPATH = d:\go_build 那么VScode开发的项目也要在d:\go_build目录下
    • 1.3 开发环境搭建(IDE为pycharm)

      '''新版本的pycharm可能已经无法使用'''
      
      pycharm的go语言开发支持插件下载:
      
      1.在pycharm中通过在线搜索go插件来安装
      
      2.可能因为版本原因,pycharm的在线插件安装可能搜索不到,可以采用本地安装的方法:
      
      插件本地安装包下载页面:
      
      https://plugins.jetbrains.com/plugin/5047-go-language-golang-org-support-plugin (pycharm社区版)
      https://plugins.jetbrains.com/plugin/9568-go (pycharm专业版)
      
      根据pycharm的idea版本号(idea版本号在安装目录下的“build.txt/readme.txt”文件中,通常是AA.BBBB.CC的形式)来选择下载插件的版本
      
      > 需要注意的是,pycharm的idea号AA.BBBB.CC 只要 AA与网站上的idea号对应上即可,它是一个范围,如idea号172.4343.24就可以下载范围“172.3968-172.*”对应的插件版本

    (2)编译环境和编译流程

    • 2.1 编译需要的目录环境

      我们的go项目的开发根目录由 GOPATH 环境变量决定了(范例为:d:/go_build),当我们需要开发项目工程时,需要在根目录下先创建src目录(规定死了),
      然后在 src 目录下创建开发的项目名称,如项目名称为app_store, 那么你的go文件应该在 d:/go_build/src/app_store目录下进行开发

      当使用,go get github.com/golang/tools相关命令来安装go的开发插件时,默认下载到 GOPATH/src/==GOPATH/src/github.com/golang/tools/…,然后再将
      该目录下的go文件编译成可执行的二进制文件,放入 $GOPATH/bin 目录下,来使用

      go get <github等网址>....,即在指定网址下载go文件,到GOPATH/src/GOPATH/bin 目录下,之后可以在IDE开发中直接使用(如调试台)

    • 2.2 编译go文件为二进制可执行代码

      使用 go build <go文件所在目录>命令,来进行go文件编译

      例如: ==GOPATH==为 d:/go_build时,编译d:/go_build/src/app_store/app.go文件时,编译的命令为 : `go build app_store/app.go则会在当前目录生成app.exe执行文件(Windows)

      go build时,默认会从$GOPATH/src/ 目录下开始寻找目录,因此只需要相对地址即可

      编译go文件为可执行文件并将文件放到指定位置下

      go build -o %GOPATH%/bin/calcs.exe app_store/app.go
      //将go文件编译到GOPATH变量所在目录下的bin目录里面,名称为calcs,后缀为.exe
      

      添加参数 “- o <执行文件路径(含文件名)>” 即可指定编译的文件位置,需要加上文件名和后缀(Windows为.exe;linux可不要)



    go基础介绍相关代码:

    package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        //   bingfa()
    
        // go pi_pie()
    
        //a := my_sum(10,20)
        //fmt.Println(a)
    
        x,y:=p_fun(10,80)
        // x,_ := p_fun(10,80) 多返回值函数时,只要一个返回值
        fmt.Println(x,y)
    
        time.Sleep(2 * time.Second) //主进程停留2秒,否则并发线程还没有开启并执行完就结束了
    }
    
    //go的高并发
    func bingfa() {
        for i := 0; i <= 100; i++ {
            go fmt.Println(i) //go关键字即表示开启一个线程(轻量级的线程goroute)
        }
    }
    
    //goroute线程之间使用管道进行数据通信
    func pi_pie() {
        pipe := make(chan int, 10) //make关键字创建一个管道(关键字chan),管道内装int类型的数据,并且管道大小能装10个数字,超过则阻塞
        pipe <- 10                 //向管道内放入数据
        pipe <- 9
        pipe <- 9
        pipe <- 7
        pipe <- 6
        var p1 int
        p1 = <-pipe //从管道取出数据
        fmt.Println(p1)
        fmt.Println(len(pipe))
    }
    
    //带返回值的函数
    func my_sum(a int,b int) int {  //函数传入2个参数,类型为整型,返回值也为整型
        sum := a+b
        return sum
    }
    
    //多返回值函数
    func p_fun(a int,b int) (int,int) { //函数传入2个整型参数,返回2个值,都为int类型
        sum := a+b
        avg := (a+b)/2
        return sum,avg
    }


    go开发部分插件无法安装解决方案:

    官方的安装文档是使用go get github.com/tools/godep,很可惜,因为“网络”问题会报一个找不到golang.org/x/tools/go/vcs的错误。

    然而https://github.com/golang/tools 是 golang.org/x/tools 的一个镜像,代码是一样的,所以我是如下安装的:

    • 1.执行命令go get github.com/golang/tools

    • 2.在GOPATH\src\github.com\golang目录下就有tools文件夹。

    • 3.在src下和github.com平级新建golang.org文件下,在此文件夹下建x文件夹,然后将tools文件夹都复制进去。

    • 4.然后再执行go get github.com/tools/godep

    此时godep安装在你的GOPATH\bin目录下。

    对其他类似 golang.org/x/tools/go/vcs 的错误的办法也管用

    展开全文
  • Go入门教程

    万次阅读 多人点赞 2020-02-26 10:24:52
    本人录制的Go入门视频 go语言开发实战:...01、Go语言介绍 02、环境搭建 03、第一个Go程序 04、命名、变量、常量 05、基础数据类型 06、格式化输出、类型转换、类型别名 07、...

    基础编程

    01、Go语言介绍
    02、环境搭建
    03、第一个Go程序

    04、命名、变量、常量
    05、基础数据类型
    06、格式化输出、类型转换、类型别名
    07、运算符
    08、流程控制

    09、自定义函数
    10、递归函数、函数类型、匿名函数与闭包
    11、延迟调用defer
    12、获取命令行参数
    13、作用域

    14、包
    15、工程管理

    复合类型

    类型 名称 长度 默认值 说明
    pointer 指针 nil
    array 数组 0
    slice 切片 nil 引⽤类型
    map 字典 n il 引⽤类型
    struct 结构体



    16、指针
    17、数组
    18、slice
    19、map
    20、结构体

    面向对象

    对于面向对象编程的支持Go 语言设计得非常简洁而优雅。因为, Go语言并没有沿袭传统面向对象编程中的诸多概念,比如继承(不支持继承,尽管匿名字段的内存布局和行为类似继承,但它并不是继承)、虚函数、构造函数和析构函数、隐藏的this指针等。

    这里写图片描述

    尽管Go语言中没有封装、继承、多态这些概念,但同样通过别的方式实现这些特性:

    • 封装:通过方法实现
    • 继承:通过匿名字段实现
    • 多态:通过接口实现

    21、匿名组合
    22、方法
    23、接口
    24、异常处理(error接口、panic、recover)
    25、反射

    文本文件处理

    26、字符串处理
    27、正则表达式
    28、JSON处理
    29、文件操作

    并发编程

    30、什么是并发编程
    31、goroutine
    32、channel
    33、select

    网络编程

    34、网络概述
    35、Socket编程
    36、HTTP报文浅析
    37、HTTP编程

    20180210174507305
    展开全文
  • GO 入门指南

    2020-01-02 17:49:24
    GO语言的目的 更少的代码,更短的编译时间(与传统开发的C/C++相比) 创建运行更快的程序,高性能与安全性(与动态语言相比) 能够很好地在多核计算机上工作 能够做到在性能上和开发速度上基本不差于任何一门...

    前言

    GO语言的目的

    1. 更少的代码,更短的编译时间(与传统开发的C/C++相比)
    2. 创建运行更快的程序,高性能与安全性(与动态语言相比)
    3. 能够很好地在多核计算机上工作
    4. 能够做到在性能上和开发速度上基本不差于任何一门其他语言

    GO语言提倡通过接口来针对面向对象编程,通过 goroutine 和 channel 来支持并发和并行编程。

    学习GO语言

    第1章:Go 语言的起源,发展与普及

    在 Go 语言出现之前,开发者们总是面临非常艰难的抉择,究竟是使用执行速度快但是编译速度并不理想的语言(如:C++),还是使用编译速度较快但执行效率不佳的语言(如:.NET、Java),或者说开发难度较低但执行速度一般的动态语言呢?显然,Go 语言在这 3 个条件之间做到了最佳的平衡:快速编译,高效执行,易于开发。

    设计者通过 goroutine 这种轻量级线程的概念来实现这个目标,然后通过 channel 来实现各个 goroutine 之间的通信。他们实现了分段栈增长和goroutine 在线程基础上多路复用技术的自动化。

    依赖管理是现今软件开发的一个重要组成部分,但是 C 语言中“头文件”的概念却导致越来越多因为依赖关系而使得构建一个大型的项目需要长达几个小时的时间。人们越来越需要一门具有严格的、简洁的依赖关系分析系统从而能够快速编译的编程语言。这正是 Go 语言采用包模型的根本原因,这个模型通过严格的依赖关系检查机制来加快程序构建的速度,提供了非常好的可量测性。

    尽管 Go 语言像其它静态语言一样执行本地代码,但它依旧运行在某种意义上的虚拟机,以此来实现高效快速的垃圾回收(使用了一个简单的标记-清除算法)。

    Go语言通过减少关键字的数量(25 个)来简化编码过程中的混乱和复杂度。干净、整齐和简洁的语法也能够提高程序的编译速度,因为这些关键字在编译过程中少到甚至不需要符号表来协助解析

    值得注意的是,因为垃圾回收和自动内存分配的原因,Go 语言不适合用来开发对实时性要求很高的软件。

    Go 语言通过另一种途径实现面向对象设计来放弃类和类型的继承。它不支持动态加载代码,不支持动态链接库,不支持静态变量等。

    第2章:安装与运行环境

    目前有2个版本的编译器:Go 原生编译器 gc 和非原生编译器 gccgo

    Go 语言本身是由 C 语言开发的,而不是 Go 语言

    Linux安装过程:

    1. 官网下载Linux下的安装包。

    2. 解压到某个目录:sudo tar zxvf go1.10.linux-amd64.tar.gz -C /usr/local

    3. 配置环境变量:

      vim ~/.bashrc
      
      export GOROOT=/usr/local/go 							//前面GO的安装解压路径
      export GOPATH=$HOME/Applications/Go 					//GO的工作路径,以后存放代码的地方
      export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin				//为了确保相关文件在文件系统的任何地方都能被调用
      
      source ~/.bashrc							//激活生效
      
    4. 检查GO version

      go version
      go env
      
    5. 编写GO的demo程序:

      package main
       
      import "fmt"
       
      func main() {
      	fmt.Printf("hello world\n")
      }
      

      测试demo程序:

      cd ~/Application/GO/src/hello     //这个目录好像需要自己创建的
      go build hello.go
      ./hello
      

      beego的安装:

      go get github.com/astaxie/beego
      go get github.com/beego/bee
      

    开发环境要求等

    使用go fmt ( gofmt ) 去统一代码风格。

    go doc工具会从 Go 程序和包文件中提取顶级声明的首行注释以及每个对象的相关注释,并生成相关文档。

    Go 语言与 C 语言的性能差距大概在 10%~20% 之间,Go 程序比 Java 或 Scala 应用程序要快上 2 倍,并比这两门语言使用少占用 70% 的内存。

    GO可以调用C和C++代码

    语言的核心结构与技术

    go文件的命名以小写字母命名,多个单词用_连接。
    对于可导出的对象,采用Pascal 命名法(第一个字母也是大写)
    否则就遵循骆驼命名法,即第一个单词的首字母小写,其余单词的首字母大写。

    基本结构和基本数据类型

    你必须在源文件中非注释的第一行指明这个文件属于哪个包

    如果你打算编译包名不是为 main 的源文件,如 pack1 ,编译后产生的对象文件将会是 pack1.a 而不是可执行程序。

    在导入一个外部包后,能够且只能够访问该包中导出的对象(以大写字母开头,类似public)

    如果你导入了一个包却没有使用它,则会在构建程序时引发错误,如 imported and not used: os ,这正是遵循了 Go 的格言:“没有不必要的代码!“。

    函数定义规范:

    func functionName(parameter_list) (return_value_list) {
    …
    }
    
    parameter_list 的形式为 (param1 type1, param2 type2, …)
    return_value_list 的形式为 (ret1 type1, ret2 type2, …)
    
    类型

    Go 语言中不存在类型继承,所有的内存在 Go 中都是经过初始化的(会初始化为默认值)

    GO命名规范:返回某个对象的函数或方法的名称一般都是使用名词,没有 Get… 之类的字符,如果是用于修改某个对象,则使用 SetName 。有必须要的话可以使用大小写混合的方式,如 MixedCaps 或 mixedCaps,而不是使用下划线来分割多个名称。

    //定义类型别名
    type IZ int
    type (
    	IZ int
    	FZ float64
    	STR string
    	)
    
    //类型转换
    var a IZ = 5
    c := int(a)
    d := IZ(c)
    
    常量

    因为在编译期间自定义函数均属于未知,因此无法用于常量的赋值,但内置函数可以使用,如:len()。

    const beef, two, c = “meat”, 2, “veg”
    const Monday, Tuesday, Wednesday, Thursday, Friday, Saturday = 1, 2, 3, 4, 5, 6
    const (
    Monday, Tuesday, Wednesday = 1, 2, 3
    Thursday, Friday, Saturday = 4, 5, 6
    )
    //枚举
    const (
    Unknown = 0
    Female = 1
    Male = 2
    )
    
    变量
    //这种因式分解关键字的写法一般用于声明全局变量
    var (
    a int
    b bool
    str string
    )
    

    Go 编译器的智商已经高到可以根据变量的值来自动推断其类型,Go 是在编译时就已经完成推断过程。变量的类型也可以在运行时实现自动推断

    var (
    HOME = os.Getenv("HOME")
    USER = os.Getenv("USER")
    GOROOT = os.Getenv("GOROOT")
    )
    
    package main
    import (
    "fmt"
    "os"
    ) f
    unc main() {
    var goos string = os.Getenv("GOOS")
    fmt.Printf("The operating system is: %s\n", goos)
    path := os.Getenv("PATH")						//在函数体内声明局部变量时,应该使用简明语法
    fmt.Printf("Path is %s\n", path)
    }
    

    所有像 int、float、bool 和 string 这些基本类型都属于值类型,另外,像数组(第 7 章)和结构(第 10 章)这些复合类型也是值类型。

    在 Go 语言中,指针(第 4.9 节)属于引用类型,其它的引用类型还包括 slices(第 7 章),maps(第 8章)和 channel(第 13 章)。被引用的变量会存储在堆中,以便进行垃圾回收,且比栈拥有更大的内存空间。

    打印的方法

    1. Printf:%s 代表字符串标识符、 %v 代表使用类型的默认输出格式的标识符,%t 来表示你要输出的值为布尔型
    2. fmt.Sprintf :与 Printf 的作用是完全相同的,不过前者将格式化后的字符串以返回值的形式返回给调用者,因此你可以在程序中使用包含变量的字符串
    3. 函数 fmt.Print 和 fmt.Println 会自动使用格式化标识符 %v 对字符串进行格式化,两者都会在每个参数之间自动增加空格,而后者还会在字符串的最后加上一个换行符

    全局变量是允许声明但不使用,局部变量不允许

    var a, b, c int
    a, b, c = 5, 7, "abc" 			//已经声明过了
    a, b, c := 5, 7, "abc"
    
    a, b = b, a  //交换两个变量的值
    
    4.5 基本类型和运算符

    Go 不存在像 C 和 Java 那样的运算符重载,表达式的解析顺序是从左至右。

    对于布尔值的好的命名能够很好地提升代码的可读性,例如以 is 或者 Is 开头的 isSorted 、isFinished 、 isVisivle ,使用这样的命名能够在阅读代码的获得阅读正常语句一样的良好体验

    Go 语言中没有 float 类型。有float32,float64(这些是与架构无关的)

    package main
    func main() {
    var a int
    var b int32
    a = 15
    b = a + a // 编译错误
    b = b + 5 // 因为 5 是常量,所以可以通过编译
    }
    

    对于整数和浮点数,你可以使用一元运算符 ++ (递增)和 – (递减),但只能用于后缀

    同时,带有 ++ 和 – 的只能作为语句,而非表达式,因此 n = i++ 这种写法是无效的,其它像f(i++) 或者 a[i]=b[i++] 这些可以用于 C、C++ 和 Java 中的写法在 Go 中也是不允许的。

    字符串的内容(纯字节)可以通过标准索引法来获取,在中括号 [] 内写入索引,索引从 0 开始计数

    获取字符串中某个字节的地址的行为是非法的,例如: &str[i] 。

    4.7 strings 和 strconv 包
    4.8 时间和日期
    4.9 指针

    Go 语言和 C、C++ 以及 D 语言这些低级(系统)语言一样,都有指针的概念。但是对于经常导致 C 语言内存泄漏继而程序崩溃的指针运算(所谓的指针算法,如: pointer+2 ,移动指针指向字符串的字节数或数组的某个位置)是不被允许的。Go 语言中的指针保证了内存安全,更像是 Java、C# 和VB.NET 中的引用。

    展开全文
  • Go语言基础入门

    2018-08-06 20:10:35
    注意:①go语言以包为单位  ②每个文件必须先声明包  ③程序想要运行必须得有main包,而且写在main方法里 一、变量   1、导入包后,必须要使用,否则报错   2、 变量的声明的格式: var 变量名 类型 ...

    注意:①go语言以包为单位

              ②每个文件必须先声明包

              ③程序想要运行必须得有main包,而且写在main方法里

    一、变量

     

    1、导入包后,必须要使用,否则报错

     

    2、 变量的声明的格式: var 变量名 类型

           注意:变量声明过后,必须要使用

         

          可以同时声明多个变量:  var a ,b int 

    3、变量的初始化

              

             var  b int = 10;//初始化

              b  = 20 ;//赋值

      4自动推导类型,要求是必须得初始化,通过初始化的值推断类型

              语法:   变量名:=值

             举例:  c := 30

             fmt.Println(" %T",c) ------>%T就是打印变量所属的类型

     

             注意: 在使用完自动推到类型后,不能再次声明这个变量了

     

    与赋值的区别:

         自动推导只能用一次,赋值可以是多次

     

    5、Println与Printf的区别:与java的类似

     

          

     

    6,多重初始化

         a,b := 10,20

    go语言实现值的交换

         i := 10

         j :=  20

        i, j = j, i  

     _匿名变量:丢弃数据不处理,   只有配合函数的返回值使用才有价值:比如,一个函数的返回值有多个,你只需要用一个,那句可以用匿名变量

     

    temp, _ :=  i,  j------->这样j的值就没了

     

    二、常量

     

    变量的声明需要 var

    常量的声明用const

     

    下面的声明b的时候没有用:

     

     多个不同类型的变量的批量声明:

     

    原本是: var  a int   

                   var b float64

     

     现再可以:     var(  ------里面也可以自动推到类型

                      a int 

                      b float64

                )

    常量也是一样的

     

    注释代码:ctrl+\

     

    三、iota枚举

     

    1、iota也称作为常量自动生成器,每一行自动累加1

     2、iota是给常量赋值使用的

    const(

         a = iota    //0

          b= iota  //1

           c = iota   //2

    )

     

    3、iota遇到const重置为0

    const d = iota  ------d为0

     

    4、如果是在同一行,值是一样的

    const(

         i   =  iota   //0

          a,b,c = iota,iota,iota   //a,b,c都是1

          d = iota  //d是2 

    )

     

    四、数据类型

     

    常用的是: bool,byte ,int uint,flaot64,string

     

     

    字符类型

    var ch byte 

    ch = 97----------->a

    或者这样赋值: ch  = 'a'

     

    '\'以反斜杠开头的字符都是转义字符

     

    字符串操作

               var str string

                str = "abc"

        他包含一个内建函数,len(字符串),表示有几个字符

        fmt.Println("len()  =",len(str))

     

    字符和字符串的区别

        字符串都是隐藏了一个结束符的,'\0'

        例如: str = " a "--------就是由‘a’和‘\0’构成的

     

    选择字符串中的某一个字符: str[0]

     

     

    复数类型:可以进行实数和虚数的计算等

    var t complex128

    t = 2.1+31.2i

    取 实部是   real(t),取虚部 imag(t)

     

    fmt格式化

    %v是自动匹配格式

    %c, %T,% ,%s,%f 

     

    输入

     

    fmt.Scanf("%d",&a)简便格式:    fmt.Scan(& a)

     

    类型别名☆非常重要

     

    type  

    例如:

     //给int64起一个别名交bigint

    type bigint int64

    var a bigint

    fmt.Printf("%T\n",a)-------->bigint 

     

    取地址符:&

    取值符: *

     

    流程控制结构

     

    if:

     

         s := "zhang"

        if s== "zhang"{//左括号必须和if同一行

     

         }

    if可以支持一个初始化语句,初始化语句和判断条件一分号分割

     

         if  a:10 ; a==10{

         } else if a>10{

         }else{

          }

     

    switch

     

       num := 1

       switch num{

           case 1:  

                 fmt.Println()

                   break  //go语言还是保留了break关键字,不写的化也是默认包含了 

                   fallthrough  //这是是不会跳出switch,会接着下面执行

           case 2:  .....

           case 3:  .....

           defalut :

         }

     

        //也可以支持初始化语句,

       switch    num : =10; num{

       }

      //甚至可以放条件

      score := 85

       

    switch{

    case   score>90: ......

    case  socre<80: ........

     }

     

    for

     

    for i : = 1;      i<=10 ;  i++{

     

      }

     

    range

     

    str=" abc "

     

    打印str每一个字符

    for i:= 0;   i<len(str); i++{

    }

    //使用迭代打印每个元素,range默认是返回两个值:一个元素的位置,一个是元素的本省

     

    for i, data := range  str{

        fmt.Printn(" 第%d个是%c ", i,  data) 

    }

    //甚至可以省略

     

    for i := range str{   //这样默认是第二个返回值是  __ (丢弃)

          fmt.Println(" 第%d个是%c ", i,  str[i])

    }

     

     

     

     

     

     

     

     

     

    展开全文
  • 本文主要为博主在学习《Go 入门指南》的过程中记录的笔记,秉持着书越读越薄的原则,博主在学习过程中记录了个人认为较为重要的知识点,以便后续查阅和翻看。 对于某些原文讲解不够明白之处,博主通过搜集资料和自行...
  • 对于学习go语言的朋友来说,是非常好的一本入手的书籍。 简介:Go(又称 Golang)是 Google 的 Robert Griesemer,Rob Pike 及 Ken Thompson 开发的一种静态强类型、编译型语言。Go 语言语法与 C 相近,但功能上有...
  •  先简单介绍一下Golang吧,Go是Google开发的一种编译型,可平行化,并具有垃圾回收功能的编程语言,如果你有C语言基础,那么学习go将会比较easy,go语言一般用在服务器编程。上述这些概念哈,看完一遍没
  • go入门及进阶书籍推荐

    万次阅读 热门讨论 2019-08-16 10:40:52
    c c++了解即可 ... Cloud.Native.Go.pdf C和指针.pdf C++面向对象多线程编程.pdf Design Pattern In Go[go语言设计模式].pdf Docker —— 从入门到实践 - v1.0.pdf Docker 容器与容器云(第2版).pdf ...
  • go语言入门实例

    2019-04-04 13:48:14
    go语言入门实例 1、环境搭建(windows) 1.1 go环境安装包下载 https://golang.org/dl/ 1.2 环境变量配置,在path环境变量中配置go的安装位置,例如: 1.3 在cmd控制台输入 go version 查看是否安装成功 2、第一个...
  • 转载:https://gobyexample.com/ Go by Example Gois an open source programming language designed for building simple, fast, and reliable software. ...Go by Exampleis a hands-on introduction to Go u...
  • Go语言入门到实战

    2019-03-18 11:50:12
    最近在学习GO语言,看到了这个教程我觉得非常适合有点其它语言基础的人快速入门GO语言,推荐给大家。 先看下大概的介绍 蔡超目前在 Mobvista 担任技术副总裁兼首席架构师,之前的 9 年,曾在亚马逊(中国)、...
  • Go 入门实战

    2018-07-08 22:26:15
    Go 入门级别实战 看了一段时间的 Go 基础语法,总觉得缺了点什么,所以今天就想试试写点什么 附.目录结构 binary.go 、 cache.go、 fibonacci.go 都属于 chestnut_math 包 main.exe 为构建后的可执行文件 ...
  • Go入门教程全集 ... Cloud.Native.Go.pdf C...Go[go语言设计模式].pdf Docker —— 从入门到实践 - v1.0.pdf Docker 容器与容器云(第2版).pdf GO语言圣经(1).pdf GO语言圣经.pdf Go 内存模型 - Go 编程语言.pdf Go 学习
  • Go语言入门经典 源码

    2020-07-30 23:30:10
    Go语言入门经典 源码
  • 过年的疫情,让我有了...这篇是关于如何学习golang这门语言的。实例代码一分享到github 点击获取源码github 学习golang 本项目是个go gin框架写的web 项目。前端使用的是x-admin的开源前端。 项目截图: ...
  • 2019千锋GO语言超详细入门教程(笔记+课件+源码)(连载)https://pan.baidu.com/s/1SAOdgmd7d82MBVFiJsj2sQ 提取码:egyb 2019千锋区块链初识与职业发展https://pan.baidu.com/s/1VrUJ6Qn19fd1D40_uQuKTQ 2019...
  • Go语言入门经典_张海燕译 PDF文件
  • Go语言入门

    2017-11-15 20:15:32
    Golang标准库文档 go语言net包rpc远程调用的使用题目描述 计算字符串最后一个单词的长度,单词以空格隔开。 输入描述: 一行字符串,非空,长度小于5000。 输出描述: 整数N,最后一个单词的长度。 示例1 输入...
  • go语言入门练习合集

    2020-04-15 11:32:34
    package main import ( "fmt" "math" ) func Sqrt(x float64) float64 { z := 1.0 for math.Abs(x - z*z) > 0.000000001 { z -= (z*z - x) / (2*z) } return z ... fmt.Println(Sqrt(2))...
  • Go语言入门经典》_张海燕
1 2 3 4 5 ... 20
收藏数 54,029
精华内容 21,611
关键字:

go 入门