Swiftui 退出程序 swift 跳出循环

1.break－Continue
 /*
break: 跳出循环, 无论循环保持条件是否还为真都不会再执行循环
continue: 跳出本次循环, 如果循环保持条件还为真还会继续执行循环
 
 OC:
 NSArray *arr = @[@1,@3, @5, @7, @8];
 for (NSNumber *num in arr) {
 if ([num isEqualTo:@(7)]) {
找到幸运数字");
     break;
 }
没有找到幸运数字");
 }
 
 NSArray *arr = @[@1,@3, @5, @7, @8];
 int count = 0;
 for (NSNumber *num in arr) {
 if (num.intValue % 2 != 0 ) {
不能被2整除");
     continue;
 }
能被2整除");
     count++;
 }
 NSLog(@"count = %d", count);
 */
 
var arr:Array<Int> = [1, 3, 5,  7, 8]
for num in  arr{
if num == 7
     {
print("找到幸运数字")
break
     }
    print("没有找到幸运数字")
 }
 
var arr1:Array<Int> = [1, 3, 5,  7, 8]
var count:Int = 0
for num in  arr1{
if num % 2 != 0
     {
print("不能被2整除")
continue
     }
    print("能被2整除")
count++
 }
print("count = \(count)")

2.
 /*
 Swith
格式: switch(需要匹配的值) case 匹配的值:  需要执行的语句
 OC:
 char rank = 'A';
 switch (rank) {
     case 'A':
优");
         break;
     case 'B':
良");
         break;
     case 'C':
差");
         break;
     default:
没有评级");
         break;
 }
 
 可以穿透
 char rank = 'A';
 switch (rank) {
     case 'A':
优");
     case 'B':
良");
         break;
     case 'C':
差");
         break;
     default:
没有评级");
         break;
 }
 
可以不写default
 char rank = 'A';
     switch (rank) {
     case 'A':
优");
         break;
     case 'B':
良");
         break;
     case 'C':
差");
         break;
 }
 
位置可以随便放
 char rank = 'E';
 switch (rank) {
     default:
没有评级");
     break;
     case 'A':
     {
         int score = 100;
优");
         break;
     }
     case 'B':
良");
         break;
     case 'C':
差");
         break;
 }
 
 
case中定义变量需要加大括号, 否则作用域混乱
 char rank = 'A';
 switch (rank) {
     case 'A':
     {
         int score = 100;
优");
         break;
     }
     case 'B':
良");
         break;
     case 'C':
差");
         break;
 }
 
 不能判断对象类型
 NSNumber *num = @100;
 switch (num) {
 
     case @100:
优");
         break;
     default:
没有评级");
         break;
 }
 */
 
 /*
Swift: 可以判断对象类型, OC必须是整数
 */
//不可以穿透
可以不写break,
var rank = "A"
 rank{
    case "A":  //相当于if
print("优")
    case "B":  // 相当于else if
print("优")
    case "C":  // 相当于else if
print("优")
    default: // 相当于else
print("没有评级")
 }
 
 /*
 因为不能穿透所以不能这么写
 var rank1 = "A"
 switch rank1{
     case "A":
     case "B":
优")
     case "C":
优")
     default:
没有评级")
 }
 */
 
//只能这么写
var rank1 = "A"
 rank1{
    case "A",  "B": //  注意OC不能这样写
print("优")
case "C":
print("差")
    default:
print("没有评级")
 }
 
 /*
不能不写default
 var rank2 = "A"
 switch rank2{
     case "A":
优")
     case "B":
良")
     case "C":
差")
 }
 */
 
 /*
位置只能在最后
 var rank3 = "A"
 switch rank3{
     default:
没有评级")
     case "A":
优")
     case "B":
良")
     case "C":
差")
 }
 */
 
