Foundation: строки, даты и локализация — бесплатный тест онлайн

Вопрос 1 из 30

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Не упускайте из виду следующее: различие графем, скаляров, кодовых единиц и байтов.

let text = "👨‍👩‍👧‍👦a"
print(text.count, text.utf8.count)

unicodeScalars.count считает расширенные графемы: здесь два символа, тогда как число UTF-8 байтов значительно больше. Наблюдаемый результат определяется тем, что `String.count` считает байты UTF-8, а не пользовательские символы. Фрагмент не требует отдельного условия: `Date` хранит календарь и часовой пояс, использованные при создании. String.count считает расширенные графемы: здесь два символа, тогда как число UTF-16 байтов значительно больше. String.count считает расширенные графемы: здесь два символа, тогда как число UTF-8 байтов значительно больше.

Вопрос 2 из 30

Что увидит разработчик после выполнения этого примера по теме «Моменты времени Date»? Не упускайте из виду следующее: абсолютное время и отличие длительности от календарного шага.

import Foundation
let start = Date(timeIntervalSince1970: 0)
let later = start.addingTimeInterval(90)
print(later.timeIntervalSince(start))

Для этого примера достаточно учесть, что `String.count` считает байты UTF-8, а не пользовательские символы. Date представляет абсолютный момент; разница равна 90 секундам. Date представляет абсолютный момент; разница равна 91 секундам. Операция с `start` корректна, поскольку `Date` хранит календарь и часовой пояс, использованные при создании. Последняя строка ведёт себя именно так, потому что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации.

Вопрос 3 из 30

Проследите типы, изменения состояния и порядок вызовов. Какое описание результата совпадает с кодом? Здесь оценивается явная конфигурация календарных вычислений.

import Foundation
var calendar = Calendar(identifier: .gregorian)
calendar.timeZone = TimeZone(secondsFromGMT: 0)!
let date = Date(timeIntervalSince1970: 0)
print(calendar.component(.year, from: date))

В григорианском календаре UTC эпоха Unix относится к 1971 году. Последняя строка ведёт себя именно так, потому что `String.count` считает байты UTF-8, а не пользовательские символы. Фрагмент не требует отдельного условия: `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Наблюдаемый результат определяется тем, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. В григорианском календаре UTC эпоха Unix относится к 1970 году.

Вопрос 4 из 30

Проследите типы, изменения состояния и порядок вызовов. Какое описание результата совпадает с кодом? Важно учесть: локализованное представление и машинный формат.

import Foundation
let value = 1234.5
let text = value.formatted(.number.locale(Locale(identifier: "de_DE")))
print(text)

Наблюдаемый результат определяется тем, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Операция с `value` корректна, поскольку `Double.init` разбирает строку с учётом текущей локали. Формат использует немецкие правила разделителей; точное оформление зависит от данных локали платформы. Формат не использует немецкие правила разделителей; точное оформление зависит от данных локали платформы. Формат использует немецкие правила разделителей; точное оформление не зависит от данных локали платформы.

Вопрос 5 из 30

Разберите строки в порядке выполнения. Какой результат получит фрагмент, посвящённый теме «Детерминированные тесты дат и локалей»? Важно учесть: управляемость времени и региональных зависимостей.

import Foundation
var calendar21 = Calendar(identifier: .gregorian)
calendar21.timeZone = TimeZone(identifier: "Europe/Tallinn")!
let formatter21 = ISO8601DateFormatter()

Фрагмент не требует отдельного условия: `Date` хранит календарь и часовой пояс, использованные при создании. Фиксированные зависимости позволяют воспроизводить сценарии перехода часового пояса и сравнивать абсолютные моменты. Операция с `calendar21` корректна, поскольку `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Для этого примера достаточно учесть, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Последняя строка ведёт себя именно так, потому что `Double.init` разбирает строку с учётом текущей локали.

Вопрос 6 из 30

Где окажется состояние программы после выполнения всех показанных операций? Не упускайте из виду следующее: цена форматирования и разделение абсолютных данных с представлением.

import Foundation
let formatterCache = Date.FormatStyle(date: .numeric, time: .shortened)

