swift 字符串

下面是一些swift字符串的一些用法, 包括 从字符串的创建, 字符串的增删改查基本操作,字符串比较, 字符串的各种判断, 再到获取某个字符串中的某个字符, 对字符串进行转码, 从控制台输入字符串 等等, 你想要的都在这(欢迎大家补充),废话不多说了, 下面是代码, 代码的注释已经很清楚了

//
//  main.swift
//  StringPra
//
//  Created by 刘瑞龙 on 15/8/27.
//  Copyright © 2015年 V1. All rights reserved.
//

import Foundation

/*
编程环境为xcode 7.0 beta 版
*/

/*--------------------(1)定义一个字符串--------------------------*/

//变量字符串, 字符串的值可以随意更改, 可赋初始值也可不赋, 不赋初始值直接使用, 编译都不会通过
var str1_1:String

//类型推断, 当直接赋值的时候, 可以不指名类型, 编译器会进行类型推断, 把 str1Test 定义为String 类型
var str1_2 = "123"

//常量字符串, 我这个版本可以不进行初始化, 可以使用时再初始化, 并且只能初始化一次, 不能再更改, 赋值时会有类型推断, 所以这里不用写类型了
let str1_3:String


/*--------------------(2)在String中的转义字符--------------------------*/

/*

\0    空字符

\\    反斜杠

\t    制表符

\n    换行符

\r    回车符

\”    双引号

\’    单引号

*/

//转义字符的用法
print("\"我的两边应该有双引号\"")
/*
打印结果:  "我的两边应该有双引号"
*/


/*--------------------(3)   /() 的用法--------------------------*/

//在OC中会有 NSString * str = [NSString stringWithFormat:@"%@%d", string, i]; 的用法
//C语言中有这样的用法 printf("%d", i);

//在swift 不在使用这样的转换字符, 而是用 /() 来拼接或者打印字符串  eg:

var str3_1 = "我今年\(99)岁了"
print(str3_1)    //对于字符串, 可以直接这么打印
/*
输出结果: 我今年99岁了
*/

var int1 = 10
print("我有\(int1)个苹果")
/*
输出结果: 我有10个苹果
*/


/*--------------------(4) 字符串的拼接--------------------------*/
/*
NSString * str = [NSString stringWithFormat:@"%@%d", string, i];
OC中的拼接字符串的方法,比较麻烦 swift 可以直接使用 + +=  这些符号直接进行拼接:
eg:
*/

let str4_1 = "123"
let str4_2 = "456"
let str4_3 = str4_1 + str4_2
print(str4_3)
/*
输出结果: 123456
*/

//对于可变字符串
var str4_4 = "hello"
let str4_5 = "world"
str4_4 += str4_5
print(str4_4)
/*
输出结果: helloworld
*/

//可能有人试图用类似于OC的字符串拼接方式进行拼接, 但发现括号里填的不是string 类型, 而是这两个类型, 对于这两个拼接方法一会儿会讲到
/*
str4_4.append(<#T##c: Character##Character#>)
str4_4.append(<#T##x: UnicodeScalar##UnicodeScalar#>)
*/


/*--------------------(5)字符串的比较--------------------------*/

/*
字符串的比较可以直接使用, 逻辑运算符号 >  >= < <= ==进行比较, 比较的标准, 就是从字符串的每一个元素开始, 比较ascii 值, 如果相同就继续向下比较, 知道比出大小 或者 相等
*/
let str5_1 = "abcdefg"
let str5_2 = "abcz"
if str5_2 > str5_1 {
    print("str5_2 比 str5_1 大")
    /*
    输出结果: str5_2 比 str5_1 大
    */
}
//其他几个逻辑运算符同理

/*
同时, OC的compare 比较方法同样适用
OC中:
[str1 compare str2]    返回值类型是NSComparisonResult其实这是一个枚举 有三个值, NSOrderdAscending  -1  升序, NSOrderdSame 0  相等, NSOrderdDescending
不区分大小写的比较:
[str1 caseInsensitiveCompare: str2];
结果形式同上
swift 代码如下:
*/

