ምዕራፍ 4 የሬይልስ-ጣዕም ያለው ሩቢ

ይህ ምዕራፍ፣ ምዕራፍ 3 ውስጥ ባሉት ምሳሌዎች ላይ በመመርኮዝ፡ ለሬይልስ አስፈላጊ የሆኑትን አንዳንድ የሩቢ ፕሮግራም ቋንቋ አካላትን ይዳስሳል። ሩቢ በጣም ሰፊ የሆነ የፕሮግራም ቋንቋ ነው፤ እንደ እድል ሆኖ አንድ ውጤታማ የሬይልስ አበልጻጊ ለመሆን የሚያስፈልገው ሩቢ ግን በአንንጻሩ ንዑስ ክፍሉ ነው፡፡ በዚህ ክፍል ውስጥ የሚሰጡ የሩቢ ፕሮግራም ቋንቋ የመግቢያ ምሳሌወች፣ ሩቢን ለማስተዋወቅ ከሚሰጡ የተለመዱ የመግቢያ ምሳሌወች በተወሰነ መልኩ የተለዩ ናቸው። ከዚህ ቀደም የቋንቋው ልምድ ቢኖራችሁም ባይኖራችሁም ይህ ምዕራፍ የተነደፈው የሬይልስ-ጣዕም ያለው ሩቢ ላይ ጠንካራ መሰረትን እንድትይዙ ተደርጎ ነው። ይህ ምዕራፍ ብዙ ነገሮችን ይሸፍናል፤ እና ሁሉንም መጀመርያ ላይ ባትረዱት ምንም ማለት አይደለም። በሚቀጥሉት ምዕራፎች ውስጥ ደጋግመን እንጣቀስበታለን፡፡¹

4.1 ሰበበ-ድርጊት

ባለፈው ምዕራፍ ላይ እንዳየነው፣ ምንም ዓይነት መሰረታዊ የሩቢ ቋንቋ ዕውቀት ባይኖረንም እንኳ አንድ የሬይልስ አፕልኬሽን መሰረትን ማበልጸግ እና እንዲሁም መፈተን መጀመር ይቻላል። እኛም ይህንን ያደረግነው በስልጠናው የተሰጡት የፈተና ከዶች ላይ በመመርኮዝ እና የፈተና ስብስቡ እስኪያልፍ ድረስ እያንዳንዱን የስህተት መልእክት በማስተካከል ነበር። ይሁን እንጅ ይህ ሁኔታ ለዘላለም እንዲህ ሁኖ ሊቀጥል አይችልም፤ እናም በሩቢ መስክ ላይ ድክመቶቻችን ምን እንደሆኑ ለመመልከት፣ ድክመቶቻችን ጋር ፊት-ለፊት ከሚያገጣጥመን አንድ ቦታ ላይ በመነጋገር የዚህ ምዕራፍ መድረክን እንከፍታለን፡፡

ልክ እንደ ክፍል 3.2 ለውጦቻችን የየራሳቸውን ይዞታ ለግላቸው ይይዙ ዘንድ፣ አንድ የተለየ የርእስ ቅርንጫፍን እንጠቀማለን:-

$ git checkout -b የሬይልስ-ጣዕም-ያለው-ሩቢ

ለውጦቹን ክፍል 4.5 ላይ ስንደርስ ወደ ዋና‘ው (main) ቅርንጫፍ እናዋህዳቸዋለን፡፡

4.1.1 አብሮገነብ ረጅወች

በዝርዝር 4.1 ላይ እንደሚታየው፣ አዲሱ አፕልኬሽናችንን ለመጨረሻ ጊዜ ያየነው በትይታችን ውስጥ የኮድ ድግግሞሽን ለማስወገድ የሬይልስ ገጽታን በመጠቀም አብዛኞቹን ቋሚ ገጾች እንዳዘመንን ነው (ይህም ከዝርዝር 3.37 ጋር አንድ ዓይነት ነው)።

ዝርዝር 4.1: 

የማሳያ አፕልኬሽኑ የጣቢያው ገጽታ።  app/views/layouts/application.html.erb
<!DOCTYPE html>
<html>
  <head>
    <title><%= yield(:title) %> | የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን</title>
    <meta charset="utf-8">
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag 'application', media: 'all',
                                           'data-turbolinks-track': 'reload' %>
    <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>

  <body>
    <%= yield %>
  </body>
</html>

እስኪ በዝርዝር 4.1 ውስጥ ካሉት ይዞታወች ውስጥ አንድ ልዩ የሆነ መስመር ላይ እናተኩር:-

<%= stylesheet_link_tag 'application', media: 'all',
                                       'data-turbolinks-track': 'reload' %>

ይህ ቅጠሉህ_አገናኝ_መለያ (stylesheet_link_tag) (ስለዚህ የሬይልስ አ.ፕ.በ² ላይ በደንብ ማንበብ ትችላላችሁ) አብሮገነቡን ³ የሬይልስ ሥልትን በመጠቀም በ‘አፕልኬሽን.ወሉቅ (application.css) ውስጥ ያሉትን ሁሉንም የመገናኛ ዓይነቶች (media types) (የኮምፒዩተር ስክሪኖችን እና የማተሚያ መሳሪያዎችን ያጠቃልላል) ያካትታል። ልምዱ ላለው የሬይልስ አበልጻጊ ይህ አንድ መስመር ኮድ ቀላል ሊመስል ይችላል፣ ነገር ግን በትንሹ አራት ግራ የሚያጋቡ የሩቢ ሃሳቦችን ይዟል። እነሱም:- አብሮገነብ የሬይልስ ሥልቶች፣ ቅንፍ የሌለው የዘዴ ጥሪ፣ ወካዮች እና ተርታወች ናቸው። እነዚህን ሃሳቦች ሁሉ በዚህ ምዕራፍ ውስጥ እንመለከታቸዋለን።

4.1.2 ብጁ ረጅወች

በትይታወች ውስጥ ጥቅም ላይ እንዲውሉ ብዛት ያላቸው አብሮገነብ ሥልቶች ጋር ታጥቆ ከመምጣቱ ባሻገር፣ ሬይልስ አዳዲሶች እንዲፈጠሩም ይፈቅዳል። እነዚህ ሥልቶች ረጅወች (Helpers) ተብለው ይጠራሉ፤ አንድ ብጁ ረጅ እንዴት እንደሚሰራ ለማየት ከዝርዝር 4.1 ውስጥ የአርዕስት ኮድ የያዘውን መስመር በመመርምር እንጀምራለን:-

<%= yield(:title) %> | የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን

ይህ ልክ ከዚህ በታች እንደተመለከተው፣ በእያንዳንዱ ትይታ ውስጥ ባለው አንድ የገጽ አርዕስት ስያሜ ላይ የተመሰረተ ነው (አቅርብ‘ን (provide) በመጠቀም):-

<% provide(:title, "መነሻ") %>
<h1>ማሳያ አፕልኬሽን</h1>
<p>
  ይህ <a href="https://www.railstutorial.org/">
  የሩቢ ኦን ሬይልስ ስልጠና ትምህርት</a>
  ማሳያ ለተባለው አፕልኬሽን፡ የመነሻ ገጽ ነው፡፡
</p>

ነገር ግን አንድ አርዕስት ባንሰጠውስ? በእያንዳዱ ገጽ ላይ የምንጠቀምበት እና ይበልጥ ግልጽ እንዲሆን ከፈለግንም አንድ የገጽ አርዕስት አማራጪ እንዲወስድ የምናደርገው፣ አንድ መሰረተ አርዕስት እንዲኖረን ማድረጉ ጥሩ ልምድ ነው። ካለ አንድ ትንሽ ችግር በስተቀር ይህንን ነገር አሁን ባለን ገጽታ ላይ በአብዛኛው አሳክተናል። ማየት እንደምትችሉት የ‘አቅርብ (provide) ጥሪን ከአንዱ ትይታ ብትሰርዙት፣ አንድ ገጽ-ተኮር አርዕስት ከሌለ ሙሉው አርዕስት እንደሚከተለው ሆኖ ይታያል:-

 | የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን

በሌላ አነጋገር አንድ ተስማሚ መሰረተ አርዕስት አለ፣ ነገር ግን መጀመሪያ ላይ አንድ ተጨማሪ ቀጥ | ያለ ሆሄም አለ።

ይህንን አንድ የገጽ አርዕስት ያለመኖር ችግር ለመፍታት፣ አንድ ሙሉ_አርዕስት (mulu_arest) የተባለ ብጁ ረጅን እንበይናለን። ይህ የ‘ሙሉ_አርዕስት (mulu_arest) ረጅ አንድ የ “የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን” የሚል አንድ መሰረተ አርዕስትን ይመልሳል፣ ይህ በንዲህ እያለ የገጹ አርዕስት ካልተበየነ (ዝርዝር 4.2)⁴ ግን አንድ ከላይ ወደ ታች ቀጥ ያለ ዘንግን ከገጹ አርዕስት ጋር በማስከተል አርዕስቱን ይመልሳል። (በምዕራፍ 7 ላይ አንድ ስምን (ሰዋሰውን) ከብዛቱ ጋር በማሳለፍ፣ አንድ ስምን እስከ ብዛቱ እንዲሰጠን የምንጠቀምበትን እና በይበልጥ በዝርዝር የምንነጋገርበትን አንድ አብዛ (abza) የተባለ ዘዴን በእግረመንገዳችን እንዳካተትን ልትገነዘቡ ይገባል።)

ዝርዝር 4.2: 

አንድ የ‘ሙሉ_አርዕስት (mulu_arest) ረጅን መበየን።  app/helpers/application_helper.rb
module ApplicationHelper

  # በገጹ መሰረት ሙሉውን አርዕስት ይመልሳል።
  def mulu_arest(yegetsu_arest = '')
    meseret_arest = "የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን"
    if yegetsu_arest.empty?
      meseret_arest
    else
      yegetsu_arest + " | " + meseret_arest
    end
  end

  # ይህ ዘዴ ምዕራፍ 7 ውስጥ ስራ ላይ ይውላል።
  # በስሙ መሰረት የስሙን ብዛት ይመልሳል።
  def abza(bzat, sim)
    if bzat != 0
      bzat == 1 ? "#{bzat} #{sim}" : "#{bzat} #{sim}och"
    else
      "#{bzat} #{sim}"
    end
  end
end

አሁን አንድ ረጅ ስላለን ይህን

<title><%= yield(:title) %> | የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን</title>

በዚህ ረጅ በመተካት ገጽታችንን እነዲያቃልልን እሱኑ መጠቀም እንችላለን:-

<title><%= mulu_arest(yegetsu_arest = '') %></title>

የዚህ ውጤት በዝርዝር 4.3 ውስጥ ቁልጪ ብሎ ይታያል።

ዝርዝር 4.3: 

የጣቢያው ገጽታ ከ‘ሙሉ_አርዕስት (mulu_arest) ረጅ ጋር። አረንጓዴ app/views/layouts/application.html.erb
<!DOCTYPE html>
<html>
  <head>
    <title><%= mulu_arest(yield(:title)) %></title>
    <meta charset="utf-8">
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag 'application', media: 'all',
                                           'data-turbolinks-track': 'reload' %>
    <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>
  <body>
    <%= yield %>
  </body>
</html>

ረጃችንን በሰራ ላይ ለማሰማራት፣ አላስፈላጊውን ቃል ማለት “መነሻ” ን ከመነሻ ገጹ ማስወገድ እንችላለን፣ ይህ ደግሞ መሰረተ አርዕስቱ በሱ ቦታ እንዲገባ ይፈቅድለታል። ይህንን የምናደረገውም መጀመርያ በዝርዝር 4.4 ላይ ባለው ኮድ ፈተናችንን በማዘመን ነው፣ ኮዱም ከዚህ በፊት የነበረውን የአርዕስት ፈተና የሚያዘምን እና በአርዕስቱ ውስጥ ብጁ "መነሻ" የተባለ ሃረግ አለመኖሩን ለመፈተሽ አንድ ፈተናን ያክላል።

ማሳሰቢያ:- በክፍል 3.4.2.1 (ዝርዝር 3.32) ውስጥ የተሰጠውን መልመጃ ከሰራችሁ፣ የናንተ ኮድ ዝርዝር 4.4 ውስጥ ካለው ኮድ በጥቂቱ ይለያል፡፡ በክፍል 1.2.2.1 ላይ እንደተገለጸው፣ የመልመጃ መልሶች በአጠቃላይ በዋናው ጽሑፍ ውስጥ እንደማይካተቱ አስታውሱ፣ ስለሆነም ማንኛውንም አይነት የኮድ መለያየት መፍትሄን ለማግኘት እንደተለመደው ቴክኒካዊ ብልሃታችሁን መጠቀም ይኖርባችኋል (ሳጥን 1.2)፡፡

ዝርዝር 4.4: 

የመነሻ ገጽ አርዕስትን ለመፈተን የዘመነ ፈተና። ቀይ test/controllers/quami_getss_controller_test.rb
require 'test_helper'

class QuamiGetssController < ActionDispatch::IntegrationTest

  test "መነሻ ገጽን ማግኘት አለበት" do
    get quami_getss_menesha_url
    assert_response :success
    assert_select "title", "የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን"
  end

  test "እርዳታ ገጽን ማግኘት አለበት" do
    get quami_getss_erdata_url
    assert_response :success
    assert_select "title", "እርዳታ | የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን"
  end

  test "ስለኛ ገጽን ማግኘት አለበት" do
    get quami_getss_silegna_url
    assert_response :success
    assert_select "title", "ስለኛ | የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን"
  end
end

አንድ ፈተና መውደቁን ለማረጋገጥ እስኪ የፈተና ስብስቡን እናስኪድ:- ⁵

ዝርዝር 4.5: ቀይ
$ rails test
3 tests, 6 assertions, 1 failures, 0 errors, 0 skips

በዝርዝር 4.6 ላይ እንደሚታየው፣ የፈተና ስብስቡ እንዲያልፍ አቅርብ (provide) ያለበት መስመርን ከመነሻ ገጽ ትይታው ላይ እናስወግደዋለን።

ዝርዝር 4.6: 

የተበጀ የገጽ አርዕስት የለለው የመነሻ ገጽ። አረንጓዴ app/views/quami_getss/menesha.html.erb
<h1>ማሳያ አፕልኬሽን</h1>
<p>
  ይህ <a href="https://www.railstutorial.org/">
  የሩቢ ኦን ሬይልስ ስልጠና ትምህርት</a>
  ማሳያ ለተባለው አፕልኬሽን፡ የመነሻ ገጽ ነው፡፡
</p>

በዚህ ጊዜ ፈተናው ማለፍ አለበት:-

ዝርዝር 4.7: አረንጓዴ
$ rails test

(የቀድሞወቹ ምሳሌዎች ያለፉትን እና የወደቁትን ፈተናወች ብዛትን እና የ‘ሬይልስ ፈትን (rails test) ትእዛዝን ከፊል ውጽዓት ያካተቱ ነበሩ፤ ከዚህ በኋላ ግን ዝርዝሩን አጪር እና ግልጽ ለማድረግ አብዛኛውን ጊዜ ይወገዳሉ።)

በክፍል 4.1.1 ውስጥ ልክ በአንድ መስመር ኮድ የአፕልኬሽን ቅጠሉህን እንደማካተት ያህል፣ በዝርዝር 4.2 ውስጥ ያለው ኮድ፣ ልምድ ባለው አንድ የሬይልስ አበልጻጊ እይታ አኳያ ሲታይ፣ በጣም ቀላል ይመስላል፤ ነገር ግን በጣም ጠቃሚ በሆኑ የሩቢ ሃሳቦች የተሞላ ነው፤ እነሱንም:- ክፋለክፍሎች (Modules)፣ ዘዴ ብየና (Method Definition)፣ ምርጫዊ የዘዴ ነጋሪአሴቶች (Optional Method Arguments)፣ አስተያየቶች (Comments)፣ የሰፈር ተለዋዋጪ ምደባ (Local Variable Assignment)፣ ቡልየኖች (Booleans)፣ ሁናቴ ተቆጣጣሪ (Control Flow)፣ ሃረግ ማያያዝ (String Concatenation) እና ተመላሽ ዋጋወች (Return Values) ናቸው። ይህ ምዕራፍ እነዚህን ሃሳቦች ሁሉ ይመለከታል።

4.2 ሃረጎች እና ዘዴዎች

ሩቢን ለመማር ዋናው መሳሪያችን የሬይልስ ሰሌዳ ይሆናል፣ ይህን ከሬይልስ አፕልኬሽኖች ጋር መስተጋብር የሚፈጥር አንድ የማዘዥያ መስመር ፕሮግራም፣ መጀመርያ በክፍል 2.3.3 ላይ አይተነዋል። ሰሌዳው ራሱ የተገነባው የሩቢ በይነግንኙነቱ (irb) አናት ላይ ስለሆነ፣ የሩቢ ቋንቋ ሙሉ ኃይል ላይ መዳረሻ አለው። (በክፍል 4.4.4 ላይ ሰሌዳው እንዲሁ በሬይልስ አካባቢ ላይም መዳረሻ እንዳለው እንመለከታለን።)

የደመና ቅ.ማ.አን እየተጠቀማችሁ ከሆነ፣ ሁለት እንድታስተካክሏቸው የማሳስባችሁ የሩቢ በይነግንኙነት ማስተካከያ ውቅረቶች አሉ። ቀላሉን የ‘ናኖ (nano) የጽሑፍ አርታኢን በመጠቀም በቤት ማውጫ ውስጥ የሚገኘውን .አይአርቢአርሲ (.irbrc) የተባለውን ፋይል ክፈቱ:- ⁶

$ nano ~/.irbrc

(ይህ ፋይል ቀድሞውኑ ላይኖር ይችላል፤ ግራም ነፈሰ ቀኝ ልክ ስታስቀምጡት በራስሰር ይፈጠራል፡፡) ከዚያ ፋይሉን በዝርዝር 4.8 ይዞታ ሙሉት፤ ይህም የሩቢ በይነግንኙነት መቀበያን (irb) ቀለል ለማድረግ እና አንዳንድ የሚነተርኩ የራስገብ-ግምስምሶች ባህሪዎችን ለማስተካከል ያዘጋጃል።

ዝርዝር 4.8: 

አንዳንድ የሩቢ በይነግንኙነት (irb) ውቅረቶችን ማከል።  ~/.irbrc
IRB.conf[:PROMPT_MODE] = :SIMPLE
IRB.conf[:AUTO_INDENT_MODE] = false

በመጨረሻም “ተቆር-ኤክስን (Ctrl-X)” ከተጫናችሁ በኋላ ይህ:- ~/.irbrc ፋይል መቀመጡን ለማጽናት y ‘ን ተጫኑ እና ከ‘ናኖ (nano) ውጡ፡፡

አሁን ሰሌዳውን በማዘዥያ መስመሩ ላይ እንደሚከተለው አድርገን መጀመር እንችላለን:-

$ rails console
Loading development environment
>>

ሰሌዳው በነባሪ የሚጀምረው በአንድ የማበልጸጊያ አካባቢ ውስጥ ነው፣ ይህም በሬይልስ ከተበየኑት ሶስት የተለያዩ አካባቢወች ውስጥ አንዱ ነው (ሌሎቹ የፈተና እና የምርት አካባቢወች ናቸው)። ያላቸው ልዩነት በዚህ ምዕራፍ ውስጥ አስፈላጊ ላይሆን ቢችልም፣ ነገር ግን ለወደፊቱ አስፈላጊ ይሆናል፣ ስለነዚህ አካባቢወች ደግሞ በክፍል 7.1.1 ውስጥ በደንብ እንማራለን።

