error: binary operator '==' cannot be applied to two 'Produs' operands
Compari cu == două valori dintr-un tip propriu care nu declară Equatable. Adaugă : Equatable la struct (Swift generează singur == dacă toate proprietățile sunt comparabile) sau scrie tu funcția ==.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Operatorul == nu există automat pentru tipurile tale. El vine din protocolul Equatable, iar mesajul binary operator '==' cannot be applied to two 'Produs' operands spune că pentru tipul Produs nu există niciun ==. În alte contexte (de exemplu direct într-un print(a == b)) compilatorul formulează același lucru mai explicit: referencing operator function '==' on 'Equatable' requires that 'Produs' conform to 'Equatable'.
La struct și enum reparația e de obicei un singur cuvânt: struct Produs: Equatable. Swift generează singur ==, care compară toate proprietățile, cu condiția ca fiecare proprietate să fie la rândul ei Equatable (Int, String, Double, tablouri de astfel de valori etc.).
Aceeași cerință apare indirect la metode care compară elemente: lista.contains(p), lista.firstIndex(of: p). La ele mesajul e puțin diferit, de exemplu requires that 'Produs' conform to 'Equatable'. Pentru Set și chei de Dictionary ai nevoie de Hashable, iar pentru sorted() și < de Comparable.
De ce apare: cauzele frecvente
1== pe o structură fără Equatable
struct Punct { let x: Int; let y: Int }
let a = Punct(x: 1, y: 2)
let b = Punct(x: 1, y: 2)
if a == b { print("același punct") }struct Punct: Equatable { let x: Int; let y: Int }
let a = Punct(x: 1, y: 2)
let b = Punct(x: 1, y: 2)
if a == b { print("același punct") }Cu : Equatable, Swift generează == care compară x și y.
2!= are aceeași cerință
struct Produs { let cod: String }
let a = Produs(cod: "A1")
let b = Produs(cod: "B2")
if a != b { print("produse diferite") }struct Produs: Equatable { let cod: String }
let a = Produs(cod: "A1")
let b = Produs(cod: "B2")
if a != b { print("produse diferite") }!= vine tot din Equatable, deci mesajul e binary operator '!=' cannot be applied to two 'Produs' operands. Metode ca contains(_:) și firstIndex(of:) cer și ele Equatable; fără protocol, folosește contains { $0.cod == "A1" }.
3Egalitate doar după un câmp
struct Client { let id: Int; let nume: String }
let c1 = Client(id: 1, nume: "Ana")
let c2 = Client(id: 1, nume: "Ana P.")
if c1 == c2 { print("același client") }struct Client: Equatable {
let id: Int
let nume: String
static func == (a: Client, b: Client) -> Bool { a.id == b.id }
}
let c1 = Client(id: 1, nume: "Ana")
let c2 = Client(id: 1, nume: "Ana P.")
if c1 == c2 { print("același client") }Dacă vrei altă regulă decât „toate proprietățile egale”, scrii tu static func ==.
Repară eroarea, direct în pagină
Programul verifică dacă un produs se află deja în coș și trebuie să afișeze Caietul e deja în coș, dar compilarea se oprește cu binary operator '==' cannot be applied to two 'Produs' operands. Repară declarația structurii, fără să schimbi comparația.
struct Produs {
let cod: String
let nume: String
}
let inCos = Produs(cod: "C12", nume: "Caiet")
let ales = Produs(cod: "C12", nume: "Caiet")
if inCos == ales {
print("Caietul e deja în coș")
} else {
print("Produs nou")
}Caietul e deja în coș
Indiciu
Adaugă protocolul Equatable în declarația structurii.
Reparația
struct Produs: Equatable {
let cod: String
let nume: String
}
let inCos = Produs(cod: "C12", nume: "Caiet")
let ales = Produs(cod: "C12", nume: "Caiet")
if inCos == ales {
print("Caietul e deja în coș")
} else {
print("Produs nou")
}De ce merge
Swift nu știe singur cum să compare două valori Produs: == vine din protocolul Equatable. Pentru o structură ale cărei proprietăți sunt toate Equatable (aici două String), e suficient să scrii : Equatable, iar compilatorul generează ==, care compară cod și nume. Cele două produse au aceleași valori, deci comparația e adevărată.
Alte forme ale mesajului
error: referencing operator function '==' on 'Equatable' requires that 'Produs' conform to 'Equatable'error: binary operator '!=' cannot be applied to two 'Produs' operandserror: referencing instance method 'contains' on 'Sequence' requires that 'Produs' conform to 'Equatable'
Cum o eviți pe viitor
- Adaugă
Equatable(șiHashable, dacă le pui înSetsau ca chei) când declari structurile de date. - Pentru căutări după un câmp, folosește variantele cu closure:
contains { $0.cod == cod },firstIndex { ... }. - Scrie
==manual doar când regula de egalitate e alta decât „toate câmpurile egale”. - La clase,
==nu se generează automat: îl scrii tu, sau compari identitatea cu===.
Întrebări frecvente
Ce diferență e între == și === ?
== compară valorile (prin Equatable). === verifică dacă două referințe indică exact același obiect și merge doar pentru clase.
De ce merge == pe String și Int fără să fac nimic?
Pentru că biblioteca standard le declară deja Equatable. Tipurile tale trebuie să o declare explicit.
Erori înrudite
error: type 'Cerc' does not conform to protocol 'Forma' Tipul declară că respectă un protocol (struct Cerc: Forma), dar îi lipsește o metodă sau o proprietate cerută ori are semnătura diferită. Adaugă membrii ceruți exact cum sunt declarați în protocol; nota de sub eroare îți arată ce lipsește. error: binary operator '*' cannot be applied to operands of type 'Double' and 'Int' Faci un calcul (* / + -) între două tipuri diferite, de obicei Double și Int. Swift nu le amestecă singur: convertește unul dintre operanzi, de exemplu pret * Double(cantitate). error: value of type 'String' has no member 'length' Apelezi o proprietate sau o metodă care nu există pe acel tip (aici length pe String). Folosește numele din Swift (count, uppercased(), append) sau verifică dacă variabila are tipul pe care îl crezi. Învață Swift de la zero, cu exerciții la fiecare lecție
Curs Swift (iOS): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
