掌握Swift 3：进阶指南与iOS开发实战

需积分: 10 61 浏览量更新于2024-07-20 收藏 10.47MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

《实用Swift》是一本旨在帮助开发者深入了解Xcode和Swift 3最新特性的实用指南，适合初级到高级iOS开发者阅读。作者埃里克·唐尼从Swift语言的进化历程讲起，深入探讨了Swift 3的关键特性，如架构与设计模式、协议导向编程、Swift泛型以及测试Swift代码。本书不仅注重编码技巧的传授，更强调理解代码背后的原因，这对开发者的技术提升至关重要。第一部分，"构建参考指南"，涵盖了以下几个章节： 1. Swift的演变：介绍了Swift语言的发展背景和关键版本更新。 2. Xcode：详细介绍了苹果的集成开发环境（IDE），包括新功能和最佳实践。 3. 包管理器：讨论如何有效地管理和依赖包，支持项目组织和模块化开发。 4. iOS架构：讲解现代iOS应用的设计原则，包括Model-View-Controller（MVC）、Model-View-ViewModel（MVVM）等模式。 5. 协议导向编程：展示如何利用Swift的协议来实现松耦合和类型安全。 6. Swift泛型：教授如何创建通用代码，提高代码的灵活性和复用性。 7. iOS UI和Storyboard：介绍iOS界面设计和交互设计的最佳实践。第二部分，"构建杂货清单应用"，通过实际项目练习，加深对所学知识的理解： 8. 杂货清单App：使用Interface Builder构建用户界面。 9. MVVM模式：如何在杂货清单应用中应用架构模式，确保数据绑定和业务逻辑分离。 10. Core Data：从头开始构建应用，学习如何使用Apple的持久化框架进行数据存储。 11. 完成线：总结整个项目的开发流程，并提供最终应用的部署和优化建议。《实用Swift》作为一本实用的参考书籍，不仅适合初次接触iOS和Swift的开发者扩展技能，也适合经验丰富的开发者巩固和提升他们的知识库。无论是希望通过深入学习Swift 3的新特性，还是寻求高级iOS开发实践的指导，这本书都能提供丰富的学习资源。

资源详情

资源推荐

xix

Introduction

Welcome to Practical Swift . I’m Eric Downey and I have been developing iOS applications

for the last six years. When Swift was released over 2 years ago, I dedicated all of my time

and energy to learning Swift and its nuances. Starting off, you might have these questions

about this book:

Who should read this book?

What am I going to learn?

What sets this book apart?

That’s easy! You should read this book if you have a working knowledge of Swift. This book

assumes familiarity with the standard iOS frameworks and general programming knowledge.

You should read this book if you are an iOS developer looking to increase your skills. You are

going to learn the new features and API of Swift 3. You will develop a well-architected iOS

app in Swift 3 and the new Xcode.

Why Write This Book?

This book is about Swift 3.0 and iOS. I will explain ideas and concepts that exist in iOS and

Swift. I will show how I would write code and provide justifications for my decisions. Then

I want you, the reader, to decide for yourself how you want to write your code using your

newfound techniques and concepts.

My goal is not to tell you how to write Swift code, but give you the knowledge you need to

feel comfortable deciding how to write your own code. I want to structure the book in this

way because I have seen too many books and articles that describe how to do a particular

task. They give you a list and explain what task each piece accomplishes. However, they

never teach you why or how it could change, depending on the circumstances. Software

development is an art form and there are many ways to structure the same solution.

xx Introduction

Book Format

Each chapter will be broken down as sections. The first section in each chapter will have

an overview of the material that will be covered. It will highlight each section and give an

overview of what you will learn in the chapter. The end of each chapter will then contain a

recap of the material. This section will go over the information that will be presented in each

chapter. We will also talk about the playground reference guide we are going to create. Let’s

start with the walkthrough of the chapters.

Chapter Walkthrough

This section is going to cover each chapter. Chapters have been grouped based on their

information. Some chapters feed into others, while some are standalone. Each chapter is

also associated with a half of the book. Section I is the first half of the book. This section

is the theory and reference building section. We will discuss concepts and techniques. The

second half, Section II, will be applying Section I in building our app. Let’s get started with

Section One and Chapter One.

Section I

Section I is going to include Chapters One through Eight. I will explain key concepts and

ideas using Swift 3.0. This book expects the reader to have a working knowledge of iOS and

Swift. Using an Xcode playground, I want you to follow along, creating a reference book of

your own. This reference will be key in Section II. The following is a walkthrough of the first

eight chapters and the information they will contain.

Chapter 1

Let’s start at the beginning, the Evolution of Swift . This is probably one of the most, if not

