Какие значения должна возвращать логическая функция в Perl?

- - - + КОРОТКИЙ ОТВЕТ

вот две самосогласованные схемы для булевых в Perl:

• 1/0 - printable и портативный
• 1/!!0 - самый как родной булевых функций в Perl

1/0вероятно, наиболее знаком программистам с других языков, таких как C или Python. Вы можете распечатать 1/0 логические значения, добавьте их и так далее. Но... Собственные логические операторы Perl не 1/0 ценностей return $a<0 - это не то же самое как return 1 if $a<0; return 0.

1/0!! - это моя попытка создать сокращенное имя для схемы, которую используют собственные логические операторы Perl: 1 для true, пустая строка, которая специально отмечена, чтобы она не создавала предупреждения при использовании в арифметике или интерполирована в строки. !!0 является одним из самых простых способов получения этого специального значения Perl false и должен быть знаком программистам на многих языках, таких как C, как стандартизация логических значений. Вы можете добавить 1/0!! печати 1/0 логические значения, если вам все равно, может ли значение false быть невидимым, т. е. пустой строкой.

избежать случайно смешивание числового 1/0, собственные условия Perl,undef и другие схемы в той же функции или библиотеке.

при преднамеренном смешивании используйте операторы преобразования, такие как

• !!$bool_0or1 преобразовать в a традиционный 1/!!0значение Perl
• (0+($a<0)) для преобразования реляционного результата Perl в 1/0
• (!!any_other_boolean())
• (0+any_other_boolean())
• ($other_bool?1:()) преобразовать в 1/() из других булевых схем
• ($other_bool?1:undef) преобразовать в 1/undef из других булевых схем

Q: есть ли какие-либо более короткие или префиксные обозначения, кроме ?:?

есть еще несколько возможные схемы

• 1/() - точнее, возвращает 1 или ничего -- что может поймать
  некоторые ошибки Perl-ish, такие как возврат логического скалярного false, например 0 или undef в контексте списка, где это станет true
• (1)/(0) - возвращает список длиной 1 conrtaining 1, или пустой список. Похожие на 1/(), последовательный в том смысле, что и истинный и false-массивы.
• 1/undef - еще одна возможность, ловит ошибки 1/() возвращает 1 или ничего!--146--> может привести к

я не решаюсь рекомендовать их. По крайней мере, 1/() непоследовательно в этом, но... они, безусловно, использовались программистами Perl, поэтому вы должны быть готовы иметь дело с кодом, который использует эти схемы. Т. е. будьте готовы отлаживать ошибки, вызванные этими схемами.

1/() моя попытка создать сокращенное имя для схемы, где функции, которые возвращаются правда return 1;, и функции, которые возвращают false do return;, т. е. return без значения операнда. Т. е. возвращает 1 или ничего. Я верю этому ничего не возвращать эквивалентно return ();. Эта схема защищает вас от ошибок, вызванных программистом, оценивающим вашу функцию в контексте списка, а не скалярном контексте. Но он подвергает вас таким ошибкам, как {1=>return_nothing_if_false(),2=>return_nothing_if_false()} (snce вы, вероятно, не хотите {1=>2}.

КСТАТИ, Я думаю что это может быть более последовательным, чтобы сделать схемы (1)/(). Это позволит вам consistentl; y имеют переменные этого логического типа, по общему признанию @array переменные.

обратите внимание, что 1/undef не эквивалентно ни одному из вышеперечисленных. 1/undef логические переменные дают предупреждения, когда false=undef печатается или интерполируется или используется в арифметике, но не тогда, когда true=1 так манипулируется и оценивается как true в контексте списка. Может возникнуть искушение сказать, что это худшее. характеристики всех схем.

я не решаюсь сомневаться в этих схемах 1/(), (1)/(), или 1 / undef. По крайней мере, 1/() противоречит себе, указывая, что

все три эти схемы 1/(), (1)/(), или 1 / undef подвергают вас таким ошибкам, как {1=>f1_return_nothing_if_false(),2=>f2_return_nothing_if_false()}, так как вы, вероятно, не хотите {a=>"b"} если оба ложны, и {a=>1,b=>1} если оба истинны. По крайней мере, если f1 возвращает true и F2 возвращает false или наоборот, вы получите предупреждение о нечетном размере хэш.

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

ИМХО, Если вы это сделаете 1/(), (1)/() или 1 / undef вы не можете безопасно вызывать такие функции в контексте массива, например, построение аргументов ключевого слова foo(kw=>boolfunc(),...) или foo({kw=>boolfunc(),kw2=>...},...). Не без необходимости разбегаться !! или 0+ повсюду.

- - - + СРЕДНЯЯ ДЛИНА Ответ

обобщающий оригинальный ответ:

Perl имеет много способов представления истины; или, скорее, Perl интерпретирует множество различных значений как true или false.

если вы создаете семейство связанных функций, i.e,. в библиотеке вам рекомендуется выбрать одну из следующих известных схем и последовательно использовать ее в своей библиотеке:

1. истина 1/0 - численный-самый портативный к / от другому языки, и больше printable

2. истина 1/!!0 - больше всего похоже на стандартные реляционные операторы Perl, менее портативные, менее печатаемые (если вы не хотите, чтобы false был невидимым)

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

@DaveCross предлагает дополнительный интересная схема

1. return 1 / return ничего (почти 1/(), пустой список)

схема, которую я помню с первых дней Perl-до refs, я думаю, даже раньше undef было значением, которое можно было вернуть. Но IIRC есть проблемы с этой схемой и use warnings, возможно ?:, поэтому я не решаюсь рекомендовать его полностью, пока кто-то не объяснит лучше, как избежать таких проблем. Возможно использование wantarray.

- - - ++ выберите 1/0 или 1/0!! (родной Perl) и быть последовательным

я рекомендую вам выбрать одну из этих булевых схем и последовательно использовать эту схему.

логическая схема 1/0, вероятно, наиболее переносима на другие языки.

в 1/!!Схема 0 сделает ваш код более похожим на собственные операторы Perl.

если вы используете 1/!!0 схема, не говорите " возвращение 0", скажем return !!0.

если вы используете 1/0 схема, не говорите return $a < $b, вместо того, чтобы сказать return 0+($a < $b)

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

• !! для нормализации стандартная для Perl 1/0!! Boolean
• 0+ или 1* для преобразования в более портативный 1/0 boolean от стандартного Perl 1/0!! boolean
• ?: и весь остальной арсенал Perl для undefs и строк, которые могут или не могут считаться ложными или неудачами

если смотреть на возвращаемое значение функции, которая возвращает ref или undef

• если 1/!!0 Perl-как логические, скажем return !!ref_retval_func() или defined ref_retval_func()

• если 1/0 более портативные логические значения, скажем return 0+!!ref_retval_func() или 0+(defined ref_retval_func())

слишком много деталей ниже.

---++ возможно?: return 1 или return nothing scheme (возможно, 1 / ()?)

@DaveCross делает интересное предложение:

• возвращает 1 для логического значения true.

• не возвращает ничего для логического значения false. Это потому, что голый
  return вернет соответствующее значение в зависимости от того как
  подпрограмма была вызвана. В документации для возврата говорится следующее:

  если EXPR не задан, возвращает пустой список в контексте списка, неопределенное значение в скалярном контексте и (конечно) вообще ничего в контексте void.

---++ анти-рекомендация: не смешивать логические схемы Например, в той же функции или библиотеке не делайте

return $arg1 < $arg2;  # returning a standard Perl 1/!!0 Boolean

в одном месте, а потом куда-то иначе, или в более поздних эволюциях того же кода, do

return 0; 
return undef; 
return ''; 
return (); 

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

- - - + ЧРЕЗМЕРНАЯ ГРЯЗНАЯ ДЕТАЛЬ

---++ обсуждение в другом месте о многих значениях истины Perl

посты что делают функции Perl, которые возвращают логическое значение на самом деле возвращение и почему Perl использует пустую строку для представления логического значения false? обсудите, какие логические функции и операторы Perl фактически возвращаются. В основном специальные значения, поведение которых определяется руководствами Perl.

@cim ссылки на руководства perl:http://perldoc.perl.org/perlsyn.html#Truth-and-Falsehood

правда и Кривда

число 0, строки '0' и "" , пустой список () , и undef все false в логическом контексте. Все остальные значения-true. Отрицание истинной ценности ! or not возвращает специальное значение false. Когда он оценивается как строка, он рассматривается как"", но как число, это рассматривается как 0. Большинство операторов Perl, возвращающих true или false, ведут себя именно такой образ.

аналогично http://perldoc.perl.org/perlop.html#Relational-Operators

реляционные Операторы

операторы Perl, возвращающие true или false, обычно возвращают значения, которые можно безопасно использовать как числа. Например, операторы отношения в этом разделе и операторы равенства в следующем возвращают 1 для true и специальной версии определенной пустой строки,"", которая подсчитывается как ноль, но освобождается от предупреждений о неправильном числовом преобразования, как и "0, но true".

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

my $formatted = $result ? '1' : '0';

который вернулся к тому, с чего мы начали.

@amon показывает нам свет (!!) в комментарии к вопросу что делают функции Perl, которые возвращают логическое значение, фактически возвращают

Sidenote: вы можете превратить любое значение в соответствующее логическое с двойное отрицание. Это ведет к !! псевдо-оператор. Очень полезно для возврат общего значения truthy или falsey вместо некоторой магии число. - Амон 22 ноября 12 в 22: 11

для этих специальных логических значений не существует литерала. Однако существует множество способов их производства:--97-->, (0<1), etc. (!!1) и (!!0) вероятно, самые хорошие-тем более, что в некоторых кругах программирования C/C++ они используются для аналогичной цели. Плюс,!! может применяться к входящее значение истины, чтобы "нормализовать" его до этого "Perl standard" boolean.

---++ анти-рекомендация: не смешивать логические схемы Например, в той же функции или библиотеке не делайте

return $arg1 < $arg2;  # returning a standard Perl 1/!!0 Boolean

в одном месте, а затем где-то еще, или в более поздних эволюциях того же кода, сделайте

return 0; 
return undef; 
return ''; 
return (); 

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

например, избегайте развития кода из

return $arg1 < $arg2;  # returning a standard Perl 1/!!0 Boolean

to

if( $arg1 < $arg2 ) {
     log_or_print('found $arg1 <$arg2');
     # other stuff to do if less-than
     return 1;
} else {
     log_or_print('found not( $arg1 < $arg2)');
     # other stuff to do if not-less-than
     # which may not be the same thing as greater-than-or-equal
     return 0;
}

или

if( $arg1 < $arg2 ) {
     ...
} else {
     ...
     return undef;
}

приходя в Perl откуда-то еще, вы можете подумать, что они эквивалентны, и они в основном, но если вы делаете такие вещи, как печать логических возвращаемых значений в тестах, вы получите различия.

если вы развиваете код из логического оператора Perl-ish

return $arg1 < $arg2;  # returning a standard Perl 1/!!0 Boolean

развивай его

if( $arg1 < $arg2 ) {
     log_or_print('found $arg1 <$arg2');
     # other stuff to do if less-than
     return 1;
} else {
     log_or_print('found not( $arg1 < $arg2)');
     # other stuff to do if not-less-than
     # which may not be the same thing as greater-than-or-equal
     return !!0;
}

если вы хотите, чтобы поведение было как можно ближе к тому же. Внимание !!0 при возврате false, насколько мне известно, нет более простого способа построить специальное возвращаемое значение Perl для false.

и наоборот, если вы хотите использовать логическую схему 1/0, их исходный код должен быть написан как

return 0+($arg1 < $arg2);  # returning a standard Perl 1/!!0 Boolean

- - - ++ создание предиката из value / undef

аналогично, у вас может возникнуть соблазн взять такая функция, как

sub find_string_in_table {
   # returns string value if found, undef if not found
   return $lookup_table->{$_[0]}; 
}

и перепроектировать ее для предиката

sub is_string_in_table {
   return find_string_in_table(@_);
}

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

sub is_string_in_table {
   return 0 
       # don't even bother for long strings
       if 1000000 < length($_[0]);
   return find_string_in_table(@_);
}

это ни 1/0, ни 1/!!0, и не является последовательным значением / undef.

(примечание: Я не говорю, что эта предварительная проверка является оптимизацией производительности- - - но я говорю, что оптимизация производительности может выглядеть так, как указано выше. Спектакль оптимизация - одна из моих специальностей, и вы хотите, чтобы такие оптимизации были рефакторингом. Это отстой, когда оптимизированный код работает лучше, но ломается в некоторых местах, где он используется. Отсюда мой интерес к коду, который работает как точно так же ... все это заменить, как родной реляционные операторы языка Perl. Точно значит точно.)

вместо этого сделайте что-то вроде следующего, если вы используете стандартные логические значения Perl-ish.

sub is_string_in_table {
   return !!0 
       # don't even bother for long strings
       if 1000000 < length($_[0]);
   return (defined find_string_in_table(@_));
}

или если вы используете 1/0 Логические значения

sub is_string_in_table {
   return 0 
       # don't even bother for long strings
       if 1000000 < length($_[0]);
   return 0+(defined find_string_in_table(@_));
}

если вместо find_string_in_table это был find_object_ref_in_table, вы можете просто вернуться 0+!!find_string_in_table(@_) потому что вам не нужно беспокоиться о струны, как q() и "0".

если вы хотите, чтобы логические функции в коде, который вы пишете, вели себя как собственные операторы Perl return (!!1) верно и (!!0) для false.

т. е. 0/1, но логически отрицать дважды используя ! оператор для преобразования 1 или 0 в "родной" Perl логический.

например

sub my_boolean_function {
      ... 
      return !!1; # true 
      ...
      return !!0; # false
}

**---+ 0/1 --> 1/!!0 преобразования **

если вы считаете !! как преобразование из "meta-boolean"в" special boolean",

рассмотрим 1* или 0+ как преобразование из специального логического в обычное 0/1 логическое.

Е. Г. print "test".(1*($a eq $b))."\n"

Е. Г. print "test".(0+($a eq $b))."\n"

?: более общий, но более подробный.

- - - ++ Non-Boolean ошибка возвращает

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

"приятно" иметь расширенное возвращаемое значение для указания специальных условий, таких как сбой, недопустимый ввод и т. д., и которые могут быть оценены в контексте операторов IF или других потоков управления, таких как операторы and И or, обычно для обработки таких ошибок, например, для предоставления значений по умолчанию.

мы ограничим наше обсуждение не-булевых функций этим коротким списком:

• ref / undef : для функций, возвращающих типичный http://perldoc.perl.org/perlobj.html object, ссылка на благословенный хэш или другой тип. Возвращение undef по ошибки, не найден и т. д.

• любое значение / undef : для функций, которые возвращает любой тип значения, скалярное число или строку, скалярный ref благословил или не благословил.

value / undef работает лучше всего, когда undef не является законным возвращаемым значением и может быть проблематичным, когда undef является законным значением.n E. g. представьте себе функцию доступа, которая возвращает значение хэш-поля, $hash - >{field} -- поле может законно иметь значение { field => undef }, таким образом, возвращая undef dfoes не различать между полем не существует и поле существующий, но имеющий значение undef.

• произвольные строки, которые могут контекстуально интерпретироваться как числа или логические значения.
• "0 но правда" - я действительно не хочу в это вдаваться, но посмотрите на что означает "0, но true" в Perl? для специальной обработки строки "0, но true". Другие строки дают предупреждения о преобразовании в число, но "0, но true" - нет.
• "0E0" - аналогично, некоторый код Perl возвращает строку "0E0", который оценивает 0 как число, но true как логическое

GLEW личное мнение: так как я пишу код, который часто нужно портировать на другие языки, я предпочитаю не использовать преимущества Perl-конкретных трюков, таких как 0+"0 but true". "0E0" по крайней мере, более портативен, если вы представляете, что на каком-то другом языке, таком как C, функция convert_string_to_float("0E0") или convert_string_to_int("0x0"). Я предпочитаю "0x0" потому что он выглядит особенным с X, и 0x0 - это целое число, а 0E0 is интерпретируется как float на некоторых языках, поэтому, скорее всего, даст ошибку.

---++ возможно?: return 1 или return nothing scheme (возможно, 1 / ()?)

@DaveCross делает интересное предложение:

• возвращает 1 для логического значения true.

• не возвращает ничего для логического значения false. Это потому, что голый
  return вернет соответствующее значение в зависимости от как
  подпрограмма была вызвана. В документации для возврата говорится следующее:

  если EXPR не задан, возвращает пустой список в контексте списка, неопределенное значение в скалярном контексте и (конечно) вообще ничего в контексте void.

это важно, так как значения true и false могут незначительно отличаться между скалярным и контекстом списка. Представьте себе такую подпрограмму: ...

@DaveCross продолжает показывать, как вернуть любое значение кроме пустого списка приводит к потере ложности, если логическая функция вычисляется в контексте массива. Даже @array=(undef) равно true.

я хотел бы, чтобы эта схема работала. Я думаю, что я использовал его много лет назад, в Perl 4 или ранее, но отказался от него, когда use warnings начали делать.

насколько я помню, у меня были проблемы с условным exprtessions ?: wigth настоящей Конвенции.

я пробовал и "вернуться", и "return ();"

считают

%  perl -wle 'print "a()=<<".a().">>\n"; sub a {if(@_) {return 1} else {return}}'
Use of uninitialized value in concatenation (.) or string at -e line 1.
a()=<<>>

%  perl -wle 'print "a()=<<".a().">>\n"; sub a {if(@_) {return 1} else {return ()}}'
Use of uninitialized value in concatenation (.) or string at -e line 1.
a()=<<>>

%  perl -wle 'print "a()=<<".a().">>\n"; sub a { return @_ } '
a()=<<0>>

%  perl -wle 'print "a()=<<".a().">>\n"; sub a { return !!@_ } '
a()=<<>>

%

- - - + ИТОГ

использовать 1/0 (печатные и портативные), 1/0!! (больше всего похоже на собственные булевы функции Perl).

возможно return 1 или return ничего, что почти то же самое как 1/(). (Но у меня были проблемы с этим подходом.)

избегайте смешивания числовых 1/0, родных условий Perl,undef и другие схемы в том же функция или библиотека.

наконец, если вы когда-либо делал

$>  perl -wle 'print false && true'

вы получили

Unquoted string "false" may clash with future reserved word at -e line 1.
Unquoted string "true" may clash with future reserved word at -e line 1.
Bareword found in conditional at -e line 1.
true

поэтому кажется вероятным, что когда-нибудь Perl может иметь "официальную" схему для булевых значений со значениями true и false.

интересно, как они будут себя вести?