Início / coding / Perguntas / 78563624
Accepted
Gordon
Asked: 2024-06-01 19:24:13 +0800 CST

Visualização SwiftUI com parâmetro vinculado opcional

  • 772

Estou tentando modificar a visualização de classificação de Stewart Lynch para oferecer suporte a uma representação estática e um "controle" para definir a classificação. Para fazer isso, preciso de algumas propriedades opcionais para abordar as duas condições diferentes. O mesmo currentRatingacontece com a classificação atual, para criar uma visão desse número de símbolos. maxRatingé a classificação máxima possível e mutableRatingé a classificação atual vinculada, para que eu possa exibir o valor da corneta como símbolos preenchidos, com o restante dos símbolos até maxRatingnão preenchidos, bem como um símbolo não preenchido e riscado para definir a classificação como 0.

Estou tendo problemas para tornar esse parâmetro vinculado também opcional. Achei isso que sugere que deveria ser possível, mas isso também é bastante antigo. De qualquer forma, tentei várias permutações como visto nas linhas comentadas, tentando fazer a inicialização funcionar, com várias falhas diferentes.

struct RatingView: View {
    var currentRating: Int?
    
    var maxRating: Int?
    @Binding var mutableRating: Int?
    
    var width:Int
    var color: UIColor
    var sfSymbol: String
    
    public init(
        currentRating: Int? = nil,
        maxRating: Int? = nil,
        mutableRating: Binding<Int?>,
//        mutableRating: Binding<Int>?,
//        mutableRating: (Binding<Int>)?,
        width: Int = 20,
        color: UIColor = .systemYellow,
        sfSymbol: String = "star"
    ) {
        self.currentRating = currentRating
        self.maxRating = maxRating
        self._mutableRating = mutableRating
//        self._mutableRating = mutableRating ?? Binding.constant(nil)
        self.width = width
        self.color = color
        self.sfSymbol = sfSymbol
    }
    
    public var body: some View {
        Text("")
    }
}

#Preview ("mutating") {
    struct PreviewWrapper: View {
        @State var rating: Int? = 3
        
        var body: some View {
            RatingView(
                maxRating: 5,
                mutableRating: $rating,
                width: 30,
                color: .red,
                sfSymbol: "heart"
            )
        }
    }
    return PreviewWrapper()
}

#Preview ("non mutating") {
    struct PreviewWrapper: View {
        
        var body: some View {
            RatingView(
                currentRating: 3,
                width: 20,
                color: .red,
                sfSymbol: "heart"
            )
        }
    }
    return PreviewWrapper()
}

Então, minha primeira pergunta é: ainda posso fazer isso no iOS 17 e, em caso afirmativo, como? E segundo, estou curioso para saber os detalhes de qual é a diferença entre essas três abordagens para os argumentos do Init.

mutableRating: Binding<Int?>
mutableRating: Binding<Int>?
mutableRating: (Binding<Int>)?

EDIT: Esclarecimento de falhas Quando uso mutableRating: Binding<Int?> e self._mutableRating = mutableRating entro Missing argument for parameter 'mutableRating' in callna non mutatingvisualização. O que presumo significa que o parâmetro não é realmente opcional, o que faz sentido dadas as diferenças mencionadas. Se eu alterar a linha do argumento para mutableRating: Binding<Int>?tornar o parâmetro opcional, obtenho Cannot assign value of type 'Binding<Int>' to type 'Binding<Int?>' on the initialization line. One of the fix options offered suggests that this might work, self._mutableRating = mutableRating ?? nil but that producesNão é possível atribuir valor do tipo 'Binding?' para digitar 'Binding<Int?>'` o que nos leva de volta à mudança no argumento.

swift

2 respostas

  1. Best Answer

    Da minha perspectiva, acredito que você está procurando:

    public init(
    ...
    mutableRating: Binding<Int?> = .constant(nil),
    ...
) { }

    Com o código acima, ambas mutatingas non mutatingvisualizações são válidas.

    • Binding< Int ?>: uma estrutura de ligação que contém um Opcional< Int > como seu wrapValue.
    • Vinculação< Int >?: um Opcional< Vinculação< Int > >
    • (Vinculação<Int> ) ? igual a Vinculação <Int> ?
    • 1

  2. Aqui está minha solução simplificada para usar uma ligação opcional a um tipo opcional e uma propriedade opcional juntas.

    struct TestView: View {
    var mutableRating: Binding<Int?>?
    let currentRating: Int?

    init(mutableRating: Binding<Int?>?) {
        self.mutableRating = mutableRating
        currentRating = nil
    }

    init(rating: Int?) {
        self.mutableRating = Optional<Binding<Int?>>.none
        currentRating = rating
    }

    var body: some View {
        if let mutableRating {
            TextField("Rating", value: mutableRating, format: .number.precision(.fractionLength(0)))
                .padding()
        } else if let currentRating {
            Text(currentRating.formatted())
        }
    }
}

#Preview {
    return TestView(mutableRating: .constant(42))
}

#Preview ("non mutating") {
    struct PreviewWrapper: View {

        var body: some View {
            VStack {
                TestView(rating: 3)
            }
            .padding()
        }
    }
    return PreviewWrapper()
}

    Testado em iOS 17.4 e macOS 14

    • 0

relate perguntas