Python позволяет проверить принадлежность к последовательности:

if x in (1, 2):

Версия расширения на C #

шаг 1: создайте метод расширения

public static class ObjectExtensions
{
    public static bool Either(this object value, params object[] array)
    {
        return array.Any(p => Equals(value, p));
    }
}

шаг 2: используйте метод расширения

if (x.Either(1,2,3,4,5,6)) 
{
}
else
{
}

Хотя в этой ветке есть ряд довольно интересных ответов, я хотел бы отметить, что они могут иметь последствия для производительности, если вы выполняете такую ​​логику внутри цикла в зависимости от языка. Насколько компьютер понимает, if (x == 1 || x == 2), безусловно, легче всего понять и оптимизировать, когда он скомпилирован в машинный код.

Когда я начал программировать, мне тоже показалось странным, что вместо чего-то вроде:

(1 < x < 10)

Пришлось написать:

(1 < x && x < 10)

Но так работает большинство языков программирования, и через некоторое время вы к этому привыкнете.

Так что я считаю, что писать

( x == 1 || x == 2 )

Такой способ написания также имеет то преимущество, что другие программисты легко поймут то, что вы написали. Использование функции для ее инкапсуляции может только усложнить задачу, потому что другим программистам нужно будет найти эту функцию и посмотреть, что она делает.

Только более новые языки программирования, такие как Python, Ruby и т. Д., Позволяют писать проще и удобнее. В основном это связано с тем, что эти языки программирования предназначены для повышения продуктивности программистов, в то время как основной целью старых языков программирования была производительность приложений, а не продуктивность программистов.

Это естественно, но зависит от языка

Ваш подход действительно может показаться более естественным, но это действительно зависит от языка, который вы используете для реализации.

Обоснование беспорядка

C является язык системного программирования и довольно близок к аппаратному обеспечению (хотя забавно, поскольку мы привыкли рассматривать язык" высокого уровня ", а не писать машинный код), он не совсем выразительный.

Современные языки высокого уровня (опять же, спорно, шепелявость не такая современная, исторически говоря, но позволит вам делать это красиво) позволяет делать такие вещи, используя встроенные конструкции или поддержку библиотеки (например, с использованием диапазонов, кортежей или эквивалентов в таких языках, как Python, Ruby, Groovy, ML-языки, Haskell ...).

Возможные решения

Опция 1

Один из вариантов для вас - реализовать функцию или подпрограмму, которая принимает массив значений и проверяет их.

Вот базовый прототип, и я оставляю вам его реализацию в качестве упражнения:

/* returns non-zero value if check is in values */
int is_in(int check, int *values, int size);

Однако, как вы быстро увидите, это очень простой и не очень гибкий:

• работает только с целыми числами,
• он работает только для сравнения одинаковых значений.

Вариант 2

На ступеньку выше по лестнице сложности (с точки зрения языков) альтернативой было бы использование препроцессора макросы в C (или C ++), чтобы добиться аналогичного поведения, но остерегайтесь побочных эффектов.

Другие варианты

Следующим шагом может быть передача указателя функции в качестве дополнительного параметра для определения поведения при вызове - point, определите для этого несколько вариантов и псевдонимов и создайте себе небольшую библиотеку компараторов.

Следующим шагом будет реализация аналогичной вещи в C ++ с использованием шаблоны, чтобы сделать это для разных типов с помощью одной реализации.

А затем продолжайте переходить к языкам более высокого уровня.

Выберите правильный язык (или научитесь отпускать!)

Как правило, языки, предпочитающие функциональное программирование, по очевидным причинам имеют встроенную поддержку такого рода вещей. .

Или просто научитесь принимать тот факт, что одни языки могут делать то, чего не могут делать другие, и что в зависимости от работы и среды все так и есть. В основном это синтаксический сахар, и вы мало что можете сделать. Кроме того, некоторые языки со временем исправят свои недостатки, обновив свои спецификации, в то время как другие просто остановятся.

Возможно, библиотека уже реализует такую ​​вещь, о которой я не знаю.

было много интересных альтернатив. Я удивлен, что никто не упомянул switch ... case - так вот:

switch(x) {
case 1:
case 2:
  // do your work
  break;
default:
  // the else part
}

1. он более читабелен, чем набор x == 1 || х == 2 || ...
2. более оптимально, чем наличие массива / набора / списка для проверки членства

Я сомневаюсь, что когда-либо сделаю это, но, чтобы ответить на ваш вопрос, вот один из способов добиться этого на C #, включающий небольшой вывод общего типа и некоторое злоупотребление перегрузкой оператора. Вы можете написать такой код:

if (x == Any.Of(1, 2)) {
    Console.WriteLine("In the set.");
}

Где Any класс определяется как:

public static class Any {
    public static Any2<T> Of<T>(T item1, T item2) {
        return new Any2<T>(item1, item2);
    }
    public struct Any2<T> {
        T item1;
        T item2;
        public Any2(T item1, T item2) {
            this.item1 = item1;
            this.item2 = item2;
        }
        public static bool operator ==(T item, Any2<T> set) {
            return item.Equals(set.item1) || item.Equals(set.item2);
        }
        // Defining the operator== requires these three methods to be defined as well:
        public static bool operator !=(T item, Any2<T> set) {
            return !(item == set);
        }
        public override bool Equals(object obj) { throw new NotImplementedException(); }
        public override int GetHashCode() { throw new NotImplementedException(); }
    }
}

Возможно, у вас может быть несколько перегрузок метода Any.Of для работы с 3, 4 или даже большим числом аргументов. Также могут быть предоставлены другие операторы, и сопутствующий класс All может делать что-то очень похожее, но с && вместо ||.

Глядя на разборку, можно заметить, что из-за необходимости вызывать Equals происходит изрядная часть бокса, так что в конечном итоге это оказывается медленнее, чем очевидная конструкция (x == 1) || (x == 2). Однако, если вы измените все <T> на int и замените Equals на ==, вы получите что-то, что выглядит хорошо встроенным, примерно с той же скоростью, что и (x == 1) || (x == 2).

Эээ, что с этим не так? Ну что ж, если вы действительно используете его много и ненавидите внешний вид, сделайте что-то вроде этого в C #:

#region minimizethisandneveropen
public bool either(value,x,y){       
    return (value == x || value == y);
}
#endregion

и в местах, где вы его используете:

if(either(value,1,2))
   //yaddayadda 

Или что-то в этом роде на другом языке :).

В php вы можете использовать

$ret = in_array($x, array(1, 2));

Насколько мне известно, в C. нет встроенного способа сделать это. Вы можете добавить свою собственную встроенную функцию для сканирования массива целых чисел для значений, равных x ....

Вот так:

inline int contains(int[] set, int n, int x)
{ 
  int i;
  for(i=0; i<n; i++)
    if(set[i] == x)
      return 1;

  return 0;
}

// To implement the check, you declare the set
int mySet[2] = {1,2};
// And evaluate like this:
contains(mySet,2,x) // returns non-zero if 'x' is contained in 'mySet'

В T-SQL

where x in (1,2)

В COBOL (прошло много времени с тех пор, как я даже бегло не взглянул на COBOL, так что здесь я могу ошибиться в некоторых деталях):

IF X EQUALS 1 OR 2
...

Так что синтаксис определенно возможен. Тогда вопрос сводится к тому, "почему он не используется чаще?"

Ну, дело в том, что разбирать подобные выражения - это своего рода сука. Не в таком одиночестве, ум, а в сложных выражениях. Синтаксис начинает становиться непрозрачным (с точки зрения разработчика компилятора), а семантика становится совершенно непонятной. IIRC, многие компиляторы COBOL даже предупредят вас, если вы используете такой синтаксис, из-за потенциальных проблем.

В .Net вы можете использовать Linq:

int[] wanted = new int{1, 2};

// you can use Any to return true for the first item in the list that passes
bool result = wanted.Any( i => i == x );

// or use Contains
bool result = wanted.Contains( x );

Хотя лично я считаю, что базовая || достаточно проста:

bool result = ( x == 1 || x == 2 );

Спасибо, Игнасио! Перевожу на Ruby:

[ 1, 2 ].include?( x )

и это тоже работает, но я не уверен, будет ли это выглядеть ясно и нормально. Если вы знаете о Ruby, сообщите, пожалуйста. Также, если кто-нибудь знает, как написать это на C, скажите, пожалуйста. Спасибо. -Натан

Perl 5 с Perl6 :: Junction:

use Perl6::Junction 'any';
say 'yes' if 2 == any(qw/1 2 3/);

Perl 6:

say 'yes' if 2 == 1|2|3;

Эта версия настолько удобочитаема и лаконична, что я бы использовал ее вместо оператора ||.

В Паскале есть (ограниченное) понятие наборов, поэтому вы можете:

if x in [1, 2] then

(не касался компилятора Паскаля десятилетиями, поэтому синтаксис может быть отключен)

Попробуйте использовать только один небитовый логический оператор (не рекомендуется, не тестировался):

if( (x&3) ^ x ^ ((x>>1)&1) ^ (x&1) ^ 1 == 0 )

Часть (x&3) ^ x должна быть равна 0, это гарантирует, что x находится между 0 и 3. У других операндов будет установлен только последний бит.

Часть ((x>>1)&1) ^ (x&1) ^ 1 гарантирует, что последний и предпоследний биты различны. Это будет применяться к 1 и 2, но не к 0 и 3.

Вы говорите, что запись (x==1 || x==2) "неудобная и трудная для чтения". Позволю себе не согласиться. Он отличается от естественного языка, но очень ясен и прост для понимания. Вам просто нужно думать как компьютер.

Кроме того, нотации, упомянутые в этом потоке, такие как x in (1,2), семантически отличаются от того, что вы действительно спрашиваете, они спрашивают, является ли x членом набора (1,2), а это не то, о чем вы спрашиваете. Вы спрашиваете if x equals to 1 or to 2, что логически (и семантически) эквивалентно if x equals to 1 or x equals to 2, что переводится как (x==1 || x==2).

В java:

 List list = Arrays.asList(new Integer[]{1,2});
 Set set = new HashSet(list);
 set.contains(1)

У меня есть макрос, который я часто использую, который несколько близок к тому, что вы хотите.

#define ISBETWEEN(Var, Low, High) ((Var) >= (Low) && (Var) <= (High))

ISBETWEEN(x, 1, 2) вернет истину, если x равно 1 или 2.

Ни C, C ++, VB.net, C # .net, ни какой-либо другой подобный язык, который я знаю, не имеют эффективного способа проверки того, является ли что-то одним из нескольких вариантов. Хотя (x == 1 || x == 2) часто является наиболее естественным способом кодирования такой конструкции, этот подход иногда требует создания дополнительной временной переменной:

  tempvar = somefunction(); // tempvar only needed for 'if' test:
  if (tempvar == 1 || tempvar == 2)
    ...

Конечно, оптимизатор должен иметь возможность эффективно избавиться от временной переменной (засунуть ее в регистр на короткое время, когда она используется), но я все еще считаю этот код некрасивым. Кроме того, на некоторых встроенных процессорах наиболее компактным и, возможно, самым быстрым способом записи (x == const1 || x == const2 || x == const3) является:

  movf  _x,w             ; Load variable X into accumulator
  xorlw const1           ; XOR with const1
  btfss STATUS,ZERO      ; Skip next instruction if zero
   xorlw const1 ^ const2 ; XOR with (const1 ^ const2)
  btfss STATUS,ZERO      ; Skip next instruction if zero
   xorlw const2 ^ const3 ; XOR with (const2 ^ const3)
  btfss STATUS,ZERO      ; Skip next instruction if zero
   goto NOPE

Этот подход требует еще двух инструкций для каждой константы; все инструкции будут выполнены. Тесты с ранним выходом сэкономят время, если ветка будет занята, и потратят время впустую. Кодирование с использованием буквальной интерпретации отдельных сравнений потребовало бы четырех инструкций для каждой константы.

Если бы в языке была конструкция «если переменная является одной из нескольких констант», я бы ожидал, что компилятор будет использовать приведенный выше шаблон кода. Жаль, что такой конструкции не существует в обычных языках.

(примечание: у Pascal есть такая конструкция, но реализации во время выполнения часто очень расточительны как по времени, так и по пространству кода).

return x === 1 || x === 2 в javascript