রুবিতে অ্যারে তৈরি এবং ছিঁড়ে ফেলার জন্য স্প্ল্যাট ব্যবহার করা

রুবি সম্পর্কে আমি যে জিনিসগুলি পছন্দ করি তার মধ্যে একটি হল এর বৈশিষ্ট্যগুলির গভীরতা। আপনি একটি অপারেটর ব্যবহার করতে পারেন, কিন্তু একটু খনন করুন এবং আপনি দেখতে পাবেন যে আপনি কেবল এটি করতে সক্ষম তার পৃষ্ঠটি স্ক্র্যাচ করছেন। নম্র স্প্ল্যাট অপারেটর (* এবং ** ) একটি দুর্দান্ত উদাহরণ।

আপনি সম্ভবত "ক্যাচ-অল" আর্গুমেন্টের জন্য স্প্ল্যাট ব্যবহার করেছেন। এবং এটিই বেশিরভাগ লোকেরা তাদের জন্য ব্যবহার করে।

def go(x, *args)
  puts args.inspect
end

go("a", "b", "c")

আপনি যদি নতুন কীওয়ার্ড আর্গুমেন্ট সিনট্যাক্স ব্যবহার করেন, তাহলে একটি ডবল স্প্ল্যাট ব্যবহার করুন:

def go(**params)
  puts params.inspect
end

go(x: 100, y: 200)

এটি দরকারী, তবে আপনি আরও অনেক কিছুর জন্য স্প্ল্যাট ব্যবহার করতে পারেন। আসুন ডুব দেওয়া যাক!

একাধিক আর্গুমেন্ট পাস করার জন্য একটি অ্যারে ব্যবহার করা

পদ্ধতিগুলি সংজ্ঞায়িত করার সময় আপনি কেবল স্প্ল্যাটগুলি ব্যবহার করতে পারবেন না, তবে পদ্ধতিগুলি কল করার সময় আপনি সেগুলি ব্যবহার করতে পারেন। তারা আপনাকে একাধিক আর্গুমেন্ট আশা করে একটি ফাংশনে একটি অ্যারে পাস করতে দেয়। অ্যারের প্রথম আইটেমটি প্রথম আর্গুমেন্টে পরিণত হয়, দ্বিতীয় আইটেমটি দ্বিতীয় আর্গুমেন্টে পরিণত হয় ইত্যাদি৷

def go(x, y)
end

point = [12, 10]
go(*point)

এবং ভুলে যাবেন না যে আপনি নতুন স্টাইলের কীওয়ার্ড আর্গুমেন্টের জন্য একটি ডাবল স্প্ল্যাট ব্যবহার করতে পারেন:

def go(x:, y:)
end

point = { x: 100, y: 200 }
go(**point)

স্প্ল্যাটটির শেষে যেতে হবে না

যদিও যুক্তি তালিকার শেষে আপনার স্প্ল্যাটেড আর্গুমেন্টগুলি রাখা সাধারণ, তবে এটির প্রয়োজন নেই এমন কোনও আইন নেই।

আপনি আর্গুমেন্ট তালিকার যে কোন জায়গায় স্প্ল্যাট রাখতে পারেন।

def go(x, *args, y)
  puts x # => 1
  puts y # => 5
  puts args.inspect # => [2,3,4]
end

go(1, 2, 3, 4, 5)

অ্যারে ধ্বংস

আর্গুমেন্ট সহ এই সমস্ত কৌশলগুলি কেবল অ্যারে ধ্বংসের একটি বিশেষ ক্ষেত্রে।

আপনি যদি "অ্যারে ডিস্ট্রাকচারিং" শব্দটির সাথে পরিচিত না হন তবে এর সহজ অর্থ হল একটি অ্যারেকে পৃথক আইটেমগুলিতে ভেঙে ফেলা। এটা এই মত দেখায়:

a, b = [1, 2]
puts a
# 1
puts b
# 2

এটি ভাল কাজ করে কিন্তু অ্যারের প্রতিটি আইটেম ধরে রাখার জন্য একটি পরিবর্তনশীল নির্দিষ্ট করতে এটি একটি ব্যথা হতে পারে। স্প্ল্যাট অপারেটর এটির চারপাশে পায় - মূলত ওয়াইল্ডকার্ডের মতো কাজ করে। কয়েকটা উদাহরণ দেখে নেওয়া যাক।

একটি অ্যারে থেকে প্রথম আইটেম পপ করা হচ্ছে

মাঝে মাঝে মূল অ্যারে পরিবর্তন না করে একটি অ্যারের প্রথম আইটেমটি পপ করতে সক্ষম হওয়া দরকারী। এই উদাহরণটি তাই করে।

first, *remainder = [1, 2, 3, 4, 5]
first
# => 1
remainder
# => [2, 3, 4, 5]

আপনি যদি প্রথম আইটেমটি চান তবে বাকি অ্যারেটি না চান, আপনি সিনট্যাক্স ব্যবহার করতে পারেন:

first, * = [1, 2, 3, 4, 5]
first
# => 1

