Swift 语法篇

一、输出语句

1
2
print("Hello World")
print("Hello World 11", "Hello World 22", separator: "*****", terminator: "\n")

  

二、简单值

  常量使用 let (只能赋值一次,赋值后值不能改变),变量使用 var。

1
2
3
let myConst = 10
var myVariable = 50
myVariable = 15   

  常量和变量在声明时候指定类型是可选的,如果声明的时候没有给定类型,编译器会自动推断类型。如果初始值不能提供足够的类型说明,则需要在声明的时候显示声明类型。  

1
let myDoubleConst: Double = 70;

  值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型,请显式转换。

1
2
3
4
5
let myString = "Hello World"
let myFloat = 4.0
 
let sum = myString + String(myFloat)
print("sum =", sum)

  简单的把值转换成字符串。  

1
2
3
4
let myConst1 = 50
let myConst2 = 100
print("myConst1 = \(myConst1); myConst2 = \(myConst2)")
print("sum = \(myConst1 + myConst2)")

  使用 [] 定义 Array 和 Dictionary,以及修改其内容。

1
2
3
4
5
6
7
8
9
10
11
var myArray = ["apple", "boy", "cat", "dog"]
myArray[0] = "www"
print(myArray)
         
         
var myDict = [
    "key1" : "value1",
    "key2" : "value2"
]
myDict["key3"] = "value3"
print(myDict)

  创建空 Array 和 Dictionary -- 确定类型。

1
2
let emptyArray = [String]()
let emptyDict = [String: Float]()

  创建空 Array 和 Dictionary -- 不确定类型。

1
2
let emptyArray1 = []
let emptyDict1 = [:]

 

三、控制流

  使用 if 和 switch 来进行条件操作,使用 for-inforwhile 和 do-while 来进行循环。包裹条件和循环变量括号可以省略,但是语句体的大括号是必须的。  

1
2
3
4
5
6
7
8
9
10
11
let scoreList = [11, 22, 33, 44, 55, 66]
var tmpScore = 0
for score in scoreList {
    if (score > 50) {
        tmpScore += 3
    }
    else {
        tmpScore += 1
    }
}
print(tmpScore)

 

  在 if 语句中,条件必须是一个布尔表达式——像 if score { ... } 这样的代码是错误的。可以使用 if 和 let 来处理这种可选变量值 (可选变量值:有可能是一个具体的值,也有可能是 nil 表示缺失)

1
2
3
4
5
6
7
8
9
10
11
var optionalName: String? = "Eileen Leung"
optionalName = nil
var greeting = "Hello"
         
if let name = optionalName // 相当于 optionalName != nil
    greeting = "\(greeting), \(optionalName)"
}
else {
    greeting = "\(greeting), Stranger"
}
print(greeting)

  switch 支持任意类型的数据以及各种比较操作——不限于整数或等值测试。default 不能缺少。运行 switch 中匹配到的子句之后,程序会退出 switch 语句,并不会继续向下运行,所以不需要在每个子句结尾写 break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
let myString = "Eileen Leung"
let result: String?;
         
switch myString {
    case "Ada":
        result = "This is \(myString)"
    case "Cherry", "Wing"// Cherry 或者 Wing
        result = "This Cherry Or Wing"
    case let x where x.hasPrefix("Eileen"):
        result = "This is Eileen"
    default:
        result = nil
}
print(result)
 
// 输出结果: This is Eileen   

  使用 for-in 来遍历字典。

1
2
3
4
5
6
7
8
9
10
11
12
13
let numberDict = [
    "key1": [10, 20, 30, 40, 50, 100],
    "key2": [1, 3, 5, 7],
    "key3": [2, 4, 6, 8, 10]
]
         
var sum = 0
for (key, numbers) in numberDict {
    for num in numbers {
        sum += num
    }
}
print(sum)
1
2
3
4
5
6
7
8
9
10
11
12
13
let myDictionary = [
    "key1": [10, 20, 30, 40, 50, 100],
    "key2": ["apple", "boy", "cat", "dog", "egg", "flight", "green", "hat", "island", "jail"],
    "key3": [1.5, 2.5, 3.5]
]
         
