博客围绕Swift语言展开，涵盖语法入门和运算符相关内容。语法部分介绍了常量与变量、整型、浮点型等多种类型及类型转换、断言等。运算符部分包含基础、高级和自定义运算符，还说明了运算符优先级和结合性。
思维导图
引用：《Swift语言实战入门》
语法入门
- 常量与变量
var sampleStr0:String
let sampleStr1:String = "hello,"
let sampleStr2="world."
sampleStr0=sampleStr1+sampleStr2
print(sampleStr0)
- 整型
var sampleInteger:Int
sampleInteger=4
var tmpInteger0=12
tmpInteger0+=1
var tmpInteger1=Int.init(3)
tmpInteger1+=1
let tmpInteger2=Int.init("24")
print(sampleInteger,tmpInteger0,tmpInteger1,tmpInteger2!)
- 浮点型
let sampleValue=1.2 //变量或常量总是默认被推断为Double类型
var tmpDouble:Double
tmpDouble=sampleValue+1.5
//Double 64位浮点数 Float 32位浮点数,使用类型别名防止Double和Float字长混淆
typealias Float32 = Float
typealias Float64 = Double
let tmpFloat32:Float=1.2
print(tmpDouble,tmpFloat32.magnitude)
- 布尔型
var sampleBoolValue:Bool
let tmpBool=true
sampleBoolValue=tmpBool&&false
print(sampleBoolValue)
- 字符串与字符
//字符串
var sampleString:String
let keyNote="someNote"
if !keyNote.isEmpty{
print(keyNote)
}
sampleString=keyNote+"is not null"
print(sampleString)
//插值
let gameName="flappy bird"
print("The game i played is \(gameName)")
//字符
var myChar:Character
myChar="^"
let doller:Character="$"
print(myChar,doller)
// lengthOfBytes
let Title="Swift is new oop language for iOS and OS X development."
print("Title has \(Title.lengthOfBytes(using: String.Encoding.utf8)) characters")
// hasPrefix
if Title.hasPrefix("Swift")
{
print("yes")
}
// hasSuffix
if Title.hasSuffix("development.")
{print("yes")}
// uppercased \lowercased
print(Title.uppercased(),Title.lowercased())
// Unicode
let animalString="a: "
for codeUnit in animalString.utf8
{
print(codeUnit)
}
for codeUnit in animalString.utf16
{
print(codeUnit)
}
for codeUnit in animalString.unicodeScalars
{
print(codeUnit)
}
- 可选（Optional）
//定义可选变量
var roundValue:Int?
print(roundValue?.description as Any) //nil
roundValue=13
print(roundValue?.description as Any) //Optional("13") 等同于 type?
print(roundValue!.description) //13
/*
可选类型定义：可选类型是使用范型枚举的形式组织的。
可以运用于 类型、结构体、类或者其他复杂数据类型
public enum Optional<Wrapped> : ExpressibleByNilLiteral {
/// The absence of a value.
///
/// In code, the absence of a value is typically written using the `nil`
/// literal rather than the explicit `.none` enumeration case.
case none
/// The presence of a value, stored as `Wrapped`.
case some(Wrapped)
...}
*/
//范型方式定义可选类型变量;使用前需要初始化
var roundValue2:Optional<Int>
roundValue2=33
///可选类型可以赋值为nil
///Objective-C中 nil 为指向不存在对象的指针
///Swift中 表示为空的关键字nil，没有其它含义
roundValue2=nil
print(roundValue2?.description as Any)
//可选是一种十分强大的类型安全机制
//var optionalValue:Optional<Int>
//optionalValue=nil
var optionalValue:Int?
if var MaxValue = optionalValue
{//安全机制：当可选变量optionalValue不为nil时成功声明MaxValue，执行if中语句体；可以避免使用值为nil的对象。
MaxValue+=1
print(MaxValue)
}
//隐式解析可选
let nullValue:String!="ac"
print(nullValue.description)
//双重可选"??";与可选运算符要区分开（ var a=b??c //如果b为nil则把c赋值给a，否则把b赋值给a ）
var doubleOptionalValue:Int??
doubleOptionalValue=10000
print(doubleOptionalValue)//Optional(Optional(10000))
var tripleOptional:Int???
tripleOptional=1344
print(tripleOptional)//Optional(Optional(Optional(1344)))
- 元组
///使用元组可以把不同的值组合到一起(元组可用于函数返回值，可以使函数一次返回更多信息)
///匿名元组：使用元素名来访问
let (appType,appName)=("game","flappy brid")
print(appType,appName)
///标准元组定义
let myProject=(oneElement:12,twoElement:"ok")
print(myProject.oneElement,myProject.1)
- 类型别名
typealias ShortInt = Int8
let age:ShortInt=18
print("I am \(age) years old")
- 类型转换
let k=Int(12.4)
print(k)
- 断言
//参数也可以是表达式，此表达式会被自动封装成闭包
assert(false, "bool值为false时程序终止；且适用于Debug模式")
运算符
- 基础运算符
//赋值运算符
let a = 5
var b:Int;
b=a
print(b) //5
//算术自反赋值运算符：“+=”、“-=”、“*=”、“/=”、“%=”
b+=5
print(b) //10
b-=2
print(b) //8
b*=2
print(b) //16
b/=3
print(b) //5
b%=2
print(b) //1
//单目负号和单目正号
b = -a //"=" 与“-”之间有空格
print(b) //-5
//算术运算符：“+” 、“-” 、“*” 、“/” 、“%”
var x=5+6
var y=10-4
let z=2.0*6.5
print(x,y,z)
x=x/3
print(x,y,z)
y=x%2
print(x,y,z)
//自增自减
var autoAdd=1
autoAdd+=4
print(autoAdd)
autoAdd-=1
print(autoAdd)
//字符连接符
var str0="hello "
var str1="world "
var intValue=10
print(str0+str1+String(intValue))
//关系运算符
///"=="，“!=”，“>”,">=","<","<=","==="(恒等，判断两个对象是否引用同一个类实例，引用为真)，“!==”（不恒等，判断两个对象是否不引用同一个类实例，不引用为真）
//三目条件运算符
var ta=33
var tb=23
var someValue=ta>tb ? ta:tb
print(someValue)
//区间运算符
///闭区间运算符
for i in 0...10
{
print(i) //包括0和10；输出： 0.....10
}
///半闭区间运算符
for i in 0..<10
{
print(i) //包括0但不包括10；输出：0.....9
}
//逻辑运算符
///逻辑非运算符“！”
let NoAllow=true
let changeAllow = !NoAllow
print(changeAllow) //false
///逻辑与运算符“&&”
let la=true
let lb=false
let lc=true
let ld=false
print(la&&lb,la&&lc,lb&&ld) //false true false
//逻辑或运算符 “||”
let ora=true
let orb=false
let orc=false
print(ora||orb,orb||orc) //true false
- 高级运算符
//高级运算符
//-----代码片段定义在Class外部
import Foundation
struct CP{
var x=0,y=0
}
func + (left: CP,right: CP) -> CP
{
return CP(x: left.x+right.x,y: left.y+right.y)
}
func += ( left: inout CP,right: CP){
left = left + right
}
//------代码片段 定义在 func中
// 位运算符
///按位取反运算符“～” :对操作数的每一位取反
let tmpBit:UInt8 = 0b11111111
let tmpBit2 = ~tmpBit
print(tmpBit,tmpBit2) //255 0
///按位与运算符“&” ：都是1时才是真
let oneBits:UInt8 = 0b11001100
let twoBits:UInt8 = 0b00111001
print(oneBits&twoBits,5&0b0001101,5&13) //0b00001000 = 8 ,5,5
///按位或“|” ：只有有一个是1则为真
print(oneBits|twoBits) //0b11111101 253
///按位异或“^”
print(oneBits^twoBits) //0b11110101 245
///按位移动运算符“<<” 、 ">>" (用途：数列排序、奇偶校验、协议编码、编码解码)
let m: UInt8 = 1 //0b00000001
print(m) //1
print(m<<1) //2
print(m<<2) //4
print(m<<3) //8
print(m<<4) //16
print(m<<5) //32
print(m<<6) //64
print(m<<7) //128
print(m<<8) //0
///有符号
let n: Int8 = -1 //0b10000001 第一位0代表正数、1代表负数
print(n) //-1
print(n<<1) //-2
print(n<<2) //-4
print(n<<3) //-8
print(n<<4) //-16
print(n<<5) //-32
print(n<<6) //-64
print(n<<7) //-128
print(n<<8) //0 0b10000000
//溢出运算符:溢出加法"&+"、溢出减法"&-"、溢出乘法"&*"
let intMax=UInt8.max
print(intMax) //255 11111111 + 1= 100000000 ->上界溢出取低位 为 00000000 = 十进制 0
print(intMax&+1) //0
let intMin=UInt8.min
print(intMin) //00000000 0
print(intMin&-1) //-1时 低位不足像高位借1 即：100000000 -1 =11111111 =255
let k:Int8 = Int8.max //有符号溢出的计算包括符号在内 ！
let kk:Int8 = k&+1 //01111111=127 +1 =》10000000=〉2^8 =128 （最高位计算在内了），又因为符号位是1为负数。==》结果 -128
print(k,kk) //127 -128
//运算符重载和运算符函数（默认的赋值运算符“=”和三目条件运算符不可重载）
let leftP:CP = CP(x:10,y:20)
let rightP:CP = CP(x:1,y:30)
var newP=leftP + rightP
print(newP) //CP(x: 11, y: 50)
//组合赋值运算符
newP += newP
print(newP)//CP(x: 22, y: 100)
- 自定义运算符
可以使用/=-+*%<>!&|^~来组合构成新的运算符
//-----代码块在Class外
postfix operator +++
//实现加上自己之后，再自增加1
postfix func +++ (left: inout CP)->CP
{
left += left
left += CP(x:1,y:1)
return left
}
//-----代码块在func内部
var p0=CP(x: 2, y: 3)
print(p0+++) //CP(x: 5, y: 7)
- 运算符优先级和结合性
结合性（associativity）包含left（左结合）、right（右结合）、none（自动）；
左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理右结合会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。
结合性默认值为 none，优先级（precedence）默认值100
// 定义结合性为left，比加法优先级高的自定义运算符+-
//class外部代码块
precedencegroup ldg{
associativity:left
higherThan:AdditionPrecedence
}
infix operator +-:ldg
func +-(left:CP,right:CP)->CP
{
return left
}
使用 +-
//使用前边定义的变量：p0 最新值为= CP(x: 5, y: 7)
var lp=CP(x: 10, y: 20)
var rp=CP(x: 3, y: 44)
//优先级为： higherThan:AdditionPrecedence
var result:CP = lp +- rp + p0 // 等价=> (lp +- rp) + p0
print(result) // CP(x: 15, y: 27)
//如果改优先级为： lowerThan:AdditionPrecedence
var result2:CP = lp +- rp + p0 // 等价=> lp +- （rp + p0）
print(result2) // CP(x: 10, y: 20)
扫一扫
3896
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
