Да, ты можешь сделать это.

В Swift вы по-прежнему можете использовать макросы препроцессора "# if / # else / # endif" (хотя и более ограниченные) согласно Документы Apple. Вот пример:

#if DEBUG
    let a = 2
#else
    let a = 3
#endif

Однако теперь вы должны установить символ «DEBUG» в другом месте. Установите его в разделе «Компилятор Swift - Пользовательские флаги» в строке «Другие флаги Swift». Вы добавляете символ DEBUG с записью -D DEBUG.

Как обычно, вы можете установить другое значение в отладке или в выпуске.

Я протестировал это в реальном коде, и он работает; хотя на детской площадке его, похоже, не узнают.

Вы можете прочитать мой исходный пост здесь.

ВАЖНОЕ ПРИМЕЧАНИЕ: -DDEBUG=1 не работает. Только -D DEBUG работает. Кажется, компилятор игнорирует флаг с определенным значением.

Как указано в Apple Документы

Компилятор Swift не включает препроцессор. Вместо этого он использует атрибуты времени компиляции, конфигурации сборки и языковые функции для достижения той же функциональности. По этой причине директивы препроцессора не импортируются в Swift.

Мне удалось добиться того, чего я хотел, используя пользовательские конфигурации сборки:

1. Перейдите в свой проект / выберите цель / Параметры сборки / найдите пользовательские флаги
2. Для выбранной цели установите собственный флаг с помощью префикса -D (без пробелов) как для отладки, так и для выпуска.
3. Выполните указанные выше действия для каждой имеющейся у вас цели.

Вот как вы проверяете цель:

#if BANANA
    print("We have a banana")
#elseif MELONA
    print("Melona")
#else
    print("Kiwi")
#endif

Протестировано с использованием Swift 2.2

Во многих ситуациях условная компиляция не нужна; вам просто нужно условное поведение, которое можно включать и выключать. Для этого вы можете использовать переменную окружения. Это имеет огромное преимущество в том, что вам на самом деле не нужно перекомпилировать.

Вы можете установить переменную среды и легко включить или выключить ее в редакторе схем:

Вы можете получить переменную среды с помощью NSProcessInfo:

    let dic = NSProcessInfo.processInfo().environment
    if dic["TRIPLE"] != nil {
        // ... do secret stuff here ...
    }

Вот пример из жизни. Мое приложение работает только на устройстве, потому что оно использует музыкальную библиотеку, которой нет в симуляторе. Как же тогда делать снимки экрана в Симуляторе для устройств, которыми я не владею? Без этих снимков экрана я не могу отправить заявку в AppStore.

Мне нужны поддельные данные и другой способ их обработки. У меня есть две переменные среды: одна, которая при включении сообщает приложению генерировать поддельные данные из реальных данных во время работы на моем устройстве; другой, который при включении использует поддельные данные (а не отсутствующую музыкальную библиотеку) во время работы на симуляторе. Включение и выключение каждого из этих специальных режимов очень просто благодаря флажкам переменных среды в редакторе схем. И бонус в том, что я не могу случайно использовать их в своей сборке App Store, потому что архивирование не имеет переменных среды.

Существенное изменение замены ifdef связано с Xcode 8. то есть с использованием условий активной компиляции.

См. Создание и связывание в Информация о выпуске Xcode 8.

Настройки новой сборки

Новая настройка: SWIFT_ACTIVE_COMPILATION_CONDITIONS

“Active Compilation Conditions” is a new build setting for passing conditional compilation flags to the Swift compiler.

Раньше нам приходилось объявлять ваши флаги условной компиляции в OTHER_SWIFT_FLAGS, не забывая добавлять «-D» к настройке. Например, для условной компиляции со значением MYFLAG:

#if MYFLAG1
    // stuff 1
#elseif MYFLAG2
    // stuff 2
#else
    // stuff 3
#endif

Значение, добавляемое к настройке -DMYFLAG

Теперь нам нужно только передать значение MYFLAG в новую настройку. Пора переместить все эти значения условной компиляции!

