Swift基础语法1

苹果提供了学习swift的非常好的工具就是Xcode中的playground。使用方法为如图：

1步



2步



之后就能够使用了，并且是实时结果显示

var str ="Hello, playground"

print("hello word")

print(str)

let  myTest = 12 //常量

var  myTest1 = 15//变量

myTest1=16

print(myTest)

print(myTest1)

let mytest2 : Double =20

print(mytest2)

//连接方式是类型（值）

let label =
"My GoodLuck Figure"

let Figure = 66

let labelFigure = label +String(Figure)

print(labelFigure)

//连接方式 \(值)

let apples = 3

let oranges = 5

let appleSummary = "I have\(apples)."

let fruitSummary ="I have\(apples+oranges)
pieces of\(appleSummary)"

print(appleSummary)

print(fruitSummary)

let shopingList = ["11","22","33"]

var shopingList1 = ["44","55","66"]

shopingList1[1]="123"//将数组内容替换掉

print(shopingList)

print(shopingList1)

//创建字典 将字典替换掉

var occupations = [

    "123":"234",

    "345":"456",

]

occupations["123"]="你好啊"

print(occupations)

//初始化数组和字典

shopingList1=[]

occupations=[:]

//流程控制图在类型后面加一个 ?来标记这个变量的值是可选的。

var optionalString: String? ="Hello word"

optionalString == nil

var optionalName: String? ="WPJ"

optionalName == nil

var greeting = "Hello!"

if let name =optionalName{

    

   greeting ="Hello,\(name)"

    greeting ="Hello1,\(greeting)\(optionalString)"

    

}else {

    print(greeting)

}

print(greeting)

//switch  switch 中匹配到的子句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句结尾写break。

let vegetable = "red pepper"

var vegetableComment = ""

switch vegetable {

case "celery":

     vegetableComment ="Add some raisins and make ants on a log."

case "cucumber","watercress":

     vegetableComment ="That would make a good tea sandwich."

case let xwhere x.hasSuffix("pepper"):

     vegetableComment ="Is it a spicy\(x)?"

default:

     vegetableComment ="Everything tastes good in soup."

}

print(vegetableComment)

//for in 使用

let interestingNumbers = [

    "Prime": [2,3,5,7,11,13],

    "Fibonacci": [1,1,2,3,5,8],

    "Square": [1,4,9,16,25],

]

var largest = 12

for (kind, numbers) ininterestingNumbers {

    print("111111----\(kind)")

    print("222222----\(numbers)")

    for numberin numbers {

        if number <largest {

            largest = number

        }

    }

}

//求数组中的最大数和最小数

print(largest)

var n = 2

while n <100 {

    n =
n * 2

}

print(n)

var m = 2

repeat {

    m =
m * 2

} while
m < 100

print(m)

var firstForLoop = 0

for i in0..<3 {

    firstForLoop +=1

}

print(firstForLoop)

var secondForLoop = 0

for var i =0 ; i <3 ; i++ {

    secondForLoop +=1

}

print(secondForLoop)

//声明一个函数调用

func greet(name: String, day:String) ->String
{

    return"Hello\(name),
today is\(day)."

}

print(greet("wpj", day:"tuesday"))

func getGasPrices() -> (Float,Int,NSNumber)
{

    return (3.59,69,3.79)

}

getGasPrices()

print(getGasPrices())

//-> 标示返回值得类型

func sumOf(numbers: Double...) ->Double {

    var sum =0.00

    for numberin numbers {

        sum += number

    }

    return sum

}

sumOf()

sumOf(42,597,12)

print(sumOf())

print(sumOf(1.11,2,3))

func returnFifteen() ->
Int {

    var y =10

    y = 10

    func add()

    {

        y+=5

    }

    add()

    return y

    

}

print(returnFifteen())

func makeIncrementer() -> (Int ->Int) {

    func addOne(number:Int) ->Int {

        return1 + number

    }

    returnaddOne

}

var increment = makeIncrementer()

print(increment(5))

func hasAnyMatches(list: [Int], condition:Int ->Bool)
->Bool {

    for itemin list {

        if condition(item) {

            returntrue

        }else

        {

            returnfalse

        }

    }

    returnfalse

}

func lessThanTen(number:
Int) -> Bool {

    return number <10

}

