2015-08-18 14:49:25 yutianguan 阅读数 181
  • Swift 2.1 基础实操高清视频教程

    我们通过一些代码片段学习Swift中的constant和variable、各种基本types和tuple以及Swift中重要的语言特性之一: type inference。并录制了泊学高清视频,同步搭配了泊阅文档,为开发者朋友们的学习提供了一种全新的学习视觉享受。

    8416 人正在学习 去看看 崔轶

swift学习:基础

常量和变量:
常量的值一旦设定就不能改,变量的值可改。
常量和变量必须在使用前声明,用let来声明常量,用var来声明变量。

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0


类型标注:
表示常量和变量存储的值的类型,如果不设定,那么就会根据之来进行类型推断。

var welcomeMessage: String

常量和变量的命名:
常量和变量的命名不能包含数字符号,箭头,保留字,连线和制表符,不能以数字开头,命名不能重复,不能改变其存储的值的类型,不能将常量好变量进行互换。

let π = 3.14159
var friendlyWelcome = "Hello!"

输出常量和变量:
println是一个用来输出的全局函数,输出的内容会在最后换行。

println(friendlyWelcome)
// 输出 "Hello!"

Swift 用字符串插值(string interpolation)的方式把常量名或者变量名当做占位符加入到长字符串中,Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中,并在开括号前使用反斜杠将其转义:
println("The current value of friendlyWelcome is \(friendlyWelcome)")
// 输出 "The current value of friendlyWelcome is Bonjour!


数值型类型转换:
要将一种数字类型转换成另一种,你要用当前值来初始化一个期望类型的新数字,这个数字的类型就是你的目标类型。

整数转换:

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)

SomeType(ofInitialValue)是调用 Swift 构造器并传入一个初始值的默认方法。你并不能传入任意类型的值,只能传入UInt16内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值(包括自定义类型)

整数和浮点数转换:
整数和浮点数的转换必须显式指定类型。

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi 等于 3.14159,所以被推测为 Double 类型

浮点数到整数的反向转换同样行,整数类型可以用Double或者Float类型来初始化:

let integerPi = Int(pi)
// integerPi 等于 3,所以被推测为 Int 类型

当用这种方式来初始化一个新的整数值时,浮点值会被截断。也就是说4.75会变成4,-3.9会变成-3。


布尔值:
Swift有两个布尔常量,true和false

let orangesAreOrange = true
let turnipsAreDelicious = false

当你编写条件语句比如if语句的时候,布尔值非常有用:

if turnipsAreDelicious {
    println("Mmm, tasty turnips!")
} else {
    println("Eww, turnips are horrible.")
}
// 输出 "Eww, turnips are horrible."

元组:
元组(tuples)把多个值组合成一个复合值。元组内的值可以是任意类型。

let http404Error = (404, "Not Found")
// http404Error 的类型是 (Int, String),值是 (404, "Not Found")

可选类型:
在类型后加个“?”表示可选,表示可以有值,也可以没有值。
隐式解析可选类型:
“!”取值的时候一定要有值,不然运行时会报错。

let possibleString: String? = "An optional string."
println(possibleString!) // 需要惊叹号来获取值
// 输出 "An optional string."

两者的区别:

let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString)  // 不需要感叹号
// 输出 "An implicitly unwrapped optional string."

断言:
可选类型可以让你判断值是否存在,你可以在代码中优雅地处理值缺失的情况。然而,在某些情况下,如果值缺失或者值并不满足特定的条件,你的代码可能没办法继续执行。这时,你可以在你的代码中触发一个断言(assertion)来结束代码运行并通过调试来找到值缺失的原因。
你可以使用全局assert函数来写一个断言。向assert函数传入一个结果为true或者false的表达式以及一条信息,当表达式为false的时候这条信息会被显示:

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因为 age < 0,所以断言会触发

何时使用断言

当条件可能为假时使用断言,但是最终一定要保证条件为真,这样你的代码才能继续运行。断言的适用情景:

  1. 整数类型的下标索引被传入一个自定义下标脚本实现,但是下标索引值可能太小或者太大。
  2. 需要给函数传入一个值,但是非法的值可能导致函数不能正常执行。
  3. 一个可选值现在是nil,但是后面的代码运行需要一个非nil值。
