Kategorien-Archiv Xcode Swift NL

Naar mijn mening is SwiftUI een absolute mijlpaal in de softwareontwikkeling. Het kost zeker tijd om te wennen aan deze nieuwe manier van ontwikkelen, maar de tijd die u bespaart op verdere projecten kan goed worden geïnvesteerd. Hier vindt u een eenvoudig voorbeeld van een SwiftUI TableView. Het voorbeeldproject kan gratis worden gedownload en gebruikt. Het project bevat bewust niet meer, zodat de essentiële functies bijdragen aan het begrip.

Het is vrij indrukwekkend hoe weinig regels code u met SwiftUI een TableView / ListView kunt maken. Maak gewoon een nieuw project aan en zorg ervoor dat SwiftUI als gebruikersinterface wordt geselecteerd.

Uiteraard heeft u voor dit voorbeeld nog 3 afbeeldingen nodig, deze zijn ook opgenomen in het voorbeeldproject.

Der eigentliche Code für das Projekt.

import SwiftUI

struct ContentView: View {
    var oListArray: [oListenEntries] = testData
    var body: some View {
        List(oListArray) { item in
            Image(item.imageName).resizable().frame(width: 32.0, height: 20.0)
            VStack(alignment: .leading){
                Text(item.make)
                Text(item.model)
                    .font(.subheadline)
                    .foregroundColor(Color.gray)
            }
        }
    }

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

Hier is de code voor de onderliggende array. Hiervoor heb ik een SwiftUI view gemaakt met de naam oListEntries.swift.

import SwiftUI

struct oListenEntries : Identifiable {
    var id = UUID()
    var make: String;
    var model: String;
    var imageName: String { return make }
}

let testData = [
    oListenEntries(make: "Flaschenhalter", model: "für Balkon oder Pool"),
    oListenEntries(make: "Pooladapter", model: "32 mm auf 12 mm"),
    oListenEntries(make: "Sektglashalter", model: "schwimmend")
]

Tijdens mijn eerste pogingen met Swift UI probeerde ik wanhopig uit te zoeken hoe ik het actieve tabblad programmatisch kon selecteren. De truc zit hem in de binding.

@State public var selection = 0

Met een klik op de knop selectie vertelt de waarde een. Aangezien Selectie direct gekoppeld is aan de tabbladbalk, verandert het actieve tabblad-item naar wens.

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

Bindend is het access token dat u kunt doorgeven om directe lees- en schrijftoegang tot de waarde mogelijk te maken zonder bezit (in de zin van het behouden van een referentietype) of kopiëren (voor een waardetype).

Wanneer de gebruiker een tabblad in het tabbladoverzicht selecteert, verandert hij of zij de waarde eenzijdig via binding en wijst de bijbehorende .tag(…) toe aan de geselecteerdeTab-variabele. Dit werkt op dezelfde manier voor @State en ObservableObject.

De programmeur kan ook op elk moment een waarde aan deze geselecteerde tabbladvariabele toekennen – en het tabbladView schakelt onmiddellijk naar het getoonde tabblad.
Dit is de sleutel tot programmatische navigatie in SwiftUI.

Hier is een voorbeeld dat je direct kunt kopiëren / plakken om ermee te spelen.

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

Deze snaaroperaties in Swift kunnen je gek maken, zelfs als je gewend bent aan een eenvoudige van C#. Daarom heb ik er naar gekeken en een beetje van dit alles in elkaar gezet. Dit werd getest met Swift 5.1

• startIndex is de index van het eerste teken
• endIndex is de index na het laatste teken

    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..



verwijst naar de index van het teken direct voor de gespecificeerde index.



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

// range
let range = str.startIndex..



De OffsetBy waarde kan positief of negatief zijn en begint met de gespecificeerde index. Hoewel het van het type String.IndexDistance is, kunt u een Int-waarde doorgeven.



De limitedBy is nuttig om ervoor te zorgen dat de offset niet leidt tot overschrijding van de limieten van de index. Het is een limietindex. Aangezien het mogelijk is dat de offset de grenswaarde overschrijdt, geeft deze methode een optioneel karakter. Het geeft nul terug als de index buiten de limieten valt.



Als de verrekening 77 in plaats van 7 zou zijn geweest, dan zou de if-afrekening zijn overgeslagen.



Wat is het probleem?



Het zou veel gemakkelijker zijn om een Int-index voor snaren te gebruiken. De reden dat je voor elke string een nieuwe String.index moet maken is omdat de karakters in Swift niet allemaal even lang zijn onder de motorkap. Een enkel Swift-karakter kan bestaan uit één, twee of zelfs meer Unicode-codepunten. Daarom moet elke unieke string de indexen van zijn karakters berekenen.



Het is mogelijk om deze complexiteit te verbergen achter een Int-index extensie, maar ik aarzel om dat te doen. Het is goed om herinnerd te worden aan wat er werkelijk gebeurt.



Een nuttige Extension



De volgende Extenson moet worden toegevoegd onder uw klasse in de code. Deze uitbreiding biedt u de mogelijkheid om de index van een hele string binnen een string te bepalen. In mijn voorbeeld "grond".



String operaties worden dus aangepakt via indices en ranges. De index is dus geen eenvoudige gehele variabele.



Dieser Block enthält unerwarteten oder ungültigen Inhalt.LösenZu HTML umwandeln



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
    }
}