text - div - title attribute anchor tag

¿Cómo puedo declarar que un campo de texto solo puede contener un número entero?

Question

En swift, estoy tratando de hacer un campo de texto que permita habilitar un botón, pero solo cuando el campo de texto contiene un número entero. ¿Cómo puedo hacer esto?

Answer 1

Primero tienes que heredar la clase UITextViewDelegate con tu propia clase

class ViewController: UIViewController, UITextViewDelegate {

2º añadir un IBOutlet

@IBOutlet weak var firstName: UITextField!

3º tienes que asegurarte de que este objeto está usando

override func viewDidLoad() {
        super.viewDidLoad()
   firstName.delegate = self
}


func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    if textField == firstName {
                let allowedCharacters = "1234567890"
                let allowedCharacterSet = CharacterSet(charactersIn: allowedCharacters)
                let typedCharacterSet = CharacterSet(charactersIn: string)
                let alphabet = allowedCharacterSet.isSuperset(of: typedCharacterSet)
              return alphabet



      }
  }

Answer 2

1. Convierta su controlador de vista en UITextFieldDelegate agregando UITextFieldDelegate a la declaración de clase.
2. Agregue IBOutlet s para su campo de texto y su botón.
3. En viewDidLoad establezca la propiedad isEnabled su botón en false y establezca self como el textField.delegate .
4. Implemente textField:shouldChangeCharactersInRange:replacementString: method. Este método se llamará cada vez que se edite el campo de texto. Allí, verifique si el campo de texto actual se convierte en un Int llamando a toInt() y habilite / deshabilite su botón como lo desee.

Aquí está el código:

class ViewController: UIViewController, UITextFieldDelegate {

    @IBOutlet weak var textField: UITextField!
    @IBOutlet weak var button: UIButton!

    override func viewDidLoad() {
        super.viewDidLoad()
        button.isEnabled = false
        textField.delegate = self
    }

    func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
        // Find out what the text field will be after adding the current edit
        let text = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string)

        if let intVal = text.toInt() {
            // Text field converted to an Int
            button.isEnabled = true
        } else {
            // Text field is not an Int
            button.isEnabled = false
        }

        // Return true so the text field will be changed
        return true
    }
}

EDITAR: En Swift 3 la propiedad enabled se cambia a isEnabled .

Answer 3

Cada campo de texto tiene un tipo de keyboardType . Puede configurar esto en UIKeyboardType.NumbersAndPunctuation para que solo muestre números y aún tenga la clave de retorno presente (IU defensiva). Luego puede usar el scanInt() para verificar si textField.text es un número entero válido.

Answer 4

Dos cosas:

1. Especifique el tipo de teclado para mostrar solo el teclado numérico. Por lo tanto, establezca el tipo de keyboardType en .numberPad . Sin embargo, esto no es suficiente para evitar que el usuario ingrese caracteres no válidos en el campo de texto. Por ejemplo, el usuario todavía puede pegar texto o cambiar teclados cuando usa un iPad.

2. Especifique el delegado del campo de texto e implemente shouldChangeCharactersInRange que no acepte ningún otro carácter que no sean los dígitos del 0 9 :

   class ViewController: UIViewController, UITextFieldDelegate {
   
       @IBOutlet weak var textField: UITextField!
   
       override func viewDidLoad() {
           super.viewDidLoad()
   
           // you can set the following two properties for the text field in Interface Builder, if you''d prefer
   
           textField.delegate = self
           textField.keyboardType = .numberPad
       }
   
       func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
           let invalidCharacters = CharacterSet(charactersIn: "0123456789").inverted
           return string.rangeOfCharacter(from: invalidCharacters) == nil
       }
   
       // or, alternatively:
       //
       // func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
       //     return string.range(of: "^//d*$", options: .regularExpression) != nil
       // }
   
   }

Para la interpretación de Swift 2, vea la revisión anterior de esta respuesta.

Answer 5

En cuanto a aceptar retroceso y otros caracteres de control, he usado el siguiente método:

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
    if string.isEmpty { // This is for accept control characters
        return true
    }
    let numericRegEx = "[0-9]"
    let predicate = NSPredicate(format:"SELF MATCHES %@", numericRegEx)

    let newText = (textFieldCount.text as! NSString).replacingCharacters(in: range, with: string)

    return predicate.evaluate(with: string)
}

