格式化 Swift 中的 Phone 个数字

Question

一旦用户开始将 phone 数字输入到此格式类型 0 (555) 444 66 77 中，我正在格式化我的文本文件，并且它工作正常，但是一旦我从服务器获取数字，我就得到了它像这样 05554446677 所以请你告诉我如何在从服务器获取它后以相同的格式编辑它？

我开始输入后的代码：

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {

    if textField == phoneNumberTextField{
        var newString = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string)
        var components = newString.componentsSeparatedByCharactersInSet(NSCharacterSet.decimalDigitCharacterSet().invertedSet)

        var decimalString = "".join(components) as NSString
        var length = decimalString.length
        var hasLeadingOne = length > 0 && decimalString.characterAtIndex(0) == (1 as unichar)

        if length == 0 || (length > 11 && !hasLeadingOne) || length > 12{
            var newLength = (textField.text as NSString).length + (string as NSString).length - range.length as Int

            return (newLength > 11) ? false : true
        }
        var index = 0 as Int
        var formattedString = NSMutableString()

        if hasLeadingOne{
            formattedString.appendString("1 ")
            index += 1
        }

        if (length - index) > 1{
            var zeroNumber = decimalString.substringWithRange(NSMakeRange(index, 1))
            formattedString.appendFormat("%@ ", zeroNumber)
            index += 1
        }
        if (length - index) > 3{
            var areaCode = decimalString.substringWithRange(NSMakeRange(index, 3))
            formattedString.appendFormat("(%@) ", areaCode)
            index += 3
        }
        if (length - index) > 3{
            var prefix = decimalString.substringWithRange(NSMakeRange(index, 3))
            formattedString.appendFormat("%@ ", prefix)
            index += 3
        }
        if (length - index) > 3{
            var prefix = decimalString.substringWithRange(NSMakeRange(index, 2))
            formattedString.appendFormat("%@ ", prefix)
            index += 2
        }

        var remainder = decimalString.substringFromIndex(index)
        formattedString.appendString(remainder)
        textField.text = formattedString as String
        return false
    }else{
        return true
    }
}

Answer 1

对 String 中的字符进行操作不是很简单。您需要以下内容：

Swift 2.1

let s = "05554446677"
let s2 = String(format: "%@ (%@) %@ %@ %@", s.substringToIndex(s.startIndex.advancedBy(1)),
    s.substringWithRange(s.startIndex.advancedBy(1) ... s.startIndex.advancedBy(3)),
    s.substringWithRange(s.startIndex.advancedBy(4) ... s.startIndex.advancedBy(6)),
    s.substringWithRange(s.startIndex.advancedBy(7) ... s.startIndex.advancedBy(8)),
    s.substringWithRange(s.startIndex.advancedBy(9) ... s.startIndex.advancedBy(10))
)

Swift 2.0

let s = "05554446677"
let s2 = String(format: "%@ (%@) %@ %@ %@", s.substringToIndex(advance(s.startIndex, 1)),
    s.substringWithRange(advance(s.startIndex, 1) ... advance(s.startIndex, 3)),
    s.substringWithRange(advance(s.startIndex, 4) ... advance(s.startIndex, 6)),
    s.substringWithRange(advance(s.startIndex, 7) ... advance(s.startIndex, 8)),
    s.substringWithRange(advance(s.startIndex, 9) ... advance(s.startIndex, 10))
)

代码将打印 0 (555) 444 66 77

Answer 2

Swift 3 & 4

此解决方案会在应用格式之前删除任何 non-numeric 个字符。它returnsnil如果源phone数字不能按假设格式化

Swift 4

Swift 4 解决方案说明了 CharacterView 和 Sting 的弃用，成为 CharacterView 的字符集合。

import Foundation