ሰሌዳው በጣም ሃሪፍ የመማሪያ መሳሪያ ነው፣ ስለዚህ እንደፈለጋችሁት ሰሌዳውን መቃኘት ትችላላችሁ፤ ምክንያቱም ምንም ነገር (ምናልባት) ስለማትሰብሩ/ስለማታበላሹ ምንም የሚያሳስባችሁ ነገር አይኖርም። ሰሌዳውን በምትጠቀሙበት ጊዜ፣ ቂርቂራ ውስጥ ከገባችሁ ከሰሌዳው በፍጹም ለመውጣት “ተቆር-ሲን (Ctrl-C)” ወይም “ተቆር-ዲን (Ctrl-D)” መጫን ትችላለችሁ። ልክ እንደ ማንኛውም አንድ መደበኛ የመናኸሪያ ቀፎ፣ ቀደም ሲል የነበሩትን ትእዛዛት ፈልጎ ለማምጣት ከፈለጋችሁ፣ የቁልፍ-ገበታችሁ ላይ ያለውን የወደ ላይ ቀስት ወካይን መጠቀም ትችላላችሁ፣ ይህን ዘዴ መጠቀሙ ብዙ ጊዜ ሊቆጥብ ይችላል።

በተቀረው የዚህ ምዕራፍ ሁሉ፣ የሩቢ አ.ፕ.በን (Ruby API) መመልከቱን በጣም ጠቃሚ ሆኖ ታገኙት ይሆናል። የሩቢ አ.ፕ.በ በመረጃ በጣም የተጠቀጠቀ (ምናልባት ከሚገባው በላይ የተጠቀጠቀ) ነው። ለምሳሌ:- ስለ ሩቢ ሃረግ ለማወቅ የሩቢን አ.ፕ.በ የ‘ሃረግ (String) ክፍል ዝርዝርን ማየት ይቻላል።

በውይይታችን ወቅት፣ አንዳንድ ጊዜ የሩቢ አስተያየቶችን (Comments) እንጠቀማለን፣ የሩቢ አስተያየቶች የሚጀምሩት በፓውንድ ምልክት # ሲሆን አስተያየቱ እስከ መስመሩ መጨረሻ ድረስ ሊዘረጋ ይችላል (ይህ ምልክት “የተርታ ምልክት (hash mark)” ወይም በይበልጥ ቅኔያዊ በሆነ አጠራር “ኦክቶተርፕ (octothorpe)” ተብሎም ይጠራል)። ሩቢ አስተያየቶች ስለማይጠቅሙት ይተዋቸዋል፣ ነገር ግን እነሱ ለእኛ ማንበብ ለምንችለው ፍጡራን (ጸሐፊውን ጨምሮ!) በጣም ጠቃሚዎች ናቸው። በዚህ ኮድ:-

# በገጹ መሰረት ሙሉውን አርዕስት ይመልሳል።
def mulu_arest(yegetsu_arest = '')
  .
  .
  .
end

ላይ ያለው የመጀመሪያው መስመር፣ ተከታዩ የሥልት ብየና ዓላማው ምን እንደሆነ የሚጠቁም አንድ አስተያየት ነው።

በየሰሌዳ ክፍለ ጊዜ ውስጥ እንደተለመደው አስተያየቶችን አታካትቱም፣ ነገር ግን እኔ ትምህርታዊ ለሆነ ዓላማ ስል የሚከተለውን ዓይነት አስተያየት በሚከተለው መልኩ አካትታለሁ:-

$ rails console
>> 17 + 42   # ሙሉ ቁጥርን መደመር።
=> 59

ይህን ክፍል በምትከታተሉት ጊዜ፣ በሰሌዳ ውስጥ በቀጥታ ትእዛዛትን በመጻፍ ወይም ከዚህ ጽሑፍ ላይ ቀድቶ በመገልበጥ ላይ የተመሰረተ ከሆነ፤ አስተያየቶቹን በሚገባ መተው ትችላላችሁ። ሰሌዳው በማንኛውም ሁኔታ አስተያየቶቹን ችላ ይላቸዋል።

4.2.1 ሃረጎች

የድር ገጾች በመጨረሻ ከአገልጋዩ ወደ አሳሹ የተላኩ የሃረጎች ሆሄወችን ያካተቱ በመሆናቸው የተነሳ፣ ምናልባት ሃረጎች ለድር አፕልኬሽኖች በጣም አስፈላጊ የውሂብ መዋቅሮች ናቸው ለማለት ይቻላል፡፡ እስኪ ሃረጎችን በሰሌዳ ውስጥ መቃኘት እንጀምር:-

$ rails console
>> ""          # አንድ ባዶ ሃረግ።
=> ""
>> "ቶማስ"      # አንድ ባዶ ያልሆነ ሃረግ።
=> "ቶማስ"

እነዚህ ሃረግ ቃልበቃል (String Literals) ናቸው (ቃልበቃሉ ሃረግ (Literal Strings) ተብለውም ይጠራሉ)። እነሱም የተፈጠሩት በድርብ ጥቅስ " ሆሄ ነው። ሰሌዳው የተመዘነውን የእያንዳንዱን መስመር ውጤት ያትማል። ይህ ማለትም በአንድ የሃረግ ቃልበቃል ሁኔታ ላይ ራሱ ሃረጉ ነው ማለት ነው።

ሃረጎችን የ + ስሌትን በመጠቀም ማያያዝ እንችላለን:-

>> "ቶማስ" + "ገሬ"    # ሃረጎችን ማያያዝ።
=> "ቶማስገሬ"
>> "foo" + "bar"     # ሃረጎችን ማያያዝ።
=> "foobar"

እዚህ ላይ "ቶማስ" ሲደመር "ገሬ" ሲመዛዘን ውጤቱ "ቶማስገሬ" ሃረግ ነው። ⁷

ሌላኛው ሃረግን የመገንባት መንገድ ደግሞ የውስጠገምት (Interpolation) ልዩ አገባብን #{} በመጠቀም ነው:- ⁸

>> ስም = "ማይክል"        # ተለዋዋጪ ምደባ።
=> "ማይክል"
>> "#{ስም} ሃርትል"       # የሃረግ ውስጠገምት።
=> "ማይክል ሃርትል"

እዚህ ጋር የ‘ "ማይክል" ዋጋን ስም ከተባለ ተለዋዋጪ ጋር ከመደብን በኋላ፣ ከዚያ "#{ስም} ሃርትል" ‘ን በውስጠገምት ወደ ሃረግ እንዲቀየር አድርገነዋል። እንዲሁም ሁለቱንም ሃረጎች አንድ የተለዋዋጪ ስም ጋር እንዲህ አድርገን ልንመድባቸውም እንችላለን:-

>> ስም = "ማይክል"
=> "ማይክል"
>> ያባት_ስም = "ሃርትል"
=> "ሃርትል"
>> ስም + " " + ያባት_ስም    # በመሃል አንድ ክፍትቦታ ያለው ማያያዝ።
=> "ማይክል ሃርትል"
>> "#{ስም} #{ያባት_ስም}"    # ተመጣጣኙ ውስጠገምት።
=> "ማይክል ሃርትል"

ልብ በሉ፣ ሁለቱ ሂሳበሃረጎች (Expressions) እኩል ናቸው፤ እኔ በበኩሌ የምመርጠው ግን የውስጠገምት ስሪቱን ነው፤ ምከንያቱም ሁልጊዜ እንደዚህ ያለ " " አንድ የክፍትቦታ ምልክት ማከሉ ትንሽ ስለሚደብር ነው።

ማተም

አንድ ሃረግን ማያ-ገጽ ላይ ለማተም (Print)፣ በጣም የታወቀ እና ብዙ ሰው የሚጠቀምበት የሩቢ ሥልት አስቀምጥ (puts) ነው (ምንም እንኳን እንዳንድ ሰዎች በተለየ አጠራር ቢጠሩትም ትክክለኛ አጠራሩ ግን “ፑትስ put ess” ነው):-

>> puts "ደስታ"     # ሃረግን ማስቀመጥ።
ደስታ
=> nil

የ‘አስቀምጥ (puts) ዘዴ ስራውን ሲሰራ፣ አንድ ያላስፈላጊ መዘዝን ያስከትላል፤ የ puts "ደስታ" ሂሳበሃረግ አንድ ሃረግን ያትም እና ከዚያም ቃልበቃል ምንምን ይመልሳል፤ ማለት ምንም‘ን (nil) ይመልሳል ይህ በሩቢ “ለምንም ነገር (nothing at all)” የተሰጠ አንድ ልዩ ዋጋ ነው። (በቀጣዩ ክፍለ ጊዜ፣ ማለት አንዳንድ ጊዜ ነገሮችን ቀለል ለማድግ ስል => nil የሚለውን ክፍል በትእዛዝ መቀበያው ላይ እንደማይወጣ አግደዋለሁ።)

ከላይ በተጠቀሱት ምሳሌዎች ላይ እንደሚታየው፣ የፑትስ ዘዴን መጠቀም ሃረጉን በራስሰር ካተመ በኋላ አንድ አዲስ መስመርን ያካትታል (በ በማዘዥያ መስመር ላይ መሰረታዊ እውቀትን ለማግኘት የሚያስፈልገውን ትምህርት ተማር ላይ እንደተብራራው የ‘አስተጋባ (echo) ትእዛዝ ጋር አንድ ዓይነት ባህሪ አለው)። በቅርብ ተዛማጁ አትም (print) የተባለው ትእዛዝ ግን ጥሬውን ሃረግ ያለ ምንም ተጨማሪ አዲስ መስመር ያትማል:-

>> print "ደስታ"    # ያለተጨማሪ መስመር ሃረግን ማተም።
ደስታ=> nil

እዚህ ላይ የሁለተኛው መስመር ማስገቢያ የ‘ ደስታ ውጽዓት ጋር ሲገጫጪ ማየት ይችላል፡፡

የአንድ ተጨማሪ ባዶ ቦታ ሙያዊ ስያሜ አዲስመስመር (Newline) ይባላል፣ እሱም በተለምዶ “በኢህዝባር ኤን backslash n” \n. ይወከላል። አትም (print) የ‘አስቀምጥ (puts) ባህሪን ይቀዳ ዘንድ፣ በሃረጉ ውስጥ አንድ ግልጽ የአዲስ መስመር ሆሄን በማካተት፣ አትምን (print) እንዲህ አድርገን ማዘጋጀት እንችላለን:-

>> print "ደስታ\n"  # ከ puts "ደስታ" ጋር አንድ ዓይነት ነው።
ደስታ
=> nil

በነጠላ ጥቅስ ውስጥ የገቡ ሃረጎች

እስካሁን ድረስ ሁሉም ምሳሌዎች ባለ ድርብ ጥቅስ ሃረጎችን ተጠቅመዋል፣ ነገር ግን ሩቢ ባለ ነጠላ ጥቅስ ሃረጎችንም ይደግፋል። ለብዙ ግልጋሎት ሁለቱም የሃረግ ዓይነቶች የሚፈለገውን ውጤት ለማግኘት አንድ ዓይነት ናቸው:-

>> 'ፋሲል'         # አንድ በነጠላ ጥቅስ ውስጥ የገባ ሃረግ።
=> "ፋሲል"
>> 'ፋሲል' + 'ከበደ'
=> "ፋሲልከበደ"

ቢሆንም ቅሉ፣ በመካከላቸው አንድ ትልቅ ልዩነት አለ፣ እሱም ሩቢ በነጠላ ጥቅስ ውስጥ የገቡ ሃረጎችን ውስጠገምት ያለማድረጉ ነው:-

>> '#{ፋሲል} ከበደ'   # በነጠላ ጥቅስ ውስጥ ያሉ ሃረጎች ውስጠገምትን አይፈቅዱም።
=> "\#{ፋሲል} ከበደ"

ሰሌዳው ባለ ድርብ ጥቅስ ሃረጎችን በመጠቀም ዋጋዎቹን እንዴት እንደሚመልስ ልብ በሉ፤ ይህም እንደ #{ ያሉ ልዩ የሆሄ ውህዶችን ለማምለጥ (Escape) አንድ ኢህዝባርን እንደሚጠይቅ ያሳያል።

በድርብ ጥቅስ የገቡ ሃረጎች በነጠላ ጥቅስ የገቡ ሃረጎች የሚሰሩትን ሁሉ መስራት ከቻሉ እና በተጨማሪም ውስጠገምት ማድረግ ከቻሉ በባለ ነጠላ ጥቅስ የገቡ ሃረጎች ጥቅም የቱ ላይ ነው?… በአብዛኛው ጊዜ በጣም ጠቃሚ ናቸው፤ ምክንያቱም እነሱ ፍጹም ቃልበቃል ናቸው። በተጨማሪም በውስጣቸው የሚይዙት ልክ እናንተ የጻፋችሁትን ሆሄ ብቻ ነው። ለምሳሌ የ “ኢህዝባር” ሆሄ በብዙ ስርዓተ ክወናዎች ላይ ልዩ ነው፣ ልክ እንደ ቃልበቃል አዲስመስመር \n። አንድ ተለዋዋጪ አንድ የቃልበቃል ህዝባርን እንዲይዝ ከፈለጋችሁ፣ ባለ ነጠላ ጥቅስ ይህንን ቀላል ያደርግላችኋል:-

>> '\n'       # አንድ የቃልበቃል ውህደት 'ህዝባር n'።
=> "\\n"

ልክ ባለፈው ምሳሌ ላይ እንዳየነው፣ ሩቢ እንደ #{ ካለ ውህደት ለማምለጥ አንድ ተጨማሪ ኢህዝባርን ይፈልጋል፤ በድርብ ጥቅስ ሃረጎች ውስጥ፣ አንድ የቃልበቃል ኢህዝባር በሁለት ኢህዝባሮች ይወከላል። ይህ አሰራር እላይ እንዳየነው ዓይነት አንድ አነስተኛ ምሳሌ ላይ ብዙም የሚቆጥብልን ነገር የለም፣ ነገር ግን ብዙ የሚመለጡ ነገሮች በሚኖሩበት ጊዜ በጣም ሊረዳ ይችላል:-

>> 'አዲስ መስመሮች (\n) እና ትሮች (\t) ሁለቱም ኢህዝባርን ይጠቀማሉ \።'
=> "አዲስ መስመሮች (\\n) እና ትሮች (\\t) ሁለቱም ኢህዝባርን ይጠቀማሉ \\።"

በመጨረሻም፣ በተለመደ ሁኔታ ላይ ሁለቱም ማለት ድርብ ጥቅስ እና ነጠላ ጥቅስ በጥሩ ሁኔታ የሚሰሩ መሆናቸውን መገንዘብ ያስፈልጋል፣ የኮድ ምንጩም እንዲሁ ብዙውን ጊዜ ያለግልጽ ንድፍ በሁለቱ ጥቅሶች መካከል ሲቀያይር ያጋጥማችኋል። በዚህ ጉዳይ ላይ “እንኳን ወደ ሩቢ በደህና መጡ! ይህን በቅርቡ ትለምዱታላችሁ።” ከማለት በስተቀር ሌላ ምንም የሚደረግ ነገር የለም።

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

የሌሎች ሰዎች መልሶችን ለማየት እና የራሳችሁን ደግሞ ለመመዝገብ፣ በሬይልስ ስልጠና ወይም ሁሉንም በበቂ ተማር መድረሻ ጥቅል ላይ ተመዝገቡ፡፡

አሁን ለምትኖሩበት ከተማ አንድ ከተማ የተባለ ተለዋዋጪ፣ እና ለክፍለ ሃገሩ ደግሞ አንድ ክፍለ_ሃገር የተባለ ተለዋዋጪን በይኑ። (እዚህ አሜሪካ ውስጥ የምትኖሩ ከሆነ፣ ተመሳሳዩን የከተማ እና የክፍለ ሃገር ስም መተካት ትችላላችሁ፡፡)
ውስጠገምትን በመጠቀም፣ በአንድ ነጠላ ሰረዝ እና በአንድ ክፍትቦታ የተለዩትን ከተማ እና ክፍለሃገር ያካተተ አንድ ሃረግን (አስቀምጥ‘ን (puts) በመጠቀም) አትሙ፣ ልክ እንደዚህ “ደሴ፣ ወሎ” ማለት ነው።
የላይኛውን መልመጃ በድጋሜ ስሩ፣ በዚህ ጊዜ ግን የከተማው እና የክፍለ ሃገሩ ስም በአንድ የትር ሆሄ መለያየት ይኖርበታል።
በላይኛው መልመጃ ላይ የድርብ ጥቅስን ከመጠቀም ይልቅ፣ ነጠላ ጥቅስን ብትጠቀሙ ውጤቱ ምንይመስላል?

4.2.2 ቁሶች እና መልእክትን ማሰተላለፍ

ሃረጎችን እና ሌላው ሳይቀር ምንም‘ን (nil) እንኳን ጨምሮ በሩቢ ውስጥ ያለ ነገር በሙሉ ቁስ (Object) ነው። የእነዚህን ሙያዊ ትርጉም በክፍል 4.4.2 ላይ እናየዋለን፣ ማንም ሰው የቁሶችን ትርጉም አንድ መጽሐፍን ከማንበብ የሚረዳው ግን አይመስለኝም፤ ስለዚህ ብዙ ምሳሌዎችን በማየት ለቁሶች ያላችሁን ግንዛቤ መገንባት ይኖርባችኋል፡፡

ቁሶች ምን እንደሚያደርጉ መግለጹ ቀላል ነው፣ ይህም ለመልእክቶች ምላሽ መስጠት ነው። ለምሳሌ:- እንደ ሃረግ ያለ አንድ ቁስ ለ‘እርዝመት (length) መልእክት ምላሽ መሰጠት ይችላል። የሚሰጠው ምላሽም በሃረጉ ውስጥ ያሉ የሆሄ ብዛትን ነው:-

>> "አልማዝ".length    # የእርዝመት "length" መልእክትን ወደ አንድ ሃረግ ማሳለፍ።
=> 4

በተለምዶ ለቁሶች የሚተላለፉት መልእክቶች ራሳቸው ዘዴዎች (Methods) ናቸው፣ እነሱም በቁሱ ላይ የተበየኑ ሥልቶች ናቸው። ⁹ ሃረጎችም ለ‘የለለነውን? (empty?) ዘዴ መልስ ይሰጣሉ:-

>> "አልማዝ".empty?
=> false
>> "".empty?
=> true

በ‘የለለነውን? (empty?) ዘዴ መጨረሻ ላይ ያለውን የጥያቄ ምልክት ልብ በሉ። ይህ የሩቢ ደንብ የሚያመለክተው፣ የሚመልሰው ዋጋ አንድ ቡልዮን (Boolean) መሆኑን ነው፤ ማለት እውነት (true) ወይም ሃሰት (false)። በተለይ ሁናቴን ለመቆጣጠር (Control Flow) ቡልየኖች በጣም ጠቀሚዎች ናቸው:-

>> ሃ = "አልማዝ"
>> if ሃ.empty?
>>   "ሃረጉ ባዶ ነው"
>> else
>>   "ሃረጉ ባዶ አይደለም"
>> end
=> "ሃረጉ ባዶ አይደለም"

