2.3. Встроенные документы

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

str = "Три девицы под окном

Пряли поздно вечерком..."

Но тогда отступ окажется частью строки.

Можно вместо этого воспользоваться встроенным документом, изначально предназначенным для многострочных фрагментов. (Идея и сам термин заимствованы из более старых языков.) Синтаксически он начинается с двух знаков <<, за которыми следует концевой маркер, нуль или более строк текста и в завершение тот же самый концевой маркер в отдельной строке:

str = <

Три девицы под окном

Пряли поздно вечерком...

EOF

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

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

some_method(<

первый кусок

текста...

str1

второй кусок...

str2

третий кусок

текста.

str3

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

str = <<'EOF'

Это не знак табуляции: \t

а это не символ новой строки: \n

EOF

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

str = <<-EOF

  Каждая из этих строк

  начинается с пары

  пробелов.

  EOF

Опишу стиль, который нравится лично мне. Предположим, что определен такой метод margin:

class String

 def margin

  arr = self.split("\n") # Разбить на строки.

  arr.map! {|x| x.sub!(/\s*\|/,"")) # Удалить начальные символы.

  str = arr.join("\n") # Объединить в одну строку.

  self.replace(str) # Подменить исходную строку.

 end

end

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

str = <

 |Этот встроенный документ имеет "левое поле"

 |на уровне вертикальной черты в каждой строке.

 |

 | Можно включать цитаты,

 | делать выступы и т.д.

end

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

 

2.4. Получение длины строки

Для получения длины строки служит метод length. У него есть синоним size.

str1 = "Карл"

x = str1.length # 4

str2 = "Дойль"

x = str2.size # 5

 

2.5. Построчная обработка

Строка в Ruby может содержать символы новой строки. Например, можно прочитать в память файл и сохранить его в виде одной строки. Применяемый по умолчанию итератор each в этом случае перебирает отдельные строки:

str = "Когда-то\nдавным-давно...\nКонец\n"

num = 0

str.each do |line|

num += 1

print "Строка #{num}: #{line}"

end

Выполнение этого кода дает следующий результат:

Строка 1: Когда-то

Строка 2: давным-давно...

Строка 3: Конец

Альтернативно можно было бы воспользоваться методом each_with_index.

 

2.6. Побайтовая обработка

Поскольку на момент написания этой книги язык Ruby еще не поддерживал интернационализацию в полной мере, то символ и байт — по существу одно и то же. Для последовательной обработки символов пользуйтесь итератором each_byte:

str = "ABC"

str.each_byte {|char| print char, " " }

#Результат: 65 66 67.

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

str = "ABC"

chars = str.scan(/./)

chars.each {|char| print char, " " }

#Результат: ABC.

 

2.7. Специализированное сравнение строк

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

Предположим, например, что мы хотим игнорировать английские артикли a, an и the, если они встречаются в начале строки, а также не обращать внимания на большинство знаков препинания. Для этого следует переопределить встроенный метод <=> (он вызывается из методов <, <=, > и >=). В листинге 2.1 показано, как это сделать.

Листинг 2.1. Специализированное сравнение строк

class String

 alias old_compare <=>

 def <=>(other)

  a = self.dup

  b = other.dup

  # Удалить знаки препинания.

  a.gsub!(/[\,\.\?\!\:\;]/, "")

  b.gsub!(/[\,\.\?\!\:\;]/, "")

  # Удалить артикли из начала строки.

  a.gsub!(/^(a |an | the )/i, "")

  b.gsub!(/^(a |an | the )/i, "")

  # Удалить начальные и хвостовые пробелы.

  a.strip!

  b.strip!

  # Вызвать старый метод <=>.

  # a.old_compare(b)

 end

end

title1 = "Calling All Cars"

title2 = "The Call of the Wild"

# При стандартном сравнении было бы напечатано "yes".

if title1 < title2

 puts "yes"

else

 puts "no" # А теперь печатается "no".

end

Обратите внимание, что мы «сохранили» старый метод <=> с помощью ключевого слова alias и в конце вызвали его. Если бы мы вместо этого воспользовались методом <, то был бы вызван новый метод <=>, что привело бы к бесконечной рекурсии и в конечном счете к аварийному завершению программы.

Отметим также, что оператор == не вызывает метод <=> (принадлежащий классу-примеси Comparable). Это означает, что для специализированной проверки строк на равенство пришлось бы отдельно переопределить метод ==. Но в рассмотренном случае в этом нет необходимости.

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

class String

 def <=>(other)

  casecmp(other)

 end

end

Есть и более простой способ:

class String

 alias <=> casecmp(other)

end

Но это не все. Надо еще переопределить оператор ==, чтобы он вел себя точно так же:

class String

 def ==(other)

  casecmp(other) == 0

 end

end

Теперь все строки будут сравниваться без учета регистра. И при всех операциях сортировки, которые определены в терминах метода <=>, регистр тоже не будет учитываться.

 

2.8. Разбиение строки на лексемы

Метод split разбивает строку на части и возвращает массив лексем. Ему передаются два параметра: разделитель и максимальное число полей (целое).

По умолчанию разделителем является пробел, а точнее, значение специальной переменной $; или ее англоязычного эквивалента $FIELD_SEPARATOR. Если же первым параметром задана некоторая строка, то она и будет использоваться в качестве разделителя лексем.

s1 = "Была темная грозовая ночь."

words = s1.split      # ["Была", "темная", "грозовая", "ночь]

s2 = "яблоки, груши, персики"

list = s2.split(", ") # ["яблоки", "груши", "персики"]

s3 = "львы и тигры и медведи"

zoo = s3.split(/ и /) # ["львы", "тигры", "медведи"]

Второй параметр ограничивает число возвращаемых полей, при этом действуют следующие правила:

1. Если параметр опущен, то пустые поля в конце отбрасываются.

2. Если параметр — положительное число, то будет возвращено не более указанного числа полей (если необходимо, весь «хвост» строки помещается в последнее поле). Пустые поля в конце сохраняются.

3. Если параметр — отрицательное число, то количество возвращаемых полей не ограничено, а пустые поля в конце сохраняются.

Ниже приведены примеры:

str = "alpha,beta,gamma,,"

list1 = str.split(",")    # ["alpha","beta","gamma"]

list2 = str.split(",",2)  # ["alpha", "beta,gamma,,"]

list3 = str.split(",",4)  # ["alpha", "beta", "gamma", ","]

list4 = str.split(",",8)  # ["alpha", "beta", "gamma", "", "")

list5 = str.split(",",-1) # ["alpha", "beta", "gamma", "", ""]

Для сопоставления строки с регулярным выражением или с другой строкой служит метод scan:

str = "I am a leaf on the wind..."

# Строка интерпретируется буквально, а не как регулярное выражение.

arr = str.scan("а") # ["а","а","а"]

# При сопоставлении с регулярным выражением возвращаются все соответствия.

arr = str.scan(/\w+/) # ["I", "am", "a", "leaf", "on", "the",

"wind"]

