ruby

Jakie są ograniczenia dotyczące nazw metod w Rubim?

Na przykład znalazłem nazwę metody

bundler?

w poniższym fragmencie kodu i nie wiem, czy znak

jest wyspecjalizowanym słowem kluczowym, czy tylko częścią nazwy metody .

# This is a predicate useful for the doc:guides task of applications.

def bundler?

 # Note that rake sets the cwd to the one that contains the Rakefile

 # being executed.

 File.exists?('Gemfile')

end

Zaproszony:

5 odpowiedzi

Anonimowy użytkownik

Potwierdzenie od:

Nazwy metod w Ruby mogą zawierać wielkie i małe litery, numery, podkreśla _ i znaki interpunkcyjne ! ,

/ KOD>.
Nazwa metody nie może zaczynać się od liczby, a znaki

mogą pojawiać się tylko na końcu.
W nazwie metody można używać znaków spoza zestawu ASCII, ale może to prowadzić do bardzo zagmatwanych sytuacji i nie powinno być powszechną praktyką.
Jest to dobra praktyka, choć nie wiązanie, aby rozpocząć nazwę metody z symbolu linii, ponieważ nazwy, które zaczynają się od wielkich liter, są stałe w Ruby. Nadal możesz używać stałej nazwy metody, ale nie będziesz mógł nazwać go bez nawiasów, ponieważ Interptterer wyszuka nazwę jako stałą:

def Capital

 nil

endCapital # NameError: uninitialized constant Capital

Capital() # => nil

Niektóre bardzo szeroko i konsekwentnie używane

umowy

podczas definiowania nazw metod:

Nazwy metod są pisane małymi literami, z podkreśleniami
```
_
```
jako separatorami słów w nazwie (na przykład
```
Math :: sqrt
```
,
```
Array # each_index
```
,. ..).
Predykaty mieć znak zapytania
jako ostatni znak (na przykład
```
Array # empty
```
,
```
Hash # has_key
```
, ...). podczas gdy predykaty zwykle zwracają wartości logiczne, nie zawsze tak jest: te metody muszą po prostu zwracać
```
nil
```
lub
```
false
```
, jeśli predykat jest fałszywy, w przeciwnym razie każdą inną wartość (na przykład ,
```
File :: size
```
zwraca
```
nil
```
jeśli plik nie istnieje, w przeciwnym razie rozmiar pliku to
```
Integer
```
).
Metody, które zmieniają stan obiektu, dla którego są wywoływane lub które zachowują się nietypowo, mają na końcu znak wykrzyknika
```
!
```
; te metody są czasami nazywane mutatory ponieważ są one zwykle destrukcyjnymi lub lokalnymi wersjami innych metod (na przykład
```
Array # sort!
```
,
```
Array # slice!
```
, ...).
Setery mieć znak równości
```
=
```
jako ostatni znak (na przykład
```
Array # [] =
```
, ...); - sugeruje interpreter języka Ruby cukier syntaktyczny aby wywołać metody ustawiające:
```
a = [4, 5, 6]a[0] = 3 # Shorthand for a.[]=(0, 3)
```

Ruby umożliwia także definiowanie operatorów przy użyciu symbolu operatora jako nazwy metody:

╔═══════════════════════════╦═════════════════════════════════════════════╦═══════╗

║ Operators (by precedence) ║ Operations ║ Arity ║

╠═══════════════════════════╬═════════════════════════════════════════════╬═══════╣

║ ! ~ + ║ Boolean NOT, bitwise complement, unary plus ║ 1 ║

║ ║ (define with method name +@, Ruby 1.9+) ║ ║

║ ║ ║ ║

║ ** ║ Exponentiation ║ 2 ║

║ ║ ║ ║

║ - ║ Unary minus (define with method name -@) ║ 1 ║

║ ║ ║ ║

║ */% ║ Multiplication, division, modulo ║ 2 ║

║ ║ ║ ║

║ + - ║ Addition, subtraction ║ 2 ║

║ ║ ║ ║

║ << >> ║ Bitwise shift ║ 2 ║

║ ║ ║ ║

║ & ║ Bitwise AND ║ 2 ║

║ ║ ║ ║

║ | ^ ║ Bitwise OR, Bitwise XOR ║ 2 ║

║ ║ ║ ║

║ < <= => > ║ Ordering ║ 2 ║

║ ║ ║ ║

║ == === != =~ !~ <=> ║ Equality, pattern matching, comparison ║ 2 ║

╚═══════════════════════════╩═════════════════════════════════════════════╩═══════╝

Metody operatora jednoargumentowego nie przekazują żadnych argumentów; metody operatorów binarnych przekazują argument i działają na nim oraz na

self

