go是高级语言吗

2023-05-14 19:05:08 语言 高级

Go是高级语言。Go语言是Google公司在2009年开源的一门高级编程语言，它为解决大型系统开发过程中的实际问题而设计，支持并发、规范统一、简单优雅，性能强大；它的主要目标是“兼具 python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性”。

go是高级语言吗

本教程操作环境：windows7系统、GO 1.18版本、Dell G3电脑。

计算机语言具有高级语言和低级语言之分。而高级语言又主要是相对于汇编语言而言的，它是较接近自然语言和数学公式的编程，基本脱离了机器的硬件系统，用人们更易理解的方式编写程序。编写的程序称之为源程序。

高级语言并不是特指的某一种具体的语言，而是包括很多编程语言，如流行的go语言，java，c，c++，C#，pascal，Python，lisp，prolog，FoxPro，易语言，中文版的C语言等等，这些语言的语法、命令格式都不相同。

Go语言是Google公司在2009年开源的一门高级编程语言，它为解决大型系统开发过程中的实际问题而设计，支持并发、规范统一、简单优雅，性能强大，被很多Go语言传道者誉为“云计算时代的C语言”。Go语言的主要目标是“兼具 Python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性”。

1.png

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视频教程、编程教学】

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是高级语言吗的详细内容，更多请关注其它相关文章！

相关文章