CODEWITHSUNDEEP
operator-keywordswift4
MikeJB24
MikeJB24

Reputation: 143

Binary operator '<' cannot be applied to two 'Int?' operands

Good evening lovely community,
this is my first post, please have mercy, if I do something wrong.
I know there are some similar questions here, but I doesn't understand it.
Maybe I understand, if someone explain it on my code.

// these are my two TextFields and the "finish"-Button.

@IBOutlet weak var goalPlayerOne: UITextField!
@IBOutlet weak var goalPlayerTwo: UITextField!
@IBOutlet weak var finishedGameButton: UIButton!

// here are my function, it should tell me, which Player has won like A < B, so B has won.

 @IBAction func finishedGameButtonPressed(_ sender: Any) {
    // define UITextField as Integer

let goalPlayerOne = "";
let goalOne = Int(goalPlayerOne);

let goalPlayerTwo = "";
let goalTwo = Int(goalPlayerTwo);

// here is the problem:
"Binary operator '<' cannot be applied to two 'Int?' operands"
// if I make a '==' it works

if goalOne < goalTwo{    
    displayMyAlertMessage(userMessage: "Player Two wins")
    return
}

Upvotes: 14

Views: 27795

Answers (3)

Farrukh Makhmudov
Farrukh Makhmudov

Reputation: 472

Well, by using guard statement you can check if both values are not nil, and converting it to Int typ 

    guard let value_one = Int(goalPlayerOne), let value_two = Int(goalPlayerTwo) else {
        print("Some value is nil")
        return
    }

so you can safely compare two values.

    if value_one < value_two {
       //Do something
    }

Upvotes: 1

ScottyBlades
ScottyBlades

Reputation: 13993

This error can also occur if you are comparing a custom type (ie: struct or class) for which you haven't implemented the Comparable protocol.

Upvotes: 1

Charles Srstka
Charles Srstka

Reputation: 17050

If you look at the declaration for Int's initializer that takes a String, you can see by the ? after init that it returns an optional:

convenience init?(_ description: String)

This means you have to unwrap it before you can do most things with it (== is an exception, since the Optional type has an overload for that operator).

There are four main ways to unwrap your optionals:

1: If let

if let goalOne = Int(someString) {
    // do something with goalOne
}

2: Guard let

guard let goalOne = Int(someString) else {
    // either return or throw an error
}

// do something with goalOne

3: map and/or flatMap

let someValue = Int(someString).map { goalOne in
    // do something with goalOne and return a value
}

4: Provide a default value

let goalOne = Int(someString) ?? 0 // Or whatever the default value should be

If you unwrap all your optionals, you'll be able to compare them as you expect.

Upvotes: 33

Related Questions