分类 移动开发 下的文章

/**

 *创建函数

 * 参数是String，返回值是String。其中参数和返回值都是可选的，但是如果有参数，或者有return，则是必须的

 */

func sayHello(name:String)->String{

    return "Hello "+name+"."

}

println(sayHello("lane"))


func sayHelloOptional(name:String?)->String{

    var result = "Hello," + (name ?? "Guest")

    return result

}

var name:String?

println(sayHelloOptional(name))


/**

 *函数和元组

 * 参数是String，返回值是String。其中参数和返回值都是可选的

 */

func maxMinScores( scores:[Int] )->( maxScore:Int, minScore:Int)?{

    if scores.isEmpty{

        return nil

    }

    var curmax = scores[0]

    var curmin = scores[0]

    for score in scores[1..<scores.count]{

        curmax = max(curmax, score)

        curmin = min(curmin, score)

    }

   //两种返回方式

    return (maxScore:curmax, minScore:curmin)

   //两种返回方式

   //return (curmax, curmin)

}


var userScores:[Int]? = [12, 990, 572, 3258, 9999, 1204]

userScores=userScores?? []

if let maxMin = maxMinScores(userScores!){

    maxMin.maxScore

    maxMin.minScore

}


/**

 *值传递、引用、默认情况

 */

//默认下不能对参数修改，只能读取。此时参数被称为常数参数

func paramTest(varName:Int)->Int{

    var sum = varName*2;

   //报错，不能对参数修改，只能读

   //varName--;

    return sum

}

//值传递，可读可写，变量前面加一个var

func paramTest1(var varName:Int)->Int{

    var sum = varName*2;

   //这个时候下句不报错了。

    varName--;

    return sum

}

//引用，可读可写，变量前面加一个inout，使用时加&

func paramTest2(inout varName:Int)->Int{

    var sum = varName*2;

   //这个时候下句不报错了。

    varName--;

    return sum

}

var param = 10;

paramTest(param)

//param = 10

paramTest1(param)

//param = 10

paramTest2(&param)

//param = 9



/**

 *函数类型

 */

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

    return a+b

}

//隐式声明一个函数类型

let funcVar = add

add(3, 4)

//显式声明一个函数类型

let funcVar2:(Int, Int)->Int = add

//显式声明一个不需要参数和返回值的函数类型

func voidFunc(){

   println("hello world")

}

//let funcVar3:()->() = voidFunc

let funcVar4:()->Void = voidFunc


/**

 *函数嵌套

 */

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

    func num(c:Int)->Int{

        return c*c

    }

    return num(a) + num(b)

}

sum(10, 20)


/**

 *返回函数类型的函数

 */

func func1(a:Int)->String{

    return "结果是"+String(a * a)

}

func func2(a:Int)->String{

    return "结果是"+String(a + a)

}

func choseFunc(a:Int)->(Int)->String{

    var result:(Int)->String

    if a%2==0 {

        result = func1

    }else{

        result = func2

    }

    return result

}

var funcName = choseFunc(10)

funcName(10)

funcName=choseFunc(5)

funcName(5)




    Swift条件控制，有for，for...in...，switch，if...else，while等，而跳出条件控制有break，continue，fallthrough。本篇文章变分析这几个控制的特性。

    for in相关的如下：

/**

* for - in 循环

*/

//for循环 >=-10 <=10

for i in -10...10{

    i*i

}

//遍历一个数组

var arr = ["a", "b", "c"]

for a in arr{

    println(a)

}

for (key, value) in enumerate(arr){

    println("\(key):\(value)")

}

//遍历一个字典

vardict = ["a":"A","b":"B","c":"C"]

for (key, value) in dict{

    println("\(key):\(value)")

}

    for相关的如下：

/**

* for 循环

*/

//等同for var i = -100; i<=100; i++

var i = -10

for ; i<=10; i++

{

    i*i

}

    if相关的如下：

//if else

iftrue{

    

}else{

    

}

    switch相关的如下：

/**

 *switch,可以对Int，String，Bool，Float，Double进行判断

 *

 *不需要显式写break;

 */

var switchValue = "a"

switchswitchValue{

    case "a":

        println("a")

    case "b":

        println("b")

   default:

        println("d")

}

//判断多个值不能写：

//case "a":

//case "A":

//  println("ok");

//而是应该写：

//case "a", "A":

    switch高级特性相关的如下：

/**

 * switch高级特性

 */

//元组在switch中

//如果想执行第一个case后还想执行第二个case，则添加fallthrough，此时直接进入下面的语句，不进行case判断

var request = (true, "success")

switchrequest{

   //这个是正确的

    case (true, "success"):

       println("true, success")

       fallthrough

   //这个也是正确的，可以忽略元组的第一个元素，将剩下的元素判断

    case (true, _):

       println("true, success")

   //这个也是正确的

    case (true, let requestStatus):

        println("当前登陆状态为：\(requestStatus)");

   default:

       println("not found!")

}

