瓦力

瓦力 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

瓦力 关注了用户 · 4月14日

民工哥 @jishuroad

10多年IT职场老司机的经验分享,坚持自学一路从技术小白成长为互联网企业信息技术部门的负责人。

我的新书:《Linux系统运维指南》

微信公众号:民工哥技术之路

民工哥:知乎专栏

欢迎关注,我们一同交流,相互学习,共同成长!!

关注 3627

瓦力 关注了用户 · 4月14日

张晋涛 @moelove

微信公众号:MoeLove
Container, Docker, Go, Kubernetes, Python, Vim;

为了准确筛选信息,可使用付费问答 https://segmentfault.com/pay/...

关注 242

瓦力 关注了用户 · 4月14日

煎鱼 @eddycjy

我的公众号:脑子进煎鱼了
博客地址:https://eddycjy.com/
喝口热水,写写代码。

关注 1988

瓦力 关注了用户 · 4月14日

上官元恒 @zsdroid

吃好喝好

关注 1870

瓦力 关注了用户 · 4月14日

顶级手法 @php_maybe

Maybe, that's not your limit。
个人微信:noone_2021
淘宝店铺:https://shop566459201.taobao....

关注 149

瓦力 关注了用户 · 4月14日

风兮清扬 @fqy

关注 444

瓦力 赞了文章 · 3月4日

Golang程序设计——基本语法

本文学习Go语言基本语法,例如变量和常量、数据类型、运算符、条件语句、循环语句。

变量和常量

变量和常量是计算机程序不可或缺的部分。本节将介绍如何在Go程序中声明、使用变量和常量、还将介绍声明方式和作用域。

变量声明

在Go语言中,声明变量的方式有多种。在前面的文章介绍过,Go语言是一种静态类型语言,因此声明变量时必须指明其类型。

例:声明string类型的变量。

package main

import "fmt"

func main() {
    var s1 string = "Hello World"
    var s2 = "Hello World"
    var s3 string
    s3 = "Hello World"
    fmt.Println(s1, s2, s3)
}
  • 使用关键字var声明变量。
  • 如果变量类型可以通过值推导则不用声明类型。s2通过值可以推导类型为string类型。
  • 变量可以在声明后赋值,未赋值的变量值为该类型的零值。
变量的类型很重要,因为这决定了可将什么值赋给该变量。例如,对于类型为string的变量,不能将整数赋值给它。将不匹配的值赋值给变量时,将导致编译错误。

例:将string类型的值赋值给int类型的变量。

package main

import "fmt"

func main() {
    var i int
    i = "Hello World"
    fmt.Println(i)
}

编译该文件将导致编译错误。

go build main.go 
# command-line-arguments
./main.go:7:4: cannot use "Hello World" (type untyped string) as type int in assignment

多变量声明

例:声明多个类型相同的变量并进行赋值(显式指定类型)。

package main

import "fmt"

func main() {
    var s1, s2 string = "S1", "S2"
    fmt.Println(s1, s2)
}

例:声明多个类型不同的变量并进行赋值(不能显式指定类型)。

package main

import "fmt"

func main() {
    var s1, i1= "S1", 1
    fmt.Println(s1, i1)
}

例:声明多个类型不同的变量(显式指定类型)。

package main

import "fmt"

func main() {
    var (
        s1 string
        i1 int
    )
    s1 = "Hello"
    i1 = 10
    fmt.Println(s1, i1)
}
声明变量后可以再次赋值,但是同一个变量只允许声明一次,否则将导致编译错误。

简短变量声明

函数中声明变量时,可以用更简洁的方式。

package main

import "fmt"

func main() {
    s1 := "Hello World"
    fmt.Println(s1)
}
  • :=表示简短变量声明,可以不使用var,不指定类型,但是必须进行赋值。
  • 只能在函数中使用简短变量声明。

变量声明最佳实践

Go语言提供了多种变量声明方式,下面的声明方式都是合法的。

var s string = "Hello"
var s1 = "Hello"
var s2 string
s2 = "Hello"
s3 := "Hello"

该使用哪种方式呢?

Go语言对此有一个限制——只能在函数内部使用简短变量声明,在函数外部必须使用var进行声明。

在标准库中遵循的约定如下:有初始值的情况下,在函数内使用简短变量声明,在函数外使用var并省略类型;无初始值的情况下使用var并指定类型。
package main

import "fmt"

var s = "Hello World"

func main() {
    s1 := "Hello World"
    fmt.Println(s, s1)
}

变量和零值

在Go语言中,声明变量时如果未初始化,则变量为默认值,该默认值也称为零值。在其他语言中未初始化的值为null或undefined。

package main

import "fmt"

func main() {
    var s string
    var i int
    var b bool
    var f float32
    fmt.Printf("%v %v %v %v\n", s, i, b, f)
}

在Go语言中,检查变量是否为空,必须与该类型的零值比较。例如检测string类型的变量是否为空,可以与""判定。

package main

import "fmt"

func main() {
    var s string
    if s == "" {
        fmt.Println("s为空")
    }
}

变量作用域

