Rubén Tejera Cordero

sort(): ordena los elementos de un array localmente y devuelve el array. Si se omite la funcion dentro del sort,  el array es ordenado atendiendo a la posición del valor Unicode de cada carácter, según la conversión a string de cada elemento.

var puntos = [1, 10, 2, 21]; 
puntos.sort(); // [1, 10, 2, 21]
// Tenga en cuenta que 10 viene antes que 2
// porque '10' viene antes que '2' según la posición del valor Unicode.

Con la compareFunction:

var arr = [ 40, 1, 5, 200 ];
arr.sort((a,b)=>a-b);  // [ 1, 5, 40, 200 ]

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic' },
  { name: 'Zeros', value: 37 }
];
items.sort(function (a, b) {
  if (a.name > b.name) {
    return 1;
  }
  if (a.name < b.name) {
    return -1;
  }
  // a must be equal to b
  return 0;
});

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/sort

 

reduce(): El método reduce() aplica una función a un acumulador y a cada valor de un array (de izquierda a derecha) para reducirlo a un único valor.

[0,1,2,3,4].reduce(function(valorAnterior, valorActual, indice, vector){
  return valorAnterior + valorActual;
}, 10); //El 10 es el valor inicial

// Primera llamada
valorAnterior = 10, valorActual = 0, indice = 0

// Segunda llamada
valorAnterior = 10, valorActual = 1, indice = 1

// Tercera llamada
valorAnterior = 11, valorActual = 2, indice = 2

// Cuarta llamada
valorAnterior = 13, valorActual = 3, indice = 3

// Quinta llamada
valorAnterior = 16, valorActual = 4, indice = 4

// el array sobre el que se llama a reduce siempre es el objeto [0,1,2,3,4] 

// Valor Devuelto: 20

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/reduce

 

some():  verifica si algún elemento de un array cumple con el test implementado por la función brindada.

function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true


[2, 5, 8, 1, 4].some(elem => elem > 10);  // false
[12, 5, 8, 1, 4].some(elem => elem > 10); // true

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/some

 

every(): verifica si todos los elementos en el arreglo pasan la prueba implementada por la función dada.

function esSuficientementeGrande(elemento, indice, arrreglo) {
  return elemento >= 10;
}
[12, 5, 8, 130, 44].every(esSuficientementeGrande);   // false
[12, 54, 18, 130, 44].every(esSuficientementeGrande); // true


[12, 5, 8, 130, 44].every(elem => elem >= 10); // false
[12, 54, 18, 130, 44].every(elem => elem >= 10); // true

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/every

 

find():  devuelve el valor del primer elemento del array que cumple la función de prueba proporcionada. En cualquier otro caso se devuelve undefined.

var array1 = [5, 12, 8, 130, 44];

var found = array1.find(function(element) {
  return element > 10;
});

console.log(found);
// expected output: 12

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/find

 

findIndex(): devuelve el índice del primer elemento de un array que cumpla con la función de prueba proporcionada. En caso contrario devuelve -1.

var array1 = [5, 12, 8, 130, 44];

function findFirstLargeNumber(element) {
  return element > 13;
}

console.log(array1.findIndex(findFirstLargeNumber));
// expected output: 3

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/findIndex

 

splice(): cambia el contenido de un array eliminando elementos existentes y/o agregando nuevos elementos.

array.splice(indiceDondeEmpezar,elementosAEliminar,elementosAInsertar);


//Eliminar 0 elementos desde el índice 2 e insertar "drum"
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(2, 0, 'drum');

// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"] 
// removed is [], no elements removed


//------------------

//Eliminar 1 elemento desde el índice 3
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
var removed = myFish.splice(3, 1);

// removed is ["mandarin"]
// myFish is ["angel", "clown", "drum", "sturgeon"]


//-----------------

//Eliminar 1 elemento desde el índice 2 e insertar "trumpet"
var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
var removed = myFish.splice(2, 1, 'trumpet');

// myFish is ["angel", "clown", "trumpet", "sturgeon"]
// removed is ["drum"]

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/splice

 

var arr = [1,2,3,4];
arr[9] = 6;

arr; // [1, 2, 3, 4, empty,empty,empty,empty,empty, 6]
arr[6]; // undefined

===   y    !===

Son operadores de comparación ESTRICTA. Significa que si los operandos tienen TIPOS DIFERENTES,  no son iguales.

l1==="1" // false
1!=="1" // true
null === undefined // false

 

==   y    !==

Son operadores de comparación RELAJADA. Significa que si los operandos tienen TIPOS DIFERENTES,  Javascript trata de convertirlos para que fueran comparables.

1=="1" // true
1!="1" // false
null == undefined // true

 

null === undefined // false
null == undefined // true

null === false // false
null == false //false

Detalles del operador ==

La comparación x == y, donde x e y son valores, regresa true o false. Esta comparación se realiza de la siguiente manera:

1. Si Type(x) y Type(y) son los mismos,
   1. Si Type(x) es Undefined, regresa true.
   2. Si Type(x) es Null, regresa true.
   3. Si Type(x) es Number,
      1. Si x es NaN, regresa false.
      2. Si y es NaN, regresa false.
      3. Si x es el mismo valor de Number que y, regresa true.
      4. Si x es +0 e y es −0, regresa true.
      5. Si x es -0 e y es +0, regresa true.
      6. Regresa false.
   4. Si Type(x) es String, regresa true si x e y son exactamente la misma secuencia de caracteres (con la misma longitud y los mismos caracteres en las posiciones correspondientes). En el caso contrario, regresa false.
   5. Si Type(x) es Boolean, regresa true, si x e y ambos son true o ambos son false. En el caso contrario, regresa false.
   6. Regresa true si x e y refieren al mismo objeto. En el caso contrario, regresa false.
2. Si x es null e y es undefined, regresa true.
3. Si x es undefined e y es null, regresa true.
4. Si Type(x) es Number y Type(y) es String,
   regresa el resultado de la comparación x == ToNumber(y).
5. Si Type(x) es String y Type(y) es Number,
   regresa el resultado de la comparación ToNumber(x) == y.
6. Si Type(x) es Boolean, regresa el resultado de la comparación ToNumber(x) == y.
7. Si Type(y) es Boolean, regresa el resultado de la comparación x == ToNumber(y).
8. Si Type(x) es String o Number, y Type(y) es Object,
   regresa el resultado de la comparación x == ToPrimitive(y).
9. Si Type(x) es Object y Type(y) es String o Number,
   regresa el resultado de la comparación ToPrimitive(x) == y.
10. Regresa false.

 

https://es.stackoverflow.com/questions/331/diferencias-entre-y-comparaciones-en-javascript