进制变换,学习笔记

By admin in 4858.com on 2019年4月26日

    斯威夫特3.0 进制转变

    斯维夫特叁.0 进制转变

字符串和字符(Strings and Characters)

  1. 在新版斯维夫特中, 对String进行了本质性的修改, 在此以前String是字符的会晤,
    所以, 那年能够那样遍历字符串:

for c in "hello" {
  print(c)
}

目前还这么玩就要报错了,
原来是字符数组被放入了3个叫characters的积极分子变量中, 所以最新的遍历姿势是

for c in "hello".characters {
  print(c)
}
// 同样的, String的长度一般由"hello".characters.count来获取
  1. 可变数组:
    正如笔记壹里面说的, 假使String用var来声称, 正是可变的, 在Swift里面,
    数组的加多尤其有利于, 应该是得益于操作符重载的佳绩, 如:

var variableString = "Horse"
variableString += " and carriage" // variableString变为"Horse and carriage"
  1. 字符串是值类型:
    所谓值类型正是赋值的时候会copy贰回, 赋值一回多1份,
    与之对应的是援引类型, 只copy地址, 赋值多少次都唯有1份. 在斯维夫特里面,
    String, Array, Dictionary和Set都以值类型,
    那也正是怎么说Swift安全的缘由之二.

  2. 字符串与字符数组的转移:
    两岸以前的转变极度自然, String有characters再次回到字符数组,
    而字符数组能够由此String的初步化函数转变为String, 如:

let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
  1. Unicode编码:
    那一块内容很多, 值得询问, 属于重要的情节不过用的时候不会太多,
    可以到时候境遇标题再来翻翻文书档案就可以.

  2. 字符串索引
    有关那块内容, 一发端看的时候认为苹果设计的很想获得, 先看例子吗:

let greeting = "Guten Tag!"
greeting[greeting.startIndex]   // startIndex肯定是0啦
// G
greeting[greeting.endIndex.predecessor()]  // endIndex是最后的index+1, 这点会让人比较困惑, 为什么不是最后的index呢
// !
greeting[greeting.startIndex.successor()] // successor从当前往后移一位
// u
let index = greeting.startIndex.advancedBy(7) // 往前移7位
greeting[index]
// 所以下面这样导致runtime error的:
greeting[greeting.endIndex] // error
greeting.endIndex.successor() // error

诚如处境下大家要对String的字符进行访问, 会直接写index,
可是这么会比较危急, 说不定就越界了, 所以苹果专门有个Index的门类,
还有1部分操作的函数来支援

字符数组有个indices的习性, 所以它的的拜访格局还能是那样的:

for index in greeting.characters.indices {
    print("\(greeting[index]) ")
}
  1. 插入和删除
    假定知道了地点的Index, 那么插入就很正规了, 可以插入字符,
    字符串和字符数组, 首要依旧要操作好index

  2. 正如字符串
    壹如既往得益于操作符重载, 未来能够平昔==来决断一个字符串相等了, 举个例子:

let greeting = "hello"
//2016-3-17更正:
//let aGreeting = "hell"+"o"  // 这么写两个常量实际指向同一份数据, 
var aGreeting = "hell"
aGreeting.appendContentsOf("o") // 这么写才能保证指向不同的数据

for index in greeting.characters.indices {
    print("\(greeting[index])", separator: "|", terminator: ".")
}
if greeting == aGreeting {
    print("OK")
}
// 用unsafeAddressOf(greeting)和unsafeAddressOf(aGreeting)可以看到2个变量的地址, 发现并不一样, 说明的确是进行了字符串内容的比较, 而不是比较地址
// 2016-3-17 更正
上面用unsafeAddressOf()函数获取地址的方法貌似并不准确, 关于String的地址, 目前可以通过str._core._baseAddress来观察, Xcode的Debug查看变量也能看到, 这样最直观.

值得一说的是, 因为String里面有Unicode的来头,
所以对Unicode字符的可比会愈发不易,
具体的事例参考官方文档看字符串比较的那一大段

