Fatal编程技术网
  • objective-c/
  • Objective c iOS中UITextField中的密码验证

Objective c iOS中UITextField中的密码验证

objective-c validation ios5 passwords

Objective c iOS中UITextField中的密码验证,objective-c,validation,ios5,passwords,uitextfield,Objective C,Validation,Ios5,Passwords,Uitextfield,我的iPhone应用程序中有1个UITextfield作为密码 我想用下面的验证来验证这个文本字段 必须至少包含10个字符 必须至少包含一个小写字母、一个大写字母、一个数字和一个特殊字符 有效的特殊字符是–@$%^&+=^.*（？=.{10，}）（？=.*d）（？=.[a-z]）（？=.[a-z]）（？=.[@$%^&+]）。$ 如何使用上述要求限制UITextField？您需要使用UITextField - (BOOL)textField:(UITextField *)textField

我的iPhone应用程序中有1个
UITextfield
作为密码

我想用下面的验证来验证这个文本字段

  • 必须至少包含10个字符
  • 必须至少包含一个小写字母、一个大写字母、一个数字和一个特殊字符
  • 有效的特殊字符是–
    @$%^&+=^.*（？=.{10，}）（？=.*d）（？=.[a-z]）（？=.[a-z]）（？=.[@$%^&+]）。$
如何使用上述要求限制
UITextField
？

您需要使用
UITextField

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
您可能希望在实现时参考的几个链接

使用正则表达式（NSRegularExpression类有关于如何编写模式本身的文档），然后：

- (BOOL)textField:(UITextField *)theTextField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    //delete
    if (string.length == 0) {
        return YES;
    }

    if (self.regEx) {
        NSMutableString* check = [NSMutableString stringWithString:theTextField.text];
        [check replaceCharactersInRange:range withString:string];
        NSTextCheckingResult* match = [self.regEx firstMatchInString:check options:0 range:NSMakeRange(0, [check length])];
        if (match.range.length != check.length) {
            return NO;
        }
    }
}
警告：以这种方式限制输入确实会让用户感到困惑。你输入了又输入，你输入的字符就不会出现

我可能会在测试区域旁边加一个小红色（！），但我总是允许输入本身

使用
NSTextFieldDelegate
协议的
控件：isValidObject:
方法，该方法允许您验证NSTextField的值。假设您已正确配置了所有interface builder部件，您可以执行以下操作：

@interface PreferencesController : NSWindowController <NSTextFieldDelegate> {
    IBOutlet NSTextField *username, *password;
}

@end

@implementation PreferencesController

- (BOOL)control:(NSControl *)control isValidObject:(id)object
{
    if (control == password) {
      // Perform validation and return YES or NO
    }

    return YES;
}

@end

@接口首选项控制器：NSWindowController{
IBOutlet NSTextField*用户名，*密码；
}
@结束
@实现首选项控制器
-（BOOL）控件：（NSControl*）控件isValidObject:（id）对象
{
如果（控制==密码）{
//执行验证并返回是或否
}
返回YES；
}
@结束
我就是这样做的。验证应在用户输入密码后完成，而不是在两者之间。我不会使用
NSRegularExpression

