“或”运算符,无需再次重复左侧条件

Python有点:

if x in [something, somethingelse]:
    ...

in 只需检查元素是否出现在给定列表中。同样,在哈斯克尔:

if x `elem` [something, somethingelse] then ...

SQL有一个 in 接线员: x in (something, somethingelse)

if (x.In("something", "somethingelse"))...

编辑

public static bool In<T>(this T item, params T[] test_values) {
  foreach (T test_value in test_values)
  {
    if (test_value.Equals(item))
    {
      return true;
    }
  }

  return false;
}

在许多编程语言中,您可以执行以下操作:

myArray[something, somethingElse].Contains(x)

... 但我猜它的表现会稍微差一点。

这个 Icon programming language

if x == (something | somethingelse) then write("Goodie!")

以下是评估模型:

1. 首先,计算括号中的表达式并得到 something
2. 某物 到 x
3. 如果它们不相等,表达式 ,并且评估引擎会自动回溯。
4. 在回溯过程中,括号表达式的求值是 ,它又成功了!这次它产生了 somethingelse .
5. 让我们假设这个比较成功。然后是尸体 if 计算,程序写入标准输出。

下面是另一个有趣的场景:每个比较要么成功,要么失败,如果成功,它将返回其右参数。因此,您可以使用进行边界检查

lo <= x < limit

(lo <= x) < limit

如果 lo x ,括号中的表达式失败,因此整个过程失败(如果普通表达式的任何部分失败,则该表达式将失败。)但是如果 瞧 最多是 那么 lo <= x 成功 x x < limit 如果成功了,整个事情就成功了。

R.I.P。

在具有“开关”运算符的语言中,您可以执行以下操作:

switch (x)
{
    case 1:
    case 2:
    {
      // do whatever
      break;
    }

    default:
    {
        // else case
        break;       
    }
}

它有点冗长,但是在C中,你可以把它隐藏在宏或者C++中,或者是模板。

MATLAB有几种方法来处理上面列出的第二种形式:

if any(x == [something somethingelse]) ...
%# OR
if ismember(x,[something somethingelse]) ...

Perl: $foo ~~ ['string',$number,qr/regex/]

A in [x, y, z]

被认为是有效的解决方案,然后函数

in(A, x, y, z)

也应该被认为是一个有效的解决方案,特别是对于允许运算符重载以便cmp(a,x,y,z)可以映射到

A in x y z

if (A == x or y or z).

if (A == x and y and z).

让我们用java来说明。

boolean or(String lhs, String... rhs){
  for(String z: rhs){
    if (lhs.equals(z) return true;
  }
  return false;
}

boolean and(String lhs, String... rhs){
  for(String z: rhs){
    if (!lhs.equals(z) return false;
  }
  return true;
}

or (A, x)
or (A, x, y)
or (A, x, y, z)

<T extends Comparable<T>>boolean or(T lhs, T... rhs){
  for(T z: rhs){
    if (lhs.compareTo(z)==0) return true;
  }
  return false;
}

<T extends Comparable<T>>boolean and(T lhs, T... rhs){
  for(T z: rhs){
    if (lhs.compareTo(z)!=0) return false;
  }
  return true;
}

所以现在您可以对实现可比较接口的任何类型进行比较。

and(stringA, stringx, stringy)
or(dateA, datex)

太糟糕了,Java不允许运算符重载,所以我们可以

stringA && stringx, stringy
dateA || datex, datey, datez

在C++中,我从未尝试过用VARARGS操作重载,甚至知道它是否可能。

然而,几个小时后再次访问此网站,

我们可以定义一个类

public class <T extends Comparable<T>> Comparigator{
  public Comparigator(T lhs){
    this.lhs = lhs;
  }
  final private T lhs;

  static public <T extends Comparable<T>> Comparigator is(T lhs){
    return (T)new Comparigator(lhs);
  }

  public boolean inAny(T... rhs){
    for(T z: rhs){
      if (this.lhs.compareTo(z)==0) return true;
    }
    return false;
  }

  public boolean inAll(T... rhs){
    for(T z: rhs){
      if (this.lhs.compareTo(z)!=0) return false;
    }
    return true;
  }

  public boolean gtAny(T... rhs){
    for(T z: rhs){
      if (this.lhs.compareTo(z)>0) return true;
    }
    return false;
  }

  public boolean gtAll(T... rhs){
    for(T z: rhs){
      if (this.lhs.compareTo(z)<=0) return false;
    }
    return true;
  }
}

import Comparigator;
.....

is(A).inAny(x,y,z); // or
is(A).inAll(w,x,y,z); // and

is(B).gtAny(k,l,m);
is(C).gtAll(j,k);

我们可以扩展它,我们可以通过扩展比较功能来实现inany、inall、gtany、gtall、ltany、ltall等等。