2019-09-26 11:47:32 fishycx 阅读数 67

1.截取某字符串的前10个字符串

let sub1 = str.prefix(10)

2.截取某字符串的后10个字符串

let str1 = str.suffix(10)

也可以换种写法

let index2 = str.index(str.endIndex, offsetBy: -10)

let sub4 = str[index2…

3.截取某字符串的第3个字符到第6个字符范围的字符串

let index3 = str.index(str.startIndex, offsetBy:3)

let index4 = str.index(str.startIndex, offsetBy:6)

let sub4 = str[index3…

4.截取指定字符串

截取 access_token开始以后的字符串

        if let range = urlStr.range(of:"access_token") {

            query =String(urlStr.suffix(from: range.lowerBound))

        }

截取不包含 access_token开始以前的字符串

    if let range = urlStr.range(of:"access_token") {

        query =String(urlStr.suffix(from: range.lowerBound))

    }

let testStr = “hello world”
//这种方法和swift3.2 类似
let index1 = testStr.index(testStr.endIndex, offsetBy: -5)
let test1 = String(testStr.suffix(from: index1))
//test1 = “hello”

let index2 = testStr.index(testStr.startIndex, offsetBy: 5)
let test2 = String(testStr.prefix(upTo: index2))//
//test1 = “world”
//当然你也可以这样,是不是更简洁了
let test3 = String(testStr.suffix(5))
//test3 = “hello”
let test4 = String(testStr.prefix(5))

2018-05-18 21:35:16 lxmgoodlucky 阅读数 206

1、所谓字符串就是一系列字符,需要用(英文的双引号"")  例如:"hello world"  "ABC"  "123"

在swift中字符串的关键字是String

2、字符就是常见的ABCDabcd等等都是字符

3、把字符串赋值给变量或者是常量:

var name:String = "Dava"  
let Id:String = "123456"
注意:其实这里是可以省略掉“String”的,因为swift中可以根据语境自动推动出类型!
var name = “Bob”

4、如果你需要很多字符串,并且需要隔行写,那么可以使用3个双引号:

var Talk = """
hello, Bob,whare are you going ?
hi,Dava ,i'm going to school!
"""

5、字符串可变性

在swift中,我们知道常量let是不可以变得,但是变量var是可以改变的

var a = "123"
a = 456 
print(a) //a此时的值为456

还可以实现字符串相加
var saing = "hello"
var action = "world"
saing += action
print(saing) //出现helloworld

6、使用for循环遍历字符串

for i in "HELLO"{
    print(i)
}
依次打印出"H" "E" "L" "L" "O"

7、字符串插值(也就是格式化字符串,使用“反斜杠\() ” ,比较重要)如下:

var a = "hello"
var b = "world"
var c = a+b
print("\(a)加上\(b)的值为\(c)")

8、字符串的统计

有时候我们需要知道有多少个字符,可以使用字符串中的 .count属性!

var b = "ABCDEFG"
print(b.count)
//结果为7个字符






2015-08-27 19:18:22 CODE_WORM 阅读数 1126

下面是一些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文件
创建完了就可以在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
    }

}

欢迎大家补充

2019-07-28 19:50:48 zjpjay 阅读数 18

<1>创建空字符串

let str1: String = ""

let str2: String = String()

<2>创建赋初值的字符串

var str3 = "helloworld-ZJP"

var str4 = String("你好")

<3>判断字符串是否为空

if str3.isEmpty {

    print("空值")

}

if str3.count == 0 {

    print("空值")

}

2016-02-23 11:20:09 WKFfantasy 阅读数 405

import UIKit


class ViewController: UIViewController {

  

