Swift2.0与iOS9编程基础

需积分: 9 71 浏览量更新于2024-07-21 收藏 5.95MB PDF 举报

"iOS9 Programming fundamentals with swift - 一本关于Swift、Xcode和Cocoa基础知识的书籍，涵盖了iOS9、Xcode7和Swift2.0，适合初学者掌握iOS开发的基础知识。作者Matt Neuburg是知名的编程书籍作者，拥有丰富的教学和编程经验。" 在深入探讨iOS应用开发之前，理解其基础至关重要，而《iOS9 Programming Fundamentals with Swift》正是一本专为此目的编写的指南。这本书详细介绍了Swift2.0，这是苹果公司备受赞誉的编程语言的最新版本，同时也覆盖了Xcode7集成开发环境（IDE）和CocoaTouch框架的基础知识。对于想要进入iOS开发领域的学习者来说，这是一个理想的学习起点。 Swift是一种强大的、安全的编程语言，它旨在简化Objective-C的复杂性，同时提供更现代的编程范式。在本书中，你将学习到Swift的关键特性，如类型系统、模式匹配、可选值、泛型以及函数式编程概念。Swift的这些特性使得代码更清晰，更易于理解和维护，从而降低了出错的可能性。 Xcode是iOS和macOS开发的主要工具，它包含了一系列强大的工具，如代码编辑器、界面构建器、调试器和性能分析器。通过本书，读者将学会如何有效地使用Xcode进行项目设置、编写代码、构建用户界面以及调试应用程序。理解Xcode的工作流程对于高效开发至关重要。 CocoaTouch是iOS应用开发的核心框架，它提供了构建用户界面和实现应用功能所需的类和API。书中会讲解如何使用UIKit来设计响应式的交互界面，以及如何利用Core Data进行数据存储，使用GameKit进行游戏开发，或者运用Multipeer Connectivity进行设备间通信。此外，本书还涵盖了测试驱动开发（TDD）和持续集成（CI）的概念，这些现代开发实践有助于提高代码质量并确保应用的稳定性。作者还将分享如何使用Apple的Auto Layout来创建适应各种屏幕尺寸和方向的动态用户界面。《iOS9 Programming Fundamentals with Swift》是一本全面且深入的教程，无论你是编程新手还是希望更新Swift知识的开发者，都能从中受益。通过阅读本书，你将能够建立起坚实的基础，为构建创新和高质量的iOS应用做好准备。

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

www.it-ebooks.info

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

www.it-ebooks.info

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

www.it-ebooks.info

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

www.it-ebooks.info

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.it-ebooks.info

剩余603页未读，继续阅读

68040277

粉丝: 24
资源: 50

Swift2.0与iOS9编程基础

IOS 11 Programming Fundamentals with Swift

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

iOS 9 Programming Fundamentals with Swift (非epub转pdf)

学习ios有哪些好的书籍

【数字逻辑fundamentals of digital logic with verilog design | 3rd editio

编写函数实现对字符串Fundamentals and applications of python programming加密和解密，循环使用密钥A basic professional course，并采用简单的异或算法。使用python编写

Fundamentals of Physics. Extended

Microsoft Certified： Fundamentals

digital fundamentals10 pdf

数字逻辑fundamentals of digital logic with verilog design | 3rd edition solu

最新资源