swift学习笔记-OC与swift区别,从OC到swift你可以看看这个

九路 等级 761 0 0

创建对象

OC:alloc initWith

Swift:(XXX:)

调用方法

OC:[uicolor redcolor]

Swift:uicolor.redcolor()

枚举

OC:UIButtonTypeContactAdd

Swift:UIButtonType.ContactAdd

输出

OC:NSLog(@"Hello, World!");

Swift:2.0开始: print("Hello, World!")

注释

* Swift的编译器将会在编译代码时自动忽略掉注释部分

*单行注释//

*多行注释/**/

与C语言多行注释不同,Swift的多行注释可以嵌套在其它的多行注释之中嵌套多行注释

*注释嵌套/*/**/*/

常量变量

* let常量:常量的值一旦设定就不能改变

* var变量:变量的值可以随意更改

*常量&变量的使用原则:

*为保证数据的安全性尽量先用let,只有需要改变的时候才使用var

常量定义格式

*声明符号常量名称:类型标注

* let number: Int

*特点:一旦设定就不能改变

定义变量格式

*声明符号常量名称:类型标注

* var number: Int

*特点:变量的值可以随意更改

*注意:一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值,Swift可以推断出这个常量或者变量的类型

常量和变量的命名

*你可以用任何你喜欢的字符作为常量和变量名,包括Unicode字符

*常量与变量名不能包含数学符号,箭头,保留的(或者非法的)Unicode码位,连线与制表符

*也不能以数字开头,但是可以在常量与变量名的其他地方包含数字

* ...和C和OC一样, no zuo no die

注意:

