Find out if Character in String is emoji?

Question

I need to find out whether a character in a string is an emoji.

For example, I have this character:

let string = ""
let character = Array(string)[0]

I need to find out if that character is an emoji.

Answer 1

What I stumbled upon is the difference between characters, unicode scalars and glyphs.

For example, the glyph ‍‍‍ consists of 7 unicode scalars:

• Four emoji characters:
• In between each emoji is a special character, which works like character glue; see the specs for more info

Another example, the glyph consists of 2 unicode scalars:

• The regular emoji:
• A skin tone modifier:

Last one, the glyph 1️⃣ contains three unicode characters:

• The digit one: 1
• The variation selector
• The Combining Enclosing Keycap: ⃣

So when rendering the characters, the resulting glyphs really matter.

Swift 5.0 and above makes this process much easier and gets rid of some guesswork we needed to do. Unicode.Scalar's new Property type helps is determine what we're dealing with. However, those properties only make sense when checking the other scalars within the glyph. This is why we'll be adding some convenience methods to the Character class to help us out.

For more detail, I wrote an article explaining how this works.

For Swift 5.0, this leaves you with the following result:

extension Character {
    /// A simple emoji is one scalar and presented to the user as an Emoji
    var isSimpleEmoji: Bool {
        guard let firstScalar = unicodeScalars.first else { return false }
        return firstScalar.properties.isEmoji && firstScalar.value > 0x238C
    }

    /// Checks if the scalars will be merged into an emoji
    var isCombinedIntoEmoji: Bool { unicodeScalars.count > 1 && unicodeScalars.first?.properties.isEmoji ?? false }

    var isEmoji: Bool { isSimpleEmoji || isCombinedIntoEmoji }
}

extension String {
    var isSingleEmoji: Bool { count == 1 && containsEmoji }

    var containsEmoji: Bool { contains { $0.isEmoji } }

    var containsOnlyEmoji: Bool { !isEmpty && !contains { !$0.isEmoji } }

    var emojiString: String { emojis.map { String($0) }.reduce("", +) }

    var emojis: [Character] { filter { $0.isEmoji } }

    var emojiScalars: [UnicodeScalar] { filter { $0.isEmoji }.flatMap { $0.unicodeScalars } }
}

Which will give you the following results:

"A̛͚̖".containsEmoji // false
"3".containsEmoji // false
"A̛͚̖▶️".unicodeScalars // [65, 795, 858, 790, 9654, 65039]
"A̛͚̖▶️".emojiScalars // [9654, 65039]
"3️⃣".isSingleEmoji // true
"3️⃣".emojiScalars // [51, 65039, 8419]
"".isSingleEmoji // true
"‍♂️".isSingleEmoji // true
"".isSingleEmoji // true
"⏰".isSingleEmoji // true
"".isSingleEmoji // true
"‍‍‍".isSingleEmoji // true
"".isSingleEmoji // true
"".containsOnlyEmoji // true
"‍‍‍".containsOnlyEmoji // true
"Hello ‍‍‍".containsOnlyEmoji // false
"Hello ‍‍‍".containsEmoji // true
" Héllo ‍‍‍".emojiString // "‍‍‍"
"‍‍‍".count // 1

" Héllœ ‍‍‍".emojiScalars // [128107, 128104, 8205, 128105, 8205, 128103, 8205, 128103]
" Héllœ ‍‍‍".emojis // ["", "‍‍‍"]
" Héllœ ‍‍‍".emojis.count // 2

"‍‍‍‍‍".isSingleEmoji // false
"‍‍‍‍‍".containsOnlyEmoji // true

For older Swift versions, check out this gist containing my old code.

Answer 2

You can use NSString-RemoveEmoji like this:

if string.isIncludingEmoji {

}

Answer 3

Use the following extensions,

extension Character {
    var isSimpleEmoji: Bool {
        guard let firstScalar = unicodeScalars.first else {
            return false
        }
        return firstScalar.properties.isEmoji && firstScalar.value > 0x238C
    }  

    var isCombinedIntoEmoji: Bool {
        unicodeScalars.count > 1 && unicodeScalars.first?.properties.isEmoji ?? false
    }

