ग्रूवी की छिपी विशेषताएं?

Question 1

ऐसा लगता है कि ग्रूवी को इस धागे में भुला दिया गया था, इसलिए मैं ग्रूवी से यही सवाल पूछूंगा।

ग्रूवी कोर के जवाबों को सीमित करने की कोशिश करें
प्रति उत्तर एक विशेषता
एक उदाहरण और सुविधा का संक्षिप्त विवरण दें, न कि केवल प्रलेखन का एक लिंक
पहली पंक्ति के रूप में बोल्ड शीर्षक का उपयोग करके सुविधा को लेबल करें

यह सभी देखें:

Question 2

स्प्रेड-डॉट ऑपरेटर का उपयोग करना

def animals = ['ant', 'buffalo', 'canary', 'dog']
assert animals.size() == 4
assert animals*.size() == [3, 7, 6, 3]

यह एक शॉर्टकट है animals.collect { it.size() }।

Question 3

साथ विधि इस चालू करने के लिए अनुमति देता है:

 myObj1.setValue(10)
 otherObj.setTitle(myObj1.getName())
 myObj1.setMode(Obj1.MODE_NORMAL)

इस मामले में

 myObj1.with {
    value = 10
    otherObj.title = name
    mode = MODE_NORMAL
 }

Question 4

छद्म वस्तुओं के रूप में हैश का उपयोग करना।

def x = [foo:1, bar:{-> println "Hello, world!"}]
x.foo
x.bar()

बतख टाइपिंग के साथ संयुक्त, आप इस दृष्टिकोण के साथ एक लंबा रास्ता तय कर सकते हैं। यहां तक कि "के रूप में" ऑपरेटर को कोड़ा करने की आवश्यकता नहीं है।

Question 5

किसी को एल्विस के बारे में पता है ?

def d = "hello";
def obj = null;

def obj2 = obj ?: d;   // sets obj2 to default
obj = "world"

def obj3 = obj ?: d;  // sets obj3 to obj (since it's non-null)

Question 6

यह पता लगाना कि किसी वस्तु पर क्या तरीके हैं, मेटाक्लास से पूछना जितना आसान है:

"foo".metaClass.methods.name.sort().unique()

प्रिंट:

["charAt", "codePointAt", "codePointBefore", "codePointCount", "compareTo",
 "compareToIgnoreCase", "concat", "contains", "contentEquals", "copyValueOf", 
 "endsWith", "equals", "equalsIgnoreCase", "format", "getBytes", "getChars", 
 "getClass", "hashCode", "indexOf", "intern", "lastIndexOf", "length", "matches", 
 "notify", "notifyAll", "offsetByCodePoints", "regionMatches", "replace", 
 "replaceAll", "replaceFirst", "split", "startsWith", "subSequence", "substring", 
 "toCharArray", "toLowerCase", "toString", "toUpperCase", "trim", "valueOf", "wait"]

Question 7

इंटरसेप्टेड मिसिंग स्टैटिक मेथड्स निम्नलिखित का उपयोग करते हैं

 Foo {
    static A() { println "I'm A"}

     static $static_methodMissing(String name, args) {
        println "Missing static $name"
     }
 }

Foo.A()  //prints "I'm A"
Foo.B()  //prints "Missing static B"

- केन

Question 8

विनाशकारी

इसे ग्रूवी में कुछ और कहा जा सकता है; इसे क्लोजर में विनाशकारी कहा जाता है। आप कभी भी विश्वास नहीं करेंगे कि यह कितना आसान है।

def list = [1, 'bla', false]
def (num, str, bool) = list
assert num == 1
assert str == 'bla'
assert !bool

Question 9

Groovy के साथ जावा कोड के परीक्षण के लिए, वस्तु ग्राफ बिल्डर अद्भुत है:

def company = builder.company( name: 'ACME' ) {
   address( id: 'a1', line1: '123 Groovy Rd', zip: 12345, state: 'JV' )
   employee(  name: 'Duke', employeeId: 1 ){
      address( refId: 'a1' )
   }
}

मानक सुविधा, लेकिन अभी भी वास्तव में अच्छा है।