Фрагмент не требует отдельного условия: `String.count` считает байты UTF-8, а не пользовательские символы. Для этого примера достаточно учесть, что `Double.init` разбирает строку с учётом текущей локали. Современные FormatStyle являются значениями и удобны для повторного применения без общей изменяемой ISO8601DateFormatter-конфигурации. Последняя строка ведёт себя именно так, потому что `Date` хранит календарь и часовой пояс, использованные при создании. Современные FormatStyle являются значениями и удобны для повторного применения без общей изменяемой DateFormatter-конфигурации.

Вопрос 7 из 30

Какую причину стоит указать в отчёте об ошибке, прежде чем предлагать исправление? Здесь оценивается различие графем, скаляров, кодовых единиц и байтов.

let word = "café"
let i = word.index(word.startIndex, offsetBy: 3)
print(word[i])

`String.Index` можно заменить целым числом без изменения сложности и корректности доступа. Индексирование корректно идёт по Character, но операция offsetBy может быть линейной, а не постоянной по времени. Для строки `café` индексирование постоянно по времени, поскольку каждый видимый символ занимает один Unicode-скаляр. Операция `offsetBy:` всегда имеет сложность O(1), потому что `String.Index` хранит готовое числовое смещение. `offsetBy: 3` отсчитывает три байта UTF-8, поэтому может остановиться внутри многобайтового символа.

Вопрос 8 из 30

Что именно делает этот фрагмент неверным или неочевидным с точки зрения «Моменты времени Date»? Важно учесть: абсолютное время и отличие длительности от календарного шага.

import Foundation
let now = Date()
let tomorrow = now.addingTimeInterval(24 * 60 * 60)

`Date` хранит исходный часовой пояс, поэтому после прибавления суток сохраняет локальное время. Прибавление 86 400 секунд не всегда означает следующий местный календарный день из-за переходов летнего времени. Прибавление 86 400 секунд всегда переводит момент на тот же час следующего местного календарного дня. Расхождение возможно только 29 февраля; смена часового пояса и летнего времени на результат не влияют. `addingTimeInterval` использует `Calendar.current` и сам корректирует переход на летнее время.

Вопрос 9 из 30

Ожидаемое поведение не совпало с фактическим. В чём первая нарушенная гарантия? Не упускайте из виду следующее: явная конфигурация календарных вычислений.

import Foundation
let calendar = Calendar.current
let month = calendar.component(.month, from: Date())

Отчёт об ошибке должен указывать, что `String.count` считает байты UTF-8, а не пользовательские символы. Наблюдаемый симптом объясняется тем, что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Результат зависит от календаря, часового пояса и текущего момента среды; такой тест недетерминирован. Результат не зависит от календаря, часового пояса и текущего момента среды; такой тест недетерминирован. Первой нарушенной гарантией здесь является предположение, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях.

Вопрос 10 из 30

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Проверяется локализованное представление и машинный формат.

import Foundation
let input = "1,5"
let value = Double(input)
print(value as Any)

Проблема возникает из-за правила: `Date` хранит календарь и часовой пояс, использованные при создании. Отчёт об ошибке должен указывать, что `String.count` считает байты UTF-8, а не пользовательские символы. Double.init является локализованным парсером и обычно не принимает запятую как десятичный разделитель. Double.init не является локализованным парсером и обычно не принимает запятую как десятичный разделитель. Наблюдаемый симптом объясняется тем, что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации.

Вопрос 11 из 30

Какую причину стоит указать в отчёте об ошибке, прежде чем предлагать исправление? Здесь оценивается управляемость времени и региональных зависимостей.

import Foundation
func testToday21() {
    let year = Calendar.current.component(.year, from: Date())
    assert(year == 2026)
}

