swift数据类型

字符串的比较使用 ＝＝

//1.1 元//目标数值的个数//1.2赋值运算符和表达式let (x,y)=(5,"Hello");print(x);print(y);//1.3运算和表达式// + - * / % 基本运算符,关于 负号,跟数学表达式是一样的//关于/  分母不能是0var a1=9/4var a2=9.00/4print(a1) //表达式中都是整数,结果也是整数print(a2) //当表达式有一个为浮点数,结果页浮点数//关于%var b1=9%4 //正数var b2=(-9)%(-4)//负数var b3=(-9)%4   //负数var b4=9%(-4)   //正数print(b1)print(b2)print(b3)print(b4)//注意浮点数取模,也是浮点数(特有)var a=8%2.5print(a)//1.4自增,自减 ++ --//1.5一元减运算符let three = 3let minusThtree = -three //注意空格print(minusThtree)//1.6一元加运算let asloMinusThree = +minusThtree; //只是为了对齐代码,不改变数值print(asloMinusThree)//1.7位运算// &// |// ^ 按位异或 相同为0 不同为1// ~ 按位取反// << 按二进制全部左移N位,右补0// >> 按二进制右移N位,对于无符号位,高位补零//1.8溢出运算符 &+ &- &* &///上溢出var max=UInt8.max; //255max = max &+ 1print(max) //0  &+n ===n-1//下溢出var min=UInt8.min; //0min = min &- 1print(min) //255 &- n ==255-(n-1)//除 0 溢出(待研究)//1.9 逻辑运算符 && || ! let xx = !(10>7)print(xx) //值只能是true 或者false//1.10 范围运算符//1. 封闭运算for index in (1...5) {    print(index)}//2.半封闭运算for index in (1..<5) {    print(index) //不包括5}//1.11 求字节运算符let size=sizeof(Int)print(size)//1.12 可选类型强制解析var value:Int?=5print(value) //可选值var bb = value! - 9 //强制解析print(bb)//1.13 类型转换//swift 不存在隐式转换//1整数的转换,整数有 8种,不一样要转换一下//2 整数和浮点数的转换

再来看一下switch，这个总算有点点进步了，以前的switch大多只支持int或枚举类型，现在swift中把switch语句的表达式判断类型上进行了扩展。其次，每个case不再需要写break;这点不错。

“let vegetable = "red pepper"
switch vegetable {
case "celery":
let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber","watercress":
let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
let vegetableComment = "Is it a spicy \(x)?"
default:
let vegetableComment = "Everything tastes good in soup."
}”

哈哈，看到没有，没有break哦。。。冒似少了几个Ｂ的代码。

switch语句的case中可以匹配一个数值范围

如果switch的条件声明在同一个函数内，这时会提示Switchcondition evaluates to a constant
要去除这个，只需要将声明的变量放在函数外就可以

WestdirectionTohead :

//1.选择结构 if / if else 语句 if(1)在swift是不对的//2.选择结构 switch 语句//    1> 不用break,匹配到,自动跳出swith,剩余不会执行//    2>可执行的语句不能为空////let grade = "B"//switch (grade) {////case "A" : print("A")//case "B" "////}//    3>多条件匹配let grade = "B"switch (grade) {case "A,B" : print("A,B")case "B"  : print("B")default:    print("没找到")}//    4>范围匹配let score = 45switch (score) {    case 0...60 : print("不及格")default:    print("及格")    }//     5>使用元组//case 中可以直接测试元组是否符合相应的条件let point = (1,1)switch point {case (0,0):print("原点")case (_,0):print("\(point.0),0 在x轴上")case (0,_):print("\(point.1),0 在y轴上")case(-2...2,-2...2):print("(\(point.0),\(point.1)) 在矩形内")default:  print("(\(point.0),\(point.1)) 在矩形外")}//     6数值绑定// 在switch 匹配中 将switch中的值给某个变量,也可以是常量//    1>let mypoint = (2,2)switch mypoint {case (let x,0):print(" 在x轴上,并且x的值为\(x)")case (0,let y):print(" 在y轴上,并且x的值为\(y)")case(let x,let y):print(" 在其他地方,并且x的值为\(x)并且y的值为\(y)")}let mypoint1 = (2,2)switch mypoint1 {case (var x,var y):print(" 在y轴上,并且x的值为\(y)")case(var x,var y):print(" 在其他地方,并且x的值为\(x)并且y的值为\(y)")    }//     2>满足多个条件(淘汰)let mypoint2=(2,0)switch mypoint2 {case let(x,y):print(" 在其他地方,并且x的值为\(x)并且y的值为\(y)")case (let x,并且x的值为\(y)")    }//    7使用where 关键字//使用where 增加判断条件let mypoint3=(2,2)switch mypoint3 {case let(x,y) where x==y:    print(" 在斜线x==y上,并且x的值为\(x)并且y的值为\(y)")case let(x,y) where x == -y:    print(" 在斜线x==-y上,并且x的值为\(x)并且y的值为\(y)")case let (x,y):    print(" 这是任意的点")    }//3 循环结构 for 语句 //for in//   1>for 后面的是常量,而非变量//   2>省略常量var value = 1var sum = 0for _ in (1...100) {    sum += value    value++}print(sum)//4.循环结构while//5.跳转结构 continue,break,fallthought// fallthrought 只能在case 下面let grade1 = "A"switch grade1 {    case "A":    print("90--100")    fallthroughcase "B":    print("80--90")    //fallthroughcase "C":    print("70--80")   // fallthroughcase "D":    print("60--70")    fallthroughdefault:    print("<< 60")    }