func format(phoneNumber sourcePhoneNumber: String) -> String? {
    // Remove any character that is not a number
    let numbersOnly = sourcePhoneNumber.components(separatedBy: CharacterSet.decimalDigits.inverted).joined()
    let length = numbersOnly.count
    let hasLeadingOne = numbersOnly.hasPrefix("1")

    // Check for supported phone number length
    guard length == 7 || (length == 10 && !hasLeadingOne) || (length == 11 && hasLeadingOne) else {
        return nil
    }

    let hasAreaCode = (length >= 10)
    var sourceIndex = 0

    // Leading 1
    var leadingOne = ""
    if hasLeadingOne {
        leadingOne = "1 "
        sourceIndex += 1
    }

    // Area code
    var areaCode = ""
    if hasAreaCode {
        let areaCodeLength = 3
        guard let areaCodeSubstring = numbersOnly.substring(start: sourceIndex, offsetBy: areaCodeLength) else {
            return nil
        }
        areaCode = String(format: "(%@) ", areaCodeSubstring)
        sourceIndex += areaCodeLength
    }

    // Prefix, 3 characters
    let prefixLength = 3
    guard let prefix = numbersOnly.substring(start: sourceIndex, offsetBy: prefixLength) else {
        return nil
    }
    sourceIndex += prefixLength

    // Suffix, 4 characters
    let suffixLength = 4
    guard let suffix = numbersOnly.substring(start: sourceIndex, offsetBy: suffixLength) else {
        return nil
    }

    return leadingOne + areaCode + prefix + "-" + suffix
}

extension String {
    /// This method makes it easier extract a substring by character index where a character is viewed as a human-readable character (grapheme cluster).
    internal func substring(start: Int, offsetBy: Int) -> String? {
        guard let substringStartIndex = self.index(startIndex, offsetBy: start, limitedBy: endIndex) else {
            return nil
        }

        guard let substringEndIndex = self.index(startIndex, offsetBy: start + offsetBy, limitedBy: endIndex) else {
            return nil
        }

        return String(self[substringStartIndex ..< substringEndIndex])
    }
}

Swift 3

import Foundation

func format(phoneNumber sourcePhoneNumber: String) -> String? {

    // Remove any character that is not a number
    let numbersOnly = sourcePhoneNumber.components(separatedBy: CharacterSet.decimalDigits.inverted).joined()
    let length = numbersOnly.characters.count
    let hasLeadingOne = numbersOnly.hasPrefix("1")

    // Check for supported phone number length
    guard length == 7 || (length == 10 && !hasLeadingOne) || (length == 11 && hasLeadingOne) else {
        return nil
    }

    let hasAreaCode = (length >= 10)
    var sourceIndex = 0

    // Leading 1
    var leadingOne = ""
    if hasLeadingOne {
        leadingOne = "1 "
        sourceIndex += 1
    }

    // Area code
    var areaCode = ""
    if hasAreaCode {
        let areaCodeLength = 3
        guard let areaCodeSubstring = numbersOnly.characters.substring(start: sourceIndex, offsetBy: areaCodeLength) else {
            return nil
        }
        areaCode = String(format: "(%@) ", areaCodeSubstring)
        sourceIndex += areaCodeLength
    }

    // Prefix, 3 characters
    let prefixLength = 3
    guard let prefix = numbersOnly.characters.substring(start: sourceIndex, offsetBy: prefixLength) else {
        return nil
    }
    sourceIndex += prefixLength

    // Suffix, 4 characters
    let suffixLength = 4
    guard let suffix = numbersOnly.characters.substring(start: sourceIndex, offsetBy: suffixLength) else {
        return nil
    }

    return leadingOne + areaCode + prefix + "-" + suffix
}

extension String.CharacterView {
    /// This method makes it easier extract a substring by character index where a character is viewed as a human-readable character (grapheme cluster).
    internal func substring(start: Int, offsetBy: Int) -> String? {
        guard let substringStartIndex = self.index(startIndex, offsetBy: start, limitedBy: endIndex) else {
            return nil
        }

        guard let substringEndIndex = self.index(startIndex, offsetBy: start + offsetBy, limitedBy: endIndex) else {
            return nil
        }

        return String(self[substringStartIndex ..< substringEndIndex])
    }
}

例子

func testFormat(sourcePhoneNumber: String) -> String {
    if let formattedPhoneNumber = format(phoneNumber: sourcePhoneNumber) {
        return "'\(sourcePhoneNumber)' => '\(formattedPhoneNumber)'"
    }
    else {
        return "'\(sourcePhoneNumber)' => nil"
    }
}

