swift

swift相关知识

• Swift编译器结构分析

  Swift介绍Swift是一种高性能的语言，拥有整洁现代的语法。swift可以和C、OC的代码和框架无缝衔接，并且swift默认是内存安全的。  Swift的代码仓库包含了Swift编译器和标准库的源码，还有例如用于IDE集成的SourceKit等相关组件。Swift编译器概况来说，Swift编译器负责将Swift源码转成高效的可执行机器码。下面我们对Swift编译器的几个主要组件进行说明。编译器基本知识构建过程构建过程分为预处理(pre-process)  用于导入文件和展开宏.纯文本操作,不考虑语言语法含义(狭义的)编译  对预处理器的输出进行编译，生成汇编语言(assemble language)。一般汇编语言代码的文件扩展名.s汇编  汇编器转为机器语言，这个过程称为汇编(assemble),输出为目标文件(object file),一般扩展名为.o链接  目标文件本身不能使用。将目标文件转换为最终可以使用的形式的过程,称为链接(link)。可执行文
• Swift系列 - 数据类型

  如果你习惯了OC的语法，第一次接触Swift的语法可能会有点抗拒，因为Swift的语法有点怪。但如果你有前端的基础，学Swift可能会有点吃力，如果你有C++的基础可能会学得比较快点。不管你有什么样的语法基础，学会Swift后你都会觉得这是门优秀的语言，总之相比哥哥OC更简洁，更高效。现在Swift的ABI版本已经到5.2了，总体趋于稳定，社区也很活跃，是系统学习的好时机。 一、打印（print） 可以认为是C的扩展写法： let word = "world" print("print output") // 输出：print output prin
• Swift语言 | Swift 语言开发 iOS 应用程序的利弊

  目前全球共有超过 7 亿台 iPhone 处于活跃状态，这造就了 iOS 作为全球第二大移动设备平台的状态。虽然安卓系统的全球市场占有率超过 iOS 系统，但在诸如美国、法国和英国的区域性市场中 iOS 系统仍然占据主导地位。因此许多公司专注于 iOS 平台进行软件开发，因为他们将 iOS 平台视作关键投资机会。如果你的公司也正计划跟随 iOS 软件开发，那么你需要作出一个至关重要的决定。你需要为你的产品选择合适的技术组合。你的目标是什么？如果是原生应用开发而不是跨平台软件，你会选用哪种编程语言？久经考验的 Objective-C 还是 Swift？为了帮助你作好这个抉择，我们来看一看使用 Swift 语言进行 iOS 开发会有哪些优势和弊端。关于这种编程语言，你必须了解哪些信息？使用 Swift 会有哪些风险？为了开始讨论 Swift 语言的优缺点，我们先回顾一下 Swift 的发展历史。Swift - 它的历史和背景故事Apple 于 2014 年的 WWDC（Worldwide Developers
• Swift 性能相关

  为什么说 Swift 性能相比较于 Objective-C 会更加 好 ？为什么在编译 Swift 的时候这么慢 ？如何更优雅的去写 Swift ？Swift中的类型首先，我们先统一一下关于类型的几个概念。平凡类型有些类型只需要按照字节表示进行操作，而不需要额外工作，我们将这种类型叫做平凡类型 (trivial)。比如，Int 和 Float 就是平凡类型，那些只包含平凡值的 struct 或者 enum 也是平凡类型。struct AStruct {     var a: Int }struct BStruct {     var a: AStruct }// AStruct & BStruct 都是平凡类型引用类型对于引用类型，值实例是一个对某个对象的引用。复制这个值实例意味着创建一个新的引用，这将

swift相关课程

• 玩儿转Swift 2.0（第二季） 本课程以Swift 2.1版本进行讲解，课程发布期间，Swift语言进行的更新将同步在本课程的代码中展现。欢迎同学们随时关注课程公告及课程问答区，紧跟Swift语言的步伐，学习最新示例代码！

  讲师：liuyubobobo 入门 15523人正在学习

• 玩儿转Swift 2.0（第一季） 介绍2.0新版本Swift语言的基础知识 。

  讲师：liuyubobobo 入门 36380人正在学习

• Swift之网络常见术语 本课程主要讲解Swift网络的常见术语，了解HTTPS、网络客户端、服务端以及socket。

  讲师：gix_ic 初级 4341人正在学习

swift相关教程

