Comment tester si une chaîne est vide dans Objective-C?
Comment tester si un NSString est vide dans Objective-C?
Vous pouvez vérifier si [string length] == 0. Cela vérifiera s'il s'agit d'une chaîne valide mais vide (@ "") ainsi que si elle est nulle, puisque l'appel de length sur néant renverra également 0.
La réponse de Marc est correcte. Mais je profite de cette occasion pour inclure un pointeur vers le isEmpty généralisé de Wil Shipley, qu'il a partagé sur son 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);
}
La première approche est valide, mais ne fonctionne pas si votre chaîne contient des espaces (@" "). Vous devez donc vider ces espaces avant de les tester.
Ce code efface tous les espaces vides des deux côtés de la chaîne:
[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];
Une bonne idée est de créer une macro afin de ne pas avoir à taper cette ligne de monstre:
#define allTrim( object ) [object stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ]
Maintenant vous pouvez utiliser:
NSString *emptyString = @" ";
if ( [allTrim( emptyString ) length] == 0 ) NSLog(@"Is empty!");
Une des meilleures solutions que j'ai jamais vues (meilleure que celle de Matt G) est cette fonction en ligne améliorée que j'ai trouvée sur un dépôt de Git Hub (celui de Wil Shipley, mais je ne trouve pas le lien):
// Check if the "thing" pass'd 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);
}
Vous devriez mieux utiliser cette catégorie:
@implementation NSString (Empty)
- (BOOL) isWhitespace{
return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]length] == 0);
}
@end
Passez simplement votre chaîne à la méthode suivante:
+(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;
}
Une autre option consiste à vérifier s'il est égal à @"" avec isEqualToString: comme ceci:
if ([myString isEqualToString:@""]) {
NSLog(@"myString IS empty!");
} else {
NSLog(@"myString IS NOT empty, it is: %@", myString);
}
Je mets ceci:
@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
Le problème est que si self est nul, cette fonction n'est jamais appelée. Ça va retourner faux, ce qui est désiré.
Version rapide
Bien qu'il s'agisse d'une question relevant de l'objectif C, je devais utiliser NSString dans Swift, aussi je vais également inclure une réponse ici.
let myNSString: NSString = ""
if myNSString.length == 0 {
print("String is empty.")
}
Ou si NSString est une option:
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.")
}
}
La version normale de Swift String est
let myString: String = ""
if myString.isEmpty {
print("String is empty.")
}
Voir aussi: Vérifier la chaîne vide dans Swift?
Utilisez simplement une des conditions ifelse comme indiqué ci-dessous:
Méthode 1:
if ([yourString isEqualToString:@""]) {
// yourString is empty.
} else {
// yourString has some text on it.
}
Méthode 2:
if ([yourString length] == 0) {
// Empty yourString
} else {
// yourString is not empty
}
Peut-être que cette réponse est le double des réponses déjà données, mais j’ai fait peu de modifications et de changements dans l’ordre de vérification des conditions. Veuillez vous référer au code ci-dessous:
+(BOOL)isStringEmpty:(NSString *)str
{
if(str == nil || [str isKindOfClass:[NSNull class]] || str.length==0) {
return YES;
}
return NO;
}
Vous pouvez vérifier si votre chaîne est vide ou non si vous utilisez cette méthode:
+(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;
}
La meilleure pratique consiste à faire en sorte qu'une classe partagée déclare UtilityClass et cette méthode de sorte que vous puissiez utiliser cette méthode en l'appelant simplement via votre application.
Vous avez 2 méthodes pour vérifier si la chaîne est vide ou non:
Supposons que votre nom de chaîne est NSString *strIsEmpty.
Méthode 1:
if(strIsEmpty.length==0)
{
//String is empty
}
else
{
//String is not empty
}
Méthode 2:
if([strIsEmpty isEqualToString:@""])
{
//String is empty
}
else
{
//String is not empty
}
Choisissez l’une des méthodes ci-dessus et découvrez si la chaîne est vide ou non.
Vérifiez simplement la longueur de votre chaîne
if (!yourString.length)
{
//your code
}
un message à NIL retournera nil ou 0, il n'est donc pas nécessaire de tester nil :).
Bonne codage ...
Post très utile, pour ajouter le support NSDictionary ainsi qu'un petit changement
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);
}
- (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;
}
Ça marche comme un charme pour moi
Si la NSString est s
if ([s isKindOfClass:[NSNull class]] || s == nil || [s isEqualToString:@""]) {
NSLog(@"s is empty");
} else {
NSLog(@"s containing %@", s);
}
Donc, mis à part le concept de base de la vérification d'une longueur de chaîne inférieure à 1, il est important de considérer le contexte de manière approfondie. Les langues, humaine, informatique ou autre, peuvent avoir des définitions différentes des chaînes vides et, dans ces mêmes langues, un contexte supplémentaire peut en modifier le sens.
Supposons qu'une chaîne vide signifie "une chaîne qui ne contient aucun caractère significatif dans le contexte actuel".
Cela pourrait signifier visuellement, étant donné que la couleur et la couleur de fond sont identiques dans une chaîne attribuée. Effectivement vide.
Cela pourrait signifier vide de caractères significatifs. Tous les points, tous les tirets ou tous les traits de soulignement peuvent être considérés comme vides. De plus, vide de caractères significatifs significatifs pourrait signifier une chaîne qui ne comprend aucun caractère que le lecteur comprend. Ils peuvent être des caractères dans un langage ou un ensemble de caractères défini comme dépourvu de sens pour le lecteur. Nous pourrions le définir un peu différemment en disant que la chaîne ne forme aucun mot connu dans une langue donnée.
Nous pourrions dire que le vide est fonction du pourcentage d'espace négatif dans les glyphes rendus.
Même une séquence de caractères non imprimables sans représentation visuelle générale n'est pas vraiment vide. Les personnages de contrôle viennent à l'esprit. En particulier, la gamme ASCII faible (je suis surpris que personne ne les ait mentionnés car ils utilisent beaucoup de systèmes et ne sont pas des espaces, car ils ne possèdent normalement pas de glyphes ni de métrique). Pourtant, la longueur de la chaîne n'est pas nulle.
Conclusion. La longueur seule n'est pas la seule mesure ici. L’appartenance à un ensemble contextuel est également très importante.
L'appartenance à un jeu de caractères est une mesure supplémentaire commune très importante. Les séquences significatives sont également assez communes. (pensez à SETI ou crypto ou captchas) Il existe également d'autres ensembles de contextes plus abstraits.
Réfléchissez donc bien avant de supposer qu'une chaîne est vide uniquement en fonction de la longueur ou des espaces.
Le meilleur moyen est d'utiliser la catégorie.
Vous pouvez vérifier la fonction suivante. Qui a toutes les conditions à vérifier.
-(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;
}
Vous pouvez facilement vérifier si la chaîne est vide avec ceci:
if ([yourstring isEqualToString:@""]) {
// execute your action here if string is empty
}
C'est aussi simple que if([myString isEqual:@""]) ou if([myString isEqualToString:@""])
if (string.length == 0) stringIsEmpty;
J'ai vérifié une chaîne vide en utilisant le code ci-dessous:
//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"];
}
vérifie ça :
if ([yourString isEqualToString:@""])
{
NsLog(@"Blank String");
}
Ou
if ([yourString length] == 0)
{
NsLog(@"Blank String");
}
J'espère que cela aidera.
Le meilleur moyen dans tous les cas est de vérifier la longueur de la chaîne donnée. Pour cela, si votre chaîne est myString, le code est le suivant:
int len = [myString length];
if(len == 0){
NSLog(@"String is empty");
}
else{
NSLog(@"String is : %@", myString);
}
//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;
}
if(str.length == 0 || [str isKindOfClass: [NSNull class]]){
NSLog(@"String is empty");
}
else{
NSLog(@"String is not empty");
}
Essayez ce qui suit
NSString *stringToCheck = @"";
if ([stringToCheck isEqualToString:@""])
{
NSLog(@"String Empty");
}
else
{
NSLog(@"String Not Empty");
}
Vous pouvez avoir une chaîne vide de deux manières:
1) @ "" // ne contient pas d'espace
2) @ "" // contient de l'espace
Techniquement, les deux chaînes sont vides. Nous pouvons écrire les deux choses simplement en utilisant UN
if ([firstNameTF.text stringByReplacingOccurrencesOfString:@" " withString:@""].length==0)
{
NSLog(@"Empty String");
}
else
{
NSLog(@"String contains some value");
}