Início / coding / Perguntas / 79468963
Accepted
Andrei Herford
Asked: 2025-02-26 16:15:01 +0800 CST

Como funcionam os modificadores de visualização como .font (que parecem alterar propriedades internas)?

  • 772

Ainda estou com dificuldade para entender como os modificadores de visualização funcionam no SwiftUI.

Até onde eu sei, os modificadores não alteram diretamente a visualização correspondente, mas, em vez disso, incorporam a visualização em uma nova visualização que aplica as alterações desejadas. Por exemplo, Text(...).padding()NÃO altera algumas propriedades da Textvisualização para criar o preenchimento, mas, em vez disso, incorpora a Textvisualização em uma nova visualização que cuida dos preenchimentos. Portanto, os modificadores não modificam a visualização, mas criam uma nova visualização com as alterações desejadas.

Certo, isso faz todo o sentido.

Mas como funcionam os modificadores, que (parecem) alterar apenas propriedades específicas de uma visualização? Por exemplo, os modificadores .fontou .tint. Embora eu entenda como uma visualização circundante pode alterar propriedades "externas" como plano de fundo, preenchimento, escala, etc., não entendo como o mesmo é possível para propriedades "internas" como a fonte? Como a Textvisualização pode saber, a partir de sua visualização circundante, qual fonte deve usar? Ou como uma visualização circundante poderia recriar a Textvisualização com todas as suas propriedades, mas apenas uma fonte alterada?

Posso criar um personalizado Text("Some example").capitalize("aoe")que crie um texto com todas as mesmas propriedades, como fonte, cor de primeiro plano, etc., mas com "ALGUM Exemplo"?

1 respostas

  1. Best Answer

    Não está claro quais outros modificadores de visualização você considera como "alterações de propriedades internas", então considerarei apenas fonte tint. Outros modificadores de visualização podem ser implementados de forma diferente.

    Ambos fonte tintsão implementados definindo valores de ambiente. Ambos são inlinable, então suas implementações podem ser encontradas nos arquivos .swiftinterface do SwiftUI.

    // from /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/SwiftUICore.framework/Modules/SwiftUICore.swiftmodule/arm64e-apple-macos.swiftinterface

@inlinable nonisolated public func tint<S>(_ tint: S?) -> some SwiftUICore.View where S : SwiftUICore.ShapeStyle {
    return environment(\.tint, tint.map(AnyShapeStyle.init))
}

@inlinable nonisolated public func font(_ font: SwiftUICore.Font?) -> some SwiftUICore.View {
    return environment(\.font, font)
}

    \.fontaqui está o fontvalor do ambiente público, mas \.tintse refere a um internalvalor de ambiente, então você não pode usá-lo em seu próprio código.

    Então, visualizações como essas Textsão apenas a leitura do valor do ambiente e a alteração de sua aparência de acordo.

    Mesmo sem olhar os arquivos .swiftinterface, você pode frequentemente inferir como algo é implementado por printing ou dumping uma visualização com esse modificador. por exemplo

    print(Text("").tint(.red))

    A saída menciona um _EnvironmentKeyWritingModifier, então pode-se inferir que ele está modificando o ambiente.

    Note que há outro modificador chamado fontque retorna a Text(ao contrário de some View). Este modificador é declarado em Textsi mesmo, então ele pode apenas criar uma cópia de self, modificar algumas propriedades e então retornar a cópia modificada.

    Então a razão pela qual font/ tintpode mudar os "internos" de uma view é porque essas views estão lendo os valores de ambiente que os modificadores definem. Não há mágica. Você não pode criar tal capitalizemodificador da mesma forma (definindo seu próprio valor de ambiente), porque Textele não lê seu valor de ambiente personalizado.

    Claro, você sempre pode criar sua própria visualização que leia o valor do ambiente:

    struct ContentView: View {
    var body: some View {
        CapitalizableText("Some example").capitalize("aoe")
    }
}

import RegexBuilder

struct CapitalizableText: View {
    let text: String
    @Environment(\.capitalizedCharacters) var capChars
    
    init(_ text: String) {
        self.text = text
    }
    
    var body: some View {
        Text(capitalized())
    }
    
    func capitalized() -> String {
        text.replacing(.anyOf(capChars)) { match in
            match.output.localizedUppercase
        }
    }
}

extension EnvironmentValues {
    @Entry var capitalizedCharacters: String = ""
}

extension View {
    func capitalize(_ chars: String) -> some View {
        environment(\.capitalizedCharacters, chars)
    }
}
    • 1

relate perguntas