Autor-Archiv Tobias Stephan

Lors de mes premières tentatives avec Swift UI, j’ai essayé désespérément de trouver comment sélectionner l’onglet actif par programmation. L’astuce est dans la reliure.

@State public var selection = 0

En cliquant sur le bouton, la sélection indique la valeur un. Comme la sélection est directement liée à la barre d’onglets, l’élément actif de l’onglet change selon les besoins.

Button("Go",action: {self.selection = 1})

La liaison est le jeton d’accès que vous pouvez passer pour permettre un accès direct en lecture et en écriture à la valeur sans en accorder la possession (au sens de conserver un type de référence) ou la copie (pour un type de valeur).

Lorsque l’utilisateur sélectionne un onglet dans l’affichage des onglets, il modifie la valeur unilatéralement par liaison et affecte le .tag(…) correspondant à la variable Tab sélectionnée. Cela fonctionne de la même manière pour @State et ObservableObject.

Le programmeur peut également attribuer une valeur à cette variable Tab sélectionnée à tout moment – et le TabView bascule immédiatement l’onglet affiché.

C’est la clé de la navigation programmatique dans SwiftUI.

Voici un exemple que vous pouvez copier / coller directement pour jouer avec.

import SwiftUI

struct ContentView: View {
    @State public var selection = 0

    let defaults = UserDefaults.standard

    var body: some View {
        TabView(selection: $selection){
            VStack {
                Text("First View")
                Button("Go",action: {self.selection = 1})
            }
            .font(.title)
            .tabItem {
                VStack {
                    Image("first")
                    Text("First")
                }
            }
            .tag(0)
            Text("Second View")

                .font(.title)
                .tabItem {
                    VStack {
                        HStack{
                            Image("second")
                            Text("Second")
                        }
                    }
            }
            .tag(1)
        }
    }
}



struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

Ces opérations sur les cordes en Swift peuvent vous rendre fou même si vous êtes habitué à un simple à partir du C#. C’est pourquoi je me suis penché sur la question et j’ai rassemblé un peu de ça. Ceci a été testé avec le Swift 5.1

• startIndex est l’indice du premier caractères
• endIndex est l’index après le dernier caractère

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.

        let str = "Hello, playground"
        print(str[str.startIndex]) // H
        //print(str[str.endIndex])   // error: after last character

        let rangeStartToEnd = str.startIndex..



before fait référence à l'index du caractère qui précède directement l'index spécifié.



// character
let index = str.index(before: str.endIndex)
str[index] 

// range
let range = str.startIndex..



La valeur OffsetBy peut être positive ou négative et part de l'indice spécifié. Bien qu'il soit de type String.IndexDistance, vous pouvez passer une valeur Int.



// character
let index = str.index(str.startIndex, offsetBy: 7)
str[index]

// range
let start = str.index(str.startIndex, offsetBy: 7)
let end = str.index(str.endIndex, offsetBy: -6)
let range = start..



Le limitedBy est utile pour s'assurer que le décalage n'entraîne pas le dépassement des limites de l'indice. C'est un indice limite. Comme il est possible que le décalage dépasse la limite, cette méthode renvoie une option. Il retourne zéro si l'indice est en dehors des limites.



if let index = str.index(str.startIndex, offsetBy: 7, limitedBy: str.endIndex) {
    str[index]
}



Si le "offset" avait été 77 au lieu de 7, l'énoncé if aurait été sauté.



Warum denn nun der ganze Umstand?



Il serait beaucoup plus facile d'utiliser un index Int pour les cordes. La raison pour laquelle vous devez créer un nouveau String.index pour chaque chaîne est que les caractères dans Swift ne sont pas tous de la même longueur sous le capot. Un seul caractère Swift peut être constitué d'un, deux ou même plusieurs points de code Unicode. Par conséquent, chaque chaîne unique doit calculer les indices de ses caractères.



Il est possible de cacher cette complexité derrière une extension d'index Int, mais j'hésite à le faire. Il est bon de se rappeler ce qui se passe réellement.



Une extension utile



L'Extenson suivant doit être ajouté sous votre classe dans le code. Cette extension vous offre la possibilité de déterminer l'index d'une chaîne entière dans une chaîne de caractères. Dans mon exemple "terre".



Les opérations sur les chaînes de caractères sont donc traitées par le biais d'indices et de plages. L'indice n'est donc pas une simple variable integer.



extension StringProtocol {
    func index(of string: S, options: String.CompareOptions = []) -> Index? {
        range(of: string, options: options)?.lowerBound
    }
    func endIndex(of string: S, options: String.CompareOptions = []) -> Index? {
        range(of: string, options: options)?.upperBound
    }
    func indices(of string: S, options: String.CompareOptions = []) -> [Index] {
        var indices: [Index] = []
        var startIndex = self.startIndex
        while startIndex < endIndex,
            let range = self[startIndex...]
                .range(of: string, options: options) {
                indices.append(range.lowerBound)
                startIndex = range.lowerBound < range.upperBound ? range.upperBound :
                    index(range.lowerBound, offsetBy: 1, limitedBy: endIndex) ?? endIndex
        }
        return indices
    }
    func ranges(of string: S, options: String.CompareOptions = []) -> [Range] {
        var result: [Range] = []
        var startIndex = self.startIndex
        while startIndex < endIndex,
            let range = self[startIndex...]
                .range(of: string, options: options) {
                result.append(range)
                startIndex = range.lowerBound < range.upperBound ? range.upperBound :
                    index(range.lowerBound, offsetBy: 1, limitedBy: endIndex) ?? endIndex
        }
        return result
    }
}