iOS convertir un grand nombre de plus petit format

-(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)]];
}

exemple d'utilisation

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

[Mise à jour]

Swift version ci-dessous:

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])";
}

exemple d'utilisation

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

Espère que cela aide

Voici ma version ! Merci pour les réponses précédentes.
Les objectifs de cette version est :

• Avoir un meilleur seuil de contrôle parce que le petit nombre de détails sont plus importants que le très grand nombre de détails
• Utiliser autant que possible NSNumberFormatter pour éviter les problèmes de localisation (comme la virgule au lieu du point en français)
• Éviter le ".0" et bien arrondir les nombres, qui peut être personnaliser à l'aide de NSNumberFormatterRoundingMode

Vous pouvez utiliser tous les merveilleux NSNumberFormatter options pour répondre à vos besoins, voir NSNumberFormatter De Référence De Classe

Le 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 ())")
}

Résultat :

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

J'ai rencontré un problème similaire essayant de formater les valeurs de l'axe y dans Shinobi Graphiques. Il requis à l'aide d'un NSNumberFormatter, donc j'ai finalement venu avec cette

NSNumberFormatter *numFormatter = [[NSNumberFormatter alloc] init];
[numFormatter setPositiveFormat:@"0M"];
[numFormatter setMultiplier:[NSNumber numberWithDouble:0.000001]];

Pour obtenir une valeur mise en forme

NSString *formattedNumber = [numFormatter stringFromNumber:[NSNumber numberWithInteger:4000000]]; //@"4M"

Cette solution ne permet pas d'avoir l'arrondissement inclus, mais si vous (ou quelqu'un d'autre) juste besoin de quelque chose de simple, cela pourrait fonctionner. Si vous avez besoin par milliers, au lieu d'en millions de dollars, vous changez le "M" à un "K" dans le setPostiveFormat méthode, et de changer le NSNumber valeur du coefficient multiplicateur à 0,001 .

Après avoir essayé un couple de ces solutions, Luca laco semble avoir la plus proche, mais j'ai fait quelques modifications à sa méthode afin d'avoir plus de contrôle sur la façon dont beaucoup de chiffres apparaît (c'est à dire si vous voulez 120.3 K à être plus court, vous pouvez le limiter à 120K). En outre, j'ai ajouté une étape supplémentaire, ce qui assure un certain nombre comme 999,999 n'apparaît pas comme 1000.0 K, au lieu de 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;
}

Swift version

Traduction directe de l'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)

Swift-4 Doble extension - Ce qui fonctionne bien dans tous les cas.

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

Ici est une version mise à jour de Luca de Iaco réponse qui fonctionne avec 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])";
}

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

J'ai utilisé gbitaudeau la réponse à faire de cet Objectif de la catégorie C de NSNumberFormatter, qui-je l'utiliser dans notre projet (Vero.co). Le NSNumberFormatter exemple, ici créé qu'une seule fois pour l'ensemble du projet.

@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

Maintenant, vous pouvez l'appeler comme ça

[NSNumberFormatter abbreviatedStringFromNumber:@(N)];

Swift 2.2 Double 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])"
}
}
}

Pourquoi les gars, vous ne obtenir ce si difficile?

il peut être aussi simple que cela:

-(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;
}