swift 基本运算符

NewBoy
426 阅读3分钟

这是我参与更文挑战的第5天，活动详情查看： 更文挑战

运算符

一元运算符

对单一操作对象操作。如：-a

一元运算符分前置运算符和后置运算符

  • 前置运算符：紧跟在操作对象之前。如：!b
  • 后置运算符：紧跟在操作对象之后。如：c!

二元运算符

运算符出现在两个操作对象之间。如：2 + 3

三元运算符

操作三个操作对象，Swift只有一个三元运算符，就是三目运算符。如：a ? b : c

赋值运算符（=）

let a = 10
let (x, y) = (1, 2)

算术运算符(+、-、*、／、%)

let value1 = 1 + 2   //3
let value2 = 3 - 1   //2
let value3 = 2 * 3   //6
let value4 = 10 / 2  //5
let value5 = 10 % 3  //1

组合赋值运算符（+=、-=、*=、/=、%=）

先运算除后赋值

var a = 3
a += 2    //a = a + 2    5
a -= 2    //a = a - 2    3
a *= 2    //a = a * 2    6
a /= 2    //a = a / 2    3
a %= 2    //a = a % 2    1

注意：
在swift中，不支持自增(++)和自减(--)的运算符

比较运算符(==、!=、>、<、>=、<=)

  • 常见比较运算符

Swift 还提供了两个标识运算符（===和!==），判断两个对象引用是否都指向同一个对象实例

1 == 1   // true
2 != 1   // true
2 > 1    // true
1 < 2    // true
1 >= 1   // true
2 <= 1   // false
  • 比较运算符多用于条件语句
let str = "swift"
if str == "swift" {
    print("swift")
} else {
    print("其他语言")
}

log：
//swift
  • 元组的比较（元组内有bool值不可以比较） 如果两个元组的元素相同，且长度相同的话，元组就可以被比较。比较元组大小会按照从左到右、逐值比较的方式，直到发现有两个值不等时停止。如果所有的值都相等，那么这一对元组我们就称它们是相等的
(1, "Android") < (2, "iOS")       // true，1 小于 2
(3, "apple") < (3, "google")      // true，3 等于 3，但是 apple 小于 google
(5, "swift") == (5, "swift")      // true，5 等于 5，swift 等于 swift

注意：
Swift 标准库只能比较七个以下元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符

空合运算符（??）

a ?? b 对可选类型a进行空判断，如果a包含一个值就进行解包，否则就返回一个默认值b，这个运算符有两个条件:

  • 表达式a必须是Optional类型
  • 默认值b的类型必须要和a存储值的类型保持一致
var a : Int?
let b  = 10
let c = a ?? b   //10

区间运算符

  • 闭区间运算符
for index in 1...5 {
    print(index)
}

log
//1  2 3 4  5
  • 半开区间运算符
for index in 1..<5 {
    print(index)
} 

log
//1 2 3 4
  • 单侧区间
let arr = [1,2,3,4,5]

for index in arr[2...] {
     print(index)
}  
log
//3 4 5

for index in arr[...3] {
     print(index)
} 
log
//1 2 3 4

for index in arr[..<3] {
     print(index)
}
log
//1 2 3

逻辑运算符(!、||、&&)

  • 逻辑非(!)
let flag = false
if !flag {
   print("pass")
} 

log
//pass
  • 逻辑或(||)
let flagA = false
let flagB = true
if flagA || flagB {
   print("pass")
}  //pass
  • 逻辑与(&&)
let flagA = false
let flagB = true

if flagA && flagB {
   print("pass")
}

位运算符（&，|，^，~，<<，>>）

  • 按位与(&) 对俩个数进行操作，结果返回一个新的数，只有这俩个操作数的相同位都是真（1），那么结果表达式的这一位才为真（1）
let bitsA = 0b1100 1100
let bitsB = 0b0011 1111
let bitsC = bitsA & bitsB  //0b0000 1100
  • 按位或（|） 对俩个数进行操作，结果返回一个新的数，只要这俩个操作数的相同位有一个是真（1），那么结果表达式的这一位就是真（1），只有俩个操作数的相同位都是假（0），那么结果表达式的这一位才是假（0）
let bitsA = 0b1100 1100
let bitsB = 0b0011 1111
let bitsC = bitsA | bitsB  //0b1111 1111
  • 按位异或（^） 对俩个数进行操作，结果返回一个新的数，比较这俩个操作数的相同位，如果相同（即同为真或同为假），那么结果表达式的这一位返回假（0），如果不同（即一个为真一个为假），那么结果表达式的这一位返回真（1）
let bitsA = 0b11001100
let bitsB = 0b00111111
let bitsC = bitsA ^ bitsB  //0b11110011
  • 按位异或（~） 对一个数进行操作，结果返回一个新的数，对操作数的每一位都取反，也就是将每一位由假（0）变真（1），由真（1）变假（0）
var bitsA = 0b1111 0000
var bitsB = ~bitsA  //0b0000 1111
  • 按位左移(<<) 对一个数进行操作，左移运算符相当于把这个数乘以2的因子，简单说就是将运算符操作数左移指定的位数，被移出的高位数直接丢弃，在低位补0
var bitsA = 0b0000 0101
var bitsB = bitsA<<2  //0b0001 0100
  • 按位右移(>>) 对一个数进行操作，右移运算符相当于把这个数除以2的因子，简单说就是将运算符操作数右移指定的位数，被移出的低位数直接丢弃，在高位中，无符号数或者有符号数的正数高位补0，有符号数的负数，补0或者补1由当前系统决定，补0叫逻辑右移，补1叫算术右移
var bitsA = 0b0001 0100
var bitsB = bitsA<<2  //0b0000 0101
avatar
文章
阅读
粉丝