PTC
הירשם שדרג ל־Pro החשבון שלך

כיצד לבצע לוקליזציה לאפליקציית iOS שלכם: מדריך בינאום ב־SwiftUI

הכינו את אפליקציית Xcode שלכם, תרגמו .xcstrings בעזרת בינה מלאכותית, ואז העלו צילומי מסך כדי ש־PTC (Private Translation Cloud) תסקור את אפליקציית iOS המרונדרת בכל שפה. מדריך זה מציג את תהליך העבודה המלא באמצעות SwiftUI ו־String Catalogs של Xcode 15+, הדרך המודרנית והמומלצת על ידי Apple. לסקירת השירות חוצה הפלטפורמות שמכסה גם iOS וגם Android, ראו תרגום אפליקציות iOS ו־Android מבוסס בינה מלאכותית.

חלק 1: כיצד לוקליזציה ב־iOS עובדת

לוקליזציה ב־iOS היא התהליך של התאמת הטקסט, העיצוב וה־assets של האפליקציה שלכם לתמיכה במספר שפות ואזורים. עם String Catalogs שהוצגו ב־Xcode 15, תהליך העבודה פשוט משמעותית בהשוואה לגישת .strings / .stringsdict הישנה (legacy).

בינאום (i18n) לעומת לוקליזציה (l10n)

אלה הם שני שלבים נפרדים, והם צריכים להתרחש בסדר הזה:

  • בינאום (i18n) הוא התשתית הטכנית. אתם מבנים את הקוד שלכם כך שטקסט, תמונות ועיצוב יוכלו להשתנות לפי locale ללא שינויי קוד. מבוצע פעם אחת, באופן אידיאלי לפני השחרור הראשון שלכם.
  • לוקליזציה (l10n) היא העבודה המתמשכת שבאה לאחר מכן. כתיבת תרגומים, התאמת פריסות, ואספקת assets ספציפיים לכל locale עבור כל שפה חדשה.

הטעות הנפוצה ביותר היא להתייחס ללוקליזציה כמשימה שלאחר ההשקה, רק כדי לגלות שבסיס הקוד אינו מוכן. חזרה לאחור כדי לתקן מחרוזות מוטמעות בקוד, פריסות בעלות כיוון קבוע ו־formatters שאינם מודעים ל־locale ברחבי אפליקציה קיימת לוקחת הרבה יותר זמן מאשר בנייה מראש עם חשיבה על לוקליזציה.

כיצד Xcode 15+ משתמש ב־Localizable.xcstrings בתור מקור האמת

מודל הלוקליזציה של Apple ב־Xcode 15+ מתמקד בקובץ יחיד לכל target: Localizable.xcstrings. קובץ זה הוא String Catalog המפורמט כ־JSON, אשר מכיל את שפת המקור שלכם יחד עם כל תרגום, כולל צורות רבים, וריאציות ספציפיות למכשיר, ו־substitutions.

Xcode מחלץ אוטומטית מחרוזות מסוג localizable מקוד ה־SwiftUI שלכם (כל Text("..."), Label("...", systemImage:), Button("..."), וכל string interpolation שמשתמש ב־LocalizedStringKey). הרצת ה־build של האפליקציה שלכם מאכלסת את Localizable.xcstrings בכל מחרוזת מקור שחולצה.

Apple תומכת במספר פורמטים. .strings (key-value ישן), .stringsdict (צורות רבים ישנות), ו־.xcstrings (מודרני). פרויקטים חדשים צריכים להתחיל עם .xcstrings. פרויקטים קיימים מבוססי .strings יכולים לבצע הגירה דרך File > New > File > String Catalog ואפשרות הייבוא של Xcode. התיעוד הרשמי של Apple בנושא לוקליזציה מכסה את הרקע המלא.

חלק 2: הגדרת פרויקט ה־Xcode שלכם ללוקליזציה

