Golang 基础整理 这一篇就够了

第一个golang程序

package main

import "fmt"

func main() {
    fmt.Println("hello golang")
}

基本数据类型

  1. 布尔型( true 或者 false)
  2. 数字类型( 整型 int 和 浮点型 float32、float64 )
  3. 字符串类型( 字符串就是一串固定长度的字符连接起来的字符序列 )
  4. 派生类型：
  • 指针类型（Pointer）
  • 数组类型
  • 结构化类型(struct)
  • Channel 类型
  • 函数类型
  • 切片类型
  • 接口类型（interface）
  • Map 类型

数字类型

  1. 整形
  • uint8

无符号 8 位整型 (0 到 255)

  • uint16

无符号 16 位整型 (0 到 65535)

  • uint32

无符号 32 位整型 (0 到 4294967295)

  • uint64

无符号 64 位整型 (0 到 18446744073709551615)

  • int8

有符号 8 位整型 (-128 到 127)

  • int16

有符号 16 位整型 (-32768 到 32767)

  • int32

有符号 32 位整型 (-2147483648 到 2147483647)

  • int64

有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

  1. 浮点型
  • float32

32位浮点型数

  • float64

64位浮点型数

  • complex64

32 位实数和虚数

  • complex128

64 位实数和虚数

  1. 其他数字类型
  • byte

类似 uint8

  • rune

类似 int32

  • uint

32 或 64 位

  • int

与 uint 一样大小

  • uintptr

无符号整型，用于存放一个指针

定义变量

// 声明一个变量
var identifier type
// 可以一次声明多个变量
var identifier1, identifier2 type
// 根据值自行判定变量类型
var v_name = value
// 简短形式 省略 var, 注意 := 左侧如果没有声明新的变量
v_name := value

定义常量

// 声明一个常量
const identifier [type] = value
// 显式类型定义
const b string = "abc"
// 隐式类型定义
const b = "abc"
// 多个相同类型的声明（隐式类型定义）
const c_name1, c_name2 = value1, value2

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值

package main

import "fmt"