ObjectGraphBuilder

(आपको अपने POJO के किसी भी गुण को देने की आवश्यकता है जो काम करने के लिए बिल्डर समर्थन के Listबजाय एक खाली सूची का डिफ़ॉल्ट मान है null।)

Question 10

println 
"""
Groovy has "multi-line" strings.
Hooray!
"""

Question 11

ग्रूवी 1.6 में, नियमित अभिव्यक्तियाँ सभी क्लोजर पुनरावृत्तियों के साथ काम करती हैं (जैसे प्रत्येक, इकट्ठा, इंजेक्शन, आदि) और आपको आसानी से कैप्चर समूहों के साथ काम करने की अनुमति मिलती है:

def filePaths = """
/tmp/file.txt
/usr/bin/dummy.txt
"""

assert (filePaths =~ /(.*)\/(.*)/).collect { full, path, file -> 
        "$file -> $path"
    } ==  ["file.txt -> /tmp", "dummy.txt -> /usr/bin"]

Question 12

जावा के विपरीत, ग्रूवी में, कुछ भी स्विच स्टेटमेंट में इस्तेमाल किया जा सकता है , न कि केवल आदिम प्रकारों में। एक सामान्य ईवेंटप्ररूप में विधि

switch(event.source) {
   case object1:
        // do something
        break
   case object2:
        // do something
        break
}

Question 13

स्पेसशिप ऑपरेटर का उपयोग करना

मैं स्पेसशिप ऑपरेटर को पसंद करता हूं, जो सभी प्रकार के कस्टम सॉर्टिंग परिदृश्यों के लिए उपयोगी है। उपयोग के कुछ उदाहरण यहां दिए गए हैं । एक स्थिति जिसमें यह विशेष रूप से सहायक होती है, वह है कई क्षेत्रों का उपयोग करके किसी वस्तु के उड़ने पर एक तुलनित्र बनाना। जैसे

def list = [
    [ id:0, first: 'Michael', last: 'Smith', age: 23 ],
    [ id:1, first: 'John', last: 'Smith', age: 30 ],
    [ id:2, first: 'Michael', last: 'Smith', age: 15 ],    
    [ id:3, first: 'Michael', last: 'Jones', age: 15 ],   
]

// sort list by last name, then first name, then by descending age
assert (list.sort { a,b -> a.last <=> b.last ?: a.first <=> b.first ?: b.age <=> a.age })*.id == [ 3,1,0,2 ]

Question 14

क्लोज़र सभी पुराने प्रयास-अंत में संसाधन प्रबंधन के खेल को दूर कर सकते हैं। ब्लॉक के अंत में फ़ाइल स्ट्रीम स्वचालित रूप से बंद हो जाती है:

new File("/etc/profile").withReader { r ->
    System.out << r
}

Question 15

GDK के groovy.transformपैकेज के अंदर परिवर्तनों द्वारा प्रदान की जाने वाली सुविधाएँ , जैसे:

@Immutable: @Immutable एनोटेशन संकलक को एएसटी परिवर्तन को निष्पादित करने का निर्देश देता है जो आवश्यक गेटर्स, कंस्ट्रक्टर्स, बराबर, हैशकोड और अन्य सहायक विधियों को जोड़ता है जो आमतौर पर परिभाषित गुणों के साथ अपरिवर्तनीय कक्षाएं बनाते समय लिखे जाते हैं।
@CompileStatic: यह Groovy संकलक को जावा की शैली में संकलित समय जांच का उपयोग करने देगा और फिर स्थैतिक संकलन करेगा, इस प्रकार Groovy meta object प्रोटोकॉल को दरकिनार कर देगा।
@Canonical: @Canonical एनोटेशन कंपाइलर को एएसटी ट्रांसफॉर्म को निष्पादित करने का निर्देश देता है, जो आपकी कक्षा में स्थितीय कंस्ट्रक्टर, समान, हैशकोड और एक सुंदर प्रिंट स्ट्रींग जोड़ता है।

अन्य:

