Ios 如何在swift中每N个字符向字符串添加分隔符？

我有一个包含二进制数字的字符串。如何将它分成几对数字

假设字符串为：

let x = "11231245"

我想在每2个字符后添加一个分隔符，如“：”（即冒号）

我希望输出为：

"11:23:12:45"

---

如何在Swift中执行此操作？

Swift 5.2•Xcode 11.4或更高版本

extension Collection {
    func unfoldSubSequences(limitedTo maxLength: Int) -> UnfoldSequence<SubSequence,Index> {
        sequence(state: startIndex) { start in
            guard start < self.endIndex else { return nil }
            let end = self.index(start, offsetBy: maxLength, limitedBy: self.endIndex) ?? self.endIndex
            defer { start = end }
            return self[start..<end]
        }
    }

    func every(n: Int) -> UnfoldSequence<Element,Index> {
        sequence(state: startIndex) { index in
            guard index < endIndex else { return nil }
            defer { index = self.index(index, offsetBy: n, limitedBy: endIndex) ?? endIndex }
            return self[index]
        }
    }

    var pairs: [SubSequence] { .init(unfoldSubSequences(limitedTo: 2)) }
}

---

我对该代码的尝试是：

func insert(seperator: String, afterEveryXChars: Int, intoString: String) -> String {
    var output = ""
    intoString.characters.enumerate().forEach { index, c in
        if index % afterEveryXChars == 0 && index > 0 {
            output += seperator
        }
        output.append(c)
    }
    return output
}

insert(":", afterEveryXChars: 2, intoString: "11231245")

哪个输出

11:23:12:45

我的密码是swift 4

let x = "11231245"

var newText = String()
    for (index, character) in x.enumerated() {
        if index != 0 && index % 2 == 0 {
            newText.append(":")
        }
        newText.append(String(character))
    }
    print(newText)

---

输出11:23:12:45

简短而简单，如果需要，可以添加一个或两个

let

extension String {

    func separate(every: Int, with separator: String) -> String {
        return String(stride(from: 0, to: Array(self).count, by: every).map {
            Array(Array(self)[$0..<min($0 + every, Array(self).count)])
        }.joined(separator: separator))
    }
}

扩展字符串{
func separate（every:Int，带分隔符：String）->String{
返回字符串（步幅（从：0到：数组（self）.count，by:every）.map{
数组（数组（self）[$0..我会选择这个紧凑的解决方案（在Swift 4中）：

您可以进行扩展并参数化步幅和分隔符，以便可以对所需的每个值使用它（在我的示例中，我使用它转储32位空间操作的十六进制数据）：

在您的情况下，这将给出以下结果：

let x = "11231245"
print (x.separate(every:2, with: ":")

$ 11:23:12:45

扩展字符串{
func separate（every:Int）->[字符串]{
返回步幅（从：0，到：计数，按：每个）。映射{
设ix0=索引（startIndex，offsetBy:$0）；
设ix1=索引（在：ix0之后）；
如果ix1parts.append（String（self[ix0..一个简单的字符串扩展，它不要求原始字符串是步长（增量）的倍数）：

Swift 4.2.1-Xcode 10.1

extension String {

    func insertSeparator(_ separatorString: String, atEvery n: Int) -> String {
        guard 0 < n else { return self }
        return self.enumerated().map({String($0.element) + (($0.offset != self.count - 1 && $0.offset % n ==  n - 1) ? "\(separatorString)" : "")}).joined()
    }

    mutating func insertedSeparator(_ separatorString: String, atEvery n: Int) {
        self = insertSeparator(separatorString, atEvery: n)
    }
}

插入分隔符的简单单行代码（Swift 4.2）：-

Swift 5.3

    /// Adds a separator at every N characters
    /// - Parameters:
    ///   - separator: the String value to be inserted, to separate the groups. Default is " " - one space.
    ///   - stride: the number of characters in the group, before a separator is inserted. Default is 4.
    /// - Returns: Returns a String which includes a `separator` String at every `stride` number of characters.
    func separated(by separator: String = " ", stride: Int = 4) -> String {
        return enumerated().map { $0.isMultiple(of: stride) && ($0 != 0) ? "\(separator)\($1)" : String($1) }.joined()
    }

我来晚了一点，但我喜欢这样使用正则表达式：

extension String {
    func separating(every: Int, separator: String) -> String {
        let regex = #"(.{\#(every)})(?=.)"#
        return self.replacingOccurrences(of: regex, with: "$1\(separator)", options: [.regularExpression])
    }
}

"111222333".separating(every: 3, separator: " ")

输出：

"111 222 333"

为了记录在案和您将来的利益，
：
是一个“冒号”。“逗号”的意思是
，
。到目前为止，您尝试了什么？请注意，您提供的唯一代码行实际上甚至都不是有效代码。您介意我编辑您的代码吗？不需要使用计数器，您可以使用enumerate（）。您还可以添加一个附加条件（index>0）添加分隔符，以便能够将dropFirst方法删除为String.characters.enumerate（）.forEach{index，c in if index%afteryxChars==0&&index>0{…@LeoDabus一点也不，继续吧-你还在玩吗？：Pnot在玩。我对我的很满意：）为了让您知道如何使用enumerate（），代码会留下一个尾随
：
，请尝试将
：
添加到
$0.element
前面，当且仅当您不在第一个字符处时。只需添加.flatte（）.dropLast（）请求“在每两个字符之后”。如果尾随“：不需要，是的，您的建议会这样做，即：
$0.index>0&&$0.index%2==0？[“：”，$0.element]：[$0.element]，
@LeoDabus，不，如果原始字符串长度为奇数，dropLast将使用有效负载字符。@AntonBronnikov字符串（x.characters.enumerate（）.map（）{$0.index%2==1？[$0.element]：[“：”，$0.element]，$0.element]}.flant（）.dropFirst（）@LeoDabus您编写了这些扩展吗？如果是，您能帮我做些什么吗？我正在尝试插入一个“|”每70个字符，但仅当第70个字符是空格时。如果不是，则向后跨步，直到它找到空格。我基本上将其用作一个新的行生成器。我似乎不知道如何执行此操作，我尝试了许多不同的方法。是的，我写了所有这些方法。请随意发布您解决问题的方法以及出现的问题ng在一个新问题中，我会看一看。@LeoDabus很好，在这里看一看。@TheValyreanGroup所以你想在9号之后拆分字符串的每个空格？哦，是的……太简单了。我太笨了。非常感谢你的帮助。祝你过得愉快！我的xcode在声明函数时要求返回，类似这样：func separate（每一步：Int=4，带分隔符：Character=“”）->String{这不可编译。@TruMan1:您使用的是什么Xcode和Swift版本？抱歉，我刚刚意识到我试图使用字符串作为分隔符。我喜欢您是一行，实际上更容易理解（我不知道性能比较如何）。如何调整扩展名以接受字符串作为分隔符？当我切换到字符串类型时，我遇到的错误是：无法使用类型为“（FlattCollection）”@StéphanedeLuca的参数列表调用类型为“init（:）”的初始值设定项。您只需使用flatMap而不是map并加入
.init（enumerated（）.flatMap即可{$0>0&&$0%stride==0？[separator，$1]：[$1]}
newText.append（character）
这是一个非常好的解决方案。我认为这是最快捷、最容易理解的解决方案。谢谢。我添加了一个小补丁。这是一个额外的检查-因为我为第一个字符添加了额外的空格（0是任意数字的倍数）。
let x = "11231245"
print (x.separate(every:2, with: ":")

$ 11:23:12:45

extension String{

func separate(every: Int) -> [String] {
    return stride(from: 0, to: count, by: every).map {
        let ix0 = index(startIndex, offsetBy: $0);
        let ix1 = index(after:ix0);
        if ix1 < endIndex {
            return String(self[ix0...ix1]);
        }else{
            return String(self[ix0..<endIndex]);
        }
    }
}

func separate(every: Int) -> [String] {
    var parts:[String] = [];
    var ix1 = startIndex;
    while ix1 < endIndex {
        let ix0 = ix1;
        var n = 0;
        while ix1 < endIndex && n < every {
            ix1 = index(after: ix1);
            n += 1;
        }
        parts.append(String(self[ix0..<ix1]));
    }
    return parts;
}

"asdf234sdf".separate(every: 2).joined(separator: ":");

extension String {
    func inserted(_ newElement: Character,atEach increment:Int)->String {
        var newStr = self

        for indx in stride(from: increment, to: newStr.count, by: increment).reversed() {
            let index = String.Index(encodedOffset: indx)
            newStr.insert(newElement, at: index)
        }

        return newStr
    }
 }

extension String {

    func insertSeparator(_ separatorString: String, atEvery n: Int) -> String {
        guard 0 < n else { return self }
        return self.enumerated().map({String($0.element) + (($0.offset != self.count - 1 && $0.offset % n ==  n - 1) ? "\(separatorString)" : "")}).joined()
    }

    mutating func insertedSeparator(_ separatorString: String, atEvery n: Int) {
        self = insertSeparator(separatorString, atEvery: n)
    }
}

let testString = "11231245"

let test1 = testString.insertSeparator(":", atEvery: 2)
print(test1) // 11:23:12:45

var test2 = testString
test2.insertedSeparator(",", atEvery: 3)
print(test2) // 112,312,45    

let testString = "123456789"

let ansTest = testString.enumerated().compactMap({ ($0 > 0) && ($0 % 2 == 0) ? ":\($1)" : "\($1)" }).joined() ?? ""
print(ansTest) // 12:34:56:78:9

    /// Adds a separator at every N characters
    /// - Parameters:
    ///   - separator: the String value to be inserted, to separate the groups. Default is " " - one space.
    ///   - stride: the number of characters in the group, before a separator is inserted. Default is 4.
    /// - Returns: Returns a String which includes a `separator` String at every `stride` number of characters.
    func separated(by separator: String = " ", stride: Int = 4) -> String {
        return enumerated().map { $0.isMultiple(of: stride) && ($0 != 0) ? "\(separator)\($1)" : String($1) }.joined()
    }

extension String {
    func separating(every: Int, separator: String) -> String {
        let regex = #"(.{\#(every)})(?=.)"#
        return self.replacingOccurrences(of: regex, with: "$1\(separator)", options: [.regularExpression])
    }
}

"111222333".separating(every: 3, separator: " ")

"111 222 333"