...
Pregătire interviuri

100 de întrebări de interviu Swift, cu răspunsuri

Întrebările despre Swift care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Swift (iOS): primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 140 minde citit
Întrebări de interviu Swift cu răspunsuri

La un interviu în care se verifică Swift, întrebările merg de obicei pe trei niveluri: teorie despre limbaj (opționale, tipuri valoare și referință, protocoale, ARC), fragmente de cod la care trebuie să spui ce afișează sau unde e bug-ul, și o problemă scrisă live sau ca temă acasă, în care se vede cum folosești colecțiile, closures, erorile și async/await. Pentru rolurile iOS, aceste întrebări vin înaintea celor despre SwiftUI și UIKit, pentru că arată dacă stăpânești limbajul în sine.

La nivel junior se așteaptă să explici corect conceptele de bază și să scrii cod mic, fără force unwrap peste tot și fără cicluri de referințe. La nivel mid se intră în detalii: semantica copierii, dispatch, generice cu constrângeri, some vs any, izolarea actorilor, Sendable și migrarea la Swift 6. Diferența se vede mai ales în motivarea alegerilor, nu doar în sintaxă.

Folosește pagina așa: citește întâi răspunsul scurt și încearcă să formulezi singur răspunsul complet, apoi compară cu explicația detaliată. Rulează fragmentele de cod (în Xcode, într-un playground sau cu swift din terminal) și modifică-le până înțelegi de ce se comportă așa. Întrebările despre SwiftUI, UIKit și arhitectura aplicațiilor sunt pe pagina de meserie iOS Developer.

Fundamente: tipuri, operatori, String și control

1 Junior

Ce afișează codul următor și de ce?

SWIFT
print(7 / 2, 7 % 2, -7 % 2, -7 / 2, 7.0 / 2)

Răspuns scurt: Afișează 3 1 -1 -3 3.5. Împărțirea întregilor trunchiază spre zero, iar restul cu % ia semnul deîmpărțitului.

Când ambii operanzi sunt Int, operatorul / face împărțire întreagă și aruncă partea zecimală, trunchiind spre zero. De aceea 7 / 2 este 3, iar -7 / 2 este -3, nu -4 cum ar da o rotunjire în jos (floor). Literalul 7.0 este Double, deci 7.0 / 2 este 3.5: literalul 2 se adaptează automat la Double.

Operatorul % în Swift este restul împărțirii, nu modulo-ul matematic. Rezultatul păstrează semnul operandului din stânga, deci -7 % 2 dă -1. Asta contează când verifici paritatea: n % 2 == 1 ratează numerele negative impare, pe când n % 2 != 0 funcționează pentru toate. Pentru un modulo mereu pozitiv scrii ((n % m) + m) % m.

Pentru Double, % nu există. Folosești metoda dedicată:

SWIFT
let r = 7.5.truncatingRemainder(dividingBy: 2)   // 1.5
let isOdd = { (n: Int) in n % 2 != 0 }
print(isOdd(-7))                                 // true

Împărțirea unui Int la zero oprește programul la rulare, iar dacă împărțitorul este o constantă zero cunoscută la compilare, codul nici nu compilează. La Double, împărțirea la zero dă inf sau nan, fără crash.

Ce urmărește intervievatorul: Verifică dacă știi regulile aritmetice ale tipurilor întregi. Greșeala tipică este să crezi că -7 % 2 dă 1 și să scrii verificări de paritate greșite.

Eroarea, în practică:binary operator cannot be applied to operands

2 Junior

Ce se întâmplă în Swift la Int.max + 1 și de ce limbajul nu are operatorul ++?

Răspuns scurt: Depășirea unui Int oprește programul la rulare (sau dă eroare de compilare dacă valorile sunt constante). Operatorii ++ și -- au fost eliminați în Swift 3, iar în locul lor se scrie x += 1.

Swift tratează overflow-ul aritmetic ca pe o eroare, nu ca pe o valoare care „se învârte”. Dacă scrii let x = Int.max + 1 cu literali, compilatorul refuză codul („arithmetic operation overflows”). Dacă valoarea vine la rulare, programul se oprește cu o eroare de tip trap. Alegerea este intenționată: o depășire tăcută produce bug-uri greu de găsit, de exemplu un sold sau un contor care devine negativ.

Când chiar vrei aritmetică modulară (hash-uri, generatoare de numere, protocoale binare), folosești operatorii cu &:

SWIFT
let a = Int.max &+ 1        // Int.min, fără crash
let (sum, overflow) = Int.max.addingReportingOverflow(1)
print(overflow)             // true
let b = UInt8(250) &+ 10    // 4

addingReportingOverflow îți dă și rezultatul, și un indicator, util când vrei să tratezi situația explicit.

Operatorii ++ și -- au fost scoși în Swift 3 (propunerea SE-0004). Motivele: diferența dintre prefix și postfix (i++ vs ++i) era o sursă de confuzii, iar în cod Swift idiomatic aproape nu sunt necesari, pentru că buclele se scriu cu for i in 0..<n sau cu funcții precum map. Rămân += și -=, care nu returnează nimic, deci nu pot fi folosite în mijlocul unei expresii.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi că Swift e un limbaj sigur la overflow. Mulți candidați vin din C sau Java și presupun că valoarea se învârte în tăcere.

Eroarea, în practică:cannot find operator '++' in scopearithmetic operation results in an overflow

3 Junior

De ce nu compilează let total = count * price dacă count este Int și price este Double? Ce dau Int(3.9), Int(-3.9) și Int("12.5")?

Răspuns scurt: Swift nu face conversii implicite între tipuri numerice, deci trebuie să scrii Double(count) * price. Int(3.9) dă 3, Int(-3.9) dă -3, iar Int("12.5") dă nil.

În Swift, operatorii aritmetici cer ca ambii operanzi să aibă același tip. Nu există promovare automată de la Int la Double, ca în C sau Java, tocmai ca să nu pierzi precizie fără să observi. Conversia se face explicit, printr-un inițializator:

SWIFT
let count = 3
let price = 2.5
let total = Double(count) * price      // 7.5
let rounded = Int(total.rounded())     // 8

O sursă de confuzie: 3 * 2.5 compilează. Literalii nu au încă un tip fix, așa că 3 devine direct Double. Problema apare doar când valorile sunt deja în variabile cu tipuri diferite.

Conversia de la Double la Int cu Int(x) trunchiază spre zero: Int(3.9) este 3, Int(-3.9) este -3. Dacă vrei rotunjire, apelezi întâi rounded(), eventual cu o regulă (.down, .up, .toNearestOrEven). Atenție: Int(Double.nan) sau o valoare prea mare oprește programul. Pentru date nesigure folosești Int(exactly:), care întoarce opțional.

Conversia din text este întotdeauna opțională, pentru că textul poate să nu fie un număr: Int("12") dă Optional(12), iar Int("12.5"), Int(" 12") sau Int("") dau nil. De aceea rezultatul se despachetează cu if let sau ?? înainte de folosire.

Ce urmărește intervievatorul: Se verifică înțelegerea sistemului de tipuri strict. Greșeala frecventă este presupunerea că Int(3.9) rotunjește la 4 sau că Int("12.5") dă 12.

Eroarea, în practică:cannot convert value to specified typecannot convert value to expected argument type

4 Junior

Prin ce diferă switch din Swift de cel din C sau Java? Ce înseamnă că trebuie să fie exhaustiv și ce face fallthrough?

Răspuns scurt: În Swift, switch trebuie să acopere toate valorile posibile, nu trece automat la cazul următor și poate potrivi intervale, tupluri și tipare. fallthrough trece explicit în corpul cazului următor, fără să-i verifice condiția.

Trei diferențe apar des la interviu.

  • Exhaustivitate: compilatorul cere ca fiecare valoare posibilă să fie tratată. Pentru un enum enumeri toate cazurile; pentru Int sau String ai nevoie de default.
  • Fără trecere implicită: după ce un caz se execută, switch se termină. Nu mai scrii break la fiecare caz. În schimb, un caz nu poate avea corp gol: dacă nu vrei să faci nimic, scrii break.
  • Tipare bogate: un caz poate lista mai multe valori, intervale sau condiții.
SWIFT
let grade = 8
switch grade {
case 10:
    print("excelent")
case 8, 9:
    print("foarte bine")
    fallthrough
case 5..<8:
    print("promovat")
default:
    print("restanță")
}
// foarte bine
// promovat

Aici fallthrough intră în corpul cazului 5..<8 chiar dacă 8 nu este în interval. Asta este capcana: fallthrough nu reevaluează condiția următoare, doar continuă execuția. Nu poate fi folosit nici dacă următorul caz leagă variabile cu let.

switch funcționează și pe String, pe tupluri și pe enum-uri cu valori asociate, iar primul caz potrivit câștigă. De aceea ordinea contează: un caz general pus înaintea unuia specific îl face pe cel specific inaccesibil, iar compilatorul poate semnala că un caz nu va fi atins niciodată.

Ce urmărește intervievatorul: Verifică dacă știi regulile specifice Swift. Candidații greșesc des comportamentul lui fallthrough, crezând că testează condiția cazului următor.

Eroarea, în practică:switch must be exhaustive'case' label must have an executable statement

5 Junior

Ce afișează codul următor?

SWIFT
let point = (2, -2)
switch point {
case (0, 0):
    print("origine")
case (let x, 0):
    print("pe axa x la \(x)")
case let (x, y) where x == y:
    print("pe diagonala x = y")
case let (x, y) where x == -y:
    print("pe diagonala x = -y")
default:
    print("altundeva")
}

Răspuns scurt: Afișează pe diagonala x = -y. Primele trei cazuri nu se potrivesc, iar al patrulea leagă x = 2, y = -2 și condiția where este adevărată.

Exemplul combină trei mecanisme de pattern matching: potrivirea pe tupluri, legarea valorilor cu let și gărzile where.

  • case (0, 0) cere ambele componente egale cu zero. Nu se potrivește.
  • case (let x, 0) acceptă orice prima componentă și o leagă la x, dar a doua trebuie să fie 0. Avem -2, deci nu.
  • case let (x, y) where x == y leagă ambele valori, apoi verifică garda. 2 == -2 este fals.
  • case let (x, y) where x == -y leagă la fel, iar 2 == -(-2) este adevărat, deci se execută.

let pus în fața tuplului leagă toate componentele, pe când (let x, 0) leagă doar una. Poți folosi și _ ca să ignori o componentă: case (_, 0) înseamnă „orice punct pe axa x”.

Același mecanism apare în if case și for case:

SWIFT
let points = [(0, 3), (2, 0), (5, 0)]
for case let (x, 0) in points {
    print("pe axa x: \(x)")   // 2, apoi 5
}
if case 1...9 = point.0 {
    print("x are o singură cifră")
}

Pentru că default există, switch este exhaustiv. Fără el, compilatorul ar cere un caz care acoperă toate tuplurile rămase, de exemplu case (_, _).

Ce urmărește intervievatorul: Testează citirea atentă a cazurilor în ordine și înțelegerea gărzilor where. Unii candidați cred că se execută toate cazurile adevărate sau confundă legarea parțială cu cea totală.

6 Junior

Care este diferența dintre 0..<n, 0...n și stride(from:to:by:)? Ce se întâmplă la for i in 5...1?

Răspuns scurt: 0..<n exclude capătul, 0...n îl include, iar stride permite pași diferiți de 1, inclusiv negativi. 5...1 oprește programul la rulare, pentru că un interval cere limita de jos mai mică sau egală cu cea de sus.

Swift are două tipuri principale de interval: half-open a..<b (de la a până la b exclusiv) și closed a...b (inclusiv b). Pentru indecșii unui tablou se folosește aproape mereu 0..<array.count sau, mai sigur, array.indices, ca să nu ieși din limite.

Un interval merge doar crescător, cu pas 1. Pentru alt pas sau pentru parcurgere inversă folosești stride:

SWIFT
for i in stride(from: 10, to: 0, by: -3) {
    print(i, terminator: " ")      // 10 7 4 1
}
print()
for i in stride(from: 0, through: 10, by: 5) {
    print(i, terminator: " ")      // 0 5 10
}
print()
for i in (1...3).reversed() {
    print(i, terminator: " ")      // 3 2 1
}

to: exclude capătul, through: îl include dacă pasul ajunge exact la el. stride merge și cu Double, de exemplu stride(from: 0.0, to: 1.0, by: 0.25).

Codul for i in 5...1 compilează, dar la rulare crapă cu „Range requires lowerBound <= upperBound”. Același lucru se întâmplă cu 0...n - 1 când n este 0, un bug clasic la tablouri goale. 0..<0 este în schimb un interval gol valid, iar bucla pur și simplu nu se execută. De aceea forma ..< este preferată pentru indecși.

Intervalele sunt și valori: poți scrie (18...65).contains(age) sau poți folosi intervale parțiale ca array[2...].

Ce urmărește intervievatorul: Se verifică dacă știi cum să eviți erorile de limită. Greșeala tipică este 0...count - 1, care crapă la colecții goale.

Eroarea, în practică:Range requires lowerBound <= upperBoundC-style for statement was removed in Swift 3

7 Junior

De ce nu compilează let c = name[0] pentru un String? Scrie o funcție care întoarce al n-lea caracter al unui text.

Răspuns scurt: String nu se indexează cu Int, pentru că un caracter poate ocupa un număr variabil de octeți. Folosești String.Index, obținut cu index(_:offsetBy:), sau convertești textul în Array.

În Swift, un Character este un grapheme cluster: ce percepe utilizatorul ca o literă, care poate fi format din unul sau mai mulți scalari Unicode și ocupă un număr variabil de octeți. Ca să găsești al n-lea caracter, trebuie să parcurgi textul de la început, deci operația este O(n). Swift refuză să ascundă acest cost în spatele unui name[0] care ar părea O(1), așa că cere un String.Index.

SWIFT
func character(at n: Int, in text: String) -> Character? {
    guard n >= 0, n < text.count else { return nil }
    let i = text.index(text.startIndex, offsetBy: n)
    return text[i]
}

print(character(at: 2, in: "Ștefan") ?? "-")   // e
print(character(at: 9, in: "Ștefan") ?? "-")   // -

Funcția întoarce opțional, ca să nu crape la indecși invalizi. Variante scurte: text.dropFirst(n).first sau text.first și text.last pentru capete.

Indecșii unui String sunt valabili doar pentru acel text. Dacă îi folosești pe alt String sau după o modificare, poți obține un crash.

Dacă ai nevoie de acces aleator repetat, de exemplu într-un algoritm cu doi indici, convertește o singură dată: let chars = Array(text). Atunci chars[i] este O(1). Este o optimizare frecventă la exercițiile de live coding cu palindromuri sau anagrame.

Subșirurile obținute prin indecși sunt Substring, care împart memoria cu textul original. Le convertești cu String(sub) când le păstrezi pe termen lung.

Ce urmărește intervievatorul: Verifică înțelegerea modelului Unicode din Swift și a costului operațiilor pe text. Candidații slabi spun doar „așa e sintaxa”, fără să explice de ce.

Eroarea, în practică:cannot subscript String with an Int

8 Junior

Ce afișează codul următor?

SWIFT
let a = "café"
let b = "cafe\u{301}"
print(a.count, b.count)
print(a.utf8.count, b.utf8.count)
print(a == b)

Răspuns scurt: Afișează 4 4, apoi 5 6, apoi true. Ambele texte au 4 caractere vizibile, dar sunt codificate diferit în UTF-8, iar Swift le compară după echivalența canonică Unicode.

a folosește caracterul precompus é (U+00E9). b folosește litera e urmată de accentul combinat U+0301. Vizual sunt identice.

  • count numără caractere (grapheme clusters). e plus accentul combinat formează un singur caracter, deci ambele texte au 4.
  • utf8.count numără octeții UTF-8. é precompus ocupă 2 octeți, deci a are 5. În b, e ocupă 1 octet și accentul 2, deci 6.
  • == pe String folosește echivalența canonică Unicode: două texte care reprezintă aceleași caractere sunt egale, chiar dacă scalarii diferă. Rezultatul este true.

Există mai multe vederi ale aceluiași text:

SWIFT
print(a.unicodeScalars.count, b.unicodeScalars.count)   // 4 5
print(Array(b.utf8).prefix(3))                          // [99, 97, 102]

Consecințe practice: count pe String este O(n), pentru că trebuie să parcurgă textul și să grupeze scalarii, deci nu îl apela într-o buclă pe un text lung. Limitele de lungime de la un API (de exemplu „maxim 255 de octeți”) trebuie verificate pe utf8.count, nu pe count. Iar diacriticele românești pot veni în ambele forme din surse diferite (copy-paste, macOS, Windows), dar compararea cu == le tratează corect. Atenție doar la Dictionary cu chei text sau la hash-uri calculate pe octeți: acolo forma contează dacă lucrezi direct cu utf8.

Ce urmărește intervievatorul: Arată dacă înțelegi că un caracter nu este un octet. Greșeala comună este să presupui că count dă numărul de octeți sau că cele două texte sunt diferite.

Eroarea, în practică:Can't form a Character from a longer String

9 Junior

Ce afișează fiecare linie?