//牢记几个标准的函数//1>绝对值函数abs() 返回值为一个正数或者0 可以获取 -10,10,-1.233,1.233的绝对值//2>最大值函数max()/最小值函数min() 可以数值,也可以字符串或者字符,如果是字符串,则是比较字符串的首字符,如果是字符,则三个数都是字符进行比较,否则会出现错误//3>序列的最大值函数 maxElenment()/最小值函数 minelement(),可以是数值,也可以范围(范围)//let seq=[1,34,45,77,34]//maxElement(seq)//maxElement(1...100)//4>判断序列是否包含指定元素函数contains()// contains(序列,元素)var seq=["swift","hello","world"]if seq.contains("swift") { //比较的时候,会区分大小写    print("包含")}//5.序列排序函数 sort()print("排列前:\(seq)")seq.sortInPlace();print("排列后:\(seq)")//6序列倒序函数 reverse()for i in seq.reverse() {    print(i)}//1无参函数func printA() {print("A")}printA();//在swift 中一定要声明之前,调用在后//2有参函数// func funcname(参数1:数据类型,参数二:数据类型)->返回值func nameString(name:String) {}//注意1>参数的个数,和调用传的个数相同//    2>顺序//  //3函数参数的特殊情况//    3.1>本地参数func func1(start:Int,end:Int,str:String) {//start,end,str为本地参数}//    3.2,外部参数func joinFunc1(startInt start:Int,endInt end:Int,toString str:String) {}//startInt,endInt,toString 为外部参数//         注意1>调用必须用外部参数//            2>顺序//            3 快速书写 #(淘汰)//func joinFunc2(#start:Int,#end:Int,#toSting:String) {//////}//    3.3 设定内部参数的默认值func joinFunc2(start:Int=0,str:String="默认值") {    }       //无参默认,传值,可以覆盖掉默认值//    3.4将外部参数设置为默认值func joinString(sting s1:String,toString s2:String="swift",withSting s3:String="---") {    print("\(s1)\(s3)\(s2)")}joinString(sting: "hello")//   3.5可变参数 //使一个参数能接受0个或多个指定类型的参数 ...func average(numbers:Double...) {    var total:Double=0        for number in numbers {    total += number    }    print(total)}//      注意1>在一个函数中可变参数只能有一个//          2> 多个参数中,可变参数只能排在末尾average(1,5)average(34,45)//   3.6 常量参数和变量参数//  函数中,默认参数都是常量//要想在使用中修改参数的值 加var 了func hhh (var name:String){    name="lichungui"        print(name)}hhh("sdfg")//   3.7输入输出参数inout 可改变参数的值func test(inout number:Int) {number=100}var a:Int=0;test(&a)print(a) //神奇 100//4.函数的返回值//  1>一个返回值func range(start:Int,end:Int)->Int {return end-start}//   2>多个返回值(元组)func count(sting:String)->(vowels:Int,consonants:Int,others:Int) {    var vowels=0,consonants=0,others=0  return(vowels,consonants,others)}//   3,无返回值//5.函数类型  //1>使用函数类型func add(a:Int,b:Int)->Int {    return a+b}var mathFuc :(Int,Int)->Int=add;var mathFuntion=add;//类型推断print(mathFuc(1,5))//  2>使用函数类型作为参数 (淘汰)//func mutiply(a:Int,b:Int)->Int {//    //    return a*b//}////func printResult(fuc:(Int:Int)->Int,a:Int,b:Int) {////    print(fuc(a,b))//}////printResult(add,a: 3,b: 2)//printResult(mutiply(100,b: 200) )//   3>使用函数类型作为返回值类型//6闭包类型 OC block  lambda//   1>闭包表达式// {(参数列表)-> 返回值 in //  语句// }//   2>无参var str={ () in    print("aaa")}str()//   3>有参var str1={ (str:String) in    print(str)    }str1("asdfgh")//   4注意事项//    1>推断类型//    2>省略 return //    3简写参数名(淘汰)//var array=[1,5]////var v1=compare(array,500,{//   name: String,day: String > //}//)//    4>trailing 闭包let digitnames = [     0: "Zero",1: "One",2: "Two",3: "Three",4: "Four",5: "Five",6: "Six",7: "Seven",8: "Eight",9: "Nine" ]let numbers = [16,58,510]let strings = numbers.map {     (var number) -> String in      var output = "";     while number > 0{         output = digitnames[number % 10]! + output    number /= 10    }    return output}print(strings) // 打印出来的结果: [Onesix,FiveEight,FiveOneZero]/***  PS:1.在这个例子中,strings 常量被推断为字符串类型数组,即 [String],map 在数组中为每一个元素调用了闭包表达式,您不需要指定闭包的输入参数 number 的类型,因为可以通过要映射的数组类型进行推断,闭包表达式在每次被调用的时候创建了一个字符串并返回。其使用求余运算符 (number %10) 计算最后一位数字并利用 digitnames 字典获取所映射的字符串.2.字典 digitnames 下标后跟着一个叹号 (!),因为字典下标返回一个可选值 (optional value),表明即使该 key 不存在也不会查找失败,在上例中,它保证了 number % 10 可以总是作为一个 digitnames 字典的有效下标 key,因此叹号可以用于强展开 (force-unwrap) 存储在可选下标项中的 String 类型值.*///捕获/***  在我们使用闭包的时候,其实我们还可以捕获我们自己定义的常量或者变量,即使里面的常量和变量的作用域不存在,闭包仍然可以在闭包函数体内引用或者修改,Swift 最简单的闭包形式是嵌套函数,也就是定义在其他函数体内的函数,嵌套函数可以捕 获其外部函数所有的参数以及定义的常量和变量,让我们一起来看看:*/func makeIncrementor(forIncrement amount: Int) -> () -> Int {    var runningTotal = 0    func incrementor() -> Int {        runningTotal += amount        return runningTotal    }    return incrementor}let incrementBySeven = makeIncrementor(forIncrement: 7)let aaa = incrementBySeven()print(aaa) // 打印出来的结果: 7/***  1.makeIncrementor 返回类型为 () -> Int,这意味着其返回的是一个函数,而不是一个简单类型值,该函数在每次调用时不接受参数只返回一个 Int 类型的值,关于函数返回其他函 数的内容,请查看 Function Types as Return Types.2.makeIncrementor 函数定义了一个整型变量 runningTotal (初始为 0) 用来存储当前增加总数,该值通过 incrementor 返回.3.makeIncrementor 有一个 Int 类型的参数,其外部命名为 forIncrement,内部命名为 amount,表示每次 incrementor 被调用时 runningTotal 将要增加的量.4.incrementor 函数用来执行实际的增加 *** 作,该函数简单地使 runningTotal 增加 amount,并将其返回.5.Swift 会决定捕获引用还是拷贝值,您不需要标注 amount 或者 runningTotal 来声明在嵌入的 incrementor 函数中的使用方式,Swift 同时也处理 runingTotal 变量的内存管理 *** 作,如果不再被 incrementor 函数使用,则会被清除.*/let incrementBySeven1 = makeIncrementor(forIncrement: 7)let a3 = incrementBySeven1()let b3 = incrementBySeven1()let c3 = incrementBySeven1()print("\(a3),\(b3),\(c3)") // 打印出来的结果: 7,14,21//上面已经很好的解释了,这里我就不多做解释了,还有一个注意点,比如:let incrementBySeven2 = makeIncrementor(forIncrement: 7)let a4 = incrementBySeven2()let b4 = incrementBySeven2()let c4 = incrementBySeven2()print("\(a4),\(b4),\(c4)") // 打印出来的结果: 7,21let incrementByTen = makeIncrementor(forIncrement: 10)let A5 = incrementByTen()let B5 = incrementByTen()let C5 = incrementByTen()print("\(A5),\(B5),\(C5)") // 打印出来的结果: 10,20,30//虽然这两个常量调用的是同一个闭包,但是它们之间所捕获的内容并没有关联,这个需要注意.