@Slf4jयह स्थानीय परिवर्तन लॉगबैक लॉगिंग का उपयोग करके आपके प्रोग्राम में लॉगिंग क्षमता जोड़ता है। लॉग नाम के एक अनबाउंड वैरिएबल पर हर विधि कॉल लॉग करने वाले को कॉल करने के लिए मैप की जाएगी।
ग्रूवी का एक्सएमएल स्लपर : एक्सएमएल का आसान पार्सिंग। किलर फीचर!

Question 16

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

def list = ['key', 'value', 'foo', 'bar'] as Object[]
def map = list.toSpreadMap()

assert 2 == map.size()
assert 'value' == map.key
assert 'bar' == map['foo']

Question 17

क्लोजर-आधारित इंटरफ़ेस कार्यान्वयन

यदि आपके पास एक टाइप किया हुआ संदर्भ है जैसे:

MyInterface foo

आप का उपयोग करके पूरे इंटरफ़ेस को लागू कर सकते हैं:

foo = {Object[] args -> println "This closure will be called by ALL methods"} as MyInterface

वैकल्पिक रूप से, यदि आप प्रत्येक विधि को अलग से लागू करना चाहते हैं, तो आप उपयोग कर सकते हैं:

foo = [bar: {-> println "bar invoked"}, 
    baz: {param1 -> println "baz invoked with param $param1"}] as MyInterface

Question 18

nullसूची से मान निकालें

def list = [obj1, obj2, null, obj4, null, obj6]
list -= null
assert list == [obj1, obj2, obj4, obj6]

Question 19

मुझे पता है कि मुझे थोड़ी देर हो चुकी है, लेकिन मुझे लगता है कि यहाँ कुछ अच्छी सुविधाएँ गायब हैं:

संग्रह प्लस / माइनस ऑपरेटर

def l = [1, 2, 3] + [4, 5, 6] - [2, 5] - 3 + (7..9)
assert l == [1, 4, 6, 7, 8, 9]

def m = [a: 1, b: 2] + [c: 3] - [a: 1]
assert m == [b: 2, c: 3]

स्विच स्टेटमेंट

switch (42) {
  case 0: .. break
  case 1..9: .. break
  case Float: .. break
  case { it % 4 == 0 }: .. break
  case ~/\d+/: .. break
}

रंग और अनुक्रमण

assert (1..10).step(2) == [1, 3, 5, 7, 9]
assert (1..10)[1, 4..8] == [2, 5, 6, 7, 8, 9]
assert ('a'..'g')[-4..-2] == ['d', 'e', 'f']

यूनिकोड चर नाम

def α = 123
def β = 456
def Ω = α * β
assert Ω == 56088

Question 20

@प्रतिनिधि

class Foo {
    def footest() { return "footest"}   
}

class Bar {
    @Delegate Foo foo = new Foo()     
}

def bar = new Bar()

assert "footest" == bar.footest()

Question 21

शाब्दिक में अंडरस्कोर

लंबी शाब्दिक संख्याएँ लिखते समय, आँख पर यह पता लगाना कठिन होता है कि कुछ संख्याओं को एक साथ कैसे रखा जाता है, उदाहरण के लिए, हज़ारों शब्दों के समूह, इत्यादि के साथ, आपको संख्याओं में अंडरस्कोर रखने की अनुमति देकर, उन समूहों को स्थान देना आसान है:

long creditCardNumber = 1234_5678_9012_3456L
long socialSecurityNumbers = 999_99_9999L
double monetaryAmount = 12_345_132.12
long hexBytes = 0xFF_EC_DE_5E
long hexWords = 0xFFEC_DE5E
long maxLong = 0x7fff_ffff_ffff_ffffL
long alsoMaxLong = 9_223_372_036_854_775_807L
long bytes = 0b11010010_01101001_10010100_10010010

Question 22

निहित तर्क के साथ तर्क पुनर्मूल्यांकन एक और अच्छा है।

यह कोड:

def foo(Map m=[:], String msg, int val, Closure c={}) {
  [...]
}

इन सभी विभिन्न तरीकों को बनाता है:

foo("msg", 2, x:1, y:2)
foo(x:1, y:2, "blah", 2)
foo("blah", x:1, 2, y:2) { [...] }
foo("blah", 2) { [...] }

