Konwersja wielkości pliku w bajtach na ciąg czytelny dla człowieka


239

Korzystam z tej funkcji, aby przekonwertować rozmiar pliku w bajtach na rozmiar pliku czytelny dla człowieka:

function getReadableFileSizeString(fileSizeInBytes) {
    var i = -1;
    var byteUnits = [' kB', ' MB', ' GB', ' TB', 'PB', 'EB', 'ZB', 'YB'];
    do {
        fileSizeInBytes = fileSizeInBytes / 1024;
        i++;
    } while (fileSizeInBytes > 1024);

    return Math.max(fileSizeInBytes, 0.1).toFixed(1) + byteUnits[i];
};

Wydaje się jednak, że nie jest to w 100% dokładne. Na przykład:

getReadableFileSizeString(1551859712); // output is "1.4 GB"

Nie powinno tak być "1.5 GB"? Wygląda na to, że podział przez 1024 traci precyzję. Czy całkowicie coś rozumiem, czy jest na to lepszy sposób?


3
getReadableFileSizeString (0); zwraca 0,1 kb; p
Daniel Magnusson

2
Dlaczego powinna wynosić 1,5? To, 1.445281982421875co poprawnie zaokrągla w dół do 1,4.
mpen

1
1551859712 / (1024 ^ 3) = 1.445281982421875 co jest poprawne!
HM

2
Uwielbiam to, co dodałeś YB. Wątpliwy, każdy dostanie nawet 1 YB za swoją DB. Kosztuje 100 bilionów dolarów !
guyarad,

4
@ guyarad - jest słynne zdjęcie dysku twardego o pojemności 5 MB sprzed 50 lat (był wielkości pokoju i ważył około tony). jestem pewien, że wtedy nawet nie marzyli o GB i TB i patrzcie, gdzie jesteśmy dzisiaj ... nigdy nie mów nigdy ;-)
TheCuBeMan

Odpowiedzi:


45

Zależy to od tego, czy chcesz użyć konwencji binarnej czy dziesiętnej.

Na przykład pamięć RAM jest zawsze mierzona w systemie binarnym, więc wyrażenie 1551859712 jako ~ 1,4GiB byłoby poprawne.

Z drugiej strony producenci dysków twardych lubią używać dziesiętnych, więc nazwaliby to ~ 1,6 GB.

Aby się pomylić, dyskietki wykorzystują mieszankę dwóch systemów - ich 1 MB to w rzeczywistości 1024000 bajtów.


3
kolacja zabawna ;-) „Aby się pomylić, dyskietki używają mieszanki dwóch systemów - ich 1 MB to w rzeczywistości 1024000 bajtów”.
FranXho

prawda, rozmiary pamięci RAM są mierzone za pomocą jednostek IEC, rozmiary dysków za pomocą metryki .. istnieje izomorficzny moduł npm do konwersji obu: rozmiar bajtów
Lloyd

351

Oto jeden napisałem:

function humanFileSize(bytes, si=false, dp=1) {
  const thresh = si ? 1000 : 1024;

  if (Math.abs(bytes) < thresh) {
    return bytes + ' B';
  }

  const units = si 
    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] 
    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
  let u = -1;
  const r = 10**dp;

  do {
    bytes /= thresh;
    ++u;
  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);


  return bytes.toFixed(dp) + ' ' + units[u];
}


console.log(humanFileSize(5000, true))  // 5.0 kB
console.log(humanFileSize(5000, false))  // 4.9 KiB
console.log(humanFileSize(-10000000000000000000000000000))  // -8271.8 YiB
console.log(humanFileSize(999949, true))  // 999.9 kB
console.log(humanFileSize(999950, true))  // 1.0 MB
console.log(humanFileSize(999950, true, 2))  // 999.95 kB
console.log(humanFileSize(999500, true, 0))  // 1 MB


1
Dokonuję jednej korekty: oceniając próg, weź wartość bezwzględną. W ten sposób funkcja będzie obsługiwała wartości ujemne. Fajna funkcja! Dziękujemy za nieużywanie instrukcji zamiany !!
Aaron Blenkush

20
@AaronBlenkush: Kiedy miałbyś ujemny rozmiar pliku?
mpen

