Ruby Language
연산자
수색…
비고
연산자는 메소드입니다.
대부분의 연산자는 실제로는 메쏘드이므로, x + y 는 인자 y 가진 x 의 + 메소드를 호출합니다 x.+(y) 이것은 x.+(y) 됩니다. 주어진 연산자의 의미 론적 의미를 가진 메서드를 직접 작성하면 해당 클래스에 변형을 구현할 수 있습니다.
바보 같은 예로서 :
# A class that lets you operate on numbers by name.
class NamedInteger
name_to_value = { 'one' => 1, 'two' => 2, ... }
# define the plus method
def + (left_addend, right_addend)
name_to_value(left_addend) + name_to_value(right_addend)
end
...
end
&& vs. and , || 를 사용하는 경우 대 or
boolean을 표현하는 두 가지 방법이있다. && 와 and , 그리고 || 또는 or - 그들은 항상은 아니지만, 종종 상호 교환이 가능합니다. 우리는 이것을 "문자"와 "단어"변형이라고 부를 것입니다.
문자 변형은 더 높은 우선 순위를 가지 므로 더 복잡한 명령문에서 괄호를 사용할 필요가 없으므로 예기치 않은 오류가 발생하지 않습니다.
단어 변형은 원래 부울 연산자가 아닌 제어 흐름 연산자 로 사용됩니다. 즉, 체인 메소드 선언문에 사용되도록 설계되었습니다.
raise 'an error' and return
부울 연산자로 사용할 수는 있지만 우선 순위가 낮 으면 예측할 수 없게됩니다.
둘째, 많은 루비 스트는 x.nil과 같은 부울 표현식 ( true 또는 false 평가되는 표현식)을 만들 때 문자 변형을 선호 x.nil? || x.empty? . 한편, 일련의 메소드 가 평가되고 하나가 실패 할 수있는 경우에는 변형 단어가 선호됩니다. 예를 들어 실패시 nil 을 반환하는 메서드에 variant라는 단어를 사용하는 일반적인 관용구는 다음과 같습니다.
def deliver_email
# If the first fails, try the backup, and if that works, all good
deliver_by_primary or deliver_by_backup and return
# error handling code
end
운영자 우선 순위 및 방법
가장 높은 것에서 가장 낮은 것까지 이것이 Ruby의 우선 순위 표입니다. 우선 순위가 높은 작업은 우선 순위가 낮은 작업보다 먼저 발생합니다.
╔═══════════════════════╦════════════════════════════════════════╦═════════╗
║ Operators ║ Operations ║ Method? ║
╠═══════════════════════╬════════════════════════════════════════╬═════════╣
║ . ║ Method call (e.g. foo.bar) ║ ║
║ [] []= ║ Bracket Lookup, Bracket Set ║ ✓¹ ║
║ ! ~ + ║ Boolean NOT, complement, unary plus ║ ✓² ║
║ ** ║ Exponentiation ║ ✓ ║
║ - ║ Unary minus ║ ✓² ║
║ * / % ║ Multiplication, division, modulo ║ ✓ ║
║ + - ║ Addition, subtraction ║ ✓ ║
║ << >> ║ Bitwise shift ║ ✓ ║
║ & ║ Bitwise AND ║ ✓ ║
║ | ^ ║ Bitwise OR, Bitwise XOR ║ ✓ ║
║ < <= >= > ║ Comparison ║ ✓ ║
║ <=> == != === =~ !~ ║ Equality, pattern matching, comparison ║ ✓³ ║
║ && ║ Boolean AND ║ ║
║ || ║ Boolean OR ║ ║
║ .. ... ║ Inclusive range, Exclusive range ║ ║
║ ? : ║ Ternary operator ║ ║
║ rescue ║ Modifier rescue ║ ║
║ = += -= ║ Assignments ║ ║
║ defined? ║ Defined operator ║ ║
║ not ║ Boolean NOT ║ ║
║ or and ║ Boolean OR, Boolean AND ║ ║
║ if unless while until ║ Modifier if, unless, while, until ║ ║
║ { } ║ Block with braces ║ ║
║ do end ║ Block with do end ║ ║
╚═══════════════════════╩════════════════════════════════════════╩═════════╝
단항 + 및 단항 -은 +obj , -obj 또는 -(some_expression) 입니다.
Modifier-if, modifier-unless 등은 해당 키워드의 수정 자 버전입니다. 예를 들어 표현식을 제외하고 이것은 수정 자입니다.
a += 1 unless a.zero?
✓ 연산자를 메서드로 정의 할 수 있습니다. 대부분의 메소드의 이름은 연산자 이름과 동일합니다 (예 :
class Foo
def **(x)
puts "Raising to the power of #{x}"
end
def <<(y)
puts "Shifting left by #{y}"
end
def !
puts "Boolean negation"
end
end
Foo.new ** 2 #=> "Raising to the power of 2"
Foo.new << 3 #=> "Shifting left by 3"
!Foo.new #=> "Boolean negation"
괄호 조회 및 대괄호 집합 방법 ( [] 및 []= )은 이름 뒤에 정의 된 인수를가집니다 (예 :
class Foo
def [](x)
puts "Looking up item #{x}"
end
def []=(x,y)
puts "Setting item #{x} to #{y}"
end
end
f = Foo.new
f[:cats] = 42 #=> "Setting item cats to 42"
f[17] #=> "Looking up item 17"
² "단항 플러스"및 "단항 마이너스"연산자는 +@ 및 -@ 와 같은 메서드로 정의됩니다 (예 :
class Foo
def -@
puts "unary minus"
end
def +@
puts "unary plus"
end
end
f = Foo.new
+f #=> "unary plus"
-f #=> "unary minus"
³ 초기 버전의 Ruby에서는 부등호 연산자 != 와 일치하지 않는 연산자 !~ 를 메소드로 정의 할 수 없었습니다. 대신 해당 동등 연산자 == 또는 일치 연산자 =~ 에 대한 메서드가 호출되었으며 해당 메서드의 결과는 루비에 의해 반전 된 부울 값이었습니다.
자신의 != 또는 !~ 연산자를 정의하지 않으면 위의 동작이 계속 적용됩니다. 그러나 Ruby 1.9.1부터이 두 연산자를 메소드로 정의 할 수도 있습니다.
class Foo
def ==(x)
puts "checking for EQUALITY with #{x}, returning false"
false
end
end
f = Foo.new
x = (f == 42) #=> "checking for EQUALITY with 42, returning false"
puts x #=> "false"
x = (f != 42) #=> "checking for EQUALITY with 42, returning false"
puts x #=> "true"
class Foo
def !=(x)
puts "Checking for INequality with #{x}"
end
end
f != 42 #=> "checking for INequality with 42"
대소 문자 평등 연산자 (===)
Triple Equals 라고도합니다.
이 연산자는 항등 여부를 테스트하지 않고 오른쪽 피연산자에 왼쪽 피연산자와 IS A 관계 가 있는지 테스트합니다. 따라서 유명한 이름의 대소 문자 연산자 는 오해의 소지가 있습니다.
그래서이 대답 은 그것을 설명합니다 : a === b 를 묘사 a === b 가장 좋은 방법 a === b 입니다. "나는 a라는 서랍이 a , b 를 넣는 것이 합리적입니까?" 다른 말로하면, 세트 a 는 멤버 b 합니까?
예 ( 출처 )
(1..5) === 3 # => true
(1..5) === 6 # => false
Integer === 42 # => true
Integer === 'fourtytwo' # => false
/ell/ === 'Hello' # => true
/ell/ === 'Foobar' # => false
재정의하는 클래스 ===
대부분의 클래스는 case 문에서 의미있는 의미를 제공하기 위해 === 를 재정의합니다. 그들 중 일부는 다음과 같습니다.
╔═════════════════╦════════════════════╗
║ Class ║ Synonym for ║
╠═════════════════╬════════════════════╣
║ Array ║ == ║
║ ║ ║
║ Date ║ == ║
║ ║ ║
║ Module ║ is_a? ║
║ ║ ║
║ Object ║ == ║
║ ║ ║
║ Range ║ include? ║
║ ║ ║
║ Regexp ║ =~ ║
║ ║ ║
║ String ║ == ║
╚═════════════════╩════════════════════╝
권장 관행
사례 평등 연산자 === 의 명시 적 사용은 피해야합니다. 그것은 평등을 테스트하는 것이 아니라 오히려 포함 하고 있으며, 그 사용은 혼란 스러울 수 있습니다. 동의어 메서드를 대신 사용하면 코드가 명확하고 이해하기 쉽습니다.
# Bad
Integer === 42
(1..5) === 3
/ell/ === 'Hello'
# Good, uses synonym method
42.is_a?(Integer)
(1..5).include?(3)
/ell/ =~ 'Hello'
안전한 탐색 연산자
Ruby 2.3.0은 안전한 탐색 연산자 인 &. 추가했습니다 &. . 이 연산자는 조건문에서 object && object.property && object.property.method 의 패러다임을 단축하기위한 것입니다.
예를 들어, 당신은이 House 와 객체 address 속성을, 당신은 발견 할 street_name 로부터 address . 이 함수를 사용하여 이전 버전의 Ruby에서 nil 오류를 방지하려면 다음과 같은 코드를 사용하십시오.
if house && house.address && house.address.street_name
house.address.street_name
end
안전한 항법 운영자는이 조건을 단축합니다. 대신 다음과 같이 작성할 수 있습니다.
if house&.address&.street_name
house.address.street_name
end
주의:
안전한 탐색 연산자는 연결된 조건부와 정확히 같은 동작을하지 않습니다. 연결된 조건문 (첫 번째 예)을 사용하면 address 가 false 라고 가정하면 if 블록이 실행되지 않습니다. 안전 탐색 연산자는 nil 값만 인식하지만 false 와 같은 값을 허용합니다. address 가 false 인 경우 SNO를 사용하면 오류가 발생합니다.
house&.address&.street_name
# => undefined method `address' for false:FalseClass