Go语言—变量、数据类型、控制结构

Go 语言基础语法:变量、数据类型与控制结构 在上述代码中,先声明了一个 int 类型的变量 num 和一个 string 类型的变量 str,随后对它们进行赋值,并使用 fmt.Printf 函数输出变量的值。在上述代码中,funcWithMultiReturns 函数返回两个值,通过匿名变量 _ 忽略了返回的 int 类型值,仅获取了 string 类型值。Go 语言中,不同类型的变量在进行运算或赋值时,常常需要进行类型转换。当 Go 语言编译器能够根据初始化值推断出变量的数据类型时,可省略类型声明,使用 := 进行变量声明和初始化:​。 阅读详情

第一个Go程序

第一个简单的HelloGo程序hello.go

package main

import (
	"fmt"
)

func main() {
	fmt.Println("hello,Go!")
}
  • 定义一个包名位main,main是可执行程序的包名,所有Go源文件必须有一个包声明语句,通过包名管理命名空间
  • import 引入一个外部包 fmt,可以是标准库的包,也可以是第三方自定义的包,fmt是标准输入/输出包
  • func 关键字声明定义一个函数,函数名为main,main代表程序的入口函数
  • 调用fmt包里的Println函数打印一句话

注意:

  • 源程序以.go结尾
  • 默认为UTF-8编码
  • 标识符区分大小写
  • 语句结尾分号可以忽略不写
  • 函数以func开头,函数体的{必须在函数头所在行尾部,不能单独起一行
  • 调用包里方法通过.访问符
  • main函数所在的包名必须是main

标识符和关键字

标识符用来定义变量、类型、常量等语法对象的符号名称,不能使用语言预留的标识符,会导致歧义

Go的标识符构规则:标识符由若干个字母、下划线_、和数字组成,且第一个字符必须是字母。字母区分大小写,Unicode可以作为标识符构成,但不建议这样使用。不能包含空格。
注意:

  • 标识符的命名要尽量采取简短且有意义;

  • 不能和标准库中的包名重复;

  • 为变量、函数、常量命名时采用驼峰命名法,例如 stuName、getVal;
    在这里插入图片描述

  • 关键字:语言保留的特定语法含义的标识符

  • 数据类型标识符:语言基本的内置类型,用在变量和常量声明,Go是强类型静态编译型语言,可以自动推到类型,但定义新的类型时必须指定类型标识符

  • 常量标识符:代表一个常量值,表达特殊的含义

  • 空白标识符:_用来声明一个匿名的变量,在赋值表达式的左端,空白标识符也通常被用作占位,比如忽略多个返回值中的一个

  • 内置函数:是高级语言的一种语法糖,由于语言内置,不需要使用import来引入,内置函数具有全局可见性

变量和常量

通过一个标识符绑定一块内存地址,如果内训可以修改,则为变量,不能修改为常量
基本类型变量声明:

  1. 显示完整声明

    var 变量名 类型 [ = 值]
    
  • 变量声明后会立即为其分配空间
  • 不指定初始值默认初始化为零值
  1. 短类型声明

    变量名 := 值
    
  • :=这只能出现在

  • Go 编译器会自动进行数据类型推断

  • Go 支持多个类型变量同时声明并赋值
    如:

    a , b := 1 , "hello"
    

Go 语言提供自动内存管理,不需要关心变量的生存期和存放位置,编译器使用栈逃逸技术能够自动为变量分配空间:可能在栈上,也可能在堆上。

常量
常量分为布尔类型、字符串类型、数值型常量,存储在只读段里。
预声明标识符itoa用在常量声明中,初始值为0。一组多个常量同时声明其值逐行增加,itoa可以看作自增的枚举变量,专门用来初始化常量。

	//类似枚举的iota
	const (
		c0 = iota // c0 == 0
		c1 = iota // c1 == 1
		c2 = iota // c2 == 2
	)

	//简写模式
	const (
		c0 = iota // c0 == 0
		c1        // c1 == 1
		c2        // c2 == 2
	)

	//分开的const语句
	const x = iota // x == 0
	const y = iota // y == 0

基本数据类型

布尔型
关键字bool,取值true和false
声明的bool变量如果不初始化,默认为false

var ok bool
ok = true

或者

ok := false

bool类型与整数类型不能相互转换
bool类型用在:比较表达式和逻辑表达式的结果,if和for的条件部分一定是布尔类型的值或表达式

整型
不同类型的整形必须进行强制类型转换

var a int = 1
var b int32 = 2
b = a //error

整形支持算术运算和位运算,算术表达式和位操作的结果还是整型

var a int = (1 + 2) * 3
var b int = 1000 >> 2

浮点型
用于表示包含小数数据,有两种类型分别是float32和float64
浮点数自动类型推倒位float64

var b := 10.00 

计算机很难对浮点型数精确存储,两个浮点数之间不要用==或!=进行比较,高精度科学计算使用math

复数型
在计算机中使用两个浮点数表示,一个表示实部,一个表示虚部,complex64是由两个float32构成的,complex128是由两个float64构成的。复数的字面量表示和数学表示法一样。

var v1 complex64 = 3.1 + 5i
v2 := 3.1 + 6i

//Go有三个函数处理复数
var v = complex(2.1, 3) //构造一个复数
a := real(v1)           //返回复数的实部
b := image(v2)          //返回复数的虚部

字符串类型

  • 字符串初始化可以使用字符串字面常量
var a = "hello world"
  • 字符串是常量,可以通过类似数组索引访问字节单元,但不能修改某字节的值
var a = "hello,world"
b := a[0]
a[1] = 'a' //error
  • 字符串转换为切片[]byte(s)时候要慎用,尤其是数据量较大时候,每次转换都需要赋值大量的内容
a := "hello,world"
b := []byte(a)
  • 字符串末尾不包含NULL字符,和C/C++不一样
  • 字符串底层实现是一个二元数据结构,一个是指向字节数组的起点,另一个是长度,如:
type stringStruct struct {
	str unsafe.Pointer	//指向底层字节数组的指针
	len int	//字节数组的长度
}
  • 基于字符串创建的切片和源字符串指向相同的底层字符串数组,一样不能修改,对字符串的切片操作返回的子串仍然是string,而非slice
a := "hello,world"
b := a[0:4]
c := a[1:]
d := a[:4]
  • 字符串和切片的转换:字符串可以转换为字节数组,也可以转换为Unicode的字数组
a := "hello,world"
b := []byte(a)
c := []rune(a)
  • 字符串的运算:拼接、求长度、遍历
a := "hello"
b := "world"
c := a + b	//字符串拼接
len(a)	//len函数获取字符串的长度
d := "hello,世界"
//遍历字节数组
for i := 0; i<len(d); i++ {
	fmt.Println(d[i])
}
//遍历rune数组
for i, v :=range d {
	fmt.Println(i,v)
}

rune类型
Go内置两种字符类:1.byte的字节类型;2.表示Unicode编码的字符rune。
rune在Go内部是int32类型的别名,占用4个字节。
Go语言默认字符编码就是UTF-8类型的,如果需要特殊的编码转换,使用Unicode/UTF-8标准包。

复合数据类型

复合类型是由其他类型组合而成的类型。
Go的基本符合数据类型有:指针、数组、切片、字典、通道、结构、接口。

指针
指针的声明类型为*T, Go同样支持多级指针**T。通过在变量名前面加&来获取变量的地址。

  • 在赋值语句中,*T出现在“=”左边表示指针声明,*T出现在“=”右边表示取指针指向的值(varName为变量名)。
var a =ll
p := &a
  • 结构体指针访问结构体字段仍然使用“.”点操作符,Go语言没有“>”操作符。
	type User struct {
		name string
		age  int
	}
	andes := User{
		name: "andes",
		age:  18,
	}
	p := &andes
	fmt.Println(p.name) //p.name通过“.”操作符访问成员变量
  • Go不支持指针的运算。Go由于支持垃圾回收,如果支持指针运算,则会给垃圾回收的实现带来很多不便,在C和C++里面指针运算很容易出现问题,因此Go直接在语言层面禁止指针运算。
	a := 1234
	p := &a
	p++ //不允许,报non-numeric type*int错误
  • 函数中允许返回局部变量的地址。
    Go编译器使用“栈逃逸”机制将这种局部变量的空间分配在堆上。
func sum(a, b int) *int {
	sum := a + b
	return &sum //允许,sum会分配在heap上
}

数组
数组的类型名是[n]类型,其中n是数组长度。比如一个包含2个int类型元素的数组类型可表示为[2]int。数组一般在创建时通过字面量初始化,单独声明一个数组类型变量而不进行初始化是没有意义的。

	var arr [2]int                       //声明一个有两个整型的数组,但元素默认值都是0,一般很少这样使用
	array := [...]float64{7.0, 8.5, 9.1} //[...1后面跟字面量初始化列表
  • 数组的初始化
a := [3]int{1, 2, 3}   //指定长度和初始化字面量
a := [...]int{1, 2, 3} //不指定长度,但是由后面的初始化列表数量来确定其长度
a := [3]int{1: 1, 2: 3}   //指定总长度,并通过索引值进行初始化,没有初始化元素时使用类型默认值
a := [...]int{1: 1, 2: 3} //不指定总长度,通过索引值进行初始化,数组长度由最后一个索引值确定,没有指定索引的元素被初始化为类型的零值
  • 数组的特点
    (1)数组创建完长度就固定了,不可以再追加元素。
    (2)数组是值类型的,数组赋值或作为函数参数都是值拷贝。
    (3)数组长度是数组类型的组成部分,[10]int和[20]int表示不同的类型。
    (4)可以根据数组创建切片。
  • 数组元素访问
a := [...]int{1, 2, 3}
b := a[0]
for i,v := range a {
	//...
}
  • 数组长度
a :=[...]int{1,2,3}
alength := len(a)
for i:=0; i<alength; i++ {
	//...
}

切片(slice)
数组的定长性和值拷贝限制了其使用场景,Go提供了另一种数据类型slice(切片),这是一种变长数组,其数据结构中有指向数组的指针,所以是一种引用类型。
在Go中,几乎所有场景,可以使用切片代替数组

ll type slice struct {
	array unsafe.Pointer
	len int
	cap int
}

Go为切片维护三个元素:指向底层数组的指针、切片的元素数量、底层数组的容量。

  • 切片创建
  1. 由数组创建
    创建语法array [begin:end].
    array表示数组名;
    begin表示开始索引,可以不指定,默认是0;
    end表示结束索引,可以不指定,默认是len(array)。
    array[begin:end]表示一个包含end-begin个元素的切片(切片容量),第一个元素是aray[b],最后一个元素是array[e-1]。
    注意:按数组下标算,左闭右开,表示包含begin下表,不包含end下标
var array = [...]int{0, 1, 2, 3, 4, 5, 6}
s1 :=  array[0:4]	//[0 1 2 3]
s2 := array[:4]	//[0 1 2 3]
s3 := array[2:]	//[2 3 4 5 6]
  1. 内置函数make创建切片
a := make([]int, 10)	//len = 10, cap = 10, 结果为[0 0 0 0 0 0 0 0 0 0]
b := make([]int, 10, 15)	//len = 10, cap = 15, 结果为[0 0 0 0 0 0 0 0 0 0]
  1. 直接声明切片类型变量
var a []int	//结果为[]

直接声明切片类型变量是没有意义的,此时切片的底层的数据结构

  • 切片的操作
    内置函数len()返回切片长度。
    内置函数cap()返回切片底层数组容量。
    内置函数append()对切片追加元素。
    内置函数copy()用于复制一个切片。
	a := [...]int{0, 1, 2, 3, 4, 5, 6}
	b := make([]int, 2, 4)
	c := a[0:3]
	
	fmt.Println(len(b)) //2
	fmt.Println(cap(b)) //4
	
	b = append(b, 1)
	fmt.Println(b)      //[0 0 1]
	fmt.Println(len(b)) //3
	fmt.Println(cap(b)) //4
	
	b = append(b, c...)
	fmt.Println(b)      //[0 0 1 0 1 2]
	fmt.Println(len(b)) //6
	fmt.Println(cap(b)) //cap(b)=8,底层数组发生扩展
	
	d := make([]int, 2, 2)
	copy(d, c)          //copy只会复制d和c中长度最小的
	fmt.Println(d)      //[0 1]
	fmt.Println(len(d)) //2
	fmt.Println(cap(d)) //2

注意:
向切片增加元素时,切片的容量会自动增长。1024 以下时,一两倍方式增长。

  • 字符串和切片的相关转换
str := "hello world"
a := []byte(str)	///将字符串转换为[]byte类型切片
b := []tune(str)	//将字符串转换为[]rune类型切片

字典(map)
Go语言内置的字典类型叫map。map的类型格式是:map[K]T,其中K可以是任意可以进行比较的类型,T是值类型。map也是一种引用类型。

  • map的创建。
  1. 使用字面量创建。
ma := map[string]int {"a":1,"b":2}
fmt.Println(ma["a"])
fmt.Println(ma["b"])
  1. 使用内置make创建。
make(map[k]T)	//map的容量使用默认位
make(map[K)T , len) //map 的容量使用给定 len 值

mpl := make(map[int]string)
mp2 := make(map[int]string , 10) 

mpl[1] = "tom"
mp2[1] = "pony"
  • map支持的操作
    map的单个键值访问格式为mapName[key],更新某个key的值时mapName[key]放到等号左边,访问某个key的值时mapName[key]放在等号的右边。
    可以使用range遍历一个map类型变量,但是不保证每次迭代元素的顺序。
    删除map中的某个键值,使用如下语法:delete(mapName,key)。delete是内置函数,用来删除map中的某个键值对。
    可以使用内置的len()函数返回map中的键值对数量。
	mp := make(map[int]string)
	mp[1] = "tom"
	mp[2] = "pony"
	mp[3] = "jaky"

	delete(mp, 3)

	fmt.Println(len(mp)) //2

	for k, v := range mp {
		fmt.Println("key=", k, "value=", v)
	}
	//key= 1 value= tom
	//key= 2 value= pony

注意:
Go内置的map不是并发安全的,并发安全的map可以使用标准包sync中的map。
不要直接修改map value内某个元素的值,如果想修改map的某个键值,则必须整体赋值。

	type User struct {
		name string
		age  int
	}
	ma := make(map[int]User)
	andes := User{
		name: "andes",
		age:  18,
	}
	ma[1] = andes
	//ma[1].age = 19 //ERROR ,不能通过 map 引用直接修改
	andes.age = 19
	ma[1] = andes           //必须整体替换 value
	fmt.Printf(" %v\n", ma) //map[1:{andes 19}]

结构体(struct)
Go中的struct类型和C类似,由多个不同类型元素组合而成。这里面有两层含义:
第一,struct结构中的类型可以是任意类型;
第二,struct的存储空间是连续的,其字段按照声明时的顺序存放(注意字段之间有对齐要求)。
struct有两种形式:
一种是struct 类型字面量;
另一种是使用type声明的自定义struct类型。

  1. struct类型字面量。
    struct类型字面量的声明格式:
struct { 
    FeildName FeildType 
    FeildName FeildType 
    FeildName FeildType
}
  1. 自定义 truct 类型
    自定义 struct 类型声明格式如下
type TypeName struct { 
	FeildName Fe ldType
	FeildName FeildType 
	FeildName FeildType
}

实际使用struct字面量的场景不多,更多的时候是通过type自定义一个新的类型来实现的。
type是自定义类型的关键字,不但支持struct类型的创建,还支持任意其他子定义类型的创建。

	type Person struct {
		Name string
		Age  int
	}
	
	type Student struct {
		*Person
		Number int
	}
	
	//不推荐这种初始化方式,一旦truct加字段,则整个初始化语句会报
	a := Person{"Tom", 21}
	//推荐这种使用 Feild 名字的初始化方式,没有指定的字段则默认初始化为类型的零值
	p := &Person{
		Name: "tata",
		Age:  12,
	}
	s := Student{
		Person: p,
		Number: 110,
	}

控制结构

现代计算机存储结构无论“普林斯顿结构”,还是“哈佛结构”,程序指令都是线性地存放在存储器上。程序执行从本质上来说就是两种模式:顺序和跳转。

顺序就是按照程序指令在存储器上的存放顺序逐条执行。
跳转就是遇到跳转指令就跳转到某处继续线性执行。

顺序在Go里面体现在从main函数开始逐条向下执行,就像我们的程序源代码顺序一样;跳转在Go里面体现为多个语法糖,包括goto语句和函数调用、分支(if、switch、select)、循环(for)等。

跳转分为两种:一种是无条件跳转,比如函数调用和goto语句;一种是有条件的跳转,比如分支和循环。

if 语句
if后面的条件判断子句不需要用小括号括起来。
{必须放在行尾,和if或if else放在一行。
if后面可以带一个简单的初始化语句,并以分号分割,该简单语句声明的变量的作用域是整个if语句块,包括后面的else if和else分支。
Go语言没有条件运算符(a>b?a:b),这也符合Go的设计哲学,只提供一种方法做事情。
if分支语句遇到return后直接返回,遇到break则跳过break下方的if语句块。

if x <= y {
	return y
} else {
	return x
}

完整的if else 实例

if x := f(); x < y {
	return x
} else if x > z {
	return z
} else {
	return y
}

switch 语句
switch 语句会根据传入的参数检测井执行符合条件的分支。
switch和if 语句一样,switch后面可以带一个可选的简单的初始化语句。
switch后面的表达式也是可选的,如果没有表达式,则case子句是一个布尔表达式,而不是一个值,此时就相当于多重if else语句。
switch条件表达式的值不像C语言那样必须限制为整数,可以是任意支持相等比较运算的类型变量。
通过fallthough 语句来强制执行下一个case子句(不再判断下一个case子句的条件是否满足)。
switch 支持default 语句,当所有的case分支都不符合时,执行default 语句,并且default语句可以放到任意位置,并不影响 switch的判断逻辑。
switch和.(type)结合可以进行类型的查询,这个放到4.2节介绍。

switch i := "y"{//switch 后面可以带上一个初始化语
case "y","Y": //多个 case 值使用逗号分隔
	fmt.Println ("yes") //yes 
	fallthrough //fallthrough 会跳过接下来的 case 条件表达式,直接执行下一 case 语句
case "n","N":  
	fmt Println("no") //no
}

附加:
select 是一种类似于switch语法结构的分支语句。

for 语句

Go语言仅支持一种循环语句,即for语句。
Go对应C循环的三种场景如下。

  1. 类似C里面的for循环语句
for init;condition;post{ }
  1. 类似C里面的while 循环语句
for condition{ }
  1. 类似C里面的while(1)死循环语句
for{ }
  • for 语句对数组、切片、字符串、map、通道的访问
//访问map
for key, value := range map {}
for key := range map {}

//访问数组
for index, value := range array {}
for index := range array {}
for _, value := range array {}

//访问切片
for index, value := range slice {}
for index := range slice {}
for _, value := range slice {}

//访问通道
for value := range channel {}

标签和跳转

Go 语言使用标签(Lable)来标识一个语句的位置,用于goto、break、continue 语句的跳转,标签的语法是Lable:Statement。

  • goto
    goto语句用于函数的内部的跳转,需要配合标签一起使用,具体的格式如下:
goto Lable 

goto Lable的语义是跳转到标签名后的语句处执行,goto语句有以下几个特点:

  1. goto语句只能在函数内跳转。
  2. goto语句不能跳过内部变量声明语句,这些变量在goto语句的标签语句处又是可见的。例如:
goto L //BAD,跳过v:=3这条语句是不允许的
V:=3
L:

goto 语句只能跳到同级作用域或者上层作用域内,不能跳到内部作用域内。例如:

if n%2==1{
	goto L1
}
for n > 0 {
	f()
	n--
}
L1:
	fn()
	n--
  • break
    break用于函数内跳出for、switch、select语句的执行,有两种使用格式:
    单独使用,用于跳出break当前所在的for、switch、select语句的执行。
    和标签一起使用,用于跳出标签所标识的for、switch、select语句的执行,可用于跳出多重循环,但标签和break必须在同一个函数内。例如:
L1:
	for i := 0; ; i++ {
		for j := 0; ; j++ {
			if i >= 5 {
				break L1 //跳出L1标签所在的for循环break L1
			}
			if j > 10 {
				break //默认仅跳出离break最近的内层循环break
			}
		}
	}
  • continue
    continue 用于跳出for循环的本次迭代,跳到for循环的下一次迭代的post语句处执行,也有两种使用格式:
    单独使用,用于跳出continue当前所在的for循环的本次迭代。
    和标签一起使用,用于跳出标签所标识的for 语句的本次迭代,但标签和continue必须在同一个函数内。例如:
L1:
	for i := 0; ; i++ {
		for j := 0; ; j++ {
			if i >= 5 {
				continue L1 //跳出L1标签所在的for循环i++处执行
			}

			if j > 10 {
				continue //默认仅跳出离continue最近的内层循环j++处执行
			}
		}
	}
掌握Go语言数据类型与控制结构 本文深入探讨了Go语言中的数据类型、变量声明、类型转换、类型推断和零值概念。同时,我们还学习了控制结构和决策制定,包括条件语句、比较运算符和逻辑运算符的应用,为编写复杂和智能的Go程序打下坚实基础。 阅读详情

相关推荐

基于ADS\HFSS\Matlab的平面带通发夹滤波器设计

写在最前面,前段时间完成了一个小项目,实现13.5~14GHz的带通滤波器,算是第一个微波项目,在老师、学长、各种大神的指点下,最终完成了指标,想来这段时间收获良多,想到老师教导的,有能力的话要尽可能帮助别人,以及网络上很少面向于小白的教程,于是决定把自己做这个小项目的经过,一些关键步骤,还有软件操作和公式讲解都发出来,供大家指正借鉴。由于我目前大三,刚学习电磁场、微波工程等等,技术实在有限,同时这样是我第一次发帖子,只能尽可能的将自己确认过正确的内容,步骤以及一些经验写出来,供大家借鉴。

likaifeng12138的博客 5224

golang之unsafe包

环境 go version go1.14.4 linux/amd64 go语言中指针类型的限制 要说unsafe.Pointer, 不得不说这个话题. 学过c语言的同学都知道, p++, p--, p1 == p2这种代码在c语言太过常见. 但是go中的指针有很多的限制: 不能进行数学运算i := 3 p := &i p++ // Invalid operation: p++ (non-numeric type *int) p = &i + 5 // Invalid operation:

开心就好的专栏 1508

Python 驱动 CAD 二次开发:从零搭建自动化绘图环境

本文详细介绍了如何利用Python进行CAD二次开发,实现自动化绘图。通过win32com库建立Python与CAD软件的通信,文章从环境搭建、连接CAD、操作文档到核心绘图与批量处理,提供了完整的实战指南。该方法能显著提升机械设计、建筑绘图等领域的重复性工作效率,将创造力从繁琐劳动中解放出来。

weixin_29093169的博客 1241

go中的指针

指针的声明: a:=99 var b *int b=&amp;a c:=88 d:=&amp;c 这时指针b和d的内容是a和c的内存地址。 0xc042054080 0xc0420540b0 go中的指针是不能运算的: e:=55 f:=&amp;e f++ 报错: invalid operation: f++ (non-numeric type *in...

qq_20867981的博客 287

Windows/Linux双平台指南:3种方法快速释放被占用的GPU内存(含任务管理器替代方案)

本文详细介绍了在Windows和Linux双平台下快速释放被占用GPU内存的3种方法,包括任务管理器替代方案。从基础操作到高阶技巧,帮助用户彻底解决GPU内存驻留问题,提升计算资源利用率。特别适用于深度学习开发者和服务器管理员处理显存泄漏等常见问题。

j0k1l2m3n的博客 262

用了7年的 source insight 3.5 背景色及字体配置(提升code效率)

在此记录并share用了7年的 source insight 3.5 背景色及字体配置,提升阅读代码效率

Chasing Freedom 7531

【golang - 关键词】指针、引用、new、&

占坑待续

Start to go for my future! 555

【物理模拟】PBD算法详解

参考MatthiaMuller的十分钟物理(他就是PBD算法的发明者)

beidou111的博客 9501

Go 系列教程-5 基础知识

Go 系列教程 —— 15. 指针 什么是指针? 指针是一种存储变量内存地址(Memory Address)的变量。 如上图所示,变量 b 的值为 156,而 b 的内存地址为 0x1040a124。变量 a 存储了 b 的地址。我们就称 a 指向了 b。 指针的声明 指针变量的类型为 *T,该指针指向一个 T 类型的变量。 接下来我们写点代码。 package main i...

ytd7777的专栏 521

Simulink开发项1000例实战专栏--实例148:构建一个完整的电动汽车电池SOH评估仿真模型,包括电池建模模块、数据采集模块、SOH估算算法模块以及性能评估模块

电动汽车的动力电池是其核心部件,而电池的健康状态(State of Health, SOH)直接影响车辆的续航能力和使用寿命。SOH通常定义为当前电池容量与初始容量的比值,用百分比表示。通过基于MATLAB/Simulink平台的SOH评估仿真,可以实时监测电池的退化情况,并为电池管理系统(BMS)提供决策依据。本项目旨在构建一个完整的电动汽车电池SOH评估仿真模型,包括电池建模模块、数据采集模块、SOH估算算法模块以及性能评估模块,并通过仿真验证SOH评估的准确性。

xiaoheshang_123的博客 342

使用 MATLAB/Simulink 搭建一个步进电机细分控制系统的仿真模型

步进电机(Stepper Motor)是一种将电脉冲信号转换为角位移或线位移的执行元件,广泛应用于数控机床、3D打印、机器人、精密仪器等领域。其特点是开环控制、定位精度高、响应快、无累积误差。然而,传统步进电机在整步或半步运行时存在振动大、噪音高、转矩波动明显等问题。为了解决这些问题,细分控制技术被广泛采用。细分控制通过对绕组电流进行精确控制,使转子在两个整步之间实现平滑移动,从而提升电机的运行平稳性和位置精度。本教程将带你使用搭建一个步进电机细分控制系统的仿真模型,并通过仿真分析其。

amy_mhd的博客 429

golang基础语法

Go(又称 Golang)是 Google 的 Robert Griesemer,Rob Pike 及 Ken Thompson 开发的一种静态强类型、编译型语言。Go 语言语法与 C 相近,但功能上有:内存安全,GC(垃圾回收),结构形态及 CSP-style 并发计算

qq_52960593的博客 2523

作物生长模型Oryza V3实战9:控制文件参数详解

control.dat是ORYZA水稻模型的核心配置文件,主要包含三部分:1)基础参数设置与模拟时间定义;2)关键文件路径配置,包括土壤参数文件(soil.sol)、作物参数文件(cultivar.crp)、田间管理文件(manage.exp)及气象数据目录,同时指定输出结果文件(res.dat)和运行日志(model.log);3)可选参数和输出控制选项。该文件通过关联各类输入数据(气象、土壤、品种特性等)和输出结果,实现模型运行的全流程控制,支持参数调整后继续模拟和中断恢复功能。

