1.Swift 是一种新的编程语言,用于编写 iOS,OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制,Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架
2.
- 简单值(Simple Values)
- 控制流(Control Flow)
- 函数和闭包(Functions and Closures)
- 对象和类(Objects and Classes)
- 枚举和结构体(Enumerations and Structures)
- 协议和扩展(Protocols and Extensions)
- 泛型(Generics)
3.print("Hello, world!")
4.
简单值:使用
let
来声明常量,使用var
来声明变量。let声明的常量只能赋值一侧 而var可以多出赋值
例如:
var myVariable =42 myVariable =50let myConstant =42
常量或变量的类型必须和所赋值的类型一样,可以不用明确的声明类型,因为赋值时编译器会自动推断类型,在上面的例子中,编译器推断出
myVariable
是一个整数(integer)因为它的初始值是整数。
如果没有初始值或没有足够的信息定义它的类型,那么可以再变量后面声明类型用冒号分开。
例:
let implicitInteger =70let implicitDouble = 70.0 let explicitDouble: Double =70
显示转化和隐式转化: 系统可以自己识别转换的类型为隐式转化,而需要认为的指定类型转换的为显示转化,否则系统自身无法处理类型转换。
把常量或变量转转换为字符串,再常量前加一个反斜杠
let apples =3let oranges =5let appleSummary ="I have\(apples) apples."let fruitSummary ="I have\(apples + oranges) pieces of fruit."
使用方括号
[]
来创建数组和字典,并使用下标或者键(key)来访问元素。最后一个元素后面允许有个逗号。
varshoppingList = ["test1","test2","test3","test4 "]
shoppingList[1] ="test5"
print(shoppingList)
var occupations = [
"OM1" : "OM1",
"OM0" : "OM1"
]
occupations["OM2"] ="test3"
shoppingList[1] ="test5"
print(shoppingList)
var occupations = [
"OM1" : "OM1",
"OM0" : "OM1"
]
occupations["OM2"] ="test3"
print(occupations)
输出["test1", "test5", "test3", "test4 "]
["OM1": "OM1", "OM0": "OM1", "OM2": "test3"]
当key存在时直接替换掉key对应的值,若key不存在则添加一直新的key值
创建空数组字典
letemptyArray = [String]()
letemptyDic = [String:Float]()
print(emptyArray)
print(emptyDic)
如果类型已确定 :可直接这样声明
shoppingList = [] occupations = [:]
控制流
使用
if
和switch
来进行条件操作,使用for-in
、for
、while
和repeat-while
来进行循环。包裹条件和循环变量括号可以省略,但是语句体的大括号是必须的。
letsoureArray = ["OM1","OM2","OM3","OM4","OM5"]
for soure in soureArray {
if soure == "OM2" {
print(soure)
}
}
let soureArray2 = [10,11,12,13,14,15]
var jiSuan = 0
for value in soureArray2 {
if value > 12 {
jiSuan += value
print(jiSuan)
}
for soure in soureArray {
if soure == "OM2" {
print(soure)
}
}
let soureArray2 = [10,11,12,13,14,15]
var jiSuan = 0
for value in soureArray2 {
if value > 12 {
jiSuan += value
print(jiSuan)
}
}
在
if
语句中,条件必须是一个布尔表达式——这意味着像if score { ... }
这样的代码将报错,而不会隐形地与 0 做对比。 例如 ifvalue >12, 处理数值缺失使用if
和let 。在类型后面加一个问号来标记这个变量的值是可选的 ,此时值可以为NIL
letoptainString:String? ="Hello"
print(optainString ==nil)
let optainName :String? ="John"
var getting = "Hello!"
if let name = optainName {
getting = "Hello \(name)"
print(getting)
print(optainString ==nil)
let optainName :String? ="John"
var getting = "Hello!"
if let name = optainName {
getting = "Hello \(name)"
print(getting)
}
如果变量的可选值是
nil
,条件会判断为false
,大括号中的代码会被跳过。如果不是nil
,会将值赋给let
后面的常量,这样代码块中就可以使用这个值了。
switch
支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。
例
letvegetable ="perper.OM2"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "OM1", "OM2":
print("That would make a good tea sandwich.")
case let x where x.hasPrefix("perper"):
print("Is it a spicy\(x)")
default:
print("Everything tastes good in soup.")
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "OM1", "OM2":
print("That would make a good tea sandwich.")
case let x where x.hasPrefix("perper"):
print("Is it a spicy\(x)")
default:
print("Everything tastes good in soup.")
}
switch 可以是if判断 可以加 或(多个值)
遍历字典可以使用for in
letnumbers = [
"OM1":[2,3,4, 5, 6],
"OM2":[7,8,9],
"OM3":[10,11,12,13],
]
var largest = 0
for (kind, number) in numbers {
for soures in number {
if soures > largest {
largest = soures;
print(kind)
print(largest)
}
}
"OM1":[2,3,4, 5, 6],
"OM2":[7,8,9],
"OM3":[10,11,12,13],
]
var largest = 0
for (kind, number) in numbers {
for soures in number {
if soures > largest {
largest = soures;
print(kind)
print(largest)
}
}
}
kind 为遍历的key值 number 为value 集
使用
if
和switch
来进行条件操作,使用for-in
、for
、while
和repeat-while
来进行循环
varn =2
while n < 100 {
n = n * 2
}
print(n)
var m = 2
repeat {
m = m * 2
} while m < 100
while n < 100 {
n = n * 2
}
print(n)
var m = 2
repeat {
m = m * 2
} while m < 100
print(m)
for 循环有两种方式
varfirstForLoop =0
for i in 0..<4{
firstForLoop += i
}
print(firstForLoop)
var secondForLoop = 0
for var i = 0; i < 4; ++i {
secondForLoop += i
}
for i in 0..<4{
firstForLoop += i
}
print(firstForLoop)
var secondForLoop = 0
for var i = 0; i < 4; ++i {
secondForLoop += i
}
print(secondForLoop)
0..<4 i<4 效果一致 使用
..<
创建的范围不包含上界,如果想包含的话需要使用...
。
// 闭包 函数
使用func
来声明一个函数,使用名字和参数来调用函数。使用->
来指定函数返回值的类型。
func greet(name: String, foot:String) ->String{
return "hello \(name), today eat\(foot)."
}
greet("xiaoMing", foot:"salad")
return "hello \(name), today eat\(foot)."
}
greet("xiaoMing", foot:"salad")
print(greet("xiaoMing", foot:"salad"))
1. 使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示
funccalculates(scores: [Int]) -> (min:Int, max:Int, sum:Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculates([5,3,100,3 ,9])
print(statistics.sum)
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculates([5,3,100,3 ,9])
print(statistics.sum)
print(statistics.1)
2.函数可以带有可变个数的参数,这些参数在函数内表现为数组的形式
funcsumOf(numbers:Int...) ->Int {
varsum =0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42,579,12)
print(sumOf(42,579,12))
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42,579,12)
print(sumOf(42,579,12))
使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。
func calculates(scores: [Int]) -> (min:Int, max:Int, sum:Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculates([5,3,100,3 ,9])
print(statistics.sum)
print(statistics.1)
函数可以带有可变个数的参数,这些参数在函数内表现为数组的形式:
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)
函数也可以当做参数传入另一个函数。
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, condition: lessThanTen)
var arr = [1,2,3,4,5]
func famp(a : Int) ->Int{
return a + 10
}
var arr2 = arr.map(famp)
print(arr2)
func famp(a : Int) ->Int{
return a + 10
}
var arr2 = arr.map(famp)
print(arr2)
print(arr2 = (arr2))
letmappedNumbers = numberss.map({numberssin3* numberss})
print(mappedNumbers)
map为遍历使用 sort 为排序使用numbers为数组类型
let sortedNumbers = numberss.sort{$0 > $1}
print(sortedNumbers)