直接上代码,不BB。。用 playground编写!
import UIKit
//
var str = “Hello, playground”
//开采语言,面向对象
/*1.let
常量,那几个不要点,笔者不知晓是哪儿来的,;不要甘休符号,作者不明白是那种语言

  模块能够直接行使,写的不是很好,应接来喷

  模块能够一向利用,写的不是很好,接待来喷

聚拢类型

数组, 字典和聚合(Set)都以会晤类型, 在斯维夫特中CollectionType是三个体协会议,
只要您兑现了这么些体协会议, 都算集结, 并且如前文所述, 那几个集中都以值类型.
那些集中都匡助通用项目(generic types), 能够领略为C++的模板.
在ObjC的摩登加的三大特点之一也是那一个.

以Array为例子, Set和Dictionary基本上都大约, 有专门的会独自点出来.

  1. 声称方式:

var someInts = [Int]() // 貌似以前不是这么玩的
print("someInts is of type [Int] with \(someInts.count) items.")
var threeDoubles = [Double](count: 3, repeatedValue: 0.0)// 默认值的方式
var shoppingList: [String] = ["Eggs", "Milk"]

// 字典声明也差不多:
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
  1. 操作:
    扩大什么的都相比健康, 直接看有的得益于操作符重载的用法吧:

shoppingList += ["Baking Powder"]
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// 注意不能直接 += "Apple"

比较有特色的玩的方法是:

shoppingList[4...6] = ["Bananas", "Apples"]//把index为4,5,6的替换为后面的数组, 但是前面是3个元素, 后面是2个, 多出的那个呢? 被丢掉了...
// 注意: 左边多右边少是可以的, 反过来就错了

Dictionary里面用下标赋值为nil是不会crash的,
与Objc里面setValue:forKey:同样会移除原有值(如有), 不过, 调用updateValue
设置为nil则会crash, 同时, Dictionary里面抽出的值是Optional的,
记得拆包再用

  1. 遍历:
    和事先字符串那么些大概, 看一下元组在此地的施用:

for (index, value) in shoppingList.enumerate() {
print(“Item (index + 1): (value)”)
}
// cmd+单击能够看到enumerate()重返二个EnumerateSequence对象,
再点进入是2个结构体, 开采有1个next函数, 是那样的
//func next() -> (index: Int, element: Base.Element)?
那是富有可遍历对象必要落成的方法, 重回的正是二个要素, 包蕴index和element

// 同样Dictionary也得以这么遍历:
for (airportCode, airportName) in airports {
print(“(airportCode): (airportName)”)
进制变换,学习笔记。}
// 借使想单独遍历key也许value, .keys和.values能够挽救

4. 排序:
提供了sort(), 调用即可:

var numberArray = [3,1,4,8,2]
numberArray.sort() // 暗许升序

当然还可以自己写, 然后传给sort, 这里牵涉到闭包, 会有很多写法, 最简单的是:

numberArray.sort(>) // 降序排列

4. 集合关系
intersect: 2个集合的交集
union: 2个集合的并集
exclusiveOr: 2个集合并集减去交集
subtract: 集合减去与另一集合的交集
官方图:
https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/setVennDiagram_2x.png


简单介绍了下集合类型, 其实里面包含了不少东西, 也牵涉到了苹果对于Swift的设计理念--面向协议编程, 和闭包的东西. 暂时先介绍到这里, 更进一步的可以看看[官方文档](https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html#//apple_ref/doc/uid/TP40014097-CH8-ID105)


###流程控制

1. for循环:
之前已经讲过一些了, 比如:

for i in 1…5 {
print(“(index) times 5 is (index * 5)”)
}
//相比较有趣的是下划线(_)在那边的选用
for _ in 1…5 {
// do something five times
}
// 用下划线代表那个值笔者不要求

// 当然也保留了守旧的方式, 只是会用的人应当会很少了
for var index = 0; index < 3; ++index {
print(“index is (index)”)
}

2. while循环:
和别的语言差不多, 有区别的是引入了一个repeat, 替换掉了do-while, 因为do因为用在do-try-catch里面去了, 解释好牵强...

3. if条件语句
基本上也差不多, 只是不需要加括号了, 同时判断的值必须要是实现了BooleanType协议的, 不然会报错, 例如:

var i = 1
if i { // 会报错, 因为Int没有达成BooleanType
// print(“i is not 0”)
}

4. switch:
switch在Swift得到了大量的增强, 因为switch涉及到模式匹配, 而Swift的模式匹配十分强大.
4.1 switch不仅仅匹配整数, 还可以匹配字符,字符串, 严格说来是任何只要实现了Equatable协议的对象
4.2 switch的case默认自带break, 但是如果这一case一行语句都没有, 是需要手动加上break的. 同时如果你想让这个case不自动break, 就要加上关键字fallthrough, 
4.3 范围匹配, 以官网例子说明:

let approximateCount = 62
let countedThings = “moons orbiting Saturn”
var naturalCount: String
switch approximateCount {
case 0:
naturalCount = “no”
case 1..<5:
naturalCount = “a few”
case 5..<12:
naturalCount = “several”
case 12..<100:
naturalCount = “dozens of”
case 100..<1000:
naturalCount = “hundreds of”
default:
naturalCount = “many”
}
print(“There are (naturalCount) (countedThings).”)

值得说明的是, 范围必须包含条件的全部可能的范围, 简单来说就是, 如果不是枚举, 就把default写上
4.4 元组在switch里面也得到了很广的使用, 还是用例子来说明:

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
print(“(0, 0) is at the origin”)
case (_, 0): // 下划线代表任性值都能够相称上
print(“((somePoint.0), 0) is on the x-axis”)
case (0, _):
print(“(0, (somePoint.1)) is on the y-axis”)
case (-2…2, -2…2):
print(“((somePoint.0), (somePoint.1)) is inside the box”)
default:
print(“((somePoint.0), (somePoint.1)) is outside of the box”)
}

4.5 值绑定, 依然例子:

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
print(“on the x-axis with an x value of (x)”)
case (0, let y):
print(“on the y-axis with a y value of (y)”)
case let (x, y):
print(“somewhere else at ((x), (y))”)
}
// 同时还足以加条件判别, 可是是用where:
let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
print(“((x), (y)) is on the line x == y”)
case let (x, y) where x == -y:
print(“((x), (y)) is on the line x == -y”)
case let (x, y):
print(“((x), (y)) is just some arbitrary point”)
}

5. 流程跳转:
其实也就是break, continue, fallthrough, return和throw, 这些关键字都可能打破当前的流程, 跳到别的流程中去, fallthrough已经介绍过, 其余的都和别的语言一致

6. 标签:
与C语言的标签可以跳来跳去不通, Swift的标签配合循环使用, 个人感觉用的范围应该不多, 有兴趣的在官网看下例子就好.

7. guard:
Swift2引入了一个新的关键字, guard, 可以在函数中对参数进行一些判断, 以官网例子来看代码:

func greet(person: [String: String]) {
guard let name = person[“name”] else { // 必须保障有name, 不然就回到
return
}
print(“Hello (name)!”)
guard let location = person[“location”] else { // 必须确定保证有location,
不然就回来
print(“I hope the weather is nice near you.”)
return
}
print(“I hope the weather is nice in (location).”)
}

如果一定要问guard和if的区别是什么, 那么直接援引一个例子来感受一下吧(更多guard优于if的例子请[查看原文](http://swift.gg/2015/08/06/swift-guard-better-than-if/)):

struct Person {
let name: String
var age: Int
}

func createPerson() throws -> Person {
guard let age = age, let name = name
where name.characters.count > 0 && age.characters.count > 0 else
{
throw InputError.InputMissing
}

    guard let ageFormatted = Int(age) else {
        throw InputError.AgeIncorrect
    }

    return Person(name: name, age: ageFormatted)
}

// 假诺用if来写, 会是如此的:
func createPersonNoGuard() -> Person? {
if let age = age, let name = name
where name.characters.count > 0 && age.characters.count > 0
{
if let ageFormatted = Int(age) {
return Person(name: name, age: ageFormatted)
} else {
return nil
}
} else {
return nil
}
}
急需不停地if-let, 还要写 else {return nil}, 借使再多一点属性须求判别,
就越来越多的if-let和else{return nil}…

8. 检查版本可用性

这个是Swift2带来的大杀器, 在iOS或者OSX版本更迭中, 总有一些新的API出现, 也有旧的API废弃, 如果你的APP需要兼容多个系统版本, 那么势必要为这些API进行甄别, 但是这样的成本过高, 必须要对这些API什么时候引入, 什么时候废除有谱, 或者每次去查看, 这都对APP出现unrecognized selector异常埋下隐患, 所以这是Swift安全的原因之三, 同时, 如果你写了一些API是高于你在工程中设置的最低版本的话, 编译器是会给你报错, 强制你去判断的, 我觉得这点非常人性化. 判断的具体写法是这样的:

if #available(iOS 9, OSX 10.10, ) {// 最终的那些是通配符,
主要是为随后实行做的预备, 假诺以往来了三个CarOS或许HouseOS,
那么就能相配上了
// Use iOS 9 APIs on iOS, and use OS X v10.10 APIs on OS X
} else {
// Fall back to earlier iOS and OS X APIs
}

同时, 如果你的某个类或者某个函数使用了高版本的API, 那么你就要在前面写上@available, 这样编译器就会为你做检查了:

@available(iOS 9.2, OSX 10.10.3, *)
class MyClass {
// class definition
}

简单介绍到这里, 这一篇就算结束了, 前面基本算都是基础知识, 惯例, 细节部分参考[官方文档](https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ControlFlow.html#//apple_ref/doc/uid/TP40014097-CH9-ID120)

/
let string = “hello”
var a = 10
/

一.var 只是报告编写翻译器这几个是1个变量,具体是何等类型只怕要告诉编写翻译器的

 

 

*/
var Scenes,scripts,sounds:String

    // Data -> HexStrings

    // Data -> HexStrings

