راهنمای سریع متدهای آرایه در Ruby — از صفر تا صد

۹۲ بازدید
آخرین به‌روزرسانی: ۱۲ مهر ۱۴۰۲
زمان مطالعه: ۷ دقیقه
راهنمای سریع متدهای آرایه در Ruby — از صفر تا صد

در این مقاله راهنمای سریع متدهای آرایه در Ruby ارائه شده است و در آن تلاش شده همه موارد واقعاً مفید ذکر شوند. هر زمان که از یک متد آرایه استفاده می‌کنید، باید مطمئن شوید که مستندات آن را برای کسب اطلاعات بیشتر بررسی کرده‌اید. برای هر چه خلاصه‌تر ماندن این راهنما، مقادیر بازگشتی را در کامنت‌ها نوشته‌ایم. بنابراین "arr # -> "stuff به این معنی است که مقدار بازگشتی برای arr به صورت "stuff" است.

ایجاد آرایه

برای ایجاد یک آرایه خالی جدید از دستور زیر استفاده کنید:

1arr = []
2arr2 = Array.new

ایجاد آرایه جدید با مقادیر:

1arr_with_stuff = ["value", "separated by comma"] 
2arr_with_stuff2 = Array.new(["a", "b", "c"])
3range_to_arr = (1..9).to_a

ایجاد آرایه جدید با مقادیر تکراری: برخی اوقات لازم است که آرایه‌ای با چند مقدار تکراری داشته باشیم:

1arr = Array.new(5, " ")
2# -> [" ", " ", " ", " ", " "]

ایجاد آرایه‌ای از رشته‌ها با میانبر: با استفاده از میانبر w% می‌توانید یک آرایه از رشته‌ها بدون گیومه یا کاما بسازید:

1arr = %w(cat dog mouse 1 2)
2# -> ["cat", "dog", "mouse", "1", "2"]

تبدیل رشته به یک آرایه: عبارت split# موجب افراز یک رشته به یک آرایه می‌شود.

این دستور یک آرگومان به صورت رشته می‌گیرد تا تعیین شود آیتم‌های آرایه چگونه باید افراز شوند. در صورت عدم تعیین این گزینه از فاصله استفاده خواهد شد. برای این که هر کاراکتر به یک آیتم مجزا در آرایه حاصل تبدیل شود، باید آرگومانی به صورت "" ارسال شود:

1arr = "this is a string”.split 
2arr # -> ["this", "is", "a", "string"] 
3"hey".split("") # -> ["h","e","y"]

نکته اضافی - تبدیل یک آرایه به یک رشته: با استفاده از join# می‌توان کاری در جهت عکس انجام داد و یک رشته جدید از آیتم‌های یک آرایه ساخت. این دستور یک رشته به عنوان آرگومان اختیاری می‌گیرد که بین مقادیر مختلف قرار می‌دهد:

1arr = %w(cat dog mouse)
2str = arr.join(", ")
3str # -> "cat, dog, mouse"
4str2 = arr.join
5str2 #-> "catdogmouse"

خواندن/دریافت مقادیر

دریافت طول آرایه: length# و size# معادل هم هستند:

1arr = %w(cat dog mouse cow pig)
2arr.length # -> 5
3arr.size # -> 5

دریافت مقادیر یک اندیس:

1arr[0] # -> "cat"
2arr[1] # -> "dog"
3arr[100] # -> nil

دریافت اندیس یک مقدار با index#:

1arr.index("dog") # -> 1
2arr.index("asdaf") # -> nil

دریافت مقدار اندیس از انتها به ابتدا: می‌توان با استفاده از اعداد منفی از انتهای آرایه به سمت ابتدا حرکت کرد:

1arr[-1] # -> "pig"
2arr[-2] # -> "cow"
3arr[-100] # -> nil

دریافت مقدار یک اندیس یا مقدار پیش‌فرض: fetch# مقدار موجود در یک اندیس را بازگشت می‌دهد یا آرگومان پیش‌فرض با مقدار بلوک کد را بازگشت خواهد داد:

