swift2.0 - study

//

// main.swift

// mycmd

// Created by zhaoxuhui on 15/10/27.

// Copyright ? 2015年 zhaoxuhui. All rights reserved.

//

import Foundation

var str = "Hello,playground"

//swift初见

let shoppinglist = ["aaa","bbb"];

var shopdic = [1:"aaa",3:"ccc",2:"bbb"];

shopdic[1] = "aA";

for s in shopdic {

print(s);

}

var optionalstring:String? = "hello";

print(optionalstring == nil);

if let name = optionalstring{

print("optionalstring != nil")

}else{

print("optionalstring == nil")

}

let vetetable = "red paper"

var comment:String;

switch vetetable{

case "celery":

comment = "celery a";

case let x where x.hasPrefix("re"):

comment = "prefix re:(x)";

case "red paper"://这行不会走了

comment = "red paper";

default:

comment = "no comment";

}

print(comment);

let nameNumbers = [

"zhao":[1,2,3,4],

"xu":[2,4,6,8],

"hui":[3,9],

"zxh":[1,0,1,0]];

for (name,nums) in nameNumbers{

for num in nums{

//print(num);

}

print(name,nums);

}

print(nameNumbers.dynamicType);

var n = 2 ;

while n<10{

n*=2;

}

print("n=(n)");

var m = 20;

repeat{

m*=2;

}while m < 10;

print("m=(m)")

m = 1;

for i in 0..<4{

print(i);

}

func sumof(numbers:Int...)->Int{

var sum = 0;

for num in numbers{

sum+=num;

}

print("numbers type is (numbers.dynamicType)");

return sum;

}

var sum = sumof(1,5);

print("sum=(sum)");

func return15()->Int{

var y = 10;

func add(){

y+=5;

}

add()

return y;

}

var v = return15();

print("v=(v)");

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

func addone(number:Int)->Int{

return 1+number;

}

return addone;

}

var incrementer = makeIncrementer();

print(incrementer(5))

//闭包

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

print("numbers:(numbers)")

let mappednumbers = numbers.map { (number:Int) -> Int in

let result = 3*number;

return result;

}

print("mapped:(mappednumbers)");

let unevenNum = numbers.map { (uneven:Int) -> Int in //返回所有奇数

if uneven % 2 == 1{

return uneven;

}

return 0;

}

print("unevenNum(unevenNum)");

let num3 = numbers.map({num in 3 * num}); //更简洁的闭包

print("num3=(num3)");

let sortedNumbers = numbers.sort { $0 < $1 } //通过位置而不是参数名字来引用参数

print("sortedNumbers:(sortedNumbers)")

class NamedShape {

var numberofside:Int = 0;

var name:String;

init(name:String){

self.name = name;

print("(self) init");

}

deinit{

print("(self) deinit");

}

func hello(){print("NamedShape")}

}

var namedshape = NamedShape(name: "zxh")

class Square:NamedShape{

override func hello(){ //重写父类函数

print("Square");

}

override init(name:String){

super.init(name:name);

}

var width:Double = 1.0;

var area:Double{ //getter setter

get{

return width*width;

}

set{

width = sqrt(newValue);

}

}

}

var squ = Square(name:"aaa");

squ.hello();

squ.area = 9;

var v2=1;

//?问号的处理：

//处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。

//let optionalValue:Square?=123;

//enum枚举

enum Rank:Int{

case Ace = 1

case Two,Three,For,Five

case Jack,Queen,King

func simpleDescription()->String{

switch self{

case .Ace:

return "ace"

case .Jack:

return "jack"

case .Three:

return "three"

default:

return String(self.rawValue)

}

}

}

var vrank = Rank.Three

print(vrank);

print(vrank.rawValue);

print(vrank.simpleDescription())

let convertedRank = Rank(rawValue: 7); //使用init?(rawValue:)构造

print(convertedRank)

//结构体是传值，类是传引用

struct Card{

var rank:Rank

var suit:Int

}

//protocol

protocol ExampleProtocol{

var simpleDescription:String{get}

mutating func adjust() //虚函数

}

class SimpleClass: ExampleProtocol {

var simpleDescription:String = "a very simple class"

var anotherProperty:Int = 1995

func adjust() { //类的重写虚函数不需要加mustating，因为类中的方法经常会修改类

simpleDescription += " now 100% adjusted"

}

}

