iOS konvertiert große Zahlen in kleinere Formate

Wie kann ich konvertieren, werden alle Nummern, die mehr als 3 Ziffern nach unten zu einer 4-stelligen oder weniger Zahl?

Dies ist genau, was ich meine:

10345 = 10.3k
10012 = 10k
123546 = 123.5k
4384324 = 4.3m

Rundung ist nicht ganz wichtig, aber ein plus.

Ich habe mir in NSNumberFormatter aber nicht gefunden haben, die richtige Lösung, und ich habe noch zu finden, eine passende Lösung hier. Jede Hilfe wird sehr geschätzt, Dank!

InformationsquelleAutor der Frage Kyle Begeman | 2013-08-16

-(NSString*) suffixNumber:(NSNumber*)number
{
    if (!number)
        return @"";

    long long num = [number longLongValue];

    int s = ( (num < 0) ? -1 : (num > 0) ? 1 : 0 );
    NSString* sign = (s == -1 ? @"-" : @"" );

    num = llabs(num);

    if (num < 1000)
        return [NSString stringWithFormat:@"%@%lld",sign,num];

    int exp = (int) (log10l(num) / 3.f); //log10l(1000));

    NSArray* units = @[@"K",@"M",@"G",@"T",@"P",@"E"];

    return [NSString stringWithFormat:@"%@%.1f%@",sign, (num / pow(1000, exp)), [units objectAtIndex:(exp-1)]];
}

Beispiel für die Nutzung

NSLog(@"%@",[self suffixNumber:@100]); //100
NSLog(@"%@",[self suffixNumber:@1000]); //1.0K
NSLog(@"%@",[self suffixNumber:@1500]); //1.5K
NSLog(@"%@",[self suffixNumber:@24000]); //24.0K
NSLog(@"%@",[self suffixNumber:@99900]); //99.9K
NSLog(@"%@",[self suffixNumber:@99999]); //100.0K
NSLog(@"%@",[self suffixNumber:@109999]); //110.0K
NSLog(@"%@",[self suffixNumber:@5109999]); //5.1M
NSLog(@"%@",[self suffixNumber:@8465445223]); //8.5G
NSLog(@"%@",[self suffixNumber:[NSNumber numberWithInt:-120]]); //-120
NSLog(@"%@",[self suffixNumber:[NSNumber numberWithLong:-5000000]]); //-5.0M
NSLog(@"%@",[self suffixNumber:[NSNumber numberWithDouble:-3.5f]]); //-3
NSLog(@"%@",[self suffixNumber:[NSNumber numberWithDouble:-4000.63f]]); //-4.0K

[Update]

Swift-version unter:

func suffixNumber(number:NSNumber) -> NSString {

    var num:Double = number.doubleValue;
    let sign = ((num < 0) ? "-" : "" );

    num = fabs(num);

    if (num < 1000.0){
        return "\(sign)\(num)";
    }

    let exp:Int = Int(log10(num) / 3.0 ); //log10(1000));

    let units:[String] = ["K","M","G","T","P","E"];

    let roundedNum:Double = round(10 * num / pow(1000.0,Double(exp))) / 10;

    return "\(sign)\(roundedNum)\(units[exp-1])";
}

Beispiel für die Nutzung

print(self.suffixNumber(NSNumber(long: 100))); //100.0
print(self.suffixNumber(NSNumber(long: 1000))); //1.0K
print(self.suffixNumber(NSNumber(long: 1500))); //1.5K
print(self.suffixNumber(NSNumber(long: 24000))); //24.0K
print(self.suffixNumber(NSNumber(longLong: 99900))); //99.9K
print(self.suffixNumber(NSNumber(longLong: 99999))); //100.0K
print(self.suffixNumber(NSNumber(longLong: 109999))); //110.0K
print(self.suffixNumber(NSNumber(longLong: 5109999))); //5.1K
print(self.suffixNumber(NSNumber(longLong: 8465445223))); //8.5G
print(self.suffixNumber(NSNumber(long: -120))); //-120.0
print(self.suffixNumber(NSNumber(longLong: -5000000))); //-5.0M
print(self.suffixNumber(NSNumber(float: -3.5))); //-3.5
print(self.suffixNumber(NSNumber(float: -4000.63))); //-4.0K

