Ruby: опрацювання рядків

Розробка уроку

Тема уроку: опрацювання рядків мовою Ruby.

Мета: ознайомити з процедурами й функціями рядкових величин.

По завершенню вивчення учень знає і уміє використовувати засоби мови Ruby для опрацювання рядкових величин.

Обладнання: комп’ютери з встановленими ОС, браузером, середовищем програмування мовою Ruby або стійким сполученням до мережі Інтернет для роботи з online-сервісами, дана інструкція.

Структура уроку

Організаційний етап.
Актуалізація опорних знань.
Вивчення нового матеріалу.
Інструктаж з ТБ.
Вироблення пратичних навичок.
Підбиття підсумків уроку.
Домашнє завдання.

Хід уроку
1. Організаційний етап
Привітання з класом. Перевірка присутності і готовності учнів до уроку.

2. Актуалізація опорних знань

Інтерпретована мова програмування — мова програмування, в якій початковий (сирцевий) код програми не перетворюють попередньо повністю у машинний код для виконання, на відміну від компільованих мов, а виконують рядок за рядком з допомогою спеціальної програми-інтерпретатора.

Ruby — це інтерпретована мова високого рівня для швидкого і зручного об’єктно-орієнтованого програмування.

Алфавіт мови Ruby включає:

великі та малі літери латиниці;
арабські цифри;
пробіл, символи табуляції, символ переходу на наступний рядок тощо;
спеціальні символи , . ; : ? ‘ ” ! | / \ ~ ( ) [ ] { } < > # % ^ & - + * =

Коментар — це частина тексту програми для пояснення програми чи окремих вказівок, що не впливає на виконання програми.

Коментар мовою Ruby у рядку починають символом # (дієз):# текст коментаря

Розгалуження — це простий, але потужний інструмент створення нелінійних алгоритмів. Для його запису використовують оператор такого вигляду:

if умова [then] код… [elsif умова [then] код…]… [else код…] end

Тут квадратними дужками вказано на необов'язковість відповідної складової. За умову може слугувати довільний арифметичний чи логічний вираз (логічним виразом називають такий вираз, у результаті обчислення якого одержують логічне значення true/так, або false/ні).

Вираз if використовують для перевірки справдження умови. Значения умови false и nil вважають хибними (false), а всі решта — будуть істинними (true).

Оператор повторення for:

for змінна in діапазон [do] код (тіло циклу) end

використовують для виконання тіла циклу для кожного елемента з діапазону значень.

Інша форма запису:

діапазон.each do |змінна| код (тіло циклу) end

Оператори керування циклом:

break — перериває виконання циклу;
next — перериває виконання поточного кроку (ітерації) циклу з переходом до наступного кроку;
redo — запускає цикл заново.

Метод введення gets має два необов'язкових аргументи:

Перший аргумент — це роздільник, тобто символ або комбінація символів, до якого буде здійснено зчитування. Значення роздільника як усталено — це ознака кінця рядка, яка у різних операційних системах різна. Інтерпретатор Ruby ініціалізує глобальну змінну $/ «правильним» значенням роздільника. Інакше кажучи, виклики gets і gets($/) еквівалентні. Як роздільник можна вказати порожній рядок або nil. У першому випадку зчитування буде здійснюватися до двох ознак кінця рядка (зчтування «абзацу»), в іншому — буде прочитаний весь файл. Якщо методу gets передають два аргументи, то даний аргумент записують першим.
Другий аргумент — максимальна довжина прочитаного фрагменту. Буде прочитано не більше зазначеного числа байт. Якщо методу gets передають два аргументи, то даний аргумент записують другим.

Метод gets повертає прочитаний рядок або nil, якщо файл було прочитано до кінця. За допомогою методу gets з файлу можна прочитати і рівно один символ.

Метод виведення puts приймає один або більше об'єктів і приводить їх вигляду рядків. Якщо передано масив, кожний елемент масиву буде виведено окремим рядком. Виклик без аргументів призводить до переходу на новий рядок.

Метод виведення print, на відміну від методу puts, не вставляє між рядковими представленнями об'єктів ознаку кінця рядка і не завершує нею виведення. Значення спеціальної змінної $, розділяє об`єкти при виведенні. Її перевизначення призводить до зміни результату виведення:

print 1, 2, 3 # => 123 $, = ", " print 1, 2, 3 # => 1, 2, 3

3. Вивчення нового матеріалу