-(void)textFieldDidEndEditing:(UITextField *)textField{
   int numberofCharacters = 0;
   BOOL lowerCaseLetter,upperCaseLetter,digit,specialCharacter = 0;
   if([textField.text length] >= 10)
   {
      for (int i = 0; i < [textfield.text length]; i++) 
      {
         unichar c = [textfield.text characterAtIndex:i];
         if(!lowerCaseLetter)
         {
           lowerCaseLetter = [[NSCharacterSet lowercaseLetterCharacterSet] characterIsMember:c];
         }
         if(!upperCaseLetter)
         {
           upperCaseLetter = [[NSCharacterSet uppercaseLetterCharacterSet] characterIsMember:c];
         }
         if(!digit)
         {
            digit = [[NSCharacterSet decimalDigitCharacterSet] characterIsMember:c];
         }
         if(!specialCharacter)
         {
            specialCharacter = [[NSCharacterSet symbolCharacterSet] characterIsMember:c];
         }
      }

      if(specialCharacter && digit && lowerCaseLetter && upperCaseLetter)
      {
         //do what u want
      }
      else
      { 
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                        message:@"Please Ensure that you have at least one lower case letter, one upper case letter, one digit and one special character"
                                                       delegate:nil cancelButtonTitle:@"OK" otherButtonTitles:nil];
        [alert show];
      }

   }
   else
   {
      UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                        message:@"Please Enter at least 10 password"
                                                       delegate:nil cancelButtonTitle:@"OK" otherButtonTitles:nil];
        [alert show];
   }
}

-（void）textfieldDendediting:（UITextField*）textField{
int numberofCharacters=0；
BOOL小写字母，大写字母，数字，特殊字符=0；
如果（[textField.text length]>=10）
{
对于（int i=0；i<[textfield.text length]；i++）
{
unichar c=[textfield.text characterAtIndex:i]；
如果（！小写字母）
{
lowerCaseLetter=[[NSCharacterSet lowercaseLetterCharacterSet]特征成员：c]；
}
if（！大写字母）
{
大写字母=[[NSCharacterSet uppercaseLetterCharacterSet]特征成员：c]；
}
如果（！位）
{
数字=[[NSCharacterSet decimalDigitCharacterSet]特征成员：c]；
}
如果（！specialCharacter）
{
specialCharacter=[[NSCharacterSet symbolCharacterSet]特征成员：c]；
}
}
if（特殊字符、数字、小写字母、大写字母）
{
//做你想做的
}
其他的
{ 
UIAlertView*警报=[[UIAlertView alloc]initWithTitle:@“错误”
信息：@“请确保您至少有一个小写字母、一个大写字母、一个数字和一个特殊字符”
代表：无取消按钮：@“确定”其他按钮：无]；
[警报显示]；
}
}
其他的
{
UIAlertView*警报=[[UIAlertView alloc]initWithTitle:@“错误”
信息：@“请输入至少10个密码”
代表：无取消按钮：@“确定”其他按钮：无]；
[警报显示]；
}
}
希望这有帮助…

您可以使用下面的函数验证密码验证，只需传递密码字符串，这将返回BOOL值

-(BOOL) isPasswordValid:(NSString *)pwd {

    NSCharacterSet *upperCaseChars = [NSCharacterSet characterSetWithCharactersInString:@"ABCDEFGHIJKLKMNOPQRSTUVWXYZ"];
    NSCharacterSet *lowerCaseChars = [NSCharacterSet characterSetWithCharactersInString:@"abcdefghijklmnopqrstuvwxyz"];

    //NSCharacterSet *numbers = [NSCharacterSet characterSetWithCharactersInString:@"0123456789"];

    if ( [pwd length]<6 || [pwd length]>20 )
        return NO;  // too long or too short
    NSRange rang;
    rang = [pwd rangeOfCharacterFromSet:[NSCharacterSet letterCharacterSet]];
    if ( !rang.length )
        return NO;  // no letter
    rang = [pwd rangeOfCharacterFromSet:[NSCharacterSet decimalDigitCharacterSet]];
    if ( !rang.length )
        return NO;  // no number;
    rang = [pwd rangeOfCharacterFromSet:upperCaseChars];
     if ( !rang.length )
         return NO;  // no uppercase letter;
    rang = [pwd rangeOfCharacterFromSet:lowerCaseChars];
    if ( !rang.length )
        return NO;  // no lowerCase Chars;
    return YES;
}