ከሁለት በላይ የሆነ አረፍተ ነገርን ለማጠቃለል፣ አለያከሆነን (elsif)፡ ( አለያ + ከሆነ (else + if)) መጠቀም እንችላለን:-

>> if ሃ.nil?
>>   "ተለዋዋጩ ምንም ነው"
>> elsif ሃ.empty?
>>   "ተለዋዋጩ ባዶ ነው"
>> elsif ሃ.include?("አልማዝ")
>>   "ሃረጉ 'አልማዝ' ን ያካትታል"
>> end
=> "ሃረጉ 'አልማዝ' ን ያካትታል"

ቡልየኖችን && (“እና and”)፣ || (“ወይም or”) እና ! (“አይደለም not”) የተባሉ ስሌቶችን በመጠቀም ልነጣምራቸው እንችላለን:-

>> ሀ = "አልማዝ"
=> "አልማዝ"
>> በ = ""
=> ""
>> puts "ሁለቱም ሃረጎች ባዶ ናቸው" if ሀ.empty? && በ.empty?
=> nil
>> puts "አንድኛው ሃረግ ባዶ ነው" if ሀ.empty? || በ.empty?
"አንድኛው ሃረግ ባዶ ነው"
=> nil
>> puts "ሀ ባዶ አይደለም" if !ሀ.empty?
"ሀ ባዶ አይደለም"
=> nil

ሩቢ ውስጥ ሁሉም ነገር ቁስ ስለሆነ፣ ይህንን ጪብጥ በመከተል ምንም (nil) ራሱ አንድ ቁስ ነው ማለት ነው፤ ስለዚህ እሱም ቢሆን ለዘዴዎች መልስ ሊሰጥ ይችላል ማለት ነው። ለምሳሌ የወደ-ሃረግ (to_s) ዘዴ በአብዛኛው ማንኛውንም ቁስ ወደ አንድ ሃረግ ይቀይራል:-

>> nil.to_s
=> ""

ይህ በርግጠኝነት አንድ ባዶ ሃረግን ይመስላል፣ እኛም በርካታ ዘዴዎችን ወደ ምንም (nil) በማስተላለፍ ይህን እውነታ ለማረጋገጥ እስርስር ዘዴ (Method Chaining) በመባል የሚታወቀውን ዘዴ መጠቀም እንችላለን:-

>> nil.empty?
NoMethodError: undefined method `empty?' for nil:NilClass
>> nil.to_s.empty?      # የእስርስር ዘዴ
=> true

እዚህ ጋር እንደምናየው የ‘ምንም (nil) ቁስ ለየለለነውን? (empty?) ዘዴ በራሱ ምላሽ እንደማይሰጥ ሲሆን፣ ለ‘ምንምወደ._ሃረግ (nil.to_s) ዘዴ ግን መልስ እንደሚሰጥ ነው።

ምንም አለመሆንን (nil-ness) የሚፈትሽ አንድ ልዩ የመፈተሻ ዘዴ አለ፣ እሱንም ይህንን እንደሚመስል መገመት ትችሉ ይሆናል:-

>> "አልማዝ".nil?
=> false
>> "".nil?
=> false
>> nil.nil?
=> true

ይህ ኮድ:-

puts "ሀ ባዶ አይደለም" if !ሀ.empty?

አንድ ተጨማሪ የ‘ከሆነ (if) ቁልፍቃል ተለዋጪ አጠቃቀም እንዳለ ያሳያል፣ ሩቢ ከሆነን (if) ተከታትሎ የመጣ አንድ ዓረፍተሐሳብ እውንት ከሆነ ብቻ፣ አንድ ዓረፍተሐሳብን እንድትጽፉ ይፈቅድላችኋል። በተመሳሳይ መንገድ የሚሰራ ካልሆነ-በስተቀር (unless) የተባለ አንድ ተተኪ ቁልፍቃልም አለ:-

>> ሃረግ = "አልማዝ"
>> puts "'#{ሃረግ}' ሃረግ ባዶ አይደለም።" unless ሃረግ.empty?
'አልማዝ' ሃረግ ባዶ አይደለም።
=> nil

ምንም (nil) ልዩ ቁስ መሆኑን ማስተዋል አስፈላጊ ነው፣ ምክንያቱም ከ‘ሃሰት (false) በስተቀር በቡልየን አውድ ውስጥ ብቸኛ የሆነ የሩቢ የሃሰት ቁስ ስለሆነ ነው። ይህንን !! በመጠቀም ማየት እንችላለን (!! “ባንግ ባንግ (bang bang)” ተብሎ ይነበባል)፣ ይህ ስልት አንድ ቁስን ሁለት ጊዜ ይዋሽ (ከነበረበት ሁኔታ ወደ ተቃራኒው ይቀይር) እና ውጤቱን ወደ ቡሊያን እንዲቀየር ያስገደደዋል:-

>> !!nil
=> false

ዜሮንም 0 እንኳን ሳይቀር ሁሉም የሩቢ ቁሶች እውነት (true) ናቸው:-

>> !!0
=> true

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

የ “ተበተ” ሃረግ እርዝመቱ ስንት ነው?
የ‘አገላብጥ (reverse) ዘዴን በመጠቀም “ተበተ” በተገላቢጦሽ ሲጻፍ አንድ ዓይነት መሆኑን አረጋግጡ፡፡
አንድ ሃ የተባለ ተለዋዋጪን ከ “ተበተ” ሃረግ ጋር በይኑ። ከዚያ የማመዛዘኛ ስሌትን (comparison operator) == በመጠቀም የ‘ ሃ ዋጋ ከ‘ ሃ.reverse ዋጋ ጋር እኩል መሆኑን አረጋግጡ፡፡
በዝርዝር 4.9 ውስጥ ያለው ኮድ ዋጋው ምንድነው? ሃ ‘ን “onomatopoeia” በተባለው ሃረግ በይናችሁ ኮዱን እንዳዲስ ብትሞክሩት ምን ለውጥ ያሳያል? ጠቃሚ ምክር:- የወደላይ ቀስትን በመጠቀም ያለፈውን ትእዛዝ ፈልጎ ማውጣት እና ማረም ትችላላችሁ፡፡

ማሳሰቢያ:- በእንግሊዝኛ Palindrome ማለት አንድ ቃል፣ አንድ ሃረግ ወይም አንድ ቅደም ተከተል ያለው ነገር ተገላብጦ ሲጻፍ ፍጹም አንድ አይነት የሆነ ማለት ነው። እኔም የዚህን ቀጥተኛ ትርጉም በአማርኛ ስላላገኘሁ እሱን ይገልጻል በማለት አንሶላ የሚል ትርጉም ሰጥቸዋለሁ (ብዙ ጊዜ አንድ አንሶላ ተገላብጦ ሲነጠፍ አንድ አይነት መልክ ይኖረዋል ብየ ስላሰብኩ ነው)። ለምሳሌ “ተበተ” የሚለው ቃል ተገላብጦ ሲጻፍ ፍጹም አንድ ነው፤ ስለሆነም አንድ አንሶላ ብለን እንጠራዋለን ማለት ነው።

ዝርዝር 4.9: 

አንድ ቀላል የአንሶላ ፈተና።
>> puts "ሃ አንሶላ ነው!" if ሃ == ሃ.reverse

4.2.3 ዘዴ ብያና

ሰሌዳው ልክ እንደ መነሻ (menesha) ተግባር በዝርዝር 3.9 ላይ እና ለ‘ሙሉ_አርዕስት (mulu_arest) ረጅ በዝርዝር 4.2 ላይ እንዳደረግነው፣ አንድ ዓይነት በሆነ መንገድ ዘዴዎችን እንድንበይን ይፈቅድልናል። (በሰሌዳው ውስጥ ዘዴዎችን መበየን ትንሽ አድካሚ እና አሰልቺ ነው፣ ለዛም እንደተለመደው አንድ ፋይልን ትጠቅማላችሁ፣ አላማው ምሳሌወችን ሰርቶ ለማሳየት ከሆነ ግን ሰሌዳው ምቹ መሳርያ ነው።) እስኪ ለምሳሌ አንድ ነጠላ ነጋሪአሴትን (Argument) የሚዎስድ አንድ ሃረገ_መልእክት የተባለ ሥልትን እንበይን፣ እሱም አንድ ነጋሪአሴትን ወስዶ በነጋሪአሴቱ ባዶ ወይም ባዶ አለመሆን ላይ በመመስረት አንድ መልእክትን የሚሰጥ ይሆናል:-

>> def ሃረገ_መልእክት(ሃረ = '')
>>   if ሃረ.empty?
>>     "አንድ ባዶ ሃረግ ነው!"
>>   else
>>     "ሃረጉ ባዶ አይደለም።"
>>   end
>> end
=> :ሃረገ_መልእክት
>> puts ሃረገ_መልእክት("ሞላ")
ሃረጉ ባዶ አይደለም።
>> puts ሃረገ_መልእክት("")
አንድ ባዶ ሃረግ ነው!
>> puts ሃረገ_መልእክት
አንድ ባዶ ሃረግ ነው!

መጨረሻ ላይ ባለው ምሳሌ ላይ እንዳየነው፣ ነጋሪአሴቱን ሙሉ ለሙሉ መተው ይቻላል (የቅንፍ ምልክቶቹን ብንተዋቸውም የሚያመጣው ለውጥ ስለለለ እነሱንም በተጨማሪ መተው እንችላለን)። ምክንያቱም ይህ ኮድ:-

def ሃረገ_መልእክት(ሃረ = '')

አንድ ነባሪ ነጋሪአሴትን ስለያዘ ነው፣ አሁን ባለው ሁኔታ ላይ፣ ባዶ ሃረግን ይዟል ማለት ነው። ይሄ ደግሞ የ ሃረ ነጋሪአሴትን አማራጫዊ እንዲሆን ያደርገዋል፣ እናም እንዳለ ብንተወው በራስሰር ነባሪ ዋጋውን ይይዛል።

የሩቢ ሥልቶች አንድ ተዘዋዋሪ ምላሽ (Implicit Return) እንዳላቸው እና ይህ ማለትም የሚመልሱት ዋጋ መጨረሻ ላይ የተመዛዘነውን ዓረፍተሐሳብ እንደሆነ ልብ ልትሉ ይገባል፣ በዚህ ሁኔታ ላይ ከሁለቱ አንዱ የሃረጎች መልእክት፣ የዘዴው የ‘ ሃረ ነጋሪአሴት ባዶ ወይም ባዶ አለመሆን ላይ ይመረኮዛል። ሩቢ በተጨማሪ አንድ የግልጽ ምላሽ (Explicit Return) አማራጪም አለው፣ ከዚህ በታች የተመለከተው ሥልት እላይ ካለው ሥልት ጋር አቻ ነው:-

>> def ሃረገ_መልእክት(ሃረ = '')
>>   return "አንድ ባዶ ሃረግ ነው!" if ሃረ.empty?
>>   return "ሃረጉ ባዶ አይደለም።"
>> end

(ጥንቁቁ አንባቢ በዚህ ጊዜ ሁለተኛው መልስ (return) አስፈላጊ እንዳልሆነ ሊገነዘብ ይችል ይሆናል፣ ምክንያቱም በሥልቱ ውስጥ የመጨረሻው ሂሳበሃረግ እስከሆነ ድረስ፣ የ‘መልስ (return) ቁልፍቃል ቢኖርም ባይኖርም የ "ሃረጉ ባዶ አይደለም።" ሃረግ ስለሚመለስ ነው፣ ነገር ግን የ‘መልስ (return) ቁልፍቃልን በሁለቱም ቦታዎች መጠቀሙ ደስ የሚል ሚዛናዊ እይታን ይሰጠዋል።)

ጠሪውን በተመለከተ የሥልቱ የነጋሪአሴት ስም ፋይዳ እንደሌለው መገንዘብ አስፈላጊ ነው፡፡ በሌላ አነጋገር ከላይ ያለው የመጀመርያ ምሳሌ ሃረ በሌላ ተቀባይነት ባለው የተለዋዋጪ ስም ማለት በ‘ የስልቱ_ነጋሪአሴት ተለዋዋጪ ቢተካ፣ ይህም ልክ እንደ በፊቱ ይሰራል ማለት ነው:-

>> def ሃረገ_መልእክት(የስልቱ_ነጋሪአሴት = '')
>>   if የስልቱ_ነጋሪአሴት.empty?
>>     "አንድ ባዶ ሃረግ ነው!"
>>   else
>>     "ሃረጉ ባዶ አይደለም።"
>>   end
>> end
=> :ሃረገ_መልእክት
>> puts ሃረገ_መልእክት("")
አንድ ባዶ ሃረግ ነው!
>> puts ሃረገ_መልእክት("ሞላ")
ሃረጉ ባዶ አይደለም።

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

በዝርዝር 4.10 ውስጥ ይህን_ሙሉ የሚለውን ቃል፣ በተገቢው የንጽጽር መፈተሻ በመተካት አንድ ቃል አንሶላ (Palindrome) መሆኑን የሚያረጋግጥ አንድ ዘዴ በይኑ (ለምሳሌ:- “ተረተ” እና “ጥጥ” ተገላብጠው ሲጻፉ አንድ አንሶላወች (ዓይነት ቃላቶች) ናቸው)። ጠቃሚ ምክር:- በዝርዝር 4.9 ላይ የታየውን ንጽጽር ተጠቀሙ።
አንሶላ_ሞካሪ() የተባለውን ዘዴ በመጠቀም “ተረተ” የሚለው ቃል አንሶላ መሆኑን እና “onomatopoeia” የሚለው ቃል አንሶላ አለመሆኑን አረጋግጡ፡፡
እዚህ:- አንሶላ_ሞካሪ("ተረተ") ዘዴ ላይ፣ የምንምነውን? (nil?) ዘዴን በመጥራት ከጥሪው የሚገኘው ምላሽ ምንም (nil) መሆኑን አረጋግጡ (ምንምነውን?‘ን (nil?) በዘዴው ውጤት ላይ መጥራቱ እውነትን (true) መመለስ ይኖርበታል)፡፡ ይህ የሚሆንበት ምክንያት በዝርዝር 4.10 ውስጥ ያለው ኮድ ውጤቱን ከመመለስ ይልቅ ውጤቱን ስለሚያትም ነው።

ዝርዝር 4.10: 

አንድ ቃል አንሶላ መሆኑን የሚያረጋግጥ ዘዴ።
>> def አንሶላ_ሞካሪ(ሃረ)
>>   if ይህን_ሙሉ
>>     puts "ይህ አንድ አንሶላ ነው!"
>>   else
>>     puts "ይህ አንድ አንሶላ አይደለም።"
>>   end
>> end

4.2.4 ወደ አርዕስት ረጅው መመለስ

አሁን በዝርዝር 4.2 ውስጥ ያሉትን የ‘ሙሉ_አርዕስት (mulu_arest) እና የ‘ አብዛ (abza) ረጅ ዘዴዎችን የምንረዳበት አንድ አቋም ላይ እንገኛለን፣ ይህም በዝርዝር 4.11 ውስጥ የአስተያየት ምልክት ከተደረገባቸው ማብራሪያወች ጋር ቀርቧል፡፡¹⁰

ዝርዝር 4.11: 

ሁለት የተብራሩ የ‘ አርዕስት_ረጅ እና የ‘ (ብዛት_ረጅ)።  app/helpers/application_helper.rb
module ApplicationHelper

  # በገጹ መሰረት ሙሉውን አርዕስት ይመልሳል።                    # የስነዳ አስተያየት
  def mulu_arest(yegetsu_arest = '')            # የዘዴ ብየና፣ ከአማራጪ ነጋሪአሴት ጋር
    meseret_arest = "የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን"   # የተለዋዋጪ ምደባ
    if yegetsu_arest.empty?                               # የቡልዮን ፍተሻ
      meseret_arest                                       # ተዘዋዋሪ ምላሽ
    else                                                  # አለያ
      yegetsu_arest + " | " + meseret_arest               # ሃረግን ማያያዝ
    end
  end

  # ይህ ዘዴ ምዕራፍ 7 ውስጥ ስራ ላይ ይውላል።
  # በስሙ መሰረት የስሙን ብዛት ይመልሳል።
  def abza(bzat, sim)                           # የዘዴ ብየና፣ ከአማራጭ ነጋሪአሴት ጋር
    if bzat != 0                                         # የቡልዮን ፈተና
      bzat == 1 ? "#{bzat} #{sim}" : "#{bzat} #{sim}och" # ተዘዋዋሪ ምላሽ
    else                                                 # አለያ
      "#{bzat} #{sim}"                                   # ሃረግን ማያያዝ
    end
  end
end

እነዚህ ስብስቦች:- (አንድ የስልት ብያኔ ከአንድ ምርጫዊ ነጋሪአሴት፣ ከተለዋዋጪ ምደባ፣ ከቡልየን ፍተሻዎች፣ ከሁናቴ ተቆጣጣሪ እና ከሃረግ ማያያዝ ስብስቦች ጋር)¹¹ በጣቢያችን ገጽታ ውስጥ ጥቅም ላይ የሚውሉ ሁላት የተጠቀጠቁ የረጅ ዘዴወችን ለመስራት በአንድነት ውለዋል። የመጨረሻው የሚያስፈልገን ነገር ክፍለክፍል አፕልኬሽንረጅ (module ApplicationHelper) ሲሆን፤ ክፍለክፍል (Module) ተዛማጅነት ያላቸው ዘዴዎችን በአንድነት ለመጠቅለል እና ከዚያም አክልን (include) በመጠቀም ከሩቢ ክፍል ጋር በማደባለቅ መጠቀም የምንችልበትን መንገድ ይሰጠናል። የተለመደውን ሩቢን በምንጽፍበት ወቅት በአብዛኛው ጊዜ ክፍለክፍልን ጽፈን ከዛም በቁም ነገር እራሳችን ክፍለክፍሎቹን እናካትታቸዋለን፤ በአንድ የረጅ ክፍለክፍል አውድ ውስጥ ግን ሬይልስ ራሱ ይህንን ስራ በኛ ምትክ ያከናውንልናል። በዚህ ምክንያት የ‘ሙሉ_አርዕስት (mulu_arest) እና የ‘አብዛ (abza) ረጅ ዘዴወቹ በስራተምትሃት (Automagically) በሁሉም ትይታዎች ውስጥ ይገኛሉ ማለት ነው።

4.3 ሌሎች የውሂብ መዋቅሮች

ምንም እንኳ የድር አፕልኬሽኖች ውለው እድረው ሃረጎች ቢሆኑም፤ እነዚህ ሃረጎችን ለመስራት ግን በእውነቱ ሌሎች የውሂብ መዋቅሮችን መጠቀምንም ይጠይቃል። በዚህ ክፍል ውስጥም ስለ አንዳንድ የሩቢ የውሂብ መዋቅሮች ማለት የሬይልስ አፕልኬሽኖችን ለመስራት ጠቃሚ የሆኑትን እንማራለን።

4.3.1 ድርድሮች እና ከክሳቦች

ድርድር (Array) ማለት በተወሰነ ቅደም ተከተል ያለ የነገሮች ዝርዝር ማለት ነው። ስለ ድርድሮች እስከ አሁን ድረስ በሬይልስ ስልጠና ውስጥ ምንም አልተማርንም፣ እነሱን መረዳቱ ግን ተርታወችን (ክፍል 4.3.3) እና የሬይልስ የውሂብ ቅርጸትን (መልክኣ አሰራርን) ለመረዳት አንድ ጥሩ መሰረትን ይጥላል (ለምሳሌ:- በክፍል 2.3.3 ውስጥ የ‘ብዙ_አለው (has_many) ማሕበር ላይ አይተናቸዋል፣ እናም በክፍል 13.1.3 ላይ ደግሞ በይበልጥ ተሸፍኗል)።

እስከ አሁን ድረስ ሃረጎችን ለመረዳት ብዙ ጊዜ እጥፍተናል፣ እና የ‘ከፋፍል (split) ዘዴን በመጠቀም ከሃረጎች ወደ ድርድሮች በቀላሉ ለመቀየር የሚያስችል አንድ ቀላል መንገድ አለ፡-

>>  "አፈወርቅ መላኩ  ተፈራ".split  # አንድ ሃረግን ሶስት አባላት ወደያዘ አንድ ድርድር መቀየር።
=> ["አፈወርቅ", "መላኩ", "ተፈራ"]

የዚህ ክዋኔ ውጤት ሶሰት ሃረጎችን ያካተተ አንድ ድርድር ነው። ከፋፍል (split) በአንድ ድርድር ውስጥ ያለ ሃረግን በነባሪነት በሌጣቦታ ላይ ይከፋፍላል፣ ነገር ግን ማንኛውም ነገር ላይ መከፋፈል ትችላላችሁ:-

>> "አፈወርቅጨመላኩጨተፈራ".split('ጨ')
=> ["አፈወርቅ", "መላኩ", "ተፈራ"]

ልክ በብዙ የኮምፒዩተር ቋንቋዎች እንደተለመደው ሁሉ፣ የሩቢ ድርድሮችም በባለ ዜሮ መነሻ (zero-offset) የሚጀምሩ ናቸው። ይህ ማለት በድርድሮች ውስጥ የመጀመርያው አባል ጠቋሚ 0 ሲሆን፤ የሁለተኛው ጠቋሚ ደግሞ 1 ይሆናል ማለት ነው፣ ከዚያም እንደዛ እያለ በዛ መልኩ ይቀጥላል:-

>> ሀ = [42, 8, 17]
=> [42, 8, 17]
>> ሀ[0]               # ሩቢ ድርድርን ለመድረስ ማዕዘነቅንፍን ይጠቀማል።
=> 42
>> ሀ[1]
=> 8
>> ሀ[2]
=> 17
>> ሀ[-1]              # ጠቋሚ አሉታም መሆን ይችላል!
=> 17

እዚህ ጋር ሩቢ የድርድር አባላቶችን ለመዳረስ ማዕዘነቅንፎችን እንደሚጠቀም እናያለን። ሩቢ ከዚህ የቅንፍ ስርዓተ-ምልክት በተጨማሪ ለተለመዱ የአባላቶች መድረሻ ተመሳሳይ ትርጉም ያላቸው ቃላቶችን ይሰጣል፡-¹²

>> ሀ                  # በቃ 'ሀ' ምን ዋጋ እንደያዘ ማዘካከር።
=> [42, 8, 17]
>> ሀ.first
=> 42
>> ሀ.second
=> 8
>> ሀ.last
=> 17
>> ሀ.last == ሀ[-1]    # == `ን ተጠቅሞ ማነጻጸር።
=> true
>> ሀ != nil           # != `ን ተጠቅሞ ማነጻጸር።
=> true