.
Ważne jest, aby ściśle przestrzegać arsenału operatorów; podczas gdy możliwe jest zdefiniowanie metod operatora o różnej wartości (na przykład metoda

, która przyjmuje dwa argumenty), Ruby nie pozwoli ci wywołać metody ze składnią operatora (będzie jednak działać ze składnią kropkową).
Dobrą praktyką jest jak najbardziej trzymać się oryginalnej semantyki operatora: powinna być intuicyjna dla kogoś, kto zna oryginalne znaczenie operatora, jak to działa z niestandardowymi klasami.
Język oferuje również cukier syntaktyczny dla

Specjalny
, Metoda inna-ooe [] , która jest zwykle używana do dostępu do wartości tablicy i hasha. Metoda

[]

można określić za pomocą dowolnej arrości.
Dla każdego operatora binarnego w tabeli, oprócz porządkowania, równości, porównania i dopasowywania wzorców, Ruby oferuje także skrócone przypisanie (na przykład

x + = y

rozwija się do

x = x + y

); nie możesz zdefiniować ich jako metod, ale możesz zmienić ich zachowanie, definiując operatory, na których są oparte.
Żaden z tych znaków nie może być używany w normalnych nazwach metod (na przykład

do & amp; print

lub

start-up

nie są prawidłowymi nazwami metod).

Anonimowy użytkownik

Potwierdzenie od:

To, co inni mówią, jest prawdziwe w przypadku składni wbudowanej, jednak wydaje się, że nie ma nieodłącznych ograniczeń co do tego, czego można użyć, jeśli używasz metod takich jak

define_method

send

define_method(:'$% ^&') { 0 }

define_method(:'你好') { 1 }send(:'$% ^&') == 0 or raise

send(:'你好') == 1 or raise

Ten fakt może być przydatny: na przykład

,
http://api.rubyonrails.org/cla ... -test
Metoda ActiveSupport :: Testing :: Declarative.test Railsów używa jej, aby uniknąć wykonywania złożonych konwersji do:

test 'Some Controller#Method' do

do bardziej solidnej nazwy, która może kolidować z innym testem o nazwie:

test 'Some Controller_Method' do

Jest to określone w

przewodnik po testach
http://guides.rubyonrails.org/ ... odels
.
Ciekawostka: Podobna rzecz dzieje się w Javie, gdzie nazwa metody kodu bajtowego daje znacznie większy wybór niż język Java:

Dlaczego maszyna JVM pozwala nam nazwać funkcję, która zaczyna się od cyfry w kodzie bajtowym?
https://coderoad.ru/26791204/

Anonimowy użytkownik

Potwierdzenie od:

Nazwy metod mogą kończyć się na

lub

. Podkreślenia są również dozwolone. Ponadto istnieje kilka metod, które wyglądają jak operatory (na przykład

& > & >

[]

), które możesz zdefiniować dla własnych klas.

Anonimowy użytkownik

Potwierdzenie od:

Aby dodać jedną rzecz: możesz również powiedzieć obiektowi, aby uruchomił metodę

bez imienia

i spróbuje wywołać metodę o nazwie

call

#!/usr/bin/env rubyclass Foo=begin

 def call(*args)

 puts "received call with #{args.join(' ')}"

 end

=end def method_missing(m, *args, &block)

 puts "received method_missing on `#{m}(#{args.join(', ')})`"

 endendf = Foo.new

f.('hi') # Not a syntax error! method_missing with m of :call

f.send :'', 'hmm' # method_missing with m set to :''

f.send nil, 'bye' # raises an error

W rzeczywistości nie ma metody o nazwie

Wywołanie

zdefiniowane na

Obiekt

, ale jest jeden na klasach

Metoda

ProC

.
W niektórych językach

()

jest instrukcją wywołania funkcji i jest bardzo podobna do tego, co się tutaj dzieje.
Jest to używane na przykład w JBuilderze Railsów:
https://github.com/rails/jbuilder
https://github.com/rails/jbuilder
Jest to udokumentowane na stronie 196 książki O'Reilly Ruby:

Ruby 1.9 oferuje dodatkowy sposób wywoływania obiektu

Proc

; zamiast nawiasów kwadratowych możesz użyć nawiasów z prefiksem kropki:

z = f.(x,y)

. ()

wygląda jak wywołanie metody, w której brakuje nazwy metody. Nie jest to instrukcja, którą można zdefiniować, ale raczej cukier składniowy, który wywołuje metodę

call

. Może być używany z dowolnym obiektem, który definiuje metodę

call

i nie jest ograniczony do obiektów

Proc

Anonimowy użytkownik

Potwierdzenie od:

Prawidłowe znaki to

aZ,

0-9

jeśli nie na początku,

(dla wartości logicznych funkcje) i

(dla funkcji destrukcyjnych) i

(dla ustawiaczy).

Aby odpowiedzieć na pytania, Zaloguj się lub Zarejestruj się

Jakie są ograniczenia dotyczące nazw metod w Rubim?

5 odpowiedzi

Powiązane pytanie

Stan problemu

Jakie są ograniczenia dotyczące nazw metod w Rubim?

Linki dotyczące treści

5 odpowiedzi

Powiązane pytanie

Stan problemu