WORDS

Introduktion till Linq: Lambdauttryck

Om du blir förvirrad av vad x => x egentligen betyder, så har du kommit rätt! Syntaxen är kompakt och kan vara svårtydd, om man inte vet vad alla delar betyder.

Lambdauttryck (eng. lambda expressions) är metoder eller funktioner som man definierar som del av ett uttryck, oftast utan att ge dom ett namn.

En fet pil: =>

Det som kännetecknar ett lambdauttryck i C# är =>, en "fet pil" (eng. fat arrow).

parametrar => implementation

Det som står till vänster om pilen är parametrar till metoden, och det som står till höger är implementationen. Både parametrar och implementation kan se ut på olika sätt.

Frivilliga typer, parenteser och måsvingar

Motsvarande i Javascript: Samma syntax, förutom alternativ med angiven typ, då Javascript är dynamiskt typat.

En sak som gör lambdauttryck komplicerade, är att det finns flera olika syntaxer för samma sak. Ofta kan man hoppa över en del av syntaxen, men inte alltid. Här följer några exempel, som alla ger samma resultat.

public class Example
{
    private bool IsSmall(int number)
    {
        return number < 10;
    }

    public IEnumerable<int> GetSmallNumbers(IEnumerable<int> numbers)
    {
        // Alla tilldelningar nedan ger exakt samma resultat.
        IEnumerable<int> result;

        // `Where` tar en metod med en `int` som inparameter,
        // och som returnerar `bool`. Observera att vi inte
        // anropar metoden, utan *skickar* hela metoden som
        // en parameter.
        result = numbers.Where(IsSmall);

        // 1. Man kan deklarera hela metoden inline. Man
        // anger inget namn, utan använder `=>` för att visa
        // att det är ett lambdauttryck.
        result = numbers.Where((int number) =>
        {
            return number < 10;
        });

        // 2. Eftersom `Where` kräver ett lambdauttryck med
        // `int` som inparameter, behöver vi inte ange det
        // explicit.
        result = numbers.Where((number) =>
        {
            return number < 10;
        });

        // 3. Eftersom lambdauttrycket bara har *en* implicit
        // typad parameter, kan vi strunta i parenteserna
        // runtom.
        result = numbers.Where(number =>
        {
            return number < 10;
        });

        // 4. Om implementationen bara är `return <uttryck>`,
        // så kan man ta bort måsvingarna och nyckelordet
        // `return`. Det blir riktigt kompakt.
        result = numbers.Where(number => number < 10);

        // Äntligen får vi returnera resultatet.
        return result;
    }
}

Namngivning

Ofta namnges parametrar med någon enstaka bokstav, såsom x. Om det är det minsta otydligt vad parametern innebär, så rekommenderar jag ett längre namn.

public class Example
{
    /// <summary>
    /// Hämta antalet anställda, vars chef är under 25 år.
    /// </summary>
    public int GetManagerStat(IEnumerable<Employee> employees)
    {
        // För varje anställd, hämta hens chef. Räkna
        // därefter bara chefer som är under 25 år. Vad blir
        // antalet element?

        var result = employees
            // Här är `x` en anställd.
            .Select(x => x.Manager)

            // Här är `x` en chef.
            .Count(x => x.Age < 25);

        // Om man vill kan man förtydliga med längre variabelnamn:
        result = employees
            .Select(employee => employee.Manager)
            .Count(manager => manager.Age < 25);

        return result;
    }
}