Funktionsvariabler

Du kan skicka in variabler i funktioner i de flesta programmeringsspråk. Det kan se ut så här:

function MyFunction($myData1 = 123, $myData2 = 'Hello')

Om du skriver så här:

MyFunction(,'Hej');

så betyder det att du nöjer dig med standardvärdet på första variabeln, och sätter ett eget värde på den andra variabeln.

Om du råkar blanda ihop det hela och skriver:

MyFunction('Hej', 456);

Då måste MyFunction göra en kontroll av varje variabel att den innehåller det som förväntats.
Programmeringsspråk som har en inbyggd kontroll av variablernas datatyp kommer att protestera. Men PHP och Javascript har inte detta (PHP har en svag kontroll i senare versioner av PHP)

Jag ska presentera ett förslag för dig så får du fundera på det. Det här förslaget fungerar i alla programmeringsspråk men jag ger dig ett exempel i PHP och i Javascript.

Först ett exempel i PHP

    final protected function _Default(array $default = array(), array $in = array())
    {
        if (is_array($default) === false and is_array($in) === true) {
            return $in;
        }
        if (is_array($default) === true and is_array($in) === false) {
            return $default;
        }

        $answer = array_intersect_key(array_merge($default, $in), $default);

        foreach ($default as $key => $data) {
            if (gettype($answer[$key]) !== gettype($default[$key]) and is_null($default[$key]) === false) {
                $answer[$key] = $default[$key];
            }
        }
        return $answer;
    }

    final protected function MyFunction (array $in = array())
    {
        $default = array(
            'myData1' => 123,
            'myData2' => 'Hello'
        );
        $in = $this->_Default($default, $in);

Använd så här

    $response = $this->MyFunction(array('myData2' => 'Hej'));

Exempel i JavaScript

    var _Default = function ($default, $in) {
        "use strict";

        if (typeof $default !== 'object' && typeof $in === 'object') {
            return _ByVal($in);
        }
        if (typeof $default === 'object' && typeof $in !== 'object') {
            return _ByVal($default);
        }

        var $answer = {}, $key;

        for ($key in $default) {
            $answer[$key] = $default[$key];
            if ($in.hasOwnProperty($key)) {
                if ($in[$key] !== null) {
                    if (typeof $in[$key] === typeof $default[$key] || $default[$key] === null) {
                        $answer[$key] = $in[$key];
                    }
                }
            }
        }
        return _ByVal($answer);
    };

    var MyFunction = function ($in) {
        "use strict";
        var $default = {
                'myData1': 123,
                'myData2': 'Hello'
            };
        $in = _Default($default, $in);

Använd så här

    $response = MyFunction({'MyData2': 'Hej'});

Så vad är det här då?

I vanliga fall brukar man tala om vilka variabler man vill ha in i MyFunction, i detta faller skickar man istället in en associativ array (Objekt).
Så med det här sättet får du följande fördelar:

• Du kan lägga till eller ta bort variabelnamn i $default utan att behöva ändra i den kod som använder funktionen.
• Du kan kalla på en funktion och ange namnen på de variabler du inte vill ha defaultvärde på.
• I MyFunction vet du vilka variabler som finns i $in och att de har rätt datatyper.
• Använder du dessutom _Default på ut-arrayern så är det ingen tvekan om vad som skickas ut från din funktion.

Och nackdelarna är

• Du får ingen hjälp av din editor att se vilka variabler som funktionen ska ha (Tills någon skriver en plugin till editorn för att fixa det)

Och ytterligare en fördel är att om du alltid har en in-array och en ut-array så kan du ha ett generellt sätt att kalla på dessa funktioner. Mer om det i en senare artikel.