使用Swift打造iOS 8应用基础教程

需积分: 10 108 浏览量更新于2024-07-21 1 收藏 6.53MB PDF 举报

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

30元优惠券

资源详情

资源推荐

www.allitebooks.com

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

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

xiv | Preface

www.allitebooks.com

Versions

This book is geared to Swift 1.2, iOS 8.3, and Xcode 6.3, which were in early beta at the

time the book was completed. 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 com‐

pendiously available in my earlier books. The book does contain, nevertheless, a few

words of advice about backward compatibility (especially in Chapter 9).

Xcode 6 has eliminated some of the templates that you choose from when creating a

new project. The loss of the Utility Application template is a pity, because it embodied

and illustrated the standard patterns of protocol and delegate; but that’s no problem,

because I can illustrate them for you (Chapter 11). The loss of the Empty Application

template is severe; it is, after all, perfectly reasonable to write an app without a storyboard

(several of my own apps are structured in that way). Accordingly, in Chapter 6, I give

instructions for turning a Single View Application–based template into something sim‐

ilar to what the Empty Application template would have given you. Also, the Xcode 6

templates are based primarily on storyboards; although I treat storyboards as the pri‐

mary Interface Builder design milieu, I still demonstrate how to make and work with

a .xib file.

At the time of this writing, Apple was still making frequent adjustments to the Swift

language and to the way the Objective-C APIs are bridged to it, and Swift 1.2, which I

have documented in this book, was still in beta. I have tried to keep my code up-to-date,

but please make allowances, and be prepared to compensate for the possibility that my

examples may contain slight occasional impedance mismatches.

Acknowledgments

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.

Some details of the presentation of the Swift language came from suggestions by Andrew

Duncan, whose book on Objective-C is a classic in its own right.

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)

Preface | xv

• 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 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 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

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.

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

xvi | Preface

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

program that teaches programming, but an exposition of the thought process that de‐

veloped 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:

Italic

Indicates new terms, URLs, email addresses, filenames, and file extensions.

Constant width

Used for program listings, as well as within paragraphs to refer to program elements

such as variable or function names, databases, data types, environment variables,

statements, and keywords.

Constant width bold

Shows commands or other text that should be typed literally by the user.

Constant width italic

Shows text that should be replaced with user-supplied values or by values deter‐

mined by context.

Preface | xvii

剩余581页未读，继续阅读

泗哥

粉丝: 17
资源: 26

使用Swift打造iOS 8应用基础教程

IOS 11 Programming Fundamentals with Swift

iOS 11 Programming Fundamentals with Swift Swift, Xcode, and Cocoa Basics azw3

iOS 12 Programming Fundamentals with Swift (mobi)

iOS 8 Programming Fundamentals with Swift

iOS 12 Programming Fundamentals with Swift

iOS 10 Programming Fundamentals with Swift epub

iOS 12 Programming Fundamentals with Swift Swift, Xcode, and Cocoa Basics

iOS 13 Programming Fundamentals with Swift.zip

iOS 12 Programming Fundamentals with Swift (epub)

iOS 10 Programming Fundamentals with Swift pdf 0分

iOS 11 Programming Fundamentals with Swift Swift, Xcode, and Cocoa Basics 无水印pdf

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

numexpr-2.8.3-cp38-cp38-win_amd64.whl

ujson-5.3.0-cp311-cp311-win_amd64.whl

基于MATLAB车牌识别程序技术实现面板GUI.zip

RJFireWall-maste赛资源

最新资源