• 3.2 Set (只读集合) 和 MutableSet (可变集合) 集合初始化在 Kotlin 中 Set 只读集合初始化主要是通过 setOf<T> 函数，而 MutableSet 可变集合初始化主要是通过 mutableSetOf<T> 函数。Set 初始化：fun setInit() { //通过setOf<T>(xx,xx,xx)函数初始化,带初始化元素的集合 val languages1: Set<String> = setOf<String>("kotlin", "dart", "java", "swift") //Set<String>可以不用声明，通过setOf<String>可以类型推导出具体类型 val languages2 = setOf<String>("kotlin", "dart", "java", "swift") //<String>泛型类型可以不用声明，通过集合内部元素初始化值的类型，可以推导出元素类型是String val languages3 = setOf("kotlin", "dart", "java", "swift") //通过setOf<T>函数初始化空集合 val emptyLanguages1: Set<String> = setOf<String>() //<String>泛型类型可以不用声明，通过List<String>可以知道是泛型类型是String val emptyLanguages2: Set<String> = setOf() //注意: 这是不合法的，因为无法推导出具体元素类型// val emptyLanguages3 = setOf() //空集合还可以通过emptySet<T>函数来实现，实际上通过源码发现setOf<T>()，最后都是委托调用emptySet<T>() val emptyLanguages4 = emptySet<String>()}MutableSet 初始化：fun mutableSetInit() { //通过mutableSetOf<T>(xx,xx,xx)函数初始化,带初始化元素的集合 val languages1: MutableSet<String> = mutableSetOf<String>("kotlin", "dart", "java", "swift") //MutableSet<String>可以不用声明，通过mutableSetOf<String>可以类型推导出具体类型 val languages2 = mutableSetOf<String>("kotlin", "dart", "java", "swift") //<String>泛型类型可以不用声明，通过集合内部元素初始化值的类型，可以推导出元素类型是String val languages3 = mutableSetOf("kotlin", "dart", "java", "swift") //mutableSetOf<T>函数初始化空集合 val emptyLanguages1: MutableSet<String> = mutableSetOf<String>() //<String>泛型类型可以不用声明，通过MutableSet<String>可以知道是泛型类型是String val emptyLanguages2: MutableSet<String> = mutableSetOf() //注意: 这是不合法的，因为无法推导出具体元素类型// val emptyLanguages3 = mutableSetOf() //空集合还可以通过LinkedHashSet<T>函数来实现，实际上通过源码发现mutableSetOf<T>()，最后都是委托调用LinkedHashSet<T>() //而且LinkedHashSet<T>实际上就是Java中的LinkedHashSet<T>,只不过是Kotlin中取了一个别名而已 val emptyLanguages4: MutableSet<String> = LinkedHashSet<String>()}集合遍历Tips：Set 和 MutableSet 的遍历是一样的。Set 的遍历：fun main() { val languageSet = setOf("kotlin", "dart", "java", "swift") //for-in for (language in languageSet) { println(language) } //for-each languageSet.forEach { println(it) } //for-in-indices for (index in languageSet.indices) { println(languageSet.elementAt(index))//注意，Set是没有get方法运算符重载函数的， // 所以不能直接通过languageSet[index]获取，但是可以通过扩展函数elementAt获取 } //while-iterator val iterator = languageSet.iterator() while (iterator.hasNext()) { println(iterator.next()) }}MutableSet 的遍历 fun main() { val languageSet = mutableSetOf("kotlin", "dart", "java", "swift") languageSet.add("ruby") languageSet.add("python") //for-in for (language in languageSet) { println(language) } //for-each languageSet.forEach { println(it) } //for-in-indices for (index in languageSet.indices) { println(languageSet.elementAt(index))//注意，Set是没有get方法运算符重载函数的， // 所以不能直接通过languageSet[index]获取，但是可以通过扩展函数elementAt获取 } //while-iterator val iterator = languageSet.iterator() while (iterator.hasNext()) { println(iterator.next()) }}
• 2.2 创建一个 Kotlin/Native 项目 - 选择左侧的 Kotlin/Native, 并选择右侧的 Sing View App with a Kotlin/Native Framework- 填写项目名和包名，选择语言 Swift (这里先以 Swift 为例)最后 finish 即可创建完毕 Kotlin/Native 项目，创建完毕后项目结构如下：
• 3.1 List (只读集合) 和 MutableList (可变集合) 集合初始化Tips： 在 Kotlin 中 List 只读集合初始化主要是通过 listOf<T> 函数，而 MutableList 可变集合初始化主要是通过 mutableListOf<T> 函数。List 初始化：fun listInit() { //通过listOf<T>(xx,xx,xx)方法初始化,带初始化元素的集合 val languages1: List<String> = listOf<String>("kotlin", "dart", "java", "swift") //List<String>可以不用声明，通过listOf<String>可以类型推导出具体类型 val languages2 = listOf<String>("kotlin", "dart", "java", "swift") //<String>泛型类型可以不用声明，通过集合内部元素初始化值的类型，可以推导出元素类型是String val languages3 = listOf("kotlin", "dart", "java", "swift") //通过listOf<T>函数初始化空集合 val emptyLanguages1: List<String> = listOf<String>() //<String>泛型类型可以不用声明，通过List<String>可以知道是泛型类型是String val emptyLanguages2: List<String> = listOf() //注意: 这是不合法的，因为无法推导出具体元素类型// val emptyLanguages3 = listOf() //空集合还可以通过emptyList<T>函数来实现，实际上通过源码发现listOf<T>()，最后都是委托调用emptyList<T>() val emptyLanguages4 = emptyList<String>()}MutableList 初始化：fun mutableListInit() { //通过mutableListOf<T>(xx,xx,xx)函数初始化,带初始化元素的集合 val languages1: MutableList<String> = mutableListOf<String>("kotlin", "dart", "java", "swift") //MutableList<String>可以不用声明，通过mutableListOf<String>可以类型推导出具体类型 val languages2 = mutableListOf<String>("kotlin", "dart", "java", "swift") //<String>泛型类型可以不用声明，通过集合内部元素初始化值的类型，可以推导出元素类型是String val languages3 = mutableListOf("kotlin", "dart", "java", "swift") //mutableListOf<T>函数初始化可变空集合 val emptyLanguages1: MutableList<String> = mutableListOf<String>() //<String>泛型类型可以不用声明，通过MutableList<String>可以知道是泛型类型是String val emptyLanguages2: MutableList<String> = mutableListOf() //注意: 这是不合法的，因为无法推导出具体元素类型// val emptyLanguages3 = mutableListOf() //可变空集合还可以通过ArrayList<T>函数来实现，实际上通过源码发现mutableListOf<T>()，最后都是委托调用ArrayList<T>() //而且ArrayList<T>实际上就是Java中的ArrayList<T>,只不过是Kotlin中取了一个别名而已，关于具体内容请参考这个类kotlin.collections.TypeAliasesKt实现 val emptyLanguages4: MutableList<String> = ArrayList<String>()}集合遍历Tips： List 和 MutableList 的遍历是一样的.List 遍历：fun main() { val languageList = listOf("kotlin", "dart", "java", "swift") //for-in for (language in languageList) { println(language) } //for-each languageList.forEach { println(it) } //for-in-indices for (index in languageList.indices) { println(languageList[index]) } //while-iterator val iterator = languageList.iterator() while (iterator.hasNext()) { println(iterator.next()) }}MutableList 遍历：fun main() { val languageList = mutableListOf("kotlin", "dart", "java", "swift") languageList.add("ruby") languageList.add("python") //for-in for (language in languageList) { println(language) } //for-each languageList.forEach { println(it) } //for-in-indices for (index in languageList.indices) { println(languageList[index]) } //while-iterator val iterator = languageList.iterator() while (iterator.hasNext()) { println(iterator.next()) }}
• 3.3 Map (只读集合) 和 MutableMap (可变集合) 集合初始化Map 的初始化：fun mapInit() { //通过mapOf<K,V>(xx to xx,xx to xx,xx to xx)函数初始化,带初始化元素的集合, val languages1: Map<String, String> = mapOf<String, String>( "1" to "kotlin", "2" to "dart", "3" to "java", "4" to "swift" ) // xx to xx实际上是Pair<K,V>的中缀表达式简写形式 val languages2: Map<String, String> = mapOf<String, String>( Pair("1","kotlin"), Pair("2","dart"), Pair("3","java"), Pair("4","swift") ) //Map<K,V>可以不用声明，通过mapOf<String,String>可以类型推导出具体类型 val languages3 = mapOf<String, String>( Pair("1","kotlin"), Pair("2","dart"), Pair("3","java"), Pair("4","swift") ) //<String, String>泛型类型可以不用声明，通过集合内部元素初始化值的类型，可以推导出元素类型是<String, String> val languages4 = mapOf( Pair("1","kotlin"), Pair("2","dart"), Pair("3","java"), Pair("4","swift") ) //通过mapOf<K,V>函数初始化空集合 val emptyLanguages1: Map<String, String> = mapOf<String, String>() //<String, String>泛型类型可以不用声明，通过Map<String, String>可以知道是泛型类型是<String, String> val emptyLanguages2: Map<String, String> = mapOf() //注意: 这是不合法的，因为无法推导出具体元素类型// val emptyLanguages3 = mapOf() //空集合还可以通过emptyMap<K,V>函数来实现，实际上通过源码发现mapOf<K,V>()，最后都是委托调用emptyMap<K,V>() val emptyLanguages4 = emptyMap<String, String>()}MutableMap 的初始化：fun mutableMapInit() { //通过mutableMapOf<K,V>(xx to xx,xx to xx,xx to xx)函数初始化,带初始化元素的集合, val languages1: MutableMap<String, String> = mutableMapOf<String, String>( "1" to "kotlin", "2" to "dart", "3" to "java", "4" to "swift" ) // xx to xx实际上是Pair<K,V>的中缀表达式简写形式 val languages2: MutableMap<String, String> = mutableMapOf<String, String>( Pair("1","kotlin"), Pair("2","dart"), Pair("3","java"), Pair("4","swift") ) //MutableMap<K,V>可以不用声明，通过mutableMapOf<String,String>可以类型推导出具体类型 val languages3 = mutableMapOf<String, String>( Pair("1","kotlin"), Pair("2","dart"), Pair("3","java"), Pair("4","swift") ) //<String, String>泛型类型可以不用声明，通过集合内部元素初始化值的类型，可以推导出元素类型是<String, String> val languages4 = mutableMapOf( Pair("1","kotlin"), Pair("2","dart"), Pair("3","java"), Pair("4","swift") ) //通过mapOf<K,V>函数初始化空集合 val emptyLanguages1: MutableMap<String, String> = mutableMapOf<String, String>() //<String, String>泛型类型可以不用声明，通过MutableMap<String, String>可以知道是泛型类型是<String, String> val emptyLanguages2: MutableMap<String, String> = mutableMapOf() //注意: 这是不合法的，因为无法推导出具体元素类型// val emptyLanguages3 = mutableMapOf() //空集合还可以通过LinkedHashMap<K,V>函数来实现，实际上通过源码发现mutableMapOf<K,V>()，最后都是委托调用LinkedHashMap<K,V>() //而且LinkedHashMap<K,V>实际上就是Java中的LinkedHashMap<K,V>,只不过是Kotlin中取了一个别名而已 val emptyLanguages4: MutableMap<String, String> = HashMap<String, String>()}集合的遍历Tips：Map 和 MutableMap 的遍历是一样的.Map 的遍历：fun main() { val languageMap: Map<String, String> = mapOf<String, String>("1" to "kotlin", "2" to "dart", "3" to "java") //for-in-entry for (entry in languageMap) { println("key: ${entry.key} ---> value: ${entry.value}") } //for-in-解构声明 for ((key, value) in languageMap) { println("key: $key ---> value: $value") } //for-each languageMap.forEach { key, value -> println("key: $key ---> value: $value") } //for-each-解构声明 languageMap.forEach { (key, value) -> println("key: $key ---> value: $value") } //for-in-Map.Entry for (entry in languageMap.entries) { println("key: ${entry.key} ---> value: ${entry.value}") } //for-each-Map.Entry languageMap.entries.forEach { entry -> println("key: ${entry.key} ---> value: ${entry.value}") } //for-each-index-Map.Entry languageMap.entries.forEachIndexed { index, entry -> println("index: $index -----> key: ${entry.key} ---> value: ${entry.value}") } //for-in-Map中的key for (key in languageMap.keys) { println("key: $key") } //for-each-Map中的key languageMap.keys.forEach { println(it) } //for-in-Map中的value for (value in languageMap.values) { println("value: $value") } //for-each-Map中的value languageMap.values.forEach { println(it) } //while-iterator val iterator = languageMap.iterator() while (iterator.hasNext()) { val entry = iterator.next() println("key: ${entry.key} ---> value: ${entry.value}") }}MutableMap 的遍历：fun main() { val languageMap: MutableMap<String, String> = mutableMapOf<String, String>("1" to "kotlin", "2" to "dart", "3" to "java") languageMap["4"] = "swift" languageMap.putAll(mapOf("5" to "ruby", "6" to "python")) //for-in-entry for (entry in languageMap) { println("key: ${entry.key} ---> value: ${entry.value}") } //for-in-解构声明 for ((key, value) in languageMap) { println("key: $key ---> value: $value") } //for-each languageMap.forEach { key, value -> println("key: $key ---> value: $value") } //for-each-解构声明 languageMap.forEach { (key, value) -> println("key: $key ---> value: $value") } //for-in-Map.Entry for (entry in languageMap.entries) { println("key: ${entry.key} ---> value: ${entry.value}") } //for-each-Map.Entry languageMap.entries.forEach { entry -> println("key: ${entry.key} ---> value: ${entry.value}") } //for-each-index-Map.Entry languageMap.entries.forEachIndexed { index, entry -> println("index: $index -----> key: ${entry.key} ---> value: ${entry.value}") } //for-in-Map中的key for (key in languageMap.keys) { println("key: $key") } //for-each-Map中的key languageMap.keys.forEach { println(it) } //for-in-Map中的value for (value in languageMap.values) { println("value: $value") } //for-each-Map中的value languageMap.values.forEach { println(it) } //while-iterator val iterator = languageMap.iterator() while (iterator.hasNext()) { val entry = iterator.next() println("key: ${entry.key} ---> value: ${entry.value}") }}
• 4.2 Kotlin/Native + Objective C 项目结构分析 在 IOS 同事帮助下，进一步了解 IOS APP 启动基本知识，这将有助于我们接下来改造我们项目结构，使得它更加简单，完全可以删除额外的 Swift 代码，包括 APP 启动代理那块都交由 Kotlin 来完成。- 先创建一个 Kotlin/Native + OC 的项目，这里就不重复创建过程，直接把 OC 目录结构给出：可以看到 OC 与 Swift 项目结构差不多哈，可以看到其中有几个重要的文件，main.m、AppDelegate.m、ViewController.mmain.m APP 启动入口，相当于 main 函数，先从 main 函数入手，然后一步步弄清整个启动流程。#import <UIKit/UIKit.h>#import "AppDelegate.h"int main(int argc, char * argv[]) { @autoreleasepool { return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));//这里也调用了AppDelegate类 }}然后转到 AppDelegate.m, 可以看到在 didFinishLaunchingWithOptions 函数中调用了 KNFKotlinNativeFramework 中的 helloFromKotlin 函数。- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { // KNFKotlinNativeFramework class is located in the framework that is generated during build. // If it is not resolved, try building for the device (not simulator) and reopening the project NSLog(@"%@", [[[KNFKotlinNativeFramework alloc] init] helloFromKotlin]);//注意这里调用helloFromKotlin，并输出日志 return YES;}
• 4.1 Kotlin/Native + Swift 项目结构分析 我们知道 main 函数是很多应用程序的入口，ios 也不例外，在 AppDelegate.swift 中有 @UIApplicationMain 的注解，这里就是 APP 启动的入口。@UIApplicationMain //main函数注解入口，所以AppDelegate类相当于启动入口类class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow?//默认加了UIWindow func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { // KNFKotlinNativeFramework class is located in the framework that is generated during build. // If it is not resolved, try building for the device (not simulator) and reopening the project NSLog("%@", KNFKotlinNativeFramework().helloFromKotlin())//注意: 这里就是调用了Kotlin中的一个helloFromKotlin方法，并把返回值用Log打印出来，所以你会看到App启动的时候是有一段Log被打印出来 return true } ...}KotlinNativeFramework 类：class KotlinNativeFramework { fun helloFromKotlin() = "Hello from Kotlin!" //返回一个Hello from Kotlin!字符串}但是呢，有追求的程序员绝对不能允许跑出来的是一个空白页面，空白页面那还怎么装逼呢？哈哈。在 ViewController.swift 中的 viewDidLoad 函数中加入一个文本 (UILabel)。class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() let label = UILabel(frame: CGRect(x: 0, y: 0, width: 300, height: 21)) label.center = CGPoint(x: 160, y: 285) label.textAlignment = .center label.font = label.font.withSize(15) label.text = "Hello IOS, I'm from Kotlin/Native" view.addSubview(label) } override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() // Dispose of any resources that can be recreated. }}最后重新 run 一遍，效果如下：

swift相关搜索

s line safari浏览器 samba SAMP samplerate sandbox sanitize saper sas sass save smarty模板 smil smtp snapshot snd snmptrap soap soapclient soap协议

查看更多慕课网实用课程