print(testFormat(sourcePhoneNumber: "1 800 222 3333"))
print(testFormat(sourcePhoneNumber: "18002223333"))
print(testFormat(sourcePhoneNumber: "8002223333"))
print(testFormat(sourcePhoneNumber: "2223333"))
print(testFormat(sourcePhoneNumber: "18002223333444"))
print(testFormat(sourcePhoneNumber: "Letters8002223333"))
print(testFormat(sourcePhoneNumber: "1112223333"))

示例输出

'1 800 222 3333' => '1 (800) 222-3333'

'18002223333' => '1 (800) 222-3333'

'8002223333' => '(800) 222-3333'

'2223333' => '222-3333'

'18002223333444' => nil

'Letters8002223333' => '(800) 222-3333'

'1112223333' => nil

Answer 3

屏蔽号码输入

/// mask example: `+X (XXX) XXX-XXXX`
func format(with mask: String, phone: String) -> String {
    let numbers = phone.replacingOccurrences(of: "[^0-9]", with: "", options: .regularExpression)
    var result = ""
    var index = numbers.startIndex // numbers iterator

    // iterate over the mask characters until the iterator of numbers ends
    for ch in mask where index < numbers.endIndex {
        if ch == "X" {
            // mask requires a number in this place, so take the next one
            result.append(numbers[index])

            // move numbers iterator to the next index
            index = numbers.index(after: index)

        } else {
            result.append(ch) // just append a mask character
        }
    }
    return result
}

从 UITextField 委托方法调用上述函数：

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    guard let text = textField.text else { return false }
    let newString = (text as NSString).replacingCharacters(in: range, with: string)
    textField.text = format(with: "+X (XXX) XXX-XXXX", phone: newString)
    return false
}

所以，这样效果更好。

"" => ""
"0" => "+0"
"412" => "+4 (12"
"12345678901" => "+1 (234) 567-8901"
"a1_b2-c3=d4 e5&f6|g7h8" => "+1 (234) 567-8"

Answer 4

Swift 3 但也应该可以翻译成 Swift 4

错误处理

enum PhoneNumberFormattingError: Error {
    case wrongCharactersInPhoneNumber
    case phoneNumberLongerThanPatternAllowes
}

创建模式

enum PhoneNumberFormattingPatterns: String {
    case mobile = "+xx (yxx) xxxxxxxxxxx"
    case home = "+xx (yxxx) xxxx-xxx"
}

插入函数

/**
     Formats a phone-number to correct format
     - Parameter pattern: The pattern to format the phone-number.
     - Example:
        - x: Says that this should be a digit.
        - y: Says that this digit cannot be a "0".
        - The length of the pattern restricts also the length of allowed phone-number digits.
            - phone-number: "+4306641234567"
            - pattern: "+xx (yxx) xxxxxxxxxxx"
            - result: "+43 (664) 1234567"

     - Throws:
        - PhoneNumberFormattingError
            - wrongCharactersInPhoneNumber: if phone-number contains other characters than digits.
            - phoneNumberLongerThanPatternAllowes: if phone-number is longer than pattern allows.
     - Returns:
        - The formatted phone-number due to the pattern.
     */
extension String {
    func vpToFormattedPhoneNumber(withPattern pattern: PhoneNumberFormattingPatterns) throws -> String {
        let phoneNumber = self.replacingOccurrences(of: "+", with: "")
        var retVal: String = ""
        var index = 0
        for char in pattern.rawValue.lowercased().characters {
            guard index < phoneNumber.characters.count else {
                return retVal
            }

            if char == "x" {
                let charIndex = phoneNumber.index(phoneNumber.startIndex, offsetBy: index)
                let phoneChar = phoneNumber[charIndex]
                guard "0"..."9" ~= phoneChar else {
                    throw PhoneNumberFormattingError.wrongCharactersInPhoneNumber
                }
                retVal.append(phoneChar)
                index += 1
            } else if char == "y" {
                var charIndex = phoneNumber.index(phoneNumber.startIndex, offsetBy: index)
                var indexTemp = 1
                while phoneNumber[charIndex] == "0" {
                    charIndex = phoneNumber.index(phoneNumber.startIndex, offsetBy: index + indexTemp)
                    indexTemp += 1
                }

                let phoneChar = phoneNumber[charIndex]
                guard "0"..."9" ~= phoneChar else {
                    throw PhoneNumberFormattingError.wrongCharactersInPhoneNumber
                }
                retVal.append(phoneChar)
                index += indexTemp
            } else {
                retVal.append(char)
            }
        }

        if phoneNumber.endIndex > phoneNumber.index(phoneNumber.startIndex, offsetBy: index) {
            throw PhoneNumberFormattingError.phoneNumberLongerThanPatternAllowes
        }

        return retVal
    }
}