Пожалуйста, обратитесь к ссылке ниже, чтобы узнать больше о функции Swift Build Settings в Xcode 8: http://www.miqu.me/blog/2016/07/31/xcode-8-new-build-settings-and-анализатор-улучшения/

Начиная с Swift 4.1, если все, что вам нужно, это просто проверить, построен ли код с конфигурацией отладки или выпуска, вы можете использовать встроенные функции:

• _isDebugAssertConfiguration() (истина, если для оптимизации установлено значение -Onone)
• _isReleaseAssertConfiguration() (true, если для оптимизации установлено значение -O) (недоступно в Swift 3+)
• _isFastAssertConfiguration() (верно, если для оптимизации установлено значение -Ounchecked)

e.g.

func obtain() -> AbstractThing {
    if _isDebugAssertConfiguration() {
        return DecoratedThingWithDebugInformation(Thing())
    } else {
        return Thing()
    }
}

По сравнению с макросами препроцессора,

• ✓ Вам не нужно определять собственный флаг -D DEBUG, чтобы использовать его
• ~ Это фактически определяется с точки зрения настроек оптимизации, а не конфигурации сборки Xcode

• ✗ Недокументированный, что означает, что функция может быть удалена в любом обновлении (но она должна быть безопасной для AppStore, поскольку оптимизатор преобразует их в константы)

  • these once removed, but brought back to public to lack of @testable attribute, fate uncertain on future Swift.

• ✗ Использование if / else всегда будет генерировать предупреждение «Никогда не будет выполнено».

Xcode 8 и выше

Используйте параметр Активные условия компиляции в разделе Настройки сборки / Компилятор Swift - Пользовательские флаги.

• Это новый параметр сборки для передачи флагов условной компиляции компилятору Swift.
• Простые флаги добавления вроде этого: ALPHA, BETA и т. Д.

Затем проверьте его с помощью условия компиляции, например:

#if ALPHA
    //
#elseif BETA
    //
#else
    //
#endif

Совет. Вы также можете использовать #if !ALPHA и т. д.

Препроцессора Swift нет. (Во-первых, произвольная подстановка кода нарушает безопасность типов и память.)

Однако Swift включает параметры конфигурации во время сборки, поэтому вы можете условно включить код для определенных платформ или стилей сборки или в ответ на флаги, которые вы определяете с помощью -D аргументов компилятора. Однако, в отличие от C, условно скомпилированный раздел вашего кода должен быть синтаксически завершенным. Об этом есть раздел в Использование Swift с Cocoa и Objective-C.

Например:

#if os(iOS)
    let color = UIColor.redColor()
#else
    let color = NSColor.redColor()
#endif

Константа isDebug на основе условий активной компиляции

Другое, возможно, более простое решение, которое по-прежнему приводит к логическому значению, которое вы можете передавать в функции без добавления #if условных обозначений по всей кодовой базе, - это определить DEBUG как одну из целей сборки вашего проекта Active Compilation Conditions и включить следующее (я определяю его как глобальную константу) :

#if DEBUG
    let isDebug = true
#else
    let isDebug = false
#endif

Константа isDebug на основе настроек оптимизации компилятора

Эта концепция основана на ответе kennytm

Основное преимущество при сравнении с kennytm заключается в том, что он не полагается на частные или недокументированные методы.

В Swift 4:

let isDebug: Bool = {
    var isDebug = false
    // function with a side effect and Bool return value that we can pass into assert()
    func set(debug: Bool) -> Bool {
        isDebug = debug
        return isDebug
    }
    // assert:
    // "Condition is only evaluated in playgrounds and -Onone builds."
    // so isDebug is never changed to true in Release builds
    assert(set(debug: true))
    return isDebug
}()

По сравнению с макросами препроцессора и ответом kennytm,

• ✓ Вам не нужно определять собственный флаг -D DEBUG, чтобы использовать его
• ~ Это фактически определяется с точки зрения настроек оптимизации, а не конфигурации сборки Xcode