SWIFT
let x = 5
print("x = \(x)")
print(#"x = \(x)"#)
print(#"x = \#(x)"#)

Când folosești raw strings și text pe mai multe linii?

Răspuns scurt: Afișează x = 5, apoi x = \(x) literal, apoi x = 5. Într-un raw string, \ nu mai este caracter de escape decât dacă e urmat de același număr de #.

Interpolarea \(expresie) inserează valoarea oricărei expresii în text. În prima linie obții x = 5.

Un raw string este delimitat de #" și "#. În interiorul lui, backslash-ul este un caracter obișnuit, așa că \(x) apare exact așa în rezultat. Ca să interpolezi totuși, scrii \#(x): backslash-ul urmat de același număr de # ca delimitatorul. De aceea a treia linie afișează din nou x = 5. Poți folosi și ##"..."## dacă textul conține "#.

Raw strings sunt utile când textul are multe backslash-uri: expresii regulate, căi Windows, JSON cu ghilimele.

SWIFT
let pattern = #"\d{3}-\d{4}"#          // fără \\d
let json = #"{"name": "Ana", "age": 30}"#

Textul pe mai multe linii se scrie între trei ghilimele, fiecare pe linia ei:

SWIFT
let message = """
    Salut, \(x)!
      Rândul acesta are două spații în plus.
    Linie lungă \
    continuată fără newline.
    """

Indentarea liniei cu ghilimelele de închidere este eliminată din toate liniile, deci poți alinia textul cu codul. Un \ la final de linie lipește linia următoare fără caracter de linie nouă. Ghilimelele simple din interior nu trebuie escapate.

Pentru tipurile tale poți controla ce apare la interpolare implementând CustomStringConvertible sau extinzând DefaultStringInterpolation, de exemplu pentru formatarea sumelor.

Ce urmărește intervievatorul: Verifică familiaritatea cu sintaxa de text din Swift. Mulți candidați nu știu de raw strings și scriu expresii regulate pline de \\.

Eroarea, în practică:invalid escape sequence in literal

10 Mid

Cum funcționează parametrii inout? De ce nu compilează codul următor?

SWIFT
func addInto(_ a: inout Int, _ b: inout Int) {
    a += b
}
var n = 1
addInto(&n, &n)

Răspuns scurt: Un parametru inout se copiază în funcție, iar la final valoarea modificată se scrie înapoi. Codul dă eroare de exclusivitate: aceeași variabilă nu poate fi accesată simultan prin două accesuri inout dintre care cel puțin unul modifică.

Semantica oficială a lui inout este copy-in copy-out: la apel, valoarea argumentului este copiată în parametru, funcția lucrează pe copie, iar la ieșire rezultatul este scris înapoi în variabila originală. Compilatorul optimizează de obicei prin transmiterea adresei, dar comportamentul observabil rămâne cel descris. La apel pui &, ca să fie clar că variabila poate fi modificată.

SWIFT
func clamp(_ value: inout Int, to range: ClosedRange<Int>) {
    value = min(max(value, range.lowerBound), range.upperBound)
}
var volume = 15
clamp(&volume, to: 0...10)
print(volume)   // 10

Poți transmite doar variabile var, nu constante sau literali. Dacă transmiți o proprietate cu didSet, observatorul rulează o singură dată, după ce funcția se termină, pentru că atunci se face scrierea înapoi.

Codul din întrebare încalcă regula de exclusivitate a accesului, introdusă în Swift 4 și impusă de Swift 5: pe durata unui acces de modificare la o variabilă, nu poate exista niciun alt acces suprapus la ea. addInto(&n, &n) deschide două accesuri inout la n în același timp, iar compilatorul raportează „overlapping accesses to 'n'”. Când conflictul nu se poate detecta la compilare (de exemplu prin closures sau proprietăți de clasă), Swift îl verifică la rulare în build-urile de debug.

Regula există pentru că, altfel, rezultatul ar depinde de ordinea scrierilor înapoi și ar permite optimizări nesigure. Soluția este o copie explicită: var tmp = n și apoi addInto(&n, &tmp).

Ce urmărește intervievatorul: Verifică dacă înțelegi că inout nu este o referință în sensul C++. Puțini candidați cunosc regula de exclusivitate, care apare și în erori reale cu swap pe același tablou.

Eroarea, în practică:inout parameter requires explicit '&'cannot pass immutable value as inout argument

11 Mid

Ce afișează codul și cum ieși din ambele bucle când găsești valoarea?

SWIFT
let grid = [[1, 2], [3, 4], [5, 6]]
for row in grid {
    for v in row {
        switch v {
        case 3: break
        default: print(v)
        }
    }
}

Răspuns scurt: Afișează 1 2 4 5 6, pe linii separate. break din switch iese doar din switch, nu din buclă. Ca să oprești ambele bucle, etichetezi bucla exterioară și scrii break outer.

Capcana este că break într-un switch din interiorul unei bucle se aplică celei mai apropiate instrucțiuni care îl acceptă, adică chiar switch-ului. Cazul 3 nu face nimic, iar bucla continuă cu 4, 5, 6. Mulți candidați se așteaptă ca break să oprească bucla, cum ar face într-un if.

Soluția sunt labeled statements: dai un nume buclei și îl folosești în break sau continue.

SWIFT
outer: for row in grid {
    for v in row {
        switch v {
        case 3:
            break outer
        default:
            print(v)
        }
    }
}
// 1
// 2

Etichetele funcționează și cu continue: continue outer sare direct la următorul rând, ignorând restul valorilor din rândul curent. Poți eticheta și while, repeat sau chiar if și do.

În multe cazuri, o soluție mai curată este să muți căutarea într-o funcție și să folosești return:

SWIFT
func position(of target: Int, in grid: [[Int]]) -> (row: Int, col: Int)? {
    for (r, row) in grid.enumerated() {
        if let c = row.firstIndex(of: target) { return (r, c) }
    }
    return nil
}

Funcția este mai ușor de testat, iar rezultatul opțional comunică clar situația în care valoarea nu există. Etichetele rămân utile în algoritmi cu mai multe niveluri de bucle, unde extragerea în funcții ar complica codul.

Ce urmărește intervievatorul: Verifică atenția la detalii în controlul fluxului. Greșeala tipică este să crezi că break din switch oprește bucla.

Eroarea, în practică:unlabeled 'break' only allowed in a loop or switch

Opționale

12 Junior

Ce tip are n și ce afișează codul?

SWIFT
struct Address { var city: String }
struct User { var address: Address? }

let user: User? = User(address: nil)
let n = user?.address?.city.count
print(n ?? 0)
print(user?.address == nil)

Răspuns scurt: n are tipul Int?, nu Int??, iar codul afișează 0 și true. Optional chaining se oprește la primul nil și rezultatul final este un singur nivel de opțional.

Optional chaining evaluează lanțul de la stânga la dreapta. user există, dar address este nil, așa că întreaga expresie se oprește acolo și dă nil. city.count nu se mai evaluează.

Regula de tip: dacă orice verigă din lanț folosește ?., rezultatul este opțional, dar nivelurile nu se adună. Chiar dacă avem două ?., n este Int?. count întoarce Int, iar lanțul îl face Int?. Dacă o proprietate din lanț este deja opțională, de exemplu var zip: String?, atunci user?.address?.zip este tot String?, nu String??.

n ?? 0 dă 0, iar user?.address == nil este true. Compararea cu nil funcționează pentru orice opțional.

Optional chaining merge și pentru apeluri de metode și atribuiri:

SWIFT
var maybeUser: User? = User(address: Address(city: "Iași"))
maybeUser?.address?.city = "Cluj"        // se execută doar dacă totul există
let changed: Void? = maybeUser?.address?.city.append("-Napoca")
print(changed != nil)                    // true: apelul a avut loc
print(maybeUser?.address?.city ?? "-")   // Cluj-Napoca

O metodă care întoarce Void, apelată prin chaining, devine Void?. Asta îți spune dacă apelul s-a executat sau lanțul s-a oprit.

Când afișezi direct un opțional cu print(n), compilatorul avertizează și vezi Optional(...) în consolă. De aceea în cod real despachetezi întâi sau dai o valoare implicită.

Ce urmărește intervievatorul: Testează înțelegerea tipului rezultat dintr-un lanț. Candidații cred adesea că două ?. produc un opțional dublu sau că expresia crapă la nil.

Eroarea, în practică:cannot use optional chaining on non-optional value

13 Junior

Ce înseamnă if let name { ... } (fără = name) și cum combini mai multe condiții de despachetare într-un singur if?

Răspuns scurt: Din Swift 5.7, if let name este prescurtarea pentru if let name = name: creează o constantă nenulă cu același nume. Mai multe legări și condiții se separă prin virgulă și sunt evaluate în ordine, toate trebuind să fie adevărate.

Înainte de Swift 5.7 scriai if let name = name, adică umbreai (shadowing) variabila opțională cu una neopțională cu același nume. Propunerea SE-0345 a introdus forma scurtă, care face același lucru și funcționează și cu guard și while:

SWIFT
func greet(name: String?, age: Int?) {
    if let name, let age, age >= 18 {
        print("Bun venit, \(name), ai \(age) ani")
    } else {
        print("Date incomplete sau minor")
    }
}

func load(id: String?) {
    guard let id, !id.isEmpty else { return }
    print("Încarc \(id)")
}

Condițiile separate prin virgulă se evaluează de la stânga la dreapta și se opresc la prima falsă. O legare poate folosi valori din legările anterioare, de exemplu if let text, let n = Int(text), n > 0.

Nu poți combina legări cu ||, pentru că în ramura adevărată nu s-ar ști care variabilă există. Pentru „oricare dintre ele”, folosești ??: if let value = primary ?? fallback.

Forma scurtă merge doar cu un identificator simplu. if let user.name nu compilează; acolo scrii if let name = user.name.

Diferența practică față de guard: variabila din if let există doar în blocul if, iar cea din guard let rămâne disponibilă până la sfârșitul funcției. Pentru validări la începutul funcției, guard păstrează codul principal neindentat; pentru o ramură scurtă, if let este mai natural. În closures, guard let self else { return } este folosit des după o captură [weak self].

Ce urmărește intervievatorul: Arată dacă scrii Swift modern și dacă știi regulile listelor de condiții. Unii candidați încearcă să combine legări cu || sau nu cunosc forma scurtă.

Eroarea, în practică:value of optional type must be unwrappedoptional must be unwrapped to refer to member

14 Junior

Scrie o funcție parseAge(_:) care primește un text și întoarce vârsta ca Int doar dacă textul este un număr între 0 și 130, altfel nil. Arată și cum o folosești.

Răspuns scurt: Folosești Int(text) pentru conversie și verifici intervalul cu guard, întorcând Int?. La apel despachetezi cu if let sau dai o valoare implicită cu ??.

O funcție care poate eșua fără să conteze motivul exact întoarce în mod natural un opțional. Int(_:) pentru String întoarce deja Int?, deci îl combini cu o verificare de interval:

SWIFT
func parseAge(_ text: String) -> Int? {
    guard let age = Int(text), (0...130).contains(age) else {
        return nil
    }
    return age
}

let inputs = ["34", "-2", "abc", "150", "0"]
for input in inputs {
    if let age = parseAge(input) {
        print("\(input): vârsta \(age)")
    } else {
        print("\(input): invalid")
    }
}

let ages = inputs.compactMap(parseAge)   // [34, 0]

De reținut:

  • guard cu virgulă combină despachetarea și condiția. Dacă oricare eșuează, ieși imediat cu nil.
  • (0...130).contains(age) este mai lizibil decât age >= 0 && age <= 130.
  • Funcția poate fi transmisă direct la compactMap, care păstrează doar valorile nenule.

Dacă interviul continuă cu „și dacă vreau să știu de ce e invalid?”, răspunsul este să treci la o funcție throws cu un enum de erori (notANumber, outOfRange), pentru că un opțional nu poartă informație despre cauză.

Atenție la spațiile din jurul numărului: Int(" 34") dă nil. Dacă datele vin dintr-un formular, curăță textul întâi, de exemplu cu text.filter { !$0.isWhitespace } sau cu trimmingCharacters(in: .whitespaces) din Foundation.

Ce urmărește intervievatorul: Este un mini-exercițiu de cod care arată dacă folosești natural opționalele și guard. Greșelile tipice sunt force unwrap pe Int(text)! și uitarea cazurilor de margine.

15 Junior

Ce este un implicitly unwrapped optional (String!) și când apare în cod real?

Răspuns scurt: Este un opțional care se despachetează automat acolo unde se cere un tip neopțional și crapă dacă e nil. Apare la proprietăți inițializate după init, de exemplu outlet-urile @IBOutlet, și la API-uri vechi din Objective-C.

Declarația var label: String! creează un implicitly unwrapped optional (IUO). Din Swift 4.2, IUO nu mai este un tip separat, ci un atribut al declarației: variabila are tipul String?, dar compilatorul o despachetează forțat implicit când o folosești într-un loc care cere String.

SWIFT
var title: String! = nil
title = "Raport"
let upper: String = title.uppercased()   // despachetare implicită
let copy = title                         // copy are tipul String?, nu String!
print(copy ?? "-")
title = nil
// let crash: String = title             // crapă la rulare

Observă că copy este inferat ca String?. Caracterul „implicit” nu se propagă prin inferență, ca să nu răspândească riscul.

Unde este acceptabil:

  • @IBOutlet weak var button: UIButton! în UIKit: outlet-ul e setat de sistem după inițializare, dar înainte să-l folosești.
  • Proprietăți care nu pot fi setate în init, dar sigur sunt setate înainte de folosire, de exemplu în metode setUp() din testele XCTest.
  • API-uri Objective-C neadnotate pentru nulabilitate, importate automat cu !.

În cod nou, IUO trebuie evitat. Alternativele mai sigure sunt: un inițializator care primește valoarea, o proprietate lazy, sau un opțional obișnuit cu despachetare explicită. Un crash de tipul „Unexpectedly found nil while implicitly unwrapping an Optional value” într-un raport de crash indică aproape sigur o astfel de proprietate folosită prea devreme sau după eliberare.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre IUO și force unwrap obișnuit. Candidații declară uneori proprietăți cu ! doar ca să scape de erorile de inițializare.

Eroarea, în practică:Unexpectedly found nil while unwrapping an Optional

16 Junior

Optional este un enum. Scrie un switch care tratează separat valoarea lipsă, valorile mai mari de 3 și restul, apoi arată cum parcurgi doar elementele nenule dintr-un [Int?].

Răspuns scurt: Optional<Wrapped> are cazurile .none și .some(Wrapped), deci poți folosi switch cu case nil, case let x? și gărzi where. Pentru tablouri folosești for case let x? in array.

În biblioteca standard, Optional este definit aproximativ așa:

SWIFT
enum Optional<Wrapped> {
    case none
    case some(Wrapped)
}

Int? este doar sintaxă pentru Optional<Int>, iar nil este .none. Pentru că este un enum, poți aplica tot pattern matching-ul:

SWIFT
func describe(_ value: Int?) {
    switch value {
    case nil:
        print("lipsă")
    case let x? where x > 3:
        print("mare: \(x)")
    case .some(let x):
        print("mic: \(x)")
    }
}
describe(nil)   // lipsă
describe(7)     // mare: 7
describe(2)     // mic: 2

case let x? este prescurtarea pentru case .some(let x). switch-ul este exhaustiv fără default, pentru că acoperă .none și toate valorile .some.

Același tipar merge în bucle și în if case:

SWIFT
let readings: [Int?] = [4, nil, 9, nil, 1]
for case let r? in readings {
    print(r)                  // 4, 9, 1
}
let valid = readings.compactMap { $0 }   // [4, 9, 1]
if case let first?? = readings.first {
    print("primul: \(first)") // primul: 4
}

Ultimul exemplu e interesant: readings.first este Int?? (tabloul poate fi gol, iar elementul poate fi nil), așa că ai nevoie de două ? în tipar.

Înțelegerea faptului că Optional e un enum explică de ce poți scrie extensii pe el (extension Optional where Wrapped == String) și de ce map și flatMap există și pentru opționale.

Ce urmărește intervievatorul: Se verifică dacă vezi opționalele ca pe un tip obișnuit, nu ca pe magie. Candidații buni folosesc for case let și știu de unde vin opționalele duble.

17 Junior

Ce afișează codul următor? Atenție la tabloul de opționale.

SWIFT
let values: [Int?] = [1, nil, 3]
print(values.max { ($0 ?? 0) < ($1 ?? 0) } as Any)
let a: Int? = 3
print(a == 3)
// print(a > 2)

De ce linia comentată nu compilează?

Răspuns scurt: Afișează Optional(Optional(3)) și true. Compararea cu == funcționează pentru opționale cu Wrapped: Equatable, dar < și > nu sunt definite pentru Optional, așa că a > 2 nu compilează.

max(by:) pe [Int?] întoarce un Int??: exteriorul spune dacă tabloul are elemente, interiorul este elementul însuși. Elementul maxim este Optional(3), iar as Any îl afișează cu ambele niveluri: Optional(Optional(3)). Comparatorul tratează nil ca 0.

Optional este Equatable când Wrapped este Equatable. La a == 3, literalul 3 este promovat la Int?, apoi se compară. Rezultatul este true. Merge și a == nil.

Operatorii de ordine (<, >, <=, >=) au existat pentru opționale în Swift 2, dar au fost eliminați în Swift 3 (SE-0121). Motivul: nu e clar dacă nil trebuie să fie mai mic sau mai mare decât orice valoare, iar comparații ca user.age > 18 cu age opțional produceau rezultate surprinzătoare în tăcere. Acum ești obligat să decizi explicit:

SWIFT
if let a, a > 2 { print("mai mare") }
print((a ?? 0) > 2)            // nil tratat ca 0
let sorted = values.sorted { ($0 ?? .min) < ($1 ?? .min) }
print(sorted)                  // [nil, Optional(1), Optional(3)]
let clean = values.compactMap { $0 }.sorted()   // [1, 3]

Varianta cu compactMap este de obicei cea dorită: elimini valorile lipsă și lucrezi cu un [Int] obișnuit. Dacă nil trebuie să apară la final, folosești .max în loc de .min ca valoare de înlocuire.

Ce urmărește intervievatorul: Testează înțelegerea opționalelor imbricate și a motivului pentru care Swift interzice compararea ordonată. Greșeala tipică este să crezi că rezultatul este 3 simplu.

18 Mid

Ce afișează codul următor și de ce?

SWIFT
func fallback() -> Int {
    print("calculez fallback")
    return 0
}
let cached: Int? = 5
let value = cached ?? fallback()
print(value)
print(cached ?? 0 + 10)

Răspuns scurt: Afișează 5 și apoi tot 5. fallback() nu se apelează, pentru că partea dreaptă a lui ?? este un @autoclosure evaluat doar la nevoie, iar cached ?? 0 + 10 înseamnă cached ?? (0 + 10).

Semnătura operatorului din biblioteca standard este, simplificat:

SWIFT
func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T

@autoclosure transformă expresia din dreapta într-un closure care se execută doar dacă opționalul este nil. Deoarece cached are valoarea 5, fallback() nu rulează și mesajul nu apare. Asta permite să scrii valori implicite costisitoare (citirea dintr-un fișier, un calcul) fără să plătești costul când nu e nevoie. Același mecanism îl folosesc &&, || și assert.

A doua capcană este precedența. ?? are precedență mai mică decât operatorii aritmetici, deci cached ?? 0 + 10 se citește cached ?? (0 + 10). Cum cached există, rezultatul e 5, nu 15. Dacă voiai să aduni 10 la valoare, scrii (cached ?? 0) + 10.

Poți înlănțui operatorul, iar ultimul termen poate fi la rândul lui opțional:

SWIFT
let fromUser: String? = nil
let fromSettings: String? = "ro"
let language = fromUser ?? fromSettings ?? "en"   // "ro"
let maybe: String? = fromUser ?? fromSettings     // tot opțional

Poți folosi @autoclosure și în funcțiile tale, de exemplu într-un logger care construiește mesajul doar dacă nivelul de log este activ:

SWIFT
func debugLog(_ message: @autoclosure () -> String, enabled: Bool) {
    if enabled { print(message()) }
}

Ce urmărește intervievatorul: Verifică dacă știi că evaluarea este leneșă și cum se citește precedența. Mulți candidați spun că fallback() se apelează mereu sau că a doua linie afișează 15.

Eroarea, în practică:value of optional type must be unwrapped

19 Mid

Ce tipuri au n și m și când folosești map și flatMap pe un Optional?

SWIFT
let text: String? = "42"
let n = text.map { Int($0) }
let m = text.flatMap { Int($0) }

Răspuns scurt: n este Int??, iar m este Int?. map aplică o transformare valorii dacă există; flatMap se folosește când transformarea întoarce ea însăși un opțional, ca să nu obții un opțional dublu.

Optional are metode de transformare, la fel ca o colecție cu zero sau un element.

  • map(_:): dacă valoarea există, aplică funcția și împachetează rezultatul. Int($0) întoarce Int?, așa că rezultatul devine Int??.
  • flatMap(_:): aplică o funcție care întoarce deja opțional și aplatizează rezultatul la un singur nivel, Int?.
SWIFT
let doubled = m.map { $0 * 2 }                 // Optional(84)
let label = m.map { "Ai \($0) puncte" } ?? "Fără scor"
let none: String? = nil
print(none.map { $0.count } as Any)            // nil

Avantajul este că eviți un if let doar ca să transformi o valoare. Codul de mai jos face același lucru, dar e mai lung:

SWIFT
var label2: String
if let score = m { label2 = "Ai \(score) puncte" } else { label2 = "Fără scor" }

Combinația map(...) ?? valoareImplicită apare des când construiești texte pentru interfață sau parametri pentru URL-uri, de exemplu user.avatarPath.flatMap(URL.init(string:)).

Ca regulă: map când transformarea nu poate eșua, flatMap când poate. Nu exagera cu lanțuri lungi de map și flatMap pe opționale: dacă ai trei sau patru pași, un guard let cu mai multe condiții este de obicei mai ușor de citit.

Pe colecții, flatMap cu un closure care întoarce opțional a fost redenumit compactMap în Swift 4.1, tocmai ca să nu fie confundat cu aceste variante.

Ce urmărește intervievatorul: Verifică dacă înțelegi Optional ca pe un container și dacă eviți opționalele duble. Candidații confundă des flatMap pe opționale cu cel pe tablouri.

20 Mid

Ce afișează codul următor și cum păstrezi o cheie cu valoarea nil într-un dicționar [String: Int?]?

SWIFT
var scores: [String: Int?] = ["ana": 9, "dan": nil]
print(scores["dan"] as Any)
print(scores["ion"] as Any)
scores["ana"] = nil
print(scores.keys.sorted())

Răspuns scurt: Afișează Optional(nil), nil și ["dan"]. Subscriptul întoarce Int??, iar atribuirea lui nil șterge cheia. Ca să păstrezi cheia cu valoare lipsă, folosești updateValue(nil, forKey:) sau .some(nil).

Subscriptul unui dicționar întoarce mereu Value?, ca să semnaleze că cheia poate lipsi. Când Value este Int?, rezultatul este un opțional dublu Int??, cu trei stări distincte:

  • .some(.some(9)): cheia există și are valoare;
  • .some(.none): cheia există, dar valoarea e nil (cazul "dan", afișat Optional(nil));
  • .none: cheia lipsește (cazul "ion", afișat nil).

Atribuirea scores["ana"] = nil nu pune nil ca valoare, ci elimină cheia, pentru că nil este interpretat ca Int??.none. După linie, rămâne doar "dan".

Ca să păstrezi cheia cu valoare lipsă:

SWIFT
scores["ion"] = .some(nil)
scores.updateValue(nil, forKey: "maria")
print(scores.keys.sorted())     // ["dan", "ion", "maria"]

if let entry = scores["dan"] {
    print("cheia există, valoarea: \(entry as Any)")
}

Situația apare în practică la payload-uri JSON pentru PATCH, unde trebuie să distingi „câmp absent” (nu modifica) de „câmp null” (șterge valoarea). Un [String: Int?] sau un Int?? modelează exact aceste trei stări.

Totuși, opționalele duble sunt greu de citit. În cod de producție este adesea mai clar un enum explicit:

SWIFT
enum FieldUpdate<T> { case keep, clear, set(T) }

Codul devine autoexplicativ și nu mai depinde de subtilitățile lui nil.

Ce urmărește intervievatorul: Testează înțelegerea opționalelor imbricate într-un caz real. Aproape toți candidații se așteaptă ca scores["ana"] = nil să păstreze cheia.

Colecții, closures și funcții de ordin superior

Exersează capitolul cu exerciții reale: Curs Swift online →
21 Junior

Ce afișează codul următor? Cum elimini corect elementele pare dintr-un tablou?

SWIFT
var numbers = [1, 2, 3, 4]
for n in numbers {
    if n % 2 == 0 { numbers.append(n * 10) }
}
print(numbers)

Răspuns scurt: Afișează [1, 2, 3, 4, 20, 40]. for-in parcurge copia tabloului de la începutul buclei, deci elementele adăugate nu sunt vizitate. Pentru ștergere folosești numbers.removeAll { $0 % 2 == 0 }.

Array este tip valoare. Bucla for n in numbers obține un iterator pe valoarea tabloului din momentul începerii. Când adaugi elemente, mecanismul copy-on-write face ca numbers să primească un buffer nou, iar iteratorul continuă pe vechiul conținut, cu 4 elemente. Bucla nu devine infinită și nu vede 20 sau 40.

Problema apare la ștergerea prin indecși calculați la început:

SWIFT
var items = [1, 2, 3, 4]
for i in 0..<items.count {
    if items[i] % 2 == 0 { items.remove(at: i) }   // crapă: index out of range
}

Intervalul 0..<4 este fix, dar după prima ștergere tabloul are doar 3 elemente, iar indecșii se decalează. Variante corecte:

SWIFT
var a = [1, 2, 3, 4]
a.removeAll { $0 % 2 == 0 }            // [1, 3], O(n), modifică pe loc

let b = [1, 2, 3, 4].filter { $0 % 2 != 0 }   // tablou nou

var c = [1, 2, 3, 4]
for i in c.indices.reversed() where c[i] % 2 == 0 {
    c.remove(at: i)                     // de la coadă, indecșii rămân valizi
}

removeAll(where:) este preferată: parcurge tabloul o singură dată, pe când remove(at:) repetat mută elementele de fiecare dată și ajunge la O(n²).

În limbaje ca Java, modificarea unei liste în timpul iterării aruncă ConcurrentModificationException. În Swift nu primești eroare, dar nici nu vezi modificările, ceea ce poate surprinde.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii valorii la iterare și a modului corect de ștergere. Greșeala tipică este ștergerea cu remove(at:) într-o buclă pe indecși.

22 Junior

Ce operații pe tablouri pot opri aplicația și cum ai scrie un subscript sigur, array[safe: 10], care întoarce nil?

Răspuns scurt: Opresc programul accesul cu index invalid, removeFirst() sau removeLast() pe un tablou gol și intervalele invalide. Un subscript sigur verifică indices.contains(index) și întoarce un opțional.

Swift alege siguranța: accesul în afara limitelor nu citește memorie străină, ci oprește programul cu „Index out of range”. Operațiile care pot crăpa:

  • array[i] cu i negativ sau mai mare decât count - 1;
  • removeFirst(), removeLast(), remove(at:) pe tablou gol sau cu index invalid;
  • array[2..<10] dacă intervalul depășește limitele.

Există variante care întorc opțional: first, last, randomElement(), popLast(), min(), max(), firstIndex(of:). Le preferi când golul este posibil.

Pentru acces prin index fără crash, scrii o extensie pe Collection:

SWIFT
extension Collection {
    subscript(safe index: Index) -> Element? {
        indices.contains(index) ? self[index] : nil
    }
}

let colors = ["roșu", "verde"]
print(colors[safe: 1] ?? "-")    // verde
print(colors[safe: 5] ?? "-")    // -

Fiind pe Collection, merge și pentru String, ArraySlice sau orice colecție. Pentru Array, indices este un Range<Int>, deci contains este O(1).

Totuși, un subscript sigur nu trebuie folosit peste tot. Dacă un index invalid înseamnă un bug de logică, un crash în dezvoltare te ajută să-l găsești, iar ascunderea lui cu nil mută problema mai departe. Subscriptul sigur e potrivit când indexul vine din exterior: o poziție primită de la server, o selecție a utilizatorului sau un index calculat care poate legitim să lipsească.

Ce urmărește intervievatorul: Verifică dacă știi ce operații crapă și dacă alegi conștient între crash și opțional. Unii candidați propun subscriptul sigur ca soluție universală, ascunzând bug-uri.

Eroarea, în practică:Fatal error: Index out of rangeCan't remove last element from an empty collection

23 Junior

Scrie o funcție care primește un text și întoarce de câte ori apare fiecare cuvânt, ignorând majusculele. Afișează apoi primele 3 cuvinte după frecvență.

Răspuns scurt: Parcurgi cuvintele obținute cu split(separator:) și incrementezi counts[word, default: 0] += 1. Pentru top 3 sortezi perechile după valoare descrescător și iei prefix(3).

Soluția idiomatică folosește subscriptul cu default:, care întoarce valoarea implicită când cheia lipsește și permite modificarea pe loc:

SWIFT
func wordFrequency(_ text: String) -> [String: Int] {
    var counts: [String: Int] = [:]
    let words = text.lowercased().split { !$0.isLetter }
    for word in words {
        counts[String(word), default: 0] += 1
    }
    return counts
}

let text = "Ana are mere. Ana are și pere, iar mere are și Dan."
let freq = wordFrequency(text)
let top = freq
    .sorted { $0.value != $1.value ? $0.value > $1.value : $0.key < $1.key }
    .prefix(3)
for (word, count) in top {
    print(word, count)
}
// are 3
// ana 2
// mere 2

Puncte de discutat la interviu:

  • split { !$0.isLetter } desparte după orice caracter care nu e literă, deci elimină și punctuația. isLetter recunoaște și diacriticele.
  • split întoarce Substring, de aceea convertești cu String(word) înainte să-l folosești ca cheie.
  • Ordinea unui Dictionary nu este definită și poate diferi între rulări, așa că sortarea este obligatorie pentru un rezultat stabil. Criteriul secundar alfabetic face ordinea deterministă la egalitate.
  • Complexitatea este O(n) pentru numărare și O(k log k) pentru sortarea celor k cuvinte distincte.

O alternativă cu reduce(into:) este words.reduce(into: [:]) { $0[String($1), default: 0] += 1 }. Este concisă, dar bucla explicită e mai ușor de urmărit într-un interviu live.

Ce urmărește intervievatorul: Este un exercițiu clasic de live coding care arată stăpânirea dicționarelor. Greșelile tipice sunt despachetarea manuală cu if let și uitarea că ordinea dicționarului nu e garantată.

24 Junior

Ai lista cursurilor terminate de Ana și de Dan ca Set<String>. Cum afli cursurile comune, pe cele terminate doar de Ana și pe toate la un loc? De ce elementele unui Set trebuie să fie Hashable?

Răspuns scurt: Folosești intersection, subtracting și union. Elementele trebuie să fie Hashable pentru că Set le stochează într-un tabel hash, ceea ce dă verificarea apartenenței în O(1) în medie.

Set este o colecție neordonată de elemente unice, construită pe un tabel hash. Operațiile de mulțimi sunt directe:

SWIFT
let ana: Set = ["Swift", "Git", "SQL", "Python"]
let dan: Set = ["Swift", "Java", "SQL"]

print(ana.intersection(dan).sorted())         // ["SQL", "Swift"]
print(ana.subtracting(dan).sorted())          // ["Git", "Python"]
print(ana.union(dan).count)                   // 5
print(ana.symmetricDifference(dan).sorted())  // ["Git", "Java", "Python"]
print(Set(["Swift"]).isSubset(of: ana))       // true

var done = ana
let (inserted, _) = done.insert("Swift")
print(inserted)                               // false: exista deja

Variantele cu form... (formUnion, formIntersection) modifică mulțimea pe loc. sorted() apare în exemple pentru că ordinea de afișare a unui Set nu este garantată.

De ce Hashable: la inserare, Set calculează hash-ul elementului ca să afle în ce poziție îl pune, iar la contains caută direct acolo. Rezultatul este O(1) în medie, față de O(n) pentru Array.contains. Când două elemente ajung în aceeași poziție, Set le compară cu ==, deci ai nevoie și de Equatable, pe care Hashable îl include.

Pentru tipurile tale, compilatorul sintetizează Hashable dacă toate proprietățile stocate sunt Hashable:

SWIFT
struct Course: Hashable { let id: Int; let title: String }

Alegerea practică: Set când contează unicitatea și căutarea rapidă, Array când contează ordinea sau duplicatele. Un truc des folosit este Set(array).count != array.count pentru a detecta duplicate.

Ce urmărește intervievatorul: Verifică dacă știi operațiile de mulțimi și motivul tehnic al cerinței Hashable. Candidații construiesc des bucle imbricate pentru o simplă intersecție.

25 Junior

Ce afișează codul următor?

SWIFT
let raw = ["1", "doi", "3"]
print(raw.map { Int($0) })
print(raw.compactMap { Int($0) })
let nested = [[1, 2], [3], []]
print(nested.flatMap { $0 })
print(nested.map { $0.count })

Răspuns scurt: Afișează [Optional(1), nil, Optional(3)], [1, 3], [1, 2, 3] și [2, 1, 0]. map păstrează câte un rezultat pentru fiecare element, compactMap elimină nil-urile, iar flatMap aplatizează tablourile imbricate.

Cele trei funcții par asemănătoare, dar fac lucruri diferite:

  • map transformă fiecare element și întoarce un tablou cu același număr de elemente. Int($0) întoarce Int?, deci rezultatul este [Int?], iar "doi" devine nil.
  • compactMap aplică transformarea și păstrează doar rezultatele nenule. Este instrumentul standard pentru „încearcă să convertești și ignoră ce nu merge”. Rezultatul este [Int].
  • flatMap se aplică atunci când transformarea întoarce o secvență și concatenează toate secvențele într-una. Tabloul gol nu contribuie cu nimic.
SWIFT
struct Order { let id: Int; let items: [String] }
let orders = [Order(id: 1, items: ["carte", "pix"]), Order(id: 2, items: ["caiet"])]

let allItems = orders.flatMap { $0.items }           // ["carte", "pix", "caiet"]
let ids = orders.map(\.id)                           // [1, 2]
let urls = ["https://a.ro", ""].compactMap { $0.isEmpty ? nil : $0 }

Istoric, flatMap pe secvențe accepta și closures care întorc opționale și făcea ce face azi compactMap. În Swift 4.1 acea variantă a fost redenumită compactMap, pentru că numele crea confuzie. În cod vechi poți vedea încă flatMap folosit astfel, cu avertisment de deprecare.

map(\.id) folosește un key path ca funcție, posibil din Swift 5.2. Toate aceste funcții sunt nelenese pe tablouri: creează imediat un tablou nou. Pentru lanțuri lungi pe date mari, .lazy evită tablourile intermediare.

Ce urmărește intervievatorul: Este o întrebare de bază la orice interviu Swift. Greșeala frecventă este confuzia dintre flatMap și compactMap sau presupunerea că map elimină nil-urile.

26 Junior

Ai o listă de vânzări cu oraș și sumă. Calculează totalul și totalul pe fiecare oraș. Care este diferența dintre reduce(_:_:) și reduce(into:_:)?

Răspuns scurt: Totalul se obține cu reduce(0) { $0 + $1.amount }, iar totalul pe oraș cu reduce(into: [:]) { $0[$1.city, default: 0] += $1.amount }. reduce(into:) modifică acumulatorul pe loc, deci e mai eficient pentru colecții ca acumulator.

reduce combină toate elementele într-o singură valoare. Există două forme:

  • reduce(initial) { acc, element in ... }: closure-ul întoarce un acumulator nou la fiecare pas.
  • reduce(into: initial) { acc, element in ... }: acumulatorul este inout și îl modifici pe loc.
SWIFT
struct Sale { let city: String; let amount: Double }
let sales = [
    Sale(city: "Iași", amount: 120),
    Sale(city: "Cluj", amount: 80),
    Sale(city: "Iași", amount: 30)
]

let total = sales.reduce(0) { $0 + $1.amount }          // 230.0

let byCity = sales.reduce(into: [String: Double]()) { acc, sale in
    acc[sale.city, default: 0] += sale.amount
}
print(byCity["Iași"] ?? 0)                               // 150.0

let grouped = Dictionary(grouping: sales, by: \.city)   // [String: [Sale]]
let totals = grouped.mapValues { $0.reduce(0) { $0 + $1.amount } }

De ce contează diferența: cu forma clasică, dacă acumulatorul este un dicționar sau un tablou, fiecare pas ar crea o copie nouă, ceea ce face operația O(n²) pentru colecții mari. reduce(into:) evită copiile, pentru că acumulatorul este modificat direct.

Pentru valori simple, ca o sumă sau un maxim, forma clasică este perfectă și mai scurtă: sales.map(\.amount).reduce(0, +). Operatorul + poate fi transmis direct ca funcție.

Dictionary(grouping:by:) este alternativa cea mai lizibilă când ai nevoie de grupuri, apoi mapValues pentru agregare. Într-un interviu, alegerea între aceste variante arată că știi și biblioteca standard, nu doar buclele.

Ce urmărește intervievatorul: Verifică stăpânirea funcțiilor de agregare și conștientizarea costului copierii. Candidații folosesc des reduce cu un dicționar returnat la fiecare pas, fără să știe că e ineficient.

27 Junior

Scrie o funcție makeMultiplier(_:) care întoarce o funcție ce înmulțește cu un factor dat. Ce tip are rezultatul și cum transmiți funcții existente ca argumente?

Răspuns scurt: Funcția întoarce tipul (Int) -> Int, adică un closure care capturează factorul. În Swift funcțiile sunt valori: le poți păstra în variabile, transmite ca argumente și întoarce din alte funcții.

În Swift funcțiile sunt first-class: au tipuri precum (Int) -> Int sau (String, Int) -> Bool și pot fi folosite ca orice altă valoare.

SWIFT
func makeMultiplier(_ factor: Int) -> (Int) -> Int {
    return { value in value * factor }
}

let triple = makeMultiplier(3)
print(triple(5))                     // 15
print([1, 2, 3].map(triple))         // [3, 6, 9]

func isEven(_ n: Int) -> Bool { n % 2 == 0 }
print([1, 2, 3, 4].filter(isEven))   // [2, 4]
print([3, 1, 2].sorted(by: >))       // [3, 2, 1]
print([1, 2, 3].reduce(0, +))        // 6
print(["1", "x"].compactMap(Int.init))   // [1]

Puncte de explicat:

  • Closure-ul întors capturează parametrul factor. Fiecare apel al lui makeMultiplier produce o funcție nouă, cu propriul factor.
  • Poți transmite numele unei funcții unde se așteaptă un closure cu aceeași semnătură: filter(isEven).
  • Operatorii sunt funcții: > are tipul (Int, Int) -> Bool, + are (Int, Int) -> Int.
  • Inițializatorii pot fi folosiți ca funcții: Int.init sau String.init(describing:).

Funcțiile care întorc funcții sunt utile pentru configurare: un formatter de preț pentru o anumită monedă, un validator cu o lungime minimă dată, un filtru construit din opțiunile utilizatorului. Poți ține și un dicționar de operații: let ops: [String: (Double, Double) -> Double] = ["+": (+), "*": (*)].

Tipurile funcțiilor sunt tipuri referință în spate, iar capturarea de variabile mutabile duce la stare partajată, subiect care apare apoi la întrebările despre memorie.

Ce urmărește intervievatorul: Verifică dacă înțelegi funcțiile ca valori și capturarea. Candidații juniori scriu rar filter(isEven) sau sorted(by: >) și nu știu că operatorii sunt funcții.

28 Junior

Un coleg a scris if users.filter({ $0.isAdmin }).count > 0 și let admin = users.filter({ $0.isAdmin }).first. Ce ai schimba și de ce?

Răspuns scurt: Le-ai înlocui cu users.contains { $0.isAdmin } și users.first { $0.isAdmin }. Variantele cu filter construiesc un tablou nou și parcurg toată lista, pe când contains(where:) și first(where:) se opresc la primul rezultat.

filter creează întotdeauna un tablou nou cu toate elementele care se potrivesc și parcurge întreaga colecție. Dacă ai nevoie doar de răspunsul „există?” sau de primul element, munca în plus e inutilă:

SWIFT
struct User { let name: String; let isAdmin: Bool; let age: Int }
let users = [User(name: "Ana", isAdmin: false, age: 17),
             User(name: "Dan", isAdmin: true, age: 30)]

let hasAdmin = users.contains { $0.isAdmin }          // se oprește la Dan
let admin = users.first { $0.isAdmin }                // User?
let index = users.firstIndex { $0.isAdmin }           // Int?
let allAdults = users.allSatisfy { $0.age >= 18 }     // false
let adminCount = users.count { $0.isAdmin }           // Swift 6: count(where:)

Beneficii:

  • Scurtcircuitare: căutarea se oprește când răspunsul e cunoscut. Pe o listă de 100.000 de elemente cu un admin la început, diferența e mare.
  • Fără alocări: nu se creează tablouri intermediare.
  • Intenție clară: contains(where:) spune exact ce vrei să afli.

O capcană legată: allSatisfy pe o colecție goală întoarce true (adevăr vid). Dacă logica ta cere „lista are elemente și toate sunt valide”, verifică și !isEmpty.

Tot aici intră isEmpty în loc de count == 0. Pentru Array diferența e mică, dar pentru String sau colecții leneșe count este O(n), iar isEmpty e O(1).

count(where:) a fost adăugat în Swift 6.0 (SE-0220). În versiuni mai vechi folosești reduce(0) { $0 + ($1.isAdmin ? 1 : 0) } sau, mai puțin eficient, filter(...).count.

Ce urmărește intervievatorul: Este o întrebare de code review care arată atenția la performanță și lizibilitate. Candidații nu cunosc des contains(where:) și comportamentul lui allSatisfy pe colecții goale.

29 Mid

Ce afișează codul următor? Ce s-ar întâmpla fără .lazy?

SWIFT
let result = (1...).lazy
    .map { n -> Int in
        print("map \(n)")
        return n * n
    }
    .filter { $0 % 2 == 0 }
    .prefix(2)

for x in result {
    print("primit \(x)")
}

Răspuns scurt: Afișează alternat map 1, map 2, primit 4, map 3, map 4, primit 16. Fără .lazy, map ar încerca să transforme intervalul infinit 1... și programul nu s-ar termina niciodată.

.lazy transformă secvența într-una leneșă: map și filter nu mai produc tablouri, ci învelișuri care calculează fiecare element abia când este cerut. Lanțul se evaluează element cu element, la cererea buclei for:

  • bucla cere primul element; prefix cere de la filter, care cere de la map: map 1 dă 1, respins de filter;
  • map 2 dă 4, acceptat, deci apare primit 4;
  • map 3 dă 9, respins; map 4 dă 16, acceptat, apare primit 16;
  • prefix(2) a dat deja două elemente, deci nu mai cere nimic și bucla se termină.

Ordinea alternată arată că nu există etape separate „întâi toate map, apoi toate filter”.

(1...) este un interval infinit. Fără .lazy, map încearcă să construiască un tablou cu toate elementele și nu se termină niciodată.

Când folosești lazy:

  • pe colecții mari, când ai nevoie doar de primele rezultate (first(where:), prefix);
  • când vrei să eviți tablourile intermediare în lanțuri lungi.

Capcane:

  • Closures se pot executa de mai multe ori. Dacă accesezi de două ori același element al unei colecții leneșe sau o parcurgi de două ori, map rulează din nou. Nu pune efecte secundare (cereri de rețea, contoare) în closures leneșe.
  • Pentru colecții mici, lazy nu aduce câștig și complică tipurile rezultate (LazyMapSequence<...>). Când ai nevoie de un tablou concret, apelezi Array(result).

Ce urmărește intervievatorul: Verifică înțelegerea evaluării leneșe și a ordinii de execuție. Majoritatea candidaților presupun că toate apelurile map se fac înainte de filter.

30 Mid

Sortează o listă de studenți descrescător după notă, iar la note egale alfabetic după nume. Ce regulă trebuie să respecte closure-ul de sortare?

Răspuns scurt: Compari întâi notele, iar la egalitate numele, sau folosești compararea de tupluri. Closure-ul trebuie să fie o ordine strictă: întoarce true doar dacă primul element trebuie să fie strict înaintea celui de-al doilea, deci nu folosești >= sau <=.

Varianta explicită este cea mai ușor de citit:

SWIFT
struct Student { let name: String; let grade: Int }
let students = [
    Student(name: "Maria", grade: 9),
    Student(name: "Andrei", grade: 10),
    Student(name: "Bianca", grade: 9)
]

let ranked = students.sorted { a, b in
    if a.grade != b.grade { return a.grade > b.grade }
    return a.name < b.name
}
print(ranked.map(\.name))   // ["Andrei", "Bianca", "Maria"]

O variantă scurtă folosește compararea tuplurilor, care merge lexicografic, element cu element, pentru tupluri de până la 6 elemente Comparable. Ca să ai notă descrescătoare și nume crescător, inversezi doar componenta notei:

SWIFT
let ranked2 = students.sorted { ($1.grade, $0.name) < ($0.grade, $1.name) }

E concisă, dar mai greu de citit, așa că la interviu explică-o.

Regula importantă: predicatul trebuie să fie o ordine strictă slabă. Pentru elemente egale trebuie să întoarcă false în ambele sensuri. Dacă scrii $0.grade >= $1.grade, încalci regula: rezultatul poate fi inconsecvent, iar unele implementări pot chiar să se oprească cu eroare.

Pentru texte afișate utilizatorilor, compararea cu < lucrează pe scalari Unicode, deci „Ștefan” ajunge după „Zoe”. Pentru ordinea așteptată de un vorbitor de română folosești localizedStandardCompare din Foundation sau un Comparator cu localizare.

Pentru reutilizare, poți face Student conform cu Comparable sau poți folosi SortDescriptor din Foundation, dar pentru criterii de o singură folosință un closure e suficient.

Ce urmărește intervievatorul: Testează sortarea pe mai multe criterii și cunoașterea contractului comparatorului. Greșeala tipică este folosirea lui >=, care pare inofensivă, dar strică ordinea.

31 Mid

Implementează o secvență proprie care generează numerele Fibonacci și poate fi folosită direct într-un for-in. Ce trebuie să implementezi?

Răspuns scurt: Implementezi Sequence și IteratorProtocol cu o metodă mutating func next() -> Int?. Orice tip care respectă Sequence primește automat for-in, map, filter, prefix și restul metodelor.

for-in funcționează pe orice tip Sequence. Protocolul cere o metodă makeIterator(), care întoarce un IteratorProtocol cu next(). Când tipul este propriul iterator, makeIterator() vine gata implementat:

SWIFT
struct Fibonacci: Sequence, IteratorProtocol {
    private var current = 0
    private var following = 1

    mutating func next() -> Int? {
        let value = current
        (current, following) = (following, current + following)
        return value
    }
}

for n in Fibonacci().prefix(8) {
    print(n, terminator: " ")       // 0 1 1 2 3 5 8 13
}
print()
let firstOver100 = Fibonacci().first { $0 > 100 }   // Optional(144)
let evens = Fibonacci().lazy.filter { $0 % 2 == 0 }.prefix(4)
print(Array(evens))                 // [0, 2, 8, 34]

Secvența este infinită, deci folosești mereu prefix, first(where:) sau lazy. Un map direct nu s-ar termina. În plus, după aproximativ 90 de pași, current + following depășește Int.max și programul se oprește. Într-o versiune reală poți întoarce nil când apare overflow, folosind addingReportingOverflow.

next() este mutating, pentru că iteratorul își schimbă starea. Pentru că este o structură, fiecare Fibonacci() începe de la zero, iar copierea unui iterator îi copiază și starea.

Pentru cazuri simple nu e nevoie de un tip nou. Biblioteca standard are sequence(first:next:) și sequence(state:next:):

SWIFT
let powers = sequence(first: 1) { $0 < 1000 ? $0 * 2 : nil }
print(Array(powers))                // [1, 2, 4, ..., 1024]

Diferența față de Collection: o Sequence poate fi parcursă o singură dată și nu are indecși.

Ce urmărește intervievatorul: Verifică înțelegerea protocoalelor din biblioteca standard care stau în spatele lui for-in. Candidații uită că secvența e infinită și o transmit direct la map.

32 Senior

Funcția de mai jos elimină duplicatele păstrând ordinea, dar este lentă pe 100.000 de elemente. De ce și cum o optimizezi?

SWIFT
func unique(_ items: [String]) -> [String] {
    var result: [String] = []
    for item in items {
        if !result.contains(item) { result.append(item) }
    }
    return result
}

Răspuns scurt: result.contains este O(n), deci funcția este O(n²). Folosești un Set auxiliar pentru elementele văzute, ceea ce face verificarea O(1) în medie și funcția O(n), păstrând ordinea din tabloul rezultat.

Pentru fiecare element, contains parcurge tabloul result, care crește până la n elemente. Pe date fără duplicate faci în jur de n²/2 comparații de text, adică miliarde pentru 100.000 de elemente.

Soluția păstrează tabloul pentru ordine și adaugă un Set pentru căutare:

SWIFT
func unique<T: Hashable>(_ items: [T]) -> [T] {
    var seen = Set<T>()
    seen.reserveCapacity(items.count)
    return items.filter { seen.insert($0).inserted }
}

print(unique(["b", "a", "b", "c", "a"]))   // ["b", "a", "c"]

insert întoarce un tuplu (inserted: Bool, memberAfterInsert:), deci un singur apel verifică și adaugă. reserveCapacity evită realocările repetate ale tabelului hash. Varianta generică funcționează pentru orice tip Hashable.

Set(items) singur nu e suficient: elimină duplicatele, dar pierde ordinea.

Alte costuri ascunse din colecții, utile la întrebări de optimizare:

  • removeFirst() și insert(_:at: 0) pe Array sunt O(n), pentru că mută toate elementele. Pentru o coadă folosești doi indici, două stive sau Deque din pachetul swift-collections.
  • String.count și indexarea cu index(_:offsetBy:) sunt O(n).
  • append este O(1) amortizat; dacă știi dimensiunea finală, reserveCapacity reduce realocările.
  • Dictionary și Set au căutare O(1) în medie, dar depind de un hash(into:) bine distribuit.
  • Copierea unui tablou e ieftină până la prima modificare (copy-on-write); modificarea unei copii partajate copiază tot bufferul.

Înainte de optimizare, măsoară pe build Release, pentru că în Debug diferențele sunt distorsionate.

Ce urmărește intervievatorul: Testează analiza complexității și cunoașterea structurilor potrivite. Candidații propun des Array(Set(items)), care pierde ordinea cerută.

Struct, class și enum

33 Junior

Când primește un struct inițializatorul memberwise automat și când îl pierzi? Cum adaugi un inițializator propriu fără să-l pierzi?

Răspuns scurt: Un struct primește automat init cu toate proprietățile stocate dacă nu definești niciun inițializator în corpul lui. Dacă scrii unul în corpul tipului, memberwise dispare; dacă îl scrii într-o extensie, se păstrează.

Compilatorul generează un memberwise initializer cu câte un parametru pentru fiecare proprietate stocată, în ordinea declarării. Proprietățile var cu valoare implicită devin parametri cu valoare implicită, iar cele let deja inițializate sunt excluse.

SWIFT
struct Product {
    let id: Int
    var name: String
    var price: Double = 0
}
let p1 = Product(id: 1, name: "Carte")             // price = 0
let p2 = Product(id: 2, name: "Pix", price: 4.5)

extension Product {
    init(id: Int, name: String, priceInBani: Int) {
        self.init(id: id, name: name, price: Double(priceInBani) / 100)
    }
}
let p3 = Product(id: 3, name: "Caiet", priceInBani: 799)

Dacă mutai init(id:name:priceInBani:) în corpul lui Product, linia cu p1 nu ar mai compila. Regula există pentru că un inițializator propriu exprimă de obicei o validare sau un invariant, iar compilatorul nu vrea să-ți ofere o cale de a-l ocoli.

Alte reguli de reținut:

  • Memberwise are nivelul de acces internal, sau private dacă vreo proprietate stocată e private. Într-un pachet Swift, un public struct nu are inițializator public automat; trebuie să-l scrii.
  • Dacă reordonezi proprietățile, se schimbă ordinea parametrilor și poți strica apelurile existente.
  • Clasele nu primesc memberwise, doar un init() implicit când toate proprietățile au valori implicite.

În practică, organizarea „proprietăți în corp, inițializatori de conveniență în extensii” păstrează ambele variante.

Ce urmărește intervievatorul: Verifică dacă știi regulile inițializatorilor generați. O surpriză frecventă este dispariția memberwise după adăugarea unui init sau lipsa lui la tipurile publice din pachete.

34 Junior

Care dintre liniile marcate compilează și de ce?

SWIFT
class Box { var value = 0 }
struct Point { var x = 0 }

let box = Box()
box.value = 5        // (1)
let point = Point()
point.x = 5          // (2)
box = Box()          // (3)

Răspuns scurt: Doar linia (1) compilează. let pe o clasă face constantă referința, nu obiectul, deci proprietățile var se pot schimba. let pe un struct face constantă întreaga valoare, deci (2) nu compilează, iar (3) încearcă să schimbe o referință constantă.

Diferența vine din semantica tipurilor.

Clasa este tip referință. Variabila box conține o referință către un obiect din heap. let înseamnă că referința nu se poate schimba: box va arăta mereu către același obiect. Obiectul însă poate fi modificat prin proprietățile var, deci (1) este valid. Linia (3) încearcă să facă box să arate către alt obiect, ceea ce let interzice.

Structura este tip valoare. Variabila point conține chiar datele. let face constantă întreaga valoare, inclusiv toate proprietățile, chiar dacă sunt declarate var. Linia (2) dă eroarea „cannot assign to property: 'point' is a 'let' constant”. Din același motiv, pe un struct let nu poți apela metode mutating.

SWIFT
var movable = Point()
movable.x = 5            // ok: variabila e var

let shared = Box()
func reset(_ b: Box) { b.value = 0 }   // ok: modifici obiectul prin referință
reset(shared)

Ultima funcție arată un lucru important: oricine are o referință la un obiect îl poate modifica, chiar dacă tu ai declarat-o let. La structuri, o funcție primește o copie și nu poate modifica originalul fără inout.

Consecința practică: cu structuri, let îți dă imutabilitate reală și ușor de verificat. Cu clase, pentru imutabilitate trebuie să declari proprietățile let sau private(set). De aceea modelele de date în Swift se scriu de obicei ca struct.

Ce urmărește intervievatorul: Arată dacă înțelegi ce anume face constant let în cele două semantici. Candidații veniți din Java cred des că let pe struct se comportă ca final pe o referință.

Eroarea, în practică:cannot assign to property: 'p' is a 'let' constantcannot use mutating member on immutable value

35 Junior

Care este diferența dintre == și === în Swift? Ce afișează codul?

SWIFT
final class Person: Equatable {
    let name: String
    init(name: String) { self.name = name }
    static func == (l: Person, r: Person) -> Bool { l.name == r.name }
}
let a = Person(name: "Ana")
let b = Person(name: "Ana")
let c = a
print(a == b, a === b, a === c)

Răspuns scurt: Afișează true false true. == compară egalitatea valorilor după regula definită în Equatable, iar === verifică identitatea, adică dacă două referințe arată către același obiect.

== este definit de protocolul Equatable și înseamnă „sunt echivalente după criteriul tipului”. Aici Person consideră egale două persoane cu același nume, deci a == b este true.

=== este operatorul de identitate, disponibil doar pentru instanțe de clasă (AnyObject). Verifică dacă cele două referințe indică același obiect din memorie. a și b sunt două obiecte diferite, create separat, deci a === b este false. c este o copie a referinței a, deci a === c este true. Există și !==.

Pentru structuri și enum-uri, === nu compilează, pentru că valorile nu au identitate: două valori egale sunt interschimbabile.

Când contează diferența:

  • Într-un delegate sau într-o listă de observatori, vrei să elimini exact obiectul înregistrat, nu unul „egal”: observers.removeAll { $0 === target }.
  • La cache-uri de obiecte, verifici dacă ai deja aceeași instanță.
  • În teste, XCTAssertIdentical verifică identitatea, iar XCTAssertEqual egalitatea.

O greșeală de design este să implementezi == pe o clasă comparând doar id-ul, apoi să o folosești într-un Set fără hash(into:) consecvent. Regula: dacă a == b, atunci hash-urile trebuie să fie egale.

Dacă ai nevoie de un identificator stabil pentru un obiect, fără Equatable, poți folosi ObjectIdentifier(a), care este Hashable și se bazează pe identitate.

Ce urmărește intervievatorul: Verifică dacă distingi egalitatea de identitate. Greșeala frecventă este să crezi că == pe clase compară implicit referințele, ca în Java.

36 Junior

Cum funcționează rawValue la un enum? Ce întoarce Level(rawValue: "expert") și ce valori brute primesc automat cazurile?

Răspuns scurt: Un enum cu tip brut (String, Int etc.) asociază fiecărui caz o valoare constantă și primește init?(rawValue:), care întoarce nil pentru valori necunoscute. Pentru String, valoarea implicită e numele cazului; pentru Int, numerotarea pornește de la 0.

Declari tipul brut după numele enum-ului. Compilatorul generează proprietatea rawValue și un inițializator failable:

SWIFT
enum Level: String {
    case junior, mid
    case senior = "Senior"
}
print(Level.mid.rawValue)                 // mid
print(Level(rawValue: "Senior") == .senior)  // true
print(Level(rawValue: "expert") == nil)   // true

enum Priority: Int {
    case low = 1, medium, high            // 1, 2, 3
}
print(Priority.high.rawValue)             // 3

Reguli:

  • La String, valoarea implicită este numele cazului exact cum e scris. La Int, pornește de la 0 sau continuă de la ultima valoare explicită, crescând cu 1.
  • Valorile brute trebuie să fie literali unici; nu pot fi calculate la rulare.
  • init?(rawValue:) întoarce opțional, pentru că textul primit poate să nu corespundă unui caz.

Cel mai des folosești rawValue la granița cu exteriorul: JSON, UserDefaults, parametri de URL. Un enum cu String și Codable se decodează automat din valoarea brută. Pericolul apare când serverul trimite o valoare nouă: decodarea eșuează pentru tot obiectul. Soluția este un inițializator propriu care mapează valorile necunoscute pe un caz unknown.

Nu confunda valorile brute cu valorile asociate. Valoarea brută este fixă pentru fiecare caz, iar cea asociată se dă la crearea fiecărei instanțe, ca în case failed(String). Un enum nu poate avea, în mod direct, și tip brut, și valori asociate.

Ce urmărește intervievatorul: Testează lucrul practic cu enum-uri și date externe. Candidații uită că init(rawValue:) întoarce opțional și îl despachetează forțat.

Eroarea, în practică:enum with raw type cannot have cases with argumentsraw value for enum case is not unique

37 Junior

De ce se recomandă să nu pui default într-un switch pe un enum propriu? Ce face CaseIterable și ce este @unknown default?

Răspuns scurt: Fără default, când adaugi un caz nou compilatorul îți arată fiecare switch care trebuie actualizat. CaseIterable generează allCases cu toate cazurile, iar @unknown default se folosește pentru enum-uri din biblioteci care pot primi cazuri noi.

Exhaustivitatea lui switch este o unealtă de siguranță. Dacă enumeri explicit toate cazurile, adăugarea unui caz nou produce erori de compilare exact în locurile care trebuie revizuite. Un default ascunde aceste locuri: cazul nou intră în tăcere pe ramura implicită, de multe ori cu un comportament greșit.

SWIFT
enum PaymentMethod: CaseIterable {
    case card, transfer, cash
}

func fee(for method: PaymentMethod) -> Double {
    switch method {
    case .card: return 1.5
    case .transfer: return 0
    case .cash: return 0
    }
}

for method in PaymentMethod.allCases {
    print(method, fee(for: method))
}
print(PaymentMethod.allCases.count)   // 3

Dacă adaugi case voucher, funcția fee nu mai compilează până nu decizi taxa pentru voucher.

CaseIterable este sintetizat automat pentru enum-urile fără valori asociate. Îl folosești pentru liste de opțiuni într-un picker, pentru teste care verifică toate cazurile sau pentru validări. Ordinea din allCases este ordinea declarării.

@unknown default apare la enum-uri din framework-uri compilate cu library evolution, cum sunt multe din SDK-urile Apple. Acestea pot primi cazuri noi într-o versiune viitoare de sistem, fără ca aplicația ta să fie recompilată. @unknown default tratează aceste cazuri la rulare, dar compilatorul te avertizează dacă nu ai acoperit explicit toate cazurile cunoscute acum, deci păstrezi și siguranța.

Ce urmărește intervievatorul: Verifică dacă folosești compilatorul ca plasă de siguranță. Candidații pun default din reflex și nu cunosc diferența față de @unknown default.

Eroarea, în practică:switch must be exhaustive

38 Junior

Ce afișează codul și ce rol au override, super și final?

SWIFT
class Animal {
    func sound() -> String { "..." }
    func describe() -> String { "Fac \(sound())" }
}
class Dog: Animal {
    override func sound() -> String { "ham" }
    override func describe() -> String { super.describe() + "!" }
}
let pet: Animal = Dog()
print(pet.describe())

Răspuns scurt: Afișează Fac ham!. Apelul se rezolvă după tipul real al obiectului (Dog), super.describe() rulează versiunea din Animal, care la rândul ei apelează sound() suprascris. final interzice suprascrierea sau moștenirea.

Variabila are tipul declarat Animal, dar obiectul este Dog. Pentru metodele de clasă, Swift folosește dispatch dinamic: la rulare se alege implementarea tipului real.

Pașii:

1. pet.describe() apelează Dog.describe(). 2. Aceasta apelează super.describe(), adică implementarea din Animal. 3. În Animal.describe(), sound() este tot un apel dinamic pe self, care este un Dog, deci întoarce "ham". 4. Rezultatul "Fac ham" primește "!" în Dog.describe().

Reguli Swift:

  • override este obligatoriu când suprascrii. Dacă îl uiți, sau dacă metoda părintelui nu există, primești eroare. Așa eviți suprascrierile accidentale și greșelile de tipar.
  • super apelează implementarea părintelui, util când extinzi comportamentul în loc să-l înlocuiești.
  • final pe o metodă sau proprietate interzice suprascrierea; pe o clasă interzice moștenirea.
SWIFT
final class Cat: Animal {
    override func sound() -> String { "miau" }
}
// class Lion: Cat {}    // eroare: Cat este final

final are și un efect de performanță: compilatorul poate apela metodele direct, fără tabela virtuală. De aceea multe ghiduri de stil recomandă ca orice clasă care nu e gândită pentru moștenire să fie final.

Structurile și enum-urile nu suportă moștenire. Pentru comportament comun între ele, Swift folosește protocoale cu implementări implicite, subiect pe care merită să-l pomenești dacă discuția continuă spre design.

Ce urmărește intervievatorul: Testează înțelegerea polimorfismului și a dispatch-ului dinamic. Unii candidați cred că tipul declarat Animal determină metoda apelată sau că sound() din Animal rulează în super.describe().

Eroarea, în practică:overriding declaration requires 'override'method does not override any method

39 Junior

Ce afișează codul următor?

SWIFT
struct Thermostat {
    var temp: Int = 20 {
        willSet { print("va deveni \(newValue)") }
        didSet {
            if temp > 30 { temp = 30 }
            print("acum \(temp), înainte \(oldValue)")
        }
    }
}
var t = Thermostat()
t.temp = 35
let u = Thermostat(temp: 50)
print(u.temp)

Răspuns scurt: Afișează va deveni 35, acum 30, înainte 20, apoi 50. Atribuirea din didSet nu declanșează din nou observatorii, iar observatorii nu rulează în timpul inițializării, deci Thermostat(temp: 50) ocolește limita.

Observatorii de proprietate rulează la fiecare atribuire după inițializare:

  • willSet înainte de schimbare, cu noua valoare în newValue;
  • didSet după schimbare, cu vechea valoare în oldValue.

La t.temp = 35 se afișează va deveni 35. Apoi didSet vede 35, îl reduce la 30 și afișează acum 30, înainte 20. Atribuirea temp = 30 din interiorul propriului didSet nu reapelează observatorii, deci nu apare recursivitate.

Capcana este ultima parte. Observatorii nu se apelează în inițializator: nici în memberwise, nici într-un init propriu. Thermostat(temp: 50) setează direct valoarea, iar limita de 30 nu se aplică. Rezultatul este 50.

Soluții dacă invariantul trebuie respectat mereu:

SWIFT
struct SafeThermostat {
    private(set) var temp: Int
    init(temp: Int) { self.temp = min(temp, 30) }
    mutating func set(_ value: Int) { temp = min(value, 30) }
}

Alternativ, un property wrapper precum @Clamped(0...30) aplică limita și la inițializare, pentru că logica stă în init(wrappedValue:).

Alte detalii utile:

  • Observatorii rulează și când proprietatea este transmisă ca inout, la finalul apelului.
  • La structuri, modificarea unei proprietăți imbricate (t.settings.mode = ...) declanșează didSet pe proprietatea exterioară, pentru că întreaga valoare se consideră schimbată.
  • Nu poți avea observatori pe o proprietate calculată; acolo pui logica direct în set.

Ce urmărește intervievatorul: Verifică ordinea observatorilor și cunoașterea excepției de la inițializare. Aproape toți candidații presupun că limita se aplică și pentru Thermostat(temp: 50).

40 Mid

De ce nu compilează inițializatorul de mai jos? Explică inițializarea în două faze a claselor.

SWIFT
class Vehicle {
    let wheels: Int
    init(wheels: Int) { self.wheels = wheels }
    func describe() -> String { "\(wheels) roți" }
}
class Bike: Vehicle {
    let brand: String
    init(brand: String) {
        print(describe())
        super.init(wheels: 2)
        self.brand = brand
    }
}

Răspuns scurt: În Swift, o subclasă trebuie să-și inițializeze toate proprietățile proprii înainte de super.init, iar self nu poate fi folosit (inclusiv apeluri de metode) până nu se termină prima fază. Aici describe() e apelat prea devreme, iar brand e setat după super.init.

Inițializarea claselor are două faze, iar compilatorul le verifică strict:

Faza 1: fiecare clasă din ierarhie își inițializează proprietățile stocate proprii, de jos în sus. Subclasa setează întâi propriile proprietăți, apoi apelează super.init, care face la fel pentru părinte. În această fază nu poți citi proprietăți, nu poți apela metode și nu poți transmite self mai departe, pentru că obiectul nu este complet.

Faza 2: după ce super.init revine, obiectul este complet inițializat. Acum poți folosi self, apela metode, modifica proprietăți moștenite.

Codul corect:

SWIFT
class Bike: Vehicle {
    let brand: String
    init(brand: String) {
        self.brand = brand          // faza 1: proprietățile proprii
        super.init(wheels: 2)       // urcă în ierarhie
        print(describe())           // faza 2: self e complet
    }
    override func describe() -> String { "\(brand), " + super.describe() }
}
let bike = Bike(brand: "Pegas")    // afișează: Pegas, 2 roți

De ce regula: dacă părintele ar apela în init o metodă suprascrisă de subclasă, aceasta ar putea citi brand înainte să aibă valoare. În Java acest scenariu e posibil și produce valori null neașteptate; Swift îl elimină la compilare.

Legat de subiect:

  • required init obligă toate subclasele să ofere acel inițializator, util când creezi instanțe prin T.Type.
  • O subclasă moștenește automat inițializatorii părintelui doar dacă nu definește niciun inițializator designated propriu și toate proprietățile noi au valori implicite.
  • Un inițializator convenience trebuie să apeleze în final un designated din aceeași clasă.

Ce urmărește intervievatorul: Verifică înțelegerea regulilor de siguranță la inițializare. Mulți candidați cunosc ordinea doar ca regulă de sintaxă, fără să știe problema pe care o previne.

Eroarea, în practică:class 'Angajat' has no initializers'self' used before all properties are initialized

41 Mid

Modelează o expresie aritmetică (număr, adunare, înmulțire) cu un enum și scrie funcția care o evaluează. De ce ai nevoie de indirect?

Răspuns scurt: Un enum cu cazuri care conțin alte expresii (add(Expr, Expr)) este recursiv, iar indirect îi spune compilatorului să stocheze valorile asociate prin referință, ca dimensiunea să fie finită. Evaluarea se face recursiv cu un switch.

Un enum este tip valoare, iar dimensiunea lui trebuie cunoscută la compilare. Dacă un caz conține direct o altă valoare de același tip, dimensiunea ar fi infinită. indirect rezolvă problema: valorile asociate ale cazurilor marcate sunt stocate într-o cutie alocată în heap, iar enum-ul păstrează doar o referință.

SWIFT
indirect enum Expr {
    case number(Int)
    case add(Expr, Expr)
    case multiply(Expr, Expr)
    case negate(Expr)
}

func evaluate(_ e: Expr) -> Int {
    switch e {
    case .number(let n): return n
    case let .add(l, r): return evaluate(l) + evaluate(r)
    case let .multiply(l, r): return evaluate(l) * evaluate(r)
    case .negate(let x): return -evaluate(x)
    }
}

func render(_ e: Expr) -> String {
    switch e {
    case .number(let n): return "\(n)"
    case let .add(l, r): return "(\(render(l)) + \(render(r)))"
    case let .multiply(l, r): return "\(render(l)) * \(render(r))"
    case .negate(let x): return "-\(render(x))"
    }
}

let e = Expr.add(.number(2), .multiply(.number(3), .number(4)))
print(evaluate(e), render(e))   // 14 (2 + 3 * 4)

Poți marca tot enum-ul cu indirect sau doar cazurile recursive: indirect case add(Expr, Expr).

De ce enum și nu o ierarhie de clase: setul de cazuri este închis, iar switch exhaustiv garantează că, dacă adaugi case divide, compilatorul îți cere să actualizezi evaluate și render. Adăugarea unei operații noi (de exemplu simplificarea expresiei) înseamnă doar o funcție nouă. Cu clase, fiecare operație ar fi o metodă în fiecare subclasă.

Aceeași tehnică modelează arbori JSON, arbori de fișiere sau liste înlănțuite imutabile.

Ce urmărește intervievatorul: Este un exercițiu clasic care arată stăpânirea enum-urilor cu valori asociate și a recursivității. Candidații uită indirect sau nu pot explica de ce e necesar.

Eroarea, în practică:recursive enum is not marked 'indirect'

42 Mid

Un ecran are isLoading: Bool, items: [Item] și errorMessage: String?. Ce probleme are acest model de stare și cum l-ai rescrie cu un enum?

Răspuns scurt: Cu trei proprietăți independente pot apărea combinații imposibile, de exemplu încărcare și eroare în același timp. Un enum cu cazurile idle, loading, loaded([Item]) și failed(String) face stările invalide imposibil de reprezentat.

Cu un Bool, un tablou și un opțional ai multe combinații posibile, dar doar câteva au sens. Nimic nu te oprește să ai isLoading == true și errorMessage != nil simultan, sau date vechi afișate lângă o eroare nouă. Fiecare loc din cod care schimbă starea trebuie să-și amintească să reseteze celelalte proprietăți, iar un bug apare când cineva uită.

Cu un enum, starea este întotdeauna exact una:

SWIFT
struct Item { let id: Int; let title: String }

enum LoadState<Value> {
    case idle
    case loading
    case loaded(Value)
    case failed(message: String)
}

struct ScreenModel {
    var state: LoadState<[Item]> = .idle

    var title: String {
        switch state {
        case .idle: return "Apasă pentru încărcare"
        case .loading: return "Se încarcă..."
        case .loaded(let items) where items.isEmpty: return "Nicio sarcină"
        case .loaded(let items): return "\(items.count) sarcini"
        case .failed(let message): return "Eroare: \(message)"
        }
    }
}

Avantaje:

  • Stările invalide nu se pot construi. Datele există doar în loaded, mesajul doar în failed.
  • switch exhaustiv obligă interfața să trateze fiecare stare, inclusiv lista goală.
  • Testele devin simple: verifici că starea este .failed după o eroare simulată.

Variante: dacă vrei să păstrezi datele vechi în timpul reîncărcării, adaugi un caz refreshing([Item]) sau ții datele separat de o stare de încărcare. Ideea nu este „totul într-un enum”, ci ca structura tipului să reflecte regulile reale.

Enum-ul generic LoadState<Value> se reutilizează pe orice ecran, cu orice tip de date.

Ce urmărește intervievatorul: Verifică gândirea de modelare a datelor, foarte prețuită la nivel mid. Candidații slabi adaugă încă un Bool pentru fiecare stare nouă.

43 Mid

Ce afișează codul următor?

SWIFT
final class Settings { var theme = "light" }
struct Profile {
    var name: String
    var settings: Settings
}
var a = Profile(name: "Ana", settings: Settings())
var b = a
b.name = "Dan"
b.settings.theme = "dark"
print(a.name, a.settings.theme)

Răspuns scurt: Afișează Ana dark. Copierea structurii copiază valoarea name, dar pentru proprietatea de tip clasă copiază doar referința, deci a și b împart același obiect Settings.

Când copiezi un struct, fiecare proprietate stocată se copiază după propria semantică. name este String, tip valoare, deci b.name e independent. settings este o clasă, deci se copiază referința, nu obiectul. Rezultatul este o copie superficială: a.settings și b.settings sunt același obiect, iar schimbarea temei prin b se vede și prin a.

Situația apare des când un model „value type” ascunde un obiect mutabil: un formatter, un cache, un NSMutableArray venit din Objective-C. Semantica de valoare a structurii este atunci doar aparentă.

Soluții:

  • Fă și Settings un struct. Este varianta cea mai simplă dacă nu ai nevoie de identitate.
  • Dacă trebuie să rămână clasă, fă-o imutabilă (let theme) și creează un obiect nou la fiecare schimbare.
  • Implementează copy-on-write manual: înainte de modificare, verifici cu isKnownUniquelyReferenced(&storage) dacă referința e unică și, dacă nu, clonezi obiectul.
SWIFT
struct SafeProfile {
    var name: String
    private var storage: Settings
    init(name: String) { self.name = name; storage = Settings() }
    var theme: String {
        get { storage.theme }
        set {
            if !isKnownUniquelyReferenced(&storage) {
                let copy = Settings(); copy.theme = storage.theme
                storage = copy
            }
            storage.theme = newValue
        }
    }
}

Așa funcționează intern și Array, String și Dictionary. Ideea de reținut la interviu: semantica de valoare este proprietatea întregului tip, nu doar a cuvântului struct.

Ce urmărește intervievatorul: Testează înțelegerea copierii superficiale. Candidații care au învățat doar „struct se copiază” presupun că și Settings se copiază.

44 Mid

Scrie un tip Vector2D care suportă +, += și înmulțirea cu un scalar, și un tip Matrix accesibil cu matrix[rând, coloană].

Răspuns scurt: Operatorii se definesc ca funcții static în tip sau într-o extensie, iar += primește operandul stâng ca inout. Accesul cu paranteze pătrate se face cu un subscript cu get și set, care poate avea mai mulți parametri.

În Swift, operatorii sunt funcții statice cu nume special. Le poți supraîncărca pentru tipurile tale:

SWIFT
struct Vector2D: Equatable {
    var x: Double, y: Double

    static func + (l: Vector2D, r: Vector2D) -> Vector2D {
        Vector2D(x: l.x + r.x, y: l.y + r.y)
    }
    static func * (v: Vector2D, k: Double) -> Vector2D {
        Vector2D(x: v.x * k, y: v.y * k)
    }
    static func += (l: inout Vector2D, r: Vector2D) { l = l + r }
    static prefix func - (v: Vector2D) -> Vector2D { Vector2D(x: -v.x, y: -v.y) }
}

var position = Vector2D(x: 1, y: 2)
position += Vector2D(x: 3, y: 0) * 2
print(position, -position == Vector2D(x: -7, y: -2))   // Vector2D(x: 7.0, y: 2.0) true

Subscript-ul definește ce înseamnă instanță[...]:

SWIFT
struct Matrix {
    let rows: Int, cols: Int
    private var data: [Double]

    init(rows: Int, cols: Int) {
        self.rows = rows; self.cols = cols
        data = Array(repeating: 0, count: rows * cols)
    }
    subscript(row: Int, col: Int) -> Double {
        get {
            precondition(row < rows && col < cols, "index în afara matricei")
            return data[row * cols + col]
        }
        set { data[row * cols + col] = newValue }
    }
}
var m = Matrix(rows: 2, cols: 2)
m[1, 0] = 5
print(m[1, 0])   // 5.0

Stocarea într-un singur tablou plat este mai eficientă decât [[Double]]. Subscripturile pot avea etichete (subscript(safe i: Int)) și pot fi generice.

Poți declara și operatori noi cu infix operator, legați de un grup de precedență. Folosește-i cu măsură: un operator + pentru vectori e natural, dar simboluri inventate fac codul greu de citit pentru colegi.

Ce urmărește intervievatorul: Verifică dacă știi să faci tipurile proprii naturale de folosit. Candidații uită de inout la += sau de newValue în setter-ul subscriptului.

Eroarea, în practică:operator declared in type must be 'static'

45 Senior

Explică tipurile de dispatch din Swift (static, prin tabelă, prin mesaj). Care se folosește pentru un struct, pentru o clasă, pentru o clasă final și pentru o cerință de protocol?

Răspuns scurt: Metodele structurilor, ale claselor final și cele din extensii (fără @objc) sunt apelate static. Metodele de clasă suprascriibile folosesc o tabelă virtuală, cerințele de protocol prin existențiale folosesc witness tables, iar @objc dynamic folosește message dispatch.

Dispatch înseamnă modul în care programul decide ce implementare rulează pentru un apel.

  • Static (direct): adresa funcției este cunoscută la compilare. Permite inlining. Se aplică metodelor de struct și enum, metodelor final sau private, metodelor din extensii pe clase Swift și funcțiilor libere.
  • Tabelă virtuală (vtable): fiecare clasă are o tabelă cu pointeri la implementările metodelor suprascriibile. Apelul citește intrarea din tabelă la rulare. Costă o indirectare și blochează inlining-ul.
  • Witness table: când apelezi o cerință de protocol pe o valoare any P sau într-un generic nespecializat, apelul trece prin tabela de conformitate a tipului concret. În cod generic specializat, compilatorul poate transforma apelul în static.
  • Message dispatch: pentru membri @objc dynamic, apelul trece prin runtime-ul Objective-C (objc_msgSend). Este cel mai flexibil (permite method swizzling și KVO) și cel mai lent.
SWIFT
protocol Greeter { func greet() -> String }
extension Greeter { func wave() -> String { "salut" } }   // nu e cerință: static

final class FastGreeter: Greeter {
    func greet() -> String { "bună" }    // static când tipul e cunoscut
}
class OpenGreeter: Greeter {
    func greet() -> String { "hei" }     // vtable: poate fi suprascrisă
}

Consecințe practice:

  • final și private ajută compilatorul să elimine indirectările. Cu Whole Module Optimization (implicit în Release), compilatorul deduce singur că o clasă internal fără subclase poate fi tratată ca final.
  • Metodele adăugate doar în extensia de protocol, nedeclarate în protocol, sunt dispatch-uite static după tipul declarat, ceea ce poate surprinde când tipul concret are o metodă cu același nume.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismelor de sub limbaj, specifică nivelului senior. Candidații știu de obicei „struct e mai rapid”, dar nu pot explica de ce.

Protocoale, extensii și generice

46 Junior

Cum faci ca print(money) să afișeze 347 lei pentru un tip propriu? De ce se adaugă des conformitățile în extensii separate?

Răspuns scurt: Implementezi CustomStringConvertible cu proprietatea description. Conformitățile se pun în extensii ca să grupezi codul pe responsabilități și ca să poți adăuga protocoale și la tipuri pe care nu le-ai scris tu.

print și interpolarea folosesc description dacă tipul respectă CustomStringConvertible:

SWIFT
struct Money {
    let amount: Int
    let currency: String
}

extension Money: CustomStringConvertible {
    var description: String { "\(amount) \(currency)" }
}

extension Money: Comparable {
    static func < (l: Money, r: Money) -> Bool {
        precondition(l.currency == r.currency, "monede diferite")
        return l.amount < r.amount
    }
}

let price = Money(amount: 347, currency: "lei")
print(price)                   // 347 lei
print("Total: \(price)")       // Total: 347 lei

Pentru depanare există și CustomDebugStringConvertible, folosit de debugPrint și de debugger.

Motivele pentru care conformitățile stau în extensii:

  • Organizare: fiecare extensie grupează codul unui protocol. Se citește ușor și se poate pune în fișiere separate.
  • Conformitate retroactivă: poți face tipuri din biblioteca standard sau din alte module să respecte protocoalele tale, de exemplu extension Int: Scorable.
  • Conformitate condiționată: extension Array: Scorable where Element: Scorable.

Limitări: o extensie nu poate adăuga proprietăți stocate și nici nu poate suprascrie metode existente.

Din Swift 6 (SE-0364), compilatorul avertizează când un tip străin primește conformitatea la un protocol străin, de exemplu extension Date: Identifiable cu ambele din alte module. Riscul este ca biblioteca să adauge mai târziu aceeași conformitate și să apară un conflict. Dacă alegi conștient, marchezi cu @retroactive.

Ce urmărește intervievatorul: Este o întrebare de bază despre protocoale și extensii. Greșeala tipică este încercarea de a adăuga proprietăți stocate într-o extensie.

47 Junior

Scrie un tip Version care compară corect versiuni ca "1.2.10" și "1.10". De ce compararea directă a textelor nu e suficientă?

Răspuns scurt: Desparți textul în numere și le compari pe rând, completând cu zero componentele lipsă, prin implementarea lui Comparable. Compararea textelor merge caracter cu caracter și ar spune greșit că "1.2.10" este mai mare decât "1.10".

Textele se compară lexicografic: la "1.2.10" vs "1.10", primul caracter diferit este 2 față de 1, deci textul spune că 1.2.10 e mai mare. Numeric, a doua componentă e 2 față de 10, deci 1.2.10 e mai mică.

Implementarea lui Comparable cere doar operatorul <. Restul (>, <=, max(), sorted()) vin gratuit:

SWIFT
struct Version: Comparable, CustomStringConvertible {
    let parts: [Int]

    init(_ text: String) {
        var p = text.split(separator: ".").map { Int($0) ?? 0 }
        while p.count > 1, p.last == 0 { p.removeLast() }   // 1.0.0 == 1
        parts = p
    }

    static func < (l: Version, r: Version) -> Bool {
        for i in 0..<max(l.parts.count, r.parts.count) {
            let a = i < l.parts.count ? l.parts[i] : 0
            let b = i < r.parts.count ? r.parts[i] : 0
            if a != b { return a < b }
        }
        return false
    }

    var description: String { parts.map(String.init).joined(separator: ".") }
}

print("1.2.10" > "1.10")                        // true (greșit)
print(Version("1.2.10") > Version("1.10"))      // false (corect)
print(Version("2.0") == Version("2"))           // true
print(["1.10", "1.2", "1.9.1"].map(Version.init).max()!)   // 1.10

Detaliu important: == este sintetizat din parts. Fără normalizarea zerourilor de la final, Version("2.0") și Version("2") ar fi diferite la ==, dar niciuna mai mică decât cealaltă la <, deci operatorii ar fi inconsecvenți. Normalizarea în init aliniază cele două definiții.

Pentru producție ai trata și sufixe ca -beta.1 după regulile Semantic Versioning, dar pentru interviu ideea principală este conversia în numere și contractul Comparable.

Ce urmărește intervievatorul: Este un exercițiu practic de interviu care verifică Comparable și cazurile de margine. Candidații nu observă des inconsecvența dintre == și <.

48 Junior

Când sintetizează compilatorul automat Equatable și Hashable? Ce regulă trebuie respectată dacă le implementezi manual?

Răspuns scurt: Compilatorul le sintetizează pentru structuri cu toate proprietățile stocate conforme și pentru enum-uri cu valori asociate conforme, dacă declari protocolul. Enum-urile fără valori asociate le au automat. La implementare manuală, două valori egale trebuie să aibă același hash.

Reguli de sinteză:

  • struct: declari Equatable sau Hashable, iar compilatorul generează implementarea dacă toate proprietățile stocate respectă protocolul. Compararea se face proprietate cu proprietate.
  • enum fără valori asociate: este automat Equatable și Hashable, fără nicio declarație.
  • enum cu valori asociate: declari protocolul, iar toate valorile asociate trebuie să-l respecte.
  • class: nu există sinteză. Implementezi manual, pentru că egalitatea claselor implică decizii despre moștenire și identitate.

Implementarea manuală apare când nu toate proprietățile contează pentru egalitate, de exemplu o entitate identificată prin id:

SWIFT
struct Customer: Hashable {
    let id: Int
    var name: String
    var lastSeen: Double

    static func == (l: Customer, r: Customer) -> Bool { l.id == r.id }
    func hash(into hasher: inout Hasher) { hasher.combine(id) }
}

var set: Set = [Customer(id: 1, name: "Ana", lastSeen: 0)]
set.insert(Customer(id: 1, name: "Ana M.", lastSeen: 5))
print(set.count)   // 1

Regula de aur: dacă a == b, atunci a.hashValue == b.hashValue. Invers nu e obligatoriu, coliziunile sunt permise. Dacă ai fi scris == după id, dar ai fi lăsat hash sintetizat din toate proprietățile, două clienți egali ar putea ajunge în poziții diferite din Set și ar apărea duplicate.

Alte detalii: nu implementa hashValue direct, care este depreciat; folosești hash(into:). Valorile hash diferă între rulări ale programului, deci nu le salva pe disc. Și nu modifica proprietățile folosite în hash cât timp obiectul se află într-un Set sau e cheie de dicționar.

Ce urmărește intervievatorul: Verifică dacă știi ce oferă compilatorul gratuit și contractul dintre == și hash. Greșeala frecventă este un == personalizat cu hash sintetizat.

Eroarea, în practică:'==' cannot be applied to two 'Produs' operands

49 Junior

De ce ai scrie o funcție generică firstDuplicate<T: Hashable>(in:) în loc de una care primește [Any]? Implementeaz-o.

Răspuns scurt: Genericele păstrează tipul real al elementelor: compilatorul verifică cerințele (Hashable), rezultatul are tipul corect fără cast-uri, iar codul poate fi specializat pentru performanță. Cu [Any] ai pierde tipul și nu ai putea nici măcar compara elementele.

Any poate ține orice valoare, dar nu știe nimic despre ea. Nu poți compara două Any cu == și nu le poți pune într-un Set. Ar trebui să faci cast-uri la rulare (as? Int), iar rezultatul ar fi tot Any, deci apelantul ar trebui să facă alt cast.

O funcție generică lucrează cu un tip substituent T, ales de apelant. Constrângerea T: Hashable spune ce operații sunt permise:

SWIFT
func firstDuplicate<T: Hashable>(in items: [T]) -> T? {
    var seen = Set<T>()
    for item in items {
        if !seen.insert(item).inserted { return item }
    }
    return nil
}

if let d = firstDuplicate(in: [3, 1, 4, 1, 5]) { print(d) }   // 1
print(firstDuplicate(in: ["ana", "dan", "ana"]) ?? "-")      // ana
print(firstDuplicate(in: [2.5, 3.5]) == nil)                 // true

Avantaje față de Any:

  • Siguranță la compilare: dacă transmiți un tip care nu e Hashable, eroarea apare imediat, nu la rulare.
  • Tip păstrat: pentru [Int] întoarce Int?, pentru [String] întoarce String?. Fără cast-uri.
  • Performanță: compilatorul poate genera versiuni specializate pentru Int sau String, fără cutii (boxing) și fără apeluri dinamice.
  • Documentație: semnătura spune exact ce cere funcția.

Biblioteca standard este construită pe generice: Array<Element>, Dictionary<Key, Value>, Optional<Wrapped>, map<T>.

Any rămâne util la granițe cu adevărat eterogene, de exemplu pentru valori dintr-un JSON netipizat sau pentru userInfo din notificări. În restul codului, genericele sau protocoalele cu some sau any sunt alegerea corectă.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce există genericele. Candidații juniori folosesc des Any și cast-uri forțate din comoditate.

50 Junior

Implementează o stivă generică Stack<Element> și folosește-o ca să verifici dacă parantezele dintr-un text sunt echilibrate.

Răspuns scurt: Stack este un struct generic care ține elementele într-un tablou privat și expune push, pop și peek, toate O(1) amortizat. Pentru paranteze, pui pe stivă fiecare deschidere și, la fiecare închidere, verifici că elementul scos se potrivește.

Un tip generic se declară cu parametrul de tip între paranteze unghiulare. Folosirea unui tablou ca stocare face push și pop O(1) amortizat, pentru că lucrezi mereu la coadă:

SWIFT
struct Stack<Element> {
    private var items: [Element] = []

    var isEmpty: Bool { items.isEmpty }
    var peek: Element? { items.last }

    mutating func push(_ item: Element) { items.append(item) }

    @discardableResult
    mutating func pop() -> Element? { items.popLast() }
}

func isBalanced(_ text: String) -> Bool {
    let pairs: [Character: Character] = [")": "(", "]": "[", "}": "{"]
    let openers = Set(pairs.values)
    var stack = Stack<Character>()
    for ch in text {
        if openers.contains(ch) {
            stack.push(ch)
        } else if let expected = pairs[ch] {
            if stack.pop() != expected { return false }
        }
    }
    return stack.isEmpty
}

print(isBalanced("f(a[1]) { x }"))   // true
print(isBalanced("(]"))              // false
print(isBalanced("(("))              // false

Decizii de design de explicat:

  • struct, nu class: stiva are semantică de valoare, deci o copie nu afectează originalul.
  • items este private, ca nimeni să nu ocolească regulile stivei.
  • pop() întoarce opțional în loc să crape pe stiva goală. @discardableResult permite apelul fără folosirea rezultatului.
  • Metodele care modifică sunt mutating.

În isBalanced, stack.pop() != expected compară un Character? cu un Character. Valoarea neopțională este promovată automat, iar o stivă goală dă nil, deci inegalitate și false. La final, stiva trebuie să fie goală, altfel au rămas paranteze nedeschise.

Extensii posibile: extension Stack: Sequence pentru parcurgere sau extension Stack: Equatable where Element: Equatable.

Ce urmărește intervievatorul: Combină un tip generic cu un algoritm clasic de interviu. Greșelile tipice sunt uitarea lui mutating și omiterea verificării finale isEmpty.

51 Junior

Care dintre tipurile de mai jos respectă protocoalele? Ce înseamnă { get } și { get set } într-un protocol?

SWIFT
protocol Named { var name: String { get } }
protocol Counter { var count: Int { get set } }

struct A: Named { let name: String }
struct B: Named { var name: String { "calculat" } }
struct C: Counter { let count: Int }
struct D: Counter { var count: Int }

Răspuns scurt: A, B și D respectă protocoalele, C nu. { get } cere cel puțin citire, deci acceptă let, var sau o proprietate calculată; { get set } cere și scriere, deci nu acceptă let sau o proprietate calculată doar cu getter.

Într-un protocol, proprietățile se declară mereu cu var și cu accesul minim cerut, nu cu modul de stocare.

  • { get }: tipul trebuie să permită citirea. Poate fi o constantă let (A), o proprietate calculată (B) sau o var stocată. Faptul că A.name e let nu încalcă nimic.
  • { get set }: tipul trebuie să permită și citirea, și scrierea. C declară let count, deci nu se poate scrie, iar compilatorul refuză conformitatea. D cu var este corect, la fel și o proprietate calculată cu get și set.

Un detaliu des întrebat: dacă accesezi o valoare prin tipul protocolului, vezi doar ce cere protocolul.

SWIFT
var b = B()
let named: any Named = A(name: "Ana")
// named.name = "Dan"      // eroare: protocolul cere doar get

var counter: any Counter = D(count: 1)
counter.count += 1          // ok: get set
print(counter.count)        // 2

Alte reguli pentru cerințe:

  • Metodele care modifică un struct trebuie declarate mutating în protocol. O clasă le implementează fără mutating.
  • Cerințele static se declară cu static, iar o clasă le poate implementa cu class ca să permită suprascrierea.
  • Un protocol nu poate cere ca proprietatea să fie stocată sau să aibă o valoare implicită; asta ține de tipul concret.
  • Poți cere async sau throws pe proprietăți doar-citire: var data: Data { get async throws }.

Gândit așa, protocolul descrie o interfață, nu o implementare, iar fiecare tip alege cum o satisface.

Ce urmărește intervievatorul: Verifică înțelegerea cerințelor de proprietăți. Candidații cred des că { get } cere o proprietate calculată sau că let nu poate satisface un protocol.

Eroarea, în practică:type does not conform to protocolproperty in protocol must have explicit { get }

52 Mid

Scrie o metodă average() disponibilă pe orice colecție de numere zecimale și fă o structură generică Pair<T> comparabilă cu == doar când T este Equatable.

Răspuns scurt: Folosești o extensie constrânsă: extension Collection where Element: BinaryFloatingPoint. Pentru Pair, declari conformitate condiționată: extension Pair: Equatable where T: Equatable {}, iar compilatorul sintetizează ==.

O extensie constrânsă adaugă metode doar pentru tipurile care îndeplinesc o condiție. Toate colecțiile primesc metoda, cu condiția ca elementele să fie numere zecimale:

SWIFT
extension Collection where Element: BinaryFloatingPoint {
    func average() -> Element? {
        guard !isEmpty else { return nil }
        return reduce(0, +) / Element(count)
    }
}

print([2.0, 4.0, 9.0].average() ?? 0)        // 5.0
print(Set<Float>([1, 2]).average() ?? 0)     // 1.5
print([Double]().average() as Any)            // nil
// [1, 2, 3].average()                       // eroare: Int nu e BinaryFloatingPoint

Metoda apare pe Array, Set, ArraySlice și orice altă colecție, pentru că extensia este pe protocolul Collection, nu pe un tip anume. Element(count) convertește numărul de elemente, pentru că BinaryFloatingPoint oferă un inițializator din orice întreg.

Conformitatea condiționată (Swift 4.1) face un tip generic să respecte un protocol doar pentru anumite argumente:

SWIFT
struct Pair<T> {
    var first: T
    var second: T
}
extension Pair: Equatable where T: Equatable {}
extension Pair: Hashable where T: Hashable {}

print(Pair(first: 1, second: 2) == Pair(first: 1, second: 2))   // true

Un Pair de obiecte care nu sunt Equatable se poate crea, dar nu se poate compara. Biblioteca standard folosește același mecanism: Array este Equatable doar dacă Element este, iar Optional este Hashable doar dacă Wrapped este.

Diferența dintre cele două: extensia constrânsă adaugă metode, conformitatea condiționată adaugă un protocol, cu tot ce vine odată cu el (de exemplu Pair poate deveni cheie de dicționar).

Ce urmărește intervievatorul: Arată dacă poți scrie cod generic reutilizabil. Candidații scriu de obicei extensia doar pe Array where Element == Double, care e mult mai restrictivă.

53 Mid

Ce face cerința init() într-un protocol și de ce compilatorul cere required când o clasă o implementează?

SWIFT
protocol Configurable { init() }

class Cache: Configurable {
    init() {}
}

func build<T: Configurable>(_ type: T.Type) -> T { T() }

Răspuns scurt: Cerința init() permite codului generic să creeze instanțe cu T(). O clasă nefinală trebuie să-l marcheze required, ca toate subclasele să-l ofere; altfel build(SubCache.self) nu ar avea cum să construiască o subclasă.

Protocoalele pot cere inițializatori, metode statice și tipul Self. Asta permite funcții generice care construiesc valori fără să știe tipul concret:

SWIFT
protocol Configurable {
    init()
    static var defaultName: String { get }
}

final class Logger: Configurable {
    init() {}                                  // final: nu e nevoie de required
    static var defaultName: String { "logger" }
}

class Cache: Configurable {
    required init() {}
    class var defaultName: String { "cache" }  // class: poate fi suprascrisă
}

class DiskCache: Cache {
    required init() { super.init() }
    override class var defaultName: String { "disk" }
}

func build<T: Configurable>(_ type: T.Type) -> T {
    print("Construiesc \(T.defaultName)")
    return T()
}

let c = build(DiskCache.self)   // Construiesc disk

De ce required: conformitatea la Configurable se moștenește. DiskCache este și el Configurable, deci build(DiskCache.self) trebuie să poată apela DiskCache(). Dacă subclasa ar putea să nu aibă init(), garanția s-ar rupe. required obligă fiecare subclasă să ofere inițializatorul, explicit sau prin moștenire automată.

Pentru struct, enum sau clase final nu există subclase, deci required nu e necesar.

Metodele care întorc Self funcționează pe același principiu:

SWIFT
protocol Cloneable { func clone() -> Self }

O clasă care implementează clone() trebuie să întoarcă tipul dinamic, de obicei prin type(of: self).init(), ceea ce necesită tot un required init.

Situații practice: fabrici generice, deserializare, crearea de mock-uri în teste și registre de dependențe.

Ce urmărește intervievatorul: Testează legătura dintre protocoale, generice și moștenire. Candidații adaugă required doar pentru că cere compilatorul, fără să știe motivul.

Eroarea, în practică:'required' initializer must be provided by subclassinit requirement needs a 'required' initializer

54 Mid

Ce înseamnă protocol Entity: Identifiable, Codable și ce înseamnă un parametru de tip some Identifiable & Codable? Ce se întâmplă dacă două protocoale oferă implementări implicite pentru aceeași metodă?

Răspuns scurt: Primul este moștenire de protocoale: orice tip Entity trebuie să respecte și Identifiable și Codable. Al doilea este compunere ad-hoc, cerută doar într-un loc. Dacă două extensii oferă aceeași metodă, apelul devine ambiguu și tipul trebuie să o implementeze explicit.

Moștenirea de protocoale creează un protocol nou care include cerințele altora și poate adăuga cerințe proprii:

SWIFT
protocol Entity: Identifiable, Codable where ID == Int {
    var updatedAt: Double { get }
}

struct Note: Entity {
    let id: Int
    var text: String
    var updatedAt: Double
}

Clauza where ID == Int restrânge tipul asociat al lui Identifiable.

Compunerea cu & combină protocoale fără să le dai un nume. E utilă când o funcție are nevoie de o combinație rară:

SWIFT
func save(_ item: some Identifiable & Codable) { /* encodează și salvează după id */ }
typealias Persistable = Identifiable & Codable

Codable însuși este doar un alias: Encodable & Decodable.

Când preferi unul sau altul: dacă combinația are un sens propriu în domeniu și apare des, dă-i nume (Entity). Dacă e doar o cerință tehnică a unei funcții, compunerea este suficientă și nu creează încă un protocol de întreținut.

Conflictul de implementări implicite:

SWIFT
protocol Walker { func move() -> String }
protocol Swimmer { func move() -> String }
extension Walker { func move() -> String { "merge" } }
extension Swimmer { func move() -> String { "înoată" } }

struct Duck: Walker, Swimmer {
    func move() -> String { "merge și înoată" }   // obligatoriu
}

Fără implementarea din Duck, compilatorul nu poate alege și raportează că tipul nu respectă protocoalele. Spre deosebire de moștenirea multiplă din C++, Swift nu are reguli implicite de prioritate, deci rezolvarea e mereu explicită. Dacă unul dintre protocoale îl moștenește pe celălalt, se alege implementarea din protocolul mai specific.

Ce urmărește intervievatorul: Verifică dacă știi să combini protocoale fără ierarhii inutile. Puțini candidați știu ce se întâmplă la conflictul de implementări implicite.

55 Mid

Ai o ierarhie de clase Bird cu metoda fly(), iar acum trebuie adăugat un pinguin, care nu zboară, și o rață, care și înoată. Cum ai rescrie modelul cu programare orientată pe protocoale?

Răspuns scurt: Desparți capabilitățile în protocoale mici (Flying, Swimming), cu implementări implicite în extensii, și le compui pe tipuri struct. Fiecare tip ia doar comportamentele pe care le are, fără metode moștenite care nu au sens.

Moștenirea forțează o singură ierarhie. Dacă Bird are fly(), pinguinul o moștenește și trebuie să o suprascrie cu o eroare sau cu o metodă goală, încălcând principiul substituției Liskov: codul care primește un Bird se așteaptă să poată zbura. Rața ar avea nevoie de două ierarhii, imposibil la clase.

Programarea orientată pe protocoale (POP) pornește de la capabilități:

SWIFT
protocol Animal { var name: String { get } }
protocol Flying { var maxAltitude: Int { get } }
protocol Swimming { var maxDepth: Int { get } }

extension Flying {
    func fly() -> String { "zbor până la \(maxAltitude) m" }
}
extension Swimming {
    func swim() -> String { "înot până la \(maxDepth) m" }
}

struct Sparrow: Animal, Flying { let name = "vrabie"; let maxAltitude = 100 }
struct Penguin: Animal, Swimming { let name = "pinguin"; let maxDepth = 200 }
struct Duck: Animal, Flying, Swimming {
    let name = "rață"; let maxAltitude = 300; let maxDepth = 5
}

func launch(_ flyers: [any Flying]) { flyers.forEach { print($0.fly()) } }
launch([Sparrow(), Duck()])     // pinguinul nici nu poate fi transmis

Avantaje:

  • Tipurile pot fi struct, cu semantică de valoare.
  • Compui oricâte capabilități, fără ierarhii adânci.
  • Compilatorul garantează că launch primește doar ce zboară.

Limite: protocoalele nu au stare stocată, deci datele se repetă în fiecare tip, iar prea multe protocoale mici fragmentează codul. Clasele rămân potrivite când ai nevoie de identitate, stare partajată sau integrare cu framework-uri bazate pe moștenire, cum ar fi UIKit.

Ce urmărește intervievatorul: Verifică gândirea de design dincolo de sintaxă. Candidații cunosc des termenul POP, dar nu pot arăta concret ce problemă rezolvă față de moștenire.

56 Mid

Ce sunt primary associated types (Swift 5.7) și ce înseamnă some Collection<Int>? Cum declari un protocol propriu care le folosește?

Răspuns scurt: Un protocol își poate declara tipul asociat principal între paranteze unghiulare, de exemplu protocol Store<Item>. Atunci poți scrie some Collection<Int> sau any Store<String>, fixând tipul elementelor fără o clauză where și fără generic explicit.

Înainte de Swift 5.7, ca să ceri „orice colecție de Int”, scriai o funcție generică cu clauză where:

SWIFT
func sumOld<C: Collection>(_ values: C) -> Int where C.Element == Int {
    values.reduce(0, +)
}

Propunerea SE-0346 a introdus primary associated types. Biblioteca standard le declară pentru protocoale ca Sequence<Element> și Collection<Element>, așa că poți scrie:

SWIFT
func sum(_ values: some Collection<Int>) -> Int {
    values.reduce(0, +)
}
print(sum([1, 2, 3]), sum(Set([4, 5])), sum(1...10))   // 6 9 55

func evens(upTo n: Int) -> some Sequence<Int> {
    stride(from: 0, through: n, by: 2)
}

Parametrul some Collection<Int> este echivalent cu genericul de mai sus. La tipul întors, apelantul știe că primește o secvență de Int, fără să afle tipul concret (StrideThrough<Int>).

Pentru protocoalele tale:

SWIFT
protocol Store<Item> {
    associatedtype Item
    func all() -> [Item]
    mutating func add(_ item: Item)
}

struct MemoryStore<Item>: Store {
    private var items: [Item] = []
    func all() -> [Item] { items }
    mutating func add(_ item: Item) { items.append(item) }
}

var notes: any Store<String> = MemoryStore<String>()
notes.add("cumpără lapte")
print(notes.all())    // ["cumpără lapte"]

any Store<String> este un existențial constrâns: poate ține orice store de texte, iar metodele care folosesc Item sunt disponibile cu tipul concret String.

Alege ca tip principal asociatul pe care utilizatorii îl constrâng cel mai des. Un protocol poate avea mai multe tipuri asociate, dar de obicei doar unul sau două sunt principale.

Ce urmărește intervievatorul: Verifică familiaritatea cu Swift modern. Candidații care au învățat din materiale mai vechi nu cunosc sintaxa și scriu clauze where lungi.

57 Senior

De ce nu compilează funcția de mai jos? Ce garantează some la tipul întors și cum ai rezolva?

SWIFT
protocol Shape { func area() -> Double }
struct Circle: Shape { var r: Double; func area() -> Double { .pi * r * r } }
struct Square: Shape { var side: Double; func area() -> Double { side * side } }

func makeShape(round: Bool) -> some Shape {
    if round { return Circle(r: 1) }
    return Square(side: 1)
}

Răspuns scurt: Un tip întors some Shape înseamnă un singur tip concret, fix, ales de funcție și ascuns apelantului. Aici ramurile întorc tipuri diferite, deci compilatorul refuză. Soluțiile sunt any Shape, un enum care învelește cazurile sau un tip comun.

Un tip opac (some P la valoarea întoarsă) este un „generic invers”. La un generic obișnuit, apelantul alege tipul. La un tip opac, funcția îl alege, iar compilatorul îl cunoaște exact, dar îl ascunde de apelant. Condiția este ca tipul să fie același la fiecare apel. Aici o ramură întoarce Circle, alta Square, iar eroarea spune că instrucțiunile return nu au același tip de bază.

De ce există restricția: compilatorul păstrează identitatea tipului. Două apeluri ale aceleiași funcții întorc garantat același tip, ceea ce permite operații imposibile cu existențiale:

SWIFT
func unitSquare() -> some Shape & Equatable { Square(side: 1) }
extension Square: Equatable {}
print(unitSquare() == unitSquare())   // true: același tip ascuns

Cu any Shape & Equatable, compararea ar fi imposibilă direct, pentru că cele două valori ar putea avea tipuri diferite.

Rezolvări pentru exemplul inițial:

SWIFT
func makeAnyShape(round: Bool) -> any Shape {
    round ? Circle(r: 1) : Square(side: 1)     // existențial: tipul se decide la rulare
}

enum AnyKindShape: Shape {
    case circle(Circle), square(Square)
    func area() -> Double {
        switch self {
        case .circle(let c): return c.area()
        case .square(let s): return s.area()
        }
    }
}
func makeShape(round: Bool) -> some Shape {
    round ? AnyKindShape.circle(Circle(r: 1)) : .square(Square(side: 1))
}

any e cel mai simplu, cu un mic cost de stocare indirectă și dispatch dinamic. Enum-ul păstrează un tip concret unic. SwiftUI folosește tipuri opace la body tocmai ca tipurile lungi ale ierarhiei de view-uri să nu fie scrise de mână, iar ramurile if sunt unificate de result builder într-un tip condițional.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a tipurilor opace dincolo de diferența teoretică dintre some și any. Greșeala tipică este credința că some înseamnă „orice tip care respectă protocolul”.

Eroarea, în practică:opaque return type: no matching underlying types

58 Senior

Poți transmite un any Shape unei funcții generice func describe<T: Shape>(_ s: T)? Ce cost are un existențial any față de un generic?

Răspuns scurt: Da, din Swift 5.7 existențialul este „deschis” implicit (SE-0352): compilatorul extrage tipul concret și apelează genericul. Un existențial costă stocare într-un container cu buffer mic sau alocare în heap și apeluri dinamice prin witness table, fără specializare.

Un existențial any Shape este o cutie care poate conține orice tip conform. Intern, este un container cu un buffer inline de trei cuvinte, un pointer la metadatele tipului și un pointer la witness table pentru Shape. Valorile mici încap în buffer; cele mai mari sunt alocate în heap. Fiecare apel de metodă trece prin witness table.

Înainte de Swift 5.7, nu puteai transmite un any Shape unei funcții <T: Shape>. Deschiderea implicită a existențialelor (SE-0352) rezolvă: la apel, compilatorul scoate valoarea din cutie, îi află tipul dinamic și apelează genericul cu el.

SWIFT
protocol Shape { func area() -> Double }
struct Circle: Shape { var r: Double; func area() -> Double { 3.14 * r * r } }
struct Square: Shape { var side: Double; func area() -> Double { side * side } }

func describe<T: Shape>(_ s: T) -> String { "\(T.self): \(s.area())" }

let shapes: [any Shape] = [Circle(r: 1), Square(side: 2)]
for s in shapes { print(describe(s)) }
// Circle: 3.14
// Square: 4.0

Comparația de cost:

  • Generic sau some: tipul e cunoscut static. Compilatorul poate genera o versiune specializată, apelurile devin directe și pot fi inline, iar valorile nu se ambalează.
  • any: flexibilitate la rulare (colecții eterogene, valori schimbate dinamic), cu prețul indirectării și, uneori, al alocării.

Recomandarea curentă: folosește implicit some sau generice și treci la any doar când ai nevoie de eterogenitate. Cuvântul any a devenit obligatoriu pentru protocoale cu tipuri asociate din 5.7; pentru celelalte protocoale este încă opțional în Swift 6, dar poate fi impus cu feature-ul ExistentialAny.

Ce urmărește intervievatorul: Testează înțelegerea modelului de execuție al protocoalelor, relevant pentru performanță. Candidații folosesc des any peste tot, fără să știe că generic ar fi mai eficient.

Eroarea, în practică:type 'any Forma' cannot conform to 'Forma'

ARC și durata de viață a obiectelor

Exersează capitolul cu exerciții reale: Curs Swift online →
59 Junior

Ce afișează codul următor și în ce ordine?

SWIFT
class Session {
    let name: String
    init(name: String) { self.name = name; print("init \(name)") }
    deinit { print("deinit \(name)") }
}
var s: Session? = Session(name: "A")
s = Session(name: "B")
print("gata")
s = nil

Răspuns scurt: Afișează init A, init B, deinit A, gata, deinit B. Obiectul nou este creat înainte de atribuire, iar obiectul vechi este eliberat imediat după ce pierde ultima referință puternică.

Pașii, urmărind numărul de referințe puternice (strong):

1. Session(name: "A") creează obiectul A și afișează init A. s îl referă: A are o referință. 2. La s = Session(name: "B"), partea dreaptă se evaluează întâi, deci apare init B. 3. Atribuirea înlocuiește referința din s. A rămâne fără nicio referință, iar ARC îl eliberează imediat, deci deinit A. 4. Se afișează gata. 5. s = nil elimină ultima referință la B: deinit B.

Asta este diferența practică dintre ARC și un garbage collector: eliberarea este deterministă și se întâmplă imediat după ce dispare ultima referință puternică, nu „cândva mai târziu”.

deinit este util pentru:

  • verificarea în dezvoltare că un ecran sau un view model chiar se eliberează (un print în deinit este primul test pentru un leak);
  • eliberarea resurselor: oprirea unui timer, închiderea unui fișier, anularea unui task.

Reguli despre deinit: există doar la clase și actori, nu primește parametri, nu se apelează manual și rulează automat și pentru clasele părinte, după cel al subclasei.

Atenție la variabilele locale în build-urile optimizate: compilatorul poate elibera un obiect imediat după ultima lui folosire, nu neapărat la finalul blocului. Pentru variabile globale, ca în exemplu, ordinea este cea descrisă.

Ce urmărește intervievatorul: Verifică dacă înțelegi momentul exact al eliberării sub ARC. Greșeala frecventă este să crezi că A se eliberează abia la finalul programului.

60 Junior

Câte referințe puternice există după fiecare linie și când se afișează deinit X?

SWIFT
var a: Session? = Session(name: "X")
var b = a
var c = b
a = nil
b = nil
print("încă există")
c = nil

Răspuns scurt: După primele trei linii există trei referințe puternice. După a = nil și b = nil rămâne una, deci obiectul trăiește și apare încă există. Abia la c = nil contorul ajunge la zero și se afișează deinit X.

ARC (Automatic Reference Counting) ține pentru fiecare obiect un contor de referințe puternice. Fiecare variabilă, constantă, proprietate sau captură într-un closure care referă obiectul cu strong (implicit) crește contorul; fiecare referință care dispare sau e suprascrisă îl scade. Când contorul ajunge la zero, obiectul este eliberat și deinit rulează.

Urmărirea exemplului:

  • var a = Session(...): contor 1.
  • var b = a: se copiază referința, nu obiectul. Contor 2.
  • var c = b: contor 3.
  • a = nil: contor 2.
  • b = nil: contor 1. Obiectul e încă viu, apare încă există.
  • c = nil: contor 0, apare deinit X.

Cele trei variabile sunt de tip Session?. Atribuirea lui nil doar elimină referința; nu distruge obiectul cât timp altcineva îl mai ține.

Referințele pot veni și din locuri mai puțin evidente:

SWIFT
var registry: [Session] = []
var d: Session? = Session(name: "Y")
registry.append(d!)      // tabloul ține o referință puternică
d = nil                  // fără deinit: registry încă îl ține
registry.removeAll()     // deinit Y

Colecțiile, closure-urile stocate, timerele, notificările și task-urile pot păstra obiecte în viață. De aceea, când un obiect nu se eliberează, întrebarea este „cine mai ține o referință puternică la el?”.

Referințele weak și unowned nu cresc contorul puternic, deci nu împiedică eliberarea. Pe ele se bazează ruperea ciclurilor de referințe.

Contorul nu se citește direct în cod de producție; pentru investigații folosești Memory Graph Debugger sau Instruments.

Ce urmărește intervievatorul: Verifică modelul mental al contorizării referințelor. Candidații cred uneori că a = nil distruge obiectul, indiferent de celelalte referințe.

61 Junior

Cum diferă ARC din Swift de garbage collector-ul din Java sau C#? Ce avantaje și dezavantaje are fiecare?

Răspuns scurt: ARC eliberează obiectele determinist, imediat ce dispare ultima referință puternică, fără pauze, dar nu poate elibera singur ciclurile de referințe. Un GC cu trasare găsește și ciclurile, dar eliberează în momente nedeterminate și consumă resurse pentru colectare.

ARC introduce la compilare instrucțiuni de incrementare și decrementare a contorului de referințe (retain și release). Nu există un proces separat care scanează memoria.

Garbage collector-ul cu trasare din JVM sau .NET pornește periodic de la rădăcini (stivă, variabile globale) și marchează tot ce e accesibil. Ce nu e accesibil este eliberat.

Avantajele ARC:

  • Determinism: obiectul dispare imediat. deinit rulează într-un moment previzibil, deci poți elibera resurse (fișiere, conexiuni) acolo.
  • Fără pauze de colectare: important pentru animații fluide și pentru consumul de baterie pe dispozitive mobile.
  • Memorie folosită mai puțin: nu e nevoie de spațiu suplimentar în care obiectele moarte să aștepte colectarea.

Dezavantajele ARC:

  • Ciclurile de referințe nu se eliberează niciodată automat. Dacă A ține B și B ține A, contoarele nu ajung la zero. Programatorul trebuie să folosească weak sau unowned.
  • Costul fiecărei operații: retain și release sunt operații atomice, deci au un cost în buclele care copiază des referințe. Compilatorul elimină multe dintre ele prin optimizări.

Avantajele GC: ciclurile sunt rezolvate automat, iar codul nu trebuie să se gândească la proprietatea referințelor. Dezavantaje: pauze, finalizatori nedeterminiști (în Java, finalize() este depreciat tocmai din acest motiv) și consum mai mare de memorie.

Pentru un dezvoltator Swift, consecința practică este că trebuie să gândești în termeni de proprietate: cine deține un obiect (referință puternică) și cine doar îl observă (referință slabă). Exemplele tipice sunt delegatele, closures care capturează self și relațiile părinte-copil.

Ce urmărește intervievatorul: Verifică înțelegerea compromisurilor de design. Candidații veniți din Java nu știu adesea că ARC nu rezolvă ciclurile.

62 Mid

Ce afișează codul următor și de ce compilatorul dă un avertisment?

SWIFT
weak var current = Session(name: "temp")
print(current?.name ?? "deja eliberat")

Răspuns scurt: Afișează init temp, deinit temp, apoi deja eliberat. O referință weak nu ține obiectul în viață, iar nimeni altcineva nu-l referă puternic, deci este eliberat imediat după creare.

Session(name: "temp") creează un obiect, dar singura referință către el este weak. Referințele slabe nu cresc contorul puternic, deci după atribuire contorul este zero. ARC eliberează obiectul imediat, apare deinit temp, iar current devine automat nil. Compilatorul detectează situația și avertizează: „instance will be immediately deallocated because variable 'current' is 'weak'”.

Ce trebuie reținut despre weak:

  • Este întotdeauna opțional, pentru că poate deveni nil în orice moment, când obiectul dispare.
  • Funcționează doar cu tipuri clasă (sau protocoale constrânse la AnyObject).
  • Este potrivită pentru relații în care celălalt obiect poate dispărea înainte: delegate, părinte văzut din copil, observatori.

Bug-ul apare în forme mai subtile, de exemplu când singurul proprietar real lipsește:

SWIFT
final class Screen {
    weak var service: Session?
    init() { service = Session(name: "api") }   // eliberat imediat
}
let screen = Screen()
print(screen.service == nil)                     // true

Dacă Screen trebuie să dețină serviciul, referința trebuie să fie puternică. weak este pentru relații în care altcineva este proprietarul.

Cu unowned situația e mai gravă:

SWIFT
// unowned let s = Session(name: "x")
// print(s.name)   // crash: obiectul a fost deja eliberat

unowned nu devine nil; accesarea după eliberare oprește programul.

Regula practică: pentru fiecare referință slabă, poți arăta cine deține obiectul? Dacă nu, ai un bug de proprietate.

Ce urmărește intervievatorul: Testează înțelegerea faptului că weak nu deține obiectul. Candidații pun uneori weak din reflex, ca „protecție împotriva leak-urilor”, și obțin obiecte eliberate prea devreme.

Eroarea, în practică:'weak' variable should have optional type

63 Mid

Unde este problema de memorie în clasa de mai jos și cum o rezolvi?

SWIFT
final class Report {
    let title = "Vânzări"
    lazy var header: () -> String = {
        "Raport: \(self.title)"
    }
    deinit { print("deinit Report") }
}
var r: Report? = Report()
print(r!.header())
r = nil

Răspuns scurt: header este un closure stocat de obiect care capturează puternic self, deci obiectul se ține singur în viață și deinit nu rulează. Soluția este [unowned self] sau [weak self] în closure, ori o proprietate lazy care stochează rezultatul, nu closure-ul.

Codul afișează Raport: Vânzări, dar nu și deinit Report. Ciclul este: obiectul Report ține o referință puternică la closure prin proprietatea header, iar closure-ul capturează self puternic. După r = nil, fiecare ține celălalt în viață.

O proprietate lazy poate folosi self în inițializator, pentru că rulează după ce obiectul este complet. Aici însă valoarea inițială este chiar closure-ul, care rămâne stocat.

Variante de rezolvare:

SWIFT
final class Report {
    let title = "Vânzări"

    // 1. Captură neproprietară: closure-ul nu poate trăi mai mult decât obiectul
    lazy var header: () -> String = { [unowned self] in
        "Raport: \(self.title)"
    }

    // 2. Stochezi rezultatul, nu closure-ul: closure-ul se execută o dată și dispare
    lazy var headerText: String = "Raport: \(title)"

    // 3. Proprietate calculată: nimic stocat
    var headerComputed: String { "Raport: \(title)" }

    deinit { print("deinit Report") }
}

[unowned self] este sigur aici pentru că closure-ul este ținut doar de obiect, deci nu poate fi apelat după ce obiectul dispare. Dacă closure-ul ar fi transmis și altor obiecte, [weak self] este alegerea sigură.

Varianta 2 nu creează ciclu: inițializatorul unei proprietăți lazy obișnuite se execută o singură dată, iar rezultatul e un String, nu un closure.

Tiparul general de recunoscut: un obiect care stochează un closure care se referă la același obiect. Apare la callback-uri salvate ca proprietăți (onComplete, validator), la handler-e de evenimente și la configurări de tip builder.

Ce urmărește intervievatorul: Verifică recunoașterea unui ciclu mai puțin evident decât delegate-ul clasic. Candidații nu observă des că un closure lazy stocat capturează self.

Eroarea, în practică:reference to property in closure requires 'self'read an unowned reference, object already destroyed

64 Mid

Ce afișează codul următor? Ce spune rezultatul despre natura closures?

SWIFT
func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}
let c1 = makeCounter()
let c2 = c1
print(c1(), c2(), c1())
let c3 = makeCounter()
print(c3())

Răspuns scurt: Afișează 1 2 3 și apoi 1. Closures sunt tipuri referință: c2 este aceeași instanță ca c1 și împarte variabila capturată count, pe când c3 este un closure nou, cu propriul count.

La fiecare apel makeCounter() se creează o variabilă locală count și un closure care o capturează. Pentru că closure-ul supraviețuiește funcției, variabila este mutată într-o cutie din heap, ținută în viață de closure.

Closures sunt tipuri referință. let c2 = c1 nu copiază closure-ul și nici count; copiază referința. Ambele nume arată către aceeași instanță. Prin urmare:

  • c1() face count 1;
  • c2() incrementează aceeași variabilă: 2;
  • c1() din nou: 3.

c3 provine dintr-un apel separat al lui makeCounter, deci are propria cutie cu count = 0, iar primul apel dă 1.

Consecințe:

  • Stare partajată ascunsă: dacă transmiți un closure care capturează o variabilă mutabilă către mai multe componente, toate modifică aceeași stare. Când lucrezi concurent, asta devine o cursă de date. Swift 6 refuză să trimită astfel de closures între domenii de concurență dacă nu sunt @Sendable.
  • Durata de viață: tot ce capturează un closure trăiește cât trăiește closure-ul. Dacă un closure stocat capturează un obiect mare, acel obiect nu se eliberează.
  • Lista de captură copiază: cu { [count] in ... }, closure-ul primește o copie a valorii din momentul creării. Nu ar mai putea însă modifica acea copie, pentru că e constantă.

Același mecanism stă la baza tiparului de „memoizare” prin closures sau al generatoarelor de ID-uri. Dacă vrei comportament de valoare, folosește un struct cu metodă mutating, unde copierea creează stări independente.

Ce urmărește intervievatorul: Testează înțelegerea capturilor și a semanticii referință a closures. Mulți candidați se așteaptă ca c2 să aibă propriul contor și răspund 1 1 2.

65 Mid

De ce nu compilează struct Node { var value: Int; var next: Node? }, dar compilează struct Tree { var value: Int; var children: [Tree] }?

Răspuns scurt: Un struct trebuie să aibă dimensiune fixă, iar Node? ar conține direct un alt Node, deci dimensiunea ar fi infinită. Un Array stochează elementele în heap și are dimensiune fixă indiferent de conținut, deci [Tree] e permis.

Tipurile valoare sunt stocate inline: un struct ocupă suma dimensiunilor proprietăților lui. Un Optional<Node> are cel puțin dimensiunea unui Node, iar acel Node conține la rândul lui alt Optional<Node>, la nesfârșit. Compilatorul raportează: „value type 'Node' cannot have a stored property that recursively contains it”.

Array<Tree> arată, intern, ca o referință către un buffer alocat în heap. Dimensiunea lui este aceeași, indiferent câte elemente are, deci Tree are dimensiune finită. La fel funcționează Dictionary, Set și String.

Soluții pentru o listă înlănțuită:

SWIFT
// 1. Clasă: nodurile sunt referințe
final class ListNode {
    var value: Int
    var next: ListNode?
    init(_ value: Int, next: ListNode? = nil) { self.value = value; self.next = next }
}

// 2. Enum indirect: valoare imutabilă, stocată indirect
indirect enum List {
    case empty
    case node(Int, List)
}

// 3. Cutie explicită pentru un struct
final class Box<T> { let value: T; init(_ v: T) { value = v } }
struct Node {
    var value: Int
    var next: Box<Node>?
}

let list = List.node(1, .node(2, .empty))

Alegerea depinde de folosire: o clasă permite modificarea nodurilor pe loc (necesar la algoritmi de inversare a listei), enum-ul indirect dă semantică de valoare și pattern matching.

O observație legată de memorie: o listă înlănțuită foarte lungă de clase poate provoca stack overflow la eliberare, pentru că eliberarea primului nod declanșează recursiv eliberarea celorlalte. Pentru liste de sute de mii de noduri, scrii un deinit care eliberează nodurile iterativ.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care sunt stocate tipurile valoare. Candidații nu pot explica de ce tabloul este permis, iar asta arată dacă înțeleg sau doar memorează reguli.

Eroarea, în practică:value type recursively contains itself

66 Senior

Un test verifică un observator weak și trece în Debug, dar pică în Release. Ce garantează Swift despre durata de viață a unei variabile locale și ce face withExtendedLifetime?

SWIFT
func check() {
    let resource = Resource()
    weak var observer = resource
    doWork()
    print(observer == nil)
}

Răspuns scurt: Swift garantează că un obiect trăiește până la ultima lui folosire, nu până la sfârșitul blocului. În Release, resource poate fi eliberat imediat după ultima utilizare, deci observer devine nil. withExtendedLifetime(resource) { ... } garantează viața obiectului pe toată durata closure-ului.

În multe limbaje, o variabilă locală ține obiectul în viață până la finalul domeniului lexical. Swift nu oferă formal această garanție. Optimizatorul poate scurta durata de viață a obiectului până după ultima folosire, iar resource nu mai este folosit după ce e atribuit lui observer. În Debug, optimizările lipsesc și obiectul trăiește până la finalul funcției; în Release, poate fi eliberat mai devreme. De aici diferența dintre build-uri.

Din Swift 5.7, compilatorul păstrează mai conservator duratele lexicale ale variabilelor, ceea ce reduce surprizele, dar dependența de ordinea eliberării rămâne fragilă, mai ales cu referințe weak, unowned sau pointeri nesiguri.

Când ai nevoie de garanție, o ceri explicit:

SWIFT
func check() {
    let resource = Resource()
    weak var observer = resource
    withExtendedLifetime(resource) {
        doWork()
        print(observer == nil)    // false, garantat
    }
}

Situații reale în care contează:

  • Token-uri de observare: dacă un obiect returnat de o funcție de înregistrare trebuie ținut ca să rămână activ, păstrează-l într-o proprietate, nu într-o variabilă locală nefolosită.
  • Pointeri nesiguri: Unmanaged, withUnsafePointer sau date transmise către C. Obiectul trebuie să trăiască cât timp pointerul este folosit.
  • Teste de memorie: verificările de tipul „după X, obiectul s-a eliberat” trebuie scrise cu domenii explicite (o funcție separată sau un bloc do { }) și, ideal, cu addTeardownBlock, care verifică referința slabă după test.

Ideea pentru interviu: nu te baza pe momentul exact al eliberării decât acolo unde limbajul îl garantează; exprimă dependențele de viață explicit, prin proprietari clari sau prin withExtendedLifetime.

Ce urmărește intervievatorul: Este o întrebare de nivel senior despre detalii de optimizare care produc bug-uri reale. Puțini candidați știu că durata de viață nu este legată strict de domeniul lexical.

Tratarea erorilor

67 Junior

Definește erorile pentru un formular de înregistrare (email gol, parolă prea scurtă cu lungimea minimă) astfel încât să poți afișa mesaje clare utilizatorului.

Răspuns scurt: Creezi un enum conform cu Error, cu un caz pentru fiecare problemă și valori asociate pentru detalii. Pentru mesaje implementezi LocalizedError cu errorDescription, ca error.localizedDescription să întoarcă textul tău.

În Swift, orice tip conform cu protocolul Error poate fi aruncat. Un enum este alegerea naturală pentru erori de domeniu: are un set închis de cazuri și poate purta detalii prin valori asociate.

SWIFT
import Foundation

enum SignupError: Error, Equatable {
    case emptyEmail
    case invalidEmail(String)
    case passwordTooShort(min: Int)
}

extension SignupError: LocalizedError {
    var errorDescription: String? {
        switch self {
        case .emptyEmail:
            return "Introdu adresa de email."
        case .invalidEmail(let value):
            return "Adresa „\(value)” nu pare validă."
        case .passwordTooShort(let min):
            return "Parola trebuie să aibă cel puțin \(min) caractere."
        }
    }
}

func validate(email: String, password: String) throws {
    guard !email.isEmpty else { throw SignupError.emptyEmail }
    guard email.contains("@") else { throw SignupError.invalidEmail(email) }
    guard password.count >= 8 else { throw SignupError.passwordTooShort(min: 8) }
}

do {
    try validate(email: "ana@exemplu.ro", password: "123")
} catch {
    print(error.localizedDescription)   // Parola trebuie să aibă cel puțin 8 caractere.
}

Detalii de discutat:

  • LocalizedError face parte din Foundation. Fără ea, localizedDescription ar afișa un text generic, nefolositor pentru utilizator.
  • Equatable pe enum-ul de erori simplifică testele: XCTAssertThrowsError plus compararea erorii cu cazul așteptat.
  • Valoarea asociată min păstrează mesajul corect dacă regula se schimbă.
  • Pentru aplicații localizate, textele vin din String(localized:), nu sunt scrise direct în cod.

Separă erorile de domeniu (validare, reguli de business) de cele tehnice (rețea, decodare). Interfața afișează primele direct, pe cele tehnice le traduce în mesaje generice și le trimite la logging.

Ce urmărește intervievatorul: Verifică modelarea erorilor ca tipuri. Candidații juniori aruncă des erori generice cu text liber sau ignoră complet LocalizedError.

Eroarea, în practică:call can throw but is not marked with 'try'thrown expression type does not conform to 'Error'

68 Junior

Cum prinzi separat o eroare anume, o categorie de erori și orice altă eroare? Ce afișează codul pentru signup(password: "123")?

SWIFT
do {
    try signup(password: "123")
} catch SignupError.passwordTooShort(let min) {
    print("minim \(min) caractere")
} catch let e as SignupError {
    print("altă problemă de validare: \(e)")
} catch {
    print("neașteptat: \(error)")
}

Răspuns scurt: Afișează minim 8 caractere dacă funcția aruncă passwordTooShort(min: 8). Clauzele catch se verifică în ordine: un caz anume cu valori legate, apoi un tip cu as, iar catch fără tipar prinde orice și oferă eroarea în variabila implicită error.

Fiecare catch poate avea un tipar, iar prima clauză care se potrivește câștigă:

  • catch SignupError.passwordTooShort(let min) prinde doar acel caz și extrage valoarea asociată.
  • catch let e as SignupError prinde orice altă eroare de acest tip și o leagă cu tipul concret, ca să poți face switch pe ea.
  • catch simplu prinde orice. Variabila error este creată automat.

Poți folosi și condiții:

SWIFT
enum NetworkError: Error { case status(Int), offline }

func load() throws { throw NetworkError.status(503) }

do {
    try load()
} catch NetworkError.status(let code) where code >= 500 {
    print("eroare de server \(code), reîncerc")
} catch NetworkError.status(let code) {
    print("eroare de client \(code)")
} catch NetworkError.offline {
    print("fără conexiune")
} catch {
    print("altceva: \(error)")
}

Ordinea contează: dacă pui catch let e as NetworkError primul, clauzele specifice de după nu mai sunt atinse niciodată.

Reguli de exhaustivitate: într-o funcție care nu este throws, un do-catch trebuie să prindă toate erorile, deci ai nevoie de un catch general la final. Într-o funcție throws, poți prinde doar ce te interesează, iar restul se propagă automat. Cu erorile tipizate din Swift 6, dacă do aruncă un singur tip concret, un catch care acoperă toate cazurile acelui enum este suficient.

Greșeli de evitat: un catch gol care înghite eroarea fără niciun log și transformarea tuturor erorilor în același mesaj, ceea ce face depanarea imposibilă.

Ce urmărește intervievatorul: Testează folosirea tiparelor în catch și înțelegerea ordinii. Candidații scriu des un singur catch cu if let și cast-uri în interior.

Eroarea, în practică:call can throw but is not marked with 'try'errors thrown from here are not handled

69 Junior

Ce afișează codul următor?

SWIFT
func process(fail: Bool) throws {
    print("start")
    defer { print("defer 1") }
    defer { print("defer 2") }
    if fail { throw CancellationError() }
    print("lucru terminat")
}
try? process(fail: false)
try? process(fail: true)

Răspuns scurt: Primul apel afișează start, lucru terminat, defer 2, defer 1. Al doilea afișează start, defer 2, defer 1. Blocurile defer rulează la ieșirea din domeniu, oricum s-ar ieși, în ordinea inversă declarării.

defer programează un bloc de cod care se execută când controlul părăsește domeniul curent: la return, la sfârșitul natural al funcției, la throw sau la break dintr-o buclă. Mai multe blocuri defer rulează în ordine inversă (ultimul declarat, primul executat), ca o stivă.

La primul apel, funcția ajunge la final, deci afișează lucru terminat, apoi defer 2 și defer 1. La al doilea apel, throw iese din funcție, iar cele două blocuri rulează tot, în aceeași ordine. try? ignoră eroarea.

Un defer se înregistrează doar dacă execuția ajunge la el. Un defer scris după throw nu rulează.

Folosirea tipică este eliberarea garantată a resurselor, chiar și pe căile de eroare:

SWIFT
func readConfig(path: String) throws -> String {
    let file = try openFile(path)
    defer { file.close() }               // se închide orice ar urma
    guard let text = try file.readAll(), !text.isEmpty else {
        throw ConfigError.empty
    }
    return text
}

final class Spinner {
    var isLoading = false
    func load() async throws {
        isLoading = true
        defer { isLoading = false }      // indicatorul se oprește și la eroare
        try await fetchData()
    }
}

Restricții: într-un defer nu poți folosi return, break sau throw ca să ieși din el. defer se aplică domeniului în care e scris: unul pus într-un if rulează la ieșirea din if, nu din funcție.

Nu folosi defer pentru logică obișnuită care se poate scrie liniar, pentru că inversează ordinea de citire și face codul mai greu de urmărit.

Ce urmărește intervievatorul: Verifică ordinea de execuție și utilitatea reală a lui defer. Candidații greșesc des ordinea, crezând că blocurile rulează în ordinea scrierii.

70 Junior

Ce tip are u în codul de mai jos și când e potrivit try?, dar nu try!?

SWIFT
func findUser(id: Int) throws -> String? {
    guard id >= 0 else { throw LookupError.invalidId }
    return id == 1 ? "Ana" : nil
}
let u = try? findUser(id: 1)

Răspuns scurt: Din Swift 5, u are tipul String?, nu String??, pentru că try? aplatizează opționalul. try? e potrivit când eșecul nu necesită explicație; try! doar când o eroare este imposibilă logic, pentru că altfel aplicația crapă.

try? transformă rezultatul unei funcții throws într-un opțional: valoarea dacă reușește, nil dacă aruncă. În Swift 4, dacă funcția întorcea deja un opțional, rezultatul era opțional dublu, String??. Propunerea SE-0230 (Swift 5) a schimbat regula: try? aplatizează, deci u este String?.

Asta are un preț: nu mai poți distinge între „funcția a aruncat eroare” și „funcția a întors nil”. Ambele devin nil. Dacă diferența contează, folosești do-catch:

SWIFT
do {
    if let name = try findUser(id: 2) {
        print("găsit \(name)")
    } else {
        print("nu există")          // id valid, utilizator lipsă
    }
} catch {
    print("cerere invalidă: \(error)")
}

Când e potrivit try?:

  • Operații opționale în care eșecul nu schimbă fluxul: ștergerea unui fișier temporar, citirea unei valori din cache.
  • Combinat cu ??: let config = (try? loadConfig()) ?? .default.
  • Cu guard: guard let data = try? Data(contentsOf: url) else { return }, dacă ai log-uri în altă parte.

try! oprește programul dacă apare eroarea. Este acceptabil doar când eroarea e imposibilă din motive pe care le poți explica, de exemplu o expresie regulată constantă scrisă de tine (try! Regex("[0-9]+")) sau un fișier din bundle-ul aplicației fără de care aplicația nu poate funcționa. Pentru date de la utilizator, rețea sau disc, try! este un crash programat.

Regula de code review: fiecare try? care înghite o eroare importantă ascunde un bug, iar fiecare try! trebuie să aibă o justificare clară.

Ce urmărește intervievatorul: Verifică dacă știi regula de aplatizare și compromisurile fiecărei forme. Candidații folosesc try? peste tot și pierd informația despre eroare.

Eroarea, în practică:'try!' expression unexpectedly raised an error

71 Junior

Ce este o inițializare failable (init?) și când o preferi unui init care aruncă erori? Scrie un tip Email și un tip Password care ilustrează diferența.

Răspuns scurt: init? întoarce nil când datele nu sunt valide și e potrivit când motivul e evident sau irelevant. Un init cu throws e preferabil când apelantul trebuie să afle de ce a eșuat, de exemplu ca să afișeze un mesaj anume.

Ambele forme exprimă faptul că o valoare nu se poate construi din orice date. Diferența este cât de multă informație primește apelantul.

SWIFT
struct Email {
    let value: String
    init?(_ raw: String) {
        let parts = raw.split(separator: "@")
        guard parts.count == 2, parts[1].contains(".") else { return nil }
        value = raw.lowercased()
    }
}

struct Password {
    enum Problem: Error { case tooShort(min: Int), noDigit }
    let value: String
    init(_ raw: String) throws {
        guard raw.count >= 8 else { throw Problem.tooShort(min: 8) }
        guard raw.contains(where: \.isNumber) else { throw Problem.noDigit }
        value = raw
    }
}

if let email = Email("Ana@Exemplu.ro") { print(email.value) }   // ana@exemplu.ro
do {
    _ = try Password("parolasecreta")
} catch Password.Problem.noDigit {
    print("Adaugă cel puțin o cifră")
}

Pentru Email, apelantul are nevoie doar de răspunsul „valid sau nu”, deci init? e suficient. Pentru Password, utilizatorul trebuie să afle ce să corecteze, deci erorile distincte sunt utile.

Exemple din biblioteca standard: Int("abc"), URL(string:) și init?(rawValue:) sunt failable, pentru că motivul e evident. API-urile de decodare (JSONDecoder().decode) aruncă, pentru că ai nevoie de detalii: ce cheie lipsește, ce tip nu se potrivește.

Avantajul de design al acestor tipuri: odată construit un Email, restul codului știe că valoarea e validă și nu mai trebuie să verifice din nou. Este ideea de a valida la graniță, apoi a folosi tipuri care garantează invariantul.

Există și init!, care întoarce un IUO, folosit rar, de obicei la interoperabilitatea cu Objective-C.

Ce urmărește intervievatorul: Verifică alegerea între opțional și eroare la construcție. Candidații validează des datele în multe locuri în loc să folosească un tip care garantează validitatea.

72 Mid

Ce înseamnă rethrows? Scrie o funcție transformAll care aplică o transformare elementelor și aruncă doar dacă transformarea primită aruncă.

Răspuns scurt: rethrows spune că funcția aruncă doar dacă closure-ul primit ca parametru aruncă. Când transmiți un closure care nu aruncă, apelul nu mai are nevoie de try, la fel ca la map sau filter.

O funcție de ordin superior primește adesea closures. Unele pot arunca, altele nu. Dacă ai marca funcția cu throws, toți apelanții ar fi obligați să scrie try, chiar și cu closures sigure. rethrows rezolvă: funcția este considerată aruncătoare doar atunci când argumentul ei aruncă.

SWIFT
enum ParseError: Error { case invalid(String) }

func transformAll<T, U>(_ items: [T], _ transform: (T) throws -> U) rethrows -> [U] {
    var result: [U] = []
    result.reserveCapacity(items.count)
    for item in items {
        result.append(try transform(item))
    }
    return result
}

let doubled = transformAll([1, 2, 3]) { $0 * 2 }     // fără try
print(doubled)                                       // [2, 4, 6]

do {
    let numbers = try transformAll(["1", "x"]) { text -> Int in
        guard let n = Int(text) else { throw ParseError.invalid(text) }
        return n
    }
    print(numbers)
} catch {
    print(error)                                     // invalid("x")
}

Reguli:

  • O funcție rethrows poate arunca doar erorile provenite din apelurile closure-urilor primite, nu erori proprii independente.
  • Biblioteca standard a folosit masiv rethrows: map, filter, sorted(by:), first(where:), contains(where:).
  • Dacă stochezi closure-ul pentru mai târziu (@escaping), rethrows nu mai are sens, pentru că apelul nu mai are loc în timpul funcției.

În Swift 6, erorile tipizate generalizează mecanismul: o funcție poate fi scrisă ca func f<E: Error>(_ body: () throws(E) -> Void) throws(E). Funcția aruncă exact tipul de eroare al closure-ului, iar dacă acesta e Never, apelul nu aruncă deloc. Unele funcții din biblioteca standard, precum map, au trecut la această formă.

Ce urmărește intervievatorul: Verifică înțelegerea tratării erorilor în funcțiile de ordin superior. Candidații pun throws pe astfel de funcții, obligând toți apelanții să folosească try inutil.

Eroarea, în practică:errors thrown from here are not handled

73 Mid

Care este diferența dintre assert, precondition și fatalError? Ce se întâmplă cu fiecare într-un build Release?

Răspuns scurt: assert verifică doar în build-urile de debug, precondition verifică și în Release (cu optimizări obișnuite), iar fatalError oprește programul mereu. Toate sunt pentru erori de programare, nu pentru situații recuperabile, care se tratează cu throws sau opționale.

Toate trei opresc programul când o condiție nu e îndeplinită, dar diferă după nivelul de optimizare:

  • assert(condiție, mesaj): evaluat doar în -Onone (Debug). În Release (-O), condiția nici nu se mai calculează. E bun pentru verificări costisitoare de invarianți în timpul dezvoltării.
  • precondition(condiție, mesaj): evaluat în Debug și în Release. Doar în -Ounchecked, o setare rar folosită, nu mai este verificat. Folosit pentru condiții fără de care continuarea ar corupe date.
  • fatalError(mesaj): oprește programul întotdeauna. Întoarce Never, deci compilatorul știe că execuția nu continuă.

Există și assertionFailure() și preconditionFailure() pentru ramurile care nu ar trebui să fie atinse.

SWIFT
func withdraw(_ amount: Int, from balance: Int) -> Int {
    precondition(amount >= 0, "suma nu poate fi negativă")
    assert(balance < 1_000_000_000, "sold suspect în testare")
    return balance - amount
}

enum Theme: String { case light, dark }
func color(for raw: String) -> Theme {
    guard let theme = Theme(rawValue: raw) else {
        fatalError("Temă necunoscută în configurația din bundle: \(raw)")
    }
    return theme
}

Un tipar frecvent în UIKit este required init?(coder:) cu corpul fatalError(...), pentru inițializatori obligatorii pe care nu îi folosești.

Criteriul de alegere: dacă situația poate apărea legitim (date de la server, introduse de utilizator, fișier lipsă), nu e o eroare de programare și trebuie tratată prin throws sau nil. Aserțiunile documentează presupuneri despre propriul tău cod. Un precondition care pică în producție generează un crash cu mesaj clar, preferabil unei corupții silențioase de date.

Ce urmărește intervievatorul: Verifică dacă știi comportamentul pe niveluri de optimizare și diferența dintre bug și eroare recuperabilă. Candidații folosesc des assert pentru validarea datelor de intrare, care în Release nu mai e verificată.

Eroarea, în practică:Precondition failed

74 Mid

Cum transformi o funcție throws într-un Result și invers? Când are sens să păstrezi rezultatul ca Result în loc să arunci?

Răspuns scurt: Result { try f() } captează rezultatul sau eroarea, iar try result.get() face drumul invers. Result are sens când trebuie să stochezi sau să transmiți rezultatul mai departe, de exemplu într-o colecție de rezultate sau într-un callback.

Result<Success, Failure> este un enum cu cazurile .success și .failure. Conversiile sunt directe:

SWIFT
enum LoadError: Error { case notFound }

func loadScore(for name: String) throws -> Int {
    guard name == "ana" else { throw LoadError.notFound }
    return 42
}

let r1 = Result { try loadScore(for: "ana") }    // Result<Int, any Error>
let r2 = Result { try loadScore(for: "dan") }

let doubled = r1.map { $0 * 2 }                  // .success(84)
let message = r2.mapError { _ in "Nu am găsit scorul" }

switch r2 {
case .success(let score): print("scor \(score)")
case .failure(let error): print("eroare: \(error)")   // eroare: notFound
}

let value = try r1.get()                         // înapoi la throws

Operații utile: map și flatMap transformă valoarea de succes, mapError transformă eroarea, iar get() aruncă dacă e eșec.

Când păstrezi un Result:

  • Colectezi rezultate multiple, unde unele pot eșua și vrei să le raportezi pe toate: let results = names.map { name in Result { try loadScore(for: name) } }.
  • Stochezi rezultatul pentru mai târziu, de exemplu într-un cache care reține și eșecurile.
  • API-uri cu callback care nu pot folosi throws, cum ar fi codul scris înainte de async/await.
  • Teste: un mock configurat cu un Result decide dacă întoarce valoare sau eroare.

În cod nou cu async/await, preferi async throws pentru fluxul normal, pentru că se citește liniar și se combină cu try. Result rămâne util ca valoare. Nu transforma fiecare funcție într-una care întoarce Result doar din obișnuință; adaugă un strat de switch în plus la fiecare apel fără niciun câștig.

Ce urmărește intervievatorul: Arată dacă știi să treci între cele două stiluri și când folosești fiecare. Candidații cunosc Result doar din completion handlers și nu știu de get() sau Result { }.

75 Senior

Ce sunt erorile tipizate, throws(ParseError), introduse în Swift 6? Ce avantaje și ce dezavantaje au față de throws obișnuit?

Răspuns scurt: Cu throws(ParseError) funcția declară exact tipul de eroare aruncat, iar în catch variabila error are acel tip concret, deci poți face switch exhaustiv. Dezavantajul este rigiditatea: adăugarea altui tip de eroare schimbă semnătura și strică apelanții.

Până în Swift 6, orice funcție throws arunca any Error, deci în catch trebuia să faci cast-uri. Propunerea SE-0413 a introdus typed throws:

SWIFT
enum ParseError: Error {
    case empty
    case notANumber(String)
}

func parse(_ text: String) throws(ParseError) -> Int {
    guard !text.isEmpty else { throw .empty }
    guard let n = Int(text) else { throw .notANumber(text) }
    return n
}

do {
    let n = try parse("x7")
    print(n)
} catch {
    // error are tipul ParseError
    switch error {
    case .empty: print("text gol")
    case .notANumber(let t): print("nu e număr: \(t)")
    }
}

throw .empty funcționează cu sintaxa scurtă, pentru că tipul e cunoscut. throws(any Error) este echivalent cu throws, iar throws(Never) cu o funcție care nu aruncă.

Avantaje:

  • Exhaustivitate: switch acoperă toate cazurile, fără default.
  • Fără alocări: erorile nu mai trebuie ambalate într-un existențial, important pentru Embedded Swift și cod de performanță.
  • Generice: funcțiile de ordin superior pot propaga exact tipul de eroare al closure-ului.

Dezavantaje:

  • Evoluția API-ului: dacă o funcție începe să apeleze o bibliotecă de rețea, nu poate arunca noile erori fără să schimbe semnătura sau să le înfășoare.
  • Ierarhii complicate: ajungi să creezi enum-uri care învelesc enum-uri.

Recomandarea din propunerea însăși: folosește throws obișnuit în majoritatea codului, mai ales la granițele modulelor publice. Erorile tipizate se potrivesc în cod intern, unde setul de erori este închis și stabil, cum ar fi un parser sau un validator, și în funcții generice care doar transmit mai departe erorile primite.

Ce urmărește intervievatorul: Verifică familiaritatea cu Swift 6 și capacitatea de a cântări un instrument nou. Candidații entuziaști propun erori tipizate peste tot, fără să vadă costul de evoluție.

Eroarea, în practică:thrown expression type cannot be converted

Concurență: async/await, Task, actors

76 Junior

Cât durează aproximativ fiecare variantă și de ce?

SWIFT
func fetch(_ name: String) async throws -> String {
    try await Task.sleep(for: .seconds(1))
    return name
}

// Varianta A
let a = try await fetch("a")
let b = try await fetch("b")

// Varianta B
async let c = fetch("c")
async let d = fetch("d")
let both = try await [c, d]

Răspuns scurt: Varianta A durează în jur de 2 secunde, pentru că al doilea apel pornește abia după ce primul se termină. Varianta B durează în jur de o secundă, pentru că async let pornește imediat ambele operații ca task-uri copil care rulează în paralel.

await nu înseamnă „pornește în paralel”, ci „așteaptă aici rezultatul”. În varianta A, execuția se suspendă la primul await până când fetch("a") se termină, apoi pornește fetch("b"). Cele două așteptări se adună: aproximativ 2 secunde.

În varianta B, fiecare async let creează un task copil care începe să ruleze imediat, fără să aștepte. Funcția curentă continuă până la try await [c, d], unde așteaptă ambele rezultate. Cum operațiile se suprapun, timpul total este cel al celei mai lente, aproximativ o secundă.

SWIFT
let clock = ContinuousClock()
let elapsed = try await clock.measure {
    async let x = fetch("x")
    async let y = fetch("y")
    _ = try await (x, y)
}
print(elapsed)   // aproximativ 1 secundă

Când folosești fiecare formă:

  • Secvențial când al doilea pas depinde de primul, de exemplu încarci utilizatorul și apoi comenzile lui după user.id.
  • async let când ai un număr fix și mic de operații independente.
  • withTaskGroup când numărul de operații e cunoscut abia la rulare, de exemplu o listă de URL-uri.

Greșeala tipică în code review: un ecran care încarcă profilul, notificările și setările una după alta, deși sunt independente. Schimbarea în async let reduce timpul de încărcare fără alt efort.

Task.sleep(for:) cu Duration cere iOS 16 sau macOS 13; în versiuni mai vechi există Task.sleep(nanoseconds:). Spre deosebire de Thread.sleep, nu blochează firul: task-ul este suspendat, iar firul rămâne liber pentru alte lucrări.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre așteptare și paralelism. Candidații cred des că simpla folosire a lui async face operațiile paralele.

77 Junior

Ce este un punct de suspendare? Ce se întâmplă cu firul de execuție când o funcție ajunge la await?

Răspuns scurt: Este un await la care funcția poate fi pusă în pauză până când rezultatul e gata. Firul nu este blocat, ci eliberat pentru alte task-uri, iar funcția poate continua pe alt fir, cu excepția codului izolat pe @MainActor.

În modelul async/await din Swift, await marchează locurile în care funcția poate fi suspendată. Nu e garantat că se suspendă (dacă rezultatul e deja disponibil, continuă imediat), dar trebuie să scrii codul presupunând că se poate.

SWIFT
func step(_ name: String) async -> String {
    try? await Task.sleep(for: .milliseconds(100))
    return name
}

func run() async {
    print("înainte")
    let a = await step("a")      // punct de suspendare
    print("după \(a)")
}

Ce se întâmplă la suspendare:

  • Starea funcției (variabile locale, poziția) este salvată, iar firul curent este eliberat și preia alte task-uri. Spre deosebire de un apel blocant, firul nu stă degeaba.
  • La reluare, funcția poate continua pe alt fir din pool-ul cooperativ. Pentru codul izolat pe @MainActor, reluarea se face pe actorul principal.
  • Între suspendare și reluare poate rula alt cod. Dacă lucrezi pe un actor, starea lui se poate schimba între două await-uri.

Consecințe practice:

  • Nu presupune că o valoare citită înainte de await mai este actuală după. Recitește-o sau verifică din nou condiția.
  • Nu ține un lock (NSLock, os_unfair_lock) peste un await; reluarea pe alt fir poate duce la blocaje.
  • Poți apela await doar dintr-un context asincron. Dintr-o funcție sincronă pornești un Task { }.
  • await face vizibile în cod toate locurile în care se poate întâmpla altceva, ceea ce e un avantaj de lizibilitate față de callback-uri.

Ce urmărește intervievatorul: Testează modelul mental corect al execuției asincrone. Candidații cred des că await blochează firul, ca un apel sincron.

Eroarea, în practică:expression is 'async' but is not marked with 'await'

78 Junior

De ce rezultatul codului de mai jos poate fi mai mic decât 1000 și cum îl corectezi?

SWIFT
final class Counter { var value = 0 }

func race() async {
    let counter = Counter()
    await withTaskGroup(of: Void.self) { group in
        for _ in 0..<1000 {
            group.addTask { counter.value += 1 }
        }
    }
    print(counter.value)
}

Răspuns scurt: Task-urile rulează în paralel pe fire diferite și modifică simultan aceeași proprietate. += înseamnă citire, adunare și scriere, iar două task-uri pot citi aceeași valoare, deci se pierd incrementări. Soluția este un actor sau un lock, iar Swift 6 refuză oricum codul la compilare.

Acesta este un data race: două sau mai multe fire accesează aceeași memorie în același timp, iar cel puțin unul scrie, fără sincronizare. counter.value += 1 nu este atomic: un task citește 41, altul citește tot 41, amândouă scriu 42, iar o incrementare se pierde. Rezultatul variază de la o rulare la alta, iar în cazuri mai complexe (tablouri, dicționare) cursa poate corupe memoria și produce crash-uri.

În modul Swift 6, codul nu compilează: Counter nu este Sendable, iar closure-ul trimis lui addTask îl capturează. În Swift 5 primești avertismente doar cu verificarea strictă activată.

Corectura cu un actor, care serializează accesul la starea lui:

SWIFT
actor SafeCounter {
    private(set) var value = 0
    func increment() { value += 1 }
}

func safe() async {
    let counter = SafeCounter()
    await withTaskGroup(of: Void.self) { group in
        for _ in 0..<1000 {
            group.addTask { await counter.increment() }
        }
    }
    print(await counter.value)   // 1000
}

Fiecare apel increment() rulează pe rând, deci nu se pierde nimic. Apelurile din afara actorului cer await, pentru că pot aștepta ca actorul să se elibereze.

Alternative:

  • Mutex din modulul Synchronization (Swift 6, iOS 18 sau macOS 15) pentru secțiuni critice scurte și sincrone.
  • Fiecare task întoarce un rezultat, iar agregarea se face la final: group.addTask { 1 } și apoi for await x in group { total += x }. Fără stare partajată, nu e nevoie de sincronizare.

Pentru depistarea curselor în cod existent, activezi Thread Sanitizer din schema Xcode.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce este o cursă de date și cum o previne Swift. Candidații juniori nu văd de ce += 1 poate fi o problemă.

79 Junior

În ce ordine se afișează literele?

SWIFT
@MainActor
func test() {
    print("A")
    Task { print("B") }
    print("C")
}

Ce s-ar schimba dacă funcția nu ar fi izolată pe @MainActor?

Răspuns scurt: Se afișează A, C, B. Task { } nu rulează imediat: moștenește izolarea pe actorul principal și poate porni abia după ce test() eliberează actorul. Fără izolare, task-ul ar rula pe alt fir, iar ordinea dintre B și C nu ar mai fi garantată.

Task { } creează un task nou și îl pune în coada executorului, apoi întoarce imediat controlul. Nu așteaptă execuția closure-ului.

Un task creat cu Task { } moștenește izolarea contextului. Aici contextul este @MainActor, deci closure-ul trebuie să ruleze pe actorul principal. Actorul este ocupat cu test(), care e sincronă și nu are niciun punct de suspendare. Prin urmare, task-ul poate porni abia după ce test() se termină: ordinea A, C, B este garantată.

Dacă funcția ar fi nonisolated, task-ul ar rula pe executorul global, adică pe un fir din pool, în paralel cu restul funcției. A apare sigur primul, dar B poate apărea înainte sau după C, în funcție de planificare.

Consecințe practice:

  • Nu te baza pe ordinea dintre codul de după Task { } și conținutul task-ului. Dacă ai nevoie de rezultat, fă funcția async și folosește await.
  • Codul de după Task { } într-un handler de buton rulează imediat; starea „se încarcă” trebuie setată înainte de task, nu în interiorul lui, dacă vrei să apară instant.
SWIFT
@MainActor
final class LoginModel {
    var isLoading = false
    func tapLogin() {
        isLoading = true            // vizibil imediat
        Task {
            defer { isLoading = false }
            try? await Task.sleep(for: .seconds(1))   // în loc de cererea reală
        }
    }
}

Task-ul de mai sus rulează pe actorul principal, dar în timpul lui await actorul este liber, deci interfața rămâne responsivă. Asta arată diferența dintre a fi pe main actor și a bloca firul principal.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care Task moștenește contextul. Candidații presupun des că Task { } rulează imediat sau mereu pe un fir de fundal.

80 Mid

Care este diferența dintre Task { } și Task.detached { }? Când ai folosi Task.detached?

Răspuns scurt: Task { } moștenește izolarea pe actor, prioritatea și valorile task-local ale contextului, iar Task.detached nu moștenește nimic. Niciunul nu este anulat automat cu apelantul. Task.detached e rar necesar, de exemplu pentru muncă grea care nu trebuie să ruleze pe actorul apelantului.

Ambele creează task-uri nestructurate: nu sunt legate de domeniul în care au fost create și pot trăi mai mult decât funcția care le-a pornit. Diferența este ce preiau din context.

Task { } moștenește:

  • izolarea pe actor (dacă ești pe @MainActor, closure-ul rulează tot pe main actor);
  • prioritatea task-ului curent;
  • valorile @TaskLocal, de exemplu un ID de cerere pentru logging.

Task.detached { } nu moștenește nimic: rulează pe executorul global, cu prioritatea dată explicit sau cea implicită.

SWIFT
func buildReport() -> String { (1...1_000).map(String.init).joined(separator: ",") }

@MainActor
final class ReportModel {
    var status = ""

    func refresh() {
        Task {
            status = "se generează"         // pe MainActor, fără await
        }
        Task.detached(priority: .utility) {
            let report = buildReport()      // nu ocupă actorul principal
            await self.finish(report)
        }
    }
    func finish(_ report: String) { status = "gata: \(report.count) caractere" }
}

În task-ul detașat, accesul la self trece prin await, pentru că ReportModel este izolat pe main actor.

Când are sens Task.detached: muncă sincronă grea (procesare de imagini, parsare mare) pornită dintr-un context izolat pe main actor. Totuși, o soluție adesea mai curată este o funcție nonisolated async sau, din Swift 6.2, o funcție marcată @concurrent, care cere explicit execuția în afara actorului apelantului.

Pentru ambele forme, anularea e manuală: păstrezi referința let task = Task { ... } și apelezi task.cancel() când ecranul dispare. Folosește Task.detached doar când poți explica de ce nu vrei moștenirea; altfel pierzi prioritatea și contextul de logging fără motiv.

Ce urmărește intervievatorul: Testează cunoașterea diferențelor de moștenire a contextului. Candidații folosesc Task.detached din reflex, crezând că e singura cale de a ieși de pe firul principal.

81 Mid

Scrie o funcție countdown(from:) care întoarce un AsyncStream<Int> cu o valoare pe secundă și arată cum o consumi. Cum oprești producerea când consumatorul nu mai ascultă?

Răspuns scurt: Construiești AsyncStream cu un closure care primește un continuation, trimiți valori cu yield și închizi cu finish(). Consumatorul folosește for await. Setezi onTermination ca să anulezi task-ul producător când consumatorul se oprește sau e anulat.

AsyncStream adaptează orice sursă de evenimente (timer, notificări, callback-uri) la protocolul AsyncSequence, deci o poți parcurge cu for await.

SWIFT
func countdown(from n: Int) -> AsyncStream<Int> {
    AsyncStream { continuation in
        let producer = Task {
            for i in stride(from: n, through: 0, by: -1) {
                continuation.yield(i)
                try? await Task.sleep(for: .seconds(1))
                if Task.isCancelled { break }
            }
            continuation.finish()
        }
        continuation.onTermination = { _ in
            producer.cancel()
        }
    }
}

func run() async {
    for await value in countdown(from: 3) {
        print(value)               // 3, 2, 1, 0
        if value == 1 { break }    // onTermination oprește producătorul
    }
    print("gata")
}

Puncte importante:

  • yield trimite o valoare; finish() încheie secvența, iar bucla for await se termină.
  • onTermination se apelează când secvența se termină din orice motiv: finish(), break în consumator sau anularea task-ului consumator. Este locul pentru curățenie: anularea task-ului, oprirea unui timer, eliminarea unui observator.
  • Fără onTermination, producătorul ar continua să ruleze inutil după break.
  • Un AsyncStream are un singur consumator. Pentru mai mulți ascultători trebuie să creezi câte un stream pentru fiecare.
  • Implicit, valorile se pun într-un buffer nelimitat. Cu bufferingPolicy: .bufferingNewest(1) păstrezi doar ultima, util pentru actualizări de stare.

Pentru surse care pot eșua folosești AsyncThrowingStream, cu continuation.finish(throwing: error). Din Swift 5.9, AsyncStream.makeStream(of:) întoarce stream-ul și continuation-ul separat, util când producătorul este o clasă cu callback-uri.

Ce urmărește intervievatorul: Verifică legarea API-urilor bazate pe evenimente de async/await. Greșeala tipică este omiterea lui onTermination, care lasă producători activi la nesfârșit.

82 Mid

Care dintre accesările de mai jos compilează fără await și de ce?

SWIFT
actor BankAccount {
    let id: String
    private(set) var balance: Double = 0
    init(id: String) { self.id = id }
    func deposit(_ amount: Double) { balance += amount }
    nonisolated var label: String { "Cont \(id)" }
}

let account = BankAccount(id: "RO01")
print(account.id)            // (1)
print(account.label)         // (2)
print(account.balance)       // (3)
account.deposit(100)         // (4)

Răspuns scurt: (1) și (2) compilează fără await: id este o constantă let de tip Sendable, iar label este nonisolated. (3) și (4) cer await, pentru că accesează starea izolată a actorului din afara lui.

Un actor își protejează starea mutabilă: proprietățile var și metodele lui sunt izolate și pot fi folosite direct doar din interiorul actorului. Din afară, orice acces trece prin await, pentru că apelul poate trebui să aștepte ca actorul să termine altă lucrare.

  • (1) id este let și de tip Sendable (String). O constantă nu se poate schimba, deci nu există risc de cursă, iar Swift permite citirea sincronă din același modul.
  • (2) label este marcat nonisolated: nu face parte din domeniul izolat și poate fi apelat sincron. Poate folosi doar date neizolate, adică id. Dacă ar citi balance, nu ar compila.
  • (3) balance este o var izolată. Corect: print(await account.balance). Din cauza lui private(set), din afară poate fi doar citită.
  • (4) deposit este o metodă izolată: await account.deposit(100).
SWIFT
await account.deposit(100)
let current = await account.balance
print(current)                          // 100.0

Detalii de discutat:

  • În interiorul actorului, metodele se apelează între ele fără await, pentru că rulează deja în același domeniu de izolare.
  • nonisolated este util pentru conformitatea la protocoale sincrone, de exemplu Hashable sau CustomStringConvertible, construite din date imutabile.
  • Fiecare await account.x este un acces separat. Codul if await account.balance > 50 { await account.withdraw(50) } are o cursă logică: între cele două apeluri, alt task poate retrage bani. Verificarea și modificarea trebuie puse împreună într-o singură metodă a actorului.

Ultima observație este, de obicei, ce diferențiază un răspuns mid de unul junior.

Ce urmărește intervievatorul: Testează regulile concrete de izolare a actorilor. Candidații nu știu des că o constantă let se poate citi fără await sau fac verificarea și modificarea în două apeluri separate.

Eroarea, în practică:actor-isolated property can not be mutated

83 Mid

Scrie o funcție generică retry care reîncearcă o operație asincronă de cel mult N ori, cu pauză dublată între încercări, și care respectă anularea.

Răspuns scurt: Rulezi operația într-o buclă; la eroare, dacă mai ai încercări și eroarea nu este de anulare, aștepți cu Task.sleep și dublezi pauza. Task.sleep aruncă CancellationError la anulare, deci reîncercarea se oprește singură.

O implementare compactă cu backoff exponențial:

SWIFT
func retry<T: Sendable>(
    maxAttempts: Int = 3,
    initialDelay: Duration = .milliseconds(200),
    _ operation: @Sendable () async throws -> T
) async throws -> T {
    var delay = initialDelay
    var attempt = 1
    while true {
        do {
            return try await operation()
        } catch is CancellationError {
            throw CancellationError()
        } catch {
            guard attempt < maxAttempts else { throw error }
            try await Task.sleep(for: delay)     // aruncă dacă task-ul e anulat
            delay = delay * 2
            attempt += 1
        }
    }
}

actor FlakyServer {
    private var calls = 0
    func request() throws -> String {
        calls += 1
        if calls < 3 { throw URLError(.timedOut) }
        return "răspuns după \(calls) încercări"
    }
}
let server = FlakyServer()
let value = try await retry { try await server.request() }
print(value)   // răspuns după 3 încercări

Decizii de explicat:

  • Anularea: dacă utilizatorul părăsește ecranul și task-ul e anulat, nu are sens să reîncerci. CancellationError e propagată imediat, iar Task.sleep aruncă la anulare, deci nu aștepți degeaba.
  • Backoff exponențial: 200 ms, 400 ms, 800 ms. Reduce presiunea pe server.

Îmbunătățiri pentru producție:

  • Jitter: o componentă aleatoare în pauză, ca multe aplicații să nu reîncerce simultan după o pană.
  • Reîncearcă doar erori tranzitorii: timeout, lipsă conexiune, HTTP 503. O eroare 400 sau 401 nu se rezolvă prin reîncercare. Un parametru shouldRetry: (Error) -> Bool face funcția configurabilă.

URLError vine din Foundation. Closure-ul este @Sendable, ca în modul Swift 6 să poată rula în afara actorului apelantului, dar nu e @escaping, pentru că e folosit doar în timpul funcției.

Ce urmărește intervievatorul: Este un exercițiu practic frecvent la interviurile cu async/await. Greșelile tipice sunt ignorarea anulării și reîncercarea oricărei erori, inclusiv a celor permanente.

84 Mid

Scrie o funcție care descarcă în paralel o listă de URL-uri și întoarce datele în aceeași ordine ca URL-urile. Cum ai limita numărul de descărcări simultane?

Răspuns scurt: Folosești withThrowingTaskGroup, iar fiecare task întoarce perechea (index, data), pentru că rezultatele sosesc în ordinea terminării, nu a pornirii. Le pui în tablou după index. Pentru limită, pornești întâi K task-uri și adaugi câte unul nou la fiecare rezultat primit.

Un task group întoarce rezultatele în ordinea în care se termină task-urile. Dacă al treilea URL răspunde primul, rezultatul lui vine primul. De aceea fiecare task întoarce și indexul:

SWIFT
import Foundation

func downloadAll(_ urls: [URL], maxConcurrent: Int = 4) async throws -> [Data] {
    try await withThrowingTaskGroup(of: (Int, Data).self) { group in
        var results = [Data?](repeating: nil, count: urls.count)
        var next = 0

        func addNext() {
            guard next < urls.count else { return }
            let index = next, url = urls[index]
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return (index, data)
            }
            next += 1
        }

        for _ in 0..<min(maxConcurrent, urls.count) { addNext() }
        for try await (index, data) in group {
            results[index] = data
            addNext()
        }
        return results.compactMap { $0 }
    }
}

