const isContains = (child, parent) => parent.contains(child);

const hasFocus = ele => (ele === document.activeElement);

const touchSupported = () => ('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch);

const isIE = !!document.documentMode;

const isMacBrowser = /Mac|iPod|iPhone|iPad/.test(navigator.platform);

const siblings = ele => [].slice.call(ele.parentNode.children).filter((child) => (child !== ele));

const getSelectedText = () => window.getSelection().toString();

history.back();

// Ya da
history.go(-1);

// Kullanım durumuna göre seçmek gerek display eleman kaldırıldığında boşluk bırakmaz, visibility de ise boşluğu kalır
const hide = ele => ele.style.display = 'none';

// Ya da
const hide = ele => ele.style.visibility = 'hidden';

const addAfter = (ele, anotherEle) => anotherEle.parentNode.insertBefore(ele, anotherEle.nextSibling);

// Ya da
const addAfter = (ele, anotherEle) => anotherEle.insertAdjacentElement('afterend', ele);

const addBefore = (ele, anotherEle) => anotherEle.parentNode.insertBefore(ele, anotherEle);

// Ya da
const addBefore = (ele, anotherEle) => anotherEle.insertAdjacentElement('beforebegin', ele);

const addHtmlAfter = (html, ele) => ele.insertAdjacentHTML('afterend', html);

const addHtmlBefore = (html, ele) => ele.insertAdjacentHTML('beforebegin', html);

const goTo = url => location.href = url;

const reload = () => location.reload();

// Ya da
const reload = () => (location.href = location.href);

const replace = (ele, newEle) => ele.parentNode.replaceChild(newEle, ele);

const goToTop = () => window.scrollTo(0, 0);

const show = ele => ele.style.display = '';

const stripHtml = html => (new DOMParser().parseFromString(html, 'text/html')).body.textContent || '';

const toggle = ele => (ele.style.display = (ele.style.display === 'none') ? 'block' : 'none');

// `arr` örnek bir dizi
const isEmpty = arr => !Array.isArray(arr) || arr.length === 0;

// Örnekler
isEmpty([]);            // true
isEmpty([1, 2, 3]);     // false

// `arr` örnek bir dizi
const clone = arr => arr.slice(0);

// Ya da
const clone = arr => [...arr];

// Ya da
const clone = arr => Array.from(arr);

// Ya da
const clone = arr => arr.map(x => x);

// Ya da
const clone = arr => JSON.parse(JSON.stringify(arr));

// Ya da
const clone = arr => arr.concat([]);

// `a` ve `b` birer dizi
const isEqual = (a, b) => JSON.stringify(a.sort()) === JSON.stringify(b.sort());

// Örnekler
isEqual([1, 2, 3], [1, 2, 3]);      // true
isEqual([1, 2, 3], [1, 3, 2]);      // true
isEqual([1, 2, 3], [1, '2', 3]);    // false

// `a` ve `b` birer dizi
const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);

// Ya da
const isEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);

// Örnekler
isEqual([1, 2, 3], [1, 2, 3]);      // true
isEqual([1, 2, 3], [1, '2', 3]);    // false

const toObject = (arr, key) => arr.reduce((a, b) => ({ ...a, [b[key]]: b }), {});

// Örnek
toObject(
    [
        { id: '1', isim: 'Hamza', yas: 25 },
        { id: '2', isim: 'Kaya', yas: 27 },
        { id: '3', isim: 'Sedat', yas: 29 },
    ],
    'id'
);
/* 
{
    '1': { id: '1', isim: 'Hamza', yas: 25 },
    '2': { id: '2', isim: 'Kaya', yas: 27 },
    '3': { id: '3', isim: 'Sedat', yas: 29 },
}
*/

const toNumbers = arr => arr.map(Number);

// Ya da
const toNumbers = arr => arr.map(x => +x);

// Örnek
toNumbers(['2', '3', '4']);     // [2, 3, 4]

const groupBy = (arr, key) => arr.reduce((acc, item) => ((acc[item[key]] = [...(acc[item[key]] || []), item]), acc), {});