作用域指变量可以在什么地方使用,而不是说变量在哪里声明的。Go语言使用基于块的词法作用域,简单来说就是{}会产生一个作用域。

Go语言作用域规则如下:

  1. 一对大括号({})表示一个块,块是可以嵌套的
  2. 对于在块内声明的变量,可以在本块以及子块中访问
  3. 子块可以访问父块的变量,父块不能访问子块的变量

例:Go语言的作用域。

package main

import "fmt"

func main() {
    var s1 = "s1"
    {
        var s2 = "s2"
        // 可以访问s1,s2
        fmt.Println(s1, s2)
        {
            var s3 = "s3"
            // 可以访问s1,s2,s3
            fmt.Println(s1, s2, s3)
        }
    }
    // 只能访问s1
    fmt.Println(s1)
}
简单来说,就是块内可以访问块外的变量,块外不能访问块内变量。

声明常量

常量只在整个程序运行过程中都不变的值,常量必须在声明时赋值,声明后不可以更改。

Go语言使用const关键字声明常量。

package main

import "fmt"

const s = "Hello"

func main() {
    const s2 = "World"
    const s3,s4 = "Hello","World"
    fmt.Println(s, s2)
}
常量也支持一次声明多个,此外常量的作用域和变量作用域一致。

数据类型

Go语言提供了丰富的数据类型,按类别分为布尔型、数值型(整数、浮点数、复数)、字符串型 、派生型。其中派声型包括指针类型、数组类型、结构体类型、接口类型、Channel类型、函数类型、切片类型和Map类型。

派生类型我们将在后面的内容中进行介绍。

布尔类型

布尔类型值只能为true或false。某些语言允许使用1和0来表示true和false,但Go语言不允许。

布尔类型的零值为false。

package main

import "fmt"

func main() {
    var b bool
    if b {
        fmt.Println("b是true")
    } else {
        fmt.Println("b是false")
    }
} 

数值型

Go语言中数值型包含整数、浮点数以及复数。

整数型

类型字节数范围
byte10 ~ 28
uint810 ~ 28
int81-27 ~ 27-1
uint1620 ~ 216
int162-215 ~ 215-1
uint3240 ~ 232
int324-231 ~ 231-1
uint6480 ~ 264
int648263 ~ 263-1
int平台相关(32位或64位)
uint平台相关(32位或64位)

浮点数

类型字节数范围
float324-3.403E38 ~ 3.403E38
float648-1.798E308 ~ 1.798E308

复数

字符串类型

字符串可以是任何字符序列,包括数字、字母和符号。Go语言使用Unicode来存储字符串,因此可以支持世界上所有的语言。

下面是一些字符串示例:

var s = "$%^&*"
var s2 = "1234"
var s3 = "你好"

运算符

运算符用于在程序运行时执行数据运算和逻辑运算。Go语言支持的运算符有:

  • 算术运算符
  • 逻辑运算符
  • 关系运算符
  • 位运算符

算术运算符

算术运算符是用来对数值类型进行算术运算的。下表列出了Go语言支持的算术运算符。

运算符说明
+相加
-相减
*相乘
/相除
%取余
++自增
--自减
package main

import "fmt"

func main() {
    var (
        a = 10
        b = 20
    )
    fmt.Printf("a+b=%d\n", a+b)
    fmt.Printf("a-b=%d\n", a-b)
    fmt.Printf("a*b=%d\n", a*b)
    fmt.Printf("a/b=%d\n", a/b)
    fmt.Printf("a%%b=%d\n", a%b)
    a++
    fmt.Printf("a++=%d\n", a)
    a--
    fmt.Printf("a--=%d\n", a)
}
和其他语言不同的是,Go语言不提供++a,--a运算符,只提供a++,a--。

关系运算符

关系运算符用来判断两个值的关系。下表列出了Go语言支持的关系运算符。

运算符说明
==判断两个值是否相等
!=判断两个值是否不相等
>判断运算符左边的值是否大于右边的值
<判断运算符左边的值是否小于右边的值
>=判断运算符左边的值是否大于等于右边的值
<=判断运算符左边的值是否小于等于右边的值
package main

import "fmt"

func main() {
    var (
        a = 10
        b = 20
    )
    if a == b {
        fmt.Println("a==b")
    } else {
        fmt.Println("a!=b")
    }

    if a < b {
        fmt.Println("a<b")
    } else {
        fmt.Println("a>=b")
    }

    if a <= b {
        fmt.Println("a<=b")
    } else {
        fmt.Println("a>b")
    }
}

逻辑运算符

逻辑运算符用来对操作数进行逻辑判断。下表列出了Go语言支持的逻辑运算符。

运算符说明
&&逻辑与。两边操作数都为true则结果为true,否则为false
\\逻辑或。两边操作数只要有一个为true则结果为true,否则为false
!逻辑非。如果操作数为true则结果为false,否则为true
package main

import "fmt"

func main() {
    var a, b = true, false
    if a && b {
        fmt.Println("a和b同时为true")
    } else {
        fmt.Println("a和b至少一个为false")
    }

    if a || b {
        fmt.Println("a和b至少一个为true")
    } else {
        fmt.Println("a和b都为false")
    }
    if !a {
        fmt.Println("a是false")
    } else {
        fmt.Println("a是true")
    }
}