let str5_3 = "abcdefg"
let str5_4 = "abcz"
let resutlt: NSComparisonResult = str5_3.compare(str5_4)   //返回值为 NSComparisonResult 枚举类型
switch resutlt {
case .OrderedAscending:
    print("str5_3 小于 str5_4")
case .OrderedSame:
    print("str5_3 等于 str5_4")
case .OrderedDescending:
    print("str5_3 大于 str5_4")
}
/*
输出结果: str5_3 小于 str5_4
*/

//使用这个不区分大小写的比较也是一样的
str5_3.caseInsensitiveCompare(str5_4)


/*
str5_3.compare(<#T##aString: String##String#>, options: <#T##NSStringCompareOptions#>, range: <#T##Range<Index>?#>, locale: <#T##NSLocale?#>)
这个方法也和OC总类似, 第二个参数 比较规则(从前到后, 还是从后到前, 不分大小写, 区分大小写 等等), 第三个参数是确定比较位置, 第四个是填本地信息的,直接填nil就行;
值得注意的是 第三个参数, 所填的range 是第一个用前面的字符串的这个range的字符串和后者整个字符串相比, 比如, 你用ABCD 和 ABC 相比较, 如果设置range 为(0, 1) 那么你是用 A 和 ABC相比, 而不是A与A相比较
eg:
*/
let str5_5 = "abcab"
let str5_6 = "abczz"
let range = Range(start: advance(str5_5.startIndex, 3), end: advance(str5_5.endIndex, 0))
let str = str5_5.substringWithRange(range)
print("str == \(str)")
let options: NSStringCompareOptions = .LiteralSearch
let optionResult: NSComparisonResult = str5_5.compare(str5_6, options: options, range: range, locale: nil)
//range 为比较str5_5 第3个字符到最好一个字符也就是"ab", 和 整个 str5_6 比较, 所以 str_5 小于 str_6
switch optionResult {
case .OrderedAscending:
    print("str5_5 小于 str5_6")
case .OrderedSame:
    print("str5_5 等于 str5_6")
case .OrderedDescending:
    print("str5_5 大于 str5_6")
}
/*
打印结果: str5_5 小于 str5_6
*/



/*--------------------(6)字符串大小写的转换--------------------------*/
//swift 使用Unicode编码, Unicode 编码 整合了 世界上大部分语言以及emoji表情, 在网站上显示为 ?? 的部分就是emoji表情, 但是在swift中是正常识别的

let str6_1 = "a��bcDEfg哈哈哈123"
print(str6_1.lowercaseString)
let str6_2 = str6_1.uppercaseString
print(str6_2)
/*
输出结果:  a��bcdefg哈哈哈123
          A��BCDEFG哈哈哈123
*/
/*根据例子结果可以看出来, 这两个方法是对字符串中字母进行处理, 其他的不变:
uppercaseString : 将全部字母变为大写
lowercaseString : 将全部字母变为小写
而且都是重写生成了一个字符串, 而不是在原有字符串进行变化
*/


/*------------(7)判断字符串是否为空 & 判断是否某个前缀 后缀----------*/
let str7_1 = ""
if str7_1.isEmpty {
    print("str7_1  is Empty")
    /*
    输出结果: str7_1  is Empty
    */
}

let str7_2 = "www.v1.cn"
if str7_2.hasPrefix("www") {
    print("str7_2 有前缀 www")
    /*
    输出结果: str7_2 有前缀 www
    */
}
if str7_2.hasSuffix("cn") {
    print("str7_2 有后缀 cn")
    /*
    输出结果: str7_2 有后缀 cn
    */
}


/*--------------------(8)获取字符串的子串--------------------------------*/

let str8_1 = "hello world"
/*
这三个, 后两个就不多说了, 只要会创建index就知道怎么回事了, 下面说下第一个
substringWithRange(<#T##aRange: Range<Index>##Range<Index>#>)
substringFromIndex(<#T##index: Index##Index#>)
substringToIndex(<#T##index: Index##Index#>)
*/
let indexStart = advance(str8_1.startIndex, 0)  //index 的创建方式
let indexEnd = advance(str8_1.startIndex, 5)
let range8_1 = Range(start: indexStart, end: indexEnd) //range的创建方式
let str8_2 = str8_1[range8_1]        //由于String 实现了 subscript 可以通过[]里填range 的方式 获取子串, 也可以通过填Index来过去character
print("str8_2 == \(str8_2)")
/*
输出结果: str8_2 == hello
*/