// Örnek
groupBy([
    { marka: 'audi', model: 'q8', yil: '2019' },
    { marka: 'audi', model: 'rs7', yil: '2020' },
    { marka: 'ford', model: 'mustang', yil: '2019' },
    { marka: 'ford', model: 'explorer', yil: '2020' },
    { marka: 'bmw', model: 'x7', yil: '2020' },
], 'marka');

/*
{
  "audi": [
    { "marka": "audi", "model": "q8", "yil": "2019" },
    { "marka": "audi", "model": "rs7", "yil": "2020" }
  ],
  
  "ford": [
    { "marka": "ford", "model": "mustang", "yil": "2019" },
    { "marka": "ford", "model": "explorer", "yil": "2020" }
  ],

  "bmw": [
    { "marka": "bmw", "model": "x7", "yil": "2020" }
  ]
}
*/

const countBy = (arr, prop) => arr.reduce((prev, curr) => (prev[curr[prop]] = ++prev[curr[prop]] || 1, prev), {});

// Örnek
countBy([
    { marka: 'audi', model: 'q8', yil: '2019' },
    { marka: 'audi', model: 'rs7', yil: '2020' },
    { marka: 'ford', model: 'mustang', yil: '2019' },
    { marka: 'ford', model: 'explorer', yil: '2020' },
    { marka: 'bmw', model: 'x7', yil: '2020' },
], 'marka');

// { 'audi': 2, 'ford': 2, 'bmw': 1 }

const lengthBy = (arr, val) => arr.reduce((a, v) => (v === val ? a + 1 : a), 0);

// Örnekler
lengthBy([2, 1, 3, 3, 2, 3], 2);                // 2
lengthBy(['a', 'b', 'a', 'c', 'a', 'b'], 'a');  // 3

const lengthAll = arr => arr.reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {});

// Örnekler
lengthAll([2, 1, 3, 3, 2, 3]);               // { '1': 1, '2': 2, '3': 3 }
lengthAll(['a', 'b', 'a', 'c', 'a', 'b']);   // { 'a': 3, 'b': 2, 'c': 1 }

const kumulatif = arr => arr.map((sum => value => sum += value)(0));

// Ya da
const kumulatif = arr => arr.reduce((a, b, i) => i === 0 ? [b] : [...a, b + a[i - 1]], []);

// Ya da
const kumulatif = arr => arr.reduce((a, b, i) => i === 0 ? [b] : [...a, b + a[i - 1]], 0);

// Örnek
kumulatif([1, 2, 3, 4]);   // [1, 3, 6, 10]
// 1             = 1
// 1 + 2         = 3
// 1 + 2 + 3     = 6
// 1 + 2 + 3 + 4 = 10

const aralik = (min, max) => [...Array(max - min + 1).keys()].map(i => i + min);

// Ya da
const aralik = (min, max) => Array(max - min + 1).fill(0).map((_, i) => min + i);

// Ya da
const aralik = (min, max) => Array.from({ length: max - min + 1 }, (_, i) => min + i);

// Örnek
aralik(5, 10);   // [5, 6, 7, 8, 9, 10]

// `arr` dizisinde `n` e en yakın eleman
const enYakini = (arr, n) => arr.reduce((prev, curr) => Math.abs(curr - n) < Math.abs(prev - n) ? curr : prev);

// Ya da
const enYakini = (arr, n) => arr.sort((a, b) => Math.abs(a - n) - Math.abs(b - n))[0];

// Örnek
enYakini([29, 87, 8, 78, 97, 20, 75, 33, 24, 17], 50);   // 33

const longStrings = arr => arr.filter(i => i.length === Math.max(...(arr.map(el => el.length))))
const longStringLength = s => Math.max(...(s.map(el => el.length)));

// Örnek
longStrings(['hamza', 'kaya', 'sedat', 'javascript']);  // javascript
longStringLength(['hamza', 'kaya', 'sedat', 'javascript']);  // 10

const max = arr => Math.max(...arr);

const min = arr => Math.min(...arr);

const flat = arr => [].concat.apply([], arr.map(a => Array.isArray(a) ? flat(a) : a));
// Ya da
const flat = arr => arr.reduce((a, b) => Array.isArray(b) ? [...a, ...flat(b)] : [...a, b], []);

// Ya da
// Browser destekliyormu kontrol etmek için https://caniuse.com/#feat=array-flat
const flat = arr => arr.flat();

// Örnek
flat(['kedi', ['aslan', 'kaplan']]);   // ['kedi', 'aslan', 'kaplan']

const ortalama = arr => arr.reduce((a, b) => a + b, 0) / arr.length;

const ortakElamanlar = (a, ...arr) => [...new Set(a)].filter(v => arr.every(b => b.includes(v)));

// Örnekler
ortakElamanlar([1, 2, 3], [2, 3, 4, 5]);               // [2, 3]
ortakElamanlar([1, 2, 3], [2, 3, 4, 5], [1, 3, 5]);    // [3]

const sum = arr => arr.reduce((a, b) => a + b, 0);

const unique = arr => [...new Set(arr)];

// Ya da
const unique = arr => arr.filter((el, i, array) => array.indexOf(el) === i);

// Ya da
const unique = arr => arr.reduce((acc, el) => acc.includes(el) ? acc : [...acc, el], []);

const union = (...arr) => [...new Set(arr.flat())];

// Örnek
union([1, 2], [2, 3], [3], [1,2,3,4]);     // [1, 2, 3, 4]

// birleştir ama tekrar eden elemanları silme
const merge = (a, b) => a.concat(b);
// Ya da
const merge = (a, b) => [...a, ...b];

// birleştir ve tekrar eden elemanları sil
const merge = (a,b) => [...new Set(a.concat(b))];
// Ya da
const merge = (a,b) => [...new Set([...a, ...b])];

const kuralKontrol = (arr, kural) => arr.reduce((acc, i) => (acc[kural(i) ? 0 : 1].push(i), acc), [[], []]);

// Örnek, 2 ye bölünebilme durumlarına göre
kuralKontrol([1, 2, 3, 4, 5], n => n % 2);     // [[2, 4], [1, 3, 5]]

const hatalilariFiltrele = arr => arr.filter(Boolean);

// Örnek
hatalilariFiltrele([0, 'a string', '', NaN, true, 5, undefined, 'another string', false]); // ['a string', true, 5, 'another string']

const rastgele = arr => arr.map(a => ({ sort: Math.random(), value: a })).sort((a, b) => a.sort - b.sort).map(a => a.value);

// Ya da
const rastgele = arr => arr.sort(() => .5 - Math.random());

// Örnek
rastgele([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);   // [9, 1, 10, 6, 8, 5, 2, 3, 7, 4]

const sirala = arr => arr.sort((a, b) => a - b);

// Örnek
sirala([1, 5, 2, 0, 4, 3, -1]);      // [-1, 0, 1, 2, 3, 4, 5]

const grupla = (arr, s) => arr.reduce((acc, e, i) => (i % s ? acc[acc.length - 1].push(e) : acc.push([e]), acc), []);

// Örnekler
grupla([1, 2, 3, 4, 5, 6, 7, 8], 3);        // [[1, 2, 3], [4, 5, 6], [7, 8]]
grupla([1, 2, 3, 4, 5, 6, 7, 8, 9], 4);     // [[1, 2, 3, 4], [5, 6, 7, 8], [9]]

const degistir = matris => matris[0].map((col, i) => matris.map(row => row[i]));

// Ya da
const degistir = matris => matris[0].map((col, c) => matris.map((row, r) => matris[r][c]));

// Ya da
const degistir = matris => matris.reduce((prev, next) => next.map((item, i) => (prev[i] || []).concat(next[i])), []);

// Örnek
degistir([             // [
    [1, 2, 3],          //      [1, 4, 7],
    [4, 5, 6],          //      [2, 5, 8],
    [7, 8, 9],          //      [3, 6, 9],
]);                     //  ]

const unzip = arr => arr.reduce((acc, c) => (c.forEach((v, i) => acc[i].push(v)), acc), Array.from({ length: Math.max(...arr.map(a => a.length)) }, (_) => []));

// Örnek
unzip([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]);  // [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]]

/*
    a     1
     b   2
      c 3
      d 4
      e 5
*/

const zip = (...arr) => Array.from({ length: Math.max(...arr.map(a => a.length)) }, (_, i) => arr.map(a => a[i]));

// Örnek
zip(['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]);   // [['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]

/*
Fermuar gibi teker teker birleştirme
        a 1
        b 2
       c   3
      d     4
     e       5
*/

const isFunction = v => ['[object Function]', '[object GeneratorFunction]', '[object AsyncFunction]', '[object Promise]'].includes(Object.prototype.toString.call(v));

// Örnekler
isFunction(function() {});          // true
isFunction(function*() {});         // true
isFunction(async function() {});    // true

const isGeneratorFunction = v => Object.prototype.toString.call(v) === '[object GeneratorFunction]';

// Örnekler
isGeneratorFunction(function() {});     // false
isGeneratorFunction(function*() {});    // true

const isAsyncFunction = v => Object.prototype.toString.call(v) === '[object AsyncFunction]';

// Örnekler
isAsyncFunction(function() {});         // false
isAsyncFunction(function*() {});        // false
isAsyncFunction(async function() {});   // true

const soldanSaga = (...fns) => x => fns.reduce((y, f) => f(y), x);
const sagdanSola = (...fns) => x => fns.reduceRight((y, f) => f(y), x);


// Örnek
const lowercase = str => str.toLowerCase();
const capitalize = str => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;

const fn1 = soldanSaga(lowercase, capitalize);
const fn2 = sagdanSola(capitalize, lowercase);


fn1('heLLO WoRlD') // 'Hello world';
fn2('heLLO WoRlD') // 'Hello world';

const curry = (fn, ...args) => fn.length <= args.length ? fn(...args) : curry.bind(null, fn, ...args);

// Örnek
const topla = (a, b, c) => a + b + c;
curry(topla)(1)(2)(3);    // 6
curry(topla)(1, 2, 3);    // 6
curry(topla, 1)(2, 3);    // 6
curry(topla, 1)(2)(3);    // 6
curry(topla, 1, 2)(3);    // 6
curry(topla, 1, 2, 3);    // 6

// Bağımsız değişkenlerin sırasını tersine çevirin
const flip = fn => (...args) => fn(...args.reverse());

// İkili fonksiyonlar için
const flip = fn => (b, a) => fn(a, b);

// Ya da curried fonksiyonlar için
const flip = fn => b => a => fn(a)(b);

// Örnek
const isParent = (parent, child) => parent.children.includes(child);
const isChild = flip(isParent);

// XOR Kapısı, girişindeki işaretler birbirinden farklı olduğu zaman çıkış olarak 1 verir, diğer tüm hallerde 0 verir. 
// XOR kapısının Boole Cebiri eşitliği; A xor B = A'B+AB' şeklindedir.

const xor = (a, b) => (a && !b) || (!a && b);

// Ya da
const xor = (a, b) => !(!a && !b) && !(a && b);

// Ya da
const xor = (a, b) => Boolean(!a ^ !b);

// Örnekler
xor(true, true);        // false
xor(false, false);      // false
xor(true, false);       // true
xor(false, true);       // true

const memoize = fn => ((cache = {}) => arg => cache[arg] || (cache[arg] = fn(arg)))();

// Örnek
// Fibonacci fonksiyonu
const fibonacci = memoize(n => n <= 2 ? 1 : fibonacci(n - 1) + fibonacci(n - 2));

fibonacci(1);    // 1
fibonacci(2);    // 1
fibonacci(3);    // 2
fibonacci(4);    // 3
fibonacci(5);    // 5
fibonacci(6);    // 8

const turet = (fn, ...a) => (...b) => fn(...a, ...b);

// Örnek
const topla = (x, y) => x + y;
const ikiFazlasi  = turet(topla, 2);
ikiFazlasi(8);     // 10

const fibo = (n, memo = {}) => memo[n] || (n <= 2 ? 1 : (memo[n] = fibo(n - 1, memo) + fibo(n - 2, memo)));

// Örnekler
fibo(1);    // 1
fibo(2);    // 1
fibo(3);    // 2
fibo(4);    // 3
fibo(5);    // 5
fibo(6);    // 8

// 2 sayı ile hesaplamak için
const obeb = (a, b) => b === 0 ? a : obeb(b, a % b);

// 2 den fazla sayı ile hesaplamak için
const obeb = (...arr) => { const min = Math.min(...arr); for (let obeb = min; obeb > 1; obeb--) { let bolunebilme = true; for (let j = 0; j < arr.length; j++) {if (arr[j] % obeb !== 0) { bolunebilme = false; break; } } if (bolunebilme){ return obeb } } return 1}

// Örnek
obeb(10, 15);    // 5

const ortalama = (...args) => args.reduce((a, b) => a + b) / args.length;

// Örnek
ortalama(3,5,7,9);    // 6

const faktoriyel = n => n <= 1 ? 1 : n * faktoriyel(n - 1);

// Örnekler
faktoriyel(2);   // 2
faktoriyel(3);   // 6
faktoriyel(4);   // 24
faktoriyel(5);   // 120
faktoriyel(6);   // 720

const topla = (...args) => args.reduce((a, b) => a + b);

// Örnek
topla(1, 2, 3, 4);    // 10

// verilen ilk değer , min ve max değerlerinin arasındaysa o değeri alır, 
// diğer durumlarda en fazla ya da en az olarak verilen değeri döner
const uret = (deger, min = 0, max = 1) => Math.max(min, Math.min(max, deger));

// Örnek
uret(199, 10, 25);     // 25

const toChar = n => `${n >= 26 ? toChar(Math.floor(n / 26) - 1) : ''}${'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[n % 26]}`;

// Örnekler
toChar(0);     // A
toChar(1);     // B
toChar(25);    // Z

toChar(26);     // AA
toChar(27);     // AB
toChar(51);     // AZ

toChar(701);   // ZZ
toChar(702);   // AAA
toChar(703);   // AAB

const dereceRadyan = num => (num * Math.PI) / 180.0;

const radyanDerece = num => num * 180 / Math.PI;

const rakamlari = n => `${n}`.split('').map(v => parseInt(v));

// Örnek
rakamlari(1453);    // [1, 4, 5, 3]

const sifirOnEk = (sayi, uzunluk) => (sayi / Math.pow(10, uzunluk)).toFixed(uzunluk).substr(2);

// Ya da
const sifirOnEk = (sayi, uzunluk) => `${Array(uzunluk).join('0')}${sayi}`.slice(-uzunluk);

// Ya da
const sifirOnEk = (sayi, uzunluk) => String(sayi).padStart(uzunluk, '0');


// Örnek, 5ten kısaysa
sifirOnEk(42, 5);     // '00042'

const yuvarla = (n, basamak = 0) => Number(`${Math.round(`${n}e${basamak}`)}e-${basamak}`);

// Örnekler
yuvarla(0.987654321, 2)     // 0.99
yuvarla(0.987654321, 3)     // 0.988
yuvarla(0.987654321, 4)     // 0.9877
yuvarla(0.987654321, 5)     // 0.98765

const kes = n => ~~n;

// Örnekler
kes(25.198726354);         // 25
kes(-25.198726354);        // -25

const toFixed = (n, fixed) => `${n}`.match(new RegExp(`^-?\\d+(?:\.\\d{0,${fixed}})?`))[0];

// Örnekler
toFixed(25.198726354, 1);       // 25.1
toFixed(25.198726354, 2);       // 25.19
toFixed(25.198726354, 3);       // 25.198
toFixed(25.198726354, 4);       // 25.1987
toFixed(25.198726354, 5);       // 25.19872
toFixed(25.198726354, 6);       // 25.198726

const isEqual = (...objects) => objects.every(obj => JSON.stringify(obj) === JSON.stringify(objects[0]));

// Örnekler
isEqual({ foo: 'bar' }, { foo: 'bar' });    // true
isEqual({ foo: 'bar' }, { bar: 'foo' });    // false

const toObj = arr => Object.fromEntries(arr)
//ya da
const toObj = arr => arr.reduce((a, c) => ((a[c[0]] = c[1]), a), {});


// Örnek
toObj([['a', 1], ['b', 2], ['c', 3]]);      // { a: 1, b: 2, c: 3 }

const ayikla = (objs, key) => objs.map(obj => obj[key]);

// Örnek
ayikla([
    { isim: 'Ahmet', yas: 20 },
    { isim: 'Mehmet', yas: 25 },
    { isim: 'Ali', yas: 30 },
], 'isim');         // ['Ahmet', 'Mehmet', 'Ali']

const getVal = (path, obj) => path.split('.').reduce((acc, c) => acc && acc[c], obj);

// Örnek
getVal('a.b', { a: { b: 'Deneme' } });   // 'Deneme';

const tersCevir = obj => Object.keys(obj).reduce((res, k) => Object.assign(res, {[obj[k]]: k}), {});

// Örnek
tersCevir({ a: '1', b: '2', c: '3' });     // { 1: 'a', 2: 'b', 3: 'c' }

const omit = (obj, keys) => Object.keys(obj).filter(k => !keys.includes(k)).reduce((res, k) => Object.assign(res, {[k]: obj[k]}), {});

// Örnek
omit({a: '1', b: '2', c: '3'}, ['a', 'b']);     // { c: '3' }

const pick = (obj, keys) => Object.keys(obj).filter(k => keys.includes(k)).reduce((res, k) => Object.assign(res, {[k]: obj[k]}), {});

// Örnek
pick({ a: '1', b: '2', c: '3' }, ['a', 'b']);   // { a: '1', b: '2' }

const randomBoolean = () => Math.random() >= 0.5;

const randomFloat = (min, max) => Math.random() * (max - min) + min;

const randomHEX = () => `#${Math.random().toString(16).slice(2, 8).padEnd(6, '0')}`;

// Ya da
const randomHEX = () => `#${(~~(Math.random()*(1<<24))).toString(16)}`;

const randomInteger = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;

const randomIp = () => Array(4).fill(0).map((_, i) => Math.floor(Math.random() * 255) + (i === 0 ? 1 : 0)).join('.');

// Örnek
randomIp();     // 175.89.174.131

const generateString = (len, chars) => Array(len).fill('').map((v) => chars[Math.floor(Math.random() * chars.len)]).join('');

// Örnek
generateString(10, 'abc'); // "abccbbaabc"

const generateString = length => Array(length).fill('').map((v) => Math.random().toString(36).charAt(2)).join('');

const uuid = (a) => a ? (a ^ Math.random() * 16 >> a / 4).toString(16) : ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuid);

const randomArrayInRange = (min, max, n) => Array.from({ length: n }, () => Math.floor(Math.random() * (max - min + 1)) + min);

// Örnek
randomArrayInRange(1, 100, 10);     // [11, 82, 41, 35, 76, 83, 43, 15, 60, 54]

const randomItem = arr => arr[(Math.random() * arr.length) | 0];

const ilkHarfiBuyut = str => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;

// Örnek
ilkHarfiBuyut('hello world');      // 'Hello world'

const truePath = path => !/^([a-z]+:)?[\\/]/i.test(path);

// Örnekler
truePath('/foo/bar/baz');         // false
truePath('C:\\foo\\bar\\baz');    // false
truePath('foo/bar/baz.txt');      // true
truePath('foo.md');               // true

// Palindrom, tersten okunuşu da aynı olan cümle, sözcük ve sayılara denilmektedir.

const isPalindrom = str => str === str.split('').reverse().join('');

// Örnekler
isPalindrom('abc');         // false
isPalindrom('abcba');       // true
isPalindrom('123454321');   // true