• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

Swift语法基础入门一(适合有C,OC开发人员)

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

Swift开发体验

/*:
创建对象
* OC:     alloc initWithXXX 方法
* Swift:  (xxx:)
*/

/*:
调用方法
* OC:     [UIColor redColor];
* Swift    UIColor.redColor()
*/


/*:
枚举
* OC:      UIButtonTypeContactAdd
* Swift:   UIButtonType.ContactAdd
*/

//[[UIView alloc] init];
//[[UIView alloc] initWithFrame: ];
//let view = UIView()

let view = UIView(frame:CGRect(x: 0, y: 0, width: 100, height: 100))
view.backgroundColor = UIColor.redColor()

let btn = UIButton(type: UIButtonType.ContactAdd)
btn.center = view.center
view.addSubview(btn)
  • 注释

    • Swift 的编译器将会在编译代码时自动忽略掉注释部分
    • 单行注释 //
    • 多行注释 /**/
  • 与 C 语言多行注释不同,Swift 的多行注释可以嵌套在其它的多行注释之中嵌套多行注释

    • 注释嵌套 //**//

常量和变量

常量变量

  • let 常量: 常量的值一旦设定就不能改变
  • var 变量: 变量的值可以随意更改
  • 常量&变量的使用原则:
  • 为保证数据的安全性尽量先用 let,只有需要改变的时候才使用 var

常量定义格式

  • 声明符号 常量名称: 类型标注
  • let number: Int
  • 特点: 一旦设定就不能改变

let number: Int = 10
//number = 20

定义变量格式

  • 声明符号 变量名称: 类型标注
  • var number: Int
  • 特点: 变量的值可以随意更改
  • 注意: 一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值,Swift可以推断出这个常量或者变量的类型
var number2: Int = 10
number2 = 20

类型推断

  • 编译器可以在编译代码的时候自动推断出表达式的类型。(其它语言是没有类型推断)
  • 原理很简单,只要检查你赋的值即可
  • 如果没有指定表达式的类型, 也没有赋予初始值, 编译器会报错(type annotation missing in pattern)
let number3 = 10
var number4 = 20.1

// 注意点: 如果没有指定表达式的类型, 也没有赋予初始值, 编译器会报错
var number5: Int
number5 = 88

类型安全

  • Swift 是一个类型安全(type safe)的语言, 它会在编译你的代码时进行类型检查(type checks),并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误
  • swift 对数据类型要求异常严格, swift 中任何时候,都不会做隐式转换,如果要对不同类型的数据进行计算,必须显示类型转换 注意:
  • 结合数字类常量和变量不同于结合数字类字面量。字面量8可以直接和字面量3.1415926相加,因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测
  • Double和CGFloat也需要转换

//let number6: Int = 10.1
let number7 = 10
let number8 = 10.1
//let sum = number7 + number8
let sum = Double(number7) + number8
let sum1 = number7 + Int(number8)

// 字面量之间运算可以是不同类型
let sum2 = 10 + 10.1

// CGFloat/Double
let point = CGPoint(x: 10.10, y: 20.20)
let temp = point.x
let sum3 = Double(temp) + number8

常量和变量的命名

  • 你可以用任何你喜欢的字符作为常量和变量名,包括 Unicode 字符
  • 常量与变量名不能包含数学符号,箭头,保留的(或者非法的)Unicode 码位,连线与制表符
  • 也不能以数字开头,但是可以在常量与变量名的其他地方包含数字
  • ... 和C和OC一样