Si desea que también acepte puntos flotantes, simplemente cambie RegEx a

let numericRegEx = "[.0-9]"

Si limita el tamaño del texto a 10, cambie la última fila de la siguiente manera:

return predicate.evaluate(with: string) && newText.count < 10

Answer 6

Puede usar NSScanner para hacer eso aquí, ya que puede ser útil intentar usar esto y avisarme si hay algún problema.

if( [[NSScanner scannerWithString:@"-123.4e5"] scanFloat:NULL] )
    NSLog( @"/"-123.4e5/" is numeric" );
else
    NSLog( @"/"-123.4e5/" is not numeric" );

if( [[NSScanner scannerWithString:@"Not a number"] scanFloat:NULL] )
    NSLog( @"/"Not a number/" is numeric" );
else
    NSLog( @"/"Not a number/" is not numeric" );

vaya a través del enlace http://rosettacode.org/wiki/Determine_if_a_string_is_numeric#Objective-C . Inténtalo de inmediato, los nombres de clase y método son los mismos.

Answer 7

Aquí hay un método reutilizable para Cocoa, Swift 4.1

1- Crea un archivo con la clase NSTextFieldFormated abajo

2- En el '' inspector de identidad '', cambie la '' clase CustomClass '' del campo a formatear a NSTextFieldFormated

3- En el '' inspector de atributos '' defina el '' valor mínimo int '', '' int valor máximo int '' y '' int longitud '' del campo a formatear

4- Arrastre y suelte un ''Objeto'' (NSObject) desde la '' Biblioteca de objetos '' a '' Ver escena del controlador '' en la lista de objetos del generador de interfaz de esquema (a la izquierda del área de dibujo de la interfaz)

5- En el '' inspector de identidad '' establezca la '' clase CustomClass '' en NSTextFieldFormated

6- Seleccione el campo a formatear y, en el inspector de conexiones, configure el delegado de campo al nuevo objeto '' Formato de campo de texto '' en '' Ver escena del controlador ''.

Entonces el NSTextField ahora está formateado .

class NSTextFieldFormated: NSTextField, NSControlTextEditingDelegate {

    private struct Digit {
        var minValue: Int?      // minimum
        var maxValue: Int?      // maximum
        var digitAmt: Int?      // minimumIntegerDigits
    }
    private var digit = Digit()

    //-Integer
    @IBInspectable var intMinValue: Int {
        get {
            guard let minVal = digit.minValue else { return Int.min }
            return minVal
        }
        set { digit.minValue = newValue ; setFormatter() }
    }
    @IBInspectable var intMaxValue: Int {
        get {
            guard let maxVal = digit.maxValue else { return Int.max }
            return maxVal
        }
        set { digit.maxValue = newValue ; setFormatter() }
    }
    @IBInspectable var intLenght: Int {
        get {
            guard let length = digit.digitAmt else { return -1 }
            return length
        }
        set { digit.digitAmt = newValue ; setFormatter() }
    }

    private func setFormatter() {
        let lformatter = IntegerFormatter()
        lformatter.minimum = intMinValue as NSNumber
        lformatter.maximum = intMaxValue as NSNumber
        if intLenght != -1 {
            lformatter.minimumIntegerDigits = intLenght
        }
        self.formatter = lformatter
    }

    class IntegerFormatter: NumberFormatter {
        override func isPartialStringValid(_ partialString: String, 
            newEditingString newString: AutoreleasingUnsafeMutablePointer<NSString?>?, 
            errorDescription error: AutoreleasingUnsafeMutablePointer<NSString?>?) -> Bool {

            if partialString.rangeOfCharacter(from: CharacterSet.decimalDigits.inverted) != nil {
                NSSound.beep()
                return false
            }

            return Int(partialString) != nil
        }
    }

    override func controlTextDidChange(_ notification: Notification) {
        if let textField = notification.object as? NSTextFieldFormated {
            if let val = Int(textField.stringValue) {
                //print(">4")
                if val > textField.intMaxValue {
                    textField.stringValue = String(textField.intMaxValue)
                }
            }
        }
    }
}

Answer 8

Swift 4: ¿Qué tal un guard simple y typecasting to Int como se muestra a continuación?

func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {

        guard let _ = Int(string) else {
            button.isEnabled = false
            return true
        }
            button.isEnabled = true
            return true
}