JAVASCRIPT

JS array sort

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

sort javascript array

var points = [40, 100, 1, 5, 25, 10];
points.sort((a,b) => a-b)

javascript orderby

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];

// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});

// sort by name
items.sort(function(a, b) {
  var nameA = a.name.toUpperCase(); // ignore upper and lowercase
  var nameB = b.name.toUpperCase(); // ignore upper and lowercase
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }

  // names must be equal
  return 0;
});

array sort

Array.Sort(array); // this will Modify original Array

sort javascript

//Higher order function for sorting

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

const points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){
  return a - b
});


////HOF/////
numArray.sort(function(a, b){
  return a - b
});
//output >> [1 ,5 , 10 ,25 ,40 ,100]

javascript sort

var names = ["Peter", "Emma", "Jack", "Mia", "Eric"];
names.sort(); // ["Emma", "Eric", "Jack", "Mia", "Peter"]

var objs = [
  {name: "Peter", age: 35},
  {name: "Emma", age: 21},
  {name: "Jack", age: 53}
];

objs.sort(function(a, b) {
  return a.age - b.age;
}); // Sort by age (lowest first)

sort js

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

sort in javascript

//sort is function in js which sort according to alphanumerical
//for array with number it is little twist
const items= ["Banana","Orange","Apple"];
const ratings = [92,52,2,22]
console.log(items.sort())// reuturn ["Apple","Banana","Orange]
//for array with number
ratings.sort(function(a,b){
return a-b; //ascending for decending b-a
// return is negative a is sorted befor b 
// positive b is sorted before a
// if they are the same is 0 then nothing changes.
})

JavaScript Sorting Arrays

let persolize=[ { key: 'speakers', view: 10 }, { key: 'test', view: 5 } ]
  
persolize.sort((a,b) => a.view - b.view);

//If it only array and not an array object, use below statement
//persolize.sort((a,b) => a - b);

sort method in js

// Sort method

// const arr = [3,53,423,534,3];
// console.log(arr.sort());

// const names = ["fahad", "taha", "salman", "mojeeb"]; // This looks good but if we solve this sort this like with capital letters it'll give first priority to capital letter then it'll sort small letters the example is given below

// names.sort();
// console.log(names);

// Example
// const namesWithCapitalLetters = ["fahad", "Taha", "salman", "mojeeb"];
// namesWithCapitalLetters.sort();

// console.log(namesWithCapitalLetters);

// That's how it works :)

// How to get expected output

// const arr = [3,53,423,534,3];
// console.log(arr.sort()); ---> We're not getting expected output while we're doing this but there is a way with that we can get our expected output

// The way

const arr = [3, 53, 423, 534, 3];
console.log(arr.sort((a, b) => a - b));

// How this is working questing is this?

// What javascript here doing is first javascript 3 and 52 a = 3 b = 52; And now if we 3 to 52 and we'll get number greater than 0 then javascript sort those numbers in order of b then a ---> like 52, 3 and if we got the output less than 0 then javascript sort the number in order of a, b ---> 3  52 and yes you're right this is the correct output :)

// A use case of sort method

// Imagine you have a ecommerce site and you want to sort products prices then how can you sort the prices of products with sort method example given below

// Example
const userCart = [
  { producdId: 1, producdPrice: 355 },
  { producdId: 2, producdPrice: 5355 },
  { producdId: 3, producdPrice: 34 },
  { producdId: 4, producdPrice: 3535 },
];

// Use this for low to high
userCart.sort((a, b) => a.producdPrice - b.producdPrice);

// console.log(userCart)

// ===================================

// Use this for high to low
userCart.sort((a, b) => b.producdPrice - a.producdPrice);

// console.log(userCart)

// ==============The End=================

js sort

let numbers = [4, 10, 5, 1, 3];
numbers.sort((a, b) => a - b);
console.log(numbers);

// [1, 2, 3, 4, 5]

sort array in javascript

//This method will be sort array in ascending order:
var numArray = [5, 10, 12, 9, 31, 21, 18, 55, 39, 40];
numArray.sort((a, b) => {
  return a - b;
});
console.log(numArray);

//This method will be sort array in descending order:
numArray.sort((a, b) => {
  return b - a;
});

console.log(numArray)

//sort array by date

// Name Z to A
array.sort((a, b) => (a.name > b.name ? -1 : 1))

console.log(array)
// Sort by date
array.sort((a,b) =>  new Date(a.date) - new Date(b.date));

console.log(array)

js sort array

// ascending (normal)
numArray.sort((a,b) => a-b);

// decending (reverse)
numArray.sort((a,b) => b-a);

javascript sort

homes.sort(function(a, b) {
    return parseFloat(a.price) - parseFloat(b.price);
});

arr.sort

//sort an array of strings
var fruitSalad = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']

//sort an array of numbers
var scores = [1, 10, 2, 21]; 
scores.sort(); // [1, 10, 2, 21]
// Watch out that 10 comes before 2,
// because '10' comes before '2' in Unicode code point order.

//sorts an array of words
var randomThings = ['word', 'Word', '1 Word', '2 Words'];
randomThings.sort(); // ['1 Word', '2 Words', 'Word', 'word']
// In Unicode, numbers come before upper case letters,
// which come before lower case letters.

javascript sort

homes.sort((a, b) => parseFloat(a.price) - parseFloat(b.price));

Sort in array in Javascript

const ascending: any= values.sort((a,b) =>  (a > b ? 1 : -1));
const descending: any= values.sort((a,b) => (a > b ? -1 : 1))

sort array javascript

let array = ['12'. '54'];
array.sort((a,b) => a -b);

