Хэл Фултон - Программирование на языке Ruby Страница 22

s1 = "Бостонское чаепитие"

s2 = s1.downcase # "бостонское чаепитие"

s3 = s2.upcase   # "БОСТОНСКОЕ ЧАЕПИТИЕ"

Метод capitalize представляет первый символ строки в верхнем регистре, а все остальные - в нижнем:

s4 = s1.capitalize # "Бостонское чаепитие"

s5 = s2.capitalize # "Бостонское чаепитие"

s6 = s3.capitalize # "Бостонское чаепитие"

Метод swapcase изменяет регистр каждой буквы на противоположный:

s7 = "ЭТО БЫВШИЙ попугай."

s8 = s7.swapcase # "это бывший ПОПУГАЙ."

Начиная с версии 1.8, в язык Ruby включен метод casecmp, который работает аналогично стандартному методу <=>, но игнорирует регистр:

n1 = "abc".casecmp("xyz") # -1

n2 = "abc".casecmp("XYZ") # -1

n3 = "ABC".casecmp("xyz") # -1

n4 = "ABC".casecmp("abc") # 0

n5 = "xyz".casecmp("abc") # 1

У каждого из перечисленных методов имеется аналог, осуществляющий модификацию «на месте» (upcase!, downcase!, capitalize!, swapcase!).

He существует встроенных методов, позволяющих узнать регистр буквы, но это легко сделать с помощью регулярных выражений:

if string=~ /[a-z]/

 puts "строка содержит символы в нижнем регистре"

end

if string =~ /[A-Z]/

 puts "строка содержит символы в верхнем регистре"

end

if string =~ /[A-Z]/ and string =~ /а-z/

 puts "строка содержит символы в разных регистрах"

end

if string[0..0] =~ /[A-Z]/

 puts "строка начинается с прописной буквы"

end

Отметим, что все эти методы не учитывают местные особенности (locale).

2.12. Вычленение и замена подстрок

В Ruby к подстрокам можно обращаться разными способами. Обычно применяются квадратные скобки, как для массивов, но внутри скобок может находиться пара объектов класса Fixnum, диапазон, регулярное выражение или строка. Ниже мы рассмотрим все варианты.

Если задана пара объектов класса Fixnum, то они трактуются как смещение от начала строки и длина, а возвращается соответствующая подстрока.

str = "Шалтай-Болтай"

sub1 = str[7,4]   # "Болт"

sub2 = str[7,99]  # "Болтай" (выход за границу строки допускается)

sub3 = str[10,-4] # nil (отрицательная длина)

Важно помнить, что это именно смещение и длина (число символов), а не начальное и конечное смещение.

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

str1 = "Алиса"

sub1 = str1[-3,3] # "иса"

str2 = "В Зазеркалье"

sub3 = str2[-8,6] # "зеркал"

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

str = "Уинстон Черчилль"

sub1 = str[8..13]  # "Черчил"

sub2 = str[-4..-1] # "илль"

sub3 = str[-1..-4] # nil

sub4 = str[25..30] # nil

Если задано регулярное выражение, то возвращается строка, соответствующая образцу. Если соответствия нет, возвращается nil:

str = "Alistair Cooke"

sub1 = str[/1..t/] # "list"

sub2 = str[/s.*r/] # "stair"

sub3 = str[/foo/]  # nil

Если задана строка, то она и возвращается, если встречается в качестве подстроки в исходной строке; в противном случае возвращается nil:

str = "theater"

sub1 = str["heat"]  # "heat"

sub2 = str["eat"]   # "eat"

sub3 = str["ate"]   # "ate"

sub4 = str["beat"]  # nil

sub5 = str["cheat"] # nil

Наконец, в тривиальном случае, когда в качестве индекса задано одно число Fixnum, возвращается ASCII-код символа в соответствующей позиции (или nil, если индекс выходит за границы строки):

str = "Aaron Burr"

ch1 = str[0]  # 65

ch1 = str[1]  # 97

ch3 = str[99] # nil

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

str1 = "Шалтай-Болтай"

str1[7,3] = "Хва"        # "Шалтай-Хватай"

str2 = "Алиса"

str2[-3,3] = "ександра"  # "Александра"

str3 = "В Зазеркалье"

str3[-9,9] = "стеколье"  # "В Застеколье"

str4 = "Уинстон Черчилль"

str4[8..11] = "X"        # "Уинстон Хилль"

str5 = "Alistair Cooke"

str5[/e$/] ="ie Monster" # "Alistair Cookie Monster"