6.程序控制结构

for - in,for,while,do-while

在for-in 中使用k/v数组，

“let interestingNumbers = [
"Prime": [2,7,11,13],
"Fibonacci": [1,1,8],
"Square": [1,4,9,16,25],
]
var largest = 0
for (kind,numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
largest”

这个让我感慨的就是每个变量都没有进行显式的声明类型。这也许就是swift所宣存的精确，高效的一个原因之一吧。

另外for 也像pascal一样支持“..”范围 *** 作符。可能熟释DELPHI的朋友一定很深的印象。像这样的for

procedure foroperation

var

char c;

begin

for (c in ['a'..'z']) do

begin

//do something.

end;

end;

官网的例子：

“var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop

var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop”

两个for 过程是一样的，即i都是从0-3. 其实delphi 中还有low() to high() *** 作的，这个swift应该没有吧，如果有的话，我想apple的工程师都应经历了pascal的时代。

值得注意的是：swift中不仅有".." 也有"..."，分别代表什么呢。两个点，相当于小于如0..3 等价于 0<=i<3 而使用...则相等于 "<=" 如 0..3 等价于 0<=i<=3

while / do while

“var n = 2
while n < 100 {
n = n * 2
}
n

var m = 2
do {
m = m * 2
} while m < 100
m”


7.函数的语法

“func greet() ->{
return "Hello \(name),today is \(day)."
}
greet("Bob","Tuesday")”

通过这个例子，可以看到使用func关键词进行声明，其次 输入参数 使用“变量：类型”的型式，这还真像pascal，你还别说。最有特色的就是这个返回值，参过->符号指定返回的类型。这个也许是C++的地址函问符的一个使用方式吧，每个函数返回的其实都是一个地址块。另外函数如果有多个返回（即传出参数）怎么处理呢？如C/C++ 的使用“**”指针的指针 如 func(char ** outstring) 但在 swift中则：

“func getGasPrices() -> (Double,Double,Double) {
return (3.59,3.69,3.79)
}
getGasPrices()”

其次swift中的函数参数为数组时的写法，也很特别：

“func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42,597,12)”