用法

let phoneNumber = "+4306641234567"
let phoneNumber2 = "4343211234567"

do {
    print(try phoneNumber.vpToFormattedPhoneNumber(withPattern: .mobile))
    print(try phoneNumber2.vpToFormattedPhoneNumber(withPattern: .home))
} catch let error as PhoneNumberFormattingError {
    switch error {
    case .wrongCharactersInPhoneNumber:
        print("wrong characters in phone number")
    case .phoneNumberLongerThanPatternAllowes:
        print("too long phone number")
    default:
        print("unknown error")
    }
} catch {
    print("something other went wrong")
}

// output: +43 (664) 1234567
// output: +43 (4321) 1234-567

Answer 5

你可以使用这个库https://github.com/luximetr/AnyFormatKit

例子

let phoneFormatter = DefaultTextFormatter(textPattern: "### (###) ###-##-##")
phoneFormatter.format("+123456789012") // +12 (345) 678-90-12

使用起来非常简单。

Answer 6

这里有很多不错的答案，但我采用了完全不同的方法，并认为我会分享以防有帮助。

首先，我将格式化步骤和组件分解为各自独立的职责。

Phone 数字格式通常可以分为本地、国内或国际格式类型，具体取决于字符串长度。

我定义了类型：

/// Defines the three different types of formatting phone numbers use
///
/// - local: Numbers used locally.
/// - domestic: Numbers used locally including area codes.
/// - international: Numbers used internationally with country codes.
public enum PhoneFormatType {
    case local
    case domestic
    case international
}

然后定义可用于格式化 phone 数字字符串的分隔符：

// Defines separators that are available for use in formatting
// phone number strings.
public enum PhoneFormatSeparator {
    case hyphen
    case plus
    case space
    case parenthesisLH
    case parenthesisRH
    case slash
    case backslash
    case pipe
    case asterisk

    public var value: String {
        switch self {
        case .hyphen: return "-"
        case .plus: return "+"
        case .space: return " "
        case .parenthesisLH: return "("
        case .parenthesisRH: return ")"
        case .slash: return "/"
        case .backslash: return "\"
        case .pipe: return "|"
        case .asterisk: return "*"
        }
    }
}

接下来我定义了指定索引（在 phone 数字字符串中）的格式规则，其中插入了 +、- 等分隔符。

// defines the separators that should be inserted in a phone number string
// and the indexes where they should be applied
public protocol PhoneNumberFormatRule {

    // the index in a phone number where this separator should be applied
    var index: Int { get set }

    // the priority in which this rule should be applied. Sorted in inverse, 0 is highest priority, higher numbers are lower priority
    var priority: Int { get set }

    // the separator to use at this index
    var separator: PhoneFormatSeparator { get set }
}

/// Default implementation of PhoneNumberFormatRule
open class PNFormatRule: PhoneNumberFormatRule {
    public var index: Int
    public var priority: Int
    public var separator: PhoneFormatSeparator

    public init(_ index: Int, separator: PhoneFormatSeparator, priority: Int = 0) {
        self.index = index
        self.separator = separator
        self.priority = priority
    }
}

定义这些后，我创建了将规则与给定格式类型相关联的规则集。

/// Defines the rule sets associated with a given phone number type.
/// e.g. international/domestic/local
public protocol PhoneFormatRuleset {

    /// The type of phone number formatting to which these rules apply
    var type: PhoneFormatType { get set }

    /// A collection of rules to apply for this phone number type.
    var rules: [PhoneNumberFormatRule] { get set }

    /// The maximum length a number using this format ruleset should be. (Inclusive)
    var maxLength: Int { get set }
}

