Início / coding / Perguntas / 78843288
Accepted
john smith
Asked: 2024-08-07 18:57:04 +0800 CST

Como limpar um TextField quando ele está vinculado a um objeto SwiftData que não é opcional

  • 772

Digamos que você tenha um objeto SwiftData que não permite opcionais:

@Model
class MySet: Identifiable {
    var id: UUID
    var weight: Int
    var reps: Int
    var isCompleted: Bool
    var exercise: Exercise

Então você obtém dos dados do MySet uma lista desses MySets e os anexa a um estado:

  @State var sets: [MySet]

            if let newSets = exercise.sets {    //unwrapping the passed exercises sets
                if (!newSets.isEmpty) {     //we passed actual sets in so set them to our set
                    sets = newSets
                }

E você usa essa lista de estados em um ForEach e vincula o Textfield diretamente aos dados assim:

 ForEach($sets){ $set  in

 TextField("\(set.weight)", value: $set.weight, formatter: NumberFormatter())
                                        .keyboardType(.decimalPad)

   TextField("\(set.reps)", value: $set.reps,formatter: NumberFormatter())
                                        .keyboardType(.decimalPad)
                                    


}

Isso vinculará tudo o que estiver escrito no TextField diretamente ao objeto SwiftData, o que é um problema porque, digamos que você tenha 50 escritos e queira alterá-lo para 60, você precisa limpar o 50 para escrever o 60 e já que o objeto SwiftData não permite nulo, permitirá que você remova o 0, mas não o 5. Existe alguma maneira de remediar isso sem que o objeto swiftData permita opcionais, por exemplo, capturar a limpeza do TextField e torná-lo 0 em vez de nulo quando for limpo?

Tento consertar isso vinculando TextField a um novo estado e usando onChanged:

@State private var reps: Int = 0
@State private var weight: Int = 0

                            TextField("\(myset.weight)", value: $weight, formatter: NumberFormatter())
                                .keyboardType(.decimalPad)
                             
                                .onChange(of: weight) { newWeight in
                                    // Code to run when propertyToWatch changes to newValue
                                    if newWeight != 0 {
                                        myset.weight = newWeight
                                    }
                                }

mas agora ele está mudando cada repetição e peso de todas as séries quando eu digito uma em vez de apenas aquela em que estou digitando

swift

2 respostas

  1. Você pode criar uma ligação personalizada que deve resolver o problema:

    private func weightBinding(for set: MySet) -> Binding<Int?> {
    Binding<Int?>(
         get: { set.weight },
         set: { value in
             if let value {
                set.weight = value
             }
          }
      )
}

ForEach(sets) { set in
   TextField("\(set.weight)", value: weightBinding(for: set), formatter: NumberFormatter())
}

// or as extension if you prefer:
extension MySet {
    var weightBinding: Binding<Int?> {
        Binding<Int?>(
            get: { self.weight },
            set: { value in
                if let value {
                    self.weight = value
                }
            }
        )
    }
}

TextField("\(set.weight)", value: set.weightBinding, formatter: NumberFormatter())

    Assim você pode limpar o campo de texto, mas se não inserir um novo valor e parar de editar, ele usará o último valor.

    EDITAR:

    Se você deseja definir o valor como 0 quando o campo de texto estiver vazio, você precisa alterar o Binding para isto:

    
 Binding<Int?>(
         get: { set.weight },
         set: { value in
             self.weight = value ?? 0
          }
      )
    • 1
  2. Best Answer

    Não sei por que seu código não está funcionando. Ajudaria ter um exemplo mínimo reproduzível para trabalhar.

    No entanto, uma maneira de chegar a uma solução seria criar um wrapper genérico para um arquivo TextField. O wrapper pode conter a variável de estado de sombra e realizar a cópia do opcional para o não opcional.

    Aqui está uma tentativa de implementar tal wrapper. Eu optei pelo Textfieldinicializador que leva ParseableFormatStyle:

    struct ValueField<F>: View
where F: ParseableFormatStyle, F.FormatInput: Equatable, F.FormatOutput == String {
    private let titleKey: LocalizedStringKey
    @Binding private var value: F.FormatInput
    private let format: F
    private let prompt: Text?
    @State private var fieldVal: F.FormatInput?
    @FocusState private var isFocused: Bool

    init(
        _ titleKey: LocalizedStringKey,
        value: Binding<F.FormatInput>,
        format: F,
        prompt: Text? = nil
    ) {
        self.titleKey = titleKey
        self._value = value
        self.format = format
        self.prompt = prompt
    }

    var body: some View {
        TextField(titleKey, value: $fieldVal, format: format, prompt: prompt)
            .focused($isFocused)
            .onChange(of: fieldVal) { oldVal, newVal in
                if let newVal, newVal != value {
                    value = newVal
                }
            }
            .onChange(of: isFocused, initial: true) { oldVal, newVal in
                if newVal {
                    fieldVal = nil
                } else if fieldVal == nil {
                    fieldVal = value
                }
            }
    }
}

    Exemplo de uso:

    struct ContentView: View {
    @State private var val: Int = 0

    var body: some View {
        VStack(spacing: 40) {
            ValueField(
                "Weight",
                value: $val,
                format: .number,
                prompt: Text("Weight")
            )
            .keyboardType(.decimalPad)

            TextField("Dummy", text: dummy)
        }
        .textFieldStyle(.roundedBorder)
        .padding()
    }

    private var dummy: Binding<String> {
        Binding<String>(
            get: { "\(val)" },
            set: { _ in /* NOP */ }
        )
    }
}

    Animação

    • 0

relate perguntas