rtrim - PHP code example

The php Function Rtrim

The php function rtrim is a powerful string manipulation and sanitization tool that eliminates whitespaces and pre-defined characters from both sides of the string. It is widely used in scenarios such as data validation, input sanitization, and formatting output. It also helps in ensuring the integrity and consistency of strings and improves string comparisons.

The trim() function has been around since PHP 4. It is an essential tool for manipulating and sanitizing strings in various ways such as trimming form input, formatting output, and more. It is a highly reliable function and it continues to get various performance optimizations with each new release of PHP.

In addition to its standard function, the trim() function has an optional second parameter that lets developers customize its behavior and remove specific characters or character sets from both sides of a string. This customization allows developers to customize the behavior of trim() to meet their unique needs.

To use rtrim(), you must first specify the string that you want to trim. Then, you must provide the list of characters that you want to strip from the end of the string. The rtrim() function will return the modified version of the string if the trimming is successful. Otherwise, it will return the original string.

rtrim example

$headers = [
      'Content-Type' => ['text/html'],
    ];
    $body = Json::encode([
      'version' => '1.0',
      'type' => 'video',
      'html' => 'test',
    ]);
    $valid_response = new Response(200, $headers, $body);
    // Strip off the trailing '}' to produce a response that will cause a JSON     // parse error.     $invalid_response = new Response(200, $headers, rtrim($body, '}'));
    // A response that is valid JSON, but does not decode to an array, should     // produce an exception as well.     $non_array_response = new Response(200, $headers, '"Valid JSON, but not an array..."');

    $mock_handler = new MockHandler([
      $valid_response,
      $invalid_response,
      $non_array_response,
    ]);
    $client = new Client([
      'handler' => HandlerStack::create($mock_handler),
    ]);

        }

        // Unsets default rows and cols if defined in extra field as array or string.         if ((is_array($extra) && array_key_exists('rows', $extra)) || (is_string($extra) && stripos(preg_replace('/\s+/', '', $extra), 'rows=') !== false)) {
            unset($defaults['rows']);
        }

        if ((is_array($extra) && array_key_exists('cols', $extra)) || (is_string($extra) && stripos(preg_replace('/\s+/', '', $extra), 'cols=') !== false)) {
            unset($defaults['cols']);
        }

        return '<textarea ' . rtrim(parse_form_attributes($data, $defaults)) . stringify_attributes($extra) . '>'
                . htmlspecialchars($val)
                . "</textarea>\n";
    }
}

if (! function_exists('form_multiselect')) {
    /** * Multi-select menu * * @param array|string $name * @param array|object|string $extra string, array, object that can be cast to array */

/** * @var array */
    private $files;

    /** * @param string $basePath * @param string $sourceFile */
    public function __construct($basePath, $sourceFile)
    {
        $this->basePath = rtrim($basePath, '/') . '/';
        $this->sourceFile = $sourceFile;

        $this->files = $this->readList($sourceFile);
    }

    public function addFile($file)
    {
        $this->files[] = $file;
    }

    /** * @return RequirementsPathResult */

$class   = ltrim(preg_replace($pattern, '', $classname), '\\');

        $classParts = explode('\\', $class);
        $classPath  = '';

        foreach ($classParts as $part) {
            // make the first letter lowercase, because auto routing makes             // the URI path's first letter uppercase and search the controller             $classPath .= lcfirst($part) . '/';
        }

        return rtrim($classPath, '/');
    }

    /** * Gets a route for the default controller. * * @phpstan-return list<array> */
    private function getRouteForDefaultController(
        string $classShortname,
        string $defaultController,
        string $uriByClass,

        $str = str_replace("\n\n", "</p>\n\n<p>", $str);

        // Convert single spaces to <br> tags         $br  = '<br' . _solidus() . '>';
        $str = preg_replace("/([^\n])(\n)([^\n])/", '\\1' . $br . '\\2\\3', $str);

        // Wrap the whole enchilada in enclosing paragraphs         if ($str !== "\n") {
            // We trim off the right-side new line so that the closing </p> tag             // will be positioned immediately following the string, matching             // the behavior of the opening <p> tag             $str = '<p>' . rtrim($str) . '</p>';
        }

        // Remove empty paragraphs if they are on the first line, as this         // is a potential unintended consequence of the previous code         return preg_replace('/<p><\/p>(.*)/', '\\1', $str, 1);
    }

    /** * Protect Characters * * Protects special characters from being formatted later * We don't want quotes converted within tags so we'll temporarily convert them to {@DQ} and {@SQ} * and we don't want double dashes converted to emdash entities, so they are marked with {@DD} * likewise double spaces are converted to {@NBS} to prevent entity conversion */