221

Go语言基本语法

Go语言(通常称为Golang)是由Google开发的一种静态类型、编译型语言,它旨在简化系统编程、网络编程和并发编程的复杂性。Go语言以其简洁、高效和易于理解的语法而受到开发者的喜爱。

owolai的博客 1084

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

【Go入门篇】第二章:Go 语言中的变量、数据类型与控制结构

在上一章中,我们介绍了 Go 语言的基本特点和开发环境的搭建。本章将深入学习 Go 语言的 **基础语法**,包括变量、数据类型、运算符、控制结构等内容,帮助你更好地理解 Go 代码的基本构成。

分享技术,记录思考和感悟 565

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Go语言24小时极速学习教程(一)基础语法

Go语言(也称为Golang)是一种由Google开发的编程语言,以其简洁、高效和并发支持而闻名。从本文开始,将带你快速完成Go语言的学习,如果你之前有过Java或者C语言的基础,学习它将很容易,本教程忽略环境搭建步骤,直奔主题。

杨若瑜的技术博客 1601

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

【介绍下Golang的基本语法】

⭐Golang(通常称为Go)是一种由Google开发的静态类型、编译型语言,它具有简洁、高效和易于维护等特点,Go的设计哲学旨在简化编程任务,并提供快速的编译时间和高效的执行性能。⭐这只是Golang基本语法的一个快速概述,Go非常注重实践,推荐你通过编写实际的程序来进一步学习,你可以访问官方文档。:每个Go文件都以包声明开始,定义当前文件属于哪个包。关键字定义变量,Go也支持类型推断。:Go有基本的数据类型比如。

