형식을 사용하여 문자열을 작성하는 방법

형식을 사용하여 문자열을 작성하는 방법

작성해야 할 필요가 있습니다.String변환할 수 있는 포맷으로Int,Int64,Double, 기타는 다음과 같이 입력합니다.StringObjective-C를 사용하여 다음을 수행할 수 있습니다.

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

스위프트 말고 어떻게 해야 하죠?

이게 도움이 될 것 같아요

import Foundation

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

결과 예:

timeNow in hex: 5cdc9c8d

별 다른 것 없어.

let str = NSString(format:"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, LONG_VALUE, STRING_VALUE)

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

업데이트: 이 답변은 Swift가 작성하기 전에 작성했습니다.String(format:)API에 추가되어 있습니다.상위 답변에서 주어진 방법을 사용합니다.

아니요.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)

나는 둘 다 그렇다고 생각한다.

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

그리고.

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

사용자가 포맷에 대해 물어봤기 때문에 둘 다 허용됩니다.또한 두 가지 케이스가 모두 원하는 대로 충족됩니다.

int, long, double 등의 타입을 문자열로 변환할 수 있는 포맷의 문자열을 작성해야 합니다.

분명히 전자는 후자보다 포맷을 더 세밀하게 제어할 수 있지만 후자가 허용 가능한 답이 아니라는 것을 의미하지는 않습니다.

먼저 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;

이것이 훨씬 더 명확하다.

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);

인정된 답변은 이 문제를 해결하기 위한 최선의 일반적인 솔루션입니다(즉,String(format:_:)로부터의 방법.Foundation) 하지만...

Swift © 5 를 사용하고 있는 경우는, 새로운 테크놀로지를 활용할 수 있습니다.StringInterpolationProtocol앱에서 일반적인 문자열 포맷 사용 사례에 적합한 구문 슈가 몇 가지를 제공하는 프로토콜입니다.

이 새로운 프로토콜의 개요는 다음과 같습니다.

문자열 리터럴이 빌드되는 동안 보간 기능이 있는 내용을 나타냅니다.

몇 가지 간단한 예:

extension String.StringInterpolation {

    /// Quick formatting for *floating point* values.
    mutating func appendInterpolation(float: Double, decimals: UInt = 2) {
        let floatDescription = String(format: "%.\(decimals)f%", float)
        appendLiteral(floatDescription)
    }

    /// Quick formatting for *hexadecimal* values.
    mutating func appendInterpolation(hex: Int) {
        let hexDescription = String(format: "0x%X", hex)
        appendLiteral(hexDescription)
    }

    /// Quick formatting for *percents*.
    mutating func appendInterpolation(percent: Double, decimals: UInt = 2) {
        let percentDescription = String(format: "%.\(decimals)f%%", percent * 100)
        appendLiteral(percentDescription)
    }

    /// Formats the *elapsed time* since the specified start time.
    mutating func appendInterpolation(timeSince startTime: TimeInterval, decimals: UInt = 2) {
        let elapsedTime = CACurrentMediaTime() - startTime
        let elapsedTimeDescription = String(format: "%.\(decimals)fs", elapsedTime)
        appendLiteral(elapsedTimeDescription)
    }
}

다음과 같이 사용할 수 있습니다.

let number = 1.2345
"Float: \(float: number)" // "Float: 1.23"
"Float: \(float: number, decimals: 1)" // "Float: 1.2"

let integer = 255
"Hex: \(hex: integer)" // "Hex: 0xFF"

let rate = 0.15
"Percent: \(percent: rate)" // "Percent: 15.00%"
"Percent: \(percent: rate, decimals: 0)" // "Percent: 15%"

let startTime = CACurrentMediaTime()
Thread.sleep(forTimeInterval: 2.8)
"∆t was \(timeSince: startTime)" // "∆t was 2.80s"
"∆t was \(timeSince: startTime, decimals: 0)" // "∆t was 3s"

이것은 SE-0228에 의해 도입되었으므로, 이 신기능에 대한 자세한 이해를 위해 원래의 제안서를 읽어보시기 바랍니다.마지막으로 프로토콜 문서도 유용합니다.

이 출판 이후 많은 시간이 흘렀다는 것을 알지만, 저는 비슷한 상황에 빠졌고, 제 삶을 단순화하기 위해 시뮬레이션 클래스를 만들었습니다.

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/

Foundation을 Import할 수 없거나 round()를 사용하거나 String을 원하지 않는 경우 "We <3 Swift"에서 배운 간단한 솔루션이 있습니다.

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

결과: 31.726

다음 코드를 사용합니다.

    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) "

String(format:)의 장점은 포맷 문자열을 저장한 후 나중에 12개 위치에서 재사용할 수 있다는 것입니다.이 한 곳에서 현지화할 수도 있습니다.보간법의 경우처럼 몇 번이고 다시 작성해야 합니다.

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은 작은 기능을 사용하여 기능이 저하되어 실행 속도가 빨라지기 때문에 매우 좋습니다.

변수 버전을 사용하거나 고정 열을 가져오려면 함수 버전을 사용할 수 있습니다.길이가 필요한 열보다 작으면 필드만 확장됩니다.

NSString을 위해 오래된 목표 C 루틴에 의존하지 않는 순수한 스위프트를 갖게 되었습니다.

★★String(format: "%s" ...)에서는 '크래쉬'와 같은 쓸 수 가 나와 있습니다.여기에서는 다음과 같은 것을 쓸 수 있는 코드가 있습니다."hello".center(42); "world".alignLeft(42):

extension String {

    // note: symbol names match to nim std/strutils lib:

    func align (_ boxsz: UInt) -> String {
        self.withCString { String(format: "%\(boxsz)s", $0) }
    }

    func alignLeft (_ boxsz: UInt) -> String {
        self.withCString { String(format: "%-\(boxsz)s", $0) }
    }

    func center (_ boxsz: UInt) -> String {
        let n = self.count
        guard boxsz > n else { return self }
        let padding = boxsz - UInt(n)
        let R = padding / 2
        guard R > 0 else { return " " + self }
        let L = (padding%2 == 0) ? R : (R+1)
        return " ".withCString { String(format: "%\(L)s\(self)%\(R)s", $0,$0) }
    }

}

테스트 성공:

 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))
        }

언급URL : https://stackoverflow.com/questions/24074479/how-to-create-a-string-with-format