码迷,mamicode.com
首页 > Web开发 > 详细

<html>

时间:2017-08-20 19:46:07      阅读:215      评论:0      收藏:0      [点我收藏+]

标签:action   mod   lin   隐藏   text   tor   粉丝   数据   可见   

赋值(Assignment)

变量的值能够通过赋值操作符 = 来更新, v = 10。

x = 1                       // 具名变量x
*p = true                   // 指针变量
person.name = "bob"         // 结构体struct的字段
count[x] = count[x] * scale // 数组、切片或者map的某个元素

算数操作符和位操作符都有相应的一元操作符形式。 v = v + x 等价于 v += x。比如:
count[x] *= scale
这样的缩略形式能省去不少反复的工作,同一时候数字变量还能通过++递增或者--递减:
v := 1
v++    // same as v = v + 1; v becomes 2
v--    // same as v = v - 1; v becomes 1 again

1.元组(tuple) 赋值
元组赋值同意一次性给多个变量赋值。= 右边的表达式会在左边的变量被更新之前先求值,当=左右两边都有相同的变量时,这样的求值方式会非常实用,比如交换两个变量的值:
x, y = y, x

a[i], a[j] = a[j], a[i]
再比方计算两个数的最大公约数(GCD):
func gcd(x, y int) int {
    for y != 0 {
        x, y = y, x%y
    }
    return x
}
或者计算斐波那契数列第N个值:
func fib(n int) int {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        x, y = y, x+y
    }
    return x
}

元组赋值也能够把一些零散的赋值组合起来:
i, j, k = 2, 3, 5

   可是假设表达式较为复杂时,应该尽量避免元组赋值,分开赋值的可读性会更好。

    一些特定的表达式。比如函数调用有多个返回值,这样的情况下 = 左边必须有相应数量的变量来进行赋值:

f, err = os.Open("foo.txt")  // 函数调用有两个返回值

非常多时候,函数会利用这样的多返回值特性来额外返回一个值,这个值会说明函数的调用是否成功(可能是一个error类型变量err,或者bool类型变量ok)。在map中查找某个值,类型断言。从channel中接收值等等都会有两个返回值。当中第二个值就是一个bool类型:   

v, ok = m[key]             // map lookup
v, ok = x.(T)              // type assertion
v, ok = <-ch               // channel receive

Go语言还支持匿名变量 (用过函数式语言的读者应该了解这样的机制),我们能够把不想要的值赋给空白标示符(=左边的变量数目和右边的值数目必须相同):

_, err = io.Copy(dst, src) // 仅仅关心Copy的成功与否,不关心详细Copy的字节数,因此丢弃第一个值
_, ok = x.(T)              // 仅仅关心类型断言的成功与否。不关心x的详细值,因此丢弃第一个值

   2.可赋值性

上面的赋值语句是一种显式赋值。可是某些情况下,会发生隐式赋值:在函数调用中,隐式赋值给函数參数;函数返回时。隐式赋值给return的操作数;还有相似以下的组合类型:

medals := []string{"gold", "silver", "bronze"}
这里就是隐式赋值,等价的显式形式是这样的:
medals[0] = "gold"
medals[1] = "silver"
medals[2] = "bronze"

相同的还有map、channel类型等,都支持这样的隐式赋值。

不管是用显式赋值或隐式赋值,仅仅要 = 左右两边有相同的类型就可以。

针对不同类型的详细赋值规则会在兴许章节详细解说。对于我们眼下已经讨论过的那些类型,规则是非常easy的:类型必须准确匹配(因此Go是强类型的静态语言)。nil能够被赋值给interface或者其他引用类型。

常量(constant)赋值在类型转换时非常有灵活性。能够避免大多数显式类型转换:

	const x = 112
	var v float64 = x  
	fmt.Println(v) //output:112
两个变量是否能用 == 或 != 比較取决于可赋值性,a == b 仅仅有在a = b可行时才干推断。

类型声明

变量的类型定义了变量的一些个性化属性。比如变量占领的内存大小、在内存中的排列,变量内部的组织形式,变量支持的操作。变量的行为method等。

在实际项目中。非常多自己定义类型都有相同的底层类型。比如:int能够是循环的索引,时间戳。文件描写叙述符或者一个月份。float64类型能够是车辆行驶速度,温度。

使用type就能够声明具名类型,这样就能够在底层类型之上构建自己的须要的时间戳。文件描写叙述符等类型。

type name underlying-type
具名类型声明一般都发生在package级别,因此该类型是包内可见的,假设类型是导出的(首字母大写)。那么就是全局可见的。为了解释类型声明,这里把不同的温度计量单位设置为不同的类型:
package tempconv

import "fmt"

type Celsius float64
type Fahrenheit float64

const (
    AbsoluteZeroC Celsius = -273.15
    FreezingC     Celsius = 0
    BoilingC      Celsius = 100
)

func CToF(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) }

func FToC(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) }
上面定义了两个类型Celsius(摄氏度)和Fahrenheit(华氏度),作为温度的两种不同单位。

即使两个类型的底层类型是相同的float64。可是它们是全然不同的类型,所以它们彼此之间不能比較,也不能在算术表达式中结合使用,这样的规则能够避免错误的使用两种不同的温度单位,由于两个温度单位的类型是不同的,CToF和FToC返回的两个值也是全然不同的。



