Eric Downey的《Practical Swift》英文无水印PDF免费获取指南

需积分: 0 190 浏览量更新于2024-07-19 收藏 10.51MB PDF 举报

"《Practical Swift》是由Eric Downey编著的一本实用指南，专为Swift编程语言爱好者设计。该书以英文原版形式提供，无水印PDF版本可供阅读，确保了内容的清晰度和版权合法性。Eric Downey是这本书的主要作者，来自美国哥伦布市，展示了他对Swift语言深入的理解和实践经验。本书的国际标准书号(ISBN)分别为纸质版：978-1-4842-2279-9，电子版：978-1-4842-2280-5，同时具有DOI（Digital Object Identifier）10.1007/978-1-4842-2280-5，便于读者在全球范围内追踪和引用。图书馆登记号为2016960664，强调了版权归属，所有内容受到法律保护。《Practical Swift》享有全面的版权保护，包括翻译、复制、再版、图片再现、朗读、广播、微缩胶片复制，以及任何形式的信息存储和检索，电子适应、计算机软件使用等。特别指出，对于学术评论、学术分析或者仅为计算机系统内部使用的部分摘录，可以按照出版商所在地的版权法进行有限复制。作为一本实践性教程，书中内容涵盖了Swift语言的基础知识、高级特性和实际项目案例，帮助读者从入门到精通，无论是开发者、初学者还是经验丰富的程序员，都能从中获得有价值的指导和提升。无论是在FoxitReader还是PDF-XChangeViewer等PDF阅读器上，都能顺利打开并阅读所有的页面。由于本书源于网络共享，如果发现侵权，请及时与上传者或csdn平台沟通，以便处理相关事宜。总体来说，《Practical Swift》是一本权威且实用的Swift编程指南，是广大开发者不可或缺的学习资源。"

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页未读，继续阅读

yinkaisheng-nj

粉丝: 763

Eric Downey的《Practical Swift》英文无水印PDF免费获取指南

数据清洗实战：无水印PDF版

jQuery实战指南：无水印英文PDF

Swift编程实战：2016年Apress原版PDF，免费下载

Practical C 无水印pdf 0分

Android Software Development A Collection of Practical Projects 无水印pdf 0分

Practical DevOps 无水印原版pdf

Practical OpenCV 无水印原版pdf

Spatial Cloud Computing A Practical Approach 无水印原版pdf

Practical Machine Learning 无水印pdf

Practical Reverse Engineering 无水印pdf

最新资源