1arr.fetch(0) # -> "cat"
2arr.fetch(-1) # -> "pig"
3arr.fetch(100) # -> raise a KeyError 
4arr.fetch(100, "nothing there") # -> "nothing there" 
5arr.fetch(100) { |key| "nothing at index #{key}" }
6# -> "nothing at index 100"

دریافت یک قطعه از آرایه: می‌توان از کاما یا بازه‌ها (ranges) استفاده کرد:

1arr = ["cat", "dog", "mouse", "cow", "pig"]
2arr[1,3] # -> ["dog", "mouse", "cow"]
3arr[1..3] # -> ["dog", "mouse", "cow"]
4arr[1...3] # -> ["dog", "mouse"]
5arr[1..-1] # -> ["dog", "mouse", "cow", "pig"]

بررسی وجود یک مقدار در آرایه با استفاده از ?include#:

1arr = %w(cat dog mouse)
2arr.include?("cat") # -> true   
3arr.include?("zzz") #-> false

افزودن و به‌روزرسانی مقادیر

تغییر یک مقدار در یک اندیس:

1arr = %w(cat dog mouse)
2arr[0] = "lynx"
3arr # -> ["lynx", "dog", "mouse"]

افزودن یک مقدار به انتهای یک آرایه: عملگر << به نام عملگر shovel نامیده می‌شود، اما می‌توانید از push# نیز استفاده کنید. این متدها آرایه اصلی را تغییر می‌دهند:

1arr = %w(cat dog mouse)
2arr << "cobra" 
3# returns changed array
4# -> ["cat", "dog", "mouse", "cobra"]
5arr.push("crow") 
6# returns changed array
7# -> ["cat", "dog", "mouse", "cobra", "crow"]
8# push can take multiple, << can't 
9arr.push("cow", "bee")
10# returns changed array
11# -> ["cat", "dog", "mouse", "cobra", "crow", "cow", "bee"]

افزودن یک مقدار به ابتدای آرایه با استفاده از unshift#:

1arr = %w(cat dog mouse)
2arr.unshift("clam") 
3# returns changed array
4# -> ["clam", "cat", "dog", "mouse"]
5arr.unshift("cow", "bee")
6# returns changed array
7# -> ["cow", "bee", "clam", "cat", "dog", "mouse"]

افزودن یک مقدار به میانه آرایه با استفاده از insert#:

1arr = %w(cat dog mouse)
2arr.insert(1, "cow")
3# returns changed array
4# -> ["cat", "cow", "dog", "mouse"]
5arr.insert(1, "bee", "pig")
6# returns changed array
7# -> ["cat", "bee", "pig", "cow", "dog", "mouse"]

حذف و پاک کردن مقادیر

برای حذف یک مقدار از آرایه از delete# استفاده می‌کنیم:

1arr = %w(cat dog mouse)
2arr.delete("cat") 
3# -> returns "cat"
4arr # -> ["dog", "mouse"]
5arr.delete("cat") 
6# -> returns nil
7arr # -> ["dog", "mouse"]
8arr.delete("whaaa?") { "not found" }   
9# -> "not found"
10# leave original alone by subtracting arrays
11# also lets you delete more than one item
12arr = %w(cat dog mouse pig cow)
13arr2 = arr - ["cat", "mouse"]
14arr2 # -> ["dog", "pig", "cow"]
15arr # -> ["cat", "dog", "mouse", "pig", "cow"]

برای حذف عنصری بر اساس اندیس از delete_at# به صورت زیر استفاده می‌کنیم:

1arr = %w(cat dog mouse)
2arr.delete_at(0) # -> "cat"
3arr # -> ["dog", "mouse"]
4arr.delete_at(100) # -> nil

برای حذف آخرین مقدار از pop# استفاده می‌کنیم:

1arr = %w(cat dog mouse)
2arr.pop # -> "mouse"
3arr # -> ["cat", "dog"]
4arr.pop # -> "dog"
5arr.pop # -> "cat" 
6arr.pop # -> nil

برای حذف اولین مقدار از shift# استفاده می‌کنیم:

1arr = %w(cat dog mouse)
2arr.shift # -> "cat"
3arr # -> ["dog", "mouse"]
4arr.shift # -> "dog" 
5arr.shift # -> "mouse"
6arr.shift # -> nil

تغییر دادن ترتیب آرایه

آرایه را با استفاده از sort# می‌توان مرتب‌سازی کرد:

1arr_num = [4,12,9,1]
2arr_alpha = %w(ba aa cb bb)
3arr_num.sort # -> [1, 4, 9, 12]
4arr_alpha.sort # -> ["aa", "ba", "bb", "cb,"]
5# permanently change original arr
6arr_num.sort!
7arr_alpha.sort!

برای معکوس کردن ترتیب عناصر آرایه از reverse# استفاده می‌کنیم:

1arr = %w(first mid last)
2arr.reverse # -> ["last", "mid", "first"]
3arr # -> ["first", "mid", "last"]
4# permanently change original arr
5arr.reverse!
6# useful for sorting in reverse order
7arr.sort.reverse

برای تصادفی ساختن ترتیب عناصر آرایه از shuffle# و !shuffle# استفاده می‌کنیم. shuffle یک کپی از آرایه با عناصر تصادفی ایجاد می‌کند و !shuffle روی خود آرایه این کار را انجام می‌دهد:

1arr = [1,2,3,4]
2arr.shuffle # -> [2, 1, 3, 4]
3arr # -> [1, 2, 3, 4]
4arr.shuffle! # -> [4, 2, 1, 3]
5arr # -> [4, 2, 1, 3]

نکته اضافی - انتخاب یک مقدار تصادفی از آرایه: sample# یک مقدار تصادفی از یک آرایه بازگشت می‌دهد:

1[1,2,3,4].sample # -> 1
2[1,2,3,4].sample # -> 3

Each# و Map#

این دو متد همراه با نسخه‌های مختلفشان احتمالاً یکی از مهم‌ترین متدهای آرایه‌ای در Ruby هستند. این متدها هر دو روی حلقه تکرار می‌شوند، اما تفاوت اصلی آن‌ها این است که ‎#each همواره آرایه اصلی را بازگشت می‌دهد و ‎#Map یک آرایه جدید بازمی‌گرداند.

تعریف تکرار روی آرایه با استفاده از each#:

1arr = %w(a b c)
2arr.each do |val| 
3  puts "value is #{x}"
4end 
5# will put each value but return:
6# ["a", "b", "c"]

تعریف تکرار روی آرایه با یک اندیس به وسیله each_with_index#:

1arr = %w(a b c)
2arr.each_with_index do |val, idx| 
3  puts “index #{idx}: #{val}4end 
5# still returns:
6# ["a", "b", "c"]

ایجاد یک شیء جدید با each: عبارت each_with_object# یک متد مفید است که امکان افزودن یک شیء مفروض در طی هر تکرار را فراهم می‌سازد. در نهایت به جای بازگشت آرایه اصلی، این شیء بازگشت می‌یابد:

1arr = %w(a b c)
2arr.each_with_object({}) do |value, result|
3  result[value] = value.upcase
4end
5# returns: 
6# {"a"=>"A", "b"=>"B", "c"=>"C"}

همچنین می‌توانید از with_object# برای به هم متصل ساختن each_with_index# استفاده کنید. برای نمونه می‌توانید آرایه‌های صریح را سریعاً به شیءها تبدیل کنید:

1arr = %w(a b c)
2arr
3  .each_with_index
4  .with_object({}) do |(value, idx), result|
5    result[value.to_sym] = "I was index #{idx}"
6  end
7# returns: 
8# {
9#   "a"=>"I was index 0", 
10#   "b"=>"I was index 1", 
11#   "c"=>"I was index 2"
12# }

تعریف تکرار روی آرایه‌ها و ایجاد یک آرایه جدید با map#:

1arr = %w(a b c) 
2arr2 = arr.map do |value| 
3  “#{value}!!4end 
5arr2 # -> [ “a!!, “b!!, “c!!]
6arr # ->[ “a”, “b”, “c” ]

همچنان که در ruby رایج است، علامت ! به معنی این است که به جای بازگشت یک کپی، !map# آرایه اصلی را تغییر خواهد داد:

1arr = %w(a b c) 
2arr.map! do |value| 
3  “#{value}!!4end
5arr # -> [ “a!!, “b!!, “c!!]

