strcmp - PHP code example

The php Function Strcmp and Its Uses

The php function strcmp is an inbuilt function, which is used to compare two strings. It is a binary safe and case sensitive function that returns an integer value based on the comparison of two strings.

String comparison is one of the most common operations when working with data in PHP. It’s important to understand how this functions works and its uses in order to develop more efficient applications. This article will discuss the strcmp() and strcasecmp() functions and their use cases in PHP to help you improve your string manipulation skills.

The strcmp() function compares the upper and lower case versions of two strings and returns an integer value based on their comparison. The function takes the first string, $str1 and the second string, $str2 as its parameters. Both of these strings must be in the upper and lower case respectively. The function will return a negative integer value, if the first string is less than the second string, or a positive integer value, if the first string is greater than the second string.

There are many reasons to use the php function strcmp, but one of the most popular uses is for sorting arrays of strings in a case sensitive manner. Another common use is for filtering an array based on a prefix of a string. This is commonly done using the array_filter() function, which will check for any strings starting with the specified prefix. This is often referred to as a pregmatch operation and is useful for testing passwords against brute force attacks.

strcmp example

    private static function sort_start_ascending( $a, $b ) {
        $by_start = $a->start - $b->start;
        if ( 0 !== $by_start ) {
            return $by_start;
        }

        $by_text = isset( $a->text, $b->text ) ? strcmp( $a->text, $b->text ) : 0;
        if ( 0 !== $by_text ) {
            return $by_text;
        }

        /* * This code should be unreachable, because it implies the two replacements * start at the same location and contain the same text. */
        return $a->end - $b->end;
    }

        $countryIsos = array_map(fn ($country) => [
            'iso3' => $country['iso3'],
            'default' => $country['iso'] === $localeIsoCode,
            'translated' => $this->translator->trans('shopware.installer.select_country_' . mb_strtolower((string) $country['iso3'])),
        ], $countries);

        usort(/** * sorting country by translated * * @param array<string, string> $first * @param array<string, string> $second */ $countryIsos, fn (array $first, array $second) => strcmp((string) $first['translated'], (string) $second['translated']));

        return $countryIsos;
    }
}

return -1;
                }

                if ($a['tax_rate'] < $b['tax_rate']) {
                    return 1;
                }

                if ($a['tax_rate'] > $b['tax_rate']) {
                    return -1;
                }

                return strcmp($a['ordernumber'], $b['ordernumber']);
            }
        );

        return array_values($items);
    }
}

$collection->add($row['name'], unserialize($row['route']));
    }

    return $collection;
  }

  /** * Comparison function for usort on routes. */
  protected function routeProviderRouteCompare(array $a, array $b) {
    if ($a['fit'] == $b['fit']) {
      return strcmp($a['name'], $b['name']);
    }
    // Reverse sort from highest to lowest fit. PHP should cast to int, but     // the explicit cast makes this sort more robust against unexpected input.     return (int) $b['fit'] <=> (int) $a['fit'];
  }

  /** * {@inheritdoc} */
  public function getAllRoutes() {
    $select = $this->connection->select($this->tableName, 'router')

  public static function compare(Link $a, Link $b) {
    // Any string concatenation would work, but a Link header-like format makes     // it clear what is being compared.     $a_string = sprintf('<%s>;rel="%s"', $a->getHref(), $a->rel);
    $b_string = sprintf('<%s>;rel="%s"', $b->getHref(), $b->rel);
    $cmp = strcmp($a_string, $b_string);
    // If the `href` or `rel` of the links are not equivalent, it's not     // necessary to compare target attributes.     if ($cmp === 0) {
      return (int) !empty(DiffArray::diffAssocRecursive($a->getTargetAttributes(), $b->getTargetAttributes()));
    }
    return $cmp;
  }

  /** * Merges two equivalent links into one link with the merged cacheability. * * The links must share the same URI, link relation type and attributes. * * @param \Drupal\jsonapi\JsonApiResource\Link $a * The first link. * @param \Drupal\jsonapi\JsonApiResource\Link $b * The second link. * * @return static * A new JSON:API Link object with the cacheability of both links merged. */

