Числа, оператори и изрази:

  • Каква е разликата между Integer и Float?

числата без десетични точки се наричат ​​цели числа, а числата с десетични точки обикновено се наричат ​​числа с плаваща запетая или, по-просто, числа с плаваща запетая.

  • Защо трябва да внимавате, когато преобразувате напред и назад между цели числа и числа с плаваща замък?

Могат да възникнат проблеми с точността между преобразуването на цели числа и числа с плаваща единица

  • Каква е разликата между =, == и ===?

= е оператор за присвояване, == операторът за сравнение проверява дали стойностите на два операнда са равни или не и === се използва за тестване на равенство в рамките на клауза when на оператор case, т.е. (1..10) === 5 връща true

  • Как се правят експоненти в Ruby?

т.е. 2 ** 4 би било равно на 16

  • Какво е диапазон?

Range е друг страхотен клас. Диапазоните представляват интервали от числа.

  • Как създавате диапазон?

числа = (1..10) ще даде 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

  • Каква е разликата между (1..3) и (1...3)?

Ruby създава тези последователности с помощта на операторите за диапазон ‘’..’’ и ‘’…’’. Формата с две точки създава включващ диапазон, докато формата с три точки създава диапазон, който изключва указаната висока стойност.

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
  • Какви са трите начина за създаване на диапазон?

Ruby поддържа диапазони и ни позволява да използваме диапазони по различни начини:

  • Диапазони като последователности
  • Диапазони като условия
  • Диапазони като интервали

Низове:

  • Каква е разликата между единични и двойни кавички?

Единичните кавички не могат да задържат/отпечатват екраниращи последователности директно, докато двойните кавички могат. т.е. низовете в двойни кавички се използват за интерполация на низове в Ruby.

  • Какво е интерполация на низове?

интерполацията на низ използва #{}, дефинирайте променлива и я поставете вътре в #{} и тя ще бъде оценена, т.е. a = 1 поставя „Числото #{a}“

[1] pry(main)› a = 1
=› 1
[2] pry(main)› поставя „Числото #{a}“
Числото 1
=› нула

  • Какво представляват escape героите?

Те се използват за добавяне на табулатори към низове или за екраниране на знаци в текст в единични кавички. \t is tab, \” би избягал от двойни кавички в един израз в кавички и има още няколко, но не толкова често използвани.

Ескейп последователности

По-долу са някои от най-често срещаните последователности за избягване, които могат да се появят в двойни кавички.

Изпробвайте този примерен код, за да разберете по-добре екраниращите последователности.

puts "Hello\t\tworld"
 
puts "Hello\b\b\b\b\bGoodbye world"
 
puts "Hello\rStart over world"
 
puts "1. Hello\n2. World"

Резултатът:

$ double-quotes.rb
Hello		world
Goodbye world
Start over world
1. Hello
2. World
  • Какво представляват прекъсванията на редовете?

за unix/linux „\n“ е нов ред

  • Как правите други неща в струни?

можете да използвате метода to_s

  • Как свързвате низове?

Конкатенирането на низове е създаване на един низ от множество низове.

#!/usr/bin/ruby
lang = "Ruby" + " programming" + " languge"
puts lang
lang = "Python" " programming" " language"
puts lang
lang = "Perl" << " programming" << " language"
puts lang
lang = "Java".concat(" programming").concat(" language")
puts lang
  • Как получавате достъп до конкретен знак или подниз?

Можете да използвате низови методи, т.е.

Търсене / Замяна I

str.end_with?(str2)

Връща true, ако str завършва със str2

str.include?(str2)

Връща true, ако str включва str2

str.index(str2)

Върнат индекс на първото появяване на str2 в str

str.rindex(str2)

Връща индекса на последното срещане на str2 в str

str.start_with?(str2)

Връща true, ако str започва със str2

  • Как се разделят низовете на масиви?

информация за методите на низове → http://ruby-doc.com/docs/ProgrammingRuby/html/ref_c_string.html

splitstr.split( pattern=$;, [ limit ] ) -› масив

Разделя str на поднизове въз основа на разделител, връщайки масив от тези поднизове.

пример "сега е моментът".split»["сега", "на", "времето"]

  • По какво си приличат низовете и масивите? Масиви и низове

Повече за масивите и низовете можете да намерите на http://www.peachpit.com/articles/article.aspx?p=1278994&seqNum=5

Масиви и низове

Конверсиите между масиви и низове са доста често срещани, така че искам да обърна малко повече внимание на темата тук. Не забравяйте, че масивът е списък от стойности, докато низът е всеки символ в кавички (или група от знаци). Методът to_s ще преобразува масив в низ чрез комбиниране на всички стойности:

a = [1, 2, 3, 4]
a.to_s # Returns "1234"
  • Как получавате и почиствате въведеното от потребителя в командния ред?

gets.chomp

gets.chomp подканя потребителите за въвеждане и връща въведеното от тях под формата на низ! Ура И разбира се, можете да конвертирате низа в цяло число чрез to_i или float чрез to_f!

