IOS 17 Programming for Beginners Unlock the World of IOS Development with Swift 5. 9, Xcode 15, and IOS 17 - Your Path to App Store Success
In a world with nearly 2 million apps on the App Store, the demand for skilled iOS developers has never been higher. "iOS 17 Programming for Beginners, Eighth Edition" is your gateway to this lucrative and dynamic field. This hands-on guide is tailored for those who are new to iOS and take...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, England :
Packt Publishing Ltd
[2023]
|
| Edición: | Eighth edition |
| Colección: | Expert insight.
|
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009781237606719 |
Tabla de Contenidos:
- Cover
- Copyright
- Contributors
- Table of Contents
- Preface
- Part 1
- Chapter 1: Exploring Xcode
- Technical requirements
- Downloading and installing Xcode from the App Store
- Exploring the Xcode user interface
- Running your app in Simulator
- Understanding the Devices and Build sections
- Running your app on an iOS device
- Trusting the Developer App certificate on your iOS device
- Summary
- Chapter 2: Simple Values and Types
- Technical requirements
- Introducing Swift playgrounds
- Customizing fonts and colors
- Running playground code
- Exploring data types
- Representing integers
- Representing floating-point numbers
- Representing strings
- Representing Booleans
- Using common data types in the playground
- Exploring constants and variables
- Understanding type inference and type safety
- Using type annotation to specify a type
- Using type safety to check values
- Exploring operators
- Using arithmetic operators
- Using compound assignment operators
- Using comparison operators
- Using logical operators
- Performing string operations
- Using the print() statement
- Summary
- Chapter 3: Conditionals and Optionals
- Technical requirements
- Introducing conditionals
- Using if statements
- Using switch statements
- Introducing optionals and optional binding
- Summary
- Chapter 4: Range Operators and Loops
- Technical requirements
- Exploring range operators
- Exploring loops
- The for-in loop
- The while loop
- The repeat-while loop
- Summary
- Chapter 5: Collection Types
- Technical requirements
- Exploring arrays
- Creating an array
- Checking the number of elements in an array
- Adding a new element to an array
- Accessing an array element
- Assigning a new value to a specified index
- Removing an element from an array
- Iterating over an array
- Exploring dictionaries.
- Creating a dictionary
- Checking the number of elements in a dictionary
- Adding a new element to a dictionary
- Accessing a dictionary element
- Assigning a new value to an existing key
- Removing an element from a dictionary
- Iterating over a dictionary
- Exploring sets
- Creating a set
- Checking the number of elements in a set
- Adding a new element to a set
- Checking whether a set contains an element
- Removing an item from a set
- Iterating over a set
- Performing set operations
- Understanding set membership and equality
- Summary
- Chapter 6: Functions and Closures
- Technical requirements
- Exploring functions
- Creating a function
- Using custom argument labels
- Using nested functions
- Using functions as return types
- Using functions as parameters
- Using a guard statement to exit a function early
- Exploring closures
- Simplifying closures
- Summary
- Chapter 7: Classes, Structures, and Enumerations
- Technical requirements
- Understanding classes
- Creating a class declaration
- Making an instance of the class
- Making a subclass
- Overriding a superclass method
- Understanding structures
- Creating a structure declaration
- Making an instance of the structure
- Comparing value types and reference types
- Deciding between classes and structures
- Understanding enumerations
- Creating an enumeration
- Summary
- Chapter 8: Protocols, Extensions, and Error Handling
- Technical requirements
- Exploring protocols
- Creating a protocol declaration
- Exploring extensions
- Adopting a protocol via an extension
- Creating an array of different types of objects
- Exploring error handling
- Summary
- Learn more on Discord
- Chapter 9: Swift Concurrency
- Technical requirements
- Understanding Swift concurrency
- Examining an app without concurrency
- Updating the app using async/await.
- Improving efficiency using async-let
- Summary
- Section II
- Chapter 10: Setting Up the User Interface
- Technical requirements
- Learning useful terms in iOS development
- A tour of the JRNL app
- Using the Journal List screen
- Using the Add New Journal Entry screen
- Using the Journal Entry Detail screen
- Using the Map screen
- Modifying your Xcode project
- Setting up a tab bar controller scene
- Setting the tab bar button titles and icons
- Embedding view controllers in navigation controllers
- Configuring Interface Builder
- Summary
- Chapter 11: Building Your User Interface
- Technical requirements
- Adding a table view to the Journal List screen
- Connecting storyboard elements to the view controller
- Configuring data source methods for the table view
- Setting the delegate and data source properties of the table view
- Adopting the UITableViewDataSource and UITableViewDelegate protocols
- Presenting a view modally
- Adding a bar button to the navigation bar
- Adding a new view controller scene
- Adding Cancel and Save buttons to the navigation bar
- Summary
- Chapter 12: Finishing Up Your User Interface
- Technical requirements
- Implementing the Journal Entry Detail screen
- Implementing the Map screen
- Summary
- Chapter 13: Modifying App Screens
- Technical requirements
- Modifying the Journal List screen
- Adding an image view to journalCell
- Adding labels to journalCell
- Modifying the Add New Journal Entry screen
- Adding a custom view to the New Entry scene
- Adding a switch to the New Entry scene
- Adding a text field and a text view to the New Entry scene
- Adding an image view to the New Entry scene
- Embedding user interface elements in a stack view
- Modifying the Journal Entry Detail screen
- Configuring the number and size of static table view cells.
- Adding user interface elements to static table view cells
- Summary
- Section III
- Chapter 14: Getting Started with MVC and Table Views
- Technical requirements
- Understanding the Model-View-Controller design pattern
- Exploring view controllers
- Understanding table views
- Conforming to the UITableViewDataSource protocol
- Conforming to the UITableViewDelegate protocol
- Creating a TableViewExampleController instance
- Revisiting the Journal List screen
- Summary
- Chapter 15: Getting Data into Table Views
- Technical requirements
- Understanding model objects
- Creating a class to represent a journal entry
- Creating sample data
- Displaying data in a table view
- Creating a custom UITableViewCell subclass
- Connecting the outlets in journalCell
- Updating the data source methods in JournalListViewController
- Summary
- Chapter 16: Passing Data between View Controllers
- Technical requirements
- Passing data from the Add New Journal Entry screen to the Journal List screen
- Creating the AddJournalEntryViewController class
- Connecting the UI elements to the AddJournalEntryViewController class
- Creating a JournalEntry instance from user input
- Updating the table view with a new journal entry
- Removing rows from a table view
- Exploring text field and text view delegate methods
- Passing data from the Journal List screen to the Journal Entry Detail screen
- Creating the JournalEntryDetailViewController class
- Connecting the UI elements to the JournalEntryDetailViewController class
- Displaying the details of a journal entry
- Displaying the details of a selected journal entry
- Summary
- Chapter 17: Getting Started with Core Location and MapKit
- Technical requirements
- Getting your device location using the Core Location framework
- Modifying the AddJournalEntryViewController class.
- Modifying the Info.plist file
- Creating the MapViewController class
- Updating the JournalEntry class to conform to the MKAnnotation protocol
- Displaying annotation views on the Map screen
- Configuring a pin to display a callout
- Going from the Map screen to the Journal Entry Detail screen
- Displaying a map snapshot on the Journal Entry Detail screen
- Summary
- Chapter 18: Getting Started with JSON Files
- Technical requirements
- Creating a singleton
- Modifying the JournalEntry class to be JSON-compatible
- Loading and saving JSON data
- Summary
- Chapter 19: Getting Started with Custom Views
- Technical requirements
- Creating a custom UIStackView subclass
- Adding your custom view to the Add New Journal Entry screen
- Adding your custom view to the Journal Entry Detail screen
- Summary
- Chapter 20: Getting Started with the Camera and Photo Library
- Technical requirements
- Creating a new UIImagePickerController instance
- Implementing UIImagePickerControllerDelegate methods
- Getting permission to use the camera or photo library
- Summary
- Chapter 21: Getting Started with Search
- Technical requirements
- Implementing a search bar for the Journal List screen
- Modifying table view data source methods
- Modifying the prepare(for:sender:) method
- Modifying the method to remove journal entries
- Summary
- Chapter 22: Getting Started with Collection Views
- Technical requirements
- Understanding collection views
- Modifying the Journal List screen to use a collection view
- Replacing the table view with a collection view
- Adding user interface elements to the collection view cell
- Modifying the JournalListTableViewCell class
- Modifying the JournalListViewController class
- Dynamically modifying collection view cell size using size classes
- Understanding size classes.
- Modifying the JournalListViewController class.
