Ordena una lista de objetos por un campo snippet

// copy first — sort MUTATES the receiver:
const sorted = [...items].sort((a, b) => a.name.localeCompare(b.name));

// machine keys, or when locale rules are wrong for the data:
const byTitle = [...items].sort((a, b) => (a.title < b.title ? -1 : a.title > b.title ? 1 : 0));

// multi-key tiebreak: 0 (equal) falls through to the next comparator
const byTitleThenDate = [...items].sort(
  (a, b) => a.title.localeCompare(b.title) || new Date(a.date) - new Date(b.date),
);

interface Item {
  title: string;
  date: string; // ISO — strings compare chronologically
}

const byTitle = (a: Item, b: Item): number => a.title.localeCompare(b.title);

// multi-key: compose comparators with || — zero (equal) falls through
const byTitleThenDate = (a: Item, b: Item): number =>
  byTitle(a, b) || b.date.localeCompare(a.date); // newest first on ties

import "sort"

// fast — but NOT stable: equal-Title rows may arrive in any order
sort.Slice(items, func(i, j int) bool {
	return items[i].Title < items[j].Title
})

// equal-key rows keep their input order:
sort.SliceStable(items, func(i, j int) bool {
	return items[i].Title < items[j].Title
})

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
struct Item {
    title: String,
}

// stable — equal-key rows keep their input order
items.sort_by(|a, b| a.title.cmp(&b.title));

// multi-key: tuples compare field-by-field, the free tiebreak chain
items.sort_by(|a, b| (&a.last, &a.first).cmp(&(&b.last, &b.first)));

// faster, no stability guarantee — fine when keys are unique
items.sort_unstable_by(|a, b| a.title.cmp(&b.title));

// <=> (spaceship) is the comparator primitive: -1, 0, or 1, no branches
usort($items, fn($a, $b) => $a['title'] <=> $b['title']);

// multi-key: compare fields left to right until one differs
usort($items, fn($a, $b) => [$a['last'], $a['first']] <=> [$b['last'], $b['first']]);

// usort re-indexes numerically — make the reset explicit, not accidental:
$items = array_values($items);

sorted_items = sorted(items, key=lambda x: x['title'])  # new list

# multi-key via tuple — ties break on the second field:
by_last_first = sorted(items, key=lambda x: (x['last'], x['first']))

# descending: reverse=True, not negation (only works on numbers)
by_title_desc = sorted(items, key=lambda x: x['title'], reverse=True)

# items.sort(key=...) sorts in place instead

// LINQ — lazy, stable, never mutates the source:
var sorted = items.OrderBy(i => i.Title)
                  .ThenBy(i => i.Date);

// in place, on List<T> — UNSTABLE:
items.Sort((a, b) => string.CompareOrdinal(a.Title, b.Title));

import java.util.Comparator;

items.sort(Comparator.comparing(Item::title)
                      .thenComparing(Item::date));

// nullable field — decide where the nulls land, or get an NPE mid-sort:
items.sort(Comparator.comparing(
        Item::title,
        Comparator.nullsLast(Comparator.naturalOrder())));

let sorted = items.sorted { $0.title < $1.title }

// explicit multi-key tiebreak:
let full = items.sorted {
    $0.title == $1.title ? $0.date < $1.date : $0.title < $1.title
}

// mutating form, on a var array:
var mutable = items
mutable.sort { $0.title < $1.title }

val sorted = items.sortedBy { it.title } // RETURNS a new list

// multi-key, mixed directions:
val full = items.sortedWith(
    compareBy<Item> { it.title }.thenByDescending { it.date })

// in place, on a MutableList — returns Unit, not a list:
items.sortBy { it.title }

# key block — the key is computed once per element:
sorted = items.sort_by { |i| i[:title] }

# array keys compare element-wise — the multi-key form:
by_last_first = items.sort_by { |i| [i[:last], i[:first]] }

# two-arg comparator block, when you need full control (descending on ties):
items.sort { |a, b| [a[:title], b[:date]] <=> [b[:title], a[:date]] }

const std = @import("std");

const Item = struct { title: []const u8 };

fn byTitle(_: void, a: Item, b: Item) bool {
    return std.mem.lessThan(u8, a.title, b.title);
}

// stable; the context arg ({} here) is mandatory even when unused:
std.mem.sort(Item, items, {}, byTitle);

// when equal-key order does not matter and speed does:
std.sort.pdq(Item, items, {}, byTitle);