2017-03-02 15:37:34 Reflection_ 阅读数 328
  • Swift 2.1 基础实操高清视频教程

    我们通过一些代码片段学习Swift中的constant和variable、各种基本types和tuple以及Swift中重要的语言特性之一: type inference。并录制了泊学高清视频,同步搭配了泊阅文档,为开发者朋友们的学习提供了一种全新的学习视觉享受。

    8416 人正在学习 去看看 崔轶
          3:Swift原生数据类型

3.1 Swift数据类型
•数据类型用来定义变量是属于哪个性质,并加以配置内存。由于swift属于类型安全的语句,所以可以在定义变量前表明类型或者以推导的方式得知。Swift的基本数据类型有整型、浮点型、字符串、字符、布尔,同时也包含所谓的集合类型,如数组和字典。
3.2 整型
•整数分为有、无负的整数。Int表示有负的整数。而Uint表示无负的整数。Swift又提供8,16,32,64位的int和Uint,如int8、int16、int32、int64分别表示8位、16位、32位、64位的int。而Uint8、Uint16、Uint32、Uint64则表示8位、16位、32位、64位的Uint。
一般来说,你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int,长度与当前平台的原生字长相同:
•在32位平台上,Int和Int32长度相同。
•在64位平台上,Int和Int64长度相同
•除非你需要特定长度的整数,一般来说使用Int就够了。这可以提高代码一致性和可复用性。即使是在32位平台上,Int可以存储的整数范围也可以达到-2,147,483,648~2,147,483,647,大多数时候这已经足够大了。
3.3 浮点型
•float和double都表示浮点数,其中float占4个字节,而double占8个字节。
•浮点类型比整数类型表示的范围更大,可以存储比Int类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型:
•Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。Float表示32位浮点数。精度要求不高的话可以使用此类型。
3.4 数字表示方式
•数字也可以包含格式化信息来使得他们变得易读。整数和浮点数都能前面添加额外的零或者下划线来提升可读性。这两种格式化都不会影响实际的数值:
1.let paddedDouble = 000123.456
2.let oneMillion = 1_000_000
3.let justOverOneMillion = 1_000_000.000_000_1
3.5 进制数字表示方式
•整型类型常量除了以十进制表示外,也可以以二进制、八进制或是十六进制的方法表示。
整数字可以如下书写:
十进制数字,没有前缀
二进制数字,以0b作为前缀
八进制数字,以0o作为前缀
十六进制数字,以0x作为前缀
3.6 指数表示
•浮点型字面量可以额外带一个可选的指数符:
•十进制:可选指数符为e,表示10的n次方,注意有正负。
1.25e2:表示1.25乘以10的2次方,即125.0
1.25e-2:表示1.25乘以10的-2次方,即0.0125
•十六进制:可选指数符为p,表示2的n次方,也有正负之分。
0xFp2:表示15乘以2的2次方,直接写是60.0
0xFp-2:表示15乘以2的-2次方,直接写是3.75
3.7 数字类型之间的转换
•Swift对于类型的检查非常严格,不同类型之间不能随便转换。在通常情况下请使用Int来标记变量或者常量的整数类型,即使已知的数值并不为负,使用默认的整数类型好处是可以保证常量和变量类型的一致性,并且和推测出得类型进行匹配。仅在有特殊需求的时候使用其他的数据类型,比如外来源明确大小的数据,或者是因为性能,内存使用或者其他必要的优化。在这些情况下使用明确的大小的类型能够有助于发现意外数值溢出并潜在记录使用的数据特性。
3.8 整型之间的转换
•对于每种数字类型的常量或变量所能存储的数字的范围是各不相同的。一个Int8的常量或者变量能存储从-128到127之间的数字,然后Int的常量或变量能存储0到255之间的数字。当一个数字在一个整数类型的常量或变量所表述的范围之外进行赋值时,在编译代码时就会报出一个错误:
let cannotBeNegative: UInt8 = -1 // UInt8 不能存储一个负数
let TooBig: Int8 = Int.max + 1 // Int8不能存储比它的最大值还要大的值
因为第个数字类型存储不同范围的值,你必须在个别的基础上选择加入数字类型转换。这种选择机制阻止了隐藏的转换错误帮助你作出明确的类型转换意图。
把一个指定数字类型转换成另外一种类型,你可以用这个存在的数字来初始化一个你期望想得到的类型新数字。下边这个例子中,常量twoThousand在的类型是UInt16,然而,常量one的类型是UInt8,他们不能直接相加在一起,因为他们的类型不一样。这个例子中可以把one做为初始值调用UInt16(one)来创建一个新的UInt16,用这个新的数字来代替原来的位置。
  let​ ​twoThousand​: ​UInt16​ = ​2_000
  let​ ​one​: ​UInt8​ = ​1
  ​let​ ​twoThousandAndOne​ = ​twoThousand​ + ​UInt16​(​one​)
