视频：P1-8 日期：4.25/ 4.26/ 4.27
目录
1.查看 swift 版本：终端输入 xcrun swift -version
2.基础数据类型：Int,Float,Double,Bool,Character,String
1.Optional可选类型：var a:Int? = 10
P7：switch case 和 fallthrough穿透效果
P8：区间运算符、for in 循环、continue 和 break
P1：数据类型、变量常量、类型判断、拼接字符串
1.查看 swift 版本：终端输入 xcrun swift -version
2.基础数据类型：Int,Float,Double,Bool,Character,String
3.变量常量：var,let
var a:Int = 123
var b:String = "Hello World"
let c:Float = 2.54.类型推断
//类型推断和Python很像，就是编译器直接判断该变量/常量的类型，不需要人工确定类型。
var a = "Hello World"
var b = 12
b = 100 //可以直接更改为相同数据类型，但是常量不可更改，且都不可以更改为其他类型5.判断数据类型
//希望能打印出数据对象的类型，用type()、print()
var a = 123
type(of:a)
print(type(of:a))
print(type(of:true))6.输出语句：print()
其中，print(items:Any...)，items是参数名称，参数是Any，后面的 “...” 是可变参数。
print(a,b,c)
print("12345/nabcde")7.拼接字符串：\()语法和+号语法
利用拼接字符串把不同类型的数据对象连接在一起：
print("\(true)-\(123)+\(2.4)")
//true-123+2.48.注释
Swift注释和Java几乎一样：
//有双斜杠注释，单行注释
/*这是
多行注释
*/P2：类型别名、类型转换
1.类型别名
typealias意思就是“type类型alias别名”。
typealias dog = Int
//即dog也就是Int的另一个名字，可以直接：
var a:dog = 10
var n:Int = 20
print(a,b)
//10,20
typealias S = String
//即S也就是String的另一个名字，可以直接：
var c:S = "hello"
var d:String = "world"
print(c,d)
//hello world2.类型转换
类型()
var a = 10
let b = false
//先定义两个变量，接下来进行类型转换：
print("we can get : "+ String(a))
//we can get : 10
print("we can get : "+ String(b))
//we can get : false
print("we can get : "+ String(1.5))
//we can get : 1.5
print("we can get : "+ String(true))
//we can get : true??语法
//将其他类型转换为字符串类型很容易，但字符串不能随意转为其他类型：
var a = "abc"
var b = "123"
var c = Double(a) ?? 100
print(Int(a))
//无法转换，报错Error
print(Int(b))
//Optional(123)
//可以转换，但会有Optional(可选类型)，Optional函数在后面章节讲到
print(Int(a) ?? 100) //意思是转换a为整型，如果无法转换的话就取？？后面的值
//100
print(c) //同样无法转换，只不过？？语法写在了前面
//100
其他转换：
print(Int(100.5))//转整型取前面的整数
//100
print(Double(10))
//10.0
print(Bool(0))//只要非零都是true
//falseP3:可选类型和解析值
1.Optional可选类型：var a:Int? = 10
var a:Int? = 10
var b:Int? = nil //nil是空的意思
/*？语法的意思就是不确定等号后面有真实值，a/b是可选类型，可以是10也可以是空*/
print(a)
print(b)
//Optional(10)
//nil
print(a ?? 0) //如果a有值，那就输出a，否则输出0
print(b ?? 100) //如果b有值不为空，那就输出b，否则输出100
//10 因为a不为空，但输出不再是Optional(10),而就是确定的10
//100 因为b为空，所以输出100
2.解析值
/*如果确定有真实值，可以用！语法进行解析*/
print(a!)
print(b!)
//10 因为a有真实值，强行解析得到真实值
//报错Error 因为b没有真实值，是空，强行解析就会报错例子：
var a:Int？ = 10
if(a == nil)
{
print("a没有值")
}
else
{
print("a的值 = \(a!)") /*这里要用！解析，否则出来就带有Optional*/
}
//a的值 = 10P4：元组类型
元组可以封装很多类型，包括Int，String，Bool。在定义元组时可以不明确定义类型。
1.定义元组
var c:(Int) = ()
//报错Error：定义了类型必须有值
var d = ()
//不报错2.打印元组的值
var a:(Int,String) = (10,"swift") //明确定义类型
var b = (1,1.4,"hello",true) //自动判断类型，类型推断
/*打印值，元组的索引和python不一样*/
print(a.0)
print(a.1)
//10
//swift
print(b.0)
print(b.1)
print(b.2)
//1
//1.4
//hello3.修改元组的值
/*可以修改变量元组的值*/
print(b.0)
//1
b.0 = 100
print(b.0)
//100
/*不能修改常量元组的值*/
let d = (1,"123")
d.0 = 3
//报错Error元组是值传递，不是引用，copy后不改变原值。
4.类字典索引
//第一种
var e = (name1:"hello",name2:true)
print(e.name1) //直接通过键来索引值
//hello
//第二种
var e:(name1:Int,name2:String) = (100,"hello")
print(e.name1)
//1005.对应值索引
let (n1,n2) = ("hello", 2)
print(n1)
print(n2)
//hello
//2
//如果对应个数不对会报错，例如：
let (n1,n2) = ("hello",true,2)
//报错Error
//但可以用下划线_来忽略掉该值
let (n1,_,n2) = ("hello",true,2)
print(n1,n2)
//hello 2P5:基础运算符
1.基本运算符
加法：+
减法：-
乘法：*
除法：/
求余：%
赋值：=
2.比较运算符
等于：==
不等：!=
大于：>
小于：<
大于等于：>=
小于等于：<=
3.逻辑运算符
逻辑与：&&
逻辑或：||
逻辑非：!
4.三元运算符(a为真取b值，a为假取c值）
a ? b : c
var a:Int? = 100
var value=a != nil ? a!:0
/*将值赋给value，看a是否为空，若不为空则a为a的解析值，否则为0*/
print(value)
//1005.合并空值运算符（取可选类型的值)
??
var a:Int? = 100
var value = a ?? 0
print(value)
//1006.区间运算符（很重要）
7.其他操作说明
1>减号放前面表示负数：-8，-9，-45
2>感叹号放Bool值前面表示取相反值：!true=false; !false=true
3>感叹号放在可选类型后面表示解析值，在可选类型的知识点里：
var a:Int ? = 20; print(a!)
4>a=a+b可以写成a+=b,包括-=，*=，/=
5>没有i++，i--这种运算
6>===和!==来判断两个引用是否相等，在类和对象的知识点里。
8.运算符优先级
P6: if 语句、可选项绑定、隐式展开
1.if 语句
var a = ("world",234)
var b = ("hello",234)
if (a == b)
{
print("a == b")
}
else
{
print("a != b")
}2.可选项绑定
var a:Int? = 10
if let value = a //注意这里的可选类型a没有加！解析值
{
print("value的值= \(value)") //如果a有值就打印
}
else
{
print("没有值")
}
//value的值= 10
var b:String? = nil
if var value = b
{
print("value的值= \(value)")
}
else
{
print("b没有值")
}
//b没有值
3.隐式展开
如果明确了可选类型是有值的，那么每次就不用用！来解析值，而是直接在定义变量的时候用！标记。这样在下面再使用value的时候，就不用！解析值了。
var value:String! = "hello world"
var value2:String = value
/*value2是可选类型，但没有用！解析值，直接将value的值赋给value2*/
print(value2)
//hello world
var a:Int! = nil
var b:Int = a
print(b)
//报错Error，没值会报错
var a:Int! = nil
var b = a //没有给b定义类型
print(b)
//nil
/*不会报错，因为没有给b定义类型，直接是nil空值看似多此一举，但在改变值的情况下就会报错，所以需要进行！解析
var a:Int = 100
a = nil
print(a)
//报错Error
//普通类型在任何情况下都不能没有值
var a:Int! = 100
a = nil
print(a)
//nil
//不会报错P7：switch case 和 fallthrough穿透效果
1.switch case （默认没有穿透效果）
var a = "b"
switch a
{
case "a","b","c":
print("1")
case "e","f":
print("2")
default:
print("没有匹配")
}
//1
/*这样的匹配只要a的值在case后面以逗号分隔的里面就行*/区间运算符知识点
var a = 10
switch a
{
case 1..<5: //意思就是看a是否在1，2，3，4的范围里
print("1")
case 5..<10:
print("2")
default:
print("没有匹配")
}
//没有匹配where知识点
var value = (10,20)
switch value
{
case let(name1,name2) where name1 < name2: //where是判断name1是否小于name2
print("name1 = \(name1)")
print("name2 = \(name2)")
case var(10,name3): //var会有警告，一般用let()
print("name3 = \(name3)")
default:
print("others")
}
//name1 = 10
//name2 = 202.fallthrough穿透效果
/*1.无穿透效果,按顺序*/
var value = 20
switch value
{
case 10:
print("1")
case 20:
print("2")
default:
print("其他")
}
//2
/*2.有穿透效果,1个fallthrough向下穿透一个case*/
var value = 10
switch value
{
case 10:
print("1")
fallthrough
case 20:
print("2")
default:
print("其他")
}
//1
//2
/*2个fallthrough依次向下穿透*/
var value = 10
switch value
{
case 10:
print("1")
fallthrough
case 20:
print("2")
fallthrough
default:
print("其他")
}
//1
//2
//其他
/*1个fallthrough没有连接起来就不会穿透了*/
var value = 10
switch value
{
case 10:
print("1")
case 20:
print("2")
fallthrough
default:
print("其他")
}
//1P8：区间运算符、for in 循环、continue 和 break
1.区间运算符
表示数值的范围
var a = 1...4
print("the range is \(a)")
//1...4
var b = 1..<4
print("the range is \(b)")
//1..<4
var c = 1...
print(c)
//PartialRangeFrom(lowerBound: 1)
/*要注意的就是3个.和2个.的区别*/
2.for in 循环
单间隔循环
for i in 1...4
{
print(i)
}
/*
1
2
3
4
*/
for i in 1..<4
{
print(i)
}
/*
1
2
3
*/多间隔循环:调用 stride(from,through,by) 函数
for i in stride(from:0,to:10,by:2) //to不包括结尾
{
print(i)
}
/*
0
2
4
6
8
*/
for i in stride(from:0,through:10,by:2) //through包括结尾
{
print(i)
}
/*
0
2
4
6
8
10
*/反向遍历，调用.reversed()函数。
for i in (0...5).reversed()
{
print(i)
}
/*
5
4
3
2
1
0
*/
for i in stride(from:0,through:10,by:2).reversed() //through包括结尾
{
print(i)
}
/*
10
8
6
4
2
0
*/注意是先遍历再反过来，所以to还是不包括结尾，不能弄反。
for i in stride(from:0,to:10,by:2).reversed() //through包括结尾
{
print(i)
}
/*
8
6
4
2
0
*/
for i in stride(from:20,to:10,by:-2).reversed() //through包括结尾
{
print(i)
}
/*
12
14
16
18
20
*/
//都没有包括103.continue 和 break（和其他编程语言相同)
continue 用于跳过本次循环，执行下一次循环。
for i in 1...5
{
if (i == 2)
{
continue //跳过
}
print(i)
}
/*
1
3
4
5
*/break 用于结束当前整个循环，如果有循环嵌套，只影响自己的循环，不影响其他外面的循环。
//单循环
for i in 1...5
{
if (i == 2)
{
break
}
print(i)
}
/*
1
*/
//嵌套循环
for i in 0...2
{
print("外部循环=\(i)")
for j in 0...2
{
if (j == 1)
{
break
}
print("内部循环=\(j)")
}
}
/*
外部循环=0
内部循环=0
外部循环=1
内部循环=0
外部循环=2
内部循环=0
*/
扫一扫
832
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