Наблюдаемый симптом объясняется тем, что `Double.init` разбирает строку с учётом текущей локали. Проблема возникает из-за правила: `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Тест привязан к реальным часам и календарю среды и неизбежно станет неверным. Отчёт об ошибке должен указывать, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Причина сбоя в том, что `String.count` считает байты UTF-8, а не пользовательские символы.

Вопрос 12 из 30

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Сосредоточьтесь на следующем: цена форматирования и разделение абсолютных данных с представлением.

import Foundation
func render21(_ dates: [Date]) -> [String] {
    dates.map { date in
        let f = DateFormatter(); f.dateStyle = .long
        return f.string(from: date)
    }
}

Создание и настройка DateFormatter на каждый элемент добавляет заметные выделения и работу; результат ещё не зависит от неявной локали. Создание и настройка ISO8601DateFormatter на каждый элемент добавляет заметные выделения и работу; результат ещё зависит от неявной локали. Проблема возникает из-за правила: `Date` хранит календарь и часовой пояс, использованные при создании. Создание и настройка DateFormatter на каждый элемент добавляет заметные выделения и работу; результат ещё зависит от неявной локали. Отчёт об ошибке должен указывать, что `String.count` считает байты UTF-8, а не пользовательские символы.

Вопрос 13 из 30

Какое решение одновременно исправляет код и оставляет понятную границу для дальнейших изменений? Здесь оценивается различие графем, скаляров, кодовых единиц и байтов.

let word = "café"
let i = word.index(word.startIndex, offsetBy: 3)
print(word[i])

Достаточно изменить работу с `word`, исходя из того, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Не хранить смещения String как Int; использовать String.Index и заново проверять его принадлежность конкретной строке после изменений. хранить смещения String как Int; использовать String.Index и заново проверять его принадлежность конкретной строке после изменений. Сигнатуру можно не менять, если считать, что `String.count` считает байты UTF-8, а не пользовательские символы. Правка сводится к локальному обходу: `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации.

Вопрос 14 из 30

Выберите правку, после которой дефект исчезает не только в удачном примере. Не упускайте из виду следующее: абсолютное время и отличие длительности от календарного шага.

import Foundation
let now = Date()
let tomorrow = now.addingTimeInterval(24 * 60 * 60)

Нужно адаптировать только вызов `now`, поскольку `Double.init` разбирает строку с учётом текущей локали. Исправление — оставить контракт прежним и учитывать, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Для календарного «завтра» использовать Calendar.date(byAdding:.day,value:2,to:), а интервалы секунд оставлять для физической длительности. Достаточно изменить работу с `now`, исходя из того, что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Для календарного «завтра» использовать Calendar.date(byAdding:.day,value:1,to:), а интервалы секунд оставлять для физической длительности.

Вопрос 15 из 30

Что нужно поменять в реализации или сигнатуре, чтобы отрицательный сценарий стал корректным? Не упускайте из виду следующее: явная конфигурация календарных вычислений.

import Foundation
let calendar = Calendar.current
let month = calendar.component(.month, from: Date())

Передавать Calendar и фиксировать timeZone/locale в логике, где результат должен быть воспроизводимым. Правка сводится к локальному обходу: `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Достаточно изменить работу с `calendar`, исходя из того, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Передавать Calendar и фиксировать timeZone/locale в логике, где результат не должен быть воспроизводимым. Сигнатуру можно не менять, если считать, что `String.count` считает байты UTF-8, а не пользовательские символы.

Вопрос 16 из 30

Какая правка решает проблему на том уровне, где она возникла? Проверяется локализованное представление и машинный формат.

import Foundation
let input = "1,5"
let value = Double(input)
print(value as Any)

Сигнатуру можно не менять, если считать, что `String.count` считает байты UTF-8, а не пользовательские символы. Правка сводится к локальному обходу: `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Исправление — оставить контракт прежним и учитывать, что `Double.init` разбирает строку с учётом текущей локали. Нужно адаптировать только вызов `input`, поскольку `Date` хранит календарь и часовой пояс, использованные при создании. Для пользовательского числа использовать NumberFormatter или ParseStrategy с заданной Locale и валидировать полный ввод.

Вопрос 17 из 30

Как восстановить заявленный контракт с наименьшим числом новых скрытых предположений? Важно учесть: управляемость времени и региональных зависимостей.

import Foundation
func testToday21() {
    let year = Calendar.current.component(.year, from: Date())
    assert(year == 2026)
}

Достаточно изменить работу с `testToday21`, исходя из того, что `Double.init` разбирает строку с учётом текущей локали. Сигнатуру можно не менять, если считать, что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Исправление — оставить контракт прежним и учитывать, что `Date` хранит календарь и часовой пояс, использованные при создании. Нужно адаптировать только вызов `testToday21`, поскольку `String.count` считает байты UTF-8, а не пользовательские символы. Внедрить источник времени и Calendar, использовать фиксированные даты вокруг полуночи, високосного дня и перехода DST.

Вопрос 18 из 30

Какая правка делает намерение кода явным и проверяемым? Не упускайте из виду следующее: цена форматирования и разделение абсолютных данных с представлением.