因为加法两边都的类型都是UInt16,这种加法是允许的。输出常量(twoThousandAndOne)的类型被推断出来是UInt16,因为它是两个UInt16值的和。
Swift类型初始化时调用默认方法SomeType(初始化值)比如Double(value),Int8(value),并把初始值传递给它。在后台,UInt16有一个初始化程序来接收一个UInt8的值,这个初始化程序通过接收到的UInt8的值来创建一个新的UInt16。在这里不能随便传递一个类型,不管怎样,它必须提供一个UInt16的类型初始化程序。扩展现有类型提供一个接收新类型的初始化程序(包含自己类型定义)来覆盖的扩展。
3.9 整型与浮点型之间的转换
•整数和浮点数之间的转换必须显示的指明:
let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFive // pi = 3.14159 pi的类型为Double
•在这里,常量three的值被用于创建一个类型为Double的新数字,所以在加号的两边的类型是一样的。如果没有进行转换,这个加法运算将不能被允许通过。
浮点数转整数也必须得明确的指明。一个整数可以通过一个双数度数或一个单精度数来初始化:
let integerPi = Int(pi); // integerPi = 3 类型为Int
当把一个浮点数转换为一个整数时其浮点数的值最会被截取小数部分。这意味着 4.75 转换成4,-3.9转换成-3.
☀注意:对于数字常量和变量的合并的标准和数字字面量值的合并标准是不同的。字面量3可以直接加字面量0.14159,因为数字字面没有一个明确的类型,它们的类型只是通过编译器推断指明出来的。
3.10 布尔型
•Swift中的布尔型(bool)是许多原始函数的基础。我们用枚举来定义MyBool类型的模型,它有两个不同的case:
enum MyBool {
case myTrue, myFalse
}
•Swift 有一个基本的布尔类型 Bool.布尔值被称作逻辑值,因为他们只能是真或者假。Swift 提供了两个布尔常量:true和false.如果你在创建变量和常量的时候,就给他们true或者false,那么就没有必要声明类型为Bool了。使用那些已知类型的值来初始化常量或者变量的时候,类型推断可以使得Swift的代码更加的简洁,更具有可读性。在处理条件语句,比如if语句的时候,布尔值就非常有用。
3.11 元组类型
•定义:元组类型由N个任意类型的数据组成(N>=0),组成元组类型的数据可以称为“元素”
知识点:
1.元组数据中的元素可以有名称也可以没有名称
2.元组数据中的元素可以为空
3.元素访问可以通过元素名称或者下标
4.声明成var的元组数据中的元素可以被改变
5.可以指定元素的类型(在明确指出元素类型的情况下不能加上元素的名称)
6.可以用多个变量接收元组数据
7.可以将元素分别赋值给多个变量
8.可以用下划线_忽略某个元素的值,从而取出其他的元素
9.你可以通过元组创建任意类型的排列,并且可以包含任意数量的不同类型,比如你可以创建 (Int,Int,Int) 或者 (String,Bool) 或者任意其他你需要的排列组合。
3.12 可选类型
•Swift定义后缀来作为标准库中的定义的命名型类型Optional的简写。换句话说,下面两个声明是等价的:
1.var optionalInteger: Int?
2.var optionalInteger: Optional
在上述两种情况下,变量optionalInteger都被声明为可选整型类型。注意在类型和?之间没有空格。类型Optional是一个枚举,有两种形式,None和Some(T),又来代表可能出现或可能不出现的值。任意类型都可以被显式的声明(或隐式的转换)为可选类型。当声明一个可选类型时,确保使用括号给?提供合适的作用范围。比如说,声明一个整型的可选数组,应写作(Int[])?,写成Int[]?的话则会出错。如果你在声明或定义可选变量或特性的时候没有提供初始值,它的值则会自动赋成缺省值nil。可选符合LogicValue协议,因此可以出现在布尔值环境下。此时,如果一个可选类型T?实例包含有类型为T的值(也就是说值为Optional.Some(T)),那么此可选类型就为true,否则为false。
3.13 可选类型概念
•在swift中,可选类型其根源就是一个枚举型,里面有None和Some两种类型。
•可选类型是Swift的一个特色。它表示一个变量有可能有值,也可能没有值(nil)。
声明的方式是“数据类型+问号”。而当要使用一个可选类型的变量是,要在后面加感叹号“!”。
3.14 可选类型值拆包
•如果我们要判断可选类型的值是不是存在,通常会用到一个if-else语句。如果可选类型的值存在,就将可选类型的值取出来。
• 如果我们像正常情况下的打印可选类型的值就会出现上图篮框中的打印内容。但是很显然,我们 只需要Optional(123)中括号中的内容,这就需要将可选类型的值进行拆包。怎么拆包呢?其实很简单,只要在Optional类型的名称之后加一个!即可。即将打印方法写成
println(“(number) has an integer value of (converedNumber!)”) 即可。
ps:如果可选类型没有值的时候,则不能进行拆包,会报错
有些时候,我们明确知道一个可选类型是有值的,这个时候我们就不用再使用if语句check了。这种情况我们把它叫做间接拆包。 对间接拆包的可选类型进行绑定,只需如下图所示即可。因为可选类型的变量(或常量)一直有值,不需要再写else的情况。 间接拆包主要用于类的初始化。如果一个类的初始化过程中包含另外一个类的属性,当使用普通的可选类型的时候,就还需要有一个拆包的过程,这样或造成一个强制引用的问题。因此为了避免强制引用问题,这里类的初始化过程使用间接拆包(这里只是提一下)。
•什么时候用拆包?什么时候使用间接拆包?只要判断可变类型的值会不会出现nil的情况。
3.15 可选绑定
•增加一个临时量并给临时变量赋可选值,通过if条件判断获得可选类型的值,这就叫做绑定。
为什么要绑定呢?绑定了之后,就可以对获取到可选类型值的tempValue做一些操作。用if来进行绑定,主要用于设定一个临时的变量,来进行一些额外的操作。

