Easy way to get size of folder (ObjC/Cocoa)?

Right now I’m using this code to get the size of a folder:

NSArray *contents;
        NSEnumerator *enumerator;
        NSString *path;
        contents = [[NSFileManager defaultManager] subpathsAtPath:folderPath];
        enumerator = [contents objectEnumerator];
        while (path = [enumerator nextObject]) {
            NSDictionary *fattrib = [[NSFileManager defaultManager] fileAttributesAtPath:[folderPath stringByAppendingPathComponent:path] traverseLink:YES];
            fileSize +=[fattrib fileSize];

        [contents release];
        [path release]; 

The problem is that its highly innacurate. It either adds a few megabytes or deducts a few megabytes from the actual size. For example I got the file size of an .app bundle and this method reported 16.2MB, whereas the actual thing is 15.8.

  • Selection Highlight in NSCollectionView
  • How to avoid adding multiple NSNotification observer?
  • Shared UITableViewDelegate
  • Execute a terminal command from a Cocoa app
  • How to simplify callback logic with a Block?
  • Using NSPredicate to filter an NSArray based on NSDictionary keys
  • What’s the best way to get the size of a folder?


    7 Solutions Collect From Internet About “Easy way to get size of folder (ObjC/Cocoa)?”

    I needed to do this today myself, and I’ve found that the code in this post on the Cocoa-dev list is super fast and matches what Finder says to the byte. (don’t forget to OR in the kFSCatInfoRsrcSizes flag so you get resource fork sizes, too!)

    If you need more explanation on how to use it, just leave a comment and I’ll edit this post. =)

    The documentation for fileSize states it does not include the size of a resource fork. You may need to use the Carbon File Manager API to reliably calculate directory sizes.

    I just wanted to second Dave DeLong’s suggestion about the post on Cocoa-dev, but add a cautionary note to be sure to read all the posts in the thread. There is one by Rosyna that’s particularly worth noting. In my case I followed that advice (changing max items per fetch to 40) and saw a speed jump as well as the end to a nasty crashing bug.

    I know that this is an old topic. But for anyone out there looking for answers on how to do this,

    [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:&isDir];
            if (isDir) {
                NSPipe *pipe = [NSPipe pipe];
                NSTask *t = [[[NSTask alloc] init] autorelease];
                [t setLaunchPath:@"/usr/bin/du"];
                [t setArguments:[NSArray arrayWithObjects:@"-k", @"-d", @"0", path, nil]];
                [t setStandardOutput:pipe];
                [t setStandardError:[NSPipe pipe]];
                [t launch];
                [t waitUntilExit];
                NSString *sizeString = [[[NSString alloc] initWithData:[[pipe fileHandleForReading] availableData] encoding:NSASCIIStringEncoding] autorelease];
                sizeString = [[sizeString componentsSeparatedByString:@" "] objectAtIndex:0];
                bytes = [sizeString longLongValue]*1024;
            else {
                bytes = [[[NSFileManager defaultManager] attributesOfItemAtPath:path error:nil] fileSize];

    It will use terminal to determine a size for folders in bytes. And it will use Cocoa’s built in NSFileManager to get the size of files. It’s very fast, and gets the exact size that finder reports.

    This is typically how it is done. 2 possibilities:

    1. Check your byte -> megabyte conversion routines. Also, do you want megabytes or mebibytes? (It probably depends on what you’re comparing it to.)

    2. Try passing NO for the traverseLink parameter. There might very well be a symlink in the bundle pointing to something else that the routine you’re comparing it to won’t account for. You’ll either count something in the bundle twice, or you’ll include something outside the bundle entirely (most likely the former).

    This code is as extension(category) to the NSFileManager class. It sums the sizes of all folder content.
    Note that error treatment could be enhanced.

     @interface NSFileManager(Util)
            - (NSNumber *)sizeForFolderAtPath:(NSString *) source error:(NSError **)error;
        @implementation NSFileManager(Util)
            - (NSNumber *)sizeForFolderAtPath:(NSString *) source error:(NSError **)error
                NSArray * contents;
                unsigned long long size = 0;
                NSEnumerator * enumerator;
                NSString * path;
                BOOL isDirectory;
                // Determine Paths to Add 
                if ([self fileExistsAtPath:source isDirectory:&isDirectory] && isDirectory) 
                    contents = [self subpathsAtPath:source]; 
                    contents = [NSArray array];
                // Add Size Of All Paths 
                enumerator = [contents objectEnumerator]; 
                while (path = [enumerator nextObject]) 
                    NSDictionary * fattrs = [self attributesOfItemAtPath: [ source stringByAppendingPathComponent:path ] error:error];
                    size += [[fattrs objectForKey:NSFileSize] unsignedLongLongValue]; 
                // Return Total Size in Bytes 
                return [ NSNumber numberWithUnsignedLongLong:size];

    hope this will help

    - (unsigned long long) fastFolderSizeAtFSRef:(NSString *)theFilePath
    unsigned long long totalSize = 0;
    NSFileManager *fileManager = [NSFileManager defaultManager];
    BOOL  isdirectory;
    NSError *error;
    if ([fileManager fileExistsAtPath:theFilePath])
        NSMutableArray * directoryContents = [[fileManager contentsOfDirectoryAtPath:theFilePath error:&error] mutableCopy];
        for (NSString *fileName in directoryContents)
            if (([fileName rangeOfString:@".DS_Store"].location != NSNotFound) )
                NSString *path = [theFilePath stringByAppendingPathComponent:fileName];
                if([fileManager fileExistsAtPath:path isDirectory:&isdirectory] && isdirectory  )
                        totalSize =  totalSize + [self fastFolderSizeAtFSRef:path];
                    unsigned long long fileSize = [[fileManager attributesOfItemAtPath:path error:&error] fileSize];
                    totalSize = totalSize + fileSize;
    return totalSize;