ከላይ ያሉት የመጨረሻወቹ ሁለት ምሳሌውች ሩቢ ከሌሎች ቋንቋዎች ጋር የሚጋራቸውን የእኩልነት ማነጻጸሪያ == እና ከተዛማጁ != “እኩል አይደለም (not equal)” ስሌት ጋር ያሰተዋውቃሉ። ሩቢ ከሌሎች ቋንቋዎች ጋር ከሚጋራቸው ስሌቶች ውስጥ ጥቂቶቹን እንቃኝ:-

>> በ = ሀ.length     # ልክ እንደ ሃገጎች ድርድሮችም ለእርዝመት ጥሪ ምላሽ ይሰጣሉ።
=> 3
>> በ == 3
=> true
>> በ == 1
=> false
>> በ != 1
=> true
>> በ >= 1
=> true
>> በ < 1
=> false

ከ‘እርዝመት (length) ዘዴ በተጨማሪ (ከላይ ባለው የመጀመሪያ መስመር ላይ ታይቷል)፣ ድርድሮች ለብዙ ዘዴዎችም ምላሽ ይሰጣሉ:-

>> ሀ
=> [42, 8, 17]
>> ሀ.empty?
=> false
>> ሀ.include?(42)
=> true
>> ሀ.sort
=> [8, 17, 42]
>> ሀ.reverse
=> [17, 8, 42]
>> ሀ.shuffle
=> [17, 42, 8]
>> ሀ
=> [42, 8, 17]

ከላይ ከተጠቀምንባቸው ዘዴዎች መካከል አንዳቸውም ቢሆን የ ሀ ‘ን ይዞታ ከቀድሞ ይዞታው ፈጽሞ እንደማይለውጠው አስተውሉ። ድርድሮቹን ለመለወጥ (Mutate) ተዛማጅ የሆነውን “የባንግ” ማለት የቃል አጋኖ ዘዴን መጠቀም ይኖርብናል (“ባንግ” ተብሎ የተሰየመበት ምክንያት፣ እንደ ልማድ የቃለ አጋኖ ምልክት በዚህ ይዞታ ውስጥ ሲደመጥ “ባንግ” ተብሎ ስለሚደመጥ ነው):-

>> ሀ
=> [42, 8, 17]
>> ሀ.sort!
=> [8, 17, 42]
>> ሀ
=> [8, 17, 42]

እንዲሁም የ‘ግፋ (push) ዘዴን ወይም አቻውን እና “አካፋ (Shovel)” << ተብሎ የሚጠራውን ስሌት በመጠቀም፣ ወደ ድርድሮች አንዳንድ አባላትን እንዲህ አድርገን ማከል እንችላለን፡-

>> ሀ.push(6)                  # 6 ቁጥርን ወደ ድርድሩ መግፋት።
=> [42, 8, 17, 6]
>> ሀ << 7                     # 7 ቁጥርን ወደ ድርድሩ መግፋት።
=> [42, 8, 17, 6, 7]
>> ሀ << "ወንድየ" << "ወዳጆ"      # የድርድር ግፊቶችን ማስተሳሰር።
=> [8, 17, 42, 6, 7, "ወንድየ", "ወዳጆ"]

ይህ የመጨረሻው ምሳሌ የሚገፉትን ነገሮች በአንድ ላይ ማስተሳሰር እንደምትችሉ እና በሌሎች በርካታ የፕሮግራም ቋንቋዎች ውስጥ ድርድሮች ላይ መደረግ ከሚገባው በተቃረነ መልኩ የሩቢ ድርድሮች የተለያዩ የውሂብ ዓይነትቶችን (ማለት እዚህ ሁኔታ ላይ ቁጥሮች እና ሃረጎችን) መያዝ እንደሚችሉ ያሳያል።

ቀደም ብለን የ‘ከፋፍል (split) ዘዴ አንድ ሃረግን ወደ አንድ ድርድር ሲቀይረው ተመልክተናል። የ‘አገጣጥም (join) ዘዴን በመጠቀም ደግሞ ወደ ተቃራኒው መንገድ መሄድም እንችላለን:-

>> ሀ
=> [42, 8, 17, 6, 7, "ወንድየ", "ወዳጆ"]
>> ሀ.join                       # ምንም ላይ ማገናኘት።
=> "4281767ወንድየወዳጆ"
>> ሀ.join('፣ ')                 # በነጠላ ሰረዝ ማገናኘት።
=> "8፣ 17፣ 42፣ 6፣ 7፣ ወንድየ፣ ወዳጆ"

ከድርድሮች ጋር በጣም የሚዛመዱ ከክሳቦች (Ranges) ናቸው፣ ይህንንም የ‘ወደ_ሃረግ (to_a) ዘዴን በመጠቀም እና ወደ ድርድሮች በመለወጥ በቀላሉ ልትረዱት የምትችሉ ይሆናል:-

>> 0..9                 # አንድ ከ0 እስከ9 የያዘ ከክሳብን መፍጠር።
=> 0..9
>> 0..9.to_a            # ውይ! 9 ቁጥር ላይ የ`ወደ\_ሃረግ (to_a) ዘዴን ጠራን።
NoMethodError: undefined method `to_a' for 9:Fixnum
>> (0..9).to_a          # በከክሳብ ላይ የ`ወደ\_ሃረግ (to_a) ዘዴን ለመጠራት ቅንፍን መጠቀም።
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

ምንም እንኳን ከ 0..9 አንድ ብቁ ከክሳብ ቢሆንም፣ ከላይ ያለው ሁለተኛው ሂሳበሃረግ፣ በሱ ላይ አንድ ዘዴን ለመጥራት ግን አንድ ቅንፍን ማከል እንደሚያስፈልገን ያሳያል።

ከክሳቦች የድርድር አባላትን ጎትቶ ለማውጣት ጠቃሚዎች ናቸው:-

>> ሀ = %w[ወንድየ ወዳጆ አቢሻ ለኣከ]      # %w `ን በመጠቀም አንድ ድርድርን መስራት።
=> ["ወንድየ", "ወዳጆ", "አቢሻ", "ለኣከ"]
>> ሀ[0..2]
=> ["ወንድየ", "ወዳጆ", "አቢሻ"]

በተለይ አንድ ጠቃሚ ዘዴ ቢኖር፣ የድርድሩን እርዝመት በቀጥታ ሳይጠቀሙ በከክሳቡ መጨረሻ ላይ -1 ጠቋሚን በመጠቀም እያንዳንዱ የድርድር አባላትን ከመጀመርያው እስከ መጨረሻው መምረጥ መቻሉ ነው:-

>> ሀ = (0..9).to_a
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>> ሀ[2..(ሀ.length-1)]               # የድርድር እርዝመቱን በግልጽ መጠቀም።
=> [2, 3, 4, 5, 6, 7, 8, 9]
>> ሀ[2..-1]                         # የ -1 ጠቋሚ ብልሃትን መጠቀም።
=> [2, 3, 4, 5, 6, 7, 8, 9]

ከክሳቦች በተጨማሪ ሆሄወች ጋርም ይሰራሉ:-

>> ('a'..'e').to_a
=> ["a", "b", "c", "d", "e"]

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

ይህንን:- በ = "አንድ, ሁለት".split(", ") ምሳሌ በመከተል ይህን_ሙሉ የሚለውን ቃል በተገቢው ኮድ ሙሉ። በ = "A man, a plan, a canal, Panama"ይህን_ሙሉ።
ከ በ የተገኘውን ውጤት በማገጣጠም፣ ውጤቱን ጨ ከተባለ ተለዋዋጪ ጋር መድቡት (ምሳሌ ሠ = ጠ.join) ማለት ይህን_ሙሉ የሚለውን ቃል፣ በተገቢው ኮድ ሙሉ። ጨ = በይህን_ሙሉ።
ከላይ የተገኘውን የ ጨ ውጤት በቃላቶቹ መሃል ያለውን ክፍትቦታ ለማጥፋት የ‘ከፋፍል (split) ዘዴን ተጠቀሙ፣ ቃላቶቹን ለማገናኘት ደግሞ የ‘አገጣጥም (join) ዘዴን ተጠቀሙ (ምሳሌ:- ጠ.split.join)። ከዚያ ሌጣቦታውን አጥፍታችሁ ያገናኛችሁት ውጤትን በዝርዝር 4.10 ላይ ባለው ዘዴ ውስጥ በማስገባት አንድ አንሶላ አለመሆኑን አረጋግጡ፡፡ የ‘ንዑስ-ፊደል (downcase) ዘዴን በመጠቀም ጨ.downcase አንድ አንሶላ መሆኑን አረጋግጡ፡፡
ከኤ (a) እስከ ዜድ (z) ከክሳብ ውስጥ ሰባተኛው ፊደል ምንድነው? ከክሳቡ ቢገላበጥ ሰባተኛው (7) ፊደል ምን ይሆናል? ጠቃሚ ምክር:- እነዚህን ጥያቄዎች ለመመለስ ወደ ድርድር መቀየር አለባችሁ፡፡

4.3.2 ጥምሮች

ሁለቱም ድርድሮች እና ከክሳቦች ጥምሮችን (Blocks) ለሚቀበሉ በርካታ ዘዴዎች ምላሽ ይሰጣሉ፤ ጥምር በተመሳሳይ መልኩ በሩቢ ውስጥ በጣም ጠቃሚና በጣም ግራ ከሚያጋቡ ባህሪዎች ውስጥ አንዱ ነው።

>> (1..5).each { |ጠ| puts 2 * ጠ }  # ተለዋዋጪ "ጠ" ጠቋሚ ለማለት ነው።
2
4
6
8
10
=> 1..5

ይሄ ኮድ የ‘እያንዳንዳቸው (each) ዘዴን ከ (1..5) ከክሳብ ላይ ይጠራ እና አንድባንድ የከክሳቡን አባላት በጥምሩ { |ጠ| puts 2 * ጠ } ውስጥ ያሳልፋቸዋል። በተለዋዋጪ ስሙ ዙርያ የቆሙ ቀጥ ያሉ ሁለት መስመሮች |ጠ| ውስጥ ያለው “ጠ” የሩቢ የጥምር ተለዋዋጪ አገባብ ነው፣ በተጨማሪም በጥምሩ ላይ ምን ማድረግ እንደሚገባ የማወቁ ፋንታ የዘዴው ነው። በዚህ ሁኔታ ላይ፣ የከክሳቡ እያንዳንዳቸው (each) ዘዴ በአንድ ነጠላ የሰፈር ተለዋዋጪ (Local Variable)¹³ አንድ ጥምርን መቆጣጠር ይችላል፣ ይህንንም እኛ ጠ ብለን ጠርተነዋል፤ እሱም በከክሳቡ ውስጥ ላሉ ለእያንዳንዱ አባላት ጥምሩ ውስጥ የሚገኘው ኮድ በላያቸው ላይ እንዲፈጸምባቸው ያደርጋል።

የሐረግ ቅንፎች አንድ ጥምርን ለማመልከት አንደኛው መንገድ ሲሆኑ፣ ነገር ግን አንድ ሌላ ሁለተኛ መንገድም አለ፡-

>> (1..5).each do |ጠ|
?>   puts 2 * ጠ
>> end
2
4
6
8
10
=> 1..5

ጥምሮች ከአንድ መስመር በላይ ሊሆኑ ይችላሉ፣ እንደውም አብዛኛውን ጊዜ ከአንድ መስመር በላይ ናቸው። በሬይልስ ስልጠና ላይ ለአጪር መስመር ጥምሮች አንድ የሐረግ ቅንፍን ብቻ፣ ለረዣዥም የአንድ መስመር እና ለብዙ መስመር ጥምሮች ደግሞ የተለመደውን የ‘አድርግ..ጨርስ (do..end) አገባብን እንከተላለን:-

>> (1..5).each do |ቁጥር|
?>   puts 2 * ቁጥር
>>   puts '--'
>> end
2
--
4
--
6
--
8
--
10
--
=> 1..5

እዚህ ላይ በ ጠ ቦታ ምትክ ቁጥር የሚለውን ተለዋዋጪ ተጠቅመናል ይህንን ያደረግንበት ምክንያትም ማንኛውም ዓይነት የተለዋዋጪ ስም ይህንን ማድረግ እንደሚችል ለማሳየት ነው።

አንድ ፕሮግራም የማድረግ ጥልቅ ዕውቀት ከሌላችሁ በስተቀር፣ ጥምሮችን ለመረዳት አቋራጪ ወይም አጪር መንገድ የለውም፤ እነሱን ለመረዳት ብዙ ጊዜ እነሱን በስራ ላይ ማየት አለባቸሁ፣ እናም መጨረሻ ላይ ትለምዷቸዋላችሁ።¹⁴ እንደ እድል ሁኖ፣ የሰው ልጆች ከተጨባጪ ምሳሌዎች አጠቃላይ ግንዛቤን በማድረግ ረገድ በጣም ጥሩ ችሎታ አላቸው፣ ስለሆነም እዚህ ጋር ጥቂት የተጨመሩ እና እንዲሁም የ‘ካርታ (map) ዘዴን በመጠቀም የተካተቱ ጥቂት ምሳሌወችን እንመለከታለን:-

>> 3.times { puts "ሆያ ሆየ ሆ!" }  # 3.times አንድ ጥምርን ያለ ምንም ተለዋዋጪ ይወስዳል።
ሆያ ሆየ ሆ!
ሆያ ሆየ ሆ!
ሆያ ሆየ ሆ!
=> 3
>> (1..5).map { |ጠ| ጠ**2 }   # የ ** ስርዓተ-ምልክቱ የ 'ሃይለ' ቁጥር ስርዓተ-ምልክት ነው።
=> [1, 4, 9, 16, 25]
>> %w[a b c]                    #  ይህ %w አንድ የሃረግ ድርድርን እንደሚሰራ እስታውሱ።
=> ["a", "b", "c"]
>> %w[a b c].map { |ሆሄ| ሆሄ.upcase }
=> ["A", "B", "C"]
>> %w[A B C].map { |ሆሄ| ሆሄ.downcase }
=> ["a", "b", "c"]

እንደምታዩት የ‘ካርታ (map) ዘዴ ምላሽ የሚሰጠው በጥምሩ ውስጥ ለእያንዳንዱ ድርድር ወይም ከክሳብ አባላት የተሰጠውን ተግባር በመፈጸም የሚገኘውን ውጤት ነው። በመጨረሻዎቹ ሁለት ምሳሌዎች በጥምሩ ውስጥ ያለው የ‘ካርታ (map) ዘዴ አንድ የተወሰነ ዘዴን በጥምር ተለዋዋጩ ላይ መጠራትን ያሳትፋል፣ እናም በዚህ ሁኔታ ላይ የሚያገለግል አንድ “symbol-to-proc” የተባለ እና የተለመደ አጪር-ጽሕፈት አለ፡-

>> %w[A B C].map { |ሆሄ| ሆሄ.downcase }
=> ["a", "b", "c"]
>> %w[A B C].map(&:downcase)
=> ["a", "b", "c"]

(ይህ እንግዳ ግን ጥብቅብቅ ኮድ በክፍል 4.3.3 ውስጥ የምንወያይበትን አንድ ወካይን (Symbol) ይጠቀማል።) ስለዚህ ኮድ አመሰራረት አንድ አስደናቂ ነገር ቢኖር፣ ይህ ኮድ በመጀመርያ ወደ ሩቢ ኦን ሬይልስ መታከሉ እና ከዚያ ሰዎች በጣም ስለወደዱት ከሩቢ ቋንቋ ስረመሰረት ጋር ለመዋሃድ መብቃቱ ነው።

የጥምሮች ምሳሌ ማጠቃለያ ይሆን ዘንድ በዝርዝር 4.4 ካለው ፋይል ውስጥ አንድ ነጠላ ፈተናን መመልከት እንችላልን፡-

test "መነሻ ገጽን ማግኘት አለበት" do
  get quami_getss_menesha_url
  assert_response :success
  assert_select "title", "የሩቢ ኦን ሬይልስ ስልጠና ማሳያ አፕልኬሽን"