var a = SimpleClass()

print(a.simpleDescription)

a.adjust()

let aDescription = a.simpleDescription;

print(aDescription);

struct SimpleStructure:ExampleProtocol {

var simpleDescription:String = "a simple structure"

mutating func adjust() { //结构体的重写虚函数需要加mustating

simpleDescription += " (adjusted)"

}

}

var b = SimpleStructure()

b.adjust()

let bDescription = b.simpleDescription

print(bDescription);

extension Int:ExampleProtocol{ //extension来为现有的类添加功能，比如方法和参数

var simpleDescription:String{

return "The number is (self)"

}

mutating func adjust(){

self += 42

}

}

print(7.simpleDescription)

//泛型

func repeatItem<Item>(item:Item,times:Int)->[Item]{

var result = [Item]()

for _ in 0 ..< times {

result.append(item)

}

return result

}

var items = repeatItem("kick",times: 4);

print(items);

//swift 教程

let cat = "I am a cat";print(cat) //这样必须加分号;

var n8:Int8; //有符号int8位

var un8:UInt8 //无符号int8位

var n16:Int16

var n32:Int32

var n64:Int64

//swift提供了8，16，32，64位的整形

print(Int64.max); //Int64的最大值

//Int的长度与平台相应，64位平台为64，32位平台为32

/*十进制，无前缀

二进制，0b

八进制，0o

十六进制，0x

十进制浮点数，1.25e2

十六进制浮点数，0xFp2，代表15*2^2等于60

*/

//类型转换

let three = 3

let pi = Double(three)

//类型别名

typealias AudioSample = UInt16

let http404error = (404,"not found")

print(http404error.dynamicType) //(Int,String)

let(statusCode,statusMessage) = http404error //分解

let(statusCode1,_) = http404error //如果你只需要一个元素，分解的时候忽略的部分使用_标记

print("the status code is (http404error.0)") //访问元组中的一个元素

let http200status = (statusCode:200,description:"OK") //给元组命名

print("the status code is (http200status.statusCode)")

//可选类型

let possibleNumber = "123"

let convertedNumber = Int(possibleNumber)

print(convertedNumber.dynamicType,"rn",convertedNumber)

//如果声明一个可选常量或者变量没有赋值，那么自动为nil

//可选值的强制解析,前面有一个叹号！表示要强制解析，我知道这个可选有值

let notpossibleNumber = "aaa"

if let actualNumber = Int(notpossibleNumber) { //可选绑定

print("is num")

print("is not num")

//print(actualNumber) //不可打印，swift的自由语法限制

}

let possibleint:Int? = 123;

print(possibleint.dynamicType)

let realint = possibleint!; //可选变为不可选

print(realint.dynamicType)

let assumedint:Int! = nil;

print(assumedint.dynamicType) //ImplicitlyUnwrappedOptional<Int>//隐式可算类型//当第一次赋值之后以后总会有值//有的书也成为绝对有有值，强制解析此值

//print(assumedint)//打印这个会崩溃

//异常处理//讲的不完整

func canThrowAnError() throws{

}

do{//一个do的声明创建了一个新的包含作用域，使得错误能被传播到一个或更多catch从句

try canThrowAnError()

//没有错误消息

}catch{

//有一个错误消息

}

//断言

let age = -3

//assert(age>=0,"a person's age cannot be less than zero") //这个将打印在下方调试All Output,debug中断运行

//在软件发布之前使用断言可以快速发现问题

//基本运算符

//对浮点数进行取余运算%

let (x,y) = (1,2)

print(x,y)

//swift 赋值操作不返回任何值

var ifa=1,ifb=2

//if ifa = ifb {}//编不过

//溢出

//swift不支持溢出运算

x &+ y//使用&+来实现溢出运算

//%取余对负数和浮点数有效-9%4即-9 = 4*（-2）+ -1余数是-1

//b的符号会被忽略a%b和a&-b结果是一样的

//使用===和!==来判断两个对象是否为引用同一对象实例

//空合运算符

//a ?? b//对a进行空判断，如果a包含一个值那么解封，否则返回b

//a必须是Optional类型

//相当于a != nil ? a! : b

//区间运算符

//a...b//[a,b]

//a..<b//[a,b)

//p77字符串

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!