# Можно задать блок.

str.scan(/\w+/) {|x| puts x }

Класс StringScanner из стандартной библиотеки отличается тем, что сохраняет состояние сканирования, а не выполняет все за один раз:

require 'strscan'

str = "Смотри, как я парю!"

ss = StringScanner.new(str)

loop do

 word = ss.scan(/\w+/) # Получать по одному слову.

 break if word.nil?

 puts word

 sep = ss.scan(/\W+/)  # Получить следующий фрагмент,

                       # не являющийся словом.

 break if sep.nil?

end

 

2.9. Форматирование строк

В Ruby, как и в языке С, для этой цели предназначен метод sprintf. Он принимает строку и список выражений, а возвращает строку. Набор спецификаторов в форматной строке мало чем отличается от принятого в функции sprintf (или printf) из библиотеки С.

name = "Боб"

age =28

str = sprintf("Привет, %s... Похоже, тебе %d лет.", name, age)

Спрашивается, зачем нужен этот метод, если можно просто интерполировать значения в строку с помощью конструкции #{expr}? А затем, что sprintf позволяет выполнить дополнительное форматирование - например, задать максимальную ширину поля или максимальное число цифр после запятой, добавить или подавить начальные нули, выровнять строки текста по левой или правой границе и т.д.

str = sprintf("%-20s %3d", name, age)

В классе String есть еще метод %, который делает почти то же самое. Он принимает одно значение или массив значений любых типов:

str = "%-20s %3d" % [name, age] # To же, что и выше

Имеются также методы ljust, rjust и center; они принимают длину результирующей строки и дополняют ее до указанной длины пробелами, если это необходимо.

str = "Моби Дик"

s1 = str.ljust(12)  # "Моби Дик"

s2 = str.center(12) # "  Моби Дик  "

s3 = str.rjust(12)  # "    Моби Дик"

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

str = "Капитан Ахав"

s1 = str.ljust(20,"+")   # "Капитан Ахав++++++++"

s2 = str.center(20,"-")  # "----Капитан Ахав----"

s3 = str.rjust(20,"123") # "12312312Капитан Ахав"

 

2.10. Строки в качестве объектов ввода/вывода

Помимо методов sprintf и scanf, есть еще один способ имитировать ввод/вывод в строку: класс StringIO.

Из-за сходства с объектом IO мы рассмотрим его в главе, посвященной вводу/выводу (см. раздел 10.1.24).

 

2.11. Управление регистром

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

Метод downcase переводит символы всей строки в нижний регистр, а метод upcase — в верхний:

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 могут вызвать недоумение. Ведь оба преобразуют объект в строковое представление, так?

Но есть и различия. Во-первых, любой объект в принципе можно как-то преобразовать в строку, поэтому почти все системные классы обладают методом to_s. Однако метод to_str в системных классах не реализуется никогда.

Как правило, метод to_str применяется для объектов, очень похожих на строки, способных «замаскироваться» под строку. В общем, можете считать, что метод to_s — это явное преобразование, а метод to_str — неявное.

