फैक्टर में स्ट्रिंग अक्षरों के क्रम से बनती है। sequences वोकैबुलरी के अधिकतर शब्द स्ट्रिंग पर भी काम करते हैं, और इसके अलावा splitting, ascii तथा उनके जैसी अन्य वोकैबुलरी में स्ट्रिंग संभालने वाले खास शब्द भी हैं।
स्ट्रिंग दोहरे उद्धरण चिह्नों के बीच लिखी जाती है। आम एस्केप सीक्वेंस इस्तेमाल होते हैं, जैसे \n, \t, \r, \\ और \":
"hello, world" . ! => "hello, world"
"first\nsecond" print ! prints two lines
चूँकि स्ट्रिंग एक क्रम होती है, sequences वोकैबुलरी के length और nth शब्द इस पर सीधे काम करते हैं।
length अक्षरों की संख्या लौटाता है:
"hello" length . ! => 5
nth एक 0 से शुरू होने वाला इंडेक्स और वह क्रम लेता है, और उस स्थान पर मौजूद एलिमेंट लौटाता है। स्ट्रिंग के लिए एलिमेंट एक अक्षर होता है, यानी एक कोड पॉइंट (एक पूर्णांक), कोई एक अक्षर की सबस्ट्रिंग नहीं:
0 "hello" nth . ! => 104 (CHAR: h)
4 "hello" nth . ! => 111 (CHAR: o)
किसी एक कोड पॉइंट को एक अक्षर की स्ट्रिंग में बदलने के लिए strings वोकैबुलरी का 1string ( char -- str ) इस्तेमाल कीजिए। CHAR: किसी लिटरल कोड पॉइंट का पार्सर के समय वाला रूप है:
CHAR: A 1string . ! => "A"
0 "hello" nth 1string . ! => "h"
splitting वोकैबुलरी स्ट्रिंग को टुकड़ों में काटती है।
split1 किसी सेपरेटर के पहले मिलने पर काटता है और दोनों हिस्से लौटाता है:
split1 ( seq subseq -- before after )
"foo: bar" ": " split1 .s
! => "foo"
! => "bar"
split सेपरेटर सेट के किसी भी अक्षर पर काटता है, और इससे खाली टुकड़े भी बन सकते हैं:
"[ERROR]: Stack overflow" "[]" split .
! => { "" "ERROR" ": Stack overflow" }
harvest (sequences में) खाली टुकड़ों को हटा देता है:
"[ERROR]: Stack overflow" "[]" split harvest .
! => { "ERROR" ": Stack overflow" }
जब स्ट्रिंग टुकड़ों के ऐरे में बँट जाती है, तो first, second, third और fourth (sequences में) उस स्थान पर मौजूद टुकड़ा लौटाते हैं:
"apple,bee,carrot,duck" "," split first . ! => "apple"
"apple,bee,carrot,duck" "," split second . ! => "bee"
"apple,bee,carrot,duck" "," split third . ! => "carrot"
"apple,bee,carrot,duck" "," split fourth . ! => "duck"
जब आप स्टैक पर शुरुआती सारे टुकड़े एक साथ चाहते हैं, तो first2 और first3 एक ही चरण में दो या तीन टुकड़े खोल देते हैं:
"apple,bee,carrot,duck" "," split first2 .s
! => "apple"
! => "bee"
"apple,bee,carrot,duck" "," split first3 .s
! => "apple"
! => "bee"
! => "carrot"
स्ट्रिंग पर ही first पहला अक्षर लौटाता है, यानी एक कोड पॉइंट, कोई सबस्ट्रिंग नहीं:
"hello" first . ! => 104 (CHAR: h)
[ blank? ] trim (sequences से, और blank? ascii वोकैबुलरी से) आगे और पीछे का खाली स्थान हटा देता है:
" Disk full \r\n" [ blank? ] trim .
! => "Disk full"
>lower और >upper (ascii से) केस बदली हुई नई स्ट्रिंग लौटाते हैं:
"WARNING" >lower . ! => "warning"
"hello" >upper . ! => "HELLO"
sequences के दो शब्द स्ट्रिंग जोड़कर बनाते हैं:
surround किसी स्ट्रिंग के आगे एक प्रीफिक्स और पीछे एक सफिक्स लगा देता है:
surround ( seq pre post -- new-seq )
"warning" "(" ")" surround . ! => "(warning)"
glue दो स्ट्रिंग के बीच एक सेपरेटर रखकर उन्हें जोड़ता है:
glue ( s1 s2 sep -- s )
"Disk full" "(error)" " " glue . ! => "Disk full (error)"
इस अभ्यास में आप लॉग लाइनों को संसाधित करेंगे।
हर लॉग लाइन एक स्ट्रिंग होती है, जिसका फॉर्मेट "[<LEVEL>]: <MESSAGE>" होता है।
लॉग लेवल तीन होते हैं: INFO, WARNING, और ERROR.
आपके पास तीन कार्य हैं। हर कार्य स्टैक से एक लॉग लाइन लेता है।
message को इस तरह बनाइए कि वह लॉग लाइन का मैसेज लौटाए। मैसेज के शुरू और अंत में मौजूद खाली जगह हटा दी जानी चाहिए।
"[ERROR]: Invalid operation" message .
! => "Invalid operation"
"[WARNING]: Disk almost full\r\n" message .
! => "Disk almost full"
log-level को इस तरह बनाइए कि वह लॉग लाइन का लेवल छोटे अक्षरों में लौटाए।
"[ERROR]: Invalid operation" log-level .
! => "error"
reformat को इस तरह बनाइए कि वह पहले मैसेज रखे और उसके बाद छोटे अक्षरों में लॉग लेवल को गोल ब्रैकेट में डाले।
"[INFO]: Operation completed" reformat .
! => "Operation completed (info)"
नोट: इस अभ्यास की सारी स्ट्रिंग ASCII हैं। आगे के अभ्यासों में ऐसी स्ट्रिंग्स पर काम होगा जो Unicode को भी संभालती हैं।
Exercism पर साइन अप कीजिए और Factor को 47 कॉन्सेप्ट163 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।