2016-09-03 18:00:19 yangyi2083334 阅读数 689
  • Swift 2.1 基础实操高清视频教程

    我们通过一些代码片段学习Swift中的constant和variable、各种基本types和tuple以及Swift中重要的语言特性之一: type inference。并录制了泊学高清视频,同步搭配了泊阅文档,为开发者朋友们的学习提供了一种全新的学习视觉享受。

    8416 人正在学习 去看看 崔轶

swift 4.1 可选型optional

标签(空格分隔): swift


可选型 optional ,表示一个值可能为空。但是这个空,在swift中就叫可选型,用关键字nil表示。它既不是0,也不是不存在,它就是nil

要么是它自身的值,要么为nil。nil就是可选型的默认值

简单记录下,就不展开的说了。

0. 申明一个可选项

用: 字符类型+? 必须显示的申明

var errorCode:Int? = 404
var errorMessage:String? = "Not Found!"

errorCode = nil

print( errorMessage )  // 输出:Optional("Not Found!")

1. 不能隐示的申明

//var errorCode1? = 404 //报错,必须声明类型

var errorCode2:Int? = 404 //得像这样,显示的申明一个类型

// Int? 和 Int 不是一种类型
let imInt = 405 //Int 型
errorCode = imInt
print(errorCode)  //Optional(405)

//imInt = errorCode //报错了,把一个可选型赋值给一个Int型,报错。

2. 可选型的解包。

解包就是我得使用它了。确认强制解包用:!

var errorCode3:String? = "404"

//"the errorcode is " + errorCode3 // 报错:2种不同的类型不能直接拼装使用。