2301_81357485的博客 657

AgentScope 2.0 实战指南:从终端调试到 4 步上线多智能体服务

AgentScope 2.0 是阿里通义实验室开源的生产级多智能体框架,要求 Python 3.11+。本文按"本地调试 → 隔离执行 → 权限管控 → 服务化上线"的完整链路展开,帮你把真正敢放心的 AI 智能体交付成多租户在线服务。 ## 三个落地场景:AgentScope 能拿来干什么 先看架构不如先想用途。下面三个场景在仓库里都有可直接运行的示例: **场景一:终端代码助手。** 给

gitblog_00994的博客 847

Golang入门简介与基本语法学习_golang csdn(2),Golang详解

在Go语言中,函数是一等公民。函数的定义形式为。

2301_82244608的博客 1201

Go语言教程第二集 数据类型和控制语句

上节课的思考题是打印出自己的名字,这个作业比较简单,属于文本的替换,你只需要把我示例中的"Hello 世界"修改成自己的名字即可,比如以我的名字为例,替换为“飞雪无情”。经过上一节课的学习,你已经对 Go 语言的程序结构有了初步了解,也准备好了相应的开发环境。但是一个完整的项目需要更复杂的逻辑,不是简单的“Hello 世界”可相比的。这些逻辑通过变量、常量、类型、函数方法、接口、结构体组成,这节课我就将带你认识它们,让你的 Go 语言程序变得更加生动。变量代表可变的数据类型,也就是说,它在程序执行的过程中可