Hoffe es hilft

InformationsquelleAutor der Antwort Luca Iaco

Ich hatte das gleiche Problem und endete mit Kyle ' s Ansatz, aber leider bricht es beim Nummern wie 120000 verwendet werden, zeigt 12k statt 120K und ich brauchte, um zu zeigen, kleine zahlen wie: 1.1 K statt der Rundung nach unten auf 1K.

Also hier mein edit von Kyle ' s ursprüngliche Idee:

Results:
[self abbreviateNumber:987] ---> 987
[self abbreviateNumber:1200] ---> 1.2K
[self abbreviateNumber:12000] ----> 12K
[self abbreviateNumber:120000] ----> 120K
[self abbreviateNumber:1200000] ---> 1.2M
[self abbreviateNumber:1340] ---> 1.3K
[self abbreviateNumber:132456] ----> 132.5K

-(NSString *)abbreviateNumber:(int)num {

NSString *abbrevNum;
float number = (float)num;

//Prevent numbers smaller than 1000 to return NULL
if (num >= 1000) {
    NSArray *abbrev = @[@"K", @"M", @"B"];

    for (int i = abbrev.count - 1; i >= 0; i--) {

        //Convert array index to "1000", "1000000", etc
        int size = pow(10,(i+1)*3);

        if(size <= number) {
            //Removed the round and dec to make sure small numbers are included like: 1.1K instead of 1K
            number = number/size;
            NSString *numberString = [self floatToString:number];

            //Add the letter for the abbreviation
            abbrevNum = [NSString stringWithFormat:@"%@%@", numberString, [abbrev objectAtIndex:i]];
        }

    }
} else {

    //Numbers like: 999 returns 999 instead of NULL
    abbrevNum = [NSString stringWithFormat:@"%d", (int)number];
}

return abbrevNum;
}

- (NSString *) floatToString:(float) val {
NSString *ret = [NSString stringWithFormat:@"%.1f", val];
unichar c = [ret characterAtIndex:[ret length] - 1];

while (c == 48) { //0
    ret = [ret substringToIndex:[ret length] - 1];
    c = [ret characterAtIndex:[ret length] - 1];

    //After finding the "." we know that everything left is the decimal number, so get a substring excluding the "."
    if(c == 46) { //.
        ret = [ret substringToIndex:[ret length] - 1];
    }
}

return ret;
}

Ich Hoffe das kann dir helfen, Jungs.

InformationsquelleAutor der Antwort Ricardo Corrêa de Souza

Hier meine version ! Vielen Dank für die vorherigen Antworten.
Die Ziele dieser version ist :

Besser threshold-regler, weil die kleine Zahl, die details sind wichtiger, sehr große Anzahl details
Verwenden Sie so viel wie möglich NSNumberFormatter zu vermeiden Lage Probleme (wie z.B. Komma statt Punkt in Französisch)
Vermeiden ".0" und auch Runden von zahlen, die passen mit NSNumberFormatterRoundingMode

Können Sie alle wunderbar NSNumberFormatter Optionen, um Ihre Bedürfnisse zu erfüllen, sehen NSNumberFormatter Klasse Referenz

Den code (gist):

extension Int {

    func formatUsingAbbrevation () -> String {
        let numFormatter = NSNumberFormatter()

        typealias Abbrevation = (threshold:Double, divisor:Double, suffix:String)
        let abbreviations:[Abbrevation] = [(0, 1, ""),
                                           (1000.0, 1000.0, "K"),
                                           (100_000.0, 1_000_000.0, "M"),
                                           (100_000_000.0, 1_000_000_000.0, "B")]
                                           //you can add more !

        let startValue = Double (abs(self))
        let abbreviation:Abbrevation = {
            var prevAbbreviation = abbreviations[0]
            for tmpAbbreviation in abbreviations {
                if (startValue < tmpAbbreviation.threshold) {
                    break
                }
                prevAbbreviation = tmpAbbreviation
            }
            return prevAbbreviation
        } ()

        let value = Double(self) / abbreviation.divisor
        numFormatter.positiveSuffix = abbreviation.suffix
        numFormatter.negativeSuffix = abbreviation.suffix
        numFormatter.allowsFloats = true
        numFormatter.minimumIntegerDigits = 1
        numFormatter.minimumFractionDigits = 0
        numFormatter.maximumFractionDigits = 1

        return numFormatter.stringFromNumber(NSNumber (double:value))!
    }

}


