Groovy og Gradle: JVM-automatisering og byggeutvikling · leksjon

Forstå Groovy closures

Lær konseptet closures, hvordan De definerer dem og deres mange bruksområder i Groovy.

Leksjon 2 av 411 trinn

Forstå Groovy closures er en gratis leksjon i Groovy og Gradle: JVM-automatisering og byggeutvikling på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Groovy og Gradle: JVM-automatisering og byggeutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Groovy og Gradle: JVM-automatisering og byggeutvikling inneholder totalt 4 leksjoner.

Hva er Groovy-closures?

Velkommen til Groovy-closures-verdenen! En closure er i hovedsak en kodeblokk som kan behandles som en variabel.

Tenk på den som en liten funksjon De kan definere, lagre og sende rundt. Closures er en kraftig funksjon som gjør Groovy-kode svært fleksibel og kortfattet.

De er førsteklasses objekter, noe som betyr at de kan tilordnes variabler, sendes som argumenter og returneres fra metoder.
De kan fange opp variabler fra det omkringliggende området, selv etter at dette området er ferdig med å kjøre.

Grunnleggende closure-syntaks

Det er enkelt å definere en closure. Omslutt kodeblokken med krøllparenteser {}. La oss se på et enkelt eksempel:

class Main {
  static void main(String[] args) {
    // Define a simple closure
    def sayHello = {
      println "Hello from a closure!"
    }

    // Call (execute) the closure
    sayHello()
  }
}

Closures med parametere

Akkurat som metoder kan closures ta imot parametere. List parameterne før ->-operatoren (pilen), etterfulgt av closure-ens innhold.

Dette gjør at closure-en kan utføre operasjoner basert på inndataene den mottar.

class Main {
  static void main(String[] args) {
    // Closure that takes two parameters
    def add = { num1, num2 ->
      return num1 + num2
    }

    // Call the closure with arguments
    def result = add(10, 5)
    println "Sum: ${result}"

    // You can also omit 'return' for the last statement
    def multiply = { a, b -> a * b }
    println "Product: ${multiply(4, 3)}"
  }
}

Nøkkelordet «it»

Når en closure tar nøyaktig én parameter, tilbyr Groovy en spesiell implisitt variabel kalt it. De trenger ikke deklarere it eksplisitt.

Dette gjør closures med én parameter enda kortere og mer lesbare, særlig når de brukes med samlingsmetoder.

class Main {
  static void main(String[] args) {
    // Closure using 'it' for a single parameter
    def square = { it * it }

    println "Square of 7: ${square(7)}"

    def greetPerson = { "Hello, ${it}!" }
    println greetPerson("Alice")
  }
}

Closures som metodeargumenter

En av de vanligste og kraftigste bruksområdene for closures i Groovy er å sende dem som argumenter til metoder. Mange Groovy-metoder, særlig metoder på samlinger, er utformet for å ta imot closures.

Hvis en closure er det siste argumentet til en metode, kan De plassere den utenfor parentesene. Da blir koden svært ryddig og DSL-lignende.

class Main {
  static void main(String[] args) {
    def numbers = [1, 2, 3, 4, 5]

    // Using 'each' with a closure to iterate
    numbers.each { num ->
      println "Number: ${num}"
    }

    println "---"

    // Using 'collect' with a closure to transform
    def doubledNumbers = numbers.collect { it * 2 }
    println "Doubled: ${doubledNumbers}"
  }
}

Fange opp variabler: leksikalsk område

Closures har leksikalsk område, noe som betyr at de husker og kan få tilgang til variabler fra området der de ble definert, selv om dette området ikke lenger eksisterer.

Dette er en viktig egenskap som skiller closures fra vanlige metoder, og gjør at de kan ta med seg kontekst.

class Main {
  static void main(String[] args) {
    def name = "Groovy User" // Variable in the outer scope

    def introduce = {
      // The closure 'introduce' captures 'name'
      println "My name is ${name}."
    }

    introduce() // Calls the closure, accessing 'name'

    name = "CoddyKit Enthusiast" // Change the outer variable
    introduce() // The closure still references the updated 'name'
  }
}