और अधिक। नाम और क्रमिक तर्कों को गलत क्रम / स्थिति में रखकर पेंच कसना असंभव है।

बेशक, "फू" की परिभाषा में, आप "स्ट्रिंग" और "इंट" को "स्ट्रिंग संदेश" और "इंट वैल" से छोड़ सकते हैं - मैंने उन्हें केवल स्पष्टता के लिए छोड़ दिया।

Question 23

मुझे लगता है कि यह पैरामीटर और पैरामीटर-डिफ़ॉल्ट-मान के रूप में क्लोजर का एक संयोजन है:

public void buyItems(Collection list, Closure except={it > 0}){
  list.findAll(){except(it)}.each(){print it}
}
buyItems([1,2,3]){it > 2}
buyItems([0,1,2])

प्रिंट: "312"

Question 24

विधि मापदंडों में प्रसार ऑपरेटर का उपयोग करना

कोड को डेटा में परिवर्तित करते समय यह एक बड़ी मदद है:

def exec(operand1,operand2,Closure op) {
    op.call(operand1,operand2)
}

def addition = {a,b->a+b}
def multiplication = {a,b->a*b}

def instructions = [
     [1,2,addition],
     [2,2,multiplication]
]

instructions.each{instr->
    println exec(*instr)
}

यह भी उपयोगी है यह उपयोग:

String locale="en_GB"

//this invokes new Locale('en','GB')
def enGB=new Locale(*locale.split('_'))

Question 25

संस्मरण

मेमोइज़ेशन एक अनुकूलन तकनीक है जिसमें महंगी फ़ंक्शन कॉल के परिणामों को संग्रहीत करना और कैश किए गए परिणाम को वापस करना जब भी फ़ंक्शन को फिर से उसी तर्कों के साथ कहा जाता है।

एक असीमित संस्करण है, जो कभी जोड़ेगा (इनपुट दलीलें, वापसी मूल्य) यह कभी देखेगा; और एक सीमित संस्करण, जो अंतिम N इनपुट तर्कों को देखा जाएगा और उनके परिणाम, LRU कैश का उपयोग करेंगे।

तरीकों का संस्मरण:

import groovy.transform.Memoized

@Memoized
Number factorial(Number n) {
    n == 0 ? 1 : factorial(n - 1)
}

@Memoized(maxCacheSize=1000)
Map fooDetails(Foo foo) {
    // call expensive service here
}

बंदों का संस्मरण:

def factorial = {Number n ->
    n == 0 ? 1 : factorial(n - 1)
}.memoize()

fooDetails = {Foo foo ->
    // call expensive service here
}.memoizeAtMost(1000)

कंप्यूटर विज्ञान में मेमोइज़ेशन के उपयोग के बारे में विकिपीडिया पृष्ठ पर व्यापक जानकारी है। मैं सिर्फ एक सरल व्यावहारिक उपयोग को इंगित करूंगा।

किसी स्थिरांक का अंतिम संभावित क्षण में पता लगाना

कभी-कभी आपके पास एक निरंतर मूल्य होता है जिसे कक्षा की परिभाषा या निर्माण समय पर आरंभ नहीं किया जा सकता है। उदाहरण के लिए, निरंतर अभिव्यक्ति दूसरे वर्ग या किसी अन्य वर्ग से एक विधि का उपयोग कर सकती है, जिसे आपकी कक्षा के आरंभ के बाद कुछ और (स्प्रिंग या ऐसे) द्वारा प्लग किया जाएगा।

इस मामले में, आप अपने स्थिरांक को एक गटर में बदल सकते हैं और इसे सजा सकते हैं @Memoized। इसकी गणना केवल एक बार की जाएगी, पहली बार जब यह एक्सेस किया जाता है, और फिर कैश और पुन: उपयोग किया जाता है:

import groovy.transform.Memoized

@Memoized
def getMY_CONSTANT() {
    // compute the constant value using any external services needed
}

Question 26

