Delphi 中是否存在或者将来是否存在条件运算符？

Question

我猜我已经太长时间没有接触德尔福了；在过去的几年里，我一直忙于 Java 和 PHP。现在，当我重新开始做一些 Delphi 工作时，我意识到我真的很怀念 Java 和 PHP 都支持的条件运算符。

在您的 Delphi 程序中，您会在多少地方找到这样的行？

var s : string;
begin
  ...<here the string result is manipulated>...

  if combo.Text='' then
      s := 'null'
    else
      s := QuotedStr(combo.Text);

  result := result + s;
end;

一个简单的

result := result + (combo.text='')?'null':quotedStr(combo.text);

就足够了。我喜欢这个的原因是它不仅缩短了代码，这样我还可以避免声明一些辅助 s:string 变量。

为什么条件运算符不是 Delphi 的一部分以及 - 它们会受到支持吗？我注意到 2009 版本的 Delphi（泛型）有相当多的语言扩展，那么为什么不添加这个功能呢？

Answer 1

这样的操作符不是当前 Delphi 版本的一部分，因为它不是以前版本的一部分，并且需求不足以证明添加它的成本是合理的。 （您会发现该解释适用于很多您希望在很多产品中拥有的功能。）

Delphi 提供了一组 IfThen 函数在 Math 和 StrUtils 单元中，但它们有一个不幸的特性，即评估它们的值参数，因此这样的代码将会失败：

Foo := IfThen(Obj = nil, '<none>', Obj.Name);

要真正做到正确，需要编译器的帮助。在 Delphi 社区中，我感觉到普遍不喜欢使用问号和冒号的 C 风格语法。我见过使用这样的语法的提案：

Foo := if Obj = nil then
         '<none>'
       else
         Obj.Name;

条件运算符如此有吸引力的部分原因是它们可以让您编写简洁的代码，但是 Delphi 将所有内容都写出来的风格使得上述内容没有吸引力，即使将所有内容都放在一行上。

它实际上并不需要采用运算符的形式。 Delphi Prism 提供了一个编译器魔法函数Iif，仅评估其两个值参数之一：

Foo := Iif(Obj = nil, '<none>', Obj.Name);

您问为什么这样的功能不会与 Delphi 2009 中添加的所有其他语言功能一起添加。我认为这就是您的原因。还有许多其他语言变化正在进行，需要精心处理；开发人员不需要承担更多的负担。功能不是免费的。

您问Delphi 是否会有这样的功能。我不了解内河码头的计划会议，而且我不得不将水晶球送去维修，所以我不能肯定地说，但我预测如果它会有有这样的功能，它将以 Delphi Prism 的 Iif 函数的形式出现。这个想法出现在 Quality Central 的讨论快结束时，并且有人反对说，作为一个新的保留字，它会破坏与已经定义同名函数的其他人的代码的向后兼容性。但这不是一个有效的对象，因为它不需要是保留字。它可以是一个标识符，就像 Writeln 和 Exit 一样，它可以在其他单元中重新定义，即使来自 System 单元的标识符被特殊对待。

Answer 2

好的。今天的 WTF 代码 :)

如何获得主要类似于三元/条件函数的东西。

program Project107;
{$APPTYPE CONSOLE}

uses SysUtils;

type
  TLazyIfThen<T:record>=record
    class function IfThen(aCondition:Boolean;aIfTrue, aIfFalse:TFunc<T>):T; static;
  end;

  class function TLazyIfThen<T>.IfThen(aCondition:Boolean;aIfTrue, aIfFalse:TFunc<T>):T;
  begin
    if aCondition then
      Result := aIfTrue
    else
      Result := aIfFalse
  end;

begin
  WriteLn(
    TLazyIfThen<Integer>.IfThen(
      True,
      function:Integer begin result := 0 end,
      function:Integer begin result := 1 end
    )
  );
  ReadLn;
end.

是的，它或多或少没什么用，但它表明它是可以做到的。

Answer 3

有一个关于此的 QC 报告 (8451)，其中进行了合理的讨论。

2004 年 6 月提出，Borland/CodeGear/Embarcadero 似乎没有任何回应。

Answer 4

重载的 IFTHEN 函数有许多可用的简单类型句柄。

StrUtils.IfThen (String)

Math.IfThen (Integer)

Math.IfThen (Int64)

Math.IfThen (Double)（也适用于 TDateTime）