对于每一个类型T,都有一个相应的类型转换T(x),能够把x转换为T类型。

当且仅当两个类型具有相同的底层类型时。才干进行类型转换,比如上文中的Celsius和Fahrenheit。或者两个类型都是指针类型,指向的是同一个底层类型。

数值类型之间、string和[]byte之间都能够进行转换,这些转换可能会改变值的表现形式。

比如。将浮点数转化为整数会截取掉小树部分;将string转化为[]byte切片会分配内存空间创建string的一份拷贝(内存拷贝往往是性能瓶颈之中的一个)。总之类型转换是编译期完毕的。在执行期是不会失败的。

具名类型的底层类型决定了它的结构和表现形式。也决定了它支持的基本操作(能够理解为继承自底层类型),就好像直接使用底层类型一样。因此对于Celsius和Fahrenheit来说,float64支持的算术操作。它们都支持:

fmt.Printf("%g\n", BoilingC - FreezingC) // "100" °C
boilingF := CToF(BoilingC)
fmt.Printf("%g\n", boilingF - CToF(FreezingC)) // "180" °F
fmt.Printf("%g\n", boilingF - FreezingC)       // compile error: type mismatch
再比方:
type temp int
func main() {	
	var x1 temp = 1
	var x2 temp = 2
	fmt.Println(x1 + x2)//output:3

}

假设两个值有相同的具名类型。那么就能够用比較操作符==和<进行比較;或者两个值,一个是具名类型,一个是具名类型的底层类型。也能够进行比較。可是两个不同的具名类型是不能够直接比較的:

var c Celsius
var f Fahrenheit
fmt.Println(c == 0)          // "true"
fmt.Println(f >= 0)          // "true"
fmt.Println(c == f)          // compile error: type mismatch
fmt.Println(c == Celsius(f)) // "true"!

我们都知道浮点数是不精确的表达形式,因此两个浮点数之间的比較是须要格外小心的。这里注意最后一个类型转换后浮点数之间的比較。Celsius(f)没有改变f的值,是由于c和f两个都是初始化为0,所以能够放心比較。


假设在项目中有些地方须要反复的去写一个复杂类型时,那么使用具名变量能够带来极大的便利。


我们还能够为具名类型定义特有的行为。这些行为就是Go语言中的类型方法(method),在兴许章节我们还会详细解说。

以下的代码定义了Celsuis类型的一个methond:String,

func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) }

非常多自己定义类型都会定义一个String method,由于在调用fmt包的函数去打印该类型时,String会控制该类型的打印方式(这里事实上是实现了Stringer这个接口,和其他OO语言不同,Go语言的接口实现是隐式的):
c := FToC(212.0)
fmt.Println(c.String()) // "100°C"
fmt.Printf("%v\n", c)   // "100°C"; no need to call String explicitly
fmt.Printf("%s\n", c)   // "100°C"
fmt.Println(c)          // "100°C"
fmt.Printf("%g\n", c)   // "100"; does not call String
fmt.Println(float64(c)) // "100"; does not call String



欢迎大家增加Go语言核心技术QQ群894864,里面热心大神非常多哦。

版权声明:本文为Sunface原创文章。请任意转载并注明出处。同一时候欢迎大家增加Golang隐修会,QQ群894864,大神非常多。

举报

相关文章推荐

对个帖子的总结:严重声明:C语言中不存在数组的类型。它不过一个概念!

http://bbs3.chinaunix.net/viewthread.php?tid=1631299这篇文章讲到了C语言指针的理解。楼主尽管理解了指针,可是说话有点偏激。观点不全然正确。 C语言中不仅不存在数组类型,也不存在char, short, int, long, float, double等等这些类型,非要说C存在一种类型,那也能够说仅仅有一种类型:内存段。何为内存段?就是一块内存。临时称为raw_piece.<b

Go语言核心之美 1.1-命名篇

一.命名篇 1.Go的函数、变量、常量、自己定义类型、包(Package)的命名方式遵循下面规则: 1)首字符能够是随意的Unicode字符或者下划线 2)剩余字符能够是Unicode字符、下划线、...
技术分享

欢迎关注CSDN程序人生公众号

关注程序猿生活。汇聚开发轶事。

Go语言的复合数据类型struct,array。slice,map

1、结构体 struct 定义格式: type 结构体名称 struct { 属性1 类型 属性2 类型 ... } 结构体的初始化能够使用new关键词和var关键词。不同的是假设使用new,则返回类型是一个指针,使用var,则是结构体自身。 type User struct { name

HIBERNATE - 符合Java习惯的关系数据库持久化

Hibernate參考文档3.1.2文件夹前言 1. 翻译说明 2. 版权声明1. Hibernate入门 1.1. 前言 1.2. 第一部分 - 第一个Hibernate应用程序 1.2.1. 第一个...
  • 微博
    微信
    QQ
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多仅仅同意输入30个字)

技术分享

<html>

标签:action   mod   lin   隐藏   text   tor   粉丝   数据   可见   

原文地址:http://www.cnblogs.com/yxysuanfa/p/7400922.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
分享档案
周排行
mamicode.com排行更多图片
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!