Cum funcționează:

  • La început pornesc cel mult maxConcurrent descărcări.
  • De fiecare dată când una se termină, rezultatul e pus la poziția lui și pornește următoarea. Astfel ai mereu cel mult K cereri active.
  • La final, toate pozițiile sunt completate, iar compactMap transformă [Data?] în [Data].

Comportamentul la erori: dacă un task aruncă, for try await propagă eroarea, iar grupul anulează automat task-urile rămase și le așteaptă înainte să iasă. Dacă vrei rezultate parțiale, fiecare task întoarce un Result, iar grupul nu mai aruncă.

De ce limita contează: sute de cereri simultane pot satura conexiunea, pot depăși limitele serverului și consumă memorie. Pentru câteva elemente, varianta fără limită (toate addTask într-o buclă) este suficientă.

Funcția locală addNext modifică next și group din funcția exterioară, ceea ce e permis pentru că rulează sincron în același task.

Ce urmărește intervievatorul: Testează folosirea task group-urilor dincolo de exemplul de bază. Candidații uită des că ordinea rezultatelor nu este ordinea pornirii.

85 Senior

Ce înseamnă concurență structurată? Ce se întâmplă în codul de mai jos dacă countOrders() aruncă o eroare sau dacă task-ul părinte este anulat?

SWIFT
func loadDashboard() async throws -> (orders: Int, users: Int) {
    async let orders = countOrders()
    async let users = countUsers()
    return try await (orders, users)
}