for (key, valueList) in myDictionary {
    print(key, ": [")
     for value in valueList {
        print("\t", value, ",")
    }
    print("}")
}

  使用 while 来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。

1
2
3
4
5
6
7
8
9
var n = 2
while n < 100 {
    n = n * 2
}
 
var m = 2
repeat {
    m = m * 2
} while m < 100

  在循环中使用 ..< 和 ... 来表示范围,其中 ..< 创建的范围不包含上界,如果想包含的话需要使用 ... 。

1
2
3
4
var firstForLoop = 0
for i in 0..<3 // 相当于 for var i = 0; i < 3; ++i
    firstForLoop += i
}
1
2
3
4
var secondForLoop = 0
for j in 0...3 // 相当于 for var j = 0; j <= 3; ++j
    secondForLoop += 1
}

  

四、函数和闭包

  使用 func 来声明一个函数,使用名字和参数来调用函数。使用 -> 来指定函数返回值。

1
2
3
4
5
6
7
8
9
10
11
12
13
func sum(numbers: Array<Int>, base: Int) -> Int {
    var sum = base
    for number in numbers {
        sum += number
    }
    return sum
}
 
 
// 调用
let myNumbers = [1, 3, 5, 7, 9]
let sumValue = sum(myNumbers, base: 50)
print(sumValue)

  返回多个参数。

1
2
3
func getFloatValue() -> (value1: Float, value2: Float, value3: Float) {
    return (1.0, 5.0, 3.5)
}

  参数数量可变。

1
2
3
4
5
6
7
8
9
10
11
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}   
 
// 调用处
print(sumOf(5))
print(sumOf(10, 20, 30))

  函数可以嵌套。被嵌套的函数可以访问外侧函数的变量,你可以使用嵌套函数来重构一个太长或者太复杂的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func returnFifteen() -> Int {
    var y = 10
         
    func add() {
        y += 5
    }
         
    add()
    return y
}
 
 
// 调用处
print(returnFifteen())

  函数可以作为另一个函数的返回值。

1
2
3
4
5
6
7
8
9
10
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
 
// 调用处
let increment = makeIncrementer()
print(increment(7))

  函数也可以当做参数传入另一个函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func hasAnyMatches(list: Array<Int>, condition: Int -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
     
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
 
// 调用处
let numbers = [20, 19, 7, 12]
let result = hasAnyMatches(numberscondition: lessThanTen)
print("result = \(result)")

  函数实际上是一种特殊的闭包,你可以使用{}来创建一个匿名闭包。使用 in 来分割参数并返回类型。

  闭包完整格式:

1
2
3
4
5
6
7
{
    (参数名: 参数类型) -> 返回类型 in
     
    执行代码
 
    return 返回值
}

  完整格式例子:

1
2
3
4
5
6
let numbers = [20, 19, 7, 12]
let result = hasAnyMatches(numbers, condition: ({
            (number: Int) -> Bool in
            return number > 10
    }))
print("result = \(result)")

  

 

posted on   EileenLeung  阅读(189)  评论(0编辑  收藏  举报

编辑推荐:
· Java 中堆内存和栈内存上的数据分布和特点
· 开发中对象命名的一点思考
· .NET Core内存结构体系(Windows环境)底层原理浅谈
· C# 深度学习:对抗生成网络(GAN)训练头像生成模型
· .NET 适配 HarmonyOS 进展
阅读排行:
· 用 DeepSeek 给对象做个网站,她一定感动坏了
· DeepSeek+PageAssist实现本地大模型联网
· 手把手教你更优雅的享受 DeepSeek
· 腾讯元宝接入 DeepSeek R1 模型,支持深度思考 + 联网搜索,好用不卡机!
· 从 14 秒到 1 秒:MySQL DDL 性能优化实战
< 2025年2月 >
26 27 28 29 30 31 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 1
2 3 4 5 6 7 8

统计

点击右上角即可分享
微信分享提示