    var isEmoji: Bool { isSimpleEmoji || isCombinedIntoEmoji }
}

extension String {
    var containsEmoji: Bool {
        contains(where: { $0.isEmoji })
    }
}

How to use

let str = ""
print(str.containsEmoji) // true

Original answer by reference.

Answer 4

You can use this code example or this pod.

To use it in Swift, import the category into the YourProject_Bridging_Header

#import "NSString+EMOEmoji.h"

Then you can check the range for every emoji in your String:

let example: NSString = "string‍‍‍withemojis✊" //string with emojis

let containsEmoji: Bool = example.emo_containsEmoji()

    print(containsEmoji)

// Output: ["true"]

I created an small example project with the code above.

Answer 5

extension String {
    // Returns false for if string contains characters like "Á‍‍1️⃣"
    var hasRestrictedCharacter: Bool {
        contains { !$0.isASCII }
    }
}

let testChars = " d1/Á‍‍1️⃣"

for char in testChars {
    let value = "\(char)".hasRestrictedCharacter
    print("\(char) : \(value)")
}

//  : false
//d : false
//1 : false
/// : false
//Á : true
// : true
//‍‍ : true
// : true
//1️⃣ : true

Answer 6

Future Proof: Manually check the character's pixels; the other solutions will break (and have broken) as new emojis are added.

Note: This is Objective-C (can be converted to Swift)

Over the years these emoji-detecting solutions keep breaking as Apple adds new emojis w/ new methods (like skin-toned emojis built by pre-cursing a character with an additional character), etc.

I finally broke down and just wrote the following method which works for all current emojis and should work for all future emojis.

The solution creates a UILabel with the character and a black background. CG then takes a snapshot of the label and I scan all pixels in the snapshot for any non solid-black pixels. The reason I add the black background is to avoid issues of false-coloring due to Subpixel Rendering

The solution runs VERY fast on my device, I can check hundreds of characters a second, but it should be noted that this is a CoreGraphics solution and should not be used heavily like you could with a regular text method. Graphics processing is data heavy so checking thousands of characters at once could result in noticeable lag.

-(BOOL)isEmoji:(NSString *)character {
    
    UILabel *characterRender = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 1, 1)];
    characterRender.text = character;
    characterRender.font = [UIFont fontWithName:@"AppleColorEmoji" size:12.0f];//Note: Size 12 font is likely not crucial for this and the detector will probably still work at an even smaller font size, so if you needed to speed this checker up for serious performance you may test lowering this to a font size like 6.0
    characterRender.backgroundColor = [UIColor blackColor];//needed to remove subpixel rendering colors
    [characterRender sizeToFit];
    
    CGRect rect = [characterRender bounds];
    UIGraphicsBeginImageContextWithOptions(rect.size,YES,0.0f);
    CGContextRef contextSnap = UIGraphicsGetCurrentContext();
    [characterRender.layer renderInContext:contextSnap];
    UIImage *capturedImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    
    CGImageRef imageRef = [capturedImage CGImage];
    NSUInteger width = CGImageGetWidth(imageRef);
    NSUInteger height = CGImageGetHeight(imageRef);
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    unsigned char *rawData = (unsigned char*) calloc(height * width * 4, sizeof(unsigned char));
    NSUInteger bytesPerPixel = 4;//Note: Alpha Channel not really needed, if you need to speed this up for serious performance you can refactor this pixel scanner to just RGB
    NSUInteger bytesPerRow = bytesPerPixel * width;
    NSUInteger bitsPerComponent = 8;
    CGContextRef context = CGBitmapContextCreate(rawData, width, height,
                                                 bitsPerComponent, bytesPerRow, colorSpace,
                                                 kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
    CGColorSpaceRelease(colorSpace);
    
    CGContextDrawImage(context, CGRectMake(0, 0, width, height), imageRef);
    CGContextRelease(context);
    
    BOOL colorPixelFound = NO;
    
    int x = 0;
    int y = 0;
    while (y < height && !colorPixelFound) {
        while (x < width && !colorPixelFound) {
            
            NSUInteger byteIndex = (bytesPerRow * y) + x * bytesPerPixel;
            
            CGFloat red = (CGFloat)rawData[byteIndex];
            CGFloat green = (CGFloat)rawData[byteIndex+1];
            CGFloat blue = (CGFloat)rawData[byteIndex+2];
            
            CGFloat h, s, b, a;
            UIColor *c = [UIColor colorWithRed:red green:green blue:blue alpha:1.0f];
            [c getHue:&h saturation:&s brightness:&b alpha:&a];//Note: I wrote this method years ago, can't remember why I check HSB instead of just checking r,g,b==0; Upon further review this step might not be needed, but I haven't tested to confirm yet. 
            
            b /= 255.0f;
            
            if (b > 0) {
                colorPixelFound = YES;
            }
            
            x++;
        }
        x=0;
        y++;
    }
    
    return colorPixelFound;
    
}