//switch可以比较范围

var request2 = (5, 12);

switchrequest2{

    case (1...8, 10...20):

        println("ok")

   default:

       println("not found!")

}

//switch的case中可以增加逻辑判断

var request3 = (3, 3)

switchrequest3{

    case let(x, y) where x==y:

        println("\(x)->\(y)")

   default:

       println("not found!")

}

    控制转移相关的如下，break只能跳出一层循环，如果要跳出多层，可以看下面的例子。另外break只能跳出循环，而不是花括号得代码块，比如if：

/**
 *控制转移
 * fallthrough、break、continue
 */
import UIKit
var board = Array<Array<Int>>()
for i in 0...10{
    board.append(Array(count:10, repeatedValue:0))
}
let x = Int(arc4random()%10)
let y = Int(arc4random()%10)
board[x][y] = 1
board
var i = 0, j = 0
mainloop:for i = 0; i<10; i++ {
    for j=0; j < 10; j++ {
        if board[i][j] == 1 {
            break mainloop
        }
    }
}
println("\(i)-\(j)")

    Swift的集合有两种，是数组和字典，显式声明和隐式声明、增删改查、基本操作等将在本文介绍。

/**

 *数组的初始化

 */

//数组只能存同一种数据类型

var array = ["a", "b", "c"]

array[0] = "A"

//显式的声明存储字符串的数组

var array2:[String] = ["a", "b", "c"]

var array3:Array<String> = ["a", "b", "c"]

//创建空数组，存储Int类型

var array4 = [Int]()

var array5 = Array<String>()

var array6:[Int] = []

var array7:Array<Int> = []

//清空数组，清空后，后期仍然只能使用之前定义的数据类型

array2 = []

array2 = [String]()

array2 = Array<String>()

//初始化，10个值，每个值都为0

var array8 = [Int](count:10, repeatedValue:0)

//数组合并

var array9 = [1, 2, 3]

var array10 = array8+array9



/**

 *数组的基本操作

 */

var array = ["A", "B", "C", "D"]

//数组的总数

array.count

//数组是否为空

array.isEmpty

//数组结尾加入新的元素

array.append("E")

array += ["F"]

array += ["G", "H"]

//数组任意位置加入新元素

array.insert("b", atIndex: 2)

//删除任意位置的元素，返回所删除的元素的值

array.removeAtIndex(1)

//删除最后一个元素

array.removeLast()

//删除所有元素

array.removeAll(keepCapacity: false)

//修改单个元素

array[0] = "AA"

//修改一组元素，若key为2...4，包含2，3，4三个key，而value只有一个，那么2，3，4三个值将只剩一个

array[2...4] = ["AA", "BB", "CC"]

array[2..<4] = ["AA", "bb"]

//遍历数组

for index in 0..<array.count{

    println("\(index) -> \(array[index])")

}

for item in array{

    println(item)

}

for (index, item) in enumerate(array){

    println("\(index) -> \(item)")

}



/**

 * 字典

 *键值对，可以是任意类型，但是一旦声明了一个字典，那么只能有一种搭配的类型。比如下面是键是Int，值是String。那么所有的键都必须是Int，所有的值都必须是String

 */

//隐式声明字典

var dictionary = [1:"a", 2:"b", 3:"c"]

//现式声明字典

var dictionary1:Dictionary<Int, String> = [1:"a", 2:"b", 3:"c"]

var dictionary2:[Int:String] = [1:"a", 2:"b", 3:"c"]

//声明空字典、清空一个已有的字典

var dictionary3 = Dictionary<Int, String>()

var dictionary4 = [Int, String]()

//清空字典的特殊表示

dictionary4 = [:]


/**

 *字典的基本操作

 */

//字典总数

var dictionary = [1:"a", 2:"b", 3:"c"]

dictionary.count

//字典是否为空

dictionary.isEmpty

//调用，传入的key可以是任意值，程序不会报错，因为返回的是optional。key不存在时返回nil

dictionary[1]

"第一个元素：" + dictionary[1]!

//插入新元素

dictionary[4] = "d"

//修改元素两种方式

dictionary[4] = "e"

var oldValue = dictionary.updateValue("e", forKey: 4)

//删除元素两种方式

dictionary[4] = nil

var oldValue4 = dictionary.removeValueForKey(4)

//字典的遍历

for (key, value) in dictionary{

    println("\(key) -> \(value)")

}

//遍历key

Array(dictionary.keys)

[Int](dictionary.keys)

//遍历value

Array(dictionary.values)

[String](dictionary.values)

    初探Swift之Swift字符串、字符串处理、字符串函数。Swift字符串本质是一个对象，同其他语言一样，可以使用拼接、长度、子字符串查找、子字符串替换、子字符串删除等操作。


//字符串长度，长度为5

var str_es = "swift"

countElements(str_es)