Я уже сказал, что ни в одном системном классе не определен метод to_str (по крайней мере, мне о таких классах неизвестно). Но иногда они вызывают to_str (если такой метод существует в соответствующем классе).

Первое, что приходит на ум, — подкласс класса String; но на самом деле объект любого класса, производного от String, уже является строкой, так что определять метод to_str излишне.

А вот пример из реальной жизни. Класс Pathname определен для удобства работы с путями в файловой системе (например, конкатенации). Но путь естественно отображается на строку (хотя и не наследует классу String).

require 'pathname'

path = Pathname.new("/tmp/myfile")

name = path.to_s # "/tmp/myfile"

name = path.to_str # "/tmp/myfile" (Ну и что?)

# Вот где это оказывается полезно...

heading = "Имя файла равно " + path

puts heading# " Имя файла равно /tmp/myfile"

В этом фрагменте мы просто дописали путь в конец обычной строки "Имя файла равно". Обычно такая операция приводит к ошибке во время выполнения, поскольку оператор + ожидает, что второй операнд — тоже строка. Но так как в классе Pathname есть метод to_str, то он вызывается. Класс Pathname «маскируется» под строку, то есть может быть неявно преобразован в String.

На практике методы to_s и to_str обычно возвращают одно и то же значение, но это необязательно. Неявное преобразование должно давать «истинное строковое значение» объекта, а явное можно расценивать как «принудительное» преобразование.

Метод puts обращается к методу to_s объекта, чтобы получить его строковое представление. Можно считать, что это неявный вызов явного преобразования. То же самое справедливо в отношении интерполяции строк. Вот пример:

class Helium

 def to_s

  "He"

 end

 def to_str

  "гелий"

 end

end

e = Helium.new

print "Элемент "

puts e              # Элемент He.

puts "Элемент " + e # Элемент гелий.

puts "Элемент #{e}" # Элемент He.

Как видите, разумное определение этих методов в собственном классе может несколько повысить гибкость применения. Но что сказать об идентификации объектов, переданных методам вашего класса?

Предположим, например, что вы написали метод, который ожидает в качестве параметра объект String. Вопреки философии «утипизации», так делают часто, и это вполне оправдано. Например, предполагается, что первый параметр метода File.new — строка.

Решить эту проблему просто. Если вы ожидаете на входе строку, проверьте, имеет ли объект метод to_str, и при необходимости вызывайте его.

def set_title(title)

 if title.respond_to? :to_str

  title = title.to_str

 end

 # ...

end

Ну а если объект не отвечает на вызов метода to_str? Есть несколько вариантов действий. Можно принудительно вызвать метод to_s; можно проверить, принадлежит ли объект классу String или его подклассу; можно, наконец, продолжать работать, понимая, что при попытке выполнить операцию, которую объект не поддерживает, мы получим исключение ArgumentError.

Короткий путь к цели выглядит так:

title = title.to_str rescue title

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

title = title.to_str rescue title.to_s rescue title

# Обрабатывается маловероятный случай, когда отсутствует даже метод to_s.

С помощью неявного преобразования можно было бы сделать строки и числа практически эквивалентными:

class Fixnum

 def to_str

  self.to_s end

 end

str = "Число равно " + 345 # Число равно 345.

Но я не рекомендую так поступать: «много хорошо тоже нехорошо». В Ruby, как и в большинстве языков, строки и числа — разные сущности. Мне кажется, что ясности ради преобразования, как правило, должны быть явными.

И еще: в методе to_str нет ничего волшебного. Предполагается, что он возвращает строку, но если вы пишете такой метод сами, ответственность за то, что он действительно так и поступает, ложится на вас.

 

2.17. Дописывание в конец строки

Для конкатенации строк применяется оператор <<. Он «каскадный», то есть позволяет выполнять подряд несколько операций над одним и тем же операндом-приемником.

str = "А"

str << [1,2,3].to_s << " " << (3.14).to_s

# str теперь равно "А123 3.14".

Если число типа Fixnum принадлежит диапазону 0..255, то оно будет преобразовано в символ:

str = "Marlow"

str << 101 << ", Christopher"

# str теперь равно "Marlowe, Christopher".

 

2.18. Удаление хвостовых символов новой строки и прочих

Часто бывает необходимо удалить лишние символы в конце строки. Типичный пример — удаление символа новой строки после чтения строки из внешнего источника.

Метод chop удаляет последний символ строки (обычно это символ новой строки). Если перед символом новой строки находится символ перевода каретки (\r), он тоже удаляется. Причина такого поведения заключается в том, что разные операционные системы неодинаково трактуют понятие «новой строки». В UNIX-подобных системах новая строка представляется символом \n. А в DOS и Windows для этой цели используется пара символов \r\n.

str = gets.chop # Прочитать, удалить символ новой строки.

s2 = "Some string\n" # "Some string" (нет символа новой строки).

s3 = s2.chop! # s2 теперь тоже равно "Some string".

s4 = "Other string\r\n"

s4.chop! # "Other string" (нет символа новой строки).

Обратите внимание, что при вызове варианта chop! операнд-источник модифицируется.

Важно еще отметить, что последний символ удаляется, даже если это не символ новой строки:

str = "abcxyz"

s1 = str.chop # "abcxy"

Поскольку символ новой строки присутствует не всегда, иногда удобнее применять метод chomp:

str = "abcxyz"

str2 = "123\n"

str3 = "123\r"

str4 = "123\r\n"

s1 = str.chomp  # "abcxyz"

s2 = str2.chomp # "123"

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

# \n, но также \r и \r\n.

s3 = str3.chomp # "123"

s4 = str4.chomp # "123"

Как и следовало ожидать, имеется также метод chomp! для замены «на месте». Если методу chomp передана строка-параметр, то удаляются перечисленные в ней символы, а не подразумеваемый по умолчанию разделитель записей. Кстати, если разделитель записей встречается в середине строки, то он не удаляется:

str1 = "abcxyz"

str2 = "abcxyz"

s1 = str1.chomp("yz") # "abcx"

s2 = str2.chomp("x")  # "abcxyz"

 

2.19. Удаление лишних пропусков

Метод strip удаляет пропуски в начале и в конце строки, а вариант strip! делает то же самое «на месте».

str1 = "\t \nabc \t\n"

str2 = str1.strip  # "abc"

str3 = str1.strip! # "abc"

#str1 теперь тоже равно "abc".

Под пропусками, как обычно, понимаются пробелы, символы табуляции и перевода на новую строку.

Чтобы удалить пропуски только в начале или только в конце строки, применяйте методы lstrip и rstrip:

str = " abc "

s2 = str.lstrip # "abc "

s3 = str.rstrip # " abc"

Имеются также варианты lstrip! и rstrip! для удаления «на месте».

 

2.20. Повтор строк

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

etc = "Etc. "*3 # "Etc. Etc. Etc. "

ruler = " + " + (". "*4+"5" + "."*4+" + ")*3

# "+....5....+....5....+....5....+"

 

2.21. Включение выражений в строку

Это легко позволяет сделать синтаксическая конструкция #{}. Нет нужды думать о преобразовании, добавлении и конкатенации; нужно лишь интерполировать переменную или другое выражение в любое место строки:

puts "#{temp_f} по Фаренгейту равно #{temp_c} по Цельсию"

puts "Значение определителя равно #{b*b — 4*а*с}."

puts "#{word} это #{word.reverse} наоборот."

Внутри фигурных скобок могут находиться даже полные предложения. При этом возвращается результат вычисления последнего выражения.

str = "Ответ равен #{ def factorial(n)

 n==0 ? 1 : n*factorial(n-1)

end

answer = factorial(3) * 7}, естественно."

# Ответ равен 42, естественно.

При интерполяции глобальных переменных, а также переменных класса и экземпляра фигурные скобки можно опускать:

print "$gvar = #$gvar и ivar = #@ivar."

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

 

2.22. Отложенная интерполяция

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

str = proc {|x,у,z| "Числа равны #{x}, #{у} и #{z}" }

s1 = str.call(3,4,5) # Числа равны 3, 4 и 5.

s2 = str.call(7,8,9) # Числа равны 7, 8 и 9.

Другое, более громоздкое решение состоит в том, чтобы сохранить строку, заключенную в одиночные кавычки, потом «обернуть» ее двойными кавычками и вычислить:

str = '#{name} - мое имя, а #{nation} - моя родина'

name, nation = "Стивен Дедал", "Ирландия"

s1 = eval('"' + str + '"')

# Стивен Дедал - мое имя, а Ирландия - моя родина.

Можно также передать eval другую функцию привязки:

bind = proc do

 name,nation = "Гулливер Фойл", "Земля"

 binding

end.call # Надуманный пример; возвращает привязанный контекст блока

s2 = eval('"' + str + '"',bind)

# Гулливер Фойл - мое имя, а Земля - моя родина.

У техники работы с eval есть свои «причуды». Например, будьте осторожны, вставляя управляющие последовательности, скажем \n.

 

2.23. Разбор данных, разделенных запятыми

Данные, разделенные запятыми, часто встречаются при программировании. Это в некотором роде «наибольший общий делитель» всех форматов обмена данными. Например, так передаются данные между несовместимыми СУБД или приложениями, которые не поддерживают никакого другого общего формата.

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

Задача оказывается простой, поскольку такой формат данных подозрительно напоминает встроенные в Ruby массивы данных разных типов. Достаточно заключить все выражение в квадратные скобки, чтобы получить массив.

string = gets.chop!

#Предположим, что прочитана такая строка:

#"Doe, John", 35, 225, "5'10\"", "555-0123"

data = eval("[" + string + "]") # Преобразовать в массив.

data.each {|x| puts "Значение = #{x}"}

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

Значение = Doe, John

Значение =35

Значение =225

Значение = 5' 10"

Значение = 555-0123

