कोटलिन नेटिव: फाइलों का ट्रैक रखें

जब आप एक कमांड लाइन उपयोगिता लिखते हैं, तो आखिरी चीज जिस पर आप भरोसा करना चाहते हैं वह यह है कि जेवीएम, रूबी या पायथन कंप्यूटर पर स्थापित है जहां यह चल रहा होगा। मैं एक बाइनरी फ़ाइल भी लेना चाहूंगा जिसे लॉन्च करना आसान होगा। और स्मृति प्रबंधन के साथ बहुत परेशान मत करो।

उपरोक्त कारणों से, हाल के वर्षों में, जब भी मुझे ऐसी उपयोगिताओं को लिखने की आवश्यकता हुई, मैंने गो का उपयोग किया।

गो में अपेक्षाकृत सरल सिंटैक्स है, एक अच्छा मानक पुस्तकालय है, एक कचरा संग्रह है, और आउटपुट पर हमें एक बाइनरी मिलती है। ऐसा लगता है कि और क्या चाहिए?

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

हमें जो समस्या हल करनी है: कोटलिन नेटिव पर एक साधारण फ़ाइल वॉचर लिखें। तर्क के रूप में, उपयोगिता को फ़ाइल पथ और स्कैन की आवृत्ति मिलनी चाहिए। यदि फ़ाइल बदल गई है, तो उपयोगिता को नए नाम के साथ उसी फ़ोल्डर में इसकी एक प्रति बनानी होगी।

दूसरे शब्दों में, एल्गोरिथ्म इस तरह दिखना चाहिए:

fileToWatch = getFileToWatch() howOftenToCheck = getHowOftenToCheck() while (!stopped) { if (hasChanged(fileToWatch)) { copyAside(fileToWatch) } sleep(howOftenToCheck) } 

ठीक है, इसलिए हम जो हासिल करना चाहते हैं उसे सुलझा लिया जाए। कोड लिखने का समय।

बुधवार

पहली चीज जो हमें चाहिए वह एक आईडीई है। विम प्रेमी कृपया चिंता न करें।

हम परिचित इंटेलीज आईडीईए लॉन्च करते हैं और पाते हैं कि कोटलिन नेटिव में यह शब्द से बिल्कुल भी नहीं हो सकता है। आपको CLion का उपयोग करने की आवश्यकता है।

2004 में C का सामना करने वाले व्यक्ति की गलतफहमी अभी खत्म नहीं हुई है। एक उपकरण की जरूरत है। यदि आप OSX का उपयोग करते हैं, तो सबसे अधिक संभावना है कि CLION खुद को उपयुक्त टूलकिन मिलेगा। लेकिन अगर आप विंडोज का उपयोग करने का निर्णय लेते हैं और सी में प्रोग्राम नहीं करते हैं, तो आपको कुछ साइगविन को स्थापित करने के लिए ट्यूटोरियल के साथ टिंकर करना होगा।

आईडीई स्थापित, टूलचिन को हल किया। क्या मैं पहले से ही कोड लिखना शुरू कर सकता हूं? लगभग।
चूँकि Kotlin Native अभी भी कुछ प्रयोगात्मक है, इसलिए CLion में इसके लिए प्लगइन डिफ़ॉल्ट रूप से स्थापित नहीं है। तो इससे पहले कि हम पोषित शिलालेख देखें "न्यू कोटलिन / नेटिव एप्लिकेशन" को इसे मैन्युअल रूप से स्थापित करना होगा।

कुछ सेटिंग्स

और इसलिए, अंत में हमारे पास एक खाली कोटलिन मूल परियोजना है। दिलचस्प है, यह ग्रैडल पर आधारित है (और मेकफाइल्स पर नहीं), और यहां तक ​​कि कोटलिन स्क्रिप्ट संस्करण पर भी।

build.gradle.kts . build.gradle.kts पर build.gradle.kts नज़र build.gradle.kts :

 plugins { id("org.jetbrains.kotlin.konan") version("0.8.2") } konanArtifacts { program("file_watcher") } 

हमारे द्वारा उपयोग किया जाने वाला एकमात्र प्लगइन कोनान कहा जाता है। वह हमारी बाइनरी फ़ाइल का उत्पादन करेगा।

konanArtifacts हम निष्पादन योग्य फ़ाइल का नाम निर्दिष्ट करते हैं। इस उदाहरण में, हमें file_watcher.kexe मिलता है

कोड