Răspuns scurt: Concurența structurată leagă durata task-urilor copil de domeniul în care au fost create: funcția nu se termină până nu se termină copiii. Dacă countOrders() aruncă, users este anulat și așteptat, apoi eroarea se propagă; dacă părintele este anulat, anularea ajunge automat la ambii copii.

În concurența structurată, task-urile copil create cu async let sau withTaskGroup formează un arbore cu task-ul părinte. Regulile:

  • Un copil nu poate trăi mai mult decât domeniul care l-a creat. La ieșirea din funcție, toți copiii sunt fie terminați, fie anulați și așteptați.
  • Anularea se propagă în jos: anularea părintelui marchează automat toți copiii ca anulați.
  • Erorile se propagă în sus: dacă un copil aruncă și eroarea ajunge la await, ceilalți copii sunt anulați, iar funcția iese cu eroarea abia după ce ei se opresc.

În exemplu, dacă countOrders() aruncă, try await (orders, users) propagă eroarea. Înainte de ieșire, users primește anulare și este așteptat. Nu rămâne nicio lucrare orfană.

Un async let pe care nu îl aștepți niciodată este anulat și așteptat implicit la ieșirea din domeniu.

Contrastul cu task-urile nestructurate:

SWIFT
func loadDashboardLeaky() async throws -> Int {
    let usersTask = Task { try await countUsers() }   // nestructurat
    let orders = try await countOrders()              // dacă aruncă aici...
    return orders + (try await usersTask.value)       // ...usersTask continuă singur
}

