Formattting numéro de Téléphone dans l'Swift

Swift 3 & 4

Cette solution supprime tous les caractères non numériques avant d'appliquer la mise en forme. Il retourne nil si la source numéro de téléphone ne peut pas être formatée selon les hypothèses.

Swift 4

La Swift 4 solution des comptes pour l'abandon du CharacterView et la Piqûre de devenir une collection de caractères que l'CharacterView est.

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 || (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 || (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])
}
}

Exemple

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"))

Exemple De Sortie

'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'

OriginalL'auteur Mobile Dan

Vraiment la solution la plus simple:

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(encodedOffset: index)
let patternCharacter = pattern[stringIndex]
guard patternCharacter != replacmentCharacter else { continue }
pureNumber.insert(patternCharacter, at: stringIndex)
}
return pureNumber
}
}

Utilisation:

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

OriginalL'auteur Дарія Прокопович

Swift 3, mais devrait également être traduisible Swift 4

1. ErrorHandling

   enum PhoneNumberFormattingError: Error {
   case wrongCharactersInPhoneNumber
   case phoneNumberLongerThanPatternAllowes
   }

2. De Créer Des Motifs

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

3. Insérer Une Fonction

   /**
   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
   }
   }

4. Utilisation

   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

OriginalL'auteur Thomas Staltner

Il y a un certain nombre de bonnes réponses ici, mais j'ai pris une approche complètement différente et j'ai pensé partager au cas où il permet.

Pour commencer j'ai rompu la mise en forme étapes et les composants dans leurs propres responsabilités distinctes.

Numéro de téléphone, le format peut généralement être divisé en local, national ou international types de formats qui varient en longueur de la chaîne.

J'ai défini les types:

///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
}

Ensuite défini les séparateurs disponibles pour formater une chaîne du numéro de télé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 "*"
}
}
}

Ensuite, j'ai défini des règles de mise en forme que spécifier l'index (dans un numéro de téléphone string) où les séparateurs comme +,-,etc, sont insérés.

//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
}
}

Avec ces définie, j'ai créé des règles qui associent les règles avec un certain type de format.

///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 }
}

Avec tout défini de cette façon, vous pouvez configurer des règles rapidement pour convenir à n'importe quel format que vous avez besoin.

Voici un exemple d'un jeu de règles qui définit les 3 règles pour un trait d'union formaté chaîne du numéro de téléphone généralement utilisés dans les états-unis:

    //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)
]
}

La (pas si) de soulever des poids lourds de la logique de mise en forme qui se passe ici:

//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
} 

J'ai créé un cadre avec un exemple de projet que vous pouvez regarder par ici: https://github.com/appteur/phoneformat

Ici est de savoir comment il fonctionne lorsque vous tapez:

J'ai aussi configurer de sorte que vous pouvez simplement importer avec cocoapods.

pod 'SwiftPhoneFormat', '1.0.0'

Puis l'utiliser:

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

OriginalL'auteur digitalHound

C'est l'extension qui permettra de remplir pleinement vos besoins:

 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"

OriginalL'auteur Prabhat Kasera