當前位置：聚優網>聚優網>教育>如何學好一門編程語言？

如何學好一門編程語言？

時間：2022-04-01 14:32:37 教育

如何學好一門編程語言？

　　學好一門編程語言是十分不容易的，但是如果學會了，它的實用性是很強的，下面小編為大家整理了學好一門編程語言的辦法，大家可以參考借鑒。

　　如何學好一門編程語言?

　　一、多總結

　　多總結才能加深理解、增強記憶。舉例，Go 中有 slice、map、channal 類型，它們都可以用 make 生成實例，但 slice 和 map 還可以用以下形式初始化，也是編程規范中建議的初始化方式：

　　colors := map[string]string{}

　　slice := []int{}

　　但注意了，channal 則沒有這樣的語法：msg := chan string{}

　　上面兩句是生成實例，表示空集合，但下面兩句則表示實例不存在，值為 nil

　　var colors map[string]string

　　var slice []int

　　另外，結構體指針 slice 還可以象下面這樣初始化，結構體實例不用明確地指定類型(使用了類型推導)、不用明確地取地址運算(&)。

　　type Product struct {

　　name string

　　price float64

　　}

　　products := []*Product{{"Spanner", 3.99}, {"Wrench", 2.49}, {"Screwdriver", 1.99}}

　　看到沒有，如果不經常總結，這一圈學下來會把你整的稀里糊涂的。

　　二、多比較

　　學一門新語言一定要與你之前已經熟悉的語言經常作比較，找出它們的相同與不同，這樣才能加深記憶和理解，否則學完之后腦子里會一片混亂，搞不清誰是誰非了。

　　就拿數組來說吧，在 Java、Scala、Go 中定義、實例化、賦值是不一樣的。

　　//Java

　　int[] arr;//定義數組，不可以指定數組長度

　　arr = new int[5];//創建數組對象(實例化)，指定數組長度

　　arr[1] = 8;//賦值

　　//Scala

　　val arr = new Array[Int](5) //數組在Scala里用的是泛型類，構造函數參數指定數組大小

　　arr(1) = 8 //賦值，注意用的是括弧

　　//Go

　　arr := [5]int{} //創建數組，初始化5個元素都為0，注意如果不指定數組長度，則是另外一種類型Slice

　　arr[1] = 8 //賦值

　　再比如 Map 在 Scala 與 Go 語言里定義、初始化、訪問也是不同的，作了以下比較后印象會非常深刻，把它們記下來，這樣以后使用就不會搞混了。

　　//Scala

　　val capital = Map("France" -> "Paris", "Japan" -> "Tokyo")

　　println(capital.get("France"))

　　//Go

　　capital := map[string]string{"France": "Paris", "Japan": "Tokyo"}

　　fmt.Println(capital["France"])

　　Go 同時給多個變量賦值在 Scala 里可以用模式匹配做到，如下：

　　//Scala(使用樣本類的模式匹配)

　　case class Tao(name: String, age: Int);

　　val Tao(myName, myAge) = Tao("taozs", 18);

　　println(myName)

　　println(myAge)

　　//Go

　　myName, myAge := "taozs", 18

　　fmt.Println(myName)

　　fmt.Println(myAge)

　　//Scala(使用元組的模式匹配)

　　val (myNumber, myString) = (123, "abe")

　　println(myNumber)

　　println(myString)

　　//Go

　　myNumber, myString := 123, "abe"

　　fmt.Println(myNumber)

　　fmt.Println(myString)

　　以下是 Scala 和 Go 定義和實現函數的區別：

　　//Scala

　　val increase: Int => Int = (x: Int) => x + 1

　　println(increase(8))

　　//Go

　　var increase func(int) int = func(x int) int { return x + 1 }

　　fmt.Println(increase(8))

　　除了在 Scala 和 Go 里都可以類型推導外，在 Scala 里還可以這樣定義函數：

　　//Scala

　　val increase = (_: Int) + 1

　　為方便自己將來隨時查閱，可以建立下面這樣的對比表格，描述不一定要求規范，自己能看懂就行。

　　三、轉變思維方式，

　　學會用這門語言去思考

　　學會用語言去思考是關鍵。如果你以前是學 C 的，轉學 Java，你一定要改變以前面向過程的思維，學會用面向對象的思維去分析問題;以前學 Java 的，轉學 Scala 則要學會用函數式的編程思維解決問題。

　　舉一個函數式編程的例子，以下是 Java 語言常用的 for 循環，循環變量從 1 到 10 執行 10 次循環體：

　　// 命令式編程

　　for (int i = 1; i < 10; i++) {

　　// 此處是循環體做10次

　　}

　　這被稱為命令式編程 (Imperative Programming)，但學了 Scala 的函數式編程 (Functional Programming) 后，解決同樣的問題，我們可以換一種思維：構建 1 到 10 的列表序列，針對列表中的每個元素分別執行函數，如下：

　　//函數式編程

　　val autoList = (1 to 10).map(i => /*此處是函數體，針對1到10的每一個分別調用 1次*/)

　　已經習慣了 Java 編程的，對 Scala 的函數式編程、樣本類、模式匹配、不可變對象、隱式轉換等需要一個逐步適應的過程，要漸漸學會用它們思考和解決問題。

　　再舉個 Scala 與 Go 思維方式不同的例子，要實現對一個字符串里的每個字符加 1 的操作，Scala 里可以這樣：

　　"abc".map(cc => cc + 1)

　　"abc"是一個字符串對象，調用它的方法 map，這是純面向對象的思維，但在 Go 里就要轉變為面向過程的思維：

　　name := "abc"

　　second := strings.Map(func(x rune) rune {

　　return x + 1

　　}, name)

　　注意，這里的 strings 是包 (package)，調用它的公共函數 Map，被人操作的對象 name 字符串作為函數參數傳入。Go 提供的函數 len、cap、append、等其實都是面向過程的，雖然 Go 也提供有面向對象的支持，已經習慣了面向對象編程的，剛開始學 Go 語言需要特別留意這一點。

　　四、多看開源代碼

　　學一門語言就是學一種思維方式，如今 GitHub 上可下載的開源代碼海量級，通過看別人的代碼，學習別人是如何解決問題的，養成用該語言思考的習慣，另外還能學習到一些非常有用的技巧，比如我在看一個 Go 語言性能測試框架代碼時看到有以下寫法：

　　func main() {

　　defer profile.Start().Stop()

　　...

　　}

　　這個意思是指剛進入程序時執行 Start( ) 函數，程序退出前調用 Stop( ) 函數，非常好的技巧啊!可以用于需要在程序執行前和程序完成后分別執行一段邏輯的場景。再看 Start( ) 函數是怎么實現的：

　　func Start(options ...func(*Profile)) interface {

　　Stop()

　　} {

　　...

　　return &prof