the most, important chapter, as it sets the stage for everything. The first chapter is, in part,

a look back at the previous versions of Swift. It will walk through the release of Swift 1 and

what the new language offered us as iOS developers (I was just starting to get good at

Objective-C). We will then jump right into Swift 2 and all the cool new features. The biggest

addition and my favorite, Protocol Oriented Programming, was added in this release. If this is

not apparent, look at how many times protocols show themselves throughout this book. If I

counted right, we will discuss protocols in Chapters Five, Seven, Ten, Eleven, and Twelve. ☺

Then, by far the most important section in Chapter One, is Swift 3 . We will look at some of

the biggest changes in Swift 3. One of the biggest changes in Swift 3 is the introduction of

the API design guidelines. I will try to follow the guidelines as best I can. There will always

be room for improvement, but I hope you can look at each and every method, protocol,

class, etc. and know exactly what it is meant to do given the grammar used. Chapter One

also discussed other major proposals that are going live with Swift 3. We will go into detail in

Chapter One.

xxi Introduction

Chapters 2

Chapters Two and Three, are somewhat external to Swift 3. I included them because they

are important topics. We should know what features are available to use in our IDE, Xcode.

We will examine previous features in Xcode such as the UI Debugger and Code Coverage as

well as the brand new Xcode Source Editor Extensions. Given that we can now extend our

IDE, this opens the door for a much better development experience. I know I am going to

enjoy all the emojification extensions and making life harder on my coworkers. Chapter Two

will also discuss the Address Sanitizer, Thread Sanitizer, and the Memory Graph Debugger.

The Memory Graph Debugger is a very powerful tool and I am really looking forward to using

it in Xcode 8.

Chapter 3

Chapter Three explains the idea of Swift modules. Swift modules include our apps and

dynamic frameworks. Dynamic frameworks make creating third party libraries super easy,

which just makes them more important to understand as more can show up our projects. We

will also touch on some package managers available, such as Cocoapods, Carthage, and

the official Swift Package Manager.

The official Swift Package Manager is where I am very hopeful. The more widely adopted

this package manager becomes, the greater the potential for Swift to run anywhere.

Since Swift was open sourced, I have been very hopeful to see it pop up in other areas of

development, such as game development. The Swift Package Manager and Swift being

open source make this a possibility. In Chapter Three we are going to build a basic package

of our own.

Chapters 4

Chapter Four is all about architecture. We will examine several design patterns including

MVC, MVVM, Presenter, and Dependency Injection. Design patterns are key to software

development in general. Everything has its own flavor and iOS is no different. We will only

briefly touch on MVC, the main design pattern in iOS. The two main patterns we will go

into detail about are MVVM and Dependency Injection. These are the two main patterns we

are going to use when building our app in Section II. Chapter Four will also discuss Anti-

Patterns. Design Patterns can make our code extensible and allow it to scale. Anti-Patterns

are the opposite. We will examine how certain Anti-Patterns can ruin our code bases and

how to avoid them. Chapter Four will then feed directly into Chapter 5 , Protocol Oriented

Programming.

Chapter 5

Protocol Oriented Programming (POP) is a really awesome topic. It can solve a lot of

different problems, but it requires a slightly different way of thinking. Chapter Five is going to

prepare us to use POP in Section II and our app. POP was introduced in Swift 2 and we will

touch on it in Chapter One when discussing the evolution. POP can describe architecture,

which is why Chapter Four is so important, but more on that later. Understanding how to

effectively use POP can also avoid Anti-Patterns.

xxii Introduction

Chapter 6

Chapter Six is all about Swift generics. It walks through how generics allow for some

pretty awesome functional paradigms in Swift. This is so important to understand as

these techniques show up more and more in Swift. Then, it’s right back to protocols

with associated types. Associated types are really the last piece of Protocol Oriented

Programming. We can keep the type information in a particular protocol and use this to our

advantage in our extensions.

Chapter 7

This is going to be a heavy chapter. There are a lot of figures. We will discuss Auto Layout,

constraints, the new device configurations, and trait variations. The trait variations are by

far my favorite part of this chapter. We will see how to build a completely different interface

for landscape versus portrait. We can see how to activate and deactivate constraints and

properties based on different traits. And how could I resist throwing in a protocol. ☺ As the

iOS ecosystem expands and we see more devices, the more we are going to have to do as

developers to make sure our apps run and display correctly on each device. My hope is this

chapter will go a long way in helping you understand how to achieve this goal.

Chapter 8

This chapter is going to be all about testing. The previous chapters will take you through

techniques and concepts that can make coding super simple and quick. This chapter is

