Em C / C ++ / Objective C, você pode definir uma macro usando pré-processadores do compilador. Além disso, você pode incluir / excluir algumas partes do código usando pré-processadores do compilador.

#ifdef DEBUG
    // Debug-only code
#endif

Existe uma solução semelhante no Swift?

Sim, você pode fazer isso.

No Swift, você ainda pode usar as macros de pré-processador "# if / # else / # endif" (embora mais restritas), conforme documentos da Apple . Aqui está um exemplo:

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

Agora, você deve definir o símbolo "DEBUG" em outro lugar. Defina-o na seção "Swift Compiler - Custom Flags", na linha "Other Swift Flags". Você adiciona o símbolo DEBUG à -D DEBUGentrada.

Como de costume, você pode definir um valor diferente no Debug ou no Release.

Eu testei em código real e funciona; embora não pareça ser reconhecido em um playground.

Você pode ler meu post original aqui .

NOTA IMPORTANTE: -DDEBUG=1 não funciona. Só -D DEBUGfunciona. Parece que o compilador está ignorando um sinalizador com um valor específico.

Conforme declarado no Apple Docs

O compilador Swift não inclui um pré-processador. Em vez disso, tira proveito dos atributos em tempo de compilação, configurações de compilação e recursos de idioma para obter a mesma funcionalidade. Por esse motivo, as diretivas de pré-processador não são importadas no Swift.

Consegui alcançar o que queria usando configurações de compilação personalizadas:

1. Vá para o seu projeto / selecione seu destino / Configurações de compilação / pesquise sinalizadores personalizados
2. Para o destino escolhido, defina seu sinalizador personalizado usando o prefixo -D (sem espaços em branco), para Debug e Release
3. Execute as etapas acima para cada alvo que você tiver

Veja como você verifica o destino:

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

Testado usando o Swift 2.2

Em muitas situações, você realmente não precisa de compilação condicional ; você só precisa de um comportamento condicional que possa ser ligado e desligado. Para isso, você pode usar uma variável de ambiente. Isso tem a enorme vantagem de você não precisar recompilar.

Você pode definir a variável de ambiente e ativá-la ou desativá-la facilmente no editor de esquema:

Você pode recuperar a variável de ambiente com NSProcessInfo:

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

Aqui está um exemplo da vida real. Meu aplicativo é executado apenas no dispositivo, porque usa a biblioteca de músicas, que não existe no Simulador. Como, então, tirar capturas de tela no Simulador para dispositivos que não possuo? Sem essas capturas de tela, não posso enviar para a AppStore.

Preciso de dados falsos e uma maneira diferente de processá-los . Eu tenho duas variáveis ​​de ambiente: uma que, quando ativada, informa ao aplicativo para gerar os dados falsos a partir dos dados reais enquanto estiver sendo executado no meu dispositivo; o outro que, quando ligado, usa os dados falsos (e não a biblioteca de músicas que falta) durante a execução no Simulador. É fácil ativar ou desativar cada um desses modos especiais, graças às caixas de seleção de variáveis ​​de ambiente no editor de esquema. E o bônus é que não posso usá-los acidentalmente na minha compilação na App Store, porque o arquivamento não possui variáveis ​​de ambiente.

Uma grande mudança de ifdefsubstituição ocorreu com o Xcode 8. ou seja, o uso das Condições de Compilação Ativas .

Consulte Construção e vinculação no Xcode 8 Release note .

Novas configurações de compilação

Nova configuração: SWIFT_ACTIVE_COMPILATION_CONDITIONS

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

Anteriormente, tínhamos que declarar seus sinalizadores de compilação condicional em OTHER_SWIFT_FLAGS, lembrando-se de acrescentar "-D" à configuração. Por exemplo, para compilar condicionalmente com um valor MYFLAG:

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

O valor a ser adicionado à configuração -DMYFLAG

Agora só precisamos passar o valor MYFLAG para a nova configuração. Hora de mover todos esses valores de compilação condicional!

Consulte o link abaixo para obter mais recursos do Swift Build Settings no Xcode 8: http://www.miqu.me/blog/2016/07/31/xcode-8-new-build-settings-and-analyzer-improvements/

A partir do Swift 4.1, se tudo o que você precisa é apenas verificar se o código foi criado com a configuração de depuração ou liberação, você pode usar as funções internas:

• _isDebugAssertConfiguration() (verdadeiro quando a otimização está definida como -Onone)
• _isReleaseAssertConfiguration()(verdadeiro quando a otimização está definida como -O) (não disponível no Swift 3+)
• _isFastAssertConfiguration()(verdadeiro quando a otimização está definida como -Ounchecked)

por exemplo

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

Comparado com macros de pré-processador,

• ✓ Você não precisa definir um -D DEBUGsinalizador personalizado para usá-lo
• ~ Na verdade, é definido em termos de configurações de otimização, não na configuração de compilação do Xcode

• ✗ Não documentado, o que significa que a função pode ser removida em qualquer atualização (mas deve ser segura na AppStore, pois o otimizador as transformará em constantes)

  • estes foram removidos , mas trazidos de volta ao público por falta de @testableatributos , destino incerto no futuro Swift.

• ✗ Usar if / else sempre gerará um aviso "Nunca será executado".

Xcode 8 e acima

Use a configuração Condições de compilação ativa em Configurações de compilação / Compilador Swift - sinalizadores personalizados .

• Esta é a nova configuração de compilação para passar sinalizadores de compilação condicional para o compilador Swift.
• Flags Adicionar simples como este: ALPHA, BETAetc.

Em seguida, verifique-o com condições de compilação como esta:

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

Dica: você também pode usar #if !ALPHAetc.

Não há pré-processador Swift. (Por um lado, a substituição arbitrária de código quebra a segurança de tipo e de memória.)

No entanto, o Swift inclui opções de configuração em tempo de construção, para que você possa incluir condicionalmente código para determinadas plataformas ou estilos de construção ou em resposta a sinalizadores definidos com -Dargumentos do compilador. Ao contrário do C, porém, uma seção compilada condicionalmente do seu código deve estar sintaticamente concluída. Há uma seção sobre isso em Usando o Swift With Cocoa e o Objective-C .

Por exemplo:

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

Meus dois centavos para o Xcode 8:

a) Um sinalizador personalizado usando o -D prefixo funciona bem, mas ...

b) Uso mais simples:

No Xcode 8, há uma nova seção: "Condições de Compilação Ativas", já com duas linhas, para depuração e lançamento.

Basta adicionar sua definição SEM -D.

Constante isDebug com base nas condições de compilação ativa

Outra solução, talvez mais simples, que ainda resulta em um booleano que você pode passar para funções sem aplicar #ifcondicionais em toda a base de código é definir DEBUGcomo um dos objetivos de construção do projeto Active Compilation Conditionse incluir o seguinte (eu a defino como uma constante global):

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

Constante isDebug com base nas configurações de otimização do compilador

Este conceito baseia-se na resposta de kennytm

A principal vantagem ao comparar com o kennytm é que isso não depende de métodos particulares ou não documentados.

No 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
}()

Comparado com as macros do pré-processador e a resposta do kennytm ,

• ✓ Você não precisa definir um -D DEBUGsinalizador personalizado para usá-lo
• ~ Na verdade, é definido em termos de configurações de otimização, não na configuração de compilação do Xcode

• ✓ Documentado , o que significa que a função seguirá os padrões normais de liberação / descontinuação da API.

• ✓ O uso de if / else não gerará um aviso "Nunca será executado".

Moignans responder aqui funciona bem. Aqui está outra informação, caso ajude,

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

Você pode negar as macros como abaixo,

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

Nos projetos Swift criados com o Xcode Versão 9.4.1, Swift 4.1

#if DEBUG
#endif

funciona por padrão porque nas macros do pré-processador DEBUG = 1 já foi definido pelo Xcode.

Então você pode usar #if DEBUG "fora da caixa".

A propósito, como usar os blocos de compilação de condições em geral está escrito no livro da Apple, The Swift Programming Language 4.1 (a seção Declarações de Controle do Compilador) e como escrever os sinalizadores de compilação e o que é equivalente às macros C do Swift. outro livro da Apple, usando Swift com cacau e objetivo C (na seção Diretivas de pré-processador)

Esperança no futuro A Apple escreverá o conteúdo mais detalhado e os índices de seus livros.

XCODE 9 E ACIMA

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

Após definir DEBUG=1as GCC_PREPROCESSOR_DEFINITIONSconfigurações de compilação, prefiro usar uma função para fazer isso:

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

E então apenas coloque nesta função qualquer bloco que eu queira omitir nas compilações de depuração:

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

A vantagem quando comparada com:

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

É que o compilador verifica a sintaxe do meu código, por isso tenho certeza de que a sintaxe está correta e se compila.

! [No Xcode 8 e acima, vá para a configuração de construção -> procure sinalizadores personalizados] 1

Em código

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

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

Fonte

Isso se baseia na resposta de Jon Willis que se baseia na afirmação, que só é executada nas compilações de depuração:

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

Meu caso de uso é para registrar instruções de impressão. Aqui está uma referência para a versão Release no 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)" )

impressões:

Log: 0.0

Parece que o Swift 4 elimina completamente a chamada de função.