end

ሁሉንም ነገር አንድ ባንድ በዝርዝር ማወቁ አስፈላጊ አይደለም (በእውነቱ ከሆነ፣ እኔ እራሴም ብሆን ያለ ምንም ቅድመ ዝግጅት ዝርዝሩን አንድ ባንድ አላውቀውም)፣ ነገር ግን የአድርግ (do) ቁልፍቃል እዛ በመኖሩ ምክንያት የፈተናው (test) አካል ጥምር መሆኑን ማረጋገጥ እንችላለን። የፈተና (test) ዘዴው አንድ የሃረግ ነጋሪአሴትን እና አንድ ጥምርን ይወስዳል፣ ከዚያም የፈተና ስብስቡን ለማስኬድ የጥምሩን አካል ይፈጽማል። በነገራችን ላይ አሁን የነሲብ ንዑስ-ግዝአቶችን ለማመንጨት በክፍል 1.4.2 ላይ የጣልኳትን አንድ መስመር የሩቢ ኮድን የምንረዳበት ሁኔታ ላይ ደርሰናል:-¹⁵

('a'..'z').to_a.shuffle[0..7].join

እስኪ ከስር መሰረቱ “ሀ” ብለን እንገንባው:-

>> ('a'..'z').to_a                     # አንድ ባለፊደል ድርድር።
=> ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
"p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
>> ('a'..'z').to_a.shuffle             # መበወዝ
=> ["c", "g", "l", "k", "h", "z", "s", "i", "n", "d", "y", "u", "t", "j", "q",
"b", "r", "o", "f", "e", "w", "v", "m", "a", "x", "p"]
>> ('a'..'z').to_a.shuffle[0..7]       # ስምንቱን የመጀመሪያ አባለት ጎትቶ ማውጣት።
=> ["f", "w", "i", "a", "h", "p", "c", "x"]
>> ('a'..'z').to_a.shuffle[0..7].join  # አንድ ሃረግ ለማድረግ ሁሉንም ባንድነት ማያያዝ።
=> "mznpybuj"

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

ከ 0..16 ከክሳብ ውስጥ ያሉ የሁለት ሃይለ ($ 2^2 $) ቁጥሮችን በስክሪናችሁ ላይ አትሙ፡፡ በስክሪናችሁ ላይ የምታትሟቸው የቁጥሮች ብዛት የመጀመሪያ አስራሰባቱን (17) ብቻ ይሆናል፡፡
አንድ ሆሄወችን የያዘ ድርድር ወስዶ፣ አንድ ሃረግ የሆነ ዓበይት ፊደላትን የሚሰጥ ተጣሪ የተባለ ዘዴ ፍጠሩ (ለምሳሌ:- ['n', 'e', 'g', 'a'] ‘ን ወስዶ "NEGA" ‘ን የሚሰጥ ማለት ነው)። ይሄ:- ተጣሪ(['h', 'i', 'w', 'e','t']) ይህንን:- "HIWET" እንደሚሰጥ አረጋግጡ፡፡ ጠቃሚ ምክር:- ይህንን ጥያቄ ለመመለስ ካርታ (map)፣ ዓቢ-ፊደል (upcase) እና አገጣጥም (join) የተባሉትን ዘዴዎች ተጠቀሙ።
ፊደሎችን አደባልቆ የተደባለቁትን ሰባት (7) ፊደሎች በአንድ ሃረግ የሚሰጥ፣ አንድ ብውዝ_ንዑስ_ግዝአት የተባለ ዘዴ ፍጠሩ።
በዝርዝር 4.12 ላይ ያሉትን የጥያቄ ምልክቶች ከፋፍል (split)፣ በውዝ (shuffle) እና አገጣጥም (join) በተባሉት ዘዴ በመሙላት በተሰጠው አንድ ሃረግ ውስጥ ያሉትን ፊደላትን ደባልቆ የሚሰጥ አንድ ሥልት ፍጠሩ።

ዝርዝር 4.12: 

አንድ ሃረግ የሚበውዝ ሥልትን ለመፍጠር የሚያገለግል መሰረት።
>> def ሃረግ_በወዜ(ሃረ)
>>   ሃረ.?('').?.?
>> end
>> ሃረግ_በወዜ("ኤደን")
=> "ድሽረ"

4.3.3 ተርታ እና ወካይ

ተርታወች በመሰረቱ በሙሉ-ቁጥር ጠቋሚዎች ብቻ ያልተወሰኑ ድርድሮች ናቸው። (እንደውም በዚህ ምክንያት በአንዳንድ የኮምፒዩተር ፕሮግራም ቋንቋዎች ላይ፣ በተለይም በፐርል አንዳንድ ጊዜ ተርታወችን ተጎዳኝ ድርድሮች (Associative Arrays) ብለው ይጠሯቸዋል።) እንደውም የተርታ ጠቋሚወች (Indices) እና ቁልፎች (Keys)፣ የሆነውን ዓይነት ቁስ መሆን ይችላሉ። ለምሳሌ ሃረጎችን ልክ እንደ ቁልፎች አድርገን መጠቀም እንችላለን፡-

>> ተጠቃሚ = {}                          # {} አንድ ባዶ ተርታ።
=> {}
>> ተጠቃሚ["ስም"] = "ማይክል"              # ቁልፍ "ስም"፣ ዋጋ "ማይክል"
=> "ማይክል"
>> ተጠቃሚ["የአባት_ስም"] = "ሃርትል"        # ቁልፍ "የአባት_ስም"፣ ዋጋ "ሃርትል"
=> "ሃርትል"
>> ተጠቃሚ["ስም"]                       # አባልን መድረሱ ልክ እንደ ድርድር ነው።
=> "ማይክል"
>> ተጠቃሚ                               # አንድ የተርታ ቃልበቃል ውክልና
=> {"ስም"=>"ማይክል", "የአባት_ስም"=>"ሃርትል"}

ተርታወች የቁልፍ-ዋጋ ጥንዶችን በያዙ የሐረግ ቅንፎች ይበየናሉ፣ አንድ ጥንድ የሐረግ ቅንፍ ካለ ቁልፍ-ዋጋ ማለትም:- {}—አንድ ባዶ ተርታ ይባላል። እዚህ ላይ ልብ ማለት ያለባችሁ፣ ለተርታ የምንጠቀምበት ጥንድ የሐረግ ቅንፍ፣ ለጥምሮች ከምንጠቀመው ጥንድ የሐረግ ቅንፍ ጋር ምንም ዓይነት ግንኙነት እንደለለው ነው። (ልክ ነው ይህ ግራ ሊያጋባ ይችላል።) ምንም እንኳን ተርታወች ድርድሮችን ቢመስሉም፣ አንዱ ወሳኝ ልዩነታቸው ተርታወች በአጠቃይ ውሰጣቸው ያሉትን አባላቶቻቸውን በአንድ የተወሰነ ተርታ ማስቀመጥ ላይ እርግጠኛነትን አለመስጠታቸው ነው። ¹⁶ የአባላቶቹ ተርታ አስፈላጊ ሁኖ ከተገኘ፣ ድርድርን ተጠቀሙ።

ማዕዘነቅንፎችን [ ] ተጠቅሞ አንድ ባንድ ተርታወችን ከመበየን ይልቅ፣ ሌላ የተሻለ ቀላል መንገድ አለ። እሱም አንድ የቃልበቃል ውክልናን ማለት ቅንፎችን እና ዋጋቸውን በዚህ ምልክት => በመከፋፈል ነው። ይህ ምልክትም => “ሃሽሮኬት” በመባል ይታወቃል:-

>> ተጠቃሚ = { "ስም" => "ማይክል", "የአባት_ስም" => "ሃርትል" }
=> {"ስም"=>"ማይክል", "የአባት_ስም"=>"ሃርትል"}

እዚህ ጋር እኔ የተለመደውን የሩቢ ባህልን በመከተል በተርታወቹ መግቢያ እና መጨረሻ ላይ አንድ ተጨማሪ ክፍትቦታን ተጠቅሜለሁ፣ እንደተለመደው በሰሌዳው ውጽአት እነሱም ችላ ይባላሉ። (ለምን እንደዚህ ዓይነት ክፍትቦታ መጠቀሙ የሩቢ ባህል እንደሆነ እኔን አትጠይቁኝ፣ ምናልባት አንድ ከድሮ ተደማጪነት ያለው የሩቢ አበልጻጊ የተጨማሪ ክፍትቦታዎቹን መልክ ስለወደዳቸው እንደ ባህል ሆኖ የቀረ ሊሆን ይችላል።)

እስከ አሁን ድረስ ሃረጎችን የተርታ ቁልፍች በማድረግ ተጠቅመናል፣ ነገር ግን በሬይልስ ውስጥ ከነሱ ይልቅ በጣም የተለመደው ወካዮችን መጠቀም ነው። ወካዮች ሃረጎችን ይመስላሉ፣ ነገር ግን ወካዮችን ስንበይን የምንጀምረው በድርብ ጥቅስ በማካበብ ሳይሆን፣ ሁለት ነጥብ መጀመሪያቸው ላይ በማጣበቅ ነው። ለምሳሌ :ስም ወካይ ነው። በመሰረቱ ወካዮችን ልክ ምንም ተጨማሪ ኮተት እንደሌላቸው ሃረጎች አድርጋችሁ ማሰብ ትችላላችሁ:-¹⁷

>> "ስም".split('')
=> ["ስ", "ም"]
>> :ስም.split('')
NoMethodError: undefined method `split' for :ስም:Symbol
>> "ነጋ".reverse
=> "ጋነ"
>> :ነጋ.reverse
NoMethodError: undefined method `reverse' for :ነጋ:Symbol

ወካዮች በጣም ጥቂት የፕሮግራም ቋንቋዎች ጋር የተጋሩ እና ልዩ የሆኑ የሩቢ የውሂብ አይነቶች ስለሆኑ መጀመሪያ ላይ ስታዩዋቸው እንግዳ ሊሆኑባችሁ ይችላሉ፣ ነገር ግን ሬይልስ በብዛት ስለሚጠቀምባቸው በአጪር ጊዜ ውስጥ ትለምዷቸዋላችሁ። ከሃረጎች ጋር በተቃረነ መልኩ፣ ሁሉም ሆሄወች ወካዮች የመሆን ብቃት የላቸውም፡-

>> :ነጋ-ገብረስላሰ
NameError: undefined local variable or method `ገብረስላሰ' for main:Object
>> :2ብር
SyntaxError

ወካያችሁን በአንድ ፊደል እና በተለመዱ የቃል ሆሄወች እስከጀመራችሁ ድረስ ትክክል ናችሁ፡፡

ወካይን እንደ ተርታ ቁልፍ አኳያ አድርጎ ለመበየን፣ አንድ የ‘ ተጠቃሚ ተርታን እንደሚከተለው አድርገን መበየን እንችላለን:-

>> ተጠቃሚ = { :ስም => "ማይክል ሃርትል", :ኤመልእክት => "ማይክል@ምሳሌ.ኮም" }
=> {:ስም=>"ማይክል ሃርትል", :ኤመልእክት=>"ማይክል@ምሳሌ.ኮም"}
>> ተጠቃሚ[:ስም]              # ከ :ስም ጋር የሚጎዳኝ ዋጋን መድረስ።
=> "ማይክል ሃርትል"
>> ተጠቃሚ[:መሕለፈቃል]        # የአንድ ያልተበየነ የቁልፍ ዋጋን መድረስ።
=> nil

ከላይ በተሰጠው ምሳሌ እንዳየነው ለአንድ ያልተበየነ ተርታ የቁልፉ ዋጋ ምንም (nil) ብቻ ነው።

ተርታወች ላይ ወካዮችን እንደ ቁልፍች አድርጎ መጠቀሙ በጣም የተለመደ ስለሆነ፣ ሩቢ ከሩቢ 1.9 ስሪት ጀምሮ ለዚሁ ልዩ ሁኔታ አንድ አዲስ አገባብን ይደገፋል:-

>> ሀ1 = { :ስም => "ማይክል ሃርትል", :ኤመልእክት => "ማይክል@ምሳሌ.ኮም" }
=> {:ስም=>"ማይክል ሃርትል", :ኤመልእክት=>"ማይክል@ምሳሌ.ኮም"}
>> ሀ2 = { ስም: "ማይክል ሃርትል", ኤመልእክት: "ማይክል@ምሳሌ.ኮም" }
=> {:ስም=>"ማይክል ሃርትል", :ኤመልእክት=>"ማይክል@ምሳሌ.ኮም"}
>> ሀ1 == ሀ2
=> true

የሁለተኛው አገባብ፣ የወካዩን እና የሃሽሮኬቱን ውህደት፣ ሁለት ነጥብ ባለው የቁልፍ ስም እና ከአንድ ዋጋ ጋር በማከታተል ይተካል፡፡

{ ስም: "ማይክል ሃርትል", ኤመልእክት: "ማይክል@ምሳሌ.ኮም" }

ይህ አመሰራረት ከሌሎች ቋንቋዎች (ማለት እንደ ጃቫስክሪፕት ባሉ ቋንቋዎች) የተርታ ስርዓተ-ምልክት ጋር በጣም የሚመሳሰል ቢሆንም፣ እውቅናውን ያገኘው ግን በሬይልስ ማህበረሰብ ነው። ሁለቱንም አገባቦች እስከ አሁን ድረስ በተርታ ውስጥ በሰፊው ስለምንጠቀምባቸው የሁለቱንም አጠቃቀም በሚገባ ለይቶ ማወቁ በጣም አስፈላጊ ነው። እንደ አጋጣሚ ሆኖ ይህን መለየቱ ትንሽ ግራ ያጋባል፣ ለምሳሌ:- :ስም በራሱ ተቀባይነት አለው፣ ነገር ግን ስም: በራሱ ምንም ዓይነት ትርጉም የለውም። የመጨረሻ መስመር ላይ ያሉት :ስም => እና ስም: ሁለቱም አንድ ዓይነት የሚሆኑት በቃልበቃል ተርታወች ውስጥ (Literal Hashes) ስንጠቀምባቸው ብቻ ነው ስለዚህ:-

{ :ስም => "ማይክል ሃርትል" }

እና

{ ስም: "ማይክል ሃርትል" }

እኩል ናቸው፣ ካልሆነ ግን ወካይን ለመበየን :ስም ‘ን (ሁለት ነጥብ መጀመሪያ ላይ በማጣበቅ) መጠቀም ይኖርባችኋል፡፡

የተርታ ዋጋዎች ሁሉንም ዓይነት ነገሮች ሊሆኑ ይችላሉ፣ ሌላው ሳይቀር በዝርዝር 4.13 ላይ እንደሚታየው፣ ተርታወች የሌሎች ተርታወች ዋጋዎችም ሊሆኑ ይችላሉ።

ዝርዝር 4.13: 

የተቃቀፉ ተርታወች
>> ሰሚአሴቶች = {}       # አንድ 'ሰሚአሴቶች' የተባለ ተርታን መበየን
=> {}
>> ሰሚአሴቶች[:ተጠቃሚ] = { ስም: "ማይክል ሃርትል", ኤመልእክት: "ማይክል@ምሳሌ.ኮም" }
=> {:ስም=>"ማይክል ሃርትል", :ኤመልእክት=>"ማይክል@ምሳሌ.ኮም"}
>> ሰሚአሴቶች
=> {:ተጠቃሚ=>{:ስም=>"ማይክል ሃርትል", :ኤመልእክት=>"ማይክል@ምሳሌ.ኮም"}}
>> ሰሚአሴቶች[:ተጠቃሚ][:ኤመልእክት]
=> "ማይክል@ምሳሌ.ኮም"

እንደዚህ ዓይነት የተርታወች-ተርታን ማለት የተቃቀፉ ተርታወችን (Nested Hashes) ሬይልስ በአብዛኛው ጊዜ ይጠቀምባቸዋል፣ ይህንን እውነታም በክፍል 7.3 ውስጥ ማየት እንጀምራለን።

ልክ እንደ ድርድሮች እና ከክሳቦች፣ ተርታወችም ለ‘እያንዳንዳቸው (each) ዘዴ መልስን ይሰጣሉ፡፡ ለምሳሌ ሁለት ሁናታወችን ለመለየት፣ :ስኬታማ እና :አደገኛ የተባሉት ቁልፎችን የያዘ አንድ ብልጪታ የተባለ ተርታን እንመልከት፡-

>> ብልጪታ = { ስኬታማ: "ይሰራል!", አደገኛ: "አይሰራም" }
=> {:ስኬታማ=>"ይሰራል!", :አደገኛ=>"አይሰራም"}
>> ብልጪታ.each do |ቁልፍ, ዋጋ|
?>   puts "#{ቁልፍ.inspect} የተባለው ቁልፍ  #{ዋጋ.inspect} የተባለ ዋጋ አለው።"
>> end
:ስኬታማ የተባለው ቁልፍ  "ይሰራል!" የተባለ ዋጋ አለው።
:አደገኛ የተባለው ቁልፍ  "አይሰራም" የተባለ ዋጋ አለው።

አስተውሉ የ‘እያንዳንዳቸው (each) ዘዴ ለድርድሮች፣ አንድ ጥምር ከአንድ ተለዋዋጪ ጋር ሲወስድ ለተርታወች ግን ሁለት ተለዋዋጮችን ይወስዳል፣ እነሱም አንድ ለቁልፍ (Key) እና አንድ ለዋጋ (Value) ናቸው፤ ስለሆነም ለአንድ ተርታ የ‘እያንዳንዳቸው (each) ዘዴ በአንድ ጊዜ፣ በአንድ ተርታ አንድ የቁልፍ-ዋጋ ጥንድ ላይ ይደጋግማል፡፡

የመጨረሻው ምሳሌ ጠቃሚ የሆነውን የ‘መርምር (inspect) ዘዴን ይጠቀማል፤ ይህ ደግሞ በተጠራበት ቁስ ላይ አንድ የሃረግ ቃልበቃል ውክልናን ይመስላል፡-

>> puts (1..5).to_a            # አንድ ድርድርን በአንድ ሃረግ መልክ ማስቀመጥ።
1
2
3
4
5
>> puts (1..5).to_a.inspect    # ድርድርን በአንድ ቃልበቃል ማስቀመጥ።
[1, 2, 3, 4, 5]
>> puts :ስም, :ስም.inspect
ስም
:ስም
>> puts "ይሰራል!", "ይሰራል!".inspect
ይሰራል!
"ይሰራል!"

በነገራችን ላይ የ‘መርምር (inspect) ዘዴን በመጠቀም አንድ ቁስን ማተሙ በጣም የተለመደ ስለሆነ፣ ለሱ የሚሆን አንድ አቋራጪም አለ፣ አቋራጩም ፒ‘ (p)¹⁸ ይባላል:-

>> p :ስም             # ከ 'puts :ስም.inspect' ውጽአት ጋር አንድ ዓይነት ነው።
:ስም

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

ቁልፎቹ 'አንድ' ፣ 'ሁለት' እና 'ሶስት' ፤ ዋጋወቹ ደግሞ 'ሓደ' ፣ 'ክልተ' እና 'ሰለስተ' የሆነ አንድ ተርታን በይኑ። በተርታው ላይ በመደጋገም ለእያንዳንዱ የቁልፍ/ዋጋ ጥንድ የ "'#{ቁልፍ}' በትግርኛ '#{ዋጋ}'" ውጽዓትን አትሙ፡፡
:ስም እና :አባት የተባለ ቁልፎቹ ያሏቸው ሰው1 ፣ ሰው2 እና ሰው3 የተባሉ ሶስት ተርታወችን ፍጠሩ (ለምሳሌ:- ሰው4 = { ስም: "ኤደን", አባት: "ነጋ" })። ከዚያ ሰሚአሴቶች[:አባት] የ‘ ሰው1 ውጤት፣ ሰሚአሴት[:እናት] የ‘ ሰው2 ውጤት፣ ሰሚአሴቶች[:ልጅ] ደግሞ የ‘ ሰው3 ውጤት እድርጎ የሚይዝ አንድ የ‘ ሰሚአሴት ተርታ ፍጠሩ። ሰሚአሴቶች[:አባት][:ስም] የሚገባውን ዋጋ እንደሰጠ አረጋግጡ፡፡
ስሙ፣ የኤመልእክት አድራሻው እና የፍጪ መሕለፈቃል (Password Digest) ቁልፎቹ ከወካይ ጋር የተጎዳኘ አንድ ተርታ ፍጠሩ (ምሳሌ:- ከተ = {ከተማ: "አዲስ አበባ"})። ከዚያ የተርታውን ስም ዋጋ የራሳችሁን ስም፣ የኤመልእክት አድራሻውን ዋጋ የራሳችሁን የኤመልእክት እና የፍጪ መሕለፈቃሉን ዋጋ ደግሞ በነሲብ አስራ ስድስት የንዑስ የእንግሊዝኛ ፊደላት የተመሰረተ አንድ ሃረግ ስጡት።
በመስመር ላይ አንድ የሩቢ አ.ፕ.በ ፈልጋችሁ፡ አዋህድ (merge) ስለተባለው የተርታ ዘዴ አንብቡ። የሚከተለው የሂሳበሃረግ ዋጋ ምንድነው?
```
  { "ሀ" => 100, "ለ" => 200 }.merge({ "ለ" => 300 })