//中文字符串长度，长度为2，一个汉子为1

var str_ch = "你好"

countElements(str_ch)


//声明一个字符

let myChar:Character = "!"


//比较，同其他语言，是按照字典的顺序。与长度无关

let a = "abcd";

let b = "abd";

a == b

a > b

a < b


//字符串的前缀和后缀

let chapterNames = [

    "第一：1111",

    "第二：1111",

    "第二：1111a",

    "第二：1111",

    "第三：1111",

    "第三：1111a",

]

//前缀为“第二”的个数统计

var count = 0

for name in chapterNames{

    if name.hasPrefix("第二"){

        count++

    }

}

count

//后缀为“a”的个数统计

count = 0

for name in chapterNames{

    if name.hasSuffix("a"){

        count++

    }

}

count




//字符串高级操作，需要引入Foundation

import Foundation


var str = "hello WOrld";

//首字母大写

str.capitalizedString

//大写

str.uppercaseString

//小写

str.lowercaseString


//去除两边的空格

var str2 = "  hi ! "

str2.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())


//字符串按照空格分割为数组，同php的explode函数

var str3 = "hello world"

str3.componentsSeparatedByString(" ")


//数组连接为字符串，同php的implode函数

var str4 = "_"

str4.join(["1","2","3"])


//查找字符串

var str = "Welcome to play Swift! Step by Step learn Swift language from now!"

str.rangeOfString("Step")

//第二个参数是枚举，可以根据Xcode的提示看到，NSStringCompareOptions.CaseInsensitiveSearch是不区分大小写

str.rangeOfString("welcome", options: NSStringCompareOptions.CaseInsensitiveSearch)


//字符串的开头位置

str.startIndex

//字符串的结束为止

str.endIndex


//Range

let strRange = Range<String.Index>(start:str.startIndex, end:str.endIndex)

//在Range范围内查找

let startIndex = str.startIndex

let endIndex:String.Index = advance(str.startIndex, 10)

let searchRange = Range<String.Index>(start:startIndex, end:endIndex)

str.rangeOfString("Step", options: NSStringCompareOptions.CaseInsensitiveSearch, range: searchRange)

//截取开头的4个字符

var toIndex = advance(str.startIndex, 4)

str.substringToIndex(toIndex)

    初探Swift，Swift变量声明，let和var分别声明常量和变量。Swift数据类型，包括整型，浮点型，字符型，布尔型，可选型等，已经强制类型转换和if选择。

//-----------变量相关----------

//常量

let maxNum = 1000

//变量

var index = 0


var a=0.0, y=0, z=0

a = 1;

a = 1.1;

//报错

//a = "a";


//显示申明类型

var test : Int

test = 10


var red, green, blue : Int

//十进制

red = 17;

//二进制，以0b开头

red =0b10001

//八进制，以0o开头

red = 0o21

//十六进制，以0x开头

red = 0x11


//科学计数法

let b = 0.012

letc =1.2e-2


//多位整数的表示法

lete =1000000

letf =1_000_000

letg =1_000_000


//自动类型转换

let h:Float = 1

//Xcode beta2会将1.2转为1，而Xcode beta3直接报错。

//let i:Int = 1.2


//强制类型转换

let j:Double = Double(h) + b


//变量名，任何unicode都可以

let 姓名 = "小明"

println(姓名 + "，你好")




//----------选择-----------

let bool1 = true

let bool2:Bool = false


//即使语句块只有一行，花括号{}也不能省略,在选择里，只有true和false，1和0都是不可以的。

if bool1{

    println("hello");

}else if bool2{

    println("world");

}else{

    println("swift");

}




//---------元组-----------

let tuples_1 = ("小明", "男", 21, true)

//元组可以赋值给变量

let (name, sex, age, status) = tuples_1

println("姓名："+name+"，性别："+sex);

//元祖可以用.0，.1，.2来访问

println("姓名："+tuples_1.0+"，性别："+tuples_1.1);


//每个元祖都赋一个key

let tuples_2 = (date:"2015-01-05", time:"16:06", author:"lane")

println("日期："+tuples_2.date+" "+tuples_2.time+"，作者："+tuples_2.author);

println("日期："+tuples_2.0+" "+tuples_2.1+"，作者："+tuples_2.2);


//至提取元组的第一个值，不关心后面的值

let login = (true, "小明")

let (staic, _) = login

if staic{

    println("hi");

}else{

    println("hi hi");

}

//元组的类型显示声明

let login2:(Bool, String) = (true, "小明")



//可选型optional

var optionalVar1:Int?

optionalVar1=1


let userAge = "18"

var age = userAge.toInt()


if(age != nil){

    println("You age is " + String(age!) )

}else{

   println("Invalidate userInput")

}


//解包

if let userInput = userAge.toInt(){

    println("you age is\(userInput)");

}

let m:String? = "hello";

let n:String! = "hi";

  1. 1
  2. 2