Afficher les nombres avec le suffixe ordinal en PHP

Je souhaite afficher les nombres comme suit

• 1 comme 1er,
• 2 comme 2ème,
• ...,
• 150 comme 150e.

Comment trouver le suffixe ordinal correct (st, nd, rd ou th) pour chaque nombre de mon code?

de wikipedia :

$ends = array('th','st','nd','rd','th','th','th','th','th','th');
if (($number %100) >= 11 && ($number%100) <= 13)
   $abbreviation = $number. 'th';
else
   $abbreviation = $number. $ends[$number % 10];

Où $numberest le numéro que vous souhaitez écrire. Fonctionne avec n'importe quel nombre naturel.

En tant que fonction:

function ordinal($number) {
    $ends = array('th','st','nd','rd','th','th','th','th','th','th');
    if ((($number % 100) >= 11) && (($number%100) <= 13))
        return $number. 'th';
    else
        return $number. $ends[$number % 10];
}
//Example Usage
echo ordinal(100);

PHP a des fonctionnalités intégrées pour cela . Il gère même l'internationalisation!

$locale = 'en_US';
$nf = new NumberFormatter($locale, NumberFormatter::ORDINAL);
echo $nf->format($number);

Notez que cette fonctionnalité n'est disponible que dans PHP 5.3.0 et versions ultérieures.

Cela peut être accompli en une seule ligne en exploitant des fonctionnalités similaires dans les fonctions de date / heure intégrées de PHP. Je soumets humblement:

Solution:

function ordinalSuffix( $n )
{
  return date('S',mktime(1,1,1,1,( (($n>=10)+($n>=20)+($n==0))*10 + $n%10) ));
}

Explication détaillée:

La date()fonction intégrée a une logique de suffixe pour gérer les calculs du nième jour du mois. Le suffixe est renvoyé lorsqu'il Sest indiqué dans la chaîne de format:

date( 'S' , ? );

Depuis date()nécessite un horodatage (pour ?ci - dessus), nous allons passer notre entier en $ntant que dayparamètre mktime()et l' utilisation des valeurs fictives de 1la hour, minute, secondet month:

date( 'S' , mktime( 1 , 1 , 1 , 1 , $n ) );