```

4.3.4 ወ.ሉ.ቅን በድጋሜ ማየት

አሁን በዝርዝር 4.1 ላይ ያለውን፣ በገጽታው ላይ ወራጅ የሉህ ቅጥን ለማካተት የሚጠቅመውን መስመር በድጋሜ የምናይበት ጊዜ ነው:-

<%= stylesheet_link_tag 'application', media: 'all',
                                       'data-turbolinks-track': 'reload' %>

አሁን ይህንን መረዳት የምንችልበት ደረጃ ላይ እጅግ በጣም ተቃርበናል፡፡ በክፍል 4.1 ላይ በግልጽ እንደተገለጸው፣ ሬይልስ ቅጦችን ለማካተት አንድ ልዩ ሥልትን በይኗል፣ ስለዚህም ይህ:-

stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

ወደዚህ ሥልት የሚደረግ አንድ ጥሪ ነው፡፡ ነገር ግን እዚህ ላይ በርካታ ሚስጥሮች አሉ፡፡ አንደኛ፣ ቅንፎቹ የት አሉ? በሩቢ ውስጥ እነዚህ ምርጫዊ ናቸው፣ ስለሆነም እነዚህ ሁለቱ እኩል ናቸው:-

# ቅንፎች በሥልት ጥሪ ላይ ምርጫዊ ናቸው።
# ስለሆነም ይህ:-
stylesheet_link_tag('application', media: 'all',
                                   'data-turbolinks-track': 'reload')
# ከዚህ ጋር አንድ ነው:-
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

ሁለተኛ፣ የ‘ማህደረመረጃ (media) ነጋሪአሴት አንድ ተርታን ይመስላል፣ ነገር ግን የሐረግ ቅንፎቹ የት አሉ? በአንድ ሥልት ጥሪ ላይ ተርታወች የመጨረሻ ነጋሪአሴት ሲሆኑ፣ የሐረግ ቅንፎቹ ምርጫዊ ናቸው፣ ስለዚህም እነዚህ ሁለቱ እኩል ናቸው:-

# ተርታወች የመጨረሻ ነጋሪአሴት ሲሆኑ፣ የሐረግ ቅንፎቹ ምርጫዊ ናቸው።
# ስለሆነም ይህ:-
stylesheet_link_tag 'application', { media: 'all',
                                     'data-turbolinks-track': 'reload' }
# ከዚህ ጋር አንድ ነው:-
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

በመጨረሻም፣ በመጨረሻዎቹ አባላቶች መካከል አንድ የመስመር መቋረጥ/ስብራት ቢኖርም እንኳ ሩቢ መስመሮቹን ግን በትክክል ለምን ይተረጉማል የሚለው ጥያቄ ይሆናል? :-

stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

መልሱም ሩቢ በዚህ አውድ ውስጥ አዲስመስመሮችን እና ሌሎች ሌጣቦታወችን መለየት ስለማይችል ነው፡፡¹⁹ እኔ ኮዱን የከፋፈልኩበት ምክንያት በአንድ መስመር ውስጥ የኮድ ሆሄወች ይዞታ ከ 80 በታች ከሆነ ለመነበብ አመች እና ምርጫየም ስለሆነ ነው፡፡²⁰

ስለዚህ አሁን ይህ መስመር:-

stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

ከሁለት ነጋሪአሴቶች ጋር የ‘ቅጠሉህ_አገናኝ_መለያ (stylesheet_link_tag) ሥልትን ይጠራል፣ ሃረጉ የቅጥ ፋይል መንገዱን ሲጠቁም፣ ተርታው ሁለት አባላቶችን አካቶ የመገናኛ ዓይነቱን እና በሬይልስ 4.0 የታከለውን የቱርቦሊንክስ ገጸባህሪን እንዲጠቀም ለሬይልስ ይነግራል፡፡ በ <%= ... %> ቅንፎች አማካይነት ውጤቶቹ በክ.ሩ ወደ ዝግጁገጽታወቹ ውሰጥ እንዲገቡ ሆኗል፣ በአሳሹ ውስጥ ያለውን የገጹን ምንጪ ብታዩት፣ ቅጡን ለማካተት ያስፈለገውን ሃ.ጽ.መ.ቋ ማየት ትችላላችሁ (ዝርዝር 4.14) (በዝርዝር 4.14 ውስጥ ያሉ ሌሎች ተጨማሪ ነገሮች ለምሳሌ እንደ ?body=1 እና ረጅሙ የአስራስድስትዮሽ አሃዝ የተጨመሩት በሬይልስ ሲሆን፣ ይህም የሆነው ከአገልጋዩ የወ.ሉ.ቅ ለውጥ ሲመጣ፣ አሳሾቹ ቅጡን እንዳዲስ መጫናቸውን ለማረጋገጥ ነው፡፡ የአስራስድስትዮሽ ሃረጉ ሆን ተብሎ ልዩ ስለተደረገ የናንተ ስሪት በዝርዝር 4.14 ላይ ከምታዩት አስራስድስትዮሽ ጋር ፈጽሞ አይመሳሰልም።)

ዝርዝር 4.14: 

በወ.ሉ.ቅ መታከል የተሰራው የሃ.ጽ.መ.ቋ ምንጪ።
<link rel="stylesheet" media="all" href="/assets/application.self-
f0d704deea029cf000697e2c0181ec173a1b474645466ed843eb5ee7bb215794.css?body=1"
data-turbolinks-track="reload" />

4.4 የሩቢ ክፍሎች

ቀደም ሲል ሩቢ ውስጥ የሚገኝ ነገር ሁሉ ቁስ ነው ብለናል፣ እናም በመጨረሻ በዚህ ክፍል ውስጥ የራሳችን የሆኑ የተወሰኑ ቁሶችን ለመበየን በቅተናል፡፡ ሩቢ እንደ አብዛኞቹ ቁስ-ተኮር ቋንቋዎች፣ ክፍሎችን (Classes)፣ ዘዴዎችን ለማደራጀት ይጠቀምባቸዋል፤ ከዛም እነዚህ ክፍሎች ቁሶችን ለመፍጠር ይቀረጻሉ (Instantiate)፡፡ ለቁስ-ተኰር ቋንቋ አዲስ ከሆናችሁ፣ ይህ ትርጉም የለሽ ነገር ሊመስል ይችላል፣ ስለሆነም እስኪ አንዳንድ ተግባራዊ የሆኑ ምሳሌዎችን አብረን እንመልከት፡፡

4.4.1 መስራቾች

ቁሶችን ለማስጀመር ክፍሎችን በመጠቀም ላይ ብዙ ምሳሌዎችን ተመልክተናል፣ እስከ አሁን ግን በግልጽ እንደዛ ማድረግን አልተመለከትንም፡፡ ለምሳሌ አንድ ሃረግን ለመቀረጽ፣ የድርብ ጥቅስ ሆሄወችን እንጠቀማለን፣ ይህም የአንድ ሃረግ ቃልበቃል መስራችን (Literal Constructor) በመጠቀም ነው:-

>> ሃ = "አማንኤል"  # ድርብ-ጥቅስን ለአንድ የሃረግ ቃልበቃል መስራች በመጠቀም
=> "አማንኤል"
>> ሃ.class
=> String

እነዚ ጋር የምናየው ሃረጎች ለ‘ክፍል (class) ዘዴ ምላሽ እንደሚሰጡ እና አባል የሆኑበትን ክፍል ብቻ እንደሚመልሱ ነው።

አንድ የቃልበቃል መስራችን ከመጠቀም ሌላ፣ ከሱ ጋር እኩል የሆነውን ስዩም መስራች (Named Constructor) የተባለውን መስራች መጠቀም እንችላለን፣ ይህም በራሱ ክፍል ላይ የ‘አዲስ (new) ዘዴን መጥራትን ያሳትፋል:-²¹

>> ሃረ = String.new("ድንቄ") # አንድ ስዩም መስራችን በመጠቀም አንድ ሃረግን መቀረፅ
=> "ድንቄ"
>> ሃረ.class
=> String
>> ሃረ == "ድንቄ"
=> true

ይህ ከቃልበቃል መስራች ጋር እኩል ነው፣ ነገር ግን ይህ ምን እያረግን እንደሆነ እጅግ በግልጽ ያሳያል።

ድርድሮች ልክ እንደ ሃረጎች በተመሳሳይ መንገድ ይሰራሉ:-

>> ድ = Array.new([1, 3, 2])
=> [1, 3, 2]

በተቃራኒው፣ ተርታወች ደግሞ የተለዩ ናቸው፡፡ ለምሳሌ:- የድርድር መስራቹ ድርድር.አዲስ (Array.new) አንድ የመቅረጫ ዋጋ ለድርድሩ ሲወስድ፣ ተርታ.አዲስ (Hash.new) ግን አንድ ነባሪ ዋጋ ለተርታው ይወስዳል፣ ይህም የተርታው ዋጋ፣ አንድ ያልተፈጠረ ቁልፍ ነው፡-

>> ተ = Hash.new
=> {}
>> ተ[:ድንቄ]       # ላልተፈጠረ ቁልፍ ዋጋውን ለመድረስ መሞከር :ድንቄ
=> nil
>> ተ = Hash.new(0) # ላልተፈጠረ ቁልፍ ከምንም ይልቅ 0ን እንደ አንድ ነባሪ ዋጋ አድርጎ ማዘጋጀት
=> {}
>> ተ[:ድንቄ]
=> 0

አንድ ዘዴ በራሱ ክፍል ላይ ሲጠራ፣ ማለት ልክ እንደ አዲስ (new) ዓይነቱ ዘዴ የክፍል ዘዴ (Class Method) ይባላል፡፡ በአንድ ክፍል ላይ አዲስ‘ን (new) መጥራት የሚያመጣው ውጤት የክፍሉን ቁስ ሲሆን፣ ቁሱ ቅርፀተ ክፍል (Instance) ይባላል፣ በቅርፀቱ ላይ የሚጠራ ዘዴ ማለት ልክ እንደ እርዝመት (length) ዓይነቱ ዘዴ ደግሞ ቅርፀተ ዘዴ (Instance Method) ይባላል፡፡

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

ከ 1 እስከ 10 ላሉት ከክሳብ የቃልበቃል መስራች ምን ይመስላል? (ምሳሌ:- ከ 50 እስከ 100 ላሉት ከክሳብ እንደዚህ:- 50..100 ነው።)
የ‘ከክሳብ (Range) ክፍልን እና የ‘አዲስ (new) ዘዴን በመጠቀምስ እንዴት አድርገን የላይኛውን ጥያቄ መመስረት እንችላለን? ጠቃሚ ምክር:- እዚህ ላይ የ‘አዲስ (new) ዘዴ ሁለት ነጋሪአሴቶችን ይወስዳል።
ይህንን:- == የንጽጽር ስሌት በመጠቀም፣ ከላይ ያሉት ሁለት መልመጃወች ውስጥ የቃልበቃሉ እና የስዩም መስራቹ ውጤቶች ፍጹም አንድ መሆናቸውን አረጋግጡ፡፡

4.4.2 የክፍሎች መወራረስ

ስለክፍሎች በሚማሩበት ጊዜ የ‘ምዕባየክፍል (superclass) ዘዴን በመጠቀም የክፍል ስርዓተ-መዓረጉን (Class Hierarchy) ማወቁ ጠቃሚ ነው:-

>> ሃረ = String.new("በቀለ")
=> "በቀለ"
>> ሃረ.class                       # የሃረ ክፍልን መፈለግ
=> String
>> ሃረ.class.superclass            # የሃረ ምዕባየክፍልን መፈለግ
=> Object
>> ሃረ.class.superclass.superclass #ሩቢ ከ1.9ስሪት ጀምሮ 1 መሰረተቁስ የተባለ መሰረተክፍል አለው
=> BasicObject
>> ሃረ.class.superclass.superclass.superclass
=> nil

ይህ የውርስ ስርዓተ-መዓረግ በምስል 4.1 ላይ በአንድ ስእላዊ መግለጫ ላይ ይታያል፡፡ እዚህ ጋር እንደምናየው፣ የ‘ሃረግ (String) ምዕባየክፍል ቁስ (Object) ነው፣ የ‘ቁስ (Object) ምዕባየክፍል መሰረተቁስ (BasicObject) ነው፣ ነገር ግን መሰረተቁስ (BasicObject) ምዕባየክፍል የለውም። ይህ ንድፍ ለሁሉም የሩቢ ቁሶች እውን ይሆናል፣ ይህንን የክፍል መወራረስ እስከ ቅድመ አያቱ ድረስ ብንሄድ፣ ሁሉም የሩቢ ክፍሎች የመጡት ከ‘መሰረተቁስ (BasicObject) ሲሆን ለራሱ ግን ምዕባየክፍል የለውም፡፡ ይህ “ሁሉም ነገር በሩቢ ውስጥ ቁስ ነው” ለሚለው አባባል ሙያዊ ትርጉሙ ነው፡፡

የ‘ሃረግ (String) ክፍል የውርስ ስርዓተ-መዓረግ።

ስለ ክፍሎች በደንብ ለመረዳት በራሳችን አንድ ክፍል መፍጠርን የሚተካው የለም፡፡ እስኪ ቃሉ ከግራ ወደ ቀኝ እና እንዲሁም ከቀኝ ወደ ግራ ሲጻፍ እውነት‘ን (true) የሚመልስ አንድ የ‘ቃል (Qal) ክፍልን ከአንድ አንሶላ? ዘዴ ጋር እንስራ:-

>> class Qal
>>   def አንሶላ?(ሃረግ)
>>     ሃረግ == ሃረግ.reverse
>>   end
>> end
=> :አንሶላ?

እንደሚከተለው አድርገን ልንጠቀምበት እንችላለን:-

>> ቃሉ = Qal.new              # አንድ አዲስ የቃል ቁስን መስራት
=> #<Qal:0x00007fa77a050ba8>
>> ቃሉ.አንሶላ?('ነጋሲ')
=> false
>> ቃሉ.አንሶላ?('ተረተ')
=> true

ይህ ምሳሌ በጣም ካስገረማችሁ ጥሩ ነው፣ ይሄም ሆን ተብሎ የተደረገ/የተነደፈ ነው። አንድ ሃረግን እንደ አንድ ነጋሪአሴት አድርጎ የሚወስድ አንድ ዘዴን ለመስራት አንድ አዲስ ክፍልን መፍጠሩ ያልተለመደ ነገር ነው። አንድ ቃል አንድ ሃረግ ስለሆነ፣ በዝርዝር 4.15 ላይ እንደታየው፣ የ‘ቃል (Qal) ክፍላችን ከ‘ሃረግ (String) መውረሱ የበለጠ ትርጉም እንዲሰጥ ያደርገዋል፡፡ (የበፊቶቹን የ‘ቃል (Qal) ብያኔወች ከሰሌዳው ለማጽዳት፣ ከሰሌዳው ወጥታችሁ እንደገና ግቡ።)

ዝርዝር 4.15: 

የ‘ቃል (Qal) ክፍልን በሰሌዳ ውስጥ መበየን።
>> class Qal < String             # Qal ከሃረግ ይወርሳል።
>>   # ሃረጉ የራሱ ተገላቢጦሽ ከሆነ እውነትን ይመልሳል።
>>   def አንሶላ?
>>     self == self.reverse        # እራሱ ሃረጉ ሰልፍ (እራሱ) ነው
>>   end
>> end
=> nil

ይህ:- Qal < String የሩቢ የመወራረስ አገባብ ነው (በክፍል 3.2 ላይ በደንብ ተገልጿል)፣ ይህም ከአዲሱ አንሶላ? ዘዴ በተጨማሪ ቃላቶች ራሳቸው ከሃረጎች ጋር አንድ ዓይነት የሆኑ ዘዴወች እንዳላቸው ያረጋግጣል:-

>> ሃረ = Qal.new("ተረተ")    # አንድ አዲስ ቃል ፈጥሮ በ "ተረተ" መቅረፅ
=> "ተረተ"
>> ሃረ.አንሶላ?               # ቃላቶች የ አንሶላ? ዘዴ አላቸው።
=> true
>> ሃረ.length              # ቃላቶች መደባዊ የሃረግ ዘዴወችንም ይወርሳሉ።
=> 3

የ‘ቃል (Qal) ክፍል ከ‘ሃረግ (String) ስለሚወርስ፣ ሰሌዳውን በመጠቀም የክፍሉን ስርዓተ-መዓረግ በግልጽ ማየት እንችላለን:-

>> ሃረ.class
=> Qal
>> ሃረ.class.superclass
=> String
>> ሃረ.class.superclass.superclass
=> Object

ይህ ስርዓተ-መዓረግ በምስል 4.2 ውስጥ በስእላዊ መግለጫ ቀርቧል፡፡

(አብሮገነብ ያልሆነ) የዝርዝር 4.15 የ‘ቃል (Qal) ክፍል የውርስ ስርዓተ-መዓረግ፡፡

አንድን ቃል በተገላቢጦሹ አንድ ዓይነት ቃል መሆኑን ማረጋገጡ በ‘ቃል (Qal) ክፍሉ ውስጥ መድረስን እንደሚያሳትፍ ከዝርዝር 4.15 አስተውሉ፡፡ ሩቢ የ‘ራሥ (self) ቁልፍቃልን በመጠቀም ይህንን እንድናደርግ ይፈቅድልናል፣ በ‘ቃል (Qal)-ክፍሉ ውስጥ ራሥ (self) ራሱ-ቁሱ ነው፣ ይህም ይህንን በመጠቀም:-

self == self.reverse

ቃሉ አንድ አንሶላ እንደሆነ እና እንዳልሆነ መፈተሽ እንችላለን፡፡ በእርግጥ በአንድ ዘዴ ወይም ባሕሪ ላይ (አንድ የሆነ ነገር እየመደብን ካልሆነ በስተቀር) በሃረግ ክፍል ውስጥ ራሥ‘ን (self) መጠቀሙ እንደ አማራጪ ይወሰዳል፡፡ ስለዚህ ይህ ኮድ:-

self == reverse

ተብሎ ቢጻፍም በሚገባ ይሰራል፡፡

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

የከክሳብ፣ የተርታ እና የወካይ የክፍል ስርዓተ-መዓረጎች እነማን ናቸው?
በዝርዝር 4.15 ላይ ያለው ኮድ፣ ራሥ-ገላብጥ (self.reverse) የሚለው ኮድ፣ በ‘አገላብጥ (reverse) ቢተካ፣ ኮዱ አሁንም እንደሚሰራ አረጋግጡ፡፡

4.4.3 አብሮገነብ ክፍሎችን ማሻሻል

መወራረስ አንድ ሃይለኛ ሃሳብ ስለሆነ፣ በአንሶላወች አኳያ የ‘ አንሶላ? ዘዴን ወደ ሃረጉ (String) ክፍል ማከሉ የበለጠ ትርጉም የሚሰጥ ሊያደርገው ይችላል፣ ስለሆነም በአንድ ቃልበቃል ሃረግ ላይ አንሶላነውን? (አንሶላ?) ብለን የመጥራት ችሎታን ይሰጠናል፣ ይህንን ባሁኑ ጊዜ ማድረግ አንችልም:-

>> "ተበተ".አንሶላ?
NoMethodError: undefined method `አንሶላ?' for "ተበተ":String