let testValue:[Int] = [598, -999, 1000, -1284, 9940, 9980, 39900, 99880, 399880, 999898, 999999, 1456384, 12383474]

testValue.forEach() {
    print ("Value : \($0) -> \($0.formatUsingAbbrevation ())")
}

Ergebnis :

Value : 598 -> 598
Value : -999 -> -999
Value : 1000 -> 1K
Value : -1284 -> -1.3K
Value : 9940 -> 9.9K
Value : 9980 -> 10K
Value : 39900 -> 39.9K
Value : 99880 -> 99.9K
Value : 399880 -> 0.4M
Value : 999898 -> 1M
Value : 999999 -> 1M
Value : 1456384 -> 1.5M
Value : 12383474 -> 12.4M

InformationsquelleAutor der Antwort gbitaudeau

Flávio J Caetano Vieira Antwort umgewandelt Swift 3.0

extension Int {
    var abbreviated: String {
        let abbrev = "KMBTPE"
        return abbrev.characters.enumerated().reversed().reduce(nil as String?) { accum, tuple in
            let factor = Double(self) / pow(10, Double(tuple.0 + 1) * 3)
            let format = (factor.truncatingRemainder(dividingBy: 1)  == 0 ? "%.0f%@" : "%.1f%@")
            return accum ?? (factor > 1 ? String(format: format, factor, String(tuple.1)) : nil)
            } ?? String(self)
    }
}

InformationsquelleAutor der Antwort AbdulMomen عبدالمؤمن

13

Ich lief in ein ähnliches Problem versucht zu format y-Achse Werte in der Shinobi-Charts. Es Bedarf mit einem NSNumberFormatter, so dass ich schließlich kam mit dieser
```
NSNumberFormatter *numFormatter = [[NSNumberFormatter alloc] init];
[numFormatter setPositiveFormat:@"0M"];
[numFormatter setMultiplier:[NSNumber numberWithDouble:0.000001]];
```
Bekommen einen formatierten Wert
```
NSString *formattedNumber = [numFormatter stringFromNumber:[NSNumber numberWithInteger:4000000]]; //@"4M"
```
Diese Lösung nicht mit Rundung enthalten, aber wenn Sie (oder jemand anderes) muss nur einfach etwas, das funktionieren könnte. Wenn Sie brauchen, von der Tausende statt Millionen, ändern Sie das "M" ein "K" in der setPostiveFormat Methode, und ändern Sie die NSNumber Wert in der Multiplikator 0,001 .

InformationsquelleAutor der Antwort Taidg Murphy

Hier sind zwei Methoden, die ich mit gekommen, die zusammen arbeiten, um zu produzieren den gewünschten Effekt. Diese wird auch automatisch in der Runde. Dies wird auch angeben, wie viele zahlen insgesamt wird sichtbar durch die übergabe des int. Dez.

Auch in der float zu string-Methode, die Sie ändern können, die @"%.1f" zu @"%.2f"@"%.3f" etc sagen, wie viele Dezimalstellen sichtbar zu zeigen, nach dem Komma.

For Example:

52935 --->  53K
52724 --->  53.7K





