您的位置：首页 > 移动开发 > Swift

Swift学习笔记-1

2014-06-03 18:00 260 查看

Apple官方开发手册地址：
https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html
语法概览

1 Simple Values

常量定义：let

变量定义：var

常量或变量类型和初始值一致：
var myVariable = 42
myVariable = 50
let myConstant = 42

也可以显式的指定类型：
let explicitDouble:Double = 70

类型转换，比如String()：

let label = "The width is "
let width = 94
let widthLabel = label + String(width)

打印常量/变量值使用 \()

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

创建数组或字典，使用[ ]：

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

初始化一个空的数组或字典：

let emptyArray = String[]()
let emptyDictionary = Dictionary<String, Float>()

2 Control Flow

条件判断 if / switch

循环控制 for-in for while do-while

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
teamScore

switch case

let vegetable = "red pepper"
switch vegetable {
case "celery":
let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
let vegetableComment = "Is it a spicy \(x)?"
default:
let vegetableComment = "Everything tastes good in soup."
}

for-in

let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
largest

while/do-while

var m = 2
do {
m = m * 2
} while m < 100
m

for

传统格式：
var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop

新的格式：
var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop

3 Functions and Closures

函数名(参数1，参数2)->返回类型
func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")

返回多个参数：

func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79)
}
getGasPrices()

可变参数：

func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42, 597, 12)

函数嵌套：

func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()

返回嵌套函数返回值：

func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)<pre name="code" class="objc">    class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}

用另一个函数作参数：

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)

{}和$的使用

numbers.map({ number in 3 * number })

sort([1, 5, 3, 12, 2]) { $0 > $1 }

4 Objects and Classes

类实现.构造和析构函数 init

/deinit

class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
<code class="code-voice">deinit</code>(){}

func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}

类使用:

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

类的继承和函数重载：

<pre name="code" class="objc">class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
子类中初始化需要执行：
1）设置子类属性值
2）父类初始化
3）设置父类属性值
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}

 var perimeter: Double {
get {
return 3.0 * sideLength
}
set {
sideLength = newValue / 3.0
}
}

override func simpleDescription() -> String {
return "An equilateral triagle with sides of length \(sideLength)."
}
}

预设置 willSet和 didSet

willSet {
square.sideLength = newValue.sideLength
}

When working with optional values, you can write

before operations like methods, properties, and subscripting. If the value before the

nil

, everything after the

is ignored and the value of the whole expression is

nil

. Otherwise, the optional value is unwrapped, and everything after the

acts on the unwrapped value. In both cases, the value of the whole expression is an optional value.

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

5 Enumerations and Structures

enum的定义和使用

enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func simpleDescription() -> String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
case .King:
return "king"
default:
return String(self.toRaw())
}
}
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()

enum值和raw值的转换（toRaw和fromRaw）

if let convertedRank = Rank.fromRaw(3) {
let threeDescription = convertedRank.simpleDescription()
}

struct

和class的区别：

struct使用的时候是拷贝，class使用的时候是引用。

6 Protocols and Extensions

声明一个protocol

protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}

协议使用：

   class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
structSimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b =
4000
SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

Notice the use of the

mutating

keyword in the declaration of

SimpleStructure

to mark a method that modifies the structure.

Use

extension

to add functionality to an existing type

extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
simpleDescription

7 Generics

参数类型待定：

func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
var result = ItemType[]()
for i in 0..times {
result += item
}
return result
}
repeat("knock", 4)

使用

where

带参数列表：

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
return true
}
}
}
return false
}
anyCommonElements([1, 2, 3], [3])

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航