PHP Function Strev - How to Reverse a String

PHP has many built-in string functions which can be used to manipulate strings. These function can either reverse the string or modify it to create another string. These functions are very useful in various cases where it is required to do string manipulation. Among the most popular string functions are strlen(string) and str_word_count(). These function can be used to validate input fields and determine the number of words in a string.

The php function strrev can be used to reverse the string. This function works in a similar manner to the strlen(string) function. It returns the original string reversed. The following program demonstrates the usage of this function.

In order to reverse the string, an array of string is created and then each index value is called backwards to print the reversed string. This loop is then repeated. This process is repeated until the original string is completely reversed.

The php strrev function is one of the most important and useful string functions in PHP. This function can be used to reverse any string, regardless of its length or characters. The strrev function is also very simple to use, and you can easily learn the basics of this function. This article will explore a few examples of how the php strrev function is used, as well as some tips on using this function in your own code.

Andreas Behr - CTO of DesertCoderz
You are a developer and looking for Shopware projects?
Apply Now!

strrev example

class LastLetterBigTwigFilter extends AbstractExtension
{
    public function getFilters(): array
    {
        return [
            new TwigFilter('lastBigLetter', $this->convert(...)),
        ];
    }

    public function convert(string $text): string
    {
        return strrev(ucfirst(strrev($text)));
    }
}


        $str = clone $this;
        $str->string = $string;

        return $str;
    }

    public function reverse(): static
    {
        $str = clone $this;
        $str->string = strrev($str->string);

        return $str;
    }

    public function slice(int $start = 0, int $length = null): static
    {
        $str = clone $this;
        $str->string = (string) substr($this->string, $start, $length ?? \PHP_INT_MAX);

        return $str;
    }

    


        // Last Page - Number of Samples         if (!getid3_lib::intValueSupported($info['avdataend'])) {

            $this->warning('Unable to parse Ogg end chunk file (PHP does not support file operations beyond '.round(PHP_INT_MAX / 1073741824).'GB)');

        } else {

            $this->fseek(max($info['avdataend'] - $this->getid3->fread_buffer_size(), 0));
            $LastChunkOfOgg = strrev($this->fread($this->getid3->fread_buffer_size()));
            if ($LastOggSpostion = strpos($LastChunkOfOgg, 'SggO')) {
                $this->fseek($info['avdataend'] - ($LastOggSpostion + strlen('SggO')));
                $info['avdataend'] = $this->ftell();
                $info['ogg']['pageheader']['eos'] = $this->ParseOggPageHeader();
                $info['ogg']['samples']   = $info['ogg']['pageheader']['eos']['pcm_abs_position'];
                if ($info['ogg']['samples'] == 0) {
                    $this->error('Corrupt Ogg file: eos.number of samples == zero');
                    return false;
                }
                if (!empty($info['audio']['sample_rate'])) {
                    $info['ogg']['bitrate_average'] = (($info['avdataend'] - $info['avdataoffset']) * 8) / ($info['ogg']['samples'] / $info['audio']['sample_rate']);
                }
        'seires',

        // sheep         'peehs',

        // species         'seiceps',
    ];

    public function singularize(string $plural): array
    {
        $pluralRev = strrev($plural);
        $lowerPluralRev = strtolower($pluralRev);
        $pluralLength = \strlen($lowerPluralRev);

        // Check if the word is one which is not inflected, return early if so         if (\in_array($lowerPluralRev, self::UNINFLECTED, true)) {
            return [$plural];
        }

        // The outer loop iterates over the entries of the plural table         // The inner loop $j iterates over the characters of the plural suffix         // in the plural table to compare them with the characters of the actual
$fractionbitstring = str_pad(substr($normalizedbinary['normalized'], 2), $fractionbits, '0', STR_PAD_RIGHT);

        return self::BigEndian2String(self::Bin2Dec($signbit.$exponentbitstring.$fractionbitstring), $bits % 8, false);
    }

    /** * @param string $byteword * * @return float|false */
    public static function LittleEndian2Float($byteword) {
        return self::BigEndian2Float(strrev($byteword));
    }

    /** * ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic * * @link https://web.archive.org/web/20120325162206/http://www.psc.edu/general/software/packages/ieee/ieee.php * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html * * @param string $byteword * * @return float|false */