पहले से ही कोड दिखाने का समय आ गया है। यहाँ यह है, वैसे:

 fun main(args: Array<String>) { if (args.size != 2) { return println("Usage: file_watcher.kexe <path> <interval>") } val file = File(args[0]) val interval = args[1].toIntOrNull() ?: 0 require(file.exists()) { "No such file: $file" } require(interval > 0) { "Interval must be positive" } while (true) { // We should do something here } } 

आमतौर पर, कमांड लाइन उपयोगिताओं में वैकल्पिक तर्क और उनके डिफ़ॉल्ट मान भी होते हैं। लेकिन उदाहरण के लिए, हम मानेंगे कि हमेशा दो तर्क होते हैं: path और interval

जो लोग पहले से ही कोटलिन के साथ काम कर चुके हैं, उनके लिए यह अजीब लग सकता है कि java.io.File का उपयोग किए बिना, path अपने ही File वर्ग में लपेटता है। इसके लिए स्पष्टीकरण एक या दो मिनट में है।

यदि आप कोटलिन में आवश्यकता () फ़ंक्शन से परिचित नहीं हैं, तो यह तर्कों को मान्य करने का एक अधिक सुविधाजनक तरीका है। कोटलिन - यह सब सुविधा के बारे में है। कोई इस तरह लिख सकता है:

 if (interval <= 0) { println("Interval must be positive") return } 

सामान्य तौर पर, यहां सामान्य कोटलिन कोड है, कुछ भी दिलचस्प नहीं है। लेकिन अब से यह मजेदार होगा।

चलो नियमित कोटलिन कोड लिखने की कोशिश करते हैं, लेकिन हर बार जब हमें जावा से कुछ का उपयोग करने की आवश्यकता होती है, तो हम कहते हैं "उफ़!"। क्या आप तैयार हैं?

चलो अपने while वापस जाते हैं, और इसे हर interval कुछ प्रतीक छापते हैं, उदाहरण के लिए, एक अवधि।

 var modified = file.modified() while (true) { if (file.modified() > modified) { println("\nFile copied: ${file.copyAside()}") modified = file.modified() } print(".") // ... Thread.sleep(interval * 1000) } 

Thread जावा से एक वर्ग है। हम कोटलिन नेटिव में जावा कक्षाओं का उपयोग नहीं कर सकते हैं। केवल कोटलिन की कक्षाएं। कोई जावा।

वैसे, क्योंकि main हमने java.io.File उपयोग नहीं किया था

अच्छा, फिर क्या इस्तेमाल किया जा सकता है? C से कार्य!

 var modified = file.modified() while (true) { if (file.modified() > modified) { println("\nFile copied: ${file.copyAside()}") modified = file.modified() } print(".") sleep(interval) } 

दुनिया सी में आपका स्वागत है

अब जब हमें पता है कि हमें किस चीज़ का इंतजार है, तो आइए देखें कि हमारी File से क्या exists() फ़ंक्शन:

 data class File(private val filename: String) { fun exists(): Boolean { return access(filename, F_OK) != -1 } // More functions... } 

File एक साधारण data class , जो हमें बॉक्स से toString() का कार्यान्वयन देती है, जिसे हम बाद में उपयोग करेंगे।

"हुड के तहत," हम access() फ़ंक्शन सी को कॉल करते हैं, जो -1 लौटता है अगर ऐसी कोई फ़ाइल मौजूद नहीं है।

इस सूची में और भी modified() :

 fun modified(): Long = memScoped { val result = alloc<stat>() stat(filename, result.ptr) result.st_mtimespec.tv_sec } 

प्रकार के अनुमान का उपयोग करके फ़ंक्शन को थोड़ा सरल किया जा सकता है, लेकिन यहां मैंने ऐसा नहीं करने का फैसला किया, ताकि यह स्पष्ट हो कि फ़ंक्शन वापस नहीं आता है, उदाहरण के लिए, Boolean ।

इस फ़ंक्शन में दो दिलचस्प विवरण हैं। सबसे पहले, हम alloc() उपयोग करते हैं alloc() । चूंकि हम सी का उपयोग करते हैं, कभी-कभी हमें संरचनाओं को आवंटित करने की आवश्यकता होती है, और यह मॉलोक () का उपयोग करके मैन्युअल रूप से सी में किया जाता है।

इन संरचनाओं को भी मैन्युअल रूप से जारी किया जाना चाहिए। memScoped() का memScoped() फ़ंक्शन memScoped() लिए आता है, जो हमारे लिए यह करेगा।

यह हमारे लिए सबसे अधिक वजनदार फ़ंक्शन पर विचार करने के लिए बना हुआ है: opyAside()

 fun copyAside(): String { val state = copyfile_state_alloc() val copied = generateFilename() if (copyfile(filename, copied, state, COPYFILE_DATA) < 0) { println("Unable to copy file $filename -> $copied") } copyfile_state_free(state) return copied } 

यहां हम C फंक्शन copyfile_state_alloc() उपयोग करते हैं, जो copyfile() लिए आवश्यक संरचना का चयन करता है।

लेकिन हमें इस संरचना को स्वयं जारी करना होगा - उपयोग करना
copyfile_state_free(state)

दिखाने के लिए बची हुई आखिरी चीज है नामों की पीढ़ी। वहाँ एक छोटा सा कोटलिन है:

 private var count = 0 private val extension = filename.substringAfterLast(".") private fun generateFilename() = filename.replace(extension, "${++count}.$extension") 

यह एक बहुत अच्छा अनुभव कोड है जो कई मामलों की अनदेखी करता है, लेकिन यह एक उदाहरण के लिए करेगा।

प्रारंभ

अब यह सब कैसे चलाया जाए?

एक विकल्प पाठ्यक्रम का उपयोग करने के लिए है। वह हमारे लिए सबकुछ करेगा।

लेकिन प्रक्रिया को बेहतर ढंग से समझने के लिए कमांड लाइन का उपयोग करें। हां, और कुछ सीआई CLION से हमारा कोड नहीं चलाएंगे।

 ./gradlew build && ./build/konan/bin/macos_x64/file_watcher.kexe ./README.md 1 

सबसे पहले, हम ग्रैडल का उपयोग करके अपनी परियोजना को संकलित करते हैं। यदि सब कुछ ठीक हुआ, तो निम्न संदेश दिखाई देगा:

 BUILD SUCCESSFUL in 16s 

सोलह सेकंड! हां, JVM के लिए कुछ गो या यहां तक ​​कि कोटलिन की तुलना में, परिणाम निराशाजनक है। और यह अभी भी एक छोटी परियोजना है।

अब आपको स्क्रीन के पार डॉट्स देखना चाहिए। और यदि आप फ़ाइल की सामग्री बदलते हैं, तो एक संदेश दिखाई देगा। कुछ इस तस्वीर की तरह:

 ................................ File copied: ./README.1.md ................... File copied: ./README.2.md 

लॉन्च समय को मापना मुश्किल है। लेकिन हम जांच कर सकते हैं कि हमारी प्रक्रिया कितनी मेमोरी लेती है, उदाहरण के लिए, गतिविधि मॉनिटर: 852KB। बुरा नहीं है!

कुछ निष्कर्ष

और इसलिए, हमें पता चला कि कोटलिन नेटिव की मदद से हम एक ही निष्पादन योग्य फ़ाइल को उसी गो से कम मेमोरी फ़ुटप्रिंट के साथ प्राप्त कर सकते हैं। जीतना? वास्तव में नहीं।

यह सब कैसे परीक्षण करें? गो या कोटलिन के साथ काम करने वाले जानते हैं कि दोनों भाषाओं में इस महत्वपूर्ण कार्य के लिए अच्छे समाधान हैं। कोटलिन नेटिव का अब तक इससे बुरा नाता है।

ऐसा लगता है कि 2017 में JetBrains ने इसे हल करने की कोशिश की । लेकिन यह देखते हुए कि आधिकारिक कोटलिन मूल उदाहरणों के परीक्षण भी नहीं हैं, जाहिरा तौर पर अभी भी सफलतापूर्वक नहीं हुए हैं।

एक और समस्या है क्रॉसप्लेट रिकॉर्डर विकास। जिन लोगों ने C से बड़े मेरे साथ काम किया, उन्होंने शायद पहले ही देखा कि मेरा उदाहरण OSX पर काम करेगा, लेकिन विंडोज पर नहीं, क्योंकि मैं केवल platform.darwin साथ उपलब्ध कई कार्यों पर भरोसा करता हूं। मुझे उम्मीद है कि भविष्य में कोटलिन नेटिव में अधिक आवरण होंगे जो इसे मंच से अमूर्त करने की अनुमति देगा, उदाहरण के लिए, जब फ़ाइल सिस्टम के साथ काम कर रहा है।

आप सभी कोड उदाहरण यहां पा सकते हैं।

और मेरे मूल लेख का एक लिंक , अगर आप अंग्रेजी में पढ़ना पसंद करते हैं