221

我需要创建一个String可以将Int, Int64,Double等类型转换为String. 使用Objective-C,我可以通过以下方式做到这一点:

NSString *str = [NSString stringWithFormat:@"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, STRING_VALUE];

如何与 Wwift 做同样的事情?

4

13 回答 13

435

我认为这可以帮助你:

let timeNow = time(nil)
let aStr = String(format: "%@%x", "timeNow in hex: ", timeNow)
print(aStr)

示例结果:

timeNow in hex: 5cdc9c8d
于 2014-06-07T13:08:39.817 回答
112

没什么特别的

let str = NSString(format:"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, LONG_VALUE, STRING_VALUE)
于 2014-06-06T05:04:19.613 回答
53
let str = "\(INT_VALUE), \(FLOAT_VALUE), \(DOUBLE_VALUE), \(STRING_VALUE)"

更新:String(format:)我在 Swift添加到它的 API之前写了这个答案。使用上面答案给出的方法。

于 2014-06-06T05:04:56.543 回答
46

不需要NSString

String(format: "Value: %3.2f\tResult: %3.2f", arguments: [2.7, 99.8])

或者

String(format:"Value: %3.2f\tResult: %3.2f", 2.7, 99.8)
于 2015-05-31T05:26:35.193 回答
16

我会争辩说,两者

let str = String(format:"%d, %f, %ld", INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE)

let str = "\(INT_VALUE), \(FLOAT_VALUE), \(DOUBLE_VALUE)"

都是可以接受的,因为用户询问了格式并且两种情况都符合他们的要求:

我需要创建一个可以将 int、long、double 等类型转换为字符串的格式的字符串。

显然,前者比后者允许更好地控制格式,但这并不意味着后者不是一个可接受的答案。

于 2015-11-05T17:19:58.190 回答
6

首先阅读Swift 语言的官方文档。

答案应该是

var str = "\(INT_VALUE) , \(FLOAT_VALUE) , \(DOUBLE_VALUE), \(STRING_VALUE)"
println(str)

这里

1) 默认任意浮点值double

EX.
 var myVal = 5.2 // its double by default;

-> 如果你想显示浮点值,那么你需要明确定义这样的

 EX.
     var myVal:Float = 5.2 // now its float value;

这要清楚得多。

于 2014-06-06T05:07:14.257 回答
3
let INT_VALUE=80
let FLOAT_VALUE:Double= 80.9999
let doubleValue=65.0
let DOUBLE_VALUE:Double= 65.56
let STRING_VALUE="Hello"

let str = NSString(format:"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, STRING_VALUE);
 println(str);
于 2014-06-06T05:22:46.567 回答
1

我知道自此发布以来已经过去了很多时间,但是我陷入了类似的境地并创建了一个 simples 类来简化我的生活。

public struct StringMaskFormatter {

    public var pattern              : String    = ""
    public var replecementChar      : Character = "*"
    public var allowNumbers         : Bool      = true
    public var allowText            : Bool      = false


    public init(pattern:String, replecementChar:Character="*", allowNumbers:Bool=true, allowText:Bool=true)
    {
        self.pattern            = pattern
        self.replecementChar    = replecementChar
        self.allowNumbers       = allowNumbers
        self.allowText          = allowText
    }


    private func prepareString(string:String) -> String {

        var charSet : NSCharacterSet!

        if allowText && allowNumbers {
            charSet = NSCharacterSet.alphanumericCharacterSet().invertedSet
        }
        else if allowText {
            charSet = NSCharacterSet.letterCharacterSet().invertedSet
        }
        else if allowNumbers {
            charSet = NSCharacterSet.decimalDigitCharacterSet().invertedSet
        }

        let result = string.componentsSeparatedByCharactersInSet(charSet)
        return result.joinWithSeparator("")
    }

    public func createFormattedStringFrom(text:String) -> String
    {
        var resultString = ""
        if text.characters.count > 0 && pattern.characters.count > 0
        {

            var finalText   = ""
            var stop        = false
            let tempString  = prepareString(text)

            var formatIndex = pattern.startIndex
            var tempIndex   = tempString.startIndex

            while !stop
            {
                let formattingPatternRange = formatIndex ..< formatIndex.advancedBy(1)

                if pattern.substringWithRange(formattingPatternRange) != String(replecementChar) {
                    finalText = finalText.stringByAppendingString(pattern.substringWithRange(formattingPatternRange))
                }
                else if tempString.characters.count > 0 {
                    let pureStringRange = tempIndex ..< tempIndex.advancedBy(1)
                    finalText = finalText.stringByAppendingString(tempString.substringWithRange(pureStringRange))
                    tempIndex = tempIndex.advancedBy(1)
                }

                formatIndex = formatIndex.advancedBy(1)

                if formatIndex >= pattern.endIndex || tempIndex >= tempString.endIndex {
                    stop = true
                }

                resultString = finalText

            }
        }

        return resultString
    }

}

以下链接发送到完整的源代码: https ://gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

该解决方案基于本文:http: //vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-swift-basics/

于 2016-07-11T12:16:47.973 回答
1

如果您不能导入 Foundation、使用round()和/或不想要String ,我通过“We <3 Swift”学到了一个简单的解决方案:

var number = 31.726354765
var intNumber = Int(number * 1000.0)
var roundedNumber = Double(intNumber) / 1000.0

结果:31.726

于 2016-10-26T19:33:15.893 回答
0

使用以下代码:

    let intVal=56
    let floatval:Double=56.897898
    let doubleValue=89.0
    let explicitDaouble:Double=89.56
    let stringValue:"Hello"

    let stringValue="String:\(stringValue) Integer:\(intVal) Float:\(floatval) Double:\(doubleValue) ExplicitDouble:\(explicitDaouble) "
于 2014-06-06T05:06:20.483 回答
0

String(format:) 的美妙之处在于你可以保存一个格式化字符串,然后在很多地方重用它。它也可以在这个单一的地方进行本地化。在插值方法的情况下,您必须一次又一次地编写它。

于 2021-01-08T12:08:34.127 回答
0

简单的功能不包含在 Swift 中,因为它包含在其他语言中,所以通常可以快速编码以供重用。程序员创建包含所有这些重用代码的技巧文件包的专业提示。

因此,从我的技巧包中,我们首先需要在缩进中使用字符串乘法。

@inlinable func * (string: String, scalar: Int) -> String {
    let array = [String](repeating: string, count: scalar)
    return array.joined(separator: "")
}

然后是添加逗号的代码。

extension Int {
    @inlinable var withCommas:String {
        var i = self
        var retValue:[String] = []
        while i >= 1000 {
            retValue.append(String(format:"%03d",i%1000))
            i /= 1000
        }
        retValue.append("\(i)")
        return retValue.reversed().joined(separator: ",")
    }

    @inlinable func withCommas(_ count:Int = 0) -> String {
        let retValue = self.withCommas
        let indentation = count - retValue.count
        let indent:String = indentation >= 0 ? " " * indentation : ""

        return indent + retValue
    }
}

我刚刚写了最后一个函数,所以我可以让列对齐。

@inlinable 很棒,因为它需要小功能并减少它们的功能,因此它们运行得更快。

您可以使用变量版本,或者要获得固定列,请使用函数版本。设置小于所需列的长度只会扩展该字段。

现在你有了纯 Swift 的东西,并且不依赖于 NSString 的一些旧的目标 C 例程。

于 2021-01-17T20:39:28.187 回答
-2

尝试成功:

 var letters:NSString = "abcdefghijkl"
        var strRendom = NSMutableString.stringWithCapacity(strlength)
        for var i=0; i<strlength; i++ {
            let rndString = Int(arc4random() % 12)
            //let strlk = NSString(format: <#NSString#>, <#CVarArg[]#>)
            let strlk = NSString(format: "%c", letters.characterAtIndex(rndString))
            strRendom.appendString(String(strlk))
        }
于 2014-07-12T08:20:34.293 回答