Fonctions sur les chaînes de caractères

Voir aussi

Pour des fonctions encore plus puissantes de gestion et manipulation des chaînes, reportez-vous aux expressions rationnelles POSIX et expressions rationnelles Perl.

Sommaire

  • addcslashes — Ajoute des slash dans une chaîne, à la mode du langage C
  • addslashes — Ajoute des antislashs dans une chaîne
  • bin2hex — Convertit des données binaires en représentation hexadécimale
  • chop — Alias de rtrim
  • chr — Retourne un caractère à partir de son code ASCII
  • chunk_split — Scinde une chaîne
  • convert_cyr_string — Convertit une chaîne d'un jeu de caractères cyrillique à l'autre
  • convert_uudecode — Décode une chaîne au format uuencode
  • convert_uuencode — Encode une chaîne de caractères en utilisant l'algorithme uuencode
  • count_chars — Retourne des statistiques sur les caractères utilisés dans une chaîne
  • crc32 — Calcule la somme de contrôle CRC32
  • crypt — Hachage à sens unique (indéchiffrable)
  • echo — Affiche une chaîne de caractères
  • explode — Coupe une chaîne en segments
  • fprintf — Écrit une chaîne formatée dans un flux
  • get_html_translation_table — Retourne la table de traduction des entités utilisée par htmlspecialchars et htmlentities
  • hebrev — Convertit un texte logique hébreux en texte visuel
  • hebrevc — Convertit un texte logique hébreux en texte visuel, avec retours à la ligne
  • hex2bin — Convertit une chaîne binaire encodée en hexadécimal
  • html_entity_decode — Convertit toutes les entités HTML en caractères normaux
  • htmlentities — Convertit tous les caractères éligibles en entités HTML
  • htmlspecialchars_decode — Convertit les entités HTML spéciales en caractères
  • htmlspecialchars — Convertit les caractères spéciaux en entités HTML
  • implode — Rassemble les éléments d'un tableau en une chaîne
  • join — Alias de implode
  • lcfirst — Met le premier caractère en minuscule
  • levenshtein — Calcule la distance Levenshtein entre deux chaînes
  • localeconv — Lit la configuration locale
  • ltrim — Supprime les espaces (ou d'autres caractères) de début de chaîne
  • md5_file — Calcule le md5 d'un fichier
  • md5 — Calcule le md5 d'une chaîne
  • metaphone — Calcule la clé metaphone
  • money_format — Met un nombre au format monétaire
  • nl_langinfo — Rassemble des informations sur la langue et la configuration locale
  • nl2br — Insère un retour à la ligne HTML à chaque nouvelle ligne
  • number_format — Formate un nombre pour l'affichage
  • ord — Retourne le code ASCII d'un caractère
  • parse_str — Analyse une requête HTTP
  • print — Affiche une chaîne de caractères
  • printf — Affiche une chaîne de caractères formatée
  • quoted_printable_decode — Convertit une chaîne quoted-printable en chaîne 8 bits
  • quoted_printable_encode — Convertit une chaîne 8 bits en une chaîne quoted-printable
  • quotemeta — Protège les métacaractères
  • rtrim — Supprime les espaces (ou d'autres caractères) de fin de chaîne
  • setlocale — Modifie les informations de localisation
  • sha1_file — Calcule le sha1 d'un fichier
  • sha1 — Calcule le sha1 d'une chaîne de caractères
  • similar_text — Calcule la similarité de deux chaînes
  • soundex — Calcule la clé soundex
  • sprintf — Retourne une chaîne formatée
  • sscanf — Analyse une chaîne à l'aide d'un format
  • str_getcsv — Analyse une chaîne de caractères CSV dans un tableau
  • str_ireplace — Version insensible à la casse de str_replace
  • str_pad — Complète une chaîne jusqu'à une taille donnée
  • str_repeat — Répète une chaîne
  • str_replace — Remplace toutes les occurrences dans une chaîne
  • str_rot13 — Effectue une transformation ROT13
  • str_shuffle — Mélange les caractères d'une chaîne de caractères
  • str_split — Convertit une chaîne de caractères en tableau
  • str_word_count — Compte le nombre de mots utilisés dans une chaîne
  • strcasecmp — Comparaison insensible à la casse de chaînes binaires
  • strchr — Alias de strstr
  • strcmp — Comparaison binaire de chaînes
  • strcoll — Comparaison de chaînes localisées
  • strcspn — Trouve un segment de chaîne ne contenant pas certains caractères
  • strip_tags — Supprime les balises HTML et PHP d'une chaîne
  • stripcslashes — Décode une chaîne encodée avec addcslashes
  • stripos — Recherche la position de la première occurrence dans une chaîne, sans tenir compte de la casse
  • stripslashes — Supprime les antislashs d'une chaîne
  • stristr — Version insensible à la casse de strstr
  • strlen — Calcule la taille d'une chaîne
  • strnatcasecmp — Comparaison de chaînes avec l'algorithme d'"ordre naturel" (insensible à la casse)
  • strnatcmp — Comparaison de chaînes avec l'algorithme d'"ordre naturel"
  • strncasecmp — Compare en binaire des chaînes de caractères
  • strncmp — Comparaison binaire des n premiers caractères
  • strpbrk — Recherche un ensemble de caractères dans une chaîne de caractères
  • strpos — Cherche la position de la première occurrence dans une chaîne
  • strrchr — Trouve la dernière occurrence d'un caractère dans une chaîne
  • strrev — Inverse une chaîne
  • strripos — Cherche la position de la dernière occurrence d'une chaîne contenue dans une autre, de façon insensible à la casse
  • strrpos — Cherche la position de la dernière occurrence d'une sous-chaine dans une chaîne
  • strspn — Trouve la longueur du segment initial d'une chaîne contenant tous les caractères d'un masque donné
  • strstr — Trouve la première occurrence dans une chaîne
  • strtok — Coupe une chaîne en segments
  • strtolower — Renvoie une chaîne en minuscules
  • strtoupper — Renvoie une chaîne en majuscules
  • strtr — Remplace des caractères dans une chaîne
  • substr_compare — Compare deux chaînes depuis un offset jusqu'à une longueur en caractères
  • substr_count — Compte le nombre d'occurrences de segments dans une chaîne
  • substr_replace — Remplace un segment dans une chaîne
  • substr — Retourne un segment de chaîne
  • trim — Supprime les espaces (ou d'autres caractères) en début et fin de chaîne
  • ucfirst — Met le premier caractère en majuscule
  • ucwords — Met en majuscule la première lettre de tous les mots
  • vfprintf — Écrit une chaîne formatée dans un flux
  • vprintf — Affiche une chaîne formatée
  • vsprintf — Retourne une chaîne formatée
  • wordwrap — Effectue la césure d'une chaîne
add a note add a note

User Contributed Notes 24 notes

up
1
kristin at greenapple dot on dot ca
9 years ago
I really searched for a function that would do this as I've seen it in other languages but I couldn't find it here. This is particularily useful when combined with substr() to take the first part of a string up to a certain point.

strnpos() - Find the nth position of needle in haystack.

<?php

   
function strnpos($haystack, $needle, $occurance, $pos = 0) {
       
        for (
$i = 1; $i <= $occurance; $i++) {
           
$pos = strpos($haystack, $needle, $pos) + 1;
        }
        return
$pos - 1;
       
    }

?>

Example: Give me everything up to the fourth occurance of '/'.

<?php

    $haystack
= "/home/username/www/index.php";
   
$needle = "/";
   
   
$root_dir = substr($haystack, 0, strnpos($haystack, $needle, 4));
   
    echo
$root_dir;
   
?>

Returns: /home/username/www

Use this example with the server variable $_SERVER['SCRIPT_NAME'] as the haystack and you can self-discover a document's root directory for the purposes of locating global files automatically!
up
0
admin at fivestarbuy dot com
9 years ago
This example lets you parse an unparsed strings variables. Warning: This could cause security leaks if you allow users to pass $variables through this engine. I recommend only using this for your Content Management System.

<?
$mytime
=time();
$mydog="My Dog Ate My PHP!";

# Your Parsing String:
$s1 = 'Hyphen Variable Preserving: $mytime, and $mydog';
echo
"Before: <br><br>$s1<br><br>";

# Remember, wherever you define this, it will not be defined GLOBAL into the function
# which is why we define it here. Defining it global could lead to security issues.
$vardata=get_defined_vars();

# Parse the string
$s1 = StrParse($s1,$vardata);

echo
"After: <br><br>$s1";

function
StrParse($str,$vardata) {
# Takes a string, or piece of data, that contains PHP Variables

# For example, unparsed variables like:  Test using time: $mytime
# This example shows $mytime, and not the actual variable value.
# The end result shows the actual variable value of $mytime.

# This is useful for building a content management system,
# and directing your variables into your content data,
# where content is stored in a file or database, unparsed.
# Of course this could slow down page loads, but it's a good way
# to parse data from current variables into your loaded new data
# making it compatible.

# Then the variables are replaced with the actual variable..
$getvarkeys=array_keys($vardata);
$ret=$str;
for (
$x=0; $x < count($getvarkeys); $x++) {
   
$myvar=$getvarkeys[$x];
   
#echo "Variable: " . $myvar . " [" . $vardata[$myvar] . "]<br>";
   
$ret=str_replace('$' . $myvar, $vardata[$myvar], $ret);
}
return
$ret;

}

?>
up
0
james dot d dot baker at gmail dot com
9 years ago
<?php
/*
Written By James Baker, May 27th 2005

sentenceCase($string);
    $string: The string to convert to sentence case.

Converts a string into proper sentence case (First letter of each sentance capital, all the others smaller)

Example Usage:
echo sentenceCase("HELLO WORLD!!! THIS IS A CAPITALISED SENTENCE. this isn't.");

Returns:
Hello world!!! This is a capitalised sentence. This isn't.
*/

function sentenceCase($s){
   
$str = strtolower($s);
   
$cap = true;
   
    for(
$x = 0; $x < strlen($str); $x++){
       
$letter = substr($str, $x, 1);
        if(
$letter == "." || $letter == "!" || $letter == "?"){
           
$cap = true;
        }elseif(
$letter != " " && $cap == true){
           
$letter = strtoupper($letter);
           
$cap = false;
        }
       
       
$ret .= $letter;
    }
   
    return
$ret;
}
?>
up
0
andy a t onesandzeros d o t biz
10 years ago
I use these little doo-dads quite a bit. I just thought I'd share them and maybe save someone a little time. No biggy. :)

// returns true if $str begins with $sub
function beginsWith( $str, $sub ) {
    return ( substr( $str, 0, strlen( $sub ) ) == $sub );
}

// return tru if $str ends with $sub
function endsWith( $str, $sub ) {
    return ( substr( $str, strlen( $str ) - strlen( $sub ) ) == $sub );
}

// trims off x chars from the front of a string
// or the matching string in $off is trimmed off
function trimOffFront( $off, $str ) {
    if( is_numeric( $off ) )
        return substr( $str, $off );
    else
        return substr( $str, strlen( $off ) );
}

// trims off x chars from the end of a string
// or the matching string in $off is trimmed off
function trimOffEnd( $off, $str ) {
    if( is_numeric( $off ) )
        return substr( $str, 0, strlen( $str ) - $off );
    else
        return substr( $str, 0, strlen( $str ) - strlen( $off ) );
}
up
0
[tab!]
10 years ago
//
// string strtrmvistl(  string str, [int maxlen = 64],
//                      [bool right_justify = false],
//                      [string delimter = "<br>\n"])
//
// splits a long string into two chunks (a start and an end chunk)
// of a given maximum length and seperates them by a given delimeter.
// a second chunk can be right-justified within maxlen.
// may be used to 'spread' a string over two lines.
//

function strtrmvistl($str, $maxlen = 64, $right_justify = false, $delimter = "<br>\n") {
    if(($len = strlen($str = chop($str))) > ($maxlen = max($maxlen, 12))) {
        $newstr = substr($str, 0, $maxlen - 3);

        if($len > ($maxlen - 3)) {
            $endlen = min(($len - strlen($newstr)), $maxlen - 3);
            $newstr .= "..." . $delimter;

            if($right_justify)
                $newstr .= str_pad('', $maxlen - $endlen - 3, ' ');

            $newstr .= "..." . substr($str, $len - $endlen);
        }

        return($newstr);
    }

    return($str);
}
up
0
terry dot greenlaw at logicalshift dot com
10 years ago
Here's a simpler "simplest" way to toggle through a set of 1..n colors for web backgrounds:

<?php
$colours
= array('#000000', '#808080', '#A0A0A0', '#FFFFFF');

// Get a colour
$color = next($colors) or $color = reset($colors);
?>

The code doesn't need to know anything about the number of elements being cycled through. That way you won't have to tracking down all the code when changing the number of colors or the color values.
up
-1
administrador(ensaimada)sphoera(punt)com
8 years ago
I've prepared this simple function to obtain a string delimited between tags (not only XML tags!). Anybody needs something like this?.

<?php

function get_string_between($string, $start, $end){
   
$string = " ".$string;
    
$ini = strpos($string,$start);
     if (
$ini == 0) return "";
    
$ini += strlen($start);    
    
$len = strpos($string,$end,$ini) - $ini;
     return
substr($string,$ini,$len);
}

$string = "this [custom] function is useless!!";
echo
get_string_between($string,"[","]");
// must return "custom";
?>
more functions at http://www.sphoera.com
up
-1
Anonymous
9 years ago
to: james dot d dot baker at gmail dot com

PHP has a builtin function  for doing what your function does,

http://php.net/ucfirst
http://php.net/ucwords
up
-1
mike &#34;eyes&#34; moe
7 years ago
Here is a truly random string generator it uses the most common string functions it will work on anywhere.

<?php
   
function random_string($max = 20){
       
$chars = explode(" ", "a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9");
        for(
$i = 0; $i < $max; $i++){
           
$rnd = array_rand($chars);
           
$rtn .= base64_encode(md5($chars[$rnd]));
        }
        return
substr(str_shuffle(strtolower($rtn)), 0, $max);
    }
?>
up
-1
rh at richardhoward dot net
9 years ago
<?php
/**
Utility class: static methods for cleaning & escaping untrusted (i.e.
user-supplied) strings.

Any string can (usually) be thought of as being in one of these 'modes':

pure = what the user actually typed / what you want to see on the page /
       what is actually stored in the DB
gpc  = incoming GET, POST or COOKIE data
sql  = escaped for passing safely to RDBMS via SQL (also, data from DB
       queries and file reads if you have magic_quotes_runtime on--which
       is rare)
html = safe for html display (htmlentities applied)

Always knowing what mode your string is in--using these methods to
convert between modes--will prevent SQL injection and cross-site scripting.

This class refers to its own namespace (so it can work in PHP 4--there is no
self keyword until PHP 5). Do not change the name of the class w/o changing
all the internal references.

Example usage: a POST value that you want to query with:
$username = Str::gpc2sql($_POST['username']);
*/

//This sets SQL escaping to use slashes; for Sybase(/MSSQL)-style escaping
// ( ' --> '' ), set to true.
define('STR_SYBASE', false);

class
Str {
    function
gpc2sql($gpc, $maxLength = false)
    {
        return
Str::pure2sql(Str::gpc2pure($gpc), $maxLength);
    }
    function
gpc2html($gpc, $maxLength = false)
    {
        return
Str::pure2html(Str::gpc2pure($gpc), $maxLength);
    }
    function
gpc2pure($gpc)
    {
        if (
ini_get('magic_quotes_sybase'))
           
$pure = str_replace("''", "'", $gpc);
        else
$pure = get_magic_quotes_gpc() ? stripslashes($gpc) : $gpc;
        return
$pure;
    }
    function
html2pure($html)
    {
        return
html_entity_decode($html);
    }
    function
html2sql($html, $maxLength = false)
    {
        return
Str::pure2sql(Str::html2pure($html), $maxLength);
    }
    function
pure2html($pure, $maxLength = false)
    {
        return
$maxLength ? htmlentities(substr($pure, 0, $maxLength))
                          :
htmlentities($pure);
    }
    function
pure2sql($pure, $maxLength = false)
    {
        if (
$maxLength) $pure = substr($pure, 0, $maxLength);
        return (
STR_SYBASE)
               ?
str_replace("'", "''", $pure)
               :
addslashes($pure);
    }
    function
sql2html($sql, $maxLength = false)
    {
       
$pure = Str::sql2pure($sql);
        if (
$maxLength) $pure = substr($pure, 0, $maxLength);
        return
Str::pure2html($pure);
    }
    function
sql2pure($sql)
    {
        return (
STR_SYBASE)
               ?
str_replace("''", "'", $sql)
               :
stripslashes($sql);
    }
}
?>
up
-1
Stephen Dewey
6 years ago
If you want a function to return all text in a string up to the Nth occurrence of a substring, try the below function.

Works in PHP >= 5.

(Pommef provided another sample function for this purpose below, but I believe it is incorrect.)

<?php

// Returns all of $haystack up to (but excluding) the $n_occurrence occurrence of $needle. Therefore:
//        If there are < $n_occurrence occurrences of $needle in $haystack, the entire string will be returned.
//        If there are >= $n_occurrence occurrences of $needle in $haystack, the returned string will end before the $n_occurrence'th needle.
// This function only makes sense for $n_occurrence >= 1
function nsubstr($needle, $haystack, $n_occurrence)
{
   
// After exploding by $needle, every entry in $arr except (possibly) part of the last entry should have its content returned.
   
$arr = explode($needle,$haystack,$n_occurrence);
   
// Examine last entry in $arr. If it contains $needle, cut out all text except for the text before $needle.
   
$last = count($arr) - 1;
   
$pos_in_last = strpos($arr[$last],$needle);
   
    if (
$pos_in_last !== false)
       
$arr[$last] = substr($arr[$last],0,$pos_in_last);
   
    return
implode($needle,$arr);
}

$string = 'd24jkdslgjldk2424jgklsjg24jskgldjk24';

print
'S:  ' . $string . '<br>';
print
'1: ' . nsubstr('24',$string,1) . '<br>';
print
'2: ' . nsubstr('24',$string,2) . '<br>';
print
'3: ' . nsubstr('24',$string,3) . '<br>';
print
'4: ' . nsubstr('24',$string,4) . '<br>';
print
'5: ' . nsubstr('24',$string,5) . '<br>';
print
'6: ' . nsubstr('24',$string,6) . '<br>';
print
'7: ' . nsubstr('24',$string,7) . '<br>';

/*
// prints:
S: d24jkdslgjldk2424jgklsjg24jskgldjk24
1: d
2: d24jkdslgjldk
3: d24jkdslgjldk24
4: d24jkdslgjldk2424jgklsjg
5: d24jkdslgjldk2424jgklsjg24jskgldjk
6: d24jkdslgjldk2424jgklsjg24jskgldjk24
7: d24jkdslgjldk2424jgklsjg24jskgldjk24
*/

?>

Note that this function can be combined with wordwrap() to accomplish a routine but fairly difficult web design goal, namely, limiting inline HTML text to a certain number of lines. wordwrap() can break your string using <br>, and then you can use this function to only return text up to the N'th <br>.

You will still have to make a conservative guess of the max number of characters per line with wordwrap(), but you can be more precise than if you were simply truncating a multiple-line string with substr().

See example:

<?php

$text
= 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Pellentesque id massa. Duis sollicitudin ipsum vel diam. Aliquam pulvinar sagittis felis. Nullam hendrerit semper elit. Donec convallis mollis risus. Cras blandit mollis turpis. Vivamus facilisis, sapien at tincidunt accumsan, arcu dolor suscipit sem, tristique convallis ante ante id diam. Curabitur mollis, lacus vel gravida accumsan, enim quam condimentum est, vitae rutrum neque magna ac enim.';

$wrapped_text = wordwrap($text,100,'<br>',true);

$three_lines = nsubstr('<br>',$wrapped_text,3);

print
'<br><br>' . $three_lines;

$four_lines = nsubstr('<br>',$wrapped_text,4);

print
'<br><br>' . $four_lines;

/*
prints:

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Pellentesque id massa. Duis sollicitudin
ipsum vel diam. Aliquam pulvinar sagittis felis. Nullam hendrerit semper elit. Donec convallis
mollis risus. Cras blandit mollis turpis. Vivamus facilisis, sapien at tincidunt accumsan, arcu

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Pellentesque id massa. Duis sollicitudin
ipsum vel diam. Aliquam pulvinar sagittis felis. Nullam hendrerit semper elit. Donec convallis
mollis risus. Cras blandit mollis turpis. Vivamus facilisis, sapien at tincidunt accumsan, arcu
dolor suscipit sem, tristique convallis ante ante id diam. Curabitur mollis, lacus vel gravida

*/

?>
up
-2
navarr at gmail dot com
8 years ago
stripos for PHP4.x

<?php
 
function stripos($haystack,$needle) {
    return
strpos(strtoupper($haystack),strtoupper($needle));
  }
?>
up
-1
webmaster at cafe-clope dot net
9 years ago
A comprehensive concatenation function, that works with array and strings

<?php
function str_cat() {
 
$args = func_get_args() ;
   
 
// Asserts that every array given as argument is $dim-size.
  // Keys in arrays are stripped off.
  // If no array is found, $dim stays unset.
 
foreach($args as $key => $arg) {
    if(
is_array($arg)) {
      if(!isset(
$dim))
       
$dim = count($arg) ;
      elseif(
$dim != count($arg))
        return
FALSE ;
     
$args[$key] = array_values($arg) ;
    }
  }
       
 
// Concatenation
 
if(isset($dim)) {
   
$result = array() ;
    for(
$i=0;$i<$dim;$i++) {
     
$result[$i] = '' ;
      foreach(
$args as $arg)
       
$result[$i] .= ( is_array($arg) ? $arg[$i] : $arg ) ;
    }
    return
$result ;
  } else {
    return
implode($args) ;
  }
}
?>

A simple example :

<?php
str_cat
(array(1,2,3), '-', array('foo' => 'foo', 'bar' => 'bar', 'noop' => 'noop')) ;
?>

will return :
Array (
  [0] => 1-foo
  [1] => 2-bar
  [2] => 3-noop
)

More usefull :

<?php
$myget
= $_GET ; // retrieving previous $_GET values
$myget['foo'] = 'b a r' ; // changing one value
$myget = str_cat(array_keys($myget), '=', array_map('rawurlencode', array_values($myget))) ;
$querystring = implode(ini_get('arg_separator.output'), $myget)) ;
?>

will return a valid querystring with some values changed.

Note that <?php str_cat('foo', '&', 'bar') ; ?> will return 'foo&bar', while <?php str_cat(array('foo'), '&', 'bar') ; ?> will return array(0 => foo&bar)
up
-1
str at maphpia dot com
1 year ago
I was looking for a function to find the common substring in 2 different strings. I tried both the mb_string_intersect and string_intersect functions listed here but didn't work for me. I found the algorithm at http://en.wikibooks.org/wiki/Algorithm_implementation/Strings/Longest_common_substring#PHP so here I post you the function

<?php

/**
* Finds the matching string between 2 strings
*
* @param string $string1
* @param string $string2
* @param number $minChars
*
* @return NULL|string
*
* @link http://en.wikibooks.org/wiki/Algorithm_implementation/Strings/Longest_common_substring#PHP
*/
function string_intersect($string_1, $string_2)
{
   
$string_1_length = strlen($string_1);
   
$string_2_length = strlen($string_2);
   
$return          = "";

    if (
$string_1_length === 0 || $string_2_length === 0) {
       
// No similarities
       
return $return;
    }

   
$longest_common_subsequence = array();

   
// Initialize the CSL array to assume there are no similarities
   
for ($i = 0; $i < $string_1_length; $i++) {
       
$longest_common_subsequence[$i] = array();
        for (
$j = 0; $j < $string_2_length; $j++) {
           
$longest_common_subsequence[$i][$j] = 0;
        }
    }

   
$largest_size = 0;

    for (
$i = 0; $i < $string_1_length; $i++) {
        for (
$j = 0; $j < $string_2_length; $j++) {
           
// Check every combination of characters
           
if ($string_1[$i] === $string_2[$j]) {
               
// These are the same in both strings
               
if ($i === 0 || $j === 0) {
                   
// It's the first character, so it's clearly only 1 character long
                   
$longest_common_subsequence[$i][$j] = 1;
                } else {
                   
// It's one character longer than the string from the previous character
                   
$longest_common_subsequence[$i][$j] = $longest_common_subsequence[$i - 1][$j - 1] + 1;
                }

                if (
$longest_common_subsequence[$i][$j] > $largest_size) {
                   
// Remember this as the largest
                   
$largest_size = $longest_common_subsequence[$i][$j];
                   
// Wipe any previous results
                   
$return       = "";
                   
// And then fall through to remember this new value
               
}

                if (
$longest_common_subsequence[$i][$j] === $largest_size) {
                   
// Remember the largest string(s)
                   
$return = substr($string_1, $i - $largest_size + 1, $largest_size);
                }
            }
           
// Else, $CSL should be set to 0, which it was already initialized to
       
}
    }

   
// Return the list of matches
   
return $return;
}
up
-1
t0russ at gmail dot com
9 years ago
to kristin at greenaple dot on dot ca:
thanx for sharing.
your function in recursive form proved to be slightly faster and it returns false (as it should) when the character is not found instead of number 0:
<?php
function strnposr($haystack, $needle, $occurance, $pos = 0) {
    return (
$occurance<2)?strpos($haystack, $needle, $pos):strnposr($haystack,$needle,$occurance-1,strpos($haystack, $needle, $pos) + 1);
}
?>
up
-2
Anonymous
9 years ago
In response to hackajar <matt> yahoo <trot> com,

No string-to-array function exists because it is not needed. If you reference a string with an offset like you do with an array, the character at that offset will be return. This is documented in section III.11's "Strings" article under the "String access and modification by character" heading.
up
-2
Verdauga
6 years ago
Just a note in regards to bloopletech a few posts down:

The word "and" should not be used when converting numbers to text.  "And" (at least in US English) should only be used to indicate the decimal place.

Example:
1,796,706 => one million, seven hundred ninety-six thousand, seven hundred six.
594,359.34 => five hundred ninety four thousand, three hundred fifty nine and thirty four hundredths
up
-2
php at moechofe dot com
9 years ago
<?php
 
/*
  * str_match
  *
  * return a string with only cacacteres defined in a expression return false if the expression is not valid
  *
  * @param $str string the string
  * @param $match the expression based on the class definition off a PCRE regular expression.
  *   the '[', ']', '\' and '^' at class start need to be escaped.
  *   like : -a-z0-9_@.
  */
 
function str_match( $str, $match )
  {
   
$return = '';
    if(
eregi( '(.*)', $match, $class ) )
    {
     
$match = '['.$regs[1].']';
      for(
$i=0; $i<strlen($str); $i++ )
      if(
ereg( '['.$class[1].']', $str[$i] ) )
     
$return .= $str{$i};
      return
$return;
    }
    else return
false;
  }

 
/*
  * example
  * accept only alphanum caracteres from the GET/POST parameters 'a'
  */

 
if( ! empty($_REQUEST['a']) )
   
$_REQUEST['a'] = str_match( $_REQUEST['a'], 'a-zA-Z0-9' );
  else
   
$_REQUEST['a'] = 'default';
?>
up
-3
SteveRusin
8 years ago
The functions below:

function beginsWith( $str, $sub )
function endsWith( $str, $sub )

Are correct, but flawed.  You'd need to use the === operator instead:

function beginsWith( $str, $sub ) {
   return ( substr( $str, 0, strlen( $sub ) ) === $sub );
}
function endsWith( $str, $sub ) {
   return ( substr( $str, strlen( $str ) - strlen( $sub ) ) === $sub );
}

Otherwise, endsWith would return "foobar.0" ends with ".0" as well as "0" or "00" or any amount of zeros because numerically .0 does equal 0.
up
-2
m
7 years ago
Regarding the code for the function beginsWith($str, $sub), I found that it has problems when only one character is present after the string searched for. I found that this works better instead:

<?php
function beginsWith($str, $sub) {
    return (
strncmp($str, $sub, strlen($sub)) == 0);
}
?>
up
-2
da (dot) blayde (a t) gmail (dot) com
8 years ago
Sometimes when converting integers to strings, it looks better to have the number spelled out. I wrote this function that converts integers from -999 to 999 into spelled out strings:

function int2str($int=0){
$doOnes=true;
$neg=$int<0?true:false;
$int=abs(round($int));
$str='';
switch(strlen($int)){
  case 1:$int='0'.$int;
  case 2:$int='0'.$int;
  case 3:$int.='';break;
  default:return $int;
}
switch($int{0}){
  case 1:$str.='one-hundred-';break;
  case 2:$str.='two-hundred-';break;
  case 3:$str.='three-hundred-';break;
  case 4:$str.='four-hundred-';break;
  case 5:$str.='five-hundred-';break;
  case 6:$str.='six-hundred-';break;
  case 7:$str.='seven-hundred-';break;
  case 8:$str.='eight-hundred-';break;
  case 9:$str.='nine-hundred-';break;
}
switch($int{1}){
  case 1:
   switch($int{2}){
    case 0:$str.='ten-';break;
    case 1:$str.='eleven-';break;
    case 2:$str.='twelve-';break;
    case 3:$str.='thirteen-';break;
    case 4:$str.='fourteen-';break;
    case 5:$str.='fifteen-';break;
    case 6:$str.='sixteen-';break;
    case 7:$str.='seventeen-';break;
    case 8:$str.='eighteen-';break;
    case 9:$str.='nineteen-';break;
   }
   $doOnes=false;
  break;
  case 2:$str.='twenty-';break;
  case 3:$str.='thirty-';break;
  case 4:$str.='forty-';break;
  case 5:$str.='fifty-';break;
  case 6:$str.='sixty-';break;
  case 7:$str.='seventy-';break;
  case 8:$str.='eighty-';break;
  case 9:$str.='ninety-';break;
}
if($doOnes){
  switch($int{2}){
   case 1:$str.='one-';break;
   case 2:$str.='two-';break;
   case 3:$str.='three-';break;
   case 4:$str.='four-';break;
   case 5:$str.='five-';break;
   case 6:$str.='six-';break;
   case 7:$str.='seven-';break;
   case 8:$str.='eight-';break;
   case 9:$str.='nine-';break;
}}
$str=substr($str,0,-1);
if($neg){
  $str='negative '.$str;
}
if($int=='000'){
  $str='zero';
}
return $str;
}

Hope this helps someone,
-Blayde
up
-2
Pommef
9 years ago
Example: Give me everything up to the fourth occurance of '/'.

<?php

   $haystack
= "/home/username/www/index.php";
  
$needle = "/";
 
   function
strnpos($haystack, $needle, $occurance, $pos = 0) {
       
       
$res = implode($needle,$haystack);
       
       
$res = array_slice($res, $pos$occurance);
       
        return
explode ($needle,$res);
    }
?>
up
-3
admin at rotarymulundeast dot org
8 years ago
Here's an easier way to find nth...

function nth($numbex){
  if ($numbex%10 == 1 && $numbex%100 != 11) $sth='st';
  elseif ($numbex%10 == 2 && $numbex%100 != 12) $sth='nd';
  elseif ($numbex%10 == 3 && $numbex%100 != 13) $sth='rd';
  else $sth = 'th';
  return $sth;
}

there is is no need to check if the user has entered a non-integer as we may be using this function for expressing variables as well eg. ith value of x , nth root of z ,etc...
up
-6
Tomek Rychtyk
2 years ago
Get the intersection of two strings using array_intersect

<?php

function string_intersect($string1, $string2)
{
   
$array1 = $array2 = array();

    for(
$i = 0, $j = 0, $s1_len = strlen($string1), $s2_len = strlen($string2);($i < $s1_len) || ($j < $s2_len); $i++, $j++) {
        if(
$i < $s1_len) {
           
$array1[] = $string1[$i];
        }
        if(
$j < $s2_len) {
           
$array2[] = $string2[$j];
        }
    }

    return
implode('', array_intersect($array1, $array2));
}

?>

For more advanced comparison you can use array_uintersect as well.
To Top