Komma igång med Core Data Tutorial

Detta är ett förkortat kapitel från vår bok Core Data by Tutorials, som har uppdaterats helt för Swift 4.2 och iOS 12. Denna handledning presenteras som en del av vår iOS 12 lanseringsfest — njut!

Välkommen till kärndata!

i denna handledning skriver du din allra första Core Data-app. Du ser hur lätt det är att komma igång med alla resurser som finns i Xcode, från startkodsmallar till Datamodellredigeraren.

du kommer att slå marken igång redan från början. I slutet av handledningen vet du hur du ska:

• modelldata med xcodes modellredigerare
• Lägg till nya poster i kärndata
• hämta en uppsättning poster från kärndata
• visa de hämtade posterna med en tabellvy.

du får också en känsla av vad kärndata gör bakom kulisserna och hur du kan interagera med de olika rörliga bitarna.

komma igång

öppna Xcode och skapa ett nytt iOS-projekt baserat på appmallen Single View. Namnge appens hitlista och se till att använda kärndata är markerad.

om du markerar rutan Använd kärndata kommer Xcode att generera standardkodskod för vad som kallas NSPersistentContainer i AppDelegate.Snabb.

NSPersistentContainer består av en uppsättning objekt som underlättar att spara och hämta information från kärndata. Inuti denna behållare finns ett objekt för att hantera Kärndatatillståndet som helhet, ett objekt som representerar datamodellen och så vidare.

standardstacken fungerar bra för de flesta appar, men beroende på din app och dess datakrav kan du anpassa stacken för att bli effektivare.

tanken för denna exempelapp är enkel: det kommer att finnas en tabellvy med en lista med namn för din egen ”hitlista”. Du kan lägga till namn i den här listan och så småningom använda kärndata för att se till att data lagras mellan sessioner. Vi tolererar inte våld på den här webbplatsen, så du kan naturligtvis tänka på den här appen som en favoritlista för att hålla reda på dina vänner!

klicka på Huvud.storyboard för att öppna den i Interface Builder. Välj view controller på duken och bädda in den i en navigationskontroller. Från Xcodes redigeringsmeny väljer du bädda in i … Scorpion Navigation Controller.

klicka på navigationskontrollens navigeringsfält för att välja den och klicka sedan på föredrar stora titlar i Attributgranskaren. Detta ger exempelappen en titelstil som matchar Apples aktieappar.

dra sedan en tabellvy från objektbiblioteket till vykontrollen och ändra storlek på den så att den täcker hela vyn.

om den inte redan är öppen, använd ikonen i det nedre vänstra hörnet på din duk för att öppna Gränssnittsbyggarens dokumentkontur.

Ctrl-dra från tabellvyn i dokumentkonturen till dess överordnade vy och välj det inledande utrymmet till Safe Area-begränsningen:

gör detta tre gånger, välja begränsningar avslutande utrymme till säkert område, topp utrymme till säkert område och slutligen, botten utrymme till säkert område. Om du lägger till de fyra begränsningarna kommer tabellvyn att fylla sin överordnade vy.

dra sedan ett Bar – Knappobjekt och placera det på vykontrollens navigeringsfält. Slutligen väljer du bar – knappen och ändrar dess systemobjekt för att lägga till.

din duk ska likna följande skärmdump:

varje gång du trycker på knappen Lägg till visas en varningskontroll som innehåller ett textfält. Därifrån kan du skriva någons namn i textfältet. Om du trycker på Save sparar du namnet, avvisar varningskontrollen och uppdaterar tabellvyn och visar alla namn du har angett.

men först måste du göra vykontrollen tabellvyns datakälla. I duken drar du Ctrl – dra från tabellvyn till den gula visningskontrollikonen ovanför navigeringsfältet, som visas nedan, och klickar på datakälla:

om du undrar behöver du inte ställa in tabellvyns delegat eftersom det inte kommer att utlösa någon åtgärd att knacka på cellerna. Det blir inte enklare än så här!

öppna assistentredigeraren genom att trycka på Command-Option-Enter eller genom att välja mittknappen på Redigeringsverktygsuppsättningen på Xcode-fältet.

Ctrl-dra från tabellvyn till ViewController.swift inuti klassdefinitionen för att skapa en IBOutlet.

