През 2008 г. Apple обяви и пусна iPhone SDK 2.0. Това събитие започна нова революция в разработката на софтуер и по този начин се роди ново поколение разработчици, които сега са признати за разработчици на iOS .
Много от тези разработчици никога преди не са използвали Objective-C и това беше първото предизвикателство, което Apple имаше за тях. Въпреки неизвестен синтаксис и ръчно управление на паметта, той беше изключително успешен, като помогна за попълването на App Store с десетки хиляди приложения. Apple непрекъснато подобряваше Objective-C с всяка нова версия, добавяйки блокове и литерали ( литерали ), добавяне на опростено боравене с памет с автоматично преброяване на референции и много други функции, които показват съвременен език за програмиране.
И след шест години работа и подобряване на Objective-C, Apple реши отново да предизвика предизвикателства пред разработчиците. Отново разработчиците на iOS ще трябва да научат нов език за програмиране: Бързо . Swift премахва несигурното управление на показалеца и въвежда нови и безсилни функции, като същевременно поддържа взаимодействие както с Objective-C, така и с C.
Swift 1.0 е стабилна и силна платформа за разработка, която със сигурност ще се развива по интересни начини през следващите години. Това е идеалният момент да започнете да изследвате този нов език, тъй като очевидно това е бъдещето на разработката на iOS.
Целта на този урок е да даде към разработчиците на Objective-C бърз преглед на новите функции на езика Swift, който ви помага да направите следващата стъпка и да започнете да прегръщате Swift във вашата ежедневна работа. Няма да отделям много време за обяснение на Objective-C, ще предположа, че сте запознати с разработката на iOS.
Probando Swift срещу Objective-C
За да започнете да изследвате Swift това, от което се нуждаете, е изтеглете XCode 6 от App Store и създайте зона за игра, с която да експериментирате. Всички примери, споменати в тази статия, са направени по този начин.
Уебсайт на Apple Swift е най-добрата справка за изучаване на Swift програмиране. Ще видите, че е много ценно, и докато не сте напълно в крак с развитието на Swift Мисля, че ще се връщате често тук.
Променливи и константи
За да декларирате променлива в Swift, използвайте ключовата дума var.
var x = 1 var s = 'Hello' Ще забележите, че двете променливи s и x те са от различен тип. x е цяло число, докато 's' е низ от символи. Swift е безопасен тип език и ще изведе типове променливи от присвоената стойност. Ако искате вашият код да бъде по-четлив, можете по желание да коментирате типа променлива:
var y: Int y = 2 Константите са подобни, но се декларират с помощта на let вместо var. Не е необходимо да знаете стойността на константа по време на компилация, но трябва да й присвоите стойност точно веднъж.
let c1 = 1 // Constante conocida al momento de la compilación var v = arc4random() let c2 = v // Constante conocida solo en momento de ejecución Както подсказва името, те са неизменни, така че следният код ще причини грешка по време на компилиране.
let c = 1 c = 3 // error Други видове също могат да бъдат декларирани като константи. Например следният код декларира масив като константа и ако се опитате да модифицирате някой от елементите, компилаторът Swift ще докладва за грешка:
var arr2 = [4, 5, 6] arr2[0] = 8 print (arr2) // [8, 5, 6] let arr = [1, 2, 3] a[0] = 5 // error По желание
Константите трябва да бъдат инициализирани, когато са декларирани, точно както променливите трябва да бъдат инициализирани преди да ги използват. И така, къде е еквивалентът nil на Objective-C? Суифт въвежда незадължителни стойности . Незадължителните стойности могат да имат стойност или да бъдат nil. Ако погледнете следния код, ще забележите, че x е присвоена като стойност Opcional от 2014. Това означава, че компилаторът Swift е знаел, че x може да бъде nil.
var s = '2014' var x = s.toInt() print(x) // Optional(2014) Ако направите промяна в този код и присвоите стойността 'abc' до s, което не може да бъде преобразувано в цяло число, ще забележите, че x вече е nil.
var s = 'abc' var x = s.toInt() print(x) // nil Типът на връщане на toInt() е Int?, което е a Незадължително int . Нека се опитаме да извикаме стандартна функция на x:
var x = '2014'.toInt() print(x.successor()) // error Компилаторът съобщава за грешка, тъй като x е по избор и потенциално може да бъде нула . Трябва да опитаме x първо и се уверете, че sucessor се извиква на реално число, а не на стойност nil
var x = '2014'.toInt() if x != nil { print(x!.successor()) // 2015 } Имайте предвид, че трябва да разгънем x добавяне на удивителен знак (!) . Когато се уверим, че x съдържа стойност, имаме достъп до нея. В противен случай ще получим грешка при изпълнението. Ние също можем да правим това, което Swift призовава по избор подвързване , като по този начин преобразува незадължителната в незадължителна променлива
Разработка на приложения за iOS за визуално студио
let x = '123'.toInt() if let y = x { print(y) } Кодът за if ще работи само ако x има стойност и се присвоява на y. Имайте предвид, че не е необходимо да разгъваме y, неговият незадължителен тип, тъй като знаем, че x не е nil.
Вижте урока на Apple за Swift, където можете да прочетете подробно за незадължителни и интересни функции като по избор верига
Струнна интерполация
В Objective-C низът за форматиране обикновено се извършва с метода stringWithFormat:
NSString *user = @'Gabriel'; int days = 3; NSString *s = [NSString stringWithFormat:@'posted by %@ (%d days ago)', user, days]; Суифт има функция, наречена Струнна интерполация който прави същото, но е по-компактен и по-лесен за четене:
let user = 'Gabriel' let days = 3 let s = 'posted by (user) (days) ago' Можете също да използвате изрази:
let width = 2 let height = 3 let s = 'Area for square with sides (width) and (height) is (width*height)' За да научите повече за бързата интерполация на низове, отидете на тук .
Характеристика
Дефиницията на функция в Swift е различна от тази на C. Примерна дефиниция на функция е следната:
func someFunction(s:String, i: Int) -> Bool { ... // code } Суифт функциите са първокласни типове . Това означава, че можете да присвоявате функции на променливи, да ги предавате като параметри на функции или да ги накарате да връщат типове:
func stringLength(s:String) -> Int { return countElements(s) } func stringValue(s:String) -> Int { if let x = s.toInt() { return x } return 0 } func doSomething(f:String -> Int, s:String) -> Int { return f(s).successor() } let f1 = stringLength let f2 = stringValue doSomething(f1, '123') // 4 doSomething(f2, '123') // 124 Отново Суифт извежда типовете f1 и f2 (String -> Int), въпреки че бихме могли да ги дефинираме изрично:
let f1:String -> Int = stringLength Функциите могат да върнат и други функции:
func compareGreaterThan(a: Int, b: Int) -> Bool { return a > b } func compareLessThan(a: Int, b: Int) -> Bool { return a (Int, Int) -> Bool { if greaterThan { return compareGreaterThan } else { return compareLessThan } } let f = comparator(true) println(f(5, 9)) Намира се ръководство за функции в Swift тук .
Изброявания
Enums в Swift са много по-мощни, отколкото в Objective-C. Тъй като Swift го структурира, те могат да имат методи и се предават като стойности:
enum MobileDevice : String { case iPhone = 'iPhone', Android = 'Android', WP8 = 'Windows Phone8', BB = 'BlackBerry' func name() -> String { return self.toRaw() } } let m = MobileDevice.Android print(m.name()) // 'Android' За разлика от Objective-C, Swift изброяванията могат да присвояват низове, символи или плувки като стойности за всеки член, различни от цели числа. Удобният метод toRaw() връща стойността, присвоена на всеки член.
Изброяванията също могат да бъдат параметризирани:
enum Location { case Address(street:String, city:String) case LatLon(lat:Float, lon:Float) func description() -> String { switch self { case let .Address(street, city): return street + ', ' + city case let .LatLon(lat, lon): return '((lat), (lon))' } } } let loc1 = Location.Address(street: '2070 Fell St', city: 'San Francisco') let loc2 = Location.LatLon(lat: 23.117, lon: 45.899) print(loc1.description()) // '2070 Fell St, San Francisco' print(loc2.description()) // '(23.117, 45.988)' Можете да намерите повече информация за изброяванията тук .
Туплас
Tuples групират множество стойности в една съставна стойност. Стойностите в един кортеж могат да бъдат от всякакъв тип и не е задължително да бъдат от един и същи тип.
let person = ('Gabriel', 'Kirkpatrick') print(person.0) // Gabriel Можете също така да назовете отделни елементи на кортежа:
let person = (first: 'Gabriel', last: 'Kirkpatrick') print(person.first) Кортежите са изключително удобни като типове на връщане за функции, които трябва да върнат повече от една стойност:
func intDivision(a: Int, b: Int) -> (quotient: Int, remainder: Int) { return (a/b, a%b) } print(intDivision(11, 3)) // (3, 2) let result = intDivision(15, 4) print(result.remainder) // 3 За разлика от Objective-C, Swift поддържа намиране на модели в случай на случай или превключване на случай:
let complex = (2.0, 1.1) // real and imaginary parts switch complex { case (0, 0): println('Number is zero') case (_, 0): println('Number is real') default: println('Number is imaginary') } Във втория случай не ни интересува истинската част на числото, затова използваме _ така че да може да съвпада с всичко. Можете също така да проверите дали има допълнителни условия за всеки отделен случай. За това трябва да се присъедините към стойностите на шаблона:
let complex = (2.0, 1.1) switch complex { case (0, 0): println('Number is zero') case (let a, 0) where a > 0: println('Number is real and positive') case (let a, 0) where a <0: println('Number is real and negative') case (0, let b) where b != 0: println('Number has only imaginary part') case let (a, b): println('Number is imaginary with distance (a*a + b*b)') } Обърнете внимание как трябва да съпоставим само стойностите, които ще използваме в сравнението или в превключвател .
c corporation vs s corporation vs llc
Можете да прочетете повече за Tuples тук .
Класове и структури
За разлика от Objective-C, Swift не изисква от вас да създавате отделен интерфейс и документи за изпълнение за персонализирани класове и структури. Докато научавате за Swift, ще се научите да дефинирате клас или структура в един документ и външният интерфейс за този клас или структура автоматично се предоставя за използване от друг код.
Определете класове
Определенията на класовете са много прости:
class Bottle { var volume: Int = 1000 func description() -> String { return 'This bottle has (volume) ml' } } let b = Bottle() print(b.description()) Както виждаш, декларацията и изпълнението са в един и същ документ . Swift вече не използва заглавка или документи за внедряване. Нека добавим таг към нашия пример:
class Bottle { var volume: Int = 1000 var label:String func description() -> String { return 'This bottle of (label) has (volume) ml' } } Компилаторът ще се оплаче, тъй като етикетът е незадължителна променлива и няма да съдържа стойност, когато е създадена инстанция на бутилка. Трябва да добавим инициализатор:
class Bottle { var volume: Int = 1000 var label:String init(label:String) { self.label = label } func description() -> String { return 'This bottle of (label) has (volume) ml' } } Или можем да използваме type Opcional за свойство, което не е необходимо да се инициализира. В следващия пример преобразуваме в volumen a Número entero Opcional:
class Bottle { var volume: Int? var label:String init(label:String) { self.label = label } func description() -> String { if self.volume != nil { return 'This bottle of (label) has (volume!) ml' } else { return 'A bootle of (label)' } } } Структури
Езикът Swift също има structs, но те са много по-гъвкави, отколкото в Objective-C. Следният урок на кода дефинира a struct:
struct Seat { var row: Int var letter:String init (row: Int, letter:String) { self.row = row self.letter = letter } func description() -> String { return '(row)-(letter)' } } Подобно на класовете в Swift, структурите могат да имат методи, свойства, инициализатори и да съответстват на протоколи. Основната разлика между класовете и структурите е тази класовете се предават по препратка, докато структурите се предават по стойност .
Този пример демонстрира предаване на класовете чрез препратка:
let b = Bottle() print(b.description()) // 'b' bottle has 1000 ml var b2 = b b.volume = 750 print(b2.description()) // 'b' and 'b2' bottles have 750 ml Ако се опитаме да направим нещо подобно с struct, ще забележите, че променливите се предават със стойности:
настройка на производителността в sql server 2012 стъпка по стъпка
var s1 = Seat(row: 14, letter:'A') var s2 = s1 s1.letter = 'B' print(s1.description()) // 14-B print(s2.description()) // 14-A Кога трябва да използваме struct и кога използваме class? Както в Objective-C и C, използвайте структури, когато трябва да групирате някои стойности и очаквате те да бъдат копирани, а не референтни или RGB цветове.
Екземплярът на клас е традиционно известен като обект. Класовете и структурите на Swift обаче са много по-близки по функционалност, отколкото на други езици, и много функционалности могат да бъдат приложени към екземпляри от структурна структура или клас. Поради тази причина най-общият термин, използван по отношение на Swift, е instancia, който се отнася за всеки от тези два.
Научете основите на Swift класове и структури тук .
Имоти
Както видяхме по-рано, свойствата в Swift се декларират с ключовата дума var в рамките на определението за клас или структура. Също така можем да декларираме с инструкцията let
struct FixedPointNumber { var digits: Int let decimals: Int } var n = FixedPointNumber(digits: 12345, decimals: 2) n.digits = 4567 // ok n.decimals = 3 // error, decimals is a constant Също така имайте предвид, че свойствата на класа са силно препратени, освен ако не използвате префикса weak като ключова дума. Въпреки това, има някои сладости с незадължителни свойства на слаб, така че прочетете Глава Автоматично референтно счетоводство в Swift Guide на Apple ..
Изчислени свойства
Изчислените свойства не съхраняват стойност. По-скоро те предоставят getter и незадължителен setter за извличане и задаване на други свойства и стойности индиректно.
Следният код предоставя пример за изчислена стойност sign:
enum Sign { case Positive case Negative } struct SomeNumber { var number:Int var sign:Sign { get { if number <0 { return Sign.Negative } else { return Sign.Positive } } set (newSign) { if (newSign == Sign.Negative) { self.number = -abs(self.number) } else { self.number = abs(self.number) } } } } Можем също така да дефинираме свойства само за четене само чрез внедряване на гетер:
struct SomeNumber { var number:Int var isEven:Bool { get { return number % 2 == 0 } } } В Objective-C свойствата обикновено са подкрепени от променлива на екземпляр, изрично декларирана или автоматично създадена от компилатора. От друга страна, в Суифт, свойство няма съответна променлива на екземпляра . Тоест, до хранилището за обект на собственост не може да се осъществи пряк достъп. Да предположим, че имаме това в Objective-C:
// .h @interface OnlyInitialString : NSObject @property(strong) NSString *string; @end // .m @implementation OnlyInitialString - (void)setString:(NSString *newString) { if (newString.length > 0) { _string = [newString substringToIndex:1]; } else { _string = @''; } } @end Тъй като в Swift изчислените свойства нямат резервно хранилище, имаме нужда от нещо подобно:
class OnlyInitialString { var initial:String = '' var string:String { set (newString) { if countElements(newString) > 0 { self.initial = newString.substringToIndex(advance(newString.startIndex, 1)) } else { self.initial = '' } } get { return self.initial } } } Свойствата са обяснени по-подробно тук
Следва продължение
Има много по-важни и нови неща, които да научите в Swift като общо програмиране, взаимодействие с библиотеки Objective-C, затваряне, по избор верига и претоварване на оператора. Един урок не може напълно да опише нов език, но не се съмнявам, че ще бъде написано много повече за програмирането на Swift. Мисля обаче това Бързо четене ще помогне на много разработчици на Objective-C, които не са намерили време, нито са научили подробности за езика Swift, да тръгнат и да позволят на птицата Swift да ви отведе до нови висоти.