func main() {
    const (
        a = iota   //0
        b          //1
        c          //2
        d = "ha"   //独立值，iota += 1
        e          //"ha"   iota += 1
        f = 100    //iota +=1
        g          //100  iota +=1
        h = iota   //7,恢复计数
        i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运行结果

0 1 2 ha ha 100 100 7 8

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1

条件控制语句

if & if else

package main

import "fmt"

func main() {
    var a = 12
    if a > 10 {
        fmt.Println("a>10")
    } else {
        fmt.Println("a<=10")
    }
}

运行结果

a>10

switch

package main

import "fmt"

func main() {
    var a = 12
    switch a {
    case 1:
        fmt.Println(1)
    case 2:
        fmt.Println(2)
    case 12:
        fmt.Println(12)
    default:
        fmt.Println(a)
    }
}

运行结果

12

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true

package main

import "fmt"

func main() {
    var a = 1
    switch a {
    case 1:
        fmt.Println(1)
        fallthrough
    case 2:
        fmt.Println(2)
    case 12:
        fmt.Println(12)
    default:
        fmt.Println(a)
    }
}

运行结果

1
2

select

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

package main

import "fmt"

func main() {
    var c1, c2, c3 chan int
    var i1, i2 int
    select {
    case i1 = <-c1:
        fmt.Printf("received ", i1, " from c1\n")
    case c2 <- i2:
        fmt.Printf("sent ", i2, " to c2\n")
    case i3, ok := <-c3:
        if ok {
            fmt.Printf("received ", i3, " from c3\n")
        } else {
            fmt.Printf("c3 is closed\n")
        }
    default:
        fmt.Printf("no communication\n")
    }
}

运行结果

no communication

循环控制语句

for

package main

import "fmt"

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

package main

import "fmt"

func main() {
    var i = 1
    for i < 10 {
        fmt.Println(i)
        i++
    }
}

运行结果

1
2
3
4
5
6
7
8
9

死循环

for {

}

函数

package main

import "fmt"

func main() {
    test(1)
}
func test(i int) int {
    for i < 10 {
        fmt.Println(i)
        i++
    }
    return i
}

运行结果

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
    i := test(1, 9)
    fmt.Println("最大值为：", i)
}
func test(i, j int) int {
    if i > j {
        return i
    } else {
        return j
    }
}

运行结果

最大值为： 9

函数返回多个值

package main

import "fmt"

func main() {
    s, s2 := test("hello", "go")
    fmt.Println(s, s2)
}
func test(i, j string) (string, string) {
    return i, j
}

运行结果

hello go

值传递 和 引用传递

package main

import "fmt"

func main() {
    var a = 3
    var b = 4
    fmt.Println("值传递运行前a=", a, "b=", b)
    test1(a, b)
    fmt.Println("值传递运行后a=", a, "b=", b)
    fmt.Println("===============================================")
    var i = 1
    var j = 2
    fmt.Println("引用传递运行前i=", i, "j=", j)
    test2(&i, &j)
    fmt.Println("引用传递运行后i=", i, "j=", j)
}

// 值传递
func test1(i, j int) (int, int) {
    var temp int
    temp = i
    i = j
    j = temp
    return i, j
}

// 引用传递
func test2(i, j *int) (int, int) {
    var temp int
    temp = *i
    *i = *j
    *j = temp
    return *i, *j
}

运行结果

值传递运行前a= 3 b= 4
值传递运行后a= 3 b= 4
===============================================
引用传递运行前i= 1 j= 2
引用传递运行后i= 2 j= 1

函数作为实参

package main

import "fmt"

func main() {
    funcA := func(a int) int {
        return a
    }
    fmt.Println(funcA(12))
}

运行结果

12

闭包

Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

package main

import "fmt"

func main() {
    next := getSequence()
    fmt.Println(next())
    fmt.Println(next())
    fmt.Println(next())
}

func getSequence() func() int {
    a := 1
    return func() int {
        a++
        return a
    }
}

运行结果

2
3
4

方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集

package main

import "fmt"

type Circle struct {
    radius float64
}

func (circle Circle) getPerimeter() float64 {
    return 3.14 * circle.radius * 2
}
func main() {
    var circle Circle
    circle.radius = 10
    fmt.Println(circle.getPerimeter())
}

运行结果

62.800000000000004

变量作用域

Go 语言中变量可以在三个地方声明：

  • 函数内定义的变量称为局部变量
  • 函数外定义的变量称为全局变量
  • 函数定义中的变量称为形式参数
package main

import "fmt"

// 全局变量
var a = 1

func main() {
    // 局部变量
    var b = 2
    test(a)
    test(b)
}

// 形式参数
func test(a int) {
    fmt.Println(a)
}

数组

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型

声明数组

// 形式
var variable_name [SIZE] variable_type
// 举例
var balance [10] float32

初始化数组

// 初始化一个长度为5的float32数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
// 如果忽略 [] 中的数字不设置数组大小
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance[6] = 60.0

访问数组元素

var a float32 = balance[5]

指针

一个指针变量指向了一个值的内存地址

声明指针

// 形式
var var_name *var-type
// 举例
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */
package main

import "fmt"

func main() {
    var a int = 20 /* 声明实际变量 */
    var ip *int    /* 声明指针变量 */

    ip = &a /* 指针变量的存储地址 */

    fmt.Printf("a 变量的地址是: %x\n", &a)

    /* 指针变量的存储地址 */
    fmt.Printf("ip 变量储存的指针地址: %x\n", ip)

    /* 使用指针访问值 */
    fmt.Printf("*ip 变量的值: %d\n", *ip)
}

运行结果

a 变量的地址是: c00000a0b0
ip 变量储存的指针地址: c00000a0b0
*ip 变量的值: 20

空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil。

nil 指针也称为空指针。一个指针变量通常缩写为 ptr。

package main

import "fmt"

func main() {
    var ip *int /* 声明指针变量 */

    /* 指针变量的存储地址 */
    fmt.Printf("ip 的值为: %x\n", ip)
}

运行结果

ip 的值为: 0

空指针判断

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

指针数组

package main

import "fmt"

func main() {
    a := []int{10, 100, 200}
    // 遍历数组
    for i := 0; i < len(a); i++ {
        fmt.Printf("a[%d] = %d\n", i, a[i])
    }
    fmt.Println("==================================")
    // 有一种情况，我们可能需要保存数组，这样我们就需要使用到指针。
    // 以下声明了整型指针数组：
    var ptr [3]*int
    for i := 0; i < len(a); i++ {
        /* 整数地址赋值给指针数组 */
        ptr[i] = &a[i]
    }
    for i := 0; i < len(ptr); i++ {
        fmt.Printf("a[%d] = %d\n", i, *ptr[i])
    }
}

运行结果

a[0] = 10
a[1] = 100
a[2] = 200
==================================
a[0] = 10
a[1] = 100
a[2] = 200

指向指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。
指向指针的指针变量声明格式

var ptr **int;
package main

import "fmt"

func main() {
    var a int
    var ptr *int
    var pptr **int

    a = 3000

    /* 指针 ptr 地址 */
    ptr = &a

    /* 指向指针 ptr 地址 */
    pptr = &ptr

    /* 获取 pptr 的值 */
    fmt.Printf("变量 a = %d\n", a)
    fmt.Printf("指针变量 *ptr = %d\n", *ptr)
    fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}

运行结果

变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000

指针作为函数参数

package main

import "fmt"

func main() {
    var a = 3
    var b = 4
    fmt.Println("值传递运行前a=", a, "b=", b)
    test1(a, b)
    fmt.Println("值传递运行后a=", a, "b=", b)
    fmt.Println("===============================================")
    var i = 1
    var j = 2
    fmt.Println("引用传递运行前i=", i, "j=", j)
    test2(&i, &j)
    fmt.Println("引用传递运行后i=", i, "j=", j)
}

// 值传递
func test1(i, j int) (int, int) {
    var temp int
    temp = i
    i = j
    j = temp
    return i, j
}

// 引用传递
func test2(i, j *int) (int, int) {
    var temp int
    temp = *i
    *i = *j
    *j = temp
    return *i, *j
}

运行结果

值传递运行前a= 3 b= 4
值传递运行后a= 3 b= 4
===============================================
引用传递运行前i= 1 j= 2
引用传递运行后i= 2 j= 1

结构体

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

Title ：标题
Author ： 作者
Subject：学科
ID：书籍ID

定义

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}
package main