此模型如下所示在 Andreas 评论的示例中，但对于简单类型来说，这是非常合理的。如果遵循 Delphi/Pascal 方法约定，而不是屈服于使用尽可能少的字符的 C 方式。

就我个人而言，我不希望看到 Delphi 中引入条件运算符（即 ?:），因为与 C 及其衍生语言相比，我更喜欢 Delphi/Pascal 的可读性。我更愿意看到更多创新的 Delphi 类型解决方案来解决这样的问题，而不是实现更多的 C 主义。

Answer 5

Delphi 中没有条件运算符，我严重怀疑是否会有条件运算符，但你可能永远不知道。您可以随时在 Embarcadero 提出请求。

另一种方法是定义 Iff 函数：

function Iff(const ACondition: Boolean; const ATrueValue, AFalseValue: XXX): XXX;
begin
  if ACondition then
    Result := ATrueValue
  else
    Result := AFalseValue;
end;

其中 XXX 是所需的类型。

使用 as：

Result := Result + Iff(combo.text='', 'null', quotedStr(combo.text));

不实现条件运算符有多种原因。其中之一是可读性。 Pascal（还有 Delphi）比 C 语法语言更注重可读性，C 语法语言更注重字符能力（每个字符尽可能多的信息）。条件运算符功能强大，但（根据某些人的说法）不可读。但如果你看看 Delphi 中的（可怕的）with 语句......（无需多说）。
另一个原因是不需要条件运算符。这是真的。但还有更多不需要的内容仍在实施中。

最后，这只是一个品味问题。

但是，如果您只想评估一个参数，则始终可以使用以下内容，这违反了字符能力概念的可读性：

[overdesignmode]

// Please don't take this that serious.
type
  TFunc = function(): XXX;
function Iff(const ACondition: Boolean; const ATrueFunc, AFalseFunc: TFunc): XXX;
begin
  if ACondition then
    ATrueFunc
  else
    AFalseFunc;
end;

[/overdesignmode]

Answer 6

我更希望他们实现惰性求值，它会更强大并且可以在不同的场景中使用。请参阅以下链接的详细信息

http://www.digitalmars.com/d/2.0 /lazy-evaluation.html

干杯

Answer 7

另一种选择是使用泛型：

Cond<T> = class
    public class function IIF(Cond: boolean; IfVal: T; ElseVal: T): T;
  end;

implementation

class function Cond<T>.IIF(Cond: boolean; IfVal, ElseVal: T): T;
begin
  if Cond then
    Result := IfVal
  else
    Result := ElseVal;
end;

这是非常可读的：

var MyInt: Integer;
begin
  MyInt:= Cond<Integer>.IIF(someCondition, 0, 42);

注意：正如 Alan Bryant（于 6/21/2004 7:26:21 AM）在 QR 8451，这将始终评估所有 3 个参数 - 因此请注意，它不是真正的三元运算符。

Answer 8

实际上，对于字符串，您可以使用：StrUtils.IfThen函数：

function IfThen(AValue: Boolean;
        const ATrue: string;
        AFalse: string = ): string; overload;

查看delphi帮助wiki：http://docwiki.embarcadero.com/VCL/en/StrUtils.IfThen

它完全符合您的需要。

Answer 9

更好的是支持多种数据类型和结果的重载 IIF（内联 if）。

Answer 10

Jedi 代码库 ( JCL ) 使用一组名为 Iff() 的函数实现了三元运算符。请参阅此处的文档：

http://wiki.delphi-jedi。 org/wiki/JCL_Help:Iff@Boolean@Boolean@Boolean

要下载 JCL，您可以访问此站点：

http://sourceforge.net/projects/jcl/

Answer 11

当天的 WTF 代码 Nr. 2：

program TernaryOpTest;

uses
  System.SysUtils, Vcl.Dialogs;

type
  TGetValue = reference to function(): Double;

function TernaryOp(condition: Boolean; trueFunc, falseFunc: TGetValue): Double;
begin
  if condition then begin
    if Assigned(trueFunc) then Result := trueFunc() else raise EArgumentNilException.Create('trueFunc not defined.');
  end
  else begin
    if Assigned(falseFunc) then Result := falseFunc() else raise EArgumentNilException.Create('falseFunc not defined.');
  end;
end;

procedure TernaryTest(x: Double);
var
  v: Double;
begin
  v := TernaryOp(x <> 0, function(): Double begin Result := 1/x; ShowMessage('True case'); end, function(): Double begin Result := 0; ShowMessage('False case'); end);
  ShowMessage(FloatToStr(v));
