Swift基础练习代码
//import Foundation
/*
//////////////////////////////
//test print
//输出测试
//////////////////////////////
println("Hello, World!")
println ("Hi")
let num=20141218
var str="hello"
println(str)
print("test println string with vstr \(str)")
println()
print("test println string with lint \(num)")
println()
println(num)
*/
/*
//////////////////////////////
//test the maxnum and minnum of num
//整形极值测试
//////////////////////////////
println(Int8.min)
println(Int8.max)
println(Int16.min)
println(Int16.max)
println(Int32.min)
println(Int32.max)
println(Int64.min)
println(Int64.max)
//unsign
println(UInt8.min)
println(UInt8.max)
println(UInt16.min)
println(UInt16.max)
println(UInt32.min)
println(UInt32.max)
println(UInt64.min)
println(UInt64.max)
*/
/*
//////////////////////////////
//test 2,8,10,16 adecimal
//2,8，10，16进制数值表示
//////////////////////////////
let l2=0b11
let l8=0o11
let l10=11
let l16=0x11
print("0b11:\(l2) 0o11:\(l8) 11:\(l10) 0x11:\(l16)")
println()
//decimal
var v10=1.1e3
var v16=0x1.1p3
println("1.1e3:\(v10) 0x1.1p3:\(v16)")
*/
/*
//////////////////////////////
//test change type
//类型转化
//////////////////////////////
var vint=3
var vfloat=1.1+Float(vint)
var vdouble=Double(vfloat)
var vfsum=4.1
println("Float:\(vfloat) Double:\(vdouble) \(Double(vfsum))")
*/
/*
//////////////////////////////
//test type alias
//型别名
//////////////////////////////
typealias D=Double
var vint=3
var vfloat=1.1+Float(vint)
var vdouble=D(vfloat)
println("Float:\(vfloat) Double:\(vdouble)")
*/
/*
//////////////////////////////
//test tuples
//元组测试
//////////////////////////////
let tname=(zhao:"zhao","qian","sun")
println("get value by sup:\(tname.0) \(tname.1) \(tname.2)")
let (name1,_,_)=tname
println("get value by parm:\(name1)")
println("get value by name:\(tname.zhao)")
*/
/*
//////////////////////////////
//test switch
//switch测试
//////////////////////////////
var str="adress"
switch( str)
{
case "name" : println("this is name")
case "address": println("this is address")
default : println("this is others")
}
*/
/*
//////////////////////////////
//test assertion
//断言测试
//////////////////////////////
var vint = -1
//当vint>0不城里时，输出"the number is too small"
assert(vint>0,"the number is too small")
println()
*/
/*
//////////////////////////////
//test for-in,for,while,do-while
//流控测试or-in,for,while,do-while
//////////////////////////////
println("for-in")
for vint in 1...5 {
println("\(vint) * 5 = \(vint * 5)")
}
println("for")
for (var vint=1;vint<6;vint++)
{
println("\(vint) * 5 = \(vint * 5)")
}
println("while")
var vint=0
while(vint<6)
{
println("\(vint) * 5 = \(vint * 5)")
vint++
}
println("do-while")
vint=1
do{
println("\(vint) * 5 = \(vint * 5)")
vint++
}
while(vint<6)
*/
/*
//////////////////////////////
//test array
//获取数组元素
//////////////////////////////
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count
{
println(" \(i + 1) name is \(names[i])")
}
var num=0
for name in names
{
num++
println(" \(num) name is \(name)")
}
y
let teamage = [
"Prime": [18,25,32,26,21],
"Fibonacci": [24,25,20,31,22],
"Square": [29,24,31,22,34,26, 25],
]
println("team largest age")
for (kind, ages) in teamage {
var largest = 0
for age in ages {
if age > largest {
largest = age
}
}
println("\(kind) \(largest)")
//println("team:\(kind) largest age:\(largest)")
}
*/
/*
//////////////////////////////
//test func
//函数输出测试
//////////////////////////////
func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)."
}
println(greet("Bob", "Tuesday"))*/
/*
//////////////////////////////
//test intnum add
//加法计算
//////////////////////////////
func add(nums:Double...)->Double
{
var sum=0.0
for num in nums
{sum += num}
return sum
}
var sum = add(1,2,30.1)
println(sum)
*/
/*
//////////////////////////////
//test string append
//字符串拼接
//////////////////////////////
func strappend(str:String...)->String
{
var strappend="";
for s in str
{
strappend += s;
}
return strappend;
}
println(strappend("hello ","everyone","."))
func strappend(strlist:[String])->String
{
var str="";
for s in strlist
{
str += s;
}
return str;
}
var s=["hello ","everyone","."]
println(strappend(s))
*/
/*
//////////////////////////////
//test enennum and oddnum
//判断一组整形参数的奇偶性
//////////////////////////////
func hasAnyMatches(list: [Int], condition: Int -> Bool) {
for item in list {
if condition(item) {
println("\(item) is evennum!")
}
else
{
println("\(item) is oddnum!")
}
}
}
func evennum(number: Int) -> Bool {
return number % 2 == 0
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, evennum)
*/
/*
//////////////////////////////
//test enum
//枚举做Switch的选择值
//////////////////////////////
enum Directionint:Int
{
case North=5
case South
case West,East
}
enum Direction:String
{
case North="North"
case South=""
case West="West"
case East="East"
}
var dir=Direction.North
switch dir
{
case .North: println("You choose Noth")
case .South: println("You choose South")
case .East: println("You choose East")
case .West: println("You choose West")
default:
println("You are wrong");
}
println(dir.hashValue)
dir = .South
println(dir.hashValue)
dir = .West
println(dir.hashValue)
dir = .East
println(dir.hashValue)
//let nvalue=Direction.North.toRaw()// 以前的方法，已经不能用
let nvalue=Direction.North.rawValue
println(nvalue)
println(Direction.East.rawValue)
enum Barcode
{
case UPCA(Int,Int,Int)
case QR(String)
}
let book=Barcode.UPCA(9,7894561230,3)
let tv=Barcode.QR("television")
var product=tv
switch product{
case let .UPCA(numberSystem,identifier,check):
//case .UPCA(let numberSystem,let identifier,let check)://和上式等同
println("UPC-A code with value of \(numberSystem) \(identifier) \(check)")
case .QR(let productCode):
println("QR code with value of “\(productCode)”")
}
*/
/*
//////////////////////////////
//test class
//类继承
//////////////////////////////
//形状父类
class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
//正方形
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDescription() -> String {
return "A square with sides of length \(sideLength)."
}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
var s=test.simpleDescription()
//println(s)
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
var perimeter: Double {
get {return 3.0 * sideLength }
set {sideLength = newValue / 3.0}
}
override func simpleDescription() -> String {
return "An equilateral triagle with sides of length \(sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
//println(triangle.perimeter)
//println(triangle.simpleDescription())
class TriangleAndSquare {
var triangle: EquilateralTriangle {
willSet {
square.sideLength = newValue.sideLength
}
}
var square: Square {
willSet {
triangle.sideLength = newValue.sideLength
}
}
init(size: Double, name: String) {
square = Square(sideLength: size, name: name)
triangle = EquilateralTriangle(sideLength: size, name: name)
}
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
println(triangleAndSquare.square.sideLength)
println(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
println(triangleAndSquare.triangle.sideLength)
*/
/*
//继承父类的属性，方法
//使用构造器对属性进行赋值，只能有一个init构造器来初始化
//init构造器不能与父类的参数完全相同（包括顺序）否则得加override来重写
class NamedShape {
var sideLength:Double = 0.0
var name: String
init(name: String,sideLength:Double) {
self.sideLength=sideLength
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(sideLength) sides."
}
}
//正方形
class Square: NamedShape {
override init(name: String,sideLength: Double ) {
super.init(name: name,sideLength:sideLength)
//numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDescription() -> String {
return "A square with sides of length \(sideLength)."
}
}
let test = Square( name: "my test square",sideLength: 5.2)
test.area()
var s=test.simpleDescription()
println(s)
//
class EquilateralTriangle: NamedShape {
//var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
// self.sideLength = sideLength
super.init(name: name,sideLength:sideLength)
//numberOfSides = 3
}
var perimeter: Double {
get {return 3.0 * sideLength }
set {sideLength = newValue / 3.0}
}
override func simpleDescription() -> String {
return "An equilateral triagle with sides of length \(sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
//println(triangle.perimeter)
//println(triangle.simpleDescription())
class TriangleAndSquare {
var triangle: EquilateralTriangle {
willSet {
square.sideLength = newValue.sideLength
}
}
var square: Square {
willSet {
triangle.sideLength = newValue.sideLength
}
}
init(size: Double,name: String) {
square = Square(name: name,sideLength: size )
triangle = EquilateralTriangle(sideLength: size, name: name)
}
}
var triangleAndSquare = TriangleAndSquare(size: 10,name: "another test shape")
println(triangleAndSquare.square.sideLength)
println(triangleAndSquare.triangle.sideLength)
println(triangleAndSquare.triangle.simpleDescription())
triangleAndSquare.square = Square(name: "larger square",sideLength: 50)
println(triangleAndSquare.triangle.sideLength)
println(triangleAndSquare.square.simpleDescription())
*/
/*
///////////////////////////////////
//test struct
//结构体做参数
//////////////////////////////////
struct Size{
var width=0.0
var height=0.0
//var area=self.width * self.height
func area() -> Double
{
return self.width * self.height;
}
}
let t = Size(width:3, height: 4)
println("\(t.width) \(t.height) \(t.area())")
func prop(tt:Size)->(Double,Double)
{
return ((tt.width + tt.height) * 2,tt.width * tt.height)
}
let (c,s)=prop(t)
println(prop(t))
println("circumference:\(c) area:\(s) ")
*/
/*
/////////////////////////////////////////////
//type casting
//类型转化
////////////////////////////////////////////
class MediaItem{
var name:String
init(name:String){
self.name=name
}
}
class Movie:MediaItem{
var director:String
init(name:String,director:String){
self.director=director
super.init(name:name)//父类初始化，属性name赋值
}
}
class Song:MediaItem{
var artist:String
init(name:String,artist:String){
self.artist=artist
super.init(name:name)
}
}
let library = [
Movie(name:"Casablana",director:"Micheal Curtiz"),
Movie(name:"Blue Suede Shoes",director:"Elvis Presley"),
Song(name:"The One And only",artist:"Chesney Hawkes")
]
var movieCount = 0
var songCount = 0
let lmovie = Movie(name:"Casablana",director:"Micheal Curtiz")
//println("\(lmovie.name) \(lmovie.director)")
for item in library{
if item is Movie{
++movieCount
println("a \(item.name)")
}
else if item is Song{
++songCount
println("b \(item.name)")
}
}
for item in library{
if let m = item as? Movie{
++movieCount
println("\(movieCount) MovieName:\(m.name) MovieDirector:\(m.director)")
}
else if let s = item as? Song{
++songCount
println("\(songCount) SongName:\(s.name) SongArtist:\(s.artist)")
}
}
let library1 = [
Movie(name:"Casablana",director:"Micheal Curtiz"),
Movie(name:"Blue Suede Shoes",director:"Elvis Presley")
]
for m in library1 as [Movie]
{
println("MovieName:\(m.name) MovieDirector:\(m.director)")
}
*/
/////////////////////////////////
//交换参数
/////////////////////////////////
/*func swapTwoInts(inout a: Int, inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
var a=1,b=2
println("before changing a=\(a) b=\(b)")
swapTwoInts(&a ,&b)
println("after changing a=\(a) b=\(b)")
*/
/////////////////////////////////
//范型
//交换参数
/////////////////////////////////
/*
func swapTwoValues<T>(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
println("after changing someInt=\(someInt) anotherInt=\(anotherInt)")
swapTwoValues(&someInt, &anotherInt)
println("after changing someInt=\(someInt) anotherInt=\(anotherInt)")
var someString = "hello"
var anotherString = "world"
println("after changing someString=\(someString) anotherString=\(anotherString)")
swapTwoValues(&someString, &anotherString)
println("after changing someString=\(someString) anotherString=\(anotherString)")
*/
/*
/////////////////////////////////
//结构体增加元素
/////////////////////////////////
struct Stack<T>{
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
//items.jo
}
}
var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
for item in stackOfStrings.items{
println(item)
}
*/
/*
for i in join([1,2],[[4,5],[6,7],[8,9]]){
println(i)
}
println(join([1,2],[[4,5],[6,7],[8,9]]))
println(join(":", ["A", "B", "C"])) //== "A:B:C"
*/
/*
func findStringIndex(array:[String], valueToFind:String) -> Int?{
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
if let foundIndex = findStringIndex(strings, "llama") {
println("The index of llama is \(foundIndex)")
}
//"The index of llama is 2
*/
/*
//不能直接在范型中使用“＝＝”需要Equatable来限制类型
func findIndex<T: Equatable>(array:[T],valueToFind:T) ->Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
println(doubleIndex)
// doubleIndex is an optional Int with no value, because 9.3 is not in the array
let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
println(stringIndex)
// stringIndex is an optional Int containing a value of
*/