-（BOOL）isPasswordValid:（NSString*）pwd{
NSCharacterSet*大写字符=[NSCharacterSet characterSetWithCharactersInString:@“ABCDEFGHIJKLKMNOPQRSTUVWXYZ]”；
NSCharacterSet*小写字符=[NSCharacterSet characterSetWithCharactersInString:@“abcdefghijklmnopqrstuvwxyz]”；
//NSCharacterSet*数字=[NSCharacterSet characterSetWithCharactersInString:@“0123456789”]；
如果（[pwd长度]20）
返回否；//太长或太短
恩斯兰格·朗；
Range=[pwd rangeOfCharacterFromSet:[NSCharacterSet-letterCharacterSet]]；
如果（！rang.length）
返回否；//没有字母
Range=[pwd rangeOfCharacterFromSet:[NSCharacterSet decimalDigitCharacterSet]]；
如果（！rang.length）
返回NO；//没有数字；
Range=[pwd rangeOfCharacterFromSet:upperCaseChars]；
如果（！rang.length）
返回NO；//没有大写字母；
rang=[pwd rangeOfCharacterFromSet:lowerCaseChars]；
如果（！rang.length）
返回NO；//没有小写字符；
返回YES；
}
我有一个优雅的表单解决方案（如注册），在这里您需要进行大量验证

我的自定义UITextField中有插座：

@IBInspectable var regexpValidation: String? = nil
在故事板中，我可以通过属性检查器访问它，并将regexp字符串像这样放置（对于电子邮件）：