-(NSString *)abbreviateNumber:(int)num withDecimal:(int)dec {

    NSString *abbrevNum;
    float number = (float)num;

    NSArray *abbrev = @[@"K", @"M", @"B"];

    for (int i = abbrev.count - 1; i >= 0; i--) {

        //Convert array index to "1000", "1000000", etc
        int size = pow(10,(i+1)*3);

        if(size <= number) {
            //Here, we multiply by decPlaces, round, and then divide by decPlaces.
            //This gives us nice rounding to a particular decimal place.
            number = round(number*dec/size)/dec;

            NSString *numberString = [self floatToString:number];

            //Add the letter for the abbreviation
            abbrevNum = [NSString stringWithFormat:@"%@%@", numberString, [abbrev objectAtIndex:i]];

            NSLog(@"%@", abbrevNum);

        }

    }


    return abbrevNum;
}

- (NSString *) floatToString:(float) val {

    NSString *ret = [NSString stringWithFormat:@"%.1f", val];
    unichar c = [ret characterAtIndex:[ret length] - 1];

    while (c == 48 || c == 46) { //0 or .
        ret = [ret substringToIndex:[ret length] - 1];
        c = [ret characterAtIndex:[ret length] - 1];
    }

    return ret;
}

Hoffe, dies hilft jemand, wer es braucht!

InformationsquelleAutor der Antwort Kyle Begeman

Nach dem Versuch ein paar dieser Lösungen, Luca laco zu haben scheint, ist es am nächsten, aber ich habe einige änderungen, um seine Methode, um mehr Kontrolle darüber zu haben, wie viele Ziffern angezeigt wird (D. H. wenn Sie möchten, 120.3 K kürzer ist, können Sie es zu begrenzen, 120K). Zusätzlich habe ich eine zusätzliche Schritt, die sicherstellt, dass eine Nummer wie 999,999 erscheint nicht als 1000.0 K, eher 1.0 M.

/*
 With "onlyShowDecimalPlaceForNumbersUnder" = 10:
 Original number: 598 - Result: 598
 Original number: 1000 - Result: 1.0K
 Original number: 1284 - Result: 1.3K
 Original number: 9980 - Result: 10K
 Original number: 39900 - Result: 40K
 Original number: 99880 - Result: 100K
 Original number: 999898 - Result: 1.0M
 Original number: 999999 - Result: 1.0M
 Original number: 1456384 - Result: 1.5M
 Original number: 12383474 - Result: 12M
 */

- (NSString *)suffixNumber:(NSNumber *)number
{
    if (!number)
        return @"";

    long long num = [number longLongValue];
    if (num < 1000)
        return [NSString stringWithFormat:@"%lld",num];

    int exp = (int) (log(num) / log(1000));
    NSArray * units = @[@"K",@"M",@"G",@"T",@"P",@"E"];

    int onlyShowDecimalPlaceForNumbersUnder = 10; //Either 10, 100, or 1000 (i.e. 10 means 12.2K would change to 12K, 100 means 120.3K would change to 120K, 1000 means 120.3K stays as is)
    NSString *roundedNumStr = [NSString stringWithFormat:@"%.1f", (num / pow(1000, exp))];
    int roundedNum = [roundedNumStr integerValue];
    if (roundedNum >= onlyShowDecimalPlaceForNumbersUnder) {
        roundedNumStr = [NSString stringWithFormat:@"%.0f", (num / pow(1000, exp))];
        roundedNum = [roundedNumStr integerValue];
    }

    if (roundedNum >= 1000) { //This fixes a number like 999,999 from displaying as 1000K by changing it to 1.0M
        exp++;
        roundedNumStr = [NSString stringWithFormat:@"%.1f", (num / pow(1000, exp))];
    }

    NSString *result = [NSString stringWithFormat:@"%@%@", roundedNumStr, [units objectAtIndex:(exp-1)]];

    NSLog(@"Original number: %@ - Result: %@", number, result);
    return result;
}

InformationsquelleAutor der Antwort beebcon

Ich weiß, es gibt schon viele Antworten und unterschiedliche Weise, aber dies ist, wie ich es gelöst mit einer eher funktionalen Ansatz:

extension Int {
    var abbreviated: String {
        let abbrev = "KMBTPE"
        return abbrev.characters
            .enumerated()
            .reversed()
            .reduce(nil as String?) { accum, tuple in
                let factor = Double(self) / pow(10, Double(tuple.0 + 1) * 3)
                let format = (factor - floor(factor) == 0 ? "%.0f%@" : "%.1f%@")
                return accum ?? (factor >= 1 ? String(format: format, factor, String(tuple.1)) : nil)
            } ?? String(self)
    }
}