በሚገርም ሁኔታ፣ ሩቢ ይህንን ነገር እንድናደርግ ይፈቅዳል፤ ማለትም የሩቢ ክፍሎች ሊከፈቱ እና ሊሻሻሉ ይችላሉ፣ እናም ሩቢ እንደ እኛ ላሉ ተራ ሰዎች (በሩቢ ላልተካነው) ሳይቀር እንኳን ዘዴዎችን በእነሱ ላይ እንድናክል ይፈቅድልናል:-

>> class String
>>   # ሃረጉ ተገላብጦ እራሱ ከሆነ እውነትን ይመለሳል።
>>   def አንሶላ?
>>     self == self.reverse
>>   end
>> end
=> nil
>> "ተረተ".አንሶላ?
=> true

(የትኛው ሃሪፍ እንደሆነ አላውቀውም:- ሩቢ ዘዴዎችን ወደ አብሮገነብ ክፍሎች እንድናክል መፍቀዱ፤ ወይስ "ተረተ" አንድ አንሶላ መሆኑ። እናንተስ ምን ትላላችሁ?)

አብሮገነብ ክፍሎችን ማሻሻል አንድ ሃያል ብልሃት ነው፣ ግን “ከታላቅ ሃይል ጋር ከፍተኛ ሃላፊነት ይጠበቃል” እንደተባለው በጣም ጥሩ የሆነ ምክንያት ከሌለ በስተቀር ዘዴዎችን በሩቢ ክፍል ውስጥ ማከሉ እንደ መጥፎ ስራ ይቆጠራል። ሬይልስ እንደዛ ቢያደርግ አንዳንድ ጥሩ ምክንያቶች ይኖሩታል፣ ለምሳሌ:- በድር አፕልኬሽኖች ውስጥ ብዙውን ጊዜ ተለዋዋጮች ባዶ (Blank) እንዳይሆኑ ለመከላከል እንፈልጋለን እንበል፣ ስለዚህም “የአንድ ተጠቃሚ ስም ከክፍትቦታ እና ከሌጣቦታ በስተቀር ሌላ የሆነ ነገር መሆን ይችላል፣” ብለን አንድ ደንብ ደነገግን እንበል፣ ለዚህ መፍትሔ ይሆን ዘንድ፣ ሬይልስ አንድ የ‘ባዶነውን? (blank?) ዘዴን ወደ ሩቢ አክሏል። የሬይልስ ሰሌዳ፣ ሬይልስ ወደ ሩቢ የጨመራቸውን ዘዴዎች ሁሉ በራስሰር ስለሚያካትት፣ ስለዚሁ ጉዳይ አንድ ምሳሌን ማየት እንችላለን (ይህ በሩቢ በይነግንኙነት (irb) ውስጥ ፈጽሞ አይሰራም።):

>> "".blank?
=> true
>> "      ".empty?
=> false
>> "      ".blank?
=> true
>> nil.blank?
=> true

እዚህ ላይ እንደምናየው፣ የአንድ ክፍትቦታዎች ሃረግ ባዶ (Empty) አይደለም፣ ግን ምንም (nil) ነው፡፡ ምንም (nil) ባዶ እንደሆነ ልብ በሉ፤ ምክንያቱም ምንም (nil) ሃረግ ስላልሆነ ነው። ይህ ሬይልስ ወደ ሃረግ (String) መሰረተ ክፍል ባዶነውን? ‘ን (blank?) እንዳከለ እና ሃረግ ራሱ ቁስ (Object) እንደሆነ አንድ ፍንጪን ይሰጣል (ይህንንም በዚህ ምዕራፍ መጀመሪያ ላይ አይተነዋል)። ሌሎች ወደ ሩቢ ክፍሎች የታከሉ የሬይልስ እክሎች ምሳሌዎችን በክፍል 9.1 ላይ እናያለን፡፡

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

“alula” የሚለው ቃል አንድ አንሶላ እና “onomatopoeia” የሚለው ቃል ደግሞ አንድ አንሶላ አለመሆኑን አረጋግጡ፡፡ “Malayalam” የተባለው የደቡብ ህንድ ቋንቋስ? ጠቃሚ ምክር:- መጀመሪያ ቃሉን ወደ ንዑስ የእንግሊዝኛ ፊደላት ቀይሩት፡፡
በዝርዝር 4.16 ላይ ያለውን ኮድ እንደ አንድ መመሪያ አድርጋችሁ በመውሰድ፣ አንድ በውዘው የተባለ ዘዴን በ‘ሃረግ (String) ክፍሉ ውስጥ አክሉ፡፡ ጠቃሚ ምክር:- ዝርዝር 4.12 ‘ን ተጣቀሱ፡፡
ከዝርዝር 4.16 ራሥ.‘ን (self.) ብታስወግዱትም እንኳ ኮዱ እንደሚሰራ አረጋግጡ።

ዝርዝር 4.16: 

ከ‘ሃረግ (String) ክፍል ጋር የተያያዘ አንድ የ በውዘው ዘዴ መሰረት።
>> class String
>>   def በውዘው
>>     self.?('').?.?
>>   end
>> end
>> "አስናቀች".በውዘው
=> "ናችአቀስ"

4.4.4 አንድ የመቆጣጠሪያ ክፍል

ስለ ክፍሎች እና ስለ መወራረስ ስናወራ፣ ከዚህ በፊት ስለነሱ እንደሰማን አንዳንድ ትዝታ ቀስቅሰውባችሁ ሊሆን ይችላል፣ ምክንያቱም ሁለቱንም ከዚህ በፊት በቋሚ ገጾች መቆጣጠሪያ (ዝርዝር 3.22) ላይ አይተናቸዋልና።

class QuamiGetssController < ApplicationController

  def menesha
  end

  def erdata
  end

  def silegna
  end
end

አሁን ቢያንስ ቢያንስ ይህ ኮድ ምን ማለት እንደሆነ ለመገንዘብ የሚያስችል አንድ አቋም ላይ ትገኛላችሁ፣ ለምሳሌ:- ይህ ቋሚገጾችመቆጣጠሪያ (QuamiGetssController) የሚለው ኮድ፣ ከአፕልኬሽንመቆጣጠሪያ (ApplicationController) የሚወርስ አንድ ክፍል እንደሆነ እና የ‘መነሻ (menesha)፣ የ‘እርዳታ (erdata) እና የ‘ስለኛ (silegna) ዘዴዎችን ታጥቆ/ሰንቆ እንደመጣ ታውቃላችሁ። እያንዳንዱ የሬይልስ የሰሌዳ ክፍለ ጊዜ፣ የሬይልስ የሰፈር አካባቢን ስለሚጪን እኛ አንድ መቆጣጠሪያን በግልጽ መፍጠር እና የክፍሉን ስርዓተ-መዓረግ²² መመርመር እንችላለን:-

>> controller = QuamiGetssController.new
=> #<QuamiGetssController:0x00007ff2ea31c2e0>
>> controller.class
=> QuamiGetssController
>> controller.class.superclass
=> ApplicationController
>> controller.class.superclass.superclass
=> ActionController::Base
>> controller.class.superclass.superclass.superclass
=> ActionController::Metal
>> controller.class.superclass.superclass.superclass.superclass
=> AbstractController::Base
>> controller.class.superclass.superclass.superclass.superclass.superclass
=> Object

የዚህ ስርዓተ-መዓረግ ሰእላዊ መግለጫ በምስል 4.3 ላይ ይታያል፡፡

የቋሚ ገጾች መቆጣጠሪያ የውርስ ስርዓተ-መዓረግ።

የመቆጣጠሪያውን ተግባሮች በሰሌዳ ውስጥ ሆነን እንኳን መጥራት እንችላለን፣ እነሱም ዘዴወች ብቻ ናቸው:-

>> controller.menesha
=> nil

እዚህ ጋር ተመላሹ ዋጋ ምንም (nil) ነው፣ ምክንያቱም የ‘መነሻ (menesha) ተግባር ባዶ ስለሆነ ነው፡፡

እንዴ! እንዳው አስፈላጊ ባይሆንም፣ ተግባሮች ተመላሽ ዋጋ አልነበራቸውም እንዴ?! በምዕራፍ 3 ላይ እንዳየነው፣ የ‘መነሻ (menesha) ተግባር ጥቅም አንድ የድር ገጽን ለማቅረብ ነው እንጅ አንድ ዋጋን ለመመለስ አይደለም። እና እኔ መቸም ቢሆን ቋሚገጾችመቆጣጠሪያ.አዲስ (QuamiGetssController.new) ብየ በየትኛውም ቦታ መጥራቴን እንደማላስታውስ እርግጠኛ ነኝ፣ ታድያ ምን እየተከናወነ ነው?!

በመከናወን ላይ ያለው ነገር፣ ሬይልስ በሩቢ መጻፉ ሬይልስ ግን ሩቢ አለመሆኑ ነው። አንዳንድ የሬይልስ ክፍሎች እንደ ማንኛውም የሩቢ ቁሶች ናቸው፤ አንዳንዶቹ ግን የሬይልስ የአስማት ወፍጮ እህሎች ብቻ ናቸው፡፡ ሬይልስ የተለየ ስለሆነ፣ ከሩቢ ተለይቶ መጠናት እና መረዳት የሚገባው መዋቅር ነው።

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

በምዕራፍ 2 በጨዋታ አፕልኬሽኑ ማውጫ ላይ የሬይልስ ሰሌዳን በማስኬድ እና አዲስ.ተጠቃሚ‘ን (Teteqami.new) በመጠቀም አንድ የ‘ተጠቃሚ (Teteqami) ቁስ መፍጠር እንደምትችሉ አረጋግጡ፡፡
የ‘ተጠቃሚ (Teteqami) ቁስ የክፍል ስርዓተ-መዓረግን እወቁ።

4.4.5 አንድ የተጠቃሚ ክፍል

በምዕራፍ 6 ውስጥ የተጠቃሚ ቅርጸት የሚጠብቀውን አንድ የ‘ተጠቃሚ (Teteqami) ክፍል፣ ማለት በራሳችን የተሟላ አንድ ክፍልን በመስራት የሩቢ ቋንቋ ቅኝታችንን እናጠናቅቃለን።

እስከ አሁን ድረስ የክፍል ብያኔን በሰሌዳ ውስጥ ስናስገባ ቆይተናል፣ ነገር ግን ይሄ አሰራር በአጪር ጊዜ ውስጥ አሰልቺ እየሆነ ይመጣል። ስለዚህ በዚህ ፈንታ አብነታዊ_ተጠቃሚ.rb የተባለ አንድ ፋይል በአፕልኬሽናችሁ ስረ ማውጫ ላይ ፍጠሩ እና ይዞታውን በዝርዝር 4.17 ይዘቶች ሙሉት።

ዝርዝር 4.17: 

ለአንድ አብነት ተጠቃሚ የሚሆን ኮድ።  አብነታዊ_ተጠቃሚ.rb
class Teteqami
  attr_accessor :ስም, :ኤመልእክት

  def initialize(ባሕርያት = {})
    @ስም  = ባሕርያት[:ስም]
    @ኤመልእክት = ባሕርያት[:ኤመልእክት]
  end

  def ቅሩጽ_ኤመልእክት
    "#{@ስም} <#{@ኤመልእክት}>"
  end
end

እዚህ ላይ ብዙ ነገር እየተካሄደ ነው፤ ስለዚህ እስኪ አንድ ባንድ እንመልከተው። ከመጀመርያው መስመር ስንጀምር:-

  attr_accessor :ስም, :ኤመልእክት

ይህ መስመር ከአንድ ተጠቃሚ ስም እና የኤመልእክት አድራሻ ጋር የሚዛመዱ የባሕሪ መዳረሻወችን (Attribute Accessors) ይፈጥራል። ይህ በክፍል 2.2.2 እና በክፍል 3.4.2.1 ውስጥ በአጪሩ የተጠቀሱትን የ‘ @ስም እና የ‘ @ኤመልእክት ቅርፀ ተለዋዋጮችን (Instance Variables) ፈልጎ ለማውጣት (አግኝ (get)) እና ለማዘጋጀት (አዘጋጅ (set)) የሚያስችሉ “የአግኝ (getter)” እና “የአዘጋጅ (setter)” ሥልቶችን ይፈጥራል፡፡ በሬይልስ ውስጥ የቅርፀ ተለዋዋጮች ዋናው አስፈላጊነት፣ እነሱ በትይታወች ውስጥ በራስሰር ስለሚገኙ ነው፣ በአጠቃላይ እነሱ ግን በአንድ የሩቢ ክፍል ውስጥ ሙሉ በሙሉ መገኘት ለሚፈለጉ ተለዋዋጮች ጥቅም ላይ ይውላሉ። (ስለዚህ ጉዳይ በአጪር ጊዜ ውስጥ ብዙ የምንለው ነገር ይኖረናል፡፡) ቅርፀ ተለዋዋጮች ሁልጊዜ በአንድ የ @ ምልክት ይጀምራሉ፣ እና ባልተበየኑበት ጊዜ ዋጋቸው ደግሞ ምንም (nil) ነው፡፡

የመጀመሪያው የ‘አስጀምር (initialize) ዘዴ በሩቢ ውስጥ ልዩ የሆነ ዘዴ ነው:- ይህ አዲስ.ተጠቃሚ‘ን (Teteqami.new) በምንፈጽምበት ጊዜ የሚጠራ ዘዴ ነው። እዚህ ላይ ይህ የተለየ የ‘አስጀምር (initialize) ዘዴ አንድ ባሕርያት የተባለ ነጋሪአሴትን ይወስዳል:-

  def initialize(ባሕርያት = {})
    @ስም = ባሕርያት[:ስም]
    @ኤመልእክት = ባሕርያት[:ኤመልእክት]
  end

እዚህ ጋር የ‘ ባሕርያት ተለዋዋጩ አንድ የነባሪ ባዶ ተርታ ጋር እኩል የሆነ ዋጋ አለው፣ ስለሆነም አንድ ተጠቃሚን ያለ ስም ወይም ያለ አንድ የኤመልእክት አድራሻ መበየን እንችላለን ማለት ነው። (በክፍል 4.3.3 ላይ ተርታ ቁልፎች ከለሉት ምንም‘ን (nil) እንደሚመልስ እንደተመለከትን አስታውሱ፣ ስለዚህ የ‘ :ስም ቁልፍ ከለለም ባሕርያት[:ስም] ምንምን (nil) ይመልሳል፣ እንደሁም የ‘ :ኤመልእክት ቁልፍ ከለለም ባሕርያት[:ኤመልእክት] ምንምን (nil) ይመልሳል ማለት ነው)።

በመጨረሻም፣ ክፍላችን ለ‘ @ስም እና ለ‘ @ኤመልእክት የተመደቡ የተለዋዋጮች ዋጋወችን የሚጠቀም፣ አንድ ቅሩጽ_ኤመልእክት የተባለ ዘዴን ይበይን እና የሃረግ ውስጠገምትን በመጠቀም አንድ በጥሩ ሁኔታ የተቀረጸ የተጠቃሚ የኤመልእክት አድራሻን ይገነባል (ክፍል 4.2.1):-

  def ቅሩጽ_ኤመልእክት
    "#{@ስም} <#{@ኤመልእክት}>"
  end

@ስም እና @ኤመልእክት (የ @ ምልክቱ እንደሚያመለክተው) ቅርፀ ተለዋዋጮች ስለሆኑ፣ በ‘ ቅሩጽ_ኤመልእክት ዘዴ ውስጥ በራስሰር ይገኛሉ።

እስቲ ሰሌዳውን እናስጀምር፣ ባለንበት ሰሌዳ ላይ አንድ ፋይልን ለማቅረብ የሚያገለግለውን የ‘ጠይቅ (require) ዘዴን በመጠቀም የ‘ አብነታዊ_ተጠቃሚ ኮድን እናስፈልግ እና የኛን የተጠቃሚ ክፍል እናሹረው፡-

>> require './አብነታዊ_ተጠቃሚ'   # የአብነታዊ_ተጠቃሚ ኮድን የምትጪኑት በዚህ መንገድ ነው፡፡
=> true
>> አብነት = Teteqami.new
=> #<Teteqami:0x00007fe @ስም=nil, @ኤመልእክት=nil>
>> አብነት.ስም          # የ ባሕርያት[:ስም] ምንም እስከሆነ ድረስ ውጤቱም ምንም (nil) ነው።
=> nil
>> አብነት.ስም = "አብነታዊ ተጠቃሚ"        # አንድ ምንም ያልሆነ (non-nil) ስምን መመደብ።
=> "አብነታዊ ተጠቃሚ"
>> አብነት.ኤመልእክት = "ተጠቃሚ@አብነት.ኮም" # አንድ ምንም ያልሆነ የኤመልእክትን መመደብ።
=> "ተጠቃሚ@አብነት.ኮም"
>> አብነት.ቅሩጽ_ኤመልእክት
=> "አብነታዊ ተጠቃሚ <ተጠቃሚ@አብነት.ኮም>"

እዚህ ጋር ይህ ነጥብ:- '.' የዩኒክስ ትእዛዝ ሲሆን፣ ይህም “አሁን ያለበትን ማውጫ” ይወክላል፣ እናም './አብነታዊ_ተጠቃሚ' ሩቢን፣ ተዛማጅ አድራሻው ላይ አንድ አብነታዊ ተጠቃሚ የተባለ ፋይልን እንዲፈልግ ይነግረዋል፡፡ ቀጣዩ ኮድ አንድ ባዶ ‘አብነታዊ ተጠቃሚ’ ይፈጥር እና ከዛም፣ ስሙን እና የኤመልእክት አድራሻውን በመመደብ በተዛማጁ ባሕሪ ላይ በቀጥታ ይሞላል። (እነዚህ ምደባወች የተሳኩት በዝርዝር 4.17 ላይ ባለው የ‘ባሕሪ_መዳረሻ (attr_accessor) በተባለው ኮድ ነው።) ይህን በምንጽፍበት ጊዜ:-

