0Pricing
Swift Academy · Lezione

Da destra a sinistra e direzione del layout

Supporti le lingue RTL e i layout speculari.

Da destra a sinistra e direzione del layout è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Lingue con scrittura da destra a sinistra

Arabo, ebraico, persiano e urdu si scrivono da destra a sinistra (RTL). Per queste persone l'intera interfaccia dovrebbe rispecchiarsi: i pulsanti di navigazione indietro devono puntare a destra, gli elenchi devono allinearsi al margine destro e l'avanzamento deve procedere da destra a sinistra. Il supporto RTL è una parte fondamentale dell'internazionalizzazione.

// RTL locales include: ar, he, fa, ur
// The whole UI mirrors, not just the text.

Inizio e fine, non sinistra e destra

La regola d'oro è progettare usando leading e trailing invece di sinistra e destra. Leading indica il punto da cui inizia la lettura: a sinistra in inglese, a destra in arabo. Usando leading e trailing, il sistema rispecchia automaticamente il layout in RTL.

// SwiftUI uses leading/trailing automatically:
// HStack { Image(...); Text("Title") }
// .padding(.leading, 16)  // flips in RTL
let edge = "leading mirrors automatically"
_ = edge

Leggere layoutDirection

SwiftUI espone la direzione corrente tramite il valore d'ambiente layoutDirection, che può essere .leftToRight o .rightToLeft. Leggetelo quando vi serve una logica dipendente dalla direzione, ad esempio per scegliere una risorsa grafica per il chevron.

// In a SwiftUI View:
// @Environment(\.layoutDirection) var direction
// let chevron = direction == .rightToLeft
//     ? "chevron.left" : "chevron.right"
let ltr = "leftToRight"
let rtl = "rightToLeft"
print(ltr, rtl)

Rispecchiare SF Symbols e immagini

Molti SF Symbols si rispecchiano automaticamente. Per le immagini personalizzate direzionali, indicate che devono invertirsi con la direzione del layout, così una freccia che punta in avanti continuerà a puntare in avanti in RTL. Il modificatore flipsForRightToLeftLayoutDirection controlla questo comportamento.

// SwiftUI:
// Image("forwardArrow")
//   .flipsForRightToLeftLayoutDirection(true)
let shouldFlip = true
_ = shouldFlip

Imporre una direzione

Talvolta una sottovista deve mantenere una direzione fissa, ad esempio un numero di telefono o un frammento di codice da sinistra a destra all'interno di un layout RTL. Sovrascrivete la direzione applicando il modificatore environment(\.layoutDirection, _) solo a quella gerarchia.

// Keep a code block LTR even in an RTL app:
// CodeView(snippet)
//   .environment(\.layoutDirection, .leftToRight)
let forced = "leftToRight subtree"
_ = forced

Allineamento del testo e multilineTextAlignment

Usate .leading e .trailing anche per l'allineamento del testo. Un paragrafo allineato con .leading aderisce automaticamente al margine destro in arabo. Evitate .left/.right, che non si invertono mai.

// Text(longBody)
//   .multilineTextAlignment(.leading) // flips in RTL
let alignment = "leading flips, left does not"
_ = alignment

Testo bidirezionale

I paragrafi RTL contengono spesso sequenze LTR, come URL, numeri e nomi di marchi in inglese. L'algoritmo bidirezionale Unicode gestisce l'ordine, ma potete racchiudere le sequenze ambigue tra caratteri di isolamento direzionale per impedire che l'ordine visivo risulti alterato.

import Foundation
// First-strong isolate keeps an embedded run intact
let isolated = "\u{2068}example.com\u{2069}"
print(isolated.count > 0)

Contenuto semantico per viste che non si rispecchiano

Alcuni controlli, come i pulsanti di riproduzione multimediale e le timeline, NON devono rispecchiarsi perché il loro significato è fisico, non legato alla direzione di lettura. L'attributo semanticContentAttribute di UIKit, con valori come .playback, .spatial e .forceLeftToRight, indica al sistema quando mantenere una direzione fissa.

// UIKit example:
// playbackBar.semanticContentAttribute = .playback
// mapOverlay.semanticContentAttribute = .spatial
let keepFixed = "playback / spatial do not mirror"
_ = keepFixed

Testare RTL senza tradurre

Non vi serve una traduzione in arabo per testare il rispecchiamento. Eseguite l'app con la Right-to-Left Pseudolanguage nelle impostazioni della lingua dell'app dello schema. L'interfaccia si rispecchia usando le stringhe esistenti, così potete individuare immediatamente i problemi causati da .left/.right inseriti manualmente.

// Edit Scheme > Run > Options >
//   App Language: Right-to-Left Pseudolanguage
let test = "mirror without real translations"
_ = test

Problemi comuni con RTL

Prestate attenzione a questi casi:

  • Allineamento o spaziatura con .left/.right inseriti manualmente.
  • Viste posizionate manualmente usando offset x fissi.
  • Immagini personalizzate direzionali che non si invertono.
  • Chevron indietro o cursori che puntano nella direzione sbagliata.
  • Stringhe bidirezionali concatenate il cui ordine risulta alterato.
// Replace fixed offsets with leading/trailing layout
// so AutoLayout / SwiftUI can mirror them.
let rule = "prefer leading/trailing everywhere"
_ = rule

Una riga pronta per RTL

Una riga ben costruita usa leading e trailing ovunque, consente ai simboli di invertirsi e impone una direzione solo quando lo richiede il significato. Una vista di questo tipo non necessita di alcuna modifica per apparire corretta sia in inglese sia in arabo.

// HStack {
//   Image(systemName: "star")
//   Text("Favorite")
//   Spacer()
//   Image(systemName: "chevron.forward") // mirrors
// }
// .padding(.horizontal, 16)
let ready = "row mirrors automatically"
_ = ready

Verifica rapida

Ricordate il principio fondamentale per un layout compatibile con RTL.

Riepilogo

Avete imparato a supportare le lingue con scrittura da destra a sinistra:

  • Progettate usando leading/trailing, mai sinistra/destra.
  • Leggete l'ambiente layoutDirection per la logica dipendente dalla direzione.
  • Invertite le immagini direzionali; sovrascrivete la direzione per le gerarchie fisse, come quelle che contengono codice o numeri di telefono.
  • Usate semanticContentAttribute per i controlli di riproduzione e spaziali che non devono rispecchiarsi.
  • Testate con la pseudolingua RTL prima della pubblicazione.

Domande Frequenti

La lezione «Da destra a sinistra e direzione del layout» è gratuita?

Sì — il testo completo di «Da destra a sinistra e direzione del layout» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Da destra a sinistra e direzione del layout»?

Supporti le lingue RTL e i layout speculari. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Da destra a sinistra e direzione del layout»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Cataloghi di stringhe e stringhe localizzate
  2. Pluralizzazione e Stringsdict
  3. Formattazione in base alle impostazioni locali
  4. Da destra a sinistra e direzione del layout
← Torna a Swift Academy