内连函数的支持

很多高级语方中都有内连函数，内连函数的使用也是很常见的一种，不仅使得代码执行更加高效，同时也减少了内存碎片。

一起看一下swift的内连函数的写法：

“func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()”

还有一个特另的：就是swift还提供了在函数中返回函数来看一下，写法也比较另类：

“func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer() //increment 可理解为addOne的函数指针
increment(7)”

把这段代码解读一下，首先红色部分是一个函数，入参为整型，返回一个整型的值。 再来看最外层的函数makeIncrementer 没有入参，有返回值，而返回值是使用"()"括起来。

int ->int 这个表示返回的为一个函数地址，该函数有一个int型的输入参数，同时还有一个int 型的返回值参数。这与c/c++的函数指很是有差别。

在swift中，函数也可以作为参数进行传递：（见红色部分）

“func hasAnyMatches(List: Int[],) -> Bool {
for item in List {
if condition(item) {
return true
}
}
return false
}
func lessthanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20,19,12]
hasAnyMatches(numbers,0)">lessthanTen)”


最后还有三个没有理解透，等有ios 8 的环境再验证，好像是匿名函数的使用。

“numbers.map({ (number: Int) -> Int in let result = 3 * number return result })” “numbers.map({ number in 3 * number })” “sort([1,12,2]) { $0 > $1 }”

以上是内存溢出为你收集整理的swift数据类型全部内容，希望文章能够帮你解决swift数据类型所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。