አብነት.ስም = "አብነታዊ ተጠቃሚ"

ሩቢ የ‘ @ስም ተለዋዋጪን ከ‘ "አብነታዊ ተጠቃሚ" ጋር ያዘጋጃል (ለ‘ ኤመልእክት ባሕሪውም በተመሳሳይ መንገድ ያዘጋጃል)፣ ከዚያ እኛ በ ቅሩጽ_ኤመልእክት ዘዴ ላይ እንጠቀምበታለን፡፡

ክፍል 4.3.4 ላይ የተማርነውን በማስታወስ፣ መጨረሻ ላይ የሚገኙትን የተርታ ነጋሪአሴቶች የሐረግ ቅንፎችን መተው እንችላለን፣ ቅድመ ብይን ባሕሪወችን የያዘ አንድ ተርታን ወደ አስጀምር (initialize) ዘዴ በማሳለፍ አንድ ተጠቃሚን መፍጠር እንችላለን:-

>> ተጠቃሚ = Teteqami.new(ስም: "ማይክል ሃርተል", ኤመልእክት: "ማሃርተል@አብነት.ኮም")
=> #<Teteqami:0x00007fe @ስም="ማይክል ሃርተል", @ኤመልእክት="ማሃርተል@አብነት.ኮም">
>> ተጠቃሚ.ቅሩጽ_ኤመልእክት
=> "ማይክል ሃርተል <ማሃርተል@አብነት.ኮም>"

ከምዕራፍ 7 ጀምሮ አንድ የተርታ ነጋሪአሴትን በመጠቀም ቁሶችን እንዴት መቅረፅ እንደምንችል እናያለን፣ ይህ በሬይልስ አፕልኬሽኖች ውስጥ የተለመደ እና ብልሃቱ ደግሞ ክምር ምደባ (Mass Assignment) በመባል ይታወቃል።

መልመጃዎች

የሬይልስ ስልጠናን ለገዙ ሰወች በሙሉ የሁሉም የመልመጃ መልሶች እዚህ ላይ ይገኛሉ።

በአብነታዊ ተጠቃሚ ክፍል ላይ ያለውን የ‘ ስም ባሕሪን ወደ ሁለት ማለት ስም እና የአባት_ስም ወደተባሉ ባሕሪወች ለውጡ እና ከዚያ በአንድ ክፍትቦታ የተለዩ የስም እና የአባት ስምን የሚመስል አንድ ሙሉ_ስም የተባለ ዘዴን አክሉ። የምታክሉት የ ሙሉ_ስም ዘዴ የተጠየቃችሁትን አቀማመጥ ይይዝላችሁ ዘንድ፣ ቅሩጽ_ኤመልእክት ላይ የተጠቀምነውን ብልሃት ተጠቀሙ።
በአንድ ነጠላ ሰረዝ እና በአንድ ክፍትቦታ የተለያየ ስም እና የአባት ስምን የሚመስል አንድ ፍንትት_ስም የተባለ ዘዴን አክሉ።
ሙሉ_ስም.split ከ‘ ፍንትት_ስም.split('፣ ').reverse ጋር ተመሳሳይ እንደሆነ አረጋግጡ።

4.5 ማጠቃለያ

የሩቢ ቋንቋ አጠቃላይ እይታችን እዚህ ላይ ይደመደማል። በምዕራፍ 5 ውስጥ እሱን የማሳያ አፕልኬሽኑን በማበልጸግ ስራ ላይ ማዋል እንጀምራለን፡፡

ከክፍል 4.4.5 በኋላ የ‘ አብነታዊ_ተጠቃሚ.rb ፋይልን ስለማንጠቀምበት፣ የሚከተለውን ትእዛዝ በመጠቀም ከአፕልኬሽናችሁ እንድታስወግዱት ስል ሃሳቤን አቀርባለሁ:-

$ rm አብነታዊ_ተጠቃሚ.rb

ከዚያ ሌሎቹን ለውጦች ከዋናው የኮድ ምንጪ ማከማቻ ጋር አቀላቅሉ እና ወደ ዋና‘ው (main) ቅርንጫፍ ካዋሃዳችሁ በኋላ ወደ ጊትሃብ ግፉ እና ከዚያ ወደ ሃረኩ አሰማሩ:-

$ git commit -am "አንድ የሙሉ አርዕስት (mulu_arest) ረጅን ማከል"
$ git checkout main
$ git merge  የሬይልስ-ጣዕም-ያለው-ሩቢ

እውነታውን ለመፈተሽ ያህል፣ ከመግፋት ወይም ከማሰማራት በፊት የፈተና ስብስቡን ማስኬዱ ሊዘወተር የሚገባው አንድ ጥሩ ልማድ ነው:-

$ rails test

ከዚያ ወደ ጊትሃብ ግፉት:-

$ git push

በመጨረሻም ወደ ሃረኩ አሰማሩት:-

$ git push heroku

4.5.1 በዚህ ምዕራፍ ውስጥ የተማርናቸው ነገሮች:-

ሩቢ የሆሄወችን ሃረጎች ለማንቀሳቀስ ብዙ ዘዴዎች እንዳሉት፣
በሩቢ ውስጥ ያለው ነገር ሁሉ ቁስ እንደሆነ፣
ሩቢ በ‘በይን (def) ቁልፍቃል በኩል ዘዴ መበየንን እንደሚደግፍ፣
ሩቢ በ‘ክፍል (class) ቁልፍቃል በኩል ክፍል መበየንን እንደሚደግፍ፣
የሬይልስ ትይታወች የማይለዋዋጥ ሃ.ጽ.መ.ቋን ወይም ክት ሩቢን ሊይዙ እንደሚችሉ፣
አብሮገነቦቹ የሩቢ የውሂብ መዋቅሮች ድርድርን፣ ከክሳቦችን እና ተርታወችን እንደሚያጠቃልሉ፣
የሩቢ ጥምሮች (ከሌሎች ነገሮች በተጨማሪ) በሚቆጠሩ የውሂብ መዋቅሮች ላይ ተፈጥሯዊ ድግግሞሽን የሚፈቅዱ እና እንደ ልብ የሚገሩ መስራቾች እንደሆኑ፣
ወካዮች እንደ ሃረጎች መሰየሚወች እንደሆኑ፤ ነገር ግን ልክ እንደ ሃረጎች ተጨማሪ መዋቅር እንደለላቸው፣
ሩቢ የቁስ መወራረስን እንደሚደግፍ፣
አብሮገነቡን የሩቢ ክፍልን መክፈት እና ማሻሻል እንደሚቻል እና
“ተረተ” የሚለው ቃል አንድ አንሶላ እንደሆነ ተምረናል።

1. ከሩቢ ጋር የበለጠ የትውውቅ ስረዓትን ተከትሎ የሚሰራ ዕውቀትን ለመገብየት በሩቢ ላይ መሰረታዊ እውቀትን ለማግኘት የሚያስፈልገውን ተማርን ተመልከቱ።

2. “አ.ፕ.በ” የአፕልኬሽን ፕሮግራም በይነገጽ:- ከአንድ ሶፍትዌር ስርዓት ጋር ለመግባባት የሚያገለግል የዘዴዎች እና የደንቦችን ስብስብ የያዘ አንድ ረቂቅ ንጣፍ (Abstraction Layer) ነው፡፡ እኛ አበልጻጊዎቹ ስለ ፕሮግራሙ ውስጣዊ አሰራር ማወቅ አያስፈልገንም፡፡ እኛ ማወቅ ያለብን ከውጪ በኩል ማለት ለህዝብ የተጋለጠውን የአፕልኬሽኑን በይነገጽ (አ.ፕ.በ) ብቻ ነው። በዚህ ሁኔታ ላይ የ‘ቅጠሉህ_አገናኝ_መለያ (stylesheet_link_tag) ዘዴ “እንዴት ተሰራ?” ከማለት ይልቅ እኛ እንዴት እንደሚሰራ ብቻ ማወቁ ያስፈልገናል ማለት ነው፡፡

3. አብሮገነብ ሥልት (Built-in Function) ማለት ከአፕልኬሽኑ ወይም ከመዋቅሩ ጋር አብሮ የተሰራ ወይም በውስጡ የተካተተ ሥልት ማለት ነው።

4. አንድ ረጅ ለአንድ የተለየ መቆጣጠሪያ የተወሰነ ከሆነ ረጂውን በተዛማጁ የረጅ ፋይል ውስጥ ማስቀመጥ ይኖርባችኋል፤ የቋሚ ገጾች መቆጣጠሪያ ረጂዎች አብዛኛውን ጊዜ በ‘አፕ/ረጅወች/ቋሚ_ገጾች_ረጅ.አርቢ (app/helpers/quami_getss_helper.rb) ውስጥ ይገባሉ። በእኛ ሁኔታ ላይ የ‘ሙሉ_አርዕስት (mulu_arest) ረጅው እና የ‘አብዛ (abza) ረጅው፣ በሁሉም የጣቢያው ገጾች ውስጥ ጥቅም ላይ ይውላሉ ብለን እንጠብቃለን፤ ሬይልስም ለእንደዚህ አይነቱ ፋይል፣ አንድ የተለየ የረጅ ፋይል አለው እሱም አፕ/ረጅወች/አፕልኬሽን_ረጅ.አርቢ (app/helpers/application_helper.rb) ነው።

5. እኔ በአጠቃላይ ሁሉም የተሟላ እንዲሆን ብየ የፈተና ስብስቡን አስኪጀዋለሁ፣ ነገር ግን በክፍል 3.6.2 እንደተገለጸው፡ እኔ በግሌ ብዙውን ጊዜ የምጠቀመው ጋርድን ብቻ ነው።

6. ናኖ (nano) የተባለው የጽሑፍ አርታኢ ለጀማሪዎች ቀላል ነው፣ እኔ ግን ሁልጊዜ ለእንደዚህ ዓይነቱ አጪር ስራ በምትኩ ቪምን እጠቀማለሁ፡፡ አነስተኛ የቪም ማሳያን™ ለመማር ይሄንን አገናኝ ማለት በጽሑፍ አርታኢ ላይ መሰረታዊ እውቀትን ለማግኘት የሚያስፈልገውን ተማርን ጎብኙ።

7. የ “foo” እና የ “bar” አመጣጥን ለማወቅ እና በተለይ “foobar” ከ “FUBAR” ጋር ግንኙነት እንደለለው ለመረዳት የጃርገን ፋይል መግቢያ ላይ “foo” ‘ን ተመልከቱ።

8. ፐርልን ወይም ፒኤችፒን የሚያውቁ አበልጻጊዎች፣ በቀጥታ ይህንን አገባብ እዚህ ውስጥ:- "foo $bar" ካለው የዶላር ምልክት የተለዋዋጪ ውስጠገምት ጋር ማነጻጸር አለባቸው፡፡

9. በቀረው በዚህ ምዕራፍ ውስጥ አልፎ አልፎ በድንገት ሥልት (Function) እና ዘዴ (Method) እያልኩ ስለመቀያየሬ አስቀድሜ ይቅርታ እላለሁ። በሩቢ ውስጥ ሁለቱም አንድ ዓይነት ናቸው። ሁሉም ሥልቶች ዘዴዎች፣ ሁሉም ዘዴዎች ደግሞ ሥልቶች ናቸው። ምክንያቱም ሁሉም ነገር በሩቢ ውስጥ ቁስ ስለሆነ ነው።

10. አሁንም ያልተረዳነው አንድ ነገር አለ፣ ይህም ሬይልስ እንዴት ሁሉንም ነገር በአንድ ላይ እንደሚያይዘው ነው፤ ማለት ዓ.አ.ሃ.አወችን ከተግባሮች ጋር እንዴት እንደሚያመላክታቸው፣ የ‘ሙሉ_አርዕስትን (mulu_arest) እና የ‘አብዛ (abza) ረጅን እንዴት በትይታዎች ውስጥ እንዲኖሩ እንደሚያደርጋቸው ወዘተረፈ ናቸው። ይህ አንድ አስደሳች ርዕሰ ጉዳይ ስለሆነ እኔም በበለጠ እንድትመለከቱት ምክሬን እለግስላችኋለሁ፣ ነገር ግን ሬይልስን በሚጠቀሙበት ጊዜ ሬይልስ በትክክል እንዴት እንደሚሰራ ማወቁ አስፈላጊ አይደለም።

11. በዚህ ፈንታ የሃረግ ውስጠገምትን ለመጠቀም ቃጥታችሁ ይሆናል፤ (በእርግጥም፣ ከዚህ በፊት በነበሩት በሁሉም የስልጠና ስሪቶች ላይ የተጠቀምነው ዘዴ ያንን ነበር።) ነገር ግን አቅርብ (provide) ላይ የሚደረግ አንድ ጥሪ፣ ሃረግን ወደ አንድ የተለመደ ዓይነት ሃረግ ከመቀየር ይልቅ፣ ወደ አንድ አስተማማኝየግጪት-መከላከያ (SafeBuffer) ቁስ ነው ሚቀይረው። ተርጉሞ በአንድ ማሳያ ዝግጁገጽታ ውስጥ ካስገባ በኋላ፣ ከማንኛውንም የገባ ሃ.ጽ.መ.ቋ ያስመልጥ እና እንደዚህ አይንቱን አርዕስት “እርዳታ’ው እየመጣ ነው Help’s on the way” ወደ “Help&#39;s on the way” ይቀይረዋል። (በዚህ አጋጣሚ ይህንን አስፈላጊ ጉዳይ ስላመለከቱን ክቡር አንባቢ ጀርሚ ፍሌችማንን ላመሰግናቸው እወዳለሁ።)

12. እዚህ ጋር የተጠቀምነው የ‘ሁለተኛ (second) ዘዴ የሩቢ ክፍል አይደለም፣ ነገር ግን በሬይልስ ተጨምሯል። በዚህ ጊዜ የሚሰራውም የሬይልስ ሰሌዳው የሬይልስ ቅጥያዎችን ራሱ በራስሰር ሩቢ ውስጥ ስለሚያካትታቸው ነው።

13. የሰፈር ተለዋዋጪ (Local Variable):- ማለት ባንድ ቦታ ላይ ብቻ የተወሰነ ተለዋዋጪ ማለት ነው።

14. በሌላ በኩል ፕሮግራም የሚያደርጉ ኪኢላወች ጥምሮች ድምዳሜወች (Closures) መሆናቸውን በማወቃቸው የሚጠቀሙት ጥቅም ሊኖር ይችላል፣ ማለት አንድ አጪር ስም-አልባ ሥልት ከውሂብ ጋር ማያያዛቸውን ያውቃሉ።

15. በምዕራፍ 1 ላይ እንደተጠቀሰው፣ በዚህ ሁኔታ ላይ ይሄ ኮድ:- ('a'..'z').to_a.sample(8).join በይበልጥ ጥብቅብቅ ያለ አንድ አይነት ውጤትን ያስገኛል።

16. በሩቢ 1.9 እና ከዚያ በኋላ ያሉት የሩቢ ስሪቶች ላይ ተርታወች ወደ ውስጣቸው የሚገቡትን አባላት ልክ በገቡበት ተርታ መሰረት በትክክል በእርግጠኛነት ያስቀምጧቸዋል፣ ነገር ግን በአንድ የተለየ ተርታ አቀማመጥ ላይ እምነት መጣሉ አላዋቂነት ነው።

17. ወካዮች ትንሽ የሆነ ጓዝን ስለያዙ እነሱን እርስ በርስ ማነጻጸር ቀላል ነው። ሃረጎች ሆሄ በሆሄ መነጻጸር አለባቸው። በሌላ በኩል ወካዮችን ሁሉንም በአንድ ጊዜ ማነጻጸር ይችላል። ይህም ለተርታ ቁልፎች መጠቀሚያነት ተስማሚ እንዲሆኑ ያደርጋቸዋል።

18. በእውነቱ በ‘ፒ (p) እና በ‘አስቀምጥ (puts) ዘዴ መሃል ግልጽ ልዩነት አለ። ይህም የ‘ፒ (p) ዘዴ የቁስ ምላሽን ሲያትም የ‘አስቀምጥ (puts) ዘዴ ግን ሁልጊዜ ምንም‘ን (nil) ይመልሳል። (ይህንን ላመላከቱት ክቡር አንባቢ ካታርዜና ሲዌክ ምስጋና ይግባቸው እላለሁ።)

19. አዲስመስመር ማለት በአንድ መስመር ላይ፣ መጨረሻ ላይ የሚመጣው ነገር ማለት ነው፤ ስለዚህም በአዲስመስመር እንጀምራለን፡፡ አዲስመስመር በክፍል 4.2.1.1 እንደተጠቀሰው፣ በተለምዶ በ \n ሆሄ ይወከላል፡፡

20. ለምሳሌ:- በምስል 1.12 ላይ ከተመለከታችሁ ምስሉ ላይ በቀኝ በኩል የሚታየውን ቀጥ ያለ መስመር በናንተ የጽሑፍ አርታኢ ላይ ማድረግ ትችላላችሁ፣ እዚያ ላይ የምታዩት ቀጥ ያለ መስመር 80 ሆሄወችን ብቻ ወደ ጎን እንዲይዝ ያደርጋል። የዳመና ቅ.ማ.አው ይህንን በተፈጥሮው ያከናውናል (ክፍል 1.1.1)፡፡ (በምስል 1.12 ላይ ያለው ምስል ላይ መስመሩ በደንብ ላይታያችሁ ይችላል።) ሰብላይም የተባለውን የጽሑፍ አርታኢ የምትጠቀሙ ከሆነ ግን እንደሚመለከተው ማድረግ ትችላላችሁ:- View > Ruler > 78 or View > Ruler > 80።

21. እነዚህ ውጤቶች እናንተ ከምትጠቀሙበት የሩቢ ስሪት አንጻር ሊለያዩ ይችላሉ፡፡ ይህ ምሳሌ ሩቢ 1.9.3 ወይም ከዚያ በላይ የሆነ የሩቢ ስሪትን እየተጠቀማችሁ እንደሆነ ይገምታል፡፡

22. በዚህ ስርዓተ-መዓረግ ውስጥ እያንዳንዱ ክፍል ምን እንደሚያደርግ ማወቅ አያስፈልጋችሁም። እኔኳ ራሴ እ.ኤ.አ. ከ 2005 ጀምሬ በሬይልስ እየሰራሁ ሁሉ ነገር ምን እንደሚያደርግ አላውቅም። ይህ ማለት (ሀ) እኔ ሙሉ በሙሉ ብቃት የለኝም ወይም (ለ) ሁሉንም ውስጠ አሰራር ሳያውቁ ብቃት ያለው የሬይልስ አበልጻጊ ሊሆኑ ይችላሉ፡፡ የሁለታችንም (ማለት ያንተ/ች የአንባቢው/ዋ እና የኔ) ምክንያት የኋለኛው እንዲሆን ተስፋ አደርጋለሁ፡፡

ማንበቡን ይቀጥሉ