let swfitone,swifttow:String

    func dataToHexStringArrayWithData(data: NSData) -> [String] {

    func dataToHexStringArrayWithData(data: NSData) -> [String] {

swfitone = “Something Just Like This , this is sing”
swifttow = “The is New swift String “
Scenes = “Test switf string practice Unity scenes”
scripts = “This is test unity Scripts Ptactice”
sounds = “I Don,t Understand This Varlable”
/*
其壹是1个常量赋值过了,就不能够修改了。!
swfitone = “time show paly”
if type Don,t Agree,Don,t JiSuan ,Swift No Support
举例类型分歧样,不能一向总括,swfit 不支持电动类型转换
*/
var Myname,speed:NSInteger
speed = 10

        let byteArray:[Int] = DataToIntWithData(data: data)

        let byteArray:[Int] = DataToIntWithData(data: data)

//墙砖类型,跟oc是1律的。
var Myprice = Double(speed);

        var byteStrings: [String] = []

        var byteStrings: [String] = []

var stringtest = “YinShiShengm”

        for (_,value) in byteArray.enumerated() {

        for (_,value) in byteArray.enumerated() {

var StringtestTo:String = “XianShishengM”;
//打印与C# 一致
print(Myprice)
//—–The Above Let Vat Statement Over —–

            byteStrings.append(ToHex(tmpid: value))

            byteStrings.append(ToHex(tmpid: value))

let Error = (404,” Net Work Not Found”)

        }

        }

//var DataSouer:String

        return byteStrings

        return byteStrings

print(Error.0)
let (code,status) = Error

    }

    }

