Swift基本语法及与OC比较之二

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› 移动开发›Swift 教程
原作者: [db:作者] 来自: [db:来源] 收藏邀请
  1 //MARK:-----------------控制流-----------------
  2 //MARK: 1.for - in 循环 ,不用声明Value类型
  3 
  4 //for value in 1...6 {
  5 //print(value)
  6 //
  7 //}
  8 
  9 
 10 //不需要具体的值，只是为了得到循环次数
 11 
 12 //for _ in 1...6 {
 13 //print("123")
 14 //}
 15 
 16 
 17 //MARK: 2.for循环，和C一样，只是没有 括号
 18 
 19 //for var i = 0 ; i < 26 ; i++ {
 20 //print("i = \(i)")
 21 //}
 22 
 23 //MARK: 3.while 循环,和C一致
 24 
 25 //var whileValue = 0
 26 //while whileValue < 10 {
 27 //    whileValue++
 28 //
 29 //    print("while ++ -- \(whileValue)")
 30 //}
 31 
 32 
 33 //MARK: 4. do-while 循环
 34 
 35 //var number = 0
 36 
 37 //repeat {
 38 //print("number -- \(number)")
 39 //number++
 40 //}while false
 41 
 42 //repeat {
 43 //    print("number -- \(number)")
 44 //    number++
 45 //}while number < 10
 46 
 47 //MARK: 5. if-else 语句，分支语句
 48 //var applePrice = 8.5 // double
 49 //
 50 //if applePrice < 5 {
 51 //
 52 //    print("applePrice -- \(applePrice)")
 53 //}else{
 54 //    print("applePrice -- \(applePrice)")
 55 //}
 56 
 57 
 58 //MARK: if-else语句 的值绑定 可以保护程序
 59 
 60 //var optionValue :Int?
 61 //var optionValue :Int? = 5
 62 //if var tempOptionValue = optionValue {
 63 //    //如果可选类型有值，就走条件成立的语句
 64 //print("value = \(tempOptionValue)")
 65 //}else{
 66 //    //如果没有值，就走条件不成立的语句
 67 //    print("可选类型为nil")
 68 //}
 69 
 70 
 71 
 72 //MARK: 6.witch - case
 73 //（1）Swift中没有自动贯穿，即使把break删掉，也不会贯穿达下个case语句
 74 //（2）有需要贯穿需求的时候，需要加贯穿语句  fallthrough
 75 //（3）如果case中，没有任何语句，就必须加break ，没有语句就不必加break
 76 //（4）如果不写default，case语句必须包含所有情况。否则必须写。
 77 //var switchValue = 11
 78 //switch switchValue {
 79 //case 10:
 80 //    print("10")
 81 ////    break
 82 //case 11:
 83 //    print("11")
 84 ////    break
 85 //
 86 //    fallthrough
 87 //case 12:
 88 //    print("12")
 89 ////    break
 90 //default:
 91 //    print("other")
 92 //
 93 //}
 94 
 95 //MARK: switch -case 的值绑定
 96 //当case条件满足时，进入case语句，把值赋给我们设的局部变量（常量）
 97 //var (x,y) = (0,10)
 98 //switch (x,y){
 99 //case (let localX,0):