import "fmt"

// 一、定义结构体
type Books struct {
    title   string
    author  string
    subject string
    book_id int
}

func main() {

    // 创建一个新的结构体
    fmt.Println(Books{"Go 语言", "Google", "Go 语言教程", 6495407})

    // 也可以使用 key => value 格式
    fmt.Println(Books{title: "Go 语言", author: "Google", subject: "Go 语言教程", book_id: 6495407})

    // 忽略的字段为 0 或 空
    fmt.Println(Books{title: "Go 语言", author: "Google"})

    fmt.Println("=========================")

    // 二、访问结构体成员
    /* book 2 描述 */
    var Book2 Books
    Book2.title = "Python 教程"
    Book2.author = "Python"
    Book2.subject = "Python 语言教程"
    Book2.book_id = 6495700
    /* 打印 Book2 信息 */
    fmt.Printf("Book 2 title : %s\n", Book2.title)
    fmt.Printf("Book 2 author : %s\n", Book2.author)
    fmt.Printf("Book 2 subject : %s\n", Book2.subject)
    fmt.Printf("Book 2 book_id : %d\n", Book2.book_id)
    fmt.Println("=========================")
    // 三、结构体作为函数参数
    printBook(Book2)
    fmt.Println("=========================")
    // 四、结构体指针
    printBook2(&Book2)
}

func printBook(book Books) {
    fmt.Printf("Book title : %s\n", book.title)
    fmt.Printf("Book author : %s\n", book.author)
    fmt.Printf("Book subject : %s\n", book.subject)
    fmt.Printf("Book book_id : %d\n", book.book_id)
}

func printBook2(book *Books) {
    fmt.Printf("Book title : %s\n", book.title)
    fmt.Printf("Book author : %s\n", book.author)
    fmt.Printf("Book subject : %s\n", book.subject)
    fmt.Printf("Book book_id : %d\n", book.book_id)
}

运行结果

{Go 语言 Google Go 语言教程 6495407}
{Go 语言 Google Go 语言教程 6495407}
{Go 语言 Google  0}
=========================
Book 2 title : Python 教程
Book 2 author : Python
Book 2 subject : Python 语言教程
Book 2 book_id : 6495700
=========================
Book title : Python 教程
Book author : Python
Book subject : Python 语言教程
Book book_id : 6495700
=========================
Book title : Python 教程
Book author : Python
Book subject : Python 语言教程
Book book_id : 6495700

切片(Slice)

Go 数组的长度不可改变,与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片

  1. var identifier []type
  2. var slice1 []type = make([]type, len) 或者简写 slice1 := make([]type, len) 指定长度
  3. make([]T, length, capacity) 指定容量
package main

import "fmt"

func main() {
    // 切片初始化
    var slice = []int{1, 2, 3}
    // 从下标startIndex到endIndex-1 下的元素 切片截取
    fmt.Println(slice[0:2])
    fmt.Println(slice[:2])
    fmt.Println(slice[0:])
    fmt.Println("=======================")
    // len() 和 cap() 函数
    fmt.Printf("len=%d cap=%d slice=%v\n", len(slice), cap(slice), slice)
    fmt.Println("=======================")
    // 空切片
    var numbers []int

    fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers)

    if numbers == nil {
        fmt.Printf("切片是空的\n")
    }
    fmt.Println("=======================")
    // append() 和 copy() 函数
    var numbers1 []int
    // append() 追加
    numbers1 = append(numbers1, 1)
    numbers1 = append(numbers1, 2, 3, 4)
    fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers1), cap(numbers1), numbers1)
    fmt.Println("=======================")
    // copy() 复制
    /* 创建切片 numbers2 是之前切片的两倍容量*/
    numbers2 := make([]int, len(numbers1), (cap(numbers1))*2)
    /* 拷贝 numbers1 的内容到 numbers2 */
    copy(numbers2, numbers1)
    fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers2), cap(numbers2), numbers2)
}

