I have an array like:
(
"8461.86","8468.22","8468.22","8162.59","8164.50","7280.59" )
I try to sort this array decendingly as per following:
sortedArray = [arr_distance sortedArrayUsingComparator:^(id firstObject, id secondObject) {
return [((NSString *)firstObject) compare:((NSString *)secondObject) options:NSNumericSearch];
}];
But i got following array like:
(
"7280.59","8162.59","8164.50","8461.86","8468.22","8468.22" )
Why this happen?
I also try with like
return [firstObject compare:secondObject options:NSNumericSearch];
But not getting proper sorted array.
NSSortDescriptor *desc = [[NSSortDescriptor alloc]initWithKey:#"" ascending:NO];
NSMutableArray *yourTempArray = [[NSMutableArray alloc]initWithObjects:#"8459.93",#"8466.28",#"8466.28",#"8160.70",#"8162.61",#"7278.56", nil];
[yourTempArray sortUsingDescriptors:[NSArray arrayWithObject:desc]];
NSLog(#"sotedAr == %#",yourTempArray);
Output:
sotedAr == (
"8466.28",
"8466.28",
"8459.93",
"8162.61",
"8160.70",
"7278.56"
)
To sort in descending order, you could just switch the firstObject and secondObject in your code:
sortedArray = [arr_distance sortedArrayUsingComparator:^(id firstObject, id secondObject) {
return [((NSString *)secondObject) compare:((NSString *)firstObject) options:NSNumericSearch];
}];
Try following code:-
NSSortDescriptor *frequencyDescriptor = [NSSortDescriptor sortDescriptorWithKey:#""
ascending:NO
comparator:^(id obj1, id obj2) {
return [obj1 compare:obj2 options:NSNumericSearch];
}];
NSEnumerator * enumerator = [arr_distance objectEnumerator];
NSArray * descriptors = [NSArray arrayWithObjects:frequencyDescriptor, nil];
NSArray * sortedArray = [arr_distance sortedArrayUsingDescriptors:descriptors];
enumerator = [sortedArray objectEnumerator];
NSLog(#"sortedArray = %#",sortedArray);
// use sortedArray which is sorted
Below code may be useful for sorting your array in descending order
NSArray *arr = [NSArray arrayWithObjects:#"8459.93",#"8466.28",#"8466.28",#"8160.70",#"8162.61",#"7278.56", nil];
NSMutableArray *yourTempArray = [[NSMutableArray alloc]init];
[yourTempArray addObjectsFromArray:arr];
NSLog(#"before sorting = %#",yourTempArray);
NSSortDescriptor* sort = [NSSortDescriptor sortDescriptorWithKey: #"self" ascending: NO];
[yourTempArray sortUsingDescriptors:[NSArray arrayWithObject:sort]];
NSLog(#"After sorting = %#",yourTempArray);
Related
I'm trying to sort a set and it works fine most of the time. But when I start using my app on an old iPhone 5c and a lot of objects get into the set, I would eventually hit this error:
EXC_BREAKPOINT (code=EXC_ARM_BREAKPOINT, subcode=0xdefe)
here is the code plus stacktrace:
if(manager.allBeacons){
NSSet *beacons = [manager.allBeacons copy];
NSSet *filteredSet = [[NSSet alloc] initWithSet:[beacons filteredSetUsingPredicate:predicate]];
if(filteredSet){
//NSSortDescriptor *descriptor = [[NSSortDescriptor alloc] initWithKey:#"RSSI" ascending:NO];
//NSArray *sortDescriptors = [NSArray arrayWithObject:descriptor];
//NSArray *sortedArray = [[NSArray alloc] initWithArray:[filteredSet.allObjects sortedArrayUsingDescriptors:sortDescriptors]];
NSArray *sortedArray = [filteredSet.allObjects sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {
if([obj1 isKindOfClass:[BLUSBeacon class]] && [obj2 isKindOfClass:[BLUSBeacon class]]){
BLUSBeacon *beacon1 = obj1;
BLUSBeacon *beacon2 = obj2;
if(beacon1.RSSI.integerValue > beacon2.RSSI.integerValue){
return (NSComparisonResult)NSOrderedAscending;
}
if(beacon1.RSSI.integerValue < beacon2.RSSI.integerValue){
return (NSComparisonResult)NSOrderedDescending;
}
}
return (NSComparisonResult)NSOrderedSame;
}];
if(sortedArray){
self.beacons = sortedArray;
[self.tableView reloadData];
}
}
}
And here is the last step in the stacktrace in case it serves any purpose:
As you can see, I was trying to sort with descriptors initially, but that made it crash even sooner.
Any thoughts?
adding data to mutable array and calculate distance from lat and long and adding this to my array , i think it may be enumerated for loop when adding to data from server to my mutable array. Advance Thanks
NSArray *arr;
NSMutableArray * mapViewDataArrayNew = [[NSMutableArray alloc]init];
mSaveDataArr=[[NSMutableArray alloc]init];
self.barsDataArray=[[NSMutableArray alloc]init];
arr = [responseData[kData] mutableCopy];
Distancearr =[DRMapView initializeValue];
for(int ii =0;ii<[arr count];ii++)
{
NSMutableDictionary * object =arr[ii];
mMapViewObj = [[DRMapView alloc]init];
[mMapViewObj setUpData:object :ii+1];
[object setObject:mMapViewObj.mDistance forKey:kDistance];
[mSaveDataArr addObject:object];
[mapViewDataArrayNew addObject:mMapViewObj];
}
//Sort array
NSSortDescriptor *sortByName =[NSSortDescriptor sortDescriptorWithKey:kDistance ascending:YES];
NSArray *sortDescriptors = [NSArray arrayWithObject:sortByName];
NSArray *sortedArray = [Distancearr sortedArrayUsingDescriptors:sortDescriptors];
Distancearr=nil;
Distancearr=sortedArray;
NSOrderedSet *orderedSet = [NSOrderedSet orderedSetWithArray:Distancearr];
Distancearr=nil;
Distancearr = [orderedSet array];
for(NSMutableDictionary *dict in Distancearr)
{
NSNumber *dist = [dict objectForKey:kDistance];
for(DRMapView * mapObj in mapViewDataArrayNew)
{
if([mapObj.mDistance isEqualToNumber:dist])
{
[self.barsDataArray addObject:mapObj];
}
}
}
//Reload table view
distanceLbl.text=[NSString stringWithFormat:#"Maximum distance limit %# Km",[HelperUDLib getObject:#"barRange"]];
[UIView transitionWithView:listView
duration:1.0f
options:UIViewAnimationOptionTransitionCrossDissolve
animations:^(void) {
[weakSelf.barsListTableView reloadData];
distanceLbl.text=[NSString stringWithFormat:#"Maximum distance limit 200 Km"];
}
completion:nil];
If I'm trying to sort BL_Player by their playerScore property:
NSArray *sortedPlayers = [players sortedArrayUsingComparator: ^(BL_Player *a1, BL_Player *a2) {
return [a1.playerScore compare:a2.playerScore options:NSNumericSearch];
OR
NSArray *sortedPlayers = [players sortedArrayUsingComparator:^NSComparisonResult(id a, id b) {
NSInteger first = [(BL_Player *)a playerScore];
NSInteger second = [(BL_Player *)b playerScore];
return [first compare:second options:NSNumericSearch];
}];
both of which return bad receiver types. What's wrong with doing comparisons on ints or NSInteger?
Try this one:
NSArray *sortedPlayers = [players sortedArrayUsingComparator: ^(BL_Player *a1, BL_Player *a2) {
if (a1.playerScore > a2.playerScore) {
return NSOrderedAscending;
}
else if (a1.playerScore < a2.playerScore) {
return NSOrderedDescending;
}
else
return NSOrderedSame;
}
Change as per your requirement.
May help you.
A better approach to do this:
NSSortDescriptor *sortDescriptor;
sortDescriptor = [[NSSortDescriptor alloc] initWithKey:#"playerScore"
ascending:YES];
NSArray *sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
NSArray *sortedArray;
sortedArray = [players sortedArrayUsingDescriptors:sortDescriptors];
for descending order change YES to NO.
I have a horizontally and vertically scrollable table. I get the data for the header and first column from the web service(json). I want to sort the data in ascending order and remove duplicate data from both header and the first column. For removing duplicate values I used the following code:
-(void) requestFinished: (ASIHTTPRequest *) request
{
NSString *theJSON = [request responseString];
SBJsonParser *parser = [[SBJsonParser alloc] init];
NSMutableArray *jsonDictionary = [parser objectWithString:theJSON error:nil];
headData = [[NSMutableArray alloc] init];
NSMutableArray *head = [[NSMutableArray alloc] init];
leftTableData = [[NSMutableArray alloc] init];
NSMutableArray *left = [[NSMutableArray alloc] init];
rightTableData = [[NSMutableArray alloc]init];
for (NSMutableArray *dictionary in jsonDictionary)
{
Model *model = [[Model alloc]init];
model.cid = [[dictionary valueForKey:#"cid"]intValue];
model.iid = [[dictionary valueForKey:#"iid"]intValue];
model.yr = [[dictionary valueForKey:#"yr"]intValue];
model.val = [dictionary valueForKey:#"val"];
[mainTableData addObject:model];
[head addObject:[NSString stringWithFormat:#"%ld", model.yr]];
[left addObject:[NSString stringWithFormat:#"%ld", model.iid]];
}
NSOrderedSet *orderedSet = [NSOrderedSet orderedSetWithArray:head];
headData = [[orderedSet array] mutableCopy];
// NSSet *set = [NSSet setWithArray:left];
// NSArray *array2 = [set allObjects];
// NSLog(#"%#", array2);
NSOrderedSet *orderedSet1 = [NSOrderedSet orderedSetWithArray:left];
NSMutableArray *arrLeft = [[orderedSet1 array] mutableCopy];
//remove duplicate enteries from header array
[leftTableData addObject:arrLeft];
NSMutableArray *right = [[NSMutableArray alloc]init];
for (int i = 0; i < arrLeft.count; i++)
{
NSMutableArray *array = [[NSMutableArray alloc] init];
for (int j = 0; j < headData.count; j++)
{
/* NSPredicate *predicate = [NSPredicate predicateWithFormat:#"SELF.iid == %ld", [[arrLeft objectAtIndex:i] intValue]];
NSArray *filteredArray = [mainTableData filteredArrayUsingPredicate:predicate];*/
NSPredicate *predicate = [NSPredicate predicateWithFormat:#"SELF.iid == %ld AND SELF.yr == %ld", [[arrLeft objectAtIndex:i] intValue], [[headData objectAtIndex:j] intValue]];
NSArray *filteredArray = [mainTableData filteredArrayUsingPredicate:predicate];
if([filteredArray count]>0)
{
Model *model = [filteredArray objectAtIndex:0];
[array addObject:model.val];
}
}
[right addObject:array];
}
[rightTableData addObject:right];
}
How will I sort the arrays in ascending order?
Please help.
OK, so you have a model object that looks something like this...
#interface Model: NSObject
#property NSNumber *idNumber;
#property NSNumber *year;
#property NSString *value;
#end
Note, I am intentionally using NSNumber and not NSInteger for reasons that will become clear.
At the moment you are trying to do a lot all in one place. Don't do this.
Create a new object to store this data. You can then add methods to get the data you need. Seeing as you are displaying in a table view sectioned by year and then each section ordered by idNumber then I'd do something like this...
#interface ObjectStore: NSObject
- (void)addModelObject:(Model *)model;
// standard table information
- (NSInteger)numberOfYears;
- (NSInteger)numberOfIdsForSection:(NSinteger)section;
// convenience methods
- (NSNumber *)yearForSection:(NSInteger)section;
- (NSNumber *)idNumberForSection:(NSInteger)section row:(NSInteger)row;
- (NSArray *)modelsForSection:(NSInteger)section row:(NSInteger)row;
// now you need a way to add objects
- (void)addModelObject:(Model *)model;
#end
Now to implement it.
We are going to store everything in one dictionary. The keys will be years and the objects will be dictionaries. In these dictionaries the keys will be idNumbers and the objects will be arrays. These array will hold the models.
So like this...
{
2010 : {
1 : [a, b, c],
3 : [c, d, e]
},
2013 : {
1 : [g, h, u],
2 : [e, j, s]
}
}
We'll do this with all the convenience methods also.
#interface ObjectStore: NSObject
#property NSMutableDictionary *objectDictionary;
#end
#implementation ObjectStore
+ (instancetype)init
{
self = [super init];
if (self) {
self.objectDictionary = [NSMutableDictionary dictionary];
}
return self;
}
+ (NSInteger)numberOfYears
{
return self.objectDictionary.count;
}
+ (NSInteger)numberOfIdsForSection:(NSinteger)section
{
// we need to get the year for this section in order of the years.
// lets create a method to do that for us.
NSNumber *year = [self yearForSection:section];
NSDictionary *idsForYear = self.objectDictionary[year];
return idsForYear.count;
}
- (NSNumber *)yearForSection:(NSInteger)section
{
// get all the years and sort them in order
NSArray *years = [[self.obejctDictionary allKeys] sortedArrayUsingSelector:#selector(compare:)];
// return the correct year
return years[section];
}
- (NSNumber *)idNumberForSection:(NSInteger)section row:(NSInteger)row
{
// same as the year function but for id
NSNumber *year = [self yearForSection:section];
NSArray *idNumbers = [[self.objectDictionary allKeys]sortedArrayUsingSelector:#selector(compare:)];
return idNumbers[row];
}
- (NSArray *)modelsForSection:(NSInteger)section row:(NSInteger)row
{
NSNumber *year = [self yearForSection:section];
NSNumber *idNumber = [self idForSection:section row:row];
return self.objectDictionary[year][idNumber];
}
// now we need a way to add objects that will put them into the correct place.
- (void)addModelObject:(Model *)model
{
NSNumber *modelYear = model.year;
NSNumber *modelId = model.idNumber;
// get the correct storage location out of the object dictionary
NSMutableDictionary *idDictionary = [self.objectDictionary[modelYear] mutableCopy];
// there is a better way to do this but can't think atm
if (!idDictionary) {
idDictionary = [NSMutableDictionary dictionary];
}
NSMutableArray *modelArray = [idDictionary[modelId] mutableCopy];
if (!modelArray) {
modelArray = [NSMutableArray array];
}
// insert the model in the correct place.
[modelArray addObject:model];
idDictionary[modelId] = modelArray;
self.objectDictionary[modelYear] = idDictionary;
}
#end
With all this set up you can now replace your complex function with this...
-(void) requestFinished: (ASIHTTPRequest *) request
{
NSString *theJSON = [request responseString];
SBJsonParser *parser = [[SBJsonParser alloc] init];
NSDictionary *jsonDictionary = [parser objectWithString:theJSON error:nil];
for (NSDictionary *dictionary in jsonDictionary)
{
Model *model = [[Model alloc]init];
model.cid = [dictionary valueForKey:#"cid"];
model.idNumber = [dictionary valueForKey:#"iid"];
model.year = [dictionary valueForKey:#"yr"];
model.val = [dictionary valueForKey:#"val"];
[self.objectStore addModelObject:model];
}
}
To get the models out for a particular row then just use...
[self.objectStore modelsForSection:indexPath.section row:indexPath.row];
To get the number of sections in the tableview delegate method...
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
return [self.objectStore numberOfYears];
}
No messing around with the model in the view controller.
Welcome to the MVC pattern.
There's a crap ton of code here but by placing all the code here you can remove all the complex code from your VC.
NSSet keeps only non-duplicate objects within themselves so to keep only unique objects in array you can use NSSet as -
Suppose you have array with duplicate objects
NSArray *arrayA = #[#"a", #"b", #"a", #"c", #"a"];
NSLog(#"arrayA is: %#", arrayA);
//create a set with the objects from above array as
//the set will not contain the duplicate objects from above array
NSSet *set = [NSSet setWithArray: arrayA];
// create another array from the objects of the set
NSArray *arrayB = [set allObjects];
NSLog(#"arrayB is: %#", set);
The output from the above looks like:
arrayA is: (
a,
b,
a,
c,
a
)
arrayB is: {(
b,
c,
a
)}
and to sort a mutable array in ascending order you can use NSSortDescriptor and sortUsingDescriptors:sortDescriptors. Also you need to provide the key on the basis of which array will be sorted.
NSSortDescriptor *sortDescriptor;
sortDescriptor = [[NSSortDescriptor alloc] initWithKey:#"key" ascending:YES];
NSArray *sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
[array sortUsingDescriptors:sortDescriptors];
[sortDescriptor release];
Here you will get what you want.
//sort description will used to sort array.
NSSortDescriptor *descriptor=[[NSSortDescriptor alloc] initWithKey:#"iid" ascending:YES];
NSArray *descriptors=[NSArray arrayWithObject: descriptor];
NSArray *reverseOrder=[arrLeft sortedArrayUsingDescriptors:descriptors];
reverseOrder is your desire output.
there is another way you can sort objects that followed model.
NSArray *someArray = /* however you get an array */
NSArray *sortedArray = [someArray sortedArrayUsingComparator:^(id obj1, id obj2) {
NSNumber *rank1 = [obj1 valueForKeyPath:#"iid"];
NSNumber *rank2 = [obj2 valueForKeyPath:#"iid"];
return (NSComparisonResult)[rank1 compare:rank2];
}];
here sortedArray is our output.
you can replace same things for yr key as well.
This is what I did to sort the header data in ascending order and to remove duplicates from both header and leftmost column. Hope this will help others
NSOrderedSet *orderedSet3 = [NSOrderedSet orderedSetWithArray:head3];
headData3 = [[orderedSet3 array] mutableCopy];
[headData3 sortUsingComparator:^NSComparisonResult(NSString *str1, NSString *str2)
{
return [str1 compare:str2 options:(NSNumericSearch)];
}];
NSOrderedSet *orderedSet4 = [NSOrderedSet orderedSetWithArray:left3];
NSMutableArray *arrLeft3 = [[orderedSet4 array] mutableCopy];
[leftTableData3 addObject:arrLeft3];
I have an array populated by dictionaries, and I need to sort the array alphabetically by the values of one of the keys of the dictionaries.
This is my array:
tu dictus: (
{
brand = Ryul;
productTitle = Any;
quantity = 1;
subBrand = "Ryul INJ";
type = Product;
},
{
brand = Trol;
productTitle = Different;
quantity = 2;
subBrand = "";
type = Brand;
},
{
brand = Dtor;
productTitle = Any;
quantity = 1;
subBrand = "";
type = Product;
},
{
brand = Ryul;
productTitle = Different;
quantity = 2;
subBrand = "Ryul CHES";
type = SubBrand;
},
{
brand = Anan;
productTitle = Any;
quantity = 1;
subBrand = "";
type = Product;
}
)
Normally for sorting an array I will use
myArray = [uniqueProdsArray sortedArrayUsingSelector:#selector(localizedCaseInsensitiveCompare:)];
But how do sort using the brand key of the dictionary?
I think this will do it:
brandDescriptor = [[NSSortDescriptor alloc] initWithKey:#"brand" ascending:YES];
sortDescriptors = [NSArray arrayWithObject:brandDescriptor];
sortedArray = [myArray sortedArrayUsingDescriptors:sortDescriptors];
I pulled the code from Sort Descriptor Programming Topics. Also, Key-Value Coding comes into play, in that sortedArrayUsingDescriptors: will send a valueForKey: to each element in myArray, and then use standard comparators to sort the returned values.
We Got The Solution By Using The Method Follows
[self.jsonData sortUsingDescriptors: [NSArray arrayWithObjects: [NSSortDescriptor sortDescriptorWithKey:"fullname" ascending:YES], [NSSortDescriptor sortDescriptorWithKey:"id" ascending:NO], nil]];
Where:-
jsonData - MutableArray Which holds the Parsed JSON Data.
fullname - the data we want to sort.
id - An unique data which comes with the inner dictionary.
As an addition to QED's code,
NSSortDescriptor * brandDescriptor = [[NSSortDescriptor alloc] initWithKey:#"brand" ascending:YES];
NSArray * sortedArray = [myArray sortedArrayUsingDescriptors:#[brandDescriptor]];
This clarifies the classes of the variables and optimises the array creation with fast-enumeration.
Thanks
arrSorted = [arrBrand sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
if ([[obj1 valueForKey:#"iUserId"] integerValue] > [[obj2 valueForKey:#"iUserId"] integerValue]) {
return (NSComparisonResult)NSOrderedDescending;
}
if ([[obj1 valueForKey:#"iUserId"] integerValue] < [[obj2 valueForKey:#"iUserId"] integerValue]) {
return (NSComparisonResult)NSOrderedAscending;
}
return (NSComparisonResult)NSOrderedSame;
}];
In switf:
var descriptor: NSSortDescriptor = NSSortDescriptor(key: "brand", ascending: true)
var sortedResults: NSArray = results.sortedArrayUsingDescriptors([descriptor])
Use following code for sort using the "brand" key from the dictionary..
NSSortDescriptor * brandDescriptor = [[NSSortDescriptor alloc] initWithKey:#"brand" ascending:YES];
NSArray * sortDescriptors = [NSArray arrayWithObject:brandDescriptor];
NSArray * sortedArray = [myArray sortedArrayUsingDescriptors:sortDescriptors];
NSLog(#"sortedArray %#",sortedArray);
Use following code, If you to sorting according two keys from the dictionary; Like, "brand" key and productTitle key from the dictionary:-
NSSortDescriptor * brandDescriptor = [[NSSortDescriptor alloc] initWithKey:#"brand" ascending:YES];
NSSortDescriptor * productTitleDescriptor = [[NSSortDescriptor alloc] initWithKey:#"productTitle" ascending:YES];
NSArray * sortDescriptors = [NSArray arrayWithObjects:brandDescriptor, productTitleDescriptor, nil];
NSArray * sortedArray = [feedData sortedArrayUsingDescriptors:sortDescriptors];
NSLog(#"sortedArray %#",sortedArray);
My code was crashing when using NSSortDescriptor so ended up using a block which works great in my use case, where I am expecting the "rank" to be an NSNumber. If the object can't be converted to an integer it will not sort but it also won't cause a crash.
NSArray *sortedArray = [data sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
long data1 = [[obj1 valueForKey:#"rank"] integerValue];
long data2 = [[obj2 valueForKey:#"rank"] integerValue];
if (data1 > data2) {
return (NSComparisonResult)NSOrderedDescending;
}
if (data1 < data2) {
return (NSComparisonResult)NSOrderedAscending;
}
return (NSComparisonResult)NSOrderedSame;
}];
NSSortDescriptor *brandDescriptor = [[[NSSortDescriptor alloc] initWithKey:#"Position" ascending:YES selector:#selector(localizedStandardCompare:)] autorelease];
NSArray *sortDescriptors = [NSArray arrayWithObject:brandDescriptor];
NSArray *sortedArray = [arrTemp sortedArrayUsingDescriptors:sortDescriptors];
array_PreLagData=(NSMutableArray*)sortedArray;
unsorted array
Printing description of arrTemp:
<__NSArrayM 0x10282100>(
{
Milker2 = "11:03:17 AM";
Position = 2;
},
{
Milker1 = "11:03:28 AM";
Position = 25;
},
{
Milker3 = "11:03:18 AM";
Position = 3;
},
{
Milker1 = "11:03:16 AM";
Position = 1;
Strip = "11:32:32 AM";
},
{
Milker1 = "11:03:21 AM";
Position = 10;
}
)
Sorted array
<__NSArrayI 0x101363c0>(
{
Milker1 = "11:03:16 AM";
Position = 1;
Strip = "11:32:32 AM";
},
{
Milker2 = "11:03:17 AM";
Position = 2;
},
{
Milker3 = "11:03:18 AM";
Position = 3;
},
{
Milker1 = "11:03:21 AM";
Position = 10;
},
{
Milker1 = "11:03:28 AM";
Position = 25;
}
)
[enter link description here][1]
[1]: https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/SortDescriptors/Articles/Creating.html#//apple_ref/doc/uid/20001845-BAJEAIEE
you can do this .
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:#"d LLLL yyyy"];
NSComparator compareDates = ^(id string1, id string2)
{
NSDate *date1 = [formatter dateFromString:string1];
NSDate *date2 = [formatter dateFromString:string2];
return [date1 compare:date2];
};
NSSortDescriptor * sortDesc1 = [[NSSortDescriptor alloc] initWithKey:#"date" ascending:NO comparator:compareDates];
[array sortUsingDescriptors:[NSArray arrayWithObjects:sortDesc1, nil]];
Just try it out easiest way...
myArray = [[NSMutableArray alloc] init];
NSMutableArray *tempArray = [[NSMutableArray alloc] init];
[tempArray removeAllObjects];
[tempArray addObjectsFromArray: myArray];
NSString *key = #"brand";
NSSortDescriptor *brandDescriptor = [[NSSortDescriptor alloc] initWithKey:key ascending:YES];
NSArray *sortDescriptors = [NSArray arrayWithObjects:brandDescriptor,nil];
NSArray *sortedArray = [tempArray sortedArrayUsingDescriptors:sortDescriptors];
[brandDescriptor release];
[tempArray removeAllObjects];
tempArray = (NSMutableArray*)sortedArray;
[myArray removeAllObjects];
[myArray addObjectsFromArray:tempArray];
Use this for swift 4
let sortedArray = arrayTobeSort.sorted {$0["keyName"].compare($1["keyName"]) == ComparisonResult.orderedAscending}
You can also use ComparisonResult.orderedDescending to sort in descending order