go是不是高級語言

這篇文章主要介紹“go是不是高級語言”，在日常操作中，相信很多人在go是不是高級語言問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”go是不是高級語言”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

go是高級語言。Go語言是Google公司在2009年開源的一門高級編程語言，它為解決大型系統開發過程中的實際問題而設計，支持并發、規范統一、簡單優雅，性能強大；它的主要目標是“兼具 Python 等動態語言的開發速度和 C/C++ 等編譯型語言的性能與安全性”。

計算機語言具有高級語言和低級語言之分。而高級語言又主要是相對于匯編語言而言的，它是較接近自然語言和數學公式的編程，基本脫離了機器的硬件系統，用人們更易理解的方式編寫程序。編寫的程序稱之為源程序。

高級語言并不是特指的某一種具體的語言，而是包括很多編程語言，如流行的go語言，java，c，c++，C#，pascal，python，lisp，prolog，FoxPro，易語言，中文版的C語言等等，這些語言的語法、命令格式都不相同。

Go語言是Google公司在2009年開源的一門高級編程語言，它為解決大型系統開發過程中的實際問題而設計，支持并發、規范統一、簡單優雅，性能強大，被很多Go語言傳道者譽為“云計算時代的C語言”。Go語言的主要目標是“兼具 Python 等動態語言的開發速度和 C/C++ 等編譯型語言的性能與安全性”。

Go語言有時候被描述為“C 類似語言”，或者是“21 世紀的C語言”。Go 從C語言繼承了相似的表達式語法、控制流結構、基礎數據類型、調用參數傳值、指針等很多思想，還有C語言一直所看中的編譯后機器碼的運行效率以及和現有操作系統的無縫適配。

Go的優缺點

程序員的心聲：如果現實世界需要我能夠在幾天內對一個生產系統進行原型設計、測試和部署，而且在每秒能處理比原來多5倍請求，CPU和內存的開銷還都很小。我想大概只有Go語言可以勝任了。

Go語言有如下優點：

• 單獨的二進制發布：Go項目編譯會生成一個靜態的可執行文件。該文件可獨立運行而不需要其他依賴。這種方式特別適合于云原生容器環境。

• 交叉編譯：在任何操作系統上都可以編譯在其他平臺上可運行的二進制文件。比如在Mac系統上可編譯出在Linux和Windows上可運行的二進制文件。

• 垃圾回收：Go語言支持垃圾回收。相比較，C++，Rust等需要開發者自己控制。

• 執行性能：Go非常的快。性能接近于C++。遠高于Java，Python、Node。

• 開發效率：Go語言同時具備靜態語言的運行性能和動態語言的開發效率。

• 簡單，高效：Go語言的設計哲學里就包括了簡單和高效。一個典型的反例就是復雜，臃腫的Java語言。

• 并發性：語言層面支持并發，通過協程和通道簡化并發開發，提高并發性能。

• 豐富的標準庫：Go標準庫覆蓋了文本，IO，網絡，加密，Web服務，遠程RPC，模板引擎等功能。

• 可以調用C語言：可以調用C語言函數，進一步優化性能，復用C語言龐大的生態系統。

• 快速編譯時間：Go的編譯特別快。大家可以參考兩款靜態博客生成系統，Hexo(Node開發)和Hugo(Go開發)。

• 工程型：Go語言設計的目的就是成為一門工程語言，解決實際的工程問題。Go語言定義了開發規范，并提供了豐富的工具。使用Go語言可以編寫出容易閱讀和理解，容易測試、維護和擴展的程序。

Go語言有如下缺點：

• 缺少重量級框架。如Ruby的Rails，Python的Django，Java的Spring。

• 錯誤處理：沒有異常系統。Go官方正在解決該問題。

• 軟件包管理：很長時間以來，Go官方都沒有一套軟件包管理體制。直到最近，Go的1.13版本正式引入了Go Module作為官方的依賴管理工具。

• 不是標準的面向對象的編程模型：這個也是Go語言的一個創新。如果你是堅實的OOP的擁護者，可能會有些不適應

golang高級語法

rune

package main

import "fmt"

//rune相當于go的char  使用utf8編碼，中文占3個字節，英文一個字節

func main() {
	s:= "ok我愛你"
	fmt.Println(len(s))    // 11
	fmt.Println(len([]rune(s)))  // 5
	fmt.Println(len([]byte(s)))  // 11

	// str是int32類型
	for i, str := range s {
		fmt.Printf("%d %c", i, str)
		fmt.Println()
	}

	// str是byte類型
	for i, str := range []byte(s) {
		fmt.Printf("%d %x", i, str)
		fmt.Println()
	}

	// str是rune類型
	for i, str := range []rune(s) {
		fmt.Printf("%d %c", i, str)
		fmt.Println()
	}


}

slice切片

• slice的底層是數組

• slice是對數組的view

• slice可以向后擴展，不可以向前擴展

• s[i]不可以超過len(s), 向后擴展不可以超越底層數組cap(s)

• slice內部維持了3個變量，ptr指針指向slice的第一個元素，len指定了slice的長度，cap指定了slice的容量。

• slice進行append時，容量不夠會進行翻倍。

有如下
arr := [...]{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
則
s1值為[2,3,4,5],  len(s1)=4, cap(s1)=6 
s2值為[5,6], len(s2)=2, cap(s2)=3
slice底層是數組
slice可以向后擴展，不可以向前擴展
s[i]不可以超過len(s), 向后擴展不可以超越底層數組cap(s)

接著上題
arr := [...]{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
s3 := append(s2, 10)
s4 := append(s3, 11)
s5 := append(s4, 12)
則
s1值為[2,3,4,5]
s2值為[5,6]
s3值為[5,6,10]
s4值為[5,6,10,11]
s5值為[5,6,10,11,12]
arr值為[0, 1, 2, 3, 4, 5, 6, 10]

由于s4和時s5已經超過arr的cap，此時系統會生成一個新的數組，所以s4和s5是對新數組的view，即s4和s5 no longer view arr

• 添加元素時如果超越cap，系統會重新分配更大的底層數組，原來的數組被拷貝過去，如果原來的數組沒人用則會被gc

• 由于值傳遞的關系，必須接受append的返回值

map

• go語言所以類型都有默認值

• 當map取值的key不存在時，只會返回默認值，不會報錯。判斷key存不存在用 key, ok := m[“key”]

• map使用哈希表，作為map的key必須可以比較相等

• 除了slice，map， function的內建類型都可以作為key

• struce類型不包含上述字段，也可以作為key

struct

• 只有使用指針才可以改變結構體內容

• nil指針也可以調用方法

• 如何擴充系統類型或者別人的類型：通過結構體繼承，通過類型起別名

package main


// 如何擴充系統類型或者別人的類型：通過結構體繼承，通過類型起別名
type queue []int

func (q *queue) push(v int) {
	*q = append(*q, v)
}

func (q *queue) pop() int {
	head := (*q)[0]
	*q = (*q)[1:]
	return head
}

func (q *queue) isEmpty() bool {
	return len(*q) == 0
}

func main() {

}

• 值接受者vs指針接受者，

• 值接受者是go語言特有

• 要改變內容必須使用指針接受者，

• 結構過大也考慮使用指針接受者。

• 值/指針接受者都可以調用值/指針調用

package main

import "fmt"

type node struct {
	value int
	left, right *node
}

func newNode(value int) *node{
	return &node{
		value: value,
		left:  nil,
		right: nil,
	}
}

func (n node) setVal(val int) {
	n.value = val
}

func (n *node) setValue(vall int) {
	n.value = vall
}

func (n node) print() {
	fmt.Println(n.value)
}

func (n *node) travel() {
	if n == nil {
		return
	}

	fmt.Println(n.value)
	n.left.travel()
	n.right.travel()
}

func main() {

	var root node
	root = node{}
	root.left = &node{value:5}
	root.right = new(node)
	root.left.right = &node{4, nil, nil}
	root.right.left = newNode(7)
	
	// 調用指針方法，相當于引用傳遞，可以改變外部的值
	root.left.setValue(100)
	fmt.Println(root.left.value)
	
	// 值傳遞，調用值方法，方法內部不能改變外部值
	root.left.setVal(99)
	fmt.Println(root.left.value)
	
	// 先序遍歷
	root.travel()
}

interface

• 多用接口組合

defer

• panic和return都不影響defer的調用

到此，關于“go是不是高級語言”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！