वर्णों और स्ट्रिंग की तुलना करने के लिए सबसे अधिक क्लोज़रस्क्यू तरीका कौन सा है? (सिंगल चार स्ट्रिंग)

Question

मैं सोच रहा था कि क्लोजर में एक चरित्र और स्ट्रिंग की तुलना करने के लिए सबसे अच्छा (क्लोज़ेरेस) तरीका कौन सा है। जाहिर है ऐसा ही कुछ गलत रिटर्न:

(= (first "clojure") "c") 

क्योंकि पहले रिटर्न एक java.lang.Character और "सी" एकल वर्ण स्ट्रिंग है। एक कलाकार का आविष्कार किए बिना सीधे चार और स्ट्रिंग की तुलना करने के लिए एक निर्माण मौजूद है? मुझे इस से अलग रास्ता नहीं मिला है:

(= (str (first "clojure")) "c") 

लेकिन मैं संतुष्ट नहीं हूं। कोई विचार? अलविदा, अल्फ्रेडो

Answer 1

सीधे आगे स्ट्रिंग इंटरऑप के बारे में कैसे?

(= (.charAt "clojure" 0) \c)

या

(.startsWith "clojure" "c")

यह रूप में तेजी से इसे पाने के लिए और एक seq ऑब्जेक्ट को आवंटित नहीं करता है (और अपने दूसरे उदाहरण के लिए एक अतिरिक्त स्ट्रिंग में) के रूप में किया जाना चाहिए जो तुरंत बस को फिर से फेंक दी जाती है तुलना करो

Answer 2

आप अपने दूसरे उदाहरण में जैसे ही स्ट्र का उपयोग कर सकते हैं। इसके साथ वास्तव में कुछ भी गलत नहीं है। मेरा मतलब है, आप पहले इसे "सी" पर कॉल कर सकते हैं और इसे एक चरित्र बनाने के लिए भी कर सकते हैं, लेकिन यह वास्तव में कोई फर्क नहीं पड़ता। क्या कोई कारण है कि आप इस तरह नहीं हैं? चरित्र पर str को कॉल करके यह वास्तव में आपके कोड में बहुत कुछ नहीं जोड़ रहा है।

Answer 3

चरित्र शाब्दिक Clojure में \a \b \c ... लिखा जाता है तो आप बस

(= (first "clojure") \c) 

Answer 4

लिख सकते हैं आप clojure.contrib.string से ले समारोह इस्तेमाल कर सकते हैं। या अपना खुद का फ़ंक्शन लिखें जो पहले char को देता है यदि ऐसा कुछ है जिसे आपको अक्सर चाहिए।

Answer 5

तारों को तब से अनुक्रम बनाने के बिना सीधे अनुक्रमित किया जा सकता है और उस अनुक्रम का पहला भाग ले सकता है।

(= (nth "clojure" 0) \c) 
=> true 

इस जावा कोड के माध्यम से n वें कॉल:

static public Object nth(Object coll, int n){ 
    if(coll instanceof Indexed) 
     return ((Indexed) coll).nth(n); <------- 
    return nthFrom(Util.ret1(coll, coll = null), n); 
} 

जो कुशलता से चरित्र सीधे पढ़ता है। इस जावा कोड के माध्यम से

पहली कॉल:

static public Object first(Object x){ 
    if(x instanceof ISeq) 
     return ((ISeq) x).first(); 
    ISeq seq = seq(x); <----- (1) 
    if(seq == null) 
     return null; 
    return seq.first(); <------ (2) 
} 

जो स्ट्रिंग (1) के लिए एक seq बनाता है (एक seq के निर्माण वास्तव में तेजी से होता है) और फिर उस seq से पहले आइटम लेता है (2)। वापसी के बाद सीक कचरा है।

सीक स्पष्ट रूप से क्लोजर में अनुक्रमिक कुछ भी एक्सेस करने का सबसे मूर्ख तरीका है और मैं उन्हें बिल्कुल खटखटा नहीं रहा हूं। यह जानना दिलचस्प है कि आप क्या बना रहे हैं। पर अपनी सभी कॉल को nth पर कॉल करने के साथ समय-समय पर अनुकूलन का मामला होने की संभावना है।अगर आप स्ट्रिंग में 100 वां चार मैं की तरह वें

संक्षेप में एक अनुक्रमित पहुँच समारोह का उपयोग कर सुझाव हैं: छोटे सामान :)

Answer 6

पसीना नहीं आता मूलरूप (कम से कम Clojure स्तर पर - हालांकि Kotarak's answer और दूसरों को इसके विकल्पों के लिए देखें), आप दो अनुक्रमों की तुलना कर रहे हैं: "क्लोजर" और "सी"। समानता की स्थिति यह है कि प्रत्येक अनुक्रम का पहला तत्व बराबर है। तो तुम क्या कर सकते हैं, तो आप सीधे इस व्यक्त करना चाहता हूँ

(apply = (map first ["clojure" "c"])) 

या दूसरी तरह के आसपास है, जहां आप पात्रों में से प्रत्येक जोड़ी के बीच समानता तुलना में एक आलसी अनुक्रम बनाने के लिए, और बस के पहले तत्व ले:

(clojure.string/starts-with? "clojure" "c") 

:

(first (map = "clojure" "c")) 

Answer 7

user=> (= (subs "clojure" 0 1) "c") 
true 
user=> (= (str (first "clojure") "c")) 
true 

Answer 8

इन दिनों आप जरूरी जावा इंटरॉप उपयोग करने के लिए की जरूरत नहीं हैसिर्फ एक पतली आवरण है (लगभग .startsWith)।

तो अब यदि आप क्लोजर और क्लोजरस्क्रिप्ट दोनों का उपयोग करते हैं तो आपको जावा और जावास्क्रिप्ट इंटरऑप दोनों को याद रखना होगा।