map.with_index#: با زنجیره‌سازی چند with_index# می‌توان به اندیس دسترسی یافت. توجه کنید که map# و with_index# دو متد مجزا هستند که متفاوت از each_with_index# محسوب می‌شوند:

1arr = %w(a b c)
2arr.map.with_index do |value, idx|
3  "index #{idx} is '#{value}'"
4end
5#returns: 
6# [
7#   "index 0 is 'a'", 
8#   "index 1 is 'b'", 
9#   "index 2 is 'c'"
10# ]

متدهای مفید دیگر

بررسی خالی بودن آرایه با ?empty#:

1arr.empty? # returns true or false

الحاق (ترکیب) آرایه‌ها: توجه کنید که ترتیب اضافه شدن آرایه‌ها اهمیت دارد:

1arr1 = [1, 2, 3]
2arr2 = [4, 5, 6]
3arr3 = [7, 8, 9]
4# leaves originals alone 
5arr1 + arr3 + arr2
6# returns: 
7# [1, 2, 3, 7, 8, 9, 4, 5, 6]
8# if you want to permanently alter original 
9# use concat
10arr1.concat(arr2)
11arr1 # -> [1, 2, 3, 4, 5, 6]

بررسی وجود مقداری با شرط خاص: ?any# مقدار درست/نادرست بازگشت می‌دهد. زمانی نتیجه true است که دست کم یکی از آیتم‌های آرایه، شرط تعریف شده را داشته باشد و در غیر این صورت مقدار false بازگشت می‌یابد:

1arr = [1,2,3,4]   
2arr.any? do |num| 
3  num > 2   
4end      
5# returns true

بررسی وجود یک شرط برای همه یا هیچ کدام از آیتم‌ها: با استفاده از all# می‌توانیم بررسی کنیم که آیا تک‌تک آیتم‌های آرایه یک شرط خاص را دارند یا نه و ‎#none نیز عکس آن عمل می‌کند.

1arr = [1,2,3,4]   
2arr.all? do |num| 
3  num < 100
4end      
5# returns true
6# check for the reverse with none?
7arr = [1,2,3,4]   
8arr.none? do |num| 
9  num < 100
10end
11# returns false

یافتن مقدار نخست برای تطبیق شرط با find#:

1[1, 2, 3, 4].find do |num| 
2  num.even? 
3end 
4# returns 2

بازگشت همه مقادیری که حائز یک شرط خاص هستند با select#:

1[1, 2, 3, 4].select do |num| 
2  num.even? 
3end 
4# returns [2, 4]

اگر تنها تعداد آیتم‌هایی که یک شرط خاص را دارند برایتان مهم است، در این صورت می‌توانید از count# استفاده کنید. این متد صرفاً تعداد مقادیر را بازگشت می‌دهد:

1[1, 2, 3, 4, 5, 6].count do |num| 
2  num.even? 
3end 
4# returns 3

حذف عناصر تکراری یا مقدارهای nil: متد ‎#uniq موارد تکراری را از آرایه حذف می‌کند و متد ‎#copact نیز مقادیر تهی را پاک خواهد کرد. هر دو این متدها یک کپی از آرایه بازگشت می‌دهند. برای این که تغییرات روی آرایه اصلی اجرا شوند، می‌توانید به ترتیب از متدهای uniq!‎# یا !‎#compact استفاده کنید:

1[1, 2, 3, 1, 2, 4].uniq 
2# returns [1, 2, 3, 4]
3[1, nil, 2, nil, 3].compact
4# returns [1, 2, 3]

سخن پایانی

به این ترتیب به پایان این مقاله با موضوع معرفی متدهای آرایه Ruby می‌رسیم. توجه کنید که این مقاله شامل همه متدهای مرتبط با آرایه نیست و صرفاً انواع مهم‌تر فهرست شده‌اند.

اگر این مطلب برای شما مفید بوده است، آموزش‌های زیر نیز به شما پیشنهاد می‌شوند:

==

بر اساس رای ۰ نفر
آیا این مطلب برای شما مفید بود؟
اگر بازخوردی درباره این مطلب دارید یا پرسشی دارید که بدون پاسخ مانده است، آن را از طریق بخش نظرات مطرح کنید.
منابع:
itnext
نظر شما چیست؟

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *