主頁 > 後端開發 > 【go語言學習】函式function

【go語言學習】函式function

2020-10-30 23:01:59 後端開發

函式是組織好的、可重復使用的、用于執行指定任務的代碼塊，
Go語言中支持函式、匿名函式和閉包，并且函式在Go語言中屬于“一等公民”，

一、函式的宣告和呼叫

1、函式的宣告

Go語言中定義函式使用func關鍵字，具體格式如下：

func funcName(parametername type) (output type) {
    //這里是處理邏輯代碼
    //回傳多個值
    return valu
}
  • func 函式由func開始宣告
  • funcName 函式名
  • () 函式的標志
  • parametername type 函式的引數串列，引數串列指定引數的型別、順序以及個數，引數是可選，可有可無；這里的引數相當于一個占位符，所以也叫形式引數，當函式被呼叫時，傳入的值傳遞給引數，這個值被稱為實際引數
  • ouput type 回傳值串列，回傳值可以由名稱和型別組成，也可以只寫型別不寫名稱；回傳值可以有一個或多個，當有一個回傳值時可以不加()，多個回傳值時必須加()
  • 函式體：實作指定功能的代碼塊{}里面的內容，
2、函式的呼叫

可以通過funcName(parameter)的方式呼叫函式，呼叫有回傳值的函式時，可以不接收其回傳值，

package main

import "fmt"

func main() {
    a := 10
    b := 20
    res := sum(a, b)
    fmt.Printf("%v + %v = %v", a, b, res)
}

func sum(a, b int) int {
    return a + b
}

運行結果

10 + 20 = 30

二、函式的引數

1、引數的使用：

形式引數：定義函式時，用于接收外部傳入的資料，叫做形式引數，簡稱形參，
實際引數：呼叫函式時，傳給形參的實際的資料，叫做實際引數，簡稱實參，
函式呼叫：

  • A：函式名稱必須匹配
  • B：實參與形參必須一一對應：順序，個數，型別
    函式的引數中如果相鄰變數的型別相同，則可以省略型別，如：
package main

import "fmt"

func main() {
    a := 10
    b := 20
    res := add(a, b)
    fmt.Printf("%v + %v = %v", a, b, res)
}

func add(a, b int) sum int {
    sum = a + b
    return
}
2、可變引數

可變引數是指函式的引數數量不固定，Go語言中的可變引數通過在引數名后加...來標識，

注意：可變引數通常要作為函式的最后一個引數，

func funcName(arg ...int) {}

arg ...int告訴Go這個函式接受不定數量的引數，注意，這些引數的型別全部是int，在函式體中，變數arg是一個int型別的slice

3、引數的傳遞

go語言函式的引數也是存在值傳遞和參考傳遞

資料型別：

  • 按照資料型別來分：

    • 基本資料型別
      int，float，string，bool
    • 復合資料型別
      arry，slice，map，struct，interface，chan...

  • 按照資料的存盤特點來分：

    • 值型別的資料，操作的是資料本身，
      int，float，string，bool，arry，struct
    • 參考型別的資料，操作的資料的地址，
      slice，map，chan

  • 值傳遞：值型別的資料傳遞為值傳遞，傳遞的是資料的副本，修改資料，對原始資料沒有影響，

package main

import "fmt"

func main() {
	arr1 := [3]int{1, 2, 3}
	fmt.Println("函式呼叫前，陣列的資料：", arr1)
	fun(arr1)
	fmt.Println("函式呼叫后，陣列的資料：", arr1)
}

func fun(arr2 [3]int) {
	fmt.Println("函式中，陣列的資料：", arr2)
	arr2[0] = 100
	fmt.Println("函式中，修改后資料的資料：", arr2)
}

運行結果

函式呼叫前，陣列的資料： [1 2 3]
函式中，陣列的資料： [1 2 3]
函式中，修改后資料的資料： [100 2 3]
函式呼叫后，陣列的資料： [1 2 3]
  • 參考傳遞：參考型別的資料傳遞為參考傳遞，傳遞的資料的地址，導致多個變數指向同一塊記憶體，
package main

import "fmt"

func main() {
	slice1 := []int{1, 2, 3}
	fmt.Println("函式呼叫前，切片的資料：", slice1)
	fun(slice1)
	fmt.Println("函式呼叫后，切片的資料：", slice1)
}

func fun(slice2 []int) {
	fmt.Println("函式中，切片的資料：", slice2)
	slice2[0] = 100
	fmt.Println("函式中，修改后切片的資料：", slice2)
}

運行結果