InformationsquelleAutor der Antwort Flávio J Vieira Caetano

Swift version

Direkte übersetzung von Objective-C version

func abbreviateNumber(num: NSNumber) -> NSString {
    var ret: NSString = ""
    let abbrve: [String] = ["K", "M", "B"]

    var floatNum = num.floatValue

    if floatNum > 1000 {

        for i in 0..<abbrve.count {
            let size = pow(10.0, (Float(i) + 1.0) * 3.0)
            println("\(size)   \(floatNum)")
            if (size <= floatNum) {
                let num = floatNum / size
                let str = floatToString(num)
                ret = NSString(format: "%@%@", str, abbrve[i])
            }
        }
    } else {
        ret = NSString(format: "%d", Int(floatNum))
    }

    return ret
}

func floatToString(val: Float) -> NSString {
    var ret = NSString(format: "%.1f", val)
    var c = ret.characterAtIndex(ret.length - 1)

    while c == 48 {
        ret = ret.substringToIndex(ret.length - 1)
        c = ret.characterAtIndex(ret.length - 1)


        if (c == 46) {
            ret = ret.substringToIndex(ret.length - 1)
        }
    }
    return ret
}


abbreviateNumber(123)
abbreviateNumber(12503)
abbreviateNumber(12934203)
abbreviateNumber(12234200003)
abbreviateNumber(92234203)
abbreviateNumber(9223.3)

InformationsquelleAutor der Antwort coderek

Können Sie diese einfache Funktion, die Idee ist einfach zu verstehen

-(NSString*) suffixNumber:(NSNumber*)number
    double value = [number doubleValue];
    NSUInteger index = 0;
    NSArray *suffixArray = @[@"", @"K", @"M", @"B", @"T", @"P", @"E"];

    while ((value/1000) >= 1){
       value = value/1000;
       index++;
    }

    //3 line of code below for round doubles to 1 digit
    NSNumberFormatter *fmt = [[NSNumberFormatter alloc] init];
    [fmt setMaximumFractionDigits:1];
    NSString *valueWith1Digit = [fmt stringFromNumber:[NSNumber numberWithFloat:value]];

    NSString *svalue = [NSString stringWithFormat:@"%@%@",valueWith1Digit, [suffixArray objectAtIndex:index]];
    return svalue;
}

Test

NSLog(@"%@",[self suffixNumber:@100]);     // 100
NSLog(@"%@",[self suffixNumber:@1000]);    //1K
NSLog(@"%@",[self suffixNumber:@10345]);   //10.3K
NSLog(@"%@",[self suffixNumber:@10012]);   //10K
NSLog(@"%@",[self suffixNumber:@123456]);  //123.5K
NSLog(@"%@",[self suffixNumber:@4384324]); //4.4M
NSLog(@"%@",[self suffixNumber:@10000000]) //10M

InformationsquelleAutor der Antwort Phan Van Linh

Aktualisierte Antwort für die zügige Umsetzung

extension Int {
    func abbreviateNumber() -> String {
        func floatToString(val: Float) -> String {
            var ret: NSString = NSString(format: "%.1f", val)

            let c = ret.characterAtIndex(ret.length - 1)

            if c == 46 {
                ret = ret.substringToIndex(ret.length - 1)
            }

            return ret as String
        }

        var abbrevNum = ""
        var num: Float = Float(self)

        if num >= 1000 {
            var abbrev = ["K","M","B"]

            for var i = abbrev.count-1; i >= 0; i-- {
                let sizeInt = pow(Double(10), Double((i+1)*3))
                let size = Float(sizeInt)

                if size <= num {
                    num = num/size
                    var numStr: String = floatToString(num)
                    if numStr.hasSuffix(".0") {
                        let startIndex = numStr.startIndex.advancedBy(0)
                        let endIndex = numStr.endIndex.advancedBy(-2)
                        let range = startIndex..<endIndex
                        numStr = numStr.substringWithRange( range )
                    }

                    let suffix = abbrev[i]
                    abbrevNum = numStr+suffix
                }
            }
        } else {
            abbrevNum = "\(num)"
            let startIndex = abbrevNum.startIndex.advancedBy(0)
            let endIndex = abbrevNum.endIndex.advancedBy(-2)
            let range = startIndex..<endIndex
            abbrevNum = abbrevNum.substringWithRange( range )
        }

        return abbrevNum
    }
}