14
Właśnie skopiowałem twoją funkcję do Arkusza Google, którego używam, aby pokazać różnicę wielkości po operacji „czyszczenia”. Przed, Po i Różnice. Operacja czyszczenia spowodowała wzrost niektórych tabel bazy danych i zmniejszenie innych. Na przykład tabela A ma różnicę -1,95 MB, a tabela B ma różnicę 500 kB. Dlatego: pozytywne i negatywne :-)
Aaron Blenkush

Oto skompresowana wersja skryptu:function humanFileSize(B,i){var e=i?1e3:1024;if(Math.abs(B)<e)return B+" B";var a=i?["kB","MB","GB","TB","PB","EB","ZB","YB"]:["KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"],t=-1;do B/=e,++t;while(Math.abs(B)>=e&&t<a.length-1);return B.toFixed(1)+" "+a[t]}
RAnders00

1
@ RAnders00: Dzięki za zminimalizowaną wersję. Czy możesz mi jednak powiedzieć, dlaczego wstawiłeś dwa niewidoczne znaki Unicode U + 200C (ZERO WIDTH NON-JOINER) i U + 200B (ZERO WIDTH SPACE) po E często EiB ? Czy ma to być znak wodny, abyś mógł śledzić, kto używał tego kodu? Jeśli tak, uważam, że powinieneś był uczynić to przejrzystym w swoim poście.
Lewiatan

81

Kolejny przykład wykonania obliczeń

function humanFileSize(size) {
    var i = Math.floor( Math.log(size) / Math.log(1024) );
    return ( size / Math.pow(1024, i) ).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
};

8
wygląda na to, że nie obsługuje 0
Offirmo

4
Czy obsługuje czy nie 0? W końcu to z if (size == 0) {} else {} jest jeszcze bardziej eleganckie niż większość, jakie widziałem.
Rodrigo

13
Zmiana pierwszego wiersza var i = size == 0 ? 0 : Math.floor( Math.log(size) / Math.log(1024) );wydaje się załatwić sprawę, jeśli ma wartość 0. Zwróci „0 B”.
Gavin