fegus的博客 308

Go语言自学笔记(一)

Go(又称Golang)是Google开发的一种静态强类型、编译型、并发型,并具有垃圾回收功能的编程语言。 Go语言的基本语句: package main //声明main包 import "fmt" //导入fmt包 func main(){ //创建主函数 fmt.Println("Hello go") //调用fmt包中的打印函数 } 需要注意的是: Go...

ialbo的博客 656

go语言的基础语法(变量、常量、基本数据类型,for、switch,case、数组、slice(切片)、make和new、map)

必须指定数组的长度//定义一个长度为5元素类型为int的数组avara[5]intvarb[5]bool补充数组可以通过下标进行访问,下标是从0开始,最后一个元素下标是len-1,访问越界(下标在合法范围之外),则触发访问越界,会panic。...

ydl1128的博客 542

go基础(一)基础数据类型与控制结构

基础数据类型与变量 基本数据类型 go语言提供了丰富的数据类型 整形 byte,int,int8,int16,int32,int64,还有uint等 浮点 float32,float64 字符串 string rune rune等同于int32,这里提一个用法,统计非unicode字符数,用rune 类型转换 go不支持隐式类型转换,必须显示指定,类似函数,valueOfTypeB = typeB(valueOfTypeA), demo a := 5.0 b := int(a) 变量 变量的定义相对灵活,