return $element;
  }

  /** * Validates a password_confirm element. */
  public static function validatePasswordConfirm(&$element, FormStateInterface $form_state, &$complete_form) {
    $pass1 = trim($element['pass1']['#value']);
    $pass2 = trim($element['pass2']['#value']);
    if (strlen($pass1) > 0 || strlen($pass2) > 0) {
      if (strcmp($pass1, $pass2)) {
        $form_state->setError($element, t('The specified passwords do not match.'));
      }
    }
    elseif ($element['#required'] && $form_state->getUserInput()) {
      $form_state->setError($element, t('Password field is required.'));
    }

    // Password field must be converted from a two-element array into a single     // string regardless of validation results.     $form_state->setValueForElement($element['pass1'], NULL);
    $form_state->setValueForElement($element['pass2'], NULL);

    public function __construct(\Traversable $iterator, int|callable $sort, bool $reverseOrder = false)
    {
        $this->iterator = $iterator;
        $order = $reverseOrder ? -1 : 1;

        if (self::SORT_BY_NAME === $sort) {
            $this->sort = static fn (\SplFileInfo $a, \SplFileInfo $b) => $order * strcmp($a->getRealPath() ?: $a->getPathname(), $b->getRealPath() ?: $b->getPathname());
        } elseif (self::SORT_BY_NAME_NATURAL === $sort) {
            $this->sort = static fn (\SplFileInfo $a, \SplFileInfo $b) => $order * strnatcmp($a->getRealPath() ?: $a->getPathname(), $b->getRealPath() ?: $b->getPathname());
        } elseif (self::SORT_BY_NAME_CASE_INSENSITIVE === $sort) {
            $this->sort = static fn (\SplFileInfo $a, \SplFileInfo $b) => $order * strcasecmp($a->getRealPath() ?: $a->getPathname(), $b->getRealPath() ?: $b->getPathname());
        } elseif (self::SORT_BY_NAME_NATURAL_CASE_INSENSITIVE === $sort) {
            $this->sort = static fn (\SplFileInfo $a, \SplFileInfo $b) => $order * strnatcasecmp($a->getRealPath() ?: $a->getPathname(), $b->getRealPath() ?: $b->getPathname());
        } elseif (self::SORT_BY_TYPE === $sort) {
            $this->sort = static function D\SplFileInfo $a, \SplFileInfo $b) use ($order) {
                if ($a->isDir() && $b->isFile()) {
                    return -$order;
                } elseif ($a->isFile() && $b->isDir()) {

    /** * @return void */
    protected function listBundles(OutputInterface|StyleInterface $output)
    {
        $title = 'Available registered bundles with their extension alias if available';
        $headers = ['Bundle name', 'Extension alias'];
        $rows = [];

        $bundles = $this->getApplication()->getKernel()->getBundles();
        usort($bundles, fn ($bundleA, $bundleB) => strcmp($bundleA->getName(), $bundleB->getName()));

        foreach ($bundles as $bundle) {
            $extension = $bundle->getContainerExtension();
            $rows[] = [$bundle->getName(), $extension ? $extension->getAlias() : ''];
        }

        if ($output instanceof StyleInterface) {
            $output->title($title);
            $output->table($headers, $rows);
        } else {
            $output->writeln($title);

$cronSecureByAccount = $this->Config()->get('cronSecureByAccount');

        // No security policy specified, accept all requests         if (empty($cronSecureAllowedKey) && empty($cronSecureAllowedIp) && !$cronSecureByAccount) {
            return true;
        }

        // Validate key         if (!empty($cronSecureAllowedKey)) {
            $urlKey = $request->getParam('key');

            if (strcmp($cronSecureAllowedKey, $urlKey) == 0) {
                return true;
            }
        }

        // Validate ip         if (!empty($cronSecureAllowedIp)) {
            $requestIp = $request->getServer('REMOTE_ADDR');

            if (\in_array($requestIp, explode(';', $cronSecureAllowedIp))) {
                return true;
            }
        }

    public function updateSnippetAction()
    {
        $snippets = $this->Request()->getParam('snippets', []);

        // Batch mode         if (!empty($snippets)) {
            foreach ($snippets as $snippet) {
                /** @var Snippet $snippetModel */
                $snippetModel = $this->get('models')->getRepository(Snippet::class)->find($snippet['id']);
                $dirty = $snippetModel->getDirty() || strcmp($snippetModel->getValue(), $snippet['value']) != 0;
                $snippetModel->setDirty($dirty);
                $snippetModel->setValue($snippet['value']);

                if (!$this->isSnippetValid($snippetModel)) {
                    $this->get('models')->remove($snippetModel);
                    continue;
                }
            }
            $this->get('models')->flush();
            $this->View()->assign(['success' => true]);

/** * Sorts a collection of resources or resource identifiers. * * This is useful for asserting collections or resources where order cannot * be known in advance. * * @param array $resources * The resource or resource identifier. */
  protected static function sortResourceCollection(array &$resources) {
    usort($resources, function D$a, $b) {
      return strcmp("{$a['type']}:{$a['id']}", "{$b['type']}:{$b['id']}");
    });
  }

  /** * Determines if a given resource exists in a list of resources. * * @param array $needle * The resource or resource identifier. * @param array $haystack * The list of resources or resource identifiers to search. * * @return bool * TRUE if the needle exists is present in the haystack, FALSE otherwise. */

  public static function strcasecmp($str1, $str2) {
    return strcmp(mb_strtoupper($str1), mb_strtoupper($str2));
  }

  /** * Checks whether a string is valid UTF-8. * * All functions designed to filter input should use drupal_validate_utf8 * to ensure they operate on valid UTF-8 strings to prevent bypass of the * filter. * * When text containing an invalid UTF-8 lead byte (0xC0 - 0xFF) is presented * as UTF-8 to Internet Explorer 6, the program may misinterpret subsequent * bytes. When these subsequent bytes are HTML control characters such as * quotes or angle brackets, parts of the text that were deemed safe by filters * end up in locations that are potentially unsafe; An onerror attribute that * is outside of a tag, and thus deemed safe by a filter, can be interpreted * by the browser as if it were inside the tag. * * The function does not return FALSE for strings containing character codes * above U+10FFFF, even though these are prohibited by RFC 3629. * * @param string $text * The text to check. * * @return bool * TRUE if the text is valid UTF-8, FALSE if not. */

  public static function compare(ResourceIdentifier $a, ResourceIdentifier $b) {
    $result = strcmp(sprintf('%s:%s', $a->getTypeName(), $a->getId()), sprintf('%s:%s', $b->getTypeName(), $b->getId()));
    // If type and ID do not match, return their ordering.     if ($result !== 0) {
      return $result;
    }
    // If both $a and $b have an arity, then return the order by arity.     // Otherwise, they are considered equal.     return $a->hasArity() && $b->hasArity()
      ? $a->getArity() - $b->getArity()
      : 0;
  }

function _usort_terms_by_name( $a, $b ) {
_deprecated_function( __FUNCTION__, '4.7.0', 'wp_list_sort()' );

return strcmp( $a->name, $b->name );
}

/** * Sort menu items by the desired key. * * @since 3.0.0 * @deprecated 4.7.0 Use wp_list_sort() * @access private * * @global string $_menu_item_sort_prop * * @param object $a The first object to compare * @param object $b The second object to compare * @return int -1, 0, or 1 if $a is considered to be respectively less than, equal to, or greater than $b. */

'-',
                    ' ',
                    str_replace(
                        '_',
                        ' ',
                        $mappedKey
                    )
                )
            )
        );

        if (isset($mappedKeyParts[0]) && strcmp($mappedKeyParts[0], $mappedKey) !== 0) {
            $associationField = $definition->getField($mappedKeyParts[0]);

            if ($associationField !== null && $associationField instanceof ManyToOneAssociationField) {
                $fullKey = implode(' ', $mappedKeyParts);
                array_shift($mappedKeyParts);
                $leftoverKey = implode(' ', $mappedKeyParts);

                $associationDefinition = $associationField->getReferenceDefinition();

                // try full key first (something like 'tax_rate' which is a field of the tax entity).                 $associationGuess = $this->guessKeyFromMappedKey($keyLookupTable, $fullKey, $associationDefinition, $depthLimit - 1);