Po prostu FYI; Wiem, że odpowiedzią jest zwykły JavaScript, ale jeśli ktoś nie chce go użyć w TypeScript, to nie działa (niepoprawnie wpisany, jak robisz, toFixeda potem robisz matematykę za pomocą łańcucha. Co robi * 1?
Frexuz

1
*1Zmienia typ danych z napisu na numer, więc dla wartości 1024można dostać 1 kBzamiast 1.00 kB. Możesz uszczęśliwić TypeScript, robiąc Number((size / Math.pow(1024, i)).toFixed(2))to samo.
Adrian T

38

Oto prototyp służący do konwersji liczby na czytelny ciąg zgodny z nowymi standardami międzynarodowymi.

Istnieją dwa sposoby przedstawiania dużych liczb: Możesz wyświetlić je w wielokrotnościach 1000 = 10 3 (podstawa 10) lub 1024 = 2 10 (podstawa 2). Jeśli dzielisz przez 1000, prawdopodobnie używasz nazw prefiksów SI, jeśli dzielisz przez 1024, prawdopodobnie używasz nazw prefiksów IEC. Problem zaczyna się od podzielenia przez 1024. Wiele aplikacji używa do tego nazw prefiksów SI, a niektóre używają nazw prefiksów IEC. Obecna sytuacja to bałagan. Jeśli widzisz nazwy prefiksów SI, nie wiesz, czy liczba jest podzielona przez 1000, czy 1024

https://wiki.ubuntu.com/UnitsPolicy

http://en.wikipedia.org/wiki/Template:Quantities_of_bytes

Object.defineProperty(Number.prototype,'fileSize',{value:function(a,b,c,d){
 return (a=a?[1e3,'k','B']:[1024,'K','iB'],b=Math,c=b.log,
 d=c(this)/c(a[0])|0,this/b.pow(a[0],d)).toFixed(2)
 +' '+(d?(a[1]+'MGTPEZY')[--d]+a[2]:'Bytes');
},writable:false,enumerable:false});

Ta funkcja nie zawiera loop, a więc jest prawdopodobnie szybsza niż niektóre inne funkcje.

Stosowanie:

Prefiks IEC

console.log((186457865).fileSize()); // default IEC (power 1024)
//177.82 MiB
//KiB,MiB,GiB,TiB,PiB,EiB,ZiB,YiB

Prefiks SI

console.log((186457865).fileSize(1)); //1,true for SI (power 1000)
//186.46 MB 
//kB,MB,GB,TB,PB,EB,ZB,YB

ustawiłem IEC jako domyślny, ponieważ zawsze korzystałem z trybu binarnego, aby obliczyć rozmiar pliku ... używając mocy 1024


Jeśli chcesz tylko jeden z nich w krótkiej funkcji oneliner:

SI

function fileSizeSI(a,b,c,d,e){
 return (b=Math,c=b.log,d=1e3,e=c(a)/c(d)|0,a/b.pow(d,e)).toFixed(2)
 +' '+(e?'kMGTPEZY'[--e]+'B':'Bytes')
}
//kB,MB,GB,TB,PB,EB,ZB,YB

IEC

function fileSizeIEC(a,b,c,d,e){
 return (b=Math,c=b.log,d=1024,e=c(a)/c(d)|0,a/b.pow(d,e)).toFixed(2)
 +' '+(e?'KMGTPEZY'[--e]+'iB':'Bytes')
}
//KiB,MiB,GiB,TiB,PiB,EiB,ZiB,YiB

Stosowanie:

console.log(fileSizeIEC(7412834521));

jeśli masz jakieś pytania dotyczące funkcji, po prostu zapytaj


bardzo ładny kompaktowy kod, ale osobiście dodałbym kilka dodatkowych znaków do kontroli miejsc dziesiętnych.
Orwellophile,

Cześć! W rzeczywistości kod jest taki, jak napisałem go po raz pierwszy w jsfiddle. W ostatnich latach nauczyłem się używać skrótów i bitów. Wolne urządzenia mobilne, powolny internet, mało miejsca ... dzięki temu zaoszczędziłem dużo czasu. Ale to nie wszystko, ogólna wydajność drastycznie wzrosła w każdej przeglądarce, a cały kod ładuje się znacznie szybciej ... Nie używam jquery, więc nie muszę ładować 100kb za każdym razem. Muszę też powiedzieć, że javascript piszę również w mikrokontrolerach, Smart TV, konsolach do gier. te mają ograniczoną przestrzeń (MCU), wydajność (SmartTV) i naturalnie czasami wolne połączenie (mobilne)
cocco

Powiedział, że mam nadzieję, że rozumiesz mój wybór. Wszystko, co mogę zrobić, to wyjaśnić, czego nie rozumiesz, a po drugiej stronie zawsze chętnie się uczę nowych rzeczy. Jeśli w moim kodzie jest coś, co może zwiększyć wydajność lub zaoszczędzić miejsce, cieszę się, że to słyszę.
cocco,

18
Minimalizacja powinna być częścią procesu kompilacji, a nie stylu kodowania. Żaden poważny programista nie użyje tego kodu z tego powodu, ponieważ czytanie i weryfikowanie poprawności zajmuje zbyt dużo czasu.
huysentruitw

1
Dla tych, którzy nie lubią oglądać „15.00 Bajtów”, możesz po prostu nieco zmodyfikować tę część:.toFixed(e ? 2 : 0)
Lukman

20
sizeOf = function (bytes) {
  if (bytes == 0) { return "0.00 B"; }
  var e = Math.floor(Math.log(bytes) / Math.log(1024));
  return (bytes/Math.pow(1024, e)).toFixed(2)+' '+' KMGTP'.charAt(e)+'B';
}

sizeOf (2054110009);
// => „1,91 GB”

sizeOf (7054110);
// => „6,73 MB”

sizeOf ((3 * 1024 * 1024));
// => „3,00 MB”


2
Jeśli chcesz pozbyć się dodatkowej przestrzeni dla bajtów, można wykorzystać przestrzeń zerową szerokość \u200b: '\u200bKMGTP'.
cdmckay

15

Rozwiązanie jako komponent ReactJS

Bytes = React.createClass({
    formatBytes() {
        var i = Math.floor(Math.log(this.props.bytes) / Math.log(1024));
        return !this.props.bytes && '0 Bytes' || (this.props.bytes / Math.pow(1024, i)).toFixed(2) + " " + ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'][i]
    },
    render () {
        return (
            <span>{ this.formatBytes() }</span>
        );
    }
});

AKTUALIZACJA Dla osób używających es6 tutaj jest wersja bezstanowa tego samego komponentu

const sufixes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
const getBytes = (bytes) => {
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  return !bytes && '0 Bytes' || (bytes / Math.pow(1024, i)).toFixed(2) + " " + sufixes[i];
};

const Bytes = ({ bytes }) => (<span>{ getBytes(bytes) }</span>);

Bytes.propTypes = {
  bytes: React.PropTypes.number,
};

1
Wielkie dzięki. Po prostu zapomniał „bajty” wewnątrz Math.log () w pierwszym wierszu getBytes funkcjonować
BaptWaels

Bardzo dobrze. W celu ujednoznacznienia iz notacją ES6 możesz użyć tego: return (! Bytes && '0 Bytes') || ${(bytes / (1024 ** i)).toFixed(2)} ${suffixes[i]};
Little Brain

12

Oparty na pomyśle Cocco , oto mniej zwarty - ale mam nadzieję, że bardziej wyczerpujący przykład.

<!DOCTYPE html>
<html>
<head>
<title>File info</title>

<script>
<!--
function fileSize(bytes) {
    var exp = Math.log(bytes) / Math.log(1024) | 0;
    var result = (bytes / Math.pow(1024, exp)).toFixed(2);

    return result + ' ' + (exp == 0 ? 'bytes': 'KMGTPEZY'[exp - 1] + 'B');
}

function info(input) {
    input.nextElementSibling.textContent = fileSize(input.files[0].size);
} 
-->
</script>
</head>

<body>
<label for="upload-file"> File: </label>
<input id="upload-file" type="file" onchange="info(this)">
<div></div>
</body>
</html> 

8

Chciałem zachowania „menedżera plików” (np. Eksploratora Windows), w którym liczba miejsc dziesiętnych jest proporcjonalna do wielkości liczbowej. Niby żadna inna odpowiedź tego nie robi.

function humanFileSize(size) {
    if (size < 1024) return size + ' B'
    let i = Math.floor(Math.log(size) / Math.log(1024))
    let num = (size / Math.pow(1024, i))
    let round = Math.round(num)
    num = round < 10 ? num.toFixed(2) : round < 100 ? num.toFixed(1) : round
    return `${num} ${'KMGTPEZY'[i-1]}B`
}

Oto kilka przykładów:

humanFileSize(0)          // "0 B"
humanFileSize(1023)       // "1023 B"
humanFileSize(1024)       // "1.00 KB"
humanFileSize(10240)      // "10.0 KB"
humanFileSize(102400)     // "100 KB"
humanFileSize(1024000)    // "1000 KB"
humanFileSize(12345678)   // "11.8 MB"
humanFileSize(1234567890) // "1.15 GB"

użycie toFixed konwertuje go na ciąg, więc twoja runda jest albo ciągiem, albo liczbą. jest to zła praktyka, możesz łatwo przekonwertować go z powrotem na liczbę:+num.tofixed(2)
Vincent Duprez

Nie .toPrecision(3)obejmuje wszystkich tych przypadków? Och .. Chyba nie obejmuje od 1000 do 1023. Bummer.
mpen

7

Kolejny przykład podobny do tych tutaj

function fileSize(b) {
    var u = 0, s=1024;
    while (b >= s || -b >= s) {
        b /= s;
        u++;
    }
    return (u ? b.toFixed(1) + ' ' : b) + ' KMGTPEZY'[u] + 'B';
}

Mierzy pomijalnie lepszą wydajność niż inne z podobnymi funkcjami.


Zapewnia to lepszą wydajność niż niektóre inne odpowiedzi. Używam tego. Niektóre inne sprawiły, że moje karty Chrome zawiesiły się i zajmowały 99,9% procesora podczas okresowych obliczeń.
Nir Lanka,

5

Oto moje - działa również na naprawdę duże pliki -_-

function formatFileSize(size)
{
    var sizes = [' Bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'];
    for (var i = 1; i < sizes.length; i++)
    {
        if (size < Math.pow(1024, i)) return (Math.round((size/Math.pow(1024, i-1))*100)/100) + sizes[i-1];
    }
    return size;
}

Łączy w sobie wydajność zarówno pętli, jak i potęgowania, a jednocześnie jest dość trudna do odczytania. Naprawdę nie widzę sensu.
spectras

2
Nie używaj go wtedy. To tylko procesor klienta, który jest używany, więc kogo to obchodzi;)
fiffy

