如何检查是一个字符串或数字？

编辑 Swift 2.2:

在迅捷2.2中使用 Int(yourArray[1])

var yourArray = ["abc", "94761178","790"]
var num = Int(yourArray[1])
if num != nil {
println("Valid Integer")
}
else {
println("Not Valid Integer")
}

它将向您显示字符串是有效的整数，并且 num包含有效的 Int。您可以使用 num进行计算。

来自文件:

如果该字符串表示适合整数的整数，则返回 对应的整数。它接受匹配正则 仅表达“[-+ ] ? [0-9] +”。

从下面的 stackoverflow 文章中获得下面的 isInteger ()函数: 在 Java 中确定 String 是否为整数

我认为这就是您想要做的(其中 nameOfArray 是您想要传递的数组)

void convertStrArrayToIntArray( int[] integerArray ) {


for (int i = 0; i < nameOfArray.length(); i++) {
if (!isInteger(nameOfArray[i])) {
integerArray[i] = nameOfArray[i].toString();
}
}


}

正确的方法是使用 String的 toInt()方法，以及一个可选的绑定来确定转换是否成功。所以你的循环应该是这样的:

let myArray = ["abc", "94761178","790"]


for val in myArray {
if let intValue = val.toInt() {
// It's an int
println(intValue)
} else {
// It's not an int
println(val)
}
}

toInt()方法返回一个 Int?，即一个可选的 Int，如果字符串不能转换为整数，则返回 nil; 如果转换成功，返回一个 Int值(包装在可选内容中)。

方法文档(使用 CMD + 单击 Xcode 中的 toInt显示)说明:

如果该字符串表示适合整数的整数，则返回相应的整数。它接受匹配正则表达式“[-+ ] ？[0-9] + .

从 Swift 2开始，删除了 String.toInt ()。 引入了一个新的 Int Initializer: Int (str: String)

for target in ["abc", "94761178","790"]
{
if let number = Int(target)
{
print("value: \(target) is a valid number. add one to get :\(number+1)!")
}
else
{
print("value: \(target) is not a valid  number.")
}
}

请注意，使用 Int初始值设定项检查字符串/数字是有限制的。具体来说，是2 ^ 32-1或4294967295的最大值。这可能会导致问题，因为电话号码8005551234将不能通过 Int(8005551234)检查，尽管是一个有效的号码。

更安全的方法是使用 NSCharacterSet检查字符串范围内与小数集匹配的任何字符。

let number = "8005551234"
let numberCharacters = NSCharacterSet.decimalDigitCharacterSet().invertedSet
if !number.isEmpty && number.rangeOfCharacterFromSet(numberCharacters) == nil {
// string is a valid number
} else {
// string contained non-digit characters
}

此外，将其添加到 String扩展中可能会很有用。

public extension String {


func isNumber() -> Bool {
let numberCharacters = NSCharacterSet.decimalDigitCharacterSet().invertedSet
return !self.isEmpty && self.rangeOfCharacterFromSet(numberCharacters) == nil
}


}

下面是一个使用 String 扩展的小型 Swift 版本:

斯威夫特3/斯威夫特4:

extension String  {
var isNumber: Bool {
return !isEmpty && rangeOfCharacter(from: CharacterSet.decimalDigits.inverted) == nil
}
}

斯威夫特2:

   extension String  {
var isNumber : Bool {
get{
return !self.isEmpty && self.rangeOfCharacterFromSet(NSCharacterSet.decimalDigitCharacterSet().invertedSet) == nil
}
}
}

如果您想要接受一个更细粒度的方法(即接受像 4.5或 第三季，第10集这样的数字) ，您可以这样进行:

func isNumber(val: String) -> Bool
{
var result: Bool = false
let parseDotComNumberCharacterSet = NSMutableCharacterSet.decimalDigitCharacterSet()
parseDotComNumberCharacterSet.formUnionWithCharacterSet(NSCharacterSet(charactersInString: ".e"))


let noNumberCharacters = parseDotComNumberCharacterSet.invertedSet
if let v = val
{
result = !v.isEmpty && v.rangeOfCharacterFromSet(noNumberCharacters) == nil
}
return result
}

为了获得更好的分辨率，您可以使用正则表达式. 。

Xcode 8和 Swift 3.0

我们还可以检查:

 //MARK: - NUMERIC DIGITS
class func isString10Digits(ten_digits: String) -> Bool{


if !ten_digits.isEmpty {


let numberCharacters = NSCharacterSet.decimalDigits.inverted
return !ten_digits.isEmpty && ten_digits.rangeOfCharacter(from: numberCharacters) == nil
}
return false
}

Swift 3.0版本

func isNumber(stringToTest : String) -> Bool {
let numberCharacters = CharacterSet.decimalDigits.inverted
return !s.isEmpty && s.rangeOfCharacter(from:numberCharacters) == nil
}

我认为最好的解决办法是:

extension String {
var isNumeric : Bool {
return Double(self) != nil
}
}

斯威夫特三，四

extension String {
var isNumber: Bool {
let characters = CharacterSet.decimalDigits.inverted
return !self.isEmpty && rangeOfCharacter(from: characters) == nil
}
}

这种方法也适用于混合数字的字符串:

public extension String {
func isNumber() -> Bool {
return !self.isEmpty && self.rangeOfCharacter(from: CharacterSet.decimalDigits) != nil && self.rangeOfCharacter(from: CharacterSet.letters) == nil
}}

你会得到这样的结果:

这个代码对我适用于 Swift 3/4

  func isNumber(textField: UITextField) -> Bool {
let allowedCharacters = CharacterSet.decimalDigits
let characterSet = CharacterSet(charactersIn: textField.text!)
return allowedCharacters.isSuperset(of: characterSet)
//        return true
}

我认为使用 NumberFormatter是一种简单的方法: (Swift 5)

import Foundation


extension String {


private static let numberFormatter = NumberFormatter()


var isNumeric : Bool {
Self.numberFormatter.number(from: self) != nil
}
}

您可以对任意长度的整数使用此方法。

func getIntegerStrings(from givenStrings: [String]) -> [String]
{
var integerStrings = [String]()
for string in givenStrings
{
let isValidInteger = isInteger(givenString: string)
if isValidInteger { integerStrings.append(string) }
}
return integerStrings
}


func isInteger(givenString: String) -> Bool
{
var answer = true
givenString.forEach { answer = ("0"..."9").contains($0) && answer }
return answer
}


func getIntegers(from integerStrings: [String]) -> [Int]
{
let integers = integerStrings.compactMap { Int($0) }
return integers
}


let strings = ["abc", "94761178", "790", "18446744073709551615000000"]
let integerStrings = getIntegerStrings(from: strings)
let integers = getIntegers(from: integerStrings)


print(integerStrings) // ["94761178", "790", "18446744073709551615000000"]
print(integers) // [94761178, 790]

但是，正如@Can 所指出的，您只能获得2 ^ 31-1的整数值(32位拱上的有符号整数限制)。但是，对于较大的值，仍然可以得到字符串表示形式。

简单的解决办法如下:

extension String {
public var isNumber: Bool {
return !isEmpty && rangeOfCharacter(from: CharacterSet.decimalDigits.inverted) == nil
}
}

这段代码将返回一个转换后的整数数组:

["abc", "94761178","790"].map(Int.init) // returns [ nil, 94761178, 790 ]

或者

["abc", "94761178","790"].map { Int($0) ?? 0 } // returns [ 0, 94761178, 790 ]