ग्रोवी जावा प्लेटफॉर्म के लिए पायथन, रूबी और स्मॉलटाक की क्षमताओं के साथ जावा भाषा के विकल्प के रूप में विकसित एक वस्तु-उन्मुख प्रोग्रामिंग भाषा है।
ग्रूवी जावा-जैसे सिंटैक्स का उपयोग जेवीएम के बायोटेक के गतिशील संकलन के साथ करता है और सीधे अन्य जावा कोड और पुस्तकालयों के साथ काम करता है। भाषा का उपयोग किसी भी जावा प्रोजेक्ट में या स्क्रिप्टिंग भाषा के रूप में किया जा सकता है।
ग्रूवी फीचर्स (इसे जावा से अलग करना):
- स्थैतिक और गतिशील टाइपिंग
- सूचियों, साहचर्य सरणियों, सरणियों और नियमित अभिव्यक्तियों के लिए अंतर्निहित वाक्यविन्यास
- शॉर्ट सर्किट
- अधिभार संचालन
[
http://ru.wikipedia.org/wiki/Groovy ]
इसके अलावा, लगभग हमेशा जावा कोड मान्य groovy कोड है।
स्थापना
स्थापित करने के लिए, आपको से संग्रह डाउनलोड करने की आवश्यकता है
। साइट , इसे एक सुविधाजनक जगह पर अनज़िप करें और पर्यावरण चर GROOVY_HOME जोड़ें, और पथ में नाली / बिन में पथ जोड़ें:
export GROOVY_HOME=~/path/to/groovy/ export PATH=$GROOVY_HOME/bin:$PATH
NetBeans IDE 7.0 में, ग्रूवी समर्थन बॉक्स से बाहर आता है, ग्रहण आईडीई के लिए एक बहुत अच्छा प्लगइन है जो आप
यहां प्राप्त कर सकते
हैं ।
ग्रूवी
जावा से सबसे महत्वपूर्ण अंतर: ग्रूवी में, सब कुछ एक वस्तु है। सभी आदिम प्रकार तुरंत वस्तुओं में पैक किए जाते हैं। यानी "इंट एक्स" वास्तव में "इंटेगर एक्स" है
println 1.class int a = 10 println a.class
class java.lang.Integer class java.lang.Integer
आपको यह नहीं भूलना चाहिए कि सभी पैकेजिंग प्रकार अपरिवर्तनीय हैं, इसलिए, हर बार किसी भी गणना के साथ एक नई वस्तु बनाई जाएगी।
ग्रूवी में लाइनें
1) जावा स्ट्रिंग्स - एकल उद्धृत स्ट्रिंग्स
2) ग्रूवी स्ट्रिंग्स, उर्फ GStrings - साधारण उद्धरण चिह्नों में
आप ग्रोवी स्ट्रिंग्स में पैरामीटर डाल सकते हैं, आप साधारण स्ट्रिंग्स में पैरामीटर नहीं डाल सकते
javaString = 'java' groovyString = "${javaString}" j = '${javaString}' bigGroovyString = """ ${javaString} ${groovyString} ${j} ${2 + 2} """ println bigGroovyString
java java ${javaString} 4
+ और * संचालन स्ट्रिंग्स पर लागू होते हैं
groovy:000> a = "a" ===> a groovy:000> a + "123" ===> a123 groovy:000> a * 5 ===> aaaaa
इसके अलावा, ++ और - - स्ट्रिंग्स पर लागू होते हैं (चूंकि ग्रूवी ऑपरेटर ओवरलोडिंग का समर्थन करता है)
groovy:000> a = 'abc' ===> abc groovy:000> a++ ===> abd groovy:000> a-- ===> ab
ग्रूवी में भाषा निर्माण के स्तर पर नियमित अभिव्यक्ति का एक सेट है:
groovy:000> r =~
नक्शे + सूचियों के लिए मूल समर्थन
भाषा निर्माण के स्तर पर शब्दकोशों (नक्शे) और सूचियों का भी समर्थन किया जाता है:
groovy:000> a = [1, 3, 5] ===> [1, 3, 5] groovy:000> b = [1: true, 0: false] ===> {1=true, 0=false}
सीमाओं
आप निम्नानुसार सूची आइटम ग्रूवी में एक्सेस कर सकते हैं:
groovy:000> a = "0123456789" ===> 0123456789 groovy:000> a[1..4] ===> 1234 groovy:000> a[1..-1] ===> 123456789 groovy:000> a[-1..0] ===> 9876543210 groovy:000> a[1..<9] ===> 12345678 groovy:000> a[1, 3, 5] ===> 135 groovy:000> b = 1..5 ===> 1..5 groovy:000> a[b] ===> 12345
रेंज एक ही वस्तु है, इसलिए उत्तरार्द्ध जैसे निर्माण संभव हैं। अजगर में नकारात्मक सूचकांक, सूची के अंत से तत्वों को वापस करते हैं।
रेंज लाइनों से बना जा सकता है:
groovy:000> 'a'..'aa' ===> a..aa
इसके अलावा, सीमा किसी भी ऑब्जेक्ट से बनाई जा सकती है जिसमें अगले () और मौजूदा () तरीके हैं।
चक्र
Groovy में छोरों जावा में बिल्कुल के रूप में कर रहे हैं, प्लस एक और "foreach" उन्हें जोड़ा गया है:
for (i in 0..9) { print i } for (int i = 0; i < 9; ++i) { print i } for (Integer i : 0..9) { print i }
कार्यों
def functionA(argA) { print ArgA } int functionB(int argB) { print argB return argB } String fuctionC() { "Hello World" }
वापसी कीवर्ड वैकल्पिक है; डिफ़ॉल्ट रूप से, फ़ंक्शन में अंतिम उल्लेख किए गए चर का मान वापस आ जाएगा।
बंद
समापन एक अनाम फ़ंक्शन है।
def cl = {a, b -> println a println b } cl(1, 2)
कई वस्तुओं में ऐसी विधियाँ हैं जिनके लिए पैरामीटर के रूप में क्लोज़र पास किया जाता है:
1.upto 10, { print it } 10.times { print it }
प्रसंस्करण अनुक्रमों के लिए बड़ी संख्या में विधियां उपलब्ध हैं जिनके लिए क्लोजर लागू किया जा सकता है:
'qwerty'.each { print it } ('a'..'z').each { print it } ('a'..'z').findAll { el -> // = filter el in ['e', 'y', 'u', 'i', 'o', 'a'] }.each { print it + ' ' } (0..10).collect { el -> // = map el * 10 }.each { print it + ' ' } def sum = (0..10).inject(0) { prev, elem -> // = reduce return prev + elem }
क्लोजर में रिटर्न कीवर्ड का उपयोग करना भी आवश्यक नहीं है। यदि पैरामीटर नाम स्पष्ट रूप से निर्दिष्ट नहीं है, तो इसका उपयोग डिफ़ॉल्ट रूप से किया जाता है।
चूंकि क्लोजर एक ऑब्जेक्ट है, कुछ भी इसे दूसरे क्लोजर से वापस करने से रोकता है, और इस प्रकार उच्च-ऑर्डर फ़ंक्शन बनाता है:
def cloA = {param -> def cloB = { return param * 10 } } def b = cloA(10) println b(10)
फ़ाइलें
प्रत्येकFile और प्रत्येकFileRecursive कार्य निर्देशिकाओं के लिए हैं:
new File('.').eachFile { println it }
./.project ./src ./.settings ./.classpath ./bin
पाठ फ़ाइलों को संसाधित करने के लिए - प्रत्येक फ़ंक्शन:
new File('textfile.txt').eachLine { println it }
फ़ाइलों को लिखना भी बहुत सुविधाजनक है:
def pw = new File('textfile.txt').newPrintWriter() pw.println("new line")
कक्षाएं
class Account { String name BigDecimal value } // // - // a = new Account() // a.setName("Account #1") // a.setValue(new BigDecimal(10)) a = new Account(name : "Account #1", value : new BigDecimal(10)) // def name = a.getName() a.setName("Account #2") println "${a.name}" class Person { def first def last // void setFirst(first) { println "${this.first} is becoming ${first}" this.first = first } } p = new Person(first : "A", last : "G") // , p.first = "C" println "${p.first} ${p.last}" // java class ExtendedAccount extends Account { def debt // ExtendedAccount(name, value, debt) { setName(name) setValue(value) setDebt(debt) } def String toString() { "${name} ${value} ${debt}" } } // "Could not find matching constructor for: ExtendedAccount()" //e = new ExtendedAccount() println new ExtendedAccount("A", new BigDecimal(10), 1)
अपरिवर्तनीय वर्गों को अपरिवर्तनीय एनोटेशन का उपयोग करके परिभाषित किया गया है:
@Immutable class ImmutableClass { String a Integer b } def ic = new ImmutableClass(a : "a", b : 1)
इस एनोटेशन का उपयोग करते समय, आपको स्पष्ट रूप से इंगित करना चाहिए कि फ़ील्ड किस प्रकार का डेटा है।
ऑपरेटरों
"?:" एल्विस ऑपरेटर
def b = a ?: "b"
चर ए की जाँच करता है, और यदि यह शून्य या गलत है, तो यह आगे बताए गए मूल्य को लेता है। अन्यथा, चर का मान लिया जाता है।
"?।" सुरक्षित नेविगेशन
NullPointerException त्रुटि से बचने के लिए उपयोग किया जाता है
def user = Users.get("a") def posts = user?.posts println posts
यदि उपयोगकर्ता NullPointerException को फेंकने के बजाय अशक्त है, तो अशक्त वापस आ जाएगा।
"*।" फैला हुआ संचालक
एक संग्रह के सभी तत्वों के लिए निर्दिष्ट विधि को लागू करता है। निम्नलिखित के बराबर:
parent*.action == parent.collect {ch -> child?.action}
उपयोग उदाहरण:
def sizes = ['string', 'long string']*.size() println sizes
[6, 11]
आप सूचियों और शब्दकोशों को संकलित करने के लिए भी मोनो का उपयोग कर सकते हैं:
def x = [2, 3] def y = [0, 1, *x, 4] println y def a = [3 : 'c', 4 : 'd'] def b = [1 : 'a', 2: 'b', * : a, 5 : 'e'] println b
[0, 1, 2, 3, 4] [1:a, 2:b, 3:c, 4:d, 5:e]
ग्रूवी में, आप ऑपरेटरों को अधिभारित कर सकते हैं +, -, *, आदि। ऐसा करने के लिए, आपको कक्षा के लिए उपयुक्त विधि को परिभाषित करने की आवश्यकता है। उदाहरण के लिए, ++ ऑपरेटर को ओवरलोड करने के लिए, आपको अगली () विधि को ओवरराइड करने की आवश्यकता है:
class RandomVal { // private def value private Random randomGen = new Random() def next() { this.value = randomGen.nextInt() } RandomVal() { this.value = randomGen.nextInt() } def String toString() { "${this.value}" } } def r = new RandomVal() println(r) r++ println(r)
ऑपरेटर "==" पहले से ही सभी वस्तुओं के लिए अतिभारित है - और "आइक्ल्स ()" विधि कहता है। ओवरलोड ऑपरेटरों को पुनर्निर्धारित करने के लिए आवश्यक तरीकों की एक पूरी सूची यहां उपलब्ध है:
http://groovy.codehaus.org/Operator+Overloading ।
एसक्यूएल
एसक्यूएल प्रश्नों को बहुत सरलता से संभाला जाता है:
import groovy.sql.Sql def final ADDRESS = "jdbc:jtds:sqlserver://serverName/dbName" def final USERNAME = "username" def final PASSWD = "password" def final DRIVER = "net.sourceforge.jtds.jdbc.Driver" sql = Sql.newInstance(ADDRESS, USERNAME, PASSWD, DRIVER) sql.eachRow("select * from tableName") { el -> println "${el.id} -- ${el.firstName}" } def firstName = "A" def lastName = "G" sql.execute("insert into tableName (firstName, lastName) " + "values (${firstName}, ${lastName})") sql.execute("insert into tableName (firstName, lastName) " + "values (?, ?)", [firstName, lastName])
एक्सएमएल
एक्सएमएल उत्पन्न करने के लिए इस्तेमाल किए जा सकने वाले ग्रूवी में बिल्डर हैं। पीढ़ी के लिए, मार्कअपबस्टल ऑब्जेक्ट का एक उदाहरण बनाया जाता है, जिस पर छद्म तरीकों को कहा जाता है - इस विधि का नाम और पारित पैरामीटर का उपयोग टैग बनाने के लिए किया जाएगा:
import groovy.xml.MarkupBuilder def mb = new MarkupBuilder() mb.html() { head() { title("This is the title") } body() { div("class" : "main") { p("this is the body") } } }
निष्कर्ष:
<html> <head> <title>This is the title</title> </head> <body> <div class='main'> <p>this is the body</p> </div> </body> </html>
आप किसी भी PrintWriter को MarkupBuilder कंस्ट्रक्टर के पैरामीटर के रूप में पास कर सकते हैं:
def fb = new MarkupBuilder(new File("index.html").newPrintWriter())
XML पार्सिंग भी बहुत सरल है:
import groovy.xml.MarkupBuilder import java.io.StringWriter def sw = new StringWriter() def mb = new MarkupBuilder(sw) mb.html() { body() { div("class" : "main") { p("this is the body") } div() { p("this is the body 1") p("this is the body 2") p("this is the body 3") } } } def xml = sw.toString() println xml import groovy.util.XmlParser; def parser = new XmlParser() def doc = parser.parseText(xml) //def doc = parser.parse("index.html") println doc.body.div[1].p[1] // Node println doc.body.div[1].p // , Node println doc.body.div["@class"] // class div
निष्कर्ष:
<html> <body> <div class='main'> <p>this is the body</p> </div> <div> <p>this is the body 1</p> <p>this is the body 2</p> <p>this is the body 3</p> </div> </body> </html> p[attributes={}; value=[this is the body 2]] [p[attributes={}; value=[this is the body 1]], p[attributes={}; value=[this is the body 2]], p[attributes={}; value=[this is the body 3]]] [main, null]
Groovlets
GroovyServlet वर्ग का उपयोग करके, Groovy पर स्क्रिप्ट को सर्वलेट्स के रूप में चलाना संभव है।
सबसे पहले, इसके लिए आपको web.xml में कुछ लाइनें जोड़ने की आवश्यकता है:
<servlet> <servlet-name>GroovyServlet</servlet-name> <servlet-class>groovy.servlet.GroovyServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>GroovyServlet</servlet-name> <url-pattern>*.groovy</url-pattern> </servlet-mapping>
अब .groovy फ़ाइलों के लिए सभी अनुरोध GroovyServlet वर्ग द्वारा संसाधित किए जाएंगे।
इन लिपियों में उपयोग के लिए निम्नलिखित चर पहले से ही उपलब्ध हैं:
- अनुरोध और प्रतिक्रिया
- संदर्भ, आवेदन, सत्र
- बाहर (= response.getWriter ())
- sout (= response.getOutputStream ())
- html (= नया मार्कअपबर्स्ट (आउट))
html.html() { body() { div( : ) { p() } div() { p() p() p() } } }
यह ब्राउज़र को जेनरेट किया गया html पेज देगा।
उपयोग किए गए स्रोतों की सूची:
केनेथ बार्कले, जॉन सैवेज "ग्रूवी प्रोग्रामिंग: जावा डेवलपर्स के लिए एक परिचय"
http://groovy.codehaus.org/