1unitedpower: Datum kürzen

Beitrag lesen

ich habe noch einen Testlauf mit meiner preg_match Methode gemacht, allerdings stumpf mit handgeschnitztem microtime in einem Commandline-PHP.

Ups, hab die Methode glatt vergessen. Hab sie nun auch mal in meinen Benchmark gepackt.

PHP cached dem Vernehmen nach Regexe, d.h. er erste Aufruf dauert länger als die Folgeaufrufe, das kann ich aber nicht messen. Die Laufzeit ist zu kurz, für einen Call werden mir immer 0 Mikrosekunden gemeldet.

Das kann gut sein, dafür gibt es in phpbench die Warmup-Phase. Da werden die Benchmarks ausgeführt ohne dass sie gemessen werden.

Die kleinste microtime-Differenz, die ich hier sehe, scheint 1ms zu sein. Sehr ärgerlich, Windows kann das eigentlich genauer, aber PHP scheint es nicht zu nutzen.

Hmm, ich hab auch PHP unter Windows benutzt, bei mir scheint das kein Problem zu sein.

Hab in einem neuen Lauf alle Algorithmen auf ihren Kern reduziert und noch einen einen sehr banalen Algorithmus benchStringAccess hinzugenommen. Parameter wie zuvor.

+-------------------+---------+---------+---------+---------+------- -+--------+-------+
| subject           | best    | mean    | mode    | worst   | stdev   | rstdev | diff  |
+-------------------+---------+---------+---------+---------+------- -+--------+-------+
| benchBernd        | 1.851μs | 1.890μs | 1.865μs | 1.951μs | 0.038μs | 2.03%  | 4.73x |
| benchUrsus        | 0.507μs | 0.517μs | 0.520μs | 0.530μs | 0.009μs | 1.67%  | 1.30x |
| benchDedlfix      | 3.213μs | 3.260μs | 3.240μs | 3.342μs | 0.045μs | 1.39%  | 8.16x |
| benchRolfPreg     | 1.015μs | 1.036μs | 1.037μs | 1.053μs | 0.014μs | 1.33%  | 2.59x |
| benchStringAccess | 0.390μs | 0.399μs | 0.393μs | 0.414μs | 0.010μs | 2.43%  | 1.00x |
| bench1UnitedPower | 3.323μs | 3.373μs | 3.342μs | 3.438μs | 0.046μs | 1.36%  | 8.45x |
+-------------------+---------+---------+---------+---------+------- -+--------+-------+
<?php

namespace SelfHtml;

use \DateTimeImmutable;

class FormatDateBench
{

    public function provideDateStrings()
    {
        yield ['date' => '2019-05-07'];
    }

    /**
     * @ParamProviders({"provideDateStrings"})
     * @Warmup(5)
     * @Revs({10000})
     * @Iterations(5)
     */
    public function benchBernd($params)
    {
        $date = $params['date'];
        $d = explode("-", $date);
        return sprintf("%02d.%02d.%02d", $d[2], $d[1], substr($d[0], 2, 4));
    }

    /**
     * @ParamProviders({"provideDateStrings"})
     * @Warmup(5)
     * @Revs({10000})
     * @Iterations(5)
     */
    public function benchUrsus($params)
    {
        $date = $params['date'];
        return (
            substr($date, 8, 2) . '.' .
            substr($date, 5, 2) . '.' .
            substr($date, 2, 2)
        );
    }

    /**
     * @ParamProviders({"provideDateStrings"})
     * @Warmup(5)
     * @Revs({10000})
     * @Iterations(5)
     */
    public function benchDedlfix($params)
    {
        $input = $params['date'];
        return date('d.m.y', strtotime($input));
    }

    /**
     * @ParamProviders({"provideDateStrings"})
     * @Warmup(5)
     * @Revs({10000})
     * @Iterations(5)
     */
    public function benchRolfPreg($params)
    {
        $date = $params['date'];
        preg_match("/^..(?<year>..).(?<month>..).(?<day>..)$/", $date, $matches);
        return (
            $matches['day'] . "." .
            $matches['month'] . "." .
            $matches['year']
        );
    }

    /**
     * @ParamProviders({"provideDateStrings"})
     * @Warmup(5)
     * @Revs({10000})
     * @Iterations(5)
     */
    public function benchStringAccess($params)
    {
        $date = $params['date'];
        return $date[8] . $date[9] . '.' . $date[5] . $date[6] . '.' . $date[2] . $date[3];
    }


    /**
     * @ParamProviders({"provideDateStrings"})
     * @Warmup(5)
     * @Revs({10000})
     * @Iterations(5)
     */
    public function bench1UnitedPower($params)
    {
        $input = $params['date'];
        return DateTimeImmutable::createFromFormat('Y-m-d', $input)->format('d.m.y');
    }

}

0 44

Datum kürzen

  1. 1
    1. 0
      1. 0
  2. 0
  3. 0
    1. 0
      1. 0
      2. 0
        1. 0
        2. 0
          1. 0
            1. 0
              1. 0
                1. 0
                  1. 0
                    1. 0
                      1. 0
                        1. 0
                  2. 1
                    1. 0
                      1. 0
                        1. 0
                          1. 0
                            1. 0
                            2. 0

                              microtime(true)

                              1. 0
                                1. 0
                                  1. 0
                                    1. 5
                              2. 0
                              3. 0
                                1. -1

                                  Kann passieren

                          2. 0
                            1. 0
                      2. 0
                        1. 0
                      3. 0
                        1. 0
                          1. 0
                            1. 0

                              PS: Benchmark Code

                            2. 0
                              1. 0
      3. 0