InformationsquelleAutor der Antwort Aadi007

Hier ist eine aktualisierte version von Luca entschied sich Iaco ' s Antwort, das funktioniert mit Swift 4

func suffixNumber(number: NSNumber) -> String {
    var num:Double = number.doubleValue
    let sign = ((num < 0) ? "-" : "" )
    num = fabs(num)
    if (num < 1000.0) {
        return "\(sign)\(num)"
    }

    let exp: Int = Int(log10(num) / 3.0)
    let units: [String] = ["K","M","G","T","P","E"]
    let roundedNum: Double = round(10 * num / pow(1000.0,Double(exp))) / 10

    return "\(sign)\(roundedNum)\(units[exp-1])";
}

InformationsquelleAutor der Antwort Josh

extension Int {
    func abbreviateNumber() -> String {
        func floatToString(val: Float) -> String {
            var ret: NSString = NSString(format: "%.1f", val)

            var c = ret.characterAtIndex(ret.length - 1)

            if c == 46 {
                ret = ret.substringToIndex(ret.length - 1)
            }

            return ret as String
        }

        var abbrevNum = ""
        var num: Float = Float(self)

        if num >= 1000 {
            var abbrev = ["K","M","B"]

            for var i = abbrev.count-1; i >= 0; i-- {
                var sizeInt = pow(Double(10), Double((i+1)*3))
                var size = Float(sizeInt)

                if size <= num {
                    num = num/size
                    var numStr: String = floatToString(num)
                    if numStr.hasSuffix(".0") {
                        numStr = numStr.substringToIndex(advance(numStr.startIndex,count(numStr)-2))
                    }

                    var suffix = abbrev[i]
                    abbrevNum = numStr+suffix
                }
            }
        } else {
            abbrevNum = "\(num)"
            if abbrevNum.hasSuffix(".0") {
                abbrevNum = abbrevNum.substringToIndex(advance(abbrevNum.startIndex, count(abbrevNum)-2))
            }
        }

        return abbrevNum
    }
}

InformationsquelleAutor der Antwort Zoyt

1

Wenn Sie daran interessiert sind, Formatierungs-bytes zählen, wird in diesem Artikel von Mattt Thompson zeigt, wie Sie mit iOS/OSX builtin NSByteCountFormatter

Gibt es auch builtin-Formatierer für Energie mass Länge und ein paar andere.

Die crux ist, dass für die meisten gängigen Einheiten, die Sie nicht brauchen, um zu schreiben von benutzerdefiniertem code, Apple hat bereits die mühsame Arbeit für Sie. Überprüfen Sie Ihre online-Referenz für NS[SomeUnit] - Formatierer, z.B. MKDistanceFormatterNSDateIntervalFormatter oder NSDateFormatter usw ...

InformationsquelleAutor der Antwort verec

Ich verwendet gbitaudeau Antwort, um dieses Ziel-C Kategorie der NSNumberFormatter, die ich verwenden in unserem Projekt (Vero.co). Die NSNumberFormatter Beispiel hier nur einmal erstellt für das gesamte Projekt.

