common-lisp
प्रारूप

पैरामीटर

टिप्पणियों

मूल उपयोग और सरल निर्देश

प्रारूप के पहले दो तर्क एक आउटपुट स्ट्रीम और एक नियंत्रण स्ट्रिंग हैं। मूल उपयोग के लिए अतिरिक्त तर्कों की आवश्यकता नहीं होती है। t पासिंग स्ट्रीम के रूप में *standard-output* को लिखता है।

> (format t "Basic Message")
Basic Message
nil

वह अभिव्यक्ति Basic Message को स्टैण्डर्ड आउटपुट, और रिटर्न nil में nil ।

पासिंग nil धारा के रूप में एक नया स्ट्रिंग बनाता है, और यह रिटर्न।

> (format nil "Basic Message")
"Basic Message"

अधिकांश नियंत्रण स्ट्रिंग निर्देशों के लिए अतिरिक्त तर्क की आवश्यकता होती है। ~a निर्देश ( "सौंदर्य") के रूप में यद्यपि द्वारा किसी भी तर्क प्रिंट होगा princ प्रक्रिया। यह बिना किसी एस्केप वर्ण के फ़ॉर्म को प्रिंट करता है (कीवर्ड्स प्रमुख कोलन के बिना प्रिंट किए जाते हैं, उनके आस-पास के उद्धरण और उसके बाद के तार)।

> (format nil "A Test: ~a" 42)
"A Test: 42"
> (format nil "Multiples: ~a ~a ~a ~a" 1 (list 2 3) "four five" :six)
"Multiples: 1 (2 3) four five SIX"
> (format nil "A Test: ~a" :test)
"A Test: TEST"
> (format nil "A Test: ~a" "Example")
"A Test: Example"

~a अतिरिक्त इनपुट के आधार पर ~a वैकल्पिक रूप से दाएं या बाएं-पैड इनपुट।

> (format nil "A Test: ~10a" "Example")
"A Test: Example   "
> (format nil "A Test: ~10@a" "Example")
"A Test:    Example"

~s निर्देशन ~a जैसा ~a , लेकिन यह वर्णों से बच जाता है।

> (format nil "A Test: ~s" 42)
"A Test: 42"
> (format nil "Multiples: ~s ~s ~s ~s" 1 (list 2 3) "four five" :six)
"Multiples: 1 (2 3) \"four five\" :SIX"
> (format nil "A Test: ~s" :test)
"A Test: :TEST"
> (format nil "A Test: ~s" "Example")
"A Test: \"Example\""

एक सूची में बदलाव

एक ~{ और ~} निर्देशों का उपयोग कर एक सूची पर पुनरावृति कर सकते हैं।

CL-USER> (format t "~{~a, ~}~%" '(1 2 3 4 5))
1, 2, 3, 4, 5, 

~^ बचने के लिए इस्तेमाल किया जा सकता है अगर कोई और तत्व नहीं बचे हैं।

CL-USER> (format t "~{~a~^, ~}~%" '(1 2 3 4 5))
1, 2, 3, 4, 5

एक अंकीय तर्क दिया जा सकता है ~{ सीमित करने के कितने पुनरावृत्तियों किया जा सकता है:

CL-USER> (format t "~3{~a~^, ~}~%" '(1 2 3 4 5))
1, 2, 3, 

~@{ एक सूची के बजाय शेष तर्कों पर पुनरावृति करेगा:

CL-USER> (format t "~a: ~@{~a~^, ~}~%" :foo 1 2 3 4 5)
FOO: 1, 2, 3, 4, 5

Sublists ~:{ : का उपयोग करके इसे पुनरावृत्त किया जा सकता है

CL-USER> (format t "~:{(~a, ~a) ~}~%" '((1 2) (3 4) (5 6)))
(1, 2) (3, 4) (5, 6) 

सशर्त अभिव्यक्ति

सशर्त अभिव्यक्ति ~[ और ~] साथ की जा सकती है। अभिव्यक्ति के खंड ~; का उपयोग करके अलग हो जाते हैं ~; ।

डिफ़ॉल्ट रूप से, ~[ तर्क सूची से पूर्णांक लेता है, और संबंधित खंड चुनता है। खंड शून्य पर शुरू होते हैं।

(format t "~@{~[First clause~;Second clause~;Third clause~;Fourth clause~]~%~}"
        0 1 2 3)
; First clause
; Second clause
; Third clause
; Fourth clause

अंतिम खंड को ~:; साथ अलग किया जा सकता है ~:; इसके बजाय इसे अन्य खंड बनाने के लिए।

(format t "~@{~[First clause~;Second clause~;Third clause~:;Too high!~]~%~}"
        0 1 2 3 4 5)
; First clause
; Second clause
; Third clause
; Too high!
; Too high!
; Too high!

यदि सशर्त अभिव्यक्ति ~:[ साथ शुरू होती है, तो यह पूर्णांक के बजाय एक सामान्यीकृत बूलियन की अपेक्षा करेगी। इसमें केवल दो खंड हो सकते हैं; यदि पहला बूलियन NIL था, और दूसरा खण्ड सत्य होने पर छपा होता है।

(format t "~@{~:[False!~;True!~]~%~}"
        t nil 10 "Foo" '())
; True!
; False!
; True!
; True!
; False!

यदि सशर्त अभिव्यक्ति ~@[ साथ शुरू होती है, तो केवल एक खंड होना चाहिए, जो मुद्रित होता है यदि इनपुट, एक सामान्यीकृत बूलियन, सत्य था। सत्य होने पर बूलियन का सेवन नहीं किया जाएगा।

(format t "~@{~@[~s is truthy!~%~]~}"
        t nil 10 "Foo" '())
; T is truthy!
; 10 is truthy!
; "Foo" is truthy!