Count emojis only from a string

I think the problem is that the strings you've posted contain Unicode features than the .Net Framework (as opposed to dotnet core / dotnet 5) doesn't understand.

For example, the emoji "‍‍‍" is called Family: Woman, Woman, Girl, Boy and although it renders as a single image, it's composed of 4 separate emoji that are combined with a Zero Width Joiner:

$zwj   = [System.Char]::ConvertFromUtf32( 0x0200D ); # zero width joiner
$girl  = [System.Char]::ConvertFromUtf32( 0x1F466 );
$boy   = [System.Char]::ConvertFromUtf32( 0x1F467 );
$man   = [System.Char]::ConvertFromUtf32( 0x1F468 );
$woman = [System.Char]::ConvertFromUtf32( 0x1F469 );

# https://emojipedia.org/family-woman-woman-girl-boy/
$family_woman_woman_girl_boy = $woman + $zwj + $woman + $zwj + $girl + $zwj + $boy;

$family_woman_woman_girl_boy
# ‍‍‍

If you run your sample in PowerShell 7.1 (which is based on dotnet core) you get this:

# ‍‍‍
$text = $family_woman_woman_girl_boy;
$se = [System.Globalization.StringInfo]::GetTextElementEnumerator($text)
$cnt = 0
while($se.MoveNext()) { $cnt += 1 }
$cnt
# 1

but if you run it in Windows PowerShell 5.1 (based on the .net framework) you get:

# ‍‍‍
$text = $family_woman_woman_girl_boy;
$se = [System.Globalization.StringInfo]::GetTextElementEnumerator($text)
$cnt = 0
while($se.MoveNext()) { $cnt += 1 }
$cnt
# 7

and you can see PS 5.1 is counting the individual emoji and the $zwj = 4 + 3 = 7.

In your first example $str = '‍‍‍‍️‍' you've also got these emoji:

$rainbow           = [System.Char]::ConvertFromUtf32( 0x1F308 );
$waving_white_flag = [System.Char]::ConvertFromUtf32( 0x1F3F3 );
$light_skin_tone   = [System.Char]::ConvertFromUtf32( 0x1F3FB );
$red_hair          = [System.Char]::ConvertFromUtf32( 0x1F9B0 );
$var_16            = [System.Char]::ConvertFromUtf32( 0x0FE0F ); # variation selector-16

# https://emojipedia.org/woman-light-skin-tone-red-hair/
$woman_light_skin_tone_red_hair = $woman + $light_skin_tone + $zwj + $red_hair;

# https://emojipedia.org/rainbow-flag/
$rainbow_flag = $waving_white_flag + $var_16 + $zwj + $rainbow;

and then your sample in PowerShell 7.1 is:

# ‍‍‍‍️‍
$text = $woman_light_skin_tone_red_hair + $family_woman_woman_girl_boy + $rainbow_flag;
$se = [System.Globalization.StringInfo]::GetTextElementEnumerator($text)
$cnt = 0
while($se.MoveNext()) { $cnt += 1 }
$cnt
# 3

and in PowerShell 5.1 is:

# ‍‍‍‍️‍
$text = $woman_light_skin_tone_red_hair + $family_woman_woman_girl_boy + $rainbow_flag;
$se = [System.Globalization.StringInfo]::GetTextElementEnumerator($text)
$cnt = 0
while($se.MoveNext()) { $cnt += 1 }
$cnt
# 14

Note that PowerShell 5.1 is not counting $var_16, but it is counting $zwj, so the total is 14, not 15.

If you break your other examples down in the same way the results make more sense.

In addition, if you break the composite emoji down into individual items the PowerShell 5.1 version works fine:

# 
$text = $woman + $woman + $girl + $boy;
$se = [System.Globalization.StringInfo]::GetTextElementEnumerator($text)
$cnt = 0
while($se.MoveNext()) { $cnt += 1 }
$cnt
# 4

so it's specifically a problem with the composite emoji.

That seems to explain why you're seeing those results, but as for how to work around it...

Basically, emojis are a huge pain. Let's take this string, how many emoji characters are there?

'foo ‍‍   bar'

That's right, there are seven valid emoji characters. Emojis can be combined or modified with others:

‍‍ =  ‍ + ‍ + 
 

 =   + 

In UTF16 (as powershell's [char] is 16-bit), it looks something like this:

# emoji character is split in two for UTF16, and "glued" together with zero-width-joiner character U+200D to other emojis
‍‍ = '0xd83d,0xdc68,0x200d,0xd83d,0xdc69,0x200d,0xd83d,0xdc66'

# modified with a variation selector character
 = '0xd83d,0xdc67,0xd83c,0xdffb'

This function works fine to get emojis from a string for educational purposes in both 5.1 and v7. I just wrote it for a one-time issue though - it will not work in many circumstances (see below):

Function Get-Emojis {
param ($string = (Get-Content emojis.txt -Encoding UTF8))

# Iterate through each char until emoji
$result = for ($i = 0; $i -lt $string.length) {

    # character arrays are made of UTF16 characters, so emojis are always split up into pairs
    # check if character is part of a surrogate pair, otherwise increment
    if ( [System.Char]::IsSurrogatePair($string[$i],$string[$i+1]) ) {
        
        # add char pair to output
        [char[]]$output = $string[$i],$string[$i+1]
        $iIsEmoji = $true
        $i+=2
        
        # check following characters for either a zero-width-joiner or a variation selector, and add to output.
        # loop because many emojis can be combined
        While ($iIsEmoji) {
            # check if next character is a joiner (unicode 200D)
            # or a variation selector character (FE00-FE0F):
            if ( $string[$i] -in (0xFE00..0xFE0F+0x200d) ) {
                $output += $string[$i]
                $i+=1
            }

            #check if next two characters are emoji modifiers (skin tone etc) (U+1F300-U+1F5FF)
            elseif ( [System.Char]::IsSurrogatePair($string[$i],$string[$i+1]) ) {
                # check if pair is within modifier character range
                if ([System.char]::ConvertToUtf32($string[$i],$string[$i+1]) -in 0x1F300..0x1F5FF ) {
                    $output += $string[$i],$string[$i+1]
                    $i+=2
                }
                # but if not in range, it's probably a separate emoji, so end.
                else { $iIsEmoji = $false }
            }
            else { $iIsEmoji = $false }
        }
 
        # Return full emoji string
        $output -join $null
    }
    else {$i += 1}
}
$result
}

# Usage: Only one string at a time.
# note: specify encoding when importing weird text from a file - otherwise different powershell versions can misbehave 

# example: What emoji is ‍‍   this
$string = get-content C:\temp\emojis.txt -Encoding utf8
$emojis = Get-Emojis -string $string
$emojis.count

4

Warnings:

• This will grab any character that is above the utf16 limit of U+FFFF (not just emojis)
• It only grabs characters above that limit. No dingbats or many other types of symbols.
• it's not very efficient.

It shows the process though, so it may be helpful

Hmm, enumeraterunes() in ps 7 says '14' for the first one and '12' for the emojis in the last one. $str2 has the simplest behavior where each emoji is 2 surrogate characters.

$str = '‍‍‍‍️‍'
$str.length # 22
$str.EnumerateRunes() | measure | % count # 14

$str2 = ''              
$str2.length # 14
$str2.EnumerateRunes() | measure | % count # 7

$str3 = '‍‍‍‍'
$str3.length # 20
$str3.EnumerateRunes() | measure | % count # 12