【Swift编程基础】P1-8

59 阅读 0 评论 39 点赞

我是靠谱客的博主爱笑手机，最近开发中收集的这篇文章主要介绍【Swift编程基础】P1-8，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

视频：P1-8 日期：4.25/ 4.26/ 4.27

P1：数据类型、变量常量、类型判断、拼接字符串

1.查看 swift 版本：终端输入 xcrun swift -version

2.基础数据类型：Int,Float,Double,Bool,Character,String

3.变量常量：var,let

4.类型推断

5.判断数据类型

6.输出语句：print()

7.拼接字符串：()语法和+号语法

8.注释

P2：类型别名、类型转换

1.类型别名

2.类型转换

P3:可选类型和解析值

1.Optional可选类型：var a:Int? = 10

2.解析值

P4：元组类型

1.定义元组

2.打印元组的值

3.修改元组的值

4.类字典索引

5.对应值索引

P5:基础运算符

1.基本运算符

2.比较运算符

4.三元运算符(a为真取b值，a为假取c值）

5.合并空值运算符（取可选类型的值)

6.区间运算符（很重要）

7.其他操作说明

8.运算符优先级

P6: if 语句、可选项绑定、隐式展开

1.if 语句

2.可选项绑定

3.隐式展开

P7：switch case 和 fallthrough穿透效果

1.switch case （默认没有穿透效果）

2.fallthrough穿透效果

P8：区间运算符、for in 循环、continue 和 break

1.区间运算符

2.for in 循环

3.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.5

4.类型推断

//类型推断和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.4

8.注释

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 world

2.类型转换

类型()

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
//false

P3:可选类型和解析值

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的值 = 10

P4：元组类型

元组可以封装很多类型，包括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
//hello

3.修改元组的值

/*可以修改变量元组的值*/
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)
//100

5.对应值索引

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 2

P5:基础运算符

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)
//100

5.合并空值运算符（取可选类型的值)

var a:Int? = 100
var value = a ?? 0
print(value)
//100

6.区间运算符（很重要）

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 = 20

2.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("其他")
}
//1

P8：区间运算符、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
*/
//都没有包括10

3.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
*/