namnge sedan den nya egenskapen IBOutlet tableView, vilket resulterar i följande rad:

@IBOutlet weak var tableView: UITableView!

nästa, Ctrl-dra från knappen Lägg till i ViewController.swift precis under din viewDidLoad() definition. Den här gången skapar du en åtgärd istället för ett uttag, namnger metoden addName , med en typ UIBarButtonItem:

@IBAction func addName(_ sender: UIBarButtonItem) { }

du kan nu hänvisa till tabellvyn och bar-knappobjektets åtgärd i kod.

därefter ställer du in modellen för tabellvyn. Lägg till följande egenskap i ViewController.swift under tableView IBOutlet:

var names: = 

names är en föränderlig array som håller strängvärden som visas av tabellvyn. Ersätt sedan implementeringen av viewDidLoad() med följande:

override func viewDidLoad() { super.viewDidLoad() title = "The List" tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")}

detta ställer in en titel i navigeringsfältet och registrerar klassen UITableViewCell med tabellvyn.

nästa, fortfarande i ViewController.swift, Lägg till följande UITableViewDataSource – tillägg under din klassdefinition för ViewController:

// MARK: - UITableViewDataSourceextension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return names.count } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.textLabel?.text = names return cell }}

om du någonsin har arbetat med UITableView, bör den här koden se väldigt bekant ut. Först returnerar du antalet rader i tabellen som antalet objekt i din names array.

nästa, tableView(_:cellForRowAt:) dequeues tabellvyceller och fyller dem med motsvarande sträng från matrisen names.

därefter behöver du ett sätt att lägga till nya namn så att tabellvyn kan visa dem. Implementera metoden addName IBAction som du Ctrl-släpade in i din kod tidigare:

// Implement the addName IBAction@IBAction func addName(_ sender: UIBarButtonItem) { let alert = UIAlertController(title: "New Name", message: "Add a new name", preferredStyle: .alert) let saveAction = UIAlertAction(title: "Save", style: .default) { action in guard let textField = alert.textFields?.first, let nameToSave = textField.text else { return } self.names.append(nameToSave) self.tableView.reloadData() } let cancelAction = UIAlertAction(title: "Cancel", style: .cancel) alert.addTextField() alert.addAction(saveAction) alert.addAction(cancelAction) present(alert, animated: true)}

varje gång du trycker på knappen Lägg till kommer den här metoden att presentera en UIAlertController med ett textfält och två knappar: spara och Avbryt.

spara infogar textfälten aktuell text i matrisen names och laddar sedan om tabellvyn. Eftersom names arrayen är den modell som stöder tabellvyn visas vad du än skriver i textfältet i tabellvyn.

slutligen bygga och köra din app för första gången. Tryck sedan på knappen Lägg till. Varningskontrollen kommer att se ut så här:

Lägg till fyra eller fem namn i listan. Du bör se något liknande nedan:

din tabellvy visar data och din array lagrar namnen, men det stora som saknas här är uthållighet. Arrayen finns i minnet men om du tvingar avsluta appen eller starta om enheten, din träfflista kommer att utplånas. Kärndata ger uthållighet, vilket betyder att det kan lagra data i ett mer hållbart tillstånd så att det kan överleva en appåterstart eller en omstart av enheten.

du har inte lagt till några Kärndataelement ännu, så ingenting bör kvarstå när du navigerar bort från appen. Låt oss testa det här. Tryck på Hem-knappen om du använder en fysisk enhet eller motsvarande (Shift + 6 + h) om du använder simulatorn. Detta tar dig tillbaka till det välbekanta appnätet på startskärmen:

på startskärmen trycker du på Hitlistikonen för att få appen tillbaka till förgrunden. Namnen finns fortfarande på skärmen. Vad var det som hände?

när du trycker på hemknappen går appen för närvarande i förgrunden till bakgrunden. När detta händer fryser operativsystemet allt som för närvarande finns i minnet, inklusive strängarna i namnmatrisen. På samma sätt, när det är dags att vakna och återgå till förgrunden, återställer operativsystemet det som brukade vara i minnet som om du aldrig hade lämnat.

Apple introducerade dessa framsteg i multitasking tillbaka i iOS 4. De skapar en sömlös upplevelse för iOS-användare men lägger till en rynka i definitionen av uthållighet för iOS-utvecklare. Är namnen verkligen kvar?

Nej, inte riktigt. Om du helt hade dödat appen i fast app switcher eller stängt av telefonen, skulle dessa namn vara borta. Du kan verifiera detta också. Med appen i förgrunden, ange snabb App switcher. Du kan göra detta genom att antingen dubbelklicka på hemknappen om enheten har en eller långsamt dra uppåt från botten av skärmen Om du är på en iPhone X.

härifrån, flick HitList app snapshot uppåt för att avsluta appen. Om du arbetar på en iPhone X måste du trycka länge på appens ögonblicksbild tills en röd raderingsknapp visas längst upp till höger.

när du har tagit bort appen från app switcher, bör det inte finnas några spår av HitList i levande minne (no pun intended). Kontrollera namnen är borta genom att återvända till startskärmen och trycka på HitList ikonen för att utlösa en ny lansering.

skillnaden mellan blixtfrysning och uthållighet kan vara uppenbar om du har arbetat med iOS under en tid och är bekant med hur multitasking fungerar. I användarens sinne är det dock ingen skillnad. Användaren bryr sig inte om varför namnen fortfarande finns där, om appen gick in i bakgrunden och kom tillbaka, eller för att appen sparade och laddade om dem. Allt som betyder något är namnen finns kvar när appen kommer tillbaka!

så det verkliga testet av uthållighet är om dina data fortfarande finns kvar efter en ny applansering.

modellering av dina Data

nu vet du hur du kontrollerar uthållighet, du kan dyka in i kärndata. Ditt mål för HitList-appen är enkelt: fortsätt Namnen du anger så att de är tillgängliga för visning efter en ny applansering.

fram till den här tiden har du använt vanliga gamla Swift-strängar för att lagra namnen i minnet. I det här avsnittet ersätter du dessa strängar med Kärndataobjekt.

det första steget är att skapa en hanterad objektmodell, som beskriver hur kärndata representerar data på disken.

som standard använder Core Data en SQLite-databas som den ihållande butiken, så du kan tänka på datamodellen som databasschemat.

eftersom du har valt att använda kärndata skapade Xcode automatiskt en Datamodellfil för dig och namngav den HitList.xcdatamodeld.

Öppna HitList.xcdatamodeld. Som du kan se har Xcode en kraftfull Datamodellredigerare:

Datamodellredigeraren har många funktioner som du kan utforska senare. Låt oss nu fokusera på att skapa en enda Kärndataenhet.

klicka på Lägg till enhet längst ner till vänster för att skapa en ny enhet. Dubbelklicka på den nya enheten och ändra dess namn till Person, så:

du kanske undrar varför modellredigeraren använder termen Entity. definierade du inte bara en ny klass? Som du kommer att se inom kort kommer Core Data med sitt eget ordförråd. Här är en snabb genomgång av vissa termer som du ofta stöter på:

• en enhet är en klassdefinition i kärndata. Det klassiska exemplet är en Employee eller en Company. I en relationsdatabas motsvarar en entitet en tabell.
• ett attribut är en information som är kopplad till en viss enhet. Till exempel kan en Employee – enhet ha attribut för den anställdes name, position och salary. I en databas motsvarar ett attribut ett visst fält i en tabell.
• en relation är en länk mellan flera entiteter. I kärndata kallas relationer mellan två enheter till-en-relationer, medan de mellan en och många enheter kallas till-många relationer. Till exempel kan en Manager ha en till-många relation med en uppsättning anställda, medan en individ Employee vanligtvis har en till-en relation med sin chef.

nu vet du vad ett attribut är, du kan lägga till ett attribut till Person objekt skapat tidigare. Fortfarande i HitList.xcdatamodeld, välj Person på vänster sida och klicka på plustecknet ( + ) under attribut.

ange det nya attributets namn till, er, namn och ändra dess typ till sträng:

i kärndata kan ett attribut vara av en av flera datatyper.

Spara till kärndata

öppna ViewController.swift, lägga till följande centrala datamodulen import under UIKit import:

import CoreData

denna import är allt du behöver för att börja använda Core Data API i din kod.

nästa, ersätt names egenskapsdefinitionen med följande:

var people: = 

du lagrar Personentiteter snarare än strängnamn, så du byter namn på matrisen som fungerar som tabellvyns datamodell till people. Det har nu instanser av NSManagedObject snarare än enkla strängar.

NSManagedObject representerar ett enda objekt som lagras i Core Data; du måste använda den för att skapa, redigera, spara och ta bort från din core Data persistent store. Som du kommer att se inom kort är NSManagedObject en formskiftare. Det kan ta formen av vilken enhet som helst i din datamodell och använda alla attribut och relationer du definierade.

eftersom du ändrar tabellvyns modell måste du också ersätta båda datakällmetoderna som implementerats tidigare. Ersätt ditt UITableViewDataSource – tillägg med följande:

// MARK: - UITableViewDataSourceextension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return people.count } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let person = people let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) cell.textLabel?.text = person.value(forKeyPath: "name") as? String return cell }}

den mest signifikanta förändringen av dessa metoder sker i tableView(_:cellForRowAt:). Istället för att matcha celler med motsvarande sträng i modellmatrisen matchar du nu celler med motsvarande NSManagedObject.

notera hur du tar tag i attributet name från NSManagedObject. Det händer här:

cell.textLabel?.text = person.value(forKeyPath: "name") as? String

Varför måste du göra det här? Som det visar sig vet NSManagedObject inte om attributet name som du definierade i din datamodell, så det finns inget sätt att komma åt det direkt med en egenskap. Det enda sättet som kärndata ger för att läsa värdet är nyckelvärdeskodning, vanligtvis kallad KVC.

nästa, hitta addName(_:) och ersätt save UIAlertAction med följande:

let saveAction = UIAlertAction(title: "Save", style: .default) { action in guard let textField = alert.textFields?.first, let nameToSave = textField.text else { return } self.save(name: nameToSave) self.tableView.reloadData()}

detta tar texten i textfältet och överför den till en ny metod som heter save(name:). Xcode klagar eftersom save(name:) inte existerar än. Lägg till det nedan addName(_:):

func save(name: String) { guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return } // 1 let managedContext = appDelegate.persistentContainer.viewContext // 2 let entity = NSEntityDescription.entity(forEntityName: "Person", in: managedContext)! let person = NSManagedObject(entity: entity, insertInto: managedContext) // 3 person.setValue(name, forKeyPath: "name") // 4 do { try managedContext.save() people.append(person) } catch let error as NSError { print("Could not save. \(error), \(error.userInfo)") }}

det är här Core Data sparkar in! Här är vad koden gör:

1. innan du kan spara eller hämta något från din kärn datalager, måste du först få tag på en NSManagedObjectContext. Du kan betrakta ett hanterat objektkontext som en ”scratchpad” i minnet för att arbeta med hanterade objekt.

   Tänk på att spara ett nytt hanterat objekt till kärndata som en tvåstegsprocess: först sätter du in ett nytt hanterat objekt i ett hanterat objektkontext; när du är nöjd ”begår du” ändringarna i ditt hanterade objektkontext för att spara det på disken.

   Xcode har redan genererat ett hanterat objektkontext som en del av det nya projektets Mall. Kom ihåg att detta bara händer om du markerar kryssrutan Använd kärndata i början. Detta förvalda objektkontext lever som en egenskap hos NSPersistentContainer i applikationsombudet. För att komma åt det får du först en referens till appdelegaten.

2. du skapar ett nytt hanterat objekt och infogar det i hanterat objektkontext. Du kan göra detta i ett steg med NSManagedObjectstatiska metod: entity(forEntityName:in:).

   du kanske undrar vad en NSEntityDescription handlar om. Minns tidigare, NSManagedObject kallades en shape-shifter-klass eftersom den kan representera vilken enhet som helst. En entitetsbeskrivning är den del som länkar entitetsdefinitionen från din datamodell med en instans av NSManagedObject vid körning.

1. med NSManagedObject i handen ställer du in attributet name med nyckelvärdeskodning. Du måste stava KVC-tangenten (name i det här fallet) exakt som den visas i din datamodell, annars kommer din app att krascha vid körning.
2. du förbinder dina ändringar till person och sparar till disk genom att ringa save i det hanterade objektkontexten. Obs! save kan kasta ett fel, varför du kallar det med hjälp av try nyckelordet inom ett do-catch – block. Slutligen sätter du in det nya hanterade objektet i people – arrayen så att det visas när tabellvyn laddas om.

det är lite mer komplicerat än att använda en rad strängar, men inte så illa. En del av koden här, till exempel att få det hanterade objektkontexten och enheten, kan göras bara en gång i din egen init() eller viewDidLoad() och återanvändas senare. För enkelhetens skull gör du allt på samma sätt.

Bygg och kör appen och Lägg till några namn i tabellvyn:

om namnen faktiskt lagras i kärndata bör HitList-appen klara uthållighetstestet. Med appen i förgrunden, gå till fast app switcher och avsluta den sedan.

från Springboard trycker du på HitList-appen för att utlösa en ny lansering. Vänta, vad hände? Tabellvyn är tom:

du sparade till kärndata, men efter en ny applansering är arrayen people Tom! Det beror på att data sitter på disken och väntar på dig, men du visar inte det ännu.

hämta från kärndata

för att hämta data från din beständiga butik till det hanterade objektkontexten måste du hämta den. Öppna ViewController.swift och Lägg till följande nedan viewDidLoad():

override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) //1 guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return } let managedContext = appDelegate.persistentContainer.viewContext //2 let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person") //3 do { people = try managedContext.fetch(fetchRequest) } catch let error as NSError { print("Could not fetch. \(error), \(error.userInfo)") }}

