掌握iOS 10开发基础：Swift 3与Xcode 8与Cocoa入门指南

5星 · 超过95%的资源需积分: 10 63 浏览量更新于2024-07-20 1 收藏 8.43MB PDF 举报

《iOS 10编程基础：用Swift》（O'Reilly，2016年版）是一本全面指南，旨在帮助读者进入iOS开发领域，特别是通过掌握Swift 3，这是苹果备受赞誉的编程语言的最新版本。作者Matt Neuburg以详实的教程形式，引导读者学习iOS开发的基础知识，包括Xcode集成开发环境（IDE）、Cocoa Touch框架以及Swift的面向对象概念。本书首先介绍了Swift的关键概念，如变量和函数、作用域和命名空间、对象类型和实例，帮助读者理解如何构建和操作程序的基本结构。接着，读者将熟悉Swift的内置类型，如数字、字符串、范围、元组、可选类型、数组、字典和集合。在构建对象类型方面，书中有深入讲解，涵盖了枚举（enum）、结构体（struct）和类的声明、实例化和自定义方法。书中还着重介绍了Swift的新特性，比如协议（protocols）和泛型（generics），这些都是Swift 3中的创新元素。此外，读者还将了解到Xcode 8及Swift 3对API的更新，以及Foundation框架的桥梁类型和其他新功能。学习者将跟随作者的脚步，探索项目从创建到App Store发布的完整生命周期，了解Xcode的自动代码签名和调试工具。对于应用程序界面设计，书中会指导读者使用 nib 编辑器（Interface Builder）来构造用户界面，并理解Cocoa事件驱动模型及其设计模式和关键功能。此外，书中还会展示Swift如何与C和Objective-C API进行交互，这对于iOS开发者来说至关重要。完成基础学习后，读者将具备足够的实力去深入探索iOS应用开发的细节，因为作者的另一本配套书籍《Programming iOS 10》将进一步深化主题。这本书是iOS开发者的宝贵资源，适合初学者和有一定经验的开发者提升技能，紧跟iOS 10时代的步伐。版权信息和出版信息也清晰标注，确保读者获取的是最新且合法的教材。

aspects of the language that, in my experience, actually come into play in the

course of programming iOS.

• Part II turns to Xcode, the world in which all iOS programming ultimately takes

place. It explains what an Xcode project is and how it is transformed into an app,

and how to work comfortably and nimbly with Xcode to consult the documenta‐

tion and to write, navigate, and debug code, as well as how to bring your app

through the subsequent stages of running on a device and submission to the App

Store. There is also a very important chapter on nibs and the nib editor (Interface

Builder), including outlets and actions as well as the mechanics of nib loading;

however, such specialized topics as autolayout constraints in the nib are post‐

poned to the other book.

• Part III introduces the Cocoa Touch framework. When you program for iOS, you

take advantage of a suite of frameworks provided by Apple. These frameworks,

taken together, constitute Cocoa; the brand of Cocoa that provides the API for

programming iOS is Cocoa Touch. Your code will ultimately be almost entirely

about communicating with Cocoa. The Cocoa Touch frameworks provide the

underlying functionality that any iOS app needs to have. But to use a framework,

you have to think the way the framework thinks, put your code where the frame‐

work expects it, and fulfill many obligations imposed on you by the framework.

To make things even more interesting, Cocoa uses Objective-C, while you’ll be

using Swift: you need to know how your Swift code will interface with Cocoa’s

features and behaviors. Cocoa provides important foundational classes and adds

linguistic and architectural devices such as categories, protocols, delegation, and

notifications, as well as the pervasive responsibilities of memory management.

Key–value coding and key–value observing are also discussed here.

The reader of this book will thus get a thorough grounding in the fundamental

knowledge and techniques that any good iOS programmer needs. The book itself

doesn’t show how to write any particularly interesting iOS apps, but it does constantly

use my own real apps and real programming situations to illustrate and motivate its

explanations. And then you’ll be ready for Programming iOS 10, of course!

Versions

