constant - PHP code example

What is a PHP Function Constant?

A php function constant is an identifier for a simple value that cannot be changed during the execution of the script. It is contrasted with variables, which have values that can be modified during the runtime of a program. Constants are a useful tool to have when working with PHP and can be used in a variety of ways.

In PHP, a constant is defined using the define() function and is handled at compile time before the script runs. Constants are different from variables because they do not use the $ prefix and follow a convention of using uppercase letters as the starting point for the identifier.

Constants are an important part of the programming language as they can be used to enforce immutability in a program. They can also be used to create values that are accessible from anywhere in the script, even within functions and classes. This can help with creating consistent naming conventions and make the code easier to read.

A PHP constant is defined using the define() function which takes two parameters, first the name of the constant and then the value. The name of the constant must start with a letter or an underscore and can only contain letters, numbers and underscores. Once a constant has been defined it can never be undefined or redefined. The get_defined_constants() function can be used to see all the user-defined constants and core constants that are defined in a PHP script.

constant example

                        return null;
                    case str_starts_with($scalar, '!php/const'):
                        if (self::$constantSupport) {
                            if (!isset($scalar[11])) {
                                throw new ParseException('Missing value for tag "!php/const".', self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
                            }

                            $i = 0;
                            if (\defined($const = self::parseScalar(substr($scalar, 11), 0, null, $i, false))) {
                                return \constant($const);
                            }

                            throw new ParseException(sprintf('The constant "%s" is not defined.', $const), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
                        }
                        if (self::$exceptionOnInvalidType) {
                            throw new ParseException(sprintf('The string "%s" could not be parsed as a constant. Did you forget to pass the "Yaml::PARSE_CONSTANT" flag to the parser?', $scalar), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
                        }

                        return null;
                    case str_starts_with($scalar, '!php/enum'):
                        if (self::$constantSupport) {

    public function test_constants( $constant, $value ) {
        $acceptable_values = (array) $value;

        if ( defined( $constant ) && ! in_array( constant( $constant ), $acceptable_values, true ) ) {
            return array(
                'description' => sprintf(
                    /* translators: 1: Name of the constant used. 2: Value of the constant used. */
                    __( 'The %1$s constant is defined as %2$s' ),
                    "<code>$constant</code>",
                    '<code>' . esc_html( var_export( constant( $constant ), true ) ) . '</code>'
                ),
                'severity'    => 'fail',
            );
        }
    }

    public static function getOption(string $name): int
    {
        // Convert         $constantName = self::getOptionName($name);

        if (!\defined($constantName)) {
            throw new LdapException(sprintf('Unknown option "%s".', $name));
        }

        return \constant($constantName);
    }

    public static function isOption(string $name): bool
    {
        return \defined(self::getOptionName($name));
    }
}

<?php
global $wpcom_api_key, $akismet_api_host, $akismet_api_port;

$wpcom_api_key    = defined( 'WPCOM_API_KEY' ) ? constant( 'WPCOM_API_KEY' ) : '';
$akismet_api_host = Akismet::get_api_key() . '.rest.akismet.com';
$akismet_api_port = 80;

function akismet_test_mode() {
    return Akismet::is_test_mode();
}

function akismet_http_post( $request, $host, $path, $port = 80, $ip = null ) {
    $path = str_replace( '/1.1/', '', $path );

    return Akismet::http_post( $request, $path, $ip );
}

throw new InvalidArgumentException(sprintf('Tag "<%s>" with type="binary" is not a valid base64 encoded string.', $name));
                    }
                    $arguments[$key] = $value;
                    break;
                case 'abstract':
                    $arguments[$key] = new AbstractArgument($arg->nodeValue);
                    break;
                case 'string':
                    $arguments[$key] = $trim ? trim($arg->nodeValue) : $arg->nodeValue;
                    break;
                case 'constant':
                    $arguments[$key] = \constant(trim($arg->nodeValue));
                    break;
                default:
                    $arguments[$key] = XmlUtils::phpize($trim ? trim($arg->nodeValue) : $arg->nodeValue);
            }
        }

        return $arguments;
    }

    /** * Get child elements by name. * * @return \DOMElement[] */

foreach ($this->findFixtures($fixturePath) as $fixtureFile) {
            require $fixtureFile;
            $declared = get_declared_classes();
            /** @var string $currentFixtureClass */
            $currentFixtureClass = end($declared);
            if (!str_contains($currentFixtureClass, 'Fixture.php')) {
                $currentFixtureClass = $declared[\count($declared) - 2];
            }

            if (
                is_subclass_of($currentFixtureClass, AbstractGroupAwareExtension::class)
                && \constant("$currentFixtureClass::TARGET_GROUP") === $runGroup
            ) {
                $fixture = new $currentFixtureClass($container);
                $fixture->configure($this->resolver);
                $fixture->load($container);
            }
        }

        if (isset($url)) {
            $_SERVER['DATABASE_URL'] = $url;
        }
    }

