Como faço para testar se um NSString
está vazio no Objective-C?
Como faço para testar se um NSString
está vazio no Objective-C?
Respostas:
Você pode verificar se [string length] == 0
. Isso verificará se é uma sequência válida, mas vazia (@ "") e se é nula, pois a chamada length
nil também retornará 0.
ZERO WIDTH SPACE
é realmente não importa, porque, apesar disso , @"\u200B"
é um caractere; portanto, se você testar a seqüência de caracteres vazia, ela dirá que não é porque existe um caractere. Apenas não é possível imprimir seguindo o padrão Unicode.
![string length]
. Parece mais limpo.
A resposta de Marc está correta. Mas aproveito a oportunidade para incluir um ponteiro para a generalização de Wil Shipley isEmpty
, que ele compartilhou em seu blog :
static inline BOOL IsEmpty(id thing) {
return thing == nil
|| ([thing respondsToSelector:@selector(length)]
&& [(NSData *)thing length] == 0)
|| ([thing respondsToSelector:@selector(count)]
&& [(NSArray *)thing count] == 0);
}
-isNotEmpty
:)
A primeira abordagem é válida, mas não funciona se sua string tiver espaços em branco ( @" "
). Portanto, você deve limpar esses espaços em branco antes de testá-lo.
Este código limpa todos os espaços em branco nos dois lados da string:
[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];
Uma boa idéia é criar uma macro, para que você não precise digitar esta linha de monstro:
#define allTrim( object ) [object stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ]
Agora você pode usar:
NSString *emptyString = @" ";
if ( [allTrim( emptyString ) length] == 0 ) NSLog(@"Is empty!");
NSString
categoria que adiciona um método chamado trimmedString
que faz exatamente o que você escreveu.
whitespaceCharacterSet
não inclui novas linhas! Aqui está uma categoria que eu escrevi incluindo trim
e alguns outros métodos úteis: github.com/alexch/unsuck/blob/master/unsuck/NSString%2BUnsuck.m github.com/alexch/unsuck/blob/master/unsuckTests/…
Uma das melhores soluções que eu já vi (melhor que a de Matt G) é essa função inline aprimorada que peguei em um repo do Git Hub (o de Wil Shipley, mas não consigo encontrar o link):
// Check if the "thing" passed is empty
static inline BOOL isEmpty(id thing) {
return thing == nil
|| [thing isKindOfClass:[NSNull class]]
|| ([thing respondsToSelector:@selector(length)]
&& [(NSData *)thing length] == 0)
|| ([thing respondsToSelector:@selector(count)]
&& [(NSArray *)thing count] == 0);
}
condenseToSingleNSData(id thing)
? expandToNSArray(id thing)
? Mais cedo ou mais tarde, você perguntará com que classe de classe está lidando, melhor fazê-lo na primeira referência.
Você deve usar melhor esta categoria:
@implementation NSString (Empty)
- (BOOL) isWhitespace{
return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]length] == 0);
}
@end
@implementation NSString (Empty) - (BOOL) empty{ return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]length] == 0); } @end
Como uma combinação da resposta de Marc e Kyle.
Eu coloquei isso:
@implementation NSObject (AdditionalMethod)
-(BOOL) isNotEmpty
{
return !(self == nil
|| [self isKindOfClass:[NSNull class]]
|| ([self respondsToSelector:@selector(length)]
&& [(NSData *)self length] == 0)
|| ([self respondsToSelector:@selector(count)]
&& [(NSArray *)self count] == 0));
};
@end
O problema é que, se o eu for nulo, essa função nunca será chamada. Retornará false, o que é desejado.
-(BOOL)isEmpty{ return ![self isNotEmpty]}
não funcionará na categoria.
condenseToSingleNSData(id thing)
? expandToNSArray(id thing)
? Mais cedo ou mais tarde, você perguntará com que classe de classe está lidando, melhor fazê-lo na primeira referência.
Apenas passe sua string para o seguinte método:
+(BOOL)isEmpty:(NSString *)str
{
if(str.length==0 || [str isKindOfClass:[NSNull class]] || [str isEqualToString:@""]||[str isEqualToString:NULL]||[str isEqualToString:@"(null)"]||str==nil || [str isEqualToString:@"<null>"]){
return YES;
}
return NO;
}
Basta usar uma das if
else
condições, como mostrado abaixo:
Método 1:
if ([yourString isEqualToString:@""]) {
// yourString is empty.
} else {
// yourString has some text on it.
}
Método 2:
if ([yourString length] == 0) {
// Empty yourString
} else {
// yourString is not empty
}
Embora essa seja uma pergunta do Objetivo C, eu precisava usar o NSString
Swift, por isso também incluirei uma resposta aqui.
let myNSString: NSString = ""
if myNSString.length == 0 {
print("String is empty.")
}
Ou se NSString
for um opcional:
var myOptionalNSString: NSString? = nil
if myOptionalNSString == nil || myOptionalNSString!.length == 0 {
print("String is empty.")
}
// or alternatively...
if let myString = myOptionalNSString {
if myString.length != 0 {
print("String is not empty.")
}
}
A String
versão normal do Swift é
let myString: String = ""
if myString.isEmpty {
print("String is empty.")
}
Veja também: Verifique a sequência vazia no Swift?
Pode ser que essa resposta seja a duplicata das respostas já fornecidas, mas fiz poucas modificações e alterações na ordem de verificação das condições. Consulte o código abaixo:
+(BOOL)isStringEmpty:(NSString *)str
{
if(str == nil || [str isKindOfClass:[NSNull class]] || str.length==0) {
return YES;
}
return NO;
}
Você pode verificar se sua string está vazia ou não usando este método:
+(BOOL) isEmptyString : (NSString *)string
{
if([string length] == 0 || [string isKindOfClass:[NSNull class]] ||
[string isEqualToString:@""]||[string isEqualToString:NULL] ||
string == nil)
{
return YES; //IF String Is An Empty String
}
return NO;
}
A melhor prática é fazer com que uma classe compartilhada diga UtilityClass e anuncie esse método para que você possa usar esse método apenas chamando-o através de seu aplicativo.
Você tem 2 métodos para verificar se a sequência está vazia ou não:
Vamos supor que seu nome de string seja NSString *strIsEmpty
.
Método 1:
if(strIsEmpty.length==0)
{
//String is empty
}
else
{
//String is not empty
}
Método 2:
if([strIsEmpty isEqualToString:@""])
{
//String is empty
}
else
{
//String is not empty
}
Escolha qualquer um dos métodos acima e saiba se a string está vazia ou não.
Basta verificar o comprimento da corda
if (!yourString.length)
{
//your code
}
uma mensagem para NIL retornará nulo ou 0, portanto, não é necessário testar nil :).
Feliz codificação ...
Portanto, além do conceito básico de verificar se o comprimento de uma string é menor que 1, é importante considerar o contexto profundamente. Os idiomas humano ou computador ou de outra forma podem ter definições diferentes de cadeias vazias e, nesses mesmos idiomas, um contexto adicional pode alterar ainda mais o significado.
Digamos que string vazia signifique "uma string que não contenha caracteres significativos no contexto atual".
Isso pode significar visualmente, pois na cor e na cor de fundo são as mesmas em uma sequência atribuída. Efetivamente vazio.
Isso pode significar vazio de caracteres significativos. Todos os pontos, traços ou sublinhados podem ser considerados vazios. Além disso, vazio de caracteres significativos significativos pode significar uma sequência que não possui caracteres que o leitor entenda. Eles podem ser caracteres em um idioma ou conjunto de caracteres definido como sem sentido para o leitor. Poderíamos definir um pouco diferente dizer que a string não forma palavras conhecidas em um determinado idioma.
Poderíamos dizer que vazio é uma função da porcentagem de espaço negativo nos glifos renderizados.
Mesmo uma sequência de caracteres não imprimíveis sem representação visual geral não está realmente vazia. Personagens de controle vêm à mente. Especialmente a faixa ASCII baixa (fico surpreso que ninguém tenha mencionado isso porque eles usam muitos sistemas e não são espaços em branco, pois normalmente não têm glifos nem métricas visuais). No entanto, o comprimento da string não é zero.
Conclusão. O comprimento por si só não é a única medida aqui. A associação ao conjunto contextual também é bastante importante.
A associação ao conjunto de caracteres é uma medida adicional comum muito importante. Sequências significativas também são bastante comuns. (pense em SETI ou cripto ou captchas) Também existem conjuntos de contexto mais abstratos.
Portanto, pense com cuidado antes de assumir que uma string está vazia apenas com base no comprimento ou espaço em branco.
Postagem muito útil, para adicionar suporte ao NSDictionary, bem como uma pequena alteração
static inline BOOL isEmpty(id thing) {
return thing == nil
|| [thing isKindOfClass:[NSNull class]]
|| ([thing respondsToSelector:@selector(length)]
&& ![thing respondsToSelector:@selector(count)]
&& [(NSData *)thing length] == 0)
|| ([thing respondsToSelector:@selector(count)]
&& [thing count] == 0);
}
condenseToSingleNSData(id thing)
? expandToNSArray(id thing)
? Mais cedo ou mais tarde, você perguntará com que classe de classe está lidando, melhor fazê-lo na primeira referência.
- (BOOL)isEmpty:(NSString *)string{
if ((NSNull *) string == [NSNull null]) {
return YES;
}
if (string == nil) {
return YES;
}
if ([string length] == 0) {
return YES;
}
if ([[string stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceAndNewlineCharacterSet]] length] == 0) {
return YES;
}
if([[string stringByStrippingWhitespace] isEqualToString:@""]){
return YES;
}
return NO;
}
stringByStrippingWhitespace
A melhor maneira é usar a categoria.
Você pode verificar a seguinte função. Que tem todas as condições para verificar.
-(BOOL)isNullString:(NSString *)aStr{
if([(NSNull *)aStr isKindOfClass:[NSNull class]]){
return YES;
}
if ((NSNull *)aStr == [NSNull null]) {
return YES;
}
if ([aStr isKindOfClass:[NSNull class]]){
return YES;
}
if(![[aStr stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] length]){
return YES;
}
return NO;
}
if (string.length == 0) stringIsEmpty;
Você pode facilmente verificar se a string está vazia com isso:
if ([yourstring isEqualToString:@""]) {
// execute your action here if string is empty
}
Eu verifiquei uma string vazia usando o código abaixo:
//Check if we have any search terms in the search dictionary.
if( (strMyString.text==(id) [NSNull null] || [strMyString.text length]==0
|| strMyString.text isEqual:@"")) {
[AlertView showAlert:@"Please enter a valid string"];
}
É tão simples quanto if([myString isEqual:@""])
ouif([myString isEqualToString:@""])
//Different validations:
NSString * inputStr = @"Hey ";
//Check length
[inputStr length]
//Coming from server, check if its NSNull
[inputStr isEqual:[NSNull null]] ? nil : inputStr
//For validation in allowed character set
-(BOOL)validateString:(NSString*)inputStr
{
BOOL isValid = NO;
if(!([inputStr length]>0))
{
return isValid;
}
NSMutableCharacterSet *allowedSet = [NSMutableCharacterSet characterSetWithCharactersInString:@".-"];
[allowedSet formUnionWithCharacterSet:[NSCharacterSet decimalDigitCharacterSet]];
if ([inputStr rangeOfCharacterFromSet:[allowedSet invertedSet]].location == NSNotFound)
{
// contains only decimal set and '-' and '.'
}
else
{
// invalid
isValid = NO;
}
return isValid;
}
Você pode ter uma sequência vazia de duas maneiras:
1) @ "" // Não contém espaço
2) @ "" // Contém espaço
Tecnicamente, as duas cordas estão vazias. Podemos escrever as duas coisas apenas usando UMA condição
if ([firstNameTF.text stringByReplacingOccurrencesOfString:@" " withString:@""].length==0)
{
NSLog(@"Empty String");
}
else
{
NSLog(@"String contains some value");
}
Tente o seguinte
NSString *stringToCheck = @"";
if ([stringToCheck isEqualToString:@""])
{
NSLog(@"String Empty");
}
else
{
NSLog(@"String Not Empty");
}
if(str.length == 0 || [str isKindOfClass: [NSNull class]]){
NSLog(@"String is empty");
}
else{
NSLog(@"String is not empty");
}
str.length
lançará uma exceção se str
for nulo.
if( [txtMobile.text length] == 0 )
{
[Utility showAlertWithTitleAndMessage: AMLocalizedString(@"Invalid Mobile No",nil) message: AMLocalizedString(@"Enter valid Mobile Number",nil)];
}
@"\u200B"
(consistindo apenas no caractere Unicode ZERO WIDTH SPACE . A impressão imprimirá 0 caracteres (verifique usando fonte monoespaçada), mas string.length fornecerá 1. Existem outros caracteres Unicode (como OBJECT REPLACEMENT CHARACTER ) que se comportam da mesma forma. obter o último ao analisar texto PDF.