Swift 2.0入门：iOS 9开发基石

4星 · 超过85%的资源需积分: 10 19 浏览量更新于2024-07-21 2 收藏 5.29MB PDF 举报

"iOS 9 Programming Fundamentals with Swift(O'Reilly,2015)是一本由编程专家Matt Neuburg编写的指南，旨在引领读者进入iOS开发的世界，特别关注Swift 2.0这一革命性的编程语言。本书针对的是iOS 9系统、Xcode 7以及Swift的最新版本，为开发者提供了坚实的基础知识。书中首先介绍了Swift的关键概念，如变量和函数、作用域与命名空间、对象类型（枚举、结构体和类）以及实例化。作者深入浅出地讲解了Swift内置的各种数据类型，如数字、字符串、范围、元组、可选类型、数组、字典和集合。这些基础知识是构建高效iOS应用的基石。 Swift 2.0的革新内容也是本书的重点，包括选项集、协议扩展、错误处理、guard语句以及可用性检查等。通过学习这些新特性，开发者能够提升代码的可读性和健壮性。此外，书中还详细阐述了Xcode项目从创建到App Store发布的完整生命周期，包括如何使用nibs和界面构建工具Interface Builder设计用户界面。Cocoa框架的事件驱动模型及其设计模式和功能也得到了深入剖析，帮助读者理解如何与C和Objective-C API进行无缝交互。作者Matt Neuburg以其丰富的经验和深厚的专业背景，使本书成为iOS开发者的宝贵资源。他拥有古典学博士学位，曾在多家高校任教，并担任过MacTech杂志编辑和TidBITS贡献编辑，出版过多部关于Mac和iOS开发的权威指南，如《Programming iOS 8》、《REALbasic: The Definitive Guide》和《AppleScript: The Definitive Guide》。通过阅读这本书，读者不仅能掌握Swift语言的基础，还能了解iOS开发的工具链和核心机制，为后续深入开发iOS应用打下坚实的基础。对于那些想要进入iOS开发领域，或者希望提升Swift技能的开发者来说，这是一本不可多得的实用教程。"

Memory management

Swift manages memory automatically. You will rarely have to concern yourself with

memory management.

Cocoa compatibility

The Cocoa APIs are written in C and Objective-C. Swift is explicitly designed to

interface with most of the Cocoa APIs.

These features make Swift an excellent language for learning to program iOS.

The alternative, Objective-C, still exists, and you can use it if you like. Indeed, it is easy

to write an app that includes both Swift code and Objective-C code; and you may have

reason to do so. Objective-C, however, lacks the very advantages that Swift offers.

Objective-C agglomerates object-oriented features onto C. It is therefore only partially

object-oriented; it has both objects and scalar data types, and its objects have to be slotted

into one particular C data type (pointers). Its syntax can be difficult and tricky; reading

and writing nested method calls can make one’s eyes glaze over, and it invites hacky

habits such as implicit nil-testing. Its type checking can be and frequently is turned off,

resulting in programmer errors where a message is sent to the wrong type of object and

the program crashes. It uses manual memory management; the recent introduction of

ARC (automatic reference counting) has alleviated some of the programmer tedium

and has greatly reduced the likelihood of programmer error, but errors are still possible,

and memory management ultimately remains manual.

Recent revisions and additions to Objective-C — ARC, synthesis and autosynthesis,

improved literal array and dictionary syntax, blocks — have made it easier and more

convenient, but such patches have also made the language even larger and possibly even

more confusing. Because Objective-C must encompass C, there are limits to how far it

can be extended and revised. Swift, on the other hand, is a clean start. If you were to

dream of completely revising Objective-C to create a better Objective-C, Swift might be

what you would dream of. It puts a modern, rational front end between you and the

Cocoa Objective-C APIs.

Therefore, Swift is the programming language used throughout this book. Nevertheless,

the reader will also need some awareness of Objective-C (including C). The Foundation

and Cocoa APIs, the built-in commands with which your code must interact in order

to make anything happen on an iOS device, are still written in C and Objective-C. In

order to interact with them, you have to know what those languages would expect. For

example, in order to pass a Swift array where an NSArray is expected, you need to know

what consitutes an object acceptable as an element of an Objective-C NSArray.

Therefore, in this edition, although I do not attempt to teach Objective-C, I do describe

it in enough detail to allow you to read it when you encounter it in the documentation

and on the Internet, and I occasionally show some Objective-C code. Part III, on Cocoa,

