Wie teste ich, ob eine Zeichenfolge in Objective-C leer ist?
Wie teste ich, ob ein NSString in Objective-C leer ist?
Sie können überprüfen, ob [string length] == 0. Dies prüft, ob es sich um eine gültige, aber leere Zeichenfolge (@ "") handelt und ob sie null ist, da der Aufruf von length bei null ebenfalls 0 zurückgibt.
Marc hat richtig geantwortet. Aber ich werde diese Gelegenheit nutzen, um einen Hinweis auf Wil Shipleys verallgemeinertes isEmpty aufzunehmen, den er in seinem 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);
}
Der erste Ansatz ist gültig, funktioniert aber nicht, wenn Ihre Zeichenfolge Leerzeichen enthält (@" "). Sie müssen also diese Leerzeichen löschen, bevor Sie sie testen.
Dieser Code löscht alle Leerzeichen auf beiden Seiten der Zeichenfolge:
[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];
Eine gute Idee ist, ein Makro zu erstellen, damit Sie diese Monsterzeile nicht eingeben müssen:
#define allTrim( object ) [object stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ]
Jetzt können Sie verwenden:
NSString *emptyString = @" ";
if ( [allTrim( emptyString ) length] == 0 ) NSLog(@"Is empty!");
Eine der besten Lösungen, die ich je gesehen habe (besser als die von Matt G), ist diese verbesserte Inline-Funktion, die ich bei einigen Git Hub-Repos (Wil Shipleys, aber ich kann den Link nicht finden) gefunden habe:
// 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);
}
Sie sollten diese Kategorie besser verwenden:
@implementation NSString (Empty)
- (BOOL) isWhitespace{
return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]length] == 0);
}
@end
Übergeben Sie einfach Ihren String an folgende Methode:
+(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;
}
Eine andere Möglichkeit ist, zu überprüfen, ob es @"" mit isEqualToString: entspricht:
if ([myString isEqualToString:@""]) {
NSLog(@"myString IS empty!");
} else {
NSLog(@"myString IS NOT empty, it is: %@", myString);
}
Ich habe folgendes gesagt:
@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
Das Problem ist, dass diese Funktion niemals aufgerufen wird, wenn self gleich null ist. Es wird false zurückgegeben, was erwünscht ist.
Schnelle Version
Obwohl es sich um eine Ziel-C-Frage handelt, musste NSString in Swift verwendet werden, daher werde ich hier auch eine Antwort einfügen.
let myNSString: NSString = ""
if myNSString.length == 0 {
print("String is empty.")
}
Oder wenn NSString optional ist:
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.")
}
}
Die normale Swift String Version ist
let myString: String = ""
if myString.isEmpty {
print("String is empty.")
}
Siehe auch: Leerstring in Swift prüfen?
Verwenden Sie einfach eine der folgenden ifelse Bedingungen:
Methode 1:
if ([yourString isEqualToString:@""]) {
// yourString is empty.
} else {
// yourString has some text on it.
}
Methode 2:
if ([yourString length] == 0) {
// Empty yourString
} else {
// yourString is not empty
}
Vielleicht ist diese Antwort das Duplikat der bereits gegebenen Antworten, aber ich habe nur wenige Modifikationen und Änderungen in der Reihenfolge der Überprüfung der Bedingungen vorgenommen. Bitte beziehen Sie sich auf den folgenden Code:
+(BOOL)isStringEmpty:(NSString *)str
{
if(str == nil || [str isKindOfClass:[NSNull class]] || str.length==0) {
return YES;
}
return NO;
}
Mit dieser Methode können Sie überprüfen, ob Ihre Zeichenfolge leer ist oder nicht:
+(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;
}
Die beste Vorgehensweise besteht darin, eine gemeinsam genutzte Klasse dazu zu bringen, UtilityClass zu sagen, und diese Methode zu bewerben, damit Sie diese Methode verwenden können, indem Sie sie einfach in Ihrer Anwendung aufrufen.
Sie haben zwei Methoden, um zu überprüfen, ob die Zeichenfolge leer ist:
Nehmen wir an, Ihr String-Name ist NSString *strIsEmpty.
Methode 1:
if(strIsEmpty.length==0)
{
//String is empty
}
else
{
//String is not empty
}
Methode 2:
if([strIsEmpty isEqualToString:@""])
{
//String is empty
}
else
{
//String is not empty
}
Wählen Sie eine der oben genannten Methoden und erfahren Sie, ob die Zeichenfolge leer ist oder nicht.
Überprüfen Sie einfach Ihre Stringlänge
if (!yourString.length)
{
//your code
}
eine Nachricht an NIL gibt nil oder 0 zurück. Sie müssen also nicht auf nil testen :).
Viel Spaß beim Codieren ...
Sehr nützlicher Beitrag, um NSDictionary-Unterstützung sowie eine kleine Änderung hinzuzufügen
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;
}
Es wirkt wie ein Zauber für mich
Wenn NSStrings ist
if ([s isKindOfClass:[NSNull class]] || s == nil || [s isEqualToString:@""]) {
NSLog(@"s is empty");
} else {
NSLog(@"s containing %@", s);
}
Abgesehen von dem Grundkonzept, nach einer String-Länge von weniger als 1 zu suchen, ist es daher wichtig, den Kontext gründlich zu betrachten. Sprachen Mensch oder Computer oder auf andere Weise haben möglicherweise unterschiedliche Definitionen für leere Zeichenfolgen, und innerhalb derselben Sprachen kann zusätzlicher Kontext die Bedeutung weiter ändern.
Angenommen, leere Zeichenfolge bedeutet "eine Zeichenfolge, die im aktuellen Kontext keine signifikanten Zeichen enthält".
Dies könnte visuell bedeuten, da Farbe und Hintergrundfarbe in einer zugewiesenen Zeichenfolge identisch sind. Effektiv leer.
Dies kann bedeuten, dass keine aussagekräftigen Zeichen mehr vorhanden sind. Alle Punkte, Bindestriche oder Unterstriche können als leer betrachtet werden. Außerdem kann ein String, der keine aussagekräftigen signifikanten Zeichen enthält, eine Zeichenfolge sein, die der Leser nicht versteht. Dies können Zeichen in einer Sprache oder in einem Zeichensatz sein, die für den Leser als bedeutungslos definiert sind. Wir könnten es etwas anders definieren, wenn wir sagen, dass die Zeichenfolge in einer bestimmten Sprache keine bekannten Wörter bildet.
Wir könnten sagen, dass leer eine Funktion des Prozentsatzes des negativen Raums in den gerenderten Glyphen ist.
Auch eine Folge nicht druckbarer Zeichen ohne allgemeine visuelle Darstellung ist nicht wirklich leer. Steuerzeichen fallen mir ein. Besonders der niedrige ASCII Bereich (ich bin überrascht, dass niemand diese erwähnt hat, da sie viele Systeme überfluten und keine Leerzeichen sind, da sie normalerweise keine Glyphen und keine visuellen Metriken enthalten). Die Stringlänge ist jedoch nicht Null.
Fazit. Länge allein ist hier nicht das einzige Maß. Die kontextbezogene Set-Mitgliedschaft ist ebenfalls sehr wichtig.
Die Mitgliedschaft im Zeichensatz ist eine sehr wichtige zusätzliche Maßnahme. Sinnvolle Sequenzen sind auch ziemlich häufig. (Denken Sie an SETI oder Crypto oder Captchas.) Weitere abstraktere Kontextmengen sind ebenfalls vorhanden.
Überlegen Sie also sorgfältig, bevor Sie davon ausgehen, dass eine Zeichenfolge nur aufgrund der Länge oder des Leerzeichens leer ist.
Der beste Weg ist, die Kategorie zu verwenden.
Sie können die folgende Funktion überprüfen. Welches hat alle Bedingungen zu überprüfen.
-(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;
}
Sie können auf einfache Weise überprüfen, ob die Zeichenfolge leer ist:
if ([yourstring isEqualToString:@""]) {
// execute your action here if string is empty
}
Es ist so einfach wie if([myString isEqual:@""]) oder if([myString isEqualToString:@""])
if (string.length == 0) stringIsEmpty;
Ich habe eine leere Zeichenfolge mit folgendem Code überprüft:
//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"];
}
überprüfen Sie dies :
if ([yourString isEqualToString:@""])
{
NsLog(@"Blank String");
}
Oder
if ([yourString length] == 0)
{
NsLog(@"Blank String");
}
Hoffe das wird helfen.
In jedem Fall ist es am besten, die Länge der angegebenen Zeichenfolge zu überprüfen. Wenn Ihre Zeichenfolge myString ist, lautet der Code folgendermaßen:
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");
}
Versuche Folgendes
NSString *stringToCheck = @"";
if ([stringToCheck isEqualToString:@""])
{
NSLog(@"String Empty");
}
else
{
NSLog(@"String Not Empty");
}
Sie können eine leere Zeichenfolge auf zwei Arten haben:
1) @ "" // Enthält kein Leerzeichen
2) @ "" // Leerzeichen enthalten
Technisch sind beide Zeichenfolgen leer. Wir können beide Dinge einfach mit ONE Condition schreiben
if ([firstNameTF.text stringByReplacingOccurrencesOfString:@" " withString:@""].length==0)
{
NSLog(@"Empty String");
}
else
{
NSLog(@"String contains some value");
}