func main() {
url := "ziyuan.work"
for i, v := range url {
fmt.Println(i, v)
}
}
//output:
//0 122
//1 105
//2 121
//3 117
//4 97
//5 110
//6 46
//7 119
//8 111
//9 114
//10 107
range map：
func main() {
userList := make(map[string]string)
userList["url"] = "ziyuan.work"
for key, value := range userList {
value = "I change myself" //改变的只是提取item的值，userlist不受影响
fmt.Println(userList[key])
fmt.Println(value)
}
}
// output:
//ziyuan.work
//I change myself
range channel：
func main() {
wg := sync.WaitGroup{}
wg.Add(1)
c := make(chan int)
go func() {
defer wg.Done()
for i := 0; i < 10; i++ {
c <- i
}
}()
go func() {
wg.Wait()
close(c)
}() // 当使用range对channel操作时，会无限遍历，最终变成死锁，因此需要关闭channel
for value := range c {
log.Println(value)
}
}
//output:
//0
//1
//2
//3
//4
//5
//6
//7
//8
//9
由于完整的128位UUID在BLE链路层中会占用较大的数据负载空间，BLE规范引入了两种压缩形式的UUID：16位UUID和32位UUID。这些缩短形式仅适用于由蓝牙SIG定义和分配的标准UUID，用于标识标准服务、特征及相关类型。缩短形式的UUID可通过嵌入至蓝牙基础UUID（Bluetooth Base UUID）中恢复为完整的128位UUID，其格式如下：
为了算法的简单性和实际实现，只考虑 4 个变量，一个大质数 P 和 G（P 的元根）和两个私钥值 a 和 b。 P和G都是公开可用的数字。用户（比如 Alice 和 Bob）选择私有值 a 和 b，然后生成密钥并公开交换。对方收到密钥并生成一个密钥，之后他们使用相同的密钥进行加密。
D-H算法示例代码（Go）：
// 实现 a^b mod P
func power(a, b, p int) int {
if b == 1 {
return a
} else {
pow := int(math.Pow(float64(a), float64(b)))
return pow % p
}
}
func main() {
var P int // public key P （大质数）：用作模运算的基数，限制计算范围，防止数值过大
var G int // public key G （原根）：是一个生成元，它的不同指数幂可以生成不同的数，确保密钥交换的安全性
P, G = 21, 9
var a int // a's private key
var b int // b's private key
a, b = 4, 5
var x int
var y int
x = power(G, a, P)
y = power(G, b, P)
fmt.Println("x,y", x, y)
ka := power(y, a, P) // secret key for a
kb := power(x, b, P) // secret key for b
fmt.Println("ka,kb", ka, kb)
}
代码解释：
第 1 步：A 和 B 获取公共号码 P = 23，G = 9 第 2 步：A 选择了一个私钥 a = 4 和 B 选择了一个私有密钥 b = 5 第 3 步：A 和 B 计算公共值 A： x =（9^4 mod 23） = （6561 mod 23） = 6 B： y = （9^3 mod 23） = （729 mod 23） = 16 第 4 步：A和B交换公共号码 第 5 步：A收到公钥y =16和B收到公钥 x = 6 步骤 6：A和B计算对称密钥 A：ka = y^a mod p = 65536 mod 23 = 9 B： kb = x^b mod p = 216 mod 23 = 9 第 7 步：9 是共享密钥。