@implementation NSNumberFormatter (Abbreviation)
+ (NSString*) abbreviatedStringFromNumber:(NSNumber*) number
{
    static dispatch_once_t pred;
    static NSNumberFormatter* __abbrFormatter = nil;
    static NSArray<NSDictionary*> * __abbreviations = nil;

    dispatch_once(&pred, ^{
        __abbrFormatter = [[NSNumberFormatter alloc] init];
        __abbrFormatter.numberStyle = NSNumberFormatterDecimalStyle;
        __abbrFormatter.usesGroupingSeparator = YES;
        __abbrFormatter.allowsFloats = YES;
        __abbrFormatter.minimumIntegerDigits = 1;
        __abbrFormatter.minimumFractionDigits = 0;
        __abbrFormatter.maximumFractionDigits = 2;

        __abbreviations = @[@{@"threshold":@(0.0), @"divisor":@(1.0), @"suffix":@""},
                        @{@"threshold":@(1000.0), @"divisor":@(1000.0), @"suffix":@"K"},
                        @{@"threshold":@(1000000.0), @"divisor":@(1000000.0), @"suffix":@"M"}];
    });

    double startValue = ABS([number doubleValue]);
    NSDictionary* abbreviation = __abbreviations[0];
    for (NSDictionary* tmpAbbr in __abbreviations)
    {
        if (startValue < [tmpAbbr[@"threshold"] doubleValue])
        {
            break;
        }
        abbreviation = tmpAbbr;
    }

    double value = [number doubleValue] / [abbreviation[@"divisor"] doubleValue];
    [__abbrFormatter setLocale:[NSLocale currentLocale]]; //user might change locale while the app is sleeping
    [__abbrFormatter setPositiveSuffix:abbreviation[@"suffix"]];
    [__abbrFormatter setNegativeSuffix:abbreviation[@"suffix"]];

    return [__abbrFormatter stringFromNumber:@(value)];
}
@end

Können Sie nun nennen mag

[NSNumberFormatter abbreviatedStringFromNumber:@(N)];

InformationsquelleAutor der Antwort user726522

Die folgende Methode verarbeitet sowohl positive und negative zahlen im Gegensatz zu den meisten der Lösungen hier.

Funktioniert es sogar für Währungen sowie.

BOOL isCurrency = YES; //Make it YES /NO depending upon weather your input value belongs to a revenue figure or a normal value.
double value = XXX ; //where 'XXX' is your input value

NSString *formattedValue = @"";

int decimalPlaces = 1; //number of decimal places (precision) that you want.
float multiplier;

//Enumerate number abbreviations
NSArray *abbrevations = @[@"", @"k", @"m", @"b", @"t" ];

//Go through the array backwards, so we do the largest first
int index;
for (index = abbrevations.count-1; index >= 0; index--) {

    multiplier = pow(10, decimalPlaces);

    //Convert array index to "1000", "1000000", etc
    double size = pow(10, index*3); 

    //If the number is bigger or equal do the abbreviation
    if(size <= fabs(round(value)))
    {
        //Here, we multiply by multiplier, round, and then divide by multiplier.
        //This gives us nice rounding to a particular decimal place.
        value = round(value * multiplier / size) / multiplier;


        //We are done... stop
        break;
    }
}

if (index<0)
{
    //Note: - To handle special case where x is our input number,  -0.5 > x < 0.5
    value = 0;
    index++;
}

NSString *stringFormat = nil;
//Add the letter for the abbreviation
if (isCurrency) 
{
    if (value >=0)
    {
        stringFormat = [NSString stringWithFormat:@"$%%.%0df%@", decimalPlaces, abbrevations[index]];
    }
    else
    {
        //Note: - To take care of extra logic where '$' symbol comes after '-' symbol for negative currency.
        stringFormat = [NSString stringWithFormat:@"-$%%.%df%@", decimalPlaces, abbrevations[index]];
        value = -value;
    }
}
else
{
    stringFormat = [NSString stringWithFormat:@"%%.%0df%@", decimalPlaces, abbrevations[index]];
}

formattedValue = [NSString stringWithFormat:stringFormat, value];

Ausgabe ist als unten

In Currency mode

'999' ---- '$999.0' 
'999.9' ---- '$1.0k' 
'999999.9' ---- '$1.0m' 
'-1000.1' ---- '-$1.0k' 
'-0.9' ---- '-$0.9' 

In Number mode

