Ответ 1

Правила заключаются в следующем:

• st используется с номерами, заканчивающимися на 1 (например, 1-й, произносится первым)
• nd используется с номерами, заканчивающимися на 2 (например, 92-й, произносится девяносто второй)
• rd используется с числами, заканчивающимися на 3 (например, 33-й, выраженный тридцать третий).
• В качестве исключения из вышеприведенных правил все "подростковые" числа, заканчивающиеся на 11, 12 или 13, используют -th (например, 11-й, произносится одиннадцатый, 112-й, произносится как сто [и] двенадцатый)
• th используется для всех остальных чисел (например, 9-й, произносится как девятый).

Следующий код JavaScript (переписан в июне 14) выполняет следующее:

function ordinal_suffix_of(i) {
    var j = i % 10,
        k = i % 100;
    if (j == 1 && k != 11) {
        return i + "st";
    }
    if (j == 2 && k != 12) {
        return i + "nd";
    }
    if (j == 3 && k != 13) {
        return i + "rd";
    }
    return i + "th";
}

Пример вывода для чисел между 0-115:

  0  0th
  1  1st
  2  2nd
  3  3rd
  4  4th
  5  5th
  6  6th
  7  7th
  8  8th
  9  9th
 10  10th
 11  11th
 12  12th
 13  13th
 14  14th
 15  15th
 16  16th
 17  17th
 18  18th
 19  19th
 20  20th
 21  21st
 22  22nd
 23  23rd
 24  24th
 25  25th
 26  26th
 27  27th
 28  28th
 29  29th
 30  30th
 31  31st
 32  32nd
 33  33rd
 34  34th
 35  35th
 36  36th
 37  37th
 38  38th
 39  39th
 40  40th
 41  41st
 42  42nd
 43  43rd
 44  44th
 45  45th
 46  46th
 47  47th
 48  48th
 49  49th
 50  50th
 51  51st
 52  52nd
 53  53rd
 54  54th
 55  55th
 56  56th
 57  57th
 58  58th
 59  59th
 60  60th
 61  61st
 62  62nd
 63  63rd
 64  64th
 65  65th
 66  66th
 67  67th
 68  68th
 69  69th
 70  70th
 71  71st
 72  72nd
 73  73rd
 74  74th
 75  75th
 76  76th
 77  77th
 78  78th
 79  79th
 80  80th
 81  81st
 82  82nd
 83  83rd
 84  84th
 85  85th
 86  86th
 87  87th
 88  88th
 89  89th
 90  90th
 91  91st
 92  92nd
 93  93rd
 94  94th
 95  95th
 96  96th
 97  97th
 98  98th
 99  99th
100  100th
101  101st
102  102nd
103  103rd
104  104th
105  105th
106  106th
107  107th
108  108th
109  109th
110  110th
111  111th
112  112th
113  113th
114  114th
115  115th

Ответ 2

От Shopify

function getNumberWithOrdinal(n) {
    var s=["th","st","nd","rd"],
    v=n%100;
    return n+(s[(v-20)%10]||s[v]||s[0]);
 }

Ответ 3

Минимальный однострочный подход для порядковых суффиксов

function nth(n){return["st","nd","rd"][((n+90)%100-10)%10-1]||"th"}

(это для целых положительных чисел, см. ниже для других вариантов)

объяснение

Начните с массива с суффиксами ["st", "nd", "rd"]. Мы хотим отобразить целые числа, заканчивающиеся на 1, 2, 3 (но не заканчивающиеся на 11, 12, 13) на индексы 0, 1, 2.

Другие целые числа (включая те, которые заканчиваются на 11, 12, 13) могут быть сопоставлены ни с чем другим - индексы, не найденные в массиве, будут оцениваться undefined. Это ложь в javascript и с использованием логического или (|| "th") выражение вернет "th" для этих целых чисел, что именно то, что мы хотим.

Выражение ((n + 90) % 100 - 10) % 10 - 1 делает отображение. Разрушение:

• (n + 90) % 100: Это выражение принимает входное целое число - 10 mod 100, отображение 10 в 0,... от 99 до 89, от 0 до 90,... от 9 до 99. Теперь целые числа, заканчивающиеся на 11, 12, 13 находятся на нижнем конце (отображаются на 1, 2, 3).
• - 10: теперь 10 сопоставляется с -10, 19 до -1, от 99 до 79, от 0 до 80,... от 9 до 89. Целые числа, заканчивающиеся на 11, 12, 13, отображаются в отрицательные целые числа (-9, - 8, -7).
• % 10: теперь все целые числа, заканчивающиеся на 1, 2 или 3, отображаются в 1, 2, 3. Все остальные целые числа отображаются на что-то еще (11, 12, 13 все еще отображаются на -9, -8, -7),
• - 1: вычитание одного дает окончательное отображение 1, 2, 3 в 0, 1, 2.

Проверка работы

function nth(n){return["st","nd","rd"][((n+90)%100-10)%10-1]||"th"}

//test integers from 1 to 124
for(var r = [], i = 1; i < 125; i++) r.push(i + nth(i));

//output result
document.getElementById('result').innerHTML = r.join('<br>');

<div id="result"></div>

Ответ 4

У вас всего 12 дней? У меня возникнет соблазн сделать его простым массивом поиска:

var suffixes = ['','st','nd','rd','th','th','th','th','th','th','th','th','th'];

то

var i = 2;
var day = i + suffixes[i]; // result: '2nd'

или

var i = 8;
var day = i + suffixes[i]; // result: '8th'

Ответ 5

Разбирая число в массив и реверсируя, мы можем легко проверить последние 2 цифры числа, используя array[0] и array[1].

Если число находится в подростковом возрасте array[1] = 1, оно требует "th".

function getDaySuffix(num)
{
    var array = ("" + num).split("").reverse(); // E.g. 123 = array("3","2","1")

    if (array[1] != "1") { // Number is in the teens
        switch (array[0]) {
            case "1": return "st";
            case "2": return "nd";
            case "3": return "rd";
        }
    }

    return "th";
}

Ответ 6

function getSuffix(n) {return n < 11 || n > 13 ? ['st', 'nd', 'rd', 'th'][Math.min((n - 1) % 10, 3)] : 'th'}

Ответ 7

Я написал эту функцию для решения этой проблемы:

// this is for adding the ordinal suffix, turning 1, 2 and 3 into 1st, 2nd and 3rd
Number.prototype.addSuffix=function(){
    var n=this.toString().split('.')[0];
    var lastDigits=n.substring(n.length-2);
    //add exception just for 11, 12 and 13
    if(lastDigits==='11' || lastDigits==='12' || lastDigits==='13'){
        return this+'th';
    }
    switch(n.substring(n.length-1)){
        case '1': return this+'st';
        case '2': return this+'nd';
        case '3': return this+'rd';
        default : return this+'th';
    }
};

С этим вы можете просто поместить .addSuffix() в любое число, и это приведет к тому, что вы хотите. Например:

var number=1234;
console.log(number.addSuffix());
// console will show: 1234th

Ответ 8

Альтернативный вариант ординальной функции может быть следующим:

function toCardinal(num) {
    var ones = num % 10;
    var tens = num % 100;

    if (tens < 11 || tens > 13) {
        switch (ones) {
            case 1:
                return num + "st";
            case 2:
                return num + "nd";
            case 3:
                return num + "rd";
        }
    }

    return num + "th";
}

Переменные называются более явно, использует соглашение о случае с верблюдом и может быть быстрее.

Ответ 9

Я написал эту простую функцию на днях. Хотя для даты вам не нужны большие числа, это также будет обслуживать более высокие значения (1013, 36021st и т.д.)

var fGetSuffix = function(nPos){

    var sSuffix = "";

    switch (nPos % 10){
        case 1:
            sSuffix = (nPos % 100 === 11) ? "th" : "st";
            break;
        case 2:
            sSuffix = (nPos % 100 === 12) ? "th" : "nd";
            break;
        case 3:
            sSuffix = (nPos % 100 === 13) ? "th" : "rd";
            break;
        default:
            sSuffix = "th";
            break;
    }

    return sSuffix;
};

Ответ 10

function ordsfx(a){return["th","st","nd","rd"][(a=~~(a<0?-a:a)%100)>10&&a<14||(a%=10)>3?0:a]}

См. аннотированную версию на https://gist.github.com/furf/986113#file-annotated-js

Короткие, сладкие и эффективные, как и функции утилиты. Работает с любым подписанным /unsigned integer/float. (Несмотря на то, что я не могу представить себе необходимость упорядочивать поплавки)

Ответ 11

Вот еще один вариант.

function getOrdinalSuffix(day) {
        
   	if(/^[2-3]?1$/.test(day)){
   		return 'st';
   	} else if(/^[2-3]?2$/.test(day)){
   		return 'nd';
   	} else if(/^[2-3]?3$/.test(day)){
   		return 'rd';
   	} else {
   		return 'th';
   	}
        
}
    
console.log(getOrdinalSuffix('1'));
console.log(getOrdinalSuffix('13'));
console.log(getOrdinalSuffix('22'));
console.log(getOrdinalSuffix('33'));

Ответ 12

Я хотел бы дать функциональный ответ на этот вопрос, чтобы дополнить существующий ответ:

const ordinalSuffix = ['st', 'nd', 'rd']
const addSuffix = n => n + (ordinalSuffix[(n - 1) % 10] || 'th')
const numberToOrdinal = n => `${n}`.match(/1\d$/) ? n + 'th' : addSuffix(n)

мы создали массив специальных значений, важно помнить, что массивы имеют индекс на основе нуля, поэтому ordinalSuffix [0] равен 'st'.

Наш номер функции. Доверенный проверяет, заканчивается ли число в подростковом номере, в этом случае добавьте число с "th" , так как все порядковые номера чисел "th" . В случае, если число не является подростком, мы передаем номер addSuffix, который добавляет номер в порядковый номер, который определяется, если число минус 1 (потому что мы используем индекс на основе нуля) mod 10 имеет остаток от 2 или меньше он берется из массива, в противном случае это "th" .

вывод образца:

numberToOrdinal(1) // 1st
numberToOrdinal(2) // 2nd
numberToOrdinal(3) // 3rd
numberToOrdinal(4) // 4th
numberToOrdinal(5) // 5th
numberToOrdinal(6) // 6th
numberToOrdinal(7) // 7th
numberToOrdinal(8) // 8th
numberToOrdinal(9) // 9th
numberToOrdinal(10) // 10th
numberToOrdinal(11) // 11th
numberToOrdinal(12) // 12th
numberToOrdinal(13) // 13th
numberToOrdinal(14) // 14th
numberToOrdinal(101) // 101st

Ответ 13

Старый, который я сделал для своих вещей...

function convertToOrdinal(number){
    if (number !=1){
        var numberastext = number.ToString();
        var endchar = numberastext.Substring(numberastext.Length - 1);
        if (number>9){
            var secondfromendchar = numberastext.Substring(numberastext.Length - 1);
            secondfromendchar = numberastext.Remove(numberastext.Length - 1);
        }
        var suffix = "th";
        var digit = int.Parse(endchar);
        switch (digit){
            case 3:
                if(secondfromendchar != "1"){
                    suffix = "rd";
                    break;
                }
            case 2:
                if(secondfromendchar != "1"){
                    suffix = "nd";
                    break;
                }
            case 1:
                if(secondfromendchar != "1"){
                    suffix = "st";
                    break;
                }
            default:
                suffix = "th";
                break;
         }
            return number+suffix+" ";
     } else {
            return;
     }
}

Ответ 14

Настоятельно рекомендуем отличную библиотеку date-fns. Быстро, модульно, неизменно, работает со стандартными датами.

import * as DateFns from 'date-fns';

const ordinalInt = DateFns.format(someInt, 'do');

См. Документы date-fns: https://date-fns.org/v2.0.0-alpha.9/docs/format

Ответ 15

Я написал эту функцию для более высоких чисел и всех тестовых примеров

function numberToOrdinal(num) {
    if (num === 0) {
        return '0'
    };
    let i = num.toString(), j = i.slice(i.length - 2), k = i.slice(i.length - 1);
    if (j >= 10 && j <= 20) {
        return (i + 'th')
    } else if (j > 20 && j < 100) {
        if (k == 1) {
            return (i + 'st')
        } else if (k == 2) {
            return (i + 'nd')
        } else if (k == 3) {
            return (i + 'rd')
        } else {
            return (i + 'th')
        }
    } else if (j == 1) {
        return (i + 'st')
    } else if (j == 2) {
        return (i + 'nd')
    } else if (j == 3) {
        return (i + 'rd')
    } else {
        return (i + 'th')
    }
}

Ответ 16

Intl.PluralRules, стандартный метод.

Я просто хотел бы опустить здесь канонический метод, поскольку никто, кажется, не знает его.

const english_ordinal_rules = new Intl.PluralRules("en", {type: "ordinal"});
const suffixes = {
	one: "st",
	two: "nd",
	few: "rd",
	other: "th"
};
function ordinal(number) {
	const suffix = suffixes[english_ordinal_rules.select(number)];
	return (number + suffix);
}

const test = Array(100)
	.fill()
	.map((_, index) => index)
	.map(ordinal)
	.join(" ");
console.log(test);

Ответ 17

Я не вижу этот стиль es6 в списке ответов на этой странице, и это то, что я использую:

const ordinal_suffix_of = (i) => {
  const j = i % 10, k = i % 100
  if (j == 1 && k != 11) {
      return i + "st"
  }
  if (j == 2 && k != 12) {
      return i + "nd"
  }
  if (j == 3 && k != 13) {
      return i + "rd"
  }
  return i + "th"
}

Ответ 18

попробовать

var getOrdinal = function(n) {
   var s=["th","st","nd","rd"],
   v=n%100;
   return n+(s[(v-20)%10]||s[v]||s[0]);
}

console.log(getOrdinal(10)

Ответ 19

Я настоятельно рекомендую это, это очень легко и просто читать. Надеюсь, это поможет?

• Это позволяет избежать использования отрицательного целого числа, т.е. Числа меньше 1, и возвращает false
• Возвращает 0, если вход 0

function numberToOrdinal(n) {

  let result;

  if(n < 0){
    return false;
  }else if(n === 0){
    result = "0";
  }else if(n > 0){

    let nToString = n.toString();
    let lastStringIndex = nToString.length-1;
    let lastStringElement = nToString[lastStringIndex];

    if( lastStringElement == "1" && n % 100 !== 11 ){
      result = nToString + "st";
    }else if( lastStringElement == "2" && n % 100 !== 12 ){
      result = nToString + "nd";
    }else if( lastStringElement == "3" && n % 100 !== 13 ){
      result = nToString + "rd";
    }else{
      result = nToString + "th";
    }

  }

  return result;
}

console.log(numberToOrdinal(-111));
console.log(numberToOrdinal(0));
console.log(numberToOrdinal(11));
console.log(numberToOrdinal(15));
console.log(numberToOrdinal(21));
console.log(numberToOrdinal(32));
console.log(numberToOrdinal(43));
console.log(numberToOrdinal(70));
console.log(numberToOrdinal(111));
console.log(numberToOrdinal(300));
console.log(numberToOrdinal(101));

ВЫХОД

false
0
11th
15th
21st
32nd
43rd
70th
111th
300th
101st

Ответ 20

Здесь немного другой подход (я не думаю, что другие ответы делают это). Я не уверен, люблю ли я это или ненавижу, но это работает!

export function addDaySuffix(day: number) { 
  const suffixes =
      '  stndrdthththththththththththththththththstndrdthththththththst';
    const startIndex = day * 2;

    return '${day}${suffixes.substring(startIndex, startIndex + 2)}';
  }

Ответ 21

<p>31<sup>st</sup> March 2015</p>