Dacă countOrders() aruncă sau funcția e anulată, usersTask continuă să ruleze. Trebuie anulat manual, de exemplu cu defer { usersTask.cancel() } sau cu withTaskCancellationHandler.

Anularea este cooperativă: marcarea nu oprește codul. Funcțiile trebuie să verifice Task.isCancelled sau să apeleze try Task.checkCancellation(). API-urile din sistem, cum ar fi URLSession.data(from:) și Task.sleep, fac asta singure.

Regula de design: preferă async let și task group-uri; folosește Task { } doar la granița cu codul sincron, de exemplu într-un handler de buton, și păstrează referința ca să-l poți anula.

Ce urmărește intervievatorul: Verifică înțelegerea garanțiilor modelului de concurență, esențială la nivel senior. Candidații folosesc des Task { } în interiorul funcțiilor async, pierzând propagarea anulării și a erorilor.

86 Senior

Implementează un cache de imagini cu actor care, dacă două ecrane cer simultan aceeași imagine, face o singură descărcare. De ce nu e suficient un dicționar de rezultate?

Răspuns scurt: Pe lângă rezultate, păstrezi task-urile în desfășurare, [URL: Task<Data, Error>], iar al doilea apelant așteaptă task-ul existent. Doar rezultatele nu ajung din cauza reentranței: ambii apelanți văd cache-ul gol înainte ca prima descărcare să se termine.