//如果需要使用,就得解包。用强制解包:!
"the errorcode is " + errorCode3! // 打印:the errorcode is 404

//用强制解包,是很危险的,如果这个值真的为 nil。然后强制解包,就会报错。

var errorCode4:String? = nil
//"the errorcode is " + errorCode4! // 报错了:nil被强制解包报错。

3. 可以用if 判断可选型是否为nil,安全后再用!解包

var errorCode5:String? = "502"
if errorCode5 != nil {
    print(errorCode5!) //打印:502
} else {
    print("No error!")
}

4. if 联合使用 let 关键字解包,可以不用!了

if let unwrappedErrorCode = errorCode5{
    print(unwrappedErrorCode) //打印:502
} else {
    print("No error!")
}

//也可以用相同的名字:
if let errorCode5 = errorCode5{
    print(errorCode5) //打印:502
} else{
    print("No error!")
}

5. 使用 if let 解包多个可选型的值。相当于 and 操作

if let errorCode5 = errorCode5, errorMessage = errorMessage{
    print("code is \(errorCode5), msg is \(errorMessage)")
    //打印:code is 502, msg is Not Found!
}

6. 使用 if let 再加 where 进一步限定

if let errorCode5 = errorCode5, errorMessage = errorMessage where errorCode5 == "502"{
    print("code is \(errorCode5), msg is \(errorMessage)")
}
print(errorCode5) // 它自身的值并没有被改变:Optional("502")

7. Optional chaining 链式操作

//解包
var errorMessage2: String? = "Not Found"
if let errorMessage2 = errorMessage2{
    print(errorMessage2.uppercaseString) // "NOT FOUND" 全部大写了
}

//chaining操作就是可以直接用:

if let errorMessage2 = errorMessage2?.uppercaseString{
    print(errorMessage2) // "NOT FOUND" 全部大写了
}

//也可以直接用 !强制解包,前提是你确定一定不为nil。
let upperMessage2 = errorMessage2!.uppercaseString //"NOT FOUND" 全部大写了

8. 使用 ?? 解包。更加单的三目运算符


let message2 = errorMessage == nil ? "No error" : errorMessage!

//等价。如果 errorMessage 解包成功,就把解包解包的值给 message3
let message3 = errorMessage ?? "No error" // "Not Found!"

9 .在元祖里面使用可选型

//errorMessage 设置为可选
var error1:(errorCode:Int, errorMsg:String?) = (404, "Not found!")

error1.errorMsg = nil //成功

print(error1) //打印:(404, nil)

//把整个元祖设置为可选
var error2:(errorCode:Int, errorMsg:String)? = (404, "Not Found!")

error2 = nil //成功的

print(error2) // 打印:nil

10 .隐士的申明

待续

2019-01-10 10:50:38 qq_41039988 阅读数 52
  • Swift 2.1 基础实操高清视频教程

    我们通过一些代码片段学习Swift中的constant和variable、各种基本types和tuple以及Swift中重要的语言特性之一: type inference。并录制了泊学高清视频,同步搭配了泊阅文档,为开发者朋友们的学习提供了一种全新的学习视觉享受。

    8416 人正在学习 去看看 崔轶

Swift 可选(Optionals)类型的定义

Swift 的可选(Optional)类型,用于处理值缺失的情况。可选表示"有值 “或者"没有值”。
Swfit语言定义后缀?作为命名类型Optional的简写

var str: String?      //
let num: Int? = 10   // 申明可选Int类型的常量,初始值为10

可选(Optional) 的拆包

  1. 显式拆包
    Optional 类型的值不能被直接使用,当需要用时要显示拆包,以表明我知道这个 Optional 是一定有值的:
var str: String? = "Hello World!"
print(str!)//Hello World! 

之所以要拆包使用,是因为 Optional 类型其实是一个枚举:

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)

    /// Haskell's fmap, which was mis-named
    func map<U>(f: (T) -> U) -> U?
    func getMirror() -> MirrorType
    static func convertFromNilLiteral() -> T?
}
  1. 隐式拆包
    除了显示拆包之外, Optional 还提供了隐式拆包,通过在声明时的数据类型后面加一个感叹号(!)来实现