Более общее решение дает стандартная библиотека CSV. Есть также усовершенствованный инструмент под названием FasterCSV. Поищите его в сети, он не входит в стандартный дистрибутив Ruby.

 

2.24. Преобразование строки в число (десятичное или иное)

Есть два основных способа преобразовать строку в число: методы Integer и Float модуля Kernel и методы to_i и to_f класса String. (Имена, начинающиеся с прописной буквы, например Integer, обычно резервируются для специальных функций преобразования.)

Простой случай тривиален, следующие два предложения эквивалентны:

x = "123".to_i     # 123

y = Integer("123") # 123

Но если в строке хранится не число, то поведение этих методов различается:

x = junk".to_i      # Молча возвращает 0.

y = Integer("junk") # Ошибка.

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

x = "123junk".to_i     # 123

y = Integer("123junk") # Ошибка.

Оба метода допускают наличие пропусков в начале и в конце строки:

x = " 123 ".to_i     # 123

y = Integer(" 123 ") # 123

Преобразование строки в число с плавающей точкой работает аналогично:

x = "3.1416".to_f  # 3.1416

y = Float("2.718") # 2.718

Оба метода понимают научную нотацию:

x = Float("6.02е23")   # 6.02е23

y = "2.9979246е5".to_f # 299792.46

Методы to_i и Integer также по-разному относятся к системе счисления. По умолчанию, естественно, подразумевается система по основанию 10, но другие тоже допускаются (это справедливо и для чисел с плавающей точкой).

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

Следовательно, преобразование системы счисления — это всегда преобразование одной строки в другую. Здесь мы рассмотрим преобразование из строки (обратное преобразование рассматривается в разделах 5.18 и 5.5).

Числу в тексте программы может предшествовать префикс, обозначающий основание системы счисления. Префикс 0b обозначает двоичное число, 0 — восьмеричное, а 0x — шестнадцатеричное.

Метод Integer такие префиксы понимает, а метод to_i — нет:

x = Integer("0b111") # Двоичное - возвращает 7.

y = Integer("0111")  # Восьмеричное - возвращает 73.

z = Integer("0x111") # Шестнадцатеричное - возвращает 291.

x = "0b111".to_i     # 0

y = "0111".to_i      # 0

z = "0x111".to_i     # 0

Однако у метода to_i есть необязательный второй параметр для указания основания. Обычно применяют только четыре основания: 2, 8, 10 (по умолчанию) и 16. Впрочем, префиксы не распознаются даже при определении основания.

x = "111".to_i(2)  # 7

y = "111".to_i(8)  # Восьмеричное - возвращает 73.

z = "111".to_i(16) # Шестнадцатеричное - возвращает 291.

x = "0b111".to_i # 0

y = "0111".to_i  # 0

z = "0x111".to_i # 0

Из-за «стандартного» поведения этих методов цифры, недопустимые при данном основании, обрабатываются по-разному:

x = "12389".to_i(8) # 123 (8 игнорируется).

y = Integer("012389") # Ошибка (8 недопустима).

Хотя полезность этого и сомнительна, метод to_i понимает основания вплоть до 36, когда в представлении числа допустимы все буквы латинского алфавита. (Возможно, это напомнило вам о base64-кодировании; дополнительную информацию по этому поводу вы найдете в разделе 2.37.)

x = "123".to_i(5) # 66

y = "ruby".to_i (36) # 1299022

Для преобразования символьной строки в число можно также воспользоваться методом scanf из стандартной библиотеки, которая добавляет его в модуль Kernel, а также классы IO и String:

str = "234 234 234"

x, y, z = str.scanf("%d %o %x") # 234, 156, 564

Метод scanf реализует всю имеющую смысл функциональность стандартных функций scanf, sscanf и fscanf из библиотеки языка С. Но строки, представляющие двоичные числа, он не обрабатывает.

 

2.25. Кодирование и декодирование строк в кодировке rot13

Rot13 — наверное, самый слабый из известных человечеству шифров. Исторически он просто препятствовал «случайному» прочтению текста. Он часто встречается в конференциях Usenet; например, так можно закодировать потенциально обидную шутку или сценарий фильма «Звездные войны. Эпизод 13» накануне премьеры. Принцип кодирования состоит в смещении символов относительно начала алфавита (латинского) на 13: А превращается в N, В — в О и т.д. Строчные буквы смещаются на ту же величину; цифры, знаки препинания и прочие символы игнорируются. Поскольку 13 — это ровно половина от 26 (число букв в латинском алфавите), то функция является обратной самой себе, то есть ее повторное применение восстанавливает исходный текст.

Ниже приведена реализация этого метода, добавленного в класс String, никаких особых комментариев она не требует:

class String

 def rot13

  self.tr("A-Ma-mN-Zn-z","N-Zn-zA-Ma-m")

 end

end

joke = "Y2K bug"

joke13 = joke.rot13 # "L2X oht"

episode2 = "Fcbvyre: Naanxva qbrfa'g trg xvyyrq."

puts episode2.rot13

 

2.26. Шифрование строк