foreach ( $qs as $k => $v ) {
        if ( false === $v ) {
            unset( $qs[ $k ] );
        }
    }

    $ret = build_query( $qs );
    $ret = trim( $ret, '?' );
    $ret = preg_replace( '#=(&|$)#', '$1', $ret );
    $ret = $protocol . $base . $ret . $frag;
    $ret = rtrim( $ret, '?' );
    $ret = str_replace( '?#', '#', $ret );
    return $ret;
}

/** * Removes an item or items from a query string. * * Important: The return value of remove_query_arg() is not escaped by default. Output should be * late-escaped with esc_url() or similar to help prevent vulnerability to cross-site scripting * (XSS) attacks. * * @since 1.5.0 * * @param string|string[] $key Query key or keys to remove. * @param false|string $query Optional. When false uses the current URL. Default false. * @return string New URL query string. */

$go=true;
        do {
            $tmp=@fgets($this->_ftp_control_sock, 512);
            if($tmp===false) {
                $go=$result=false;
                $this->PushError($fnction,'Read failed');
            } else {
                $this->_message.=$tmp;
                if(preg_match("/^([0-9]{3})(-(.*[".CRLF."]{1,2})+\\1)? [^".CRLF."]+[".CRLF."]{1,2}$/", $this->_message, $regs)) $go=false;
            }
        } while($go);
        if($this->LocalEcho) echo "GET < ".rtrim($this->_message, CRLF).CRLF;
        $this->_code=(int)$regs[1];
        return $result;
    }

    function _exec($cmd, $fnction="_exec") {
        if(!$this->_ready) {
            $this->PushError($fnction,'Connect first');
            return FALSE;
        }
        if($this->LocalEcho) echo "PUT > ",$cmd,CRLF;
        $status=@fputs($this->_ftp_control_sock, $cmd.CRLF);

/** * @dataProvider provideFailingSerialization */
    public function testFailingSerialization($value)
    {
        $this->expectException(NotInstantiableTypeException::class);
        $this->expectExceptionMessageMatches('/Type ".*" is not instantiable\./');
        $expectedDump = $this->getDump($value);
        try {
            VarExporter::export($value);
        } finally {
            $this->assertDumpEquals(rtrim($expectedDump), $value);
        }
    }

    public static function provideFailingSerialization()
    {
        yield [hash_init('md5')];
        yield [new \ReflectionClass(\stdClass::class)];
        yield [(new \ReflectionFunction(function D): int {}))->getReturnType()];
        yield [new \ReflectionGenerator((function D) { yield 123; })())];
        yield [function D) {}];
        yield [function D) { yield 123; }];

    public function read()
    {
        // First, read headers only         $response = '';
        $gotStatus = false;

        while (($line = @fgets($this->socket)) !== false) {
            $gotStatus = $gotStatus || (strpos($line, 'HTTP') !== false);
            if ($gotStatus) {
                $response .= $line;
                if (rtrim($line) === '') break;
            }
        }

        $this->_checkSocketReadTimeout();

        $statusCode = Zend_Http_Response::extractCode($response);

        // Handle 100 and 101 responses internally by restarting the read again         if ($statusCode == 100 || $statusCode == 101) return $this->read();

        // Check headers to see what kind of connection / transfer encoding we have

public function __construct(OutputInterface $output, CliDumper $dumper = null, ClonerInterface $cloner = null)
    {
        $this->output = $output;
        $this->dumper = $dumper;
        $this->cloner = $cloner;

        if (class_exists(CliDumper::class)) {
            $this->handler = function D$var): string {
                $dumper = $this->dumper ??= new CliDumper(null, null, CliDumper::DUMP_LIGHT_ARRAY | CliDumper::DUMP_COMMA_SEPARATOR);
                $dumper->setColors($this->output->isDecorated());

                return rtrim($dumper->dump(($this->cloner ??= new VarCloner())->cloneVar($var)->withRefHandles(false), true));
            };
        } else {
            $this->handler = fn ($var): string => match (true) {
                null === $var => 'null',
                true === $var => 'true',
                false === $var => 'false',
                \is_string($var) => '"'.$var.'"',
                default => rtrim(print_r($var, true)),
            };
        }
    }

