Een van de belangrijkste handelingen bij het werken met arrays is het zoeken naar een specifieke waarde. De PHP array_search() functie is hiervoor ontworpen. Het is in staat om zowel eendimensionale als associatieve verzamelingen te verwerken, waarbij de sleutel van de gezochte waarde wordt geretourneerd als deze in de array wordt gevonden.

Syntaxis

De geformaliseerde beschrijving van de functie array_search() in PHP is als volgt:

Gemengde array_search (gemengde waarde, array $collection [, bool strict])

Invoerparameters:

• $collection - de array waarin de zoekopdracht zal worden uitgevoerd;
• waarde - de gewenste waarde van elk type;
• strict is een optionele Booleaanse vlag die een strikt typebewust vergelijkingsmechanisme instelt.

Werkingsmechanisme

De PHP array_search() functie vergelijkt de waarde één voor één met alle waarden in de verzamelingsarray. Standaard wordt de vergelijking uitgevoerd zonder rekening te houden met de typen operanden. Deze instelling kan worden gewijzigd door de strikte vlag in te stellen op TRUE. Tekenreeksvergelijkingen zijn hoofdlettergevoelig.

Als er een match wordt gevonden, wordt de sleutel die overeenkomt met het gevonden element geretourneerd en werkt de functie niet meer. Daarom kan het niet worden gebruikt om meerdere keren voorkomen van de gewenste waarde in een array te detecteren.

Als er geen overeenkomsten worden gevonden, retourneert de functie de Booleaanse waarde FALSE.

U moet het geretourneerde resultaat controleren met behulp van de operator voor strikte gelijkheid (===). Dit is belangrijk omdat de functie mogelijk een waarde retourneert die is omgezet naar FALSE, zoals 0 of de lege tekenreeks.

Voorbeelden van gebruik

Voorbeeld 1. Wanneer u een multidimensionale array doorgeeft aan de PHP array_search() functie, zal het resultaat van het werk de sleutel van het gezochte element zijn.

"winter", "seizoen2" => "lente", "seizoen3" => "zomer", "seizoen4" => "herfst"); $result1 = array_search("winter", $array); $result2 = array_search("zomer", $array); $result3 = array_search("april", $array); ?>

In dit voorbeeld wordt $result1 ingesteld op "season1", $result2 op "season3" en $result3 op de Booleaanse waarde FALSE omdat de tekenreeks "april" niet in de bronarray voorkomt.

Voorbeeld 2. De PHP-functie array_search() kan ook een eendimensionale array verwerken, waarbij de sleutels ervan als de volgende numerieke indices worden beschouwd.

De variabele $result wordt ingesteld op 1, afhankelijk van de index van het element "hunter" in de $array.

Voorbeeld 3. Mogelijke fout bij het analyseren van het resultaat.

"Washington", 1 => "Adams", 2 => "Jefferson", 3 => "Madison", 4 => "Monroe"); $result = array_search("Washington", $presidenten); if (!$result) ( echo "G. Washington was niet de eerste president van de VS"; ) ?>

Dus zonder het resultaat met strikte gelijkheid te controleren, kun je een onverwachte boodschap krijgen dat George Washington niet de eerste president van de Verenigde Staten was.

Voorbeeld 4: Alleen de sleutel van de eerste gevonden match wordt teruggegeven.

Hoewel de waarde die u zoekt drie keer voorkomt in de array, retourneert de functie alleen het eerste gevonden resultaat - 0. Om meerdere overeenkomsten te vinden, wordt aanbevolen om de PHP-functie array_keys() te gebruiken.

Programmeren gaat over syntaxis en semantiek. De eerste wordt bepaald door de regels van de taal, de tweede door de ervaring van de ontwikkelaar. Met betrekking tot arrays kan de ontwikkelaar de syntaxis specifiek laden met semantiek. Dit is nog geen object, maar het is niet langer een array in de traditionele zin. PHP geeft je de mogelijkheid om arrays van variabelen van verschillende typen te creëren, inclusief zichzelf. Een array-element kan een functie zijn, dat wil zeggen de mogelijkheid om de array te laden met een echt algoritme, met een echte betekenis.

