min - PHP code example

PHP Function Min - What Is It?

php function min is a built-in function used to get the minimum value in an array. It can also be used to compare multiple values. Its usage depends on the type of data you want to compare and if you are using it for string or boolean values. It works best on numbers, but it can work with other types as well.

One of the most common mistakes that developers make is not knowing whether a function they are calling is returning a value or a reference. This is especially important when working with arrays because there are some cases where it is not clear if the array will be returned by value or by reference. For example, the php min function returns an array by value if you do not include & to make it return a reference. This means that if you call the php min function on an existing array and then make a change to the original array, it will not be updated in your copy of the array.

Another problem with the php min function is that it does not correctly support arrays with a single key. This is because it uses the same alias for each array element, rather than the key of the array element itself. This is a problem because it can cause confusion for developers who are trying to use the php min function on an array with a single key. It is recommended that you use a different solution, such as the array_key_exists() function, to avoid these problems.

min example

$criteria->hasCondition($criteriaPart->getName()),
            $criteriaPart->getLabel()
        );
    }

    /** * @param array<string, mixed> $data */
    private function createRangeResult(ProductAttributeFacet $criteriaPart, array $data, Criteria $criteria): RangeFacetResult
    {
        $values = array_column($data['buckets'], 'key');
        $min = empty($values) ? 0 : min($values);
        $max = empty($values) ? 0 : max($values);

        $activeMin = $min;
        $activeMax = $max;

        $condition = $criteria->getCondition($criteriaPart->getName());
        if ($condition instanceof ProductAttributeCondition) {
            $value = $condition->getValue();
            if (\is_array($value)) {
                $activeMin = $value['min'];
                $activeMax = $value['max'];
            }

function fix_import_form_size( $size ) {
    if ( upload_is_user_over_quota( false ) ) {
        return 0;
    }
    $available = get_upload_space_available();
    return min( $size, $available );
}

/** * Displays the site upload space quota setting form on the Edit Site Settings screen. * * @since 3.0.0 * * @param int $id The ID of the site to display the setting for. */
function upload_space_setting( $id ) {
    switch_to_blog( $id );

/** * Returns the current line that the tokenizer is at. */
    public function currentLine()
    {
        if (empty($this->EOF) || 0 === $this->char) {
            return 1;
        }
        // Add one to $this->char because we want the number for the next         // byte to be processed.         return substr_count($this->data, "\n", 0, min($this->char, $this->EOF)) + 1;
    }

    /** * @deprecated */
    public function getCurrentLine()
    {
        return $this->currentLine();
    }

    /** * Returns the current column of the current line that the tokenizer is at. * Newlines are column 0. The first char after a newline is column 1. * * @return int The column number. */

        foreach ($this->streams as $i => $stream) {
            try {
                $stream->rewind();
            } catch (\Exception $e) {
                throw new \RuntimeException('Unable to seek stream '
                    .$i.' of the AppendStream', 0, $e);
            }
        }

        // Seek to the actual position by reading from each stream         while ($this->pos < $offset && !$this->eof()) {
            $result = $this->read(min(8096, $offset - $this->pos));
            if ($result === '') {
                break;
            }
        }
    }

    /** * Reads from all of the appended streams until the length is met or EOF. */
    public function read($length): string
    {

                return;
            }
            $this->ageDirectives[$directive] = false;
        }

        if (false !== $this->ageDirectives[$directive]) {
            $value -= $age;
            $this->ageDirectives[$directive] = null !== $this->ageDirectives[$directive] ? min($this->ageDirectives[$directive], $value) : $value;
        }
    }
}