Un actor serializează accesul la starea lui, dar este reentrant: în timpul unui await din interiorul său, alte apeluri pot rula. Varianta naivă eșuează:

SWIFT
// naiv: dacă două apeluri vin simultan, ambele descarcă
func image(for url: URL) async throws -> Data {
    if let cached = cache[url] { return cached }
    let data = try await download(url)      // aici intră al doilea apel
    cache[url] = data
    return data
}

Primul apel se suspendă la descărcare, iar al doilea găsește tot cache-ul gol și pornește o descărcare identică.

Soluția este să memorezi lucrarea în desfășurare, nu doar rezultatul:

SWIFT
import Foundation

func download(_ url: URL) async throws -> Data {
    try await URLSession.shared.data(from: url).0
}

actor ImageCache {
    private var cache: [URL: Data] = [:]
    private var inFlight: [URL: Task<Data, any Error>] = [:]

    func image(for url: URL) async throws -> Data {
        if let cached = cache[url] { return cached }
        if let running = inFlight[url] { return try await running.value }

        let task = Task { try await download(url) }
        inFlight[url] = task
        defer { inFlight[url] = nil }

        let data = try await task.value
        cache[url] = data
        return data
    }
}

De ce funcționează: verificarea și înregistrarea task-ului în inFlight se fac fără await între ele, deci atomic în raport cu actorul. Orice apel ulterior găsește task-ul și îi așteaptă rezultatul.