Иногда нежелательно, чтобы строки можно было легко распознать. Например, пароли не следует хранить в открытом виде, какими бы ограничительными ни были права доступа к файлу.

В стандартном методе crypt применяется стандартная функция с тем же именем для шифрования строки по алгоритму DES. Она принимает в качестве параметра «затравку» (ее назначение то же, что у затравки генератора случайных чисел). На платформах, отличных от UNIX, параметр может быть иным.

Ниже показано тривиальное приложение, которое запрашивает пароль, знакомый любителям Толкиена:

coded = "hfCghHIE5LAM."

puts "Говори, друг, и жми Enter!"

print "Пароль: " password = gets.chop

if password.crypt("hf") == coded

 puts "Добро пожаловать!"

else

 puts "Кто ты, орк?"

end

Стоит отметить, что на такое шифрование не стоит полагаться в серверных Web-приложениях, поскольку пароль, введенный в поле формы, все равно передаётся по сети в открытом виде. В таких случаях проще всего воспользоваться протоколом SSL (Secure Sockets Layer). Разумеется, никто не запрещает пользоваться шифрованием на сервере, но по другой причине — чтобы защитить пароль в хранилище, а не во время передачи по сети.

 

2.27. Сжатие строк

Для сжатия строк и файлов применяется библиотека Zlib.

Зачем может понадобиться сжимать строки? Возможно, чтобы ускорить ввод/вывод из базы данных, оптимизировать использование сети или усложнить распознавание строк.

В классах Deflate и Inflate имеются методы класса deflate и inflate соответственно. У метода deflate (он выполняет сжатие) есть дополнительный параметр, задающий режим сжатия. Он определяет компромисс между качеством сжатия и скоростью. Если значение равно BEST_COMPRESSION, то строка сжимается максимально, но это занимает сравнительно много времени. Значение BEST_SPEED задает максимальную скорость, но при этом строка сжимается хуже. Подразумеваемое по умолчанию значение DEFAULT_COMPRESSION выбирает компромиссный режим.

require 'zlib'

include Zlib

long_string = ("abcde"*71 + "defghi"*79 + "ghijkl"*113)*371

# long_string состоит из 559097 символов.

s1 = Deflate.deflate(long_string,BEST_SPEED) # 4188 символов.

s3 = Deflate.deflate(long_string) # 3568 символов

s2 = Deflate.deflate(long_string,BEST_COMPRESSION) # 2120 символов

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

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

 

2.28. Подсчет числа символов в строке

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

s1 = "abracadabra"

a = s1.count("с")   # 1

b = s1.count("bdr") # 5

Строковый параметр ведет себя как простое регулярное выражение. Если он начинается с символа ^, то берется дополнение к списку:

c = s1.count("^а")    # 6

d = s1.count ("^bdr") # 6

Дефис обозначает диапазон символов:

e = s1.count("a-d")  # 9

f = s1.count("^a-d") # 2

 

2.29. Обращение строки

Для обращения строки служит метод reverse (или его вариант для обращения «на месте» reverse!):

s1 = "Star Trek"

s2 = s1.reverse # "kerT ratS"

si.reverse!     # si теперь равно "kerT ratS"

Пусть требуется обратить порядок слов (а не символов). Тогда можно сначала воспользоваться методом String#split, который вернет массив слов. В классе Array тоже есть метод reverse, поэтому можно обратить массив, а затем с помощью метода join объединить слова в новую строку:

phrase = "Now here's a sentence"

phrase.split(" ").reverse.join(" ")

# "sentence a here's Now"

 

2.30. Удаление дубликатов

Цепочки повторяющихся символов можно сжать до одного методом squeeze:

s1 = "bookkeeper"

s2 = s1.squeeze # "bokeper"

s3 = "Hello..."

s4 = s3.squeeze # "Helo."

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

s5 = s3.squeeze(".") # "Hello."

Этот параметр подчиняется тем же правилам, что и параметр метода count (см. раздел 2.28), то есть допускаются дефис и символ ^. Имеется также метод squeeze!.

 

2.31. Удаление заданных символов

Метод delete удаляет из строки те символы, которые включены в список, переданный в качестве параметра:

s1 = "To be, or not to be"

s2 = s1.delete("b")  # "To e, or not to e"

s3 = "Veni, vidi, vici!"

s4 = s3.delete(",!") # "Veni vidi vici"

Этот параметр подчиняется тем же правилам, что и параметр метода count (см. раздел 2.28), то есть допускаются символы - (дефис) и ^ (каре). Имеется также метод delete!.

 

2.32. Печать специальных символов

Метод dump позволяет получить графическое представление символов, которые обычно не печатаются вовсе или вызывают побочные эффекты:

s1 = "Внимание" << 7 << 7 << 7 # Добавлено три символа ASCII BEL.

puts s1.dump                   # Печатается: Внимание\007\007\007

s2 = "abc\t\tdef\tghi\n\n"

puts s2.dump                   # Печатается: abc\t\tdef\tghi\n\n

s3 = "Двойная кавычка: \""

puts s3.dump                   # Печатается: Двойная кавычка: \"

При стандартном значении переменной $KCODE метод dump дает такой же эффект, как вызов метода inspect для строки. Переменная $KCODE рассматривается в главе 4.

 

2.33. Генерирование последовательности строк

Изредка бывает необходимо получить «следующую» строку. Так, следующей для строки "aaa" будет строка "aab" (затем "aac", "aad" и так далее). В Ruby для этой цели есть метод succ:

droid = "R2D2"

improved = droid.succ # "R2D3"

pill = "Vitamin B"

pill2 = pill.succ     # "Vitamin C"

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

Существует также метод upto, который в цикле вызывает succ, пока не будет достигнуто конечное значение:

"Files, A".upto "Files, X" do | letter |

 puts "Opening: #{letter}"

end

# Выводится 24 строки.

Еще раз подчеркнем, что эта возможность используется редко, да и то на ваш страх и риск. Кстати, метода, возвращающего «предшествующую» строку, не существует.

 

2.34. Вычисление 32-разрядного CRC

Контрольный код циклической избыточности (Cyclic Redundancy Checksum, CRC) — хорошо известный способ получить «сигнатуру» файла или произвольного массива байтов. CRC обладает тем свойством, что вероятность получения одинакового кода для разных входных данных равна 1/2**N, где N — число битов результата (чаще всего 32).

Вычислить его позволяет библиотека zlib, написанная Уэно Кацухиро (Ueno Katsuhiro). Метод crc32 вычисляет CRC для строки, переданной в качестве параметра.

require 'zlib'

include Zlib

crc = crc32("Hello")        # 4157704578

crc = crc32(" world!",crc)  # 461707669

crc = crc32("Hello world!") # 461707669 (то же, что и выше)

В качестве необязательного второго параметра можно передать ранее вычисленный CRC. Результат получится такой, как если бы конкатенировать обе строки и вычислить CRC для объединения. Это полезно, например, когда нужно вычислить CRC файла настолько большого, что прочитать его можно только по частям.

 

2.35. Вычисление МD5-свертки строки

Алгоритм MD5 вырабатывает 128-разрядный цифровой отпечаток или дайджест сообщения произвольной длины. Это разновидность свертки, то есть функция шифрования односторонняя, так что восстановить исходное сообщение по дайджесту невозможно. Для Ruby имеется расширение, реализующее MD5; интересующиеся могут найти его в каталоге ext/md5 стандартного дистрибутива.

Для создания нового объекта MD5 есть два эквивалентных метода класса: new и md5:

require 'md5'

hash = MD5.md5

hash = MD5.new

Есть также четыре метода экземпляра: clone, digest, hexdigest и update. Метод clone просто копирует существующий объект, а метод update добавляет новые данные к объекту:

hash.update("Дополнительная информация...")

Можно создать объект и передать ему данные за одну операцию:

secret = MD5.new("Секретные данные")

Если задан строковый аргумент, он добавляется к объекту путем обращения к методу update. Повторные обращения эквивалентны одному вызову с конкатенированными аргументами:

# Эти два предложения:

сryptic.update("Данные...")

cryptic.update(" еще данные.")

# ... эквивалентны одному такому:

cryptic.update("Данные... еще данные.")

Метод digest возвращает 16-байтовую двоичную строку, содержащую 128-разрядный дайджест.

Но наиболее полезен метод hexdigest, который возвращает дайджест в виде строки в коде ASCII, состоящей из 32 шестнадцатеричных символов, соответствующих 16 байтам. Он эквивалентен следующему коду:

def hexdigest

 ret = ''

 digest.each_byte {|i| ret << sprintf{'%02x' , i) }

 ret

end

secret.hexdigest # "b30e77a94604b78bd7a7e64ad500f3c2"

Короче говоря, для получения MD5-свертки нужно написать:

require 'md5'

m = MD5.new("Секретные данные").hexdigest

 

2.36. Вычисление расстояния Левенштейна между двумя строками

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

Расстоянием Левенштейна называется минимальное число элементарных модификаций, которым нужно подвергнуть одну строку, чтобы преобразовать ее в другую. Элементарными модификациями называются следующие операции: del (удаление одного символа), ins (замена символа) и sub (замена символа). Замену можно также считать комбинацией удаления и вставки (indel).

Существуют разные подходы к решению этой задачи, но не будем вдаваться в технические детали. Достаточно знать, что реализация на Ruby (см. листинг 2.2) позволяет задавать дополнительные параметры, определяющие стоимость всех трех операций модификации. По умолчанию за базовую принимается стоимость одной операции indel (стоимость вставки = стоимость удаления).

Листинг 2.2. Расстояние Левенштейна