函式呼叫前，切片的資料： [1 2 3]
函式中，切片的資料： [1 2 3]
函式中，修改后切片的資料： [100 2 3]
函式呼叫后，切片的資料： [100 2 3]
  • 指標傳遞：傳遞的就是資料的記憶體地址，

三、函式的回傳值

函式的回傳值：
一個函式的執行結果，回傳給函式呼叫處，執行結果就叫函式的回傳值，
return陳述句：
一個函式的定義上有回傳值，那么函式中必須有return陳述句，將執行結果回傳給函式的呼叫處，
函式的回傳結果必須和函式定義的一致，型別、數量、順序，

  • 回傳值的命名
    函式定義時可以給回傳值命名，并在函式體中直接使用這些變數，最后通過return關鍵字回傳，
func add(x, y int) (sum int) {
	sum = x + y
	return
}
  • 多回傳值
    一個函式可以沒有回傳值，也可以有一個回傳值，也可以有回傳多個值，
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}
  • 空白識別符號-可用來舍棄某些回傳值，
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}
_, sub := calc(10, 20) //舍棄sum

四、函式的作用域

作用域：變數可以使用的范圍，

1、全域變數

全域變數是定義在函式外部的變數，它在程式整個運行周期內都有效， 所有的函式都可以使用，而且共享這一份資料，

package main

import "fmt"

var a = 10

func main() {
	fmt.Println("test呼叫前，main中訪問a：", a)
	test()
	fmt.Println("test呼叫后，main中訪問a：", a)
}

func test() {
	fmt.Println("操作前，test中訪問a: ", a)
	a = 20
	fmt.Println("操作后，test中訪問a: ", a)
}

運行結果

test呼叫前，main中訪問a： 10
操作前，test中訪問a:  10
操作后，test中訪問a:  20
test呼叫后，main中訪問a： 20
2、區域變數

一個函式內部定義的變數，就叫做區域變數
區域變數只能在定義的范圍內訪問操作

package main

import "fmt"

func main() {
	test()
	fmt.Println("main中訪問a：", a) //undefined: a
}

func test() {
	a := 20
	fmt.Println("test中訪問a: ", a)
}

運行結果

# command-line-arguments
.\main.go:7:35: undefined: a

區域變數和全域變數重名，優先訪問區域變數，

package main

import "fmt"

var a = 100

func main() {
	test()
}

func test() {
	a := 20
	fmt.Println("test中訪問a: ", a)
}

運行結果

test中訪問a:  20

另外，if，switch，for陳述句中宣告的變數也屬于區域變數，在代碼塊外無法訪問，

五、函式的本質

函式也是Go語言中的一種資料型別，可以作為另一個函式的引數，也可以作為另一個函式的回傳值，

1、函式是一種資料型別
package main

import "fmt"

func main() {
	fmt.Printf("%T\n", fun1) //fun1的型別是func(int, int)
	fmt.Printf("%T\n", fun2) //fun2的型別是func(int, int) int
}

func fun1(a, b int) {
	fmt.Println(a, b)
}

func fun2(c, d int) int {
	fmt.Println(c, d)
	return 0
}

運行結果

func(int, int)
func(int, int) int
2、定義函式型別的變數
var f fun(int, int) int

上面陳述句定義了一個變數f，它是一個函式型別，這種函式接收兩個int型別的引數并且回傳一個int型別的回傳值，
所有引數和回傳值符合條件的函式可以賦值給f變數

package main

import "fmt"

func main() {
	var f func(int, int) int
	f = sum
	res := f(20, 10)
	fmt.Println("20 + 10 = ", res)
	f = sub
	res = f(20, 10)
	fmt.Println("20 - 10 = ", res)
}

func sum(a, b int) int {
	return a + b
}

func sub(a, b int) int {
	return a - b
}

運行結果

20 + 10 =  30
20 - 10 =  10

六、匿名函式

匿名函式就是沒有函式名的函式

func (引數) (回傳值) {
    函式體
}

匿名函式因為沒有函式名，所以沒辦法像普通函式那樣呼叫，所以匿名函式需要保存到某個變數或者作為立即執行函式，

package main

import "fmt"

func main() {
	// 將匿名函式保存到變數中
	sum := func(a, b int) int {
		return a + b
	}
	// 通過變數呼叫匿名函式
	res := sum(10, 20)
	fmt.Println("10 + 20 =", res)
	// 自執行函式,匿名函式定義完直接加()執行
	func(c, d int) {
		fmt.Printf("%v + %v = %v\n", c, d, c+d)
	}(10, 20)
}

運行結果

10 + 20 = 30
10 + 20 = 30

七、高階函式

go語言支持函式式編程：

  • 將一個函式作為另一個函式的引數
  • 將一個函式作為另一個函式的回傳值

1、回呼函式

