篇文章主要介绍: 常量 变量, 数组 字典, 元祖, 循环结构 分支结构, 函数
定义常量
// 输出语句
print("Hello, World!")
// 使用let定义一个常量,不能重新赋值
// Swift支持隐式类型推断,可以根据初值,自动的判断Swift的数据类型
let a = 10
let b : String = "nihao"
let c = 20.1
// Swift不支持隐式类型转换,不能让两个不一样的数据类型做四则运算 (需要强转)
//let d = a + c // 错误
// Swift强转的格式:数据类型(需要强转的数据)
let d = Double(a) + c
// 可以用中文/表情符号做变量名
let 迟到的 = "做俯卧撑"
let 😢 = "哭"
// Swift里面支持运算符的重载,会根据语境自动判断运算符的含义
let str1 = "abc"
let str2 = "def"
let str = str1 + str2
print(str)
定义变量
// Swift里使用var定义一个变量
var a = 10
a = 100
// 如果要定义一个初值为nil的变量的话,先指定数据类型, 格式: var + 变量名 + ":" + 变量类型? = nil
// 拆包
var b : String? = nil
数组
// Swift数组里面的数据类型必须是一样的
// 定义一个数组
let array = [1,2,3,"a"] // AnyObject Swift1.0版本 , NSObject Swift2.0版本
// 数组初始化的第二种方式,先指定数据类型
let array1 : [Int] = [1,2,3]
// 定义一个空的数组
let array2 : [Int] = []
// 定义Int类型变量数组
var array = [1,2,3,4,5]
// *** 数组的 增 删 改 查 ***
// 1. 数组的查
// 直接通过下标
print(array[1])
// 2. 数组的增
// (1).在某个位置插入一条新数据
array.insert(10, atIndex: 2)
// (2).在某个位置插入一条新数组
var array1 = [10,11,12,13]
array.insertContentsOf(array1, at: 2)
print(array)
3. 数组的删
// 删除数据的同时,保存内存空间
// Swift里面的Bool是一个枚举,只有true和false两种参数
array.removeAll(keepCapacity: true)
// 删除一个范围
let range : Range = Range(start: 0, end: 2)
array.removeRange(range)
print(array)
4. 数组的改
array[1] = 10
print(array)
5. 数组的拼接
使用运算符重载
var array2 = [6,7,8,9,10]
var array3 = array + array2
print(array3)
字典
// 创建数组的两种方式, Swift1.0这种方法不存在
// 任意类型
let dictionary2 = [1 : 2, 3 : 4, "a" : "b"]
// 指定类型
// Swift的字典里面 所有的key 所有的value都必须是同一种类型
let dictionary1 : [Int : String] = [1 : "a", 2 : "b"]
var dictionary = [1 : 2, 3 : 4, 5 : 6]
print(dictionary)
// 1. 字典增加
// 给不存在的key值赋值,代表增加的操作
dictionary[7] = 8
print(dictionary)
// 2. 字典改
// 直接根据key修改
dictionary[1] = 100
print(dictionary)
// 3. 字典的删
// 根据下标删除
dictionary.removeValueForKey(1)
// 直接赋空也可删除
dictionary[5] = nil
print(dictionary)
// 4. 字典的查
print(dictionary[3])
元组
// 使用() 表示定义一个元组,元组里面没有具体数据类型的概念
// 整体的数据结构有点类似于C语言里面的结构体
let type = ("八戒", "DHM")
// 访问元组的第一个方法 通过下标
print(type.0)
// 访问元组第二种方式 通过key值
let type2 : (name : String, nickName : String) = type
print(type2.name)
循环结构
// 1. for循环
let array = [1,2,3,4]
// 注意: 条件可省略括号() i++不能有空格
for var i = 0; i < array.count; i++ {
print("i = \(i)")
}
// 2. while循环
var i = 0
while i < 10 {
i++
print(i)
}
// 3. repeat while 和 do while一样
// Swift1.0版本的时候叫do while, Swift2.0版本的时候叫repeat
var i = 0
repeat{
i++
print(i)
}while i < 10
// 4. for in
let array = [1,2,3,4,5]
for var a in array{
print(a)
}
分支结构
// 1. if else
var timer : String? = nil
if timer != nil {
print("timer存在")
} else {
print("timer不存在")
}
// 2. switch (比if运行快) 可不写break
// (1)
let value = 0
switch value {
case 0:
print(value)
case 1:
print(value)
default:
print("超了")
}
// (2) 根据区间判断
// 0...10 表示的是 从0开始到10结束, 并且包含10
// 0..<10 表示的是 从0开始到10结束, 但不包括10
switch value {
case 0...10:
print(value)
case 11...20:
print(value)
default:
print("又超了")
}
// (3) 根据元祖判断
// "_" 表示忽略
let point = (10, 10)
switch point {
case (10, 10):
print(point)
case (_, 10):
print(point.0)
case (10, _):
print(point.1)
case (_, _):
print(point)
}
// (4) 添加新的条件
let value = 0
let value1 = 100
switch value {
case 0 where value1 < 10:
print(value)
case 0 where value1 > 10:
print("正确")
default:
print("错误")
}
函数
// 函数分类
// 1.无参无返回值
// 2.无参有单个返回值
// 3.无参有多个返回值
// 4.有参无返回值
// 5.有参有单个返回值
// 6.有参有多个返回值
// 7.inout函数
// 8.嵌套函数
// 1. 无参无返回值
// func(关键字) test(函数名) "()"(参数列表) -> Void(返回值类型){}
// ->Void 可以省略
func test () -> Void {
print("我是第一个函数,无参无返回值")
}
// 调用
test()
// 2. 无参有返回值
func test2() -> String {
return "我是第二个函数,无参有返回值"
}
// 接收函数的返回值
let str = test2()
print(str)
// 返回一个Int类型数组
func test3() -> Array {
return [1,2,3]
}
// 返回一个OC数组
func test4() -> NSArray {
return [1,2,"a","b"]
}
// 3. 有参无返回值
// 参数格式 (参数名 + ":" + 参数类型)
func test5(name : String, sex : String) {
print("我叫\(name),我的性别是\(sex)")
}
// 调用
test5("罗峰", sex: "未知")
// 参数是一个数组格式 (参数名 + ":" + Array)
func test6(phoneNumber : Array){
print(phoneNumber)
}
test6([2,3,4])
// 4. 有参有返回值
func test7(name : String) -> String{
return name
}
let str7 = test7("八戒")
print(str7)
// 5. 无参有多个返回值
func test8() -> (String,String) {
return ("八戒","20")
}
let type8 = test8()
print(type8.0)
// 6. 有参有多个返回值
func test9(name : String, age : Int) -> (String,Int){
return (name,age)
}
let 猪 = test9("八戒", age: 10)
print("你是\(猪.0)", "今年\(猪.1)岁")
// 7. inout函数
// Swift函数里面的参数 默认是使用let修持的,是不可以更改的 如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值
func test10(inout number : Int) {
number = 100 // 修改值
}
var a = 5
test10(&a) // 传地址
print(a)
// 8. 函数嵌套
// 第一层
func test11() {
// 第二层
func test12() {
// 第三层
func test13() {
// 第四层
func test14() {
// 第五层
func test15() {
// 第六层
func test16() {
// ....可以无限定义下去
}
}
}
}
}
}
