क्या रेगेक्स वर्णों के लिए स्ट्रिंग से बचने के लिए कोई आर फ़ंक्शन है

Question

मैं कुछ स्ट्रिंग्स में एक रेगेक्स अभिव्यक्ति प्रतिस्थापन बनाना चाहता हूं, और इसलिए इन स्ट्रिंग को रेगेक्स में रखने से पहले बचने की आवश्यकता है, इसलिए कि अगर स्ट्रिंग के लिए खोज में रेगेक्स वर्ण होते हैं तो यह अभी भी काम करता है।

कुछ भाषाओं में ऐसे फ़ंक्शन हैं जो आपके लिए यह करेंगे (उदा। पायथन re.escape: https://stackoverflow.com/a/10013356/1900520)। क्या आर में ऐसा कोई कार्य है?

उदाहरण के लिए (समारोह बना हुआ):

x = "foo[bar]" 
y = escape(x) # y should now be "foo\\[bar\\]" 

Answer 1

मैं पर्ल के quotemeta समारोह के एक अनुसंधान संस्करण में लिखा है:

library(stringr) 
quotemeta <- function(string) { 
    str_replace_all(string, "(\\W)", "\\\\\\1") 
} 

मैं हमेशा regexps की पर्ल स्वाद का उपयोग करें, तो यह मेरे लिए काम करता है। मुझे नहीं पता कि यह आर

में "सामान्य" regexps के लिए काम करता है संपादित करें: मुझे यह बताते हुए स्रोत मिला कि यह क्यों काम करता है। यह Quoting Metacharacters section of the perlre manpage में बताया गया है:

यह एक बार अक्षम या एक स्ट्रिंग है कि आप एक पैटर्न के लिए उपयोग करना चाहते हैं में नियमित अभिव्यक्ति अक्षरों से परे का विशेष अर्थ उद्धृत करने के लिए एक आम मुहावरा में इस्तेमाल किया गया था। सीधे शब्दों में सब से गैर- "शब्द" वर्ण बोली:

$pattern =~ s/(\W)/\\$1/g; 

आप देख सकते हैं, आर कोड ऊपर यह एक ही प्रतिस्थापन का एक सीधा अनुवाद (बैकस्लैश नरक के माध्यम से एक यात्रा के बाद)। मैनपेज भी कहते हैं (जोर मेरा):

कुछ अन्य नियमित अभिव्यक्ति भाषाओं के विपरीत, वहाँ कोई backslashed प्रतीकों कि अक्षरांकीय नहीं हैं।

जो मेरे बिंदु को मजबूत करता है कि यह समाधान केवल पीसीआरई के लिए गारंटी है।

Answer 2

जाहिर है वहाँ एक समारोह Hmisc पैकेज में escapeRegex कहा जाता है। समारोह में ही 'स्ट्रिंग' के एक इनपुट मान के लिए निम्न परिभाषा है:

gsub("([.|()\\^{}+$*?]|\\[|\\])", "\\\\\\1", string) 

मेरे पिछले जवाब:

मैं एक समारोह में बनाया गया है, लेकिन आप क्या करने के लिए एक बना सकता है तो यकीन नहीं है आपको क्या चाहिए। यह मूल रूप से केवल उन मानों का एक वेक्टर बनाता है जिन्हें आप प्रतिस्थापित करना चाहते हैं और जो वे आप उन्हें बदलना चाहते हैं उसका वेक्टर बनाता है और फिर आवश्यक प्रतिस्थापन करने वालों के माध्यम से लूप करता है।

re.escape <- function(strings){ 
    vals <- c("\\\\", "\\[", "\\]", "\\(", "\\)", 
       "\\{", "\\}", "\\^", "\\$","\\*", 
       "\\+", "\\?", "\\.", "\\|") 
    replace.vals <- paste0("\\\\", vals) 
    for(i in seq_along(vals)){ 
     strings <- gsub(vals[i], replace.vals[i], strings) 
    } 
    strings 
} 

कुछ उत्पादन

> test.strings <- c("What the $^&(){}.*|?", "foo[bar]") 
> re.escape(test.strings) 
[1] "What the \\$\\^&\\(\\)\\{\\}\\.\\*\\|\\?" 
[2] "foo\\[bar\\]"