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
}