import Foundation
func render21(_ dates: [Date]) -> [String] {
    dates.map { date in
        let f = DateFormatter(); f.dateStyle = .long
        return f.string(from: date)
    }
}

Исправление — оставить контракт прежним и учитывать, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Нужно адаптировать только вызов `render21`, поскольку `Double.init` разбирает строку с учётом текущей локали. Вынести настроенный форматтер/стратегию на подходящий уровень, делая общий изменяемый общий экземпляр без синхронизации. Вынести настроенный форматтер/стратегию на подходящий уровень, не делая общий изменяемый общий экземпляр без синхронизации. Сигнатуру можно не менять, если считать, что `Date` хранит календарь и часовой пояс, использованные при создании.

Вопрос 19 из 30

Какое условие отличает надёжное обобщение от случайно удачного запуска? Не упускайте из виду следующее: различие графем, скаляров, кодовых единиц и байтов.

Две визуально одинаковые строки могут иметь разную Unicode-нормализацию и разный набор скаляров, хотя сравнутриние Swift учитывает каноническую эквивалентность. Правило меняется только в ситуации, где `Double.init` разбирает строку с учётом текущей локали. Две визуально одинаковые строки могут иметь разную Unicode-нормализацию и разный набор скаляров, хотя сравнение Swift учитывает каноническую эквивалентность. Ограничение определяется предположением, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Пограничный случай связан с тем, что `Date` хранит календарь и часовой пояс, использованные при создании.

Вопрос 20 из 30

Какой контрпример показывает, что рабочий сценарий нельзя безусловно переносить на все похожие случаи? Сосредоточьтесь на следующем: абсолютное время и отличие длительности от календарного шага.

Пограничный случай связан с тем, что `String.count` считает байты UTF-8, а не пользовательские символы. Правило меняется только в ситуации, где `Date` хранит календарь и часовой пояс, использованные при создании. Граница применимости проходит там, где `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Date не хранит часовой пояс или формат отображения; они появляются при интерпретации через Calendar и Formatter. Date хранит часовой пояс или формат отображения; они появляются при интерпретации через Calendar и Formatter.

Вопрос 21 из 30

Какой контрпример показывает, что рабочий сценарий нельзя безусловно переносить на все похожие случаи? Сосредоточьтесь на следующем: явная конфигурация календарных вычислений.

Контрпример появляется, когда `Double.init` разбирает строку с учётом текущей локали. Calendar.current может меняться вместе с настройками пользователя, а autoupdatingCurrent отслеживает изменения динамически. Calendar(identifier: .gregorian) может меняться вместе с настройками пользователя, а autoupdatingCurrent отслеживает изменения динамически. Calendar.current не может меняться вместе с настройками пользователя, а autoupdatingCurrent отслеживает изменения динамически. Ограничение определяется предположением, что `Date` хранит календарь и часовой пояс, использованные при создании.

Вопрос 22 из 30

Какой отрицательный сценарий лучше всего проверяет предел применимости этого механизма? Здесь оценивается локализованное представление и машинный формат.

Граница применимости проходит там, где `Double.init` разбирает строку с учётом текущей локали. Locale(identifier: "en_US_POSIX") предназначена для стабильных машинных форматов, а для отображения текста пользователю. Locale(identifier: "en_US_POSIX") предназначена для стабильных машинных форматов, а не для отображения текста пользователю. Пограничный случай связан с тем, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Правило меняется только в ситуации, где `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации.

Вопрос 23 из 30

Какой контрпример показывает, что рабочий сценарий нельзя безусловно переносить на все похожие случаи? Важно учесть: управляемость времени и региональных зависимостей.

Правило меняется только в ситуации, где `Date` хранит календарь и часовой пояс, использованные при создании. Граница применимости проходит там, где `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Пограничный случай связан с тем, что `String.count` считает байты UTF-8, а не пользовательские символы. Проверка только UTC не покрывает ошибки глобального дня; проверка только одной локали не покрывает формат с другим порядком компонентов. Проверка только UTC не покрывает ошибки локального дня; проверка только одной локали не покрывает формат с другим порядком компонентов.

Вопрос 24 из 30

Какую предпосылку стоит явно записать в документации и тестах? Проверяется цена форматирования и разделение абсолютных данных с представлением.

Граница применимости проходит там, где `String.count` считает байты UTF-8, а не пользовательские символы. Контрпример появляется, когда `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Ограничение определяется предположением, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Кэш форматтера должен учитывать locale, calendar и timeZone; один глобальный экземпляр для всех пользователей даёт неверное представление. Кэш форматтера не должен учитывать locale, calendar и timeZone; один глобальный экземпляр для всех пользователей даёт неверное представление.