Answer 7

For Swift 3.0.2, the following answer is the simplest one:

class func stringContainsEmoji (string : NSString) -> Bool
{
    var returnValue: Bool = false

    string.enumerateSubstrings(in: NSMakeRange(0, (string as NSString).length), options: NSString.EnumerationOptions.byComposedCharacterSequences) { (substring, substringRange, enclosingRange, stop) -> () in

        let objCString:NSString = NSString(string:substring!)
        let hs: unichar = objCString.character(at: 0)
        if 0xd800 <= hs && hs <= 0xdbff
        {
            if objCString.length > 1
            {
                let ls: unichar = objCString.character(at: 1)
                let step1: Int = Int((hs - 0xd800) * 0x400)
                let step2: Int = Int(ls - 0xdc00)
                let uc: Int = Int(step1 + step2 + 0x10000)

                if 0x1d000 <= uc && uc <= 0x1f77f
                {
                    returnValue = true
                }
            }
        }
        else if objCString.length > 1
        {
            let ls: unichar = objCString.character(at: 1)
            if ls == 0x20e3
            {
                returnValue = true
            }
        }
        else
        {
            if 0x2100 <= hs && hs <= 0x27ff
            {
                returnValue = true
            }
            else if 0x2b05 <= hs && hs <= 0x2b07
            {
                returnValue = true
            }
            else if 0x2934 <= hs && hs <= 0x2935
            {
                returnValue = true
            }
            else if 0x3297 <= hs && hs <= 0x3299
            {
                returnValue = true
            }
            else if hs == 0xa9 || hs == 0xae || hs == 0x303d || hs == 0x3030 || hs == 0x2b55 || hs == 0x2b1c || hs == 0x2b1b || hs == 0x2b50
            {
                returnValue = true
            }
        }
    }

    return returnValue;
}

Answer 8

extension String {
    func containsEmoji() -> Bool {
        for scalar in unicodeScalars {
            switch scalar.value {
            case 0x3030, 0x00AE, 0x00A9,// Special Characters
            0x1D000...0x1F77F,          // Emoticons
            0x2100...0x27BF,            // Misc symbols and Dingbats
            0xFE00...0xFE0F,            // Variation Selectors
            0x1F900...0x1F9FF:          // Supplemental Symbols and Pictographs
                return true
            default:
                continue
            }
        }
        return false
    }
}

This is my fix, with updated ranges.

Answer 9

The absolutely similar answer to those that wrote before me, but with updated set of emoji scalars.

extension String {
    func isContainEmoji() -> Bool {
        let isContain = unicodeScalars.first(where: { $0.isEmoji }) != nil
        return isContain
    }
}


extension UnicodeScalar {

    var isEmoji: Bool {
        switch value {
        case 0x1F600...0x1F64F,
             0x1F300...0x1F5FF,
             0x1F680...0x1F6FF,
             0x1F1E6...0x1F1FF,
             0x2600...0x26FF,
             0x2700...0x27BF,
             0xFE00...0xFE0F,
             0x1F900...0x1F9FF,
             65024...65039,
             8400...8447,
             9100...9300,
             127000...127600:
            return true
        default:
            return false
        }
    }

}

Answer 10

Native one line code

"❤️".unicodeScalars.contains { $0.properties.isEmoji } // true

_{Works from Swift 5.0}

Answer 11

