---

CoffeeScript Ordinal Numbers: A Zero-to-Hero Guide to String Formatting

Learn to convert numbers into ordinal form (1st, 2nd, 3rd) in CoffeeScript. This guide covers the core logic using the modulo operator to handle special cases like 11th, 12th, and 13th, enabling you to create dynamic, human-readable strings for any application that demands a polished user experience.

Imagine running a bustling downtown deli. The line of hungry customers snakes out the door, and keeping track of who's next is becoming a challenge. Simple numbers on a ticket feel impersonal and cold. You want to make each customer feel seen, even during the lunch rush. This is the exact scenario presented in the Line Up module from the exclusive kodikra.com CoffeeScript learning path, a problem that moves beyond basic variables into the nuanced world of human-centric programming.

This challenge isn't just about code; it's about communication. Transforming a number like 22 into "22nd" or 101 into "101st" seems simple at first glance, but the rules of English grammar introduce tricky edge cases. This guide will walk you through the entire process, from understanding the logic to implementing a clean, efficient, and reusable solution in CoffeeScript. You'll not only solve the problem but also gain a deeper appreciation for handling logical exceptions in your code.

---

What Exactly Are Ordinal Numbers and Why Are They a Programming Puzzle?

Before diving into the code, it's crucial to understand the fundamental concept. In linguistics, numbers come in two primary forms: cardinal and ordinal. Understanding the difference is the first step to appreciating the programming challenge.

• Cardinal Numbers: These are the numbers you use for counting. They answer the question "How many?" Examples include one (1), two (2), three (3), and so on. They represent quantity.
• Ordinal Numbers: These numbers indicate position, rank, or order in a series. They answer the question "Which one?" Examples include first (1st), second (2nd), third (3rd), and so on. They represent rank.

The puzzle for a programmer arises because the rules for converting a cardinal number to an ordinal one in English are not uniform. You can't just append a "th" to every number. The suffix depends entirely on the last digit or, in some special cases, the last two digits of the number.

The Rules of the Game

The core logic for this conversion, which our CoffeeScript solution must implement, follows a specific hierarchy of rules:

1. The "Teen" Exception: Any number ending in 11, 12, or 13 uses the suffix "th". This rule takes precedence over all others. For example, 11 becomes "11th" (not "11st"), 112 becomes "112th" (not "112nd").
2. The "First" Rule: If the "teen" exception doesn't apply, any number ending in 1 uses the suffix "st". For example, 1 becomes "1st", 21 becomes "21st", and 101 becomes "101st".
3. The "Second" Rule: If the first two rules don't apply, any number ending in 2 uses the suffix "nd". For example, 2 becomes "2nd", 32 becomes "32nd", and 102 becomes "102nd".
4. The "Third" Rule: If none of the above rules apply, any number ending in 3 uses the suffix "rd". For example, 3 becomes "3rd", 43 becomes "43rd", and 103 becomes "103rd".
5. The Default Rule: Any number that does not meet any of the conditions above uses the suffix "th". This includes all numbers ending in 0, 4, 5, 6, 7, 8, or 9.

This hierarchy of checks is the key. Our code must evaluate the most specific exception (the teens) first before moving on to the more general rules. This is a classic example of handling edge cases in software development.

---

How to Implement Ordinal Logic in CoffeeScript: A Detailed Walkthrough

Now, let's translate these English grammar rules into elegant CoffeeScript code. The solution from the kodikra.com module provides a clean, class-based approach to encapsulate this logic, making it reusable and easy to understand. We will analyze it piece by piece to reveal its inner workings.

The Complete CoffeeScript Solution

Here is the full code for our Lineup class. It contains two methods: format, which constructs the final sentence, and getSuffix, which contains the core ordinal logic.

class Lineup
  @format: (name, number) ->
    suffix = @getSuffix number
    "#{name}, you are the #{number}#{suffix} customer we serve today. Thank you!"

  @getSuffix: (number) ->
    mod100 = number % 100
    mod10 = number % 10

    if mod100 in [11, 12, 13]
      'th'
    else if mod10 is 1
      'st'
    else if mod10 is 2
      'nd'
    else if mod10 is 3
      'rd'
    else
      'th'

module.exports = Lineup

Line-by-Line Code Breakdown

Let's dissect this code to understand every decision and piece of syntax. This deep dive will clarify not just the solution, but also key features of the CoffeeScript language.

1. The Class Definition

class Lineup

CoffeeScript provides a clean, classical syntax for creating classes, which compiles down to JavaScript's prototype-based inheritance. Here, we define a class named Lineup to act as a container for our formatting logic. This is good practice for organization, preventing our functions from polluting the global namespace.

2. The `format` Static Method

  @format: (name, number) ->
    suffix = @getSuffix number
    "#{name}, you are the #{number}#{suffix} customer we serve today. Thank you!"

• @format: ...: The @ symbol in a class context is a shortcut for this.. When used directly on a method definition like this (@format instead of format:), it defines a static method. This means we can call it directly on the class (Lineup.format(...)) without needing to create an instance (new Lineup()). This is perfect for utility functions like ours.
• (name, number) ->: This is CoffeeScript's function definition syntax. The method accepts two arguments: name (a string) and number (an integer).
• suffix = @getSuffix number: This line is the heart of the composition. It calls our other helper method, getSuffix, passing the number to it. The return value (the correct ordinal suffix) is stored in the suffix variable.
• "#{name}, you are the #{number}#{suffix}...": This is CoffeeScript's powerful string interpolation. It allows you to embed expressions and variables directly into a double-quoted string by wrapping them in #{}. This is far more readable and less error-prone than traditional string concatenation with the + operator. The final, perfectly formatted sentence is implicitly returned by the function.

3. The `getSuffix` Static Method: The Core Logic

This method is where the grammatical rules are implemented. Its sole responsibility is to take a number and return the correct two-letter suffix.

  @getSuffix: (number) ->
    mod100 = number % 100
    mod10 = number % 10

• @getSuffix: (number) ->: Another static method that takes a single number as input.
• mod100 = number % 100: This line uses the modulo operator (%). This operator returns the remainder of a division. By calculating number % 100, we isolate the last two digits of the number. For example, 311 % 100 is 11, and 42 % 100 is 42. This is essential for checking for the "teen" exceptions.
• mod10 = number % 10: Similarly, number % 10 isolates the very last digit. For example, 311 % 10 is 1, and 42 % 10 is 2. This is used for the standard "st", "nd", and "rd" rules.

The subsequent if/else if/else chain is a direct translation of our rules, executed in the correct order of precedence.

    if mod100 in [11, 12, 13]
      'th'

This is the first and most important check. CoffeeScript's in operator is a convenient way to check if a value exists within an array. If the last two digits of the number are 11, 12, or 13, we immediately return 'th' and the function stops executing. This correctly handles cases like 11th, 112th, and 913th.

    else if mod10 is 1
      'st'

If the first condition was false, we proceed to this check. We use the mod10 variable to see if the number ends in 1. CoffeeScript's is keyword compiles to JavaScript's strict equality operator (===), which is best practice. If true, we return 'st'. This handles 1st, 21st, 101st, etc.

    else if mod10 is 2
      'nd'
    else if mod10 is 3
      'rd'

Following the same pattern, we check if the number ends in 2 (for 'nd') or 3 (for 'rd').

    else
      'th'

Finally, if none of the preceding conditions were met, we reach the else block. This is our default case, which catches all other numbers (those ending in 0, 4, 5, 6, 7, 8, 9). It correctly returns 'th'.

---

Visualizing the Logic Flow

To better understand how the code makes decisions, we can visualize the process using flow diagrams. These diagrams illustrate the path the program takes from input to output.

High-Level `format` Method Flow

This diagram shows the overall process of the main format function.

    ● Start: Receive (name, number)
    │
    ▼
  ┌───────────────────────────┐
  │ Call getSuffix(number)    │
  │ to determine the suffix   │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Store returned value      │
  │ in `suffix` variable      │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Interpolate name, number, │
  │ and suffix into a string  │
  └────────────┬──────────────┘
               │
               ▼
    ● End: Return final sentence

Detailed `getSuffix` Decision Logic

This diagram provides a granular look at the conditional branching inside the `getSuffix` method, which is the brain of the operation.

    ● Start: Receive (number)
    │
    ▼
  ┌───────────────────────────┐
  │ Calculate mod100 = number % 100 │
  │ Calculate mod10  = number % 10  │
  └────────────┬──────────────┘
               │
               ▼
    ◆ Is mod100 in [11, 12, 13]?
   ╱                           ╲
  Yes                           No
  │                              │
  ▼                              ▼
┌──────────┐      ◆ Is mod10 equal to 1?
│ Return 'th' │     ╱                     ╲
└──────────┘    Yes                      No
                │                         │
                ▼                         ▼
              ┌──────────┐    ◆ Is mod10 equal to 2?
              │ Return 'st' │   ╱                     ╲
              └──────────┘  Yes                      No
                              │                         │
                              ▼                         ▼
                            ┌──────────┐    ◆ Is mod10 equal to 3?
                            │ Return 'nd' │   ╱                     ╲
                            └──────────┘  Yes                      No
                                            │                         │
                                            ▼                         ▼
                                          ┌──────────┐              ┌──────────┐
                                          │ Return 'rd' │              │ Return 'th' │
                                          └──────────┘              └──────────┘

---

Alternative Approaches and Code Optimizations

The provided solution is clean, readable, and efficient. However, exploring alternative implementations is a valuable exercise for any developer. It broadens your understanding of the language and different programming paradigms. In CoffeeScript, a switch statement can often provide a more expressive alternative to a long if/else if chain.

Refactoring with a `switch` Statement

A switch statement can make the intent of the code even clearer by grouping conditions against a single variable. Let's refactor the getSuffix method.

  @getSuffix_switch: (number) ->
    # First, handle the special "teen" case which overrides all others
    return 'th' if number % 100 in [11, 12, 13]

    # If not a teen, use a switch on the last digit
    switch number % 10
      when 1 then 'st'
      when 2 then 'nd'
      when 3 then 'rd'
      else 'th'

Analysis of the `switch` Version:

• Clarity: For many developers, the switch statement is more declarative. It clearly states: "based on the value of number % 10, choose one of the following."
• Postfix `if`: The line return 'th' if number % 100 in [11, 12, 13] uses CoffeeScript's postfix conditional. This is a highly readable way to express a simple condition, often called a "guard clause." It handles the edge case upfront, allowing the main logic to be simpler.
• Structure: By handling the teen exception first with a guard clause, the subsequent switch statement becomes very clean and only has to worry about the general rules. This separation of concerns can improve maintainability.

Both the original if/else version and this switch version are perfectly valid and perform similarly. The choice between them often comes down to team preference and coding style. Learning both patterns makes you a more versatile developer.

---

The Bigger Picture: Custom Logic vs. Production Libraries

While building this function from scratch is an excellent learning experience from the kodikra curriculum, it's important to know when to use custom code versus when to reach for a battle-tested library in a real-world, production environment.

This decision often involves a trade-off between control, performance, and development speed. Here's a breakdown of the pros and cons.

Aspect	Custom Logic (This Solution)	Third-Party Library (e.g., Moment.js, Intl)
Dependencies	✅ Zero. The code is self-contained, leading to a smaller bundle size and no external points of failure.	❌ Adds a dependency. You must manage the library's version, and it increases the overall size of your project.
Performance	✅ Extremely fast. It's a simple, direct calculation with minimal overhead.	⚠️ Potentially slower. Libraries are built for flexibility and may have more overhead, though often negligible for this task.
Learning Value	✅ Excellent. Forces you to think through edge cases and fundamental programming concepts.	❌ Minimal. You learn the library's API, not the underlying logic.
Internationalization (i18n)	❌ None. This logic is hardcoded for English. It will not work for Spanish, French, or other languages with different ordinal rules.	✅ Robust support. Modern libraries (like JavaScript's built-in Intl object) are designed to handle localization and different language rules automatically.
Maintenance	⚠️ Your responsibility. If a new edge case is found, you have to fix it.	✅ Community-maintained. Bugs are typically found and fixed by a large community of developers.

When to Choose Which?

• Choose Custom Logic: For small projects, learning exercises (like this one!), or applications where you are certain you will only ever need English and want to keep dependencies to an absolute minimum.
• Choose a Library: For large-scale applications, projects that require support for multiple languages (i18n), or when dealing with more complex formatting needs like dates, times, and currencies. Using the platform's built-in Intl API is often the best choice for modern web development.

---

Frequently Asked Questions (FAQ)

Why is it necessary to check for 11, 12, and 13 first?

This is the most critical part of the logic. The numbers 11, 12, and 13 are special exceptions to the general rules. If you checked for numbers ending in '1', '2', or '3' first, you would incorrectly label 11 as "11st", 12 as "12nd", and 13 as "13rd". By checking for the `mod100` value first, you handle these specific "teen" cases before the general rules get a chance to run.

How does this CoffeeScript code translate to modern JavaScript (ES6+)?

CoffeeScript's syntax compiles directly to JavaScript. The logic remains identical. Here's what the getSuffix method would look like in modern ES6 JavaScript:

const getSuffix = (number) => {
  const mod100 = number % 100;
  const mod10 = number % 10;

  if ([11, 12, 13].includes(mod100)) {
    return 'th';
  }
  if (mod10 === 1) {
    return 'st';
  }
  if (mod10 === 2) {
    return 'nd';
  }
  if (mod10 === 3) {
    return 'rd';
  }
  return 'th';
};

As you can see, the core concepts—modulo, conditional checks, and return values—are universal.

What is the `module.exports = Lineup` line for?

That line is part of the CommonJS module system, popularized by Node.js. It makes the Lineup class available for use in other files. Another file could then import and use our class with a line like Lineup = require('./lineup'). This is fundamental for building larger, modular applications.

Can this logic handle numbers larger than 999?

Yes, absolutely. The logic is based entirely on the last one or two digits of the number. It doesn't matter how large the number is. For example, for the number 1,234,511, mod100 would be 11, correctly identifying the "teen" exception and returning "th". For 999,901, mod10 would be 1, correctly returning "st".

Is CoffeeScript still a relevant language to learn?

While CoffeeScript's popularity has waned with the rise of modern JavaScript (ES6+ and TypeScript), learning it provides significant value. It teaches you about transpilation, clean syntax, and many of its ideas (like arrow functions, classes, and destructuring) directly influenced the development of modern JavaScript. Understanding CoffeeScript provides a unique historical context and strengthens your overall JavaScript ecosystem knowledge. Explore our complete CoffeeScript learning path to see how its concepts apply today.

What does the `in` operator do in CoffeeScript?

The in operator is a syntactic sugar for checking for the existence of an element within an array. The expression mod100 in [11, 12, 13] compiles to JavaScript code that checks if the value of mod100 is present in the given array, making the code more readable and concise than writing mod100 === 11 || mod100 === 12 || mod100 === 13.

---

Conclusion: From Logic to User Experience

Successfully solving the "Line Up" challenge is a significant milestone. You've moved beyond simple syntax and delved into the world of algorithmic thinking, edge case management, and human-centric design. The solution demonstrates the power of the modulo operator for pattern detection and the importance of structuring conditional logic correctly to handle exceptions before general rules.

The true takeaway is that elegant code often comes from a deep understanding of the problem domain—in this case, the quirky rules of English grammar. By translating those rules into a clean, reusable CoffeeScript class, you've created a tool that can enhance user interfaces, generate readable reports, and add a touch of personality to any application. This exercise, part of the comprehensive kodikra.com curriculum, is a perfect example of how fundamental programming concepts are the building blocks for creating delightful user experiences.

Technology Disclaimer: The code and concepts discussed in this article are based on the stable version of CoffeeScript 2. The logical principles are timeless and directly applicable to modern JavaScript (ES6+) and other programming languages.

---

Published by Kodikra — Your trusted Coffeescript learning resource.