class String

 def levenshtein(other, ins=2, del=2, sub=1)

  # ins, del, sub - взвешенные стоимости.

  return nil if self.nil?

  return nil if other.nil?

  dm = [] # Матрица расстояний.

  # Инициализировать первую строку.

  dm[0] = (0..self.length).collect { |i| i * ins }

  fill = [0] * (self.length - 1)

  # Инициализировать первую колонку.

  for i in 1..other.length

   dm[i] = [i * del, fill.flatten]

  end

  # Заполнить матрицу.

  for i in 1..other.length

   for j in 1..self.length

    # Главное сравнение.

    dm[i][j] = [

     dm[i-1][j-1] +

     (self[j-1] == other[i-1] ? 0 : sub),

     dm[i][j-1] * ins,

     dm[i-1][j] + del

    ].min

   end

  end

  # Последнее значение в матрице и есть

  # расстояние Левенштейна между строками.

  dm[other.length][self.length]

 end

end

s1 = "ACUGAUGUGA"

s2 = "AUGGAA"

d1 = s1.levenshtein(s2) # 9

s3 = "Pennsylvania"

s4 = "pencilvaneya"

d2 = s3.levenshtein(s4) # 7

s5 = "abcd"

s6 = "abcd"

d3 = s5.levenshtein(s6) # 0

Определив расстояние Левенштейна, мы можем написать метод similar?, вычисляющий меру схожести строк. Например:

class String

 def similar?(other, thresh=2)

  if self.levenshtein(other) < thresh

   true

  else

   false

  end

 end

end

if "polarity".similar?("hilarity")

 puts "Электричество - забавная штука!"

end

Разумеется, можно было бы передать методу similar? три взвешенные стоимости, которые он в свою очередь передал бы методу levenshtein. Но для простоты мы не стали этого делать.

 

2.37. base64-кодирование и декодирование

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

Простейший способ осуществить base64-кодирование и декодирование — воспользоваться встроенными возможностями Ruby. В классе Array есть метод pack, который возвращает строку в кодировке base64 (если передать ему параметр "m"). А в классе string есть метод unpack, который декодирует такую строку:

str = "\007\007\002\abdce"

new_string = [str].pack("m")      # "BwcCB2JkY2U="

original = new_string.unpack("m") # ["\a\a\002\abdce"]

Отметим, что метод unpack возвращает массив.

 

2.38. Кодирование и декодирование строк (uuencode/uudecode)

Префикс uu в этих именах означает UNIX-to-UNIX. Утилиты uuencode и uudecode — это проверенный временем способ обмена данными в текстовой форме (аналогичный base64).

str = "\007\007\002\abdce"

new_string = [str].pack("u")      # '(P<"!V)D8V4''

original = new_string.unpack("u") # ["\a\a\002\abdce"]

Отметим, что метод unpack возвращает массив.

 

2.39. Замена символов табуляции пробелами и сворачивание пробелов в табуляторы

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

class String

 def detab(ts=8)

  str = self.dup

  while (leftmost = str.index("\t")) != nil

   space = " "* (ts-(leftmost%ts))

   str[leftmost]=space

  end

  str

 end

 def entab(ts=8)

  str = self.detab

  areas = str.length/ts

  newstr = ""

  for a in 0..areas

   temp = str[a*ts..a*ts+ts-1]

   if temp.size==ts

    if temp =~ /+/

     match=Regexp.last_match[0]

     endmatch = Regexp.new(match+"$")

     if match.length>1

      temp.sub!(endmatch,"\t")

     end

    end

   end

   newstr += temp

  end

  newstr

 end

end

foo = "Это всего лишь тест. "

puts foo

puts foo.entab(4)

puts foo.entab(4).dump

Отметим, что этот код не распознает символы забоя.

 

2.40. Цитирование текста

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

str = <<-EOF

  When in the Course of human events it becomes necessary

  for one people to dissolve the political bands which have

  connected them with another, and to assume among the powers

  of the earth the separate and equal station to which the Laws

  of Nature and of Nature's God entitle them, a decent respect

  for the opinions of mankind requires that they should declare the

  causes which impel them to the separation.

EOF

max = 20

line = 0

out = [""]

input = str.gsub(/\n/, " ")

words = input.split(" ")

while input ! = ""

 word = words.shift

 break if not word

 if out[line].length + word.length > max

  out[line].squeeze!(" ")

  line += 1

  out[line] = ""

 end

 out[line] << word + " "

end

out.each {|line| puts line} # Печатает 24 очень коротких строки.

Библиотека Format решает как эту, так и много других схожих задач. Поищите ее в сети.

 

2.41. Заключение

Мы обсудили основы представления строк (заключенных в одиночные или двойные кавычки). Поговорили о том, как интерполировать выражения в строку в двойных кавычках; узнали, что в таких строках допустимы некоторые специальные символы, представленные управляющими последовательностями. Кроме того, мы познакомились с конструкциями %q и %Q, которые позволяют нам по своему вкусу выбирать ограничители. Наконец, рассмотрели синтаксис встроенных документов, унаследованных из старых продуктов, в том числе командных интерпретаторов в UNIX.

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

Пришло время перейти к тесно связанной со строками теме — регулярным выражениям. Регулярные выражения — это мощное средства сопоставления строк с образцами. Мы рассмотрим их в следующей главе.