//在case中定义变量不用加大括号
var rank4 = "A"
 rank4{
case "A":
var num =  10
print("优")
case "B":
print("良")
case "C":
print("差")
    default:
print("没有评级")
 }
 
 /*
 区间和元祖匹配
 var num = 10;
 switch num{
     case 1...9:
个位数")
     case 10...99:
十位数")
     default:
其它数")
 
 }
 
 
 var point = (10, 15)
 switch point{
     case (0, 0):
坐标在原点")
 可以在元祖中再加上区间
坐标的X和Y在1~10之间")
可以是任意数
坐标的X在X轴上")
     default:
         print("Other")
 }
 */
 
 
 /*
 值绑定
 var point = (1, 10)
 switch point{
 会将point中X的值赋值给X
         print("x= \(x)")
 会将point中XY的值赋值给XY
         print("x= \(x) y= \(y)")
     case var( x, y):
         print("x= \(x) y= \(y)")
     default:
         print("Other")
 }
 
 根据条件绑定
 var point = (100, 10)
 switch point{
    // 只有where后面的条件表达式为真才赋值并执行case后的语句
     case var(x, y) where x > y: 
         print("x= \(x) y= \(y)")
     default:
         print("Other")
 }
 */
 
 
 
 

  3.函数的定义 

 
 /*
: 完成某个特定任务的代码块, 给代码起一个合适的名称称之为函数名称.  以后需要执行代码块只需要利用函数名称调用即可,  好比每个人都有一个名字, 叫名字就能找到对应的人
:
func 函数名称(参数名:参数类型, 参数名:参数类型...) -> 函数返回值 {函数实现部分}
 
 OC:
 - (void)say
 {
     NSLog(@"hello");
 }
 - (void)sayWithName:(NSString *)name
 {
     NSLog(@"hello %@", name);
 }
 - (void)sayWithName:(NSString *)name age:(NSInteger)age
 {
     NSLog(@"hello %@ , I'm %tu years old", name, age);
 }
 - (NSString *)info
 {
     return @"name = lnj, age = 30";
 }
 - (NSString *)infoWithName:(NSString *)name age:(NSInteger)age
 {
     return [NSString stringWithFormat:@"name = %@, age = %tu", name, age];
 }
 
 Person *p = [[Person alloc] init];
 [p say];
 [p sayWithName:@"lnj"];
 [p sayWithName:@"lnj" age:30];
 NSLog(@"%@", [p info]);
 NSLog(@"%@", [p infoWithName:@"lnj" age:30]);
 */
 
// 无参无返回值
func say() -> Void
 {
    print("hello")
 }
 
func say1()  // 如果没有返回值可以不写
 {
    print("hello")
 }
()
 
// 有参无返回值
func sayWithName(name:String)
 {
print("hello  \(name)")
 }
("lnj")
 
func sayWithName1(name:String, age:Int)
 {
    print("hello \(name) , I'm \(age) years old ")
 }
("lnj", age: 30)
 
// 无参有返回值
func info() -> String
 {
    return "name = lnj, age = 30"
 }
(info())
 
// 有参有返回值
func info(name:String, age:Int) -> String
 {
    return "name = \(name), age = \(age)"
 }
print(info("lnj", age:30))
 
 
 /*
 嵌套函数
 */
func showArray(array:[Int])
 {
for number in
     {
print("\(number), ")
     }
 }
 /*
 func swap(inout a:Int, inout b:Int)
 {
     let temp = a
     a = b
     b = temp
 }
 */
var number = 998;
func bubbleSort(inout array:[Int])
 {
print(number)
func swap(inout a:Int, inout b:Int)
     {
print(number)
let
         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])
 //                let temp = array[j]
 //                array[j] = array[j + 1]
 //                array[j + 1] = temp
 
             }
         }
     }
 }
 
var arr:Array<Int> = [31, 13, 52,  84, 5]
(&arr)
(arr)
 
 /*
: 默认情况下的参数都是内部参数
: 如果有多个参数的情况, 调用者并不知道每个参数的含义, 
        那么能不能和OC一样让调用者直观的知道参数的含义呢? 使用外部参数
        外部参数只能外部用, 函数内部不能使用, 函数内部只能使用内部参数
 */
func divisionOpertaion1(a:  Double, b:Double) ->  Double{
return
 }
 
func divisionOpertaion2(dividend:  Double, divisor:Double) ->  Double{
return
 }
 
func divisionOpertaion3(dividend a:  Double, divisor b:Double) ->  Double{
 //    return dividend / divisor
return
 }
print(divisionOpertaion3(dividend: 10, divisor: 3.5))
 
func divisionOpertaion4(a:  Double, divisor b:Double) ->  Double{
return
 }
print(divisionOpertaion4(10, divisor: 3.5))
 
 /*
过时
// 在参数前面加上#相当于该参数即是内部参数, 也是外部参数
等价于dividend dividend: Double, divisor divisor:Double
 func divisionOpertaion5(#dividend: Double, #divisor:Double) -> Double{
     return dividend / divisor
 }
 print(divisionOpertaion5(dividend: 10, divisor: 3.5))
 */
// 取而代之第二个参数开始默认既是外部又是内部
func divisionOpertaion5(dividend:  Double, divisor:Double) ->  Double{
return
 }
print(divisionOpertaion5(10, divisor: 3.5))
 
 
 /*
:
, 当外部调用没有传递该参数时会自动使用默认值
 */
 
func joinString(s1:String ,toString s2:String, jioner s3:String) ->String
 {
return
 }
 
func joinString2(s1:String ,toString s2:String, jioner s3:String = "❤️") ->String
 {
return
 }
print(joinString2("hi", toString:"beauty"))
 
//如果指定了默认参数, 但是确没有声明外部参数时, 系统会自动把内部参数名称既作为内部参数也作为外部参数名称, 并且在调用时如果需要修改默认参数的值必须写上外部参数名称
func joinString3(s1:String ,toString s2:String, jioner:String = "❤️") ->String
 {
return
 }
print(joinString3("hi", toString:"beauty", jioner:"