//在swift中 String 可以调用OC中的 NSString方法 不用进行转换
        //字符串的字面量 可以用于为常量和变量提供初始值
        let str = "hello world"
        
        //多行字符串字面量 与oc /**/注释相似
        let string = """
                    a
                    b
                    c
                    d
                    e
                    """
        print(string)
        
        //上面代码中 换行已经包含在内 如果不想这么写还想要有换行 用\n来代替 与oc一样
        let hh = "hello \n world"
        print( hh)
        
        //在多行中不希望有多行样式 在""" 字符串中 每行字符串尾部用\ 来当做续行 不是换行 """
        //这样方便可读性
        //但是""" 符号必须独占一行才行
        let hello = """
        hello world duo hang \
        i love the world
        """
        
        //在多行中 以末尾"""符号位置为基准 若各行有字符创超出了末尾 """ 则超出的部分包含在字符串中
        print("""
        123
         456
          789
        """)
        //超出某位的"""第一个“符号 都作为空格来处理
        
//        print("""
//    123
//        456
//        789
//        """)
//这么写或报错 说是以下各行缩进不足 所以 所有的字符串换行后 都不能超过某位的”“”位置
        
        //转义字符
//  \0 空字符 \\反斜线 \t水平制表符 \n换行符 \r回车符 \"双引号 \'单引号
        
        //Unicode标量 写成\u{n} u为小写，n为任意一到八位十六进制数切可用的unicode编码
        
        print("\"注释 \"")
        print("\u{24}")
        print("\u{2665}")
        print("\u{1F496}")
        
        //若在多行字符串中使用""" 必须要用一个\符号来转义
        print("""
        Escaping the first quote \"""
        Escaping all three quotes \"\"\"
        """)
        
        //初始化一个空字符串
        var nilStr = ""
        var emptyStr = String()
        //以上两个字符串为空 且等价
        
        //判断字符串是否为空
        if nilStr.isEmpty{
            print("empty str")
        }
        
        //字符串可变性 var为变量
        var variablestr = "hello"
        variablestr += " world"
        
        let str1 = "hello"
//        str1 += "world"//此时报错 因为str1定义为常量
        
        //for in 语句来循环输出 字符串中没每个字符
        
        for 字符 in "hello world"{
            print(字符)
        }
        
        //可以通过 character 来定义 并进行字符字面量赋值，可以作为一个独立的字符量或变量
        let worldI : Character = "i"

        //可以把一个字符集合 通过String来初始化成一个字符串
        let chars : [Character] = ["a","b",worldI]
        let charStr = String(chars)
        print(charStr)
        
        //使用加号来连接两个字符串
        let string1 = "string1"
        let string2 = "string2"
        var string3 = string1 + string2
        
//        var string4 = string3 + worldI 类型不同，不能相加
        let string5 : NSString = "oc"
        
//        var string6 = string3 + string5 类型不同 得强转
         var string6 = string3 + (string5 as String)
        
        print(string3,string6)
        
        //使用+= 来将一个字符串添加到一个已经存在的字符串变量上
        var string7 = "default"
        string7 += string6
        
        //使用append 将一个字符追加到一个字符串的尾部 也可以是字符串 append方法可以追加很多
        let charchar : Character = "i"
        string7.append(charchar)
        string7.append(string1)
        
        //Unicode 用于文本的编码和表示 可以用标准格式表示来自任意语言几乎所有的在字符，并能够对文本或网页这样的外部资源中的在字符进行读写操作，Swift的string 和 character 类型是完全兼容Unicode
        //Unicode标量
        //Swift 的string类型是基于Unicode标量简历的。Unicode标量是对应字符或者修饰符的唯一的21位数字
        //Unicode码位的范围 U+0000 到 U+D7FF 或者 U+E000 到 U+10FFFF
        //Unicode标量不八廓Unicode代理项码位 范围是 U+D800 到 U+DFFF
        //不是所有的21位Unicode 标量都代表一个字符
        
        
        //单一标量
        let eacute : Character = "\u{E9}" //é
        //两个标量字形群
        let combineddeacute : Character = "\u{65}\u{301}"
        print(eacute,combineddeacute)

        
        //单一标量
        let precomposed : Character = "\u{D65c}"
        //组合标量排序 为同一个字
        let decomposed : Character = "\u{1112}\u{1161}\u{11AB}"
        print(precomposed,decomposed)

        //测试标量组合 不能颠倒
//        let teststr : Character = "\u{1161}\u{1112}\u{11AB}"
//        print(teststr)
        
        //可扩展的字符群可以使包围记号 U+20DD 标量包围其他Unicode标量，作为一个单一的character值
        print("\u{E9}\u{20DD}") //é⃝  圆形包含
        
        //地域性指示符号Unicode 标量可以组合成一个单一的character值
        // US 符号 组合 U (U+1F1FA)  S (S+1F1F8)
        print("\u{1F1FA}\u{1F1F8}") //🇺🇸 美国国旗
        
        
        
        //字符数量 用count 来知道字符串内含有多少个字符
        let teststring = "hello world"
        print("teststring has \(teststring.count) charracter")
        
        //使用字符群集作为 character值来改变字符串时，并不一定会改变字符串数量
        var word = "cafe"
        print(word + "has \(word.count) character")
        
        word += "\u{301}"
        
        print("\(word) has \(word.count) character")
        
        //NSString 的 length数量 与 Unicode 数量并不总是是相同
        //NSString 是 UTF-16表示的单元数字
        
        //Swift string值关联的索引类型 string.index 对应每个character的位置
        //Swift 中 字符串不能用 integer做索引
        
        //用startIndex 获取一个string 的第一个character索引 使用endIndex获取最后一个character位置的索引
        //但是 endIndex不能作为一个字符串的邮箱下标 如果 stirng 为空串 startindex 与endindex相等
        
        //可以使用 string index(before:)获取某一下标前面  index(after:)获取某一下标后面  index(_:offsetby:)获取某一下标的偏移量 避免多次使用前两个
        //三种方法也可以用在 array dictionary set中
        
        let indexString = "hello world"
        
        print(indexString[indexString.startIndex])
        
//        print(indexString[indexString.endIndex]) 代码出错 因为endindex 为字符串最后一个字符末尾 往后一位为空字符
        
        print(indexString[indexString.index(before: indexString.endIndex)]) //d
        print(indexString[indexString.index(after: indexString.startIndex)]) //e
        print(indexString[indexString.index(indexString.startIndex, offsetBy: 5)]) //因为空格 所以看不出来
        print(indexString[indexString.index(indexString.startIndex, offsetBy: 6)]) //w
        
        //indices  为字符串所有索引范围 range 用来访问单个字符   indices 目录
        for indexx in indexString.indices{
//            print(indexString[indexx])
            print(indexString[indexx], separator:"-", terminator: " ") //由于打印的是单个字符 所以连接符没有起到作用
            //terminator 默认是添加换行符，若果换成别的 就不起到换行效果，会连接下个print语句打印的内容
        }
        
        print(indexString.indices)
        
        //插入
        var welcome = "welcome"
        //在末尾加一个感叹号 在一个指定索引加一个单个字符
        welcome.insert("!", at: welcome.endIndex)
        print(welcome)
        
        //在感叹号前加一段 字符串 在一个指定索引加一段字符串
        welcome.insert(contentsOf: " to China", at: welcome.index(before: welcome.endIndex))
        print(welcome)
        
        //删除某个下标的字符
        welcome.remove(at: welcome.index(before: welcome.endIndex))//删除感叹号
        print(welcome)
        
        //删除一端 指定范围的字符串
        welcome.removeSubrange(welcome.index(welcome.endIndex, offsetBy: -8)..<welcome.endIndex)//删除to china
        print(welcome)
        
        //子字符串
        let testSTR = "hello,world"
        let index_ = testSTR.index(of: ",") ?? testSTR.endIndex  //义为 字符串testSTR 中有”,“ 这个字符下标吗 有的话就用这个字符下标 ，没有的话 就用末尾下标
        let fix = testSTR[..<index_] //往字符串里传一个范围 返回这个范围内的所以字符串
        //此时 fix 为substring类型的实例 需要另起一个string 类型的 去接收以便长久化
        
        let newFix = String(fix)
        
        print(fix,newFix)//hello hello
        
        //string 与substring 区别在于性能优化上，substring 可以重用原string 的内存空间,或者另一个substring，string也一样
        //意味着在修改string 和substring 之前都不需要消耗内存去复制内存。可以直接修改
        
        //疑问 若果修改substring 会不会修改原string
        
        var sourstr = "helloworld"
        var substr = String(sourstr[sourstr.startIndex..<sourstr.index(sourstr.startIndex, offsetBy: 5)])
        print(substr)
        
        substr = "welcome"
        print(sourstr) //事实不会
        
        //string 与substring 都可以调用 stringprotocol的函数
        
        //字符串比较 三种比较方式  字符串字符相等，前缀和后缀相等
        
        let me = "i like you"
        let me1 = "i like you"
        
        let you = "you like i" //me
        
        if me == me1{
            print("same string")
        }
        
        //如果两个字符串的可扩展字形集群是相等的，那它们就是相等的，在这个情况下，即使可扩展的字形集群集是有不同的Unicode标量构成的，只要它们有相同的语言意义和外观，就认为它们标准相等
        
        //ex:
        let e = "\u{E9}"
        let oe = "\u{65}\u{301}"
        
        if e == oe {
            print("same string")
        }
        
        let arrar = ["abc","abd","abe","bbc","bbd","bbe"]
        var sameprefix = 0
        var samesuff = 0
        
        for str in arrar{
            if str.hasPrefix("a"){
                sameprefix += 1 //md 不能用++ 来代表自加
            }else if str.hasSuffix("c"){
                samesuff += 1
            }
        }
        print("arr has \(sameprefix) sameprefix  , has \(samesuff) suff")
        
        //字符串的Unicode表示形式
        //每一个字符串中的小块编码都被称作代码单元，这些包括UTF-8编码格式（编码字符为8位的代码单元） UTF-16 UTF-32
        //其中 21位的Unicode 标量值集合，也是字符串的UTF-32编码格式
        
        //可以通过string 的 utf8属性来访问它的UTF-8表示 。
        //为 string.UTF8View  值为无符号8位（Uint8）的集合 每一个Uint8值都是一个字符UTF-8表示
        //使用为字符串.utf8
        
        let dogstr = "a little dog"
        for codeUint in dogstr.utf8{
            print("\(codeUint)",terminator:" ")
        }
        //输出为97 32 108 105 116 116 108 101 32 100 111 103
        //字母部分与ASCII表示相同
        
        for codeUint in dogstr.utf16{
            print("\(codeUint)",terminator:" ")
        }
       
        //Unicode的标量表示  通过string unicodescalars 来访问标量表示 其为UnicodeScalarView 类型属性，
        //UnicodeScalarView 为UnicodeScalar类型的集合
        let bigDog = "dog!!🐩"
        
        for scalar in bigDog.unicodeScalars{
            print(scalar.value,terminator:" ")// .value 就是.UInt32
        }
        
        //其实似懂非懂，主要还是想知道用在何处，键盘？火星文输入法？自定义字的组合？