var numbers = [20,19,7,12]

print(hasAnyMatches(numbers, condition:lessThanTen))

print(lessThanTen)

numbers.map ({ (number:Int) ->Intin

    let result =3 * number

    return result

})

print(numbers.map({numberin3
* number}))

class Shleep {

    var numberOfSides =0

    func simpleDescription() ->String {

        return"A shape with\(numberOfSides)
sides."

    }

    

}

print(Shleep)

/*在32位平台上，Int和Int32长度相同。

 在64位平台上，Int和Int64长度相同。*/

let minValue=UInt8.min,maxValue=UInt8.max

print(minValue,maxValue)

let minValue1=Int8.min,maxValue1=Int8.max

print(minValue1,maxValue1)

let minValue2=UInt.min,maxValue2=UInt.max

print(minValue2,maxValue2)

/*Double：64位浮点数。当你需要存储很大或者很高精度的浮点数时使用此类型。

 Float：32位浮点数。精度要求不高时使用此类型*/

typealias AudioSample =
UInt16 //起别名

var BoolType:Bool

BoolType=true//布尔型用true和false 不能用yes和no不能用1和0

print(BoolType)

/*Swfit 类型安全检查会阻止非 Boolean类型的值用在 Boolean的地方。下面的例子中编译器会报告错误：*/

let http404Error = (404,"Not Found")

/*(404, "Not Found") 是将一个 Int类型值和一个 String类型值组合在一起，表示
HTTP状态码的两个部分：数字和描述。它可以被描述为 “一个（Int，String）类型的元组”。*/

let (statusCode,statusMessage) =http404Error//将http404分解成单独的常量或变量(这里是常量)

print(statusCode)

print(statusMessage)

let (justStatuCode,_) =http404Error//只需要一部分的话 忽略的部分用_代替

print(justStatuCode)

http404Error.1

http404Error.0//索引标示元素中的值

//给元组中的元素重命名

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

print(http200Status.statusCode)//直接打印statusCode
404  但是重命名之后打印200

print(http200Status.description)

//toInt  将字符串转换成int类型 强制转型可用以下方法 类型（对象）

let possibleNumber = ""

let convertedNumber = Int(possibleNumber)

//打印对象的类型方法

let typeName =
convertedNumber.dynamicType

//! 表示有值要使用它

print(typeName)

print(possibleNumber.dynamicType)

if convertedNumber==111{

    print("\(possibleNumber)
has an integer value of \(convertedNumber!)")//此处不加！则会打印Optional(111)加！则表示有值强制解析

}else{

    print("\(possibleNumber)
could not be converted tu an integer)")

}

//print(convertedNumber!)

//可选绑定 用来判断actualNumber 是否有值

if var actualNumber =Int(possibleNumber)
{

    print("\(possibleNumber)
has an integer value of \(actualNumber)")

} else {

    print("\(possibleNumber)
could not be converted to an integer")

}

//如果定义一个可选常量或变量没有提供默认值，它们会被自动设置为 nil  任何类型的可选都可以被设置为
nil，不只是对象类型。

var surveyAnswer: String? ="123"

print("surveyAnswer is\(surveyAnswer)")

print("surveyAnswer add ! is\(surveyAnswer!)")

var surveyAnswer1: String?

print("surveyAnswer1 is\(surveyAnswer1)")

// 隐式解析可选将？改为！

let possibleString: String? ="An optional string."

print(possibleString)

//隐式可选其实相当于对象后边加！

let assumedString:String!  ="An implicitly unwrapped optional string."

print(assumedString)

//断言调试可以使用全局 assert函数来写一个断言。向 assert函数传入一个结果为
true或者 false的表达式以及一条信息，当表达式为 false的时候这条信息会被显示

let age =3 //加入断言的时候出现不合理的就会报错

assert(age >=0,"A person's age cannot
be less than zero")

//如果写成是assert(age < 0, "A person's age cannot be less than zero")就会报错

/*  断言的使用场景  */

/* 整数下标索引被传递一个定制的下标实现，下标索引值可能太小或者太大。

 给函数传入一个值，但是非法的值可能导致函数不能正常执行。

 可选值现在是 nil，但是后面的代码运行需要一个非nil值。
*/

Demo下载：http://download.csdn.net/detail/bddzzw/9629700