2
@fiffy Cóż, procesor klienta też jest cenny, szczególnie na urządzeniach mobilnych i przy złożonych aplikacjach. :)
Raito,

5

Oparty na odpowiedzi Cocco, ale nieco pozbawiony zera (szczerze mówiąc, te, z którymi czułem się komfortowo, zostały / zostały dodane) i nie pokazuje końcowych zer, ale nadal obsługuje 0, mam nadzieję, że będą przydatne dla innych:

function fileSizeSI(size) {
    var e = (Math.log(size) / Math.log(1e3)) | 0;
    return +(size / Math.pow(1e3, e)).toFixed(2) + ' ' + ('kMGTPEZY'[e - 1] || '') + 'B';
}


// test:
document.write([0, 23, 4322, 324232132, 22e9, 64.22e12, 76.22e15, 64.66e18, 77.11e21, 22e24].map(fileSizeSI).join('<br>'));


4
1551859712 / 1024 = 1515488
1515488 / 1024 = 1479.96875
1479.96875 / 1024 = 1.44528198242188

Twoje rozwiązanie jest poprawne. Ważną rzeczą do zrozumienia jest to, że aby dostać się 1551859712do 1.5, musisz wykonać podział przez 1000, ale bajty są liczone w liczbach binarnych do dziesiętnych po 1024, dlatego wartość Gigabajtów jest mniejsza.