一個函式被作為引數傳遞給另一個函式，那么這個函式就叫做回呼函式，
回呼函式并不會馬上被呼叫執行，它會在包含它的函式內的某個特定的時間點被“回呼”（就像它的名字一樣），

package main

import "fmt"

func main() {
	res := calc(10, 20, add)
	fmt.Println(res)
}
// add是一個func(int, int)int型別的函式，可以作為引數傳遞給calc函式
func add(a, b int) int {
	return a + b
}

// calc 高階函式，它有兩個int型別的引數和一個func(int, int)int函式型別的引數
// oper 回呼函式，它被作為引數傳遞給calc函式
func calc(a, b int, oper func(int, int) int) int {
	res := oper(a, b)
	return res
}

運行結果

30
2、函式作為回傳值
package main

import "fmt"

func main() {
	fun := calc("+")
	res := fun(10, 20)
	fmt.Println("10 + 20 =", res)
}

func sum(a, b int) int {
	return a + b
}

func sub(a, b int) int {
	return a - b
}

func calc(s string) func(int, int) int {
	switch s {
	case "+":
		return sum
	case "-":
		return sub
	default:
		fmt.Println("你傳的是個啥玩意！")
		return nil
	}
}

運行結果

10 + 20 = 30
3、閉包

一個外層函式，有內層函式，該內層函式會操作外層函式的區域變數（外層函式的引數，或外層函式定義的變數），并且該內層函式作為外層函式的回傳值，
這個內層函式和外層函式的區域變數，統稱為閉包結構，

區域變數的生命周期會發生改變，正常的區域變數隨著函式的呼叫而創建，隨著函式的結束而銷毀，
但是閉包結構的外層函式的區域變數并不會隨著外層函式的結束而銷毀，因為內層函式還要繼續使用，

package main

import "fmt"

func main() {
	fun := add()
	res := fun()
	fmt.Println("第一次呼叫，res=", res)
	res = fun()
	fmt.Println("第二次呼叫，res=", res)
	res = fun()
	fmt.Println("第二次呼叫，res=", res)
}

func add() func() int {
	i := 0
	return func() int {
		i++
		return i
	}
}

運行結果

第一次呼叫，res= 1
第二次呼叫，res= 2
第二次呼叫，res= 3

七、defer陳述句

defer是Go語言中的延遲執行陳述句，用來添加函式結束時執行的代碼，常用于釋放某些已分配的資源、關閉資料庫連接、斷開socket連接、解鎖一個加鎖的資源，
Go語言機制擔保一定會執行defer陳述句中的代碼，

1、延遲函式
  • 被延遲的函式，在離開所在的函式或方法時，執行（報錯的時候也會執行
  • 如果有很多defer陳述句，遵從“先進后出”的模式
package main

import "fmt"

func main() {
	a := 1
	b := 2
	c := 3
	d := 4
    //defer a++ //a++ 是一個陳述句，并非函式或方法，程式報錯
	defer fmt.Println("defer", a)
	defer fmt.Println("defer", b)
	defer fmt.Println("defer", c)
	defer fmt.Println("defer", d)
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
}

運行結果

1
2
3
4
defer 4
defer 3
defer 2
defer 1
2、延遲方法

延遲并不僅僅局限于函式，延遲一個方法呼叫也是完全合法的，

package main

import "fmt"

// Student 學生結構體
type Student struct {
	name string
	city string
}

func (s Student) hello() {
	fmt.Printf("我叫%v, 我來自%v，\n", s.name, s.city)
}

func main() {
	s := Student{
		name: "jack",
		city: "北京市",
	}
	defer s.hello()
	fmt.Print("大家好，")
}

運行結果

大家好，我叫jack, 我來自北京市
3、延遲引數

defer宣告時會先計算確定引數的值，defer推遲執行的僅是其函式體，

package main

import "fmt"

func main() {
	a := 1
	defer fun(a)
	a++
	fmt.Println("main中的a =", a)
}

func fun(a int) {
	fmt.Println("fun中的a =", a)
}

運行結果

main中的a = 2
fun中的a = 1
4、defer與return
  • 所有函式在執行 RET 回傳指令之前，都會先檢查是否存在 defer 陳述句，若存在則先逆序呼叫 defer 陳述句進行收尾作業再退出回傳；
  • 匿名回傳值是在 return 執行時被宣告，有名回傳值則是在函式宣告的同時被宣告，因此在 defer 陳述句中只能訪問有名回傳值，而不能直接訪問匿名回傳值；
  • return 其實應該包含前后兩個步驟：第一步是給回傳值賦值（若為有名回傳值則直接賦值，若為匿名回傳值則先宣告再賦值）；第二步是呼叫 RET 回傳指令并傳入回傳值，而 RET 則會檢查 defer 是否存在，若存在就先逆序插播 defer 陳述句，最后 RET 攜帶回傳值退出函式；
  • 因此，??defer、return、回傳值三者的執行順序應該是：return最先給回傳值賦值；接著 defer 開始執行一些收尾作業；最后 RET 指令攜帶回傳值退出函式，