שלב 1: הפעלת לוקליזציה. פתחו את הפרויקט שלכם ב־Xcode ובחרו את קובץ הפרויקט ב־Navigator. תחת הלשונית Info, גללו אל Localizations. אנגלית כבר מופיעה בתור שפת בסיס. לחצו על + כדי להוסיף כל שפת יעד (ספרדית, צרפתית, ערבית וכו').

שלב 2: יצירת String Catalog. לחצו קליק ימני על הפרויקט שלכם ובחרו New File from Template. חפשו String Catalog והוסיפו אותו. שמרו על השם המוגדר כברירת מחדל Localizable.xcstrings. הריצו build לפרויקט פעם אחת עם Cmd+B. ה־Xcode סורק את הקוד שלכם, מוצא כל מחרוזת מסוג localizable, ומאכלס את הקטלוג באופן אוטומטי.

שלב 3: סימון מחרוזות ללוקליזציה. ב־SwiftUI, כל מחרוזת מילולית (literal string) שמועברת אל Text(_:), Label, תוויות פעולה מסוג Button, כותרות ניווט וכו', היא אוטומטית LocalizedStringKey:

import SwiftUI

struct WelcomeView: View {
    let userName: String
    let unreadCount: Int

    var body: some View {
        VStack {
            Text("Welcome, \(userName)!")
            Text("You have \(unreadCount) unread messages")
            Button("Get Started") {
                // action
            }
        }
    }
}

ישנן שתי תבניות שבהן Xcode אינו יכול לחלץ מחרוזות אוטומטית. שתיהן נכשלות בשקט:

טיפ 1: הימנעו מהעברת משתנים אל Text. כאשר אתם מעבירים משתנה לתצוגת Text במקום מחרוזת מילולית, SwiftUI מתייחס אליו כמחרוזת רגילה ומדלג לחלוטין על חיפוש בקטלוג:

// NOT localized - SwiftUI treats the variable as a plain String
let title = "welcome_title"
Text(title)

// Localized correctly
Text(LocalizedStringKey(title))

טיפ 2: השתמשו ב־String(localized:) מחוץ לתצוגות. עבור מחרוזות שעליכם לבצע להן לוקליזציה ב־view model, בפונקציית עזר, או בכל מקום מחוץ לתצוגת SwiftUI, השתמשו ב־String(localized:) במקום במחרוזת רגילה:

let errorMessage = String(localized: "error_generic")

שלב 4: הוספת צורות רבים וגרסאות למכשירים שונים. מחרוזות דורשות לעיתים קרובות צורות שונות בהתאם להקשר.

עבור צורות רבים, התחילו עם המחרוזת בתצוגת ה־SwiftUI שלכם:

Text("\(bookCount) books on your shelf")

פתחו את ה־String Catalog, לחצו קליק ימני על המפתח, ובחרו Vary by Plural. ה־Xcode מייצר את קטגוריות הרבים אוטומטית וממלא אותן מראש עם מחרוזת המקור. עבור אנגלית תראו את One ואת Other. תקנו את השדה One ל־"%lld book on your shelf". סמנו את שניהם כנבדקים (reviewed).

כאשר תשלחו מאוחר יותר את הקטלוג ל־PTC, מבנה הרבים יעבור יחד עם הקובץ. עבור ערבית, PTC מייצרת תרגומים לכל שש קטגוריות הרבים (zero, one, two, few, many, other) מכיוון שדקדוק בערבית דורש את כל השש. ספרדית דורשת שתיים, בדיוק כמו אנגלית.

עבור וריאציות למכשירים שונים (למשל, ”Tap to continue“ ב־iPhone לעומת ”Click to continue“ ב־Mac), לחצו קליק ימני על המפתח ובחרו Vary by Device. הוסיפו את המכשירים שברצונכם להתאים אישית והזינו את המחרוזת המתאימה לכל אחד. iOS מגישה את הגרסה שתואמת למכשיר הנוכחי בזמן ריצה.

חלק 3: תרגום קובצי .xcstrings שלכם עם PTC

עבור פרויקטים קטנים תוכלו לפתוח כל עמודת שפה בקטלוג ולהקליד תרגומים ישירות. ככל שהאפליקציה שלכם גדלה, זה הופך לבלתי אפשרי לניהול על פני מאות מפתחות ועשרות שפות. PTC מבצעת את ההעלאה, התרגום והסנכרון.

שלב 1: ייצוא ה־String Catalog מ־Xcode. היכנסו אל Product > Export Localizations. ה־Xcode אורז את ה־String Catalog שלכם לתוך קובץ .xcloc לכל שפת יעד. עבור PTC, אתם זקוקים רק לקובץ ה־.xcstrings שנמצא בתוך החבילה .xcloc. לחצו קליק ימני על ה־.xcloc שיוצא ב־Finder ובחרו Show Package Contents כדי למצוא את Localizable.xcstrings.

אם אתם רואים התראה ”Unable to build project for localization string extraction“, הפרויקט שלכם משתמש ב־APIs בלעדיים ל־iOS ש־Xcode אינו יכול לקמפל מול ה־macOS SDK הפנימי שלו במהלך חילוץ מחרוזות. לתיקון: בחרו את ה־target של הפרויקט תחת TARGETS, היכנסו אל Build Settings, חפשו את ”Use Compiler to Extract Swift Strings“, והגדירו אותו כ־No. לאחר מכן ייצאו שוב.

שלב 2: הרשמה ל־PTC. תקופת הניסיון מכסה 20,000 מילים ל־2 שפות, מה שמספיק כדי לבצע לוקליזציה לרוב האפליקציות. לאחר תקופת הניסיון, PTC פועלת במודל Pay-As-You-Go. ללא מנוי, 500 המילים הראשונות בכל חודש הן בחינם.

שלב 3: הגדרת הפרויקט שלכם ותרגום. גררו את Localizable.xcstrings לתוך PTC. השאירו את שם קובץ הפלט כ־Localizable.xcstrings. ה־Xcode מצפה לשם המדויק הזה בעת פענוח מחרוזות שעברו לוקליזציה. בחרו את שפות היעד שלכם.

PTC מייצרת אוטומטית תיאור של האפליקציה שלכם מהקובץ שהועלה. סקרו אותו וערכו במידת הצורך. אם יש לכם קובצי תרגום קיימים, העלו אותם כדי ש־PTC תוכל להתאים את עצמה לסגנון שלכם. אחרת, בצעו תרגום מאפס. הוסיפו מונחים למילון מונחים. PTC מוסיפה את שם האפליקציה שלכם אוטומטית. הוסיפו כל טרמינולוגיה ספציפית למותג שצריכה להיות מתורגמת בדרך מסוימת או לא להיות מתורגמת כלל. לחצו על Start Translation.

שלב 4: סקירה והורדה. לאחר שהתרגום מסתיים, הלשונית Translations מציגה כל מחרוזת מקור לצד התרגום שלה. כל מי שתוסיפו לפרויקט יוכל לערוך תרגומים ישירות. אם משהו נראה לא תקין, דווחו על בעיה בתרגום ספציפי ובקשו תרגום מחדש חינמי מבוסס בינה מלאכותית. PTC לומדת מהמשוב ומיישמת אותו על מחרוזות עתידיות באותו פרויקט.

אם מחרוזת מתורגמת כלשהי חורגת ממגבלת האורך שלה, היא מודגשת. יש לכם שלוש אפשרויות. לאשר את התרגום הארוך יותר אם ה־UI שלכם יכול להכיל אותו. לבקש תרגום מחדש שמתאים למגבלה הנוכחית. להתאים את המגבלה תחת הגדרות > אורכי תרגום.

חלק 4: שילוב קובצי .xcstrings מתורגמים בפרויקט ה־Xcode שלכם

יש לכם שלוש אפשרויות.

אפשרות 1: הורדה ידנית של קבצים מ־PTC. היכנסו ללשונית Resource Files והורידו את ה־ZIP. הוא מכיל קובץ Localizable.xcstrings יחיד עם מחרוזות המקור שלכם באנגלית וכל התרגומים. סגרו את Xcode, החליפו את ה־Localizable.xcstrings הקיים בתיקיית הפרויקט שלכם בזה שהורדתם מ־PTC, ואז הפעילו מחדש את Xcode. התרגומים שלכם יופיעו ב־String Catalog עם סימון וי (checkmark) לצד כל שפה שתורגמה במלואה.

אפשרות 2: אינטגרציית Git. אם הפרויקט שלכם מאוחסן ב־GitHub, ב־GitLab או ב־Bitbucket, חברו את PTC ישירות. אינטגרציית Git היא תכונת Pro. הפעילו את Pay-As-You-Go כדי לגשת אליה. בלוח הבקרה שלכם ב־PTC, היכנסו אל הגדרות > Merge Requests ולחצו על Add Git Integration. ספקו את כתובת ה־URL של המאגר שלכם, העניקו ל־PTC גישה, ובחרו את הענף וקובצי המקור שלכם. PTC שולחת merge request עם התרגומים.

אפשרות 3: שימוש ב־API. ה־API של PTC מעניק לכם שליטה מלאה על מתי וכיצד תרגומים נמשכים אל צינור ה־build שלכם. כאשר Pay-As-You-Go מופעל, היכנסו אל הגדרות > ניהול אסימוני API, לחצו על Add access token, ולאחר מכן עיינו ב־API reference של PTC עבור ה־endpoints.

בורר שפה בתוך האפליקציה (חלק מהאפליקציות זקוקות לכך) יכול לדרוס את ה־locale של המערכת ברמת התצוגה דרך סביבת ה־SwiftUI:

import SwiftUI

@MainActor
class LocaleManager: ObservableObject {
    @Published var currentLocale: Locale = .current

    func setLocale(_ identifier: String) {
        currentLocale = Locale(identifier: identifier)
        UserDefaults.standard.set([identifier], forKey: "AppleLanguages")
    }
}

struct LanguageSettingsView: View {
    @EnvironmentObject var localeManager: LocaleManager

    var body: some View {
        List {
            Button("English") { localeManager.setLocale("en") }
            Button("Español") { localeManager.setLocale("es") }
            Button("Français") { localeManager.setLocale("fr") }
        }
        .environment(\.locale, localeManager.currentLocale)
    }
}

שינוי AppleLanguages בזמן ריצה דורש הפעלה מחדש של האפליקציה עבור חלק ממחרוזות המערכת. הדריסה של סביבת ה־SwiftUI נכנסת לתוקף באופן מיידי עבור תצוגות בתוך הטווח הזה.

חלק 5: בדיקת אפליקציית ה־iOS שלכם שעברה לוקליזציה

בדיקה עם הגדרת השפה של ה־scheme. הדרך המהירה ביותר לבדוק שפה ספציפית היא דרך ה־scheme שלכם ב־Xcode. היכנסו אל Product > Scheme > Edit Scheme, לחצו על הלשונית Options, שנו את App Language ואת App Region ל־locale הרצוי, והריצו עם Cmd+R. זה עובד היטב עבור רוב השפות. אתם אמורים לראות את אותה פריסה ואותו עיצוב כמו באנגלית כאשר כל הטקסט מוחלף.

בדיקת ערבית ושפות RTL אחרות. הגדרת השפה של ה־scheme יכולה להיות לא אמינה ב־Simulator עבור שפות RTL. השתמשו בהגדרות השפה של ה־Simulator עצמו:

  1. הריצו את האפליקציה עם Cmd+R כדי לפתוח את ה־Simulator.
  2. לחצו על Cmd+Home כדי לעבור למסך הבית.
  3. פתחו את Settings > General > Language & Region.
  4. הקישו על Add Language, בחרו בערבית, והגדירו אותה כשפה הראשית.
  5. ה־Simulator מופעל מחדש. פתחו את האפליקציה שלכם ממסך הבית.

בדקו שהטקסט מופיע בערבית ושהפריסה עוברת היפוך (mirrors) כראוי, כאשר כותרת הניווט והתוכן מיושרים לימין. לבדיקת תצוגה מקדימה מבלי להתחייב לשפה, Edit Scheme > Options > Application Language > Right-to-Left Pseudolanguage מהווה בדיקה מהירה יותר. לבדיקת התרחבות טקסט (text expansion), השתמשו ב־Double-Length Pseudolanguage כדי לראות כיצד פריסות מתמודדות עם מחרוזות ארוכות ב־30-40% לפני שאתם מתחייבים לשפת יעד.

שיטות עבודה מומלצות ללוקליזציה ב־iOS

  • בדקו את ה־UI שלכם עבור אורכי טקסט משתנים. גרמנית ארוכה בכ־30% מאנגלית. צרפתית וספרדית בכ־20%. השתמשו במערכת הפריסה הגמישה של SwiftUI, אפשרו לתוויות לגדול ולגלוש באופן טבעי, הימנעו מאילוצי רוחב קבוע על רכיבי טקסט, ובדקו במספר שפות שונות במהלך הפיתוח.
  • אל תדלגו על וריאציות של צורות רבים. ברוסית יש שלוש קטגוריות רבים, בערבית יש שש, ביפנית אין כלל. String Catalogs מטפלים בזה כאשר אתם מוסיפים את השפה. ודאו שכל השדות שנוצרו מלאים לפני שאתם משחררים את האפליקציה.
  • בצעו לוקליזציה לתמונות ול־assets. תמונות עם טקסט או ויזואליה ספציפית לתרבות דורשות וריאציות שעברו לוקליזציה. ב־Assets.xcassets, בחרו את התמונה וב־Attributes Inspector לחצו על Localize. בחרו את השפות שעבורן תרצו וריאציות והחליפו כל אחת בגרסה המתאימה. iOS מגישה את התמונה הנכונה בהתבסס על ה־locale של המשתמש.
  • שמרו על שפת הבסיס שלכם שלמה. שפת הבסיס שלכם (בדרך כלל אנגלית) היא החלופה לכל תרגום חסר. בסיס שאינו שלם עלול לגרום לשימוש בחלופות באופן בלתי צפוי אפילו בשפות שמתורגמות במלואן. Xcode מסמן מחרוזות בסיס חסרות או לא מעודכנות במהלך ה־build.
  • בצעו לוקליזציה לדף האפליקציה בחנות App Store. אפליקציה שעברה לוקליזציה עם דף אפליקציה באנגלית בלבד מאבדת משתמשים בשלב הגילוי. ב־App Store Connect תוכלו לבצע לוקליזציה לשם האפליקציה, כותרת המשנה, התיאור, ומילות המפתח לכל טריטוריה. מילות מפתח הן בעלות ערך מיוחד. Apple מאנדקסת מילות מפתח ממספר locales לכל טריטוריה, מה שמכפיל למעשה את תקציב התווים של מילות המפתח שלכם מעבר ל־100 התווים הסטנדרטיים. השתמשו בתכונה Paste to Translate של PTC עבור תוכן ה־App Store.
  • השתמשו ב־formatters המודעים ל־locale. Date.FormatStyle, Decimal.FormatStyle, ו־formatters המודעים ל־Locale. לעולם אל תטמיעו בקוד (hardcode) את "$" או "MM/DD/YYYY".
  • השתמשו ב־%lld עבור ספירת מספרים שלמים וב־String(localized: "You have ^[\(count) message](inflect: true)") היכן שחלה התאמה דקדוקית אוטומטית (grammatical agreement) של Apple.

סקירה חזותית של התרגום לאפליקציית ה־iOS המתורגמת שלכם - לשחרר בלי QA ידני לכל שפה

לאחר ש־PTC מתרגמת את ה־.xcstrings שלכם, עדיין עליכם לאמת את האפליקציה הרצה בכל שפה. באופן מסורתי זהו סבב QA ידני של מספר ימים לכל שחרור. תווית מתורגמת עלולה לגרום להצפת תוכן בשורת הניווט בגרמנית. המילה ”Send“ עשויה להיות מתורגמת כשם עצם בצרפתית כאשר הכפתור הצריך פועל. מחרוזת אנגלית המוטמעת בקוד מחוץ ל־Text(_:) תישאר באופן בולט לא מתורגמת באפליקציית ה־iOS הרצה.

ה־AI Visual QA של PTC מחליף את הסבב הזה. עבור אפליקציות iOS נייטיב (תהליך ה־extension אינו רלוונטי), השתמשו בהעלאת צילומי מסך. צלמו את המסכים הקריטיים של האפליקציה הרצה בכל שפת יעד (התחברות, הלשונית הראשית, הגדרות, מקרי קצה) והעלו אותם ל־PTC. ה־vision AI של PTC בוחן כל מסך ו:

  • מתקן בעיות ב־.xcstrings כאשר ל־PTC יש שליטה עליהן. מתרגם מחדש חלק דיבר שגוי, בוחר מילה נרדפת קצרה יותר שמתאימה לשורת הניווט, ומייצר מחדש צורת רבים עם התאמה דקדוקית נכונה.
  • מייצר פרומפט ל־Cursor / Claude Code כאשר הבעיה נמצאת בקוד ה־Swift שלכם. LocalizedStringKey חסר, String המוטמע בקוד מחוץ למערכת הלוקליזציה, או משפט שנבנה על ידי שרשור במקום substitution.

התוצר: אפליקציית iOS מאומתת לכל שחרור. לא .xcstrings מתורגם כשעוד נותר QA ידני לבצע.

תרגום דף האפליקציה בחנות ה־App Store, הערות הגרסה, והודעות הפוש שלכם

תיאור ה־App Store שלכם, הערות הגרסה (what's-new), וטקסט הודעות הפוש נמצאים מחוץ ל־Localizable.xcstrings. ה־Paste to Translate של PTC מטפל בטקסט הזה באותו פרויקט. הדביקו את טקסט המקור בלוח הבקרה של PTC, בחרו שפות יעד, וקבלו חזרה תרגומים שמשתמשים באותו מילון מונחים ובאותו טון המותג כמו המחרוזות בתוך האפליקציה שלכם. Apple מאנדקסת מילות מפתח ממספר locales לכל טריטוריה, לכן דפי אפליקציה בחנות שעברו לוקליזציה הם בעלי ערך מיוחד עבור גילוי האפליקציה.

תרגום תוכן משתמשים בתוך האפליקציה בעזרת ה־API של PTC

צ'אט בתוך האפליקציה, פוסטים חברתיים, וביקורות משתמשים דורשים תרגום עם הגעת התוכן. ה־REST API של PTC מתרגם את התוכן הזה לפי דרישה עם אימות טוקן Bearer, תוך שימוש באותו מילון מונחים ובאותו טון המותג כמו תרגומי ה־.xcstrings שלכם.

תיקון לוקליזציה ב־iOS שאינה עובדת

הסיבה הנפוצה ביותר היא שקובץ הלוקליזציה אינו נכלל ב־target של האפליקציה. לחצו על Localizable.xcstrings ב־Navigator, פתחו את ה־File Inspector, ובדקו שה־target של האפליקציה שלכם מסומן תחת Target Membership. בנוסף, ודאו שהשפה מופיעה תחת הסעיף Localizations של הפרויקט שלכם בלשונית Info. אם שניהם נראים תקינים, נקו את תיקיית ה־build עם Shift+Cmd+K והריצו build מחדש.

פורמטים של קובצי לוקליזציה ב־iOS: .xcstrings, .strings, .stringsdict, .xliff

.xcstrings (String Catalog) הוא ברירת המחדל הנוכחית מאז Xcode 15. קובץ יחיד מבוסס JSON המאגד את כל המחרוזות, כללי צורות הרבים, וגרסאות ספציפיות למכשירים. .strings הוא פורמט ה־key-value הישן (legacy), שעדיין תקף בבסיסי קוד ישנים יותר, ומצומד ל־.stringsdict עבור צורות רבים. .xliff ו־.xcloc הם פורמטים לייצוא עבור העברה למתרגמים. הם אינם פורמטים לאחסון.

לוקליזציה לשם האפליקציה שלכם בעזרת InfoPlist.strings

צרו קובץ InfoPlist.strings ובצעו לו לוקליזציה עבור כל שפה נתמכת. בכל גרסת שפה, הוסיפו את CFBundleDisplayName = "Your Translated App Name";. בחרו את הקובץ ב־Navigator, פתחו את ה־File Inspector, ולחצו על Localize כדי להוסיף וריאציות שפה. iOS מציגה את שם האפליקציה הנכון בהתבסס על שפת המכשיר.

שינוי שפת אפליקציית ה־iOS ללא הפעלה מחדש

iOS אינה מספקת API נייטיב עבור זה. הגישה הסטנדרטית היא להגדיר את AppleLanguages ב־UserDefaults ולבקש מהמשתמש להפעיל מחדש:

UserDefaults.standard.set(["es"], forKey: "AppleLanguages")
UserDefaults.standard.synchronize()

השינוי נכנס לתוקף בפעם הבאה שהאפליקציה מופעלת. אם אתם זקוקים להחלפה בתוך הפעלה (in-session switching) ללא הפעלה מחדש, עליכם לנהל את הלוקליזציה באופן ידני על ידי טעינת ה־bundle המתאים עבור השפה שנבחרה.

מדוע iOS משתמשת באנגלית כחלופה עבור שפות שאינן נתמכות

iOS משתמשת בשפת הבסיס שלכם כחלופה כאשר תרגום אינו זמין. זוהי התנהגות צפויה. כדי לצמצם את השימוש בחלופות, ודאו שה־String Catalog שלכם אינו מציג מחרוזות חסרות או לא מעודכנות לפני כל שחרור.

עד כמה לוקליזציה מבוססת בינה מלאכותית מדויקת עבור אפליקציית iOS שלמה

PTC משתמשת בבינה מלאכותית כדי לתרגם קובצי .xcstrings, .strings, ו־.stringsdict בתוך דקות, תוך שמירה אוטומטית על כללי צורות רבים ועל מצייני מיקום. רוב המחרוזות המתורגמות עולות לאוויר ללא עריכות. לקבלת התוצאות הטובות ביותר, ספרו ל־PTC על האפליקציה שלכם במהלך ההגדרה כדי שהתרגומים ישקפו את הטון והטרמינולוגיה הנכונים.

לאילו שפות ב־iOS כדאי לבצע לוקליזציה קודם

ספרדית, צרפתית, גרמנית, יפנית, וסינית מפושטת הן נקודות התחלה נפוצות מעבר לאנגלית. אם לאפליקציה שלכם כבר יש משתמשים באזור מסוים, תנו עדיפות לשפה שלהם קודם. עבור עלות ההתאמה הנמוכה ביותר, התחילו עם שפות שקרובות גיאוגרפית או תרבותית לשוק הבסיס שלכם.

בצעו לוקליזציה לאפליקציית ה־iOS שלכם

התחילו תקופת ניסיון של 30 יום ב־PTC - 20,000 מילים על חשבוננו, ללא כרטיס אשראי. העלו את ה־Localizable.xcstrings שלכם, תרגמו אותו בתוך דקות, ולאחר מכן העלו צילומי מסך ותנו ל־PTC לאמת את האפליקציה המרונדרת.

מאמרים קשורים: