JavaScript Fonksiyonları

Array.prototype.at()

Bu fonksiyon bir değeri sayi olan bir index alır. Pozitif veya negatif değerler alabilir. Negatif değer alır ile dizinin sonundan saymaya başlar ve ilk değeri 0 değildir.

index.js

let index = 1;

console.log(`${index}. index değeri ${array.at(index)}`);
// 1. index değeri 13

index = -1;
console.log(`${index}. index değeri ${array.at(index)}`);
// -1. index değeri 98

index = 8;
console.log(`${index}. index değeri ${array.at(index)}`);
// 8. index değeri undefined

lenght değerini okur ve o değere kadar arama yapar. Değeri kapsamı dışında ise undefiend döner.

index.js

const arrayItem = {
  length: 2,
  0: "a",
  1: "b",
  2: "c",
};

console.log(Array.prototype.at.call(arrayItem, 0));
// "a"

console.log(Array.prototype.at.call(arrayItem, 2));
// undefined

Array.prototype.concat()

concat iki veya daha fazla diziyi birleştirmek için kullanır. Mevcut dizileri değiştirmez yeni bir dizi oluşturur.

index.js

const array1 = ["a", "b", "g", "h"];
const array2 = ["c", "r", "t", "z"];

const newArray = array1.concat(array2);
console.log(newArray);
// [ 'a', 'b', 'g', 'h', 'c', 'r', 't', 'z' ]

const array1 = ["a", "b", "g", "h"];
const array2 = ["c", "r", "t", "z"];
const array3 = ["f", "i", "s", "w"];

const newArray2 = array1.concat(array2, array3);
console.log(newArray);
//[ 'a', 'b', 'g', 'h','c', 'r', 't', 'z','f', 'i', 's', 'w']

SYNTAX

index.js

concat();
concat(value1);
concat(value1, value2);
concat(value1, value2, /* …, */ valueN);

concat(), tüm dizi benzeri nesneleri varsayılan olarak diziler olarak ele almaz; yalnızca Sembol.isConcatSpreadable doğru bir değere (ör. true) ayarlanmışsa. Örnekte obj1 olduğu gibi kullanılırsa sonucu obje olarak alınır bir elemanlı bir obje gibi array a obje olarak katılır. [Symbol.isConcatSpreadable]: true ifedesi objenin array olarak işlem görmeisin sağlar

index.js

const obj1 = { 0: 1, 1: 2, 2: 3, length: 3 };
const obj2 = { 0: 1, 1: 2, 2: 3, length: 3, [Symbol.isConcatSpreadable]: true };
console.log([0].concat(obj1, obj2));
// [ 0, { '0': 1, '1': 2, '2': 3, length: 3 }, 1, 2, 3 ]

sparse array yapısı seyrek ise

index.js

console.log([1, , 3].concat([4, 5])); // [1, empty, 3, 4, 5]
console.log([1, 2].concat([3, , 5])); // [1, 2, 3, empty, 5]

entries

index.js

const arrayLife = [{ name: "Sefa" }, { name: "Miraç" }, { name: "Ege" }];
const iterator = arrayLife.entries();

console.log(iterator.next().value);
[0, { name: "Sefa" }];

console.log(iterator.next().value);
[1, { name: "Miraç" }];

console.log(iterator.next().value)[(2, { name: "Ege" })];

iterator tanımlandığında her adımda *next() metodu ile bir adım leriye atar ve orda kalır. Bir next metodunda kaldığı yerden devam eder.
for ..of

index.js

const arrayLife = [{ name: "Sefa" }, { name: "Miraç" }, { name: "Ege" }];
for (let element of arrayLife.entries()) {
  console.log(element);
}
//[ 0, { name: 'Sefa' } ]
//[ 1, { name: 'Miraç' } ]
//[ 2, { name: 'Ege' } ]

index.js

const arrayLife = [{ name: "Sefa" }, { name: "Miraç" }, { name: "Ege" }]
for (let [index, element] of arrayLife.entries()) {
    console.log(index, element);
}
// 0 { name: 'Sefa' }
// 1 { name: 'Miraç' }
// 2 { name: 'Ege' }

index.js

for (let element of [,"a"]){
    console.log(element);
}
// undefined
// a

index.js


const arrayLike = {
    length: 3,
    0: "a",
    1: "b",
    2: "c",
    3: "d", // ignored by entries() since length is 3
  };
  for (const entry of Array.prototype.entries.call(arrayLike)) {
    console.log(entry);
  }

// [ 0, 'a' ]
// [ 1, 'b' ]
// [ 2, 'c' ]

Array.prototype.every()

every() oluşturulan doğrulama sonucunda eğer arraylerin tümü bu doğrulamaya uyuyor ise yanıt olarak true herhangi biri ymuyosa false döner. Yöntem her değeri dolaşırken verilen doğrulamaya uymaya element var ise aramayı durudurur ve false döner.

Bütün array elemanlarının 90dan küçük olma durumunu kontrol edelim. Değer olarak true dönecektir. Bütün elemanlar 90dan küçüktür. true olarak değer dönecektir. 50 den büyük olma durumu ise false olarak dönecektir.

index.js


const newArray = [20, 34, 56, 78, 45, 12]

const isCheck = newArray.every((item) => item < 90)
console.log(isCheck);
// true

const isCheck2 = newArray.every((item) => item > 50)
console.log(isCheck2);
// false

Bir dizinin diğer bir dizizinin alt kümesi olduğunu kontrol etme

every() metonu ile array2 dolaşılacak daha sonra her item array1 içinde var mı diyerek kontrol edilecek icludes fonksiyonu ile böylelikle every return olarak boolean değer döner. includes bu değeri dağlayacaktır. array2 n,n bütün eelemanları eğer array1 inicde var ise** true yoksa false dönecektir.

index.js


const array1 = [10, 12, 14, 16, 18, 20, 22]
const array2 = [10, 12, 14]
const array3 = [10, 15, 25]

const isSubset = (array1, array2) => array2.every((item) => array1.includes(item))
console.log(isSubset(array1, array2));
// true
console.log(isSubset(array1,array3));
// false

every() üçüncü argüman olarak kullanma

arrayDizideki başka bir öğeye erişmek istiyorsanız bu argüman kullanışlıdır. Aşağıdaki örnek önce filter() pozitif değerleri çıkarmak için kullanır ve ardından every() dizinin tam olarak artıp artmadığını kontrol etmek için kullanır.

index.js


const newArray = [-2, 10, 20, 40, -1, 25]

const isIncreasing = newArray
    .filter((num) => num > 0)
    .every((num, idx, arr) => {
        console.log(num);
        console.log(idx);
        console.log(arr);
        if (idx === 0) return true;
        return num > arr[idx - 1]
      })

console.log(isIncreasing);

Seyrek dizilerde *Every() işlevini kullanma

index.js


console.log([1, , 3].every((x) => x !== undefined)); // true
console.log([2, , 2].every((x) => x === 2)); // true

Dizi dışı nesnelerde every() öğesinin çağrılması

Yöntem, özelliğini every() okur ve ardından her bir özelliğe , hepsine erişilene veya dönene kadar, negatif olmayan bir tamsayı anahtarıyla erişir .lengthth islength callbackFnfalse

index.js


const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: 345, // uzunluk 3 olduğundan, every    () tarafından göz ardı edilir
};
console.log(
  Array.prototype.every.call(arrayLike, (x) => typeof x === "string"),
); // true

Array.prototype.filter()

filter() Örnekler yöntemi, belirli bir dizinin bir kısmının yüzeyselArray bir kopyasını oluşturur ve yalnızca belirli dizideki, sağlanan işlev tarafından uygulanan testi geçen öğelere kadar filtrelenir.

hiçbir öğe testi geçemez ise boş döndürür.
string array içerisinde harf sayısının belli bir değerden büyük olması durumunu inceleyim.

index.js

const words = ['spray', 'elite', 'exuberant', 'destruction', 'present'];
const minLenght = 6;

const newWords = words.filter((word) => word.length > minLenght)
console.log(newWords);
// [ 'exuberant', 'destruction', 'present' ]

SYNTAX

index.js

filter(callbackFn)
filter(callbackFn, thisArg)

Bir array içerisinde asal sayıları bullaum.

index.js


const array = [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];

const isPrime = (num) => {
    for (let i = 2; i < num; i++) {
        if (num % i === 0) {
            return false;
        }
    }
    return num > 1
}

const primeArray = array.filter(isPrime)

console.log(primeArray);
// [ 2, 3, 5, 7, 11, 13 ]

geçerli ve geçersiz id lerin bulunması Number.isFinite() bir sayı Infinity, bir sayı null, bir sayı empty durumlarında false döndürür. Sasyının sonlumu sonsuz mu olduğnu belirler.

index.js

const array = [
    { id: 15 },
    { id: -1 },
    { id: 0 },
    { id: 3 },
    { id: 12.2 },
    {},
    { id: null },
    { id: NaN },
    { id: "undefined" },
];
let invalitEntries = 0;

const filterByID = (item) => {
    if (Number.isFinite(item.id) && item.id !== 0) {
        return true;
    }
    invalitEntries++;
    return false;
}

const arrByID = array.filter(filterByID);

console.log("Filitrelenmiş Array\n",arrByID);
// Filitrelenmiş Array
// [ { id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 } ]

console.log("Geçersiz idler\n",invalitEntries);
// Geçersiz idler
// 5

Dizi olmayan nesnelerde array çağırılması

index.js


const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: "a", // ignored by filter() since length is 3
};
console.log(Array.prototype.filter.call(arrayLike, (x) => x <= "b"));
// [ 'a', 'b' ]

Üçüncü argümanını kullanma

array Dizideki başka bir öğeye erişmek istiyorsanız, özellikle de diziye başvuran mevcut bir değişkeniniz olmadığında bu argüman kullanışlıdır. Aşağıdaki örnek, ilk önce map() her addan sayısal kimliği çıkarmak için kullanır ve ardından filter() komşularından daha büyük olanları seçmek için kullanır.

index.js


const names = ["JC63", "Bob132", "Ursula89", "Ben96"];
const greatIDs = names
  .map((name) => parseInt(name.match(/[0-9]+/)[0], 10))
  .filter((id, idx, arr) => {
// arr argümanı olmadan, diziye kolayca erişmenin bir yolu yoktur.
// bir değişkene kaydetmeden ara dizi.
    if (idx > 0 && id <= arr[idx - 1]) return false;
    if (idx < arr.length - 1 && id <= arr[idx + 1]) return false;
    return true;
  });
console.log(greatIDs); // [132, 96]

Argüman , oluşturulmakta olan dizi array değildir ; oluşturulmakta olan diziye geri çağırma işlevinden erişmenin bir yolu yoktur.

Array.prototype.find()

find() Örneklerin yöntemi, sağlanan Arraydizide sağlanan test işlevini karşılayan ilk öğeyi döndürür. Hiçbir değer test fonksiyonunu karşılamıyorsa undefined döndürülür.

Dizide bulunan öğenin dizinine ihtiyacınız varsa kullanın findIndex()
Bir değerin dizinini bulmanız gerekiyorsa kullanın indexOf(). (Buna benzer findIndex(), ancak bir test işlevi kullanmak yerine her öğenin değerle eşitliğini kontrol eder.)
Bir dizide bir değerin bulunup bulunmadığını bulmanız gerekiyorsa kullanın includes(). Yine, bir test işlevi kullanmak yerine her öğenin değerle eşitliğini kontrol eder.
Herhangi bir öğenin sağlanan test işlevini karşılayıp karşılamadığını bulmanız gerekiyorsa kullanın some().

index.js

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

const found = array1.find((element) => element > 10);

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

SYNTAX

inndex.js


find(callbackFn)
find(callbackFn, thisArg)

Sağlanan test fonksiyonunu karşılayan dizideki ilk öğe. Aksi takdirde undefinediade edilir.

Bir dizideki bir nesneyi özelliklerinden birine göre bulun

index.js


const inventory = [
    { name: "apples", quantity: 2 },
    { name: "bananas", quantity: 0 },
    { name: "cherries", quantity: 5 },
  ];

  const isCherries = (item)=>{
    return item.name === "cherries";
  }

  const selected = inventory.find(isCherries)

  console.log(selected);
// { name: 'cherries', quantity: 5 }

Bir dizide asal sayı bulma

index.js

const isPrime = (element, index, arr) => {
    let start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) {
            return false;
        }
        return element > 1
    }
}

console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
console.log([4, 5, 8, 12].find(isPrime)); // 5

Seyrek dizilerde find() işlevini kullanma

index.js

// Dizini 2, 3 ve 4 numaralı indekslerde hiçbir öğe olmadan tanımlıyoruz
const array = [0, 1, , , , 5, 6];

// Yalnızca atanmış değerleri olan indeksleri değil, tüm indeksleri gösterir
array.find((value, index) => {
  console.log("Visited index", index, "with value", value);
});
// 0 değeriyle ziyaret edilen dizin 0
// 1 değeriyle ziyaret edilen dizin 1
// Tanımsız değerle ziyaret edilen dizin 2
// Değeri tanımsız olan dizin 3'ü ziyaret edildi
// Değeri tanımsız olan dizin 4'ü ziyaret edildi
// 5 değeriyle ziyaret edilen dizin 5
// 6 değeriyle ziyaret edilen dizin 6

// Silinen dizinler dahil tüm dizinleri gösterir
array.find((value, index) => {
// İlk yinelemede 5. öğeyi sil
if (index === 0) {
    console.log("Deleting array[5] with value", array[5]);
    delete array[5];
  }
// Öğe 5 silinmiş olsa bile hala ziyaret ediliyor
console.log("Visited index", index, "with value", value);
});
// 5 değerine sahip dizi[5] siliniyor
// 0 değeriyle ziyaret edilen dizin 0
// 1 değeriyle ziyaret edilen dizin 1
// Tanımsız değerle ziyaret edilen dizin 2
// Değeri tanımsız olan dizin 3'ü ziyaret edildi
// Değeri tanımsız olan dizin 4'ü ziyaret edildi
// Tanımsız değerle ziyaret edilen dizin 5
// 6 değeriyle ziyaret edilen dizin 6

Üçüncü argümanını kullanma

array Dizideki başka bir öğeye erişmek istiyorsanız, özellikle de diziye başvuran mevcut bir değişkeniniz olmadığında bu argüman kullanışlıdır. Aşağıdaki örnek önce filter() pozitif değerleri çıkarmak için kullanır ve ardından find() komşularından daha küçük olan ilk öğeyi bulmak için kullanır.

index.js

const numbers = [3, -1, 10, 4, 10, 5, 9, 2, 6];

const firstTrough = numbers
  .filter((num) => num > 0)
  .find((num, idx, arr) => {
 // arr argümanı olmadan, diziye kolayca erişmenin bir yolu yoktur.
 // bir değişkene kaydetmeden ara dizi.
    if (idx > 0 && num >= arr[idx - 1]) return false;
    if (idx < arr.length - 1 && num >= arr[idx + 1]) return false;
    return true;
  });
console.log(firstTrough); // 3

Array.prototype.some()

Eğer dizi içerisinde şartı sağlayan bir eleman var ise true döndürür.
Array değiştirmez.
true yanıtını bulduğunda sonllanır.
Aranan özellik yok ise false döner
Boş ise false
Dizi içerisinde çift var mı?

index.js


const array = [13,34,2,6,87,16,4]

// Checks whether an element is even

const even = (number) => {
    console.log(number);
    return number%2 === 0}

const isEven = array.some(even)

console.log(isEven);
// true

SYNTAX

index.js

some(callbackFn)
some(callbackFn, thisArg)

Dizi elemanlarının değerinin test edilmesi

index.js


const isBiggerThan10 = (num, idx, arr) => num > 10;

console.log([2, 5, 8, 1, 4].some(isBiggerThan10)) // false
console.log([12, 5, 8, 1, 4].some(isBiggerThan10)); // true

Bir dizide bir değerin olup olmadığını kontrol etme

index.js


const fruits = ["apple", "banana", "mango", "guava"];

const checkAvailability = (arr,value) => arr.some((item)=>item===value);

console.log(checkAvailability(fruits,"apple"));
console.log(checkAvailability(fruits,"kiwi"));

Array.prototype.includes()

includes() Örneklerin yöntemi, bir Array dizinin girdileri arasında belirli bir değeri içerip içermediğini, döndürüp döndürmediğini true veya false uygun olup olmadığını belirler.

index.js


const array1 = [1, 2, 3,23,54,76,34];
console.log(array1.includes(2))
// true

const fruits = ["apple", "banana", "mango", "guava"];

console.log(fruits.includes('apple'));
// true

console.log(fruits.includes('app'));
// false

SYNTAX

index.js


includes(searchElement)
includes(searchElement, fromIndex)

fromIndex dizi uzunluğundan büyük veya ona eşit
fromIndexAramanın başllatılacağı sıfır tabanlı dizin
fromIndex değeri arrayın boyutuna length eşit veya büyük ise false döner
fromIndex değeri index = length - fromIndex hesaplanır eğer hesaplana index length uzunlupundan küçük veya eşit ise dizinin tamamı aranacak.

Array.prototype.splice()

splice() Örneklerin yöntemi, mevcut öğeleri kaldırarak veya değiştirerek ve/veya *yerine Array yeni öğeler ekleyerek bir dizinin içeriğini değiştirir .

SYNTAX

index.js

splice(start)
splice(start, deleteCount)
splice(start, deleteCount, item1)
splice(start, deleteCount, item1, item2)
splice(start, deleteCount, item1, item2, /* …, */ itemN)

Negatif dizin, dizinin sonundan geriye doğru sayar; eğer start < 0 kullanılırsa start + array.length.
start < -array.length, kullanılıyorsa 0.
Eğer öyleyse start >= array.length, hiçbir öğe silinmeyecek, ancak yöntem, sağlanan sayıda öğeyi ekleyerek bir ekleme işlevi gibi davranacaktır.
Atlanırsa start(ve splice()bağımsız değişken olmadan çağrılırsa), hiçbir şey silinmez. undefinedBu , dönüştürülen pass'tan farklıdır 0
Dizin 2'den önceki 0 (sıfır) öğeyi kaldırın ve "tambur" ekleyin

index.js


const myFish = ["angel", "clown", "mandarin", "sturgeon"];

const removed = myFish.splice(2,0,"Tambur");

console.log(myFish);
console.log(removed);

// myFish şu şekildedir: ["melek", "palyaço", "davul", "mandalina", "mersin balığı"]
// kaldırılan [], hiçbir öğe kaldırılmadı

Dizin 2'den önceki 0 (sıfır) öğeyi kaldırın ve "drum" ve "guitar" ekleyin

index.js

const myFish = ["angel", "clown", "mandarin", "sturgeon"];

const removed = myFish.splice(2,0,"drum","guitar")

console.log(myFish);
console.log(removed);

//  [ 'angel', 'clown', 'drum', 'guitar', 'mandarin', 'sturgeon' ]
// kaldırılan [ ], hiçbir öğe kaldırılmadı

0 dizinindeki 0 (sıfır) öğeyi kaldırın ve "angel" ekleyin

index.js


const removed = myFish.splice(0,0,"angel")

console.log(myFish);
console.log(removed);
// [ 'angel', 'clown', 'mandarin', 'sturgeon' ]
// []

Son dizindeki 0 (sıfır) öğeyi kaldırın ve "sturgeon" ekleyin

index.js

const myFish = ["angel", "clown", "mandarin"];

const removed = myFish.splice(myFish.length,0,"sturgeon") 

console.log(myFish);
console.log(removed);

// [ 'angel', 'clown', 'mandarin', 'sturgeon' ]
// []

Dizin 3'teki 1 öğeyi kaldır

index.js

const myFish = ["angel", "clown", "drum", "mandarin", "sturgeon"];

const removed = myFish.splice(3,1);
console.log(myFish);
// [ 'angel', 'clown', 'drum', 'sturgeon' ]

console.log(removed);
// [ 'mandarin' ]

Dizin 2'deki 1 öğeyi çıkarın ve "trumpet" ekleyin

index.js


const myFish = ["angel", "clown", "drum", "sturgeon"];

const removed = myFish.splice(2,1,"trumpet")

console.log(myFish);
// [ 'angel', 'clown', 'trumpet', 'sturgeon' ]

console.log(removed);
// [ 'drum' ]

0 dizininden 2 öğeyi çıkarın ve "parrot", "anemone" ve "blue" ekleyin

index.js

const myFish = ["angel", "clown", "trumpet", "sturgeon"];
const removed = myFish.splice(0,2,"parrot","anemone","blue")

console.log(myFish);
// [ 'parrot', 'anemone', 'blue', 'trumpet', 'sturgeon' ]

console.log(removed);
// [ 'angel', 'clown' ]

Dizin 2'den başlayarak 2 öğeyi kaldırın

inndex.js

const myFish = ["parrot", "anemone", "blue", "trumpet", "sturgeon"];

const removed = myFish.splice(2,2);

console.log(myFish);
 // [ 'parrot', 'anemone', 'sturgeon' ]

console.log(removed);
// [ 'blue', 'trumpet' ]

-2 dizininden 1 öğeyi kaldır

index.js

const myFish = ["angel", "clown", "mandarin", "sturgeon"];
const removed = myFish.splice(-2,1)

console.log(myFish);
// [ 'angel', 'clown', 'sturgeon' ]

console.log(removed);
// [ 'mandarin' ]

Dizin 2'den başlayarak tüm öğeleri kaldırın

inde.js

const myFish = ["angel", "clown", "mandarin", "sturgeon"];
const removed = myFish.splice(2)

console.log(myFish);
// [ 'angel', 'clown' ]

console.log(removed);
// [ 'mandarin', 'sturgeon' ]

Seyrek dizilerde splice() işlevini kullanma

index.js

const arr = [1, , 3, 4, , 6];
console.log(arr.splice(1, 2)); // [empty, 3]
console.log(arr); // [1, 4, empty, 6]

Array.prototype.entries()

entries() Örneklerin yöntemi, dizideki her dizin için key/value çiftlerini içeren Array yeni bir dizi yineleyici nesnesi döndürür. next ileri hareket ettirir ve bir sonraki value değerini verir. Eğer geziilecek eleman length boyutunu geçer ise undefined değerini veirir.

index.js

const array1 = ['a', 'b', 'c'];

const arrayEntries = array1.entries();

console.log(arrayEntries.next().value);
// [ 0, 'a' ]

console.log(arrayEntries.next().value);
// [ 0, 'a' ]
console.log(arrayEntries.next().value);
// [ 2, 'c' ]

console.log(arrayEntries.next().value);
// undefined

Dizin ve öğeyle yineleme

index.js

const a = ["a", "b", "c"];

for(let [index,element] of a.entries()){
    console.log(`Key : ${index} Value : ${element}`);
}

// Key : 0 Value : a
// Key : 1 Value : b
// Key : 2 Value : c

For...of döngüsü kullanma

index.js

const array = ["a", "b", "c"];
const arrayEntries = array.entries();

for (let [index, element] of arrayEntries) {
    console.log(`Key : ${index} Value : ${element}`);
}

// Key : 0 Value : a
// Key : 1 Value : b
// Key : 2 Value : c

Seyrek dizileri yineleme

index.js

for (const element of [, "a"].entries()) {
  console.log(element);
}
// [0, undefined]
// [1, 'a']

Dizi olmayan nesnelerde entry() çağrılması

index.js

const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: "d", // ignored by entries() since length is 3
};
for (const entry of Array.prototype.entries.call(arrayLike)) {
  console.log(entry);
}
// [ 0, 'a' ]
// [ 1, 'b' ]
// [ 2, 'c' ]

Array.from()

Statik yöntem, yinelenebilir veya dizi benzeri Array.from() bir nesneden yeni, sığ kopyalanmış bir Array örnek oluşturur .

Örnek string parçalayarak dizi yapar.
Yöntemlw değerler ayarlanabilir. Yeni farklı bir dizi döndürür

index.js

const stringArray = Array.from("foo")
console.log(stringArray);
[ 'f', 'o', 'o' ]

const array = [1, 2, 3, 4, 5, 6];
const increaseY = (x)=>x + x
const newArray = Array.from(array,increaseY)
console.log(newArray);
// [ 2, 4, 6, 8, 10, 12 ]

SYNTAX

index.js

Array.from(arrayLike)
Array.from(arrayLike, mapFn)
Array.from(arrayLike, mapFn, thisArg)

Array.from() asla seyrek bir dizi oluşturmaz. Nesnede arrayLikebazı indeks özellikleri eksikse bunlar undefined yeni dizide yer alır.
Bir Dizeden Dizi

index.js

Array.from("foo");
// [ "f", "o", "o" ]

Bir Kümeden Dizi

index.js

const map = new Map([[1, 1], [2, 2], [3, 3], [4, 4]]);

const arr = Array.from(map);

console.log(arr);
// [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ] ]

const map2 = new Map([[1, "a"], [2, "b"], [3, "c"], [4, "d"]]);

const arrayKeys = Array.from(map2.keys());
console.log(arrayKeys);
// [ 1, 2, 3, 4 ]

const arrayValue = Array.from(map2.values())
console.log(arrayValue);
// [ 'a', 'b', 'c', 'd' ]

NodeList'ten dizi

Örnekte DOM kullnaılarak img ler bir array de toplanır. Array.from() kullanılarak linklerden oluşan yeni bi dizi oluşturulur. filter yardımı ve startsWith string ifedede "http://" başlayan linkler insecureSources dizisi oluşturulur.

index.js


//DOM Öğelerinin bir özelliğini temel alan bir dizi oluşturun
const images = document.querySelectorAll("img");
const sources = Array.from(images, (image) => image.src);
const insecureSources = sources.filter((link) => link.startsWith("http://"));

Array benzeri bir nesneden gelen dizi (argümanlar)

index.js


function f() {
  return Array.from(arguments);
}

f(1, 2, 3);

// [ 1, 2, 3 ]

Ok işlevlerini ve Array.from() işlevini kullanma

index.js


// Harita işlevi olarak bir ok işlevini kullanma
// elemanları işliyoruz
Array.from([1, 2, 3], (x) => x + x);
// [2, 4, 6]

// Bir sayı dizisi oluştur
// Dizi her konumda 'tanımsız' ile başlatıldığından,
// aşağıdaki 'v'nin değeri 'tanımsız' olacak

Array.from({ length: 5 }, (v, i) => i);
// [0, 1, 2, 3, 4]

Sıra üreteci (aralık)

// Sıra oluşturucu işlevi (genellikle "aralık" olarak anılır, örneğin Clojure, PHP, vb.)

index.js


const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step)

// 0..4 aralığında sayılar üret
console.log(range(0, 4, 1));
// [ 0, 1, 2, 3, 4 ]


// 2'lik adımlarla 1..10 aralığındaki sayıları üret
console.log(range(1, 10, 2))
/// [ 1, 3, 5, 7, 9 ]

// Array.from'u kullanarak alfabenin bir dizi olarak sıralanmasını kullanarak alfabeyi oluşturun
const alphabetCode = range("A".charCodeAt(0),"Z".charCodeAt(0),1)
const alphabets = alphabetCode.map((x)=>String.fromCharCode(x));
console.log(alphabets);

// [ 'A', 'B', 'C', 'D', 'E', 'F','G', 'H', 'I', 'J', 'K', 'L','M', 'N', 'O', 'P', 'Q', 'R','S', 'T', 'U', 'V', 'W', 'X','Y', 'Z']

charCodeAt() Değerler yöntemi, verilen dizindeki UTF-16 kod birimi arasında ve onu temsil eden Stringbir tamsayı döndürür .065535
String.fromCharCode() Statik String.fromCharCode() yöntem, belirtilen UTF-16 kod birimleri dizisinden oluşturulan bir dizeyi döndürür.
Dizi olmayan kurucularda from() öğesinin çağrılması Yöntem from(), yeni dizinin uzunluğunu temsil eden tek bir argümanı kabul eden herhangi bir yapıcı fonksiyonda çağrılabilir.

index.js


function NotArray(uzunluk) {
   console.log("NotArray uzunlukla çağrıldı", len);
}

// Iterable
console.log(Array.from.call(NotArray, new Set(["foo", "bar", "baz"])));
// NotArray uzunluğu tanımsız olarak çağrıldı
// NotArray { '0': 'foo', '1': 'bar', '2': 'baz', uzunluk: 3 }

// Array-like
console.log(Array.from.call(NotArray, { uzunluk: 1, 0: "foo" }));
// NotArray uzunluğu 1 ile çağrıldı
// NotArray { '0': 'foo', uzunluk: 1 }

Değer thisbir yapıcı olmadığında düz bir Arraynesne döndürülür.

index.js

console.log(Array.from.call({}, { length: 1, 0: "foo" })); // [ 'foo' ]

Array.prototype.sort()

sort() bir arrayi sıralar. Varsayılan sıralama düzeni arandır. Öğelerin dizelere dönüştürülmesi ve ardından bunların UTF-16 kod birimi değerlerinin sıralarının karşılaştırılması üzerine kuruludur.

index.js


const fruits = ["Grape", "Grapefruit", "Lemon", "Strawberry", "Apple", "Apricot", "Banana", "Cherry"]
const arraySort = fruits.sort();
console.log(arraySort);
//['Apple','Apricot','Banana','Cherry','Grape','Grapefruit','Lemon','Strawberry']

const numbers = [17, 12, 29, 31, 159, 158, 23, 17];
const numberSort = numbers.sort();
console.log(numberSort.sort());
// [12, 158, 159, 17, 17, 23, 29, 31]
// sort() metodu sayıları sıralar iken ilk değeri kullanır tam bir sıralama için başka alternatifler verdır.

SYNTAX

index.js

sort()
sort(compareFn)

*compareFn Sıralama düzenini tanımlayan bir işlev. Dönüş değeri, işareti iki öğenin göreli sırasını gösteren bir sayı olmalıdır: küçükse negatif a, bbüyükse pozitif ave beşitse sıfır. NaNolarak ele alınır 0. İşlev aşağıdaki bağımsız değişkenlerle çağrılır:
a Karşılaştırma için ilk öğe. Asla undefined olmamalı.
b Karşılaştırma için ikinci unsur. Asla undefined olmamalı.
Atlanırsa dizi öğeleri dizelere dönüştürülür ve ardından her karakterin Unicode kod noktası değerine göre sıralanır.

index.js



fonksiyon karşılaştırmaFn(a, b) {
  if (a, bazı sıralama kriterlerine göre b'den küçükse) {
    return -1;
  } else if (a, sıralama kriterine göre b'den büyüktür) {
    return 1;
  }
  // a, b'ye eşit olmalıdır
    return 0;

}

Diziyi artan sıralama ölçüsünde artıracaktır.

index.js

function compareNumbers(a, b) {
  return a - b;
}

index.js


const comporeNumbers = (a, b) => {
  return a - b;
}

const stringArray = ["Blue", "Humpback", "Beluga"];
const numberArray = [40, 1, 5, 200];
const numericStringArray = ["80", "9", "700"];
const mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];

const arrayString = stringArray.join(); 
const arraySort1 = stringArray.sort(); 
console.log(arrayString);// Blue,Humpback,Beluga
console.log(arraySort1); // [ 'Beluga', 'Blue', 'Humpback' ]

const string2 = numberArray.join();
console.log(string2); // 40,1,5,200
const arraySort2 = numberArray.sort();
console.log(arraySort2); // [ 1, 200, 40, 5 ]
const arrayCompore1= numberArray.sort(comporeNumbers);
console.log(arrayCompore1); // [ 1, 5, 40, 200 ]


const string3 = numericStringArray.join();
console.log(string3); // 80,9,700
const arraySort3 = numericStringArray.sort();
console.log(arraySort3);// [ '700', '80', '9' ]
const arrayCompore3 = numericStringArray.sort(comporeNumbers);
console.log(arrayCompore3);// [ '9', '80', '700' ]

const string4 = mixedNumericArray.join();
console.log(string4);// 80,9,700,40,1,5,200
const arraySort4 = mixedNumericArray.sort();
console.log(arraySort4);// [ 1,   200,   40, 5,   '700', '80', '9']
const arrayCompore4 = mixedNumericArray.sort(comporeNumbers);
console.log(arrayCompore4);// [1,     5,    '9',40,    '80', 200,'700']

object sıralanması

index.js


const 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 },
];

const comporeFun = (a, b) => {
  const nameA = a.name.toUpperCase();
  const nameB = b.name.toUpperCase();

  if (nameA < nameB) return -1;

  if (nameA > nameB) return 1;

  return 0;
}

const comporeItems = items.sort(comporeFun);
console.log(comporeItems);
const comporeFun = (a, b) => {
  const nameA = a.name.toUpperCase();
  const nameB = b.name.toUpperCase();

  if (nameA < nameB) return -1;

  if (nameA > nameB) return 1;

  return 0;
}

const comporeItems = items.sort(comporeFun);
console.log(comporeItems);

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

ASCII olmayan karakterleri sıralama

index.js

const items = ["réservé", "premier", "communiqué", "café", "adieu", "éclair"];
items.sort((a, b) => a.localeCompare(b));

// items is ['adieu', 'café', 'communiqué', 'éclair', 'premier', 'réservé']

Sefa DemirtaşSoftware DeveloperSend an email

Sefa Demirtaş

JavaScript Array Fonksiyonları

JavaScript Fonksiyonları

Array.prototype.at()

Array.prototype.concat()

entries

Array.prototype.every()

Array.prototype.filter()

Array.prototype.find()

Array.prototype.some()

Array.prototype.includes()

Array.prototype.splice()

Array.prototype.entries()

Array.from()

Array.prototype.sort()