print(“code = (code)status = (status)”)

    

    

//var Mystring:String?=”8888″
//print(Mystring)
var Mystring :String? = “9999”
if var testChapao = Mystring{

    // HexString -> Data

    // HexString -> Data

print("如果有值就赋值,没有值就不赋值");
testChapao = Mystring!;
print(testChapao)

    func hexToBytes(bytesStr: String) -> Data? {

    func hexToBytes(bytesStr: String) -> Data? {

}else{
print(“str是nil”)//str不赋伊始值时

        var data = Data(capacity: bytesStr.characters.count / 2)

        var data = Data(capacity: bytesStr.characters.count / 2)

}

        let regex = try! NSRegularExpression(pattern: “[0-9a-f]{1,2}”,
options: .caseInsensitive)

        let regex = try! NSRegularExpression(pattern: “[0-9a-f]{1,2}”,
options: .caseInsensitive)

/*
一.字符串方法
2.拼接,追加
*/

        regex.enumerateMatches(in: bytesStr, options: [], range:
NSMakeRange(0, bytesStr.characters.count)) { match, flags, stop in

        regex.enumerateMatches(in: bytesStr, options: [], range:
NSMakeRange(0, bytesStr.characters.count)) { match, flags, stop in

var stringT = “stringTest1”

            let byteString = (bytesStr as NSString).substring(with:
match!.range)

            let byteString = (bytesStr as NSString).substring(with:
match!.range)

var stringT2 = “stringTest2”
//相加
var stringcomporer = stringT+stringtest
//追加C字符
stringT.append(Character(“G”))
//追加字符串
stringT.append(“Srroy”)

            var num = UInt8(byteString, radix: 16)!

            var num = UInt8(byteString, radix: 16)!

print(“string == (stringT)”)
//追加
var string5 = “(stringT)china”

            data.append(&num, count: 1)

            data.append(&num, count: 1)

print(“string5 = (string5)”)
//强转
var string6 = “100”
var string7 = “300”
//跟OC是均等的
var string8 = Int(string6)

        }

        }

var floatValue = Float(string7)
var string9 = String(floatValue!)

        guard data.count > 0 else {

        guard data.count > 0 else {

/*
1.在swfit里 全体的变量,用?修饰,并且未有初值,都是nil
2.? opitional 可选值,要么为nil
三.!拆包,倘使要拿出变量的可选值,就不能不拆包
四.在swfit中,如若声美素佳儿(Friso)(Beingmate)个变量,不用?或!修饰的话,他是一贯不值的,使用时会崩溃的
*/
//那样就定义了2个可选的int型
var Monye:Int? = 100
if Monye == nil {
print(“没有值”)
}else{
print(“有值”)
}

            return nil

            return nil

//假如要拿出去变量的值就不能够不拆包。
print(Monye!)
var Sugestring:String? = “88”
print(Sugestring!)
//要是是如此,就分明会有值!能够毫无拿直接打字与印刷的
var discount:Float! = 3.5
print(discount)

        }

        }

var IntZh = Int(string5)

        return data

        return data

//Obcjet.isEmpty
if string5.isEmpty {
print(“字符串为空”)
}else{

    }

    }

print("字符串不为空")

    

    

}

    

    