@StacySmith's answer worked great for me, just wanted to share my own version of it, since all the cool kids are doing it:

extension String.Element {
    var isEmoji: Bool {
        var shouldCheckNextScalar = false
        return unicodeScalars.contains { scalar in
            if shouldCheckNextScalar {
                if scalar == "\u{FE0F}" { // scalar that indicates that character should be displayed as emoji
                    return true
                }
                shouldCheckNextScalar = false
            }

            if scalar.properties.isEmoji {
                if scalar.properties.isEmojiPresentation {
                    return true
                }
                shouldCheckNextScalar = true
            }

            return false
        }
    }
}

extension String {
    var emojiCount: Int {
        reduce(0) { partialResult, character in
            partialResult + (character.isEmoji ? 1 : 0)
        }
    }
}

let test = " hello world ‍‍  ‍♀️ ❤️ 12345"
let count = test.emojiCount // 5

Answer 12

Swift 3 Note:

It appears the cnui_containsEmojiCharacters method has either been removed or moved to a different dynamic library. _containsEmoji should still work though.

let str: NSString = "hello"

@objc protocol NSStringPrivate {
    func _containsEmoji() -> ObjCBool
}

let strPrivate = unsafeBitCast(str, to: NSStringPrivate.self)
strPrivate._containsEmoji() // true
str.value(forKey: "_containsEmoji") // 1


let swiftStr = "hello"
(swiftStr as AnyObject).value(forKey: "_containsEmoji") // 1

Swift 2.x:

I recently discovered a private API on NSString which exposes functionality for detecting if a string contains an Emoji character:

let str: NSString = "hello"

With an objc protocol and unsafeBitCast:

@objc protocol NSStringPrivate {
    func cnui_containsEmojiCharacters() -> ObjCBool
    func _containsEmoji() -> ObjCBool
}

let strPrivate = unsafeBitCast(str, NSStringPrivate.self)
strPrivate.cnui_containsEmojiCharacters() // true
strPrivate._containsEmoji() // true

With valueForKey:

str.valueForKey("cnui_containsEmojiCharacters") // 1
str.valueForKey("_containsEmoji") // 1

With a pure Swift string, you must cast the string as AnyObject before using valueForKey:

let str = "hello"

(str as AnyObject).valueForKey("cnui_containsEmojiCharacters") // 1
(str as AnyObject).valueForKey("_containsEmoji") // 1

Methods found in the NSString header file.

Answer 13

Swift 5 solution using Scalars that works on text, smiley faces , heart emoji ❤️❤️‍ and numbers 0️⃣ 1 2 3 etc

Swift 5 Scalars have isEmoji and isEmojiPresentation properties that will help to find emoji in particular String.

isEmoji - Boolean value indicating whether the scalar has an emoji presentation, whether or not it is the default.

isEmojiPresentation - A Boolean value indicating whether the scalar is one that should be rendered with an emoji presentation, rather than a text presentation, by default.

As you can see by these definitions, we cannot just use isEmoji or isEmojiPresentation on scalars of the string - this will not tell us whether this scalar is really an emoji

Luckily Apple gave us a clue:

testing isEmoji alone on a single scalar is insufficient to determine if a unit of text is rendered as an emoji; a correct test requires inspecting multiple scalars in a Character. In addition to checking whether the base scalar has isEmoji == true, you must also check its default presentation (see isEmojiPresentation) and determine whether it is followed by a variation selector that would modify the presentation.

So finally here is my implementation that works on numbers, smiley faces , text and ❤️ symbols:

import Foundation

extension String {

    func containsEmoji() -> Bool {
        
        for character in self {
            var shouldCheckNextScalar = false
            for scalar in character.unicodeScalars {
               if shouldCheckNextScalar {
                    if scalar == "\u{FE0F}" { // scalar that indicates that character should be displayed as emoji
                        return true
                    }
                    shouldCheckNextScalar = false
                }
                
                if scalar.properties.isEmoji {
                    if scalar.properties.isEmojiPresentation {
                        return true
                    }
                    shouldCheckNextScalar = true
                }
            }
        }
        
        return false
    }
    
}

Tests:

"hello ❤️".containsEmoji()   // true
"1234567890".containsEmoji() // false
"numero 0️⃣".containsEmoji()  // true
"abcde".containsEmoji()      // false
"panda ".containsEmoji()   // true

Answer 14

There is a nice solution for the mentioned task. But Checking Unicode.Scalar.Properties of unicode scalars is good for a single Character. And not flexible enough for Strings.

We can use Regular Expressions instead — more universal approach. There is a detailed description of how it works below. And here goes the solution.

The Solution

In Swift you can check, whether a String is a single Emoji character, using an extension with such a computed property:

extension String {

    var isSingleEmoji : Bool {
        if self.count == 1 {
            let emodjiGlyphPattern = "\\p{RI}{2}|(\\p{Emoji}(\\p{EMod}|\\x{FE0F}\\x{20E3}?|[\\x{E0020}-\\x{E007E}]+\\x{E007F})|[\\p{Emoji}&&\\p{Other_symbol}])(\\x{200D}(\\p{Emoji}(\\p{EMod}|\\x{FE0F}\\x{20E3}?|[\\x{E0020}-\\x{E007E}]+\\x{E007F})|[\\p{Emoji}&&\\p{Other_symbol}]))*"

            let fullRange = NSRange(location: 0, length: self.utf16.count)
            if let regex = try? NSRegularExpression(pattern: emodjiGlyphPattern, options: .caseInsensitive) {
                let regMatches = regex.matches(in: self, options: NSRegularExpression.MatchingOptions(), range: fullRange)
                if regMatches.count > 0 {
                    // if any range found — it means, that that single character is emoji
                    return true
                }
            }
        }
        return false
    }

}

---

How it works (in details)

A single Emoji (a glyph) can be reproduced by a number of different symbols, sequences and their combinations. Unicode specification defines several possible Emoji character representations.

Single-Character Emoji

An Emoji character reproduced by a single Unicode Scalar.

Unicode defines Emoji Character as:

emoji_character := \p{Emoji}

But it doesn’t necessarily mean that such a character will be drawn as an Emoji. An ordinary numeric symbol “1” has Emoji property being true, though it still might be drawn as text. And there is a list of such symbols: #, ©, 4, etc.

One should think, that we can use additional property to check: “Emoji_Presentation”. But it doesn’t work like this. There is an Emoji like or , which have property Emoji_Presentation=false.

To make sure, that the character is drawn as Emoji by default, we should check its category: it should be “Other_symbol”.

So, in fact regular expression for Single-Character Emoji should be defined as:

emoji_character := \p{Emoji}&&\p{Other_symbol}

Emoji Presentation Sequence

A character, which normally can be drawn as either text or as Emoji. It’s appearance depends on a special following symbol, a presentation selector, which indicates its presentation type. \x{FE0E} defines text representation. \x{FE0F} defines emoji representation.

