swift基础语法篇 1

基础语法

//基础数据类型：
int float double bool character(char 单个字符) string

// 变量常量：
var a = 1 // 变量
let b = 1 //常量

//指定类型与类型推断
var a = "你好" // 类型推断 
var b:String = "我也好" // 指定类型（类型首字母大写）

//判断数据类型
var str = "xxxx"
type(of:str)

// 控制台输出
print(item:Any...) // 接受一个任意类型的可变参数
print(str)
print(str,str1)

// 字符串拼接
let s1 = "一只"
let s2 = "小白兔"
var s3 = s1 + s2; // "一只小白兔"
var s4 = "\(s1)\(s2)\(s3)" // 一只小白兔一只小白兔

var s1 = "中国"
var s2 = "china"
s1 += s2
print(s1) // 中国china

// 类型别名  和 typdef 一样 
typealias number8 = Int8
typealias number16= Int16

// 类型转换  转换失败返回 nil 空
var a = 1
var b = "1"
var c = b + String(a)
print(type(of:c))// String

// ?? 语法 空置合并 前面有值就用前面 否则用默认值
// 理解成三元简写
var x = "asdf"
var k = Int(x) ?? 10 // 转换失败 返回10 
print(k) // 10

// OPtional() 可选类型（不确定是否有值）  ≈ Integer a = null
var a:Int? = 123 
var b:Int? = nil;
print(a) // Optional(123)
// ! 语法 取出 OPtional() 的真值 
print(a!) // 123
print(b!) // 空值会抛出异常 

// 元组 不同类型放在一起的数组 ≈ Object[] obj = {1,"2",1.3};
var a = ()// 空元组
var a:(Int) = () // 会抛异常 不允许指定了类型不设置值
var a = (1 , 1.2)
var a:(Int,String) = (1,"123")

// 可以设置属性名称
var a:(arg0:String,arg1:Int) = ("hello",1)
var a = (arg0:"hello"marg1:"word") 
// 元组取值
print(a.0) // 取下标 0 
a.1 = 10 // 赋值下标 1

a.arg0 = " " // 赋值 属性

// 元组传递 值传递 不是引用
var a = ("hello","world",true)
var b = a
b.0 = "123"
print(a) // ("hello","world",true)
print(b) // ("123","world",true)

// 基础运算符
// 注意：swift 没有 ++（自增） --（自减） 运算符
 + - * 、 % < >  =  >= <= !=  && ||  ??  += -= *= /= 
 ==  !=  & | ! ~ ^  >> << 

// 区间运算符 主要配合 for循环使用
1...5  // 区间值为 1 2 3 4 5
1..<5  // 区间值为 1 2 3 4 
1... // 1 到 ∞
// if 语句 
if(true){
  
}else if(true){
  
}else{
  
}
// 小括号可以不写 
if true {
  
}else if true {
  
}else {
  
}

// switch case  不写break 也不会穿透 想要穿透效果使用多值匹配
var a = 10
switch (a){
  case 1 : 
  			break
  case 2:
  			break
  default:
  			break
}
// 匹配多个值
switch(a){
  case 1,2,3,4:
  		 break
  case 5,6,7,8:
  		break
  default:
  		break
}

 // for  in 循环
for index in 1...5 { // 步长 1
    print(index) // 1,2,3,4,5
}
for (int a = 1; a<= 5 ;a++ ){
    System.out.println(a) 
}

// for in 步长不为1 从0开始到10结束 包含10 步长为2
for index in stride(from: 0, through: 10, by: 2) {
    print(index)
}
for (int a = 0; a<= 10 ;a+=2 ){
			System.out.println(a);
}

// for in 步长不为1  从0开始到10结束 不包含10 步长2
for index in stride(from: 0, to: 10, by: 2) {
    print(index) // 0 2 4 6 8 10
}
for (int a = 0; a< 10 ;a+=2 ){
			System.out.println(a);
}
// for in 反向
for index in stride(from: 0, to: 10, by: 2).reversed() {
    print(index) // 8 6 4 2 0 
}
// 跳出 
continue // 跳出本次进入下次
break // 跳出本层所有

// while 
while(true){
  
}


// String 基本操作
var str = "ABCD"
print(str.count) // 长度

// 获取子字符
// String.Index 内部类 用于字符串索引下标 不是Int类型
var i:String.Index = str.startIndex // 字符串的第一个索引
var j:String.Index = str.endIndex // 字符串的最后一个索引 + 1
print(str[i]) // A 获取 i索引的字符
print(str[str.index(after: i)]) // B 获取 i 索引的 after（后偏移1位） 的索引位置字符
print(str[str.index(before: j)]) // F 获取 j 索引 before（前偏移1位） 的索引位置字符
print(str[str.index(i, offsetBy: 2)]) // C 获取 i索引 往后偏移 2 位 的索引位置的字符
var lastIndex = str.index(before: j) // 字符串最后一个字符的索引
print(str[i...lastIndex]) //取区间 ABCD 从 i 索引位置 一直到包含    lastIndex 索引位置
print(str[i..<lastIndex]) //取区间 ABC  从 i 索引位置 一直到不包含  lastIndex 索引位置
print(str.prefix(2)) // AB 获取从 0 开始 2 个位置的子字符串

