Swift 基本数据类型

1、整型

  • Swift 提供了 IntUInt 两种整数类型,分别表示有符号和无符号的整数类型。另外 IntUInt 后面可以带有 8、16、32 和 64,以表示 8、16、32、64 位的整数。

    • 有符号整型 Int、Int8、Int16、Int32、Int64
    • 无符号整形 UInt、UInt8、UInt16、UInt32、UInt64
  • Swift 中 IntUInt 都是可以自适应平台的类型,其类型的字长始终和当前平台的原生字长相同,即 32 位系统下声明获得的是 32 位的整型,64 位系统下获得的是 64 位的整型。

  • 整数类型有 maxmin 属性,分别表示不同整数类型的最大值和最小值。

    • 最大值

      1
      2
      // 127
      Int8.maxINT8_MAX
    • 最小值

      1
      2
      // -128
      Int8.minINT8_MIN
  • 整型的声明

    • 隐式声明机制

      1
      2
      3
      4
      // 自动调用构造函数
      let intNum = Int() // 默认初始值为 0
      let intNum = 18 // 设置初始值为 18,自动推断为 Int 型
      let intNum: Int = 18 // 设置初始值为 18
    • 显式声明机制

      1
      2
      3
      // 显式的调用初始化构造器
      let intNum = Int.init() // 默认初始值为 0
      let intNum = Int.init(18) // 设置初始值为 18
  • 其他方法或属性

    1
    2
    3
    4
    5
    6
    7
    // 计算两个数字之间的距离(两数之差),结果 3
    intNum.distance(to: 21)

    // 访问变量或常量的字符串版本,结果 “18”
    intNum.description

    。。。。。

2、浮点型

  • Swift 为我们提供了两种有符号浮点数类型 FloatDouble

    • Float 是 32 位浮点数类型。
    • Double 是 64 位浮点数类型。
  • 当使用类型推断声明一个浮点型变量或者常量时,变量或常量总是默认被推断为类 Double 型。

  • 浮点型的声明

    • 隐式声明机制

      1
      2
      3
      4
      5
      6
      7
      8
      // 自动调用构造函数,定义 Float 型
      let floatNum = Float() // 默认初始值为 0
      let floatNum: Float = 2.1 // 设置初始值为 2.1

      // 自动调用构造函数,定义 Double 型
      let doubleNum = Double() // 默认初始值为 0
      let doubleNum = 2.2 // 设置初始值为 2.2,自动推断为 Double 型
      let doubleNum: Double = 2.2 // 设置初始值为 2.2
    • 显式声明机制

      1
      2
      3
      4
      5
      6
      7
      // 显式的调用初始化构造器,定义 Float 型
      let floatNum = Float.init() // 默认初始值为 0
      let floatNum = Float.init(2.1) // 设置初始值为 2.1

      // 显式的调用初始化构造器,定义 Double 型
      let doubleNum = Double.init() // 默认初始值为 0
      let doubleNum = Double.init(2.2) // 设置初始值为 2.2

3、布尔型

  • Swift 提供了一个非真即假的逻辑类型 “布尔型”。

    • 布尔型只有两种值 truefalse
    • Swift 语言中不能直接使用 0 或者非 0 来表示逻辑真假。
    • 可以直接在布尔变量前加 !,来达到布尔值取反的作用。
  • 布尔型的声明

    • 隐式声明机制

      1
      2
      3
      4
      // 自动调用构造函数
      let boolNum = Bool() // 默认初始值为 false
      let boolNum = true // 设置初始值为 true
      let boolNum: Bool = true // 设置初始值为 true
    • 显式声明机制

      1
      2
      3
      // 显式的调用初始化构造器
      let boolNum = Bool.init() // 默认初始值为 false
      let boolNum = Bool.init(true) // 设置初始值为 true

4、元组类型

  • 可以通过使用元组,把多个不同类型的值组合在一起,组成一个复合值。

    • 元组中的成员类型可以是相同的,也可以是不同的。
    • 元组中的成员可以直接当作常量或变量使用。
    • 元组的声明中也可以使用类型推断。
    • 元组可以用作函数返回值,它可以使函数能一次返回更多的信息。
  • 元组的声明

    • 标准声明

      1
      2
      3
      4
      5
      6
      7
      8
      // 定义时指定元组名称、成员名称并且初始化
      let stu = (name: "xiaoming", age: 18)

      // 定义时指定元组名称并且初始化,不指定成员名
      let stu = ("xiaoming", 18)

      // 定义时指明元素类型
      let stu: (String, Int) = ("xiaoming", 18)
    • 匿名声明

      1
      2
      // 声明一个匿名的元组
      let (name, age) = ("xiaoming", 18)
  • 元组中元素的访问

    • 标准声明的元组

      1
      2
      3
      4
      5
      // 使用元素名访问
      let stuName = stu.name

      // 使用元素在元组中的顺序下标访问
      let stuName = stu.0
    • 匿名声明的元组

      1
      2
      // 使用元素名访问
      let stuName = name
  • 如果想要获取元组中的某些重要部分加以利用,忽略一些不重要的信息时,可以把元组的值传递到一个新的元组中。在新元组中声明那些接受重要值的值成员,而不重要的部分使用下划线 _ 表示忽略。

    1
    let (name, _) = stu
文章目录
  1. 1. 1、整型
  2. 2. 2、浮点型
  3. 3. 3、布尔型
  4. 4. 4、元组类型
隐藏目录