У мові Ruby, як і у багатьох інших сучасних мовах, вхідні дані зчитують як рядки тексту. Тому уміння опрацювати рядок необхідне при для втілення введення даних (з файлу чи з клавіатури.

Рядок (тексту), тип strings — величина для збереження послідовності символів.

Рядок зберігає довільну послідовність байтів (кодів символів), які тлумачать згідно з певними таблицями кодування. Цей структурований тип даних є стандартним для мови Ruby. Значення рядків (послідовність символів) записують в одинарних лапках (апострофах) або у звичайних подвійних лапках:

щоб записати апостроф у рядок, потрібно обмежити значення рядка подвійними лапками;
щоб записати подвійні лапки у рядок, потрібно обмежити значення рядка апострофами.
В Ruby для опису рядків і роботи з ними використовують напрацювання мови Perl. Це дає такі можливості:

необмежена довжина рядка;
можливість змінювати довжину протягом виконання програми;
довільний об'єкт можна перетворити на рядок (методами .inspect и .to_s);
є велика біблиотека методів (.gsub, .match, .scan, .split) для роботи з правилами;
у рядки, обмежені подвійними лапками, можна вставляти довільні змінні, обмежені #{ і }. Після виконання код буде заміщено результатом.

Методи опрацювання рядків подано з використанням наявної публікації в Інтернеті.

Розрізняють методи, які створюють новий рядок, не змінюючи початковий, і ті, які змінюють рядок. Зазвичай назви останніх закінчуються на !. Інакше кажучи, якщо назва метода не закінчується на !, то метод ствоює новий рядок, а не змінює вихідний. Але це правило має виключення. Наприклад, метод []= (див. далі).

Завдання 1. Ознайомитися з описом використання методів: chop, count, gets, length, split з поданого далі переліку. Літера латиниці s позначає рядок, до якого застосовують метод. У поданих далі прикладах коду передбачено виведення даних для можливості швидкої перевірки коректності коду. Радимо це робити з модифікацією перед використанням методів.

Примітка. Всe, що стосується правил при опрацюванні рядків, не вказано у програмі для загально освітніх закладів освіти навіть з профільним вивченням інформатики.

s.new(a) — повертає новий рядок, що містить копію рядка-параметра a.
s*n — повертає новий рядок, що містить n копій рядка s:

puts "Привіт! "*3 # Привіт! Привіт! Привіт!
s+t — конкатенація (об’єднання, дописування рядків) — повертає новий рядок, отриманий дописуванням t після s:

puts "Будь-"+'ласка' # Будь-ласка
s<<t — повертає новий рядок, отриманий приєднанням t до s. Якщо аргумент t належить діапазону від 0 до 255, то перед приєднанням буде його буде перетворено на символ з відповідним кодом:

puts "Будь-"<<'ласка'<<33 # Будь-ласка!
s <=> t — повертає:
- −1, якщо t менше s;
- 0, якщо t і s збігаються;
- +1, якщо t більше s.
при такому тлумаченні слів «менше» й «більше»:
- якщо рядки різні за довжиною, але збігаються на довжині коротшого з них, то большим вважають той, що довший;
- якщо змінна $= має значення false, то порівняння грунтується на порівнянні двійкових кодів символів у рядку. У ранніх версіях Ruby зміною $= можна було досягнути регістро незалежного порівняння, але зараз для цього використовують метод casecmp:
puts "abcdef" <=> "abcde" # 1 puts "abcdef" <=> "abcdef" # 0 puts "abcdef" <=> "abcdefg" # −1 puts "abcdef" <=> "ABCDEF" # 1
Метод <=> слугує основою таких методів: <, <=, >, >= і between?, які під'єднують з модулем Comparable.
s == t — повертає true, якщо рядки s і t збігаються, інакше повертає false. Інакше кажучи, повертає true тоді й лише тоді, коли код s <=> t повертає 0.
s[index] — повертає код символу з індексом index;
s[k, l] — повертає підрядок довжини l, починаючи з індексу k;
s[діапазон] — повертає підрядок, розташований у діапазоні;
s[рядок] — повертає аргумент-рядок, якщо він є підрядком s, інакше — nil;

s[правило] — повертає повертає фрагмент s, який задовольняє правилу, або nil, якщо такого збігу немає;

s[правило, index] — повертає вміст угруповання правила з номером index (якщо index дорівнює 0, то повертається фрагмент рядка, який задовольняє правилу)

В усіх випадках негативна індексація передбачає відлік з кінця рядка s. Повертає nil, якщо індекс index виходить за межі допустимого діапазону, розмір length від'ємний або початок діапазону range потрапляє після кінця рядка s.
```
s = "Hello there"
puts s[1]                   # "e"
puts s[1,3]                 # "ell"
puts s[1..3]                # "ell"
puts s[-3,2]                # "er"
puts s[-4..-2]              # "her"
puts s[12..-1]              # (nil)
puts s[-2..-4]              # ("")
puts s["lo"]                # "lo"
puts s["bye"]               # (nil)
```
puts s[/[aeiou](.)\1/] # "ell" puts s[/[aeiou](.)\1/, 0] # "ell" puts s[/[aeiou](.)\1/, 1] # "l" puts s[/[aeiou](.)\1/, 2] # (nil)
Дії методів slice и [] ідентичні:
s = "Hello there" puts s.slice(1) # "e" puts s.slice(1,3) # "ell" puts s.slice(1..3) # "ell" puts s.slice(-3,2) # "er" puts s.slice(-4..-2) # "her" puts s.slice(12..-1) # (nil) puts s.slice(-2..-4) # ("") puts s.slice("lo") # "lo" puts s.slice("bye") # (nil)
s[index] = t
s[k, l] = t
s[діапазон] = t
s[рядок] = t
s[правило] = t
s[правило, index] = t

при тлумаченні аргументів такому самому, як для попереднього методу [] — надає значенння елементу, тобто замінює частину або весь вміст рядка s. Якщо довжини рядків не збігаються за розміром, то буде проведено відповідну адаптацію. Якщо правило або рядок або індекс не дозволяють визначити позицію для заміни, то виникає помилка IndexError. Якщо використано форму виклику з правилом та індексом, то буде здійснено заміну підрядка, яка збігається угрупованням у правилі з номером index. Може виникати помилка IndexError, якщо відповідні значення виходить за межі індексації рядка. Форма виклику з діапазоном може викликати помилку RangeError.
s.ascii_only? — повертає true, якщо рядок містить лише ASCII символи, інакше повертає false.
puts "abc".ascii_only? # true puts "abcїєэёыъ".ascii_only? # false
s.capitalize — повертає копію рядка s, у якій перший символ переведено у верхний регістр, а решту — в нижній.
puts "servus".capitalize # Servus puts "SERVUS".capitalize # Servus puts "12DFЄЇ".capitalize # 12dfЄЇ
Діє лише на літери латиниці — див. останній приклад.
s.capitalize! — змінює рядок s: перший символ переведить у верхний регістр, а решту — в нижній. Повертає nil, якщо зніни не потрібні. Діє лише на літери латиниці.

s.casecmp(t) — порівнює рядки s i t аналогічно методу <=>, але без урахування регістру.

puts "abcdef".casecmp("abcde") # 1 puts "aBcDeF".casecmp("abcdef") # 0 puts "abcdef".casecmp("abcdefg") # -1 puts "abcdef".casecmp("ABCDEF") # 0

s.center(k,t) — якщо k перевищує довжину s, то повертає новий рядок довжини k, у якій підрядок s розташовано посередині і обкладено символами рядка t. Інакше повертає s.
puts "привіт".center(4) # привіт puts "привіт".center(20) # привіт puts "привіт".center(21, '*! ') # *! *! *привіт*! *! *!

s.chars — повертає масив символів рядка s.

print "мапювання".chars # ["м", "а", "п", "ю", "в", "а", "н", "н", "я"]

s.chomp(t) — повертає новий рядок, отриманий з s видаленням останнього підрядка t. Якщо системну змінну $/ не було змінено і не передано параметр t, метод chomp виладить ознаки кінця рядка s (\n, \r та \r\n).
puts "Привіт\n".chomp # Привіт puts "Привіт".chomp("віт") # При puts "Привіт".chomp("рив") # Привіт puts "Привіт \n усім".chomp # Привіт # усім
s.chomp!(t) — змінює рядок s згідно з правилом для chomp. Повертає змінений рядок або nil, якщо зміни не потрібні.
s.chop — повертає копію рядка s, з якої видалено останній символ. якщо рядок закінчується комбинацією символів \r\n, то буде видалено всю комбинацію. Для порожнього рядка s повертає порожній рядок.
str.chop! — змінює рядок s згідно з правилом для chop. Повертає змінений рядок або nil, якщо зміни не потрібні (наприклад, якщо метод chop! було застосовано до порожнього рядка).
s.clear — робить рядок s порожнім.
s.concat(t) — синонім s<<t (див. вище).
s.count t* — повертає кількість символів рядка s, що належать до множини символів рядка t. Запис переліку рядків означає належність перетину множин символів (для об'єднання потрібно записати рядок, отриманий дописуванням). За допомогою символа галочки (^) задають виключення з множини. Запис с1-c2 задає множину символів, розташованих між символами c1 і c2.
s = "1234 123 12 1 0" puts s.count "21" # 7 puts s.count "12", "2" # 3 puts s.count "312", "^1" # 5 puts s.count "61-35" # 9
s.delete t* — повертає копію рядка s після видалення всіх символів параметра t (тлумачення запису параметрів таке саме, як для count).
s = "1234 123 12 1 0" puts s.delete "0","21" # 1234 123 12 1 0 puts s.delete "1","21" # 234 23 2 0 puts s.delete "43" # 12 12 12 1 0 puts s.delete "321", "^1" # 14 1 1 1 0 puts s.delete "61-35" # 4 0
s.delete! t* — вилучає з рядка s всі символи параметра t (тлумачення запису параметрів таке саме, як для count). Повертає змінений рядок s або nil, якщо рядок s не потребував змін.
s.downcase — повертає копію рядка s, у якій всі літери латиниці вернего регістра замінено на відповідні літери нижнього.
puts "hELLO! ПРИвіт!".downcase # hello! ПРИвіт!
s.downcase! — змінює рядок s: всі літери латиниці вернього регістра замінено на відповідні літери нижнього. Повертає nil, якщо зміни не потрібні.
s.each_byte {|fixnum| block } — передає кожний байт рядка s у блок вказівок, повертає початковий рядок.
"123 abc".each_byte {|c| print c, ' ' } # 49 50 51 32 97 98 99 t=0 "123".each_byte {|c| t+=c } puts t # 150
s.each_char {|char| block } — передає код кожного символа рядка s у блок вказівок, повертає початковий рядок.
"abc".each_byte {|c| print c, ' ' } # 97 98 99
s.each(separator=$/) {|substr| block} str.each_line(separator=$/) {|substr| block} — розбиває рядок s, використовуючи значення параметра separator (як усталено separator = $/), передаючи кожний з отриманих підрядків як параметр блоку. Якщо значення параметра separator — порожній рядок, то рядок буде поділитися по символу \n, виключаючи випадок, коли кілька символів\ n йдуть підряд. У цьому випадку всі символи \n буде зараховано як один. Повертає початковий рядок.
"Привіт\nВам".each_line{|s| p s} # "Привіт\n" # "Вам" "Привіт\nВам".each_line('т'){|s| p s} # "Привіт" # "\nВам" "Привіт\n\n\nВам".each_line(''){|s| p s} # "Привіт\n\n\n" # "Вам"
s.empty? — повертає true, якщо рядок s порожній. Інакше повертає false.
puts "Привіт".empty? #-> false puts "".empty? #-> true
s.eql?(t) — повертає true, якщо рядки s i t збігаються. Інакше повертає false.
str.gsub(pattern, replacement) str.gsub(pattern) {|match| block} — повертає копію рядка s, де всі збіги з шаблоном (або рядком) pattern замінено на рядок replacement (перший шаблон) або результат виконання блоку (другий шаблон). В результаті роботи методу знайдений збіг з шаблоном pattern буде записано у спеціальну змінну $& (спадщина мови Perl). У рядку replacement можливе використання послідовностей \1, \ 2 і так далі до \9, які є посиланнями на збіги з угрупуваннями. Усередині блоку на угруповання можна посилатися за допомогою спеціальних змінних $1, $2 і так далі до $9. Також у блоці доступні спеціальні змінні $`, $& і $', які дозволяють отримати доступ до підрядку до збігу, збігом і підрядку після збігу, відповідно.
puts "Привіт".gsub(/[иі]/, '*') # Пр*в*т puts "Привіт".gsub(/([иі])/, '<\1>') # Пр<и>в<і>т puts "Привіт".gsub(/./) {|s| s[0].to_s + ' '} # П р и в і т
s.gsub!(pattern, replacement) s.gsub!(pattern) {|match| block} — здійснює заміни як gsub у рядку s. Повертає результат заміни або nil, якщо заміни неможливі.

s.hash — повертає хеш-код рядка s.

puts "ruby назавжди!".hash #-> 1622529594998255587

s.hex — повертає число, отримане у результаті тлумачення рядка s як запис числа у 16-ій системі числення (з необов'язковим зазначенням знака чи префікса 0x). Якщо перетворення нездійснене, то повертає нуль.
puts "0x0a".hex #-> 10 puts "-12".hex #-> -18 puts "0".hex #-> 0 puts "сон".hex #-> 0

s.include? t — повертає true, якщо рядок s підрядок містить підрядок або символ t.

puts "Привіт".include? "ри" # true puts "Привіт".include? "ир" # false puts "Привіт".include? ?т # true

s.index(t [, start]) — повертає індекс першого входження підрядка, символу або збігу з правилом t в рядку s. Повертає nil, якщо входження немає. Необов'язковий параметр start — індекс, з якого потрібно починати пошук входження.
puts "012345".index('3') # 3 puts "012345".index('3',4) # (nil) puts "012345".index('34') # 3 puts "012345".index('43') # (nil) puts "012345".index(/[542]/) # 2
s.insert(i, t) — вставляє рядок t після індексу i в рядок s. Від'ємну індексацію тлумачити як нумерацію з кінця рядка.
puts "abcd".insert(3, 'X') # "abcXd" puts "abcd".insert(-3, 'X') # "abXcd"
s.inspect — повертає копію рядка s, в якій всі спеціальні символи екрановано.
s = "абвгд" s[3] = '\n' puts s # абв\nд puts s.inspect # "абв\\nд"
s.intern — повертає об'єкт класа Symbol, що відповідає рядку s. Є синонім — метод to_sym.
puts 'дуб і липа'.intern # дуб і липа puts 'дуб і липа'.intern.inspect # :"дуб і липа"
s.length — повертає довжину рядка s (кількість символів). Є синонім s.size.
puts "01234".length # 5
s.ljust(j, t) — якщо значення цілого j перевищує довжину рядка s, то повертає новий рядок довжини j з рядком s на початку з наступними копіями рядка t. Інакше повертає рядок s.
puts "Привіт!".ljust(4).inspect # "Привіт!" puts "Привіт!".ljust(10).inspect # "Привіт! " puts "Привіт!".ljust(13, '1234').inspect # "Привіт!123412"
s.lstrip — повертає копію рядка s, з якої вилучено всі пробіли на початку рядка.
puts " Привіт ! ".lstrip.inspect # "Привіт ! " puts "__Привіт ! ".lstrip.inspect # "__Привіт ! "
str.lstrip! — видаляє з рядка s усі пробіли на початку рядка. Повертає nil, якщо таких пробілів немає.

s.match(p) — перетворює параметр p у правило (якщо він таким не був) і здійснює зіставлення цього правила з рядком s.

puts 'Привітання'.match('(.)\1').inspect # #<MatchData "нн" 1:"н"> puts 'Привітання'.match('(.)\1')[0].inspect # "нн" puts 'Привітання'.match(/(.)\1/)[0].inspect # "нн" puts 'Привітання'.match('xx').inspect # nil

s.next — повертає рядок, наступний після s. Наступний елемент обчислюють збільшенням на 1 коду останнього (крайнього правого у записі) елемента рядка s. Якщо в результаті збільшення виникає необхідність «перенесення», символ лівіше буде збільшено на 1. Цей процес буде повторено для всіх необхідних «переносів». У разі потреби до рядка s буде додано додатковий символ. Має синонім s.succ.
puts "ab".next # "ac" puts "a9".next # "b0" puts "<>".next # "<?" puts "19zz".next # "20aa" puts "ZZ99".next # "AAA00" puts "****".next # "**+"
s.succ! — змінює рядок на наступний (про упорядкування рядків див опис s.next). Має синонім s.succ.
s.oct — тлумачить рядок s як рядок вісімкових цифр (з необов'язковим зазначенням знака або префікса 0) і повертає відповідне число. Якщо перетворення нездійснене, повертає нуль.
puts "12".oct # 10 puts "-31".oct # -25 puts "aб".oct # 0 puts "12аб".oct # 10
s.replace(t) — замінює вміст рядка s на значення t.
s = "1234" s.replace('abc') puts s # abc
s.reverse — повертає новий рядок, у якому символи s переставлено у зворотному порядку.
puts "куб".reverse #-> бук
s.reverse! — змінює порядок слідування символів рядка s на зворотний.
s.rindex(t [, j]) — повертає індекс останнього входження підрядка, символу або збігу з правилом t в рядку s. Повертає nil, якщо входження немає. Другий необов'язковий параметр j передає індекс (fixnum), на якому потрібно закінчити пошук.
puts "Привітання".rindex('н') # 8 puts "Привітання".rindex('ф') # (nil) puts "Привітання".rindex(/[иіа]/, 5) # 4
s.rjust(j, t) — ціле число j перевищує довжину рядка s, то метод повертає новий рядок довжини j з рядком s наприкінці і з заповненням початку символами рядка t. Інакше повертає рядок s.
puts "Привіт".rjust(4).inspect # "Привіт" puts "Привіт".rjust(18).inspect # " Привіт" puts "Привіт".rjust(18, '12345').inspect # "123451234512Привіт"

s.rstrip — повертає копію рядка s після вилучення всіх прикінцевих пробілів.

puts " Привіт Вам! ".rstrip.inspect # " Привіт Вам!" puts "Привіт!".rstrip.inspect # "Привіт!"

s.rstrip! — видаляє прикінцеві пробіли з рядка s. Повертає nil, якщо в результаті роботи методу не було зроблено ніяких змін зроблено.
s.scan(p) s.scan(p) {|match, ...| block } — обидві форми виклику послідовно переглядають рядок s щодо збігу з шаблоном p (який може бути як рядком, так і правилом). Кожний збіг буде записано у масив (для першої форми виклику) або передано у блок (для другої форми виклику). Якщо шаблон p (який є правилом) не містить угруповань, то кожний збіг буде записано в окремий елемент (для першої форми виклику) або передано параметром блоку (для другої форми виклику). Також можливе використання спеціальної змінної $&, яка містить результат останнього збігу (актуально при використанні другої форми виклику). Якщо шаблон містить угруповання, то кожний збіг буде розбито на збіги угрупованням з отриманням двовимірного масиву.
a = "монархія республіка" print a.scan(/\р+/) # ["р", "р"] print "\n" print a.scan(/.../) # ["мон", "арх", "ія ", "рес", "пуб", "лік"] print "\n" print a.scan(/(...)/) # [["мон"], ["арх"], ["ія "], ["рес"], ["пуб"], ["лік"]] print "\n" print a.scan(/(..)(..)/) # [["мо", "на"], ["рх", "ія"], [" р", "ес"], ["пу", "бл"]] print "\n" print a.scan(/\р+/) {|w| print "<<#{w}>> " } # <<р>> <<р>> монархія республіка print "\n" print a.scan(/(.)(.)/) {|a,b| print b, a } # оманхряір сеуплбкімонархія республіка
s.size — повертає довжину рядка s (кількість символів). Є синонім s.length.
puts "01234".size # 5

s.slice — дії методів slice и [] ідентичні (див. вище):

s = "Hello there" puts s.slice(1) # "e" puts s.slice(1,3) # "ell" puts s.slice(1..3) # "ell" puts s.slice(-3,2) # "er" puts s.slice(-4..-2) # "her" puts s.slice(12..-1) # (nil) puts s.slice(-2..-4) # ("") puts s.slice("lo") # "lo" puts s.slice("bye") # (nil)

s.slice! — видаляє певну частину тексту з рядка s і повертає цей шматок:

s = "початковий рядок" puts s.slice!(2) # ч puts s # поатковий рядок puts s.slice!(3..6) # тков puts s # поаий рядок puts s.slice!(/о.*р/) # оаий р puts s # пядок puts s.slice!("д") # д puts s # пяок

s.split(p, [l]) — поділяє рядок s на підрядки за роздільником p (який може бути і правилом, і рядком). Якщо роздільник p не вказано, то розподіл буде проведено по символу пробілу (якщо інше не надано спеціальній змінній $;). В результаті поділу буде повернуто масив, який містить фрагменти рядка s. Сам роздільник у результат не входить.

Якщо роздільник p є правилом, то поділ буде проведено за підрядками, що підпадають під дане правило. Якщо p — рядок, то розподіл буде проведено за підрядками, які збігаються з роздільником.

Якщо задано необов'язковий параметр l, то масив-результат матиме l фрагментів рядка s. У цьому випадку останній елемент буде містити залишок, який, можливо, ще можна поділити, якщо він містить роздільники.
print " тепер саме час ".split # ["тепер", "саме", "час"] print "\n" print " тепер саме час ".split(' ') # ["тепер", "саме", "час"] print "\n" print " тепер саме час ".split(/ /) # ["", "тепер", "саме", "час"] print "\n" print "1, 2.34,56, 7".split(%r{,\s*}) # ["1", "2.34", "56", "7"] print "\n" print "Привіт".split(//) # ["П", "р", "и", "в", "і", "т"] print "\n" print "Привіт !".split(//, 3) # ["П", "р", "ивіт !"] print "\n" print "Привіт, друзі!".split(%r{\s*}) # ["П", "р", "и", "в", "і", "т", ",", "д", "р", "у", "з", "і", "!"] print "\n" print "Привіт, друзі!".split("дру") # ["Привіт, ", "зі!"] print "\n" print "1,2,,3,4,,".split(',') # ["1", "2", "", "3", "4"] print "\n" print "1,2,,3,4,,".split(',', 4) # ["1", "2", "", "3,4,,"] print "\n" print "1,2,,3,4,,".split(',', -4) # ["1", "2", "", "3", "4", "", ""]
s.squeeze(d) — cтворює множину символів рядка (рядків) d. Повертає копію рядка s, у якій кілька послідовних символів у утвореної множини замінено на один такий символ. Якщо метод викликано без параметра, то всі підряд повторювані символи буде замінено на відповідний одинараметра, то все идущие подряд повторяющиеся символы будут заменены на соответствующий единичный.
puts "аббвввггггддддд".squeeze # абвгд puts "Два слова".squeeze(" ") # Два слова puts "аббвввггггддддд".squeeze("в-г") # аббвгддддд
s.squeeze!(d) — працює так само, як і squeeze, але результат роботи зберігає у рядок s.
s.strip — повертає копію рядка s, з якої вилучено початкові й прикінцеві пробіли.
puts " Привіт ".strip.inspect # "Привіт" puts "\tБувай\r\n".strip.inspect # "Бувай"
s.strip! — вилучає з рядка s початкові й прикінцеві пробіли.
s.sub(p, r) s.sub(p) {|match| block} — повертає копію рядка s, де перший збіг з шаблоном (або рядком) p замінено на рядок r або результат виконання блоку вказівок, яким буде передано результат збігу. В результаті роботи методу, знайдений збіг з шаблоном p буде записано у спеціальну змінну $& (спадщина мови Perl). У рядку replacement можливе використання послідовностей виду \1, \2 і так далі до \9, які є посиланнями на збіги з угрупуваннями (номер угруповання рахують зліва направо). Усередині блоку на угруповання можна посилатися за допомогою спеціальних змінних виду $1, $2 і так далі до $9. Також, висловом в блоці доступні спеціальні змінні $`, $& і $', які дозволяють отримати доступ до підрядку до збігу, збігом і підрядку після збігу, відповідно.
puts "Привіт".sub('и', '*') # Пр*віт puts "Привіт".sub(/[іu]/, '*') # Прив*т puts "Привіт".sub(/([иі])/, '<\1>') # Пр<и>віт puts "Привіт".sub(/./) {|s| s[0].to_s + ' '} # П ривіт
s.sub!(p, r) s.sub!(p) {|match| block} — змінює рядок s, де перший збіг з шаблоном (або рядком) p замінено на рядок r або результат виконання блоку вказівок. Повертає результат заміни або nil, якщо заміна неможлива.
s.succ — повертає рядок, наступний після s. Наступний елемент обчислюють збільшенням на 1 коду останнього (крайнього правого у записі) елемента рядка s. Якщо в результаті збільшення виникає необхідність «перенесення», символ лівіше буде збільшено на 1. Цей процес буде повторено для всіх необхідних «переносів». У разі потреби до рядка s буде додано додатковий символ. Має синонім s.next.
puts "ab".succ # "ac" puts "a9".succ # "b0" puts "<>".succ # "<?" puts "19zz".succ # "20aa" puts "ZZ99".succ # "AAA00" puts "****".succ # "**+"
s.succ! — змінює значення рядка s на наступне. Має синонім s.next!
s.sum(n) — повертає просту n-бітну контрольну суму символів рядка s, де n = 16 як усталено. Результат — лишок від ділення на 2n - 1 суми двійкових значень кожного символу рядка s. Використання даного методу для підрахунку контрольної суми не є найкращим вибором. Рекомендують використовувати алгоритми MD5 або SHA1, описані у стандартних бібліотеках md5 і sha1.
s.swapcase — Повертає копію рядка s, в якій всі літери латиниці нижнього регістра замінено на відповідні літери верхнього, а всі літери латиниці верхнього регістру замінено на відповідні літери нижнього.
puts "Hello! Привіт!".swapcase # hELLO! Привіт!
s.swapcase! — змінює рядок s: всі літери латиниці нижнього регістра замінено на відповідні літери верхнього, а всі літери латиниці верхнього регістру замінено на відповідні літери нижнього.
s.to_f — повертає число з рухомою крапкою (десятковий дріб) як результат тлумачення рядка s. Символи після останнього числового ігнорують. Якщо початок рядка s неможливо так протлумачити, то повертає 0.0.
puts " 123 ".to_f # 123.0 puts "123.4".to_f # 123.4 puts "123.45e1".to_f # 1234.5 puts "45.67 щось інше".to_f # 45.67 puts "щось інше 45.67".to_f # 0.0
s.to_i(base) — повертає ціле число, як результат тлумачення рядка s як запису цілого числа у системі числення з основою base. Символи після останнього числового ігнорують. Якщо початок рядка s неможливо так протлумачити, то повертає 0.0. Якщо параметр base не вказано, то, як усталено, base=10.
puts "123".to_i # 123 puts "45 щось інше".to_i # 45 puts "щось інше 56".to_i # 0 puts "0a".to_i(16) # 10 puts "11".to_i(7) # 8
s.to_s s.to_str — повертають рядок s без змін.
s.to_sym — повертає об'єкт класу Symbol, який відповідає рядку s. Цей метод використовують для створення символів, які не можуть бути створені в :xxx нотації. Має синонім s.intern і обернений метод symbol.id2name.
puts "пательня".to_sym.inspect # :пательня puts 'пательня і казан'.to_sym.inspect # :"пательня і казан"
s.tr(from, to) — повертає копію рядка s, у якій символи з рядка from замінено на відповідні символи з рядка to. Якщо рядок to коротший, ніж from, то рядок to буде доповнено своїм останнім символом до довжини рядка from. У записі from і to можна використовувати нотацію c1-c2, яку буде розгорнуто у послідовність символів у діапазоні від с1 до с2. Якщо першим символом у рядку-параметрі вказати символ ^, то це буде означати всю множину символів, крім наступних.
puts "Привіт".tr('иі', '12') # Пр1в2т puts "Привіт".tr( 'уеїєоаіяию', '*') # Пр*в*т puts "Привіт".tr('^уеїєоаіяию', '*') # **и*і* puts "Привіт".tr('б-и', 'a-z') # Прhbіт
s.tr!(from, to) — перетворює рядок s, використовуючи алгоритм, описаний для методу tr. Повертає результат перетворення або nil, якщо в результаті рядок s не зазнав змін.
s.tr_s(from, to) — створює копію рядка s, перетворену за алгоритмом методу tr, але з попереднім видаленням повторень символів, описаних у рядку from.роке from.
puts "Привітання".tr_s('аня', 'АНЯ') # ПривітАНЯ puts "Привітання".tr_s('аня', '!') # Привіт! puts "Привітання".tr_s('При', '') # вітання
s.tr_s!(from, to) — перетворює рядок s за алгоритмом методу tr_s. Повертає результат перетворення або nil, якщо в результаті якщо в результаті рядок s не зазнав змін.
s.unpack(format) — декодує рядок s, який може містити двійкові дані, відповідно параметрів рядка format, і повертає масив з декодованими даними. Рядок format складається з односимвольних вказівок — див. опис за такою схемою: позначення вказівки — тип — опис:
- A — String — рядок з віддаленими прикінцевими пробілами;
- a — String — рядок;
- B — String — витягти біти з кожного символу, якщо старший двійковий розряд йде першим;
- b — String — витягти біти з кожного символу, якщо молодший двійковий розряд йде першим;
- C — Fixnum — витягти символ, як беззнаковое ціле (unsigned int);
- c — Fixnum — витягти символ, як ціле (int);
- d, D — Float — тлумачити sizeof (double) символів як дробове подвійної точності (double), власний формат («нативний»);
- E — Float — тлумачити sizeof (double) символів як дробове подвійної точності (double), прямий порядок байтів;
- e — Float — тлумачити sizeof (float) символів як дробове (float), прямий порядок байт;
- f, F — Float — тлумачити sizeof (float) символів як дробове (float), власний формат («нативний»);
- G — Float — тлумачити sizeof (double) символів як дробове з подвійною точністю (double), «мережевий» порядок байт (від старшого до молодшого розряду);
- g — Float — тлумачити sizeof (float) символів як дробове (float), «мережевий» порядок байт (від старшого до молодшого розряду);
- H — String — витягти 16-кові напівбайти з кожного символу, якщо старший напівбайт йде першим;
- h — String — витягти 16-кові напівбайти з кожного символу, якщо молодший напівбайт йде першим;
- I — Integer — тлумачити sizeof (int) (може відрізнятися, якщо використовується _) наступних символів як беззнаковое ціле (unsigned int), власний формат («нативний»);
- i — Integer — тлумачити sizeof (int) (може відрізнятися, якщо використовується _) наступних символів як ціле (int), власний формат ( «нативний»);
- L — Integer — тлумачити 4 (може відрізнятися, якщо використовувати _) наступних символи як беззнаковое довге ціле (unsigned long int), власний формат («нативний»);
- l — Integer — тлумачити 4 (може відрізнятися, якщо використовувати _) наступних символи як довге ціле (long int), власний формат («нативний»);
- M — String — рядок, закодований MIME, Multipurpose Internet Mail Extensions — багатоцільові розши́рення для інтерне́т-по́шти — Інтернет-стандарт, який розширює формат електронної пошти, додаючи підтримку:
  - текстових повідомлень в національних кодуваннях, в яких використовуються ASCII символи;
  - використання національних символів в інформаційних заголовках;
  - не текстових вкладень, як то: зображення, відео або інші файли;
  - передачу повідомлення, що складається з декількох частин);
- m — String — рядок, закодована Base64 (основа системи числення 64);
- N — Integer — тлумачити 4 символи як беззнаковое довге ціле (unsigned long int), «мережевий» порядок байт (від старшого до молодшого розряду);
- n — Fixnum — тлумачити 2 символи як беззнаковое коротке ціле (unsigned short int), «мережевий» порядок байт (від старшого до молодшого розряду);
- P — String — тлумачити sizeof (char *) символів як покажчик і повернути len символів з зазначеній області;
- p — String — тлумачити sizeof (char *) символів як покажчик на рядок із завершальним нулем;
- Q — Integer — тлумачити 8 символів як беззнаковое 64-бітове ціле;
- q — Integer — тлумачити 8 символів як 64-бітове ціле;
- S — Fixnum — тлумачити 2 (кількість може відрізнятися, якщо використовувати _) наступних символи як беззнаковое коротке ціле (unsigned short int), власний формат («нативний»);
- s — Fixnum — тлумачити 2 (кількість може відрізнятися, якщо використовувати _) наступних символи як коротке ціле (short int), власний формат («нативний»);
- U — Integer — UTF-8 символи як беззнаковое ціле;
- u — String — UU-кодований рядок;
- V — Fixnum — тлумачити 4 символи як беззнаковое довге ціле (unsigned long int), прямий порядок байтів;
- v — Fixnum — тлумачити 2 символи як беззнаковое коротке ціле (unsigned short int), прямий порядок байтів;
- w — Integer — BER-упаковане ціле (Basic Encoding Rules — основні правила кодування);
- X — перемістити покажчик на один символ назад;
- x — перемістити покажчик на один символ вперед;
- Z — String — рядок з віддаленими прикінцевими нульовими символами (null) до першого null із *;
- @ — перемістити покажчик на абсолютну позицію.
За кожною вказівкою може слідувати число, яке описує кількість повторень цієї опції. Символ «зірочка» (*) застосовує опцію до всіх елементів рядка. Після директив s, S, i, I, l та L може слідувати символ підкреслення (_), який дозволяє використовувати розміри типів (кількість біт), які специфічні для даної платформи. Інакше буде використано платформо-незалежні розміри типів. Пробільні символи в рядку format буде проігноровано.
print "abc \0\0abc \0\0".unpack('A6Z6') # ["abc", "abc "] print "\n" print "abc \0\0".unpack('a3a3') # ["abc", " \x00\x00"] print "\n" print "abc \0abc \0".unpack('Z*Z*') # ["abc ", "abc "] print "\n" print "aa".unpack('b8B8') # ["10000110", "01100001"] print "\n" print "aaa".unpack('h2H2c') # ["16", "61", 97] print "\n" print "\xfe\xff\xfe\xff".unpack('sS') # [-2, 65534] print "\n" print "now=20is".unpack('M*') # ["now is"] print "\n" print "whole".unpack('xax2aX2aX1aX2a') # ["h", "e", "l", "l", "o"]
str.upcase — повертає копію рядка s, у якій всі літери латиниці нижнього регістра замінено на відповідні літери верхнього.
puts "hEllO Привіт".upcase #-> HELLO Привіт

s.upcase! — змінює рядок s за правилом методу s.

s="hEllO Привіт" puts s.upcase! # HELLO Привіт puts s # HELLO Привіт puts s.upcase! # HELLO Привіт

s.upto(t) {|s| block} — проходить всі значення між s і t включно, передаючи їх в блок вказівок як параметр.
"a8".upto("b3") {|s| print s, ' ' } # a8 a9 b0 b1 b2 b3 print '/n' for s in "a8".."b3" # a8 a9 b0 b1 b2 b3 print s,' ' end

4. Інструктаж з ТБ
5. Вироблення практичних навичок

У наступних завданнях потрібно написати програму для виконання проголошеного завдання, використовуючи вивчені методи chop, count, gets, length, split. Якщо цих методів виявиться недостатньо, використати інші (на власний розсуд). Вважати, що рядок-аргумент містить слова, розділені пробілом, якого немає на початку тексту і наприкінці тексту. Розв'язання записати у файли з назвою Ваше_прізвище_№_завдання.rb у теку, вказану вчителем.

Завдання 2. Знайти кількість слів у рядку тексту.
Завдання 3. Надрукувати окремо з нового рядка кожне слово рядка тексту.
Завдання 4. Знайти й надрукувати перше найдовше слово рядка тексту.
Завдання 5. Порівняти створене з демонстраційними розв'язаннями: 2, 3, 4.

6. Підбиття підсумків уроку

Що таке рядок?
Які переваги мови Ruby в опрацюванні рядків.
Назвіть використані вами методи опрацювання рядків.
Чого навчилися?
Що виникало труднощі?

Виставлення оцінок.

7. Домашнє завдання

Завдання 6. Перевірити чи слова, що записані латиницею у рядку, розташовано у алфавітному порядку.

Вказівки до розв'язання

Розбити рядок на слова.
Використати порівняння рядків для пошуку пари слів, з яких попереднє має стояти після наступного в алфавітному порядку.
Якщо таку пару знайдено, вивести повідомлення про неупорядкованість, інакше — повідомлення про упорядкованість.

Протестувати програму для рядка з використанням кирилиці, у тому числі українських літер, яких немає у російській абетці. Поміркувати, як потрібно змінити програму, щоб отримувати правильну відповідь і в цьому випадку.

Завдання 7. Перекласти мовою Ruby код програми мовою Pascal для отримання нормальної диз'юнктивної форми булевої фукції.

Завдання 8 (за бажанням). Ознайомитися з усім переліком методів опрацювання рядків, поданим у цій розробці, й описом правил (перейти за посиланням на початку викладу матеріалу.

Текст упорядкував Олександр Рудик.