100 //    print("localX = \(localX)")
101 //case (0,let localY):
102 //    print("localY = \(localY)")
103 //default:
104 //    print("other")
105 //}
106 
107 //MARK: switch-case的区间匹配
108 
109 //var money : Float = 10.5
110 //switch money {
111 //case 0...10:
112 //    print("穷屌丝")
113 //case 10...100 :
114 //    print("普通人")
115 //default:
116 //    print("高富帅")
117 //}
118 
119 
120 
121 /* 词语辨析
122 fallthrough ：贯穿
123 continue :结束本次循环，进入下次循环
124 break：跳出循环
125 */
126 
127 
128 //MARK: 7.标签语
129 //sign:  主要用于循环嵌套：可以给循环加标签，这样可以给指定循环做一些操作.作用：更易于操作循环
130 //sign:while true {
131 //
132 //    for var i = 0 ; i < 10 ; i++ {
133 ////      指定break是那个控制流
134 //        if i == 5 {
135 //        break sign
136 //        }
137 //    print("i -- \(i)")
138 //    }
139 //}
140 
141 
142 //MARK: ----------------函数---------------------
143 //MARK: ----函数调用 --
144 
145 /*
146 func 函数名(参数列表) ->返回值 {
147 //实现动作部分
148 }
149 
150 */
151 
152 //func 函数名()->返回值
153 //MARK: 1.无参无返回值 , 没有返回值可以不写 ->\
154 
155 //func printFunc(){
156 //
157 //}
158 
159 
160 //func printFunc()->Void {
161 //    print("123")
162 //}
163 
164 ////diaoyong hanshu
165 //printFunc()
166 
167 //MARK: 2.有参无返回值
168 //func printCity(cityName:String){
169 //print("城市--\(cityName)")
170 //}
171 //
172 ////调用函数
173 //printCity("郑州")
174 
175 
176 //MARK: 3.无参有返回值
177 //func returnString()->String{
178 //return "北京"
179 //}
180 //
181 //let string = returnString()
182 //
183 //print(string)
184 //
185 //print(returnString())
186 
187 
188 //MARK: 4.有参有返回值 :可以支持多个返回值
189 
190 func matchFun(number1:Int,number2:Int)->(Int,Int){
191     
192     // number1++
193     return (number1 + number2,number2 * number1)
194 }
195 
196 //print(matchFun(2, number2: 3))
197 
198 
199 /*注意事项：
200 1.函数的形参是let类型（常量），而不是变量（变量）；用var修饰形参可改变
201 2.交换两个数
202 
203 */
204 
205 //1.
206 func changeCity(var loveCityName:String){
207     
208     loveCityName = "北京"
209     //    print(loveCityName)
210 }
211 
212 changeCity("上海")
213 
214 //2.交换两个数
215 //函数中任意改变形参，实参不会变
216 //MARK: 注意：要改变实参，需要传进入地址（&）,需要inout关键字---
217 func changeTwoNumber(inout number1 :Int,inout number2 :Int)->(Int,Int){//（1）
218     
219     //func changeTwoNumber(var number1 :Int,var number2 :Int)->(Int,Int){//（2）
220     
221     let tempNumber = number1;
222     number1 = number2;
223     
224     number2 = tempNumber;
225     
226     
227     return (number1,number2)
228 }
229 
230 var a = 1,b = 2
231 
232 let (x,y) = changeTwoNumber(&a, number2: &b)//（1）
233 //let (x,y) = changeTwoNumber(a, number2: b)//（2）
234 
235 //print((x,y))
236 //print("a- \(a),b - \(b)")
237 
238 
239 
240 //MARK: 给函数添加一个外部形参名，作用：在函数调用时，可以看到
241 
242 //func travelCity( cityName1:String,CityName:String, cityName3:String){//(1)
243 
244 func travelCity(firstCity cityName1:String,sencondCity CityName:String,thirdCity cityName3:String){//(2)
245     
246     //print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
247 }
248 
249 
250 //调用
251 
252 //travelCity("北京", CityName:"马尔代夫", cityName3: "巴黎")//(1)
253 travelCity(firstCity: "北京", sencondCity: "马尔代夫", thirdCity: "巴黎")//(2)
254 
255 // 简化的外部参数名：( 只需要在第一个参数名前加外部参数)
256 func travelCity1(cityName1 cityName1:String, CityName:String, cityName3:String){//(2)
257     
258     //    print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
259 }
260 
261 //调用
262 //travelCity1(cityName1: <#T##String#>, CityName: <#T##String#>, cityName3: <#T##String#>)
263 
264 
265 //MARK:-----------------函数类型-----------------
266 //MARK:1.函数类型是由，函数的参数和返回值组成
267 
268 func addFunc(number1 number1:Int,number2:Int) -> Int{
269     return number1 + number2
270 }//这个函数的类型就是  （Int,Int） ->Int
271 
272 
273 
274 //MARK:2.定义函数类型的变量：类似typeDef
275 //var tongVar :String = "string"
276 
277 var tongVar :(Int,Int)->Int = addFunc
278 
279 //print(tongVar(3,4))
280 
281 
282 //MARK:3.将函数作为参数
283 //把addFunc2作为另一个函数的参数
284 func addFunc2(number1 number1:Int,number2:Int) -> Int{
285     return number1 + number2
286 }
287 
288 //参数1- 参数名：match 参数类型：(Int,Int)->Int
289 //参数2- 参数名：number1 参数类型：Int
290 //参数3- 参数名：number2 参数类型：Int
291 
292 //func ParaFunc(match match:(Int,Int)->Int,number1:Int,number2:Int){
293 // let resultNumber1 =  match(number1,number2);
294 //    print(resultNumber1)
295 //}//(1)
296 
297 func ParaFunc(addFunc2 addFunc2:(Int,Int)->Int,number1:Int,number2:Int){
298     
299     
300     //    print(addFunc2(number1,number2))
301 }//(2)
302 
303 //调用
304 
305 //ParaFunc(match: addFunc2, number1: 2, number2: 4)//(1)
306 
307 ParaFunc(addFunc2: addFunc2, number1: 2, number2: 4)//(2)
308 
309 
310 //MARK:4函数作为返回值，返回值是一个函数类型
311 
312 func mutiFun2(number1 number1:Int,number2:Int)->Int{
313     return number1 * number2
314 }
315 
316 //定义一个函数，返回值类型是（Int，Int）->Int
317 //参数名：add  类型：Bool 返回值类型：(Int,Int)->Int
318 func selectFunc(isSelectAddFun add:Bool)-> ((Int,Int)->Int){
319     
320     
321     return add ? addFunc2 :mutiFun2;
322 }
323 
324 let result = selectFunc(isSelectAddFun: false)//result 就是函数类型，即(Int,Int)->Int
325 
326 
327 //print(result(1,2))
328 //
329 //print(selectFunc(isSelectAddFun: true)(1,2))
330 
331 //MARK：函数的嵌套
332 //func emedFun(judge judge:Bool,number:Int){
333 //    //自增函数
334 //    func addNumber(var number1:Int){
335 //        print(++number1)
336 //    }
337 //    //自减函数
338 //    func jianNumber(var number2:Int){
339 //        print(--number2)
340 //    }
341 //    //    利用bool值去判断，调用自增还是自减
342 //    let funcName = judge ? addNumber :jianNumber
343 //    //    利用参数number去调用自增或者自减
344 //    funcName(number)
345 //}
346 
347 //调用
348 
349 //emedFun(judge: false, number: 1)//在函数外层调用，对应只能调用函数外层
350 
351 
352 //MARK: 重点------闭包------
353 //类似OC中的block
354 //定义一个闭包
355 var block = { (str:String)-> Void in
356     //    block块
357     //    print(str)
358     
359 }
360 
361 //调用闭包
362 block("我爱北京天安门")
363 
364 
365 //MARK:-----------------枚举-----------------
366 /*
367 //1.枚举名首字母大写，枚举值首字母也大写
368 //2.swift的枚举和C的区别
369 2.1有case关键字
370 2.2枚举值有哈希值
371 */
372 
373 /*
374 enum City{
375 case beijing
376 case Paris
377 case NewYork
378 }
379 print(City.NewYork.hashValue)
380 
381 //3.原始值和rawValue
382 
383 enum PoneType :String{
384 case Apple = "IPhone"
385 case MI = "Mi4"
386 //    case HUAWEI = "荣耀"
387 case HUAWEI
388 }
389 
390 print(PoneType.HUAWEI.rawValue)//如果有rawValue就会打印，否则打印case后枚举值
391 
392 
393 //通过rawValue找到对应的枚举值
394 var ii = PoneType(rawValue: "荣耀")
395 
396 /*
397 //print(ii!.rawValue)//强制解析
398 print(ii?.rawValue)//可选解析
399 print(ii)//默认为可选解析
400 */
401 
402 
403 */
404 
405 
406 //MARK:相关值
407 //利用枚举的相关值结合switch-case进行值的绑定
408 
409 enum Girl{
410     case Id(Int)
411     case Info(String,Int,Double)//姓名，年龄，身高
412 }
413 
414 //进行值的绑定
415 /*
416 var girl = Girl.Info("貂蝉", 21, 165)
417 
418 switch girl {
419 case Girl.Info(var girlName,var age,var height) :
420 print("name --\(girlName)")
421 case Girl.Id(var girlID):
422 print("ID -- \(girlID)")
423 }
424 */
425 //MARK:-----------------类-----------------
426 
427 /*和OC区别：
428 
429 1.运用class关键字
430 2.没有.h .m
431 3.在同一个括号内声明属性，书写方法
432 
433 */
434 
435 //定义一个类,关键字是Class，类名首字母大写
436 class Student {
437     //类的属性（实例变量）,属性名studentAge，类型Int
438     var studentAge :Int
439     var studentName:String
440     //    给属性添加init方法，目的为给属性一个默认值
441     init(studentAge:Int,studentName:String){//一个类只能有一个init方法
442         //    给属性赋默认值
443         self.studentAge = studentAge
444           self.studentName = studentName
445     }
446 
447     //MARK:注意--类方法 （函数）
448     func printStu(){
449         print(self.studentAge,self.studentName)
450     }
451 
452 //    有参数有返回值
453     func  change(stuName:String)->String{
454     self.studentName = stuName
455     return self.studentName
456     }
457 }
458 
459 //调用该类
460 //实例化一个类对象
461 let studentItem = Student(studentAge: 26, studentName:"我饿了")
462 //属性的设置和访问
463 
464 studentItem.studentAge = 24;
465 
466 //print(studentItem.studentAge)
467 
468 //studentItem.printStu()
469 
470 //print(studentItem.change("嗯哼"))
471 
472 
473 //MARK:   ---结构体---
474 //定义一个结构体，关键字struct
475 //结构体不需要写init方法，因为它已经为我们写好了
476  struct GirlSTR {
477 //属性
478     var girlName:String
479     var girlHeight:Double
480     
 
                       
                    
                     
                      



鲜花




握手




雷人




路过




鸡蛋