নীচে আমি কীভাবে এর আগে দুটি দশমিক স্থানে একটি ফ্লোট ছাঁটাই করেছি
NSLog(@" %.02f %.02f %.02f", r, g, b);আমি ডক্স এবং ইবুকটি যাচাই করেছিলাম তবে এটি বের করতে সক্ষম হইনি। ধন্যবাদ!
নীচে আমি কীভাবে এর আগে দুটি দশমিক স্থানে একটি ফ্লোট ছাঁটাই করেছি
NSLog(@" %.02f %.02f %.02f", r, g, b);আমি ডক্স এবং ইবুকটি যাচাই করেছিলাম তবে এটি বের করতে সক্ষম হইনি। ধন্যবাদ!
উত্তর:
ডেভিডের প্রতিক্রিয়া অনুসরণ করে এখন পর্যন্ত আমার সেরা সমাধান :
import Foundation
extension Int {
func format(f: String) -> String {
return String(format: "%\(f)d", self)
}
}
extension Double {
func format(f: String) -> String {
return String(format: "%\(f)f", self)
}
}
let someInt = 4, someIntFormat = "03"
println("The integer number \(someInt) formatted with \"\(someIntFormat)\" looks like \(someInt.format(someIntFormat))")
// The integer number 4 formatted with "03" looks like 004
let someDouble = 3.14159265359, someDoubleFormat = ".3"
println("The floating point number \(someDouble) formatted with \"\(someDoubleFormat)\" looks like \(someDouble.format(someDoubleFormat))")
// The floating point number 3.14159265359 formatted with ".3" looks like 3.142আমি মনে করি এটি সর্বাধিক সুইফ্ট-জাতীয় সমাধান, বিন্যাসের ক্রিয়াকলাপগুলি সরাসরি ডেটা টাইপের সাথে বেঁধে রাখে। এটি ভাল হতে পারে যে কোথাও ফর্ম্যাটিং অপারেশনগুলির একটি অন্তর্নির্মিত গ্রন্থাগার রয়েছে, বা সম্ভবত এটি শীঘ্রই প্রকাশ করা হবে। ভাষাটি এখনও বিটাতে রয়েছে তা মনে রাখবেন।
একটি সহজ উপায় হ'ল:
import Foundation // required for String(format: _, _)
print(String(format: "hex string: %X", 123456))
print(String(format: "a float number: %.5f", 1.0321))println(String(format: "a float number: %.5f", 1.0321))
printfআলাদা এক্সটেনশন না লিখে মান সি-স্টাইলের অনেক কাছাকাছি ।
import Foundation
আমি String.localizedStringWithFormatবেশ ভাল কাজ খুঁজে পেয়েছি :
উদাহরণ:
let value: Float = 0.33333
let unit: String = "mph"
yourUILabel.text = String.localizedStringWithFormat("%.2f %@", value, unit)এটি একটি খুব দ্রুত এবং সহজ উপায় যার জটিল সমাধানের প্রয়োজন নেই।
let duration = String(format: "%.01f", 3.32323242)
// result = 3.3Col 16: 'init' has been renamed to 'init(describing:)'
এখানে বেশিরভাগ উত্তর বৈধ। তবে, আপনি যদি সংখ্যাটি প্রায়শই ফর্ম্যাট করবেন তবে একটি ফর্ম্যাট স্ট্রিং ফেরত এমন একটি পদ্ধতি যুক্ত করার জন্য ফ্লোট শ্রেণীর প্রসারকে বিবেচনা করুন। নীচে উদাহরণ কোড দেখুন। এটি একটি সংখ্যা বিন্যাসক এবং এক্সটেনশন ব্যবহার করে একই লক্ষ্য অর্জন করে।
extension Float {
func string(fractionDigits:Int) -> String {
let formatter = NSNumberFormatter()
formatter.minimumFractionDigits = fractionDigits
formatter.maximumFractionDigits = fractionDigits
return formatter.stringFromNumber(self) ?? "\(self)"
}
}
let myVelocity:Float = 12.32982342034
println("The velocity is \(myVelocity.string(2))")
println("The velocity is \(myVelocity.string(1))")কনসোলটি দেখায়:
The velocity is 12.33
The velocity is 12.3extension Float {
func string(fractionDigits:Int) -> String {
let formatter = NumberFormatter()
formatter.minimumFractionDigits = fractionDigits
formatter.maximumFractionDigits = fractionDigits
return formatter.string(from: NSNumber(value: self)) ?? "\(self)"
}
}NSNumberFormatterএই উত্তর মত আরও লোক ব্যবহার করতে চান । অন্যান্য উচ্চ-ভোট প্রাপ্ত উত্তরগুলি কেবল ডিভাইস লোকেল সেটিংস প্রতিফলিত করতে ব্যর্থ হয় (উদাহরণস্বরূপ কিছু লোকেলগুলিতে তারা দশমিক জায়গার জন্য কমা ব্যবহার করে; এটি প্রতিফলিত করে; অন্যান্য উত্তরগুলি তা দেয় না)।
NSNumberFormatterএটি শুরু করার পক্ষে যথেষ্ট ধীর। যদি সম্ভব হয় তবে এটি একটিকে সংজ্ঞায়িত করতে এবং এটি পুনরায় ব্যবহার করতে সহায়তা করে। বলেছিল, আমি এই প্রশ্নটি এখানে পড়ছি কারণ এটি আমার ক্ষেত্রে সম্ভব নয়।
আপনি স্ট্রিং ইন্টারপোলেশন দিয়ে এটি (এখনও) করতে পারবেন না। আপনার সেরা বাজিটি এখনও এনএসএস স্ট্রিং ফর্ম্যাটিং হতে চলেছে:
println(NSString(format:"%.2f", sqrt(2.0)))পাইথন থেকে এক্সট্রোপোলেটিং, মনে হচ্ছে যুক্তিসঙ্গত বাক্য গঠন হতে পারে:
@infix func % (value:Double, format:String) -> String {
return NSString(format:format, value)
}এরপরে যা আপনাকে সেগুলি এগুলি ব্যবহার করতে দেয়:
M_PI % "%5.3f" // "3.142"আপনি সমস্ত সংখ্যার প্রকারের জন্য অনুরূপ অপারেটরকে সংজ্ঞায়িত করতে পারেন, দুর্ভাগ্যক্রমে আমি জেনেরিক দিয়ে এটি করার কোনও উপায় খুঁজে পাইনি।
সুইফট 5 আপডেট
কমপক্ষে সুইফট 5 হিসাবে Stringসরাসরি সরাসরি format:আরম্ভকারীকে সমর্থন করে , তাই ব্যবহার করার দরকার নেই NSStringএবং @infixবৈশিষ্ট্যটির আর প্রয়োজন নেই যার অর্থ উপরের নমুনাগুলি এইভাবে লেখা উচিত:
println(String(format:"%.2f", sqrt(2.0)))
func %(value:Double, format:String) -> String {
return String(format:format, value)
}
Double.pi % "%5.3f" // "3.142"[NSString stringWithFormat...
কেন এত জটিল? পরিবর্তে আপনি এটি ব্যবহার করতে পারেন:
import UIKit
let PI = 3.14159265359
round( PI ) // 3.0 rounded to the nearest decimal
round( PI * 100 ) / 100 //3.14 rounded to the nearest hundredth
round( PI * 1000 ) / 1000 // 3.142 rounded to the nearest thousandthএটি খেলার মাঠে কাজ করে দেখুন।
PS: থেকে সমাধান: http://rrike.sh/xcode/rounding-various-decimal-places-swift/
রুবি / পাইথন %অপারেটরটি পুনরায় লেখার জন্য আরও মার্জিত এবং জেনেরিক সমাধান হ'ল :
// Updated for beta 5
func %(format:String, args:[CVarArgType]) -> String {
return NSString(format:format, arguments:getVaList(args))
}
"Hello %@, This is pi : %.2f" % ["World", M_PI]"Hello %@, This is pi : %.2f" % ["World", M_PI]কাজ করে তবে আশ্চর্যজনকভাবে "%@ %@" % ["Hello", "World"]উত্থাপন করুন can't unsafeBitCast... অনুমান করুন যে এটি পরবর্তী সংস্করণে সংশোধন করা হবে।
,এবং বেশিরভাগ ভাষায় বৈধ অক্ষর অপারেটর নয়। এবং ইমো, %অপারেটরটি ব্যবহার করা আরও ভাল যা ইতিমধ্যে অন্যান্য ভাষায় বিদ্যমান। বিকাশকারী.অ্যাপল.
সুইফট 4
let string = String(format: "%.2f", locale: Locale.current, arguments: 15.123)আপনি এখনও @ সাইন ছাড়াই অবজেক্টিভ-সি হিসাবে সুইফটে এনএসএলোগ ব্যবহার করতে পারেন।
NSLog("%.02f %.02f %.02f", r, g, b)সম্পাদনা করুন: সুইফ্টের সাথে কিছুক্ষণ কাজ করার পরে আমি এই প্রকরণটি যুক্ত করতে চাই
var r=1.2
var g=1.3
var b=1.4
NSLog("\(r) \(g) \(b)")আউটপুট:
2014-12-07 21:00:42.128 MyApp[1626:60b] 1.2 1.3 1.4(5.2).rounded()
// 5.0
(5.5).rounded()
// 6.0
(-5.2).rounded()
// -5.0
(-5.5).rounded()
// -6.0ফানক বৃত্তাকার (_ নিয়ম: ভাসমান পয়েন্ট রাউন্ডিংআরুল) -> ডাবল
let x = 6.5
// Equivalent to the C 'round' function:
print(x.rounded(.toNearestOrAwayFromZero))
// Prints "7.0"
// Equivalent to the C 'trunc' function:
print(x.rounded(.towardZero))
// Prints "6.0"
// Equivalent to the C 'ceil' function:
print(x.rounded(.up))
// Prints "7.0"
// Equivalent to the C 'floor' function:
print(x.rounded(.down))
// Prints "6.0"var x = 5.2
x.round()
// x == 5.0
var y = 5.5
y.round()
// y == 6.0
var z = -5.5
z.round()
// z == -6.0রূপান্তরকারী ফানক বৃত্তাকার (_ নিয়ম: ভাসমান পয়েন্ট রাউন্ডিং রুল)
// Equivalent to the C 'round' function:
var w = 6.5
w.round(.toNearestOrAwayFromZero)
// w == 7.0
// Equivalent to the C 'trunc' function:
var x = 6.5
x.round(.towardZero)
// x == 6.0
// Equivalent to the C 'ceil' function:
var y = 6.5
y.round(.up)
// y == 7.0
// Equivalent to the C 'floor' function:
var z = 6.5
z.round(.down)
// z == 6.0extension Numeric {
private func _precision(number: NSNumber, formatter: NumberFormatter) -> Self? {
if let formatedNumString = formatter.string(from: number),
let formatedNum = formatter.number(from: formatedNumString) {
return formatedNum as? Self
}
return nil
}
private func toNSNumber() -> NSNumber? {
if let num = self as? NSNumber { return num }
guard let string = self as? String, let double = Double(string) else { return nil }
return NSNumber(value: double)
}
func precision(_ minimumFractionDigits: Int,
roundingMode: NumberFormatter.RoundingMode = NumberFormatter.RoundingMode.halfUp) -> Self? {
guard let number = toNSNumber() else { return nil }
let formatter = NumberFormatter()
formatter.minimumFractionDigits = minimumFractionDigits
formatter.roundingMode = roundingMode
return _precision(number: number, formatter: formatter)
}
func precision(with numberFormatter: NumberFormatter) -> String? {
guard let number = toNSNumber() else { return nil }
return numberFormatter.string(from: number)
}
}_ = 123.44.precision(2)
_ = 123.44.precision(3, roundingMode: .up)
let numberFormatter = NumberFormatter()
numberFormatter.minimumFractionDigits = 1
numberFormatter.groupingSeparator = " "
let num = 222.3333
_ = num.precision(2)func option1<T: Numeric>(value: T, numerFormatter: NumberFormatter? = nil) {
print("Type: \(type(of: value))")
print("Original Value: \(value)")
let value1 = value.precision(2)
print("value1 = \(value1 != nil ? "\(value1!)" : "nil")")
let value2 = value.precision(5)
print("value2 = \(value2 != nil ? "\(value2!)" : "nil")")
if let value1 = value1, let value2 = value2 {
print("value1 + value2 = \(value1 + value2)")
}
print("")
}
func option2<T: Numeric>(value: T, numberFormatter: NumberFormatter) {
print("Type: \(type(of: value))")
print("Original Value: \(value)")
let value1 = value.precision(with: numberFormatter)
print("formated value = \(value1 != nil ? "\(value1!)" : "nil")\n")
}
func test(with double: Double) {
print("===========================\nTest with: \(double)\n")
let float = Float(double)
let float32 = Float32(double)
let float64 = Float64(double)
let float80 = Float80(double)
let cgfloat = CGFloat(double)
// Exapmle 1
print("-- Option1\n")
option1(value: double)
option1(value: float)
option1(value: float32)
option1(value: float64)
option1(value: float80)
option1(value: cgfloat)
// Exapmle 2
let numberFormatter = NumberFormatter()
numberFormatter.formatterBehavior = .behavior10_4
numberFormatter.minimumIntegerDigits = 1
numberFormatter.minimumFractionDigits = 4
numberFormatter.maximumFractionDigits = 9
numberFormatter.usesGroupingSeparator = true
numberFormatter.groupingSeparator = " "
numberFormatter.groupingSize = 3
print("-- Option 2\n")
option2(value: double, numberFormatter: numberFormatter)
option2(value: float, numberFormatter: numberFormatter)
option2(value: float32, numberFormatter: numberFormatter)
option2(value: float64, numberFormatter: numberFormatter)
option2(value: float80, numberFormatter: numberFormatter)
option2(value: cgfloat, numberFormatter: numberFormatter)
}
test(with: 123.22)
test(with: 1234567890987654321.0987654321)===========================
Test with: 123.22
-- Option1
Type: Double
Original Value: 123.22
value1 = 123.22
value2 = 123.22
value1 + value2 = 246.44
Type: Float
Original Value: 123.22
value1 = nil
value2 = nil
Type: Float
Original Value: 123.22
value1 = nil
value2 = nil
Type: Double
Original Value: 123.22
value1 = 123.22
value2 = 123.22
value1 + value2 = 246.44
Type: Float80
Original Value: 123.21999999999999886
value1 = nil
value2 = nil
Type: CGFloat
Original Value: 123.22
value1 = 123.22
value2 = 123.22
value1 + value2 = 246.44
-- Option 2
Type: Double
Original Value: 123.22
formatted value = 123.2200
Type: Float
Original Value: 123.22
formatted value = 123.220001221
Type: Float
Original Value: 123.22
formatted value = 123.220001221
Type: Double
Original Value: 123.22
formatted value = 123.2200
Type: Float80
Original Value: 123.21999999999999886
formatted value = nil
Type: CGFloat
Original Value: 123.22
formatted value = 123.2200
===========================
Test with: 1.2345678909876544e+18
-- Option1
Type: Double
Original Value: 1.2345678909876544e+18
value1 = 1.23456789098765e+18
value2 = 1.23456789098765e+18
value1 + value2 = 2.4691357819753e+18
Type: Float
Original Value: 1.234568e+18
value1 = nil
value2 = nil
Type: Float
Original Value: 1.234568e+18
value1 = nil
value2 = nil
Type: Double
Original Value: 1.2345678909876544e+18
value1 = 1.23456789098765e+18
value2 = 1.23456789098765e+18
value1 + value2 = 2.4691357819753e+18
Type: Float80
Original Value: 1234567890987654400.0
value1 = nil
value2 = nil
Type: CGFloat
Original Value: 1.2345678909876544e+18
value1 = 1.23456789098765e+18
value2 = 1.23456789098765e+18
value1 + value2 = 2.4691357819753e+18
-- Option 2
Type: Double
Original Value: 1.2345678909876544e+18
formatted value = 1 234 567 890 987 650 000.0000
Type: Float
Original Value: 1.234568e+18
formatted value = 1 234 567 939 550 610 000.0000
Type: Float
Original Value: 1.234568e+18
formatted value = 1 234 567 939 550 610 000.0000
Type: Double
Original Value: 1.2345678909876544e+18
formatted value = 1 234 567 890 987 650 000.0000
Type: Float80
Original Value: 1234567890987654400.0
formatted value = nil
Type: CGFloat
Original Value: 1.2345678909876544e+18
formatted value = 1 234 567 890 987 650 000.0000extension Double {
func formatWithDecimalPlaces(decimalPlaces: Int) -> Double {
let formattedString = NSString(format: "%.\(decimalPlaces)f", self) as String
return Double(formattedString)!
}
}
1.3333.formatWithDecimalPlaces(2)এখন পর্যন্ত দেওয়া উত্তরগুলি যা সর্বাধিক ভোট পেয়েছে সেগুলি এনএসএসস্ট্রিং পদ্ধতির উপর নির্ভর করছে এবং আপনি প্রয়োজন ফাউন্ডেশন আমদানি করেছেন।
যে কাজটি করে, আপনি এখনও এনএসএলগ অ্যাক্সেস রয়েছে।
সুতরাং আমি মনে করি প্রশ্নের উত্তর, আপনি যদি সুইফটে এনএসএলগ ব্যবহার চালিয়ে কীভাবে জিজ্ঞাসা করছেন তবে এটি সহজ:
import Foundation
এখানে একটি "খাঁটি" দ্রুত সমাধান রয়েছে
var d = 1.234567
operator infix ~> {}
@infix func ~> (left: Double, right: Int) -> String {
if right == 0 {
return "\(Int(left))"
}
var k = 1.0
for i in 1..right+1 {
k = 10.0 * k
}
let n = Double(Int(left*k)) / Double(k)
return "\(n)"
}
println("\(d~>2)")
println("\(d~>1)")
println("\(d~>0)")এক্সটেনশনের শক্তি
extension Double {
var asNumber:String {
if self >= 0 {
var formatter = NSNumberFormatter()
formatter.numberStyle = .NoStyle
formatter.percentSymbol = ""
formatter.maximumFractionDigits = 1
return "\(formatter.stringFromNumber(self)!)"
}
return ""
}
}
let velocity:Float = 12.32982342034
println("The velocity is \(velocity.toNumber)")আউটপুট: বেগ 12.3
রাউন্ডিং সহ:
extension Float
{
func format(f: String) -> String
{
return NSString(format: "%\(f)f", self)
}
mutating func roundTo(f: String)
{
self = NSString(format: "%\(f)f", self).floatValue
}
}
extension Double
{
func format(f: String) -> String
{
return NSString(format: "%\(f)f", self)
}
mutating func roundTo(f: String)
{
self = NSString(format: "%\(f)f", self).doubleValue
}
}
x = 0.90695652173913
x.roundTo(".2")
println(x) //0.91পদ্ধতি নীচে ব্যবহার করুন
let output = String.localizedStringWithFormat(" %.02f %.02f %.02f", r, g, b)
println(output)উপরে প্রচুর ভাল উত্তর, তবে কখনও কখনও "% .3f" ধরণের গব্বলডিগুকের চেয়ে একটি প্যাটার্ন বেশি উপযুক্ত। এখানে আমার সুইফট 3-তে একটি নাম্বার ফর্ম্যাটর ব্যবহার করে নিন।
extension Double {
func format(_ pattern: String) -> String {
let formatter = NumberFormatter()
formatter.format = pattern
return formatter.string(from: NSNumber(value: self))!
}
}
let n1 = 0.350, n2 = 0.355
print(n1.format("0.00#")) // 0.35
print(n2.format("0.00#")) // 0.355এখানে আমি 2 দশমিক সর্বদা প্রদর্শিত হতে চেয়েছিলাম তবে তৃতীয়টি যদি এটি শূন্য না হয়।
সুইফট 4 এক্সকোড 10 আপডেট
extension Double {
var asNumber:String {
if self >= 0 {
let formatter = NumberFormatter()
formatter.numberStyle = .none
formatter.percentSymbol = ""
formatter.maximumFractionDigits = 2
return "\(formatter.string(from: NSNumber(value: self)) ?? "")"
}
return ""
}
}ডাবল এবং সিজিফ্লোট প্রকারের এক্সটেনশানগুলি সম্পর্কে কী:
extension Double {
func formatted(_ decimalPlaces: Int?) -> String {
let theDecimalPlaces : Int
if decimalPlaces != nil {
theDecimalPlaces = decimalPlaces!
}
else {
theDecimalPlaces = 2
}
let theNumberFormatter = NumberFormatter()
theNumberFormatter.formatterBehavior = .behavior10_4
theNumberFormatter.minimumIntegerDigits = 1
theNumberFormatter.minimumFractionDigits = 1
theNumberFormatter.maximumFractionDigits = theDecimalPlaces
theNumberFormatter.usesGroupingSeparator = true
theNumberFormatter.groupingSeparator = " "
theNumberFormatter.groupingSize = 3
if let theResult = theNumberFormatter.string(from: NSNumber(value:self)) {
return theResult
}
else {
return "\(self)"
}
}
}ব্যবহার:
let aNumber: Double = 112465848348508.458758344
Swift.print("The number: \(aNumber.formatted(2))")প্রিন্টগুলি: 112 465 848 348 508.46
@infix func ^(left:Double, right: Int) -> NSNumber {
let nf = NSNumberFormatter()
nf.maximumSignificantDigits = Int(right)
return nf.numberFromString(nf.stringFromNumber(left))
}
let r = 0.52264
let g = 0.22643
let b = 0.94837
println("this is a color: \(r^3) \(g^3) \(b^3)")
// this is a color: 0.523 0.226 0.948আমি দুটি দশমিক স্থান সম্পর্কে জানি না , তবে এখানে শূন্য দশমিক স্থান সহ আপনি কীভাবে ভাসমানগুলি মুদ্রণ করতে পারেন, তাই আমি কল্পনা করতে পারি যে এটি 2 স্থান, 3, স্থান হতে পারে ... (দ্রষ্টব্য: আপনাকে অবশ্যই সিজিফ্লোটকে পাসে ডাবল রূপান্তর করতে হবে) স্ট্রিংয়ে (ফর্ম্যাট :) বা এটি শূন্যের মান দেখতে পাবে)
func logRect(r: CGRect, _ title: String = "") {
println(String(format: "[ (%.0f, %.0f), (%.0f, %.0f) ] %@",
Double(r.origin.x), Double(r.origin.y), Double(r.size.width), Double(r.size.height), title))
}সুইফট 2 উদাহরণ: আইওএস ডিভাইসটির পর্দার প্রস্থ দশমিক সরিয়ে ফ্লোট ফর্ম্যাট করে
print(NSString(format: "Screen width = %.0f pixels", CGRectGetWidth(self.view.frame)))@ ক্রিশ্চিয়ান ডায়েটরিচ:
পরিবর্তে:
var k = 1.0
for i in 1...right+1 {
k = 10.0 * k
}
let n = Double(Int(left*k)) / Double(k)
return "\(n)"এটিও হতে পারে:
let k = pow(10.0, Double(right))
let n = Double(Int(left*k)) / k
return "\(n)"[সংশোধন:] বিভ্রান্তির জন্য দুঃখিত * - অবশ্যই এটি ডাবলসের সাথে কাজ করে। আমি মনে করি, সর্বাধিক ব্যবহারিক (আপনি যদি অঙ্কগুলি গোল করতে চান তবে কেটে না দেওয়া) এটি এমন কিছু হবে:
infix operator ~> {}
func ~> (left: Double, right: Int) -> Double {
if right <= 0 {
return round(left)
}
let k = pow(10.0, Double(right))
return round(left*k) / k
}কেবল ফ্লোটের জন্য, কেবল ডাবল প্রতি ফ্লোট দিয়ে প্রতিস্থাপন করুন, পাউফের সাথে পাও এবং রাউন্ডফের সাথে গোল করুন।
আপডেট: আমি দেখতে পেয়েছি যে স্ট্রিংয়ের পরিবর্তে রিটার্ন টাইপ ডাবল ব্যবহার করা সবচেয়ে ব্যবহারিক practical এটি স্ট্রিং আউটপুট, অর্থাৎ:
println("Pi is roughly \(3.1415926 ~> 3)")প্রিন্টস: পাই মোটামুটি ৩.১৪২
তাই আপনি স্ট্রিংসের ক্ষেত্রেও একইভাবে ব্যবহার করতে পারেন (আপনি এখনও লিখতে পারেন: প্রিন্টলন (ডি ~> ২)), তবে অতিরিক্তভাবে আপনি এটি সরাসরি মানগুলিতেও ব্যবহার করতে পারেন, যেমন:
d = Double(slider.value) ~> 2বা যা আপনার প্রয়োজন…