காலிபர் வார்ப்புரு மொழி¶

காலிபர் வார்ப்புரு மொழி என்பது கோப்பு பாதைகளைக் குறிப்பிடுவது, மதிப்புகளை வடிவமைத்தல் மற்றும் பயனர் குறிப்பிட்ட நெடுவரிசைகளுக்கான மதிப்பைக் கணக்கிடுதல் போன்ற பணிகளுக்கு காலிபர் முழுவதும் பயன்படுத்தப்படும் ஒரு காலிபர்-குறிப்பிட்ட மொழியாகும். எடுத்துக்காட்டுகள்:

காலிபர் நூலகத்திலிருந்து வட்டு அல்லது மின் புத்தக வாசகருக்கு கோப்புகளைச் சேமிக்கும்போது கோப்புறை அமைப்பு மற்றும் கோப்பு பெயர்களைக் குறிப்பிடவும்.
காலிபர் புத்தக பட்டியலில் ஐகான்கள் மற்றும் வண்ணங்களைச் சேர்ப்பதற்கான விதிகளை வரையறுக்கவும்.
மற்ற நெடுவரிசைகளிலிருந்து தரவைக் கொண்ட மெய்நிகர் நெடுவரிசைகளை வரையறுக்கவும்.
மேம்பட்ட நூலக தேடல்.
மேம்பட்ட மெட்டாடேட்டா தேடல் மற்றும் மாற்றவும்.

ஒரு வார்ப்புரு என்ற கருத்தைச் சுற்றி மொழி கட்டப்பட்டுள்ளது, இது எந்த புத்தக மெட்டாடேட்டாவைப் பயன்படுத்த வேண்டும், அந்த மெட்டாடேட்டாவில் கணக்கீடுகள் மற்றும் அது எவ்வாறு வடிவமைக்கப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது.

அடிப்படை வார்ப்புருக்கள்¶

ஒரு அடிப்படை வார்ப்புரு ஒன்று அல்லது அதற்கு மேற்பட்ட `` வார்ப்புரு வெளிப்பாடுகள்`` கொண்டுள்ளது. ஒரு `` வார்ப்புரு வெளிப்பாடு`` சுருள் அடைப்புக்குறிக்குள் உரை மற்றும் பெயர்களைக் கொண்டுள்ளது (`` {} ``) இது செயலாக்கப்படும் புத்தகத்திலிருந்து தொடர்புடைய மெட்டாடேட்டாவால் மாற்றப்படுகிறது. எடுத்துக்காட்டாக, சாதனத்தில் புத்தகங்களைச் சேமிக்கப் பயன்படுத்தப்படும் காலிபரில் உள்ள இயல்புநிலை வார்ப்புருவில் 4 `` வார்ப்புரு வெளிப்பாடுகள்`

{author_sort}/{title}/{title} - {authors}

"ஐசக் அசிமோவ்" எழுதிய "அறக்கட்டளை" புத்தகத்திற்கு விருப்பம்

Asimov, Isaac/The Foundation/The Foundation - Isaac Asimov

ஸ்லாஷ்கள் `` வார்ப்புரு வெளிப்பாடுகள்` அல்ல, ஏனென்றால் அவை `` {} `` `க்கு இடையில் உள்ளன. அத்தகைய உரை தோன்றும் இடத்தில் விடப்படுகிறது. உதாரணமாக, வார்ப்புரு இருந்தால்

{author_sort} Some Important Text {title}/{title} - {authors}

"அறக்கட்டளை" க்கு வார்ப்புரு உருவாக்குகிறது

Asimov, Isaac Some Important Text The Foundation/The Foundation - Isaac Asimov

ஒரு நெடுவரிசையின் `` தேடல் பெயர்`` ஐப் பயன்படுத்தி தனிப்பயன் நெடுவரிசைகள் (உங்களை உருவாக்கும் நெடுவரிசைகள்) உட்பட, காலிபரில் கிடைக்கும் அனைத்து மெட்டாடேட்டாவையும் ஒரு `` வார்ப்புரு வெளிப்பாடு`` அணுகலாம். நெடுவரிசை (சில நேரங்களில்` புலங்கள்` என்று அழைக்கப்படுகிறது) க்கான தேடல் பெயரைக் கண்டுபிடிக்க, காலிபரின் புத்தக பட்டியலில் நெடுவரிசை தலைப்புக்கு மேல் உங்கள் சுட்டியைச் செல்லுங்கள். தனிப்பயன் நெடுவரிசைகளுக்கான தேடல் பெயர்கள் எப்போதும் # உடன் தொடங்குகின்றன. தொடர் வகை நெடுவரிசைகளுக்கு `` #lookup name_index`` என்ற கூடுதல் புலம் உள்ளது, இது தொடரில் அந்த புத்தகத்திற்கான தொடர் குறியீடாகும். எடுத்துக்காட்டாக, உங்களிடம் #MySeries என்ற தனிப்பயன் தொடர் நெடுவரிசை இருந்தால், #myseries_index என்ற நெடுவரிசையும் இருக்கும். நிலையான தொடர் நெடுவரிசையின் குறியீட்டுக்கு `` Sitery_index`` என்று பெயரிடப்பட்டுள்ளது.

நிலையான நெடுவரிசை அடிப்படையிலான புலங்களுக்கு கூடுதலாக, நீங்கள் பயன்படுத்தலாம்:

`` {வடிவங்கள்} `` - ஒரு புத்தகத்திற்கான காலிபர் நூலகத்தில் கிடைக்கும் வடிவங்களின் பட்டியல்

`` {அடையாளங்காட்டிகள்: புத்தகத்தின் ஐ.எஸ்.பி.என்

கொடுக்கப்பட்ட புத்தகத்திற்கான புலத்திற்கான மெட்டாடேட்டா வரையறுக்கப்படாவிட்டால், வார்ப்புருவில் உள்ள புலம் வெற்று சரத்தால் மாற்றப்படும் (`` '' ``). எடுத்துக்காட்டாக, பின்வரும் வார்ப்புருவைக் கவனியுங்கள்

{author_sort}/{series}/{title} {series_index}

அசிமோவின் "இரண்டாவது அறக்கட்டளை" புத்தகம் "அறக்கட்டளை" என்ற தொடரில் இருந்தால், வார்ப்புரு உருவாக்குகிறது

Asimov, Isaac/Foundation/Second Foundation 3

புத்தகத்திற்கு ஒரு தொடர் உள்ளிடப்படவில்லை என்றால், வார்ப்புரு உருவாக்குகிறது

Asimov, Isaac/Second Foundation

வார்ப்புரு செயலி தானாக பல ஸ்லாஷ்கள் மற்றும் முன்னணி அல்லது பின்தங்கிய இடங்களை நீக்குகிறது.

மேம்பட்ட வடிவமைப்பு¶

மெட்டாடேட்டா மாற்றீட்டிற்கு கூடுதலாக, வார்ப்புருக்கள் நிபந்தனையுடன் கூடுதல் உரையை உள்ளடக்கியது மற்றும் மாற்று தரவு எவ்வாறு வடிவமைக்கப்படுகிறது என்பதைக் கட்டுப்படுத்தலாம்.

** உரை உட்பட நிபந்தனையுடன் **

சில நேரங்களில் ஒரு புலம் காலியாக இல்லாவிட்டால் மட்டுமே வெளியீட்டில் உரை தோன்ற வேண்டும். ஒரு பொதுவான வழக்கு `` தொடர்`` மற்றும் `` தொடர்_இண்டெக்ஸ்`` அங்கு நீங்கள் எதுவும் விரும்பவில்லை அல்லது ஒரு ஹைபனால் பிரிக்கப்பட்ட இரண்டு மதிப்புகள். ஒரு சிறப்பு `` வார்ப்புரு வெளிப்பாடு`` தொடரியல் பயன்படுத்தி இந்த வழக்கை காலிபர் கையாளுகிறார்.

எடுத்துக்காட்டாக, மேலே உள்ள அறக்கட்டளை எடுத்துக்காட்டைப் பயன்படுத்தி, வார்ப்புரு அறக்கட்டளை - 3 - இரண்டாவது அடித்தளம் ஐ உருவாக்க வேண்டும் என்று வைத்துக் கொள்ளுங்கள். இந்த வார்ப்புரு அந்த வெளியீட்டை உருவாக்குகிறது:

{தொடர்} - {sitery_index} - {தலைப்பு} `

இருப்பினும், ஒரு புத்தகத்தில் தொடர் இல்லை என்றால், வார்ப்புரு ` - - தலைப்பு` ஐ உருவாக்கும், இது நீங்கள் விரும்பாதது அல்ல. பொதுவாக, மக்கள் முடிவு வெளிப்புற ஹைபன்கள் இல்லாமல் தலைப்பாக இருக்க விரும்புகிறார்கள். பின்வரும் வார்ப்புரு தொடரியல் பயன்படுத்தி இதை நீங்கள் நிறைவேற்றலாம்:

`` {புலம்: | முன்னொட்டு_டெக்ஸ்ட் | பின்னொட்டு_டெக்ஸ்ட்} ``

இந்த `` வார்ப்புரு வெளிப்பாடு`` கூறுகிறது `` புலம்` xxxx மதிப்பு இருந்தால், இதன் விளைவாக` முன்னொட்டு `` புலம்`` காலியாக இருந்தால் (மதிப்பு இல்லை), இதன் விளைவாக வெற்று சரம் (ஒன்றுமில்லை) இருக்கும், ஏனெனில் முன்னொட்டு மற்றும் பின்னொட்டு புறக்கணிக்கப்படும். முன்னொட்டு மற்றும் பின்னொட்டு வெற்றிடங்களைக் கொண்டிருக்கலாம்.

** முன்னொட்டு அல்லது பின்னொட்டில் சப்டெம்பிளேட்டுகள் ({...}) அல்லது செயல்பாடுகளை (கீழே காண்க) பயன்படுத்த வேண்டாம். **

இந்த தொடரியல் பயன்படுத்தி, வார்ப்புருவில் மேலே உள்ள தொடர் சிக்கலை நாம் தீர்க்க முடியும்

{series}{series_index:| - | - }{title}

புத்தகத்தில் தொடர் குறியீடு இருந்தால் மட்டுமே ஹைபன்கள் சேர்க்கப்படும், அதில் ஒரு தொடர் இருந்தால் மட்டுமே உள்ளது. அறக்கட்டளை உதாரணத்தைத் தொடர்ந்து, வார்ப்புரு அறக்கட்டளை - 1 - இரண்டாவது அடித்தளத்தை உருவாக்கும்.

குறிப்புகள்:

நீங்கள் ஒரு முன்னொட்டு அல்லது பின்னொட்டைப் பயன்படுத்துகிறீர்கள் என்றால் `` தேடல் பெயர்`` க்குப் பிறகு நீங்கள் பெருங்குடலை சேர்க்க வேண்டும்.
நீங்கள் இல்லை அல்லது இரண்டையும் பயன்படுத்த வேண்டும் `` | `` எழுத்துக்கள். ஒன்றைப் பயன்படுத்துதல், ` {புலம்: | -} ``, அனுமதிக்கப்படவில்லை.
`` {தொடர்: || போன்ற முன்னொட்டு அல்லது பின்னொட்டுக்கு எந்த உரையையும் வழங்குவது சரி -} ``. `` {தலைப்பு: ||} `` வார்ப்புரு `` {தலைப்பு} `` போன்றது.

** வடிவமைத்தல் **

`` Sitery_Index`` ஐ முன்னணி பூஜ்ஜியங்களுடன் மூன்று இலக்கங்களாக வடிவமைக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். இது தந்திரம் செய்கிறது:

{sitery_index: 0> 3s} ` - முன்னணி பூஜ்ஜியங்களுடன் மூன்று இலக்கங்கள்

பூஜ்ஜியங்களைப் பின்தொடர்வதற்கு, பயன்படுத்தவும்:

{sitery_index: 0 <3s} ` - பூஜ்ஜியங்களுடன் மூன்று இலக்கங்கள்

பகுதியளவு மதிப்புகளுடன் தொடர் குறியீடுகளைப் பயன்படுத்தினால், எ.கா., 1.1, தசம புள்ளிகள் வரிசைப்படுத்த வேண்டும் என்று நீங்கள் விரும்பலாம். எடுத்துக்காட்டாக, 1 மற்றும் 2.5 குறியீடுகள் 01.00 மற்றும் 02.50 ஆகத் தோன்ற வேண்டும் என்று நீங்கள் விரும்பலாம், இதனால் அவை லெக்சிக்கல் வரிசையாக்கத்தை செய்யும் சாதனத்தில் சரியாக வரிசைப்படுத்தும். இதைச் செய்ய, பயன்படுத்தவும்:

.

தரவின் முதல் இரண்டு எழுத்துக்களை மட்டுமே நீங்கள் விரும்பினால், பயன்படுத்தவும்:

`` {எழுத்தாளர்_சார்ட்: .2} `` - ஆசிரியரின் முதல் இரண்டு எழுத்துக்கள் மட்டுமே

காலிபர் வார்ப்புரு மொழி வடிவமைப்பின் பெரும்பகுதி பைத்தானில் இருந்து வருகிறது. இந்த மேம்பட்ட வடிவமைப்பு செயல்பாடுகளின் தொடரியல் பற்றிய கூடுதல் விவரங்களுக்கு பைதான் ஆவணங்கள் <https://docs.python.org/3/library/string.html#formatstrings> _.

தனிப்பயன் நெடுவரிசைகளை வரையறுக்க வார்ப்புருக்களைப் பயன்படுத்துதல்¶

காலிபர் மெட்டாடேட்டாவில் இல்லாத தகவல்களைக் காண்பிக்க அல்லது காலிபரின் இயல்பான வடிவமைப்பிலிருந்து வித்தியாசமாகக் காண்பிக்க வார்ப்புருக்கள் பயன்படுத்தப்படலாம். எடுத்துக்காட்டாக, நீங்கள் காண்பிக்காத `` isbn`` என்பதைக் காட்ட விரும்பலாம். மற்ற நெடுவரிசைகளிலிருந்து கட்டப்பட்ட நெடுவரிசை (இனிமேல் கலப்பு நெடுவரிசைகள்` என அழைக்கப்படுகிறது) மற்றும் காண்பிக்கப்படும் உரையை உருவாக்க ஒரு வார்ப்புருவை வழங்கும் வகை நெடுவரிசையுடன் தனிப்பயன் நெடுவரிசையை உருவாக்குவதை நீங்கள் நிறைவேற்றலாம். வார்ப்புருவை மதிப்பிடுவதன் முடிவை நெடுவரிசை காண்பிக்கும். எடுத்துக்காட்டாக, ISBN ஐக் காண்பிக்க, நெடுவரிசையை உருவாக்கி ` {அடையாளங்காட்டிகள்: வார்ப்புரு பெட்டியில் (ISBN)} `` தேர்ந்தெடுக்கவும். கமாவால் பிரிக்கப்பட்ட இரண்டு தொடர் தனிப்பயன் நெடுவரிசைகளின் மதிப்புகளைக் கொண்ட ஒரு நெடுவரிசையைக் காட்ட, {#தொடர் 1: ||,} {#SERIES2} `ஐப் பயன்படுத்தவும்.

கலப்பு நெடுவரிசைகள் வடிவமைப்பு உட்பட எந்த வார்ப்புரு விருப்பத்தையும் பயன்படுத்தலாம்.

குறிப்பு: கலப்பு நெடுவரிசையில் காட்டப்படும் தரவை நீங்கள் திருத்த முடியாது. அதற்கு பதிலாக மூல நெடுவரிசைகளைத் திருத்துகிறீர்கள். நீங்கள் ஒரு கலப்பு நெடுவரிசையைத் திருத்தினால், எடுத்துக்காட்டாக, அதை இருமுறை கிளிக் செய்வதன் மூலம், காலிபர் எடிட்டிங் வார்ப்புருவைத் திறக்கும், அடிப்படை தரவு அல்ல.

வார்ப்புருக்கள் மற்றும் செருகுநிரல்கள்¶

அனுப்பு-சாதனத்தின் போது புத்தகங்களில் எழுதப்பட்ட மெட்டாடேட்டாவை மாற்றுவதற்கும், விலக்கப்பட்ட செயல்பாடுகளைச் சேமிப்பதற்கும் பிளேக் போர்டுகள் பயன்படுத்தப்படுகின்றன. புத்தகத்தின் மெட்டாடேட்டாவில் எழுத தரவை வழங்க ஒரு வார்ப்புருவைக் குறிப்பிட ஒரு செருகுநிரல் உங்களை அனுமதிக்கிறது. பின்வரும் புலங்களை மாற்ற நீங்கள் செருகுநிரல்களைப் பயன்படுத்தலாம்: ஆசிரியர்கள், ஆசிரியர்_சார்ட், மொழி, வெளியீட்டாளர், குறிச்சொற்கள், தலைப்பு, தலைப்பு_சார்ட். வரிசையாக்கத்தை தீர்க்க அல்லது சிக்கல்களைக் காண்பிக்க சாதனங்களில் புத்தகங்களில் வெவ்வேறு மெட்டாடேட்டாவைப் பயன்படுத்த விரும்பும் நபர்களுக்கு இந்த அம்சம் உதவுகிறது.

நீங்கள் ஒரு செருகுநிரலை உருவாக்கும்போது, செருகுநிரல் பயன்படுத்த வேண்டிய வடிவம் மற்றும் சாதனத்தை நீங்கள் குறிப்பிடுகிறீர்கள். ஒரு சிறப்பு சாதனம் வழங்கப்படுகிறது, `` save_to_disk``, இது வடிவங்களைச் சேமிக்கும்போது பயன்படுத்தப்படுகிறது (அவற்றை ஒரு சாதனத்திற்கு அனுப்புவதற்கு மாறாக). நீங்கள் வடிவமைப்பு மற்றும் சாதனத்தைத் தேர்ந்தெடுத்ததும், மாற்றுவதற்கு மெட்டாடேட்டா புலங்களை தேர்வு செய்கிறீர்கள், புதிய மதிப்புகளை வழங்க வார்ப்புருக்களை வழங்குகிறீர்கள். இந்த வார்ப்புருக்கள் அவற்றின் இலக்கு புலங்களுடன் இணைக்கப்பட்டுள்ளன, எனவே பிளேப் போர்டுகள்` என்ற பெயர். இந்த வார்ப்புருக்களில் நீங்கள் நிச்சயமாக கலப்பு நெடுவரிசைகளைப் பயன்படுத்தலாம்.

செருகுநிரல்கள் மிகவும் நெகிழ்வானவை, மேலும் அவை ஒற்றை செயல்பாட்டு பயன்முறை, வார்ப்புரு நிரல் பயன்முறை, பொது நிரல் பயன்முறை அல்லது பைதான் வார்ப்புரு பயன்முறையில் எழுதப்படலாம்.

ஒரு செருகுநிரல் பொருந்தும் போது (உள்ளடக்க சேவையகம், வட்டில் சேமிக்கவும் அல்லது சாதனத்திற்கு அனுப்பவும்), கொடுக்கப்பட்ட வடிவம் மற்றும் சாதனத்திற்கு சரியான ஒன்றைத் தேர்வுசெய்ய காலிபர் வரையறுக்கப்பட்ட பிளேக் போர்டுகளைத் தேடுகிறது. எடுத்துக்காட்டாக, ஆண்ட்ராய்டு சாதனத்திற்கு அனுப்பப்படும் எபப் புத்தகத்திற்கு பொருத்தமான செருகுநிரலைக் கண்டுபிடிக்க, பின்வரும் தேடல் வரிசையைப் பயன்படுத்தி காலிபர் பிளேக் போர்டுகளைத் தேடுகிறார்:

வடிவமைப்பு மற்றும் சாதனத்தில் சரியான பொருத்தத்துடன் கூடிய செருகுநிரல், எ.கா., `` எபப்`` மற்றும் `` Android``
வடிவமைப்பில் சரியான பொருத்தம் மற்றும் சிறப்பு `` எந்த சாதனமும்` தேர்வு, எ.கா., `` எபப்`` மற்றும் `` எந்த சாதனமும்` `
சிறப்பு `` எந்த வடிவமும்` தேர்வு மற்றும் சாதனத்தில் சரியான பொருத்தம், எ.கா., எந்த வடிவமும்` மற்றும்` Android`
`` எந்த வடிவமும் `` எந்த சாதனமும்` `` `` `

குறிச்சொற்கள் மற்றும் ஆசிரியர்கள் துறைகள் சிறப்பு சிகிச்சையைக் கொண்டுள்ளன, ஏனெனில் இந்த இரண்டு துறைகளும் ஒன்றுக்கு மேற்பட்ட உருப்படிகளை வைத்திருக்க முடியும். ஒரு புத்தகத்தில் பல குறிச்சொற்கள் மற்றும் பல ஆசிரியர்கள் இருக்கலாம். இந்த இரண்டு புலங்களில் ஒன்று மாற்றப்பட வேண்டும் என்று நீங்கள் குறிப்பிடும்போது, ஒன்றுக்கு மேற்பட்ட உருப்படிகள் இருக்கிறதா என்று வார்ப்புருவின் முடிவு ஆராயப்படுகிறது. குறிச்சொற்களைப் பொறுத்தவரை, காலிபர் ஒரு கமாவைக் கண்டறிந்த இடங்களில் இதன் விளைவாக துண்டிக்கப்படுகிறது. எடுத்துக்காட்டாக, வார்ப்புரு `` த்ரில்லர், திகில்`` மதிப்பை உருவாக்கினால், இதன் விளைவாக இரண்டு குறிச்சொற்கள், `` த்ரில்லர்`` மற்றும் `` திகில்``. ஒரு குறிச்சொல்லின் நடுவில் கமாவை வைக்க வழி இல்லை.

ஆசிரியர்களுக்கும் இதே விஷயம் நிகழ்கிறது, ஆனால் வெட்டுக்கு வேறுபட்ட பாத்திரத்தைப் பயன்படுத்துதல், கமாவிற்கு பதிலாக ஒரு & (ஆம்பர்சண்ட்). எடுத்துக்காட்டாக, வார்ப்புரு `` வலைப்பதிவுகள், ஜோ & பதிவுகள், சூசன்`` மதிப்பை உருவாக்கினால், புத்தகம் இரண்டு ஆசிரியர்களுடன் முடிவடையும், `` வலைப்பதிவுகள், ஜோ`` மற்றும் இடுகைகள், சூசன்`. வார்ப்புரு `` வலைப்பதிவுகள், ஜோ; இடுகைகள், சூசன்`` மதிப்பை உருவாக்கினால், புத்தகத்தில் ஒரு எழுத்தாளர் ஒரு விசித்திரமான பெயரைக் கொண்டிருப்பார்.

பிளேப் போர்டுகள் புத்தகத்தில் எழுதப்பட்ட மெட்டாடேட்டாவை வட்டில் சேமிக்கும்போது அல்லது சாதனத்தில் எழுதும்போது பாதிக்கின்றன. கோப்பு பெயர்களை உருவாக்க `` வட்டில் சேமி `` வட்டுக்கு அனுப்பவும் `` `சாதனத்திற்கு அனுப்பவும். அதற்கு பதிலாக, பொருத்தமான விருப்பத்தேர்வுகள் சாளரத்தில் உள்ளிடப்பட்ட வார்ப்புருக்களைப் பயன்படுத்தி கோப்பு பெயர்கள் கட்டமைக்கப்படுகின்றன.

வார்ப்புருக்களில் செயல்பாடுகளைப் பயன்படுத்துதல் - ஒற்றை செயல்பாட்டு முறை¶

அந்த புலம் பொதுவாக தலைப்பு வழக்கில் இருக்கும்போது ஒரு புலத்தின் மதிப்பை மேல் விஷயத்தில் காண்பிக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். வார்ப்புரு செயல்பாடுகளை பயன்படுத்தி இதைச் செய்யலாம். எடுத்துக்காட்டாக, மேல் வழக்கில் தலைப்பைக் காண்பிக்க `` {தலைப்பு: பெரிய எழுத்து ()} `` போன்ற `` பெரிய எழுத்து`` செயல்பாட்டைப் பயன்படுத்தவும். தலைப்பு வழக்கில் இதைக் காட்ட, `` {தலைப்பு: டிட்லெகேஸ் ()} `` ஐப் பயன்படுத்தவும்.

``: `` க்குப் பிறகு, முதல் `` | `` அல்லது முன்னொட்டு/பின்னொட்டு எதுவும் பயன்படுத்தப்படாவிட்டால் ``} `` மூடுவதற்கு முன், செயல்பாடுகள் வார்ப்புருவின் வடிவமைப்பு பகுதிக்குச் செல்கின்றன. உங்களிடம் ஒரு வடிவம் மற்றும் செயல்பாட்டு குறிப்பு இரண்டும் இருந்தால், செயல்பாடு இரண்டாவது ``: `` க்குப் பிறகு வருகிறது. செயல்பாடுகள் வார்ப்புருவில் குறிப்பிடப்பட்டுள்ள நெடுவரிசையின் மதிப்பை மாற்றியமைக்கின்றன, பொருத்தமாக மாற்றியமைக்கப்படுகின்றன.

செயல்பாடுகளைப் பயன்படுத்துவதற்கான தொடரியல் ஒன்றாகும்

{lookup_name:function(arguments)}
{lookup_name:format:function(arguments)}
{lookup_name:function(arguments)|prefix|suffix}
{lookup_name:format:function(arguments)|prefix|suffix}

அடைப்புக்குறிகளைத் திறப்பதன் மூலமும் மூடுவதன் மூலமும் செயல்பாட்டு பெயர்கள் எப்போதும் பின்பற்றப்பட வேண்டும். சில செயல்பாடுகளுக்கு கூடுதல் மதிப்புகள் (வாதங்கள்) தேவைப்படுகின்றன, மேலும் இவை அடைப்புக்குறிக்குள் செல்கின்றன. வாதங்கள் காற்புள்ளிகளால் பிரிக்கப்படுகின்றன. நேரடி காற்புள்ளிகள் (உரையாக கமாக்கள், வாத பிரிப்பான்கள் அல்ல) ஒரு பின்சாய்வுப்பால் (`` ``) முன்னதாக இருக்க வேண்டும். கடைசி (அல்லது மட்டும்) வாதத்தில் உரை நிறைவு அடைப்புக்குறிப்பு இருக்க முடியாது.

வடிவமைப்பு விவரக்குறிப்புகள் மற்றும் முன்னொட்டு/பின்னொட்டுக்கு முன் செயல்பாடுகள் மதிப்பீடு செய்யப்படுகின்றன. ஒரு வடிவம் மற்றும் செயல்பாடு இரண்டையும் பயன்படுத்துவதற்கான எடுத்துக்காட்டுக்கு மேலும் கீழே காண்க.

** முக்கியமானது **: உங்களுக்கு நிரலாக்க அனுபவம் இருந்தால், `ஒற்றை செயல்பாட்டு பயன்முறையில் 'தொடரியல் நீங்கள் எதிர்பார்ப்பது அல்ல என்பதை நினைவில் கொள்க. சரங்கள் மேற்கோள் காட்டப்படவில்லை மற்றும் இடைவெளிகள் குறிப்பிடத்தக்கவை. அனைத்து வாதங்களும் மாறிலிகளாக கருதப்படுகின்றன; வெளிப்பாடுகள் எதுவும் இல்லை.

.

சில செயல்பாடுகளுக்கு வழக்கமான வெளிப்பாடுகள் தேவை. வார்ப்புரு மொழியில் வழக்கமான வெளிப்பாடு பொருத்தம் வழக்கு-உணர்வற்றது.

கீழேயுள்ள செயல்பாட்டு ஆவணங்களில், `` [ஏதாவது]*`` என்ற குறியீடு `` ஏதாவது`` பூஜ்ஜியமாக அல்லது அதற்கு மேற்பட்ட முறை மீண்டும் செய்யப்படலாம் என்பதாகும். குறியீட்டு `` [ஏதாவது]+`` என்பது `` ஏதாவது`` ஒன்று அல்லது அதற்கு மேற்பட்ட முறை மீண்டும் மீண்டும் செய்யப்படுகிறது (குறைந்தது ஒரு முறையாவது இருக்க வேண்டும்).

ஒற்றை செயல்பாட்டு பயன்முறையில் பயன்படுத்த நோக்கம் கொண்ட செயல்பாடுகள்:

`` மூலதனமாக்கவும் () `` - முதல் கடித மேல் வழக்கு மற்றும் மீதமுள்ள கீழ் வழக்குடன் மதிப்பை வழங்குகிறது.
`` கொண்டுள்ளது (முறை, உரை பொருத்தமாக இருந்தால், உரை பொருந்தவில்லை என்றால்) `` - வழக்கமான வெளிப்பாடு `` முறை`` உடன் மதிப்பு பொருந்துமா என்பதை சரிபார்க்கிறது. மாதிரி மதிப்புடன் பொருந்தினால் `` உரையை பொருத்தினால் உரையை வழங்குகிறது, இல்லையெனில் பொருந்தவில்லை என்றால் உரையை வழங்குகிறது.
`` எண்ணுங்கள் (பிரிப்பான்) `` - `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக மதிப்பை விளக்குகிறது மற்றும் பட்டியலில் உள்ள பொருட்களின் எண்ணிக்கையை வழங்குகிறது. பெரும்பாலான பட்டியல்கள் கமாவை பிரிப்பானாகப் பயன்படுத்துகின்றன, ஆனால் `` ஆசிரியர்கள்`` ஒரு ஆம்பர்சாண்டைப் பயன்படுத்துகிறார்கள் (&). எடுத்துக்காட்டுகள்: `` {குறிச்சொற்கள்: எண்ணிக்கை (,)} ``, `` {ஆசிரியர்கள்: எண்ணிக்கை (&)} ``. மாற்றுப்பெயர்கள்: `` கவுண்ட் () ``, `` பட்டியல்_கவுண்ட் () ``
`` {0: 5.2f} அல்லது {0:, d} `` `` அல்லது ` $ {0: 5, .2f} . வடிவமைப்பு வார்ப்புரு ` {0: `` உடன் தொடங்கி, மேலே உள்ள எடுத்துக்காட்டுகளைப் போலவே ``} `` உடன் முடிவடைய வேண்டும். விதிவிலக்கு: வடிவமைப்பு வார்ப்புருவில் ஒரு வடிவம் மட்டுமே இருந்தால், நீங்கள் முன்னணி "{0:" மற்றும் "}" ஐ பின்னால் விட்டுவிடலாம். வார்ப்புரு மொழி மற்றும் பைதான் ஆவணங்கள் <https://docs.python.org/3/library/string.html#formatstrings> _ மேலும் எடுத்துக்காட்டுகளுக்கு பார்க்கவும். வடிவமைப்பு தோல்வியுற்றால் வெற்று சரத்தை வழங்குகிறது.
`` haman_readable () `` - மதிப்பு ஒரு எண்ணாக இருக்க வேண்டும் என்று எதிர்பார்க்கிறது மற்றும் KB, MB, GB போன்றவற்றில் அந்த எண்ணைக் குறிக்கும் ஒரு சரத்தை வழங்குகிறது.
`` ifempty (காலியாக இருந்தால் உரை) `` - மதிப்பு காலியாக இல்லாவிட்டால், புலத்தின் மதிப்பைத் திருப்பி, இல்லையெனில் உரையை காலியாக இருந்தால் திரும்பவும்.
`` in_list (பிரிப்பான், [முறை, கண்டுபிடிக்கப்பட்ட_வல்,]* not_found_val) `` - `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக மதிப்பை விளக்கவும், பட்டியலில் உள்ள ஒவ்வொரு உருப்படிக்கும் எதிராக `` முறை`` சரிபார்க்கிறது. `` முறை`` ஒரு உருப்படியுடன் பொருந்தினால், `` find_val`` திரும்பவும், இல்லையெனில் `` not_found_val`` ஐத் தரவும். ஜோடி `` முறை`` மற்றும் `` find_value`` ஆகியவற்றை விரும்பிய அளவுக்கு மீண்டும் மீண்டும் செய்ய முடியும், இது உருப்படியின் மதிப்பைப் பொறுத்து வெவ்வேறு மதிப்புகளைத் தர அனுமதிக்கிறது. வடிவங்கள் வரிசையில் சரிபார்க்கப்படுகின்றன, மேலும் முதல் போட்டி திரும்பப் பெறப்படுகிறது.
`` மொழி_ஸ்ட்ரிங்ஸ் (உள்ளூர்மயமாக்கல்) -`மொழி பெயர்களைத் திருப்பி விடுங்கள் www.loc.gov/standards/iso639-2/php/code_list.php>`_ மதிப்பாக அனுப்பப்பட்டது. எடுத்துக்காட்டு: `` {மொழிகள்: மொழி_ஸ்ட்ரிங்ஸ் ()} ``. `` உள்ளூர்மயமாக்கல் பூஜ்ஜியமாக இருந்தால், சரங்களை ஆங்கிலத்தில் திருப்பித் தரவும். `` உள்ளூர்மயமாக்குதல்`` பூஜ்ஜியமாக இல்லாவிட்டால், தற்போதைய இடத்தின் மொழியில் உள்ள சரங்களை திருப்பித் தரவும். `` Lang_codes`` என்பது கமாவால் பிரிக்கப்பட்ட பட்டியல்.
`` list_item (குறியீட்டு, பிரிப்பான்) `` - `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட உருப்படிகளின் பட்டியலாக மதிப்பை 'குறியீட்டு உருப்படியைத் திருப்பித் தருகிறது. முதல் உருப்படி எண் பூஜ்ஜியம். கடைசி உருப்படி `` -1`` குறியீட்டைக் கொண்டுள்ளது `` பட்டியல்_இடெம் (-1, பிரிப்பான்) ``. உருப்படி பட்டியலில் இல்லை என்றால், வெற்று சரம் திரும்பும்.
`` தேடல் ([முறை, விசை,]* else_key) `` - வடிவங்கள் வரிசையில் மதிப்புக்கு எதிராக சரிபார்க்கப்படும். ஒரு முறை பொருந்தினால், `` KEY`` பெயரிட்ட புலத்தின் மதிப்பு திரும்பப் பெறப்படும். எந்த வடிவமும் பொருந்தவில்லை என்றால், `` else_key`` பெயரிட்ட புலத்தின் மதிப்பு திரும்பப் பெறப்படுகிறது. ஸ்விட்ச் ஐப் பார்க்கவும் (கீழே).
`` லோயர் மாடி () `` - புலத்தின் மதிப்பை சிறிய விஷயத்தில் வழங்குகிறது.
`` kation_to_stars (Use_half_stars) `` - மதிப்பீட்டை நட்சத்திரத்தின் சரமாக (`` ★ ``) எழுத்துக்களாக வழங்குகிறது. தனிப்பயன் மதிப்பீட்டு நெடுவரிசைகளுடன் கிடைக்கும் பகுதியளவு எண்களுக்கு அரை நட்சத்திர எழுத்துக்களை விரும்பினால், மதிப்பு 0 மற்றும் 5 க்கு இடையில் ஒரு எண்ணாக இருக்க வேண்டும்.
`` மறு (முறை, மாற்றீடு) `` - வழக்கமான வெளிப்பாட்டைப் பயன்படுத்திய பின் மதிப்பைத் திருப்பித் தரவும். மதிப்பில் `` முறை`` இன் அனைத்து நிகழ்வுகளும் `` மாற்று`` உடன் மாற்றப்படுகின்றன. வார்ப்புரு மொழி வழக்கு உணர்வற்ற பைதான் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்துகிறது <https://docs.python.org/3/library/re.html> _.
`` தேர்ந்தெடுக்கவும் (விசை) - ஐடி: மதிப்பு`` (காலிபர் `` அடையாளங்காட்டி` `வடிவம்) வடிவத்தைக் கொண்ட ஒவ்வொரு உருப்படியுடனும் கமாவால் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக மதிப்பை விளக்கவும். செயல்பாடு முதல் ஜோடியை ஐடியுடன் விசைக்கு சமமாகக் கண்டறிந்து தொடர்புடைய மதிப்பை வழங்குகிறது. ஐடி பொருந்தவில்லை என்றால், செயல்பாடு வெற்று சரத்தை வழங்குகிறது.
`` சுருக்கவும் (இடது எழுத்துக்கள், நடுத்தர உரை, வலது கைகள்) `` - மதிப்பின் சுருக்கப்பட்ட பதிப்பைத் திருப்பி விடுங்கள், இது மதிப்பின் தொடக்கத்திலிருந்து `` இடது எழுத்துக்கள்`` எழுத்துக்களைக் கொண்டுள்ளது, அதைத் தொடர்ந்து `` நடுத்தர உரை``, அதைத் தொடர்ந்து `` சரியான எழுத்துக்கள்` மதிப்பின் முடிவில் இருந்து. ` இடது எழுத்துக்கள்`` மற்றும் `` வலது எழுத்துக்கள்`` எதிர்மறையான முழு எண்களாக இருக்க வேண்டும். எடுத்துக்காட்டு: தலைப்பை அதிகபட்சம் 15 எழுத்துக்கள் நீளத்துடன் காண்பிக்க விரும்புகிறீர்கள் என்று வைத்துக் கொள்ளுங்கள். இதைச் செய்யும் ஒரு வார்ப்புரு `` {தலைப்பு: சுருக்கவும் (9,-, 5)} . `இவான்ஹோவின் காலங்களில் பண்டைய ஆங்கில சட்டங்கள்` என்ற தலைப்பைக் கொண்ட ஒரு புத்தகத்திற்கு, இதன் விளைவாக `பண்டைய மின்-அன்ஹோ`: தலைப்பின் முதல் 9 எழுத்துக்கள், ஒரு` `-, பின்னர் கடைசி 5 எழுத்துக்கள். மதிப்பின் நீளம் `` இடது எழுத்துக்கள்` + `` வலது எழுத்துக்கள்` + ஐ விட குறைவாக இருந்தால், `` நடுத்தர உரை`` இன் நீளம், மதிப்பு மாறாமல் திருப்பித் தரப்படும். எடுத்துக்காட்டாக, தி டோம் தலைப்பு மாற்றப்படாது.
`` str_in_list (பிரிப்பான், [சரம், find_val,]+ not_found_val) `` - `` பிரிப்பான்` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக மதிப்பை விளக்கவும், பின்னர் பட்டியலில் உள்ள ஒவ்வொரு மதிப்பிற்கும் எதிராக `` சரம்`` ஒப்பிடுக. `` சரம்`` ஒரு வழக்கமான வெளிப்பாடு அல்ல. `` சரம்`` எந்தவொரு பொருளுக்கும் சமமாக இருந்தால் (வழக்கைப் புறக்கணித்தல்) பின்னர் தொடர்புடைய `` find_val`` ஐத் தரவும். `` சரம்`` `` பிரிப்பான்கள்`` இருந்தால், அது ஒரு பட்டியலாகவும் கருதப்படுகிறது, மேலும் ஒவ்வொரு துணை மதிப்பும் சரிபார்க்கப்படுகிறது. `` சரம்`` மற்றும் `` ஃபென்ட்_வல்யூ`` ஜோடிகளை விரும்பிய பல முறை மீண்டும் மீண்டும் செய்யலாம், இது சரத்தின் மதிப்பைப் பொறுத்து வெவ்வேறு மதிப்புகளைத் தர அனுமதிக்கிறது. சரங்கள் எதுவும் பொருந்தவில்லை என்றால் `` not_found_value`` திரும்பப் பெறப்படுகிறது. சரங்கள் வரிசையில் சரிபார்க்கப்படுகின்றன. முதல் போட்டி திரும்பியது.
`` சப்யிடெம்கள் (start_index, end_index) -இந்த செயல்பாடு வகைகள் போன்ற குறிச்சொல் போன்ற படிநிலை உருப்படிகளின் பட்டியல்களை உடைக்கிறது. இது மதிப்பை குறிச்சொல் போன்ற உருப்படிகளின் கமாவால் பிரிக்கப்பட்ட பட்டியலாக விளக்குகிறது, அங்கு ஒவ்வொரு உருப்படியும் காலத்தால் பிரிக்கப்பட்ட பட்டியல். ஒவ்வொரு உருப்படியிலிருந்தும் `` start_index இலிருந்து `` END_INDEX`` வரையிலான கூறுகளை பிரித்தெடுப்பதன் மூலம் இது ஒரு புதிய பட்டியலை வழங்குகிறது, பின்னர் முடிவுகளை மீண்டும் ஒன்றிணைக்கிறது. நகல்கள் அகற்றப்படுகின்றன. காலத்தால் பிரிக்கப்பட்ட பட்டியலில் முதல் துணை சமநிலை பூஜ்ஜியத்தின் குறியீட்டைக் கொண்டுள்ளது. ஒரு குறியீடு எதிர்மறையாக இருந்தால், அது பட்டியலின் முடிவில் இருந்து கணக்கிடப்படுகிறது. ஒரு சிறப்பு விஷயமாக, பூஜ்ஜியத்தின் END_INDEX என்பது பட்டியலின் நீளமாக கருதப்படுகிறது.

எடுத்துக்காட்டுகள்:
- A.B.C கொண்ட #Genre நெடுவரிசையை அனுமானித்து:
  - `` {#genre: subitems (0,1)} `` திரும்பும் "a"
  - `` {#genre: subitems (0,2)} `` "A.B" ஐத் தருகிறது
  - `` {#genre: subitems (1,0)} `` `" B.C "ஐத் தருகிறது
