Find out if Character in String is emoji?
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.
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
}
}