/** * @param list<TimeBackoffLimit> $limits */
    public function __construct(
        private readonly string $id,
        private array $limits,
        ?int $timer = null
    ) {
        $this->attempts = 0;
        $this->timer = $timer ?? time();
        $this->unthrottledAttempts = min(array_column($this->limits, 'limit')) ?: 0;
    }

    public function __sleep(): array
    {
        $this->stringLimits = \json_encode($this->limits, \JSON_THROW_ON_ERROR);

        return ['id', 'attempts', 'timer', 'expiresAt', 'unthrottledAttempts', 'stringLimits'];
    }

    public function __wakeup(): void
    {

return NULL;
    }
  }

  /** * SQLite compatibility implementation for the LEAST() SQL function. */
  public static function sqlFunctionLeast() {
    // Remove all NULL, FALSE and empty strings values but leaves 0 (zero) values.     $values = array_filter(func_get_args(), 'strlen');

    return count($values) < 1 ? NULL : min($values);
  }

  /** * SQLite compatibility implementation for the CONCAT() SQL function. */
  public static function sqlFunctionConcat() {
    $args = func_get_args();
    return implode('', $args);
  }

  /** * SQLite compatibility implementation for the CONCAT_WS() SQL function. * * @see http://dev.mysql.com/doc/refman/5.6/en/string-functions.html#function_concat-ws */

    private $fetchCount = true;

    /** * @param int $offset * * @return $this */
    public function offset($offset)
    {
        Assertion::min($offset, 0, 'The offset must be greater than equals 0');
        $this->offset = $offset;

        return $this;
    }

    /** * @param int|null $limit * * @return $this */
    public function limit($limit)
    {

/** * @dataProvider provideJitter */
    public function testJitter(float $multiplier, int $previousRetries)
    {
        $strategy = new GenericRetryStrategy([], 1000, $multiplier, 0, 1);
        $min = 2000;
        $max = 0;
        for ($i = 0; $i < 50; ++$i) {
            $delay = $strategy->getDelay($this->getContext($previousRetries, 'GET', 'http://example.com/', 200), null, null);
            $min = min($min, $delay);
            $max = max($max, $delay);
        }
        $this->assertGreaterThanOrEqual(1000, $max - $min);
        $this->assertGreaterThanOrEqual(1000, $max);
        $this->assertLessThanOrEqual(1000, $min);
    }

    public static function provideJitter(): iterable
    {
        // multiplier, previousRetries         yield [1, 0];

        $_ = $handles = [];
        $now = null;

        foreach ($multi->openHandles as [$pauseExpiry, $h]) {
            if (null === $h) {
                continue;
            }

            if ($pauseExpiry && ($now ??= hrtime(true) / 1E9) < $pauseExpiry) {
                $timeout = min($timeout, $pauseExpiry - $now);
                continue;
            }

            $handles[] = $h;
        }

        if (!$handles) {
            usleep((int) (1E6 * $timeout));

            return 0;
        }

    private function checkTypeDeclarations(Definition $checkedDefinition, \ReflectionFunctionAbstract $reflectionFunction, array $values): void
    {
        $numberOfRequiredParameters = $reflectionFunction->getNumberOfRequiredParameters();

        if (\count($values) < $numberOfRequiredParameters) {
            throw new InvalidArgumentException(sprintf('Invalid definition for service "%s": "%s::%s()" requires %d arguments, %d passed.', $this->currentId, $reflectionFunction->class, $reflectionFunction->name, $numberOfRequiredParameters, \count($values)));
        }

        $reflectionParameters = $reflectionFunction->getParameters();
        $checksCount = min($reflectionFunction->getNumberOfParameters(), \count($values));

        $envPlaceholderUniquePrefix = $this->container->getParameterBag() instanceof EnvPlaceholderParameterBag ? $this->container->getParameterBag()->getEnvPlaceholderUniquePrefix() : null;

        for ($i = 0; $i < $checksCount; ++$i) {
            $p = $reflectionParameters[$i];
            if (!$p->hasType() || $p->isVariadic()) {
                continue;
            }
            if (\array_key_exists($p->name, $values)) {
                $i = $p->name;
            } elseif (!\array_key_exists($i, $values)) {

private function createReviews(string $productId, int $reviewCount = 3): void
    {
        $reviews = [];
        for ($i = 1; $i <= $reviewCount; ++$i) {
            $reviews[] = [
                'languageId' => Defaults::LANGUAGE_SYSTEM,
                'salesChannelId' => TestDefaults::SALES_CHANNEL,
                'productId' => $productId,
                'title' => 'Test',
                'content' => 'test',
                'points' => min(5, $i + $i / 5),
                'status' => true,
            ];
        }

        $this->getContainer()->get('product_review.repository')
            ->create($reviews, Context::createDefaultContext());
    }

    private function createSalesChannelContext(): SalesChannelContext
    {
        $salesChannelContextFactory = $this->getContainer()->get(SalesChannelContextFactory::class);

        return $this->path;
    }

    public function getLineno(): int
    {
        return $this->lineno;
    }

    public function getDetails(): string
    {
        $before = str_replace("\n", '\n', substr($this->data, max(0, $this->cursor - 20), min(20, $this->cursor)));
        $after = str_replace("\n", '\n', substr($this->data, $this->cursor, 20));

        return '...'.$before.$after."...\n".str_repeat(' ', \strlen($before) + 2).'^ line '.$this->lineno.' offset '.$this->cursor;
    }
}

private SymfonyQuestionHelper $questionHelper;
    private ProgressBar $progressBar;
    private int $lineLength;
    private TrimmedBufferOutput $bufferedOutput;

    public function __construct(InputInterface $input, OutputInterface $output)
    {
        $this->input = $input;
        $this->bufferedOutput = new TrimmedBufferOutput(\DIRECTORY_SEPARATOR === '\\' ? 4 : 2, $output->getVerbosity(), false, clone $output->getFormatter());
        // Windows cmd wraps lines as soon as the terminal width is reached, whether there are following chars or not.         $width = (new Terminal())->getWidth() ?: self::MAX_LINE_LENGTH;
        $this->lineLength = min($width - (int) (\DIRECTORY_SEPARATOR === '\\'), self::MAX_LINE_LENGTH);

        parent::__construct($this->output = $output);
    }

    /** * Formats a message as a block of text. * * @return void */
    public function block(string|array $messages, string $type = null, string $style = null, string $prefix = ' ', bool $padding = false, bool $escape = true)
    {

    public function loadClass($class, $path = null)
    {
        if (\is_array($class) && $class !== []) {
            return min(array_map([$this, __METHOD__], $class));
        }
        if (!\is_string($class)) {
            throw new Enlight_Exception('Class name must be a string');
        }
        $class = ltrim($class, self::DEFAULT_SEPARATOR);
        if (!$this->isLoaded($class)) {
            if ($path !== null) {
                $this->loadFile($path);

                return true;
            }