Groovy जावास्क्रिप्ट की तरह बहुत काम कर सकते हैं। क्लोजर के माध्यम से आपके पास निजी संस्करण और फ़ंक्शन हो सकते हैं। आप करीनों के साथ करी कार्यों को भी कर सकते हैं।

class FunctionTests {

def privateAccessWithClosure = {

    def privVar = 'foo'

    def privateFunc = { x -> println "${privVar} ${x}"}

    return {x -> privateFunc(x) } 
}


def addTogether = { x, y ->
    return x + y
}

def curryAdd = { x ->
    return { y-> addTogether(x,y)}
}

public static void main(String[] args) {
    def test = new FunctionTests()

    test.privateAccessWithClosure()('bar')

    def curried = test.curryAdd(5)

    println curried(5)
}
}

उत्पादन:

फू बार १०

Question 27

गतिशील विधि मंगलाचरण

आप इसके नाम के साथ एक स्ट्रिंग का उपयोग करके एक विधि लागू कर सकते हैं

class Dynamic {
    def one() { println "method one()" }
    def two() { println "method two()" }
}

def callMethod( obj, methodName ) {
    obj."$methodName"()
}

def dyn = new Dynamic()

callMethod( dyn, "one" )               //prints 'method one()'
callMethod( dyn, "two" )               //prints 'method two()'
dyn."one"()                            //prints 'method one()'

Question 28

ग्रूवी में एक दो लाइनों में JSON पेड़ का निर्माण कैसे करें?

1) अपने पेड़ को सेल्फ रेफरेंशियल withDefaultक्लोजर से परिभाषित करें

def tree // declare  first before using a self reference
tree = { ->  [:].withDefault{ tree() } }

2) अपना खुद का JSON ट्री बनाएं

frameworks = tree()
frameworks.grails.language.name = 'groovy'
frameworks.node.language.name = 'js'

def result =  new groovy.json.JsonBuilder(frameworks)

जो देता है: {"grails":{"language":{"name":"groovy"}},"node":{"language":{"name":"js"}}}

Question 29

सुरक्षित नेविगेशन ऑपरेटर

सुरक्षित नेविगेशन ऑपरेटर का उपयोग NullPointerException से बचने के लिए किया जाता है। आमतौर पर जब आपके पास किसी ऑब्जेक्ट का संदर्भ होता है, तो आपको यह सत्यापित करने की आवश्यकता हो सकती है कि यह ऑब्जेक्ट के तरीकों या गुणों तक पहुंचने से पहले शून्य नहीं है। इससे बचने के लिए, सुरक्षित नेविगेशन ऑपरेटर केवल अपवाद को फेंकने के बजाय अशक्त हो जाएगा, जैसे:

def person = Person.find { it.id == 123 }        // find will return a null instance    
def name = person?.name                          // use of the null-safe operator prevents from a NullPointerException, result is null

Question 30

एकाधिक चर मंदी

1) एकल लाइन में कई चर घोषणाएं

def (a,b,c) = [1,2,3]

2) विभिन्न प्रकार की घोषणाओं का उपयोग करना।

def (String a, int b) = ['Groovy', 1]

Question 31

जबरदस्ती करने वाला

जबरदस्ती ऑपरेटर (के रूप में) कास्टिंग का एक प्रकार है। ज़बरदस्ती वस्तु को एक प्रकार से दूसरे प्रकार में परिवर्तित किया जाता है जब तक कि उन्हें असाइनमेंट के लिए संगत नहीं किया जाता है। आइए एक उदाहरण लेते हैं:

Integer x = 123
स्ट्रिंग s = (स्ट्रिंग) x
पूर्णांक स्ट्रिंग के लिए असाइन करने योग्य नहीं है, इसलिए यह रनटाइम पर एक ClassCastException का उत्पादन करेगा। इसके बजाय इसका उपयोग ज़बरदस्त तरीके से किया जा सकता है:

Integer x = 123 स्ट्रिंग s = x स्ट्रिंग के रूप में
Integer स्ट्रिंग के लिए असाइन करने योग्य नहीं है, लेकिन उपयोग के रूप में यह एक स्ट्रिंग के लिए बाध्य करेगा