throw new RuntimeException(sprintf('Non-numeric env var "%s" cannot be cast to float.', $name));
            }

            return (float) $env;
        }

        if ('const' === $prefix) {
            if (!\defined($env)) {
                throw new RuntimeException(sprintf('Env var "%s" maps to undefined constant "%s".', $name, $env));
            }

            return \constant($env);
        }

        if ('base64' === $prefix) {
            return base64_decode(strtr($env, '-_', '+/'));
        }

        if ('json' === $prefix) {
            $env = json_decode($env, true);

            if (\JSON_ERROR_NONE !== json_last_error()) {
                throw new RuntimeException(sprintf('Invalid JSON in env var "%s": ', $name).json_last_error_msg());
            }

/** * @return void */
    protected function registerFunctions()
    {
        $this->addFunction(ExpressionFunction::fromPhp('constant'));

        $this->addFunction(new ExpressionFunction('enum',
            static fn ($str): string => sprintf("(\constant(\$v = (%s))) instanceof \UnitEnum ? \constant(\$v) : throw new \TypeError(\sprintf('The string \"%%s\" is not the name of a valid enum case.', \$v))", $str),
            static function D$arguments, $str): \UnitEnum {
                $value = \constant($str);

                if (!$value instanceof \UnitEnum) {
                    throw new \TypeError(sprintf('The string "%s" is not the name of a valid enum case.', $str));
                }

                return $value;
            }
        ));
    }

    private function getLexer(): Lexer
    {

return substr($identifier, 0, $this->getClassConstantPositionInIdentifier($identifier));
        }

        if ($this->identifierEndsWithClassConstant($identifier) && $this->identifierStartsWithBackslash($identifier)) {
            return substr($identifier, 1, $this->getClassConstantPositionInIdentifier($identifier) - 1);
        }

        if (! defined($identifier)) {
            throw AnnotationException::semanticalErrorConstants($identifier, $this->context);
        }

        return constant($identifier);
    }

    private function identifierStartsWithBackslash(string $identifier): bool
    {
        return $identifier[0] === '\\';
    }

    private function identifierEndsWithClassConstant(string $identifier): bool
    {
        return $this->getClassConstantPositionInIdentifier($identifier) === strlen($identifier) - strlen('::class');
    }

    private function phpize(string $value): mixed
    {
        // trim on the right as comments removal keep whitespaces         if ($value !== $v = rtrim($value)) {
            $value = '""' === substr_replace($v, '', 1, -1) ? substr($v, 1, -1) : $v;
        }
        $lowercaseValue = strtolower($value);

        return match (true) {
            \defined($value) => \constant($value),
            'yes' === $lowercaseValue,
            'on' === $lowercaseValue => true,
            'no' === $lowercaseValue,
            'off' === $lowercaseValue,
            'none' === $lowercaseValue => false,
            isset($value[1]) && (
                ("'" === $value[0] && "'" === $value[\strlen($value) - 1])
                || ('"' === $value[0] && '"' === $value[\strlen($value) - 1])
            ) => substr($value, 1, -1), // quoted string             default => XmlUtils::phpize($value),
        };
    }

if ('class' === $constant) {
            return \get_class($object);
        }

        $constant = \get_class($object).'::'.$constant;
    }

    if (!\defined($constant)) {
        throw new RuntimeError(sprintf('Constant "%s" is undefined.', $constant));
    }

    return \constant($constant);
}

/** * Checks if a constant exists. * * @param string $constant The name of the constant * @param object|null $object The object to get the constant from * * @return bool */
function twig_constant_is_defined($constant, $object = null)
{

$attr = [];
        $errmode = $c->getAttribute(\PDO::ATTR_ERRMODE);
        $c->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);

        foreach (self::PDO_ATTRIBUTES as $k => $v) {
            if (!isset($k[0])) {
                $k = $v;
                $v = [];
            }

            try {
                $attr[$k] = 'ERRMODE' === $k ? $errmode : $c->getAttribute(\constant('PDO::ATTR_'.$k));
                if ($v && isset($v[$attr[$k]])) {
                    $attr[$k] = new ConstStub($v[$attr[$k]], $attr[$k]);
                }
            } catch (\Exception) {
            }
        }
        if (isset($attr[$k = 'STATEMENT_CLASS'][1])) {
            if ($attr[$k][1]) {
                $attr[$k][1] = new ArgsStub($attr[$k][1], '__construct', $attr[$k][0]);
            }
            $attr[$k][0] = new ClassStub($attr[$k][0]);
        }

/** * Replace any constants referenced in a string with their values * * @param string $value * @return string */
    protected static function _replaceConstants($value)
    {
        foreach (self::_getConstants() as $constant) {
            if (strstr($value, $constant)) {
                $value = str_replace($constant, constant($constant), $value);
            }
        }
        return $value;
    }

    /** * Get (reverse) sorted list of defined constant names * * @return array */
    protected static function _getConstants()
    {

            $duplicated_keys[ __( 'put your unique phrase here' ) ] = true;

            foreach ( array( 'AUTH', 'SECURE_AUTH', 'LOGGED_IN', 'NONCE', 'SECRET' ) as $first ) {
                foreach ( array( 'KEY', 'SALT' ) as $second ) {
                    if ( ! defined( "{$first}_{$second}" ) ) {
                        continue;
                    }
                    $value                     = constant( "{$first}_{$second}" );
                    $duplicated_keys[ $value ] = isset( $duplicated_keys[ $value ] );
                }
            }
        }

        $values = array(
            'key'  => '',
            'salt' => '',
        );
        if ( defined( 'SECRET_KEY' ) && SECRET_KEY && empty( $duplicated_keys[ SECRET_KEY ] ) ) {
            $values['key'] = SECRET_KEY;
        }

// checks if identifier ends with ::class, \strlen('::class') === 7         $classPos = stripos($identifier, '::class');
        if ($classPos === strlen($identifier) - 7) {
            return substr($identifier, 0, $classPos);
        }

        if (!defined($identifier)) {
            throw AnnotationException::semanticalErrorConstants($identifier, $this->context);
        }

        return constant($identifier);
    }

    /** * Identifier ::= string * * @return string */
    private function Identifier()
    {
        // check if we have an annotation         if ( ! $this->lexer->isNextTokenAny(self::$classIdentifiers)) {