@Eli ... tak, wygląda na to. Wydaje mi się, że spodziewałem się „1.5” od 1551859712, ale to oznaczałoby, że jestem w systemie dziesiętnym, a nie binarnym.
Hristo

3

Uważam, że odpowiedź @ cocco jest interesująca, ale miałem z nią następujące problemy:

  1. Nie modyfikuj typów rodzimych ani typów, których nie posiadasz
  2. Napisz czysty, czytelny kod dla ludzi, pozwól programom optymalizującym zoptymalizować kod dla maszyn
  3. (Bonus dla użytkowników TypeScript) Nie działa dobrze z TypeScript

Maszynopis:

 /**
 * Describes manner by which a quantity of bytes will be formatted.
 */
enum ByteFormat {
  /**
   * Use Base 10 (1 kB = 1000 bytes). Recommended for sizes of files on disk, disk sizes, bandwidth.
   */
  SI = 0,
  /**
   * Use Base 2 (1 KiB = 1024 bytes). Recommended for RAM size, size of files on disk.
   */
  IEC = 1
}

/**
 * Returns a human-readable representation of a quantity of bytes in the most reasonable unit of magnitude.
 * @example
 * formatBytes(0) // returns "0 bytes"
 * formatBytes(1) // returns "1 byte"
 * formatBytes(1024, ByteFormat.IEC) // returns "1 KiB"
 * formatBytes(1024, ByteFormat.SI) // returns "1.02 kB"
 * @param size The size in bytes.
 * @param format Format using SI (Base 10) or IEC (Base 2). Defaults to SI.
 * @returns A string describing the bytes in the most reasonable unit of magnitude.
 */
function formatBytes(
  value: number,
  format: ByteFormat = ByteFormat.SI
) {
  const [multiple, k, suffix] = (format === ByteFormat.SI
    ? [1000, 'k', 'B']
    : [1024, 'K', 'iB']) as [number, string, string]
  // tslint:disable-next-line: no-bitwise
  const exp = (Math.log(value) / Math.log(multiple)) | 0
  // or, if you'd prefer not to use bitwise expressions or disabling tslint rules, remove the line above and use the following:
  // const exp = value === 0 ? 0 : Math.floor(Math.log(value) / Math.log(multiple)) 
  const size = Number((value / Math.pow(multiple, exp)).toFixed(2))
  return (
    size +
    ' ' +
    (exp 
       ? (k + 'MGTPEZY')[exp - 1] + suffix 
       : 'byte' + (size !== 1 ? 's' : ''))
  )
}