if string7 == string5 {
print(“字符串相等”)
}else{

    // Data -> 10

    // Data -> 10

print("字符串不等")

    func DataToIntWithData(data: NSData) -> [Int] {

    func DataToIntWithData(data: NSData) -> [Int] {

}

        var byteArray:[Int] = []

        var byteArray:[Int] = []

string7.hasPrefix(“string”)

        for i in 0..<data.length {

        for i in 0..<data.length {

string7.hasSuffix(“str”)

            var temp:Int = 0

            var temp:Int = 0

//print(JsonData!)

            data.getBytes(&temp, range: NSRange(location: i,length:1 ))

            data.getBytes(&temp, range: NSRange(location: i,length:1 ))

//var jsonstr2 = String(JsonData!, String.Encoding.utf8)
//var jsonStr2 = String(data: JsonData!, String.Encoding.utf8)
//var Jsonsrt2 = String(Data:JsonData!,encoding:NSUTF8StringEncoding)
var Jsonstr = “stringDataholle”
var JsonData:Data? = Jsonstr.data(using: String.Encoding.utf8)
//这一个怎么一定要拆包,笔者擦!
var sss:String! = String.init(data: JsonData!, encoding:
String.Encoding.utf8)

            byteArray.append(temp)

            byteArray.append(temp)

var stringjsonself = sss

        }

        }

print(stringjsonself!)

        return byteArray

        return byteArray

//循环,向下改动,决断,switch
var view:UIView = UIImageView (frame: CGRect.init(x: 0, y: 0, width:
100, height: 100))
//as 还确确实实不了然怎么用,是哪些意思
var imageview:UIImageView = view as! UIImageView
//这几个是不可能 基本数据类型的
var obj:AnyObject = imageview
//这一个手艺弄基本数据类型
var objc:Any = “stringName”
print(objc)

    }

    }

