12 Kas 2019

Javascript’in farklı bakış açısı ve gariplikleri :)

Author: strongsoul | Filed under: Teknik

Selam okuyucu, sana javascript ve ona itham edilen ama onun nezdinde öyle olmayan bazı tipsel tanımlamalardan bahsedeceğim 🙂

Javascriptin tip korumalı bir dil olmadığı aşikar fakat tip olarak bize tanıtılanlar da ne şekilde bir işleve sahip hadi beraber bakalım.

function process1(){
let person = [];
person[“name”] = “John”;
person[“lastname”] = “Wick”;
person[“carnage”] = 46;
return person;
}
console.log(“Person 1 out:”, process1())
console.log(“Person 1 length:”, process1().length)
// → Person 1 out: [ name: ‘John’, lastname: ‘Wick’, carnage: 46 ]
// → Person 1 length: 0

node un en azından javascriptten farklı olarak bu şekilde bir dönüş ile length i alabileceğini düşünürsünüz ya da düşünebilirsiniz benim gibi fakat çıktı olarak; “person 1 out” beklenen sonucu versede “-> Person: [ name: ‘John’, lastname: ‘Wick’, carnage: 46 ]” bu değişkenin lengthini almaya çalıştığımızda sonuç çıktı olarak 0’ı verir.
hmm belki de bu arkadaş da yapılandırdığımız bu dizi tanımlamasının yazımı aslında bir nevi javascriptin json obje yapısına eklemelerdeki syntax ile örtüşüyor ve bundan mütevellit object bir değere dönüşüyor, kısaca key tanımındandır bu dedik ve keyleri kaldırmaya karar verdik;

function process2(){
let person = [];
person[0] = “John”;
person[1] = “Wick”;
person[2] = 46;
person[3] = 12;
return person;
}
console.log(“Person 1 out:”, process2())
console.log(“Person 1 length:”, process2().length)
// → Person 1 out: [ ‘John’, ‘Wick’, 46, 12 ]
// → Person 1 length: 4

evet şimdi alabildik

yada key value lu ilk functiomuz için de şu şekilde alabiliriz length propertisini, – artık ne kadar zor ise key value kıstasında dolduramamış js length’i-

//console.log(“Person 1 out:”, Object.entries(process1()))
//console.log(“Person 1 length:”, Object.entries(process1()).length)

peki biz bir dizi uretip boş olan bu dizinin 333 uncu var olmayan dizi indexine bir deger atasak ?

function sirasirasinilerbirbiriniiziler(){
let myArray = [];
console.log(‘sirasirasinilerbirbiriniiziler’, myArray.length);
myArray[333] = ‘ben yeni eklendim’;
console.log(‘sirasirasinilerbirbiriniiziler’, myArray.length);
}
sirasirasinilerbirbiriniiziler();
// → sirasirasinilerbirbiriniiziler 0
// → sirasirasinilerbirbiriniiziler 334

vadaa vada ? vadaaa 🙂
hadi bir tane de veri silelim bu dizilerden

function diziyimbeninankidiziyim()
{
let myArray = [‘a’, ‘b’, ‘c’, ‘d’];
console.log(myArray);
console.log(myArray[1]);
delete myArray[1];
console.log(myArray[1]);
console.log(myArray);
}

diziyimbeninankidiziyim()

//[ ‘a’, ‘b’, ‘c’, ‘d’ ]
//b
//undefined
//[ ‘a’, <1 empty item>, ‘c’, ‘d’ ]

silmişsem silerim, dizmem, etmem diyor yani hmm himm olabilebilir.

function dizidegilmiyimyoksaoylemisaniyorumkendimi(){
let myarray = [5, 12, 6, 11, 80, 1];
myarray.sort();
console.log(‘dizidegilmiyimyoksaoylemisaniyorumkendimi array sort ->’, myarray);
}
dizidegilmiyimyoksaoylemisaniyorumkendimi();

// → dizidegilmiyimyoksaoylemisaniyorumkendimi array sort -> [ 1, 11, 12, 5, 6, 80 ]

javascript kendi içinde bir felsefik arayış içinde o yüzden sıralamada şaşırtıcı sonuçlar dönüyor js içinde yerleştirilmiş yapay zeka sıralamanın mantığını çözümlemek için dünya üzerinde bir pattern belirlemeye çalışıyor saçaklı quantum mantelitesi sıralamada rakamların karşılık geldiği değerleri bilemiyor ve değer sıralaması için 1 in neden 80 den düşük yada duruma göre yüksek olduğunun analizini yapıyor bunu daha bitiremediği için sıralama böyle geliyor :)) vadaaa 😛
şaka mı yok yok ciddi 😛 mesela ona bu felsefik çıkmazını anlatırsak bulabiliyor nasıl mı ? 🙂

function dizidegilmiyimyoksaoylemisaniyorumkendimi2()
{
let myarray = [5, 12, 6, 11, 80, 1];
myarray.sort(function(a, b){
if (a < b)
return -1;
if (a > b)
return 1;
else
return 0;
});

console.log(‘dizidegilmiyimyoksaoylemisaniyorumkendimi 2 array sort ->’, myarray);

}

dizidegilmiyimyoksaoylemisaniyorumkendimi2();

//-> dizidegilmiyimyoksaoylemisaniyorumkendimi 2 array sort -> [ 1, 5, 6, 11, 12, 80 ]

hmm himm hadi biraz da veri tiplerinin durumuna bakalım

console.log(‘[] ->’, typeof []);
console.log(‘{} ->’, typeof {});
// → [] -> object
// → {} -> object

ilginç ikiside obje olarak sonuç veriyor

typeof operatoru arkadaş bana göre ayrım yok diyor vadaaa? 😛

nasıl alacağız peki ?

function arraymibu (value) {
return typeof value === ‘object’ && value.constructor === Array;
}
console.log(‘arraymibu([])’, arraymibu([])); // outputs: true
console.log(‘arraymibu({})’, arraymibu({})); // outputs: false

— — — — — — — — — — — — — — — — — — — — — — — — —
hadi olayları biraz daha ilginçleştirelim

let x=[0];
console.log(‘x==x’, x==x) // → true; tamam doğru
console.log(‘x==!x’, x==!x) // → true; nasıl yani ? 🙂
console.log(‘Array(3)==”,,”’, Array(3)==”,,”) // → true; o ye 🙂
console.log(‘typeof NaN’, typeof NaN) // → number; 🙂
console.log(‘NaN==NaN’, NaN==NaN) // → false; neler oluyor js ?
console.log(‘typeof null’, typeof null) // → object
console.log(‘null instanceof Object’, null instanceof Object) // → false; vadaaa
console.log(‘“string” instanceof String’, “string” instanceof String) // → false; string kabuğundan çıkmış kabuğunu beğenmemiş 😛
console.log(‘9999999999999999’, 9999999999999999) // → 10000000000000000; hönk ?
console.log(‘0.1+0.2==0.3’, 0.1+0.2==0.3); // → false; ?!?!?!
console.log(‘Math.max()>Math.min() ‘, Math.max()>Math.min() ) // → false; üst satırlarda da dediğim gibi daha çözümlüyor analiz ediyor pattern çıkarıyor
console.log(‘Math.max()<Math.min()’, Math.max()<Math.min()) // → true; 🙂
console.log(‘[]+[]:’, []+[]) // → ‘’;
console.log(‘[]+{}’, []+{}) // → [object Object]; diziye olan yaklaşımın çok saygısızca js 🙂
console.log(‘{}+{}’, {}+{}) // → [object Object][object Object]
console.log(‘true+true===2’, true+true===2) // → true; tamam
console.log(‘true-true===0’, true-true===0) // → true; tamam
console.log(‘true===1 ‘, true===1) // → false; nasıl yani ? üstteki iki satır ??
console.log(‘ (!+[]+[]+![]).length’, (!+[]+[]+![]).length) // → 9 uğurlu rakam

şimdilik bu kadar başka bir yazıda görüşmek üzere.

Yorum Bırakın