夏天的伞 525

Go 语言入门指南:从零开始掌握 Go 的核心概念

本文介绍了Go语言的基础知识,包括安装方法、基本语法和核心概念。首先展示了经典的"Hello, World!"程序示例,说明Go程序的基本结构。接着详细讲解了变量与常量的声明方式、数据类型以及控制结构(if、for、switch)。然后介绍了函数定义和方法的使用,包括多返回值和方法绑定。最后重点讲解了Go语言的并发特性,包括goroutine和channel的基本用法。全文循序渐进,帮助读者快速掌握Go语言的基础知识,为后续深入学习奠定基础。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1115

go语言怎么 控制一个变量输入的范围_四周入门Go语言(week01)

【零】Go语言特点与输入输出「特点」1. 风格统一:同一件事只有一种实现方法,不同的人写出的代码风格应一致。例如:定义的变量必须要使用,if语句括号位置固定,只有for循环,fmt包能自动对齐代码2. 易上手:简单易用是设计者的初衷3. 编译型语言:直接编译成二进制码(Python等解释型语言编译成字节码后,需要通过解释器变成二进制码),因此更快4. 从底层原生支持并发,从而能显著提高并...

weixin_39626745的博客 387
上一篇: Windows下Go安装&环境配置&编译运行
下一篇: Go语言—函数
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_peak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值