The length of "👨‍👩‍👧" is 8 in JavaScript, 5 in Python, 18 in Rust and 1 in Swift

// Count the same strings in four ways (JavaScript)
const samples = [
  ['A', 'A'],
  ['あ', 'あ'],
  ['が (one code point)', 'が'],
  ['が (か + dakuten)', 'が'],
  ['𠮷', '\u{20BB7}'],
  ['𠮷野家', '\u{20BB7}野家'],
  ['😀', '\u{1F600}'],
  ['🇯🇵', '\u{1F1EF}\u{1F1F5}'],
  ['👨‍👩‍👧', '\u{1F468}‍\u{1F469}‍\u{1F467}'],
];
const segmenter = new Intl.Segmenter('ja', { granularity: 'grapheme' });
for (const [name, s] of samples) {
  const utf8 = Buffer.byteLength(s, 'utf8');
  const utf16 = s.length;                       // JavaScript's length is the number of UTF-16 code units
  const codePoints = [...s].length;             // spreading gives code points
  const graphemes = [...segmenter.segment(s)].length;
  console.log(`${name}\tutf8=${utf8}\tutf16=${utf16}\tcodepoints=${codePoints}\tgraphemes=${graphemes}`);
}

# Count the same strings in four ways (Python). Counting graphemes is not in the standard library, so we use regex
import regex  # pip install regex

samples = [
    ('A', 'A'),
    ('あ', 'あ'),
    ('が (one code point)', 'が'),
    ('が (か + dakuten)', 'が'),
    ('𠮷', '\U00020BB7'),
    ('𠮷野家', '\U00020BB7野家'),
    ('😀', '\U0001F600'),
    ('🇯🇵', '\U0001F1EF\U0001F1F5'),
    ('👨‍👩‍👧', '\U0001F468‍\U0001F469‍\U0001F467'),
]
for name, s in samples:
    utf8 = len(s.encode('utf-8'))
    utf16 = len(s.encode('utf-16-le')) // 2       # number of UTF-16 code units
    codepoints = len(s)                           # Python's len is the number of code points
    graphemes = len(regex.findall(r'\X', s))      # \X matches one user-perceived character
    print(f'{name}\tutf8={utf8}\tutf16={utf16}\tcodepoints={codepoints}\tgraphemes={graphemes}')

// Count the same strings in four ways (Swift)
let samples: [(String, String)] = [
    ("A", "A"),
    ("あ", "あ"),
    ("が (one code point)", "\u{304C}"),
    ("が (か + dakuten)", "\u{304B}\u{3099}"),
    ("𠮷", "\u{20BB7}"),
    ("𠮷野家", "\u{20BB7}野家"),
    ("😀", "\u{1F600}"),
    ("🇯🇵", "\u{1F1EF}\u{1F1F5}"),
    ("👨‍👩‍👧", "\u{1F468}\u{200D}\u{1F469}\u{200D}\u{1F467}"),
]
for (name, s) in samples {
    // Swift's count is the number of user-perceived characters (grapheme clusters)
    print("\(name)\tutf8=\(s.utf8.count)\tutf16=\(s.utf16.count)\tcodepoints=\(s.unicodeScalars.count)\tgraphemes=\(s.count)")
}

// Count the same strings in three ways (Rust). Graphemes aren't in the standard library, so we don't count them here
fn main() {
    let samples = [
        ("A", "A".to_string()),
        ("あ", "あ".to_string()),
        ("が (one code point)", "\u{304C}".to_string()),
        ("が (か + dakuten)", "\u{304B}\u{3099}".to_string()),
        ("𠮷", "\u{20BB7}".to_string()),
        ("𠮷野家", "\u{20BB7}野家".to_string()),
        ("😀", "\u{1F600}".to_string()),
        ("🇯🇵", "\u{1F1EF}\u{1F1F5}".to_string()),
        ("👨‍👩‍👧", "\u{1F468}\u{200D}\u{1F469}\u{200D}\u{1F467}".to_string()),
    ];
    for (name, s) in samples.iter() {
        // len() is the number of UTF-8 bytes, chars().count() is the number of code points
        println!("{}\tutf8={}\tutf16={}\tcodepoints={}", name, s.len(), s.encode_utf16().count(), s.chars().count());
    }
}

const s = 'a\u{20BB7}b';                       // a𠮷b
const cut = s.slice(0, 2);                      // take the first 2 code units
console.log(JSON.stringify(cut));               // cut in the middle of 𠮷: a broken character
console.log(cut.isWellFormed());                // false

const family = '\u{1F468}‍\u{1F469}‍\u{1F467}';
console.log([...family].slice(0, 3).join(''));  // not a family any more: two people

family = '\U0001F468‍\U0001F469‍\U0001F467'
print(family[:3])   # not a family any more: two people
print(family[:1])   # just one person

const a = 'が';          // が (one code point)
const b = 'が';    // か + dakuten (two code points)
console.log(a, b);           // they look the same
console.log(a === b, a.length, b.length);
console.log(a === b.normalize('NFC'));   // equal once normalized

import unicodedata

a = 'が'          # が (one code point)
b = 'が'    # か + dakuten (two code points)
print(a, b)           # they look the same
print(a == b, len(a), len(b))
print(a == unicodedata.normalize('NFC', b))   # equal once normalized

// Take the first n user-perceived characters (graphemes)
const segmenter = new Intl.Segmenter('ja', { granularity: 'grapheme' });
const graphemes = s => [...segmenter.segment(s)].map(x => x.segment);
const truncate = (s, n) => graphemes(s).slice(0, n).join('');

console.log(truncate('a\u{20BB7}b家', 2));                                              // a𠮷
console.log(truncate('\u{1F468}‍\u{1F469}‍\u{1F467}と\u{1F1EF}\u{1F1F5}', 1));  // the family emoji stays whole
console.log(graphemes('\u{1F1EF}\u{1F1F5}\u{1F1FA}\u{1F1F8}').length);                    // two flags -> 2

# Take the first n user-perceived characters (graphemes)
import regex  # pip install regex

def graphemes(s):
    return regex.findall(r'\X', s)

def truncate(s, n):
    return ''.join(graphemes(s)[:n])

print(truncate('a\U00020BB7b家', 2))                                                   # a𠮷
print(truncate('\U0001F468‍\U0001F469‍\U0001F467と\U0001F1EF\U0001F1F5', 1))  # the family emoji stays whole
print(len(graphemes('\U0001F1EF\U0001F1F5\U0001F1FA\U0001F1F8')))                       # two flags -> 2