steg för steg, det här är vad koden gör:

1. innan du kan göra något med kärndata behöver du ett hanterat objektkontext. Hämtning är inte annorlunda! Som tidigare drar du upp applikationsdelegaten och tar en hänvisning till dess ihållande behållare för att få händerna på dess NSManagedObjectContext.
2. som namnet antyder är NSFetchRequest den klass som ansvarar för att hämta från kärndata. Hämta förfrågningar är både kraftfulla och flexibla. Du kan använda hämta förfrågningar för att hämta en uppsättning objekt som uppfyller de angivna kriterierna (dvs. ge mig alla anställda som bor i Wisconsin och har varit i företaget minst tre år), individuella värden (dvs. ge mig det längsta namnet i databasen) och mer.

   hämta förfrågningar har flera kval som används för att förfina uppsättningen resultat som returneras. För tillfället borde du veta att NSEntityDescription är en av dessa obligatoriska kval.

   om du ställer in egenskapen entity för en hämtningsbegäran, eller alternativt initierar den med init(entityName:), hämtas alla objekt från en viss enhet. Det här är vad du gör här för att hämta alla Person – enheter. Observera också att NSFetchRequest är en generisk typ. Denna användning av generika anger en hämtningsbegärans förväntade returtyp, i detta fall NSManagedObject.