• ✓ Документировано, что означает, что функция будет следовать стандартным шаблонам выпуска / устаревания API.

• ✓ Использование if / else не генерирует предупреждение «Никогда не будет выполнено».

Мои два цента за Xcode 8:

а) Пользовательский флаг с префиксом -D работает нормально, но ...

б) Более простое использование:

В Xcode 8 есть новый раздел: «Активные условия компиляции», уже содержащий две строки, для отладки и выпуска.

Просто добавьте свое определение БЕЗ -D.

Moignans answer здесь отлично работает. Вот еще одна информация на случай, если это поможет,

#if DEBUG
    let a = 2
#else
    let a = 3
#endif

Вы можете отменить макросы, как показано ниже,

#if !RELEASE
    let a = 2
#else
    let a = 3
#endif

В проектах Swift, созданных с помощью Xcode версии 9.4.1, Swift 4.1

#if DEBUG
#endif

работает по умолчанию, потому что в макросах препроцессора DEBUG = 1 уже установлено Xcode.

Таким образом, вы можете использовать #if DEBUG "из коробки".

Кстати, как использовать блоки компиляции условий в целом написано в книге Apple The Swift Programming Language 4.1 (раздел Compiler Control Statements), а как писать флаги компиляции и что является аналогом макросов C в Swift написано в другая книга Apple «Использование Swift с Cocoa и Objective C» (в разделе «Директивы препроцессора»)

Надеюсь, что в будущем Apple напишет более подробное содержание и указатели для своих книг.

XCODE 9 И ВЫШЕ

#if DEVELOP
    //
#elseif PRODCTN
    //
#else
    //
#endif

Есть несколько процессоров, которые возражают, и я перечислил их ниже. вы можете изменить аргумент по своему усмотрению:

#if os(macOS) /* Checks the target operating system */

#if canImport(UIKit) /* Check if a module presents */

#if swift(<5) /* Check the Swift version */

#if targetEnvironment(simulator) /* Check envrionments like Simulator or Catalyst */

#if compiler(<7) /* Check compiler version */

Кроме того, вы можете использовать любые настраиваемые флаги, такие как DEBUG, или любые другие флаги, которые вы определили.

#if DEBUG
print("Debug mode")
#endif

После установки DEBUG=1 в ваших GCC_PREPROCESSOR_DEFINITIONS Настройках сборки я предпочитаю использовать функцию для выполнения этих вызовов:

func executeInProduction(_ block: () -> Void)
{
    #if !DEBUG
        block()
    #endif
}

А затем просто включите в эту функцию любой блок, который я хочу опустить в сборках отладки:

executeInProduction {
    Fabric.with([Crashlytics.self]) // Compiler checks this line even in Debug
}

Преимущество по сравнению с:

#if !DEBUG
    Fabric.with([Crashlytics.self]) // This is not checked, may not compile in non-Debug builds
#endif

Это компилятор проверяет синтаксис моего кода, поэтому я уверен, что его синтаксис правильный и строит.

! [В Xcode 8 и выше перейдите к настройке сборки -> найдите пользовательские флаги] 1

В коде

 #if Live
    print("Live")
    #else
    print("debug")
    #endif

func inDebugBuilds(_ code: () -> Void) {
    assert({ code(); return true }())
}

Источник

Это основано на ответе Джона Уиллиса, который полагается на assert, который выполняется только в компиляциях Debug:

func Log(_ str: String) { 
    assert(DebugLog(str)) 
}
func DebugLog(_ str: String) -> Bool { 
    print(str) 
    return true
}

Мой вариант использования - регистрация операторов печати. Вот тест для версии Release на iPhone X:

let iterations = 100_000_000
let time1 = CFAbsoluteTimeGetCurrent()
for i in 0 ..< iterations {
    Log ("⧉ unarchiveArray:\(fileName) memoryTime:\(memoryTime) count:\(array.count)")
}
var time2 = CFAbsoluteTimeGetCurrent()
print ("Log: \(time2-time1)" )

печатает:

Log: 0.0

Похоже, Swift 4 полностью исключает вызов функции.