*如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名,你可以使用反引号(`)将关键字包围的方式将其作为名字使用。

*无论如何,你应当避免使用关键字作为常量或变量名,除非你别无选择。

let🐶= "狗"

let `int` = 88

类型推断

*编译器可以在编译代码的时候自动推断出表达式的类型。(其它语言是没有类型推断)

*原理很简单,只要检查你赋的值即可

*如果没有指定表达式的类型,也没有赋予初始值,编译器会报错(type annotation missing in pattern)

//:指定类型

let dValue: Double

dValue = 22.2

print(dValue)

//:不指定类型,利用类型推断

let num = 10

print(num)

let value = 10.10

print(value)

元祖

*元组(tuples)把多个值组合成一个复合值

*将多个相同或者不同类型的值用一个小括号括起来就是一个元祖

*元组内的值可以是任意类型,并不要求是相同类型

*作为函数返回值时,元组非常有用

注意:

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

//定义元祖

let student = ("lnj", 30, 99.8)

//通过下标来访问元组中的单个元素

print(student)

print(student.0)

print(student.1)

print(student.2)

//给单个元素命名

let student1 = (name:"lnj",age:30,score:99.8)

print(student1.name)

print(student1.age)

print(student1.score)

//元组的内容分解(decompose)

let (name , age , score) = ("lnj", 30, 99.8)

print(name)

print(age)

print(score)

类型安全

* Swift是一个类型安全(type safe)的语言,它会在编译你的代码时进行类型检查(type checks),并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误

* swift对数据类型要求异常严格, swift中任何时候,都不会做`隐式转换`,如果要对不同类型的数据进行计算,必须显示类型转换

注意:

*结合数字类常量和变量不同于结合数字类字面量。字面量8可以直接和字面量3.1415926相加,因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测

* Double和CGFloat也需要转换

let ii = 10

let jj = 10.1

//let sum = ii + jj //错误写法

let sum = Double(ii) + jj

print(sum)

//注意:Double()并不会修改intValue的值,而是通过intValue的值生成一个临时的值赋值给doubleValue

print(ii)

// Double和CGFloat也需要转换

let size = CGSize(width: 10, height: 10)

let res = size.width + CGFloat(dValue)

流程控制结构

Swift提供了类似C语言的流程控制结构(if/switch/for/while/dowhile)

分支if

*只能以Bool作为条件语句

*条件语句不需要加()

* {}不能省略

* Swift中if分支的模式可以使用where语句来判断额外的条件

*其它和OCif一样

let intValue = 10

if intValue > 5{

print("OK")

}

let testValue: Int? = 10

if let d = testValue where testValue > 9

{

print("满足")

}

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的类型安全机制会报错

//if intValue = 10 { //可能将判断写错, Swift有效的避免了这种情况

if intValue == 10 {

print(intValue)

}

三目运算符

*三目运算符的特殊在于它是有三个操作数的运算符,它简洁地表达根据问题成立与否作出二选一的操作

*格式:问题?答案1 :答案2

提示:

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

注意:

*过度使用三目运算符会使简洁的代码变的难懂。我们应避免在一个组合语句中使用多个三目运算符

let result = intValue > 20 ? 20 : 10

分支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语句不会同时匹配多个条件

var rank = "A"

switch rank{

//default:

// print("没有评级")

case "A", "B":

var num = 10

print("优")

fallthrough

case "C":

print("差")

default:

print("没有评级")

}

匹配区间

*闭区间操作符...包含头包含尾

*半开区间操作符..<包含头不包含尾

var age1 = 10

switch age1 {

case 0:

print("0")

case 1..<18:

print("未成年")

case 18..<30:

print("成年")

default:

print("老年人")

}

//:匹配元祖

var point = (50, 50)

switch point{

//只有where后面的条件表达式为真才赋值并执行case后的语句

case (0, 0):

print("原点")

case (50, 50):

print("中点")

default:

print("Other")

}

//:值绑定(Value Bindings)

switch point{

//只有where后面的条件表达式为真才赋值并执行case后的语句

case var(x, y) where x > y:

print("\(x) > \(y)")

case var(x, y) where x < y:

print("\(x) < \(y)")

default:

print("Other")

}

可选类型

*可选类型表示变量可以有值,也可以没有值

* 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 doubleValue1: Optional = 10.10

var intValue1: Int? = 0

intValue1 = nil

强制解析(forced unwrapping)

let url = NSURL(string: "http://www.520it.com/")

//如果强制解析OptionalValue,但是OptionalValue中没有值时会引发一个运行时错误

print(url!)

//需要考虑url是否有值

if url != nil{

let request = NSURLRequest(URL: url!)

}

可选绑定(optional binding)

*不需要考虑url是否有值,能进入{}一定有值

*不仅可以用来判断可选类型中是否有值,同时可以将可选类型中的值赋给一个常量或者变量

*可选绑定可以用在if和while语句中

提示:

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

if let url3 = NSURL(string: "http://www.520it.com/"){

let request = NSURLRequest(URL: url3)

}

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

*有时候在程序架构中,第一次被赋值之后,可以确定一个可选类型_总会_有值。在这种情况下,每次都要判断和解析可选值是非常低效的,因为可以确定它总会有值

*隐式解析可选类型,并不需要每次都使用解析来获取可选值,一个隐式解析可选类型其实就是一个普通类型,但是可以被当做非可选类型来使用

*格式:将可选类型后面的?改为!

* let xmgButton: UIButton!

注意:

*如果一个变量之后可能变成nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话,请使用普通可选类型

let url3: NSURL? = NSURL(string: "http://www.520it.com/")

let url4: NSURL! = NSURL(string: "http://www.520it.com/")

print(url3!) //需要惊叹号来获取值

print(url4) //不需要感叹号

循环

for循环-传统

* for后的圆括号可以省略

*只能以bool作为条件语句

*如果只有条指令for后面的大括号`不可以`省略

* for后面的三个参数都可以省略,如果省略循环保持语句,那么默认为真

for var i = 0; i < 10; i += 1

{

print(i)

}

for循环-Swift

*闭区间:包含区间内所有值a...b例如: 1...5

*半闭区间:包含头不包含尾a..

// 0~9之间

for i in 0..<10

{

print(i)

}

// 0~10

for i in 0...10

{

print(i)

}

忽略_

*不关心下标可以使用_忽略下标

*在Swift中_使用非常广泛

for _ in 0...10

{

print("lnj")

}

while循环

//: while循环,每次在循环开始时计算条件是否符合

var n = 0

while n < 10

{

print(n)

n += 1

}

//: repeat-while,每次在循环结束时计算条件是否符合

var m = 0

repeat{

print(m)

m += 1

}while m < 10

数组(有序数据集)

* Swift的Array类型被桥接到Foundation的NSArray类。

*格式: [] / [Int]() / Array()

* let不可变数组

* var可变数组

注意:

*不需要改变集合的时候创建不可变集合是很好的实践。如此Swift编译器可以优化我们创建的集合。

//创建一个空数组

var arrayM5: [String] = []

var arrayM4 = [String]()

var arrayM6 = Array()

//创建一个带有默认值的数组

let array1 = ["lnj", "lmj"]

let array2 = Array(count: 5, repeatedValue: 0)

//遍历

for item in array1{

print(item)

}

//遍历同时拿到索引

for (index, item) in array1.enumerate()

{

print("index = \(index), item \(item)")

}

//获取元素

array1[0]

array1[1]

//添加元素

//不能像不可变数组中添加内容

//array1.append("why")

// let不可变对象, var可变对象

var arrayM = ["lnj", "lmj"]

arrayM.append("why")

//数组可以存放任意类型

var arrayM2 = ["lnj", "lmj", 123]

arrayM2.append("456")

//如果需要添加其它类型必须提前声明为AnyObject

//arrayM.append(123)

//合并数组

var arrayM3 = ["zs", "ls", "ww", "zl"]

arrayM += arrayM3

//只有相同类型的数组才可以合并

//arrayM2 += arrayM3

print(arrayM.count)

//和区间搭配使用

arrayM += arrayM3[0...2]

print(arrayM.count)

//删除

arrayM3.removeAtIndex(1)

arrayM3

//删除所有

//arrayM3.removeAll()

//和区间搭配使用

//arrayM3.removeRange(Range(start: 0, end: 2))

arrayM3.removeRange(0..<2) //其实Range就是半闭区间

arrayM3

//删除并保留容量

arrayM3.removeAll(keepCapacity: true)

arrayM3.capacity

arrayM3.append("1")

arrayM3.capacity

arrayM3.append("2")

arrayM3.capacity

arrayM3.append("3")

arrayM3.capacity

arrayM3.append("4")

arrayM3.capacity

arrayM3.append("5")

//超过容量,容量会直接*2

arrayM3.capacity

字典(无序数据集)

* Swift的Dictionary类型被桥接到Foundation的NSDictionary类。

*格式[:] / Dictionary

* let不可变字典

* var可变字典

注意:

*一个字典的Key类型必须遵循Hashable协议

//创建一个空字典

var dict3: [String: AnyObject]

dict3 = [:]

var dict4 = [String: AnyObject]()

//创建一个带有默认值字典

var dict5 = ["name": "lnj", "age": 30]

//最常见的字典类型[String : AnyObject],例如JSON

var dict = ["name":"lnj", "age": 30]

//遍历字典

// k,v可以随便写,前面是key后面是value

for (k, v) in dict{

print(k)

print(v)

}

//获取元素

dict["name"]

//添加元素

//如果key不存在会新增

dict["gender"] = "man"

dict

//替换元素

//如果key存在会替换

dict["name"] = "why"

//删除元素

dict.removeValueForKey("name")

dict

//合并字典

var dict2 = ["score": 123]

for (k, v) in dict2{

dict[k] = v

}

dict

字符串

* Swift的String类型与Foundation NSString类进行了无缝桥接

* OC语言中的字符串也是以\0结尾, Swift不是

* OC中字符串是一个对象, Swift中使用String是一个结构体,效率更高,支持遍历

注意

* Swift的String类型是值类型。如果您创建了一个新的字符串,那么当其进行常量、变量赋值操作,或在函数/方法中传递时,会进行值拷贝。任何情况下,都会对已有字符串值创建新副本,并对该新副本进行传递或赋值操作

// Swift字符串不是以\0结尾

var stringValue = "abc\0bcd"

print(stringValue)

//遍历字符串

var str = "南哥很帅"

for c in str.characters

{

print(c)

}

//连接字符串和字符

var str2 = "cool"

str2 += str

let myAge:Int? = 30

let myName = "lnj"

//字符串插值

//拼接字符串的时如果字符串是可选内心,要特别注意,会带上Optional

let str3 = "name = \(myName), age = \(myAge!)"

//需要格式的时候,怎么办00:00:00

let frmStr = String(format: "%02d:%02d:%02d", arguments: [9, 23, 8])

//字符串截取,建议使用NSString

let str4 = "xmgcool"

let nsStr: NSString = str4

let subStr = nsStr.substringWithRange(NSMakeRange(0, 3))

//使用startIndex属性可以获取一个String的第一个Character的索引

//使用endIndex属性可以获取最后一个Character的后一个位置的索引

let subStr2 = str4.substringToIndex(str4.startIndex.advancedBy(3))

let range = Range(start: str4.startIndex, end: str4.startIndex.advancedBy(3))

let subStr3 = str4.substringWithRange(range)

函数:

*函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字,用来标识函数做什么,并且当函数需要执行的时候,这个名字会被用于“调用”函数

*格式:

* func函数名称(参数名:参数类型,参数名:参数类型...) ->函数返回值{函数实现部分}

没有参数没有返回值

1.可以写为->Void

2.可以写为->()

3.可以省略

* Void。它其实是一个空的元组(tuple),没有任何元素,可以写成()

func say() -> Void{

print("lnj")

}

say()

func say2() -> (){

print("lnj")

}

say2()

func say3(){

print("lnj")

}

say3()

有参数没有返回值

内部/外部参数

*内部参数: Swift2.0以前,默认情况下的参数都是内部参数

* Swift2.0开始,默认将第二个参数名称作为外部参数

*外部参数只能外部用,函数内部不能使用,函数内部只能使用内部参数

*忽略外部参数:在内部参数前加_

func sum(a: Int, b: Int){

print(a + b)

}

sum(10, b: 20)

func summ(a: Int, _ b: Int){

print(a + b)

}

summ(10, 20)

// xy外部参数, ab内部参数

// Swift2.0以前可以写#

func sum2(x a: Int, y b: Int){

print(a + b)

}

sum2(x: 10, y: 20)

默认参数(Default Parameter Values)

*格式: func method(parameter: Int = 0){}

*当默认值被定义后,调用这个函数时可以忽略这个参数

*其它语言的默认参数必须写在最后面, Swift可以写在任意位置

注意

*将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时,非默认参数的顺序是一致的,同时使得相同的函数在不同情况下调用时显得更为清晰。

func joinString(s1:String , jioner:String = "❤️",toString s2:String) ->String

{

return s1 + jioner + s2;

}

joinString("lnj", jioner: "和", toString: "xmg")

joinString("lnj", toString: "xmg")

常量参数和变量参数(Constant and Variable Parameters)

*函数参数默认是常量,在函数内部不能修改

*如果想在函数中修改参数,必须在参数前加上var

注意

*对变量参数所进行的修改在函数调用结束后便消失了,并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中

func swap(var a:Int, var b:Int)

{

print("交换前a = \(a) b = \(b)")

let temp = a;

a = b; //可以修改,但不会影响实参

b = temp;

print("交换后a = \(a) b = \(b)")

}

var x = 10

var y = 20

print("交换前a = \(x) b = \(y)")

swap(x, b: y)

print("交换后a = \(x) b = \(y)")

输入输出参数(In-Out Parameters)

*变量参数,正如上面所述,仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值,并且想要在这些修改在函数调用结束后仍然存在,那么就应该把这个参数定义为输入输出参数(In-Out Parameters)

*定义一个输入输出参数时,在参数定义前加inout关键字

注意

*输入输出参数不能有默认值,而且可变参数不能用inout标记。如果你用inout标记一个参数,这个参数不能被var或者let标记。

func swap2(inout a:Int, inout b:Int)

{

let temp = a;

a = b;

b = temp;

}

var x1 = 10;

var y1 = 20;

print("交换前a = \(x1) b = \(y1)")

swap2(&x1, b: &y1)

print("交换后a = \(x1) b = \(y1)")

可变参数(Variadic Parameters)

*一个可变参数可以接收零个或多个值

*如果没有变参函数,并且函数的参数个数又不确定那么只能写多个方法或者用将函数参数改为集合

*格式func method(parameter: Int...){}

*可变参数在函数中可以当做一个数组

注意

*一个函数最多只能有一个可变参数

*变参只能是同种类型的数据

*变参必须指定数据类型

*如果函数有一个或多个带默认值的参数,而且还有一个可变参数,那么把可变参数放在参数表的最后

func add(nums:Int..., other:Int) -> Int

{

var sum = 0;

for num in nums

{

sum += num

}

return sum + other

}

print(add(1, 2, 3, other: 9))//会将99传递给第一个参数,后面的传递给nums

//没有参数有返回值

func getNumer() ->Int{

return 998

}

print(getNumer())

//有参数有返回值

func sum3(a: Int, b: Int) ->Int{

return a + b

}

print(sum3(10, b: 20))

//嵌套函数

func showArray(array:[Int])

{

//嵌套函数

func printArray(arr:[Int])

{

for number in array

{

print("\(number), ")

}

}

printArray(array)

}

showArray([1, 3, 5, 7, 9])

函数类型(Function Types)

*函数类型作为参数类型(Function Types as Parameter Types)

*函数类型作为返回类型(Function Types as Return Types)

*嵌套函数(Nested Functions)

提前退出

*像if语句一样,guard的执行取决于一个表达式的布尔值。我们可以使用guard语句来要求条件必须为真时,以执行guard语句后的代码。

*如果guard语句的条件被满足,则在保护语句的封闭大括号结束后继续执行代码

*任何使用了可选绑定作为条件的一部分并被分配了值的变量或常量对于剩下的保护语句出现的代码段是可用的

*如果条件不被满足,在else分支上的代码就会被执行。

* else这个分支必须转移控制以退出guard语句出现的代码段。它可以用控制转移语句如return,break,continue或者throw做这件事

func divide3(dividend: Double?, divisor: Double?) -> Double? {

guard let dividend = dividend else {

return .None

}

guard let divisor = divisor else {

return .None

}

guard divisor != 0 else {

return .None

}

return dividend / divisor

}

print(divide3(10, divisor: 20))

收藏
评论区

相关推荐

Swift 简介
Swift和ObjectiveC的主要区别 1,编程范式 Swift可以面向协议编程、函数式编程、面向对象编程。 Swift语言引入了协议、协议的扩展、泛型等新特性,因此使用Swift语言可以很好地面向协议编程;Swift语言将函数和闭包提升为语言的一等公民,函数可以作为一个变量、可以作为其他函数的参数、作为其他函数的返回值等来传递,所以
Swift开发-OC与Swift混编以及纯Swift编码所遇到的问题(一)
前言: 最近一段时间比较忙,公司项目比较多,直到现在年后过来以 后总结一下之前项目中遇到的问题,以及自己使用Swift开发所遇到的坑。现在大家都知道Swift已经渐渐趋于完善,以后很有可能会替代ObjectC成为主流的iOS开发语言,所以各位以后还想从事iOS开发的程序猿(媛)们,早作准备吧! 今天我们主要说一下ObjectiveC和Swift混编
Swift开发-OC与Swift混编以及纯Swift编码所遇到的问题(一)
前言: 最近一段时间比较忙,公司项目比较多,直到现在年后过来以 后总结一下之前项目中遇到的问题,以及自己使用Swift开发所遇到的坑。现在大家都知道Swift已经渐渐趋于完善,以后很有可能会替代ObjectC成为主流的iOS开发语言,所以各位以后还想从事iOS开发的程序猿(媛)们,早作准备吧! 今天我们主要说一下ObjectiveC和Swift混编
Swift开发-OC与Swift混编以及纯Swift编码所遇到的问题(二)
上篇在介绍了Swift与OC混编开发所需要准备的一些必要条件 SwiftObjectiveC混编注意事项(https://www.jianshu.com/p/52ab6a316cbe),今天只说一下我在实际项目中所踩过的坑,希望你们以后绕过这些坑吧。 1、 使用cocopods管理Swift文件所遇到的问题: 我们在开发的过程中,各种优秀的框架
swift学习笔记-OC与swift区别,从OC到swift你可以看看这个
创建对象 OC:alloc initWith Swift:(XXX:) 调用方法 OC:uicolor redcolor Swift:uicolor.redcolor() 枚举 OC:UIButtonTypeContactAdd Swift:UIButtonType.ContactAdd 输出 OC:NSLog(@"Hello
【Swift】Swift 2.0 到 Swift 3.0
问: 报错:The “Swift Language Version” (SWIFT\_VERSION) build setting must be set to a supported value for targets which use Swift. This setting can be set in the build settings editor
Swift
在oc中有NSMutableString和NSString两种类型的字符串,但在swift中分别在定义的时候使用let和var来代表是否可以操作。let和var也通用于其他类型。使用let修饰的为不可变,使用var修饰的可变。 //使用var修饰可以动态的改变值 var varStr = "nihao"
Swift3.0对AFNetworking的封装 附demo
> 由于最新的**[Alamofire](https://www.oschina.net/action/GoToLink?url=https%3A%2F%2Fgithub.com%2FAlamofire%2FAlamofire)**网络框架只支持Swift 3.0, 现在还有一大部分开发者 在项目中用OC于Swift混编的方式,所以就用最新的Swift 3.
Swift专题讲解二十——扩展
Swift专题讲解二十——扩展 --------------- ### 一、简介         Swift中的扩展与Objective-C中的类别功能相似,扩展可以为一个已有的类、结构体、枚举或者协议添加新的属性或方法,与Objective-C的类别不同的是,Swift中的扩展没有名称。         Swift中的扩展支持如下功能: 1.添加计
Swift学习第一练——用Swift实现的FlappyBird小游戏
用Swift实现的FlappyBird小游戏 ----------------------       伴随着apple公司对swift的推广态度深入,swift火的很快,并且swift精简便捷的语法和强大的功能,对于使用Object—C开发iOS的开发者来说,也有必要了解学习一下swift。这篇博客跳过swift干涩的语法,直接从一个小游戏项目开始使用s
Swift学习第二练——Swift项目时光电影
Swift学习第二练——Swift项目时光电影 -----------------------     很早以前的一个OC的练习项目,用swift重新写了一遍,因为xcode版本的更新对swift的兼容度也在不断改变,此版本适用于xcode6.1。     这个项目中,用swift将iOS官方SDK中的HTTP进行了封装,使用了swift编写的异步加载网
Swift解读专题四——字符串与字符
Swift解读专题四——字符串与字符 ------------------ ### 一、引言         Swift中提供了String类型与Characters类型来处理字符串和字符数据,Swift中的String类型除了提供了许多方便开发者使用的方法外,还可以与Foundation框架的NSString类进行转换,使用起来十分方便。 ### 二
Swift讲解专题七——函数
Swift讲解专题七——函数 -------------- ### 一、引言         函数是有特定功能的代码段,函数会有一个特定的名称调用时来使用。Swift提供了十分灵活的方式来创建与调用函数。事实上在Swift,每个函数都是一种类型,这种类型由参数和返回值来决定。Swift和Objective-C的一大区别就在于Swift中的函数可以进行嵌套
Swift调用sha1算法
在Swift中通过调用OC的CommonCrypto库可以很方便的实现String字符串转换为sha1。 在一个swift项目中,需要使用桥接头文件(Bridging header)的方式来引入一个OC库,才能调用OC中的内容。 本文也将作为Swift项目中如何调用Objective-C代码的一个介绍。 ### 标准实现步骤 1、新建一个**Obje
swift中更强大的switch和眼花缭乱的for in
从日记中整理出switch和for in。swift的switch比起oc真的是厉害坏了而且for in中的功能也比oc的更加灵活。小作笔记 1.1 swift中swich语句会将一个值与多个可能的模式匹配。然后基于第一个成功匹配的模式来执行合适的代码块,如果想要oc中匹配到case后依旧贯穿接下来的case则要增加fallthough。switch语句一