位运算符

位运算符用来对整数进行二进制位操作。下表列出了Go语言支持的位运算符。

运算符说明
&按位与
\按位或
^按位异或
>>右移
<<左移
package main

import "fmt"

func main() {
    var (
        a = 1
        b = 2
    )
    fmt.Printf("a&b=%d\n", a&b)
    fmt.Printf("a|b=%d\n", a|b)
    fmt.Printf("a^b=%d\n", a^b)
    fmt.Printf("a>>1=%d\n", a>>1)
    fmt.Printf("a<<1=%d\n", a<<1)
}

条件语句

条件语句是计算机程序的重要组成部分,几乎所有编程语言都支持。简单地说,条件语句检查指定的条件是否满足,并在满足时执行指定的操作。

下表列出了Go语言支持的条件语句。

if由一个布尔表达式后紧跟一个或多个语句组成。
if...else if...else由多个布尔表达式分支组成,并提供例外分支
switch基于不同条件执行不同操作,并提供默认操作

例:if的使用。

package main

import "fmt"

func main() {
    var a = 10
    if a > 10 {
        fmt.Println("a大于10")
    } else if a == 10 {
        fmt.Println("a等于10")
    } else {
        fmt.Println("a小于10")
    }
}

例:switch的使用。

package main

import "fmt"

func main() {
    var a = 10

    switch a {
    case 1:
        fmt.Println("a等于1")
    case 2:
        fmt.Println("a等于2")
    case 10:
        fmt.Println("a等于3")
    default:
        fmt.Println("默认分支")
    }
}
和其他语言不同,Go语言的case分支不需要添加break。

循环语句

在其他语言中一般会提供for、while、foreach等关键字实现循环,而在Go语言中只提供for关键字,但是也实现了类似的效果。

for

for循环有着经典的三段式结构:

  1. 循环初始化
  2. 循环终止条件
  3. 循环步进条件
package main

import "fmt"

func main() {
  for i := 0; i < 10; i++ {
        fmt.Println(i)
  }
}

while

while循环指定循环终止条件,不满足条件时循环一直执行并向终止条件靠拢,满足条件后终止循环。(无终止条件的循环称为死循环)

package main

import "fmt"

func main() {
  i := 0
  for i < 10 {
        fmt.Println(i)
    i++
  }
}

死循环不需要终止条件。

package main

import (
  "fmt"
  "time"
)

func main() {
  i := 0
  for {
    fmt.Println(i)
    i++
    time.Sleep(time.Second)
  }
}

foreach

foreach循环多用来遍历列表、字典等数据结构。

package main

import "fmt"

func main() {
  list := []int{1, 2, 3, 4, 5}
  for index, value := range list {
        fmt.Println(index, value)
  }
}

continue

continue用来跳过本次循环继续执行下次循环。

package main

import "fmt"

func main() {
  for i := 0; i < 5; i++ {
    if i == 1 {
      continue
    }
    fmt.Println(i)
  }
}

该程序判断i为1时跳过并执行下次循环,该程序输出如下。

0
2
3
4

3.1.5 break

break用来跳出循环,后续循环将不执行。

package main

import "fmt"

func main() {
  for i := 0; i < 5; i++ {
    if i == 1 {
      break
    }
    fmt.Println(i)
  }
}

该程序判断i为1时跳出循环,该程序输出如下。

0

小结

本文介绍了Go语言的基本语法,包括变量和常量的使用、基础数据类型、流程控制等知识。下一章将介绍Go语言的数据容器类型,包括数组、切片和映射。

img

查看原文

赞 5 收藏 3 评论 1

瓦力 提出了问题 · 2月22日

gitbook报错TypeError: Cannot read property 'pipes' of undefined

操作:
1.执行gitbook serve,成功;
2.加载扩展,成功;
3.报错
TypeError: Cannot read property 'pipes' of undefined

at ReadStream.Readable.pipe (node:internal/streams/readable:646:13)
at /Users/liuwei/.gitbook/versions/3.2.3/node_modules/cpr/lib/index.js:163:22
at callback (/usr/local/lib/node_modules/gitbook-cli/node_modules/npm/node_modules/graceful-fs/polyfills.js:299:20)
at FSReqCallback.oncomplete (node:fs:199:21)

截图
image.png

关注 2 回答 1

瓦力 赞了回答 · 2020-10-21

解决golang - 如何判断字符是不是中文?

[\p{Han}]+匹配中文,中文标点不清楚,不过也不多,都写上吧!

关注 3 回答 5

瓦力 赞了回答 · 2020-08-01

解决php7.4 不能编译安装--with-freetype-dir

官方手册中关于迁移到 PHP 7.4 部分也描述了

图片.png
图片.png

关注 2 回答 1

认证与成就

  • 获得 12 次点赞
  • 获得 35 枚徽章 获得 1 枚金徽章, 获得 10 枚银徽章, 获得 24 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2016-10-26
个人主页被 1.1k 人浏览