De syntaxis is stabiel, maar verandert van versie tot versie en is mogelijk niet altijd compatibel, zelfs niet van onder naar boven. Overdraagbaarheid van programma’s is een vergeten prestatie van de vorige eeuw. De semantiek evolueert en kan altijd worden toegepast, niet alleen in welke versie van welke taal dan ook; Het is een traditie geworden om syntactische constructies te gebruiken om uit te drukken wat niet eens in de regels van de taal was voorzien. Dit kan het gemakkelijkst worden begrepen aan de hand van het voorbeeld van arrays.

Arrays construeren

Array in PHP heeft handige syntaxis en functionaliteit. Dit kan van tevoren worden beschreven, maar het is vaak handig om indien nodig direct arrays te maken.

publiek $aNone = array(); // de array wordt beschreven en bevat niets

public $aFact = array("avocado", "perzik", "kers"); // deze array heeft drie elementen

Een array maken terwijl u een voorwaarde controleert:

$cSrcLine = "geanalyseerde datalijn";

voor ($i=0; $i<13; $i++) {

if (checkFunc($cSrcLine, $cUserLine) (

$aResultaat = "Ja"; // toevoegen aan PHP-array

$aResultaat = "Nee";

Als resultaat van de uitvoering van dit voorbeeld wordt een array van 13 elementen gemaakt, waarvan de waarden alleen de tekenreeksen "Ja" of "Nee" zijn. De elementen krijgen indexen van 0 tot 12. Hetzelfde effect kan worden bereikt door eerst de “toekomstige” PHP-array in een string te schrijven:

$cFutureArray = "";

voor ($i=0; $i<13; $i++) {

$cUserLine = inputUserLine(); // voer iets in

als ($i > 0) ( $cFutureArray .= "|"; )

if (checkFunc($cSrcLine, $cUserLine) ( $cFutureArray .= "Ja";

) else ($cFutureArray .= "Nee"; )

$aResult = explode("|", $cFutureArray);

Multidimensionale arrays

Veel contentmanagementsystemen (CMS) maken op grote schaal gebruik van arrays. Aan de ene kant is dit een goede gewoonte, aan de andere kant maakt het het gebruik ervan lastig. Zelfs als de auteur de ‘PHP-array binnen een array’-doctrine begrijpt, mag hij deze niet misbruiken: niet alleen de ontwikkelaar zal moeten wennen aan de complexe notatie. Vaak zal de maker zich na een tijdje zelf nog lang herinneren wat hij aanvankelijk schreef:

"view_manager" => array(41, "template_path_stack" => array(__DIR__ . "/../view",),

"router" => array("routes" => array("sayhello" => array(

"type" => "Zend\Mvc\Router\Http\Literal",

"opties" => array("route" => "/sayhello", "defaults" => array(

"controller" => "Helloworld\Controller\Index", "actie" => "index",))))),

"controllers" => array("aanroepbare" => array(

"Helloworld\Controller\Index" => "Helloworld\Controller\IndexController"))

Dit is een voorbeeld van de "PHP-array binnen een array"-praktijk uit ZF 2. In eerste instantie niet erg inspirerend, maar het werkt en maakt dit raamwerk aantoonbaar succesvol (voorbeeld uit ZendSkeletonApplication/module/Helloworld/config/module.config.php) .

Een array is een belangrijk gegevensconstruct tijdens ontwerp en ontwikkeling. De multidimensionale versie was ooit populair, maar na verloop van tijd bleef er behoefte bestaan ​​aan arrays van maximaal twee of drie dimensies. Op deze manier is het eenvoudiger en duidelijker, en vanuit professioneel oogpunt betekent het dat wanneer iets zich begint te vermenigvuldigen, er iets mis is in de probleemstelling of in de code.

Eenvoudig, toegankelijk en begrijpelijk

Bij het maken van een array binnen een array in PHP kun je je het beste beperken tot twee of drie niveaus. Ondanks de stabiliteit en betrouwbaarheid van PHP, maakt het fouten bij het verwerken van syntactische structuren. Je kunt dit verdragen als je een goede code-editor hebt en gewend raakt aan het nauwkeurig tellen van haakjes en komma's. PHP heeft echter geen controle over gegevenstypen (dit is het karma van modern programmeren) en stelt de ontwikkelaar in staat semantische fouten te oefenen.

De regel om de soorten variabelen of uw eigen ideeën te controleren om semantiek in syntaxis om te zetten, is vaak een onbetaalbare luxe. Dit is een verlies aan scriptsnelheid, leesbaarheid van de code, ... omdat eenvoud bij het coderen altijd essentieel is.

PHP heeft een aanzienlijk negatief kenmerk: als er onzekerheid ontstaat, loopt het script gewoon vast. Niet alle debuggers kunnen onvoorziene omstandigheden aan, en veel hangt af van de ervaring en intuïtie van de ontwikkelaar. Hoe eenvoudiger het algoritme, hoe toegankelijker de informatie is gestructureerd, hoe groter de kans dat een fout wordt gevonden of helemaal wordt voorkomen.

Het is kenmerkend dat toen de eerste arrays verschenen, varianten van gegevens werden voorgesteld in de vorm van structuren - een onhandige poging om iets uit verschillende gegevenstypen te creëren. De eerste overleefde en kreeg een nieuwe effectieve syntaxis, terwijl de laatste geschiedenis werd.

Eenvoudige en associatieve arrays

De notatie voor een tweedimensionale array is een ander paar haakjes "[" en "]", bijvoorbeeld: $aSrcData betekent toegang tot een array-element dat is opgenomen in de $aSrcData-array. Er is geen verplichting om gegevens vooraf in PHP aan te geven. Eventuele vermelde informatie kan altijd op bestaan ​​worden geverifieerd.

Het is heel effectief om alleen iets te creëren als het nodig is, in de vorm waarin het nodig was, en het te vernietigen als de behoefte eraan verdwenen is. Door betekenisvolle namen als sleutels (indexen) te gebruiken, kun je leesbare constructies krijgen die betekenisvol zijn in de context van de huidige plaats in het algoritme:

$aAnketa["naam"] = "Ivanov";
$aAnketa["leeftijd"] = 42;
$aAnketa["work"] = "Directeur";
$aAnketa["actief"] = waar;
$aTabel = $aAnketa;

$aAnketa["naam"] = "Petrov";
$aAnketa["leeftijd"] = 34;
$aAnketa["work"] = "Beheerder";
$aAnketa["actief"] = waar;
$aTabel = $aAnketa;

$aAnketa["naam"] = "Afanasyev";
$aAnketa["leeftijd"] = 28;
$aAnketa["werk"] = "Werknemer";
$aAnketa["actief"] = false;
$aTabel = $aAnketa;

$sOne .= implode ("; ", $aTable) . "
"; // tweede PHP-array in een string
$sOne .= $aTabel["werk"]; // toegang tot één element van de tweede array

Het resultaat van dit voorbeeld (de eerste array is normaal, de sleutels daarin beginnen vanaf 0, de tweede array is associatief, deze heeft vier sleutels: "naam", "leeftijd", "werk", "actief"):

$sOne = "Petrov; 34; Manager; 1
Manager";

Dit eenvoudige voorbeeld laat zien hoe een gemaakte vragenlijst op alle medewerkers kan worden toegepast. U kunt een array van medewerkers aanmaken met indexen op personeelsnummers en als u een specifieke medewerker nodig heeft, kunt u hem selecteren op personeelsnummer.

Als de organisatie divisies heeft, of er seizoensarbeiders zijn, of als u werkende gepensioneerden afzonderlijk moet identificeren, ... is het 'PHP-array in een array'-ontwerp erg handig, maar u moet zich nooit laten meeslepen door de dimensie. Twee of drie dimensies zijn de limiet voor een effectieve oplossing.

Toetsen voor het werken met arrays

Als het er voorheen toe deed hoe alles was geregeld, zijn de tradities van het binaire tijdperk, toen de programmeur wilde weten hoe de elementen van een array precies waren opgeslagen en er directe toegang toe wilde hebben, de afgelopen jaren volledig vergeten. Er zijn veel karaktercoderingen verschenen die meer dan één byte aan geheugen in beslag nemen. Het woord "bit" is nu alleen te vinden in bitzoekbewerkingen, maar het zoeken in een PHP-array is een apart onderwerp. Toegang tot elementen kan eenvoudig en associatief zijn. In het eerste geval zijn de array-elementen (waarvan een van de typen beschikbaar is in PHP) genummerd 0, 1, 2, ... In het tweede geval specificeert de programmeur zijn eigen index, vaak een "sleutel" genoemd, om toegang te krijgen de gewenste waarde.

$aLine["fruit"] = "sinaasappel"; // hier PHP-arraysleutel = "fruit"

of (zodat alles correct is, met respect voor de paginacodering en code):

$aLine = iconv("UTF-8", "CP1251", "oranje");

Bij het toevoegen van een nieuwe waarde aan de $aLine array:

$aLine = iconv("UTF-8", "CP1251", "perzik");
$aLine = iconv("UTF-8", "CP1251", "komkommer");
$aLine = iconv("UTF-8", "CP1251", "aubergine");

als resultaat van het uitvoeren van de lus:

foreach ($aLine als $ck => $cv) (
$cEen .= $ck . "=" . $cv. "
";
}

zal worden ontvangen:

vrucht=sinaasappel
0=perzik
groente=komkommer
1=aubergine

De PHP-sleutel van de array wordt bij het toevoegen van de elementen "perzik" en "aubergine" opeenvolgend gevormd vanaf 0, en bij het specificeren van de waarde zal deze gelijk zijn aan deze waarde.

Elementen uit een array verwijderen

De eenvoudigste manier is tijdens de verwerking ervan. In dit geval wordt bijvoorbeeld, als resultaat van het uitvoeren van een lus, de originele array gescand en wordt een nieuwe gevormd, waarin onnodige elementen eenvoudigweg niet worden geschreven.

Het kan gemakkelijker zijn. Als we op het laatste voorbeeld toepassen:

uitgeschakeld($aLine); // verwijder array-element PHP

dan zal het resultaat zijn:

vrucht=sinaasappel
groente=komkommer
1=aubergine

Er zijn veel opties voor het manipuleren van array-elementen. Als u bijvoorbeeld de functies implode() en explode() gebruikt, kunt u een PHP-array met één scheidingsteken in een string schrijven en deze met een ander scheidingsteken terug in een andere array parseren.

Om eenvoudigweg een hele array in PHP te verwijderen, schrijf je gewoon: unset($aLine);

Dat is genoeg.

Zoeken in een array

PHP bevat speciale zoek- en in_array()-functies, maar voordat u besluit deze te gebruiken, kunt u overwegen om zelf PHP-array-zoekopdrachten uit te voeren.

Elk project heeft specifiek geconstrueerde arrays, vooral wanneer een deel van de semantiek wordt overgebracht naar de syntaxis en wordt weergegeven door een reeks zeer specifieke betekenisvolle sleutels. Hierdoor kunt u uw eigen zoekfuncties uitvoeren, die ook op een zinvolle manier kunnen worden gelabeld.

In PHP kun je functies aanroepen waarvan de naam wordt bepaald tijdens de uitvoering van het programma. Een heel praktisch voorbeeld uit de PHPWord-bibliotheek, waarmee u MS Word-documenten kunt lezen en maken:

$elements = array("Text", "Inline", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Tabel", "Afbeelding", "Object", "Voetnoot",
"Eindnoot", "CheckBox", "TextBox", "Veld", "Lijn");

$functies = array();

voor ($i = 0; $i< count($elements); $i++) {
$functions[$i] = "toevoegen" . $elementen[$i];
}

Als gevolg hiervan ontvangt de array $functions de waarden van de array $elements, dat wil zeggen de namen van echte functies die werken met echte documentelementen.

Door $functions op $elements aan te roepen, kunt u een perfecte zoekopdracht en snelle resultaten krijgen.

Artikelen sorteren

De taak van het sorteren van gegevens is belangrijk en PHP biedt hiervoor verschillende functies: sort(), rsort(), asort(), ksort(), ... Oplopende en aflopende elementen, de tweede twee functies slaan de relaties tussen sleutels en waarden op . Soms is het zinvol om de arraywaarden willekeurig te shufflen - shuffle().

Wanneer u PHP-functies voor sorteren gebruikt, moet u niet vergeten dat elementen niet alleen verschillende typen kunnen hebben, maar ook geen volledig natuurlijke inhoud. Allereerst moet je heel voorzichtig zijn met het sorteren van tekenreeksen die Russische letters bevatten, het sorteren van datums en cijfers die in verschillende formaten zijn geschreven.

De beste manier om zelf een ideale oplossing te schrijven, tenminste in de fase van het testen van het script, is handmatig sorteren. Het helpt bij het anticiperen op onvoorziene situaties.

Stringarrays

Dankzij de functies implode() en explode() kan een array eenvoudig in een string worden omgezet en teruggestuurd. Hierdoor kunt u gegevens in een compacte weergave opslaan en indien nodig uitbreiden naar een handige staat.

Een array die is omgezet in een string opent nieuwe mogelijkheden. De taak van het zoeken naar trefwoorden in een tekst vereist bijvoorbeeld dat wat gevonden wordt, niet opnieuw wordt toegevoegd.

$cSrcLine = "Tekst Tekst ListItemRun TextBox ListItem Tekstvak Selectievakje CheckBox Tekstvak Voetnoot";

$aSrc = explode(" ", $cSrcLine);
$cDstLine = "";

voor ($i=0; $i< count($aSrc); $i++) {
$cFind = "[" . $aSrc[$i] . "]";
if (! is_integer(strpos($cDstLine, $cFind))) (
$cDstLine .= $cFind;
}
}
$aDst = explode("][", $cDstLine);

$cOne = imploderen("; ", $aDst);

Als gevolg hiervan ontvangt de variabele $cOne alleen die waarden uit de bronreeks die daar één keer voorkomen: "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Footnote".

Russische taal in sleutels en betekenissen

Het wordt niet aanbevolen om iets te gebruiken dat verband houdt met nationale coderingen in syntactische structuren. Russisch zal, net als alle andere talen waarvan de karakters verder reiken dan a-z, geen problemen veroorzaken, omdat het zich in het datagebied bevindt, maar niet in de syntaxis van de code. Soms zal zelfs een eenvoudige taak in PHP “een array naar de printer of naar het scherm uitvoeren” tot “gekke bugs” leiden, en vaker zal het script gewoon stoppen.

PHP is een loyale taal en tolereert nationale coderingen, maar er zijn veel situaties waarin de voltooide hoeveelheid werk alleen maar opnieuw moet worden gedaan omdat een sleutelwaarde op de juiste plaats en op het juiste moment opduikt, wat niet mogelijk is herkennen.

PHP-syntaxis en taalomgeving

We moeten niet vergeten dat de PHP-syntaxis één ding is, maar dat de constructies van deze syntaxis “te maken hebben” met andere applicaties, met het besturingssysteem, met hardware-opties. Er zijn veel mogelijkheden, het is nooit mogelijk om in alles te voorzien.

De regel “er zit alleen code in de code, maar er zit allerlei informatie aan de invoer, binnenkant en uitvoer” helpt onvoorziene verrassingen te voorkomen. Een PHP-waarde in een array kan “Russisch” zijn, maar de sleutel ervan moet syntactisch correct zijn, niet alleen vanuit het standpunt van de gegeven taal, maar ook vanuit het standpunt van de besturingsomgeving ervan.

(PHP 4 >= 4.0.5, PHP 5)

array_search - Zoekt naar een bepaalde waarde in een array en retourneert de bijbehorende sleutel als dit lukt

Beschrijving

Zoekt in de hooiberg naar de naaldwaarde en retourneert de sleutel als deze aanwezig is in de array, ONWAAR anders.

Opmerking: Als 'naald' een string is, wordt een hoofdlettergevoelige vergelijking uitgevoerd.

Opmerking: Tot PHP 4.2.0, array_search() teruggestuurd als het niet lukt NUL in plaats van ONWAAR .

Als u de waarde doorgeeft WAAR als optionele derde parameter strict , de functie array_search() zal ook het type naald in de hooiberg controleren.

Indien er meerdere keren een naald in de hooiberg aanwezig is, wordt de eerst gevonden sleutel teruggegeven. Gebruik de functie om de sleutels voor alle gevonden waarden terug te geven array_keys() met een optionele parameter search_value.

Ik gebruik de functie array_search() al geruime tijd om naar waarden in een array te zoeken, aangezien ik herhaaldelijk heb gehoord en gelezen dat het merkbaar sneller werkt dan het zoeken door een array in een lus, maar dat deed ik niet weet hoeveel sneller het is. Eindelijk ben ik er toe gekomen om het zelf te controleren en te tellen.

Ik vergeleek de snelheid van het zoeken door een array met deze functie met het gebruikelijke zoeken door een array in foreach- en while-lussen. Op 10-100 array-elementen is het verschil niet merkbaar en is de tijd zo kort dat het kan worden verwaarloosd. Maar voor grote arrays bleek het verschil behoorlijk groot. Naarmate de arraygrootte met een orde van grootte toenam, nam ook de zoektijd aanzienlijk toe. Met honderdduizend elementen daalde de snelheid van foreach naar 0,013 seconden, en terwijl - naar 0,017, terwijl array_search() ook langzamer ging, maar nog steeds een orde van grootte sneller bleef - 0,004 seconden. Voor een groot script dat met grote arrays werkt, zal het vervangen van een zoekopdracht in een lus door een zoekopdracht met array_search() helemaal geen “vlooienoptimalisatie” zijn.

In dit verband herinnerde ik me een recente discussie met een van mijn collega's op het werk - over de vraag of een programmeur al deze ingebouwde taalfuncties moet kennen, of dat een 'programmeursmentaliteit' en algemene kennis voldoende zijn. Zonder over deze mentaliteit in discussie te gaan, denk ik dat je nog steeds de functies moet kennen, misschien niet de hele syntaxis in detail, maar in ieder geval welke functies er zijn en wat ze in algemene termen kunnen doen.

UPD: je hebt ook de mentaliteit van een programmeur nodig! En voorzichtig zijn met je geheugen kan geen kwaad (geïnspireerd door pauze en bereik :)

Onder de hack staat de scriptcode die werd gebruikt om de tijd te berekenen:

$massa=100000; // aantal waarden in de array waarin we gaan zoeken
$zoeken=50000; // we zullen naar deze waarde zoeken in de array
$first_result=array(); // reeks resultaten om de gemiddelde waarde van de eerste optie te berekenen
$second_result=matrix(); // reeks resultaten om de gemiddelde waarde van de tweede optie te berekenen
$derde_resultaat=array(); // reeks resultaten om de gemiddelde waarde van de derde optie te berekenen

// maak en vul de array
$test_array = bereik(0, $mass-1); // dankzij SelenIT))

/*
$test_array=array();
voor ($i=0; $i<$mass; $i++)
{
$test_array=$i;
}
*/

// lus om gemiddelde waarden te berekenen
voor ($d=0; $d<30; $d++) {

//*************** Zoeken met array_search ********************

// Begin met het tellen van de tijd
$time_start = microtijd(1);
// zoekopdracht
$key = array_search($search, $test_array, waar);
// indien gevonden
if ($key!==FALSE) // het is noodzakelijk!== en niet!=, omdat het nummer van het eerste element 0 is
{
echo $test_array[$sleutel];
}
$time_end = microtijd(1);
// einde van de tijd tellen

// schrijf naar een array met waarden
$first_result=$time_end - $time_start;

//*************** Doorzoek een array met een foreach-lus ********************

// Begin met het tellen van de tijd
$time_start = microtijd(1);
// de zoekopdracht zelf
foreach ($test_array als $ta)
{
als ($ta==$zoeken)
{
echo $ta;
pauze;
}
}
$time_end = microtijd(1);
// einde van de tijd tellen

// schrijf naar een array met waarden
$second_result=$time_end - $time_start;

//*************** Doorzoek een array met een while-lus ********************

// Begin met het tellen van de tijd
$time_start = microtijd(1);

// bepaal de lengte van de array
$telling=telling($test_array);
$j=0;
// de zoekopdracht zelf
terwijl ($j<$count)
{
if ($test_array[$j]==$search) // indien gevonden
{
echo $test_array[$j];
pauze;
}
$j++;
}
$time_end = microtijd(1);
// einde van de tijd tellen

// schrijf naar een array met waarden
$third_result= $time_end - $time_start;
}

$srednee1=array_sum($first_result)/count($first_result);
$srednee2=array_sum ($second_result)/count($second_result);
$srednee3=array_sum ($derde_resultaat)/count($derde_resultaat);

Printf("eerste code gemiddeld voltooid: %.7f seconden", $srednee1);
printf("tweede code gemiddeld voltooid in: %.7f seconden", $srednee2);
printf("de derde code is gemiddeld voltooid in: %.7f seconden", $srednee3);

// resultaat:
// eerste code gemiddeld voltooid: 0,0000295 seconden
// tweede code gemiddeld voltooid: 0,0153386 seconden
// derde code gemiddeld voltooid: 0,0226001 seconden