初识你---------Swift【上篇】

从2014年WWDC（苹果开发者大会）发布的新开发语言Swift，到2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，并且Swfit完全开源。而且每一次Xcode的更新Swift都会跟着做各种调整，现在已经有好多项目都在使用，尤其是在移动端的动画切换方向，

更是给用户带来了一场新的视觉盛宴，那就简单认识一下Swift

首先是Swif定义变量的方式

在Swift中使用“let”修饰一个常量，使用“var”修饰一个变量;

let修饰常量的值是不可以更改的；
var修饰的变量的值是可以更改的；
在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。

Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断。

如:

//会自动推断变量a为Int类型
var a = 10
//会自动推断常量b为String类型
let b = "windsSunShine"

Swift会根据初值自动的推断出自己是什么类型的变量或者是常量，所以在开始定义的时候一定要赋初值或者指定数据类型，但是

Swift不支持隐式类型转换的

即不同类型的两个数据之间不能进行操作

如果让两个不一样的数据类型变量或者常量做加减乘除的操作需要提前改变变量或者是常量的数据类型

如：

var  a =  100

var b =  300.5


var c = Double(a) + b

当在Swift里面设置nil值时需要在数据类型的后面添加一个？表示这个变量可以为nil

var a1 : Int? = nil;

// 在Swift里面Bool类型是一个结构体，只有两种结果，true 和false 所以不能通过以前的非0 为真去确定Bool的真假

错误写法

//var bool = 0;

// 正确写法

var bool = true
print(bool)

在Swift里面定义字符串变量

// 字符串的拼接
//
var c = "dasadas"

var d = "sdfafsdcx"
// c d 拼接字符串

var f = c + d

需要注意的是此时的 c d f 都是 var类型的

在Swift里面定义数组：

使用 [ ] 去表示定义一个数组

// 定义的基本方式

第一种根据初值定义

let array = [1, 2, 3]

Swift中数组里面的元素必须是同一数据类型【在Swift 2.0做的改变】

array1里面会自动转换成NSObject对象类型

let array1 = [1, 2, 3, "b"]

第二种先指定数组里面元素的类型，在去给初值

let array2:[Int] = [1,2,3];

访问数组元素

// 使用var定义数组 数组中若存在值可以根据下标更改
var array:[Int] = [100];
//
var array1:[Int] = [1,2,3,4,5];

// 运算符重载
var array2 =  array + array1

print(array2);

// 在数组的末尾添加一个元素
// array必须是变量的类型
array.append(10000)
//
//// 在数组中插入一条数据
array.insert(200000, atIndex: 1)
//移除数组中的某个元素
array.removeAtIndex(1)
print(array)

在Swift里面定义字典：

定义字典的格式：

let/var 字典名 = [key: value, key : value];

let dictionary = ["a" : 1, "b" : 2];

如果字典由初值去确定key和value的数据类型，则里面的key和value的数据类型可以不同

// Swift2.0之前不可以
let dictionary1 = ["a" : 1, "b" : 2, 4 : "4"];

// 自定义输出

print("type1.0 ====\(type1.0)");

\ 后面的（）里面写入的是具体的对应的值

// 创建一个字典类型的变量，可以为空值nil
var dictionary2:[String:Int]? = nil

var dictionary2:[String:Int]? = ["1":300];
// 使用？ 修饰的数组在调用是需要在数组名后面添加一个"!"进行拆包
// 创建字典中的某个key值对应的value
dictionary2!["1"] = 200;
print(dictionary2);

在Swift里面定义元组：

定义一个元组的格式：

let 或者 var + 元组名字 =（元素）

元组是Swift中尤为特殊的一个，在Swift中真正实现可以有多的返回值的情况就是通过元组实现的

let type11 = ("windsSunShine",18);
//
let type22:(name :String, age : Int) = type11
//
print(type22);

//// 拼接打印
print("My name\(type22.name),My age is \(type22.age)岁")

//switch 可以搭配元组使用

// 定义元组使用（）
let point = (10,10)
// 应用与动画的实现
switch point {
case (10, 10): // 为（10，10）这个点时输出元组
 print(point)
   
case(_,10): // 使用_忽略某个条件
print(point.1)
case(10,_):
   
 print(point.0)
  
case(_,_): // 可以使用__忽略所有条件
 
print(point)
    
}

注意：

在Swift中 i++ 于 i ++ 是不同的，

在Swift 写i ++ 是错误的它是根据空格或者回车来断句的，所以一定要注意空格的使用

Swift的if判断语句：

在if判断中 Swift和 Objective-c的区别在于在判断语句中要将条件写完整括号可有可无

var timer :[Int]? = nil;

if timer != nil{
    
}else {
 
}

Swift的循环语句：

for：

//..< 代表 从数字1 开始到数字n 但是不能包括数字n
//... 代表的是从数字1 开始到数字n但是包含数字n
for var i in 0..<array22.count{
   
    print(array22[i])
}

此时我们可以用Swift就可以写一个冒泡排序了如下：

var  array33 = [23,45,43,12,13];

print(array33)

for var i = 0; i < 5; i++ {
    
    for var j = 0; j < 4 - i; j++ {
    
    if array33[j] > array33[j+1] {
    
        var temp = array33[j];
        array33[j] = array33[j+1]
        array33[j+1] = temp
    }
    
    }
}

    
    print(array33);

While循环：

如果说for循环是“屌丝”循环的话，那while一定是那个高富帅

var i = 0;

while i < 10 {
    
    i++
    print(i);
}


// Swift里面没有 do-while 循环用repeat替代， 在Swift1.0时，Swift中也是do-while 而在2.0之后成了repeat-while

repeat {

  i++
  print(i)

}while i < 10

分支循环switch

switch在Swift中和OC的区别在于

Swift中不用写break ,但是default里面需要写东西，每一个case里面也需要写东西

let value = 0;

switch value {
case 0:
    print(value)
    
    fallthrough // 表示0情况下面的语句全部执行
    
case 1:
    print("value======\(value)")

default:
    print("error")

switch还可以对值进行区间的匹配

switch value {
    
case 0...10:  // 包含10
    print(value);
case 11..<20:  // 不包含20
    print("value=====\(value)")
default :
    print("error")
    
}

switch可以搭配where使用

let a1 = 10
switch a1 {
    
    
case 1 where a1 < 10:
    print(10)
    
default:
    print(100)
    
}

Swift里面的方法的叫法与OC中有些许的不同在Swift中成为函数变量，而定义函数变量的的关键字就是： func

定义函数的格式：

func（关键字） test(函数名)（参数）-> 返回值类型{}

如果没有返回值可以将 -> Void 省略

无参无返回值

func  test() -> Void {
    print("我是一个无参无返回值的函数")
}

func test1(){
    print("精简之后的函数")
}

// 调用函数
test()
test1()

无参有返回值

func test2() -> String {
    return "a"
}

print(test2());

// 返回一个OC的数据类型
func test3() -> NSArray {
    return ["a","c",3]
}

// 返回一个Swift的数组 要明确元素的类型

func test4() -> Array<Int> {
    
    return [1,3,4]
}


func test5() -> Array<NSObject> {
    
    return [1, 3, "r"]
}

有多个返回值的现象：

// Swift中可以返回多个返回值，实质上是返回一个元组
func test6() ->(String, Int) {
  
    return ("a", 6)

有参无返回值

func test11( name: NSString){
    
    print(name)
    
}

// 参数是数组类型的函数 有返回值一定要写 ->
func test22(people : Array<Int>) -> Void {
    
}

在Swift的函数变量中还有一个特别的地方，那就是函数的命名方面

在Swift中包含

外部参数名

内部参数名举例如下：

func test33(waibu neibu:String) {
    
    print(neibu);
    
    print("windsSunShine")
}
//
//
//
test33(waibu: "hello");

打印结果为：

hello // 先打印的是内部参数对应的值，即调用的值

windsSunShine // 接着打印的是函数要执行的内容

如果不想让外界知道你的外部参数名的话可以使用下划线忽略掉外部参数名，每一个参数会自带一个外部参数名的，如果不写则和内部参数名一致：如下面的函数的外部参数名 age ,内部参数名也是age

func test44(nihao name:String, age:Int) {
    
    print("name = \(name),age =\(age)")
}

除此之外

在函数的内部是不能改动参数的值的，因为每一个参数是默认使用let定义的

如果需要改的话，可以手动的使用var定义

func test9(var name : String) {
    
    name = "a"
}



func test1(inout name: String) {
    
    name = "你好"
    
    
}

var name = "我很好"

test1(&name)

print(name)

打印结果是： 你好

使用inout修饰参数名，是var定义的可以更改参数的值在使用时可以改变传进来的参数值

在Swift里面可以嵌套定义函数：而在OC中只允许嵌套调用不允许嵌套定义的，同时在C 语言的函数中也是不允许嵌套定义函数的

func test14() {
    
    
    func test1() {
        
        func test2() {
            
            
        }
    }
}

最后通过上面的基础，我们可以简单的封装一个小demo用来数组的排序：代码如下：

先创建一个file在file里创建一个函数：

func maopao( inout array1 :  Array<Int>) -> Void {
    
    
    for var i = 0; i < array1.count; i++ {
        
        for var j = 0; j < array1.count - 1 - i; j++ {
            
            if array1[j] > array1[j+1] {
                
                let  temp = array1[j]
                
                array1[j] = array1[j+1]
                
                array1[j+1] = temp
                
            
        }
            
        }
    }

}

接着就可以在外部调用了

    override func viewDidLoad() {
        super.viewDidLoad()
        
        
        var array = [1,23,56,2,7,14,87,23,10];
        
    
        maopao(&array);
        print(array);
        
       
    }

欢迎转载，请注明转载和原文出处：http://www.cnblogs.com/windsSunShine/p/4989476.html

posted @ 2015-11-23 19:58 windsSunShine 阅读(518) 评论(1) 编辑收藏举报

刷新页面返回顶部

windsSunShine

初识你---------Swift【上篇】

公告