语言大杂烩（1）

发表于 更新于 分类于 阅读次数：

因为学的语言太多了所以记得有点混乱了，做个笔记记录一下各个语言的基础语法，分别是C、Go、Rust、TS、Python、Java、Dart的基础语法

数据类型、变量常量、条件判断、循环、函数

C语言
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// 基本数据类型：char、unsigned char、signed char、int、unsigned int、short、unsigned short、long、unsigned long、float、double、long long、long double、void
// 引入stdbool.h后可以使用布尔
extern int i; // 声明
int j; // 定义、未初始化，值未知
int k = 1; // 定义、初始化
const int l = 1; // i内存的值只读，定义必须同时初始化，否则报错
#define pi 3.14159;
int m = l; // 大部分编辑器执行到这一行时才会为l分配内存
int n = pi; // 预编译后这一行代码变成int n = 3.14159

int x; // 函数外定义，相当于全局变量
int y;
int addtwonum() { // 函数定义，格式：返回值 函数名(参数){ 函数体 }
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;
    extern int y;
    // 给外部变量（全局变量）x 和 y 赋值
    x = 1;
    y = 2;
    return x+y;
}

#include <stdio.h> // 引入头文件，# include 头文件 作用是预编译时将头文件内容替换这一行include

// main并不是真正的入口函数，真正的入口需要看编译器和可执行文件格式。
int main() { // 写代码时程序入口，标准返回值类型是int，用于表示程序是否正常执行，0表示正常，其他表示不正常。
    int result = addtwonum(); // 调用函数 addtwonum
    printf("result 为: %d",result);

    if (true) {
        printf('if')
    } else if (true) {
        printf('else if')
    } else {
        printf('else')
    }

    true ? printf("true") : printf("false") // 三元形式

    // 除了if还有switch，但是我不喜欢switch，只用if就够了。

    while (true) { // 还有do。。。while
        printf("这里无限循环打印")
    }

    for (int a = 10; a < 20; a = a + 1) {
        printf("a 的值： %d\n", a);
    }

    // break退出循环、continue下一次循环、goto
 
    return 0;
}

// 作用域：c只有全局作用域、函数作用域、块作用域，没有闭包作用域
int i = 1; // 全局作用域，i是1
void func() {
    int i = 2; // 函数作用域，这时候访问i是2
    if(1) {
        int i = 3; // 块作用域这时候访问i是3
    }
}
Go语言
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// 基本数据类型：uint8、uint16、uint32、uint64、int8、int16、int32、int64、uint、int、bool、byte、rune（int32）、string、float32、float64
package main
import "fmt" // 导入标准库包
var i int = 123 // 全局变变量，当前main包可访问，全局变量只能用var name type = xx形式
var I int = 123 // 全局变变量，大写开头，其他包可访问
const j int = 123 // 常量，值不可修改

func main() { // main没有返回值，错误退出可以用os.Exit(code)
    str := "Runoob" // 象牙符，由go推导类型，这里是string
    fmt.Println(str)

    if true {
        fmt.Println("true")
    } else if true {
        fmt.Println("这行不会执行")
    } else {
        fmt.Println("else,这里同样不执行")
    }

    // go没有三元，switch一样能用来做条件，但是并发用来接收通道传递的值更加常用

    for {
        fmt.Println("无限循环")
    }
    for i := 0; i < 10; i++ { // i是块级作用域，离开for后不可访问
        fmt.Println(i)
    }
    for key, val := aMap {} // 假如前面定义了aMap是一个字典
    for index, val := []int[1,2,3] {} // 获取元素下标和值
    for index, val := "你好" {} // val是rune值，index是字节位
    c := make(chan int)
    go func() {
        c <- 1
        c <- 2
        close(c)
    }()
    for v := range c {} // 拿到通道值

    // break退出循环、continue下一次循环
    // 如果上面的key，index，val不想要，用 _ 代替

    a, b := return1and2() // 多个返回值，用多个变量接收，如果不想要就用 _ 代替，比如a, _ := xx()
}

func return1and2() (int, int) {
    return 1, 2 // go能够返回多个值
}
js/ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 基础类型：string、number、bigint、boolean、undefined、symbol、null、object
// ES标准常见类型：String、Number、BigInt、Boolean、Undefined、Symbol、Null、Object、Date、Function、AsyncFuntcion、Array、ArrayBuffer、xxxArray、Error、(Weak)Map、(Weak)Set、Proxy、RegExp
// 还有很多，看：https://tc39.es/ecma262/#sec-ecmascript-language-types
i = 1 // 如果在浏览器环境执行，i挂载到window，相当于缩写了window.
var j = 2 // 全局作用域（其实不一定，还要看js虚拟机，在某些地方是读不到这个j），在最外层使用var同样挂载到window，ts环境下推到出j是number
let k = 3 // 全局，不挂载到window
const l = 4 // 全局，不挂载到window，值只读

// 脚本语言，没有入口，从上到下执行

 // ts推导出返回值是number,所以第三个:number可以缩写
function sum(a: number, b: number): number {
    return a + b
}

console.log(sum(i,j))

function fn() {
    if (true) {
        console.log(true)
    } else if (false) {
        console.log(false)
    } else {
        console.log('else')
    }
    for (;;) {} // 普通for和其他语言语言
    let arr = [1,2,3]
    for (const item of arr) {} // 有点像go的for range
    // 有break continue

    // es6之后有块级作用域，es5前没有
    let i = 1
    if (true) {
        let i = 2    // 这时i是2
    }
    // 这时i是1
}

function func1(i: number) {
    return function(j: number) {
        return i + j // 这里捕获i，作为闭包
    }
}
let i1 = func1(1)
console.log(i1(2))
Java Test.java
1
2
3
4
5
6
7
// java基础类型：byte、short、int、long、float、double、boolean、char
// 引用类型：类

// java不能写全局变量，所有数据需要在类里
public class Test { // 一个文件只能有一个类，而且要和文件名一致

}

复杂类型、类、方法