sort method js

let numbers = [0, 1 , 2, 3, 10, 20, 30 ];
numbers.sort( function( a , b){
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
});

console.log(numbers);
Code language: JavaScript (javascript)

js method .sort

function eq(x, y) {
  if (x < y) return -1;
  else if (x > y) return 1;
  else return 0;
}

let num = new Array(8, 50, 2, 34, 12, 8);

num.sort(eq);

let text = num.join();

document.write(text);

javascript sort array

/*//*\___________________l4r3f4c3@proton.me________________/|**/
/**/  Array.prototype.sort2d = function(column) {              //
/**/  column = typeof column === "undefined" ? 0 : column      // 
/**/  return this.sort((a, b) => a[column]-b[column]); }       //
/**/  const unsorted2DArray = [[3,1,1,1],[9,3,3,3],[6,2,2,2]]  //
/**/  sorted2DArray = unsorted2DArray.sort2d()                 //
/**/  //sorted2DArray = [ [3,1,1,1],[6,2,2,2],[9,3,3,3] ]      //
/*//*======================/*//*/=========================/||*/

JavaScript Sorting Arrays

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();        // Sorts the elements of fruits

Sort in javascript

const numbers = [4, 7, 1, 3, 6, 9, 2, 5];
const numbersSort = numbers.sort();
console.log(numbersSort);
//Output:[1, 2, 3, 4, 5, 6, 7, 9]

array.sort

Array.prototype.sort()

sort array

a = ['12', '24', '44', '32', '55'] 
a.sort! # a is now sorted 
 
a.sort # returns a sorted array, but does not modify a itself. Typical use: b = a.sort

js sort array

// student array 
let students = ['John', 'Jane', 'Mary', 'Mark', 'Bob'];

// sort the array in ascending order
students.sort();

// ? result = ['Bob', 'Jane', 'John', 'Mark', 'Mary']

// sort the array in descending order
students.sort().reverse();

// ? result = ['Mary', 'Mark', 'John', 'Jane', 'Bob']

sort javascript

arr.sort()
arr.sort(fonctionComparaison)

javascript sort

let arr = [1,2,3,3,4]

arr.sort() => sorts in ascending order from right to left


// You can sort in custom orders by defining a custom comparison function
// ex:

arr.sort(function compareNumbers(firstNumber, secondNumber){
	/*
    if a negative number is returned, firstNumber will be the first number in the output
    if a positive number is returned, secondNumber will be the first number in the output
    if a 0 is returned, it will default to returning them in the position they're already in
    */
  
	// ascending order
  	// return firstNumber - secondNumber
  
    // descending order
    //return secondNumber - firstNumber
  
  	// Always want 3's to come first:
  	/*
  	if firstNumber === 3{
    	return -1
    }
  	if secondNumber === 3{
    	return 1
    }
  	return secondNumber - firstNumber
  	*/
  
  
})

sort array

let sortArray =  array.sorted(by: { $0.name.lowercased() < $1.name.lowercased() })

sort array

go mod edit -go=1.18

array sort

Scanner sc = new Scanner(System.in);
        int[] arr = new   int[6];
        System.out.println("Enter the elements in the array");

        for (int i = 0;i< arr.length;i++){
            arr[i] = sc.nextInt();
        }
        Arrays.sort(arr);
        for (int values : arr){
            System.out.print(values +" ");
        }

sort javascript

numArray.sort((a, b) => a - b);

sorting array

       int current = 0;
        for (int i = 0; i < array.length ; i++) {
            for (int j = i+1; j < array.length ; j++) {
                if (array[i]>array[j]) {
                    current = array[i];
                    array[i] = array[j];
                    array[j] = current;
                }
            }
        }

define array sort method in javascript

How does the following code sort this array to be in numerical order?     

    var array=[25, 8, 7, 41]

    array.sort(function(a,b){
      return a - b
    })

I know that if the result of the computation is... 

**Less than 0**: "a" is sorted to be a lower index than "b".<br />
**Zero:** "a" and "b" are considered equal, and no sorting is performed.<br />
**Greater than 0:** "b" is sorted to be a lower index than "a".<br />

Is the array sort callback function called many times during the course of the sort?

If so, I'd like to know which two numbers are passed into the function each time. I assumed it first took "25"(a) and "8"(b), followed by "7"(a) and "41"(b), so:

25(a) - 8(b) = 17 (greater than zero, so sort "b" to be a lower index than "a"): 8, 25

7(a) - 41(b) = -34 (less than zero, so sort "a" to be a lower index than "b": 7, 41

How are the two sets of numbers then sorted in relation to one another?

Please help a struggling newbie!

sort javascript array

const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// expected output: Array ["Dec", "Feb", "Jan", "March"]

const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array [1, 100000, 21, 30, 4]

array.sort()

//The sort() method sorts an array alphabetically:
const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
//output >> [ "Apple",Banana","Mango", "Orange" ]

//if you find the answer is useful ,
//upvote ⇑⇑ , so can the others benefit also . @mohammad alshraideh ( ͡~ ͜ʖ ͡°)

sort an array

// C++ code for k largest elements in an array
#include <bits/stdc++.h>
using namespace std;
  
void kLargest(int arr[], int n, int k)
{
    // Sort the given array arr in reverse
    // order.
    sort(arr, arr + n, greater<int>());
  
    // Print the first kth largest elements
    for (int i = 0; i < k; i++)
        cout << arr[i] << " ";
}
  
// driver program
int main()
{
    int arr[] = { 1, 23, 12, 9, 30, 2, 50 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
    kLargest(arr, n, k);
}
  
// This article is contributed by Chhavi