Carbon变量与常量 #

一、变量概述 #

Carbon是静态类型语言，变量必须声明类型或能被编译器推断。变量是存储数据的命名容器，可以在程序运行时修改。

二、变量声明 #

2.1 基本语法 #

使用 var 关键字声明变量：

carbon 
var name: String = "Carbon";
var age: i32 = 25;
var pi: f64 = 3.14159;

2.2 类型推断 #

Carbon支持类型推断，可以省略类型声明：

carbon 
var x = 42;           // 推断为 i32
var y = 3.14;         // 推断为 f64
var z = "Hello";      // 推断为 String
var flag = true;      // 推断为 bool

2.3 延迟初始化 #

变量可以先声明后初始化：

carbon 
var x: i32;
x = 42;

// 但必须在首次使用前初始化
Print("{0}", x);

2.4 变量修改 #

var 声明的变量可以修改：

carbon 
var count: i32 = 0;
count = 10;
count = count + 5;
Print("{0}", count);  // 输出: 15

三、常量声明 #

3.1 使用let #

使用 let 声明不可变值：

carbon 
let MaxSize: i32 = 100;
let Pi: f64 = 3.14159265359;
let AppName: String = "MyApp";

3.2 常量不可修改 #

carbon 
let x: i32 = 42;
x = 100;  // 编译错误：常量不能修改

3.3 编译时常量 #

某些常量可以在编译时计算：

carbon 
let BufferSize: i32 = 1024 * 4;
let MaxItems: i32 = 100;

四、变量命名 #

4.1 命名规则 #

  • 以字母或下划线开头
  • 后续可以是字母、数字或下划线
  • 区分大小写
carbon 
// 有效命名
user_name
total_count
_private_var
__internal__

// 无效命名
123var       // 不能以数字开头
my-var       // 不能包含连字符

4.2 命名约定 #

类型 约定 示例
局部变量 snake_case user_name
成员变量 snake_case_ name_
常量 PascalCase MaxSize
参数 snake_case input_value

4.3 语义化命名 #

carbon 
// 好的命名
var user_count: i32 = 100;
var is_active: bool = true;
var total_price: f64 = 99.99;

// 避免的命名
var x: i32 = 100;
var flag: bool = true;
var tp: f64 = 99.99;

五、作用域 #

5.1 块作用域 #

变量在声明它的块内有效：

carbon 
fn Example() -> i32 {
  var x: i32 = 10;
  {
    var y: i32 = 20;
    Print("{0}, {1}", x, y);  // x和y都可见
  }
  Print("{0}", x);   // x可见
  // Print("{0}", y); // 错误：y不可见
  return x;
}

5.2 变量遮蔽 #

内部块可以声明同名变量：

carbon 
fn Example() -> i32 {
  var x: i32 = 10;
  {
    var x: i32 = 20;  // 遮蔽外部的x
    Print("{0}", x);  // 输出: 20
  }
  Print("{0}", x);    // 输出: 10
  return 0;
}

5.3 函数参数作用域 #

carbon 
fn Add(a: i32, b: i32) -> i32 {
  // a和b在整个函数内有效
  var result: i32 = a + b;
  return result;
}

六、初始化 #

6.1 默认初始化 #

Carbon不提供默认初始化，变量必须显式初始化：

carbon 
var x: i32;  // 未初始化，使用前必须赋值
x = 42;
Print("{0}", x);

6.2 初始化表达式 #

carbon 
var a: i32 = 10;
var b: i32 = a + 5;
var c: i32 = Add(a, b);

6.3 列表初始化 #

carbon 
var arr: [i32; 3] = (1, 2, 3);
var tuple: (i32, String) = (42, "Hello");

七、类型注解 #

7.1 显式类型 #

carbon 
var x: i32 = 42;
var y: f64 = 3.14;
var z: String = "Hello";

7.2 auto类型 #

使用 auto 让编译器推断类型：

carbon 
var x: auto = 42;           // i32
var y: auto = 3.14;         // f64
var z: auto = "Hello";      // String

7.3 类型一致性 #

carbon 
var x: i32 = 42;
var y: i32 = x;     // 类型一致
// var z: String = x; // 错误：类型不匹配

八、变量生命周期 #

8.1 局部变量 #

局部变量在块结束时销毁：

carbon 
fn Example() -> i32 {
  var x: i32 = 42;  // x创建
  {
    var y: i32 = 10;  // y创建
  }  // y销毁
  return x;
}  // x销毁

8.2 所有权 #

Carbon采用所有权系统管理资源：

carbon 
fn Example() -> i32 {
  var s: String = "Hello";  // s拥有字符串
  var t: String = s;        // 所有权转移给t
  // s不再有效
  Print("{0}", t);
  return 0;
}

九、最佳实践 #

9.1 优先使用let #

carbon 
// 优先使用let
let MaxRetry: i32 = 3;
let DefaultPort: i32 = 8080;

// 只在需要修改时使用var
var counter: i32 = 0;
counter += 1;

9.2 就近声明 #

carbon 
// 好的做法：就近声明
fn Process(data: [i32]) -> i32 {
  var sum: i32 = 0;
  for (item in data) {
    sum += item;
  }
  return sum;
}

// 避免：提前声明
fn Process(data: [i32]) -> i32 {
  var sum: i32;
  var i: i32;
  // ... 很多代码
  sum = 0;
  // ...
  return sum;
}

9.3 有意义的初始化 #

carbon 
// 好的做法
var count: i32 = 0;
var name: String = "";
var found: bool = false;

// 避免
var count: i32;
var name: String;
var found: bool;

十、常见错误 #

10.1 未初始化 #

carbon 
var x: i32;
Print("{0}", x);  // 错误：使用未初始化的变量

10.2 类型不匹配 #

carbon 
var x: i32 = "Hello";  // 错误：字符串不能赋值给整数

10.3 修改常量 #

carbon 
let x: i32 = 42;
x = 100;  // 错误：常量不能修改

10.4 作用域错误 #

carbon 
fn Example() -> i32 {
  {
    var x: i32 = 10;
  }
  Print("{0}", x);  // 错误：x不在作用域内
  return 0;
}

十一、总结 #

本章我们学习了：

  1. 变量声明：使用var声明可变变量
  2. 常量声明：使用let声明不可变值
  3. 类型推断：自动推断变量类型
  4. 作用域：块作用域、变量遮蔽
  5. 命名约定：snake_case、PascalCase
  6. 最佳实践：优先使用let、就近声明

接下来让我们学习Carbon的基本数据类型！

最后更新：2026-03-27