var str: String! = "Hello World!"
print(str) //Hello World!

  1. 空运算符
    可以用来判断变量或常量是否为nil
// 空合运算符:a ?? b 判断a是否为nil,若a不为nil对a解包,否则返回b的值
var num: Int? // 申明可选Int类型的变量num,初始值为nil
num ?? 0 // 因为num为nil,则返回0
// ?? 即为以下if else的缩写
func testOption() -> Int {
    let num: Int? = 1
    if num == nil {
        return 0
    } else {
        return num!
    }
}

2018-07-20 00:20:18 weixin_40233463 阅读数 146
  • Swift 2.1 基础实操高清视频教程

    我们通过一些代码片段学习Swift中的constant和variable、各种基本types和tuple以及Swift中重要的语言特性之一: type inference。并录制了泊学高清视频,同步搭配了泊阅文档,为开发者朋友们的学习提供了一种全新的学习视觉享受。

    8416 人正在学习 去看看 崔轶
  • 语句间可以没有分号
  • 基本数据类型 

UInt :无符号整数

  • 字面量 

字面量(literal)是用于表达源代码中一个固定值的表示法(notation)

1.整型:

二进制数,前缀是0b

八进制数,前缀是0o

十六进制数,前缀是0x

例如 let binaryInteger = 0b10001       // 二进制的17

 

2.浮点型:

浮点字面量可以是十进制(没有前缀)或者是十六进制(前缀是0x)

指数在十进制浮点数中e来指定,在十六进制浮点数中p(相当于基数和2^exp的乘)来指定

例如 1.25e-2 表示 1.25 × 10^-2,等于 0.0125

         0xFp2 表示 15 × 2^2,等于 60.0

 

3.整数和浮点数都可以添加额外的零并且包含下划线,并不会影响字面量

例如 let justOverOneMillion = 1_000_000.000_000_1

 

  • 常量、变量、运算符 

常量用let (常量是不可改变的值)

变量用var (变量定义时要赋初值)

 变量名 第一个字母小写 后面的单词每个首字母大写 lowerComeClose

可以用中文

  • 类型

常量或变量的类型是在变量名后

:类型名=值

类型可有可无

例如 let 循环次数:Int = 50

  • 类型强制转化

例子 1,常量 twoThousand 的类型是UInt16 ,而常量 one 的类型是 UInt8 。他们不能直接被相加在一起,因为他们的类型不同。所以,这里让 UInt16 (one ) 创建一个新的 UInt16 类型并用 one 的值初始化

2,用浮点数初始化一个新的整数类型的时候,数值会被截断。也就是说 4.75 会变成 4 , -3.9 会变为 -3

  • 类型别名 

用 typealias 关键字定义类型别名

例 typealias AudioSample = UInt16

     var maxAmplitudeFound = AudioSample.min

     // maxAmplitudeFound is now 0

  • 元组(tuple):用于函数返回多个值

1,元组把多个值合并成单一的复合型的值。

例 

let http404Error = (404, "Not Found")

// http404Error is of type (Int, String), and equals (404, "Not Found")

2,可以使用下标访问元组元素

print(“code is /(http404Error.0)”)

 

3, 可以在定义元组的时候给其中的单个元素命名:

 

1

let http200Status = (statusCode: 200, description: "OK")

在命名之后,你就可以通过访问名字来获取元素的值了:

 

1

2

3

4

print("The status code is \(http200Status.statusCode)")

// prints "The status code is 200"

  • 运算符:包含c语言

1,Swift 同时也提供两个等价运算符( ===  和 !== ),可以使用它们来判断两个对象的引用是否相同。

2,范围运算符

a…b ab范围内包括ab

a..<b 含a 不含b

3,取余%可对负数

4,逻辑运算符的操作数必须是Bool类型

5,nil表示值不存在

6,??合并运算符 作用于两个操作数

  左边为可选量,

  • 数组类

定义Array<Type>或 [Type]

例 var allStudents:[String]=[“john”,”Kenny”,”Wendy”,”Kim”]

  • 字典类

定义Dictionary<keyType,valueType>或 [keyType:valueType]

swift的基本语法

阅读数 3355

Swift2.0笔记1

阅读数 347

Swift下标

阅读数 383

没有更多推荐了,返回首页