Cela échoue en fait gracieusement sur les valeurs hors plage pour un jour du mois (c'est-à-dire $n > 31), mais nous pouvons ajouter une logique en ligne simple pour plafonner $nà 29:

date( 'S', mktime( 1, 1, 1, 1, ( (($n>=10)+($n>=20))*10 + $n%10) ));

La seule valeur positive( Mai 2017 ) cela échoue $n == 0, mais c'est facilement résolu en ajoutant 10 dans ce cas particulier:

date( 'S', mktime( 1, 1, 1, 1, ( (($n>=10)+($n>=20)+($n==0))*10 + $n%10) ));

Mise à jour, mai 2017

Comme observé par @donatJ, ce qui précède échoue au-dessus de 100 (par exemple "111st"), car les >=20vérifications retournent toujours vrai. Pour les réinitialiser tous les siècles, nous ajoutons un filtre à la comparaison:

date( 'S', mktime( 1, 1, 1, 1, ( (($n>=10)+($n%100>=20)+($n==0))*10 + $n%10) ));

Emballez-le simplement dans une fonction pour plus de commodité et c'est parti!

Voici un one-liner:

$a = <yournumber>;
echo $a.substr(date('jS', mktime(0,0,0,1,($a%10==0?9:($a%100>20?$a%10:$a%100)),2000)),-2);

Probablement la solution la plus courte. Peut bien sûr être enveloppé par une fonction:

function ordinal($a) {
  // return English ordinal number
  return $a.substr(date('jS', mktime(0,0,0,1,($a%10==0?9:($a%100>20?$a%10:$a%100)),2000)),-2);
}

Cordialement, Paul

EDIT1: Correction du code pour 11 à 13.

EDIT2: Correction du code pour 111, 211, ...

EDIT3: Maintenant, cela fonctionne correctement aussi pour les multiples de 10.

depuis http://www.phpro.org/examples/Ordinal-Suffix.html

<?php

/**
 *
 * @return number with ordinal suffix
 *
 * @param int $number
 *
 * @param int $ss Turn super script on/off
 *
 * @return string
 *
 */
function ordinalSuffix($number, $ss=0)
{

    /*** check for 11, 12, 13 ***/
    if ($number % 100 > 10 && $number %100 < 14)
    {
        $os = 'th';
    }
    /*** check if number is zero ***/
    elseif($number == 0)
    {
        $os = '';
    }
    else
    {
        /*** get the last digit ***/
        $last = substr($number, -1, 1);

        switch($last)
        {
            case "1":
            $os = 'st';
            break;

            case "2":
            $os = 'nd';
            break;

            case "3":
            $os = 'rd';
            break;

            default:
            $os = 'th';
        }
    }

    /*** add super script ***/
    $os = $ss==0 ? $os : '<sup>'.$os.'</sup>';

    /*** return ***/
    return $number.$os;
}
?> 

La réponse simple et facile sera:

$Day = 3; 
echo date("S", mktime(0, 0, 0, 0, $Day, 0));

//OUTPUT - rd

J'ai écrit ceci pour PHP4. Cela fonctionne bien et c'est assez économique.

function getOrdinalSuffix($number) {
    $number = abs($number) % 100;
    $lastChar = substr($number, -1, 1);
    switch ($lastChar) {
        case '1' : return ($number == '11') ? 'th' : 'st';
        case '2' : return ($number == '12') ? 'th' : 'nd';
        case '3' : return ($number == '13') ? 'th' : 'rd'; 
    }
    return 'th';  
}

il vous suffit d'appliquer une fonction donnée.

function addOrdinalNumberSuffix($num) {
  if (!in_array(($num % 100),array(11,12,13))){
    switch ($num % 10) {
      // Handle 1st, 2nd, 3rd
      case 1:  return $num.'st';
      case 2:  return $num.'nd';
      case 3:  return $num.'rd';
    }
  }
  return $num.'th';
}

De manière générique, vous pouvez l'utiliser et appeler echo get_placing_string (100);

<?php
function get_placing_string($placing){
    $i=intval($placing%10);
    $place=substr($placing,-2); //For 11,12,13 places

    if($i==1 && $place!='11'){
        return $placing.'st';
    }
    else if($i==2 && $place!='12'){
        return $placing.'nd';
    }

    else if($i==3 && $place!='13'){
        return $placing.'rd';
    }
    return $placing.'th';
}
?>

J'ai créé une fonction qui ne repose pas sur la date();fonction de PHP car ce n'est pas nécessaire, mais je l'ai également rendue aussi compacte et aussi courte que je pense que c'est actuellement possible.

Le code : (121 octets au total)

function ordinal($i) { // PHP 5.2 and later
  return($i.(($j=abs($i)%100)>10&&$j<14?'th':(($j%=10)>0&&$j<4?['st', 'nd', 'rd'][$j-1]:'th')));
}

Code plus compact ci-dessous.

Cela fonctionne comme suit :

printf("The %s hour.\n",    ordinal(0));   // The 0th hour.
printf("The %s ossicle.\n", ordinal(1));   // The 1st ossicle.
printf("The %s cat.\n",     ordinal(12));  // The 12th cat.
printf("The %s item.\n",    ordinal(-23)); // The -23rd item.

Choses à savoir sur cette fonction :

• Il traite les entiers négatifs de la même manière que les entiers positifs et conserve le signe.
• Il renvoie 11e, 12e, 13e, 811e, 812e, 813e, etc. pour les- quinze nombres comme prévu.
• Il ne vérifie pas les décimales, mais les laisser en place (utilisation floor($i), round($i)ou ceil($i)au début de l'instruction return final).
• Vous pouvez également ajouter format_number($i) au début de l'instruction de retour finale pour obtenir un entier séparé par des virgules (si vous affichez des milliers, des millions, etc.).
• Vous pouvez simplement supprimer le $idepuis le début de l'instruction return si vous souhaitez uniquement renvoyer le suffixe ordinal sans ce que vous avez entré.

Cette fonction fonctionne à partir de PHP 5.2 publié en novembre 2006 uniquement à cause de la syntaxe des tableaux courts. Si vous avez une version antérieure à celle-ci, veuillez mettre à jour car vous êtes presque dix ans à jour! A défaut, remplacez simplement le en ligne ['st', 'nd', 'rd']par une variable temporaire contenantarray('st', 'nd', 'rd'); .

La même fonction (sans retourner l'entrée), mais une vue éclatée de ma fonction courte pour une meilleure compréhension:

function ordinal($i) {
  $j = abs($i); // make negatives into positives
  $j = $j%100; // modulo 100; deal only with ones and tens; 0 through 99

  if($j>10 && $j<14) // if $j is over 10, but below 14 (so we deal with 11 to 13)
    return('th'); // always return 'th' for 11th, 13th, 62912th, etc.

  $j = $j%10; // modulo 10; deal only with ones; 0 through 9

  if($j==1) // 1st, 21st, 31st, 971st
    return('st');

  if($j==2) // 2nd, 22nd, 32nd, 582nd
    return('nd'); // 

  if($j==3) // 3rd, 23rd, 33rd, 253rd
    return('rd');

  return('th'); // everything else will suffixed with 'th' including 0th
}

Mise à jour du code :

Voici une version modifiée qui est plus courte de 14 octets entiers (107 octets au total):

function ordinal($i) {
  return $i.(($j=abs($i)%100)>10&&$j<14?'th':@['th','st','nd','rd'][$j%10]?:'th');
}

Ou pour aussi court que possible étant 25 octets plus court (96 octets au total):

function o($i){return $i.(($j=abs($i)%100)>10&&$j<14?'th':@['th','st','nd','rd'][$j%10]?:'th');}

Avec cette dernière fonction, appelez simplement o(121);et cela fera exactement la même chose que les autres fonctions que j'ai énumérées.

Mise à jour du code n ° 2 :

Ben et moi avons travaillé ensemble et l'avons réduit de 38 octets (83 octets au total):

function o($i){return$i.@(($j=abs($i)%100)>10&&$j<14?th:[th,st,nd,rd][$j%10]?:th);}

Nous ne pensons pas que cela puisse être plus court que cela! Prêt à se tromper, cependant. :)

J'espère que vous apprécierez tous.

Une version encore plus courte pour les dates du mois (jusqu'à 31) au lieu d'utiliser mktime () et ne nécessitant pas pecl intl:

function ordinal($n) {
    return (new DateTime('Jan '.$n))->format('jS');
}

ou procédural:

echo date_format(date_create('Jan '.$n), 'jS');

Cela fonctionne bien sûr car le mois par défaut que j'ai choisi (janvier) compte 31 jours.

Chose intéressante si vous l'essayez avec février (ou un autre mois sans 31 jours), il redémarre avant la fin:

...clip...
31st
1st
2nd
3rd

afin que vous puissiez compter jusqu'aux jours de ce mois avec le spécificateur de date tdans votre boucle: nombre de jours dans le mois.

function ordinal($number){

    $last=substr($number,-1);
    if( $last>3 || $last==0 || ( $number >= 11 && $number <= 19 ) ){
      $ext='th';
    }else if( $last==3 ){
      $ext='rd';
    }else if( $last==2 ){
      $ext='nd';
    }else{
      $ext='st';
    }
    return $number.$ext;
  }

J'ai trouvé une réponse dans PHP.net

<?php
function ordinal($num)
{
    // Special case "teenth"
    if ( ($num / 10) % 10 != 1 )
    {
        // Handle 1st, 2nd, 3rd
        switch( $num % 10 )
        {
            case 1: return $num . 'st';
            case 2: return $num . 'nd';
            case 3: return $num . 'rd';  
        }
    }
    // Everything else is "nth"
    return $num . 'th';
}
?>

Voici une autre version très courte utilisant les fonctions de date. Cela fonctionne pour n'importe quel nombre (non limité par les jours du mois) et prend en compte que * 11 * 12 * 13 ne suit pas le format * 1er * 2ème * 3ème.

function getOrdinal($n)
{
    return $n . date_format(date_create('Jan ' . ($n % 100 < 20 ? $n % 20 : $n % 10)), 'S');
}

J'adore ce petit extrait

<?php

  function addOrdinalNumberSuffix($num) {
    if (!in_array(($num % 100),array(11,12,13))){
      switch ($num % 10) {
        // Handle 1st, 2nd, 3rd
        case 1:  return $num.'st';
        case 2:  return $num.'nd';
        case 3:  return $num.'rd';
      }
    }
    return $num.'th';
  }

?>

ICI