is really all about learning to think the way Objective-C thinks — because the structure

and behavior of the Cocoa APIs are fundamentally based on Objective-C. And the book

xiv | Preface

ends with an appendix that details how Swift and Objective-C communicate with one

another

, as well as detailing how your app can be written partly in Swift and partly in

Objective-C.

The Scope of This Book

This book is actually one of a pair with my Programming iOS 9, which picks up exactly

where this book leaves off. They complement and supplement one another. The two-

book architecture should, I believe, render the size and scope of each book tractable for

readers. Together, they provide a complete grounding in the knowledge needed to begin

writing iOS apps; thus, when you do start writing iOS apps, you’ll have a solid and

rigorous understanding of what you are doing and where you are heading. If writing

an iOS program is like building a house of bricks, this book teaches you what a brick is

and how to handle it, while Programming iOS 9 hands you some actual bricks and tells

you how to assemble them.

When you have read this book, you’ll know about Swift, Xcode, and the underpinnings

of the Cocoa framework, and you will be ready to proceed directly to Programming iOS

9. Conversely, Programming iOS 9 assumes a knowledge of this book; it begins, like

Homer’s Iliad, in the middle of the story, with the reader jumping with all four feet into

views and view controllers, and with a knowledge of the language and the Xcode IDE

already presupposed. If you started reading Programming iOS 9 and wondered about

such unexplained matters as Swift language basics, the UIApplicationMain function,

the nib-loading mechanism, Cocoa patterns of delegation and notification, and retain

cycles, wonder no longer — I didn’t explain them there because I do explain them here.

The three parts of this book teach the underlying basis of all iOS programming:

• Part I introduces the Swift language, from the ground up — I do not assume that

you know any other programming languages. My way of teaching Swift is different

from other treatments, such as Apple’s; it is systematic and Euclidean, with peda‐

gogical building blocks piled on one another in what I regard as the most helpful

order. At the same time, I have tried to confine myself to the essentials. Swift is not

a big language, but it has some subtle and unusual corners. You don’t need to dive

deep into all of these, and my discussion will leave many of them unexplored. You

will probably never encounter them, and if you do, you will have entered an ad‐

vanced Swift world outside the scope of this discussion. To give an obvious example,

readers may be surprised to find that I never mention Swift playgrounds or the

REPL. My focus here is real-life iOS programming, and my explanation of Swift

therefore concentrates on those common, practical 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 ultima

tely 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 documentation

Preface | xv

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

the subsequen

t 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 postponed 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 un‐

derlying 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 framework

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 knowl‐

edge 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 9, of course!

Versions

This book is geared to Swift 2.0, iOS 9, and Xcode 7.

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 ver‐

sions 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).

The Swift language included with Xcode 7, Swift 2.0, has changed very significantly

from its immediate predecessor, Swift 1.2. If you were using Swift 1.2 previously, you’ll

almost certainly find that your code won’t compile with Swift 2.0 without some thorough

revision. Similarly, the code in this book, being written in Swift 2.0, is totally incom‐

patible with Swift 1.2. On the assumption that you might have some prior knowledge

of Swift 1.2, I call out, in the course of my discussion, most of the important language

features that are new or changed in Swift 2.0. But I do not describe or explain Swift 1.2

xvi | Preface

at all; if you need to know about it — though I can’t imagine why you would — consult

the previous edition of this book.

cknowledgments

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

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

Fauxsmith, and Adam Witwer come particularly to mind. And let’s not forget my first

and long-standing editor, Brian Jepson, who had nothing whatever to do with this ed‐

ition, but whose influence is present throughout.

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)

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

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

• GraphicConverter (http://www.lemkesoft.com)

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

The book was typed and edited en

tirely 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 encountered

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 flexibility of some of those

objects, especially such things as UITableView, was greatly enhanced over their OS X

counterparts. Even more important, Apple created a particularly brilliant way (UIView‐

Controller) to help the programmer make entire blocks of interface come and go and

supplant one another in a controlled, hierarchical manner, thus allowing that tiny

Preface | xvii

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 ver

y 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.

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 pedagogically

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 experience,

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

xviii | Preface

www.allitebooks.com

剩余603页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

Swift 2.0入门：iOS 9开发基石

IOS 11 Programming Fundamentals with Swift

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

iOS 12 Programming Fundamentals with Swift

iOS7Programming

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

Swift 2015：iOS 9编程基础教程

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

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

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

掌握Swift开发iOS 9应用基础：Neuburg深度解析

最新资源