else {
        $base = $current_base_url;
      }
      if ($collect_bubbleable_metadata) {
        $generated_url->addCacheContexts(['url.site']);
      }
    }
    else {
      $base = $current_base_path;
    }

    $prefix = empty($uri) ? rtrim($options['prefix'], '/') : $options['prefix'];

    $uri = str_replace('%2F', '/', rawurlencode($prefix . $uri));
    $query = $options['query'] ? ('?' . UrlHelper::buildQuery($options['query'])) : '';
    $url = $base . $options['script'] . $uri . $query . $options['fragment'];
    return $collect_bubbleable_metadata ? $generated_url->setGeneratedUrl($url) : $url;
  }

  /** * Merges in default defaults. * * @param array $options * The options to merge in the defaults. */

use Symfony\Component\Asset\VersionStrategy\VersionStrategyInterface;

#[Package('core')] class PrefixVersionStrategy implements VersionStrategyInterface
{
    private readonly string $prefix;

    public function __construct(
        string $prefix,
        private readonly VersionStrategyInterface $strategy
    ) {
        $this->prefix = rtrim($prefix, '/');
    }

    public function getVersion(string $path): string
    {
        return $this->applyVersion($path);
    }

    public function applyVersion(string $path): string
    {
        $prefixLength = \strlen($this->prefix);

        if (isset($_compile_id)) {
            $_compile_id = $_compile_id . $_compile_dir_sep;
        } else {
            $_compile_id = '';
        }
        $_cache_dir = $_template->smarty->getCacheDir();
        if ($_template->smarty->cache_locking) {
            // create locking file name             // relative file name?             if (!preg_match('/^([\/\\\\]|[a-zA-Z]:[\/\\\\])/', $_cache_dir)) {
                $_lock_dir = rtrim(getcwd(), '/\\') . DS . $_cache_dir;
            } else {
                $_lock_dir = $_cache_dir;
            }
            $cached->lock_id = $_lock_dir.sha1($_cache_id.$_compile_id.$_template->source->uid).'.lock';
        }
        $cached->filepath = $_cache_dir . $_cache_id . $_compile_id . $_filepath . '.' . basename($_source_file_path) . '.php';
        $cached->timestamp = @filemtime($cached->filepath);
        $cached->exists = !!$cached->timestamp;
    }

    /** * populate Cached Object with timestamp and exists from Resource * * @param Smarty_Template_Cached $cached cached object * @return void */

if (is_array($params)) {
            $params = (object)$params;
        }

        if (!isset($params->dirname) || !is_dir($params->dirname)) {
            /** * @see Zend_Mail_Storage_Exception */
            throw new Zend_Mail_Storage_Exception('no valid dirname given in params');
        }

        $this->_rootdir = rtrim($params->dirname, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;

        $this->_delim = isset($params->delim) ? $params->delim : '.';

        $this->_buildFolderTree();
        $this->selectFolder(!empty($params->folder) ? $params->folder : 'INBOX');
        $this->_has['top'] = true;
        $this->_has['flags'] = true;
    }

    /** * find all subfolders and mbox files for folder structure * * Result is save in Zend_Mail_Storage_Folder instances with the root in $this->_rootFolder. * $parentFolder and $parentGlobalName are only used internally for recursion. * * @return null * @throws Zend_Mail_Storage_Exception */

// Check if there is a space at the end of the line and rewind             if ($ptr > 0 && $str[$ptr - 1] == ' ') {
                --$ptr;
            }

            // Add string and continue             $out .= substr($str, 0, $ptr) . '=' . $lineEnd;
            $str = substr($str, $ptr);
        }

        $out = rtrim($out, $lineEnd);
        $out = rtrim($out, '=');
        return $out;
    }

    /** * Converts a string into quoted printable format. * * @param string $str * @return string */
    private static function _encodeQuotedPrintable($str)
    {