ios之秒学swif入门手册

mac笔记本基本操作使用

在mac上optoin代替win上的alt，command代替windows键

mac上常用快捷键

• 剪切、拷贝、粘贴和其他常用快捷键

  • Command-X：剪切所选项并拷贝到剪贴板。
  • Command-C： 将所有文件拷贝到剪贴板这同样适用于访达中的文件。
  • Command-v ：将剪贴板的内容粘贴到当前文稿或文件夹中，这同样适用于 访达中的文件。
  • Command-Z：撤销上一个命令。随后您可以按 Shift-Command-Z 来重做，从而反向执行撤销命令。在某些应用中，您可以撤销和重做多个命令。
  • Command-A：全选各项。
  • Command-F：查找文稿中的项目或打开“查找”窗口。
  • Command-G：再次查找：查找之前所找到项目出现的下一个位置。要查找出现的上一个位置，请按 Shift-Command-G。
  • Command-H：隐藏最前面的应用的窗口。要查看最前面的应用但隐藏所有其他应用，请按 Option-Command-H。
  • Command-M：将最前面的窗口最小化至“程序坞”。要最小化最前面的应用的所有窗口，请按 Option-Command-M。
  • Command-O：打开所选项，或打开一个对话框以选择要打开的文件。
  • Command-P：打印当前文稿。
  • Command-S：存储当前文稿。
  • Command-T：打开新标签页。
  • Command-W：关闭最前面的窗口。要关闭应用的所有窗口，请按下 Option-Command-W。
  • Option-Command-Esc：强制退出应用。
  • Command–空格键：显示或隐藏“聚焦”搜索栏。要从“访达”窗口执行“聚焦”搜索，请按 Command–Option–空格键。（如果您使用多个输入源以便用不同的语言键入内容，这些快捷键会更改输入源而非显示“聚焦”。了解如何更改冲突的键盘快捷键。）
  • Control-Command–空格键：显示字符检视器，您可以从中选择表情符号和其他符号。
  • Control-Command-F：全屏使用应用（如果应用支持）。
  • 空格键：使用快速查看来预览所选项。
  • Command-Tab：在打开的应用中切换到下一个最近使用的应用。
  • Shift-Command-3：拍摄整个屏幕的屏幕快照。进一步了解屏幕快照快捷键。
  • Shift-Command-N：在“访达”中创建一个新文件夹。
  • Command-逗号 (,)：打开最前面的应用的偏好设置。

• 常用操作键

  • Command-F3：快速回到桌面
  • alt+⬆️：切换输入法(自定义快捷键，可以在右上角的输入法-偏好设置定义)
  • control-Command-空格：输出特殊符号，可以直接输出表情

其它快捷键请点击查看。

秒学swif语

学习一门语言的方法

• 应用程序=数据结构+算法

  • 面向过程
  • 数据结构：常量、变量，注释、基本数据类型、函数、闭包、枚举
  • 算法：基本运算符、控制语句
  • 面向对象
  • 数据结构：类、结构体、属性、方法、附属脚本、类型嵌套、扩展、协议、范型
  • 算法：构造及析构过程

swif语言简介

swif语言体系形成了铁人三项模式，即软件+硬件+网络构成的智能设备，google和apple一样在建立一个智能设备的开放标准，对未来市场的布局和竞争。OC有20年的历史了，已经过时了，swif是oc的完全替代，他们还互相兼容。

swif语言基础语法

面向过程

• 数据结构

  • let name=”dadong”//定义常量

  • var newName=”dadong”//定义变量

  • var age:Double=30//定义指定数据类型的变量

  • 支持utf-8和unicode

  • var 小汽车="hello"
    
    小汽车="?"
    
    print(小汽车)//代码支持直接输出表情
    

  • 多个变量叠加输出

  • print(“hello”+电视)

  • print(“hello(age)”)//不同类型变量叠加

  • 注释和java类似

  • 可以在一行写多个语句，一行有多句代码的时候必须使用分号

  • 等号两边的空格需一样

  • 数据类型强转不报错String转int

  var age2="we"
  var age : Int? = Int(age2)
  print(age)//输出显示nil，表示空值
  

  • 小数类型

  var pi:Double=3.1415
  var pii:Float=3.14
  print(Double(pii)+pi)
  

  • let a=0b0010//二进制

  • let b=0o1276//八进制

  • let c=0x12F//十六进制

  • 数据类型定义别名

  typealias st = String
  var s:st="字符串别名"
  print(s)
  

  • bool类型：var e:Bool=true

  • 元组

  var tus=("hello",12,23,11,"jj",true)
  print(tus.4)
  

  • 元组使用

  func getName()->(String,Int){
      return ("Hi Himi",123)
  }
  var tus2=getName()
  print(tus2.1)
  

  • var z:Character=”A”//字符

  var z:Character="A"
  var g="sasa"
  print(g+"\(z)")//字符和字符串拼接
  //遍历字符串
  for character in g{
      print(character)
  }
  

  • 数据类型CollectionType

  • 数组

    • 数组定义

    var myList=["Hello","Test","demo"]
    var myList2:[Int] = [1,2,3]
    

    • 数组访问

    myList[0]="hello word"
    print(myList.count)
    print(myList.append("ceshi"))
    myList.insert("123", at: 2)
    print(myList.isEmpty)
    

    • 数组遍历

    for value in myList{
        print(value)
    }
    

  • 字典

    var myHash:Dictionary=["key1":"value1","key2":"value2","key3":"value3"]//定义
    print(myHash["key2"])//打印
    myHash.updateValue("value22", forKey: "key2")//更新
    myHash.removeValue(forKey: "key2")//删除
    //遍历
    for value in myHash.values{
      print(value)
    }
    

  • 枚举

    enum Sex{
      case Male
      case Female
    }
    
    var daddongSex=Sex.Male
    daddongSex = .Female
    print(daddongSex)
    
    enum name {
      case China(Int,Int)
      case Japan(String)
    }
    var myCountory = name.China(1, 2)
    print(myCountory)
    

