Snip20160301_5.png
]
for num in arr{
if num == 5
{
print("找到幸运数字")
break
}else{
print("没有找到幸运数字")
}
}
var arr1:Array = [1, 3, 5, 3, 7, 8, 4]
var count:Int = 0
for num in arr1{
if num % 2 != 0
{
print("不能被2整除")
continue
}else{
print("能被2整除")
count++
}
}
print("count = \(count)")
**输出结果: **
Snip20160301_1.png
- break: 跳出循环, 无论循环保持条件是否还为真, 都不会继续执行循环
- continue: 跳出本次循环, 如果循环保持条件还为真, 那么还会继续执行循环
2. Switch
var rank = "A"
switch rank{
case "A":
print("优")
case "B":
print("良好")
case "C":
print("良")
default:
print("没有评级")
}
// 因为Swift不能穿透，所以不能这么写，故：以下写法是错误的
//switch rank{
//
//case "A":
//case "B":
// print("良好")
//case "C":
// print("良")
//default:
// print("没有评级")
//}
switch rank{
case "A","B": //这个在我们OC中是不能够这样写的
print("优")
case "C":
print("良")
default:
print("没有评级")
}
// Swift 中的switch不能不写default的、而且他的位置只能是在最后面
// 在OC中，都知道，一旦case后面的语句多于一行的时 候，就必须加上大括号，但是在Swift是可以不用加的
var rank1 = "A"
switch rank1{
case "A":
var count = 0
print("优")
case "B":
print("良好")
case "C":
print("良")
default:
print("没有评级")
}
// 区间与元组匹配
var num = 10
switch num{
case 1...9:
print("个位数")
case 10...99:
print("两位数")
default:
print("其他数字")
}
var point = (10, 15)
switch point{
case (0, 0):
print("坐标在原点")
case (1...10,10...20):
print("你猜坐标在哪？？？")
case (_,0):
print("坐标在x轴上")
default:
print("Other")
}
// 值绑定
var point1 = (1, 10)
switch point1{
case (var x, 10): // 会将point中的x赋值给x
print("x = \(x)")
case (var x, var y): // 会将point中的x，y赋值给x，y
print("x= \(x),y = \(y)")
case var (x, y):
print("x = \(x), y = \(y)")
default:
print("Other")
}
// 根据条件绑定值
var point2 = (100, 10)
switch point2{
case var (x, y) where x > y:
print("x = \(x), y = \(y)")
default:
print("Other")
}
**输出结果: **
Snip20160301_2.png
3. 函数
3.1 函数定义:
func say() -> Void
{
print("高俊是帅哥")
}
func say1()
{
print("高俊是很屌的哟")
}
// 有参数，无返回值
func sayWithName(name:String)
{
print("hello-> \(name)")
}
sayWithName("gaojun")
// 带有多个参数的函数
func sayWithName2(name:String, age:Int)
{
print("my name is \(name),I'm \(age) years old")
}
sayWithName2("高俊", age: 19)
// 无参，有返回值
func info() -> String
{
return "my name is gaojun I'm nineteen years old"
}
print(info())
// 有参，有返回值
func infoWithName(name:String, age:Int) -> String
{
return "name is \(name), age is \(age)"
}
print(infoWithName("gaojun", age: 19))
// 嵌套函数
var arr:Array = ["gaojun", "jack", "mark"]
func showArry(array:[String])
{
for number in array
{
print("\(number), ")
}
}
showArry(arr)
//2、
func bubbleSort (inout array:[Int])
{
func swap(inout a:Int, inout b : Int)
{
let temp = a
a = b
b = temp
}
let count = array.count
for var i = 1 ; i < count ; i++
{
for var j = 0 ; j < (count - i) ; j++
{
if array[j] > array[j + 1]
{
swap(&array[j], b: &array[j + 1])
}
}
}
}
var arr1:Array = [50, 20, 30, 80]
bubbleSort(&arr1)
print(arr1)
**输出结果: **
Snip20160301_3.png
函数: 完成某个特定任务代码块, 给代码起一个合适的名称称之为函数名称
以后需要执行代码块只需要利用函数名称调用即可
好比每一个人都有一个名字, 说出名字就可以找到对应的人
3.2 Swift内部函数, 外部函数
内部函数：默认情况下的参数都是内部参数
外部函数：如果有多个参数的情况，调用者并不知道每一个参数的含义，
只能通过查看头文件的形式理解，参数的含义
那么能不能和OC不一样让调用者直观的知道参数的含义呢？使用外部参数
外部参数只能外部用，函数内部不能使用，函数内部只能使用内部参数
func divisionOpertion1(a: Double, b: Double) -> Double{
return a / b
}
print(divisionOpertion1(10.2, b: 3.1))
** 默认参数:**
可以在定义函数的时候给某个参数赋值，当外部调用没 有传递该参数时会自动使用默认值
func joinString(s1:String, toString s2: String, joiner s3: String) ->String
{
return s1 + s2 + s3
}
func joinString2(s1: String, toString
s2: String , joiner
s3: String = "❤️") ->String
{
return s1 + s3 + s2
}
print(joinString2("gaojun", toString: "beauty"))
如果指定了默认参数，但是确没有声明外部参数时
系统会自动把内部参数名称即当做内部参数名称、又当做外部参数名称
并且在调用的时，如果需要修改默认参数的值，必须写上外部参数名称
func joinString3(s1:String, toString s2: String, joiner: String = "") ->String
{
return s1 + joiner + s2;
}
print(joinString2("gaojun", toString: "beauty"))
func joinString4(s1:String, joiner: String = "❤️", toString s2: String) ->String
{
return s1 + joiner + s2;
}
print(joinString4("高俊", joiner: "", toString: "beauty"))
常数参数和遍历参数:
默认情况下，swift中所有函数参数都是常量参数，如果想砸u中修改参数，就必须在参数前加上var
func swap(var a: Int, var b: Int)
{
print("交换前 a = \(a) b = \(b)")
let temp = a
a = b
b = temp
print("交换后 a = \(a) b = \(b)")
}
swap(10, b: 20)
**inout参数: **
如果想在函数中修改外界传入的参数，
可以将参数的var换成inout ，这回会传递参数本身而不是参数的值
func swap2(inout a: Int, inout b: Int)
{
let temp = a
a = b
b = temp
}
var x1 = 10
var y1 = 20
print("交换前 a = \(x1) b = \(y1)")
swap2(&x1, b: &y1)
print("交换后 a = \(x1) b = \(y1)")
**变参函数: **
如果没有变参函数，并且函数参数个数又不确定，
那么只能写多个放啊发或者用将函数参数改为集合变参只能放到参数列表的最后一位，变参必须指定数据类型，变参只能是同类型的数据
func add(num1:Int, num2: Int, num3: Int) ->Int
{
let sum = num1 + num2 + num3
return sum
}
print(add(1, num2: 2, num3: 3))
func add1(nums: [Int]) ->Int
{
var sum = 0
for num in nums
{
sum += num
}
return sum
}
print(add1([1, 2, 3, 4]))
func add2(nums:Int...) ->Int
{
var sum = 0
for num in nums
{
sum += num
}
return sum
}
print(add2(1, 2, 3, 4, 5))
func add3(other: Int, nums: Int...) ->Int
{
var sum = 0
for num in nums
{
sum += num
}
return sum
}
print(add3(99, nums: 1, 2))
3.3 函数类型
函数类型：
类似于C语言的指向函数的指针
类似于OC中的block
函数类型是由函数的参数类型和返回值类型组成的
// 类型：（Int, Int）-> Int
func sum(a: Int, b: Int) ->Int
{
return a + b
}
func sub(a: Int, b: Int) ->Int
{
return a - b
}
// 可以利用函数类型定义函数变量和常量
var funcP: (Int, Int) ->Int = sum
funcP = sub
print(funcP(10,20))
// 函数类型可以作为函数的参数
func calFunc(a: Int, b: Int, OPtion:(Int, Int) -> Int) ->Int
{
return OPtion(a, b)
}
print(calFunc(10, b: 20, OPtion: sum))
print(calFunc(10, b: 20, OPtion: sub))
// 函数类型可以作为函数返回值
func max(a: Int, b: Int) ->Int
{
return a > b ? a : b
}
func min(a: Int, b: Int) ->Int
{
return a < b ? a : b
}
func chooseFunc(getMax:Bool) -> (Int , Int) -> Int
{
return getMax ? max : min
}
var funcP2:(Int, Int) -> Int = chooseFunc(false)
print(funcP2(10, 20))