注意:

  • 如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名,你可以使用反引号(`)将关键字包围的方式将其作为名字使用。
  • 无论如何,你应当避免使用关键字作为常量或变量名,除非你别无选择。
//let ???? = "狗"
//let `Int` = 10

元祖

  • 元组(tuples)把多个值组合成一个复合值
  • 将多个相同或者不同类型的值用一个小括号括起来就是一个元祖
  • 元组内的值可以是任意类型,并不要求是相同类型
  • 作为函数返回值时,元组非常有用

注意:

  • 元组在临时组织值的时候很有用,但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用,请使用类或者结构体而不是元组
let tuples = (10, 10.1)

//: 通过下标
tuples.0
tuples.1

//: 指定元素名称
let tuples1 = (xxx: 99,ooo: 3.14)
tuples1.xxx
tuples1.ooo

//: 分解元素
let (intValue, doubleValue) = (998, 4.1)
intValue
doubleValue

分支

  • Swift 提供了类似 C 语言的流程控制结构(if/switch/for/while/dowhile)
  • 分支if
    • 只能以Bool作为条件语句
    • 条件语句不需要加()
    • {}不能省略
    • Swift中if分支的模式可以使用where语句来判断额外的条件
    • 其它和OCif一样
let number = 10
if number == 10 {
    print("等于10")
}

if number >= 10 && number <= 20 {
    print("等于10")
}

Bool类型

  • C语言和OC并没有真正的Bool类型
  • OC语言的Bool类型YES/NO是typedef signed char BOOL;非0即真

Swift引入了真正的Bool类型true/false

  • Swift中没有C和OC中非零即真的概念
  • Swfit中逻辑值只有两个true/false
  • 如果你在需要使用Bool类型的地方使用了非布尔值,Swift 的类型安全机制会报错

三目运算符

  • 三目运算符的特殊在于它是有三个操作数的运算符, 它简洁地表达根据问题成立与否作出二选一的操作
  • 格式: 问题 ? 答案1 : 答案2

提示:

  • Swift中三目运算符用得很多

注意:

  • 过度使用三目运算符会使简洁的代码变的难懂。我们应避免在一个组合语句中使用多个三目运算符
let number1 = 10
let result = (number1 == 10) ? 10 : 0

分支Switch

  • OC中case后面必须加上break否则会贯穿, Swift不用
  • Swift中如果想贯穿必须使用fallthrough
  • OC中可以不写default,Swift中只有满足所有条件才能忽略default
  • OC中default位置可以随便放,Swift不可以
  • OC中在case中定义变量需要加大括号, 否则作用域混乱, Swift不用加大括号
  • Swift中的switch可以判断区间和元祖
  • Swift中case 分支的模式可以使用where语句来判断额外的条件

注意: Swift中每一个 case 分支都必须包含至少一条语句, 不像 C 语言里的switch语句,在 Swift 中,switch语句不会同时匹配多个条件

switch(rank){
case "A":
case "B":
NSLog(@"还不错")
break
case "C":
NSLog("差")
break
}
let age = 18
switch age {
    case 0:
        print("刚出生")
    case 18:
        print("刚成年")
        fallthrough
    case 40:
        print("一枝花")
        var name = "lnj"
    default:
        print("other")
}

// 判断元祖
let point = (0, 50)
switch point {
    case (0, 0):
        print("原点")
    case (50, 50):
        print("中点")
    case (100, 100):
        print("右下角")
    default:
        print("other")
}

// 了解
switch point {
    case let (x, y) where x == 0 && y == 0:
        print(x)
        print(y)
    case let (x, y) where x == 50 && y == 50:
        print(x)
        print(y)
    case let (x, y):
        print(x)
        print(y)
    default:
        print("other")
}

// 判断区间
// 闭区间   0...10  取值范围 0~10 包含头包含尾
// 半闭区间 0..<10  取值范围  0~9 包含头不包含尾

//let range = 0..<18
//let range = 18..<30
let range = 18...20
switch range {
//    case 0..<18:
//        print("未成年")
//    case 18..<30:
//        print("成年人")
//    default:
//        print("老炮")
    case 0...17:
        print("未成年")
    case 18...30:
        print("成年人")
    default:
        print("老炮")
}

let rank = "A"
switch rank {
//    case "A":
//        fallthrough
//    case "B":
//        print("还可以")
    case "A", "B":
        print("还可以")
    case "C":
        print("差")
    default:
        print("回家吧")
}

可选类型

可选类型

  • 可选类型表示变量可以有值, 也可以没有值
  • C 和 Objective-C 中并没有可选类型这个概念
  • Swift中只有可选类型才可以赋值为nil
  • 如果你声明一个可选常量或者变量但是没有赋值,它们会自动被设置为nil

  • 格式: Optional<类型> 或 在类型后面加上?号

可选类型的取值是一个枚举

  • None 没有值
  • Some 有值

  • 由于可选类型在Swift中随处可见, 所以系统做了一个语法糖, 在类型后面加上? 注意:

  • nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况,请把它们声明成对应的可选类型。
  • Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中,nil是一个指向不存在对象的指针, 所以Objective-C只有对象类型才能被设置为nil(基本类型不行)。在 Swift 中,nil不是指针——它是一个确定的值,用来表示值缺失。任何类型的可选状态都可以被设置为nil,不只是对象类型。
var number: Optional<Int>
number = 10
number = nil

var number1: Int
number1 = 10
//number1 = nil

// 推荐
var number2: Double?
number2 = 20.1
//number2 = nil


// Swift中可选类型的值不能当做普通类型的值来使用
// 如果想使用可选类型的值必须进行解包操作
// 只需要在变量/常量后面加上! 就可以解包
// 解包代表着告诉系统, 该变量/常量中一定有值
var number3: Double
number3 = 3.14

print(number2)
print(number2!)
print(number3)
let sum = number2! + number3

强制解析(forced unwrapping)

  • init? 构造函数, ?表示不一定能够实例化出对象
  • !表示告诉编译器一定有值, 编译能够通过, 如果运行时没有值就会直接崩溃
  • 提示: ? 和 ! 是所有刚刚接触Swift的OC程序员最最蛋疼的问题, 前期开发要注意多看文档和利用编译器提示解决(option + click) 注意
  • 在Swift开发中, 尽量不要使用强制解包, 不安全
let url = NSURL(string: "http://www.520it.com")
print(url)
//print(url!)

let url1 = NSURL(string: "http://www.520it.com/图片/abc.png")
print(url1)

可选绑定(optional binding)

  • 不需要考虑url是否有值, 能进入{}一定有值
  • 不仅可以用来判断可选类型中是否有值,同时可以将可选类型中的值赋给一个常量或者变量
  • 可选绑定可以用在if和while语句中

提示:

  • 在实际开发中,使用频率很高

注意:

  • 可选绑定中的变量/常量只能在if后面的{}中使用
if let temp = url {
    print(temp)
}

let value1: Int? = 10
let value2: Int? = 20
let value3: Int? = 30
let value4: Int? = 40

if let temp1 = value1 {
    if let temp2 = value2 {
        if let temp3 = value3 {
            if let temp4 = value4 {
                let sum = temp1 + temp2 + temp3 + temp4
            }
        }
    }
}

guard

  • guard语句是在Swift 2.0中引进的,它是用途是在未满足某个条件时,提供一个退出的路径
  • 格式: guard 表达式 else{} 注意:
  • guard中的变量/常量 可以在guard后面使用
  • guard一般用于避免使用强制拆包, 优化代码结构
func test(){
    let value1: Int? = 10
    let value2: Int? = 20
    let value3: Int? = 30
    let value4: Int? = 40

    guard let temp1 = value1 else{
        return
    }
    guard let temp2 = value2 else{
        return
    }
    guard let temp3 = value3 else{
        return
    }
    guard let temp4 = value4 else{
        return
    }
    let sum = temp1 + temp2 + temp3 + temp4
    print(sum)
}
test()

隐式解析可选类型(implicitly unwrapped optionals)

  • 有时候在程序架构中,第一次被赋值之后,可以确定一个可选类型总会有值。在这种情况下,每次都要判断和解析可选值是非常低效的,因为可以确定它总会有值
  • 隐式解析可选类型, 并不需要每次都使用解析来获取可选值, 一个隐式解析可选类型其实就是一个普通类型,但是可以被当做非可选类型来使用
  • 格式: 将可选类型后面的?改为!
  • let xmgButton: UIButton!

注意:

  • 如果一个变量之后可能变成nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话,请使用普通可选类型
let intValue: Int?
intValue = 10
print(intValue)
print(intValue!)

if intValue != nil {
    print(intValue!)
}

if let temp = intValue {
    print(temp)
}

var doubleValue: Double!
doubleValue = nil
doubleValue = 3.14
print(doubleValue)

循环

for循环-传统

  • for后的圆括号可以省略
  • 只能以bool作为条件语句
  • 如果只有条指令for后面的大括号不可以省略
  • for后面的三个参数都可以省略, 如果省略循环保持语句, 那么默认为真
for (var i = 0; i < 10; i++){
    print(i)
}
for var i = 0; i < 10; i++ {
    print(i)
}

for循环-Swift

  • 闭区间: 包含区间内所有值 a...b 例如: 1...5
  • 半闭区间: 包含头不包含尾 a..<b 例如: 1..<5 其它写法
  • Swift1.0版本写法 0..10
for i in 0..<10 {
    print(i)
}

//: while循环, 每次在循环开始时计算条件是否符合
var count = 0
while count < 10 {
    print(count)
    count++
}

count = 0
print(count)
//: repeat-while, 每次在循环结束时计算条件是否符合
repeat {
    print(count)
    count++
}while count < 10
print(count)

End


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap