1.简单值
- 常量或者变量的类型必须和你赋给它们的值一样，然而，你不用明确地声明类型，声明的同时赋值的话，编译器会自动推断类型。
let number: Float = 4 print("输出数字:", number)输出数字: 4.0
值永远不会被隐式转换为其他类型，如果你需要把一个值转换成其他类型，请显示转换
- 数字转换字符串操作（方法一）
let label = "the width is"
let width = 94
let widthLabel = label + String(width)//数字转换字符串操作
print(widthLabel)
打印结果：the width is94
- 数字转字符串操作（方法二）把值写到括号中，并且在括号之前写一个反斜杠
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pices of fruit"
print(appleSummary)
print(fruitSummary)
输出结果：I have 3 apples.
输出结果：I have 8 pices of fruit
- 数组的创建和字典的使用
使用方括号 [] 来创建数组和字典，并使用下标或者键（key）来访问元素，最后一个元素前允许有个逗号
var shoppingList = ["catfish","water","tulips","blue paint"]
shoppingList[1] = "bottle of water"
print("shoppingList:",shoppingList)
//shoppingList: ["catfish", "bottle of water", "tulips", "blue paint"]
var occupations = [
"Malcolm":"Captain",
"Kaylee":"Mechanic",
]
occupations["Jayne"] = "public relations"
print(occupations)//["Kaylee": "Mechanic", "Malcolm": "Captain", "Jayne": "public relations"]
//要创建一个空数组或者字典，使用初始化方法
let emptyArray = [String]();
let emptyDictionary = [String:Float]()
//如果类型信息可以被推断出来，你可以用【】和[:]创建空数组和空字典----就像你声明变量或者给函数传参数的时候一样。
shoppingList = []
occupations = [:]
print(shoppingList.isEmpty)//true
2.控制流
使用if和switch来进行条件控制，使用for-in、for、white和repeat-while来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的
let individualScores = [75,43,103,87,12]
var teamScore = 0
for score in individualScores{
if score > 50 {
teamScore += 3
} else{
teamScore += 1
}
}
print("temaScore:",teamScore)//temaScore: 11
- 在if语句中，条件必须是一个布尔表达式--这意味着像 if score {....}这样的代码将报错，而不会隐形的与0作比较。
- 你可以一起使用if和let来处理值缺失的情况，这些值可由可选值来代表。一个可选值是一个具体的值或者是nil以表示值缺失。
在类型后面加一个问号来标记这个变量的值是可选的
var optionalString :String? = "hello"
print(optionalString == nil)//false
print(optionalString as Any)//Optional("hello")
var optionalName:String? = nil
var greeting="Hello!"
if let name = optionalName {
greeting = "Hello,\(name)"
}
print(greeting)//Hello!
使用for-in来遍历字典，需要两个变量来表示每个键值对。字典是一个无序的集合，所以他们的键和值以任意x顺序迭代结束。
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
}
}
}
print(largest) //25
使用while来重复运行一段代码知道不满足条件。循环条件也可以在结尾，保证能至少循环一次。
var n = 2;
while n < 100 {
n = n*2//128
}
print(n)
var m = 2
repeat{
m = m * 2
}while m < 100
print(m)//128
- 你可以在循环中使用..<表示范围，也可以使用传统的写法，两者是等价的
var firstForLoop = 0
for i in 0..<4 {
firstForLoop += i
}
print(firstForLoop)
//总结: ..< 创建的范围不包含上届，如果想要包含的话需要使用...
/*
该中写法已经被swift3 废弃
var secondForLoop = 0
for var i = 0; i < 4; ++i {
secondForLoop += i
}
print(secondForLoop)
*/
3.函数和闭包
- 使用 func 来声明一个函数，使用名字和参数来调用函数。 使用-> 来指定函数返回值类型
func greet(name:String,day :String) -> String{
return "Hello \(name),today is \(day)"
}
var str = greet(name: "Bob", day: "Tuesday")
print(str) //Hello Bob,today is Tuesday
- 使用元组来让一个函数返回多个值，该元组的元素可以用名称或数字来表示
func calculateStatistics (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 = calculateStatistics(scores: [5,3,100,3,9])
print(statistics.sum)//输出结果：120
print(statistics.2)// 输出结果：120 如果把2改成3 提示：Value of tuple type '(min: Int, max: Int, sum: Int)' has no member '3'
- 函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式
func sumOf(numbers: Int ...) -> Int{
var sum = 0
for number in numbers {
sum += number
}
return sum
}
var sum = sumOf(numbers: 42,597,12)
print(sum)//651
- 函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数
func returnFifteen() -> Int{
var y = 10
func add(){
y += 5
}
add()
return y
}
var y = returnFifteen()
print("y=",y)//y=15
- 函数是第一等类型，这意味着函数可以作为另一个函数的返回值
func makeIncrementer() -> ((Int) -> Int){ // swift3以后参数需要加括号，否则报错Single argument function types require parentheses
func addOne(number: Int) -> Int{
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
print("increment:",increment)//increment: (Function)
increment(7)
print("increment含参数:",increment)//increment含参数: (Function)
函数也可以当做参数传入另一个函数
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]
var result = hasAnyMatches(list: numbers, condition: lessThanTen(number:))
print(result)//true 当遇到数字7的时候就跳出本次循环了函数结束执行
函数实际上是一种特殊的闭包：它是一段能之后被调取的代码。
闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即时闭包是在一个不同的作用域被执行的
你已经在嵌套函数例子中看到,你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离
*/
numbers.map ({ (number:Int) -> Int in
let result = 3 * number
return result
})
/*
有很多种创建更简洁闭包的方法，如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
*/
let mappedNumbers = numbers.map({number in 3*number })
print(mappedNumbers)//[60, 57, 21, 36]
/*
你可以通过参数位置而不是参数名字来引用参数--这个方法在非常短的闭包中非常有用。
当一个闭包作为最后一个参数传给一个函数的时候，它可以直接更在括号后面
当一个闭包是传给函数的唯一参数，你可以完全忽略括号
*/
let sortedNumbers = numbers.sort { $0 > $1 }
print(sortedNumbers)