（1）匿名回傳值的情況
package main

import "fmt"

func main() {
	fmt.Println(fun1())
}

func fun1() int {
	var i int
	defer func() {
		i++
	}()
	return i
}

運行結果

0
（2）有名回傳值的情況
package main

import "fmt"

func main() {
	fmt.Println(fun2())
}

func fun2() (i int) {
	defer func() {
		i++
	}()
	return i
}

運行結果

1

分析：

  • fun1()int 函式的回傳值沒有被提前聲名，其值來自于其他變數的賦值，而 defer 中修改的也是其他變數（其實該 defer 根本無法直接訪問到回傳值），因此函式退出時回傳值并沒有被修改，
  • fun2()(i int) 函式的回傳值被提前聲名，這使得 defer 可以訪問該回傳值，因此在 return 賦值回傳值 i 之后，defer 呼叫回傳值 i 并進行了修改，最后致使 return 呼叫 RET 退出函式后的回傳值才會是 defer 修改過的值，

經典案例

package main

import "fmt"

func main() {
	fmt.Println(f1())
	fmt.Println(f2())
	fmt.Println(f3())
	fmt.Println(f4())
}

func f1() int {
	x := 5
	defer func() {
		x++ // defer 訪問的是變數x，訪問不到回傳值
		// fmt.Println("f1函式defer中的x =", x) //6
	}()
	return x // 回傳值 = 5     //回傳5
}

func f2() (x int) {
	defer func() {
		x++ //defer 訪問x, 可以訪問回傳值，在RET之前，將回傳值修改為6
		// fmt.Println("f2函式defer中的x =", x) //6
	}()
	return 5 // 回傳值(x) = 5   //回傳6
}

func f3() (y int) {
	x := 5
	defer func() {
		x++ // defer 訪問變數x，將變數x修改為6
		// fmt.Println("f3函式defer中的x =", x) //6
	}()
	return x // 回傳值(y) = 5   //回傳5
}
func f4() (x int) {
	defer func(x int) {
		x++ // 這里修改的defer時傳入的x(0),將其修改為1
		// fmt.Println("f4函式defer中的x =", x) //1
	}(x) // defer 陳述句呼叫時傳入x的值為int型別的默認值0
	return 5 // 回傳值(x) = 5   //回傳5
}

運行結果

5
6
5
5
5、defer的作用域
  • defer 只對當前協程有效（main 可以看作是主協程）；
  • 當任意一條（主）協程發生 panic 時，會執行當前協程中 panic 之前已宣告的 defer；
  • 在發生 panic 的（主）協程中，如果沒有一個 defer 呼叫 recover()進行恢復，則會在執行完最后一個已宣告的 defer 后，引發整個行程崩潰；
  • 主動呼叫 os.Exit(int) 退出行程時，defer 將不再被執行，
package main

import (
	"fmt"
	// "os"
)

func main() {
	fmt.Println("start")
	// panic("崩潰了")              // defer和之后的陳述句都不再執行
	// os.Exit(1)                  // defer和之后的陳述句都不再執行
	defer fmt.Println("defer")
	// go func() {
	// 	panic("崩潰了")
	// }()                         // defer不被執行
	// panic("崩潰了")             // defer會執行，但后面的陳述句不再執行
	fmt.Println("over")
	// os.Exit(1)                  // defer不被執行
}

八、內置函式

內置函式 介紹
close 主要用來關閉channel
len 用來求長度，比如string、array、slice、map、channel
new 用來分配記憶體，主要用來分配值型別，比如int、struct，回傳的是指標
make 用來分配記憶體，主要用來分配參考型別，比如chan、map、slice
append 用來追加元素到陣列、slice中
panic和recover 用來做錯誤處理

panic和recover

Go語言中目前是沒有例外機制，但是使用panic/recover模式來處理錯誤， panic可以在任何地方引發，但recover只有在defer呼叫的函式中有效，

package main

import (
	"fmt"
)

func main() {
	fmt.Println("start")
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("recover")
			fmt.Println("活了")
		}
	}()

	panic("panic")
	fmt.Println("over")
}

運行結果

start
recover
活了

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/195907.html

標籤：Go

上一篇：Go module 本地導包方式

下一篇：4-Docker容器資料卷

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