- "A.B.C, D.E" கொண்ட #ஜென்ரே நெடுவரிசையை அனுமானித்து:
  - `` {#genre: subitems (0,1)} `` திரும்பும் "a, d"
  - `` {#genre: subitems (0,2)} `` திரும்பும் "A.B, D.E"
`` சப்ளிஸ்ட் (start_index, end_index, பிரிப்பான்) `` - `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக மதிப்பை விளக்கவும், `` start_index`` முதல் `` எண்ட்_இண்டெக்ஸ்` வரை உருப்படிகளிலிருந்து தயாரிக்கப்பட்ட புதிய பட்டியலைத் திருப்பி விடுங்கள் . முதல் உருப்படி எண் பூஜ்ஜியம். ஒரு குறியீடு எதிர்மறையாக இருந்தால், அது பட்டியலின் முடிவில் இருந்து கணக்கிடப்படுகிறது. ஒரு சிறப்பு விஷயமாக, பூஜ்ஜியத்தின் END_INDEX என்பது பட்டியலின் நீளமாக கருதப்படுகிறது.

குறிச்சொற்கள் நெடுவரிசை (இது கமாவால் பிரிக்கப்பட்டுள்ளது) "A, B, C" ஐக் கொண்டுள்ளது என்று கருதும் எடுத்துக்காட்டுகள்:
- `` {குறிச்சொற்கள்: சப்லிஸ்ட் (0,1, ,)} `` "ஏ" ஐத் தருகிறது
- `` {குறிச்சொற்கள்: சப்லிஸ்ட் (-1,0, ,)} `` "சி" ஐத் தருகிறது
- `` {குறிச்சொற்கள்: sublist (0, -1, ,)} `` "a, b" ஐத் தருகிறது
`` SWAP_AROUND_ARTICLES (பிரிப்பான்) `` - கட்டுரைகளுடன் மதிப்பை இறுதிவரை மாற்றுகிறது. மதிப்பு ஒரு பட்டியலாக இருக்கலாம், இந்த விஷயத்தில் பட்டியலில் உள்ள ஒவ்வொரு உருப்படியும் செயலாக்கப்படும். மதிப்பு ஒரு பட்டியல் என்றால், நீங்கள் `` பிரிப்பான்`` ஐ வழங்க வேண்டும். `` பிரிப்பான்`` வழங்கப்பட்டால், மதிப்பு ஒரு பட்டியல் அல்ல, ஒரு பட்டியல் அல்ல. கட்டுரைகள் என்பது` தலைப்பு_சார்ட்` உருவாக்க காலிபர் பயன்படுத்துகிறது.
`` swap_around_comma () `` - `` b, a`` என்ற படிவத்தின் மதிப்பைக் கொடுத்தால் `` a b``. LN, FN வடிவத்தில் பெயர்களை FN LN ஆக மாற்ற இது மிகவும் பயனுள்ளதாக இருக்கும். மதிப்பில் கமா இல்லை என்றால், செயல்பாடு மதிப்பை மாற்றாமல் வழங்குகிறது.
`` சுவிட்ச் ([முறை, மதிப்பு,]+ else_value) `` - ஒவ்வொரு `` வடிவத்திற்கும், மதிப்பு` ஜோடிக்கும், மதிப்பு வழக்கமான வெளிப்பாட்டுடன் `` முறை`` உடன் பொருந்துமா என்பதைச் சரிபார்க்கிறது, அப்படியானால் அதனுடன் தொடர்புடைய `` மதிப்பை வழங்குகிறது . `` பேட்டர்ன் பொருந்தவில்லை என்றால், `` Else_Value`` திரும்பியது. நீங்கள் விரும்பும் பல `` முறை, மதிப்பு` `ஜோடிகளைக் கொண்டிருக்கலாம். முதல் போட்டி திரும்பியது.
`` சோதிக்கவும் (காலியாக இல்லாவிட்டால் உரை, காலியாக இருந்தால் உரை) `` - `` காலியாக இல்லாவிட்டால் உரையை திருப்பி விடுங்கள்`` மதிப்பு காலியாக இல்லாவிட்டால், இல்லையெனில் `` காலமாக இருந்தால் உரையை திருப்பி விடுங்கள்``.
`` டைட்ட்லெஸ்கேஸ் () `` - தலைப்பு வழக்கில் புலத்தின் மதிப்பை வழங்குகிறது.
`` மொழிபெயர்ப்பு () `` - மூல புலத்தில் உள்ள சொற்களின் ஒலியை தோராயமாக மதிப்பிடுவதன் மூலம் உருவாகும் ஒரு லத்தீன் எழுத்துக்களில் ஒரு சரத்தைத் திருப்பி விடுங்கள். எடுத்துக்காட்டாக, மூல புலம் `` фёдор миха́йлович достоевский`` `` ஃபியோடோர் மிகைலோவிச் டோஸ்டோயீவ்ஸ்கி`` `` ஃபியோடர் மிகைலோவிச் டோஸ்டோயீஸ்கி.
`` பெரிய எழுத்து () `` - மேல் வழக்கில் புலத்தின் மதிப்பை வழங்குகிறது.

** அதே வார்ப்புருவில் செயல்பாடுகளையும் வடிவமைப்பையும் பயன்படுத்துதல் **

003` இல் உள்ளதைப் போல, முன்னணி பூஜ்ஜியங்களுடன் நீங்கள் காட்ட விரும்பும் ஒரு முழு எண்ணும் தனிப்பயன் நெடுவரிசை` #myint` உங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். இதைச் செய்வதற்கான ஒரு வழி 0> 3s` வடிவத்தைப் பயன்படுத்துவது. இருப்பினும், இயல்பாக ஒரு எண் (முழு எண் அல்லது மிதவை) பூஜ்ஜியத்திற்கு சமமாக இருந்தால், மதிப்பு வெற்று சரமாக காட்டப்படும், எனவே பூஜ்ஜிய மதிப்புகள் வெற்று சரத்தை உருவாக்கும், 000` அல்ல. நீங்கள் `` 000`` மதிப்புகளைக் காண விரும்பினால், வெற்று மதிப்பை மீண்டும் பூஜ்ஜியமாக மாற்ற வடிவமைப்பு சரம் மற்றும் `` ifempty`` செயல்பாடு இரண்டையும் பயன்படுத்துகிறீர்கள். வார்ப்புரு

{#myint:0>3s:ifempty(0)}

நீங்கள் முன்னொட்டு மற்றும் பின்னொட்டையும் பயன்படுத்தலாம் என்பதை நினைவில் கொள்க. எண் `` [003] `` அல்லது `` [000] `` என தோன்ற விரும்பினால், வார்ப்புருவைப் பயன்படுத்தவும்

{#myint:0>3s:ifempty(0)|[|]}

பொது நிரல் பயன்முறை¶

பொது நிரல் பயன்முறை (` ஜிபிஎம்`) வார்ப்புரு வெளிப்பாடுகளை` வார்ப்புரு மொழியில்` இல் எழுதப்பட்ட ஒரு நிரலுடன் மாற்றுகிறது. மொழியின் தொடரியல் பின்வரும் இலக்கணத்தால் வரையறுக்கப்படுகிறது

program         ::= 'program:' expression_list
expression_list ::= top_expression [ ';' top_expression ]*
top_expression  ::= or_expression
or_expression   ::= and_expression [ '||' and_expression ]*
and_expression  ::= not_expression [ '&&' not_expression ]*
not_expression  ::= [ '!' not_expression ]* | concatenate_expr
concatenate_expr::= compare_expr [ '&' compare_expr ]*
compare_expr    ::= add_sub_expr [ compare_op add_sub_expr ]
compare_op      ::= '==' | '!=' | '>=' | '>' | '<=' | '<' | 'in' | 'inlist' |
                    '==#' | '!=#' | '>=#' | '>#' | '<=#' | '<#'
add_sub_expr    ::= times_div_expr [ add_sub_op times_div_expr ]*
add_sub_op      ::= '+' | '-'
times_div_expr  ::= unary_op_expr [ times_div_op unary_op_expr ]*
times_div_op    ::= '*' | '/'
unary_op_expr   ::= [ add_sub_op unary_op_expr ]* | expression
expression      ::= identifier | constant | function | assignment | field_reference |
                    if_expr | for_expr | break_expr | continue_expr |
                    '(' expression_list ')' | function_def
field_reference ::= '$' [ '$' ] [ '#' ] identifier
identifier      ::= id_start [ id_rest ]*
id_start        ::= letter | underscore
id_rest         ::= id_start | digit
constant        ::= " string " | ' string ' | number
function        ::= identifier '(' expression_list [ ',' expression_list ]* ')'
function_def    ::= 'def' identifier '(' top_expression [ ',' top_expression ]* ')' ':'
                    expression_list 'fed'
assignment      ::= identifier '=' top_expression
if_expr         ::= 'if' condition 'then' expression_list
                    [ elif_expr ] [ 'else' expression_list ] 'fi'
condition       ::= top_expression
elif_expr       ::= 'elif' condition 'then' expression_list elif_expr | ''
for_expr        ::= for_list | for_range
for_list        ::= 'for' identifier 'in' list_expr
                    [ 'separator' separator_expr ] ':' expression_list 'rof'
for_range       ::= 'for' identifier 'in' range_expr ':' expression_list 'rof'
range_expr      ::= 'range' '(' [ start_expr ',' ] stop_expr
                    [ ',' step_expr [ ',' limit_expr ] ] ')'
list_expr       ::= top_expression
break_expr      ::= 'break'
continue_expr   ::= 'continue'
separator_expr  ::= top_expression
start_expr      ::= top_expression
stop_expr       ::= top_expression
step_expr       ::= top_expression
limit_expr      ::= top_expression

குறிப்புகள்:

ஒரு `` Top_Expression`` எப்போதும் ஒரு மதிப்பைக் கொண்டுள்ளது. `` எக்ஸ்பிரஷன்_லிஸ்ட்`` இன் மதிப்பு என்பது பட்டியலில் உள்ள கடைசி `` டாப்_எக்ஸ்பிரஷன்`` மதிப்பு. எடுத்துக்காட்டாக, வெளிப்பாடு பட்டியலின் மதிப்பு `` 1; 2; 'foobar'; 3`` என்பது `` 3``.
ஒரு தர்க்கரீதியான சூழலில், எந்தவொரு காலியாக இல்லாத மதிப்பும் `` உண்மை``
ஒரு தர்க்கரீதியான சூழலில், வெற்று மதிப்பு `` பொய்``
சரங்கள் மற்றும் எண்களை ஒன்றுக்கொன்று மாற்றாகப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, `` 10`` மற்றும் `` '10'` ஒரே விஷயம்.
கருத்துகள் '#' எழுத்துடன் தொடங்கும் வரிகள். பின்னர் ஒரு வரியில் தொடங்கும் கருத்துகள் ஆதரிக்கப்படவில்லை.

** ஆபரேட்டர் முன்னுரிமை **

ஆபரேட்டர் முன்னுரிமை (மதிப்பீட்டின் வரிசை) மிக உயர்ந்த (முதலில் மதிப்பீடு செய்யப்பட்டது) முதல் மிகக் குறைந்த (கடைசியாக மதிப்பீடு செய்யப்பட்டது):

செயல்பாட்டு அழைப்புகள், மாறிலிகள், அடைப்புக்குறிப்பு வெளிப்பாடுகள், அறிக்கை வெளிப்பாடுகள், ஒதுக்கீட்டு வெளிப்பாடுகள், புல குறிப்புகள்.
யுனரி பிளஸ் (+) மற்றும் கழித்தல் (`` -``). இந்த ஆபரேட்டர்கள் வலமிருந்து இடமாக மதிப்பீடு செய்கிறார்கள்.

வெளிப்பாடு பூஜ்ஜியத்திற்கு சமமான ஒரு பகுதியளவு காரணமாக இருந்தால் இந்த மற்றும் பிற எண்கணித ஆபரேட்டர்கள் முழு எண்களைத் தருகின்றன. எடுத்துக்காட்டாக, ஒரு வெளிப்பாடு `` 3.0`` திரும்பினால் அது `` 3`` என மாற்றப்படுகிறது.
பெருக்கி (*) பிரிக்கவும் (/). இந்த ஆபரேட்டர்கள் துணை மற்றும் இடமிருந்து வலமாக மதிப்பீடு செய்கிறார்கள். மதிப்பீட்டின் வரிசையை மாற்ற விரும்பினால் அடைப்புக்குறிப்புகள் பயன்படுத்தவும்.
(+) சேர்த்து கழிக்கவும் (`` -``). இந்த ஆபரேட்டர்கள் துணை மற்றும் இடமிருந்து வலமாக மதிப்பீடு செய்கிறார்கள்.
எண் மற்றும் சரம் ஒப்பீடுகள். இந்த ஆபரேட்டர்கள் ஒப்பீடு வெற்றி பெற்றால் `` '1'`` திருப்பித் தருகின்றன, இல்லையெனில் வெற்று சரம் (' '). ஒப்பீடுகள் துணை அல்ல: `` a <b <c`` என்பது ஒரு தொடரியல் பிழை.
சரம் ஒருங்கிணைப்பு (`` & ). `` & `` ஆபரேட்டர் இடது கை மற்றும் வலது கை வெளிப்பாடுகளை ஒருங்கிணைப்பதன் மூலம் உருவாக்கப்பட்ட ஒரு சரத்தை வழங்குகிறது. எடுத்துக்காட்டு: `` 'aaa' & 'BBB'` ' 'aaabbb'`. ஆபரேட்டர் துணை மற்றும் இடமிருந்து வலமாக மதிப்பீடு செய்கிறார்.
Unary logalor not (! ``). இந்த ஆபரேட்டர் வெளிப்பாடு தவறானது என்றால் `` '1' திருப்பித் தருகிறது (வெற்று சரத்தை மதிப்பிடுகிறது), இல்லையெனில் ' '.
தர்க்கரீதியான மற்றும் (`` && ``). இடது கை மற்றும் வலது கை வெளிப்பாடுகள் இரண்டும் உண்மையாக இருந்தால், அல்லது வெற்று சரம் '' ஆகியவை பொய்யானதாக இருந்தால் இந்த ஆபரேட்டர் '1' ஐ வழங்குகிறது. இது துணை, இடமிருந்து வலமாக மதிப்பீடு செய்கிறது, மேலும் `குறுகிய சுற்று <https://chortle.ccsu.edu/java5/notes/chap40/ch40_2.html> _.
தர்க்கரீதியான அல்லது (`` || ). இந்த ஆபரேட்டர் `` '1' இடது கை அல்லது வலது கை வெளிப்பாடு உண்மையாக இருந்தால், அல்லது இரண்டும் பொய்யானதாக இருந்தால் ' ' `` `` `` `` . இது துணை, இடமிருந்து வலமாக மதிப்பீடு செய்கிறது, மேலும் `குறுகிய சுற்று <https://chortle.ccsu.edu/java5/notes/chap40/ch40_2.html> _. இது ஒரு உள்ளடக்கிய அல்லது, இடது மற்றும் வலது கை வெளிப்பாடுகள் இரண்டும் உண்மையாக இருந்தால்` '1' திரும்பும்.

** புல குறிப்புகள் **

`` `` அல்லது $$ `` `` ஆகியவற்றைப் பின்தொடரும் தேடல் பெயரால் பெயரிடப்பட்ட மெட்டாடேட்டா புலத்தின் மதிப்பை ஒரு புலம்_பிறப்புக்கு மதிப்பீடு செய்கிறது. `` $ `` பயன்படுத்துவது `` புலம் () `` செயல்பாட்டைப் பயன்படுத்துவதற்கு சமம். `` $$ `` பயன்படுத்துவது `` ரா_ஃபீல்ட்`` செயல்பாட்டைப் பயன்படுத்துவதற்கு சமம். எடுத்துக்காட்டுகள்

* $authors ==> field('authors')
* $#genre ==> field('#genre')
* $$pubdate ==> raw_field('pubdate')
* $$#my_int ==> raw_field('#my_int')

** வெளிப்பாடுகள் என்றால் **

`` If` வெளிப்பாடுகள் முதலில் நிபந்தனையை` மதிப்பீடு செய்கின்றன. `` நிபந்தனை`` உண்மையாக இருந்தால் (காலியாக இல்லாத மதிப்பு) பின்னர் `` பின்னர்`` பிரிவில் உள்ள `` வெளிப்பாடு_லிஸ்ட்`` மதிப்பீடு செய்யப்படுகிறது. அது தவறானது என்றால், `` எலிஃப்`` அல்லது `` வேறு`` பிரிவு மதிப்பீடு செய்யப்பட்டால் `` எக்ஸ்பிரஷன்_லிஸ்ட்` வழங்கினால். `` Elif`` மற்றும் `` வேறு`` பாகங்கள் விருப்பமானவை. `` If``, `` பின்னர்``, `` elif``, `` வேறு``, மற்றும் `` fi`` ஆகிய சொற்கள் ஒதுக்கப்பட்டுள்ளன; நீங்கள் அவற்றை அடையாளங்காட்டி பெயர்களாகப் பயன்படுத்த முடியாது. புதிய லைன்களையும் வெள்ளை இடத்தையும் அவர்கள் எங்கு அர்த்தப்படுத்தினாலும் நீங்கள் வைக்கலாம். `` நிபந்தனை`` என்பது ஒரு `` டாப்_எக்ஸ்பிரஷன்`` ஒரு `` வெளிப்பாடு_லிஸ்ட்``; அரைக்காற்புள்ளிகள் அனுமதிக்கப்படவில்லை. `` எக்ஸ்பிரஷன்_லிஸ்ட்கள்`` என்பது `` டாப்_எக்ஸ்பிரஸ்ஷன்கள்`` இன் அரைக்காற்புள்ளியால் பிரிக்கப்பட்ட காட்சிகள். ஒரு `` if`` வெளிப்பாடு மதிப்பிடப்பட்ட `` எக்ஸ்பிரஷன்_லிஸ்ட்`` அல்லது வெளிப்பாடு பட்டியல் மதிப்பீடு செய்யப்படாவிட்டால் வெற்று சரம் ஆகியவற்றில் கடைசி `` டாப்_எக்ஸ்பிரஷன்`` இன் முடிவை வழங்குகிறது.

எடுத்துக்காட்டுகள்

* program: if field('series') then 'yes' else 'no' fi
* program:
      if field('series') then
          a = 'yes';
          b = 'no'
      else
          a = 'no';
          b = 'yes'
      fi;
      strcat(a, '-', b)

உள்ளமை `` if`` எடுத்துக்காட்டு

program:
  if field('series') then
    if check_yes_no(field('#mybool'), '', '', '1') then
      'yes'
    else
      'no'
    fi
  else
    'no series'
  fi

மேலே கூறியது போல், ஒரு `` if`` ஒரு மதிப்பை உருவாக்குகிறது. இதன் பொருள் பின்வருபவை அனைத்தும் சமமானவை

* program: if field('series') then 'foo' else 'bar' fi
* program: if field('series') then a = 'foo' else a = 'bar' fi; a
* program: a = if field('series') then 'foo' else 'bar' fi; a

கடைசி எடுத்துக்காட்டு, இந்த நிரல் புத்தகத்தில் ஒரு தொடர் இருந்தால் `` தொடர்` நெடுவரிசையின் மதிப்பை வழங்குகிறது, இல்லையெனில் `` தலைப்பு` நெடுவரிசையின் மதிப்பு

program: field(if field('series') then 'series' else 'title' fi)

** வெளிப்பாடுகளுக்கு **

`` வெளிப்பாடு மதிப்புகளின் பட்டியலை மீண்டும் செயல்படுத்துகிறது, அவற்றை ஒரு நேரத்தில் செயலாக்குகிறது. ` பட்டியல்_எக்ஸ்பிரஷன்`` ஒரு மெட்டாடேட்டா புலம் `` தேடல் பெயர்`` எ.கா., `` குறிச்சொற்கள்``` அல்லது #வகை` அல்லது மதிப்புகளின் பட்டியலுக்கு மதிப்பீடு செய்ய வேண்டும். தி: ரெஃப்: ரேஞ்ச் () செயல்பாடு <range_function> (கீழே காண்க) எண்களின் பட்டியலை உருவாக்குகிறது. இதன் விளைவாக செல்லுபடியாகும் `` தேடல் பெயர்`` என்றால், புலத்தின் மதிப்பு பெறப்பட்டு, அந்த புல வகைக்கு குறிப்பிடப்பட்ட பிரிப்பான் பயன்படுத்தப்படுகிறது. முடிவு சரியான தேடல் பெயர் இல்லையென்றால், அது மதிப்புகளின் பட்டியல் என்று கருதப்படுகிறது. விருப்பமான முக்கிய சொல் `` பிரிப்பான்`` வழங்கப்படாவிட்டால், பட்டியல் காற்புள்ளிகளால் பிரிக்கப்படுவதாக கருதப்படுகிறது, இந்த விஷயத்தில் `` பிரிப்பான்_எக்ஸ்பிஆர்`` மதிப்பிட்டதன் விளைவாக பட்டியல் மதிப்புகள் பிரிக்கப்பட வேண்டும். பட்டியல் `` வரம்பு () `` ஆல் உருவாக்கப்பட்டால் ஒரு பிரிப்பான் பயன்படுத்த முடியாது. பட்டியலில் உள்ள ஒவ்வொரு மதிப்பும் குறிப்பிட்ட மாறிக்கு ஒதுக்கப்படுகிறது, பின்னர் `` எக்ஸ்பிரஷன்_லிஸ்ட்`` மதிப்பீடு செய்யப்படுகிறது. வளையத்திலிருந்து வெளியேற நீங்கள் `` பிரேக்`` ஐப் பயன்படுத்தலாம், மேலும் அடுத்த மறு செய்கைக்காக வளையத்தின் தொடக்கத்திற்கு செல்ல `` தொடரவும்.

எடுத்துக்காட்டு: இந்த வார்ப்புரு வகையின் ஒவ்வொரு மதிப்புக்கும் முதல் படிநிலை பெயரை நீக்குகிறது (#வகை), புதிய பெயர்களுடன் ஒரு பட்டியலை உருவாக்குகிறது

program:
  new_tags = '';
  for i in '#genre':
    j = re(i, '^.*?\.(.*)$', '\1');
    new_tags = list_union(new_tags, j, ',')
  rof;
  new_tags

அசல் வகை வரலாறு. இராணுவம், அறிவியல் புனைகதை. மாற்றியமைத்தல் வரலாறு என்றால், ரீட்மே பின்னர் வார்ப்புரு` இராணுவம், மாற்று வரலாறு, ரீட்மே` ஐ வழங்குகிறது. இந்த வார்ப்புருவை நீங்கள் காலிபர்: கிலாபெல்: மெட்டாடேட்டாவை மொத்தமாகத் திருத்து -> தேடல் & மாற்றவும் உடன்: கிலாபெல்:` தேடலைத் தேடுங்கள் `` வார்ப்புரு`` ஐத் தேடுங்கள் வரிசைக்கு முதல் மட்டத்தை அகற்றவும், அதன் விளைவாக மதிப்பை ஒதுக்கவும் வகைக்கு.

குறிப்பு: வார்ப்புருவின் கடைசி வரி, `` புதிய_டாக்ஸ்``, இந்த விஷயத்தில் கண்டிப்பாக அவசியமில்லை, ஏனெனில் `` `` `` வெளிப்பாடு பட்டியலில் கடைசி டாப்_எக்ஸ்பிரஷனின் மதிப்பை வழங்குகிறது. ஒரு வேலையின் மதிப்பு அதன் வெளிப்பாட்டின் மதிப்பு, எனவே ` `` அறிக்கையின் மதிப்பு `` புதிய_டேக்ஸ்`` க்கு ஒதுக்கப்பட்டது.

** செயல்பாட்டு வரையறை **

மீண்டும் மீண்டும் வரும் ஒரு வார்ப்புருவில் குறியீடு இருந்தால், அந்த குறியீட்டை உள்ளூர் செயல்பாட்டில் வைக்கலாம். `` Def`` முக்கிய சொல் வரையறையைத் தொடங்குகிறது. அதைத் தொடர்ந்து செயல்பாட்டு பெயர், வாத பட்டியல், பின்னர் செயல்பாட்டில் உள்ள குறியீடு. செயல்பாட்டு வரையறை `` ஃபெட்`` முக்கிய சொல்லுடன் முடிகிறது.

வாதங்கள் நிலை. ஒரு செயல்பாடு என அழைக்கப்படும் போது, வழங்கப்பட்ட வாதங்கள் வரையறுக்கப்பட்ட அளவுருக்களுக்கு எதிராக இடமிருந்து வலமாக பொருந்துகின்றன, அளவுருவுக்கு ஒதுக்கப்பட்ட வாதத்தின் மதிப்பு. வரையறுக்கப்பட்ட அளவுருக்களைக் காட்டிலும் அதிகமான வாதங்களை வழங்குவது பிழை. அளவுருக்கள் `` a = 25`` போன்ற இயல்புநிலை மதிப்புகளைக் கொண்டிருக்கலாம். அந்த அளவுருவுக்கு ஒரு வாதம் வழங்கப்படாவிட்டால், இயல்புநிலை மதிப்பு பயன்படுத்தப்படுகிறது, இல்லையெனில் அளவுரு வெற்று சரத்திற்கு அமைக்கப்படுகிறது.

`` திரும்ப`` அறிக்கையை உள்ளூர் செயல்பாட்டில் பயன்படுத்தலாம்.

ஒரு செயல்பாடு பயன்படுத்தப்படுவதற்கு முன்பு வரையறுக்கப்பட வேண்டும்.

எடுத்துக்காட்டு: இந்த வார்ப்புரு பல நாட்களிலிருந்து ஆண்டுகள், மாதங்கள் மற்றும் நாட்களில் தோராயமான காலத்தைக் கணக்கிடுகிறது. `` To_plural () `` கணக்கிடப்பட்ட மதிப்புகளை வடிவமைக்கிறது. எடுத்துக்காட்டு `` & `` ஆபரேட்டர்

program:
      days = 2112;
      years = floor(days/360);
      months = floor(mod(days, 360)/30);
      days = days - ((years*360) + (months * 30));

      def to_plural(v, str):
              if v == 0 then return '' fi;
              return v & ' ' & (if v == 1 then str else str & 's' fi) & ' '
      fed;

      to_plural(years, 'year') & to_plural(months, 'month') & to_plural(days,'day')

** தொடர்புடைய ஆபரேட்டர்கள் **

தொடர்புடைய ஆபரேட்டர்கள் ஒப்பீடு உண்மையாக இருந்தால் `` '1'`` திருப்பித் தருகின்றன, இல்லையெனில் வெற்று சரம் (' ').

தொடர்புடைய ஆபரேட்டர்களின் இரண்டு வடிவங்கள் உள்ளன: சரம் ஒப்பீடுகள் மற்றும் எண் ஒப்பீடுகள்.

சரம் ஒப்பீடுகள் லெக்சிகல் வரிசையைப் பயன்படுத்தி வழக்கு-உணர்வற்ற சரம் ஒப்பீடு செய்கின்றன. ஆதரிக்கப்படும் சரம் ஒப்பீட்டு ஆபரேட்டர்கள் `` == , ``! `, மற்றும்` `inlist. `` இன்` ஆபரேட்டருக்கு, இடது கை வெளிப்பாட்டின் விளைவாக ஒரு வழக்கமான வெளிப்பாடு வடிவமாக விளக்கப்படுகிறது. இடது கை வழக்கமான வெளிப்பாட்டின் மதிப்பு வலது கை வெளிப்பாட்டின் மதிப்புடன் பொருந்தினால் `` இன்`` ஆபரேட்டர் உண்மை. இடது கை வழக்கமான வெளிப்பாடு வலது கை பட்டியலில் உள்ள எந்தவொரு உருப்படிகளையும் கம்மாக்களால் பிரிக்கக்கூடியதாக இருந்தால் `` inlist`` ஆபரேட்டர் உண்மை. போட்டிகள் வழக்கு-உணர்வற்றவை.

எண் ஒப்பீட்டு ஆபரேட்டர்கள் `` ==#``, ``! . இடது மற்றும் வலது வெளிப்பாடுகள் இரண்டு விதிவிலக்குகளுடன் எண் மதிப்புகளுக்கு மதிப்பீடு செய்ய வேண்டும்: சரம் மதிப்பு "எதுவுமில்லை" (வரையறுக்கப்படாத புலம்) மற்றும் வெற்று சரம் ஆகிய இரண்டும் மதிப்பு பூஜ்ஜியத்திற்கு மதிப்பீடு செய்கின்றன.

எடுத்துக்காட்டுகள்:

`` நிரல்: புலம் ('தொடர்') == 'foo'`` புத்தகத்தின் தொடர்' foo 'என்றால் ``' 1'` திரும்பும், இல்லையெனில் `` '' ``.

`` நிரல்: 'F.O.R' புலத்தில் ('தொடர்') `` புத்தகத் தொடர் வழக்கமான வெளிப்பாட்டுடன் பொருந்தினால் `` f.o`` (எ.கா., ஃபூ,` ஆஃப் ஓனிக்ஸ்`, போன்றவை .), இல்லையெனில் `` '' ``.

`` நிரல்: 'அறிவியல்' இன்லிச்ட் புலம் ('#வகை') `` புத்தகத்தின் வகைகள் ஏதேனும் வழக்கமான வெளிப்பாட்டுடன் பொருந்தினால் `` '1'``, எ.கா., அறிவியல்,` வரலாறு அறிவியல்`, அறிவியல் புனைகதை போன்றவை, இல்லையெனில்` '' `.

`` நிரல்: '^சயின்ஸ் $' இன்லிஸ்ட் புலம் ('#வகை') `` `` '1'`` புத்தகத்தின் எந்தவொரு வகைகளும் வழக்கமான வெளிப்பாட்டுடன் சரியாக பொருந்தினால், ^அறிவியல் $ , எ.கா., அறிவியல் . `அறிவியலின் வரலாறு மற்றும்` அறிவியல் புனைகதை` வகைகள் பொருந்தவில்லை. ஒரு போட்டி இல்லையென்றால் `` '' `` `திரும்பும்.

`` நிரல்: புலம் ('தொடர்')! இல்லையெனில் அது `` 'முணுமுணுப்பு'`` தருகிறது.

`` நிரல்: புலம் ('தொடர்') == 'ஃபூ' || புலம் ('தொடர்') == '1632' பின்னர் 'ஆம்' வேறு 'இல்லை' fi`` திரும்பும் `` 'ஆம்'`` என்றால் தொடர் ' 'foo' அல்லது ' 1632', இல்லையெனில் `` 'இல்லை'``.

`` நிரல்: if '^(foo | 1632) $' புலத்தில் ('தொடர்') பின்னர் 'ஆம்' வேறு 'இல்லை' fi`` திரும்புகிறது `` 'ஆம்'`` அல்லது '1632'`, இல்லையெனில்` ' இல்லை'.

`` நிரல்: 11> 2 என்றால் 'ஆம்' வேறு 'இல்லை' fi`` `` 'இல்லை'` திரும்பி வருவதால் ``> `` ஆபரேட்டர் ஒரு சொற்பொழிவு ஒப்பீட்டைச் செய்கிறார்.

`` நிரல்: 11># 2 என்றால் 'ஆம்' வேறு 'இல்லை' fi`` `` 'ஆம்'`` திரும்பி வருகிறார், ஏனெனில் ``># `` ஆபரேட்டர் ஒரு எண் ஒப்பீட்டைச் செய்கிறார்.

** கூடுதல் கிடைக்கக்கூடிய செயல்பாடுகள் **

விவரிக்கப்பட்டுள்ளவற்றுடன் கூடுதலாக பின்வரும் செயல்பாடுகள் கிடைக்கின்றன: குறிப்பு: ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>.

ஜிபிஎம் இல்` ஒற்றை செயல்பாட்டு பயன்முறையில் 'விவரிக்கப்பட்டுள்ள செயல்பாடுகள் அனைத்தும் செயல்படுவதற்கான மதிப்பைக் குறிப்பிடும் கூடுதல் முதல் அளவுரு தேவைப்படுகிறது. அனைத்து அளவுருக்கள் வெளிப்பாடு_ பட்டியல்கள் (மேலே உள்ள இலக்கணத்தைக் காண்க).

`` சேர் (x [, y]*) `` - அதன் வாதங்களின் தொகையை வழங்குகிறது. ஒரு வாதம் ஒரு எண்ணாக இல்லாவிட்டால் விதிவிலக்கை வீசுகிறது. பெரும்பாலான சந்தர்ப்பங்களில் நீங்கள் இந்த செயல்பாட்டிற்கு பதிலாக + ஆபரேட்டரைப் பயன்படுத்தலாம்.
`` மற்றும் (மதிப்பு [, மதிப்பு]*) `` - எல்லா மதிப்புகளும் காலியாக இல்லாவிட்டால், "1" என்ற சரத்தை வழங்குகிறது, இல்லையெனில் வெற்று சரத்தை வழங்குகிறது. நீங்கள் விரும்பும் பல மதிப்புகளை நீங்கள் கொண்டிருக்கலாம். பெரும்பாலான சந்தர்ப்பங்களில் நீங்கள் இந்த செயல்பாட்டிற்கு பதிலாக `` && ஆபரேட்டரைப் பயன்படுத்தலாம். `` மற்றும்`` ஐ `` && `` உடன் மாற்றக்கூடாது என்பதற்கு ஒரு காரணம், குறுகிய சுற்று பக்க விளைவுகளின் காரணமாக முடிவுகளை மாற்ற முடியும் என்றால். எடுத்துக்காட்டாக, `` மற்றும் (a = '', b = 5) `` எப்போதும் இரண்டு பணிகளையும் செய்யும், அங்கு `` && `ஆபரேட்டர் இரண்டாவது செய்ய மாட்டார்கள்.
`` ஒதுக்கு (ஐடி, வால்) `` - `` ஐடி`` க்கு `` வால்`` ஒதுக்குகிறது, பின்னர் `` வால்`` ஐ வழங்குகிறது. `` ஐடி`` ஒரு அடையாளங்காட்டியாக இருக்க வேண்டும், ஒரு வெளிப்பாடு அல்ல. பெரும்பாலான சந்தர்ப்பங்களில் நீங்கள் இந்த செயல்பாட்டிற்கு பதிலாக `` = `` ஆபரேட்டரைப் பயன்படுத்தலாம்.
`` தோராயமான_ஃபார்மேட்ஸ் () ``-புத்தகத்துடன் தொடர்புடைய வடிவங்களின் கமாவால் பிரிக்கப்பட்ட பட்டியலைத் தரவும். பட்டியல் சரியானது என்பதற்கு எந்த உத்தரவாதமும் இல்லை, அது அநேகமாக இருந்தாலும். இது மற்றும் பிற பூஜ்ஜிய-அளவுரு செயல்பாடுகளை வார்ப்புரு நிரல் பயன்முறையில் (கீழே காண்க) `` {: 'தோராயமான_பிரேதங்கள் ()'} `` ஆகியவற்றைப் பயன்படுத்தி அழைக்கலாம். இதன் விளைவாக வரும் வடிவமைப்பு பெயர்கள் எபப் போலவே எப்போதும் பெரிய எழுத்தாளர்களாக இருக்கும் என்பதை நினைவில் கொள்க. `` தோராயமான_ வடிவங்கள் () `` செயல்பாடு `` வடிவங்கள் _... `` கீழே விவாதிக்கப்பட்ட செயல்பாடுகளை விட கணிசமாக வேகமானது.
`` author_links (val_separator, ஜோடி_சப்பரேட்டர்) `` - ஆசிரியர்கள் மற்றும் அந்த ஆசிரியர்களின் இணைப்பு மதிப்புகள் கொண்ட ஒரு சரத்தை படிவத்தில் வழங்குகிறது
```
author1 val_separator author1_link pair_separator author2 val_separator author2_link etc.
```
ஒரு எழுத்தாளர் அதன் இணைப்பு மதிப்பிலிருந்து `` val_separator`` சரம் கூடுதல் இடங்கள் இல்லாமல் பிரிக்கப்படுகிறார். `` ஆசிரியர்: லிங்க்வால்யூ`` ஜோடிகள் கூடுதல் இடைவெளிகள் இல்லாமல் `` ஜோடி_சபரேட்டர்`` சரம் வாதத்தால் பிரிக்கப்படுகின்றன. ஆசிரியர் பெயர்கள் அல்லது இணைப்புகளில் ஏற்படாத பிரிப்பான் சரங்களைத் தேர்ந்தெடுப்பது உங்களுடையது. ஆசிரியர் இணைப்பு காலியாக இருந்தாலும் ஒரு ஆசிரியர் சேர்க்கப்படுவார்.
`` author_sorts (val_separator) `` - புத்தகத்தின் ஆசிரியர்களுக்கான ஆசிரியரின் வரிசை மதிப்புகளின் பட்டியலைக் கொண்ட ஒரு சரத்தை வழங்குகிறது. ஆசிரியர் மெட்டாடேட்டா தகவல்களில் (புத்தகங்களில் உள்ள ஆசிரியர்_சார்ட்டிலிருந்து வேறுபட்டது). திரும்பிய பட்டியலில் `` ஆசிரியர் வரிசை 1`` `` val_separator`` ஆசிரியர் வரிசைப்படுத்தல் 2` போன்ற படிவங்கள் உள்ளன. இந்த பட்டியலில் ஆசிரியர் வரிசைப்படுத்தப்பட்ட மதிப்புகள் புத்தகத்தின் ஆசிரியர்களின் அதே வரிசையில் உள்ளன. `` Val_separator`` ஐச் சுற்றியுள்ள இடைவெளிகளை நீங்கள் விரும்பினால், அவற்றை `` val_separator`` சரத்தில் சேர்க்கவும்.
`` book_count (வினவல், use_vl) `` - `` வினவல்`` தேடுவதன் மூலம் கண்டுபிடிக்கப்பட்ட புத்தகங்களின் எண்ணிக்கையை வழங்குகிறது. `` Use_vl`` `` 0`` (பூஜ்ஜியம்) என்றால் மெய்நிகர் நூலகங்கள் புறக்கணிக்கப்படும். இந்த செயல்பாடு மற்றும் அதன் தோழர் `` book_values () `` வார்ப்புரு தேடல்களில் குறிப்பாக பயனுள்ளதாக இருக்கும், இது ஒரே ஒரு புத்தகத்துடன் தொடர்களைத் தேடுவது போன்ற பல புத்தகங்களிலிருந்து தகவல்களை இணைக்கும் தேடல்களை ஆதரிக்கிறது. `` Allow_template_database_functions_in_composites`` என்ற மாற்றங்கள் உண்மைக்கு அமைக்கப்படாவிட்டால், கலப்பு நெடுவரிசைகளில் இதைப் பயன்படுத்த முடியாது. இதை GUI இல் மட்டுமே பயன்படுத்த முடியும்.

எடுத்துக்காட்டாக, இந்த வார்ப்புரு தேடல் இந்த செயல்பாட்டையும் அதன் தோழரையும் ஒரே ஒரு புத்தகத்துடன் மட்டுமே கண்டுபிடிக்க பயன்படுத்துகிறது:
1. சேமிக்கப்பட்ட வார்ப்புருவை வரையறுக்கவும் (பயன்படுத்துதல்: கிலாபெல்: விருப்பத்தேர்வுகள்-> மேம்பட்ட-> வார்ப்புரு செயல்பாடுகள்) வார்ப்புரு
```
program:
    vals = globals(vals='');
    if !vals then
        all_series = book_values('series', 'series:true', ',', 0);
        for series in all_series:
            if book_count('series:="' & series & '"', 0) == 1 then
                vals = list_join(',', vals, ',', series, ',')
            fi
        rof;
        set_globals(vals)
    fi;
    str_in_list(vals, ',', $series, 1, '')
```
முதல் முறையாக வார்ப்புரு இயங்கும் போது (முதல் புத்தகம் சரிபார்க்கப்பட்டது) இது தரவுத்தள தேடல்களின் முடிவுகளை `` உலகளாவிய` வார்ப்புரு மாறியில் `` வால்கள்`` ஐ சேமிக்கிறது. இந்த முடிவுகள் தேடல்களை மீண்டும் செய்யாமல் அடுத்தடுத்த புத்தகங்களை சரிபார்க்க பயன்படுத்தப்படுகின்றன.
1. ஒரு வார்ப்புரு தேடலில் சேமிக்கப்பட்ட வார்ப்புருவைப் பயன்படுத்தவும்
```
template:"program: series_only_one_book()#@#:n:1"
```
தேடல் வெளிப்பாடுகளில் மேற்கோள்களில் இருந்து தப்பிக்க வேண்டிய தேவையால் ஏற்படும் சிக்கல்களைத் தேடுவதற்கு பதிலாக சேமிக்கப்பட்ட வார்ப்புருவைப் பயன்படுத்துவது.
`` book_values (நெடுவரிசை, வினவல், செப்டம்பர், USE_VL) `` - `` நெடுவரிசை`` (ஒரு தேடல் பெயர்) என்ற நெடுவரிசையில் உள்ள தனித்துவமான மதிப்புகளின் பட்டியலை வழங்குகிறது, இது `` செப்`` ஆல் பிரிக்கப்பட்டுள்ளது, இது கண்டுபிடிக்கப்பட்ட புத்தகங்களில் `` வினவல்`` தேடுவதன் மூலம். `` Use_vl`` `` 0`` (பூஜ்ஜியம்) என்றால் மெய்நிகர் நூலகங்கள் புறக்கணிக்கப்படும். இந்த செயல்பாடு மற்றும் அதன் தோழர் `` book_count () `` வார்ப்புரு தேடல்களில் குறிப்பாக பயனுள்ளதாக இருக்கும், இது ஒரே ஒரு புத்தகத்துடன் தொடர்களைத் தேடுவது போன்ற பல புத்தகங்களிலிருந்து தகவல்களை இணைக்கும் தேடல்களை ஆதரிக்கிறது. `` Allow_template_database_functions_in_composites`` என்ற மாற்றங்கள் உண்மைக்கு அமைக்கப்படாவிட்டால், கலப்பு நெடுவரிசைகளில் இதைப் பயன்படுத்த முடியாது. இதை GUI இல் மட்டுமே பயன்படுத்த முடியும்.
`` புத்தகங்கள் () `` - காலிபர் 'அளவு' புலத்தின் மதிப்பை வழங்குகிறது. வடிவங்கள் இல்லை என்றால் வருவாய் ''.
`` check_yes_no (field_name, is_undefined, is_false, is_true) `` - தேடல் பெயரின் பெயரிடப்பட்ட ஆம்/இல்லை புலத்தின் மதிப்பு `` field_name`` `` '' '' ஆம்'` ஒரு போட்டி கண்டுபிடிக்கப்பட்டால், இல்லையெனில் வெற்று சரத்தை திருப்பித் தருகிறது. `` Is_undefined``, `` is_false``, அல்லது `` is_true`` ஐ அந்த நிபந்தனையைச் சரிபார்க்க 1 (எண்) என அமைக்கவும், இல்லையெனில் அதை 0 ஆக அமைக்கவும்: எடுத்துக்காட்டு: எடுத்துக்காட்டு:

`` check_yes_no ("#bool", 1, 0, 1) `` `` 'ஆம்'`` ஆம்/இல்லை புலம் #பூல் உண்மை அல்லது வரையறுக்கப்படவில்லை (உண்மை அல்லது பொய்).

`` Is_undefined``, `` is_false``, அல்லது `` is_true`` ஆகியவற்றில் ஒன்றுக்கு மேல் 1 ஆக அமைக்கப்படலாம்.
`` உச்சவரம்பு (x) `` - `` x`` ஐ விட அதிகமாகவோ அல்லது சமமாகவோ மிகச்சிறிய முழு எண்ணை வழங்குகிறது. `` X`` ஒரு எண் இல்லையென்றால் விதிவிலக்கை வீசுகிறது.
`` எழுத்து (எழுத்து_பெயர்) `` - எழுத்துக்குறி_ பெயர் பெயரிடப்பட்ட எழுத்தை வழங்குகிறது. எடுத்துக்காட்டாக, `` எழுத்துக்குறி ('புதிய') `` ஒரு புதிய எழுத்துப்பிழை (`` 'n') தருகிறது. ஆதரிக்கப்பட்ட எழுத்து பெயர்கள் `` புதிய வரி, `` திரும்ப``, `` தாவல்``, மற்றும் `` பின்சாய்வுக்கோடானது`.
`` cmp (x, y, lt, eq, gt) `` - இரண்டையும் எண்களாக மாற்றிய பின் `` x`` மற்றும் y` ஐ ஒப்பிடுகிறது. `` Lt`` என்றால் `` x <# y``, `` eq`` என்றால் `` x ==# y`` என்றால், இல்லையெனில் `` gt``. இந்த செயல்பாடு வழக்கமாக எண் ஒப்பீட்டு ஆபரேட்டர்களில் ஒன்றோடு மாற்றப்படலாம் (`` ==#``, `` <#``, ># `` `` `` `` `` `.
`` இணைக்கப்பட்ட_டெவிஸ்_பேம் (சேமிப்பக_லோகேஷன்_கே) `` - ஒரு சாதனம் இணைக்கப்பட்டால், சாதனத்தின் பெயரைத் திருப்பி, இல்லையெனில் வெற்று சரத்தை திருப்பி விடுங்கள். ஒரு சாதனத்தில் ஒவ்வொரு சேமிப்பக இடத்திற்கும் அதன் சொந்த சாதன பெயர் உள்ளது. `` சேமிப்பு_லோகேஷன்_கே`` பெயர்கள் `` 'பிரதானம்', `' கார்டா'`` மற்றும் `` 'கார்ட்பி'``. இந்த செயல்பாடு GUI இல் மட்டுமே செயல்படுகிறது.
`` இணைக்கப்பட்ட_டெவிஸ்_யூயிட் (சேமிப்பக_லோகேஷன்_கே) `` - ஒரு சாதனம் இணைக்கப்பட்டால், சாதனத்தை UUID (தனித்துவமான ஐடி) திருப்பி, இல்லையெனில் வெற்று சரத்தை திருப்பி விடுங்கள். ஒரு சாதனத்தில் உள்ள ஒவ்வொரு சேமிப்பக இடமும் வெவ்வேறு UUID ஐக் கொண்டுள்ளன. `` சேமிப்பிடம்_லோகேஷன்_கே`` இருப்பிட பெயர்கள் `` 'பிரதானம்', `' 'கார்டா'`` மற்றும் ' கார்ட்ப்'. இந்த செயல்பாடு GUI இல் மட்டுமே செயல்படுகிறது.
`` current_library_name () `` - தற்போதைய காலிபர் நூலகத்திற்கு பாதையில் கடைசி பெயரைத் தரவும்.
`` Current_library_path () `` - தற்போதைய காலிபர் நூலகத்திற்கு முழு பாதையையும் திருப்பி விடுங்கள்.
. நூலக பெயர் வழக்கு பாதுகாக்கப்படுகிறது. எடுத்துக்காட்டு: `` நிரல்: நடப்பு_வீர்டுவல்_லிபிரரி_பெயர் () ``. இந்த செயல்பாடு GUI இல் மட்டுமே செயல்படுகிறது.
`` date_arithmetic (தேதி, calc_spec, fmt) `` - `` calc_spec`` ஐப் பயன்படுத்தி `` தேதி` இலிருந்து புதிய தேதியைக் கணக்கிடுங்கள். விருப்பமான `` FMT`` இன் படி புதிய தேதியை வடிவமைக்கவும்: வழங்கப்படாவிட்டால், முடிவு ISO வடிவத்தில் இருக்கும். Calc_spec என்பது `` vw`` (`` `` `` `` v``) இணைக்கும் ஜோடிகளை ஒன்றிணைப்பதன் மூலம் உருவாக்கப்பட்ட ஒரு சரம், அங்கு v` என்பது எதிர்மறையான எண் மற்றும் W என்பது பின்வரும் கடிதங்களில் ஒன்றாகும்:
- `` எஸ்``: `` தேதி`` வினாடிகளை `` வி`` சேர்க்கவும்
- `` m``: `` தேதி`` நிமிடங்களுக்கு `` வி`` நிமிடங்களைச் சேர்க்கவும்
- `` h``: `` தேதி`` மணிநேரம் v` மணிநேரங்களைச் சேர்க்கவும்
- `` டி``: `` தேதி`` நாட்களை `` வி`` சேர்க்கவும்
- `` w``: `` V`` வாரங்களை `` தேதி`` சேர்க்கவும்
- `` y``: ஒரு வருடம் 365 நாட்கள் இருக்கும் `` தேதி` `` v`` ஆண்டுகளைச் சேர்க்கவும்.
எடுத்துக்காட்டு: `` '1S3D-1M'` 1 வினாடிகளைச் சேர்த்து, 3 நாட்கள் சேர்த்து, `` தேதி இலிருந்து 1 நிமிடத்தைக் கழிக்கும்.
`` நாட்கள்_பெட்வீன் (தேதி 1, தேதி 2) `` - `` தேதி 1`` மற்றும் `` தேதி 2`` க்கு இடையில் நாட்களின் எண்ணிக்கையைத் திருப்பித் தரவும். `` தேதி 1`` ஐ விட அதிகமாக இருந்தால் எண் நேர்மறையானது, இல்லையெனில் எதிர்மறையானது. `` தேதி 1`` அல்லது `` தேதி 2`` தேதிகள் இல்லையென்றால், செயல்பாடு வெற்று சரத்தை வழங்குகிறது.
`` பிரிக்கவும் (x, y) `` - `` x / y`` ஐத் தருகிறது. `` X`` அல்லது `` y`` எண்கள் இல்லையென்றால் விதிவிலக்கை வீசுகிறது. இந்த செயல்பாட்டை வழக்கமாக / ஆபரேட்டரால் மாற்றலாம்.
`` எவால் (சரம்) `` - சரம் ஒரு நிரலாக மதிப்பிடுகிறது, உள்ளூர் மாறிகளைக் கடந்து செல்கிறது. உள்ளூர் மாறிகளிலிருந்து சிக்கலான முடிவுகளை உருவாக்க வார்ப்புரு செயலியைப் பயன்படுத்த இது அனுமதிக்கிறது. இல்: குறிப்பு: வார்ப்புரு நிரல் பயன்முறை <வார்ப்புரு_மோட்>, ஏனெனில் { மற்றும் } எழுத்துக்கள் வார்ப்புரு மதிப்பிடப்படுவதற்கு முன்பு விளக்கப்படுகின்றன, நீங்கள் [ {எழுத்துக்கு மற்றும்]] பயன்படுத்த வேண்டும் `} `` எழுத்து. அவை தானாக மாற்றப்படுகின்றன. முன்னொட்டுகள் மற்றும் பின்னொட்டுகள் (| முன்னொட்டு | பின்னொட்டு தொடரியல்) பயன்படுத்தும் போது இந்த செயல்பாட்டிற்கான வாதத்தில் பயன்படுத்த முடியாது என்பதையும் நினைவில் கொள்க: ref:` வார்ப்புரு நிரல் பயன்முறை <emplatue_mode> `.
`` extrage_file_size (file_name) -புத்தகத்தின் `` தரவு/ கோப்புறை இருந்தால், இல்லையெனில் `` -1`` என்ற கூடுதல் கோப்பின் பைட்டுகளில் அளவை வழங்குகிறது, இல்லையெனில் `` -1``. `` Has_extra_files () ``, `` எக்ஸ்ட்ரா_ஃபைல்_நேம்ஸ் () `` மற்றும் `` கூடுதல்_பீல்_மோடி டைம் () `` ஆகிய செயல்பாடுகளையும் காண்க. இந்த செயல்பாட்டை GUI இல் மட்டுமே பயன்படுத்த முடியும்.
`` extral_file_modtime (file_name, fill_name, format_string) -புத்தகத்தின் `` தரவு/ கோப்புறையில் `` File_name`` இன் மாற்றும் நேரத்தை வழங்குகிறது, இல்லையெனில் `` -1``. மோடம் `` format_string`` இன் படி வடிவமைக்கப்பட்டுள்ளது (விவரங்களுக்கு `` format_date () `` ஐப் பார்க்கவும்). `` Format_string`` என்றால் வெற்று சரம் என்றால், சகாப்தத்திலிருந்து மிதக்கும் புள்ளி எண்ணாக மோடத்தை வழங்குகிறது. `` Has_extra_files () `` , கூடுதல்_பீல்_நேம்கள் () மற்றும் கூடுதல்_பீல்_சிஸ் () `ஆகியவற்றையும் காண்க. சகாப்தம் OS சார்ந்தது. இந்த செயல்பாட்டை GUI இல் மட்டுமே பயன்படுத்த முடியும்.
`` எக்ஸ்ட்ரா_ஃபைல்_நேம்ஸ் (செப் [, முறை]) `` புத்தகத்தின் `` தரவு/`` கோப்புறையில் கூடுதல் கோப்புகளின் `` செப்``-பிரிக்கப்பட்ட பட்டியலை வழங்குகிறது. விருப்ப அளவுரு `` முறை``, ஒரு வழக்கமான வெளிப்பாடு வழங்கப்பட்டால், பட்டியல் `` முறை`` பொருந்தக்கூடிய கோப்புகளுக்கு வடிகட்டப்படுகிறது. முறை போட்டி என்பது உணர்ச்சியற்றது. `` Has_extra_files () ``, `` கூடுதல்_பீல்_மோட் டைம் () `` மற்றும் எக்ஸ்ட்ரா_ஃபைல்_சிஸ் () `செயல்பாடுகளையும் காண்க. இந்த செயல்பாட்டை GUI இல் மட்டுமே பயன்படுத்த முடியும்.
`` புலம் (தேடல்_பெயர்) `` - மெட்டாடேட்டா புலத்தின் மதிப்பை தேடல் பெயருடன் `` goodup_name`` உடன் வழங்குகிறது.
`` field_exists (field_name) `` - தேடல் பெயருடன் ஒரு புலம் (நெடுவரிசை) `` field_name`` இருக்கிறதா என்பதை சரிபார்க்கிறது, அப்படியானால் `` '1'` மற்றும் வெற்று சரம் இல்லையென்றால் திரும்பப் பெறுகிறது.
`` FINT_FORMATTING (VAL, FMT, முன்னொட்டு, பின்னொட்டு) `` - {sitery_index: 05.2f | போன்ற ஒரு டெம்ப்ளேட்டில் செய்ததைப் போலவே ஒரு மதிப்புக்கு வடிவம், முன்னொட்டு மற்றும் பின்னொட்டைப் பயன்படுத்துங்கள் - |-} `. சிக்கலான ஒற்றை-செயல்பாடு- அல்லது வார்ப்புரு-நிரல்-முறை வார்ப்புருக்களை ஜிபிஎம் வார்ப்புருக்களாக மாற்றுவதற்கு இந்த செயல்பாடு வழங்கப்படுகிறது. எடுத்துக்காட்டாக, பின்வரும் நிரல் மேலே உள்ள வார்ப்புருவின் அதே வெளியீட்டை உருவாக்குகிறது
```
program: finish_formatting(field("series_index"), "05.2f", " - ", " - ")
```
மற்றொரு எடுத்துக்காட்டு: வார்ப்புருவுக்கு {தொடர்: மறு (([^s]) [^s]+(s | $), 1)} {sitery_index: 0> 2s | - | -} {தலைப்பு} ` பயன்பாடு
```
program:
  strcat(
    re(field('series'), '([^\s])[^\s]+(\s|$)', '\1'),
       finish_formatting(field('series_index'), '0>2s', ' - ', ' - '),
       field('title')
  )
```
`` first_matching_cmp (val, [cmp, result,]* else_result) ` - வரிசையில்` val <cmp` ஐ ஒப்பிடுகிறது, வெற்றிபெறும் முதல் ஒப்பீட்டிற்கு தொடர்புடைய முடிவைத் திருப்பித் தருகிறது. எந்த ஒப்பீடும் வெற்றிபெறவில்லை என்றால் வேறு_ -ரீசால்ட் திரும்பும். உதாரணமாக:
```
i = 10;
first_matching_cmp(i,5,"small",10,"middle",15,"large","giant")
```
`` "பெரிய" `` ஐத் தருகிறது. 16 முதல் மதிப்புடன் அதே எடுத்துக்காட்டு `` "ஜெயண்ட்" `` `.
`` first_non_empty (மதிப்பு [, மதிப்பு]*) ` - காலியாக இல்லாத முதல்` மதிப்பு` ஐ வழங்குகிறது. எல்லா மதிப்புகளும் காலியாக இருந்தால், வெற்று சரம் திரும்பும். நீங்கள் விரும்பும் பல மதிப்புகளை நீங்கள் கொண்டிருக்கலாம்.
`` மாடி (x) `` - `` x`` ஐ விட குறைவாகவோ அல்லது சமமாகவோ மிகப்பெரிய முழு எண்ணை வழங்குகிறது. `` X`` ஒரு எண் இல்லையென்றால் விதிவிலக்கை வீசுகிறது.
`` format_date (val, format_string) `` - மதிப்பை வடிவமைக்கவும், இது ஒரு தேதி சரமாக இருக்க வேண்டும், வடிவத்தைப் பயன்படுத்தி, ஒரு சரத்தை திருப்பி விடுங்கள். வடிவமைப்பு குறியீடுகள்:
- `` டி: `` ஒரு முன்னணி பூஜ்ஜியமில்லாத நாளாக (1 முதல் 31 வரை)
- `` டி.டி: `` ஒரு முன்னணி பூஜ்ஜியத்துடன் கூடிய நாள் (01 முதல் 31 வரை)
- `` டி.டி.டி: `` சுருக்கமாக உள்ளூர்மயமாக்கப்பட்ட நாள் பெயர் (எ.கா. "தி மோன்" முதல் "சூரியன்").
- `` dddd: `` நீண்ட உள்ளூர்மயமாக்கப்பட்ட நாள் பெயர் (எ.கா. "திங்கள்" முதல் "ஞாயிறு" வரை).
- `` எம்: `` மாதம் ஒரு முன்னணி பூஜ்ஜியம் இல்லாத எண்ணாக (1 முதல் 12 வரை).
- `` மிமீ: `` ஒரு முன்னணி பூஜ்ஜியத்துடன் கூடிய மாதமாக (01 முதல் 12 வரை)
- `` எம்.எம்.எம்: `` சுருக்கமாக உள்ளூர்மயமாக்கப்பட்ட மாத பெயர் (எ.கா. "ஜனவரி" முதல் "டிசம்பர்" வரை).
- `` எம்.எம்.எம்: `` நீண்ட உள்ளூர்மயமாக்கப்பட்ட மாத பெயர் (எ.கா. "ஜனவரி" முதல் "டிசம்பர்" வரை).
- `` yy: `` ஆண்டு இரண்டு இலக்க எண்ணாக (00 முதல் 99 வரை).
- `` yyyy: `` ஆண்டு நான்கு இலக்க எண்ணாக.
- `` எச்: `` ஒரு முன்னணி 0 (0 முதல் 11 அல்லது 0 முதல் 23 வரை, AM/PM ஐப் பொறுத்து)
- `` HH: `` ஒரு முன்னணி 0 (00 முதல் 11 அல்லது 00 முதல் 23 வரை, AM/PM ஐப் பொறுத்து)
- `` எம்: `` ஒரு முன்னணி 0 (0 முதல் 59 வரை) இல்லாமல் நிமிடங்கள்
- `` மிமீ: `` ஒரு முன்னணி 0 (00 முதல் 59 வரை) கொண்ட நிமிடங்கள்
- `` என்பது: `` ஒரு முன்னணி 0 (0 முதல் 59 வரை) இல்லாமல் விநாடிகள்
- `` எஸ்.எஸ்: `` ஒரு முன்னணி 0 (00 முதல் 59 வரை) வினாடிகள்
- `` AP: `` 24 மணி நேர கடிகாரத்திற்கு பதிலாக 12 மணிநேர கடிகாரத்தைப் பயன்படுத்தவும், 'AP' உடன் AM அல்லது PM க்கு உள்ளூர்மயமாக்கப்பட்ட சரத்தால் மாற்றப்பட்டது.
- `` AP: `` 24 மணி நேர கடிகாரத்திற்கு பதிலாக 12 மணிநேர கடிகாரத்தைப் பயன்படுத்தவும், 'AP' உடன் AM அல்லது PM க்கு உள்ளூர்மயமாக்கப்பட்ட சரத்தால் மாற்றப்பட்டது.
- `` ஐஎஸ்ஓ: `` நேரம் மற்றும் நேர மண்டலத்துடன் தேதி. ஒரே வடிவமாக இருக்க வேண்டும்.
- `` to_number: `` தேதி மற்றும் நேரத்தை மிதக்கும் புள்ளி எண்ணாக மாற்றவும் (ஒரு `நேர முத்திரை)
- `` from_number: `` ஒரு மிதக்கும் புள்ளி எண்ணை (ஒரு நேர முத்திரை) ஒரு ஐசோ` வடிவமைக்கப்பட்ட தேதியாக மாற்றவும். நீங்கள் வேறு தேதி வடிவமைப்பை விரும்பினால், விரும்பிய வடிவமைப்பு சரத்தை `` from_number`` மற்றும் ஒரு பெருங்குடலுக்கும் (: ``) சேர்க்கவும். எடுத்துக்காட்டு: `` from_number: mmm dd yyyy
நீங்கள் வடிவமைக்கும் தேதியில் உள்ளூர்மயமாக்கப்பட்ட மாத பெயர்களைக் கொண்டிருந்தால் நீங்கள் எதிர்பாராத முடிவுகளைப் பெறலாம், இது தேதி வடிவ மாற்றங்களை `` எம்.எம்.எம்.எம்`` கொண்டிருக்கும். இந்த வழக்கில், `` புலம் () `` செயல்பாட்டைப் பயன்படுத்துவதற்குப் பதிலாக
```
format_date(field('pubdate'), 'yyyy')
```
`` ரா_ஃபீல்ட் () `` செயல்பாட்டைப் பயன்படுத்தவும்
```
format_date(raw_field('pubdate'), 'yyyy')
```
`` format_date_field (field_name, format_string) `` - புலத்தில் மதிப்பை வடிவமைக்கவும் `` field_name``, இது தேதி புலத்தின் தேடல் பெயராக இருக்க வேண்டும், தரநிலை அல்லது தனிப்பயன். வடிவமைப்பு குறியீடுகளுக்கு `` format_date () `` ஐப் பார்க்கவும். இந்த செயல்பாடு format_date ஐ விட மிக வேகமாக உள்ளது மற்றும் நீங்கள் ஒரு புலத்தில் (நெடுவரிசை) மதிப்பை வடிவமைக்கும்போது பயன்படுத்தப்பட வேண்டும். கணக்கிடப்பட்ட தேதிகள் அல்லது சரம் மாறிகளில் தேதிகளுக்கு இதைப் பயன்படுத்த முடியாது. எடுத்துக்காட்டுகள்
```
format_date_field('pubdate', 'yyyy.MM.dd')
format_date_field('#date_read', 'MMM dd, yyyy')
```
`` `` formats_modtimes (date_format_string) -ஒரு புத்தகத்தின் வடிவங்களுக்கான மாற்றியமைக்கும் நேரங்களைக் குறிக்கும் கோலால் பிரிக்கப்பட்ட பொருட்களின் கமாவால் பிரிக்கப்பட்ட பட்டியலைக் குறிக்கும். `` Date_format_string அளவுரு தேதி எவ்வாறு வடிவமைக்கப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது. விவரங்களுக்கு `` format_date () `` செயல்பாட்டைக் காண்க. ஒரு குறிப்பிட்ட வடிவமைப்பிற்கான மாற்ற நேரத்தைப் பெற நீங்கள் `` தேர்ந்தெடுக்கப்பட்ட`` செயல்பாட்டைப் பயன்படுத்தலாம். வடிவமைப்பு பெயர்கள் எப்போதும் EPUB இல் உள்ளதைப் போல பெரிய எழுத்துக்கள் என்பதை நினைவில் கொள்க.
`` formats_paths () `-ஒரு புத்தகத்தின் வடிவங்களுக்கான முழு பாதையையும் கொடுக்கும் பெருங்குடல்-பிரிக்கப்பட்ட பொருட்களின் கமாவால் பிரிக்கப்பட்ட பொருட்களின் பட்டியலைத் தரவும். ஒரு குறிப்பிட்ட வடிவமைப்பிற்கான பாதையைப் பெற நீங்கள் தேர்ந்தெடுக்கப்பட்ட செயல்பாட்டைப் பயன்படுத்தலாம். வடிவமைப்பு பெயர்கள் எப்போதும் EPUB இல் உள்ளதைப் போல பெரிய எழுத்துக்கள் என்பதை நினைவில் கொள்க.
`` formats_sizes () -ஒரு புத்தகத்தின் வடிவங்களின் பைட்டுகளில் அளவைக் கொடுக்கும் கோலால் பிரிக்கப்பட்ட எஃப்எம்டி: அளவு` உருப்படிகளின் கமாவால் பிரிக்கப்பட்ட பட்டியலைத் தரவும். ஒரு குறிப்பிட்ட வடிவமைப்பிற்கான அளவைப் பெற நீங்கள் தேர்ந்தெடுக்கப்பட்ட செயல்பாட்டைப் பயன்படுத்தலாம். வடிவமைப்பு பெயர்கள் எப்போதும் EPUB இல் உள்ளதைப் போல பெரிய எழுத்துக்கள் என்பதை நினைவில் கொள்க.
`` Fractional_Part (x) `` - தசம புள்ளிக்குப் பிறகு மதிப்பை வழங்குகிறது. எடுத்துக்காட்டாக, `` பின்னம்_பார்ட் (3.14) `` திரும்பும் `` 0.14``. `` X`` ஒரு எண் இல்லையென்றால் விதிவிலக்கை வீசுகிறது.
`` get_link (field_name, field_value) `` - `` field_name` `` field_value`` உடன் புலத்திற்கான இணைப்பைப் பெறுங்கள். இணைக்கப்பட்ட இணைப்பு இல்லை என்றால், வெற்று சரத்தை திருப்பி விடுங்கள். எடுத்துக்காட்டுகள்:

`` புனைகதை`` என்ற குறிச்சொல்லுடன் இணைக்கப்பட்ட இணைப்பை பின்வருபவை வழங்குகிறது
get_link('tags', 'Fiction')
இந்த வார்ப்புரு `` மதிப்பு: இணைப்பு, ... ``
program:
 ans = '';
 for t in $tags:
     l = get_link('tags', t);
     if l then
         ans = list_join(', ', ans, ',', t & ':' & get_link('tags', t), ',')
     fi
 rof;
 ans

`` has_cover () `` - புத்தகத்தில் ஒரு கவர் இருந்தால் `` 'ஆம்'`` திரும்பவும், இல்லையெனில் வெற்று சரம்.
`` has_extra_files ([முறை]) `` - கூடுதல் கோப்புகளின் எண்ணிக்கையை வழங்குகிறது, இல்லையெனில் '' (வெற்று சரம்). விருப்ப அளவுரு `` முறை`` (ஒரு வழக்கமான வெளிப்பாடு) வழங்கப்பட்டால், கோப்புகள் கணக்கிடப்படுவதற்கு முன்பு `` முறை`` பொருந்தக்கூடிய கோப்புகளுக்கு பட்டியல் வடிகட்டப்படுகிறது. முறை போட்டி என்பது உணர்ச்சியற்றது. `` எக்ஸ்ட்ரா_ஃபைல்_பேன்ஸ் () ``, `` எக்ஸ்ட்ரா_ஃபைல்_சிஸ் () `` மற்றும் எக்ஸ்ட்ரா_ஃபைல்_மோட் டைம் () `ஆகிய செயல்பாட்டுகளையும் காண்க. இந்த செயல்பாட்டை GUI இல் மட்டுமே பயன்படுத்த முடியும்.
`` அடையாளங்காட்டி_இன்_லிஸ்ட் (VAL, ID_NAME [, find_val, not_found_val]) `` - காற்புள்ளிகளால் பிரிக்கப்பட்ட அடையாளங்காட்டிகளின் பட்டியலாக `` வால்`` க்கு சிகிச்சையளிக்கவும். ஒரு அடையாளங்காட்டிக்கு `` ஐடி_நேம்: மதிப்பு`` வடிவத்தைக் கொண்டுள்ளது. `` Id_name`` அளவுரு என்பது `` id_name`` அல்லது `` id_name: regexp`` தேட வேண்டிய ID_NAME உரை. ID_NAME உடன் பொருந்தக்கூடிய அடையாளங்காட்டி ஏதேனும் இருந்தால் முதல் வழக்கு பொருந்துகிறது. ID_NAME ஒரு அடையாளங்காட்டியுடன் பொருந்தினால் இரண்டாவது வழக்கு பொருந்துகிறது மற்றும் REGEXP அடையாளங்காட்டியின் மதிப்புடன் பொருந்துகிறது. `` Fent_val`` மற்றும் `` not_found_val`` வழங்கப்பட்டால், ஒரு பொருத்தம் இருந்தால், `` find_val`` ஐத் தரவும், இல்லையெனில் `` not_found_val`` ஐத் தரவும். `` Fent_val`` மற்றும் `` not_found_val`` வழங்கப்படாவிட்டால், ஒரு பொருத்தம் இருந்தால், `` அடையாளங்காட்டி: மதிப்பு`` ஜோடியைத் திருப்பித் தரவும், இல்லையெனில் வெற்று சரம் (`` '' ``).
`` is_marked () `` - புத்தகம் குறிக்கப்பட்டதா காலிபரில் உள்ளதா என்பதைச் சரிபார்க்கவும். அது இருந்தால், அடையாளத்தின் மதிப்பை, `` 'உண்மை'`` (கீழ் வழக்கு) அல்லது பெயரிடப்பட்ட மதிப்பெண்களின் கமாவால் பிரிக்கப்பட்ட பட்டியல். புத்தகம் குறிக்கப்படாவிட்டால் `` '' `` (வெற்று சரம்) திரும்பும். இந்த செயல்பாடு GUI இல் மட்டுமே செயல்படுகிறது.
`` மொழி_ குறியீடுகள் (lang_strings) -`மொழி குறியீடுகளைத் திருப்பி விடுங்கள் சரங்கள் தற்போதைய இடத்தின் மொழியில் இருக்க வேண்டும். `` Lang_strings என்பது கமாவால் பிரிக்கப்பட்ட பட்டியல்.
`` list_contains (மதிப்பு, பிரிப்பான், [முறை, ஃபவுண்ட்_வல்,]* not_found_val) `` - (`` in_list``` இன் மாற்றுப்பெயர்) `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக மதிப்பை விளக்குகிறது, `` `` ` பட்டியலில் உள்ள ஒவ்வொரு மதிப்பிற்கும் எதிராக மாதிரி``. `` முறை` எந்த மதிப்பையும் பொருத்தினால், find_val` ஐத் தரவும், இல்லையெனில்` not_found_val` ஐத் தரவும். `` முறை`` மற்றும் `` ஃபென்ட்_வல்யூ`` ஆகியவற்றை விரும்பிய பல முறை மீண்டும் மீண்டும் செய்யலாம், தேடலைப் பொறுத்து வெவ்வேறு மதிப்புகளைத் தர அனுமதிக்கிறது. வடிவங்கள் வரிசையில் சரிபார்க்கப்படுகின்றன. முதல் போட்டி திரும்பியது. மாற்றுப்பெயர்கள்: `` in_list () ``, `` list_contains () ``
`` list_count (மதிப்பு, பிரிப்பான்) `` - `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக `` மதிப்பு` ஆகியவற்றை விளக்குகிறது, பட்டியலில் உள்ள உருப்படிகளின் எண்ணிக்கையைத் திருப்பித் தருகிறது. மாற்றுப்பெயர்கள்: `` கவுண்ட் () ``, `` பட்டியல்_கவுண்ட் () ``
`` list_count_matching (பட்டியல், முறை, பிரிப்பான்) `` - `` பிரிப்பான்`` ஆல் பிரிக்கப்பட்ட பொருட்களின் பட்டியலாக `` பட்டியல்`` ஐ விளக்குகிறது, வழக்கமான வெளிப்பாட்டுடன் பொருந்தக்கூடிய பட்டியலில் உள்ள உருப்படிகளின் எண்ணிக்கையை திருப்பி அனுப்புகிறது . மாற்றுப்பெயர்கள்: ` list_count_matching () ``, `` count_matching () ``
`` list_difference (பட்டியல் 1, பட்டியல் 2, பிரிப்பான்) -வழக்கு-உணர்வற்ற ஒப்பீட்டைப் பயன்படுத்தி `` பட்டியல் 2 இல் காணப்படும் எந்தவொரு பொருளையும் `` பட்டியல் 1`` இலிருந்து அகற்றுவதன் மூலம் செய்யப்பட்ட பட்டியலைத் திருப்பி விடுங்கள். `` பட்டியல் 1`` மற்றும் பட்டியல் 2` ஆகியவற்றில் உள்ள உருப்படிகள் பிரிப்பானால் பிரிக்கப்படுகின்றன, திரும்பிய பட்டியலில் உள்ள உருப்படிகள்.
`` பட்டியல்_இகல்கள் (பட்டியல் 1, செப் 1, பட்டியல் 2, செப் 2, ஆம்_வல், இல்லை_வல்) `` - `` பட்டியல் 1`` மற்றும் பட்டியல் 2 ஆகியவற்றைக் கொண்டிருந்தால்` ஆம்_வல்` திரும்பவும், இல்லையெனில் `` இல்லை_வல்`` திரும்பவும். பொருத்தமான பிரிப்பான் எழுத்துக்குறியைப் பயன்படுத்தி ஒவ்வொரு பட்டியலையும் பிரிப்பதன் மூலம் உருப்படிகள் தீர்மானிக்கப்படுகின்றன (`` sep1`` அல்லது `` sep2``). பட்டியல்களில் உள்ள பொருட்களின் வரிசை பொருந்தாது. ஒப்பீடு வழக்கு-உணர்வற்றது.
`` list_intersection (பட்டியல் 1, பட்டியல் 2, பிரிப்பான்) -ஒரு வழக்கு-உணர்திறன் ஒப்பீட்டைப் பயன்படுத்தி `` பட்டியல் 2 இல் காணப்படாத `` பட்டியல் 1`` இலிருந்து அகற்றுவதன் மூலம் செய்யப்பட்ட பட்டியலைத் திருப்பி விடுங்கள். `` பட்டியல் 1` மற்றும் `` பட்டியல் 2`` ஆகியவற்றில் உள்ள உருப்படிகள் பிரிப்பானால் பிரிக்கப்படுகின்றன, திரும்பிய பட்டியலில் உள்ள உருப்படிகள்.
`` list_join (with_separator, list1, spripator1 [, list2, splator2]**) `` - மூல பட்டியல்களில் (`` பட்டியல் 1`` போன்றவை) உருப்படிகளில் சேருவதன் மூலம் செய்யப்பட்ட பட்டியலைத் தரவும் `` with_separator` ` முடிவு பட்டியலில். ஒவ்வொரு மூலத்திலும் உள்ள உருப்படிகள் `` பட்டியல் [123 ...] `` தொடர்புடைய `` பிரிப்பான் [123 ...] `` ஆகியவற்றால் பிரிக்கப்படுகின்றன. ஒரு பட்டியலில் பூஜ்ஜிய மதிப்புகள் இருக்கலாம். இது ஒற்றை மதிப்புள்ள `` வெளியீட்டாளர்` போன்ற ஒரு துறையாக இருக்கலாம், திறம்பட ஒரு உருப்படி பட்டியல். வழக்கு-உணர்வற்ற ஒப்பீட்டைப் பயன்படுத்தி நகல்கள் அகற்றப்படுகின்றன. மூல பட்டியல்களில் அவை தோன்றும் வரிசையில் உருப்படிகள் திருப்பித் தரப்படுகின்றன. பட்டியல்களில் உள்ள உருப்படிகள் கடித வழக்கில் மட்டுமே வேறுபடுகின்றன என்றால், கடைசியாக பயன்படுத்தப்படுகிறது. அனைத்து பிரிப்பான்களும் ஒன்றுக்கு மேற்பட்ட எழுத்துக்களாக இருக்கலாம்.

உதாரணமாக:
```
program:
  list_join('#@#', $authors, '&', $tags, ',')
```
முந்தைய அழைப்புகளின் முடிவுகளில் `` பட்டியல்_ஜோயின்`` பின்வருமாறு `` பட்டியல்_ஜோயின்`` ஐப் பயன்படுத்தலாம்
```
program:
  a = list_join('#@#', $authors, '&', $tags, ',');
  b = list_join('#@#', a, '#@#', $#genre, ',', $#people, '&', 'some value', ',')
```
பட்டியலை உருவாக்க நீங்கள் வெளிப்பாடுகளைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, `` ஆசிரியர்கள்`` மற்றும் #வகை ஆகியவற்றிற்கான உருப்படிகளை நீங்கள் விரும்புகிறீர்கள் என்று வைத்துக் கொள்ளுங்கள், ஆனால் வகையை "வகை:" என்ற வார்த்தையாக மாற்றியதால், வகையின் முதல் கடிதத்தைத் தொடர்ந்து, அதாவது "புனைகதை" வகை ஆகிறது " வகை: எஃப் ". பின்வருபவை அதைச் செய்யும்
```
program:
  list_join('#@#', $authors, '&', list_re($#genre, ',', '^(.).*$', 'Genre: \1'),  ',')
```
`` list_re (src_list, பிரிப்பான், அடங்கும்_ரே, opt_replace) `` - முதலில் `` src_list`` ஐ `` பிரிப்பான்`` எழுத்தைப் பயன்படுத்தி உருப்படிகளாக பிரிப்பதன் மூலம் ஒரு பட்டியலை உருவாக்குங்கள். பட்டியலில் உள்ள ஒவ்வொரு பொருளுக்கும், இது `` சேர்க்கவும்_ரே`` உடன் பொருந்துமா என்று சரிபார்க்கவும். அவ்வாறு செய்தால், அதை திருப்பித் தர வேண்டிய பட்டியலில் சேர்க்கவும். `` Opt_replace`` வெற்று சரம் இல்லையென்றால், திரும்பிய பட்டியலில் உருப்படியைச் சேர்ப்பதற்கு முன் மாற்றீட்டைப் பயன்படுத்துங்கள்.
`` list_re_group (src_list, பிரிப்பான், சேர்த்தல்_ரே, தேடல்_ரே [, வார்ப்புரு_ஃபோர்_ குழுமம்]*) `` - பட்டியல்_இது போன்ற மாற்றீடுகள் விருப்பமல்ல. இது `` re_ குழு (உருப்படி, தேடல்_ரே, வார்ப்புரு ...) `` மாற்றீடுகளைச் செய்யும்போது பயன்படுத்துகிறது.
`` list_remove_duplicates (பட்டியல், பிரிப்பான்) `` - `` பட்டியல்`` இல் நகல் உருப்படிகளை அகற்றுவதன் மூலம் செய்யப்பட்ட பட்டியலைத் தரவும். உருப்படிகள் மட்டுமே வேறுபடுகின்றன என்றால், கடைசியாக திரும்பப் பெறப்படும். `` பட்டியல்`` இல் உள்ள உருப்படிகள் `` பிரிப்பான்`` ஆல் பிரிக்கப்படுகின்றன, திரும்பிய பட்டியலில் உள்ள உருப்படிகள்.
`` list_sort (பட்டியல், திசை, பிரிப்பான்) -ஒரு வழக்கு-உணர்வற்ற லெக்சிக்கல் வகையைப் பயன்படுத்தி வரிசைப்படுத்தப்பட்ட `` பட்டியல்`. `` திசை பூஜ்ஜியமாக இருந்தால், `` பட்டியல்`` வரிசைப்படுத்தப்படுகிறது, இல்லையெனில் இறங்குகிறது. பட்டியல் உருப்படிகள் `` பிரிப்பான்`` ஆல் பிரிக்கப்படுகின்றன, திரும்பிய பட்டியலில் உள்ள உருப்படிகள்.
`` list_val, sep, id_prefix) `` - `` sep`` ஐப் பயன்படுத்தி `` பட்டியல்_வல்`` ஐப் பயன்படுத்தி `` பட்டியல்_வல்`` ஐப் பிரித்து, `` ஐடி_பிரெஃபிக்ஸ்_.என்` என்ற பெயரில் உள்ள உள்ளூர் மாறிகளுக்கு மதிப்புகளை ஒதுக்குகிறது பட்டியலில் மதிப்பு. முதல் உருப்படிக்கு நிலை 0 (பூஜ்ஜியம்) உள்ளது. செயல்பாடு பட்டியலில் கடைசி உறுப்பை வழங்குகிறது.

உதாரணமாக:
```
list_split('one:two:foo', ':', 'var')
```
அதற்கு சமம்
```
var_0 = 'one';
var_1 = 'two';
var_2 = 'foo
```
`` பட்டியல்_யூனியன் (பட்டியல் 1, பட்டியல் 2, பிரிப்பான்) - பட்டியல் 1` மற்றும் `` பட்டியல் 2`` ஆகியவற்றில் உள்ள உருப்படிகளை ஒன்றிணைப்பதன் மூலம் செய்யப்பட்ட பட்டியலைத் திருப்பி, வழக்கு-பாதுகாப்பு ஒப்பீட்டைப் பயன்படுத்தி நகல் உருப்படிகளை அகற்றவும். உருப்படிகள் வேறுபட்டால், `` பட்டியல் 1`` இல் உள்ள ஒன்று பயன்படுத்தப்படுகிறது. `` பட்டியல் 1`` மற்றும் பட்டியல் 2` ஆகியவற்றில் உள்ள உருப்படிகள்` பிரிப்பான்` ஆல் பிரிக்கப்படுகின்றன, திரும்பிய பட்டியலில் உள்ள உருப்படிகள். மாற்றுப்பெயர்கள்: `` merge_lists () ``, `` list_union () ``
`` mod (x, y) `` - மீதமுள்ள `` x / y``` இன் `` மாடி` 'ஐ வழங்குகிறது. `` X`` அல்லது `` y`` ஒரு எண் இல்லையென்றால் விதிவிலக்கை வீசுகிறது.
`` பெருக்கவும் (x [, y]*) `` - அதன் வாதங்களின் உற்பத்தியை வழங்குகிறது. எந்தவொரு வாதமும் ஒரு எண்ணாக இல்லாவிட்டால் விதிவிலக்கை வீசுகிறது. இந்த செயல்பாட்டை வழக்கமாக * ஆபரேட்டரால் மாற்றலாம்.
`` இல்லை (மதிப்பு) `` - மதிப்பு காலியாக இருந்தால் "1" என்ற சரத்தை வழங்குகிறது, இல்லையெனில் வெற்று சரத்தை வழங்குகிறது. இந்த செயல்பாட்டை வழக்கமாக ஒற்றுமையற்ற (``! ``) ஆபரேட்டருடன் மாற்றலாம்.
`` ondevice () `` - சரம் `` 'ஆம்'`` `` ondevice`` அமைக்கப்பட்டால், வெற்று சரத்தை திருப்பித் தரவும்.
`` அல்லது (மதிப்பு [, மதிப்பு]*) `` - சரம் `` '1'`` ஏதேனும் மதிப்பு காலியாக இல்லாவிட்டால், வெற்று சரத்தை வழங்குகிறது. நீங்கள் விரும்பும் பல மதிப்புகளை நீங்கள் கொண்டிருக்கலாம். இந்த செயல்பாட்டை வழக்கமாக `` || `` ஆபரேட்டரால் மாற்றலாம். பக்க விளைவுகள் காரணமாக குறுகிய சுற்று முடிவுகளை மாற்றினால் அதை மாற்ற முடியாத ஒரு காரணம்.
`` அச்சிடு (A [, b]*) `` - வாதங்களை நிலையான வெளியீட்டிற்கு அச்சிடுகிறது. கட்டளை வரியிலிருந்து (`` கலிபிரே -டெபக் -ஜி``) நீங்கள் திறனைத் தொடங்காவிட்டால், வெளியீடு ஒரு கருந்துளைக்குள் செல்லும். `` அச்சு`` செயல்பாடு எப்போதும் அதன் முதல் வாதத்தை வழங்குகிறது.

`` வரம்பு (தொடக்க, நிறுத்து, படி, வரம்பு) `` - அளவுருக்கள் தொடங்கி, நிறுத்து மற்றும் படி ஆகியவற்றால் குறிப்பிடப்பட்ட வரம்பில் சுழற்றுவதன் மூலம் உருவாக்கப்படும் எண்களின் பட்டியலை அதிகபட்ச நீளமான வரம்புடன் தருகிறது. தயாரிக்கப்பட்ட முதல் மதிப்பு 'தொடக்க'. அடுத்தடுத்த மதிப்புகள் `` நெக்ஸ்ட்_வி = நடப்பு_வி + படி``. `` நெக்ஸ்ட்_வி <நிறுத்தம்`` என்று கருதி லூப் தொடர்கிறது, இல்லையெனில் `` அடுத்த_வி> நிறுத்து``. `` தொடக்க` சோதனையில் தோல்வியுற்றால் வெற்று பட்டியல் தயாரிக்கப்படுகிறது: start`` படி` நேர்மறையாக இருந்தால். `` வரம்பு`` பட்டியலின் அதிகபட்ச நீளத்தை அமைத்து 1000 இயல்புநிலையைக் கொண்டுள்ளது. ஒரு வாதத்துடன் `` வரம்பு () `` என்று அழைப்பது `` நிறுத்து`` என்பதைக் குறிப்பிடுகிறது. இரண்டு வாதங்கள் `` தொடக்க`` மற்றும் `` நிறுத்து`` ஆகியவற்றைக் குறிப்பிடுகின்றன. மூன்று வாதங்கள் `` தொடக்க``, `` நிறுத்து``, மற்றும் `` படி`` ஆகியவற்றைக் குறிப்பிடுகின்றன. நான்கு வாதங்கள் `` தொடக்க``, `` நிறுத்து``, `` படி`` மற்றும் `` வரம்பு`` ஆகியவற்றைக் குறிப்பிடுகின்றன. எடுத்துக்காட்டுகள்
```
range(5) -> '0, 1, 2, 3, 4'
range(0, 5) -> '0, 1, 2, 3, 4'
range(-1, 5) -> '-1, 0, 1, 2, 3, 4'
range(1, 5) -> '1, 2, 3, 4'
range(1, 5, 2) -> '1, 3'
range(1, 5, 2, 5) -> '1, 3'
range(1, 5, 2, 1) -> error(limit exceeded)
```
`` RAW_FIELD (Lookup_name [, விரும்பினால்_தெபால்ட்]) `` - எந்தவொரு வடிவமைப்பையும் பயன்படுத்தாமல் `` giotup_name`` என பெயரிடப்பட்ட மெட்டாடேட்டா புலத்தை வழங்குகிறது. புலத்தின் மதிப்பு வரையறுக்கப்படவில்லை என்றால் (`` எதுவுமில்லை``) விருப்பமான இரண்டாவது வாதத்தை `` விரும்பினால்_ டெஃபால்ட்`` மதிப்பீடு செய்து வழங்குகிறது.
`` RAW_LIST (Lookup_name, பிரிப்பான்) `` - எந்தவொரு வடிவமைப்பையும் அல்லது வரிசையாக்கத்தையும் பயன்படுத்தாமல், பிரிப்பாட்டால் பிரிக்கப்பட்ட உருப்படிகளுடன் `` Lookup_name`` என பெயரிடப்பட்ட மெட்டாடேட்டா பட்டியலை வழங்குகிறது.
`` re_group (மதிப்பு, முறை [, டெம்ப்ளேட்_ஃபோர்_ குழுமம்]*) `` - வழக்கமான வெளிப்பாடு வடிவத்தை `` மதிப்பு`` ஐப் பயன்படுத்துவதன் மூலமும், பொருந்திய ஒவ்வொரு நிகழ்வையும் மாற்றியமைப்பதன் மூலமும் தொடர்புடைய வார்ப்புருவால் வழங்கப்பட்ட மதிப்புடன் மாற்றப்பட்ட ஒரு சரத்தைத் தரவும். இல்: குறிப்பு: `` வார்ப்புரு`` மற்றும் `` எவால்`` செயல்பாடுகளைப் போலவே, வார்ப்புரு நிரல் பயன்முறை <டெம்ப்ளேட்_மோட்> ``} `` க்கு.

பின்வரும் எடுத்துக்காட்டு ஒன்றுக்கு மேற்பட்ட வார்த்தைகளைக் கொண்ட ஒரு தொடரைத் தேடுகிறது மற்றும் முதல் சொல்
```
program: re_group(field('series'), "(\S* )(.*)", "{$:uppercase()}", "{$}")'}
```
`` சுற்று (x) `` - அருகிலுள்ள முழு எண்ணை `` x`` க்கு வழங்குகிறது. `` X`` ஒரு எண் இல்லையென்றால் விதிவிலக்கை வீசுகிறது.
`` sitery_sort () `` - தொடர் வரிசை மதிப்பை வழங்குகிறது.
`` strcat (a [, b]*) `` - எந்தவொரு வாதங்களையும் எடுக்கலாம். அனைத்து வாதங்களையும் ஒருங்கிணைப்பதன் மூலம் உருவாக்கப்பட்ட ஒரு சரத்தை வழங்குகிறது.
`` strcat_max (அதிகபட்சம், சரம் 1 [, முன்னொட்டு 2, சரம் 2]*) `` - வாதங்களை ஒருங்கிணைப்பதன் மூலம் உருவாக்கப்பட்ட ஒரு சரத்தை வழங்குகிறது. திரும்பிய மதிப்பு `` சரம் 1`` க்கு துவக்கப்படுகிறது. `` முன்னொட்டு, சரம்`` ஜோடிகளிலிருந்து தயாரிக்கப்பட்ட சரங்கள் மதிப்பின் முடிவில் சேர்க்கப்படுகின்றன, இதன் விளைவாக வரும் சரம் நீளம் `` அதிகபட்சம்`` ஐ விட குறைவாக இருக்கும் வரை. முன்னொட்டுகள் காலியாக இருக்கலாம். `` String1`` `` அதிகபட்சம்` ஐ விட நீளமாக இருந்தாலும்` சரம் 1` ஐ வழங்குகிறது. நீங்கள் விரும்பும் பல `` முன்னொட்டு, சரம்` `ஜோடிகளை நீங்கள் கடந்து செல்லலாம்.
`` strcmp (x, y, lt, eq, gt) - x`` மற்றும் `` y`` ஆகியவற்றின் வழக்கு-உணர்வற்ற லெக்சிகல் ஒப்பீடு செய்கிறது. `` Lt`` என்றால் `` x <y``, `` eq`` என்றால் `` x == y`` என்றால், இல்லையெனில் `` gt``. இந்த செயல்பாடு பெரும்பாலும் லெக்சிகல் ஒப்பீட்டு ஆபரேட்டர்களில் ஒருவரால் மாற்றப்படலாம் (`` == ``, ``> ``, < ``, முதலியன)
`` strcmpcase (x, y, lt, eq, gt) - x`` மற்றும் y`` ஆகியவற்றின் வழக்கு-உணர்திறன் ஒப்பீட்டு ஒப்பீடு செய்கிறது. `` Lt`` என்றால் `` x <y``, `` eq`` என்றால் `` x == y`` என்றால், இல்லையெனில் `` gt``.

குறிப்பு: இது காலிபர் பயன்படுத்தும் இயல்புநிலை நடத்தை அல்ல, எடுத்துக்காட்டாக, லெக்சிகல் ஒப்பீட்டு ஆபரேட்டர்கள் (`` == ``, > , < , முதலியன). இந்த செயல்பாடு எதிர்பாராத முடிவுகளை ஏற்படுத்தக்கூடும், முன்னுரிமை ` strcmp () `` முடிந்தவரை பயன்படுத்தவும்.
`` strlen (மதிப்பு) `` - சரத்தின் நீளத்தை `` மதிப்பு`` தருகிறது.
`` அடிமை (str, start, end) `` - `` str` 'இன் `` எண்ட்``' என்ற எழுத்துக்கள் மூலம் `` தொடக்க`` ஐ வழங்குகிறது. `` Str`` இன் முதல் எழுத்து பூஜ்ஜியத்தின் பாத்திரம். `` முடிவு`` எதிர்மறையாக இருந்தால், பல எழுத்துக்கள் வலதுபுறத்தில் இருந்து எண்ணப்படுவதை இது குறிக்கிறது. `` முடிவு`` பூஜ்ஜியமாக இருந்தால், அது கடைசி தன்மையைக் குறிக்கிறது. எடுத்துக்காட்டாக, `` அடிமை ('12345', 1, 0) `` `` 2345'`` ஐத் தருகிறது, மற்றும் `` 12345 ', 1, -1) `` 234' 234'`` திரும்புகிறது .
`` கழிக்கவும் (x, y) `` - `` x - y`` ஐ வழங்குகிறது. `` X`` அல்லது `` y`` எண்கள் இல்லையென்றால் விதிவிலக்கை வீசுகிறது. இந்த செயல்பாட்டை வழக்கமாக `` -`` ஆபரேட்டரால் மாற்றலாம்.
`` Switch_if ([test_expression, value_expression,]+ else_expression) -ஒவ்வொரு `` டெஸ்ட்_எக்ஸ்பிரஷன்` ஜோடிக்கும், `` டெஸ்ட்_எக்ஸ்பிரஷன் உண்மையாக இருந்தால் (காலியாக இல்லாதது), எனவே `` டெஸ்ட்_எக்ஸ்பிரஷன்` value_expression`. `` Test_expression`` உண்மை என்றால், `` else_expression` இன் முடிவு திரும்பப் பெறப்படும். நீங்கள் விரும்பும் அளவுக்கு `` டெஸ்ட்_எக்ஸ்பிரஷன், மதிப்பு_எக்ஸ்பிரஷன்` ஜோடிகளைக் கொண்டிருக்கலாம்.
`` இன்று () `` - இன்றைய (இப்போது) தேதி+நேர சரத்தை திருப்பித் தரவும். இந்த மதிப்பு format_date அல்லது` Days_between` இல் பயன்படுத்த வடிவமைக்கப்பட்டுள்ளது, ஆனால் வேறு எந்த சரத்தையும் போல கையாளலாம். தேதி ஐசோ <https://en.wikipedia.org/wiki/iso_8601> _ தேதி/நேர வடிவத்தில் உள்ளது.
`` வார்ப்புரு (x) `` - `` x`` ஒரு வார்ப்புருவாக மதிப்பிடுகிறது. மதிப்பீடு அதன் சொந்த சூழலில் செய்யப்படுகிறது, அதாவது அழைப்பாளருக்கும் வார்ப்புரு மதிப்பீட்டிற்கும் இடையில் மாறிகள் பகிரப்படவில்லை.
`` to_hex (val) `` - ஹெக்ஸில் குறியிடப்பட்ட சரம் `` வால்`` ஐ வழங்குகிறது. காலிபர் URL களை உருவாக்கும்போது இது பயனுள்ளதாக இருக்கும்.
`` urls_from_identifiers (அடையாளங்காட்டிகள், sort_results) - அடையாளங்காட்டிகள்`` இன் கமாவால் பிரிக்கப்பட்ட பட்டியலைக் கொடுத்தால், ஒரு அடையாளங்காட்டி என்பது பெருங்குடலால் பிரிக்கப்பட்ட ஜோடி மதிப்புகள் (` ஐடி_நேம்: ஐடி_வலூ`), ஒரு வருமானம் அடையாளங்காட்டிகளிடமிருந்து உருவாக்கப்பட்ட HTML URL களின் கமாவால் பிரிக்கப்பட்ட பட்டியல். Sort_Results `` 0`` (எழுத்து அல்லது எண்) என்றால் பட்டியல் வரிசைப்படுத்தப்படாது, இல்லையெனில் இது அடையாளங்காட்டி பெயரால் அகர வரிசைப்படி வரிசைப்படுத்தப்படுகிறது. URL கள் காட்டப்படும் போது உள்ளமைக்கப்பட்ட அடையாளங்காட்டிகள் நெடுவரிசையைப் போலவே உருவாக்கப்படுகின்றன: கிலாபெல்: புத்தக விவரங்கள்.

வார்ப்புரு வெளிப்பாடுகளில் மிகவும் சிக்கலான நிரல்கள் - வார்ப்புரு நிரல் பயன்முறை¶

வார்ப்புரு நிரல் பயன்முறை (` TPM`) என்பது ஒரு கலவையாகும்: குறிப்பு: பொது நிரல் பயன்முறை <பொது_மோட்> மற்றும்: குறிப்பு: ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>. TPM ஒற்றை செயல்பாட்டு பயன்முறையிலிருந்து வேறுபடுகிறது, இது பிற மெட்டாடேட்டா புலங்களைக் குறிக்கும் வார்ப்புரு வெளிப்பாடுகளை எழுத அனுமதிக்கிறது, உள்ளமைக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்துகிறது, மாறிகளை மாற்றியமைத்தல் மற்றும் எண்கணிதத்தை செய்கிறது. இது பொது நிரல் பயன்முறையிலிருந்து வேறுபடுகிறது, இதில் வார்ப்புரு` { மற்றும் } `` `` நிரல்: `` என்ற வார்த்தையுடன் தொடங்குவதில்லை. வார்ப்புருவின் நிரல் பகுதி ஒரு பொதுவான நிரல் பயன்முறை வெளிப்பாடு பட்டியல்.

எடுத்துக்காட்டு: ஒரு புத்தகத்திற்கான தொடரை ஒன்று இருந்தால் ஒரு வார்ப்புரு காட்ட வேண்டும் என்று வைத்துக் கொள்ளுங்கள், இல்லையெனில் தனிப்பயன் புலத்தின் மதிப்பைக் காட்டுங்கள். இதை நீங்கள் செய்ய முடியாது: ref: ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்> ஏனெனில் ஒரு வார்ப்புரு வெளிப்பாட்டிற்குள் மற்றொரு மெட்டாடேட்டா புலத்தைக் குறிப்பிட முடியாது. TPM இல், பின்வரும் வெளிப்பாடு நிரூபிக்கிறபடி

{#series:'ifempty($, field('#genre'))'}

எடுத்துக்காட்டு பல விஷயங்களைக் காட்டுகிறது:

வெளிப்பாடு : ' உடன் தொடங்கி ``'} `` உடன் முடிவடைந்தால் டிபிஎம் பயன்படுத்தப்படுகிறது. வேறு எதுவும் இருக்க வேண்டும் என்று கருதப்படுகிறது: குறிப்பு: ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>.
மாறி `` $ `` என்பது வார்ப்புருவில் பெயரிடப்பட்ட புலத்தைக் குறிக்கிறது: வெளிப்பாடு இந்த விஷயத்தில் #தொடர் இயங்குகிறது.
செயல்பாடுகளுக்கு அவற்றின் அனைத்து வாதங்களும் வழங்கப்பட வேண்டும். இயல்புநிலை மதிப்பு இல்லை. எடுத்துக்காட்டாக, நிலையான உள்ளமைக்கப்பட்ட செயல்பாடுகளுக்கு மூல புலத்தைக் குறிக்கும் கூடுதல் ஆரம்ப அளவுரு வழங்கப்பட வேண்டும்.
வெள்ளை இடம் புறக்கணிக்கப்படுகிறது மற்றும் வெளிப்பாட்டிற்குள் எங்கும் பயன்படுத்தலாம்.
பொருந்தக்கூடிய மேற்கோள்களில் நிலையான சரங்கள் இணைக்கப்பட்டுள்ளன, `` '`` அல்லது `` "` `.

ஒற்றை செயல்பாட்டு பயன்முறை மற்றும்` பொது நிரல் பயன்முறை` ஆகியவற்றின் கீழ் பட்டியலிடப்பட்டுள்ள அனைத்து செயல்பாடுகளையும் TPM இல் பயன்படுத்தலாம்.

TPM இல்,` { மற்றும் } ஆகியவற்றைப் பயன்படுத்தி சரம் எழுத்தாளர்களில் எழுத்துக்கள் பிழைகள் அல்லது எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும், ஏனெனில் அவை வார்ப்புரு செயலியைக் குழப்புகின்றன. இது அவற்றை வார்ப்புரு வெளிப்பாடு எல்லைகளாக கருத முயற்சிக்கிறது, எழுத்துக்கள் அல்ல. சில ஆனால் எல்லா நிகழ்வுகளிலும் நீங்கள் ஒரு ` `` [ மற்றும் ஒரு } ] `உடன் மாற்றலாம். பொதுவாக, உங்கள் நிரலில் `` { மற்றும் ``} `` எழுத்துக்கள் இருந்தால், நீங்கள் பொது நிரல் பயன்முறையை பயன்படுத்த வேண்டும்.

பொது நிரல் பயன்முறையைப் போலவே, ஆவணப்படுத்தப்பட்ட செயல்பாடுகளுக்கு: ref: ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்> ஆவணப்படுத்தப்பட்ட அளவுருக்களுக்கு கூடுதலாக முதல் அளவுருவாக செயல்படும் மதிப்பை நீங்கள் வழங்க வேண்டும். `TPM இல், வார்ப்புரு வெளிப்பாட்டிற்காக` தேடல் பெயர்` ஆல் குறிப்பிடப்பட்ட மதிப்பை அணுக` $ `பயன்படுத்தலாம்.

பைதான் வார்ப்புரு பயன்முறை¶

பைதான் வார்ப்புரு பயன்முறை (பி.டி.எம்) சொந்த பைதான் மற்றும் காலிபர் ஏபிஐ <https://manual.calibre-ebook.com/develop.html#api- ஆவணப்படுத்தல்-ஃபார்-வெரிட்டஸ்-பார்ட்ஸ்-கலிபிரே> _. தரவுத்தள ஏபிஐ மிகவும் பயன்பாட்டில் இருக்கும்; மேலும் விவாதம் இந்த கையேட்டின் எல்லைக்கு அப்பாற்பட்டது. பி.டி.எம் வார்ப்புருக்கள் வேகமானவை, மேலும் சிக்கலான செயல்பாடுகளைச் செய்ய முடியும், ஆனால் காலிபர் ஏபிஐ பயன்படுத்தி பைத்தானில் குறியீட்டை எவ்வாறு எழுதுவது என்பது உங்களுக்குத் தெரிந்திருக்க வேண்டும்.

ஒரு பி.டி.எம் வார்ப்புரு தொடங்குகிறது:

python:
def evaluate(book, context):
    # book is a calibre metadata object
    # context is an instance of calibre.utils.formatter.PythonTemplateContext,
    # which currently contains the following attributes:
    # db: a calibre legacy database object.
    # globals: the template global variable dictionary.
    # arguments: is a list of arguments if the template is called by a GPM template, otherwise None.
    # funcs: used to call Built-in/User functions and Stored GPM/Python templates.
    # Example: context.funcs.list_re_group()

    # your Python code goes here
    return 'a string'

சூழல் மெனுவைப் பயன்படுத்தி மேலே உள்ள உரையை உங்கள் வார்ப்புருவில் சேர்க்கலாம், வழக்கமாக வலது கிளிக் மூலம் அணுகலாம். கருத்துகள் குறிப்பிடத்தக்கவை அல்ல மற்றும் அகற்றப்படலாம். நீங்கள் பைத்தானை உள்தள்ளலைப் பயன்படுத்த வேண்டும்.

சூழல் பொருள் `` str (சூழல்) `` ஆகியவற்றை ஆதரிக்கிறது, இது சூழலின் உள்ளடக்கங்களின் ஒரு சரத்தை வழங்குகிறது, மற்றும் `` சூழல்.

`` Context.funcs`` பண்புக்கூறு உள்ளமைக்கப்பட்ட மற்றும் பயனர் வார்ப்புரு செயல்பாடுகளை அழைக்க அனுமதிக்கிறது, மேலும் ஜிபிஎம்/பைதான் வார்ப்புருக்கள் சேமித்து வைக்கப்பட்டுள்ளது, இதன் மூலம் அவற்றை உங்கள் குறியீட்டில் நேரடியாக இயக்க முடியும். செயல்பாடுகள் அவற்றின் பெயர்களைப் பயன்படுத்தி மீட்டெடுக்கப்படுகின்றன. பெயர் பைதான் முக்கிய சொல்லுடன் முரண்பட்டால், பெயரின் முடிவில் அடிக்கோடிட்டு சேர்க்கவும். எடுத்துக்காட்டுகள்:

context.funcs.list_re_group()
context.funcs.assert_()

ஒரு தொடருக்கான அனைத்து ஆசிரியர்களின் பட்டியலையும் உருவாக்கும் PTM வார்ப்புருவின் எடுத்துக்காட்டு இங்கே. பட்டியல் மற்ற நெடுவரிசைகளிலிருந்து கட்டப்பட்ட நெடுவரிசையில் சேமிக்கப்படுகிறது, குறிச்சொற்கள் போன்ற செயல்படுகிறது. இது காட்டுகிறது: கிலாபெல்: `புத்தக விவரங்கள் மற்றும் தி: கிலாபெல்:` தனி வரிகளில்` சரிபார்க்கப்பட்டது (இல்: கிலாபெல்: விருப்பத்தேர்வுகள்-> தோற்றம் & உணர்வு-> புத்தக விவரங்கள்). அந்த விருப்பத்திற்கு பட்டியல் கமாவால் பிரிக்கப்பட வேண்டும். அந்த தேவையை பூர்த்தி செய்ய வார்ப்புரு கம்மாக்களை ஆசிரியர் பெயர்களில் அரைக்காற்புள்ளிகளாக மாற்றுகிறது, பின்னர் கமாவால் பிரிக்கப்பட்ட ஆசிரியர்களின் பட்டியலை உருவாக்குகிறது. பின்னர் ஆசிரியர்கள் வரிசைப்படுத்தப்படுகிறார்கள், அதனால்தான் வார்ப்புரு எழுத்தாளர்_சார்ட்டைப் பயன்படுத்துகிறது.

python:
def evaluate(book, context):
    if book.series is None:
        return ''
    db = context.db.new_api
    ans = set()
    # Get the list of books in the series
    ids = db.search(f'series:"={book.series}"', '')
    if ids:
        # Get all the author_sort values for the books in the series
        author_sorts = (v for v in db.all_field_for('author_sort', ids).values())
        # Add the names to the result set, removing duplicates
        for aus in author_sorts:
            ans.update(v.strip() for v in aus.split('&'))
    # Make a sorted comma-separated string from the result set
    return ', '.join(v.replace(',', ';') for v in sorted(ans))

வெளியீடு: கிலாபெல்: புத்தக விவரங்கள் இது போல் தெரிகிறது:

சேமிக்கப்பட்ட வார்ப்புருக்கள்¶

இரண்டும்: குறிப்பு: பொது நிரல் பயன்முறை <பொது_மோட்> மற்றும்: குறிப்பு: பைதான் வார்ப்புரு பயன்முறை <பைதான்_மோட்> சேமிப்பு வார்ப்புருக்கள் மற்றும் அந்த வார்ப்புருக்களை மற்றொரு வார்ப்புருவில் இருந்து அழைப்பதை ஆதரிக்கவும், சேமிக்கப்பட்ட செயல்பாடுகளை அழைப்பது போன்றது. பயன்படுத்தி வார்ப்புருக்களைச் சேமிக்கிறீர்கள்: கிலாபெல்: விருப்பத்தேர்வுகள்-> மேம்பட்ட-> வார்ப்புரு செயல்பாடுகள். அந்த உரையாடலில் மேலும் தகவல்கள் வழங்கப்பட்டுள்ளன. நீங்கள் ஒரு செயல்பாட்டை அழைப்பது போலவே ஒரு வார்ப்புருவை அழைக்கிறீர்கள், விரும்பினால் நிலை வாதங்களை கடந்து செல்கிறீர்கள். ஒரு வாதம் எந்த வெளிப்பாடாகவும் இருக்கலாம். ஒரு வார்ப்புருவை அழைப்பதற்கான எடுத்துக்காட்டுகள், சேமிக்கப்பட்ட வார்ப்புருவுக்கு `` foo`` என்று பெயரிடப்பட்டுள்ளது என்று கருதுகிறது:

`` foo () `` - எந்த வாதங்களையும் கடந்து செல்லும் வார்ப்புருவை அழைக்கவும்.
`` foo (a, b) `` இரண்டு மாறிகளின் மதிப்புகளை கடந்து செல்லும் வார்ப்புருவை அழைக்கவும் `` a`` மற்றும் `` b``.
`` ஃபூ (புலம் ('தொடர்') பின்னர் புலம் ('சீரிஸ்_இண்டெக்ஸ்') வேறு 0 fi) `` - புத்தகத்தில் `` தொடர்`` இருந்தால் `` sitery_index`` ஐ கடந்து செல்லுங்கள், இல்லையெனில் மதிப்பை அனுப்பவும் ` 0`.

ஜி.பி.எம்மில் நீங்கள் `` வாதங்கள்`` செயல்பாட்டைப் பயன்படுத்தி சேமிக்கப்பட்ட வார்ப்புருவுக்கான அழைப்பில் அனுப்பப்பட்ட வாதங்களை மீட்டெடுக்கிறீர்கள். இது உள்ளூர் மாறிகள், திறம்பட அளவுருக்களை அறிவித்து துவக்குகிறது. மாறிகள் நிலை; அழைப்பில் கொடுக்கப்பட்ட அளவுருவின் மதிப்பை அவர்கள் அதே நிலையில் பெறுகிறார்கள். தொடர்புடைய அளவுரு அழைப்பில் வழங்கப்படாவிட்டால், `` வாதங்கள்`` அந்த மாறியை வழங்கிய இயல்புநிலை மதிப்பை ஒதுக்குகிறது. இயல்புநிலை மதிப்பு இல்லை என்றால், மாறி வெற்று சரத்திற்கு அமைக்கப்படுகிறது. எடுத்துக்காட்டாக, பின்வரும் `` வாதங்கள்`` செயல்பாடு 2 மாறிகள், `` விசை``, `` மாற்று``

arguments(key, alternate='series')

எடுத்துக்காட்டுகள், மீண்டும் சேமிக்கப்பட்ட வார்ப்புருவை `` foo`` என்று பெயரிட்டதாகக் கருதினால்:

`` foo ('#myseries') `` - வாதம் `` key`` மதிப்பு `` 'myseries'`` மற்றும் `` மாற்று`` இயல்புநிலை மதிப்பு ' தொடர்'``````` ' .
`` foo ('தொடர்', '#genre') `` மாறி KEY` மதிப்பை` 'தொடர்'` மற்றும்` மாற்று` என்ற மதிப்பை ஒதுக்கப்படுகிறது` #Genre '`.
`` foo () `` - மாறி `` KEY`` வெற்று சரம் ஒதுக்கப்படுகிறது மற்றும் `` மாற்று`` என்ற மாறி `` 'தொடர்'`` என்ற மதிப்பை ஒதுக்குகிறது.

PTM இல் வாதங்கள் `` வாதங்கள்` அளவுருவில் அனுப்பப்படுகின்றன, இது சரங்களின் பட்டியல். இயல்புநிலை மதிப்புகளைக் குறிப்பிட எந்த வழியும் இல்லை. வாதங்களின் எண்ணிக்கை நீங்கள் எதிர்பார்ப்பது என்பதை உறுதிப்படுத்த ` வாதங்கள்` பட்டியலின் நீளத்தை நீங்கள் சரிபார்க்க வேண்டும்.

சேமிக்கப்பட்ட வார்ப்புருக்களை சோதிக்க ஒரு எளிதான வழி `` வார்ப்புரு சோதனையாளர்` உரையாடலைப் பயன்படுத்துகிறது. அணுகலின் எளிமைக்கு இதற்கு ஒரு விசைப்பலகை குறுக்குவழியைக் கொடுங்கள்: கிலாபெல்: விருப்பத்தேர்வுகள்-> மேம்பட்ட-> விசைப்பலகை குறுக்குவழிகள்-> வார்ப்புரு சோதனையாளர். `` சேமிக்கப்பட்ட வார்ப்புருக்கள்` `உரையாடலை ஒரு குறுக்குவழியைக் கொடுப்பது சோதனையாளருக்கு இடையில் விரைவாக மாறவும், சேமிக்கப்பட்ட வார்ப்புருவின் மூலக் குறியீட்டைத் திருத்தவும் உதவும்.

வார்ப்புருக்களுக்கு கூடுதல் தகவல்களை வழங்குதல்¶

பயன்பாட்டு-குறிப்பிட்ட புத்தக மெட்டாடேட்டா போன்ற வார்ப்புரு செயலிக்கு கூடுதல் தகவல்களை அனுப்ப ஒரு டெவலப்பர் தேர்வு செய்யலாம் அல்லது செயலி என்ன செய்யக் கேட்கப்படுகிறது என்பது பற்றிய தகவல்கள். ஒரு வார்ப்புரு இந்த தகவலை அணுகலாம் மற்றும் மதிப்பீட்டின் போது அதைப் பயன்படுத்தலாம்.

** டெவலப்பர்: கூடுதல் தகவல்களை எவ்வாறு அனுப்புவது **

கூடுதல் தகவல்கள் `` மாறி_பெயர்: மாறி_ மதிப்புள்ள ஜோடிகளைக் கொண்ட பைதான் அகராதி ஆகும், அங்கு மதிப்புகள் சரங்களாக இருக்க வேண்டும். வார்ப்புரு அகராதியை அணுகலாம், `` Variang_value`` மதிப்பைக் கொண்ட `` varian_name`` என்ற பெயரிடப்பட்ட வார்ப்புரு உள்ளூர் மாறிகள் உருவாக்கலாம். பயனரால் பெயரை மாற்ற முடியாது, எனவே பிற வார்ப்புரு உள்ளூர் மாறிகளுடன் மோதாத பெயர்களைப் பயன்படுத்துவது சிறந்தது, எடுத்துக்காட்டாக பெயரை அடிக்கோடிட்டுக் காட்டுவதன் மூலம்.

இந்த அகராதி பெயரிடப்பட்ட அளவுருவைப் பயன்படுத்தி `` உலகளாவிய_வார்ஸ் = உங்கள்_டிக்ட்`` ஐப் பயன்படுத்தி வார்ப்புரு செயலிக்கு (`` ஃபார்மேட்டர்``) அனுப்பப்படுகிறது. முழு முறை கையொப்பம்

def safe_format(self, fmt, kwargs, error_value, book,
                column_name=None, template_cache=None,
                strip_results=True, template_functions=None,
                global_vars={})

** வார்ப்புரு எழுத்தாளர்: கூடுதல் தகவல்களை எவ்வாறு அணுகுவது **

வார்ப்புரு செயல்பாட்டைப் பயன்படுத்தி ஒரு வார்ப்புருவில் கூடுதல் தகவலை (`` குளோபல்ஸ்` அகராதி) அணுகலாம்

globals(id[=expression] [, id[=expression]]*)

`` ஐடி`` என்பது ஏதேனும் சட்டப்பூர்வ மாறி பெயர். டெவலப்பர் வழங்கிய கூடுதல் தகவல்களில் பெயர் உள்ளதா என்பதை இந்த செயல்பாடு சரிபார்க்கிறது. அவ்வாறு செய்தால், செயல்பாடு அந்த பெயருடன் ஒரு வார்ப்புரு உள்ளூர் மாறிக்கு வழங்கப்பட்ட மதிப்பை ஒதுக்குகிறது. பெயர் கூடுதல் தகவலில் இல்லை என்றால், `` வெளிப்பாடு`` வழங்கப்பட்டால், `` வெளிப்பாடு`` மதிப்பீடு செய்யப்பட்டு, இதன் விளைவாக உள்ளூர் மாறிக்கு ஒதுக்கப்படுகிறது. ஒரு மதிப்பு அல்லது வெளிப்பாடு வழங்கப்படாவிட்டால், செயல்பாடு உள்ளூர் மாறிக்கு வெற்று சரத்தை (`` '' ``) ஒதுக்குகிறது.

ஒரு வார்ப்புரு வார்ப்புரு செயல்பாட்டைப் பயன்படுத்தி `` குளோபல்ஸ்` `அகராதியில் ஒரு மதிப்பை அமைக்க முடியும்

set_globals(id[=expression] [, id[=expression]]*)

இந்த செயல்பாடு `` குளோபல்ஸ்` அகராதி விசையை அமைக்கிறது: மதிப்பு ஜோடி `` ஐடி: மதிப்பு`` அங்கு `` மதிப்பு`` என்பது வார்ப்புரு உள்ளூர் மாறியின் மதிப்பு `` ஐடி``. அந்த உள்ளூர் மாறி இல்லை என்றால், `` வெளிப்பாடு`` மதிப்பிடுவதன் விளைவாக `` மதிப்பு`.

முறைகளுக்கு இடையிலான வேறுபாடு குறித்த குறிப்புகள்¶

மூன்று நிரல் முறைகள்,: குறிப்பு: ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்> (எஸ்.எஃப்.எம்),: குறிப்பு: வார்ப்புரு நிரல் பயன்முறை <டெம்ப்ளேட்_மோட்> (டிபிஎம்), மற்றும்: குறிப்பு:` பொது நிரல் பயன்முறை <பொது_மோட்> ( `ஜிபிஎம்), வித்தியாசமாக வேலை செய்யுங்கள். எஸ்.எஃப்.எம் 'எளிமையானது' என்று கருதப்படுகிறது, எனவே இது நிறைய நிரலாக்க மொழி பிட்களை மறைக்கிறது.

வேறுபாடுகள்:

SFM இல், நெடுவரிசையின் மதிப்பு எப்போதும் வார்ப்புருவில் சேர்க்கப்பட்டுள்ள ஒரு செயல்பாட்டிற்கு 'கண்ணுக்கு தெரியாத' முதல் வாதமாக அனுப்பப்படுகிறது.
SFM மாறிகள் மற்றும் சரங்களுக்கு இடையிலான வேறுபாட்டை ஆதரிக்காது; அனைத்து மதிப்புகளும் சரங்கள்.
பின்வரும் SFM வார்ப்புரு தொடர் பெயர் அல்லது "தொடர் இல்லை" என்ற சரத்தை வழங்குகிறது
```
{series:ifempty(no series)}
```
TPM இல் சமமான வார்ப்புரு
```
{series:'ifempty($, 'no series')'}
```
ஜி.பி.எம் இல் சமமான வார்ப்புரு
```
program: ifempty(field('series'), 'no series')
```
`` Ifempty`` க்கான முதல் வாதம் புலத்தின் மதிப்பு `` தொடர்``. இரண்டாவது வாதம் சரம் `` இல்லை தொடர்``. SFM இல் முதல் வாதம், புலத்தின் மதிப்பு தானாகவே அனுப்பப்படுகிறது (கண்ணுக்கு தெரியாத வாதம்).
பல வார்ப்புரு செயல்பாடுகள், எடுத்துக்காட்டாக `` புத்தகங்களை () `` மற்றும் `` நடப்பு_லிபரி_பேம் () ``, எந்த வாதங்களும் எடுக்கவில்லை. 'கண்ணுக்கு தெரியாத வாதம்' காரணமாக இந்த செயல்பாடுகளை SFM இல் பயன்படுத்த முடியாது.
ஒரு வாதத்தை கணக்கிட மற்றொரு செயல்பாட்டை ஒரு செயல்பாடு அழைக்கும் உள்ளமைக்கப்பட்ட செயல்பாடுகள், SFM இல் பயன்படுத்த முடியாது. எடுத்துக்காட்டாக, இந்த வார்ப்புரு, தொடர் மதிப்பின் முதல் 5 எழுத்துக்களைத் திருப்பித் தரும் நோக்கம் கொண்டது, SFM இல் வேலை செய்யாது
```
{series:uppercase(substr(0,5))}
```
TPM மற்றும்` gpm` ஆகியவை உள்ளமைக்கப்பட்ட செயல்பாடுகளை ஆதரிக்கின்றன. TPM இல் உள்ள வார்ப்புரு
```
{series:'uppercase(substr($, 0,5))'}
```
ஜிபிஎம் இல்
```
program: uppercase(substr(field('series'), 0,5))
```
மேலே குறிப்பிட்டுள்ளபடி: Ref: வார்ப்புரு நிரல் பயன்முறை <template_mode> பிரிவு, `` {`` மற்றும் } `` `டிபிஎம்` சரம் இலக்கிய எழுத்துக்கள் பிழைகள் அல்லது எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும், ஏனெனில் அவை வார்ப்புரு செயலி குழப்பத்தை ஏற்படுத்துகின்றன . இது அவர்களை வார்ப்புரு எல்லைகளாக கருத முயற்சிக்கிறது, எழுத்துக்கள் அல்ல. சில ஆனால் எல்லா நிகழ்வுகளிலும் நீங்கள் ஒரு `` `` `[` `மற்றும் ஒரு` `}` ``] `உடன் மாற்றலாம். பொதுவாக, உங்கள் நிரலில் `` { மற்றும் ``} `` எழுத்துக்கள் இருந்தால், நீங்கள் பொது நிரல் பயன்முறையை பயன்படுத்த வேண்டும்.

பயனர் வரையறுக்கப்பட்ட பைதான் வார்ப்புரு செயல்பாடுகள்¶

உங்கள் சொந்த பைதான் செயல்பாடுகளை வார்ப்புரு செயலியில் சேர்க்கலாம். இத்தகைய செயல்பாடுகளை மூன்று வார்ப்புரு நிரலாக்க முறைகளில் பயன்படுத்தலாம். செல்வதன் மூலம் செயல்பாடுகள் சேர்க்கப்படுகின்றன: கிலாபெல்: விருப்பத்தேர்வுகள் -> மேம்பட்ட -> வார்ப்புரு செயல்பாடுகள். அந்த உரையாடலில் வழிமுறைகள் காட்டப்பட்டுள்ளன.

வார்ப்புருக்கள் சேமிக்க/அனுப்ப சிறப்பு குறிப்புகள்¶

ஒரு வார்ப்புரு சேமி வட்டுக்கு அல்லது` சாதனத்திற்கு அனுப்புங்கள்` வார்ப்புருவில் பயன்படுத்தப்படும்போது சிறப்பு செயலாக்கம் பயன்படுத்தப்படுகிறது. புலங்களின் மதிப்புகள் சுத்தம் செய்யப்படுகின்றன, கோப்பு முறைமைகளுக்கு சிறப்பு வாய்ந்த எழுத்துக்களை மாற்றியமைக்கின்றன, அவை ஸ்லாஷ்கள் உட்பட அடிக்கோடிட்டுக் காட்டுகின்றன. கோப்புறைகளை உருவாக்க புல உரையை பயன்படுத்த முடியாது என்பதே இதன் பொருள். இருப்பினும், முன்னொட்டு அல்லது பின்னொட்டு சரங்களில் ஸ்லாஷ்கள் மாற்றப்படவில்லை, எனவே இந்த சரங்களில் உள்ள குறைப்புக்கள் கோப்புறைகளை உருவாக்கும். இதன் காரணமாக, நீங்கள் மாறி-ஆழமான கோப்புறை கட்டமைப்பை உருவாக்கலாம்.

எடுத்துக்காட்டாக, தொடர்/தொடர்_இண்டெக்ஸ் - தலைப்பு என்ற கோப்புறை அமைப்பு வேண்டும் என்று வைத்துக் கொள்ளுங்கள், தொடர் இல்லை என்றால், தலைப்பு சிறந்த கோப்புறையில் இருக்க வேண்டும். இதைச் செய்வதற்கான வார்ப்புரு

{series:||/}{series_index:|| - }{title}

தொடர் காலியாக இல்லாவிட்டால் மட்டுமே ஸ்லாஷ் மற்றும் ஹைபன் தோன்றும்.

தேடல் செயல்பாடு ஆர்வமுள்ள செயலாக்கத்தை கூட செய்ய அனுமதிக்கிறது. எடுத்துக்காட்டாக, ஒரு புத்தகத்தில் ஒரு தொடர் இருந்தால், கோப்புறை கட்டமைப்பை தொடர்/தொடர் குறியீட்டு - title.fmt வேண்டும் என்று வைத்துக் கொள்ளுங்கள். புத்தகத்தில் ஒரு தொடர் இல்லையென்றால், வகை/எழுத்தாளர்_சார்ட்/தலைப்பு. Fmt என்ற கோப்புறை கட்டமைப்பை நாங்கள் விரும்புகிறோம். புத்தகத்தில் எந்த வகையும் இல்லை என்றால், நாம் 'தெரியாத' பயன்படுத்த விரும்புகிறோம். தொடரின் மதிப்பைப் பொறுத்து இரண்டு முற்றிலும் மாறுபட்ட பாதைகளை நாங்கள் விரும்புகிறோம்.

இதை நிறைவேற்ற, நாங்கள்:

`` {தொடர்}/{sitery_index} - {தலைப்பு} `` ஆகியவற்றைக் கொண்ட ஒரு கலப்பு புலத்தை உருவாக்கவும் (#AA க்கு #AA ஐ கொடுங்கள்). தொடர் காலியாக இல்லாவிட்டால், இந்த வார்ப்புரு தொடர்/தொடர்_இண்டெக்ஸ் - தலைப்பு ஐ உருவாக்கும்.
`` {#Genre: ifempty (அறியப்படாத)}/{auther_sort}/{title} `` கொண்ட ஒரு கலப்பு புலத்தை உருவாக்கவும் (#BB க்கு #BB ஐ கொடுங்கள்) உருவாக்கவும். இந்த வார்ப்புரு வகை/ஆசிரியர்_சார்ட்/தலைப்பு ஐ உருவாக்குகிறது, அங்கு வெற்று வகை` தெரியாத` உடன் மாற்றப்படுகிறது.
சேமி வார்ப்புருவை `` {தொடர்: தேடல் (.,#aa,#bb)} `` என அமைக்கவும். தொடர் காலியாக இல்லாவிட்டால் கலப்பு புலம் #aa ஐ தேர்வு செய்கிறது #பிபி தொடர் காலியாக இருந்தால். ஆகவே, தொடர் காலியாக உள்ளதா இல்லையா என்பதைப் பொறுத்து எங்களிடம் இரண்டு முற்றிலும் மாறுபட்ட சேமிப்பு பாதைகள் உள்ளன.

உதவிக்குறிப்புகள்¶

வார்ப்புருக்களை சோதிக்க வார்ப்புரு சோதனையாளரைப் பயன்படுத்தவும். நூலகத்தில் உள்ள புத்தகங்களுக்கான சூழல் மெனுவில் சோதனையாளரைச் சேர்த்து/அல்லது விசைப்பலகை குறுக்குவழியைக் கொடுங்கள்.
விரும்பிய வார்ப்புருவுடன் கட்டமைக்கப்பட்ட கலப்பு நெடுவரிசைகளைக் குறிப்பிடுவதன் மூலம் வார்ப்புருக்கள் பிற வார்ப்புருக்களைப் பயன்படுத்தலாம். மாற்றாக, நீங்கள் சேமிக்கப்பட்ட வார்ப்புருக்களைப் பயன்படுத்தலாம்.
ஒரு பிளக் போர்டில், சிறப்பு வார்ப்புருவைப் பயன்படுத்தி {} `` பயன்படுத்துவதன் மூலம் ஒரு புலத்தை காலியாக (அல்லது காலியாக எதுவுமில்லை) அமைக்கலாம். இந்த வார்ப்புரு எப்போதும் வெற்று சரத்திற்கு மதிப்பீடு செய்யும்.
எண்களைக் காட்ட மேலே விவரிக்கப்பட்ட நுட்பம் பூஜ்ஜிய மதிப்பு இருந்தாலும் அவை நிலையான புலம் தொடர்_இண்டெக்ஸுடன் வேலை செய்கின்றன.

செயல்பாடு குறிப்பு¶

Reference for all built-in template language functions