Swift - 1 (常量、变量、字符串、数组、字典、元组、循环、枚举、函数）

Swift 中导入类库使用import，不再使用<>,导入自定义不再使用""

import Foundation

1> 声明变量和常量

  • 在Swift中使用 "let" 修饰一个常量，使用 "var" 修饰一个变量;
  • let修饰常量的值是不可以更改的；
  • var修饰的变量的值是可以更改的；
  • 在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。
  • Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断。
 1 //MARK: - 定义常量、变量
 2 // 定义常量（使用完第一次就不能修改他的值了）
 3 // 用let最好给定初始值，因为使用一次不能在修改
 4 let myGender = "♂"
 5 //myGender = "男"
 6
 7 // 定义变量
 8 var carName = "BMW"
 9 carName = "Audi"
10 print(carName)    // 加不加引号都可以
11
12 //MARK: - 定义常量变量：变量类型的隐式转换
13 // 在swift中如果定义常量变量不给定相关的类型，它会隐式转换成你给定的初始值
14 let name = "Rose"    // 如果这样自定义出来一个常量，它会隐式转换成string类型
15 let name1 : String = "Jack"   // 如果给定类型，后边赋值的时候需要根据类型进行赋值
16
17 let age : Int = 18   // 如果定义常量最好给初始值，定义变量可以不给初始值
18
19 var age1 : Int?    // ? 表示age1 的类型为可选类型，其值可以为空
20 print(age1)
21
22 var char : Character =  "a"  // 赋值字符类型的时候仅需一个字母即可
23
24 // 定义一个BOOL类型的变量 [在swift中 bool类型只有true or false]
25 var flag : Bool = true

2> 字符串

  • String是有序的字符集合
  • Swift中的字符串通过String类型表示，当然也可以看成Character字符类型的集合
  • \(变量名)输出相关内容【插入式取值】
 1 //MARK: - 字符串string
 2 //(1)创建一个空字符串
 3 var str_empty = ""
 4 var str1_empty = String()
 5
 6 //(2)判断一个字符串为空字符串
 7 if str_empty.isEmpty{
 8     print("str_emrty is empty")
 9 }
10
11 //(3)字符串的拼接
12 var str_url = "http://"
13 var str = "www.baidu.com"
14
15 let str_new_url = str_url + str
16 print(str_new_url)
17 print("百度网址：\(str_new_url)")   //  \（变量名）输出相关的内容【插入式取值】
18
19 //(4)获取字符串的长度
20 var str1 : String = "abcde"
21 print(str1.characters.count)
22
23 //(5)字符串的比较
24 var str2 = "MBBoy"
25 var str3 = "GBLW"
26
27 if str2 != str3 { // == 相等   != 不相等
28     print("这两个不相等")
29 }

3. 数组、字典

　1> 数组

 1 //MARK: - 数组
 2 //Swift 中数组的元素类型必须相同
 3 //定义一个数组
 4 var nameArray = ["yuanyuan","GBLW","WYW"]
 5 print(nameArray)
 6
 7 var nameArray1 : Array<String> = ["YaQian","ZhaTian"]
 8 print(nameArray1)
 9
10 //定义一个空数组(字符串)
11 let array : Array = Array<String>()
12 print(array)
13
14 //访问数组的元素
15 print(nameArray[1])
16
17 //向数组中添加元素
18 var int_array = Array<Int>()
19 int_array.append(520)
20 int_array.append(123)
21 print(int_array)
22
23 //使用运算符添加数组元素
24 int_array += [100]
25 //使用运算符添加多个数组元素
26 int_array += [111,222]
27 print(int_array)
28
29 //插入元素到具体位置
30 int_array.insert(521, atIndex: 1)
31 print(int_array)
32
33 //移除某个元素
34 int_array.removeAtIndex(3)
35 print(int_array)
36
37 // 移除所有元素
38 int_array.removeAll()
39 print(int_array)

2> 字典

 1 //MARK: - 字典
 2 //定义一个字典类型的变量
 3 var dic : Dictionary<String,Int> = ["a":18,"b":16,"c":38]
 4 print(dic)
 5
 6 //定义空字典
 7 var dic1 : Dictionary<String,Int> = [:]
 8 print(dic1)
 9 var dic2 = Dictionary<String,Int>()
10 print(dic2)
11
12 //向字典里添加键值对
13 dic["d"] = 30
14 print(dic)
15
16 //修改字典中的内容（根据键值去修改）
17 dic["a"] = 90
18 print(dic)
19 //打印某个元素的值
20 print(dic["a"])
21
22 //删除字典中的内容(根据键去删除)
23 dic.removeValueForKey("c")
24 print(dic)

4. 元组

 1 //MARK: - 元组
 2 //定义一个元组
 3 //方法一：直接初始化一个元素（使用Swift隐式转换的特点）
 4 let tuples = ("苹果",["iOS","html5","Android"])
 5 print(tuples)
 6 //方法二：显示初始化的方式
 7 let tuples1 : (String,Array) = ("安卓",["iOS","html5","Android"])
 8 print(tuples1)
 9
10 //可变元组和不可变元组
11 var superTuples = (name:"asd", 12, ["111", "222"])
12 superTuples.name = "qwe"
13 print(superTuples.name)  //会打印name变成qwe
14
15 //let superTuples = (name:"asd", 12, ["111", "222"])
16 //superTuples.name = "qwe"
17 //print(superTuples.name)  //会报错
18
19 ////需要注意的是，可变元组虽然可以修改数据，但却不能改变其数据的数据类型：
20 //var superTuplesType = (name:"asd", 12, ["111", "222"])
21 //superTuplesType.name = 1
22 //print(superTuples.name)  //会报错
23
24 //取出元组中的值
25 //第一种取值方式：直接把元组赋值给另外一个常量，根据相关的标记进行取值
26 let tuples_new : (appStyle:String,course:Array) = tuples
27 var classInfo = tuples_new.appStyle + tuples_new.course[0] + tuples_new.course[1] + tuples_new.course[2]
28 print(classInfo)
29
30 //第二种取值方式：直接根据下标进行取值
31 let classInfoNew = tuples_new.0 + tuples_new.1[0] + tuples_new.1[1] + tuples_new.1[2]
32 print(classInfoNew)

5. 循环结构

　1> 概述

　　Swift里面的循环结构包含：for、for-in、while、repeat-while

　2> 循环

 1 //MARK: - 循环
 2 //第一种形式：
 3 for var i = 1; i < 10; i++
 4 {
 5     print(i)
 6 }
 7
 8 // 第二种形式
 9 // 1到9
10 for number in 1..<10
11 {
12     print("number:\(number)")
13 }
14
15 //第三种形式
16 // 1到10
17 for number in 1...10
18 {
19     print("number:\(number)")
20 }
21
22 //while循环和repeat...while
23 var i = 8
24 while i > 0
25 {
26     i--
27     print(i)
28 }
29
30 repeat
31 {  // 限制性一次循环体，在进行相关的循环
32     print("woaini")
33 }while 1 < 0
34
35 //使用循环遍历数组
36 var animalArray = ["cat","dog","tiger","monkey","fish"]
37 for animal in animalArray
38 {
39     print(animal)
40 }
41
42 //使用循环遍历字典
43 var animalDic = ["pig":"??","dog":"??","fish":"??"]
44 for (key,value) in animalDic
45 {
46     print("key: \(key), value: \(value)")
47 }

6. 分支结构

1> if分支结构

2> switch结构

　　在Swift里面，switch的每个case后面会自动的添加一个break，所以不需要手动的去添加了。Swift里面的枚举是可以范围枚举的，系统会根据给定的数据自动的匹配相近的范围

 1 //MARK：- 分支结构（if结构和switch格式）
 2 //if形式的
 3 let flag1 = true
 4 if flag1 == true
 5 {
 6     print("我是真的")
 7 } else {
 8     print("不可描述")
 9 }
10
11 print("=====================================================")
12 //特点1：switch形式的使用fallthrough实现贯穿每种可能
13 let value = 0
14 switch value
15 {
16 case 0:
17     print("0")
18     fallthrough
19 case 10:
20     print("10")
21     fallthrough
22 default:
23     print("other")
24 }
25
26 //特点2：case后可以使用一个范围
27 switch value
28 {
29 case 0..<10:
30     print("0 到 9")
31 case 10...100:
32     print("10 到 100")
33 default:
34     print("other")
35 }
36
37 //特点3：case后可以使用（let和var修饰的常量或者变量）where是满足某种条件
38 switch value
39 {
40 case var i where value >= 0 && value < 6:
41     i = 99
42     print(i)
43 default:
44     print("other")
45 }
46
47 //特点4：case后还可以匹配一个元祖
48 let point = (10,10)
49 switch point
50 {
51 case (10,0):
52     print("111111")
53 case (10,8):
54     print("222222")
55 case (_,10):    // 横杠代表可以忽略某个元素
56     print("333333")
57 case (10,10):
58     print("444444")
59 default:
60     print("other")
61 }

注意：

  • 不需要添加break关键字，也不会贯穿
  • 添加fallthrough，可以实现贯穿
  • switch要求每个分支必须包含代码

7. 枚举

　1> 概述

  • C 语言中，枚举类型将枚举名和一个整型值相对应。
  • Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个确定的值。
  • 如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。

　2> 代码

 1 //MARK: - 枚举（enum）
 2 //枚举原始类型为int类型
 3 enum Direction:Int
 4 {
 5     case east = 0
 6     case west = 1
 7     case south = 2
 8     case north = 3
 9 }
10
11 print(Direction.east.rawValue) // rawValue 就是找到相对应枚举的原始值
12 //枚举原始类型为string类型
13 enum season:String
14 {
15     case spring = "春天"
16     case summer = "夏天"
17     case autumn = "秋天"
18     case winnter = "冬天"
19 }
20
21 print(season.autumn.rawValue)
22
23 //根据原始值获取枚举的类型
24 print(Direction(rawValue: 2))

8. 函数

1> 概述

  • Swift里面用 func 表示声明一个函数。
  • Swift的文件格式里面没有类似于OC的.h文件。所以，如果需要定义一个私有的函数，可以在func前面添加private 修饰。

　2> 函数定义格式

　　func 函数名（参数名：参数类型，参数名：参数类型....）->返回值类型 {
　　　　函数实现
　　　　return 返回值
　　}

　3> 函数类型 五种

//MARK: - 函数
//表示函数的关键字 func
//函数的类型有：五种

//1:无返回值，无参数
func function1() ->Void
{
    print("无返回值，无参数")
}
function1()

//2:无返回值，有参数
func function2(name str:String) ->Void
{
    print("无返回值，有参数 = \(str)")
}
function2(name: "GBLW")

//3:有返回值，无参数
func function3() ->String
{
    print("有返回值，无参数")
    return "炸天"
}
print(function3())

//4:有返回值，有参数
func function4(num1:Int, num2:Int) ->Int
{
    print("有返回值，有参数")
    return num1 + num2
}
print(function4(6, num2: 9))

//5：函数返回值为元组类型的
func function5(num1:Int, num2:Int) ->(Int,Int,Int)
{
    return (num1+num2, num1-num2, num2*num1)
}
print(function5(7, num2: 6))

3> 外部参数和内部参数

  • Swift中，一个参数有两个名字，内部参数名和外部参数名
  • 内部参数名：在函数内部使用的参数名称。
  • 外部参数名：在函数调用时候，显示的参数名称
1 //外部参数和内部参数
2 //first、second就叫做外部参数：在函数调用的时候会显示出来这两个名称
3 //one、two内部参数：在函数内部使用的
4 //默认的情况下，第一个外部参数在调用的时候不显示，其余的均显示，而且和你定义的名字一样
5 func function6(first one:Int, second two:Int)
6 {
7     print((one,two))
8 }
9 function6(first: 10, second: 2)

4>函数的嵌套

 1 //函数的嵌套
 2 func test1()
 3 {
 4     func test2()
 5     {
 6         func test3()
 7         {
 8             print("哈哈，我穿了好多层")
 9         }
10         test3()
11     }
12     test2()
13     print("哈哈，好有意思")
14 }
15 test1()

5> 忽略外部参数

  • 默认情况下，函数的第一个参数，不显示外部参数名，其余参数，显示外部参数名，并且和内部参数名一致
  • 如果不想要显示外部参数名，可以使用“_”忽略掉
  • 注意：函数的第一个参数不能使用“_ ”忽略掉外部参数名。
1 //若果都不想显示外部参数  "_"的作用是忽略外部参数
2 func function7(one:Int,_ two:Int)
3 {
4     print("忽略外部参数")
5 }
6 function7(8, 8)

6> inout参数

　　inout参数:

　　　参数默认是用let修饰,即常量

　　　在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.

　　　如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.

 1 //inout修饰的参数
 2 func test(inout name:String)
 3 {
 4     name = "girl"
 5     print(name)
 6 }
 7 var myName = "yuanyuan"
 8 print("myName = \(myName)")
 9 test(&myName)
10 print("myName = \(myName)")
11
12 func admin (var name:String)
13 {
14     name = "lol"
15     print("nameOld = \(name)")
16 }
17 var lolName = "LOL"
18 print("lolName = \(lolName)")
19 admin(lolName)
20 print("lolName = \(lolName)")
时间： 2024-11-08 09:11:21

Swift - 1 (常量、变量、字符串、数组、字典、元组、循环、枚举、函数）的相关文章

Swift基础语法（常量变量、数据类型、元组、可选、断言等）

Swift 是 iOS 和 OS X 应用开发的一门新语言.然而,如果你有 C 或者 Objective-C 开发经验的话,你会发现 Swift 的很多内容都是你熟悉的. Swift 的类型是在 C 和 Objective-C 的基础上提出的,Int是整型:Double和Float是浮点型:Bool是布尔型:String是字符串.Swift 还有两个有用的集合类型,Array和Dictionary,请参考集合类型. 就像 C 语言一样,Swift 使用变量来进行存储并通过变量名来关联值.在 Sw

字符串常量与字符串数组区别

在论坛上看到过有人说字符串常量存储在只读区域,不能写只能读: 而字符数组是栈上,可读可写. #include<stdio.h> #include<stdarg.h> int main(){ /*字符数组存储于动态内存中,可以进行赋值操作*/ char message[]={'h','e','l','l','\0'}; message[2]='a'; printf("%s\n",message); /*指向字符数组的指针也可以对内存进行操作*/ char *p=m

Swift学习—字符串&amp;数组&amp;字典

字符串 OC和Swift中字符串的区别 在OC中字符串类型时NSString,在Swift中字符串类型是String OC中字符串@"",Swift中字符串"" Swift中String是第一个结构体,性能更高 String支持直接遍历 Swift提供了String和NSString之间的无缝转换 字符串的使用 用反斜线 \ 和小括号 () 做字符串插值(把常量\变量插入到字符串中) let hand = 2var age1 = 20let string1 = &q

Swift学习--常量.变量.数据类型的使用(二)

一.Swift中的数组 //Swift中的数组 //NSArray *arr = @["",""]; //和OC数组的区别就是去掉前面的@ let arr11 = ["zhangsan", "lisi"] print(arr11) // 遍历每一个元素 for a in arr11 { print(a) } // 像 OC 一样打印 print(arr11 as NSArray) // 数组中保存的都是字符串 let arr

字符串 数组 字典 日期 数学常用方法

创建空字符串,给予赋值. NSString *astring = [[NSString alloc] init]; astring = @"This is a String!";   使用变量初始化 NSString *name = @"Ivan!"; NSString *astring = [[NSString stringWithFormat:@”My name is %@!”,name]];  判断是否包含某字符串 检查字符串是否以另一个字符串开头 - (BO

Swift学习--常量.变量.数据类型的使用(一)

一.Swift中的常量和变量 /* Swift 中定义常量和变量用let/var let 代表定义一个常量 var 代表定义一个变量 Swift 中代表定义常量和变量不需要写数据类型,编译器辉根据我们后面数据的真实类型自动推导 Swift开发技巧:在做Swift开发中,我们需要经常使用option + click键来查看方法或变量 **/ //常量 let num = 10.1 //num = 9.0 //常量不能修改 //变量 //注意点: Swift开发中每一条语句后面可以不写分号,但是写上

JavaScript系列二：变量、数组、流程控制、函数以及事件响应

JavaScript入门内容的复习:JavaScript入门 输出内容 document.write("xxx"); 弹出警告窗口 alert("xxx"); 弹出确认窗口 confirm("xxx"); 弹出提问窗口 prompt("xxx"); 单行注释 // 多行注释 /* */ 函数语法格式 function xxx() { xxxx; } 引入JS外部文件的方式 <script src="xx.js&

Swift(上) 常量, 变量, 数据类型, 循环, 选择结构 简单函数

本篇内容是在XCode的Playground下编写的 那么什么是Playground呢? 提到Playground我们就不得不提Swift这个最近苹果公司力推的语言, Swift是苹果公司在WWDC2014上发布的全新开发语言.从演示视频及随后在appstore上线的标准文档看来,语法内容混合了OC,JS,Python,语法简单,使用方便,并可与OC混合使用. Xcode 6 对 Swift 有着全面深入的支持.你可以利用 100% Swift 代码创建全新的 app,或者将新的 Swift 代

写入文件 (字符串/ 数组 / 字典)

获取文件路径- (NSString *)getFilePath{         2.获取所要存储的文件路径           (1)获取Documents文件夹路径             NSDocumentDirectory 用来获取指定文件夹的路径             NSUserDomainMask 设置查找的域,我们的自己的文件都是存储在用户域的             @param yes 是否使用详细路径(绝对路径)             @return 因为最初该方法是

读取文件 (字符串 / 数组 / 字典)

获取文件路径- (NSString *)getFilePath{         2.获取所要存储的文件路径           (1)获取Documents文件夹路径             NSDocumentDirectory 用来获取指定文件夹的路径             NSUserDomainMask 设置查找的域,我们的自己的文件都是存储在用户域的             @param yes 是否使用详细路径(绝对路径)             @return 因为最初该方法是