Частта chompy chomp chomp на gets.chomp, CHOMPS от символа за нов ред, който получавате от потребителя. (Това е сериозно защо ОБИЧАМ Ruby... Искам да кажа, хайде, chomp? CHOMP? Толкова готино.)

повече за това можете да намерите на http://gigabytesandtea.com/learning-ruby-whats-the-difference-between-gets-chomp-and-stdin-gets-chomp/

  • Какво означава, че низовете са „променливи“ и защо се интересувате?

Защо низовете са променливи в Ruby

Обектите могат да бъдат променливи или неизменни. Променливите обекти са обекти, чиито състояния могат да се променят, докато неизменните обекти са обекти, чиито състояния никога не се променят след създаването. Едно важно значение на неизменните обекти е, че всяка модификация на съществуващи обекти води до нови обекти.

  • Какво е символ?

Символът по същество е същият като низ, но с една важна разлика. Символът е неизменен

  • Как символът е различен от низ?

Така че символът е по същество същият като низ, но е неизменен.

  • Какво е регулярен израз (RegEx)?

Регулярният израз е специален текстов низ за описание на модел на търсене. Можете да мислите за регулярните изрази като заместващи символи на стероиди. Вероятно сте запознати със заместващи символи като *.txt за намиране на всички текстови файлове във файловия мениджър. Еквивалентът на регулярния израз е .*\.txt.

  • Как можете да центрирате или подравнявате низ отдясно?

Другите два метода за форматиране на низове, които ще разгледаме днес, са ljust и

rjust, което означава ляво оправдаване и дясно оправдаване. Те са подобни на

център, с изключение на това, че допълват низа с интервали отдясно и отляво

страни, съответно. Нека да разгледаме и трите в действие:

Масиви:

  • Какви са трите начина за създаване на масив?

arr = Array.new

arr = []

пристигане =? знам само за два начина!

  • Как предварително попълвате масива с данни по подразбиране?

Array.new(4, „програма“)

[1] pry(main)› arr = Array.new(4, “programme”)
=› [“programme”, “programme”, “programme”, “programme”]

  • Как получавате достъп до елементи в масив?

[2] pry(main)› цели числа = [1, 2, 3, 4, 5]
=› [1, 2, 3, 4, 5]
[3] pry(main)› цели числа[2]
=› 3

Вие давате името на масива и неговия индекс, както показва примерът по-горе. Повече за достъпа до елементи в масиви можете да намерите на http://ruby-doc.org/core-2.2.0/Array.html

  • Как можете да получите достъп до конкретна група от елементи в масив?

използвайте метода на резене

slice(index) → obj или нула

slice(начало, дължина) → new_ary или нула

slice(обхват) → new_ary или нула

Препратка към елемент — Връща елемента по индекс или връща подмасив, започващ от началния индекс и продължаващ за елементи с дължина, или връща подмасив, определен от диапазон от индекси.

Отрицателните индекси се броят назад от края на масива (-1 е последният елемент). За случаи на начало и диапазон, началният индекс е точно преди елемент. Освен това се връща празен масив, когато началният индекс за диапазон от елементи е в края на масива.

Връща нула, ако индексът (или началният индекс) е извън диапазона.

a = [ "a", "b", "c", "d", "e" ]
a[2] +  a[0] + a[1]    #=> "cab"
a[6]                   #=> nil
a[1, 2]                #=> [ "b", "c" ]
a[1..3]                #=> [ "b", "c", "d" ]
a[4..7]                #=> [ "e" ]
a[6..10]               #=> nil
a[-3, 3]               #=> [ "c", "d", "e" ]
# special cases
a[5]                   #=> nil
a[6, 1]                #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []
  • Как променяте елементите в масив?

използвате Array методи като push, pop, shift и unshift

push поставя нов елемент в края на масива и pop премахва последния елемент от масива

unshift добавя нов елемент в началото на масива, а shift премахва първия елемент от масива

  • Как комбинирате масиви?

можете да концентрирате масиви, т.е

[1] pry(main)› цели числа = [1, 2, 3, 4, 5]
=› [1, 2, 3, 4, 5]
[2] pry(main)› числа = [11, 13, 16, 17, 15]
=› [11, 13, 16, 17, 15]
[3] pry(main)› цели числа + числа
= › [1, 2, 3, 4, 5, 11, 13, 16, 17, 15]

  • Как намирате стойностите в един масив, които не са в друг?

използвай булев &

>> [1,2,3] & [2,3,4]
=> [2,3]
  • Как намирате стойности в двата масива?

използвайте boolean |

>> [1,2,3] | [2,3,4]
=> [1,2,3,4]
  • Каква е разликата между push/pop и shift/unshift?

push/pop работят в края на масив, докато shift/unshift работят в предната част на масив

  • Какво представлява операторът с лопата?

операторът на лопатата ‹‹ се използва за избутване на елементи върху масива

Както методът push, така и методът ‹‹ мутират извикващия, така че оригиналният масив се променя.

  • Как › arr.pop е различен от › arr[-1]?

arr.pop премахва последния елемент от масив, докато arr[-1] показва последния елемент от масив

  • Как натискането или добавянето на друг масив към вашия масив е различно от простото им добавяне заедно?