Aspecte de discutat:

  • Erorile sunt partajate: dacă descărcarea eșuează, toți cei care așteaptă primesc eroarea, iar defer șterge intrarea, deci următorul apel reîncearcă.
  • Limita de memorie: un dicționar crește la nesfârșit. În producție folosești NSCache sau o politică LRU.

Ce urmărește intervievatorul: Este o problemă clasică senior care verifică înțelegerea reentranței în practică. Majoritatea candidaților scriu varianta naivă și cred că actorul o face sigură.

87 Senior

De ce este periculos codul de mai jos, care încearcă să apeleze o funcție async dintr-o funcție sincronă?

SWIFT
func loadSync() -> Data {
    let semaphore = DispatchSemaphore(value: 0)
    var result = Data()
    Task {
        result = await loadData()
        semaphore.signal()
    }
    semaphore.wait()
    return result
}

Răspuns scurt: semaphore.wait() blochează un fir din pool-ul cooperativ, care are aproximativ un fir pe nucleu. Dacă toate firele ajung să aștepte, task-ul care ar face signal() nu mai are unde rula și apare un deadlock. Pe main thread îngheață și interfața.

Swift Concurrency rulează task-urile pe un pool cooperativ cu un număr limitat de fire, aproximativ câte nuclee are procesorul. Modelul presupune că task-urile nu blochează niciodată un fir: la await îl eliberează pentru altele. Așa se evită explozia de fire din GCD, unde fiecare blocaj crea un fir nou.

Codul din întrebare încalcă această regulă:

  • semaphore.wait() blochează firul curent până la signal().
  • Dacă loadSync() este apelată chiar dintr-un task, se blochează un fir din pool. Dacă mai multe astfel de apeluri rulează simultan, toate firele pot ajunge blocate, iar task-urile care ar face signal() nu mai au unde să ruleze: deadlock.
  • Dacă e apelată pe main thread și loadData are nevoie de main actor, blocajul este imediat. Chiar și altfel, interfața îngheață și sistemul poate închide aplicația.
  • În Swift 6, modificarea lui result din task este semnalată ca acces concurent nesigur.

Alternative corecte:

SWIFT
// 1. Propagă async până sus
func load() async -> Data { await loadData() }

// 2. La granița cu codul sincron, pornește un task și raportează rezultatul
func loadAndShow(completion: @escaping @Sendable (Data) -> Void) {
    Task { completion(await loadData()) }
}

Direcția invers (din callback în async) se face cu withCheckedContinuation.

Reguli înrudite pentru codul async:

  • Nu bloca: fără semaphore.wait(), DispatchGroup.wait(), Thread.sleep.
  • Calculele lungi CPU într-un task trebuie împărțite sau să apeleze periodic await Task.yield(), ca să lase loc altor task-uri.
  • Lock-urile (Mutex, OSAllocatedUnfairLock) sunt acceptabile pentru secțiuni critice foarte scurte, fără niciun await în interior.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de execuție cooperativ. Candidații care vin din GCD folosesc des semafoare ca punte între sincron și async, fără să știe riscul.

Eroarea, în practică:'async' call in a function without concurrency

Property wrappers, key paths și Swift modern

Exersează capitolul cu exerciții reale: Curs Swift online →
88 Junior

Ce înseamnă private(set) și care este diferența dintre private și fileprivate când folosești extensii în același fișier?

Răspuns scurt: private(set) face proprietatea citibilă la nivelul normal de acces, dar modificabilă doar din interiorul tipului. Din Swift 4, membrii private sunt vizibili și în extensiile aceluiași tip din același fișier; fileprivate extinde vizibilitatea la tot codul din fișier, inclusiv alte tipuri.

Swift permite niveluri de acces diferite pentru citire și scriere. Tiparul cel mai folosit este private(set):

SWIFT
struct Wallet {
    private(set) var balance = 0
    private var history: [Int] = []

    mutating func add(_ amount: Int) {
        precondition(amount > 0)
        balance += amount
        history.append(amount)
    }
}

extension Wallet {
    var lastAmount: Int? { history.last }   // ok: private, același tip, același fișier
}

fileprivate func audit(_ w: Wallet) -> Int {
    w.balance                               // citire permisă
    // w.history                            // eroare: private aparține tipului
}

var w = Wallet()
w.add(50)
print(w.balance, w.lastAmount ?? 0)         // 50 50
// w.balance = 1_000                        // eroare: setter-ul e privat

Așa garantezi că soldul se schimbă doar prin add, unde se aplică regulile, dar oricine îl poate citi.

private: vizibil în declarația care îl conține și în extensiile aceluiași tip din același fișier. Regula a fost relaxată în Swift 4 (SE-0169) tocmai ca să poți organiza codul în extensii fără să treci totul pe fileprivate.

fileprivate: vizibil oriunde în fișier, inclusiv în alte tipuri sau funcții libere. Îl folosești când două tipuri strâns legate, din același fișier, au nevoie de acces la detalii comune.

Combinații utile: public private(set) var într-un pachet (citire publică, scriere internă tipului) și internal(set). Pentru tipurile de date, a ascunde setter-ele și a expune metode cu nume clare este o formă simplă de încapsulare care previne stări invalide.

Implicit, totul este internal, adică vizibil în întregul modul, deci accesul trebuie restrâns conștient.

Ce urmărește intervievatorul: Verifică folosirea practică a controlului accesului pentru încapsulare. Candidații nu cunosc des private(set) și expun proprietăți complet modificabile.

Eroarea, în practică:inaccessible due to 'private' protection level

89 Mid

Scrie un property wrapper @Clamped care ține o valoare într-un interval și expune prin $ dacă ultima atribuire a fost ajustată.

Răspuns scurt: Declari un struct marcat @propertyWrapper, cu wrappedValue care aplică limitele în init și în setter. Proprietatea projectedValue devine accesibilă ca $nume; aici întoarce un Bool care spune dacă ultima valoare a fost tăiată.

Un property wrapper mută logica repetitivă a unei proprietăți (validare, persistență, sincronizare) într-un tip reutilizabil. Compilatorul generează o proprietate de stocare _level de tipul wrapper-ului, iar level citește și scrie prin wrappedValue.

SWIFT
@propertyWrapper
struct Clamped {
    private var value: Int
    private let range: ClosedRange<Int>
    private(set) var projectedValue = false     // true dacă valoarea a fost ajustată

    init(wrappedValue: Int, _ range: ClosedRange<Int>) {
        self.range = range
        value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }

    var wrappedValue: Int {
        get { value }
        set {
            let clamped = min(max(newValue, range.lowerBound), range.upperBound)
            projectedValue = clamped != newValue
            value = clamped
        }
    }
}