'999' ---- '999.0' 
'999.9' ---- '1.0k' 
'1' ---- '1.0' 
'9999' ---- '10.0k' 
'99999.89999999999' ---- '100.0k' 
'999999.9' ---- '1.0m' 
'-1' ---- '-1.0' 
'-1000.1' ---- '-1.0k' 
'5109999' ---- '5.1m' 
'-5109999' ---- '-5.1m' 
'999999999.9' ---- '1.0b' 
'0.1' ---- '0.0' 
'0' ---- '0.0' 
'-0.1' ---- '0.0' 
'-0.9' ---- '-0.9'

Ich habe die oben genannte Methode basiert auf der @Kyle Begeman die ursprüngliche inspiration von den freigegebenen link von @Pandiyan Cool.
Dank @Jeff B für den ersten code in Javascript über den folgenden link. Gibt es eine Möglichkeit, um Runde zahlen in einen reader-freundliches format? (z.B. $1.1 k)

InformationsquelleAutor der Antwort Rajesh

Swift 2.2 als Doppel-extension:

extension Double {

var suffixNumber : String {

    get {

        var num = self

        let sign = ((num < 0) ? "-" : "" )

        num = fabs(num)

        if (num < 1000.0){
            return "\(sign)\(num)"
        }

        let exp:Int = Int(log10(num) / 3.0 )

        let units:[String] = ["K","M","G","T","P","E"]

        let roundedNum = round(10 * num / pow(1000.0,Double(exp))) / 10

        return "\(sign)\(roundedNum)\(units[exp-1])"
    }
}
}

InformationsquelleAutor der Antwort Bobj-C

Swift-4 Doble extension - Dies funktioniert in allen Fällen.

extension Double {

  //Formatting double value to k and M
  //1000 = 1k
  //1100 = 1.1k
  //15000 = 15k
  //115000 = 115k
  //1000000 = 1m
  func formatPoints() -> String{
        let thousandNum = self/1000
        let millionNum = self/1000000
        if self >= 1000 && self < 1000000{
            if(floor(thousandNum) == thousandNum){
                return ("\(Int(thousandNum))k").replacingOccurrences(of: ".0", with: "")
            }
            return("\(thousandNum.roundTo(places: 1))k").replacingOccurrences(of: ".0", with: "")
        }
        if self > 1000000{
            if(floor(millionNum) == millionNum){
                return("\(Int(thousandNum))k").replacingOccurrences(of: ".0", with: "")
            }
            return ("\(millionNum.roundTo(places: 1))M").replacingOccurrences(of: ".0", with: "")
        }
        else{
            if(floor(self) == self){
                return ("\(Int(self))")
            }
            return ("\(self)")
        }
    }

    ///Returns rounded value for passed places
    ///
    ///- parameter places: Pass number of digit for rounded value off after decimal
    ///
    ///- returns: Returns rounded value with passed places
    func roundTo(places:Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return (self * divisor).rounded() / divisor
    }
}

iOS konvertiert große Zahlen in kleinere Formate

InformationsquelleAutor der Antwort KiranJasvanee

Swift-4.0-version von Phan Van Linh Antwort

private static let suffix = ["", "K", "M", "B", "T", "P", "E"]

public static func formatNumber(_ number: Double) -> String{
   var index = 0
   var value = number
   while((value / 1000) >= 1){
       value = value / 1000
       index += 1
   }
   return String(format: "%.1f%@", value, suffix[index])
}

InformationsquelleAutor der Antwort Bassem Qoulta

-1

Warum macht Ihr Jungs es zu bekommen so schwierig?

kann es so einfach:

-(NSString *)friendlyNumber:(long long)num{

    NSString *stringNumber;

    if (num < 1000) {
        stringNumber = [NSString stringWithFormat:@"%lld", num];

    }else if(num < 1000000){
        float newNumber = floor(num / 100) / 10.0;
        stringNumber = [NSString stringWithFormat:@"%.1fK", newNumber];

    }else{
        float newNumber = floor(num / 100000) / 10.0;
        stringNumber = [NSString stringWithFormat:@"%.1fM", newNumber];
    }
    return stringNumber;
}

InformationsquelleAutor der Antwort Leo Cavalcante

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.