Golang 常量

正如 常量 这个名字所暗示的,它意味着固定。在编程语言中也是如此,也就是说,一旦定义了常量的值,就不能再进行修改。常量的基本数据类型可以是整数常量、浮动常量、字符常量或字符串字面。

如何声明: 常量的声明方式与变量类似,但使用const关键字作为前缀来声明一个具有特定类型的常量。它不能用”: = “语法来声明。

例子

package main
 
import "fmt"
 
const PI = 3.14
 
func main()
{
    const GFG = "GeeksforGeeks"
    fmt.Println("Hello", GFG)
 
    fmt.Println("Happy", PI, "Day")
 
    const Correct= true
    fmt.Println("Go rules?", Correct)
}

输出

Hello GeeksforGeeks
Happy 3.14 Day
Go rules? true

非类型和类型的数字常量:
类型的常量的工作方式类似于不可变的变量,只能与相同的类型相互操作,非类型的常量的工作方式类似于字面意思,可以与类似的类型相互操作。在Go中,常量可以带或不带类型来声明。下面是一个例子,显示了有类型和无类型的数字常量,这些常量都是有名字和无名字的。

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

以下是Go语言中的常数列表

  • 数字常数(整数常数、浮点数、复数常数)
  • 字符串常数
  • 布尔常数
1e6*time.Second*math.Exp(1)1 <<('\t'+2.0)

数值常量可以有3种

  1. 整数
  2. 浮点
  3. 复数的

整数常 量。

  • 前缀指定基数或弧度。十六进制为0x或0X,八进制为0,十进制为无。
  • 一个整数常量也可以有一个 后缀 ,是U(大写)和L(小写)的组合,分别代表无符号和长符号。
  • 它可以是一个十进制、八进制或十六进制的常数。
  • 一个int最多能存储一个64位的整数,有时甚至更少。

以下是一些整数常数的例子。

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */
212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */
COMPLEX*8
(0.0, 0.0) (-123.456E+30, 987.654E-29)

浮动类型常 数。

  • 一个浮动类型的常数有一个 整数部分,一个小数点,一个小数部分,和一个指数部分。
  • 可以用小数形式或指数形式表示为浮动常数。
  • 使用十进制形式表示时,它必须包括小数点,指数,或两者。
  • 而当使用 指数 形式表示时,它必须包括整数部分,小数部分,或两者。

下面是浮动类型常量的例子。

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

字符串

  • Go支持两种类型的字符串文字,即””(双引号样式)和”(反引号)。
  • 字符串可以用 ++= 运算符 连接起来
  • 字符串包含与字符字面意义相似的字符:普通字符、转义序列和通用字符。而这是属于无类型的。
  • 字符串类型的零值是空白字符串,可以用” “” 在字面上表示。
  • 字符串类型都可以通过使用 ==, !=, 和(相同类型的比较)等操作符来进行比较。

语法

type _string struct {
    elements *byte // underlying bytes
    len      int   // number of bytes
}

显示字符串字面的例子

"hello, geeksforgeeks" 

"hello, \ 

geeksforgeeks" 

"hello, " "geeks" "forgeeks" 

在这里,上述三条语句都是类似的,也就是说,它们没有任何特定的类型。

例子

package main
 
import "fmt"
 
func main()
{
    const A = "GFG"
    var B = "GeeksforGeeks"
     
    // Concat strings.
    var helloWorld = A+ " " + B
    helloWorld += "!"
    fmt.Println(helloWorld)
     
    // Compare strings.
    fmt.Println(A == "GFG")  
    fmt.Println(B < A)
}

输出

GFG GeeksforGeeks!
true
false

布尔常量: 布尔常量类似于字符串常量。它适用与字符串常量相同的规则。不同的是,它有两个未定型的常量true和false。

package main
 
import "fmt"
 
const Pi = 3.14
 
func main()
{
    const trueConst = true
     
    // Type definition using type keyword
    type myBool bool   
    var defaultBool = trueConst // allowed
    var customBool myBool = trueConst // allowed
     
    //  defaultBool = customBool // not allowed
    fmt.Println(defaultBool)
    fmt.Println(customBool)  
}

输出

true
true

Go中的常数: Go有字符、字符串、布尔值和数值的常数。Const声明的是一个常量值。Const语句可以出现在有var的地方,因此执行算术运算时没有任何固定精度。

// Const demonstration using go.
package main
 
import (
    "fmt"
    "math"
)
 
const s string = "GeeksForGeeks"
 
func main() {
    fmt.Println(s)
 
    const n = 5
 
    const d = 3e10 / n
    fmt.Println(d)
 
    fmt.Println(int64(d))
 
    fmt.Println(math.Sin(n))
}

输出

GeeksForGeeks
6e+09
6000000000
-0.9589242746631385