В Ruby некоторые методы имеют вопросительный знак (?), который задает вопрос типа include?, который спрашивает, включен ли рассматриваемый объект, затем возвращает истину / ложь.
Но почему у некоторых методов есть восклицательные знаки (!), а у других нет?
Что это значит?
Как правило, методы, заканчивающиеся на !, указывают на то, что метод изменит объект, для которого он вызван. Ruby называет их «опасными методами», потому что они изменяют состояние, на которое может ссылаться кто-то другой. Вот простой пример для строк:
foo = "A STRING" # a string called foo
foo.downcase! # modifies foo itself
puts foo # prints modified foo
Это выведет:
a string
В стандартных библиотеках есть много мест, где вы увидите пары методов с одинаковыми названиями, один с !, а другой без. Те, у которых нет, называются «безопасными методами», и они возвращают копию оригинала с изменениями, примененными к копии, без изменений вызываемого объекта. Вот тот же пример без !:
foo = "A STRING" # a string called foo
bar = foo.downcase # doesn't modify foo; returns a modified string
puts foo # prints unchanged foo
puts bar # prints newly created bar
Это выводит:
A STRING
a string
Имейте в виду, что это всего лишь соглашение, но многие классы Ruby следуют ему. Это также помогает вам отслеживать, что изменяется в вашем коде.
save и save! в ActiveRecord
- person ecoologic; 04.10.2011
! из здесь. Как мы можем узнать больше об этом использовании? (и кажется странным использовать один и тот же символ для двух совершенно разных вещей? Интересно, почему был сделан этот выбор дизайна)
- person stevec; 09.09.2020
valid? (это сделает save), чтобы заполнить ошибки. Взрыв также используется для опасных методов, генерирующих исключения, например save!. Это расплывчатое соглашение, на которое нельзя слишком полагаться. Я предлагаю вам разъяснить команде, что вы имеете в виду ! для всех проектов.
- person ecoologic; 10.09.2020
Восклицательный знак означает множество вещей, и иногда вы не можете сказать многое, кроме «это опасно, будьте осторожны».
Как говорили другие, в стандартных методах он часто используется для обозначения метода, который заставляет объект видоизменяться, но не всегда. Обратите внимание, что многие стандартные методы меняют свой приемник и не имеют восклицательного знака (pop, shift, clear), а некоторые методы с восклицательными знаками не меняют своего получателя (exit!). См., Например, эту статью.
Другие библиотеки могут использовать его по-другому. В Rails восклицательный знак часто означает, что метод генерирует исключение при ошибке, а не завершает работу без предупреждения.
Это соглашение об именах, но многие люди используют его несколько иначе. В вашем собственном коде хорошее правило - использовать его всякий раз, когда метод делает что-то «опасное», особенно когда существуют два метода с одинаковым именем, и один из них более «опасен», чем другой. «Опасно» может означать что угодно.
Это соглашение об именах взято из схемы.
1.3.5 Соглашения об именах
По соглашению имена процедур, которые всегда возвращают логическое значение, обычно заканчиваются на ``? ''. Такие процедуры называются предикатами.
По соглашению, имена процедур, хранящих значения в ранее выделенных местах (см. Раздел 3.4), обычно заканчиваются на ``! ''. Такие процедуры называются процедурами мутации. По соглашению значение, возвращаемое процедурой мутации, не указано.
! обычно означает, что метод воздействует на объект, а не возвращает результат. Из книги Programming Ruby:
Методы, которые являются «опасными» или модифицируют получатель, могут быть названы с завершающим знаком «!».
Правильнее всего сказать, что методы на ура! являются более опасными или удивительная версия. Есть много методов, которые видоизменяются без взрыва, например .destroy < / a> и, как правило, методы работают только там, где более безопасная альтернатива существует в основной библиотеке.
Например, в Array у нас есть .compact и .compact!, оба метода изменяют массив, но .compact! возвращает nil вместо self, если в массиве нет nil, что более удивительно, чем просто возврат self.
Единственный немутантный метод, который я нашел с треском, - это Kernel's _ 6_, что более удивительно, чем .exit, потому что вы не можете поймать SystemExit, пока процесс завершается.
Rails и ActiveRecord продолжают эту тенденцию в том, что они используют взрыв для более «неожиданных» эффектов, таких как .create!, который вызывает ошибки при сбое.
С сайта themomorohoax.com:
Челку можно использовать следующими способами в порядке моих личных предпочтений.
1) Активный метод записи вызывает ошибку, если метод не выполняет то, что обещает.
2) Активный метод записи сохраняет запись или метод сохраняет объект (например, полосу!)
3) Метод делает что-то «лишнее», например, отправляет куда-то или выполняет какое-то действие.
Дело в том, что используйте челку только тогда, когда действительно думаете о том, нужна ли она, чтобы избавить других разработчиков от раздражения, связанного с необходимостью проверять, почему вы используете челку.
Взрыв дает две подсказки другим разработчикам.
1), что нет необходимости сохранять объект после вызова метода.
2) когда вы вызываете метод, db будет изменен.
http://www.themomorohoax.com/2009/02/11/when-to-use-a-bang-exclamation-point-after-rails-methods
Простое объяснение:
foo = "BEST DAY EVER" #assign a string to variable foo.
=> foo.downcase #call method downcase, this is without any exclamation.
"best day ever" #returns the result in downcase, but no change in value of foo.
=> foo #call the variable foo now.
"BEST DAY EVER" #variable is unchanged.
=> foo.downcase! #call destructive version.
=> foo #call the variable foo now.
"best day ever" #variable has been mutated in place.
Но если вы когда-либо вызывали метод downcase! в приведенном выше объяснении, foo навсегда изменится на нижний регистр. downcase! не вернет новый строковый объект, а заменит строку на месте, полностью изменив foo на нижний регистр. Я предлагаю вам не использовать downcase!, если в этом нет крайней необходимости.
!
Мне нравится думать об этом как о взрывном изменении, которое разрушает все, что было до него. Взрыв или восклицательный знак означает, что вы вносите в свой код постоянное сохраненное изменение.
Если вы используете, например, метод Ruby для глобальной подстановкиgsub! сделанная вами подстановка будет постоянной.
Другой способ, который вы можете себе представить, - это открыть текстовый файл и выполнить поиск и замену с последующим сохранением. ! делает то же самое в вашем коде.
Еще одно полезное напоминание, если вы пришли из мира bash, sed -i имеет тот же эффект, что и постоянные сохраненные изменения.
Итог: ! методы просто изменяют значение объекта, для которого они вызываются, тогда как метод без ! возвращает управляемое значение без записи поверх объекта, для которого был вызван метод.
Используйте ! только в том случае, если вы не планируете хранить исходное значение в переменной, для которой вы вызвали метод.
Я предпочитаю делать что-то вроде:
foo = "word"
bar = foo.capitalize
puts bar
OR
foo = "word"
puts foo.capitalize
Вместо того
foo = "word"
foo.capitalize!
puts foo
На всякий случай я хотел бы снова получить доступ к исходному значению.
! изменяет объект, а не возвращает измененную копию.
- person Charles; 08.08.2016
User.create!
- person Darwin; 09.08.2016
!, опасно - это само собой разумеется; любой метод, который изменяет любой из своих аргументов, является опасным, потому что вы можете потерять данные. Признаюсь: меня учили, что ! изменяет свой объект, и я никогда не сомневался в этом. Так что я благодарю вас за это.
- person Charles; 11.08.2016
Названные «деструктивные методы». Они имеют тенденцию изменять исходную копию объекта, о котором вы говорите.
numbers=[1,0,10,5,8]
numbers.collect{|n| puts n*2} # would multiply each number by two
numbers #returns the same original copy
numbers.collect!{|n| puts n*2} # would multiply each number by two and destructs the original copy from the array
numbers # returns [nil,nil,nil,nil,nil]