  override func viewDidLoad() {

    super.viewDidLoad()

    

    //MARK: 字符串的长度

    /*

    为了获取一个字符串中的字符数量,我们可以用String.characters.count

    不同的Unicode字符以及相同Unicode字符的不同表示方式可能需要不同数量的内存空间来存储,

    因为在Swift中的字符在一个字符串中表示并不一定占用相同的内存空间。

    因此,字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。

    */

    

    let string1 ="最美的不是下雨天,是曾与你躲过雨的屋檐"

    let string2 ="Because of you ,I never stay too far from sidewalk"

    

    print("string1 has\(CFStringGetLength(string1))")

    print("string2 has\(string2.characters.count)")

    

    //MARK: 连接字符串

    /**

    字符串值可以通过加法运算符(+)相加(或者说链接)在一起并创建一个新的字符串值

    运算符-是不可以的哦

    let string6 = string3 - "o"

    print(string6)

    Character不能通过加法运算符来做处理

    */

    let string3 = "hello"

    let string4 = " jay"

    let string5 = string3 + string4

    print(string5)

    

    //MARK: 字符串插值

    /**

    字符串插值是一种全新的构建字符串的方式,可以在其中包含常量、变量、字面量和表达式

    插入字符串字面量的每一项需要包裹在以反斜线为前缀的圆括号中.

    

    所写的插值字符串在括号中的表达式里面不能包含非转义双引号  (") 和反斜杠  (\)

    并且不能包含回车或换行符

    */

    let a = 4

    let b = "\(a) * 3 ==\((a) *3)"

    print(b)

    

    //MARK: 字符串的比较

    /**

    Swift 提供了三种方式来比较字符串的值:字符串相等,前缀相等和后缀相等。

    通过调用字符串的hasPrefix/hasSuffix方法来检查字符串是否包含特定的前缀/后缀。

    这两个方法均需要以字符串作为入参并返回 Boolean值。

    这两个方法都采用逐个字符匹配的方式来比较基本字符串是否包含字符前缀或者后缀。

    */

    let equalString1 = "let it go"

    let equalString2 = "let it go"

    if equalString1 == equalString2 {

      

      print("yes, it is equal")

      

    } else {

      

      print("no,it is not equal")

      

    }

    

    let itgo = [

      "let it go",

      "let me go",

      "let you go",

      "I like",

      "it like",

      "you like"

    ]

    

    for whoGo in itgo {

      

      if (whoGo.hasPrefix("let ")) {

        

        print("\(whoGo) == has prefix of let ")

        

      }

      if (whoGo.hasSuffix(" like")) {

        print("\(whoGo) == has suffix of like")

        

      }

      

    }

    //字符串的大小写

    //你可以通过字符串的uppercaseStringlowercaseString 属性来访问一个字符串的大写或小写的版本

    

    let string1 = "May I help you ?"

    let upString1 = string1.uppercaseString

    print(upString1) //MAY I HELP YOU ?

    

    let lowString1 = string1.lowercaseString

    print(lowString1) // may i help you ?

    

    /**

    Unicode 是文本编码和表示的国际标准

    它使你可以采用标准的格式表示来自任意语言几乎所有的字符

    并能够对文本文件或网页这样的外部资源中的字符进行读写操作

    

    Swift的字符串和字符类型是完全兼容Unicode

    它支持如下所述的一系列不同的Unicode编码。

    

    Unicode中每一个字符都可以被表示成一个或多个unicode标量

    一个unicode标量是字符或者修饰符的唯一21位数(和名称)

    

    Unicode字符串被写进文本文件或其他的存储结构时

    这些 unicode 标量将会按照Unicode 定义的集中格式之一进行编码。

    每个格式将字符串编码为小的代码块-code units

    其包括 UTF-8 格式( 8 位代码单元进行编码) UTF-16 格式( 16 位代码单元进行编码)

    

    

    你可以通过遍历字符串的utf8属性来访问它的  UTF-8 表示。

    其为UTF8View类型的属性, UTF8View是无符号 8 (UInt8) 值的集合,

    每一个UIn8都是一个字符的UTF-8表示:

    let dog = "dog"

    for code in dog.utf8 {

    

    print(code)

    

    }

    // 100 111 103 33

    在上面的例子中,前四个 10 进制 codeUnit (100, 111, 103, 33) 代表了字符  d o g   !

    他们的  UTF-8 表示与其 ASCII  表示相同。

    

    

    可以通过遍历字符串的  utf16 属性来访问它的  UTF-16 表示

    其为  UTF16View  类型的属性,

    UTF16View 是无符号 16   (UInt16) 值的集合,

    每一个  UInt16  都是一个字符的 UTF-16 表示

 

    */

    

    let dog = "dog!"

    for code in dog.utf8 {

      

      print(code)

      

    }

    /**

    100

    111

    103

    33

    */

    for code in dog.utf16 {

      

      print(code)

    }

    /**

    100

    111

    103

    33

    */

    

  }


    

  }

  

}


没有更多推荐了,返回首页