swift基本语法
应用程序需要引入
import Cocoa。ios需要引入import UIKit。Swift不要求在每行结尾使用分号，但在同一行书写多条语句时，必须用分号隔开
数据类型
Int,UInt,Float,Double,Bool,String,单个字母：Character,可选类型：Optional,类型别名：typealias
变量的定义
var variableName= <intial value>
var varA = 40
print(varA)
var varB:Float = 3.1415
var varC = "hello"
//字符串
var stringA = "Hello,World!"
var stringB = String("Hello")
var stringC = stringA + stringB
var stringD = stringA.append(stringB)
if stringS.isEmpty{
}
print("\(stringC.count)")
//遍历字符串中的字符
for ch in "Runoob".characters {
print(ch)
}
常量的定义
常量需要以字母或下划线开始
let constantName = <initial value>
let constA=40
let constB:Float = 3.14159类型转换
//字符串转整型
let myString: String = "256"
let myInt: Int? = Int(myString)
//分割字符串
let fullName = "sf|ff|ss"
let fullNameArr = fullName.characters.split{$0 == "|"}.map(String.init)枚举的定义
// 定义枚举
enum DaysofaWeek {
case Sunday
case Monday
case TUESDAY
case WEDNESDAY
case THURSDAY
case FRIDAY
case Saturday
}
enum Student{
case Name(String)
case Mark(Int,Int,Int)
}
var studDetails = Student.Name("Runoob")
var studMarks = Student.Mark(98,97,95)
switch studMarks {
case .Name(let studName):
print("学生的名字是: \(studName)。")
case .Mark(let Mark1, let Mark2, let Mark3):
print("学生的成绩是: \(Mark1),\(Mark2),\(Mark3)。")
}数组的定义
var someInts:[Int] = [10, 20, 30]
//创建数量为3，初始值为0
var someInts = [Int](repeating: 0, count: 3)
someInts.append(10)
someInts+= 20
someInts[1]=50
//计算个数
print(someInts.count)
//合并数组
var intsC = intsA+intsB
for (index, item) in someInts.enumerated() {
print("在 index = \(index) 位置上的值为 \(item)")
}
//判断数组是否为空
intsA.isEmpty字典
var someDict = [Int: String]()
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
someDict[1] = "hello"
//修改值，如果不存在则创建
someDict.updateValue("One 新的值", forKey: 1)
//移除值
someDict[1] = nil
someDict.removeValue(forKey: 1)
//遍历
for (key, value) in someDict {
print("字典 key \(key) - 字典 value \(value)")
}
//我们也可以使用enumerate()方法来进行字典遍历，返回的是字典的索引及 (key, value) 对，实例如下:
for (key, value) in someDict.enumerated() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}
//字典转数组
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)
print("输出字典的键(key)")
for (key) in dictKeys {
print("\(key)")
}
print("输出字典的值(value)")
for (value) in dictValues {
print("\(value)")
}变量与常量的输出
let name = "常量1"
var age = "变量"
print("输出：\(name),\(\age)")控制结构
条件控制
//if语句
if true{
}else if{
}else{
}
//switch语句
switch var{
case 1:
fallthrough //可选,如果使用了fallthrough 语句，则会继续执行之后的 case 或 default 语句，不论条件是否满足都会执行。
case 2,3:
default:
}
//三元运算
Exp1 ? Exp2 : Exp3;循环控制
for index in var {
循环体
}
while condition
{
statement(s)
}
repeat
{
statement(s);
}while( condition );函数
语法
一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。
如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。
func runoob(name: String, site: String) -> String {
return name + site
}
print(runoob(name: "菜鸟教程：", site: "www.runoob.com"))
print(runoob(name: "Google：", site: "www.google.com"))
//可变参数
func vari<N>(members: N...){
for i in members {
print(i)
}
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu", "Runoob")函数类型
在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")函数类型作为参数类型、函数类型作为返回类型
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)闭包
let studname = { print("Swift 闭包实例。") }
studname()
//以下闭包形式接收两个参数并返回布尔值：
let divide = {(val1: Int, val2: Int) -> Int in
return val1 / val2
}
let result = divide(200, 20)
print (result)
//使用闭包排序
let names = ["AT", "AE", "D", "S", "BE"]
// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
return s1 > s2
}
var reversed = names.sorted(by: backwards)
print(reversed)
//缩写参数名
let names = ["AT", "AE", "D", "S", "BE"]
var reversed = names.sorted( by: { $0 > $1 } )
print(reversed)类
结构体
struct MarksStruct {
var mark: Int
init(mark: Int) {
self.mark = mark
}
}
var aStruct = MarksStruct(mark: 98)
var bStruct = aStruct // aStruct 和 bStruct 是使用相同值的结构体！
bStruct.mark = 97
print(aStruct.mark) // 98
print(bStruct.mark) // 97类定义
class student{
var studname: String
var mark: Int
var mark2: Int
init(){ //构造函数
}
deinit {//析构函数
}
}
//判断两个类相等用===和!==
let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")
if spClass1 === spClass2 {// false
print("引用相同的类实例 \(spClass1)")
}
//get set
var middle: (Double, Double) {
get{
return (length / 2, breadth / 2)
}
set(axis){
no1 = axis.0 - (length / 2)
no2 = axis.1 - (breadth / 2)
}
}
var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)
//只读属性
class film {
var head = ""
var duration = 0.0
var metaInfo: [String:String] {
return [
"head": self.head,
"duration":"\(self.duration)"
]
}
}
属性观察器
属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。
可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。
注意：
- 不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。
- 可以为属性添加如下的一个或全部观察器：
- willSet在设置新的值之前调用
- didSet在新的值被设置之后立即调用
- willSet和didSet观察器在属性初始化过程中不会被调用
class Samplepgm {
var counter: Int = 0{
willSet(newTotal){
print("计数器: \(newTotal)")
}
didSet{
if counter > oldValue {
print("新增数 \(counter - oldValue)")
}
}
}
}
let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800类继承
//final 关键字防止重写
class SomeClass: SomeSuperclass {
//重写属性
override var area: String {
return super.area + " ，但现在被重写为 \(print)"
}
init() //构造函数
{
super.init(stm1: 93, results: 89)
}
//重写方法
override func show() {
print("这是子类 SubClass")
}
}协议（接口）
protocol SomeProtocol {
var marks: Int { get set }
var result: Bool { get }
init(aprot: Int)
func attendance() -> String
func markssecured() -> String
}
class SomeClass: SomeProtocol {
required init(someParameter: Int) {
// 构造器实现
}
}
class subClass: SomeClass, tcpprotocol {
var no2: Int
init(no1: Int, no2 : Int) {
self.no2 = no2
super.init(no1:no1)
}
// 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
required override convenience init(no1: Int) {
self.init(no1:no1, no2:0)
}
}