快捷搜索:  as

Swift-基础巩固

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

你可以在轮回中应用..

var firstForLoop = 0

for iin 0..

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

函数可以带有可变个数的参数,这些参数在函数内体现为数组的形式

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

}

varincrement = 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

函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。

闭包中的代码能造访闭包所建感化域中能获得的变量和函数,即时闭包是在一个不合的感化域被履行的

你已经在嵌套函数例子中看到,你可以应用{}来创建一个匿名闭包。应用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)

您可能还会对下面的文章感兴趣: