usado - comprobar imei de iphone

Averiguar si una cadena es numérica o no

Question

¿Cómo podemos verificar si una cadena está formada únicamente por números? Estoy sacando una subcadena de una cadena y quiero comprobar si es una subcadena numérica o no.

NSString *newString = [myString substringWithRange:NSMakeRange(2,3)];

Answer 1

Creo que la forma más fácil de verificar que cada personaje dentro de una cadena dada sea numérico es probablemente:

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

Utilice uno de los otros métodos de fábrica de NSCharacterSet si desea un control completo sobre los caracteres aceptables.

Answer 2

Esta es una forma que no depende de la precisión limitada de intentar analizar la cadena como un número:

NSCharacterSet* notDigits = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];
if ([newString rangeOfCharacterFromSet:notDigits].location == NSNotFound)
{
    // newString consists only of the digits 0 through 9
}

Ver +[NSCharacterSet decimalDigitCharacterSet] y -[NSString rangeOfCharacterFromSet:] .

Answer 3

Esta pregunta original fue sobre Objective-C, pero también se publicó años antes de que se anunciara Swift. Entonces, si vienes desde Google y estás buscando una solución que use Swift, aquí tienes:

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

Answer 4

Extensión 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
}  }

Answer 5

La solución de Swift 3 podría ser como:

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

Answer 6

Otra opción más:

- (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;
    }
}

Ejemplo de uso:

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

Answer 7

Prueba si una cadena es un número podría ser útil

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

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

Answer 8

Puede crear un NSScanner y simplemente escanear la cadena:

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

Consulte la documentación de NSScanner para obtener más métodos para elegir.

Answer 9

Solución de Swift 3 si necesita verificar que la cadena tiene solo dígitos:

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

Answer 10

Sugiero usar el método numberFromString: de la clase NSNumberFormatter , como si el número no fuera válido, devolverá nil; de lo contrario, le devolverá un NSNumber.

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

Answer 11

Una extensión de la respuesta de @John Calsbeek y una aclaración de los comentarios de @Jeff y @gyratory circus .

+ (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;
}

Lo siguiente se puede agregar como métodos de categoría para 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;
}

Answer 12

Valide por expresión regular, por patrón "^[0-9]+$" , con el siguiente método -validateString:withPattern:

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

1. Si se considera "123.123"
   • Con el patrón "^[0-9]+(.{1}[0-9]+)?$"
2. Si exactamente números de 4 dígitos, sin "." .
   • Con el patrón "^[0-9]{4}$" .
3. Si los números de dígitos sin "." , y la longitud es entre 2 ~ 5.
   • Con el patrón "^[0-9]{2,5}$" .

La expresión regular se puede verificar en el sitio web en línea .

La función auxiliar es la siguiente.

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

Swift 3 versión:

Prueba en el patio de recreo.

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)

Answer 13

para ser claro, esto funciona para enteros en cadenas.

Aquí hay una pequeña categoría de ayudante basada en la respuesta de Juan arriba:

en archivo .h

@interface NSString (NumberChecking)

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

@end

en archivo .m

#import "NSString+NumberChecking.h"

@implementation NSString (NumberChecking)

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

@end

uso:

#import "NSString+NumberChecking.h"

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

Answer 14

Para Swift 3

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