str6 = "theater"

str6["er"] = "re"        # "theatre"

str7 = "Aaron Burr"

str7[0] = 66             # "Baron Burr"

Присваивание выражения, равного nil, не оказывает никакого действия.

2.13. Подстановка в строках

Мы уже видели, как выполняются простые подстановки. Методы sub и gsub предоставляют более развитые средства, основанные на сопоставлении с образцом. Имеются также варианты sub! и gsub!, позволяющие выполнить подстановку «на месте».

Метод sub заменяет первое вхождение строки, соответствующей образцу, другой строкой или результатом вычисления блока:

s1 = "spam, spam, and eggs"

s2 = s1.sub(/spam/,"bacon") # "bacon, spam, and eggs"

s3 = s2.sub(/(\w+), (\w+),/,'\2, \1,') # "spam, bacon, and eggs"

s4 = "Don't forget the spam."

s5 = s4.sub(/spam/) { |m| m.reverse } # "Don't forget the maps."

s4.sub!(/spam/) { |m| m.reverse }

# s4 теперь равно "Don't forget the maps."

Как видите, в подставляемой строке могут встречаться специальные символы \1, \2 и т.д. Но такие специальные переменные, как $& (или ее англоязычная версия $MATCH), не допускаются.

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

Метод gsub (глобальная подстановка) отличается от sub лишь тем, что заменяются все вхождения, а не только первое:

s5 = "alfalfa abracadabra"

s6 = s5.gsub(/a[bl]/,"xx")# "xxfxxfa xxracadxxra"

s5.gsub!(/[lfdbr]/) { |m| m.upcase + "-" }

# s5 теперь равно "aL-F-aL-F-a aB-R-acaD-aB-R-a"

Метод Regexp.last_match эквивалентен действию специальной переменной $& (она же $MATCH).

2.14. Поиск в строке

Помимо различных способов доступа к подстрокам, есть и другие методы поиска в строке. Метод index возвращает начальную позицию заданной подстроки, символа или регулярного выражения. Если подстрока не найдена, возвращается nil:

str = "Albert Einstein"

pos1 = str.index(?E)     # 7

pos2 = str.index("bert") # 2

pos3 = str.index(/in/)   # 8

pos4 = str.index(?W)     # nil

pos5 = str.index("bart") # nil

pos6 = str.index(/Wein/) # nil

Метод rindex начинает поиск с конца строки. Но номера позиций отсчитываются тем не менее от начала:

str = "Albert Einstein"

pos1 = str.rindex(?E)     # 7

pos2 = str.rindex("bert") # 2

pos3 = str.rindex(/in/)   # 13 (найдено самое правое соответствие)

pos4 = str.rindex(?W)     # nil

pos5 = str.rindex("bart") # nil

pos6 = str.rindex(/wein/) # nil

Метод include? сообщает, встречается ли в данной строке указанная подстрока или один символ:

str1 = "mathematics"

flag1 = str1.include? ?e        # true

flag2 = str1.include? "math"    # true

str2 = "Daylight Saving Time"

flag3 = str2.include? ?s        # false

flag4 = str2.include? "Savings" # false

Метод scan многократно просматривает строку в поисках указанного образца. Будучи вызван внутри блока, он возвращает массив. Если образец содержит несколько (заключенных в скобки) групп, то массив окажется вложенным:

str1 = "abracadabra"

sub1 = str1.scan(/а./)

# sub1 теперь равно ["ab","ас","ad","ab"]

str2 = "Acapulco, Mexico"

sub2 = str2.scan(/(.)(c.)/)

# sub2 теперь равно [ ["A","ca"], ["l","со"], ["i","со"] ]

Если при вызове задан блок, то метод поочередно передает этому блоку найденные значения:

str3 = "Kobayashi"

str3.scan(/["aeiou]+[aeiou]/) do |x|

print "Слог: #{x}\n" end

Этот код выводит такой результат:

Слог: Ko

Слог: ba

Слог: уа

Слог: shi

2.15. Преобразование символов в коды ASCII и обратно

В Ruby символ представляется целым числом. Это поведение изменится в версии 2.0, а возможно и раньше. В будущем предполагается хранить символы в виде односимвольных строк.

str = "Martin"

print str[0] # 77

Если в конец строки дописывается объект типа Fixnum, то он предварительно преобразуется в символ:

str2 = str << 111 # "Martino"

2.16. Явные и неявные преобразования

На первый взгляд, методы to_s и to_str могут вызвать недоумение. Ведь оба преобразуют объект в строковое представление, так?