3. du överlämnar hämtningsbegäran till det hanterade objektkontexten för att göra den tunga lyftningen. fetch(_:) returnerar en array med hanterade objekt som uppfyller de villkor som anges i hämtningsbegäran.

Bygg och kör programmet. Omedelbart bör du se listan över namn du lagt till tidigare:

toppen! De är tillbaka från de döda (pun intended). Lägg till några fler namn i listan och starta om appen för att verifiera att spara och hämta fungerar. Kort om att ta bort appen, återställa simulatorn eller kasta telefonen från en hög byggnad, kommer Namnen att visas i tabellvyn oavsett vad.

viktiga punkter

• kärndata ger uthållighet på disken, vilket innebär att dina data kommer att vara tillgängliga även efter att du har avslutat din app eller stängt av enheten. Detta skiljer sig från uthållighet i minnet, som bara sparar dina data så länge din app är i minnet, antingen i förgrunden eller i bakgrunden.
• Xcode levereras med en kraftfull Datamodellredigerare, som du kan använda för att skapa din hanterade objektmodell.
• en hanterad objektmodell består av entiteter, attribut och relationer
• en entitet är en klassdefinition i kärndata.
• ett attribut är en information som är kopplad till en entitet.
• en relation är en länk mellan flera entiteter.
• en NSManagedObject är en run-time representation av en Kärndataenhet. Du kan läsa och skriva till dess attribut med hjälp av Nyckelvärdeskodning.
• du behöver en NSManagedObjectContext till save() eller fetch(_:) data till och från kärndata.

