Swift基础教程：iOS9编程入门

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

"iOS 9 Programming Fundamentals with Swift 是一本由Matt Neuburg编写的书籍，专注于介绍使用Swift语言进行iOS应用开发的基础知识。这本书与作者的另一本著作《Programming iOS 9》相辅相成，后者从更深入的角度探讨iOS编程。这本书适合对iOS编程有一定了解或有Objective-C背景的读者，而对于初学者来说可能稍显复杂。书中涵盖了Swift语言、Xcode集成开发环境以及Cocoa框架的基础知识，为读者提供了扎实的iOS应用开发基础。全书分为三个部分： 1. **语言**：这部分介绍了Swift的基本架构，包括函数、变量、简单类型、对象类型以及流程控制等核心概念。 - 第1章详细讲解了Swift语言的整体架构，帮助读者理解其设计原则和特性。 - 第2章到第5章分别阐述了函数的使用、变量和基本类型、面向对象编程以及控制流程语句。 2. **IDE**：这部分主要涉及Xcode项目管理和开发工具的使用。 - 第6章剖析了Xcode项目的结构，解释了如何创建和管理项目。 - 第7章讨论了Xcode中的Nib文件管理，包括用户界面的构建和加载机制。 - 第8章介绍了Xcode的文档系统，帮助开发者高效查找和学习API。 - 第9章讲述了项目生命周期，涵盖了从开发到发布的过程。 3. **Cocoa**：这部分深入讲解了Cocoa框架及其在iOS开发中的作用。 - 第10章介绍了Cocoa类，包括Foundation和UIKit框架的关键组件。 - 第11章涵盖了Cocoa事件处理，如用户交互和响应链。 - 第12章讲解了内存管理，重点是iOS中的自动引用计数（ARC）。 - 第13章讨论了对象间通信，如委托和通知机制。 - 附录A对比了C、Objective-C和Swift，帮助读者理解它们之间的联系和差异。通过阅读本书，读者将能够掌握Swift、Xcode和Cocoa的基本知识，并为过渡到《Programming iOS 9》做好准备。对于那些在阅读《Programming iOS 9》时遇到未解释的概念，如Swift语言基础、UIApplicationMain函数、nib加载机制、Cocoa的委托和通知模式，以及内存管理中的循环引用问题，本书将提供详尽的解答。"

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

剩余603页未读，继续阅读

clyz465

粉丝: 0
资源: 4

Swift基础教程：iOS9编程入门

Beginning iOS 14 Programming with Swift.pdf

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

(iOS14)2021Beginning iOS Programming with Swift

iOS 12 Programming Fundamentals with Swift (epub)

iOS 10 Programming Fundamentals with Swift epub

iOS 12 Programming Fundamentals with Swift(pdf + epub + azw3)

iOS 13 Programming Fundamentals with Swift.zip

iOS 12 Programming Fundamentals with Swift (mobi)

iOS 13 Programming Fundamentals 最新2020.epub

( iOS.9.Programming.Fundamentals.with.Swift ) epub,pdf,mobi

最新资源