end;

begin
  ShowMessage('Testing true case');
  TernaryTest(10);
  ShowMessage('Testing false case');
  TernaryTest(0);
  ShowMessage('Testing exception');
  TernaryOp(False, nil, nil);
end.

Variant 数据类型的一种可能的修改是：

type
  TGetValue = reference to function(): Variant;

function TernaryOp(condition: Boolean; trueFunc, falseFunc: TGetValue): Variant;
begin
  Result := Unassigned;
  if condition then begin
    if Assigned(trueFunc) then Result := trueFunc();
  end
  else begin
    if Assigned(falseFunc) then Result := falseFunc();
  end;
end;

Answer 12

如果有帮助的话，相对于 Math.IfThen 函数的最大好处是它使用“内联”（假设编译器支持它）。

带有 TFunc 或 TFunc的版本使用时会有点难看，因为 Delphi 的匿名方法没有 Lambda 表达式（尽管我发现了一些使用 Variant 表达式的实验）

unit Zoomicon.Generics.Functors;

interface
  uses SysUtils; //for TPredicate

type
  TF = class
    class function Iff<T>(const Condition: Boolean; const ValueIfTrue, ValueIfFalse: T): T; overload; inline;
    class function Iff<T>(const Condition: Boolean; const ValueIfTrue, ValueIfFalse: TFunc<T>): T; overload; inline;
    class function Iff<T>(const Value: T; const Condition: TPredicate<T>; const ValueIfTrue, ValueIfFalse: T): T; overload; inline;
    class function Iff<T>(const Value: T; const Condition: TPredicate<T>; const ValueIfTrue, ValueIfFalse: TFunc<T>): T; overload; inline;
    class function Iff<T>(const Value: T; const Condition: TPredicate<T>; const ValueIfTrue, ValueIfFalse: TFunc<T,T>): T; overload; inline;
  end;

implementation

class function TF.Iff<T>(const Condition: Boolean; const ValueIfTrue, ValueIfFalse: T): T;
begin
  if Condition then
    result := ValueIfTrue
  else
    result := ValueIfFalse;
end;

class function TF.Iff<T>(const Condition: Boolean; const ValueIfTrue, ValueIfFalse: TFunc<T>): T;
begin
  if Condition and Assigned(ValueIfTrue) then
    result := ValueIfTrue
  else
    result := ValueIfFalse; //Note: will fail if ValueIfFalse is not assigned
end;

class function TF.Iff<T>(const Value: T; const Condition: TPredicate<T>; const ValueIfTrue, ValueIfFalse: T): T;
begin
  if Assigned(Condition) then
    result := Iff(Condition(Value), ValueIfTrue, ValueIfFalse)
  else
    result := ValueIfFalse;
end;

class function TF.Iff<T>(const Value: T; const Condition: TPredicate<T>; const ValueIfTrue, ValueIfFalse: TFunc<T>): T;
begin
  //result := Iff(Value, Condition, ValueIfTrue(), ValueIfFalse()); //use of () seems to be needed else compiler seems to match the same function (infinite recursion) //DOESN'T COMPILE (probably Delphi bug)
  if Assigned(Condition) then
    result := Iff(Condition(Value), ValueIfTrue, ValueIfFalse) //TODO: not sure if evaluation is deferred here (aka which "Iff" gets called [CTRL+Click in Delphi doesn't seem that clever], @ValueIfTrue/@ValueIfFalse to force that don't seem to compile)
  else
    result := ValueIfFalse; //Note: will fail if ValueIfFalse is not assigned
end;

class function TF.Iff<T>(const Value: T; const Condition: TPredicate<T>; const ValueIfTrue, ValueIfFalse: TFunc<T,T>): T;
begin
  //result := Iff(Value, Condition, ValueIfTrue(Value), ValueIfFalse(Value)); //DOESN'T COMPILE (probably Delphi bug)
  if Assigned(Condition) and Assigned(ValueIfTrue) {and Assigned(ValueIfFalse)} then //no need to check Assigned(ValueIfFalse) here, since in any case it will fail
    result := Iff(Condition(Value), ValueIfTrue(Value), ValueIfFalse(Value)) //Note: will fail if ValueIfFalse is not assigned
  else
    result := ValueIfFalse(Value); //Note: will fail if ValueIfFalse is not assigned
end;

end.