vart ska man gå härifrån?

du kan ladda ner det färdiga projektet för denna handledning med knapparna” ladda ner material ” längst upp eller längst ner i denna handledning.

i den här handledningen har du redan upplevt flera grundläggande Kärndatakoncept: datamodeller, enheter, attribut, hanterade objekt, hanterade objektkontexter och hämtningsförfrågningar.

om du gillade det du lärde dig i den här handledningen, varför inte kolla in den fullständiga kärndata från Tutorials-boken, som finns i vår butik?

här är en smak av vad som finns i boken:

1. Kapitel 1, Din första Core Data-App: du klickar på Arkiv nya projekt och skriver en Core Data-app från början! Det här kapitlet täcker grunderna för att konfigurera din datamodell och sedan lägga till och hämta poster.

2. Kapitel 2, Nsmanagedobject-underklasser: NSManagedObject är basdatalagringsklassen för dina Kärndataobjektgrafer. I det här kapitlet lär du dig hur du anpassar dina egna hanterade objektunderklasser för att lagra och validera data.

3. Kapitel 3, Kärndatastacken: under huven består kärndata av många delar som arbetar tillsammans. I det här kapitlet lär du dig hur dessa delar passar ihop och flyttar dig bort från starter Xcode-mallen för att bygga ditt eget anpassningsbara system.

4. Kapitel 4, mellanliggande hämtning: dina appar hämtar data hela tiden, och Core Data erbjuder många alternativ för att få data till dig effektivt. Detta kapitel omfattar mer avancerade hämtningsförfrågningar, predikat, sortering och asynkron hämtning.

5. Kapitel 5, Nsfetchedresultscontroller: tabellvyer är kärnan i många iOS-appar, och Apple vill få kärndata att spela snyggt med dem! I det här kapitlet lär du dig hur NSFetchedResultsController kan spara tid och kod när dina tabellvyer stöds av data från kärndata.

6. Kapitel 6, versionshantering och migrering: när du uppdaterar och förbättrar din app kommer dess datamodell nästan säkert att behöva ändras. I det här kapitlet lär du dig hur du skapar flera versioner av din datamodell och sedan migrerar användarna framåt så att de kan behålla sina befintliga data när de uppgraderar.

7. Kapitel 7, enhetstester: testning är en viktig del av utvecklingsprocessen, och du bör inte lämna kärndata ur det! I det här kapitlet lär du dig hur du ställer in en separat testmiljö för kärndata och ser exempel på hur du testar dina modeller.

8. Kapitel 8, mäta och öka prestanda: Ingen klagade någonsin på att en app var för snabb, så det är viktigt att vara vaksam om att spåra prestanda. I det här kapitlet lär du dig att mäta appens prestanda med olika Xcode-verktyg och sedan hämta några tips för att hantera långsamma fläckar i din kod.

9. Kapitel 9, flera hanterade Objektkontexter: i det här sista kapitlet expanderar du den vanliga Kärndatastacken för att inkludera flera hanterade objektkontexter. Du lär dig hur detta kan förbättra upplevd prestanda och hjälpa till att göra din apparkitektur mindre monolitisk och mer uppdelad.

och för att hjälpa till att söta affären är den digitala upplagan av boken till försäljning för $44.99! Men vänta inte-detta försäljningspris är endast tillgängligt under en begränsad tid.

på tal om söta erbjudanden, se till att kolla in de fantastiska priserna vi ger bort i år med iOS 11 lanseringsfest, inklusive över $9,000 i giveaways!

för att vara berättigad till denna episka iOS 12 giveaway, behöver du bara lämna en kommentar på det ursprungliga lanseringsposten, så att vi vet vilken bok eller kurs som är din favorit på den här listan — eller vilken kommande bok eller kurs du är mest upphetsad över!

vi hoppas att du njuta av den här uppdateringen, och håll ögonen öppna för fler bokreleaser och uppdateringar!