Ruby CLI प्लेग्राउंड ऑनलाइन

ब्राउज़र-आधारित Ruby CLI: बिना सेटअप के कोड टेस्ट करें, डिबग करें और सिंटैक्स सीखें।

संस्करण

नमूना

🚀 226,578 कुल निष्पादन (197 इस महीने)

👨‍💻 प्रैक्टिकल Ruby कोर्स से मास्टरी हासिल करें

💎 इस रूबी ऑनलाइन एक्ज़ीक्यूटर के बारे में

CodeUtility Ruby Executor आपको अपने ब्राउज़र में तुरंत रूबी कोड लिखने, चलाने और टेस्ट करने देता है - किसी इंस्टॉलेशन या सेटअप की ज़रूरत नहीं। यह सुरक्षित, अलग-थलग (आइसोलेटेड) वातावरण में वास्तविक Ruby इंटरप्रिटर्स पर चलता है, और 2.7, 3.1, तथा 3.2 वर्ज़न को सपोर्ट करता है।

चाहे आप Ruby की मूल बातें अभ्यास कर रहे हों, एल्गोरिद्म टेस्ट कर रहे हों, या ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग सीख रहे हों - यह टूल तुरंत फीडबैक के लिए एक सरल और इंटरैक्टिव कंसोल प्रदान करता है।

आप इससे Ruby सिंटैक्स एक्सप्लोर कर सकते हैं, जेम्स (gems) के साथ खेल सकते हैं, या बिना लोकल एनवायरनमेंट कॉन्फ़िगर किए छोटे स्निपेट्स डिबग कर सकते हैं। यह सीखने वालों, बैकएंड डेवलपर्स, और Ruby-आधारित लॉजिक के साथ प्रयोग करने वाले किसी भी व्यक्ति के लिए आदर्श है।

सभी एक्ज़ीक्यूशन सैंडबॉक्स्ड वातावरण में प्रोसेस होते हैं ताकि वास्तविक Ruby व्यवहार बनाए रखते हुए सुरक्षा और विश्वसनीयता सुनिश्चित की जा सके।

💡 इस टूल का उपयोग कैसे करें

1. एडिटर के ऊपर दिए ड्रॉपडाउन से Ruby वर्ज़न चुनें (2.7, 3.1, या 3.2)।
2. अपना Ruby कोड एडिटर एरिया में लिखें या पेस्ट करें।
3. चलाएँ पर क्लिक करें ताकि Ruby कोड चले और नीचे कंसोल में आउटपुट दिखे।
4. रन के दौरान रोकें बटन दिखाई देगा - प्रक्रिया को बीच में रोकने के लिए इस पर क्लिक करें।
5. कोड ठीक करें का उपयोग करके सिंटैक्स या इंडेंटेशन की समस्याएँ अपने-आप सुधारें।
6. ठीक करने के बाद सुधार बटन दिखाई देगा - हाल के कोड फिक्सेज़ देखने के लिए इसे क्लिक करें।
7. आप किसी फ़ाइल से कोड अपलोड कर सकते हैं या एडिटर से अपना वर्तमान कोड डाउनलोड कर सकते हैं।
8. सुरक्षा और निष्पक्षता हेतु हर रन अधिकतम 20 सेकंड तक सीमित है।

🧠 सुझाव: Ruby वातावरण में सामान्य स्टैंडर्ड लाइब्रेरी शामिल हैं - कलेक्शंस, क्लासेस और मेथड्स के साथ सीधे ब्राउज़र में प्रयोग करने के लिए उत्तम।

💡 शुरुआती के लिए रूबी बेसिक्स गाइड

1. वेरिएबल्स और कॉन्स्टेंट्स घोषित करना

Ruby डायनामिकली टाइप्ड है। कॉन्स्टेंट्स बड़े अक्षरों से शुरू होते हैं और बदले जाने के लिए नहीं होते।

x = 10
pi = 3.14
name = "Alice"
is_active = true

MAX_USERS = 100
APP_NAME = "CodeUtility"

2. कंडीशनल्स (if / case)

कंट्रोल फ्लो के लिए if, elsif, else, या case का उपयोग करें।

x = 2
if x == 1
  puts "एक"
elsif x == 2
  puts "दो"
else
  puts "अन्य"
end

case x
when 1
  puts "एक"
when 2
  puts "दो"
else
  puts "अन्य"
end

3. लूप्स

while, until, या each जैसे इटरेटर्स का उपयोग करें।

i = 0
while i < 3
  puts i
  i += 1
end

[1, 2, 3].each do |n|
  puts n
end

4. एरे

एरे क्रमबद्ध तत्वों की सूचियाँ रखते हैं। इन्हें इंडेक्स से एक्सेस करें।

fruits = ["apple", "banana", "cherry"]
puts fruits[0]
puts fruits.length

5. एरे संचालन

एरे के साथ काम करने के लिए push, pop, slice, और reverse का उपयोग करें।

fruits.push("kiwi")
fruits.pop
puts fruits[1..2]
puts fruits.reverse

# एरे कॉम्प्रिहेंशन
squares = (1..5).map { |x| x * x }
puts squares

6. कंसोल इनपुट/आउटपुट

gets.chomp से इनपुट पढ़ें और आउटपुट के लिए puts/print का उपयोग करें।

print "अपना नाम दर्ज करें: "
name = gets.chomp
puts "नमस्ते, #{name}"

7. फ़ंक्शंस

def का उपयोग करके फ़ंक्शन परिभाषित करें। आप आर्ग्युमेंट्स पास कर सकते हैं और वैल्यूज़ रिटर्न कर सकते हैं।

def greet(name)
  "नमस्ते, #{name}"
end

puts greet("Alice")

8. हैशेज़

हैश कुंजी-मूल्य (key-value) जोड़े होते हैं, जैसे डिक्शनरी या मैप।

person = { "name" => "Bob", "age" => 25 }
puts person["name"]

# सिंबल कुंजियाँ
person = { name: "Alice", age: 30 }
puts person[:name]

9. अपवाद प्रबंधन

begin-rescue-end का उपयोग करके अपवाद पकड़ें और त्रुटियों को सुव्यवस्थित ढंग से संभालें।

begin
  raise "कुछ गलत हो गया"
rescue => e
  puts e.message
end

10. फ़ाइल I/O

File मेथड्स या IO क्लासेस का उपयोग करके फ़ाइलें पढ़ें और लिखें।

File.write("file.txt", "हेलो फ़ाइल")
content = File.read("file.txt")
puts content

11. स्ट्रिंग मैनिपुलेशन

Ruby स्ट्रिंग्स कई मेथड्स सपोर्ट करती हैं: length, gsub, split, आदि।

text = " Hello World "
puts text.strip
puts text.upcase
puts text.gsub("Hello", "Hi")
puts text.split

12. क्लासेस और ऑब्जेक्ट्स

Ruby पूरी तरह ऑब्जेक्ट-ओरिएंटेड है। कंस्ट्रक्टर परिभाषित करने के लिए initialize का उपयोग करें।

class Person
  def initialize(name)
    @name = name
  end

  def greet
    "हाय, मैं #{@name} हूँ"
  end
end

p = Person.new("Alice")
puts p.greet

13. रेफरेंसेज़ (ऑब्जेक्ट म्यूटेशन)

सभी वेरिएबल्स ऑब्जेक्ट्स के रेफरेंस रखते हैं। किसी फ़ंक्शन के अंदर ऑब्जेक्ट में बदलाव मूल ऑब्जेक्ट को प्रभावित करता है।

def modify(arr)
  arr << "changed"
end

data = ["original"]
modify(data)
puts data.inspect  # ["original", "changed"]