/*--------------------(9)获取字符串中character--------------------------*/
//swift 使用Unicode编码, Unicode 编码 整合了 世界上大部分语言以及emoji表情, 在网站上显示为 ?? 的部分就是emoji表情, 但是在swift中是正常识别的

//for in 遍历获取每一个character
let str9_1 = "��ab呵呵"
for char in str8_1.characters {
    print(char)
    /*
    输出结果:
    ��
    a
    b
    呵
    呵
    */
}

//获取某一个character,因为String 类型 实现了subscript, 所以可以通过str[] 中括号中填 index 的方式来获取某个index, 下面来获取str9_1 的第一个字符
let index9_1 = advance(str9_1.startIndex, 0)
let char = str9_1[index9_1]
print("char == \(char)")
/*
输出结果: char == ��
*/


/*--------------------(10)替换字符串中某一段字符--------------------------*/
/*
//知道怎么创建range, 应该就会知道怎么用这个了, 一个用character替换range内的字符串, 一个是用String来替换range内的字符串, 下面说一下用字符串替换的
replaceRange(<#T##subRange: Range<Index>##Range<Index>#>, with: <#T##C#>)
replaceRange(<#T##subRange: Range<Index>##Range<Index>#>, with: <#T##String#>)
*/
//定义一个字符串--变量
var str10_1 = "123 world"
let str10_2 = "hello"
let range10_1 = Range(start: advance(str10_1.startIndex, 0), end: advance(str10_1.startIndex, 3))
str10_1.replaceRange(range10_1, with: str10_2)
print("str10_2 == \(str10_1)")
/*
输出结果: str10_2 == hello world
*/



/*--------(11)获取字符串中ascii表字符的int值, 并将Int转换成character 和 字符串------*/

//创建一个只含有, ascii表字符的字符串
let str11_1 = "abc"
var intStr = ""
for char11_1 in str11_1.characters {
    var tempInt: Int = 0
    for i in String(char11_1).utf8{
        tempInt = Int(i)
    }
    print(tempInt)
    /*
    输出结果: 
    97
    98
    99
    */
    intStr += String(tempInt) + "--"    //将Int类型转成String类型并且拼接
}
print("intStr == \(intStr)")
/*
输出结果 intStr == 97--98--99--
*/

//将整形转化为 character 类型 最终转化为 String 类型
let int_11_1 = 97
let char11_1: Character = Character(UnicodeScalar(int_11_1))
print("the character char11_1 is \(char11_1)")
/*
输出结果: the character char11_1 is a
*/

let str11_2 = String(char11_1)
print("the string: str11_2 is \(str11_2)")
/*
输出结果: the string: str11_2 is a
*/

/*--------(12)对swift字符串与utf8字符串进行互转------*/
/*
有些时候, 特别是从服务器发送post请求, 需要对汉语字符串进行处理, swift对字符串转码同样使用的是 OC 中的方法
*/
let str12_1 = "我是你龙哥"
let str12_2 = str12_1.stringByAddingPercentEscapesUsingEncoding(NSUTF8StringEncoding)
print("str12_2 = \(str12_2!)")
/*
输出结果: str12_2 = %E6%88%91%E6%98%AF%E4%BD%A0%E9%BE%99%E5%93%A5
*/

let str12_3 = str12_2?.stringByReplacingPercentEscapesUsingEncoding(NSUTF8StringEncoding);
print("str12_3 = \(str12_3!)")
/*
输出结果: str12_3 = 我是你龙哥
*/


/*--------(13)通过scanf 在swift语言中输入字符------*/

要从控制台输入字符串, 首先要说一下怎样和C混编, 首先先建一个C文件, 这时xcode 会提示你是否创建桥接文件, 点 creat bridging header(当然自己建也可以, 如何建等我在发博客会说)

创建完了就可以在C文件中写这个方法

//
//  SwiftScanf.c
//  StringPra
//
//  Created by 刘瑞龙 on 15/8/27.
//  Copyright © 2015年 V1. All rights reserved.
//

#include <stdio.h>

void swiftScanf(char * inputStr){
    scanf("%s", inputStr);
}

然后在桥接文件中导入这个头文件:

接下来就可以在swft中调用这个方法了, 具体向上边写的那样, 这里在写一遍:

/*--------(13)通过scanf 在swift语言中输入字符------*/

var char13_1 = UnsafeMutablePointer<CChar>.alloc(20)  //这个方法生成了一个与C中的字符指针相通的类型
swiftScanf(char13_1)    //这是桥接过来的C方法
/*
C方法实现如下:

void swiftScanf(char * inputStr){
    scanf("%s", inputStr);
}
*/
let str13_1 = String.fromCString(char13_1)  //将字符指针(即C中的字符串)转化成swift字符串
print("输入的字符为: \(str13_1!)")
/*
输入:     thisisainputchar
输出结果: thisisainputchar
*/

说明: 还有一些OC中的方法都可以在swift中用了, 只要有OC基础, 那些就都可以知道怎么用了

下面还有我用来练习字符串的练习题, 大家有兴趣可以练习下

/*--------------------------------------------------------------------*/

/*-----------------下面是我给字符串添加的一些用来练习的方法------------------*/
extension String{

    //给变量字符串添加方法, 进行ascii值从小到大排序
    mutating func sortString(){
        for var i = 1; i < self.characters.count; ++i{
            for var j = 0; j < self.characters.count - i; ++j{
                let range1 = Range(start: advance(self.startIndex, j), end: advance(self.startIndex, j + 1))
                let str1 = self.substringWithRange(range1)
                let range2 = Range(start: advance(self.startIndex, j + 1), end: advance(self.startIndex, j + 2))
                let str2 = self.substringWithRange(range2)
                if str1 > str2 {
                    self.replaceRange(range1, with: str2)
                    self.replaceRange(range2, with: str1)
                }
            }
        }
    }

    //添加类方法, 传入一个字符串,根据这个字符串生成一个ascii值从小到大排序的字符串
    static func sortStr(var str: String) -> String{
        for var i = 1; i < str.characters.count; ++i{
            for var j = 0; j < str.characters.count - i; ++j{
                let range1 = Range(start: advance(str.startIndex, j), end: advance(str.startIndex, j + 1))
                let str1 = str[range1]
                let range2 = Range(start: advance(str.startIndex, j + 1), end: advance(str.startIndex, j + 2))
                let str2 = str.substringWithRange(range2)
                if str1 > str2 {
                    str.replaceRange(range1, with: str2)
                    str.replaceRange(range2, with: str1)
                }
            }
        }
        return str
    }

    //扩展一个类方法, 传入一个字符串, 根据传入字符串生成一个逆序的字符串
    static func inverseStr(str: String) -> String{
        var string = ""
        for var i = 0; i < str.characters.count; ++i {
            let index = advance(str.endIndex, -(i + 1))
            string += String(str[index])
        }
        return string
    }

    //扩展一个类方法, 传入一个只含有字母的字符串, 根据传入字符串生成一个大小写字母翻转的字符串
    static func overStr(str: String) -> String {
        var string = ""
        for var i = 0; i < str.characters.count; ++i{
            let range = Range(start: advance(str.startIndex, i), end: advance(str.startIndex, i + 1))
            let subStr = str.substringWithRange(range)
            if subStr == subStr.lowercaseString {
                string += subStr.uppercaseString
            } else if subStr == subStr.uppercaseString {
                string += subStr.lowercaseString
            }else {
                string += subStr
            }
        }
        return string
    }

    //将字符串 翻转后 ascii 值 + 10
    static func encryptCode(code: String) -> String{
        var tempStr = ""
        for var i = 0; i < code.characters.count; ++i {
            let index = advance(code.startIndex, code.characters.count - i - 1)
            var cha: Character = code[index]
            var tempInt: Int = 0
            for j in String(cha).utf8{
                tempInt = Int(j) + 10
            }
            cha = Character(UnicodeScalar(tempInt))
            tempStr += "\(cha)"
        }
        print("\(tempStr)")
        return tempStr
    }

}

欢迎大家补充