struct Volume {
    @Clamped(0...10) var level = 5
}

var v = Volume()
v.level = 15
print(v.level, v.$level)    // 10 true
v.level = 7
print(v.level, v.$level)    // 7 false

@Clamped(0...10) var level = 5 se traduce în Clamped(wrappedValue: 5, 0...10). Spre deosebire de didSet, limita se aplică și la inițializare.

projectedValue este al doilea canal al wrapper-ului, accesat cu $. Poate avea orice tip. În SwiftUI, @State îl folosește ca să ofere un Binding ($name), iar @Published ca să ofere un publisher.

Limitări de știut:

  • Un wrapper nu poate fi folosit într-o declarație de protocol și nici pe proprietăți calculate.
  • Wrapper-ele cu stare (ca acesta) fac tipul care le conține mai mare și pot complica Codable.
  • Din Swift 5.4, wrapper-ele merg și pe variabile locale, iar din 5.5 pe parametrii funcțiilor.

Folosește-le pentru reguli care se repetă în multe locuri; pentru un singur caz, un didSet sau un setter privat este mai simplu de citit.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului din spatele wrapper-elor, mai ales a valorii proiectate. Candidații cunosc @State și $, dar nu știu că $ vine din projectedValue.

90 Mid

Ce sunt key paths în Swift? Arată cum le folosești cu map, cum scrii o sortare generică după un key path și cum modifici o valoare prin WritableKeyPath.

Răspuns scurt: Un key path, scris \Tip.proprietate, este o referință tipizată la o proprietate, nu la valoarea ei. Din Swift 5.2 poate fi folosit ca funcție (map(\.name)), iar cu WritableKeyPath poți citi și scrie proprietatea pe orice instanță.

Un key path descrie drumul către o proprietate. Are un tip precis: KeyPath<Employee, String> înseamnă „pe un Employee, duce la un String”. Îl aplici cu subscriptul [keyPath:].

SWIFT
struct Employee {
    var name: String
    var salary: Int
    var team: String
}

var staff = [
    Employee(name: "Ana", salary: 9000, team: "iOS"),
    Employee(name: "Dan", salary: 7000, team: "Web")
]

let names = staff.map(\.name)                 // ["Ana", "Dan"]

extension Sequence {
    func sorted<T: Comparable>(on key: KeyPath<Element, T>, descending: Bool = false) -> [Element] {
        sorted { descending ? $0[keyPath: key] > $1[keyPath: key]
                            : $0[keyPath: key] < $1[keyPath: key] }
    }
}
print(staff.sorted(on: \.salary).map(\.name))   // ["Dan", "Ana"]

func raise(_ list: inout [Employee], field: WritableKeyPath<Employee, Int>, by amount: Int) {
    for i in list.indices { list[i][keyPath: field] += amount }
}
raise(&staff, field: \.salary, by: 500)
print(staff[0].salary)                        // 9500

Tipurile de key path:

  • KeyPath: doar citire.
  • WritableKeyPath: citire și scriere pe tipuri valoare (necesită var sau inout).
  • ReferenceWritableKeyPath: scriere pe obiecte de clasă, chiar și prin referință let.

Utilizări practice: sortări și filtre configurabile (utilizatorul alege coloana), mapări generice între modele, validatori de formulare care primesc lista câmpurilor de verificat. SwiftUI le folosește în ForEach(items, id: \.id), iar SwiftData în SortDescriptor(\.date).

Key path-urile pot fi compuse: \Employee.name.count sau (\Employee.team).appending(path: \.count). Sunt Hashable, deci pot fi chei de dicționar, de exemplu pentru a ține erorile de validare pe câmp.

Ce urmărește intervievatorul: Verifică familiaritatea cu o unealtă des întâlnită în cod Swift modern. Candidații cunosc map(\.name), dar nu știu să scrie funcții generice care primesc key path-uri.

91 Mid

Extrage data dintr-un text precum "Comanda 1042 livrată pe 2026-10-31" folosind expresiile regulate din Swift 5.7. Ce avantaj au față de NSRegularExpression?

Răspuns scurt: Scrii un literal /(\d{4})-(\d{2})-(\d{2})/ și apelezi text.firstMatch(of:). Grupurile capturate sunt verificate la compilare și accesate tipizat (match.1), fără NSRange și fără conversii de indecși.

Swift 5.7 a adus tipul Regex, literali de expresii regulate și RegexBuilder (propunerile SE-0350, SE-0351, SE-0354). Necesită runtime-ul din iOS 16 sau macOS 13.

SWIFT
let text = "Comanda 1042 livrată pe 2026-10-31"
let date = /(\d{4})-(\d{2})-(\d{2})/

if let match = text.firstMatch(of: date) {
    let (_, year, month, day) = match.output
    print(year, month, day)                       // 2026 10 31
}

let named = /(?<id>\d+) livrată/
if let m = text.firstMatch(of: named) {
    print(Int(m.id) ?? 0)                         // 1042
}

print("2026-10-31".wholeMatch(of: date) != nil)   // true
print(text.replacing(/\d+/, with: "#"))           // Comanda # livrată pe #-#-#

Avantaje față de NSRegularExpression:

  • Verificare la compilare: o expresie greșită în literal este eroare de compilare, nu crash la rulare.
  • Capturi tipizate: tipul ieșirii este (Substring, Substring, Substring, Substring), iar grupurile cu nume devin proprietăți (m.id).
  • Lucrează direct cu String: fără NSRange, fără conversii UTF-16, cu respectarea caracterelor Unicode.
  • Integrare cu metode ca contains(_:), split(separator:), replacing(_:with:), trimmingPrefix(_:).

Pentru expresii lungi, RegexBuilder oferă o sintaxă declarativă mai ușor de citit, cu transformări în timpul potrivirii:

SWIFT
import RegexBuilder
let amount = Regex { "Total: "; Capture { OneOrMore(.digit) } transform: { Int($0)! } }

Literalii cu bară simplă /.../ sunt activați implicit în modul Swift 6. În modul Swift 5 ai nevoie de feature-ul BareSlashRegexLiterals sau folosești forma #/.../#, care merge oricând.

Ce urmărește intervievatorul: Verifică dacă cunoști uneltele moderne pentru procesarea textului. Candidații folosesc încă NSRegularExpression cu NSRange și nu știu de capturile tipizate.

92 Senior

Cum funcționează un result builder? Scrie un builder simplu care construiește un text HTML din linii, cu suport pentru if/else.

Răspuns scurt: Un tip marcat @resultBuilder definește metode statice, ca buildBlock, buildOptional și buildEither. Compilatorul rescrie corpul unui closure adnotat transformând fiecare expresie și fiecare ramură în apeluri la aceste metode. Așa funcționează body din SwiftUI, prin @ViewBuilder.

Un result builder este o transformare făcută de compilator. Într-un closure marcat cu builder-ul, expresiile scrise pe rând nu sunt ignorate, ci colectate și combinate prin metodele statice ale builder-ului.

SWIFT
@resultBuilder
enum HTMLBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.filter { !$0.isEmpty }.joined(separator: "\n")
    }
    static func buildOptional(_ part: String?) -> String { part ?? "" }
    static func buildEither(first part: String) -> String { part }
    static func buildEither(second part: String) -> String { part }
    static func buildArray(_ parts: [String]) -> String { parts.joined(separator: "\n") }
}

func page(@HTMLBuilder _ content: () -> String) -> String { content() }

let loggedIn = true
let items = ["Swift", "Git"]
let html = page {
    "<h1>Cursuri</h1>"
    if loggedIn {
        "<p>Bine ai revenit</p>"
    } else {
        "<p>Autentifică-te</p>"
    }
    for item in items {
        "<li>\(item)</li>"
    }
}
print(html)

Compilatorul transformă corpul aproximativ în HTMLBuilder.buildBlock("<h1>...", buildEither(first: "<p>Bine..."), buildArray([...])).

Metodele principale:

  • buildBlock: combină instrucțiunile unui bloc.
  • buildOptional: pentru if fără else.
  • buildEither(first:) și buildEither(second:): pentru if/else și switch.
  • buildArray: pentru for-in.
  • buildExpression: convertește fiecare expresie, util ca să accepți mai multe tipuri.

În SwiftUI, @ViewBuilder folosește buildEither pentru a produce un tip _ConditionalContent, de aceea ramurile if pot avea view-uri de tipuri diferite, iar body rămâne some View. În SDK-urile recente, buildBlock folosește parameter packs (Swift 5.9), deci limita istorică de 10 view-uri copil a dispărut.

Nu orice cod este permis în builder: declarațiile let sunt permise, dar instrucțiuni ca return sau guard nu, pentru că nu au o transformare definită.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul din spatele DSL-urilor ca SwiftUI. Candidații văd body ca pe „magie” și nu știu că ramurile if sunt tratate de metode ale builder-ului.

93 Senior

Ce sunt tipurile noncopyable (~Copyable) introduse în Swift 5.9 și ce fac consuming și borrowing? Ce afișează codul?

SWIFT
struct Ticket: ~Copyable {
    let id: Int
    consuming func redeem() { print("folosit \(id)") }
    deinit { print("distrus \(id)") }
}

func demo() {
    let ticket = Ticket(id: 7)
    ticket.redeem()
    // ticket.redeem()
}
demo()

Răspuns scurt: Afișează folosit 7, apoi distrus 7. Un tip ~Copyable are o singură instanță care nu poate fi copiată; consuming preia proprietatea și încheie viața valorii la finalul metodei, deci al doilea redeem() ar fi eroare de compilare.

Implicit, toate tipurile din Swift sunt Copyable: atribuirea sau transmiterea unei valori o copiază (sau copiază referința). Cu ~Copyable (SE-0390, Swift 5.9) declari un tip a cărui valoare are un proprietar unic, la fel ca în Rust.

În exemplu:

  • ticket deține valoarea.
  • redeem() este consuming, deci preia proprietatea lui self. După apel, ticket nu mai poate fi folosit; compilatorul raportează la a doua linie „'ticket' used after consume”.
  • La finalul metodei consumatoare, valoarea este distrusă și rulează deinit. Da, structurile noncopyable pot avea deinit.

Modificatori de parametri (SE-0377):

  • borrowing: funcția primește acces doar de citire, fără să preia proprietatea. Apelantul păstrează valoarea.
  • consuming: funcția preia valoarea; apelantul nu o mai poate folosi.
  • inout: acces exclusiv de modificare, valoarea revine apelantului.
SWIFT
func inspect(_ t: borrowing Ticket) { print("verific \(t.id)") }
func archive(_ t: consuming Ticket) { print("arhivez \(t.id)") }

Există și operatorul consume x (SE-0366), care încheie explicit viața unei variabile.

Utilizări:

  • Resurse unice: descriptori de fișier, conexiuni, token-uri care trebuie închise exact o dată. Compilatorul previne dublul close și folosirea după închidere.
  • Performanță: valori mari fără copii accidentale și fără numărare de referințe.

Din Swift 6 (SE-0427), genericele și protocoalele pot accepta tipuri noncopyable prin ~Copyable, iar Optional și Result le suportă. Limita principală: multe API-uri din biblioteca standard, inclusiv colecțiile obișnuite, cer încă Copyable.

Ce urmărește intervievatorul: Verifică interesul pentru evoluția limbajului și înțelegerea modelului de proprietate. Este un subiect de nivel senior, dar apare tot mai des la echipele care lucrează pe performanță.

94 Senior

Ce sunt macro-urile din Swift 5.9? Care este diferența dintre un macro freestanding și unul attached și cum se implementează?

Răspuns scurt: Macro-urile generează cod la compilare. Cele freestanding se apelează cu #nume(...) și produc o expresie sau declarații, iar cele attached se pun cu @Nume pe o declarație și îi adaugă membri, conformități sau accesori. Se implementează într-un plugin de compilator cu SwiftSyntax.

Spre deosebire de macro-urile din C, care înlocuiesc text, macro-urile Swift (SE-0382, SE-0389) lucrează pe arborele de sintaxă, iar codul generat este verificat de compilator ca orice alt cod.

Freestanding (#): apar singure, ca expresii sau declarații. Exemple reale: #Preview în SwiftUI, #expect și #require în Swift Testing, #Predicate în Foundation.

Attached (@): se atașează unei declarații și o extind. @Observable adaugă unei clase urmărirea proprietăților, @Model din SwiftData transformă o clasă în entitate persistentă. Rolurile posibile includ member (membri noi), peer (declarații alăturate), accessor (getter și setter), extension (conformități).

Declarația unui macro arată către implementare:

SWIFT
@freestanding(expression)
public macro stringify<T>(_ value: T) -> (T, String) =
    #externalMacro(module: "MyMacros", type: "StringifyMacro")

let (result, code) = #stringify(2 + 3)    // (5, "2 + 3")

Implementarea StringifyMacro este un tip care primește nodul de sintaxă al apelului și întoarce sintaxa nouă, folosind biblioteca SwiftSyntax. Codul stă într-un target separat de tip macro în Swift Package Manager și rulează ca plugin al compilatorului, într-un sandbox, fără acces la rețea sau la fișiere.

În Xcode, click dreapta pe macro și „Expand Macro” arată codul generat, ceea ce ajută mult la depanare.

Costuri și riscuri de discutat:

  • Dependența de swift-syntax poate crește timpul de compilare, mai ales în build-urile curate.
  • Macro-urile ascund cod: un coleg trebuie să știe ce generează @Observable ca să înțeleagă comportamentul.
  • Sunt potrivite pentru boilerplate repetitiv și bine definit (conformități, înregistrări, validări), nu pentru logică de business.

Ce urmărește intervievatorul: Verifică dacă înțelegi uneltele pe care se bazează framework-urile moderne Apple. Candidații folosesc @Observable fără să știe că e un macro și ce generează.

95 Senior

Un API trimite o listă de blocuri de conținut, fiecare cu un câmp type ("text" sau "image") și câmpuri diferite în funcție de tip. Cum le decodezi într-un enum cu valori asociate și ce faci cu tipurile necunoscute?

Răspuns scurt: Implementezi manual init(from:): citești întâi type dintr-un container cu chei, apoi decodezi câmpurile potrivite fiecărui caz. Pentru tipuri necunoscute adaugi un caz unknown în loc să arunci eroare, ca un singur bloc nou să nu strice decodarea întregii liste.

Sinteza automată a lui Codable pentru enum-uri cu valori asociate produce un format propriu (cheia este numele cazului), care rar se potrivește cu un API real. Pentru un câmp discriminator scrii init(from:) manual:

SWIFT
import Foundation

enum Block: Decodable {
    case text(String)
    case image(url: String, width: Int)
    case unknown(type: String)

    private enum CodingKeys: String, CodingKey { case type, value, url, width }

    init(from decoder: any Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        let type = try c.decode(String.self, forKey: .type)
        switch type {
        case "text":
            self = .text(try c.decode(String.self, forKey: .value))
        case "image":
            self = .image(url: try c.decode(String.self, forKey: .url),
                          width: try c.decodeIfPresent(Int.self, forKey: .width) ?? 0)
        default:
            self = .unknown(type: type)
        }
    }
}

let json = """
[{"type":"text","value":"Salut"},
 {"type":"image","url":"a.png"},
 {"type":"video","src":"v.mp4"}]
""".data(using: .utf8)!

let blocks = try JSONDecoder().decode([Block].self, from: json)
print(blocks.count)   // 3

Decizii de discutat:

  • Compatibilitate înainte: dacă default ar arunca DecodingError, un singur bloc de tip nou ar face decodarea întregii liste să eșueze, iar versiunile vechi ale aplicației ar afișa un ecran gol. Cazul unknown permite interfeței să-l ignore sau să afișeze un mesaj de tip „actualizează aplicația”.
  • Câmpuri opționale: decodeIfPresent cu valoare implicită tolerează lipsa câmpului; decode ar arunca.
  • Testare: păstrezi exemple JSON reale în teste, inclusiv tipuri necunoscute și câmpuri lipsă.

Pentru Encodable, scrii simetric encode(to:). Când variantele au multe câmpuri, o alternativă este ca fiecare caz să conțină un struct Decodable propriu, decodat din același decoder: self = .image(try ImageBlock(from: decoder)).

Ce urmărește intervievatorul: Este o problemă practică frecventă, care testează stăpânirea Codable dincolo de cazurile automate. Candidații aruncă eroare la tipuri necunoscute, fără să se gândească la versiunile vechi ale aplicației.

Situații practice și comportamentale

96 Junior

Un coleg care vine din Java nu înțelege de ce, după var b = a; b.append(4), tabloul a nu s-a schimbat. Cum i-ai explica diferența dintre tipurile valoare și tipurile referință?

Răspuns scurt: Aș porni de la o analogie (o copie a unui document față de un link partajat), aș arăta un exemplu scurt cu struct și class, apoi aș explica de ce în Swift Array, String și Dictionary sunt valori, iar copierea e ieftină datorită copy-on-write.

Un răspuns structurat are patru pași.

1. Analogia. Un tip valoare este ca un document trimis ca fișier atașat: fiecare primește copia lui, iar modificările nu se văd la ceilalți. Un tip referință este ca un link către un document online: toți cei care au link-ul văd aceleași modificări.

2. Exemplul concret, scris împreună cu colegul:

SWIFT
struct PointS { var x = 0 }
final class PointC { var x = 0 }

var s1 = PointS(); var s2 = s1; s2.x = 5
let c1 = PointC(); let c2 = c1; c2.x = 5
print(s1.x, c1.x)    // 0 5

3. Legătura cu Java. În Java, ArrayList și String sunt obiecte, deci atribuirea copiază referința. În Swift, Array, String, Dictionary și Set sunt struct-uri, deci atribuirea creează o valoare independentă. Ca să nu fie lent, Swift folosește copy-on-write: datele se copiază efectiv abia la prima modificare a unei copii partajate.

4. Consecințele practice:

  • Poți transmite un tablou unei funcții fără teama că ți-l va modifica.
  • Datele în valori sunt mai sigure în cod concurent, pentru că fiecare task are copia lui.
  • Clasele rămân pentru lucruri cu identitate și stare partajată intenționat, de exemplu un serviciu de rețea sau un cache.

Aș încheia cu o întrebare de verificare („ce se întâmplă dacă PointS ar conține o clasă?”), ca să mă asigur că a înțeles și cazul combinat. La interviu, contează să arăți că explici răbdător, pornind de la ce știe deja colegul, și că verifici înțelegerea, nu doar că recitezi definiția.

Ce urmărește intervievatorul: Verifică atât înțelegerea conceptului, cât și abilitatea de a-l comunica. Răspunsurile slabe repetă definiția fără exemplu și fără legătură cu experiența colegului.

97 Mid

În rapoartele de crash apare frecvent „Unexpectedly found nil while unwrapping an Optional value” într-un ecran de profil. Cum investighezi și cum rezolvi problema?

Răspuns scurt: Simbolizez raportul ca să găsesc linia exactă, identific valoarea despachetată forțat și de unde vine, reproduc cazul cu datele care produc nil, apoi înlocuiesc ! cu o tratare explicită și adaug un test pentru caz. La final previn repetarea printr-o regulă de lint.

Un răspuns bun descrie pașii în ordine.

1. Localizarea. Deschid raportul în Xcode Organizer sau în unealta de crash reporting folosită de echipă și verific că are simboluri (fișierele dSYM ale build-ului). Stack trace-ul simbolizat dă fișierul și linia exactă. Mă uit și la versiunea aplicației, versiunea de iOS și dacă problema a apărut după o anumită lansare.

2. Identificarea sursei de nil. Pe linia respectivă caut !, try!, as! sau o proprietate declarată cu !. Întrebarea este de unde vine valoarea: un câmp din JSON care lipsește pentru unii utilizatori, o cheie absentă din dicționar, un @IBOutlet folosit înainte de încărcarea view-ului, un URL(string:) cu caractere speciale.

3. Reproducerea. Creez datele care declanșează cazul (de exemplu un profil fără poză) și confirm crash-ul local sau într-un test unitar.

4. Corectura. Înlocuiesc force unwrap-ul cu o tratare care are sens pentru produs:

SWIFT
// înainte
let url = URL(string: profile.avatarPath!)!

// după
guard let path = profile.avatarPath, let url = URL(string: path) else {
    showPlaceholderAvatar()
    return
}

Dacă valoarea ar trebui să existe mereu, decid dacă problema e de fapt la server sau în modelul de date (câmp opțional în API, dar neopțional în aplicație).

5. Prevenția. Adaug un test pentru cazul găsit, activez regula force_unwrapping din SwiftLint, revizuiesc alte locuri cu același tipar și monitorizez rata de crash după lansare.

Ce caută intervievatorul: un proces sistematic, nu „pun ? peste tot”, și grija pentru cauza reală.

Ce urmărește intervievatorul: Verifică metoda de depanare în producție și maturitatea în tratarea opționalelor. Răspunsul slab este înlocuirea mecanică a lui ! cu ?, care ascunde problema în loc să o rezolve.

Eroarea, în practică:Unexpectedly found nil while unwrapping an Optional

98 Mid

La code review găsești într-un pull request al unui coleg mai junior multe !, try! și as!. Cum formulezi feedback-ul?

Răspuns scurt: Dau feedback concret și explicat pe fiecare caz, diferențiind situațiile acceptabile de cele riscante, propun alternativa în cod și ofer o discuție scurtă dacă tiparul se repetă. Tonul e despre cod și risc, nu despre persoană.

Un răspuns bun arată atât competența tehnică, cât și modul de colaborare.

1. Clasific cazurile. Nu toate sunt greșite:

  • try! Regex("[0-9]+") cu un literal constant sau URL(string: "https://exemplu.ro")! cu un text fix sunt acceptabile, eventual cu un comentariu.
  • json["user"] as! [String: Any], Int(textField.text!)! sau try! decoder.decode(...) pe date din rețea sunt crash-uri care așteaptă să se întâmple.

2. Comentez concret, cu alternativă. În loc de „nu folosi force unwrap”, scriu:

SWIFT
// Dacă serverul nu trimite câmpul, aplicația crapă aici.
// Propunere:
guard let age = Int(ageText) else {
    showError(.invalidAge)
    return
}

Explic riscul (ce date produc crash-ul) și ofer soluția, ca să fie ușor de aplicat.

3. Ton și prioritizare. Marchez clar ce blochează merge-ul (riscuri reale de crash) și ce e sugestie. Formulez la persoana întâi plural sau ca întrebare: „ce se întâmplă dacă avatarPath lipsește?”. Laud ce e bine făcut în PR.

4. Abordez tiparul, nu doar cazurile. Dacă e un obicei, propun o discuție de 15 minute sau pairing, în care trecem prin uneltele alternative: guard let, ??, try? cu log, erori tipizate.

5. Automatizez. Propun echipei regulile SwiftLint force_unwrapping, force_try și force_cast, ca problema să fie prinsă înainte de review, iar discuțiile să rămână despre design.

Intervievatorul vrea să vadă că poți ridica standardul echipei fără să demotivezi colegii.

Ce urmărește intervievatorul: Verifică judecata tehnică și abilitățile de comunicare în review. Răspunsurile slabe sunt fie prea permisive, fie interdicții absolute fără explicații.

Eroarea, în practică:Unexpectedly found nil while unwrapping an Optional'try!' expression unexpectedly raised an error

99 Senior

Echipa activează modul de limbaj Swift 6 pe un proiect existent și apar sute de erori de concurență (Sendable, izolare pe actori). Cum ai organiza migrarea?

Răspuns scurt: Aș migra treptat: întâi verificarea strictă ca avertismente în modul Swift 5, modul cu modul, începând cu modelele și utilitarele fără dependențe. Marchez modelele ca Sendable, stratul de interfață cu @MainActor și starea partajată cu actori, iar abia apoi trec fiecare target pe Swift 6.

Un răspuns structurat:

1. Nu comuta totul odată. Las proiectul în modul Swift 5 și activez SWIFT_STRICT_CONCURRENCY = complete (sau StrictConcurrency în Package.swift) pentru câte un target. Problemele apar ca avertismente, iar build-ul continuă să funcționeze.

2. Ordinea modulelor. Încep cu modulele frunză (modele, utilitare, networking), care nu depind de altele. Corecturile lor elimină multe avertismente în modulele care le folosesc.

3. Corecturile tipice, în ordinea preferinței:

  • Modele de date ca struct cu proprietăți imutabile, marcate Sendable (adesea compilatorul îl deduce singur pentru tipuri interne).
  • View model-uri și cod de interfață marcate @MainActor.
  • Starea mutabilă partajată (cache-uri, registre) mutată într-un actor sau protejată de un Mutex.
  • Closures trimise între domenii marcate @Sendable, fără capturi de stare mutabilă.

4. Dependențe externe. Pentru biblioteci încă nemigrate folosesc @preconcurrency import, care reduce diagnosticele la granița cu ele.

5. Scăpări controlate. @unchecked Sendable și nonisolated(unsafe) sunt acceptabile doar cu sincronizare reală în spate (de exemplu un lock) și cu un comentariu care explică de ce e sigur. Le țin într-o listă de revizuit.

6. Finalizarea. Când un target nu mai are avertismente, îl trec pe modul Swift 6 și rulez testele, inclusiv cu Thread Sanitizer.

Aș pune și reguli de echipă: cod nou scris direct în stil Swift 6, un ghid scurt cu tiparele alese și revizuirea în PR a fiecărui @unchecked. Din Swift 6.2 există și opțiunea de izolare implicită pe MainActor pentru targeturile de aplicație, care reduce mult zgomotul pentru codul de interfață; merită evaluată înainte de a adăuga adnotări peste tot.

Ce urmărește intervievatorul: Verifică experiența practică cu Swift 6 și capacitatea de a planifica o schimbare mare. Răspunsul slab este „pun @unchecked Sendable și @MainActor peste tot până compilează”.

100 Senior

O funcție care procesează câteva zeci de mii de înregistrări durează mai multe secunde pe dispozitiv. Cum abordezi optimizarea?

Răspuns scurt: Întâi măsor pe un build Release cu Time Profiler din Instruments, apoi caut cauzele tipice: algoritmi O(n²), copii neintenționate ale colecțiilor, operații O(n) pe String, existențiale și trafic ARC în bucle. Corectez pe rând și remăsor după fiecare schimbare.

Un răspuns bun pornește de la măsurare, nu de la ghicit.

1. Reproducere și măsurare. Construiesc un set de date realist și rulez pe un build Release, pentru că în Debug lipsesc optimizările și rezultatele sunt distorsionate. Folosesc Instruments cu Time Profiler pe dispozitiv real și un test de performanță (measure în XCTest sau ContinuousClock) ca reper repetabil.

2. Identificarea punctelor fierbinți. Time Profiler arată arborele de apeluri. De obicei, 80% din timp e într-un loc mic.

3. Cauzele tipice în Swift:

  • Complexitate algoritmică: array.contains sau firstIndex într-o buclă (O(n²)); se înlocuiesc cu Set sau Dictionary.
  • Copii neintenționate: modificarea unui tablou care are mai mulți proprietari declanșează copy-on-write pe tot bufferul, de exemplu când tabloul e și proprietate, și variabilă locală.
  • Text: count, index(_:offsetBy:) și concatenări repetate pe String sunt O(n); lucrezi cu utf8 sau Array(text).
  • Existențiale și generice nespecializate: [any Protocol] în bucle strânse aduce dispatch dinamic; generice sau tipuri concrete permit optimizarea.
  • Trafic ARC: multe obiecte de clasă create și copiate; struct-uri sau clase final reduc costul.
  • Alocări repetate: reserveCapacity, reutilizarea formatter-elor (DateFormatter creat în buclă este o cauză clasică).

4. Corectare iterativă. Schimb un singur lucru, remăsor, păstrez doar ce aduce câștig. Adaug un test de performanță ca să nu apară regresii.

5. Arhitectură. Dacă tot durează, mut procesarea de pe main actor (funcție nonisolated async sau task separat), o împart în bucăți cu progres afișat sau o fac incremental, doar pe datele noi.

Ce urmărește intervievatorul: Verifică disciplina de a măsura înainte de a optimiza și cunoașterea costurilor specifice Swift. Candidații sar direct la „mut pe un fir de fundal”, fără să afle unde se pierde timpul.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Swift, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Swift scriind cod, nu doar citind

Curs Swift (iOS): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.