Endre variabler som er fanget opp

Closures kan ikke bare få tilgang til variabler de har fanget opp, men også endre dem. Dette gir en kraftig måte for closures å samhandle med omgivelsene sine på.

Vær forsiktig når De endrer eksterne variabler fra en closure, siden dette noen ganger kan føre til mindre forutsigbar kode hvis det ikke håndteres nøye.

class Main {
  static void main(String[] args) {
    def counter = 0 // A variable to be captured

    def increment = {
      counter++ // Closure modifies the outer 'counter'
      println "Counter is now: ${counter}"
    }

    increment() // Counter: 1
    increment() // Counter: 2
    increment() // Counter: 3

    println "Final counter value: ${counter}"
  }
}

Closure-metoden `call()`

Selv om De kan kjøre en closure ved ganske enkelt å bruke parenteser (for eksempel myClosure()), er closures faktisk instanser av klassen groovy.lang.Closure.

Det betyr at de også har en call()-metode. Å bruke call() tilsvarer direkte kjøring og kan noen ganger være nyttig for tydelighet eller når closures kalles dynamisk.

class Main {
  static void main(String[] args) {
    def greet = { name ->
      println "Hello, ${name}!"
    }

    // Direct execution
    greet("World")

    // Execution using the call() method
    greet.call("Groovy")

    def add = { a, b -> a + b }
    println add.call(5, 7)
  }
}

Praktisk bruk: Filtrere lister

La oss bruke closures i et praktisk eksempel: filtrere elementer fra en liste. Groovys samlingsmetoder, som findAll, passer perfekt til dette.

De oppgir en closure som definerer betingelsen for inkludering, og findAll returnerer en ny liste som bare inneholder elementene som oppfyller denne betingelsen.

class Main {
  static void main(String[] args) {
    def numbers = [10, 25, 12, 30, 5, 45, 20]

    // Find numbers greater than 20
    def largeNumbers = numbers.findAll { it > 20 }
    println "Numbers > 20: ${largeNumbers}"

    // Find even numbers
    def evenNumbers = numbers.findAll { it % 2 == 0 }
    println "Even numbers: ${evenNumbers}"
  }
}

Sjekk av closure-konsepter

Hvilke av de følgende påstandene om Groovy-closures er SANNE?

Besvar den i den interaktive leksjonen

Oppsummering: Forstå closures

Godt jobbet! De har tatt et viktig skritt mot å forstå Groovys kraftige closures.

Her er en kort oppsummering av det vi gikk gjennom:

Closures er kodeblokker som behandles som førsteklasses verdier.
De bruker {} for definisjon og -> for parametere.
Nøkkelordet it forenkler closures med én parameter.
Closures sendes ofte inn som metodeargumenter, noe som gjør Groovy mer uttrykksfullt.
De har leksikalsk scope, slik at de kan fange opp og til og med endre variabler fra konteksten rundt seg.

I neste leksjon skal vi se nærmere på hvordan closures kan brukes i funksjonelle programmeringsmønstre i Groovy!

Gratis å komme i gang

Lær deg Groovy med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Forstå Groovy closures» gratis?

Ja – hele teksten i «Forstå Groovy closures» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Groovy og Gradle: JVM-automatisering og byggeutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Groovy og Gradle: JVM-automatisering og byggeutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Forstå Groovy closures»?

Lær konseptet closures, hvordan De definerer dem og deres mange bruksområder i Groovy. Du øver på Groovy og Gradle: JVM-automatisering og byggeutvikling med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Groovy og Gradle: JVM-automatisering og byggeutvikling?

Ingen tidligere erfaring er nødvendig. Groovy og Gradle: JVM-automatisering og byggeutvikling på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Forstå Groovy closures»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Groovy og Gradle: JVM-automatisering og byggeutvikling-leksjonen?

Ja. Alle Groovy og Gradle: JVM-automatisering og byggeutvikling-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Groovy og Gradle: JVM-automatisering og byggeutvikling