运行结果

[1 2]
[1 2]
[1 2 3]
=======================
len=3 cap=3 slice=[1 2 3]
=======================
len=0 cap=0 slice=[]
切片是空的
=======================
len=4 cap=4 slice=[1 2 3 4]
=======================
len=4 cap=8 slice=[1 2 3 4]

范围(Range)

package main

import "fmt"

func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

运行结果

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

Map(集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

定义集合

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

package main

import "fmt"

func main() {
    var countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap["France"] = "巴黎"
    countryCapitalMap["Italy"] = "罗马"
    countryCapitalMap["Japan"] = "东京"
    countryCapitalMap["India "] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap[country])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap["American"] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if ok {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }

    fmt.Println("========================")
    // delete() 函数
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap[country])
    }
    // 删除元素
    delete(countryCapitalMap, "France")
    fmt.Println("法国条目被删除")
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap[country])
    }
}

运行结果

France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India  首都是 新德里
American 的首都不存在
========================
India  首都是 新德里
France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
法国条目被删除
Japan 首都是 东京
India  首都是 新德里
Italy 首都是 罗马

递归函数

递归，就是在运行的过程中调用自己

阶乘

package main

import "fmt"

func main() {
    var i int = 15
    fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}

func Factorial(n uint64) (result uint64) {
    if n > 0 {
        result = n * Factorial(n-1)
        return result
    }
    return 1
}

运行结果

15 的阶乘是 1307674368000

斐波那契数列

package main

import "fmt"

func main() {
    var i int
    for i = 0; i < 10; i++ {
        fmt.Printf("%d\t", fibonacci(i))
    }
}

func fibonacci(n int) int {
    if n < 2 {
        return n
    }
    return fibonacci(n-2) + fibonacci(n-1)
}

运行结果

0    1    1    2    3    5    8    13    21    34

类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。

type_name(expression)
package main

import "fmt"

func main() {
    var sum int = 17
    var count int = 5
    var mean float32

    mean = float32(sum) / float32(count)
    fmt.Printf("mean 的值为: %f\n", mean)
}

运行结果

mean 的值为: 3.400000

接口

package main

import "fmt"

type Phone interface {
    call()
}

type NokiaPhone struct {
}
type IPhone struct {
}

func main() {
    n := new(NokiaPhone)
    n.call()
    i := new(IPhone)
    i.call()
}

func (NokiaPhone) call() {
    fmt.Println("nokiaPhone")
}

func (IPhone) call() {
    fmt.Println("IPhone")
}

运行结果

nokiaPhone
IPhone

错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。

error类型是一个接口类型，这是它的定义

type error interface {
    Error() string
}

我们可以在编码中通过实现 error 接口类型来生成错误信息。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息

package main

import (
    "errors"
    "fmt"
)

func main() {
    _, err := Sqrt(-1)

    if err != nil {
        fmt.Println(err)
    }
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
    return f, nil
}

运行结果

math: square root of negative number

并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。

goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：

go 函数名( 参数列表 )

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

package main

import (
    "fmt"
    "time"
)

func main() {
    go say("world")
    say("hello")
}

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

运行结果

hello
world
world
hello
hello
world
world
hello
hello

通道（channel）

通道（channel）是用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。
声明一个通道，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

package main

import (
    "fmt"
)

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从通道 c 中接收

    fmt.Println(x, y, x+y)
}

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 把 sum 发送到通道 c
}

运行结果

-5 17 12

通道缓冲区

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

package main

import (
    "fmt"
)

func main() {
    // 这里我们定义了一个可以存储整数类型的带缓冲通道
    // 缓冲区大小为2
    ch := make(chan int, 2)

    // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
    // 而不用立刻需要去同步读取数据
    ch <- 1
    ch <- 2

    // 获取这两个数据
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

运行结果

1
2

遍历通道与关闭通道

Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片。格式如下：

v, ok := <-ch
package main

import (
    "fmt"
)

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    // range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个
    // 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据
    // 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不
    // 会结束，从而在接收第 11 个数据的时候就阻塞了。
    for i := range c {
        fmt.Println(i)
    }
}

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    // 关闭通道
    close(c)
}

运行结果

0
1
1
2
3
5
8
13
21
34

你可能感兴趣的:(golang)

  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • Golang语言基础知识点总结 最帅猪猪侠 golang开发语言后端
    Golang语言基础知识点小总结1.go语言有两大类型：值类型：数值类型，bool，string，数组，struct结构体变量直接存储值，内存通常在栈中分配,修改值,不会对源对象产生影响引用类型：指针，slice切片，管道chan，map，interface变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾
  • golang获取用户输入的几种方式 余生逆风飞翔 golang开发语言后端
    一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
  • 【Golang】实现 Excel 文件下载功能 RumIV Golanggolangexcel开发语言
    在当今的网络应用开发中，提供数据导出功能是一项常见的需求。Excel作为一种广泛使用的电子表格格式，通常是数据导出的首选格式之一。在本教程中，我们将学习如何使用Go语言和GinWeb框架来创建一个Excel文件，并允许用户通过HTTP请求下载该文件。准备工作在开始之前，请确保您的开发环境中已经安装了Go语言和相关的开发工具。此外，您还需要安装GinWeb框架和excelize包，这两个包都将用于我
  • golang 实现文件上传下载 wangwei830 go
    Gin框架上传下载上传（支持批量上传）httpRouter.POST("/upload",func(ctx*gin.Context){forms,err:=ctx.MultipartForm()iferr!=nil{fmt.Println("error",err)}files:=forms.File["fileName"]for_,v:=rangefiles{iferr:=ctx.SaveUplo
  • golang实现从服务器下载文件到本地指定目录 余生逆风飞翔 golang服务器开发语言
    一、连接服务器，采用sftp连接模式packagemiddlewaresimport("fmt""time""github.com/pkg/sftp""golang.org/x/crypto/ssh")//建立服务器连接funcConnect(user,password,hoststring,portint)(*sftp.Client,error){var(auth[]ssh.AuthMethod
  • 【Golang】 Golang 的 GORM 库中的 Rows 函数 不爱洗脚的小滕 golang开发语言后端
    文章目录前言一、Rows函数解释二、代码实现三、总结前言在使用Go语言进行数据库操作时，GORM（GoObject-RelationalMapping）库是一个常用的工具。它提供了一种简洁和强大的方式来处理数据库操作。本文将介绍GORM库中的Rows函数，这是一个用于执行原生SQL查询并返回结果的函数。一、Rows函数解释在GORM库中，Rows函数用于执行原生SQL查询并返回*sql.Rows结
  • 【Golang】使用 Golang 语言和 excelize 库将数据写入Excel 不爱洗脚的小滕 golangexcel开发语言
    文章目录前言一、Excelize简介二、代码实现1.获取依赖2.示例代码三、总结前言在数据处理和分析中，Excel作为一种常见的电子表格格式，被广泛应用于各种场景。然而，如何在Go语言中有效地处理Excel文件呢？在这篇博客中，我将介绍如何使用Go语言和excelize库将数据写入Excel文件。一、Excelize简介Excelize是一个用于读取和写入MicrosoftExcel™(XLSX)
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • Go 面向包的设计和架构分层 云满笔记 golang架构directorylayoutsrcproject
    标题Go面向包的设计和架构分层序前项目架构分层工具包项目应用项目cmd/internal/internal/pkg/pkg/vendor/面向包的设计和验证包的位置依赖包导入应用级别的策略数据的发送和接收错误处理测试捕获错误不建议的目录结论Go面向包的设计和架构分层序本篇内容主要讲解golang项目的面向包设计准则和基础的架构分层。信息来自原文ArdanLabs:Package-Oriented-
  • Golang channel 死锁 羊城程序猿 golanggolang
    死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • [Golang] goroutine 沉着冷静2024 Golanggolang后端
    [Golang]goroutine文章目录[Golang]goroutine并发进程和线程协程goroutine概述如何使用goroutine并发进程和线程谈到并发，大多都离不开进程和线程，什么是进程、什么是线程？进程可以这样理解：进程就是运行着的程序，它是程序在操作系统的一次执行过程，是一个程序的动态概念，进程是操作系统分配资源的基本单位。线程可以这样理解：线程是一个进程的执行实体，它是比进程粒
  • golang-101-hacks(3)——包 _羊羽_
    注：本文是对golang-101-hacks中文翻译,原文地址在“Go”中，包分为两种类型:(1)main包:用于生成可执行的二进制文件，main函数是程序的入口点。下面以helllo.go为例:packagemainimport"greet"funcmain(){greet.Greet()}(2)其他类型的包也可以在细分成两类:库文件包:用来生成可以被其他人重用的目标文件。如greet.go这个
  • golang面试题 001 Jay_hj11 golang面试Golanggolang后端数据结构开发语言面试
    001gochannelclose后读的问题golangchannel关闭后，其中剩余的数据，是可以继续读取的。请看下面的测试例子。创建一个带有缓冲的channel，向channel中发送数据，然后关闭channel，最后，从channel中读取数据，输出结果。packagemainimport"fmt"//gochannelclose后读的问题funcmain(){ch:=make(chanst
  • golang文件相对路径问题 jzpfbpx golang开发语言后端
    目录结构2.具体代码：constdataFile="../data/data.json"_,fileName,_,_:=runtime.Caller(1)dataPath:=path.Join(path.Dir(fileName),dataFile)fmt.Println(dataPath)//openfilefile,err:=os.Open(dataPath)iferr!=nil{log.Fa
  • golang文件相对路径问题 jzpfbpx golang开发语言后端
    1.目录结构2.具体代码：constdataFile="../data/data.json"_,fileName,_,_:=runtime.Caller(1)dataPath:=path.Join(path.Dir(fileName),dataFile)fmt.Println(dataPath)//openfilefile,err:=os.Open(dataPath)iferr!=nil{log.
  • go 语言常见问题（4） jzpfbpx golang开发语言后端
    31.go语言编程的好处是什么编译和运行都很快。在语言层级支持并行操作。有垃圾处理器。内置字符串和maps。函数是go语言的最基本编程单位。32.说说go语言的select机制select机制用来处理异步IO问题select机制最大的一条限制就是每个case语句里必须是一个IO操作golang在语言级别支持select关键字33.解释一下go语言中的静态类型声明静态类型声明是告诉编译器不需要太多的
  • golang中创建协程以及协程间的相互通信 忍界英雄 golang开发语言
    golang中创建协程以及协程间的相互通信。在golang中创建协程在Go语言中，使用协程来实现并发模型。协程是Go语言的并发执行单元，它比传统的线程更轻量级，允许我们并发执行多个任务。Go会在内部使用一组线程来运行创建的协程，并在这些线程之间高效地分配协程执行，这样可以在不增加太多操作系统线程的情况下执行大量的协程。在golang中，我们可以方便的使用gofunc(){}()语句用于启动一个新的
  • golang学习笔记14——golang性能问题的处理方法 GoppViper golang学习笔记golang学习笔记编程语言golang性能性能优化后端
    推荐学习文档基于golang开发的一款超有个性的旅游计划app经历golang实战大纲golang优秀开发常用开源库汇总golang学习笔记01——基本数据类型golang学习笔记02——gin框架及基本原理golang学习笔记03——gin框架的核心数据结构golang学习笔记04——如何真正写好Golang代码？golang学习笔记05——golang协程池，怎么实现协程池？golang学习笔
  • golang学习笔记15——golang依赖管理方法 GoppViper golang学习笔记golang学习笔记编程语言golang依赖管理源代码管理后端
    推荐学习文档golang应用级os框架，欢迎star基于golang开发的一款超有个性的旅游计划app经历golang实战大纲golang优秀开发常用开源库汇总golang学习笔记01——基本数据类型golang学习笔记02——gin框架及基本原理golang学习笔记03——gin框架的核心数据结构golang学习笔记04——如何真正写好Golang代码？golang学习笔记05——golang协
  • golang学习笔记12——Go 语言内存管理详解 GoppViper golang学习笔记golang学习笔记编程语言golang内存管理内存优化后端
    推荐学习文档golang应用级os框架，欢迎star基于golang开发的一款超有个性的旅游计划app经历golang实战大纲golang优秀开发常用开源库汇总golang学习笔记01——基本数据类型golang学习笔记02——gin框架及基本原理golang学习笔记03——gin框架的核心数据结构golang学习笔记04——如何真正写好Golang代码？golang学习笔记05——golang协
  • golang学习笔记02——gin框架及基本原理 GoppViper golang学习笔记golang学习笔记ginhttp
    目录1.前言2.必要的知识3.路由注册流程3.1核心数据结构3.2执行流程3.3创建并初始化gin.Engine3.4注册middleware3.5注册路由及处理函数（1）拼接完整的路径参数（2）组合处理函数链（3）注册完成路径及处理函数链到路由树3.6服务端口监听4.请求处理5.请求绑定和响应渲染5.1.请求绑定5.2响应渲染结束语1.前言gin框架是golang中比较常见的web框架，截止到目
  • Golang学习路线图及go-starter.md knight11112 golang开发语言后端
    Golang学习路线图及go-starter.md背景为什么要学习golang最早接触golang是因为对区块链感兴趣，因为golang的并发和内置的网络库还有大公司的支持，先天比较适合区块链，很多著名的框架都是golang写，比如geth再后来，到新加坡Shopee工作，技术栈从Java切换成了golang，更要好好学习golang的语言特性了如下是之前列的一个学习路线图1.数据类型（含stru
  • Go的学习路线 JSU-YSJ Golang基础学习golang学习开发语言
    Golang简介go语言Go（又称Golang）是Google的RobertGriesemer，RobPike及KenThompson开发的一种静态强类型、编译型语言。Go语言语法与C相近，但功能上有：内存安全，GC（垃圾回收），结构形态及CSP-style并发计算。为什么要学习Go现有的编程语言风格各异，不能完全的运动好电脑的硬件，不高效，及各种优势于一身的语言Golang(谷歌创建)兼容静态编
  • 计算机毕业设计选题推荐-基于Python框架项目推荐（中） 计算机毕设大佬 Java毕设实战项目Python毕设实战项目爬虫+大数据毕设实战项目python计算机毕业设计django计算机毕业设计如何选题25届计算机毕业设计如何选题计算机毕业设计选题推荐24届计算机毕设选题推荐
    博主介绍：✌十余年IT大项目实战经验、在某机构培训学员上千名、专注于本行业领域✌技术范围：Java实战项目、Python实战项目、微信小程序/安卓实战项目、爬虫+大数据实战项目、Nodejs实战项目、PHP实战项目、.NET实战项目、Golang实战项目。主要内容：系统功能设计、开题报告、任务书、系统功能实现、功能代码讲解、答辩PPT、文档编写、文档修改、文档降重、一对一辅导答辩。获取源码可以联系
  • golang学习笔记11——Go 语言的并发与同步实现详解 GoppViper golang学习笔记golang学习笔记编程语言golang并发goroutine后端
    推荐学习文档golang应用级os框架，欢迎star基于golang开发的一款超有个性的旅游计划app经历golang实战大纲golang优秀开发常用开源库汇总golang学习笔记01——基本数据类型golang学习笔记02——gin框架及基本原理golang学习笔记03——gin框架的核心数据结构golang学习笔记04——如何真正写好Golang代码？golang学习笔记05——golang协
  • golang-阅读雨痕大神的Go语言学习笔记的心得 炒股养惠 golang学习之旅go
    golang-阅读雨痕大神的Go语言学习笔记的心得第一章概述1.1go与java中的局部变量初始化问题1.2golang中实现生产者消费者模型，利用管道进行数据通信第二章类型2.1类型推断的使用注意2.2常量与变量的区别2.3常量的值类型省略2.4go的枚举2.5常量和变量到底有什么区别2.6go基本类型2.7go引用类型2.7.1go中new与make的区别第一章概述1.1go与java中的局部
  • golang学习笔记16——golang部署与运维全攻略 GoppViper golang学习笔记golang学习笔记后端持续部署源代码管理
    推荐学习文档golang应用级os框架，欢迎star基于golang开发的一款超有个性的旅游计划app经历golang实战大纲golang优秀开发常用开源库汇总golang学习笔记01——基本数据类型golang学习笔记02——gin框架及基本原理golang学习笔记03——gin框架的核心数据结构golang学习笔记04——如何真正写好Golang代码？golang学习笔记05——golang协
  • 开发者关心的那些事 圣子足道 ios游戏编程apple支付
    我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
  • 负载均衡器技术Nginx和F5的优缺点对比 bijian1013 nginxF5
            对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。         目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
  • LeetCode[Math] - #9 Palindrome Number Cwind javaAlgorithm题解LeetCodeMath
    原题链接：#9 Palindrome Number   要求： 判断一个整数是否是回文数，不要使用额外的存储空间   难度：简单   分析： 题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 注：没有看到有关负数是否可以是回文数的明确结论，例如
  • 画图板的基本实现 15700786134 画图板
     要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 首先，需要显示一个JFrame界面： public class DrameFrame extends JFrame {              //显示
  • linux的ps命令 被触发 linux
    Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
  • Android 音乐播放器 下一曲 连续跳几首歌 肆无忌惮_ android
    最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 player.setOnCompletionListener(new OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp) { mp.reset(); Log.i("H
  • java导出txt文件的例子 知了ing javaservlet
    代码很简单就一个servlet,如下： package com.eastcom.servlet; import java.io.BufferedOutputStream; import java.io.IOException; import java.net.URLEncoder; import java.sql.Connection; import java.sql.Resu
  • Scala stack试玩, 提高第三方依赖下载速度 矮蛋蛋 scalasbt
    原文地址： http://segmentfault.com/a/1190000002894524 sbt下载速度实在是惨不忍睹, 需要做些配置优化 下载typesafe离线包, 保存为ivy本地库 wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 解压r
  • phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。 alleni123 linuxspider
    1. 首先从官网 http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 2. 安装依赖 sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 3. 配置环境变量 vi /etc/profil
  • JAVA IO FileInputStream和FileOutputStream，字节流的打包输出 百合不是茶 java核心思想JAVA IO操作字节流
    在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流   类 FileInputStream
  • Spring基础实例（依赖注入和控制反转） bijian1013 spring
    前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 package com.bijian.spring.base3; public interface Weapon { void kil
  • HR看重的十大技能 bijian1013 提升能力HR成长
        一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
  • 【Thrift一】Thrift编译安装 bit1129 thrift
    什么是Thrift The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
  • 【Avro三】Hadoop MapReduce读写Avro文件 bit1129 mapreduce
    Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
  • nginx定制500，502，503，504页面 ronin47 nginx　错误显示
    server { listen 80; error_page 500/500.html; error_page 502/502.html; error_page 503/503.html; error_page 504/504.html; location /test {return502;}} 配置很简单，和配
  • java-1.二叉查找树转为双向链表 bylijinnan 二叉查找树
    import java.util.ArrayList; import java.util.List; public class BSTreeToLinkedList { /* 把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \
  • Netty源码学习-HTTP-tunnel bylijinnan javanetty
    Netty关于HTTP tunnel的说明： http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 这个说明有点太简略了 一个完整的例子在这里： https://github.com/bylijinnan
  • JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 coder_xpf jqueryjsonmapval()
     JSONUtil.serialize(map)和JSON.toJSONString(map)的区别   数据库查询出来的map有一个字段为空   通过System.out.println()输出 JSONUtil.serialize(map)： {"one":"1","two":"nul
  • Hibernate缓存总结 cuishikuan 开源sshjavawebhibernate缓存三大框架
    一、为什么要用Hibernate缓存？ Hibernate是一个持久层框架，经常访问物理数据库。 为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。   二、Hibernate缓存原理是怎样的？ Hibernate缓存包括两大类：Hib
  • CentOs6 dalan_123 centos
    首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
  • 10款用 jquery 实现滚动条至页面底端自动加载数据效果 dcj3sjt126com JavaScript
      无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
  • ImageButton去边框&Button或者ImageButton的背景透明 dcj3sjt126com imagebutton
    在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 第二种方法就是将ImageButton背景改为透明，这个方法更常用 在XML里；    <ImageBut
  • JSP之c:foreach eksliang jspforearch
    原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html <c:forEach>标签用于通用数据循环，它有以下属性 属 性 描 述 是否必须 缺省值 items 进行循环的项目 否 无 begin 开始条件 否 0 end 结束条件 否 集合中的最后一个项目 step 步长 否 1
  • Android实现主动连接蓝牙耳机 gqdy365 android
    在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 大致可以分三步： 一、扫描蓝牙设备： 1、注册并监听广播： BluetoothAdapter.ACTION_DISCOVERY_STARTED BluetoothDevice.ACTION_FOUND BluetoothAdapter.ACTION_DIS
  • android学习轨迹之四：org.json.JSONException: No value for hyz301 json
    org.json.JSONException: No value for items  在JSON解析中会遇到一种错误，很常见的错误   06-21 12:19:08.714 2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
  • 干货分享：从零开始学编程 系列汇总 justjavac 编程
    程序员总爱重新发明轮子，于是做了要给轮子汇总。 从零开始写个编译器吧系列 (知乎专栏) 从零开始写一个简单的操作系统 (伯乐在线) 从零开始写JavaScript框架 (图灵社区) 从零开始写jQuery框架 (蓝色理想 ) 从零开始nodejs系列文章 (粉丝日志) 从零开始编写网络游戏 
  • jquery-autocomplete 使用手册 macroli jqueryAjax脚本
    jquery-autocomplete学习 一、用前必备 官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/ 当前版本：1.1 需要JQuery版本：1.2.6 二、使用 <script src="./jquery-1.3.2.js" type="text/ja
  • PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改 超声波 oracleplsql
    　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
  • 数据仓库数据模型之：极限存储--历史拉链表 superlxw1234 极限存储数据仓库数据模型拉链历史表
    在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
  • 10点睛Spring MVC4.1-全局异常处理 wiselyman spring mvc
    10.1 全局异常处理 使用@ControllerAdvice注解来实现全局异常处理; 使用@ControllerAdvice的属性缩小处理范围 10.2 演示 演示控制器 package com.wisely.web; import org.springframework.stereotype.Controller; import org.spring
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他