// example
[0, 1, 1024, Math.pow(1024, 2), Math.floor(Math.pow(1024, 2) * 2.34), Math.pow(1024, 3), Math.floor(Math.pow(1024, 3) * 892.2)].forEach(size => {
  console.log('Bytes: ' + size)
  console.log('SI size: ' + formatBytes(size))
  console.log('IEC size: ' + formatBytes(size, 1) + '\n')
});

1

To jest poprawa rozmiaru odpowiedzi mpen

function humanFileSize(bytes, si=false) {
  let u, b=bytes, t= si ? 1000 : 1024;     
  ['', si?'k':'K', ...'MGTPEZY'].find(x=> (u=x, b/=t, b**2<1));
  return `${u ? (t*b).toFixed(1) : bytes} ${u}${!si && u ? 'i':''}B`;    
}


0

Dla tych, którzy używają Angular, istnieje pakiet o nazwie, angular-pipesktóry ma potok do tego:

Plik

import { BytesPipe } from 'angular-pipes';

Stosowanie

{{ 150 | bytes }} <!-- 150 B -->
{{ 1024 | bytes }} <!-- 1 KB -->
{{ 1048576 | bytes }} <!-- 1 MB -->
{{ 1024 | bytes: 0 : 'KB' }} <!-- 1 MB -->
{{ 1073741824 | bytes }} <!-- 1 GB -->
{{ 1099511627776 | bytes }} <!-- 1 TB -->
{{ 1073741824 | bytes : 0 : 'B' : 'MB' }} <!-- 1024 MB -->

Link do dokumentów .


0

Moja odpowiedź może się spóźnić, ale chyba komuś to pomoże.

Prefiks metryczny:

/**
 * Format file size in metric prefix
 * @param fileSize
 * @returns {string}
 */
const formatFileSizeMetric = (fileSize) => {
  let size = Math.abs(fileSize);

  if (Number.isNaN(size)) {
    return 'Invalid file size';
  }

  if (size === 0) {
    return '0 bytes';
  }

  const units = ['bytes', 'kB', 'MB', 'GB', 'TB'];
  let quotient = Math.floor(Math.log10(size) / 3);
  quotient = quotient < units.length ? quotient : units.length - 1;
  size /= (1000 ** quotient);

  return `${+size.toFixed(2)} ${units[quotient]}`;
};

Prefiks binarny:

/**
 * Format file size in binary prefix
 * @param fileSize
 * @returns {string}
 */
const formatFileSizeBinary = (fileSize) => {
  let size = Math.abs(fileSize);

  if (Number.isNaN(size)) {
    return 'Invalid file size';
  }

  if (size === 0) {
    return '0 bytes';
  }

  const units = ['bytes', 'kiB', 'MiB', 'GiB', 'TiB'];
  let quotient = Math.floor(Math.log2(size) / 10);
  quotient = quotient < units.length ? quotient : units.length - 1;
  size /= (1024 ** quotient);

  return `${+size.toFixed(2)} ${units[quotient]}`;
};

Przykłady:

// Metrics prefix
formatFileSizeMetric(0)      // 0 bytes
formatFileSizeMetric(-1)     // 1 bytes
formatFileSizeMetric(100)    // 100 bytes
formatFileSizeMetric(1000)   // 1 kB
formatFileSizeMetric(10**5)  // 10 kB
formatFileSizeMetric(10**6)  // 1 MB
formatFileSizeMetric(10**9)  // 1GB
formatFileSizeMetric(10**12) // 1 TB
formatFileSizeMetric(10**15) // 1000 TB

// Binary prefix
formatFileSizeBinary(0)     // 0 bytes
formatFileSizeBinary(-1)    // 1 bytes
formatFileSizeBinary(1024)  // 1 kiB
formatFileSizeBinary(2048)  // 2 kiB
formatFileSizeBinary(2**20) // 1 MiB
formatFileSizeBinary(2**30) // 1 GiB
formatFileSizeBinary(2**40) // 1 TiB
formatFileSizeBinary(2**50) // 1024 TiB

-1

niech bajty = 1024 * 10 * 10 * 10;

console.log (getReadableFileSizeString (bytes))

zwróci 1000,0Кб zamiast 1MB

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.