반응형
JavaScript에서 바이트 단위의 크기를 KB, MB, GB로 변환하는 올바른 방법
이제 JavaScript를 사용하여 이 크기를 사람이 읽을 수 있는 크기로 변환합니다.이 코드를 다음과 같은 JavaScript로 변환하려고 했습니다.
function formatSizeUnits(bytes){
if (bytes >= 1073741824) { bytes = (bytes / 1073741824).toFixed(2) + " GB"; }
else if (bytes >= 1048576) { bytes = (bytes / 1048576).toFixed(2) + " MB"; }
else if (bytes >= 1024) { bytes = (bytes / 1024).toFixed(2) + " KB"; }
else if (bytes > 1) { bytes = bytes + " bytes"; }
else if (bytes == 1) { bytes = bytes + " byte"; }
else { bytes = "0 bytes"; }
return bytes;
}
이게 올바른 방법인가요?더 쉬운 방법은 없나요?
출처: (출처)
function bytesToSize(bytes) {
var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
if (bytes == 0) return '0 Byte';
var i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
return Math.round(bytes / Math.pow(1024, i), 2) + ' ' + sizes[i];
}
주의: 이것은 오리지널 코드입니다.아래의 수정 버전을 사용해 주세요.
(커뮤니티별) 고정판, 미확정판 및 ES6 편집판
function formatBytes(bytes, decimals = 2) {
if (bytes === 0) return '0 Bytes';
const k = 1024;
const dm = decimals < 0 ? 0 : decimals;
const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
const i = Math.floor(Math.log(bytes) / Math.log(k));
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}
고정 버전 (StackOverflow 커뮤니티에 의해 JSCompress에 의해 최소화됨)
function formatBytes(a,b=2,k=1024){with(Math){let d=floor(log(a)/log(k));return 0==a?"0 Bytes":parseFloat((a/pow(k,d)).toFixed(max(0,b)))+" "+["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"][d]}}
사용방법:
// formatBytes(bytes,decimals)
formatBytes(1024); // 1 KB
formatBytes('1024'); // 1 KB
formatBytes(1234); // 1.21 KB
formatBytes(1234, 3); // 1.205 KB
데모/소스:
function formatBytes(bytes, decimals = 2) {
if (bytes === 0) return '0 Bytes';
const k = 1024;
const dm = decimals < 0 ? 0 : decimals;
const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
const i = Math.floor(Math.log(bytes) / Math.log(k));
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}
// ** Demo code **
var p = document.querySelector('p'),
input = document.querySelector('input');
function setText(v){
p.innerHTML = formatBytes(v);
}
// bind 'input' event
input.addEventListener('input', function(){
setText( this.value )
})
// set initial text
setText(input.value);<input type="text" value="1000">
<p></p>PS : 변경k = 1000또는sizes = ["..."]원하는 대로(비트 또는 바이트)
이 솔루션에는 소수점 및 10자리 숫자가 포함되어 있습니다(단위는 10KB 이상일 경우).
const units = ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
function niceBytes(x){
let l = 0, n = parseInt(x, 10) || 0;
while(n >= 1024 && ++l){
n = n/1024;
}
return(n.toFixed(n < 10 && l > 0 ? 1 : 0) + ' ' + units[l]);
}
결과:
niceBytes(435) // 435 bytes
niceBytes(3398) // 3.3 KB
niceBytes(490398) // 479 KB
niceBytes(6544528) // 6.2 MB
niceBytes(23483023) // 22 MB
niceBytes(3984578493) // 3.7 GB
niceBytes(30498505889) // 28 GB
niceBytes(9485039485039445) // 8.4 PB
function formatBytes(bytes) {
var marker = 1024; // Change to 1000 if required
var decimal = 3; // Change as required
var kiloBytes = marker; // One Kilobyte is 1024 bytes
var megaBytes = marker * marker; // One MB is 1024 KB
var gigaBytes = marker * marker * marker; // One GB is 1024 MB
var teraBytes = marker * marker * marker * marker; // One TB is 1024 GB
// return bytes if less than a KB
if(bytes < kiloBytes) return bytes + " Bytes";
// return KB if less than a MB
else if(bytes < megaBytes) return(bytes / kiloBytes).toFixed(decimal) + " KB";
// return MB if less than a GB
else if(bytes < gigaBytes) return(bytes / megaBytes).toFixed(decimal) + " MB";
// return GB if less than a TB
else return(bytes / gigaBytes).toFixed(decimal) + " GB";
}
여기 라이너가 하나 있습니다.
val => ['Bytes','Kb','Mb','Gb','Tb'][Math.floor(Math.log2(val)/10)]
또는 다음과 같은 경우도 있습니다.
v => 'BKMGT'[~~(Math.log2(v)/10)]
카운트 포함:
function shortenBytes(n) {
const k = n > 0 ? Math.floor((Math.log2(n)/10)) : 0;
const rank = (k > 0 ? 'KMGT'[k - 1] : '') + 'b';
const count = Math.floor(n / Math.pow(1024, k));
return count + rank;
}
바이트와 관련된 크기를 나타내는 실제 방법은 SI 단위(10^3) 또는 IEC 단위(2^10) 두 가지가 있습니다.JEDEC도 있습니다만, 그 방법은 애매하고 혼란스럽습니다.다른 예에서는 kB가 아닌 KB를 사용하여 1킬로바이트를 나타내는 등의 오류가 있다는 것을 알게 되었기 때문에 현재 허용되는 측정 단위 범위를 사용하여 각각의 경우를 해결하는 함수를 작성하기로 했습니다.
마지막에는 (적어도 내 눈에는) 숫자가 조금 더 보기 좋게 보이는 포맷 비트가 있습니다. 만약 당신의 목적에 맞지 않으면 그 포맷을 삭제해도 됩니다.
즐거운 시간 되세요.
// pBytes: the size in bytes to be converted.
// pUnits: 'si'|'iec' si units means the order of magnitude is 10^3, iec uses 2^10
function prettyNumber(pBytes, pUnits) {
// Handle some special cases
if(pBytes == 0) return '0 Bytes';
if(pBytes == 1) return '1 Byte';
if(pBytes == -1) return '-1 Byte';
var bytes = Math.abs(pBytes)
if(pUnits && pUnits.toLowerCase() && pUnits.toLowerCase() == 'si') {
// SI units use the Metric representation based on 10^3 as a order of magnitude
var orderOfMagnitude = Math.pow(10, 3);
var abbreviations = ['Bytes', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
} else {
// IEC units use 2^10 as an order of magnitude
var orderOfMagnitude = Math.pow(2, 10);
var abbreviations = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
}
var i = Math.floor(Math.log(bytes) / Math.log(orderOfMagnitude));
var result = (bytes / Math.pow(orderOfMagnitude, i));
// This will get the sign right
if(pBytes < 0) {
result *= -1;
}
// This bit here is purely for show. it drops the percision on numbers greater than 100 before the units.
// it also always shows the full number of bytes if bytes is the unit.
if(result >= 99.995 || i==0) {
return result.toFixed(0) + ' ' + abbreviations[i];
} else {
return result.toFixed(2) + ' ' + abbreviations[i];
}
}
filesizejs 라이브러리를 사용할 수 있습니다.
바이트를 가장 논리적인 크기(KB, MB 또는 GB)로 포맷하는 유틸리티 방식
Number.prototype.formatBytes = function() {
var units = ['B', 'KB', 'MB', 'GB', 'TB'],
bytes = this,
i;
for (i = 0; bytes >= 1024 && i < 4; i++) {
bytes /= 1024;
}
return bytes.toFixed(2) + units[i];
}
let a = 235678; //bytes
console.log(a.formatBytes()); //result is 230.15KB난 이거면 돼.
bytesForHuman(bytes) {
let units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
let i = 0
for (i; bytes > 1024; i++) {
bytes /= 1024;
}
return bytes.toFixed(1) + ' ' + units[i]
}
@zayar의 코드를 약간 수정했습니다.결과에 소수점 수를 나타내는 추가 파라미터를 포함하도록 응답합니다(또한 소수점이 0인 경우 15.00KB와 같은 결과를 표시할 필요가 없습니다.대신 15KB로 충분하기 때문에 결과값을 로 묶었습니다.parseFloat())
bytesForHuman(bytes, decimals = 2) {
let units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
let i = 0
for (i; bytes > 1024; i++) {
bytes /= 1024;
}
return parseFloat(bytes.toFixed(decimals)) + ' ' + units[i]
}
비트 연산을 사용하는 것이 더 나은 해결책이 될 것입니다.이거 드셔보세요
function formatSizeUnits(bytes)
{
if ( ( bytes >> 30 ) & 0x3FF )
bytes = ( bytes >>> 30 ) + '.' + ( bytes & (3*0x3FF )) + 'GB' ;
else if ( ( bytes >> 20 ) & 0x3FF )
bytes = ( bytes >>> 20 ) + '.' + ( bytes & (2*0x3FF ) ) + 'MB' ;
else if ( ( bytes >> 10 ) & 0x3FF )
bytes = ( bytes >>> 10 ) + '.' + ( bytes & (0x3FF ) ) + 'KB' ;
else if ( ( bytes >> 1 ) & 0x3FF )
bytes = ( bytes >>> 1 ) + 'Bytes' ;
else
bytes = bytes + 'Byte' ;
return bytes ;
}
Aliceljm의 답변에 따르면, 나는 소수점 이하에서 0을 제거했다.
function formatBytes(bytes, decimals) {
if(bytes== 0)
{
return "0 Byte";
}
var k = 1024; //Or 1 kilo = 1000
var sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
var i = Math.floor(Math.log(bytes) / Math.log(k));
return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + " " + sizes[i];
}
function bytesToSize(bytes) {
var sizes = ['B', 'K', 'M', 'G', 'T', 'P'];
for (var i = 0; i < sizes.length; i++) {
if (bytes <= 1024) {
return bytes + ' ' + sizes[i];
} else {
bytes = parseFloat(bytes / 1024).toFixed(2)
}
}
return bytes + ' P';
}
console.log(bytesToSize(234));
console.log(bytesToSize(2043));
console.log(bytesToSize(20433242));
console.log(bytesToSize(2043324243));
console.log(bytesToSize(2043324268233));
console.log(bytesToSize(2043324268233343));이 솔루션은 이전 솔루션을 기반으로 구축되지만 메트릭 단위와 이진 단위를 모두 고려합니다.
function formatBytes(bytes, decimals, binaryUnits) {
if(bytes == 0) {
return '0 Bytes';
}
var unitMultiple = (binaryUnits) ? 1024 : 1000;
var unitNames = (unitMultiple === 1024) ? // 1000 bytes in 1 Kilobyte (KB) or 1024 bytes for the binary version (KiB)
['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']:
['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
var unitChanges = Math.floor(Math.log(bytes) / Math.log(unitMultiple));
return parseFloat((bytes / Math.pow(unitMultiple, unitChanges)).toFixed(decimals || 0)) + ' ' + unitNames[unitChanges];
}
예:
formatBytes(293489203947847, 1); // 293.5 TB
formatBytes(1234, 0); // 1 KB
formatBytes(4534634523453678343456, 2); // 4.53 ZB
formatBytes(4534634523453678343456, 2, true)); // 3.84 ZiB
formatBytes(4566744, 1); // 4.6 MB
formatBytes(534, 0); // 534 Bytes
formatBytes(273403407, 0); // 273 MB
원래 작업 중이던 파일 업로드 프로젝트에서 @Aliceljm의 답변을 사용했는데 최근 파일이 다운되는 문제가 발생했습니다.0.98kb라고 것1.02mb이것은 현재 사용하고 있는 최신 코드입니다.
function formatBytes(bytes){
var kb = 1024;
var ndx = Math.floor( Math.log(bytes) / Math.log(kb) );
var fileSizeTypes = ["bytes", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"];
return {
size: +(bytes / kb / kb).toFixed(2),
type: fileSizeTypes[ndx]
};
}
위와 같이 파일이 추가되면 위가 호출됩니다.
// In this case `file.size` equals `26060275`
formatBytes(file.size);
// returns `{ size: 24.85, type: "mb" }`
Windows 에서는이 「Windows 」라고.24.8mb하지만 정밀도가 더 높아도 괜찮아요
다음은 바이트를 변환하는 확실한 효과적인 방법입니다.정확한 계산을 위해 mathjs 라이브러리를 설치하면 됩니다.복사 붙여넣기만 하면 됩니다.
import { multiply, divide, round } from "mathjs";
class Size {
constructor(value, unit) {
this.value = value;
this.unit = unit.toUpperCase();
}
}
async function byteToSize(bytes) {
const B = 1;
const KB = multiply(B, 1024);
const MB = multiply(KB, 1024);
const GB = multiply(MB, 1024);
const TB = multiply(GB, 1024);
const PB = multiply(TB, 1024);
if (bytes <= KB) {
// @returns BYTE
const result = round(divide(bytes, B));
const unit = `B`;
return new Size(result, unit);
}
if (bytes <= MB) {
// @returns KILOBYTE
const result = round(divide(bytes, KB));
const unit = `KB`;
return new Size(result, unit);
}
if (bytes <= GB) {
// @returns MEGABYTE
const result = round(divide(bytes, MB));
const unit = `MB`;
return new Size(result, unit);
}
if (bytes <= TB) {
// @returns GIGABYTE
const result = round(divide(bytes, GB));
const unit = `GB`;
return new Size(result, unit);
}
if (bytes <= PB) {
// @returns TERABYTE
const result = divide(bytes, TB).toFixed(2);
const unit = `TB`;
return new Size(result, unit);
}
if (bytes >= PB) {
// @returns PETABYTE
const result = divide(bytes, PB).toFixed(2);
const unit = `PB`;
return new Size(result, unit);
}
}
const byteConversion = (bytes: number, decimals = 2) => {
if (bytes === 0) return '0 B';
const kiloByte = 1000;
const decimal = decimals < 0 ? 0 : decimals;
const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
const i: number = Math.floor(Math.log(bytes) / Math.log(kiloByte));
return `${parseFloat((bytes / kiloByte ** i).toFixed(decimal))} ${sizes[i]}`;
};
@Aliceljm answer를 갱신합니다.소수점은 1,2자리이기 때문에 소수점 첫째 자리를 반올림해서 소수점 첫째 자리를 지킵니다.3자리 숫자의 경우 단위 자리수를 반올림하고 소수점 이하 자리수를 모두 무시합니다.
getMultiplers : function(bytes){
var unit = 1000 ;
if (bytes < unit) return bytes ;
var exp = Math.floor(Math.log(bytes) / Math.log(unit));
var pre = "kMGTPE".charAt(exp-1);
var result = bytes / Math.pow(unit, exp);
if(result/100 < 1)
return (Math.round( result * 10 ) / 10) +pre;
else
return Math.round(result) + pre;
}
var SIZES = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
function formatBytes(bytes, decimals) {
for(var i = 0, r = bytes, b = 1024; r > b; i++) r /= b;
return `${parseFloat(r.toFixed(decimals))} ${SIZES[i]}`;
}제 의견을 공유하고 싶었어요.저는 이런 문제가 있었기 때문에, 저의 해결책은 이것입니다. 단위가 되며, 그 도 마찬가지로 '이러다'만 됩니다.toUnit ★★★★★★★★★★★★★★★★★」fromUnit
export function fileSizeConverter(size: number, fromUnit: string, toUnit: string ): number | string {
const units: string[] = ['B', 'KB', 'MB', 'GB', 'TB'];
const from = units.indexOf(fromUnit.toUpperCase());
const to = units.indexOf(toUnit.toUpperCase());
const BASE_SIZE = 1024;
let result: number | string = 0;
if (from < 0 || to < 0 ) { return result = 'Error: Incorrect units'; }
result = from < to ? size / (BASE_SIZE ** to) : size * (BASE_SIZE ** from);
return result.toFixed(2);
}
여기서 아이디어를 얻었습니다.
적절한 단위에 대해 재귀 및 수준 변수를 할당합니다.
function getReadableByte(count, decimal=0, level=0) {
let unitList = ["Bytes", "KB", "MB", "GB", "TB", "PT"];
if (count >= 1024.0 && (level+1 < unitList.length)) {
return getReadableByte(count/1024, decimal, ++level)
}
return `${decimal ? (count).toFixed(decimal) : Math.round(count)}${unitList[level]}`
}
console.log(getReadableByte(120, 2))알고리즘을 7배 빠르게 만들었습니다(닌자처럼 동작합니다).
function rafaelFormatBytes(number){
if(number == null || number === undefined || number <= 0) {
return '0 Bytes';
}
var scaleCounter = 0;
var scaleInitials = [' Bytes',' KB',' MB',' GB',' TB',' PB',' EB',' ZB',' YB'];
while (number >= 1024 && scaleCounter < scaleInitials.length - 1){
number /= 1024;
scaleCounter++;
}
if(scaleCounter >= scaleInitials.length) scaleCounter = scaleInitials.length - 1;
var compactNumber = number.toFixed(2)
.replace(/\.?0+$/,'')
.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
compactNumber += scaleInitials[scaleCounter];
return compactNumber.trim();
}
var testNum = 0;
var startTime, endTime;
function start() {
startTime = new Date();
};
function end() {
endTime = new Date();
var timeDiff = endTime - startTime; //in ms
// strip the ms
timeDiff /= 1000;
// get seconds
var seconds = Math.round(timeDiff, 5);
console.log(timeDiff + " seconds");
}
function formatBytes(a,b=2,k=1024){with(Math){let d=floor(log(a)/log(k));return 0==a?"0 Bytes":parseFloat((a/pow(k,d)).toFixed(max(0,b)))+" "+["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"][d]}}
console.log(formatBytes(1000000000000000000000000000));
console.log(rafaelFormatBytes(1000000000000000000000000000));
start();
for(i=0; i<100000; i++){
formatBytes(1000000000000000);
}
end();
start();
for(i=0; i<100000; i++){
rafaelFormatBytes(1000000000000000);
}
end();...및 출력:
827.18 YB
827.18 YB
0.293 seconds
0.039 seconds
맙소사!!!!
바이트를 사람에게 표시하는 방법은 다음과 같습니다.
function bytesToHuman(bytes, decimals = 2) {
// https://en.wikipedia.org/wiki/Orders_of_magnitude_(data)
const units = ["bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"]; // etc
let i = 0;
let h = 0;
let c = 1 / 1023; // change it to 1024 and see the diff
for (; h < c && i < units.length; i++) {
if ((h = Math.pow(1024, i) / bytes) >= c) {
break;
}
}
// remove toFixed and let `locale` controls formatting
return (1 / h).toFixed(decimals).toLocaleString() + " " + units[i];
}
// test
for (let i = 0; i < 9; i++) {
let val = i * Math.pow(10, i);
console.log(val.toLocaleString() + " bytes is the same as " + bytesToHuman(val));
}
// let's fool around
console.log(bytesToHuman(1023));
console.log(bytesToHuman(1024));
console.log(bytesToHuman(1025));
function bytes2Size(byteVal){
var units=["Bytes", "KB", "MB", "GB", "TB"];
var kounter=0;
var kb= 1024;
var div=byteVal/1;
while(div>=kb){
kounter++;
div= div/kb;
}
return div.toFixed(1) + " " + units[kounter];
}
원라이너
const b2s=t=>{let e=Math.log2(t)/10|0;return(t/1024**(e=e<=0?0:e)).toFixed(3)+"BKMGP"[e]};
console.log(b2s(0));
console.log(b2s(123));
console.log(b2s(123123));
console.log(b2s(123123123));
console.log(b2s(123123123123));
console.log(b2s(123123123123123));@Aliceljm에서도 같은 답변이지만, "좀 더 교훈적인" 방식으로.감사합니다! =D
function formatBytes(numBytes, decPlaces) {
/* Adjust the number of bytes informed for the most appropriate metric according
to its value.
Args:
numBytes (number): The number of bytes (integer);
decPlaces (Optional[number])): The number of decimal places (integer). If
it is "undefined" the value "2" will be adopted.
Returns:
string: The number adjusted together with the most appropriate metric. */
if (numBytes === 0) {
return "0 Bytes";
}
// NOTE: 1 KB is equal to 1024 Bytes. By Questor
// [Ref(s).: https://en.wikipedia.org/wiki/Kilobyte ]
var oneKByte = 1024;
// NOTE: Treats if the "decPlaces" is "undefined". If it is "undefined" the value
// "2" will be adopted. By Questor
if (decPlaces === undefined || decPlaces === "") {
decPlaces = 2;
}
var byteMtrcs = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
// Byte Metrics
// NOTE: Defines the factor for the number of bytes and the metric. By Questor
var mtrcNumbFactor = Math.floor(Math.log(numBytes) / Math.log(oneKByte));
// Metrics Number Factor
return parseFloat((numBytes / Math.pow(oneKByte, mtrcNumbFactor)).
toFixed(decPlaces)) + " " + byteMtrcs[mtrcNumbFactor];
}
서버에서 다른 크기 단위로 되돌아오는 파일의 메타데이터에 문제가 있었습니다.저는 @Alicejim response를 사용하여 좀 더 일반적이게 하려고 했습니다.여기서 암호를 공유하면 누군가에게 도움이 될지도 몰라요
enum SizeUnits {
Bytes = 'Bytes',
KB = 'KB',
MB = 'MB',
GB = 'GB',
TB = 'TB',
PB = 'PB',
EB = 'EB',
ZB = 'ZB',
YB = 'YB'
}
function convertSizeUnites(size: number, sourceSizeUnits: SizeUnits, targetSizeUnits: SizeUnits) {
const i = Object.keys(SizeUnits).indexOf(sourceSizeUnits);
const sizeInBytes = size * Math.pow(1024, i);
const j = Object.keys(SizeUnits).indexOf(targetSizeUnits);
return sizeInBytes / Math.pow(1024, j);
}
function formatSize(size: number, measureUnit: SizeUnits, decimals = 2) {
if (size === 0) return '0 Bytes';
const sizeInBytes = convertSizeUnites(size, measureUnit, SizeUnits.Bytes);
const dm = decimals < 0 ? 0 : decimals;
const i = Math.floor(Math.log(sizeInBytes) / Math.log(1024));
return parseFloat((sizeInBytes / Math.pow(1024, i)).toFixed(dm)) + ' ' +
Object.keys(SizeUnits)[i];
}
현재 가장 높은 순위에 있는 답변에 대한 후속 조치를 게시하고자 합니다!
엣지 케이스
엣지 케이스를 찾았어요.바이트가 아주 작아요!구체적으로는 바이트 수가 -1 ~1(배타적)인 경우.예를 들어 0.25바이트라고 합니다.
경우, 「 」Math.floor(Math.log(bytes) / Math.log(1024))-1.
울프램 알파를 사용한 일러스트입니다.
★★-1인덱스가 .formatBytes(bytes)1234 undefined'입니다.
고치다
가 이걸 건 i i는이 i i i i i i i i i i i i i i i i i i?Math.max(0, ...):
Math.max(0, Math.floor(Math.log(bytes) / Math.log(1024))
Math.max(0, ...) 0 이상임을 합니다.
이 간단한 회피책을 사용해 보세요.
var files = $("#file").get(0).files;
var size = files[0].size;
if (size >= 5000000) {
alert("File size is greater than or equal to 5 MB");
}
언급URL : https://stackoverflow.com/questions/15900485/correct-way-to-convert-size-in-bytes-to-kb-mb-gb-in-javascript
반응형
'programing' 카테고리의 다른 글
| Python 객체가 "서브스크립트 가능"인지 아닌지는 무엇을 의미합니까? (0) | 2022.10.11 |
|---|---|
| 표 크기 - MariaDB Columnstore 대 InnoDB (0) | 2022.10.11 |
| Rxandroid SubscribeOn과 ObservateOn의 차이점은 무엇입니까? (0) | 2022.10.11 |
| Symfony에서 저장소에 주입하려면 어떻게 해야 합니까? (0) | 2022.10.11 |
| Joomla - SQL 데이터베이스를 새 서버로 가져오는 중 오류가 발생했습니다. (0) | 2022.10.11 |