going to discuss how to rein all of these concepts in, so we can write high quality code that

is also testable. We will build a small class that has been influenced by another project on

Github called MockFive. We will then use this in our tests for our app in Section II. We will

build a package in Chapter Three and in Chapter Eight, we will revisit this package and write

tests for it.

The last topic we will touch on in Chapter Eight will be Test Driven Development (TDD). We

will examine what TDD is and how it works. Testing in iOS is still relatively new and TDD

even more so. It is important we talk about this topic and how it relates to iOS so we can

effectively write code and tests. We will discuss the benefits and drawbacks.

Section II

This half of the book will be about building our app. The app will be a simple grocery

list app. We will be able to create lists and items. The items are then associated with a

specific list. The purpose of this simple idea is to keep the focus on the techniques and the

architecture. We will have a clean architecture that will be tested. You can then take these

skills to any project. Here is a walkthrough for these chapters.

Chapter 9

This is the first chapter where we start our grocery list app. Chapter 9 is all about Interface

Builder and building the app’s UI. We are going to build this up first, so we do not have to

switch between Interface Builder and our code. This is also how I like to build apps. I like to

xxiii Introduction

start with the interface, so I can plan out how the pieces will communicate and which pieces

need to communicate. Even though we build our UI first, this does not mean we cannot

change it later.

This chapter is going to use code and discussion about Auto Layout from Chapter Seven. In

Chapter Seven we will build UI and constraints that we will use in our app. We are also going

to take our code and pull it into the app as well. This will be a fun chapter as we build our UI

and figure out how our app is going to look and feel.

Chapter 10

Chapter Ten is where we start coding our grocery list app. We will implement the MVVM

pattern in this chapter. The grocery app is going to use Core Data , but we will not start by

adding any support for Core Data . This chapter is going to create a placeholder, so we can

get going and not have to deal with Core Data here. We then use code from Chapter Four

and use the MVVM pattern to implement the two main pages in our app. We are also going

to use Dependency Injection here as well. Dependency Injection will become more clear

after Chapter Four but it will be used everywhere.

Chapter 11

Once we finish implementing half of our app, we will take a step back and stop using the

hardcoded data that was introduced in the Chapter Ten. This chapter is all about Core Data.

Core Data is a big topic and I have dedicated this entire chapter to discuss the topic and

how to implement it properly. We are going to rely on Protocol Oriented Programming and

Dependency Injection heavily to implement our interactions with Core Data . We will not

advance our grocery list app very much, but this chapter allows our app to use real data.

This brings us to the final chapter.

Chapter 12

In the last chapter, we are going to finish building our grocery list app. We are going to

examine all the loose ends we have left and we are going to finish them. We are also going

to take a look back at the app as a final reflection. It is going to be important to reflect on our

app, so we can bring this book together.

Playground Reference

The playground reference is the biggest take away from this book. I will be showing code

samples and I want you to use a Swift playground to hold onto all of this information. I then

ask you to keep using this playground once you finish this book. I have found it invaluable

to keep a running playground of all my ideas and issues I’ve found. The purpose of the

playground is that you use it in your day-to-day development.

I will explain how to effectively use the playground in Chapter Four. Swift playgrounds have a

cool markup system so you can document your code. I will document the code samples as I

go, but feel free to add more. We are also going to use code from our playground in Section

II when we build our app. All right, now that you have a good idea of what each chapter is

going to walk through, let’s get started with Chapter One, the Evolution of Swift .

剩余323页未读，继续阅读

ramissue

粉丝: 354
资源: 1487

掌握Swift 3：进阶指南与iOS开发实战

Packt.Mastering.Swift.3.Linux.2017

Learning.Swift.1784392502

Professional.Swift.1119016770

docker cookbook: over 100 practical and in...

practical node.js, 2nd edition

"[string \"/home/tpy/practical-cryptdb/wrapper.lua\"]:6: /home/tpy/practical-cr"

Brute-force algorithm

sar sensor有什么作用

Embedded Linux Primer: A Practical, Real-World Approach

practical uvm step by step pdf

practical linux security cookbook, 云盘

Fatal Error[Pe1696]: cannot open source file "sht.h" D:\SchoolClass\Practical Training on Sensor Network\Day11BasicRF\Project\sensor.c 14

Answer in English, Help me prepare an answer for the IELTS speaking test in part 1. The question is:Do you often wear jewelry?

practical contiki-ng pdf

opencv svm的英文参考文献

mastering opencv with practical projects源码

a practical guide to tpm 2.0教材.pdf

practical guide to splines carl de boor

practical c++ financial programming 中文

最新资源