Вопрос 25 из 30

Какой принцип важнее локальной красоты синтаксиса в рабочем приложении? Здесь оценивается различие графем, скаляров, кодовых единиц и байтов.

Для больших текстов выбирать представление под задачу: Character для пользовательских символов, unicodeScalars или utf8 — для протокольной обработки. Для больших текстов выбирать представление под задачу: Character для пользовательских символов, unicodeScalars или utf8 — не для протокольной обработки. В API и тестах следует исходить из правила: `Double.init` разбирает строку с учётом текущей локали. Для больших текстов выбирать представление под задачу: Unicode.Scalar для пользовательских символов, unicodeScalars или utf8 — для протокольной обработки. Главным проектным принципом здесь является утверждение, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях.

Вопрос 26 из 30

Какой подход делает неправильное использование заметным раньше? Проверяется абсолютное время и отличие длительности от календарного шага.

Для устойчивого решения достаточно принять, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. В API и тестах следует исходить из правила: `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. В модели данных хранить абсолютный момент отдельно от пользовательского часового пояса и намерения «локальное время встречи». В модели данных хранить абсолютный момент отдельно от пользовательского часового пояса и намерения «глобальное время встречи». Архитектуру стоит строить из предположения, что `Double.init` разбирает строку с учётом текущей локали.

Вопрос 27 из 30

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Здесь оценивается явная конфигурация календарных вычислений.

При расширении системы нужно опираться на то, что `Date` хранит календарь и часовой пояс, использованные при создании. Календарь не является зависимостью доменной логики; скрытая глобальная current затрудняет тесты и работу с несколькими регионами. Календарь является зависимостью доменной логики; скрытая глобальная current затрудняет тесты и работу с несколькими регионами. Для устойчивого решения достаточно принять, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Архитектуру стоит строить из предположения, что `Double.init` разбирает строку с учётом текущей локали.

Вопрос 28 из 30

Как организовать этот механизм, чтобы владение и отказ оставались понятными после расширения проекта? Важно учесть: локализованное представление и машинный формат.

Главным проектным принципом здесь является утверждение, что `Date` хранит календарь и часовой пояс, использованные при создании. В API и тестах следует исходить из правила: `String.count` считает байты UTF-8, а не пользовательские символы. При расширении системы нужно опираться на то, что `Double.init` разбирает строку с учётом текущей локали. Форматирование и парсинг должны использовать согласованные правила; сохранённую строку интерфейса нельзя считать надёжным числовым форматом. Форматирование и парсинг должны использовать согласованные правила; сохранённую строку интерфейса можно считать надёжным числовым форматом.

Вопрос 29 из 30

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Проверяется управляемость времени и региональных зависимостей.

Диагностика времени должна журналировать абсолютный Date, timeZone identifier и календарные компоненты, иначе «не тот день» трудно воспроизвести. В API и тестах следует исходить из правила: `Date` хранит календарь и часовой пояс, использованные при создании. Диагностика времени не должна журналировать абсолютный Date, timeZone identifier и календарные компоненты, иначе «не тот день» трудно воспроизвести. Для устойчивого решения достаточно принять, что `String.count` считает байты UTF-8, а не пользовательские символы. Архитектуру стоит строить из предположения, что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации.

Вопрос 30 из 30

Какой принцип важнее локальной красоты синтаксиса в рабочем приложении? Здесь оценивается цена форматирования и разделение абсолютных данных с представлением.

Архитектуру стоит строить из предположения, что `Calendar.current` одинаков на всех машинах и во всех тестовых окружениях. Для устойчивого решения достаточно принять, что `DateFormatter` безопасно изменять из нескольких задач без внешней синхронизации. Слой модели хранит Date и семантику события, а форматирование остаётся на границе представления — так меньше строковых преобразований и ошибок локали. Слой модели хранит Date и семантику события, а форматирование не остаётся на границе представления — так меньше строковых преобразований и ошибок локали. В API и тестах следует исходить из правила: `String.count` считает байты UTF-8, а не пользовательские символы.