Я хотів би динамічно генерувати рядок тексту на основі поточного дня. Так, наприклад, якщо це день 1, то я хотів би, щоб мій код генерував = "Її <динамічний> 1 * <динамічний рядок> st </ string string> * </dynamic>".

Всього 12 днів, тому я зробив наступне:

1. Я створив цикл для циклу, який циклічний протягом 12 днів.

2. У своєму html я дав своєму елементу унікальний ідентифікатор, за допомогою якого слід націлити його, див. Нижче:

   <h1 id="dynamicTitle" class="CustomFont leftHeading shadow">On The <span></span> <em>of rest of generic text</em></h1>

3. Тоді всередині моєї для циклу я маю такий код:

   $("#dynamicTitle span").html(i);
   var day = i;
   if (day == 1) {
       day = i + "st";
   } else if (day == 2) {
       day = i + "nd"
   } else if (day == 3) {
       day = i + "rd"
   }

ОНОВЛЕННЯ

Це цілий цикл для запиту:

$(document).ready(function () {
    for (i = 1; i <= 12; i++) {
        var classy = "";
        if (daysTilDate(i + 19) > 0) {
            classy = "future";
            $("#Day" + i).addClass(classy);
            $("#mainHeading").html("");
            $("#title").html("");
            $("#description").html("");
        } else if (daysTilDate(i + 19) < 0) {
            classy = "past";
            $("#Day" + i).addClass(classy);
            $("#title").html("");
            $("#description").html("");
            $("#mainHeading").html("");
            $(".cta").css('display', 'none');
            $("#Day" + i + " .prizeLink").attr("href", "" + i + ".html");
        } else {
            classy = "current";
            $("#Day" + i).addClass(classy);
            $("#title").html(headings[i - 1]);
            $("#description").html(descriptions[i - 1]);
            $(".cta").css('display', 'block');
            $("#dynamicImage").attr("src", ".." + i + ".jpg");
            $("#mainHeading").html("");
            $(".claimPrize").attr("href", "" + i + ".html");
            $("#dynamicTitle span").html(i);
            var day = i;
            if (day == 1) {
                day = i + "st";
            } else if (day == 2) {
                day = i + "nd"
            } else if (day == 3) {
                day = i + "rd"
            } else if (day) {
            }
        }
    }

Ці правила полягають в наступному:

• st використовується з числами, що закінчуються на 1 (наприклад, 1-й, вимовляється перший)
• nd використовується цифрами, що закінчуються на 2 (наприклад, 92-е, вимовляється дев'яносто другий)
• rd використовується цифрами, що закінчуються на 3 (наприклад, 33-е, вимовляється тридцять третє)
• Як виняток із вищезазначених правил, усі "підліткові" номери, що закінчуються на 11, 12 або 13 використовують -те (наприклад, 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

З Shopify

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

[-4,-1,0,1,2,3,4,10,11,12,13,14,20,21,22,100,101,111].forEach(
  n => console.log(n + ' -> ' + getNumberWithOrdinal(n))
);

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

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 мод 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>

Варіації

Дозволення мінус цілих чисел:

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

У синтаксисі жирової стрілки ES6 (анонімна функція):

n=>["st","nd","rd"][(((n<0?-n:n)+90)%100-10)%10-1]||"th"

Оновлення

Ще коротшою альтернативою для натуральних чисел є вираз

[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'

Дивіться цю публікацію для пояснення.

Оновлення 2

[,'st','nd','rd'][n/10%10^1&&n%10]||'th'

Ви можете використовувати локальні функції даних бібліотек моментів .

Код:

moment.localeData().ordinal(1)
//1st

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(201)
	.fill()
	.map((_, index) => index - 100)
	.map(ordinal)
	.join(" ");
console.log(test);

• Intl.PluralRulesКонструктор (Проект ECMA-402)
• Шість множинних категорій Unicode

У вас всього 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'

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

Якщо число у підлітків, array[1] = 1воно вимагає "го".

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";
}

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

Я написав цю функцію для вирішення цієї проблеми:

// 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

Альтернативним варіантом порядкової функції може бути такий:

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";
}

Змінні названі більш чітко, вони використовують умову верблюда і можуть бути швидшими.

Я написав цю просту функцію днями. Незважаючи на те, що для дати вам не потрібні великі цифри, це також буде задовольняти і більш високі значення (1013-й, 36021-й тощо)

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;
};

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

Короткий, солодкий та ефективний, як і функції утиліти. Працює з будь-яким підписаним / неподписаним цілим / float. (Навіть не дивлячись на те, що я не можу уявити, що потрібно впорядковувати поплавці)

Ось ще один варіант.

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'));

Помічаєте виняток для підлітків? Підлітки такі аквард!

Редагувати: Забули про 11 та 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'.

Наш функціональний номерToOrdinal перевіряє, чи закінчується це число підлітковим номером, і в цьому випадку додається число на "th", оскільки всі тодішні порядкові числа є "th". У випадку, якщо число не є підлітком, ми передаємо це число addSuffix, яке додає число до порядкового значення, яке визначається, якщо число мінус 1 (тому що ми використовуємо нульовий індекс) мод 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

Старий, який я зробив для своїх речей ...

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;
     }
}

Настійно рекомендую відмінну бібліотеку дат-фнів . Швидкий, модульний, незмінний, працює зі стандартними датами.

import * as DateFns from 'date-fns';

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

Див. Документи-дати-fns: https://date-fns.org/v2.0.0-alpha.9/docs/format

Я написав цю функцію для більшої кількості та всіх тестових випадків

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')
    }
}

Ось дещо інший підхід (я не думаю, що інші відповіді роблять це). Я не впевнений, люблю я це чи ненавиджу, але це працює!

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

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

Це для одного лайнера та любителів es6

let i= new Date().getDate 

// I can be any number, for future sake we'll use 9

const j = I % 10;
const k = I % 100;

i = `${i}${j === 1 &&  k !== 11 ? 'st' : j === 2 && k !== 12 ? 'nd' : j === 3 && k !== 13 ? 'rd' : 'th'}`}

console.log(i) //9th

Ще одним варіантом для номера + буде:

console.log(["st","nd","rd"][((i+90)%100-10)%10-1]||"th"]

Також для позбавлення від порядкового префіксу просто скористайтеся цими:

console.log(i.parseInt("8th"))

console.log(i.parseFloat("8th"))

не соромтеся змінювати, щоб відповідати вам

Ви також можете використовувати scales::ordinal()функцію. Це швидко і просто у використанні.

scales::ordinal(1:12)
## [1] "1st"  "2nd"  "3rd"  "4th"  "5th"  "6th"  "7th"  "8th"  "9th"  "10th" "11th" "12th"

Я настійно рекомендую це прочитати, це дуже легко і просто. Я сподіваюся, що це допоможе?

• Він уникає використання від'ємного цілого числа, тобто числа менше 1, і повертає помилкове
• Він повертає 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

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

Можна використовувати

1<sup>st</sup> 2<sup>nd</sup> 3<sup>rd</sup> 4<sup>th</sup>

для позиціонування суфікса