[a-z0-9！#$%和'*+/=？^-]+（？：[a-z0-9！#$%和'*+/=？^.[[a-z0-9]（？：[a-z0-9-]*[a-z0-9]（？：[a-z0-9-]*[a-z0-9]）+[a-z0-9]（？：[a-z0-9-]]-]+[a-z0-9]。]

然后在我的子类中，我有一个计算变量：

@IBInspectable var regexpValidation:字符串？=无//可选，在InterfaceBuilder中设置


var inputIsValid: Bool {
    get {
        if let expr = regexpValidation {
           return (text.rangeOfString(expr, options: NSStringCompareOptions.RegularExpressionSearch, range: nil, locale: nil) != nil)
        } else {
            return true
        }

    }
}


可以这样使用：


   override func resignFirstResponder() -> Bool {
        if (inputIsValid) {
            return super.resignFirstResponder()
        }
        else {
            text = ""
            return false
        }
    }



您也可以使用
Regex
来完成此操作。以下是我为您提供的几个示例：


// *** Validation for Password ***

    // "^(?=.*[A-Za-z])(?=.*\\d)[A-Za-z\\d]{8,}$" --> (Minimum 8 characters at least 1 Alphabet and 1 Number)
    // "^(?=.*[A-Za-z])(?=.*\\d)(?=.*[$@$!%*#?&])[A-Za-z\\d$@$!%*#?&]{8,16}$" --> (Minimum 8 and Maximum 16 characters at least 1 Alphabet, 1 Number and 1 Special Character)
    // "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[a-zA-Z\\d]{8,}$" --> (Minimum 8 characters at least 1 Uppercase Alphabet, 1 Lowercase Alphabet and 1 Number)
    // "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[$@$!%*?&])[A-Za-z\\d$@$!%*?&]{8,}" --> (Minimum 8 characters at least 1 Uppercase Alphabet, 1 Lowercase Alphabet, 1 Number and 1 Special Character)
    // "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[$@$!%*?&])[A-Za-z\\d$@$!%*?&]{8,10}" --> (Minimum 8 and Maximum 10 characters at least 1 Uppercase Alphabet, 1 Lowercase Alphabet, 1 Number and 1 Special Character)


列表中的第四个是您的案例，下面的代码片段演示了如何使用它：

使用以下方法：


对我来说，最好的方法是使用
NSPredicate
和regex。
这是适用于您案例的正则表达式：
^（？=.{10，}）（？=.[0-9]）（？=.[a-zA-Z]）（[@#$%^&=a-zA-Z0-9.-]+）$



目标C代码：


NSString *regex = @"^(?=.{10,})(?=.*[0-9])(?=.*[a-zA-Z])([@#$%^&=a-zA-Z0-9_-]+)$";

NSPredicate *passwordTest = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", regex];

BOOL isValid = [passwordTest evaluateWithObject:yourTextfield.text];



条件：密码应包含atle

if(![self isValidPassword:txtPassword.text]) {
    /* Show alert: "Password must be minimum 10 characters,
       at least 1 Uppercase Alphabet, 1 Lowercase Alphabet, 
       1 Number and 1 Special Character" */
}
else {
    // Password is valid
}



NSString *regex = @"^(?=.{10,})(?=.*[0-9])(?=.*[a-zA-Z])([@#$%^&=a-zA-Z0-9_-]+)$";

NSPredicate *passwordTest = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", regex];

BOOL isValid = [passwordTest evaluateWithObject:yourTextfield.text];



extension String {
    func isValidPassword() -> Bool {
        let regularExpression = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[$@$!%*?&])[A-Za-z\\d$@$!%*?&]{8,}"
        let passwordValidation = NSPredicate.init(format: "SELF MATCHES %@", regularExpression)

        return passwordValidation.evaluate(with: self)
    }
}

//Example 1

var password = "@Abcdef011" //string from UITextField (Password)
password.isValidPassword() // -> true

//Example 2

var password = "Abcdef011" //string from UITextField 
password.isValidPassword() // -> false



func validate(password: String) -> Bool
{
    let regularExpression = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[$@$!%*?&])[A-Za-z\\d$@$!%*?&]{8,}"

    let passwordValidation = NSPredicate.init(format: "SELF MATCHES %@", regularExpression)

    return passwordValidation.evaluate(with: password)
}



 func isValidated(_ password: String) -> Bool {
     var lowerCaseLetter: Bool = false
     var upperCaseLetter: Bool = false
     var digit: Bool = false
     var specialCharacter: Bool = false

     if password.characters.count  >= 8 {
         for char in password.unicodeScalars {
             if !lowerCaseLetter {
                 lowerCaseLetter = CharacterSet.lowercaseLetters.contains(char)
             }
             if !upperCaseLetter {
                 upperCaseLetter = CharacterSet.uppercaseLetters.contains(char)
             }
             if !digit {
                 digit = CharacterSet.decimalDigits.contains(char)
             }
             if !specialCharacter {
                 specialCharacter = CharacterSet.punctuationCharacters.contains(char)
             }
         }
         if specialCharacter || (digit && lowerCaseLetter && upperCaseLetter) {
             //do what u want
             return true
         }
         else {
             return false
         }
     }
     return false
 }
 let isVaildPass:Bool = isValidated("Test**00+-")
 print(isVaildPass)



 func validatePassword(password: String) -> (Bool, String) {
  //Minimum 8 characters at least 1 Alphabet and 1 Number:
var tuple: (Bool, String) = (true, "")
var string = "Requires atleast"

if(password.rangeOfCharacter(from: CharacterSet.letters) == nil){
    string = "uppercase"
    tuple = (false, string)

}
if(password.rangeOfCharacter(from: CharacterSet.decimalDigits) == nil){
    string += ", number"
       tuple = (false, string)

   }
if(password.count < 8 ){
    string += ", 8 chars"
       tuple = (false, string)

   }
return tuple }


 func isPasswordValid(in string: String) -> Observable<(Bool, String)> {
    return Observable.create { observer -> Disposable in

        let tuple = self.validation.validatePasswordForSymbol(password: string)

        observer.onNext(tuple)


        return Disposables.create()
    }
}



passwordTextField.rx.text
            .orEmpty //1
            .filter { $0.count >= 1 } //2
            .flatMap { self.isPasswordValid(in: $0) }
            .subscribe(onNext: { result in
                print("Valid password", result)
                //update UI here 
                // result will be like (false, "Requires atleast, 8 chars, number")
            }).disposed(by: disposeBag)