Ruby strings లకు మానిప్యులేషన్ కోసం సమృద్ధమైన పద్ధతుల సమితి ఉంది, మరియు చాలా వాటి రెండు రూపాలలో వస్తాయి: సాధారణ సంస్కరణ (కొత్త string ను తిరిగి ఇస్తుంది) మరియు bang (!) సంస్కరణ (string ను స్థానంలో సవరించుకుంటుంది, అసలైనది మారుతుంది). ఈ వ్యత్యాసాన్ని అర్థం చేసుకోవడం సరిషట్టత మరియు బగ్లను నివారించడానికి ముఖ్యమైనది.
"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
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) సంస్కరణలు అసలైన stringను స్థానంలో సవరిస్తాయి, అయితే non-bang సంస్కరణలు కొత్త stringను తిరిగి ఇచ్చి అసలైనది మారకుండా ఉంచుతాయి. ఇది ఒక సంపూర్ణ వ్యత్యాసం — upcase! ను ఉపయోగించినప్పుడు మీరు upcase ని కోరుకున్నారు (లేదా దీనికి విరుద్ధంగా) అసలైనది సవరించబడుతుందో లేదో మారుతుంది, ఇది సూక్ష్మ బగ్లకు కారణమవుతుంది.
"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 పద్ధతులు nil ను తిరిగి ఇస్తాయి కూడా అవి ఎటువంటి మార్పు చేయకపోతే — కాబట్టి వాటి రిటర్న్ వ్యూ నుండి చెయిన్ చేయడం విచ్ఛిన్నమయ్యేటట్లుగా ఉంటుంది.
String మానిప్యులేషన్ ప్రోగ్రామింగ్లో విస్తృతమైనది, కాబట్టి Ruby యొక్క సమృద్ధమైన string పద్ధతులను తెలుసుకోవడం రోజువారీ జ్ఞానం ఉపయోగకరమైనది — కానీ చాలా ముఖ్యమైన విషయం bang (!) vs non-bang వ్యత్యాసం ను అర్థం చేసుకోవడం, ఇది Ruby నామకరణ సమావేశం మరియు బగ్ల యొక్క సరిచేసే మూలం.
Non-bang సంస్కరణ కొత్త stringను తిరిగి ఇస్తుంది (అసలైనది మారకుండా ఉంచుతుంది), అయితే bang సంస్కరణ అసలైనది స్థానంలో సవరిస్తుంది — మరియు వాటిని గందరగోళం చేయడం అసలైన object సవరించబడుతుందో లేదో మారుతుంది, ఇది సూక్ష్మ, కష్టమైన-డీబగ్ బగ్లకు కారణమవుతుంది (ఉదా అసలైనది మారకుండా ఉండాలని ఆశించండి కానీ upcase! ను ఉపయోగించడం సవరిస్తుంది, లేదా సవరణను ఆశించండి కానీ upcase ను ఉపయోగించడం అసలైనది అస్పృశ్యంగా ఉంచుతుంది).
Ruby strings మారుకునేవి కాబట్టి మరియు చాలా పద్ధతులకు రెండు రూపాలు ఉన్నాయి, ఈ వ్యత్యాసాన్ని అర్థం చేసుకోవడం సరిషట్టత కోసం ముఖ్యమైనది — ! సాధారణంగా "స్థానంలో సవరిస్తుంది / ప్రమాదకరమైన సంస్కరణ" (strings కంటే ఇతర Ruby పద్ధతుల వరకు విస్తరించే సమావేశం map!, sort! వంటివి) ను అర్థం చేసుకోవడం సవరణ ప్రవర్తనను అంచనా వేయడానికి మరియు నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తుంది.
కూడా ఈ gotcha bang పద్ధతులు nil ను రిటర్న్ చేస్తుంటే కూడా అవి ఎటువంటి మార్పు చేయకపోతే (ఇది పద్ధతి చెయిన్ను విచ్ఛిన్నం చేస్తుంది) తెలుసుకోవడం కూడా విలువైనది.
Ruby యొక్క ఉపయోగకరమైన string పద్ధతులను మరియు ముఖ్యంగా bang/non-bang సవరణ వ్యత్యాసం (అసలైనది సవరించబడుతుందో లేదో ప్రభావితం చేసే ప్రధాన Ruby సమావేశం) ను అర్థం చేసుకోవడం సరైన Ruby ని వ్రాయడానికి ముఖ్యమైనది స్ట్రింగ్లను సురక్షితంగా నిర్వహిస్తుంది — ఇది సవరణ బగ్ల యొక్క తరచుగా మూలం, మరియు ! సమావేశం Ruby యొక్క ప్రాథమిక ఉపసర్గ ఇది స్థానంలో vs. కొత్త-object సెమాంటిక్ల గురించి అర్థం యొక్క ప్రతిబింబం, ఇది Ruby లో నిరంతర string పని కోసం ఆచరణాత్మకంగా-సంబంధితమైన జ్ఞానం మరియు విభిన్న, బగ్-ప్రవణ Ruby సమావేశం గురించి సాధారణ విషయం.
జూనియర్ నుండి సీనియర్ వరకు వివరణాత్మక సమాధానాలతో IT ఇంటర్వ్యూ ప్రశ్నల లైబ్రరీ.
విరాళం