//

    

    

//数组操作
//var arr1 = [“A”,”B”,”C”,”D”,1,2]
//隐士转化基本上不行了,那是其余艺术的实例化
var arrint:[Int] = [1,2,3,4]
var arrlintl:Array<Int> = [1,2,3,4]
var arrstring:Array<String> = Array<String>()

    // 10 -> 16

    // 10 -> 16

//arrstring.append(“wudi”)
//arrstring.append(“TL”)
arrstring.append(“ssss”)
arrstring.append(“shenwukong”)

    func ToHex(tmpid: Int) -> String {

    func ToHex(tmpid: Int) -> String {

arrstring.append(contentsOf: [“hehe”,”wukongz”])

        let leftInt: Int  = tmpid / 16

        let leftInt: Int  = tmpid / 16

for itmess in arrstring {
print(itmess)
}
//[]骨子里那个代表一个数组
var arrFloar:[Float] =
Float
//,你能够像C#一样的
var Arrfloat:Array<Float> = Array<Float>()
//初始化方法,都以均等的,那么些各种都以结构体了,
var arrstring1:[String] = Array.init(repeating: “wudi”, count: 3)

        let rightInt: Int = tmpid % 16

        let rightInt: Int = tmpid % 16

let index:Int = arrstring1.startIndex

        var leftIndex: String = “”

        var leftIndex: String = “”

let count:Int = arrstring1.count

        var rightIndex: String = “”

        var rightIndex: String = “”

print(“count = (count)”)

        let numberArray =
[“0″,”1″,”2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”A”,”B”,”C”,”D”,”E”,”F”]

        let numberArray =
[“0″,”1″,”2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”A”,”B”,”C”,”D”,”E”,”F”]

arrstring1[0] = “Tlzuishai”
//移除全部成分
arrstring1.removeAll()
//决断是还是不是为空
if arrstring.isEmpty {
print(“empty”)
}else{

        for i in 0..<numberArray.count {

        for i in 0..<numberArray.count {

print("No empty")

            if i == leftInt {

            if i == leftInt {

}

                leftIndex = numberArray[i]

                leftIndex = numberArray[i]

if arrstring1 == arrstring {
print(“数组相等”)
}else{

            }

            }

print("数组不相等")

            if i == rightInt {

            if i == rightInt {

}

                rightIndex = numberArray[i]

                rightIndex = numberArray[i]

//枚举
enum DeviceType{

            }

            }

case Iphone4
case iphone4s
case iphone5
case iphone5s
case iphone6
case iphone6s
case iphone7
case iphone7pules

        }

        }

}
var type = DeviceType.iphone7

        return “\(leftIndex)\(rightIndex)”

        return “\(leftIndex)\(rightIndex)”

if type == DeviceType.iphone7 {
print(“是iphone 7”)
}else{

    }    

    }    

print("不是iphone 7 ")

    

    

}

    // 16 -> 10

    // 16 -> 10

//字典,遍历
var arrdic:[String] = [“china”,”USA”,”Japan”,”ShangHai”]

    func ToInt(hexString: String) -> Int {

    func ToInt(hexString: String) -> Int {

//遍历时能够赢得下标和值
for (indexs,vale2) in arrdic.enumerated() {
print(“index==(indexs),values ==(vale2)”)
}

        var _hexString = hexString

        var _hexString = hexString

//
var stringfor = “i lover MySelf”
//变量字符串
for temo in stringfor.characters {
print(“forChai=(temo)”)
}

        // 转小写

        // 转小写

//var dic:[Dictionary] = [“page”:”1″,”money”:”100″,1:1]

        _hexString = _hexString.lowercased()

        _hexString = _hexString.lowercased()

var dic:[Int:Int] = [1:2,3:4]

        // 拆分字符串 转成十进制 总括

        // 拆分字符串 转成10进制 计算

var dic1:Dictionary<Int,String> = [1:”123″,2:”456″]

        var term = 0

        var term = 0

//实例化,要不后面给他 要不前面给她 实例化
var dic2 = Dictionary<Int,String>()

        let intArray =
[“0″,”1″,”2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”a”,”b”,”c”,”d”,”e”,”f”];

        let intArray =
[“0″,”1″,”2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”a”,”b”,”c”,”d”,”e”,”f”];

var dic3:Dictionary<Float,String> = Dictionary.init()

        let _hex = NSString(string: _hexString)

        let _hex = NSString(string: _hexString)

dic3.updateValue(“Tl”, forKey: 1.0)

        let left = String(format: “%c”, _hex.character(at: 0))

        let left = String(format: “%c”, _hex.character(at: 0))

print(dic3)

        let right = String(format: “%c”, _hex.character(at: 1))

        let right = String(format: “%c”, _hex.character(at: 1))

//他不曾第3个0成分的
dic3[1] = nil

        var leftValue = 0

        var leftValue = 0

print(dic3)

        var rightValue = 0

        var rightValue = 0

dic3.removeValue(forKey: 1.0)

        for (index,value) in intArray.enumerated() {

        for (index,value) in intArray.enumerated() {

var Dic4:Dictionary<Int,String> = [1:”Tl”,2:”baw”,3:”wudi”]
//获取种种key,获取字典的每种数值
var keys = Array(Dic4.keys)

            if left == value {  

            if left == value {  

for i in keys {
print(“K = (i)”)
}
var valuse = Array(Dic4.values)

                leftValue = index

                leftValue = index

for v in valuse {
print(“valus = (v)”)
}

            }  

            }  

for tmp in Dic4 {
print(“key = (tmp.0)valus = (tmp.1)”)
}
for (keys,valus2) in Dic4 {
print(“key = (keys) valus2 = (valus2)”)
}
//方法的扬言
func test(){

            if right == value {

            if right == value {

print("这个跟C#一样")

                rightValue = index

                rightValue = index

}
test()
//函数名,参数,返回值
func Sum(a:Int,B:Int)->Int{

            }

            }

return a+B

        }

        }

}

        term = leftValue * 16 + rightValue

        term = leftValue * 16 + rightValue

var maxnumber = Sum(a: 10, B: 2)

        return term;

        return term;

print(“maxnumber==(maxnumber)”)
//再次来到两个数据类型
func Nax(a:Int,b:Int,c:Int)->(Int){

    }

    }

return a+b+c

 

 

}

—————–这里是分割线,后续更新———————————

—————–那里是分割线,后续更新———————————

func Min (a:Int,B:Int,C:Int)->(Int){

return a-B-C

}
func getMaxandMin(q:Int,W:Int,C:Int)->(Int,Int){

var CurrenMax = q
var CurrentMin = W
CurrenMax = Nax(a: W, b: q, c: C)

CurrentMin = Min(a: q, B: W, C: C)

return (CurrenMax,CurrentMin)

}

var (max1,min1) = getMaxandMin(q: 10, W: 1, C: 1)

4858.com ,print(“max1 = (max1)”)

print(“min1 = (min1)”)
//inout 在个中修改传过来的值
func getLnout (y:Int){

}

//下划线的采用,元祖 是3个系列
let point = (x:100,y:100,Z:100)

let (_,y,Z) = point

print(“y = (y)”)
print(“z = (Z)”)

var Ts:String? = “ssssss”
if var _ = Ts {
print(“来了”)
}else{

print("没有")

}

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有