दिलचस्प पोस्ट
आर में मर्ज करने / डेटा में शामिल होने का सबसे तेज़ तरीका क्या है? क्यों jquery .ajax () विधि मेरी सत्र कुकी नहीं भेज रहा है? GROUP_CONCAT द्वारा आदेश एंड्रॉइड एमुलेटर दृश्य से बाहर है, मैं इसे कैसे स्थानांतरित कर सकता हूं? जावा में मैं कैसे ज्यूनेट के साथ फेंक दिया अपवाद सत्यापित कर सकता हूं? ggplot2: एक अक्ष पर घुंघराले ब्रेसिज़? मैं कैसे दो divs की स्क्रॉल स्थिति सिंक्रनाइज़ कर सकता हूँ? संख्या का वर्ग #define का उपयोग करके परिभाषित किया जा रहा है वीबी 6 से वेब सेवा का उपभोग करने का सबसे अच्छा तरीका क्या है? मानचित्र V2 InfoWindow में गतिशील सामग्री यह निर्धारित करने के लिए कि क्या जावास्क्रिप्ट में एक संख्या अजीब है प्रति वेब अनुरोध एक DbContext … क्यों? यह आईपी, साइट या मोबाइल एप्लिकेशन इस एपीआई कुंजी का उपयोग करने के लिए अधिकृत नहीं है मॉनिटर चालू / बंद करें Android में चिकनी छवि रोटेशन कैसे करें?

रूबी में बचने और अनपेक्षित स्ट्रिंग का सर्वोत्तम तरीका?

क्या रब्बी के पास भागने और अनजान स्ट्रिंग्स के लिए कोई अंतर्निहित पद्धति है? अतीत में, मैंने नियमित अभिव्यक्तियों का उपयोग किया है; हालांकि, यह मेरे लिए होता है कि रुबी संभवत: आंतरिक रूप से इस तरह के रूपांतरण हर समय करता है। शायद यह कार्यक्षमता कहीं न कहीं उजागर हो रही है

अब तक मैं इन कार्यों के साथ आया हूँ वे काम करते हैं, लेकिन वे थोड़ा सा हैक लगता है:

def escape(s) s.inspect[1..-2] end def unescape(s) eval %Q{"#{s}"} end 

क्या कोई बेहतर तरीका है?

Solutions Collecting From Web of "रूबी में बचने और अनपेक्षित स्ट्रिंग का सर्वोत्तम तरीका?"

यदि आप eval का उपयोग नहीं करना चाहते हैं, लेकिन YAML मॉड्यूल का उपयोग करने के लिए तैयार हैं, तो आप इसे इसके बजाय उपयोग कर सकते हैं:

 require 'yaml' def unescape(s) YAML.load(%Q(---\n"#{s}"\n)) end 

YAML पर YAML लिए लाभ यह है कि यह संभवतः सुरक्षित है cane eval सभी उपयोग की अनुमति नहीं देता मैंने eval के साथ $SAFE का उपयोग करने के लिए सिफारिशें देखी हैं, लेकिन ये वर्तमान में जेआरबी के माध्यम से उपलब्ध नहीं है

इसके लिए क्या है, पायथन के पास अनचेकिंग बैकस्लैश के लिए मूल समर्थन है

वहाँ से बचने के तरीकों का एक गुच्छा है, उनमें से कुछ:

 # Regexp escapings >> Regexp.escape('\*?{}.') => \\\*\?\{\}\. >> URI.escape("test=100%") => "test=100%25" >> CGI.escape("test=100%") => "test%3D100%25" 

तो, यह वास्तव में इस मुद्दे पर निर्भर करता है कि आपको हल करने की आवश्यकता है। लेकिन मैं भागने के लिए निरीक्षण का उपयोग करने से बचना चाहूंगा

अपडेट – एक डंप है, इसका प्रयोग करता है, और ऐसा लगता है कि आपको इसकी ज़रूरत है:

 >> "\n\t".dump => "\"\\n\\t\"" 

कालेब फ़ंक्शन स्ट्रिंग के पीछे की सबसे नज़दीकी चीज थीं # इंस्पेक्ट मैं ढूंढने में सक्षम था, हालांकि इसमें दो कीड़े हैं:

  • \\ सही ढंग से संभाला नहीं था
  • \ एक्स .. बैकस्लैश को बरकरार रखा।

मैंने ऊपर की बग्स को तय किया है और यह अपडेट किया हुआ संस्करण है:

 UNESCAPES = { 'a' => "\x07", 'b' => "\x08", 't' => "\x09", 'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c", 'r' => "\x0d", 'e' => "\x1b", "\\\\" => "\x5c", "\"" => "\x22", "'" => "\x27" } def unescape(str) # Escape all the things str.gsub(/\\(?:([#{UNESCAPES.keys.join}])|u([\da-fA-F]{4}))|\\0?x([\da-fA-F]{2})/) { if $1 if $1 == '\\' then '\\' else UNESCAPES[$1] end elsif $2 # escape \u0000 unicode ["#$2".hex].pack('U*') elsif $3 # escape \0xff or \xff [$3].pack('H2') end } end # To test it while true line = STDIN.gets puts unescape(line) end 

YAML का ::unescape उद्धरण वर्णों से बचने के लिए प्रतीत नहीं होता, जैसे ' और " । मुझे यह अनुमान लगा रहा है कि डिजाइन के अनुसार है, लेकिन यह मुझे दुखी बनाता है।

आप निश्चित रूप से मनमाना या ग्राहक-प्रदान किए गए डेटा पर eval का उपयोग नहीं करना चाहते हैं

यही है वह जो मेरे द्वारा उपयोग किया जाता है। मैंने जो कुछ देखा है, वह हैंडल करता है और किसी भी निर्भरता को नहीं पेश करता है

 UNESCAPES = { 'a' => "\x07", 'b' => "\x08", 't' => "\x09", 'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c", 'r' => "\x0d", 'e' => "\x1b", "\\\\" => "\x5c", "\"" => "\x22", "'" => "\x27" } def unescape(str) # Escape all the things str.gsub(/\\(?:([#{UNESCAPES.keys.join}])|u([\da-fA-F]{4}))|\\0?x([\da-fA-F]{2})/) { if $1 if $1 == '\\' then '\\' else UNESCAPES[$1] end elsif $2 # escape \u0000 unicode ["#$2".hex].pack('U*') elsif $3 # escape \0xff or \xff [$3].pack('H2') end } end 

रूबी का inspect जा सकता है:

  "a\nb".inspect => "\"a\\nb\"" 

आम तौर पर यदि हम एक स्ट्रिंग को एम्बेडेड लाइन-फीड के साथ प्रिंट करते हैं, तो हम प्राप्त करते हैं:

 puts "a\nb" a b 

अगर हम निरीक्षणित संस्करण को प्रिंट करते हैं:

 puts "a\nb".inspect "a\nb" 

एक वैरिएबल के निरीक्षण किए गए संस्करण को असाइन करें और आपके पास स्ट्रिंग के बच गए संस्करण होंगे।

बचने को पूर्ववत करने के लिए, स्ट्रिंग eval करें:

 puts eval("a\nb".inspect) a b 

मैं वास्तव में इसे इस तरह से करना पसंद नहीं है यह अभ्यास में कुछ करना चाहती है उससे ज्यादा जिज्ञासा है

मुझे संदेह है कि Shellwords.escape जो आप खोज रहे हैं वह करेंगे

https://ruby-doc.org/stdlib-1.9.3/libdoc/shellwords/rdoc/Shellwords.html#method-c-shellescape