周末闲来无事，接触一下swift,
在Xcode的playground上玩儿swift还很好玩儿的，会一边编写代码一边检查一遍即使显示
基础
基本类型
Int
Double Float
String
Bool
let c = 1_000_000_000
let d:Int = 1
let e:Double = 1.5
let f:Float = 2.2
let g:String = "12"变量与常量
let 常量
var 变量
在swift中值永远不会被隐式转换为其他类型。如果需要把一个值转换成其他类型，需要进行显式转换。
使用 \() 也可以把值转换成字符串
显式转换
let str = "The width is"
let intlet = 94
let result = str + String(intlet)
print(result)
let a = 3
let b = 0.1415926
let pi = Double(a)+b
let version = 4
let 新变量 = "你好 swift \(version)"数组与字典
[] 来创建数组和字典 也可以用 [] 和 [:] 来设置空数组和空字典
let emptyArray = [String]()
let emptyDictionary = [String: Float]()
var str = "Hello, playground"
var array = [1,2,3,4,5,6,7,8]
var ar1 = array[1]
array[1]=5
ar1 = array[1]
var dic = [String:Any]()
dic = ["a":"1","b":2.2,"c":3]
var ar2 = dic["c"]
array = []
dic=[:]元祖
多个数据的集合 类似python
var tuples = ("aven" , 200 , false)
let (nickname,code,success) = tuples
let (name,_,_) = tuples
print (tuples.0)//aven
print (nickname)//aven
print (name)//aven
let test = ( nickname:"aven" , code:200 , success:false )
print (test.nickname)//aven
逻辑操作
if 和 switch 进行条件操作
–if 语句中，条件必须是一个布尔表达式
可以一起使用 if 和 let 来处理值缺失的情况。
另一种处理可选值的方法是通过使用 ?? 操作符来提供一个默认值。如果可选值缺失的话，可以使用默认值来代替。
–switch 支持任意类型的数据以及各种比较操作
– switch 中匹配到的子句之后，程序会退出 switch 语句，并不会继续向下运行，所以不需要在每个子句结尾写 break。但一定要加上default，不然会报错。
for-in、 for、 while 和 repeat-while 进行循环操作
——for-in 来遍历字典，需要两个变量来表示每个键值对。字典是一个无序的集合，所以他们的键和值以任意顺序迭代结束。 循环中可以使用 ..< 来表示范围。使用 ..< ==> [)， … ==> []
repeat-while 类似do-while
let array = [11, 22, 33, 44, 55,66,77,88,99,111]
var team = 0
for data in array {
if data > 50 {
team += 3
} else {
team += 1
}
}
///////////////////
var optionalName: String? = nil
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}else{
greeting = "nobody"
}
let nickName: String? = "aven"
let fullName: String = "X"
let informalGreeting = "Hi \(nickName ?? fullName)"
//////////////////////////////////////////////////////
let vegetable = "red pepper"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
print("Is it a spicy \(x)?")
default:
print("Everything tastes good in soup.")
}
//// 遍历字典
let dic = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largestNumber = 0
var largestKey: String = ""
for (key, values) in dic {
for value in values {
if value > largestNumber {
largestNumber = value
largestKey = key
}
}
}
print(largestKey)
print(largestNumber)
var n = 2
while n > 100 {
n = n * 2
}
print(n)//2
var m = 2
repeat {
m = m * 2
} while m > 100
print(m)//4
for i in 0..<4 {
print(i)//0 1 2 3
}函数
func 来声明一个函数，
-> 来指定函数返回值的类型, 使用元组来让一个函数返回多个值
可变参数在函数内表现为数组的形式。
函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 _ 表示不使用参数标签。
func hi(name: String) -> String {
return "Hello \(name)."
}
print( hi(name:"aven"))//Hello aven.
func hi2(_ name: String) -> String {
return "Hello \(name)."
}
print( hi2("aven"))//Hello aven.
func hi2(nickname name: String) -> String {
return "Hello \(name)."
}
print( hi2(nickname:"aven")) //Hello aven.
func compare(_ numbers: [Int]) -> (min: Int, max: Int, sum: Int) {
var min = numbers[0]
var max = numbers[0]
var sum = 0
for score in numbers {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let result = compare([11,2,34,56,1])
print (result) //(min: 1, max: 56, sum: 104)
/////
func data(numbers: Int...) -> Double {
var sum = 0
let count = numbers.count
for number in numbers {
sum += number
}
if count == 0 {
return 0
}
return Double(sum/count)
}
print(data(numbers: 1,2,111))//38.0
print(data(numbers: 22,1,43,12,53))//26.0
print(data())//0.0函数可以嵌套。被嵌套的函数可以访问外侧函数的变量。
func newdata(_ number: Int) -> Int {
var y = number;
func add() {
y += 5
}
add()
return y
}
print(newdata(18)) //23函数可以作为另一个函数的返回值,也可以当做参数传入另一个函数。
func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
print (number)
return 1 + number
}
return addOne //((Int) -> Int)
}
var increment = makeIncrementer() //((Int) -> Int)
increment(7) //8
func hasAnyMatches(bumber: Int, condition: (Int) -> Bool) -> Bool {
if condition(bumber) {
return true
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var number = 9
hasAnyMatches(bumber: number, condition: lessThanTen) // true闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包作用域中的变量和函数，即使闭包是在一个不同的作用域被执行的。函数实际上是一种特殊的闭包。可以使用 {} 来创建一个匿名闭包。使用 in 将参数和返回值类型的声明与闭包函数体进行分离。
var numbers = [20, 19, 7, 12]
let ok = numbers.map({
(number: Int) -> Int in
if(number%2 != 0){
return 0
}else{
return number
}
})
print(ok)//[20, 0, 0, 12]
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)//[60, 57, 21, 36]
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)//[20, 19, 12, 7]