*Swift 5酒店

不要使用这种hardcoded方式来检测emojis。在Swift 5中，您可以轻松地做到这一点

let inputText = "Some 🖐string 😂😂😂 with 👹👹 👹 emoji 🖐"

let textWithoutEmoij = inputText.unicodeScalars
    .filter { !$0.properties.isEmojiPresentation }
    .reduce("") { $0 + String($1) }

print(textWithoutEmoij) // Some string  with   emoji

您可以使用模式匹配（用于emoji模式）从String中过滤掉emoji字符。

extension String {

    var emojilessStringWithSubstitution: String {
        let emojiPatterns = [UnicodeScalar(0x1F601)...UnicodeScalar(0x1F64F),
                             UnicodeScalar(0x2702)...UnicodeScalar(0x27B0)]
        return self.unicodeScalars
            .filter { ucScalar in !(emojiPatterns.contains{ $0 ~= ucScalar }) }
            .reduce("") { $0 + String($1) }
    }  
}

/* example usage */
let str = "I'm gonna do this callenge as soon as I can swing again 😂😂😂\n http://youtu.be/SW_d3fGz1hk"
print(str.emojilessStringWithSubstitution)

/* I'm gonna do this callenge as soon as I can swing again
   http://youtu.be/SW_d3fGz1hk */

请注意，上面的方法只使用了问题中的表情符号间隔，并不代表所有的表情符号，但该方法是通用的，可以通过将其他表情符号间隔添加到emojiPatterns数组中来快速扩展。
我意识到再次阅读你的问题，你更喜欢用空格字符替换表情符号，而不是删除它们（上面的过滤解决方案）。我们可以通过将上面的.filter操作替换为条件返回.map操作来实现这一点，与您的问题非常相似

extension String {

    var emojilessStringWithSubstitution: String {
        let emojiPatterns = [UnicodeScalar(0x1F600)...UnicodeScalar(0x1F64F),
                         UnicodeScalar(0x1F300)...UnicodeScalar(0x1F5FF),
                         UnicodeScalar(0x1F680)...UnicodeScalar(0x1F6FF),
                         UnicodeScalar(0x2600)...UnicodeScalar(0x26FF),
                         UnicodeScalar(0x2700)...UnicodeScalar(0x27BF),
                         UnicodeScalar(0xFE00)...UnicodeScalar(0xFE0F)]

        return self.unicodeScalars
            .map { ucScalar in
                emojiPatterns.contains{ $0 ~= ucScalar } ? UnicodeScalar(32) : ucScalar }
            .reduce("") { $0 + String($1) }
    }
}

如上所述，根据您对这篇文章的评论（列出这些间隔），现有的emoji间隔已被扩展，因此emoji检查现在可能是详尽的。

Swift 4：

extension String {
  func stringByRemovingEmoji() -> String {
    return String(self.filter { !$0.isEmoji() })
  }
}

extension Character {
  fileprivate func isEmoji() -> Bool {
    return Character(UnicodeScalar(UInt32(0x1d000))!) <= self && self <= Character(UnicodeScalar(UInt32(0x1f77f))!)
      || Character(UnicodeScalar(UInt32(0x2100))!) <= self && self <= Character(UnicodeScalar(UInt32(0x26ff))!)
  }
}

Emoji被Unicode分类为符号。字符集通常用于搜索操作。所以我们将使用字符集的属性是符号.

var emojiString =  "Hey there 🖐, welcome"
emojiString = emojiString.components(separatedBy: CharacterSet.symbols).joined()       
print(emojiString)

输出为

Hey there , welcome

现在观察emoji被一白色所取代，因此有两个空格，我们用以下方式替换它

emojiString.replacingOccurrences(of: "  ", with: " ")

上述方法替换参数：“两白色”要与：“单白色”

获取所有emoji比你想象的要复杂得多。有关如何找出哪些字符是emoji的更多信息，请查看这篇stackoverflow文章或this article。
基于这些信息，我建议使用Character的扩展来更容易地让我们理解哪些字符是emoji。然后添加一个字符串扩展名，以便轻松地将找到的emoji替换为另一个字符。

extension Character {
   var isSimpleEmoji: Bool {
      guard let firstProperties = unicodeScalars.first?.properties else {
        return false
      }
      return unicodeScalars.count == 1 &&
          (firstProperties.isEmojiPresentation ||
             firstProperties.generalCategory == .otherSymbol)
   }
   var isCombinedIntoEmoji: Bool {
      return unicodeScalars.count > 1 &&
             unicodeScalars.contains {
                $0.properties.isJoinControl ||
                $0.properties.isVariationSelector
             }
   }
   var isEmoji: Bool {
      return isSimpleEmoji || isCombinedIntoEmoji
   }
}

extension String {
    func replaceEmoji(with character: Character) -> String {
        return String(map { $0.isEmoji ? character : $0 })
    }
}

使用它将简单地变成：

"Some string 😂😂😂 with emoji".replaceEmoji(with: " ")

我发现上面给出的解决方案对某些字符不起作用，例如🏋️🏻‍♂️和🧰。
为了找到emoji的范围，我使用regex将full list of emoji characters转换为一个只有十六进制值的文件。然后我把它们转换成十进制格式并排序。最后，我写了一个脚本来查找范围。
这是isEmoji()的最终Swift扩展。

extension Character {

    func isEmoji() -> Bool {
        let emojiRanges = [
            (8205, 11093),
            (12336, 12953),
            (65039, 65039),
            (126980, 129685)
        ]
        let codePoint = self.unicodeScalars[self.unicodeScalars.startIndex].value
        for emojiRange in emojiRanges {
            if codePoint >= emojiRange.0 && codePoint <= emojiRange.1 {
                return true
            }
        }
        return false
    }

}

作为参考，这里是我编写的Python脚本，用于将十六进制字符串解析为整数，然后查找范围。

convert-hex-to-decimal。py

decimals = []
with open('hex.txt') as hexfile:
    for line in hexfile:
        num = int(line, 16)
        if num < 256:
            continue
        decimals.append(num)

decimals = list(set(decimals))
decimals.sort()

with open('decimal.txt', 'w') as decimalfile:
    for decimal in decimals:
        decimalfile.write(str(decimal) + "\n")

make-ranges。py

first_line = True
range_start = 0
prev = 0
with open('decimal.txt') as hexfile:
    for line in hexfile:
        if first_line: 
            prev = int(line)
            range_start = prev
            first_line = False
            continue

        curr = int(line)
        if prev + 1000 < curr: # 100 is abitrary to reduce number of ranges
            print("(" + str(range_start) + ", " + str(prev) + ")")
            range_start = curr
        prev = curr

这个Swift 5的代码片段对我来说很有魅力，但我还没有检查过所有的表情符号。然而它仍然显示中国，韩国等我以前的解决方案挣扎。

extension String {
    // works with unicode languages like korean
    func removeEmojis() -> String {
        return .init(
            unicodeScalars.filter {
                $0.properties.isEmojiPresentation == false &&
                $0.properties.isEmoji == false
            }
        )
    }
}

不要硬编码表情符号的范围，而是使用这个。

func 去除表情符号(字符串:String) -> String {
    let 转换为Unicode = 字符串.unicodeScalars//https://developer.apple.com/documentation/swift/string
    
    let 去除表情后的结果 = 转换为Unicode.filter { (item) -> Bool in
        let 判断是否表情 = item.properties.isEmoji
         return !判断是否表情//是表情就不保留
      }
    
    return String(去除表情后的结果)
}