Pascal中如何通过字符串变量引用类型的字段？

嘿，这个需求我太懂了——静态类型的Pascal确实不支持像test_var.test_str这种直接用字符串变量动态访问record字段的写法，但咱们有几种实用的方案能实现你要的批量赋值、循环处理的需求，我给你一一拆解：

这是处理大量字段最省心的方式，Delphi和Free Pascal都支持RTTI，能让你在运行时获取record的类型信息，通过字段名字符串匹配并赋值。

uses
  Rtti, SysUtils;

type
  type_test = record
    x: Integer;
    y: Integer;
    z: Integer;
  end;

var
  test_var: type_test;
  ctx: TRttiContext;
  rType: TRttiType;
  field: TRttiField;
  fieldNames: array of string;
  i: Integer;
begin
  // 模拟需要批量赋值的字段名列表
  SetLength(fieldNames, 3);
  fieldNames[0] := 'x';
  fieldNames[1] := 'y';
  fieldNames[2] := 'z';

  ctx := TRttiContext.Create;
  try
    // 获取record的类型信息
    rType := ctx.GetType(type_test);
    // 循环遍历字段名，批量赋值
    for i := 0 to High(fieldNames) do
    begin
      field := rType.GetField(fieldNames[i]);
      if Assigned(field) then
        // 给每个字段赋不同值，这里x=99，y=100，z=101
        field.SetValue(@test_var, 99 + i);
    end;
  finally
    ctx.Free;
  end;

  Writeln(test_var.x); // 输出99
  Writeln(test_var.y); // 输出100
  Writeln(test_var.z); // 输出101
end.

说明：需要引用Rtti单元，TRttiContext是RTTI的核心入口，GetType拿到record的类型元数据，GetField通过字段名字符串定位到具体字段，SetValue完成赋值（注意要传入record的地址@test_var）。这种方式完全支持循环批量处理，新增字段也不用改循环逻辑，只需要保证字段名正确即可。

如果不想依赖RTTI，或者字段数量较少，你可以手动写一个映射函数，用case语句匹配字段名和赋值逻辑，简单直接。

type
  type_test = record
    x: Integer;
    y: Integer;
    z: Integer;
  end;

// 自定义赋值函数：根据字段名字符串给record字段赋值
procedure SetRecordField(var rec: type_test; fieldName: string; value: Integer);
begin
  // 转小写避免大小写问题
  case LowerCase(fieldName) of
    'x': rec.x := value;
    'y': rec.y := value;
    'z': rec.z := value;
    // 后续新增字段直接在这里加case分支即可
  end;
end;

var
  test_var: type_test;
  test_str: string;
  fieldNames: array of string;
  i: Integer;
begin
  // 单个字段赋值示例
  test_str := 'x';
  SetRecordField(test_var, test_str, 99);
  Writeln(test_var.x); // 输出99

  // 批量循环赋值示例
  SetLength(fieldNames, 3);
  fieldNames[0] := 'x';
  fieldNames[1] := 'y';
  fieldNames[2] := 'z';
  for i := 0 to High(fieldNames) do
    SetRecordField(test_var, fieldNames[i], 100 + i);
  
  Writeln(test_var.y); // 输出101
end.

说明：这个方案不需要额外依赖，逻辑清晰，但字段多的话要写很多case分支，维护成本会高一些。

如果你想要更接近test_var.test_str的写法，可以给record定义一个索引器，把字段名作为索引参数，用起来更直观。

type
  type_test = record
    x: Integer;
    y: Integer;
    z: Integer;
    // 定义索引器，通过字段名字符串访问字段
    function GetField(fieldName: string): Integer;
    procedure SetField(fieldName: string; value: Integer);
    property Fields[fieldName: string]: Integer read GetField write SetField;
  end;

function type_test.GetField(fieldName: string): Integer;
begin
  case LowerCase(fieldName) of
    'x': Result := x;
    'y': Result := y;
    'z': Result := z;
  end;
end;

procedure type_test.SetField(fieldName: string; value: Integer);
begin
  case LowerCase(fieldName) of
    'x': x := value;
    'y': y := value;
    'z': z := value;
  end;
end;

var
  test_var: type_test;
  test_str: string;
begin
  test_str := 'x';
  // 用索引器赋值，写法接近你想要的效果
  test_var.Fields[test_str] := 99;
  Writeln(test_var.x); // 输出99

  // 循环批量赋值也很方便
  var fieldNames: array of string = ['x', 'y', 'z'];
  for var fname in fieldNames do
    test_var.Fields[fname] := 88;
  
  Writeln(test_var.z); // 输出88
end.

说明：这种方式把字段访问包装成了Fields属性，用字符串索引来读写，写法和你理想的test_var.test_str非常接近，同时也支持循环批量处理。

内容的提问来源于stack exchange，提问作者Lucky J C