শেষ আইটেমটি পপ করা হচ্ছে

শুরুর পরিবর্তে অ্যারের শেষ থেকে আইটেমটি টানতে, শুরুতে স্প্ল্যাটটিকে এইভাবে আটকে দিন:

*prefix, last = [1, 2, 3, 4, 5]
last
# => 5
prefix
# => [1, 2, 3, 4]

আবার, যদি আমরা একটি নির্দিষ্ট পরিবর্তনশীল না চাই, তাহলে আমাদের এটি নির্ধারণ করতে হবে না:

একটি অ্যারের প্রথম এবং শেষ n আইটেমগুলি পান

আপনি যদি স্প্ল্যাট অপারেটরটিকে মাঝখানে রাখেন, তাহলে আপনি অ্যারের প্রতিটি প্রান্ত থেকে একটি নির্বিচারে আইটেম টেনে আনতে পারেন৷

first, *, last =  [1, 2, 3, 4, 5]
first
# => 1
last
# => 5

সীমাবদ্ধতা

অ্যারে ডিস্ট্রাকচারিং-এ স্প্ল্যাট অপারেটর ব্যবহার করার সময়, আপনাকে এখনও অ্যারের শুরু এবং শেষের সাপেক্ষে অ্যারে আইটেমের অবস্থান নির্দিষ্ট করতে হবে। তাই এটি একটি দীর্ঘ অ্যারের মাঝখানে থেকে আইটেম নিষ্কাশন করার জন্য সেরা টুল নয়৷

এছাড়াও, আমি ডাবল-স্প্ল্যাট (**) ব্যবহার করে কোনও দুর্দান্ত কৌশল খুঁজে পাচ্ছি না ) অপারেটর হ্যাশ সঙ্গে জগাখিচুড়ি. খোঁড়া!

অ্যারে নির্মাণ করা হচ্ছে

স্প্ল্যাট অপারেটরটি কেবল অ্যারেগুলিকে ধ্বংস করার জন্যই নয় বরং তাদের নির্মাণের জন্যও কার্যকর।

নিম্নলিখিত উদাহরণে, আমরা দুটি অ্যারে যুক্ত করতে স্প্ল্যাট ব্যবহার করি।

[*[1,2], *[3,4]]
=> [1, 2, 3, 4]

এটি [[1, 2], [3,4]].flatten এর সমতুল্য .

এটি যদি গল্পের শেষ হয় তবে এটি খুব কার্যকর হবে না। কিন্তু স্প্ল্যাটের আরেকটি অদ্ভুত ক্ষমতা আছে। এটি বুদ্ধিমত্তার সাথে বস্তুগুলিকে অ্যারেতে বাধ্য করতে পারে।

# Usually `*thing` wraps `thing` in an array
x = *"hi mom"
# => ["hi mom"]

# ...unless it's nil
x = *nil
# => []

# Arrays are passed through unchanged
x = *[1,2,3]
# => [1, 2, 3]

# But hashes are converted to arrays
x = *{a: 1}
# => [[:a, 1]]

এটি আমাদেরকে এক টন ম্যানুয়াল টাইপ জবরদস্তি না করে অ্যারে তৈরির জন্য একটি সরঞ্জাম দেয়।

উদাহরণস্বরূপ, কল্পনা করুন যে আপনি কিছু কনফিগারেশন সিস্টেমের জন্য স্ট্রিংগুলির একটি অ্যারে সংগ্রহ করছেন। সাধারণত আপনি চান:

অ্যারে বিদ্যমান কিনা তা পরীক্ষা করুন, এবং না থাকলে তা শুরু করুন
কেউ একটি স্ট্রিং যোগ করার চেষ্টা করলে বুদ্ধিমানের সাথে সাড়া দিন, শুধুমাত্র একটি স্ট্রিং নয়

স্প্ল্যাট অপারেটর আমাদের এটি বিনামূল্যে দেয়:

# Your configuration hash may or may not have
# an existing :ignore array. 
config = { }

# The callback function might return an array
# or it might return a single item. 

def add_ignores
  "scoundrels" # could also be an array like ["scoundrels", "cads", "ne'er-do-wells"]
end

# This is where the magic happens. No matter what you 
# start with you get an array of things to ignore. 
config[:ignore] = [*config[:ignore], *add_ignores()]

এটাই

আমি আশা করি এটা স্পষ্ট যে আপনি সম্ভবত আপনার বিদ্যমান অ্যারে-ম্যানিপুলেশন কোডের সমস্ত স্প্ল্যাট ব্যবহার করতে পুনরায় লিখতে যাবেন না। এগুলি সর্বদা সঠিক সরঞ্জাম নয় এবং ঘন ঘন ব্যবহার করার সময় তারা কোডটি পড়া কঠিন করে তুলতে পারে।

যাইহোক, কখনও কখনও একটি অ্যারে স্প্ল্যাট কৌশল আপনার প্রয়োজন ঠিক কি. আমি আশা করি, যখন সেই সময় আসবে, আপনি একটি চেষ্টা করবেন। :)