What Is the Regex to Extract All the Emojis from a String

What is the regex to extract all the emojis from a string?

the pdf that you just mentioned says Range: 1F300–1F5FF for Miscellaneous Symbols and Pictographs. So lets say I want to capture any character lying within this range. Now what to do?

Okay, but I will just note that the emoji in your question are outside that range! :-)

The fact that these are above 0xFFFF complicates things, because Java strings store UTF-16. So we can't just use one simple character class for it. We're going to have surrogate pairs. (More: http://www.unicode.org/faq/utf_bom.html)

U+1F300 in UTF-16 ends up being the pair \uD83C\uDF00; U+1F5FF ends up being \uD83D\uDDFF. Note that the first character went up, we cross at least one boundary. So we have to know what ranges of surrogate pairs we're looking for.

Not being steeped in knowledge about the inner workings of UTF-16, I wrote a program to find out (source at the end — I'd double-check it if I were you, rather than trusting me). It tells me we're looking for \uD83C followed by anything in the range \uDF00-\uDFFF (inclusive), or \uD83D followed by anything in the range \uDC00-\uDDFF (inclusive).

So armed with that knowledge, in theory we could now write a pattern:

// This is wrong, keep reading
Pattern p = Pattern.compile("(?:\uD83C[\uDF00-\uDFFF])|(?:\uD83D[\uDC00-\uDDFF])");

That's an alternation of two non-capturing groups, the first group for the pairs starting with \uD83C, and the second group for the pairs starting with \uD83D.

But that fails (doesn't find anything). I'm fairly sure it's because we're trying to specify half of a surrogate pair in various places:

Pattern p = Pattern.compile("(?:\uD83C[\uDF00-\uDFFF])|(?:\uD83D[\uDC00-\uDDFF])");
// Half of a pair --------------^------^------^-----------^------^------^

We can't just split up surrogate pairs like that, they're called surrogate pairs for a reason. :-)

Consequently, I don't think we can use regular expressions (or indeed, any string-based approach) for this at all. I think we have to search through char arrays.

char arrays hold UTF-16 values, so we can find those half-pairs in the data if we look for it the hard way:

String s = new StringBuilder()
                .append("Thats a nice joke ")
                .appendCodePoint(0x1F606)
                .appendCodePoint(0x1F606)
                .appendCodePoint(0x1F606)
                .append(" ")
                .appendCodePoint(0x1F61B)
                .toString();
char[] chars = s.toCharArray();
int index;
char ch1;
char ch2;

index = 0;
while (index < chars.length - 1) { // -1 because we're looking for two-char-long things
    ch1 = chars[index];
    if ((int)ch1 == 0xD83C) {
        ch2 = chars[index+1];
        if ((int)ch2 >= 0xDF00 && (int)ch2 <= 0xDFFF) {
            System.out.println("Found emoji at index " + index);
            index += 2;
            continue;
        }
    }
    else if ((int)ch1 == 0xD83D) {
        ch2 = chars[index+1];
        if ((int)ch2 >= 0xDC00 && (int)ch2 <= 0xDDFF) {
            System.out.println("Found emoji at index " + index);
            index += 2;
            continue;
        }
    }
    ++index;
}

Obviously that's just debug-level code, but it does the job. (In your given string, with its emoji, of course it won't find anything as they're outside the range. But if you change the upper bound on the second pair to 0xDEFF instead of 0xDDFF, it will. No idea if that would also include non-emojis, though.)

Source of my program to find out what the surrogate ranges were:

public class FindRanges {

    public static void main(String[] args) {
        char last0 = '\0';
        char last1 = '\0';
        for (int x = 0x1F300; x <= 0x1F5FF; ++x) {
            char[] chars = new StringBuilder().appendCodePoint(x).toString().toCharArray();
            if (chars[0] != last0) {
                if (last0 != '\0') {
                    System.out.println("-\\u" + Integer.toHexString((int)last1).toUpperCase());
                }
                System.out.print("\\u" + Integer.toHexString((int)chars[0]).toUpperCase() + " \\u" + Integer.toHexString((int)chars[1]).toUpperCase());
                last0 = chars[0];
            }
            last1 = chars[1];
        }
        if (last0 != '\0') {
            System.out.println("-\\u" + Integer.toHexString((int)last1).toUpperCase());
        }
    }
}

Output:

\uD83C \uDF00-\uDFFF
\uD83D \uDC00-\uDDFF

Is there a Regex to match all unicode Emojis?

there is a npm package that can match all unicode emojis!
link to the package https://www.npmjs.com/package/emoji-regex
and here is some example code!

//this is to import the emoji regex package.
const emojiRegex = require('emoji-regex/RGI_Emoji.js');

//this in the actual command body. 
const regex = emojiRegex();
let a1 = message.content.match(regex)
message.channel.send(a1)

then if you activate the command: -test /p>

it will return with: /p>

Very useful!!

Filter out multiple emojis from Unicode text in Python

Little change in emoji_pattern will do the job:

emoji_pattern = re.compile(u"(["                     # .* removed
u"\U0001F600-\U0001F64F"  # emoticons
u"\U0001F300-\U0001F5FF"  # symbols & pictographs
u"\U0001F680-\U0001F6FF"  # transport & map symbols
u"\U0001F1E0-\U0001F1FF"  # flags (iOS)
                "])", flags= re.UNICODE)             # + removed

for sent in [sent1, sent2, sent3]:
    print(''.join(re.findall(emoji_pattern, sent)))

br>br>br>

How to extract all the emojis from text?

You can use the emoji library. You can check if a single codepoint is an emoji codepoint by checking if it is contained in emoji.UNICODE_EMOJI.

import emoji

def extract_emojis(s):
  return ''.join(c for c in s if c in emoji.UNICODE_EMOJI['en'])

Porting Twemoji regex to extract Unicode emojis in Java

If you're trying to match a single specific codepoint, don't mess with surrogate pairs; refer to it by number:

String emojiPattern = "\\x{1FA94}";

or by name:

String emojiPattern = "\\N{DIYA LAMP}"

If you want to match any codepoint in the block U+1FA94 is in, use the name of the block in a property atom:

String emojiPattern = "\\p{blk=Symbols and Pictographs Extended-A}";

If you switch out any of these three regular expressions your example program will print 'true'.

The problem you're running into is a UTF-16 surrogate pair is a single codepoint, and the RE engine matches codepoints, not code units; you can't match just the low or high half - just the pattern "\ud83e" will fail to match too (When used with Matcher#find instead of Matcher#matches of course), for example. It's all or none.

To do the kind of ranged matching you want, you have to turn away from regular expressions and look at the code units directly. Something like

char[] codeUnits = raw.toCharArray();
for (int i = 0; i < codeUnits.length - 1; i++) {
    if (codeUnits[i] == 0xD83E &&
        (codeUnits[i + 1] >= 0xDE94 && codeUnits[i + 1] <= 0xDE99)) {
        System.out.println("match");
    }
}

How do I extract emojis from a string in Flutter?

You can use

String extractEmojis(String text) {
  RegExp rx = RegExp(r'[\p{Extended_Pictographic}\u{1F3FB}-\u{1F3FF}\u{1F9B0}-\u{1F9B3}]', unicode: true);
  return rx.allMatches(text).map((z) => z.group(0)).toList().join(""); 
}

void main() {
    print(extractEmojis("Hey everyone quot;));
}

Output: /code>

The [\p{Extended_Pictographic}\u{1F3FB}-\u{1F3FF}\u{1F9B0}-\u{1F9B3}] regex is taken from Why do Unicode emoji property escapes match numbers? and it matches emojis proper and light skin to dark skin mode chars and red-haired to white-haired chars.

=SPLIT(REGEXREPLACE(A1,"(.)","$1@"),"@")

=TRANSPOSE(UNIQUE(TRANSPOSE(SPLIT(REGEXREPLACE(A1,"(.)","$1@"),"@"))))

# install.packages("remotes")
# remotes::install_github("hadley/emo")
emojis <- "Christian✝️, Husband, Father‍‍‍, Former TV Meteorologist, GOP, LTC , Dolfan, since ‘75, Yanks Fan⚾️ & UCONN Alum Go Whalers!"
emojis
only_emojis <- emo::ji_extract_all(emojis)
only_emojis

#  emo::ji_extract_all(emojis)
# [[1]]
#  [1] "✝️"      "\U0001f46b"      "\U0001f468"      "\U0001f469"      "\U0001f466"      "\U0001f466"      "\U0001f4fa"      "\U0001f418"      "\U0001f52b"      "\U0001f42c"      "\u26be" "\U0001f3c0"      "\U0001f40b"   

# install.packages("utf8")
utf8::utf8_print(only_emojis[[1]])  
# [1] "✝️​" "​" "​" "​" "​" "​" "​" "​" "​" "​" "⚾​" "​" "​"