通过这种方式定义的所有内容，您可以快速设置规则集以适应您需要的任何格式。

这是一个规则集示例，它为美国通常使用的 phone 格式的连字符格式的数字字符串定义了 3 条规则：

    // Formats phone numbers:
    //  .local: 123-4567
    //  .domestic: 123-456-7890
    //  .international: +1 234-567-8901
    static func usHyphen() -> [PhoneFormatRuleset] {
        return [
            PNFormatRuleset(.local, rules: [
                PNFormatRule(3, separator: .hyphen)
                ], maxLength: 7),
            PNFormatRuleset(.domestic, rules: [
                PNFormatRule(3, separator: .hyphen),
                PNFormatRule(6, separator: .hyphen)
                ], maxLength: 10),
            PNFormatRuleset(.international, rules: [
                PNFormatRule(0, separator: .plus),
                PNFormatRule(1, separator: .space),
                PNFormatRule(4, separator: .hyphen),
                PNFormatRule(7, separator: .hyphen)
                ], maxLength: 11)
        ]
    }

格式化逻辑的（并非如此）繁重的工作发生在这里：

// formats a string using the format rule provided at initialization
public func format(number: String) -> String {

    // strip non numeric characters
    let n = number.components(separatedBy: CharacterSet.decimalDigits.inverted).joined()

    // bail if we have an empty string, or if no ruleset is defined to handle formatting
    guard n.count > 0, let type = type(for: n.count), let ruleset = ruleset(for: type) else {
        return n
    }

    // this is the string we'll return
    var formatted = ""

    // enumerate the numeric string
    for (i,character) in n.enumerated() {

        // bail if user entered more numbers than allowed for our formatting ruleset
        guard i <= ruleset.maxLength else {
            break
        }

        // if there is a separator defined to be inserted at this index then add it to the formatted string
        if let separator = ruleset.separator(for: i) {
            formatted+=separator
        }

        // now append the character
        formatted+="\(character)"
    }

    return formatted
}

我创建了一个带有示例项目的框架，您可以在这里查看：https://github.com/appteur/phoneformat

这是它在您键入时的工作方式：

我也设置了它，所以你可以用 cocoapods 导入它。

pod 'SwiftPhoneFormat', '1.0.0'

然后使用它：

import SwiftPhoneFormat

var formatter = PhoneFormatter(rulesets: PNFormatRuleset.usParethesis())
let formatted = formatter.format(number: numberString)

Answer 7

真正简单的解决方案：

extension String {
    func applyPatternOnNumbers(pattern: String, replacementCharacter: Character) -> String {
        var pureNumber = self.replacingOccurrences( of: "[^0-9]", with: "", options: .regularExpression)
        for index in 0 ..< pattern.count {
            guard index < pureNumber.count else { return pureNumber }
            let stringIndex = String.Index(utf16Offset: index, in: pattern)
            let patternCharacter = pattern[stringIndex]
            guard patternCharacter != replacementCharacter else { continue }
            pureNumber.insert(patternCharacter, at: stringIndex)
        }
        return pureNumber
    }
}

用法：

guard let text = textField.text else { return }
textField.text = text.applyPatternOnNumbers(pattern: "+# (###) ###-####", replacmentCharacter: "#")

Answer 8

Swift 4

创建此函数并调用文本字段事件编辑已更改

private func formatPhone(_ number: String) -> String {
    let cleanNumber = number.components(separatedBy: CharacterSet.decimalDigits.inverted).joined()
    let format: [Character] = ["X", "X", "X", "-", "X", "X", "X", "-", "X", "X", "X", "X"]

    var result = ""
    var index = cleanNumber.startIndex
    for ch in format {
        if index == cleanNumber.endIndex {
            break
        }
        if ch == "X" {
            result.append(cleanNumber[index])
            index = cleanNumber.index(after: index)
        } else {
            result.append(ch)
        }
    }
    return result
}

Answer 9

