Groovy och Gradle: JVM-automatisering och byggsystemutveckling · Lektion

Förstå Groovy-closures

Lär er begreppet closures, hur de definieras och hur de kan användas på många olika sätt i Groovy.

Lektion 2 av 411 steg

Förstå Groovy-closures är en gratis lektion i Groovy och Gradle: JVM-automatisering och byggsystemutveckling på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Groovy och Gradle: JVM-automatisering och byggsystemutveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling innehåller totalt 4 lektioner.

Vad är Groovy-closures?

Välkomna till Groovy-closurernas värld! En closure är i grunden ett kodblock som kan behandlas som en variabel.

Tänk på den som en liten funktion som ni kan definiera, lagra och skicka vidare. Closures är en kraftfull funktion som gör Groovy-kod mycket flexibel och koncis.

De är förstaklassmedborgare, vilket innebär att de kan tilldelas variabler, skickas som argument och returneras från metoder.
De kan fånga variabler från den omgivande kontexten, även efter att den kontexten har slutat köras.

Grundläggande closuresyntax

Det är enkelt att definiera en closure. Omslut kodblocket med klammerparenteser {}. Här är ett enkelt exempel:

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 parametrar

Precis som metoder kan closures ta emot parametrar. Skriv parametrarna före operatorn -> (pilen), följt av closurens kropp.

Det gör att closuren kan utföra operationer baserat på den indata den tar emot.

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)}"
  }
}

Nyckelordet 'it'

När en closure tar exakt en parameter tillhandahåller Groovy en särskild implicit variabel som heter it. Ni behöver inte deklarera it explicit.

Det gör closures med en parameter ännu mer koncisa och lättlästa, särskilt när de används 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 metodargument

En av de vanligaste och kraftfullaste användningarna av closures i Groovy är att skicka dem som argument till metoder. Många Groovy-metoder, särskilt de som finns för samlingar, är utformade för att ta emot closures.

Om en closure är metodens sista argument kan ni placera den utanför parenteserna, vilket gör koden mycket ren och DSL-liknande.

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}"
  }
}

Fånga variabler: lexikalt scope

Closures har lexikalt scope, vilket innebär att de minns och kan komma åt variabler från det scope där de definierades, även om det scopet inte längre finns.

Detta är en viktig egenskap som skiljer closures från vanliga metoder och gör att de kan bära med sig sin kontext.

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'
  }
}

Ändra fångade variabler

Closures kan inte bara komma åt fångade variabler, utan även ändra dem. Det ger ett kraftfullt sätt för closures att samverka med sin omgivning.

Var försiktiga när ni ändrar externa variabler inifrån closures, eftersom det ibland kan leda till mindre förutsägbar kod om det inte hanteras noggrant.

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}"
  }
}

Closurens metod 'call()'

Även om ni kan köra en closure genom att helt enkelt använda parenteser (till exempel myClosure()) är closures egentligen instanser av klassen groovy.lang.Closure.

Det innebär att de också har en metod som heter call(). Att använda call() motsvarar direkt körning och kan ibland vara användbart för tydlighet eller när closures anropas dynamiskt.

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 användning: filtrera listor

Låt oss använda closures i ett praktiskt exempel: filtrera element i en lista. Groovys samlingsmetoder, som findAll, passar perfekt för detta.

Ni anger en closure som definierar villkoret för inkludering, och findAll returnerar en ny lista som endast innehåller de element som uppfyller villkoret.

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}"
  }
}

Kontroll av closure-begrepp

Vilka av följande påståenden om Groovy-closures är SANNA?

Besvara frågan i den interaktiva lektionen

Repetition: Förstå closures

Bra jobbat! Ni har tagit ett viktigt steg mot att förstå Groovys kraftfulla closures.

Här är en kort sammanfattning av det vi gick igenom:

Closures är kodblock som behandlas som förstaklassobjekt.
De använder {} för definition och -> för parametrar.
Nyckelordet it förenklar closures med en parameter.
Closures skickas ofta som metodargument, vilket gör Groovy mer uttrycksfullt.
De har lexikalt scope och kan fånga upp samt även ändra variabler från den omgivande kontexten.

I nästa lektion utforskar vi hur closures kan användas med mönster för funktionell programmering i Groovy!

Gratis att börja

Lär dig Groovy med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Förstå Groovy-closures” gratis?

Ja – hela texten till ”Förstå Groovy-closures” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling, kan Ni uppgradera till CoddyKit PRO. Kursen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling innehåller totalt 4 lektioner.

Vad lär jag mig i ”Förstå Groovy-closures”?

Lär er begreppet closures, hur de definieras och hur de kan användas på många olika sätt i Groovy. Ni övar på Groovy och Gradle: JVM-automatisering och byggsystemutveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Groovy och Gradle: JVM-automatisering och byggsystemutveckling?

Du behöver inga förkunskaper. Utbildningen i Groovy och Gradle: JVM-automatisering och byggsystemutveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Förstå Groovy-closures”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Groovy och Gradle: JVM-automatisering och byggsystemutveckling-lektionen?

Ja. Varje Groovy och Gradle: JVM-automatisering och byggsystemutveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Groovy och Gradle: JVM-automatisering och byggsystemutveckling