// 是否包含 某个字符
print(str.contains("E")) // false
// 是否有交集 只要有一个字符相同 都返回true
print(str.contains(where: String.contains("AE"))) // true

// 追加字符串
str.append("EFG")
print(str) // ABCDEFG
// 指定位置插入字符串
str.insert(contentsOf: "000", at: str.startIndex)
print(str) // 000ABCDEFG
// 修改指定位置字符串
str.replaceSubrange(str.startIndex...str.startIndex, with: "1")
print(str) // 100ABCDEFG
// 删除指定位置字符串
str.remove(at: str.startIndex)
print(str) // 00ABCDEFG

// 遍历 也可以用索引 使用区间运算
for item in str {
    print(item)
}

// 多行文本 第一行内容不能超过引号位置
var str =
"""
 hello
                       apple
    swift
"""
print(str)
// #"  "# 里面的内容都会当成字符串 特殊字符也不用转义
var s = #" （*&%……￥#@@%%|」「？》《“ "#
print(s) // （*&%……￥#@@%%|」「？》《“ 

// 数组 Array 排序过滤等可以使用stream方式
var a = [Int]()
var a = [1,2,3,4]
var a:[String] = ["你好","世界"]
var a:Array<Int> = [1,2,3,4]
// 添加
a.append(1) // 尾部追加
a += [5] 
// 数组合并 
var a = [12,11]
var b = [14,44]
var c = a + b  // c = [12,11,14,44]

// set 集合 无序不重复 
var a:Set = [1,2,3]
var a:Set<String> = ["1","2"]
var a:Set<Int> = []

// Dictionary 字典集合 Map
var a = ["A":"a","V":"v"]
var a:Dictionary<String,String> = ["A":"a","V":"v"]
var a = [String:String]()
var b:Dictionary<String,String>? = nil
// 遍历
var  a = ["1":"1","2":"2"]
for (key,value) in a {
    print(key,value)
}
// 函数 
// 函数关键字 函数名 （参数名：参数类型） -> 返回值类型
// 形参列表 都是只读的 let 不可更改
func test( a:Int,b:Int) ->Int
{
    var i = a;
    i *= 2
    return i
}
// 传引用 inout 
var i = 2
func test( a:inout Int)
{
    a *= 2
}
test(a: &i)
print(i) // 4
// arg0 与 arg1 为 外部可见参数名
// a b 内部使用参数名
func test(arg0 a:Int,agr1 b:Int) ->Int
{
    var i = a;
    i *= 2
    return i
}
// 形参 可变参数  类型...
func test( a:Int,b:Int...) -> Int
{
    var i = a;
    for x in b{
        i += x
    }
    return i
}
print(test(a: 2, b: 1,2,3,4))

//函数的返回值还是函数 以及指向函数的指针
var func1: (Int,Int)->Int // 定义变量 func1 类型是 两个Int参数 返回值也是Int的函数 类型

func sum(a:Int,b:Int)->Int{ // 求和
    return a + b
}

func test() -> (Int,Int)->Int // 两个Int参数 返回值也是Int的函数 作为返回值
{

    return sum(a:b:) // sum 函数符合需求
}

func1 = test() // 变量接收test（）的返回值  fucn1 == sum

print(func1(10,20)) // 调用func1 就是调用 sum 

// 函数指针 匿名函数
var a:(Int,Int)->Int = {(a:Int,b:Int)->Int in
    return a + b
}
print(a(10,20)) // 30

// 函数作为参数传递给另一个函数
var func1: (Int,Int)->Int
func sum(a:Int,b:Int)->Int{
    return a + b
}
func test(func1:(Int,Int)->Int) -> Int{   
    return func1(10,20)
}
print(test(func1: sum))  // 30

// 函数嵌套 
func sum() -> Int {
    func sum2()->Int{
        return 10 + 10
    }
    return sum2()
}
print(sum()) // 20

// guard 拦截语句
func test(arg1 a:Int,arg2 b:Int)->Int{
    
    guard a<10 && b<10 else { // 如果 a < 10 && b < 10 走 a * b
        return a + b					// 否则 走 a + b
    }
   return a * b
}
print(test(arg1: 10, arg2: 10)) // 20

// 闭包  就是匿名函数
{
  (a:Int , b:Int ) -> void in
  
}

// 枚举
enum  TestEnum : Int{
    case ONE = 1
    case TWO = 2
}
print(TestEnum.ONE) // ONE
print(TestEnum.ONE.rawValue) // 1

// 结构体 适合用来传递数据 只会传值不会传引用 深拷贝
struct Test{
    var name:String
    var age:Int
}