Savoir si une chaîne est numérique ou non

Je suggère d'utiliser la méthode numberFromString: de la classe NSNumberFormatter, comme si le nombre n'était pas valide, il retournerait nil; sinon, il vous renverra un NSNumber.

NSNumberFormatter *nf = [[[NSNumberFormatter alloc] init] autorelease];
BOOL isDecimal = [nf numberFromString:newString] != nil;

Vous pouvez créer un NSScanner et simplement scanner la chaîne:

NSDecimal decimalValue;
NSScanner *sc = [NSScanner scannerWithString:newString];
[sc scanDecimal:&decimalValue];
BOOL isDecimal = [sc isAtEnd];

Consultez la documentation de NSScanner pour plus de méthodes à choisir.

Je pense que la meilleure façon de vérifier que chaque caractère dans une chaîne donnée est numérique est probablement:

NSString *trimmedString = [newString stringByTrimmingCharactersInSet:[NSCharacterSet decimalDigitCharacterSet]];

if([trimmedString length])
{
    NSLog(@"some characters outside of the decimal character set found");
}
else
{
    NSLog(@"all characters were in the decimal character set");
}

Utilisez l'une des autres méthodes nscaracterset factory Si vous voulez un contrôle complet sur les caractères acceptables.

Validez par expression régulière, par motif "^[0-9]+$", avec la méthode suivante -validateString:withPattern:.

[self validateString:"12345" withPattern:"^[0-9]+$"];

1. Si "123.123" est considéré
   • avec motif "^[0-9]+(.{1}[0-9]+)?$"
2. Si exactement 4 chiffres, sans ".".
   • avec motif "^[0-9]{4}$".
3. si chiffres sans ".", et la longueur est comprise entre 2 ~ 5.
   • avec motif "^[0-9]{2,5}$".

L'expression régulière peut être vérifié dans le web en ligne site .

La fonction d'aide est la suivante.

// Validate the input string with the given pattern and
// return the result as a boolean
- (BOOL)validateString:(NSString *)string withPattern:(NSString *)pattern
{
    NSError *error = nil;
    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:pattern options:NSRegularExpressionCaseInsensitive error:&error];

    NSAssert(regex, @"Unable to create regular expression");

    NSRange textRange = NSMakeRange(0, string.length);
    NSRange matchRange = [regex rangeOfFirstMatchInString:string options:NSMatchingReportProgress range:textRange];

    BOOL didValidate = NO;

    // Did we find a matching range
    if (matchRange.location != NSNotFound)
        didValidate = YES;

    return didValidate;
}

Version Swift 3:

Test dans le terrain de jeu.

import UIKit
import Foundation

func validate(_ str: String, pattern: String) -> Bool {
    if let range = str.range(of: pattern, options: .regularExpression) {
        let result = str.substring(with: range)
        print(result)
        return true
    }
    return false
}

let a = validate("123", pattern: "^[0-9]+")
print(a)

Cette question originale portait sur Objective-C, mais elle a également été publiée des années avant L'annonce de Swift. Donc, si vous venez ici de Google et que vous cherchez une solution qui utilise Swift, voici:

let testString = "12345"
let badCharacters = NSCharacterSet.decimalDigitCharacterSet().invertedSet

if testString.rangeOfCharacterFromSet(badCharacters) == nil {
    print("Test string was a number")
} else {
    print("Test string contained non-digit characters.")
}

Pour être clair, cela fonctionne pour les entiers dans les chaînes.

Voici une petite catégorie d'aide basée sur la réponse de John ci-dessus:

Dans .h fichier

@interface NSString (NumberChecking)

+(bool)isNumber:(NSString *)string;

@end

Dans .m fichier

#import "NSString+NumberChecking.h"

@implementation NSString (NumberChecking)

+(bool)isNumber {
    if([self rangeOfCharacterFromSet:[[NSCharacterSet decimalDigitCharacterSet] invertedSet]].location == NSNotFound) {
        return YES;
    }else {
        return NO;
    }
}

@end

Utilisation:

#import "NSString+NumberChecking.h"

if([someString isNumber]) {
    NSLog(@"is a number");
}else {
    NSLog(@"not a number");
}

La solution Swift 3 pourrait être comme:

extension String {

    var doubleValue:Double? {
        return NumberFormatter().number(from:self)?.doubleValue
    }

    var integerValue:Int? {
        return NumberFormatter().number(from:self)?.intValue
    }

    var isNumber:Bool {
        get {
            let badCharacters = NSCharacterSet.decimalDigits.inverted
            return (self.rangeOfCharacter(from: badCharacters) == nil)
        }
    }
}

Solution Swift 3 si besoin de vérifier que la chaîne n'a que des chiffres:

CharacterSet.decimalDigits.isSuperset(of: CharacterSet(charactersIn: myString))

Encore une autre option:

- (BOOL)isValidNumber:(NSString*)text regex:(NSString*)regex {
    @try {
        NSPredicate *predicate = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", regex];
        return [predicate evaluateWithObject:text];
    }
    @catch (NSException *exception) {
        assert(false); 
        return NO;
    }
}

Exemple d'Utilisation:

BOOL isValid = [self isValidNumber:@"1234" regex:@"^[0-9]+$"];

Tester si une chaîne est un nombre peut être utile

int i = [@"12.3" rangeOfCharacterFromSet: [ [NSCharacterSet characterSetWithCharactersInString:@"0123456789."] invertedSet] ].location;

if (i == NSNotFound) {
     //is a number
}

Extension Swift:

extension NSString {
func isNumString() -> Bool {
    let numbers = NSCharacterSet(charactersInString: "0123456789.").invertedSet
    let range = self.rangeOfCharacterFromSet(numbers).location
    if range == NSNotFound {
        return true
    }
    return false
}  }

Pour Swift 3

var onlyDigits: CharacterSet = CharacterSet.decimalDigits.inverted
if testString.rangeOfCharacter(from: onlyDigits) == nil {
  // String only consist digits 0-9
}

Une extension de @Jean Calsbeek'réponse de s, et la clarification de la @Jeff et @giratoire de cirque's commentaires.

+ (BOOL)doesContainDigitsOnly:(NSString *)string
{
    NSCharacterSet *nonDigits = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];

    BOOL containsDigitsOnly = [string rangeOfCharacterFromSet:nonDigits].location == NSNotFound;

    return containsDigitsOnly;
}

+ (BOOL)doesContainNonDigitsOnly:(NSString *)string
{
    NSCharacterSet *digits = [NSCharacterSet decimalDigitCharacterSet];

    BOOL containsNonDigitsOnly = [string rangeOfCharacterFromSet:digits].location == NSNotFound;

    return containsNonDigitsOnly;
}

Les éléments suivants peuvent être ajoutés en tant que méthodes de catégorie pour NSString

- (BOOL)doesContainDigitsOnly
{
    NSCharacterSet *nonDigits = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];

    BOOL containsDigitsOnly = [self rangeOfCharacterFromSet:nonDigits].location == NSNotFound;

    return containsDigitsOnly;
}

- (BOOL)doesContainNonDigitsOnly
{
    NSCharacterSet *digits = [NSCharacterSet decimalDigitCharacterSet];

    BOOL containsNonDigitsOnly = [self rangeOfCharacterFromSet:digits].location == NSNotFound;

    return containsNonDigitsOnly;
}