The list of such symbols can be found [here](
https://unicode.org/Public/emoji/12.1/emoji-variation-sequences.txt).

Unicode defines presentation sequence like this:

emoji_presentation_sequence := emoji_character emoji_presentation_selector

Regular expression sequence for it:

emoji_presentation_sequence := \p{Emoji} \x{FE0F}

Emoji Keycap Sequence

The sequence looks very alike with Presentation sequence, but it has additional scalar at the end: \x{20E3}. The scope of possible base scalars used for it is rather narrow: 0-9#* — and that’s all. Examples: 1️⃣, 8️⃣, *️⃣.

Unicode defines keycap sequence like this:

emoji_keycap_sequence := [0-9#*] \x{FE0F 20E3}

Regular expression for it:

emoji_keycap_sequence := \p{Emoji} \x{FE0F} \x{FE0F}

Emoji Modifier Sequence

Some Emojis can have modified appearance like a skin tone. For example Emoji can be different: . To define an Emoji, which is called “Emoji_Modifier_Base” in this case, one can use a subsequent “Emoji_Modifier”.

In general such sequence looks like this:

emoji_modifier_sequence := emoji_modifier_base emoji_modifier

To detect it we can search for a regular expression sequence:

emoji_modifier_sequence := \p{Emoji} \p{EMod}

Emoji Flag Sequence

Flags are Emojis with their particular structure. Each flag is represented with two “Regional_Indicator” symbols.

Unicode defines them like:

emoji_flag_sequence := regional_indicator regional_indicator

For example flag of Ukraine in fact is represented with two scalars: \u{0001F1FA \u{0001F1E6}

Regular expression for it:

emoji_flag_sequence := \p{RI}{2}

Emoji Tag Sequence (ETS)

A sequence which uses a so-called tag_base, which is followed by a custom tag specification composed from range of symbols \x{E0020}-\x{E007E} and concluded by tag_end mark \x{E007F}.

Unicode defines it like this:

emoji_tag_sequence := tag_base tag_spec tag_end
tag_base           := emoji_character
                    | emoji_modifier_sequence
                    | emoji_presentation_sequence
tag_spec           := [\x{E0020}-\x{E007E}]+
tag_end            := \x{E007F}

Strange thing is that Unicode allows tag to be based on emoji_modifier_sequence or emoji_presentation_sequence in ED-14a. But at the same time in regular expressions provided at the same documentation they seem to check the sequence based on a single Emoji character only.

In Unicode 12.1 Emoji list there are only three such Emojis defined. All of them are flags of the UK countries: England , Scotland and Wales . And all of them are based on a single Emoji character. So, we’d better check for such a sequence only.

Regular expression:

\p{Emoji} [\x{E0020}-\x{E007E}]+ \x{E007F}

Emoji Zero-Width Joiner Sequence (ZWJ sequence)

A zero-width joiner is a scalar \x{200D}. With its help several characters, which are already Emojis by themselves, can be combined into new ones.

For a example a “family with father, son and daughter” Emoji ‍‍ is reproduced by a combination of father , daughter and son Emojis glued together with ZWJ symbols.

It is allowed to stick together elements, which are Single Emoji characters, Presentation and Modifier sequences.

Regular expression for such sequence in general looks like this:

emoji_zwj_sequence := emoji_zwj_element (\x{200d} emoji_zwj_element )+

Regular Expression For All Of Them

All of the mentioned above Emoji representations can be described by a single regular expression:

\p{RI}{2}
| ( \p{Emoji} 
    ( \p{EMod} 
    | \x{FE0F}\x{20E3}? 
    | [\x{E0020}-\x{E007E}]+\x{E007F} 
    ) 
  | 
[\p{Emoji}&&\p{Other_symbol}] 
  )
  ( \x{200D}
    ( \p{Emoji} 
      ( \p{EMod} 
      | \x{FE0F}\x{20E3}? 
      | [\x{E0020}-\x{E007E}]+\x{E007F} 
      ) 
    | [\p{Emoji}&&\p{Other_symbol}] 
    ) 
  )*

Answer 15

The simplest, cleanest, and swiftiest way to accomplish this is to simply check the Unicode code points for each character in the string against known emoji and dingbats ranges, like so:

extension String {

    var containsEmoji: Bool {
        for scalar in unicodeScalars {
            switch scalar.value {
            case 0x1F600...0x1F64F, // Emoticons
                 0x1F300...0x1F5FF, // Misc Symbols and Pictographs
                 0x1F680...0x1F6FF, // Transport and Map
                 0x2600...0x26FF,   // Misc symbols
                 0x2700...0x27BF,   // Dingbats
                 0xFE00...0xFE0F,   // Variation Selectors
                 0x1F900...0x1F9FF, // Supplemental Symbols and Pictographs
                 0x1F1E6...0x1F1FF: // Flags
                return true
            default:
                continue
            }
        }
        return false
    }

}

Answer 16

i had the same problem and ended up making a String and Character extensions.

The code is too long to post as it actually lists all emojis (from the official unicode list v5.0) in a CharacterSet you can find it here:

https://github.com/piterwilson/StringEmoji

Constants

let emojiCharacterSet: CharacterSet

Character set containing all known emoji (as described in official Unicode List 5.0 http://unicode.org/emoji/charts-5.0/emoji-list.html)

String

var isEmoji: Bool { get }

Whether or not the String instance represents a known single Emoji character

print("".isEmoji) // false
print("".isEmoji) // true
print("".isEmoji) // false (String is not a single Emoji)

var containsEmoji: Bool { get }

Whether or not the String instance contains a known Emoji character

print("".containsEmoji) // false
print("".containsEmoji) // true
print("".containsEmoji) // true

var unicodeName: String { get }

Applies a kCFStringTransformToUnicodeName - CFStringTransform on a copy of the String

print("á".unicodeName) // \N{LATIN SMALL LETTER A WITH ACUTE}
print("".unicodeName) // "\N{FACE WITH STUCK-OUT TONGUE AND WINKING EYE}"

var niceUnicodeName: String { get }

Returns the result of a kCFStringTransformToUnicodeName - CFStringTransform with \N{ prefixes and } suffixes removed

print("á".unicodeName) // LATIN SMALL LETTER A WITH ACUTE
print("".unicodeName) // FACE WITH STUCK-OUT TONGUE AND WINKING EYE

Character

var isEmoji: Bool { get }

Whether or not the Character instance represents a known Emoji character

print("".isEmoji) // false
print("".isEmoji) // true

Answer 17

Swift 5.0

… introduced a new way of checking exactly this!

You have to break your String into its Scalars. Each Scalar has a Property value which supports the isEmoji value!

Actually you can even check if the Scalar is a Emoji modifier or more. Check out Apple's documentation: https://developer.apple.com/documentation/swift/unicode/scalar/properties

You may want to consider checking for isEmojiPresentation instead of isEmoji, because Apple states the following for isEmoji:

This property is true for scalars that are rendered as emoji by default and also for scalars that have a non-default emoji rendering when followed by U+FE0F VARIATION SELECTOR-16. This includes some scalars that are not typically considered to be emoji.

---

This way actually splits up Emoji's into all the modifiers, but it is way simpler to handle. And as Swift now counts Emoji's with modifiers (e.g.: ‍‍‍, ‍, ) as 1 you can do all kind of stuff.

var string = " test"

for scalar in string.unicodeScalars {
    let isEmoji = scalar.properties.isEmoji

    print("\(scalar.description) \(isEmoji)")
}

//  true
//   false
// t false
// e false
// s false
// t false

---

NSHipster points out an interesting way to get all Emoji's:

import Foundation

var emoji = CharacterSet()

for codePoint in 0x0000...0x1F0000 {
    guard let scalarValue = Unicode.Scalar(codePoint) else {
        continue
    }

    // Implemented in Swift 5 (SE-0221)
    // https://github.com/apple/swift-evolution/blob/master/proposals/0221-character-properties.md
    if scalarValue.properties.isEmoji {
        emoji.insert(scalarValue)
    }
}

Answer 18

With Swift 5 you can now inspect the unicode properties of each character in your string. This gives us the convenient isEmoji variable on each letter. The problem is isEmoji will return true for any character that can be converted into a 2-byte emoji, such as 0-9.

We can look at the variable isEmoji and also check the for the presence of an emoji modifier to determine if the ambiguous characters will display as an emoji.

This solution should be much more future proof than the regex solutions offered here.

extension String {
    func containsEmoji() -> Bool {
        contains { $0.isEmoji }
    }

    func containsOnlyEmojis() -> Bool {
        return count > 0 && !contains { !$0.isEmoji }
    }
}

extension Character {
    // An emoji can either be a 2 byte unicode character or a normal UTF8 character with an emoji modifier
    // appended as is the case with 3️⃣. 0x203C is the first instance of UTF16 emoji that requires no modifier.
    // `isEmoji` will evaluate to true for any character that can be turned into an emoji by adding a modifier
    // such as the digit "3". To avoid this we confirm that any character below 0x203C has an emoji modifier attached
    var isEmoji: Bool {
        guard let scalar = unicodeScalars.first else { return false }
        return scalar.properties.isEmoji && (scalar.value >= 0x203C || unicodeScalars.count > 1)
    }
}

Giving us

"hey".containsEmoji() //false

"Hello World ".containsEmoji() //true
"Hello World ".containsOnlyEmojis() //false

"3".containsEmoji() //false
"3️⃣".containsEmoji() //true