Когато натискате или изравнявате друг масив, той добавя другия масив като един елемент или масив в масив.

[2] pry(main)› arr1 = [1, 2, 3]
=› [1, 2, 3]
[3] pry(main)› arr2 = [4, 5, 6 ]
=› [4, 5, 6]
[4] pry(main)› arr1.push(arr2)
=› [1, 2, 3, [4, 5, 6]]

Когато добавите два масива заедно, това ги изравнява в един масив.

[6] pry(main)› arr1 = [1, 2, 3]
=› [1, 2, 3]
[7] pry(main)› arr2 = [4, 5, 6 ]
=› [4, 5, 6]
[8] pry(main)› arr1 + arr2
=› [1, 2, 3, 4, 5, 6]

  • Как изтривате елементи в масив?

Има няколко метода за изтриване на елементи от масив.

#!/usr/bin/ruby
lts = %w{ a b c d e f g h}
lts.pop
lts.pop
puts lts.inspect
lts.shift
lts.shift
puts lts.inspect
lts.delete_at(0)
lts.delete('d')
puts lts.inspect
puts lts.clear
puts lts.inspect

В този скрипт демонстрираме пет метода, които изтриват елементи от масив.

lts = %w{ a b c d e f g h}

Имаме масив от 8 елемента.

lts.pop

Методът pop премахва последния елемент от масива.

lts.shift

Методът shift премахва първия елемент от масива.

lts.delete_at(0)

delete_at изтрива елемент на определена позиция. Изтриваме първия елемент от останалите елементи.

puts lts.clear

Методът clear изчиства всички елементи от масива.

lts.delete('d')

Методът за изтриване изтрива конкретен елемент от масива.

$ ./deletion.rb
["a", "b", "c", "d", "e", "f"]
["c", "d", "e", "f"]
["e", "f"]
[]

Тук виждаме резултата от примера.

  • Защо трябва да внимавате да изтривате елементи в масив?

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

  • Как можете да конвертирате масиви в низове?

Низовете много приличат на масиви... толкова много, че можем дори да преобразуваме масив в низ! Просто използвайте #join и му кажете какво, ако изобщо искате, между всеки елемент („разделител“):

[6] pry(main)› beer_run = ["къде", "е", "на", "бира"]
=› ["къде", "е", "на", "бира"]
[7] pry(main)› поставя „Давай на бира, ако чуеш, #{beer_run.join(' ')}”
Давай на бира, ако чуеш, къде е бирата< br /> =› нула

  • Как можете да конвертирате от други типове данни в масиви?

създайте масив от диапазон

[9] pry(main)› new_arr = (1..7).to_a
=› [1, 2, 3, 4, 5, 6, 7]
[10] pry(main) › p new_arr
[1, 2, 3, 4, 5, 6, 7]
=› [1, 2, 3, 4, 5, 6, 7]

можете също да разделяте низове в масив

[11] pry(main)› sent = „Хей, къде отидоха всички хубави времена!“
=› „Хей, къде отидоха всички хубави времена!“
[12] pry(main)› sent.split(“ “)
=› [“Хей”, “къде”, “имам”, “всички”, “на”, “добро”, “времена”, “отиде!”]

  • Как можете да разберете дали даден масив съдържа определена стойност?

Вижте дали масив включва елемент ИЗОБЩО, като използвате #include?, което, както трябва да видите от ? накрая връща true или false:

[13] pry(main)› arr_a = [1, 4, 5, 7, 13]
=› [1, 4, 5, 7, 13]
[14] pry(main)› arr_a.include?(4)
=› true
[15] pry(main)› arr_a.include?(33)
=› false

  • Как намирате най-големия елемент в масив?

използвайте метода на масива макс

[16] pry(main)› arr_a.max
=› 13

  • Как намирате най-малкия елемент в масив?

използвайте метода на масива мин

=› 13
[17] pry(main)› arr_a.min
=› 1

  • Как премахвате всички дубликати от вашия масив?

използвайте метода на масива uniq

[18] pry(main)› arr_a.push(5)
=› [1, 4, 5, 7, 13, 5]
[19] pry(main)› arr_a.uniq
=› [1, 4, 5, 7, 13]

  • Как да разберете колко голям е масивът?

можете да използвате размера на метода масив

[21] pry(main)› arr_a
=› [1, 4, 5, 7, 13, 5]
[22] pry(main)› arr_a.size
=› 6

  • Как подреждате масив?

използвайте метода за сортиране

[23] pry(main)› arr_a.sort
=› [1, 4, 5, 5, 7, 13]

  • Какви са конвенциите за именуване на масиви?

конвенциите за именуване на масиви следват същите правила като за променливите, които са изброени по-долу:

Имената на променливите в Ruby могат да бъдат създадени от буквено-цифрови знаци и долната черта _character. Една променлива не може да започва с число. Това улеснява интерпретатора да различи буквално число от променлива. Имената на променливите не могат да започват с главна буква. Ако идентификаторът започва с главна буква, той се счита за константа в Ruby.

  • Какво трябва да съхранявате в масиви?

Можете да поставите всичко в масив! Числа, низове, обекти, символи, хайку...