उपयोगी String methods आणि bang (!) variants कोणते आहेत?

Question

Accepted Answer

Ruby strings मध्ये हेरफेर करण्यासाठी methods चा एक समृद्ध संच आहे, आणि बरेच दोन स्वरूपात येतात: एक सामान्य आवृत्ती (**नई** string परत करते) आणि एक **bang (`!`)** आवृत्ती (string **जागेवर** बदलते, मूळ mutate करते). या फरकाची समज शुद्धता आणि bugs टाळण्यासाठी महत्वाची आहे.

## सामान्य string methods

```ruby
"hello".upcase           # "HELLO"
"HELLO".downcase          # "hello"
"  hi  ".strip             # "hi" — remove surrounding whitespace
"hello".reverse           # "olleh"
"hello".length            # 5
"hello world".split(" ")  # ["hello", "world"]
["a", "b"].join("-")       # "a-b"
"hello".sub("l", "L")      # "heLlo" — replace FIRST
"hello".gsub("l", "L")     # "heLLo" — replace ALL (global)
"hello".include?("ell")    # true
"hello".start_with?("he")  # true
"hello".chars             # ["h", "e", "l", "l", "o"]
"42".to_i; "3.14".to_f      # convert to number
"Hi #{name}"               # interpolation
```

## महत्वाचे bang (!) फरक: जागेवर mutation

```ruby
str = "hello"

# normal version — returns a NEW string, original UNCHANGED
upper = str.upcase        # upper = "HELLO", but str is STILL "hello"
puts str                  # "hello" — unchanged

# BANG version — modifies the original IN PLACE (mutates it)
str.upcase!               # str is NOW "HELLO" — the original changed!
puts str                  # "HELLO"
```

**`!` (bang) versions मूळ string जागेवर mutate करतात**, तर non-bang versions नई string परत करतात आणि मूळ अपरिवर्तित सोडतात. हा एक गंभीर फरक आहे — जेव्हा आपण `upcase!` वापरता जेव्हा आपला मतलब `upcase` होता (किंवा उलट), मूळ सुधारित होते किंवा नाही हे बदलते, ज्यामुळे सूक्ष्म bugs होऊ शकतात.

## एक bang gotcha: कोणतेही बदल न झाल्यास nil परत येणे

```ruby
"hello".upcase!     # "HELLO"
"HELLO".upcase!     # nil! — bang methods return nil if NOTHING changed
# → don't chain off a bang method's return value carelessly
str.strip!&.upcase  # be careful — strip! returns nil if there was nothing to strip
```

एक सूक्ष्म gotcha: bang methods कोणतेही बदल न झाल्यास **`nil`** परत करतात — त्यामुळे त्यांच्या return value वर chaining करणे तोडू शकते.

## हे महत्वाचे का आहे

String हेरफेर प्रोग्रामिंगमध्ये व्यापक आहे, म्हणून Ruby च्या समृद्ध string methods जाणून घेणे रोज उपयोगी ज्ञान आहे — परंतु सर्वात महत्वाचा मुद्दा **bang (`!`) विरुद्ध non-bang फरक** समजणे आहे, जो Ruby naming convention आणि bugs चा वारंवार स्रोत दोन्ही आहे.

Non-bang version **नई** string परत करते (मूळ अपरिवर्तित सोडते), तर **bang version मूळ जागेवर mutate करते** — आणि त्यांचा गोंधळ मूळ object सुधारित होते किंवा नाही हे बदलते, ज्यामुळे सूक्ष्म, debug करणे कठीण bugs होतात (उदा. मूळ अपरिवर्तित अपेक्षित करता परंतु `upcase!` वापरल्याने mutation होते, किंवा mutation अपेक्षित करता परंतु `upcase` वापरल्याने मूळ अस्पृश्य राहते).

Ruby strings mutable असल्याने आणि अनेक methods दोन्ही स्वरूपात असल्याने, या फरकाची समज शुद्धतेसाठी महत्वाची आहे — हे जाणून घेणे की `!` सामान्यतः