This book is geared to Swift 3, iOS 10, and Xcode 8.

In general, only very minimal attention is given to earlier versions of iOS and Xcode.

It is not my intention to embrace in this book any detailed knowledge about earlier

versions of the software, which is, after all, readily and compendiously available in my

earlier books. The book does contain, nevertheless, a few words of advice about back‐

ward compatibility (especially in Chapter 9).

xiv | Preface

The Swift language included with Xcode 8, Swift 3, has changed very significantly

from its predecessor, Swift 2. A few important basic syntax changes were foreshad‐

owed in Swift 2.2 and Swift 2.3, but Swift 3 adds many more, plus “renamification”

has changed the names of many standard library and Cocoa methods, along with the

new Foundation “overlay” that removes the “NS” prefix from certain type names.

Fortunately, if you have existing Swift 2 code, Xcode 8 comes with a migrator that will

update your Swift 2 code to Swift 3 in a remarkably intelligent fashion. This book,

conversely, is totally incompatible with Swift 2 and doesn’t discuss it; for the most

part, I behave as if Swift 2 never existed. I do call out a few particularly noteworthy

Swift 3 innovations, but by no means all of them.

In this edition, I have dropped my earlier convention of referring to Cocoa methods

by their Objective-C name, because “renamification” has made it impossible to

deduce the Swift 3 name of an Objective-C method. Instead, I give the name in Swift,

as a function reference (as described in Chapter 2) — that is, the name plus the

parameter labels followed by colon in parentheses. Now and then, if a method is

already under discussion and there is no ambiguity, I’ll use the bare name. (In a few

places, such as Appendix A, where the Objective-C language is explicitly under dis‐

cussion, I naturally do still use Objective-C method names.)

Please bear in mind that Apple continues to make adjustments to the Swift language.

I have tried to keep my code up-to-date right up to the moment when the manuscript

left my hands; but if, at some future time, a new version of Xcode is released along

with a new version of Swift, some of the code in this book, and even some informa‐

tion about Swift itself, might be slightly incorrect. Please make allowances, and be

prepared to compensate.

Screenshots of Xcode were taken using Xcode 8 under OS X 10.11 El Capitan. I have

not upgraded my machine to macOS 10.12 Sierra, because at the time of this writing

it was too new to be trusted with mission-critical work. If you are braver than I am

and are running Sierra, your interface may naturally look very slightly different from

the screenshots, but this difference will be minimal and shouldn’t cause any confu‐

sion.

Acknowledgments

My thanks go first and foremost to the people at O’Reilly Media who have made writ‐

ing a book so delightfully easy: Rachel Roumeliotis, Sarah Schneider, Kristen Brown,

Dan Fauxsmith, Adam Witwer, and Sanders Kleinfeld come particularly to mind.

And let’s not forget my first and long-standing editor, Brian Jepson, whose influence

is present throughout.

Preface | xv

As in the past, I have been greatly aided by some fantastic software, whose excellences

I have appreciated at every moment of the process of writing this book. I should like

to mention, in particular:

•

git (http://git-scm.com)

•

SourceTree (http://www.sourcetreeapp.com)

• TextMate (http://macromates.com)

• AsciiDoc (http://www.methods.co.nz/asciidoc)

•

Asciidoctor (http://asciidoctor.org)

•

BBEdit (http://barebones.com/products/bbedit/)

• EasyFind (http://www.devontechnologies.com/products/freeware.html)

• Snapz Pro X (http://www.ambrosiasw.com)

• GraphicConverter (http://www.lemkeso.com)

• OmniGraffle (http://www.omnigroup.com)

The book was typed and edited entirely on my faithful Unicomp Model M keyboard

(http://pckeyboard.com), without which I could never have done so much writing over

so long a period so painlessly. For more about my physical work environment, see

http://matt.neuburg.usesthis.com.

From the Programming iOS 4 Preface

A programming framework has a kind of personality, an overall flavor that provides

an insight into the goals and mindset of those who created it. When I first encoun‐

tered Cocoa Touch, my assessment of its personality was: “Wow, the people who

wrote this are really clever!” On the one hand, the number of built-in interface

objects was severely and deliberately limited; on the other hand, the power and flexi‐

bility of some of those objects, especially such things as UITableView, was greatly

enhanced over their OS X counterparts. Even more important, Apple created a partic‐

ularly brilliant way (UIViewController) to help the programmer make entire blocks

of interface come and go and supplant one another in a controlled, hierarchical man‐

ner, thus allowing that tiny iPhone display to unfold virtually into multiple interface

worlds within a single app without the user becoming lost or confused.

The popularity of the iPhone, with its largely free or very inexpensive apps, and the

subsequent popularity of the iPad, have brought and will continue to bring into the

fold many new programmers who see programming for these devices as worthwhile

and doable, even though they may not have felt the same way about OS X. Apple’s

own annual WWDC developer conventions have reflected this trend, with their

emphasis shifted from OS X to iOS instruction.

xvi | Preface

The widespread eagerness to program iOS, however, though delightful on the one

hand, has also fostered a certain tendency to try to run without first learning to walk.

iOS gives the programmer mighty powers that can seem as limitless as imagination

itself, but it also has fundamentals. I often see questions online from programmers

who are evidently deep into the creation of some interesting app, but who are stymied

in a way that reveals quite clearly that they are unfamiliar with the basics of the very

world in which they are so happily cavorting.

It is this state of affairs that has motivated me to write this book, which is intended to

ground the reader in the fundamentals of iOS. I love Cocoa and have long wished to

write about it, but it is iOS and its popularity that has given me a proximate excuse to

do so. Here I have attempted to marshal and expound, in what I hope is a pedagogi‐

cally helpful and instructive yet ruthlessly Euclidean and logical order, the principles

and elements on which sound iOS programming rests. My hope, as with my previous

books, is that you will both read this book cover to cover (learning something new

often enough to keep you turning the pages) and keep it by you as a handy reference.

This book is not intended to disparage Apple’s own documentation and example

projects. They are wonderful resources and have become more wonderful as time

goes on. I have depended heavily on them in the preparation of this book. But I also

find that they don’t fulfill the same function as a reasoned, ordered presentation of

the facts. The online documentation must make assumptions as to how much you

already know; it can’t guarantee that you’ll approach it in a given order. And online

documentation is more suitable to reference than to instruction. A fully written

example, no matter how well commented, is difficult to follow; it demonstrates, but it

does not teach.

A book, on the other hand, has numbered chapters and sequential pages; I can

assume you know views before you know view controllers for the simple reason that

Part I precedes Part II. And along with facts, I also bring to the table a degree of expe‐

rience, which I try to communicate to you. Throughout this book you’ll find me

referring to “common beginner mistakes”; in most cases, these are mistakes that I

have made myself, in addition to seeing others make them. I try to tell you what the

pitfalls are because I assume that, in the course of things, you will otherwise fall into

them just as naturally as I did as I was learning. You’ll also see me construct many

examples piece by piece or extract and explain just one tiny portion of a larger app. It

is not a massive finished program that teaches programming, but an exposition of the

thought process that developed that program. It is this thought process, more than

anything else, that I hope you will gain from reading this book.

Conventions Used in This Book

The following typographical conventions are used in this book:

Preface | xvii

剩余619页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

掌握iOS 10开发基础：Swift 3与Xcode 8与Cocoa入门指南

IOS 11 Programming Fundamentals with Swift

iOS 12 Programming Fundamentals with Swift

iOS 9 Programming Fundamentals with Swift 无水印pdf 0分

iOS7Programming

Swift编程基础：iOS 8开发入门 (O'Reilly, 2015)

iOS 10编程基础：Swift 3教程（第3版）

iOS 11编程基础：Swift 4入门指南

Swift编程：iOS 10开发实战指南（第3版）

Swift 2015：iOS 9编程基础教程

Swift 2.0入门：iOS 9开发基石

最新资源