$lyrics3offset  = $info['filesize'] - 128 - $lyrics3size;
            $lyrics3version = 1;

        } elseif ($lyrics3end == 'LYRICS200') {
            // Lyrics3v2, ID3v1, no APE
            // LSZ = lyrics + 'LYRICSBEGIN'; add 6-byte size field; add 'LYRICS200'             $lyrics3size    = $lyrics3lsz + 6 + strlen('LYRICS200');
            $lyrics3offset  = $info['filesize'] - 128 - $lyrics3size;
            $lyrics3version = 2;

        } elseif (substr(strrev($lyrics3_id3v1), 0, 9) == strrev('LYRICSEND')) {
            // Lyrics3v1, no ID3v1, no APE
            $lyrics3size    = 5100;
            $lyrics3offset  = $info['filesize'] - $lyrics3size;
            $lyrics3version = 1;
            $lyrics3offset  = $info['filesize'] - $lyrics3size;

        } elseif (substr(strrev($lyrics3_id3v1), 0, 9) == strrev('LYRICS200')) {

            // Lyrics3v2, no ID3v1, no APE
            


        // decode header         $fhBS = '';
        for ($word_offset = 0; $word_offset <= strlen($DTSheader); $word_offset += 2) {
            switch ($encoding) {
                case 0: // raw big-endian                     $fhBS .=        getid3_lib::BigEndian2Bin(       substr($DTSheader, $word_offset, 2) );
                    break;
                case 1: // raw little-endian                     $fhBS .=        getid3_lib::BigEndian2Bin(strrev(substr($DTSheader, $word_offset, 2)));
                    break;
                case 2: // 14-bit big-endian                     $fhBS .= substr(getid3_lib::BigEndian2Bin(       substr($DTSheader, $word_offset, 2) ), 2, 14);
                    break;
                case 3: // 14-bit little-endian                     $fhBS .= substr(getid3_lib::BigEndian2Bin(strrev(substr($DTSheader, $word_offset, 2))), 2, 14);
                    break;
            }
        }

        $info['dts']['raw']['frame_type']             =        $this->readBinData($fhBS,  1);
        
$this->assertFalse($entity->hasTranslation($langcode));
    $this->assertTrue($cloned->hasTranslation($langcode));

    // Check that untranslatable field references keep working after serializing     // and cloning the entity.     $entity = $this->reloadEntity($entity);
    $type = $this->randomMachineName();
    $entity->getTranslation($langcode)->type->value = $type;
    $entity = unserialize(serialize($entity));
    $cloned = clone $entity;
    $translation = $cloned->getTranslation($langcode);
    $translation->type->value = strrev($type);
    $this->assertEquals($cloned->type->value, $translation->type->value, 'Untranslatable field references keep working after serializing and cloning the entity.');

    // Check that per-language defaults are properly populated. The     // 'entity_test_mul_default_value' entity type is translatable and uses     // entity_test_field_default_value() as a "default value callback" for its     // 'description' field.     $entity = $this->entityTypeManager
      ->getStorage('entity_test_mul_default_value')
      ->create(['name' => $this->randomMachineName(), 'langcode' => $langcode]);
    $translation = $entity->addTranslation($langcode2);
    $expected = [
      [


        $str = clone $this;
        $str->string = $string;

        return $str;
    }

    public function reverse(): static
    {
        $str = clone $this;
        $str->string = strrev($str->string);

        return $str;
    }

    public function slice(int $start = 0, int $length = null): static
    {
        $str = clone $this;
        $str->string = (string) substr($this->string, $start, $length ?? \PHP_INT_MAX);

        return $str;
    }

    
/** * Generates the arrays for CompiledUrlMatcher's constructor. */
    public function getCompiledRoutes(bool $forDump = false): array
    {
        // Group hosts by same-suffix, re-order when possible         $matchHost = false;
        $routes = new StaticPrefixCollection();
        foreach ($this->getRoutes()->all() as $name => $route) {
            if ($host = $route->getHost()) {
                $matchHost = true;
                $host = '/'.strtr(strrev($host), '}.{', '(/)');
            }

            $routes->addRoute($host ?: '/(.*)', [$name, $route]);
        }

        if ($matchHost) {
            $compiledRoutes = [true];
            $routes = $routes->populateCollection(new RouteCollection());
        } else {
            $compiledRoutes = [false];
            $routes = $this->getRoutes();
        }
if (!\str_starts_with($reflection->getName(), 'Shopware\\Core\\')) {
            return [];
        }
        $parts = \explode('\\', $reflection->getName());

        $expected = \sprintf('Shopware\\Core\\%s\\%s\\%sException', $parts[2], $parts[3], $parts[3]);

        if ($exceptionClass !== $expected && !$exception->isSubclassOf($expected)) {
            // Is it in a subdomain?             if (isset($parts[5]) && \in_array($parts[4], self::VALID_SUB_DOMAINS, true)) {
                $expectedSub = \sprintf('\\%s\\%sException', $parts[4], $parts[4]);
                if (\str_starts_with(strrev($exceptionClass), strrev($expectedSub))) {
                    return [];
                }
            }

            return [
                RuleErrorBuilder::message(\sprintf('Expected domain exception class %s, got %s', $expected, $exceptionClass))->build(),
            ];
        }

        return [];
    }
}
/** * @param array|object $args * * @return array|object */
    private function maskData($args, array $keysToMask, string $path = '')
    {
        foreach ($keysToMask as $keyToMask) {
            $explode = explode('/', $keyToMask);
            $index   = end($explode);

            if (strpos(strrev($path . '/' . $index), strrev($keyToMask)) === 0) {
                if (is_array($args) && array_key_exists($index, $args)) {
                    $args[$index] = '******************';
                } elseif (
                    is_object($args) && property_exists($args, $index)
                    && isset($args->{$index}) && is_scalar($args->{$index})
                ) {
                    $args->{$index} = '******************';
                }
            }
        }

        
$steps = 2;
            for ($i = 1; $i <= $length - 2; $i += $steps) {
                for ($i2 = 1; $i2 <= $slopSize; ++$i2) {
                    $placeholder = '';
                    for ($i3 = 1; $i3 <= $slopSize + 1; ++$i3) {
                        $slops['normal'][] = mb_substr($token, 0, $i) . $placeholder . mb_substr($token, $i + $i2) . '%';
                        $placeholder .= '_';
                    }
                }
            }
            $tokenRev = strrev($token);
            for ($i = 1; $i <= $length - 2; $i += $steps) {
                for ($i2 = 1; $i2 <= $slopSize; ++$i2) {
                    $placeholder = '';
                    for ($i3 = 1; $i3 <= $slopSize + 1; ++$i3) {
                        $slops['reversed'][] = mb_substr($tokenRev, 0, $i) . $placeholder . mb_substr($tokenRev, $i + $i2) . '%';
                        $placeholder .= '_';
                    }
                }
            }
            $tokenSlops[$token] = $slops;
        }

        

    private function maskData($args, array $keysToMask, string $path = '')
    {
        foreach ($keysToMask as $keyToMask) {
            $explode = explode('/', $keyToMask);
            $index   = end($explode);

            if (strpos(strrev($path . '/' . $index), strrev($keyToMask)) === 0) {
                if (is_array($args) && array_key_exists($index, $args)) {
                    $args[$index] = '******************';
                } elseif (
                    is_object($args) && property_exists($args, $index)
                    && isset($args->{$index}) && is_scalar($args->{$index})
                ) {
                    $args->{$index} = '******************';
                }
            }
        }

        
return false;
            }

            // Advance the pointer after the above             $this->position += 4;

            // MTIME             $mtime = substr($this->compressed_data, $this->position, 4);
            // Reverse the string if we're on a big-endian arch because l is the only signed long and is machine endianness             if (current(unpack('S', "\x00\x01")) === 1)
            {
                $mtime = strrev($mtime);
            }
            $this->MTIME = current(unpack('l', $mtime));
            $this->position += 4;

            // Get the XFL (eXtra FLags)             $this->XFL = ord($this->compressed_data[$this->position++]);

            // Get the OS (Operating System)             $this->OS = ord($this->compressed_data[$this->position++]);

            // Parse the FEXTRA
Home | Imprint | This part of the site doesn't use cookies.