• 算法：

  • 基本运算

  • 加减乘除取余等赋值运算

  let age:Int=5
  let age2:Int=23
  let age3 = age*age2
  

  • 比较运算符

  if(age3>=age2){
  }
  if(age != age2){
      print(age2)
  }
  //三元运算符
  let count = (age2

  • 逻辑运算符

  if(!(a

  • 控制流

  • 循环

    //for循环
    var friends = ["Leo","Amey","Tony"]
    for friend in friends{
      print(friend)
    }
    //while循环
    var j=1,k=5
    while (k>j) {
      print(j)
      j+=j
    }
    //repeat-while循环
    repeat {
      print(j)
      j+=j
    }while(k>j)
    

  • 条件语句

    if(k>j){}else{}//if else判断语句
    //switch语句
    switch(k){
    case 1:
      print(1)
      break//swif语言默认有break
    case 2:
      print(2)
      break
    default:
          print("nothing")
      break
    }
    

面向对象

• 数据结构

  • 类：在swif中多个类可以写在一个文件中

  class TV{
      var keyCount="12"
      var keyName="Power"
      func openTV() -> String {
          return "success"
      }
  }
  var miTv = TV()
  print(miTv.keyName)
  miTv.keyName="Qiuck"
  print(miTv.keyName)//类是引用类型
  

  • 结构体

  struct TV {
      var keyName = "Albert"
      var keyNumber = 12
      func getKeyNumber() -> Int {
          return keyNumber
      }
  }
  //var myTv=TV()
  var myTv=TV(keyName: "Power", keyNumber: 24)//有自带构造函数
  print(myTv.getKeyNumber())
  

  • 结构体和类的异同

  • 相同点

    1. 都有内部变量和函数
    2. 都可以有内部下标方式去取属性
    3. 都可以有初始化函数
    4. 都可以用协议

  • 不同点

    1. 类有继承，结构体没有
    2. 类可以多重引用，结构体不行
    3. 类有析构

  复杂的对象使用类，简单对象可以用结构体

  • 协议类似java中的接口

  class  BaseClass {
  
  }
  protocol Action {
      var myName:String {
          get set
      }
      var myAge :Int {
          get
      }
      func getName() -> String
  }
  protocol ChildAction:Action {
  
  }
  //继承基类并实现多个或一个协议时需要先写基类
  class InvokeAction: BaseClass,Action,ChildAction {
      var m_name=""
      var myName: String {
          get{
              return "Wangyu"
          }
          set{
              myName = newValue
          }
      }
      var myAge: Int {
          get{
              return 30
          }
      }
      func getName() -> String {
        return "Wangyu'name"
      }
  }
  var TestProtocol:Action = InvokeAction()
  print(TestProtocol.getName())
  
  

  • 范型

  //函数中使用范型
  func swapValue(a:inout T,  b:inout T){
      let temp=a
      a = b
      b = temp
  }
  var c = "hello"
  var d = "thanks"
  swapValue(a: &c, b: &d)
  print(c)
  //类使用范型
  class VStudy {
      func getName(s:T){
          print(s)
      }
  }
  var VStusyClass=VStudy()
  VStusyClass.getName(s: 123)
  

• 算法

  • 函数

  //函数定义
  func sayHello(userName:String,age:Int)->String{
      return "用户名: \(userName) 年龄: \(age)"
  }
  print(sayHello(userName: "zhangsanfeng", age: 20))
  //多返回值的函数
  func getName()->(name:String,age:Int){
      print("NoResult")
      return ("Tony",30)
  }
  print(getName().name)
  //可变参数
  func countPerson(users:String...){
      for user in users {
          print(user)
      }
  }
  countPerson(users: "keitty","womeo","Albert")
  //更改传递参数的值
  func changeName(name: inout String){
      name+="AAA"
  }
  changeName(name: &myName)
  //A函数调用B
  func addMoney(a:Int,b:Int) -> Int{
      return a+b
  }
  var getMoney = addMoney
  var num=getMoney(1,2)
  print(num)
  

  • 构造函数

  class TV{
      var name:String = "Xiaomi"
      init(name:String) {
          self.name=name
      }
      func openTV() -> String {
          return "success"
      }
  }
  var miTv = TV(name: "Leshi")
  print(miTv.name)
  //析构函数
   deinit {
          name = ""
      }
  //继承
  class MITV:TV{
      //实现父类的构造方法
       override init(name: String) {
          super.init(name: name)
          super.name="Geli"
      }
      //重写父类变量
      override var name: String{
          get {
              return self.name
          }
          set {
              if(self.name=="dadong"){
                  super.name="hello dadong'mather"
              }else{
                  super.name="hello"
              }
          }
      }
      //可以通过final关键词限制重写和继承
  }
  var myMiTv=MITV(name: "Changhong")
  print(myMiTv.name)//继承了属性
  print(myMiTv.openTV())//继承了方法
  

5332