精华内容
下载资源
问答
  • Golang的变量常量及基本类型

    万次阅读 2016-02-01 19:04:53
    Go语言的变量声明方式与C和C++语言明显的不同。对于纯粹的变量声明, Go语言引入了 关键字var,而类型信息放在变量名之后,示例如下:1.1变量的声明var v1 int var v2 string var v3 [10]int // 数组 var v4 []...

    1,变量

    变量的声明:
    Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明, Go语言引入了
    关键字var,而类型信息放在变量名之后,示例如下:

    1.1变量的声明

    var v1 int
    var v2 string
    var v3 [10]int // 数组
    var v4 []int // 数组切片
    var v5 struct {
    f int
    }
    var v6 *int // 指针
    var v7 map[string]int // map, key为string类型, value为int类型
    var v8 func(a int) int

    变量声明语句不需要使用分号作为结束符。与C语言相比, Go语言摒弃了语句必须以分号作
    为语句结束标记的习惯。
    var关键字的另一种用法是可以将若干个需要声明的变量放置在一起,免得程序员需要重复
    写var关键字,如下所示:

    var (
    v1 int
    v2 string
    )

    1.2变量的初始化

    对于声明变量时需要进行初始化的场景, var关键字可以保留,但不再是必要的元素,如下
    所示:

    var v1 int = 10 // 正确的使用方式1
    var v2 = 10 // 正确的使用方式2,编译器可以自动推导出v2的类型
    v3 := 10 // 正确的使用方式3,编译器可以自动推导出v3的类型

    以上三种用法的效果是完全一样的。与第一种用法相比,第三种用法需要输入的字符数大大
    减少,是懒程序员和聪明程序员的最佳选择。这里Go语言也引入了另一个C和C++中没有的符号
    (冒号和等号的组合:=),用于明确表达同时进行变量声明和初始化的工作。
    指定类型已不再是必需的, Go编译器可以从初始化表达式的右值推导出该变量应该声明为
    哪种类型,这让Go语言看起来有点像动态类型语言,尽管Go语言实际上是不折不扣的强类型语
    言(静态类型语言)。
    当然,出现在:=左侧的变量不应该是已经被声明过的,否则会导致编译错误,比如下面这个
    写法:
    var i int
    i := 2
    会导致类似如下的编译错误:
    no new variables on left side of :=
    :=左侧的变量必须是没有声明过,不然就会报错

    1.3 变量赋值

    在Go语法中,变量初始化和变量赋值是两个不同的概念。下面为声明一个变量之后的赋值
    过程:
    var v10 int
    v10 = 123
    Go语言的变量赋值与多数语言一致,但Go语言中提供了C/C++程序员期盼多年的多重赋值功
    能,比如下面这个交换i和j变量的语句:
    i, j = j, i
    在不支持多重赋值的语言中,交互两个变量的内容需要引入一个中间变量:
    t = i; i = j; j = t;
    多重赋值的特性在Go语言库的实现中也被使用得相当充分,在介绍函数的多重返回值时,
    将对其进行更加深入的介绍。总而言之,多重赋值功能让Go语言与C/C++语言相比可以非常明显
    地减少代码行数。多重赋值细节和原理参照官方文档golang官网

    1.4变量匿名

    我们在使用传统的强类型语言编程时,经常会出现这种情况,即在调用函数时为了获取一个
    值,却因为该函数返回多个值而不得不定义一堆没用的变量。在Go中这种情况可以通过结合使
    用多重返回和匿名变量来避免这种丑陋的写法,让代码看起来更加优雅。
    假 设 GetName() 函 数 的 定 义 如 下 , 它 返 回 3 个 值 , 分 别 为firstName 、 lastName 和
    nickName:

    func GetName() (firstName, lastName, nickName string) {
    return "May", "Chan", "Chibi Maruko"
    }

    若只想获得nickName,则函数调用语句可以用如下方式编写:

    _, _, nickName := GetName()

    这种用法可以让代码非常清晰,基本上屏蔽掉了可能混淆代码阅读者视线的内容,从而大幅
    降低沟通的复杂度和代码维护的难度

    2常量

    在Go语言中,常量是指编译期间就已知且不可改变的值。常量可以是数值类型(包括整型、
    浮点型和复数类型)、布尔类型、字符串类型等。

    2.1字面常量

    所谓字面常量(literal),是指程序中硬编码的常量,如:
    -12
    3.14159265358979323846 // 浮点类型的常量
    3.2+12i // 复数类型的常量
    true // 布尔类型的常量
    “foo” // 字符串常量
    在其他语言中,常量通常有特定的类型,比如-12在C语言中会认为是一个int类型的常量。
    如果要指定一个值为-12的long类型常量,需要写成-12l,这有点违反人们的直观感觉。 Go语言
    的字面常量更接近我们自然语言中的常量概念,它是无类型的。只要这个常量在相应类型的值域
    范围内,就可以作为该类型的常量,比如上面的常量-12,它可以赋值给int、 uint、 int32、
    int64、 float32、 float64、 complex64、 complex128等类型的变量。

    2.2常量定义

    通过const关键字,你可以给字面常量指定一个友好的名字:

    const Pi float64 = 3.14159265358979323846
    const zero = 0.0 // 无类型浮点常量
    const (
    size int64 = 1024
    eof = -1 // 无类型整型常量
    )
    const u, v float32 = 0, 3 // u = 0.0, v = 3.0,常量的多重赋值
    const a, b, c = 3, 4, "foo"
    // a = 3, b = 4, c = "foo", 无类型整型和字符串常量

    Go的常量定义可以限定常量类型,但不是必需的。如果定义常量时没有指定类型,那么它
    与字面常量一样,是无类型常量。
    常量定义的右值也可以是一个在编译期运算的常量表达式,比如
    const mask = 1 << 3
    由于常量的赋值是一个编译期行为,所以右值不能出现任何需要运行期才能得出结果的表达
    式,比如试图以如下方式定义常量就会导致编译错误:
    const Home = os.GetEnv(“HOME”)
    原因很简单, os.GetEnv()只有在运行期才能知道返回结果,在编译期并不能确定,所以
    无法作为常量定义的右值。
    2.2.3 预定义常量

    Go语言预定义了这些常量: true、 false和iota。
    iota比较特殊,可以被认为是一个可被编译器修改的常量,在每一个const关键字出现时被
    重置为0,然后在下一个const出现之前,每出现一次iota,其所代表的数字会自动增1。
    从以下的例子可以基本理解iota的用法:

    const ( // iota被重设为0
    c0 = iota // c0 == 0
    c1 = iota // c1 == 1
    c2 = iota // c2 == 2
    )
    const (
    a = 1 << iota // a == 1 (iota在每个const开头被重设为0)
    b = 1 << iota // b == 2
    c = 1 << iota // c == 4
    )
    const (
    u = iota * 42 // u == 0
    v float64 = iota * 42 // v == 42.0
    w = iota * 42 // w == 84
    )
    const x = iota // x == 0 (因为iota又被重设为0了)
    const y = iota // y == 0 (同上)
    如果两个const的赋值语句的表达式是一样的,那么可以省略后一个赋值表达式。因此,上
    面的前两个const语句可简写为:
    const ( // iota被重设为0
    c0 = iota // c0 == 0
    c1 // c1 == 1
    c2 // c2 == 2
    )
    const (
    a = 1 <<iota // a == 1 (iota在每个const开头被重设为0)
    b // b == 2
    c // c == 4
    )

    2.3枚举(Golang没有)

    枚举指一系列相关的常量,比如下面关于一个星期中每天的定义。通过上一节的例子,我们
    看到可以用在const后跟一对圆括号的方式定义一组常量,这种定义法在Go语言中通常用于定义
    枚举值。 Go语言并不支持众多其他语言明确支持的enum关键字。
    下面是一个常规的枚举表示法,其中定义了一系列整型常量:
    const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    numberOfDays // 这个常量没有导出
    )
    同Go语言的其他符号(symbol)一样,以大写字母开头的常量在包外可见。
    以上例子中numberOfDays为包内私有,其他符号则可被其他包访问。

    3类型

    Go语言内置以下这些基础类型:

    • 布尔类型: bool
    • 整型: int8、 byte、 int16、 int、 uint、 uintptr等
    • 浮点类型: float32、 float64。
    • 复数类型: complex64、 complex128。
    • 字符串: string。
    • 字符类型: rune。
    • 错误类型: error。
    • 此外, Go语言也支持以下这些复合类型:
    • 指针(pointer)
    • 数组(array)
    • 切片(slice)
    • 字典(map)
    • 通道(chan)
    • 结构体(struct)
    • 接口(interface)

    3.1布尔类型

    Go语言中的布尔类型与其他语言基本一致,关键字也为bool,可赋值为预定义的true和
    false示例代码如下:

    var v1 bool
    v1 = true
    v2 := (1 == 2) // v2也会被推导为bool类型

    布尔类型不能接受其他类型的赋值,不支持自动或强制的类型转换。以下的示例是一些错误
    的用法,会导致编译错误:

    var b bool
    b = 1 // 编译错误
    b = bool(1) // 编译错误
    以下的用法才是正确的:
    var b bool
    b = (1!=0) // 编译正确
    fmt.Println("Result:", b) // 打印结果为Result: true

    3.2,整形

    整型是所有编程语言里最基础的数据类型。 Go语言支持下表所示的这些整型类型。

    类 型 长度(字节) 值 范 围
    int8 1 128 ~ 127
    uint8(即byte) 1 0 ~ 255
    int16 2 32 768 ~ 32 767
    uint16 2 0 ~ 65 535
    int32 4 2 147 483 648 ~ 2 147 483 647
    uint32 4 0 ~ 4 294 967 295
    int64 8 9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
    uint64 8 0 ~ 18 446 744 073 709 551 615
    int 平台相关 平台相关
    uint 平台相关 平台相关
    uintptr 同指针 在32位平台下为4字节, 64位平台下为8字节

    1. 类型表示
    需要注意的是, int和int32在Go语言里被认为是两种不同的类型,编译器也不会帮你自动
    做类型转换,比如以下的例子会有编译错误:
    var value2 int32
    value1 := 64 // value1将会被自动推导为int类型
    value2 = value1 // 编译错误
    编译错误类似于:
    cannot use value1 (type int) as type int32 in assignment。
    使用强制类型转换可以解决这个编译错误:
    value2 = int32(value1) // 编译通过
    当然,开发者在做强制类型转换时,需要注意数据长度被截短而发生的数据精度损失(比如
    将浮点数强制转为整数)和值溢出(值超过转换的目标类型的值范围时)问题。
    2. 数值运算
    Go语言支持下面的常规整数运算: +、 、 *、 /和%。加减乘除就不详细解释了,需要说下的
    是, % 和在C语言中一样是求余运算,比如:
    5 % 3 // 结果为: 2
    3. 比较运算
    Go语言支持以下的几种比较运算符: >、 <、 ==、 >=、 <=和!=。这一点与大多数其他语言相
    同,与C语言完全一致。
    下面为条件判断语句的例子:
    i, j := 1, 2
    if i == j {
    fmt.Println(“i and j are equal.”)
    }
    两个不同类型的整型数不能直接比较,比如int8类型的数和int类型的数不能直接比较,但
    各种类型的整型变量都可以直接与字面常量(literal)进行比较,比如:
    var i int32
    var j int64
    i, j = 1, 2
    if i == j { // 编译错误
    fmt.Println(“i and j are equal.”)
    }
    if i == 1 || j == 2 { // 编译通过
    fmt.Println(“i and j are equal.”)
    }
    4. 位运算
    Go语言支持表2-2所示的位运算符。

    运 算 含 义 样 例
    x << y 左移 124 << 2 // 结果为496
    x >> y 右移 124 >> 2 // 结果为31
    x ^ y 异或 124 ^ 2 // 结果为126
    x & y 124 & 2 // 结果为0
    x y
    ^x 取反 ^2 // 结果为-3

    Go语言的大多数位运算符与C语言都比较类似,除了取反在C语言中是~x,而在Go语言中
    是^x。

    3.3浮点型

    浮点型用于表示包含小数点的数据,比如1.234就是一个浮点型数据。 Go语言中的浮点类型
    采用IEEE-754标准的表达方式。
    1. 浮点数表示
    Go语言定义了两个类型float32和float64,其中float32等价于C语言的float类型,
    float64等价于C语言的double类型。
    在Go语言里,定义一个浮点数变量的代码如下:
    var fvalue1 float32
    fvalue1 = 12
    fvalue2 := 12.0 // 如果不加小数点, fvalue2会被推导为整型而不是浮点型
    对于以上例子中类型被自动推导的fvalue2,需要注意的是其类型将被自动设为float64,
    而不管赋给它的数字是否是用32位长度表示的。因此,对于以上的例子,下面的赋值将导致编译
    错误:
    fvalue1 = fvalue2
    而必须使用这样的强制类型转换:
    fvalue1 = float32(fvalue2)
    2. 浮点数比较
    因为浮点数不是一种精确的表达方式,所以像整型那样直接用==来判断两个浮点数是否相等
    是不可行的,这可能会导致不稳定的结果。
    下面是一种推荐的替代方案:
    import “math”
    // p为用户自定义的比较精度,比如0.00001
    func IsEqual(f1, f2, p float64) bool {
    return math.Fdim(f1, f2) < p
    }

    3.4 复数类型

    复数实际上由两个实数(在计算机中用浮点数表示)构成,一个表示实部(real),一个表示
    虚部(imag)。如果了解了数学上的复数是怎么回事,那么Go语言的复数就非常容易理解了。
    1. 复数表示
    复数表示的示例如下:

    var value1 complex64 // 由2个float32构成的复数类型
    value1 = 3.2 + 12i
    value2 := 3.2 + 12i // value2是complex128类型
    value3 := complex(3.2, 12) // value3结果同 value2

    2. 实部与虚部
    对于一个复数z = complex(x, y),就可以通过Go语言内置函数real(z)获得该复数的实
    部,也就是x,通过imag(z)获得该复数的虚部,也就是y。
    更多关于复数的函数,请查阅math/cmplx标准库的文档。

    3.5 字符串

    在Go语言中,字符串也是一种基本类型。相比之下, C/C++语言中并不存在原生的字符串
    类型,通常使用字符数组来表示,并以字符指针来传递。
    Go语言中字符串的声明和初始化非常简单,举例如下:
    var str string // 声明一个字符串变量
    str = “Hello world” // 字符串赋值
    ch := str[0] // 取字符串的第一个字符
    fmt.Printf(“The length of \”%s\” is %d \n”, str, len(str))
    fmt.Printf(“The first character of \”%s\” is %c.\n”, str, ch)
    输出结果为:
    The length of “Hello world” is 11
    The first character of “Hello world” is H.
    字符串的内容可以用类似于数组下标的方式获取,但与数组不同,字符串的内容不能在初始
    化后被修改,比如以下的例子:
    str := “Hello world” // 字符串也支持声明时进行初始化的做法
    str[0] = ‘X’ // 编译错误
    编译器会报类似如下的错误:
    cannot assign to str[0]
    在这个例子中我们使用了一个Go语言内置的函数len()来取字符串的长度。这个函数非常有
    用,我们在实际开发过程中处理字符串、数组和切片时将会经常用到。
    本节中我们还顺便示范了Printf()函数的用法。有C语言基础的读者会发现, Printf()函
    数的用法与C语言运行库中的printf()函数如出一辙。读者在以后学习更多的Go语言特性时,
    可以配合使用Println()和Printf()来打印各种自己感兴趣的信息,从而让学习过程更加直
    观、有趣。
    Go编译器支持UTF-8的源代码文件格式。这意味着源代码中的字符串可以包含非ANSI的字
    符,比如“ Hello world. 你好,世界!”可以出现在Go代码中。但需要注意的是,如果你的Go代
    码需要包含非ANSI字符,保存源文件时请注意编码格式必须选择UTF-8。特别是在Windows下一
    般编辑器都默认存为本地编码,比如中国地区可能是GBK编码而不是UTF-8,如果没注意这点在
    编译和运行时就会出现一些意料之外的情况。
    字符串的编码转换是处理文本文档(比如TXT、 XML、 HTML等)非常常见的需求,不过可
    惜的是Go语言仅支持UTF-8和Unicode编码。对于其他编码, Go语言标准库并没有内置的编码转
    换支持。不过,所幸的是我们可以很容易基于iconv库用Cgo包装一个。这里有一个开源项目:
    https://github.com/xushiwei/go-iconv
    1. 字符串操作
    平时常用的字符串操作如表所示。

    运 算 含 义 样 例
    x + y 字符串连接 “Hello” + “123” // 结果为Hello123
    len(s) 字符串长度 len(“Hello”) // 结果为5
    s[i] 取字符 “Hello” [1] // 结果为’e’

    更多的字符串操作,请参考标准库strings包。
    2. 字符串遍历
    Go语言支持两种方式遍历字符串。一种是以字节数组的方式遍历:
    str := “Hello,世界”
    n := len(str)
    for i := 0; i < n; i++ {
    ch := str[i] // 依据下标取字符串中的字符,类型为byte
    fmt.Println(i, ch)
    }
    这个例子的输出结果为:

    72
    101
    108
    108
    111
    44
    32
    228
    184
    150
    231
    149
    140

    可以看出,这个字符串长度为13。尽管从直观上来说,这个字符串应该只有9个字符。这是
    因为每个中文字符在UTF-8中占3个字节,而不是1个字节。
    另一种是以Unicode字符遍历:
    str := “Hello,世界”
    for i, ch := range str {
    fmt.Println(i, ch)//ch的类型为rune
    }
    输出结果为:
    0 72
    1 101
    2 108
    3 108
    4 111
    5 44
    6 32
    7 19990
    10 30028
    以Unicode字符方式遍历时,每个字符的类型是rune(早期的Go语言用int类型表示Unicode
    字符),而不是byte。

    3.6 字符类型

    在Go语言中支持两个字符类型,一个是byte(实际上是uint8的别名),代表UTF-8字符串
    的单个字节的值;另一个是rune,代表单个Unicode字符。
    关于rune相关的操作,可查阅Go标准库的unicode包。另外unicode/utf8包也提供了
    UTF8和Unicode之间的转换。
    出于简化语言的考虑, Go语言的多数API都假设字符串为UTF-8编码。尽管Unicode字符在标
    准库中有支持,但实际上较少使用。

    3.7 数组

    数组是Go语言编程中最常用的数据结构之一。顾名思义,数组就是指一系列同一类型数据
    的集合。数组中包含的每个数据被称为数组元素(element),一个数组包含的元素个数被称为数
    组的长度。
    以下为一些常规的数组声明方法:
    [32]byte // 长度为32的数组,每个元素为一个字节
    [2*N] struct { x, y int32 } // 复杂类型数组
    [1000]*float64 // 指针数组
    [3][5]int // 二维数组
    [2][2][2]float64 // 等同于2
    从以上类型也可以看出,数组可以是多维的,比如[3][5]int就表达了一个3行5列的二维整
    型数组,总共可以存放15个整型元素。
    在Go语言中,数组长度在定义后就不可更改,在声明时长度可以为一个常量或者一个常量
    表达式(常量表达式是指在编译期即可计算结果的表达式)。数组的长度是该数组类型的一个内
    置常量,可以用Go语言的内置函数len()来获取。下面是一个获取数组arr元素个数的写法:
    arrLength := len(arr)
    元素访问
    可以使用数组下标来访问数组中的元素。与C语言相同,数组下标从0开始, len(array)-1
    则表示最后一个元素的下标。下面的示例遍历整型数组并逐个打印元素内容:
    for i := 0; i < len(array); i++ {
    fmt.Println(“Element”, i, “of array is”, array[i])
    }
    Go语言还提供了一个关键字range,用于便捷地遍历容器中的元素。当然,数组也是range
    的支持范围。上面的遍历过程可以简化为如下的写法:
    for i, v := range array {
    fmt.Println(“Array element[“, i, “]=”, v)
    }
    在上面的例子里可以看到, range具有两个返回值,第一个返回值是元素的数组下标,第二
    个返回值是元素的值。
    - 值类型
    需要特别注意的是,在Go语言中数组是一个值类型(value type)。所有的值类型变量在赋值
    和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型,则在函数调用时该
    参数将发生数据复制。因此,在函数体中无法修改传入的数组的内容,因为函数内操作的只是所
    传入数组的一个副本。
    下面用例子来说明这一特点:
    package main
    import “fmt”
    func modify(array [10]int) {
    array[0] = 10 // 试图修改数组的第一个元素
    fmt.Println(“In modify(), array values:”, array)
    }
    func main() {
    array := [5]int{1,2,3,4,5} // 定义并初始化一个数组
    modify(array) // 传递给一个函数,并试图在函数体内修改这个数组内容
    fmt.Println(“In main(), array values:”, array)
    }
    该程序的执行结果为:
    In modify(), array values: [10 2 3 4 5]
    In main(), array values: [1 2 3 4 5]
    从执行结果可以看出, 函数modify()内操作的那个数组跟main()中传入的数组是两个不同的实
    例。那么,如何才能在函数内操作外部的数据结构呢?我们将在2.3.6节中详细介绍如何用数组切
    片功能来达成这个目标。

    3.8 数组切片

    在前一节里我们已经提过数组的特点:数组的长度在定义之后无法再次修改;数组是值类型,
    每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。
    不用失望, Go语言提供了数组切片(slice)这个非常酷的功能来弥补数组的不足。
    初看起来,数组切片就像一个指向数组的指针,实际上它拥有自己的数据结构,而不仅仅是
    个指针。数组切片的数据结构可以抽象为以下3个变量:
    - 一个指向原生数组的指针;
    - 数组切片中的元素个数;
    - 数组切片已分配的存储空间。
    从底层实现的角度来看,数组切片实际上仍然使用数组来管理元素,因此它们之间的关系让
    C++程序员们很容易联想起STL中std::vector和数组的关系。基于数组,数组切片添加了一系
    列管理功能,可以随时动态扩充存放空间,并且可以被随意传递而不会导致所管理的元素被重复
    复制。
    1. 创建数组切片
    创建数组切片的方法主要有两种——基于数组和直接创建,下面我们来简要介绍一下这两种
    方法。
    基于数组
    数组切片可以基于一个已存在的数组创建。数组切片可以只使用数组的一部分元素或者整个
    数组来创建,甚至可以创建一个比所基于的数组还要大的数组切片。代码清单2-1演示了如何基
    于一个数组的前5个元素创建一个数组切片。
    slice.go

    package main
    import "fmt"
    func main() {
    // 先定义一个数组
    var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    // 基于数组创建一个数组切片
    var mySlice []int = myArray[:5]
    fmt.Println("Elements of myArray: ")
    for _, v := range myArray {
    fmt.Print(v, " ")
    }
    fmt.Println("\nElements of mySlice: ")
    for _, v := range mySlice {
    fmt.Print(v, " ")
    }
    fmt.Println()
    }
    运行结果为:
    Elements of myArray:
    1 2 3 4 5 6 7 8 9 10
    Elements of mySlice:
    1 2 3 4 5

    看官大人已经注意到,Go语言支持用myArray[first:last]这样的方式来基于数组生成一
    个数组切片,而且这个用法还很灵活,比如下面几种都是合法的。
    基于myArray的所有元素创建数组切片:
    mySlice = myArray[:]
    基于myArray的前5个元素创建数组切片:
    mySlice = myArray[:5]
    基于从第5个元素开始的所有元素创建数组切片:
    mySlice = myArray[5:] 直接创建
    并非一定要事先准备一个数组才能创建数组切片。 Go语言提供的内置函数make()可以用于
    灵活地创建数组切片。下面的例子示范了直接创建数组切片的各种方法。
    创建一个初始元素个数为5的数组切片,元素初始值为0:
    mySlice1 := make([]int, 5)
    创建一个初始元素个数为5的数组切片,元素初始值为0,并预留10个元素的存储空间:
    mySlice2 := make([]int, 5, 10)
    直接创建并初始化包含5个元素的数组切片:
    mySlice3 := []int{1, 2, 3, 4, 5}
    当然,事实上还会有一个匿名数组被创建出来,只是不需要我们来操心而已。
    2. 元素遍历
    操作数组元素的所有方法都适用于数组切片,比如数组切片也可以按下标读写元素,用len()
    函数获取元素个数,并支持使用range关键字来快速遍历所有元素。
    传统的元素遍历方法如下:
    for i := 0; i

    3.9 map

    在C++/Java中, map一般都以库的方式提供,比如在C++中是STL的std::map<>,在C#中是
    Dictionary<>,在Java中是Hashmap<>,在这些语言中,如果要使用map,事先要引用相应的
    库。而在Go中,使用map不需要引入任何库,并且用起来也更加方便。
    map是一堆键值对的未排序集合。比如以身份证号作为唯一键来标识一个人的信息,则这个
    map可以定义为代码清单 2-3所示的方式。
    代码清单2-3 map1.go
    package main
    import “fmt”
    // PersonInfo是一个包含个人详细信息的类型
    type PersonInfo struct {
    ID string
    Name string
    Address string
    }
    func main() {
    var personDB map[string] PersonInfo
    personDB = make(map[string] PersonInfo)
    // 往这个map里插入几条数据
    personDB[“12345”] = PersonInfo{“12345”, “Tom”, “Room 203,…”}
    personDB[“1”] = PersonInfo{“1”, “Jack”, “Room 101,…”}
    // 从这个map查找键为”1234”的信息
    person, ok := personDB[“1234”]

    // ok是一个返回的bool型,返回true表示找到了对应的数据
    if ok {
    fmt.Println(“Found person”, person.Name, “with ID 1234.”)
    } else {
    fmt.Println(“Did not find person with ID 1234.”)
    }
    }
    上面这个简单的例子基本上已经覆盖了map的主要用法,下面对其中的关键点进行细述。
    1. 变量声明
    map的声明基本上没有多余的元素,比如:
    var myMap map[string] PersonInfo
    其中, myMap是声明的map变量名, string是键的类型, PersonInfo则是其中所存放的值类型。
    2. 创建
    我们可以使用Go语言内置的函数make()来创建一个新map。下面的这个例子创建了一个键
    类型为string、值类型为PersonInfo的map:
    myMap = make(map[string] PersonInfo)
    也可以选择是否在创建时指定该map的初始存储能力,下面的例子创建了一个初始存储能力
    为100的map:
    myMap = make(map[string] PersonInfo, 100)
    关于存储能力的说明,可以参见2.3.6节中的内容。
    创建并初始化map的代码如下:
    myMap = map[string] PersonInfo{
    “1234”: PersonInfo{“1”, “Jack”, “Room 101,…”},
    }
    3. 元素赋值
    赋值过程非常简单明了,就是将键和值用下面的方式对应起来即可:
    myMap[“1234”] = PersonInfo{“1”, “Jack”, “Room 101,…”}
    4. 元素删除
    Go语言提供了一个内置函数delete(),用于删除容器内的元素。下面我们简单介绍一下如
    何用delete()函数删除map内的元素:
    delete(myMap, “1234”)
    上面的代码将从myMap中删除键为“ 1234”的键值对。如果“ 1234”这个键不存在,那么这个调
    用将什么都不发生,也不会有什么副作用。但是如果传入的map变量的值是nil,该调用将导致
    程序抛出异常(panic)。
    5. 元素查找
    在Go语言中, map的查找功能设计得比较精巧。而在其他语言中,我们要判断能否获取到一
    个值不是件容易的事情。判断能否从map中获取一个值的常规做法是:
    (1) 声明并初始化一个变量为空;
    (2) 试图从map中获取相应键的值到该变量中;
    (3) 判断该变量是否依旧为空,如果为空则表示map中没有包含该变量。
    这种用法比较啰唆,而且判断变量是否为空这条语句并不能真正表意(是否成功取到对应的
    值) ,从而影响代码的可读性和可维护性。有些库甚至会设计为因为一个键不存在而抛出异常,
    让开发者用起来胆战心惊,不得不一层层嵌套try-catch语句,这更是不人性化的设计。在Go
    语言中,要从map中查找一个特定的键,可以通过下面的代码来实现:
    value, ok := myMap[“1234”]
    if ok { // 找到了
    // 处理找到的value
    }
    判断是否成功找到特定的键,不需要检查取到的值是否为nil,只需查看第二个返回值ok,
    这让表意清晰很多。配合:=操作符,让你的代码没有多余成分,看起来非常清晰易懂。

    展开全文
  • 在Java中,我们需要标识代码的很多元素,包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符,一个正确的标识符需要遵循以下规则: 1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,...

    1 JAVA语法基础

    1.1 标识符

    标识符可以简单的理解成一个名字。
    在Java中,我们需要标识代码的很多元素,包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符,一个正确的标识符需要遵循以下规则:

    1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,但不能包含 @、%、空格等其它特殊字符
    2. 不能以数字开头。如:123name 就是不合法
    3. 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
    4. 标识符的命名最好能反映出其作用,做到见名知意。
    5. 标识符不能是Java的关键字

    1.2 关键字

    在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。
    这50个单词都是全小写,其中有两个保留字:const和goto。
    注意,关键字不能被用作标识符!
    在这里插入图片描述
    需要注意的是,除了上述的50个关键字以外,true,false,null也不可以被用作标识符~

    1.3 注释

    几乎所有编程语言都允许程序员在代码中输入注释,因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
    注释的真正作用是: 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息, 提高代码的可读性,方便后期的维护与复用。Java的注释有3种:

    1. 单行注释: 注释单行内容.

    格式: 每行都以”//”开头.
    快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释

    2. 多行注释:注释多行内容,虽然叫多行注释,也可注释单行内容.

    格式: 以” /* ”开头, 以” * / ”结束.
    快捷方式: Ctrl+shift+/ 添加注释, Ctrl+shift+\ 取消注释, 也可以输入”/*”之后按回车添加注释

    3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.

    格式: 以” /** ”开头。 以” */ ”结尾.
    快捷方式: 输入“/**” 之后按回车添加注释

    1.4 变量

    在JAVA中,我们需要记录一些数据,但这些数据的值是不固定的,总在变,我们可以把这些数据理解为变量。
    我们通过三个元素来描述变量:变量类型 变量名以及变量值。
    int age = 18; //声明int类型的变量并赋值
    String tel ; //声明String类型的变量

    注意:

    1. 变量名必须是一个有效的标识符
    2. 变量名不可以使用java关键字
    3. 变量名不能重复

    1.5 常量

    在程序运行过程中,值一直不会改变的量成为常量。(后续会进一步学习,略…)

    2 数据类型

    2.1 基本类型介绍(八种)

    变量就是申请内存来存储值。也就是说,当创建变量的时候,需要在内存中申请空间。
    java是一个强类型的语言,会把日常见到的数据,分成好多类型.
    内存管理系统根据变量类型来分配存储空间,分配的空间只能用来储存该类型数据。
    常用的转换关系:
    位 bit,来自英文bit,音译为“比特”,表示二进制位。
    1 Byte = 8 Bits (1字节 = 8位)
    1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB八大基本类型速查表

    2.2 练习: 输入个人信息

    创建包: cn.tedu.basic
    创建类: TestInfo.java
    需求: 在控制台打印: java架构师今年20岁,月薪100000.99,感慨java是世界上最好的语言

    package cn.tedu.basic;
    /**
     * 	本类用于测试在控制台打印个人信息
     * 	需求: 在控制台打印: 
     *  java架构师XXX今年X岁,月薪XXX,感慨java是世界上最好的语言
     *  @author XYCheng
     */
    public class TestInfo {
    	//Alt+/ 提示补全代码  Ctrl+s保存代码  Ctrl+F11执行代码
    	public static void main(String[] args) {
    		/**1.在我们的程序当中{} [] () "" 都是成对出现的,而且都是英文符号*/
    		/**2. 一串数据,在java里是字符串类型—String  
    		 * 字符串类型的数据,要被一对双引号 引起来*/
    		System.out.println("欢迎来到Java世界,可爱的程序猿们");
    		
    		/**3.定义变量的规则:数据类型 数据名 数据值 */
    		String name="陈子枢";
    		int age = 18;
    		double salary = 100000.99;
    		
    		/**4.把静态数据与动态数据分开,通过+实现动态数据的动态拼接*/
    		System.out.println("我叫"+name);
    		/**5.如果是在中间拼接用""+变量+""的格式*/
    		System.out.println("java架构师"+name+",今年"+age+"岁,月薪"+salary+",感慨java是世界上最好的语言");
    	}
    }
    

    2.3 练习:查看基本类型的最大值与最小值

    创建包: cn.tedu.basic
    创建类: TestTypeScope.java

    package cn.tedu.basic;
    /**
     * 本类用于查看基本类型的最大值与最小值
     * Ctrl+Alt+向下键 快速向下复制一行
     */
    public class TestTypeScope {
    	//必须要写入口函数,否则代码无法执行,因为没有入口
    	public static void main(String[] args) {//入口函数
    		//进行整形类型的测试 byte1 short2 int4 long8
    		//1.定义变量,用变量分别保存最大值与最小值
    		//定义变量 数据类型 变量名 变量值 Ctrl+Alt+向下键 快速向下复制一行 换位置:Alt+方向键
    		/**JAVA提供了对应的基本类型的工具箱*/
    		byte byteMax = Byte.MAX_VALUE;
    		byte byteMin = Byte.MIN_VALUE;
    		System.out.println("byte类型的最大值是:"+byteMax);//127
    		System.out.println("byte类型的最小值是:"+byteMin);//-128
    	
    		short shortMax = Short.MAX_VALUE;
    		short shortMin = Short.MIN_VALUE;
    		System.out.println("short类型的最大值是:"+shortMax);//32767
    		System.out.println("short类型的最小值是:"+shortMin);//-32768
    		
    		int intMax = Integer.MAX_VALUE;
    		int intMin = Integer.MIN_VALUE;
    		System.out.println("int类型的最大值是:"+intMax);//2147483647
    		System.out.println("int类型的最小值是:"+intMin);//-2147483648
    		
    		long longMax = Long.MAX_VALUE;
    		long longMin = Long.MIN_VALUE;
    		System.out.println("long类型的最大值是:"+longMax);//9223372036854775807
    		System.out.println("long类型的最小值是:"+longMin);//-9223372036854775808
    		
    		//浮点型测试 float double
    		//1.4E-45(1.4乘以10的负45次方)
    		float floatMax = Float.MAX_VALUE;
    		float floatMin = Float.MIN_VALUE;
    		System.out.println("float类型的最大值是:"+floatMax);//3.4028235E38
    		System.out.println("float类型的最小值是:"+floatMin);//1.4E-45
    		
    		double doubleMax = Double.MAX_VALUE;
    		double doubleMin = Double.MIN_VALUE;
    		System.out.println("double类型的最大值是:"+doubleMax);//1.7976931348623157E308
    		System.out.println("double类型的最小值是:"+doubleMin);//4.9E-324
    		
    		//布尔型boolean true真 false假
    		boolean b1 = true;
    		boolean b2 = false;
    		
    		//字符型char
    		char c1 = 'a';//可以保存一个字符
    		char c2 = 97;//可以保存一个数字
    		char c3 = '中';//可以保存一个汉字
    		//char类型可以存数字,但是在打印时,会去查ASCII码表,把数字对应的字符拿出来使用
    		//ASCII码表值规定了数组0-127对应的字符,128-65535默认按照字符?来处理
    		System.out.println(c1);//a
    		System.out.println(c2);//a
    		System.out.println(c3);//中
    	}
    }
    

    2.4 练习:求圆形的面积

    需求:求出指定半径圆的面积
    公式:圆的面积:π * r * r
    创建包: cn.tedu.basic
    创建类: TestCircleArea.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**本类用于求圆的面积*/
    public class TestCircleArea {
    	public static void main(String[] args) {
    		//公式:π*r*r
    		//1.提示用户输入要求圆的半径
    		System.out.println("请您输入要求圆的半径值:");
    		//2.接收用户输入的半径值
    		double r = new Scanner(System.in).nextDouble();
    		//3.根据半径进行计算圆的面积
    		double circleArea = 3.14*r*r;
    		//4.把圆的面积打印到控制台
    		System.out.println("当半径为"+r+"时,圆的面积为:"+circleArea);
    	}
    }
    

    2.5 练习:变量交换

    变量值交换

    需求: 接收用户输入的两个值:假设a=1,b=2,并将这两个变量的值进行互换

    创建包: cn.tedu.basic
    创建类: TestValueExchage.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**本类用于交换两个变量的值*/
    public class TestValueExchage {
    	public static void main(String[] args) {
    		//1.提示并接收用于输入的两个值
    		System.out.println("请输入a的值:");
    		int a = new Scanner(System.in).nextInt();
    		System.out.println("请输入b的值:");
    		int b = new Scanner(System.in).nextInt();
    		System.out.println("a的值:"+a);
    		System.out.println("b的值:"+b);
    		
    		//2.交换a b 两个变量的值
    		int t ;//定义用来值交换的第三方变量t
    		t = a;//把a的值交给t来保存
    		a = b;//把b的值交给a来保存
    		b = t;//把t的值嫁给b来保存
    		//3.把交换后的两个值打印在控制台
    		System.out.println("交换后,a的值为:"+a);
    		System.out.println("交换后,b的值为:"+b);
    		
    	}
    }
    

    2.6 引用类型

    引用类型是一个对象类型,值是什么呢?它的值是指向内存空间的引用,就是地址,所指向的内存中保存着变量所表示的一个值或一组值。如:类,接口,数组,后面讲。。。
    (后续会进一步学习,略…)

    3 基本类型的字面值(5条)

    3.1 整数字面值是int类型

    int x = 99999;//对,右面数据的字面值是int类型
    int x = 99999999999;//错,右面数据的字面值是int类型,但是已经超出int的取值范围。

    3.2 byte,short,char三种比int小的整数可以用范围内的值直接赋值

    byte b1=127;//对,
    byte b2=128;//错,超出byte范围

    3.3 浮点数的字面值是double类型

    double r =3.14;//对
    float r =3.14;//错,右面的数据字面值是double,float是4字节存不下double类型的数据

    3.4 字面值后缀L D F

    long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可
    float b = 3.0F;//3.0字面值是double类型,加后缀F会变成float类型
    double d = 3D;//3字面值是int类型,加后缀D,会变成double类型

    3.5 进制前缀

    0b - 标识这是2进制 ,如:0b0101
    0 - 标识这是8进制, 8进制是三位,如: 023
    0x - 标识这是16进制,如: 0x0001
    \u -标识这是char类型,属于16进制

    4 基本类型的类型转换

    箭头开始的地方是小类型,箭头指向的地方是大类型
    我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数哦
    基本类型的类型转换

    4.1 小到大(隐式转换)

    byte m = 120;
    int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
    float f = 3.2f; double d = f; -->可以执行

    4.2 大到小(显式转换)

    容量大的类型转换为容量小的类型时必须使用强制类型转换。

    int x = 999;
    byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换
    1. 转换过程中可能导致溢出或损失精度
      例如:int i =128; byte b = (byte)i; //打印的结果是-128
      因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
    2. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入
      例如:float f = 32.7f; int a2 =(int) f; //打印的结果是32
    3. 不能对boolean类型进行类型转换。

    4.3 口诀:

    小到大,直接转 大到小,强制转 浮变整,小数没

    低 ------------------------------------> 高

    byte,short,char→ int→ long→float→double

    5 运算规则(5条)

    5.1 计算结果的数据类型,与最大数据类型一致

    System.out.println(3/2);//1,int/int,得到的结果类型还是int
    System.out.println(3/2d);//1.5,int/double。得到的结果是double

    5.2 byte,short,char三种比int小的整数,运算时会先自动转换成int

    byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);
    //a+b会自动提升成int类型,右面得运算结果就是int大类型
    //给左面的byte小类型赋值,不可以,需要强转。

    5.3 整数运算溢出

    整数运算溢出

    整数运算,类似于一个钟表,转到最大时,再转会回到最小。
    计算:光速运行一年的长度是多少米?3亿m/s

    //溢出的现象:
    //因为做了大的整型数据的运算,会超出int取值范围。解决方法:把整数提升成long类型。
    System.out.println(300000000L * 60 * 60 * 24 * 365);

    5.4 浮点数运算不精确

    1-0.8 (这是一个现象,后续会学习解决方案)

    5.5 浮点数的特殊值

    Infinity 无穷大 3.14/0
    NaN not a number 0/0.0 或 0.0/0

    6 拓展 标识符命名风格

    1.【强制】标识符命名均不能以数字开头,而且下划线或美元符号开始,也不能以下划线或美元符号结束
    错误案例:1name / _ name / name_ / $ name / name $
    2.【强制】代码中的命名严禁使用拼音与英文混合的方式,更不允许直接使用中文的方式。
    说明:正确的英文拼写和语法可以让阅读者易于理解,避免歧义。
    注意,即使纯拼音命名方式也要避免采用。
    正确案例:alibaba / taobao / youku / hangzhou 等国际通用的名称,可视同英文。
    错误案例:DaZheModule [打折模块] / getPingfenByName() [评分]
    3.【强制】类名使用 UpperCamelCase 风格,即第一个单词的首字母就要大写

    展开全文
  • 八种基本类型变量

    千次阅读 2016-03-08 20:21:47
    java语言中八种基本类型变量,那么应该注意的地方有哪些 ? 1、整数型 int:计算机默认整数类型都为int,占4个字节,范围为正负21亿多,如果定义一个int类型变量超出范围会报错。double:计算机默认小数类型...

    java语言中有八种基本类型变量,那么应该注意的地方有哪些 ?

    1、整数型

    • int:计算机默认整数类型都为int,占4个字节,范围为正负21亿多,如果定义一个int类型变量超出范围会报错。
    • double:计算机默认小数类型都为double,占8个字节,当参与运算时,二进制识别不了1/10,所以会发生舍入误差,导致不精确。
    • byte、short、float、long分别占1、2、4、8个字节,除非声明该变量类型,否则所有整数类型运算默认为int类型计算。
    2、字符型

    • char:定义该变量时需要用单引号‘’引用,或者用数字,有且只有一个字符,占2个字节,在计算机中是16位无符号整数形式存储,unicode全球统一编码范围为0-65535,65--A,97--a,48--0,特殊符号需要用\转义
    3、布尔类型

    • boolean:占一个字节,赋值只能为true或false,用于条件判断。

    *注*数据类型之间转换有两大原则,小到大,需强转,强转可能发生数据溢出和精度丢失;大到小自动转

    public static void main(String[] args){
    //int a=3.124;//int类型只能取整,编译错误。
      int a=(int)3.124;//强转,精度丢失,赋值a为3
      long id=362121198809123243L;
      int id1=(int)id;//此时超出int类型范围,会溢出。
      char c='2',d='2';
      System.out.println(c+d);//此时参与运算时默认为int类型,字符'2'对应int码为50,所以输出结果为100
    
    }

    
    

    展开全文
  • JAVA语法基础之变量基本数据类型

    千次阅读 2015-11-22 18:11:32
    所有的变量一个作用域,即变量在某一区域有效。 基本变量声明方式如下: type identifier [=value]; 其中type为Java的数据类型,identifier为变量的名称,指定一个符号或一个值为初始化变量。初始化表达式...

    一、变量的概念

    变量是Java程序中的一个基本存储单元。变量是一个标识符、类型及一个可选初始值的组合定义。所有的变量都有一个作用域,即变量在某一区域有效。

    基本的变量声明方式如下:

    type identifier [=value];

    其中type为Java的数据类型,identifier为变量的名称,指定一个符号或一个值为初始化变量。初始化表达式必须产生与指定变量类型一样或兼容的值。声明指定类型的多个变量时,使用逗号将变量分开。例如以下几种方式都是正确的:

    int a;

    int b = 12;

    char c = 'c';

    int d = 5, e;

    二、基本数据类型

    在Java中共有8种基本数据类型,分别为:字节型(byte)、短整型(short)、整型(int)、长整型(long)、字符型(char)、浮点型(float)、双精度型(double)、布尔型(boolean)。这些类型可以分为4组。

    整数:包括字节型(byte)、短整型(short)、整型(int)、长整型(long)。他们都是有符号整数。

    浮点型数:包括浮点型(float)、双精度型(double)。该表有小数精度要求的数字。

    字符:包括字符型(char)。表示字符集的符号。

    布尔型:包括布尔型(boolean)。一种特殊类型,仅有两个值,分别为真和假。

    1、整数

    4种整数的取值范围如下表:

    类型名 大小/位 取值范围
    byte 8 -128~127
    short 16 -32,768~32767
    int 32 -2,147,483,648~2,147,483,647
    long 64 -9,223,372,036,854,775,808~9,223,372,036,854,775,807

    这些数据都是有符号的,所有整数变量都是无法可靠的存储其取值范围以外的数据值,选择数据类型时一定要谨慎。

    2、浮点数

    2种浮点数的取值范围如下表

    类型名 大小、位 描述 取值范围
    float 32 单精度 3.4E-038~3.4E+038
    double 64 双精度 1.7E-308~1.7E+308

    3、字符型

    char类型用来存储诸如字母、数字及其他符号之类的单一字符。字符类型只能表示单个字符,表示字符类型的值是在字符两端加上单引号,如'h'。

    Java中的常用转义字符:

    转义字符 含义
    \n 换行,将光标移至下一行开始处
    \t 水平制表符(tab键),将光标移至下一制表符位置
    \b 光标退一格,相当于backspace键
    \r 回车,将光标移至当前行的开始,不移到下一行
    \\ 反斜杠
    \' 单引号'
    \" 双引号"

    4、布尔型

    boolean型用来存储布尔值,Java中布尔值只有两个,要么是true,要么是false。

    三、变量的初始化和作用域

    1、初始化

    变量可以在声明的时候初始化,也可以在声明后,通过赋值语句对其进行初始化。初始化后的变量依然可以通过赋值语句重新赋值。

    2、作用域

    • 作用域(Scope)决定了变量可使用的范围。

    • 全局变量:变量可以在整个类中被访问。

    • 局部变量:变量只能在定义其的代码段中被访问。

    • 作用域规则:在一个代码段中定义的变量只能在该代码段或者该代码段的子代码段中可见。

    四、变量的类型转换

    1、自动类型转换(隐式转换)

    多种互相兼容的数据类型在一个表达式中进行运算时,会自动的向大范围的数据类型进行进行转换。

    发生自动类型转换的条件:

    • 两种类型彼此兼容。

    • 目标类型取值范围大于源类型。

    2.强制类型转换

    当两种类型彼此不兼容,或目标类型取值范围小于源类型时,自动转换无法执行,这事就需要强制类型转换。强制类型转换格式如下:

    目标类型 变量 = (目标类型)值

    如:

    int a = 3;

    byte b = (byte)a;

    五、常量

    常量就是程序里持续不变的值,他是不能改变的数据,利用final修饰的变量就是常量。如:

    final double PI = 3.14;

    这一篇的内容比较多,但是基本都是概念性的东西,下一篇将会介绍运算符相关的知识点。

    展开全文
  • JavaScript基本概念之变量与数据类型

    千次阅读 2016-09-30 16:44:15
    变量 变量定义 变量的作用域 全局作用域 名字空间的概念 局部作用域 常量 数据类型 基本数据类型 ...基本包装类型变量变量定义ECMAScript的变量是松散类型,也就是说可以用来保存任何类型的数据。每个变量仅仅
  • 一,cmake 变量引用的方式: ...主要隐式定义和显式定义两种,前面举了一个隐式定义的例子,就是 PROJECT 指令,他会隐式的定义_BINARY_DIR 和_SOURCE_DIR 两个变量。 显式定义的例子我们前面也提到了,使用 SET 指令,就
  • 基本数据类型变量

    千次阅读 2018-08-08 11:48:14
     程序语言最基本的特征 整型、字符型等内置类型 变量,用来为对象命名 表达式和语句,操纵上述数据类型的具体值 if等控制结构 函数,定义可供随时调用的计算单元  程序语言的扩展 自定义数据类型 封装的...
  • Shell变量基本操作与常用符号详解

    万次阅读 2020-08-12 20:20:56
    shell变量一 shell脚本创建、权限、执行1.1 shell脚本的创建1.2 赋予执行权限1.3 执行脚本二 管道符号与重定向符号2.1 管道操作2.2 重定向操作三 shell变量3.1 变量类型3.2 变量赋值注意点3.2.1 双引号(")3.2.2 单...
  • PL/SQL 变量常用数据类型

    千次阅读 2012-08-06 23:53:08
    以ORACLE8i为例,可以使用的基础数据类型有类型 子类 说 明 范 围 ORACLE限制 CHAR Character String Rowid Nchar 定长字符串     民族语言字符集 ...
  • python常用基本数据类型

    千次阅读 2018-11-29 10:15:11
    python6大数据类型,今天我们主要介绍下常用的4大数据类型。 在介绍数据类型之前,先解释下变量赋值,数据类型通常也被说成变量类型,因为在python中数据都是存储在变量当中的,这个存储过程叫变量赋值。 1...
  • python:变量与赋值 基本数据类型

    千次阅读 2015-08-03 21:20:00
    变量命名规范; 1.记住不能做什么:不能用关键字,开头不能用数字,不能用操作符。只用字母和下划线开头。 2.怎么搭配最合理:没事别乱用大写。清晰。尽量不要用拼音。用拼音的话用全称。   赋值: 1.记住动态特性。...
  • java变量的两种类型

    千次阅读 2019-01-24 16:09:59
    首先要明白为什么需要数据类型? 数据类型在计算机语言中,是对内存位置的一个抽象的表达方式。不同类型的变量在内存中分配的字节数不同...- 基本类型 int、float、double、boolean、char… 不具备对象的特性(不...
  • C语言基本数据类型之整型变量

    千次阅读 2019-07-10 15:42:30
    基本数据类型之整型常量 在c语言中,整形常量分为八进制、十六进制、和十进制三种 ⑴八进制必须以0开头,以0作为八进制数的前缀。数码取值为0-7,八进制数通常是无符号数 ⑵十六进制常整数的前缀为0X或者0x。数码...
  • 核心内容: 1. 标示符 2. 变量常用 3.局部变量和作用于 4. 基本数据类型 视频地址:iPhone开发之OC变量基本数据类型1
  • Kotlin的变量和数据类型

    千次阅读 2017-12-28 10:23:08
    为了方便新手阅读,在这里我们简单介绍下变量基本数据类型的概念,老司机跳过即可。 首先我们先来搞清楚一件事就是我们编写的程序实际上都是在处理数据。不管是视频,图片,还是文字,数字等,都是数据,只不过...
  • 八种基本数据类型变量声明

    千次阅读 2017-12-13 13:56:59
    public class Test1 { static int age=12; // String str = new String("abc"); 引用类型变量的声明 public static void main(String[] args) { // 八种基本数据类型声明变量 // 整形分为四种(byte,sh
  • 一,cmake 变量引用的方式...主要隐式定义和显式定义两种,前面举了一个隐式定义的例子,就是 PROJECT 指令,他会隐式的定义_BINARY_DIR 和_SOURCE_DIR 两个变量。 显式定义的例子我们前面也提到了,使用 SET 指令,就可以
  • 第一篇文章写完后收到了很多同学的后台留言,鼓励的,也... 第二章主要讲变量基本类型,这一章内容很多,我会分很多章节来写。数据类型是程序的基础:它告诉我们数据的意义以及我们能在数据上执行的操作。 C+...
  • 语言元素 变量类型 在程序设计中,变量是一...Python中的数据类型很多,而且也允许我们自定义新的数据类型,我们先介绍几种常用的数据类型。 整型:Python中可以处理任意大小的整数(Python 2.x中int和long...
  • 设置(主要是工作路径的设置) 搜索路径是使用Matlab时候的一个重要的东西,matlab具有大量的工具...1. 是否变量 2. 是否函数 3. 是否当前目录下的m文件 4. 是否搜索路径下其他m文件   常用的设置函数 path
  • python基础 - 03 基本数据类型变量

    千次阅读 2018-05-13 14:41:22
    基本数据类型变量基本数据类型: 整型int, 浮点型float, 字符串str, 布尔型bool, 空值None1.整型: 整数 (包括正整数, 负整数, 零) 123 -123 02.浮点型:浮点数就是小数 1.12 0.14 -1.4 3.1415926 1e10(科学计数法) ...
  • Python变量类型

    千次阅读 2016-08-12 22:41:00
    前篇文章中我们基本了解了Python环境安装以及Python编程的一些基本语法和代码规则,那么接下来我们就来讲一下Python的变量赋值以及Python中的变量类型。 什么是变量变量就是在你计算机内存上开辟的一段内存空间来...
  • 基本数据类型有哪些

    万次阅读 多人点赞 2018-02-15 11:46:55
    1)四种整数类型(byte、short、int、long): byte:8 位,用于表示最小数据单位,如文件中数据,-128~127 short:16 位,很少用,-32768 ~ 32767 int:32 位、最常用,-2^31-1~2^31 (21 亿) long:64 位、次常用 ...
  • 一.背景介绍 JavaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的语言,内置支持类型。它的解释器被称为JavaScript引擎,为浏览器的一... 二.... 2.1 JS有哪些数据类型? JavaScript语言的每一个值...
  • 数据库中的常用基本数据类型

    千次阅读 2018-03-30 18:00:40
    (1) 数字类型:整数:tinyint,smallint,mediumint,int,bigint浮点数:float,double,real,decimal。超过长度会四舍五入布尔类型可以使用tinyint(0)表示false,其余为true日期和时间:date,time,datetime,timestamp,...
  • GLSL ES要求你具体地指明变量的数据类型。我们在示例程序中用来这种方式声明变量: 如: vec4 a_Position; 我们知道,在定义如main()函数这类函数的时候,必须制定函数的返回值。同样,在进行赋值操作(=)的时候,...
  • Java中的基本类型与非基本类型

    千次阅读 2019-05-22 13:39:15
    基本类型就是那些最常用的类型,例如:boolean/char/byte/short/int/long/float/double,这些类型个特点,就是变量直接存储值。举个栗子:int num=100;,变量num中存储的值就是100。 非基本类型 那啥是非基本类型...
  • 八大常用数据类型Java编程语言是静态类型的,这意味着所有变量必须先被声明才能使用。这包括说明变量类型和名称,如您已经看到的:int gear = 1;这样做会告诉你的程序,一个名为“gear”的字段存在,保存数字数据...
  • 一,MATLAB基本操作 MATLAB中常用的标点符号 空格 数组元素分隔符 逗号 数组元素分隔符;此分隔符用于指令间的分隔 分号 不显示结果指令结束标志;区分数组的行 冒号 生成一维数值数组;用作下标...
  • MATLAB基础学习(二)-变量类型与赋值

    万次阅读 多人点赞 2018-09-11 10:06:36
    matlab解决问题的最基本思路是建立脚本文件,那么脚本文件的第一段就是定义一些变量,这和C语言等编程思想是一样的。matlab提供的变量类型很多,最基础的是三种:数值变量、符号变量、字符串,其他的类型还有cell、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 426,014
精华内容 170,405
关键字:

常用变量有哪些基本类型