这是完全满足您要求的扩展：

 extension String {
 func convertToInternationalFormat() -> String {
    let isMoreThanTenDigit = self.count > 10
    _ = self.startIndex
    var newstr = ""
    if isMoreThanTenDigit {
        newstr = "\(self.dropFirst(self.count - 10))"
    }
    else if self.count == 10{
        newstr = "\(self)"
    }
    else {
        return "number has only \(self.count) digits"
    }
    if  newstr.count == 10 {
        let internationalString = "(\(newstr.dropLast(7))) \(newstr.dropLast(4).dropFirst(3)) \(newstr.dropFirst(6).dropLast(2)) \(newstr.dropFirst(8))"
        newstr = internationalString
    }
    return newstr
 }
 }

INPUT :
var str1 = "9253248954"
var str2 = "+19253248954"
var str3 = "19253248954"

OUTPUT :
str1.convertToInternationalFormat() // "(925) 324 89 54"
str2.convertToInternationalFormat() // "(925) 324 89 54"
str3.convertToInternationalFormat() // "(925) 324 89 54"

Answer 10

Swift Daria Prokopovich 的 5.1 更新很好的解决方案

extension String {

    func applyPatternOnNumbers(pattern: String, replacmentCharacter: Character) -> String {
        var pureNumber = self.replacingOccurrences( of: "[^0-9]", with: "", options: .regularExpression)
        for index in 0 ..< pattern.count {
            guard index < pureNumber.count else { return pureNumber }
            let stringIndex = String.Index(utf16Offset: index, in: self)
            let patternCharacter = pattern[stringIndex]
            guard patternCharacter != replacmentCharacter else { continue }
            pureNumber.insert(patternCharacter, at: stringIndex)
        }
        return pureNumber
    }
}

用法：

let formattedText = text.applyPatternOnNumbers(pattern: "+# (###) ###-####", replacmentCharacter: "#")

Answer 11

如果您宁愿不使用库也可以这样做。这是最佳示例的 link 或者您可以使用下面的代码。

https://ivrodriguez.com/format-phone-numbers-in-swift/

在 Swift 5.0 中格式化 10 位 phone 数字的简单代码片段，而不是包含一个大库，只需实现一个委托函数和一个格式化函数：

UITextFieldDelegate 函数

    func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    var fullString = textField.text ?? ""
    fullString.append(string)
    if range.length == 1 {
        textField.text = format(phoneNumber: fullString, shouldRemoveLastDigit: true)
    } else {
        textField.text = format(phoneNumber: fullString)
    }
    return false
}

格式化函数：

func format(phoneNumber: String, shouldRemoveLastDigit: Bool = false) -> String {
    guard !phoneNumber.isEmpty else { return "" }
    guard let regex = try? NSRegularExpression(pattern: "[\s-\(\)]", options: .caseInsensitive) else { return "" }
    let r = NSString(string: phoneNumber).range(of: phoneNumber)
    var number = regex.stringByReplacingMatches(in: phoneNumber, options: .init(rawValue: 0), range: r, withTemplate: "")

    if number.count > 10 {
        let tenthDigitIndex = number.index(number.startIndex, offsetBy: 10)
        number = String(number[number.startIndex..<tenthDigitIndex])
    }

    if shouldRemoveLastDigit {
        let end = number.index(number.startIndex, offsetBy: number.count-1)
        number = String(number[number.startIndex..<end])
    }

    if number.count < 7 {
        let end = number.index(number.startIndex, offsetBy: number.count)
        let range = number.startIndex..<end
        number = number.replacingOccurrences(of: "(\d{3})(\d+)", with: "() ", options: .regularExpression, range: range)

    } else {
        let end = number.index(number.startIndex, offsetBy: number.count)
        let range = number.startIndex..<end
        number = number.replacingOccurrences(of: "(\d{3})(\d{3})(\d+)", with: "() -", options: .regularExpression, range: range)
    }

    return number
}

Answer 12

Swift 5

String(
    format: "(%@) %@-%@",
    rawNumber.subString(from: 0, to: 2),
    rawNumber.subString(from: 3, to: 5),
    rawNumber.subString(from: 6, to: 9)
)

格式化 Swift 中的 Phone 个数字

Formatting Phone number in Swift

string

string-formatting

uitextfield

ios

swift

Swift 3 & 4

Swift 4

Swift 3

例子

示例输出

屏蔽号码输入