undefined Tipi

Giriş
Açıklaması şöyle. Yani property global olmasına rağmen değeri değiştirilemez.

In modern browsers (JavaScript 1.8.5 / Firefox 4+), undefined is a non-configurable, non-writable property per the ECMAScript 5 specification. Even when this is not the case, avoid overriding it.

İster global ister yerel olsun ismi undefined değişken yaratmamak lazım.

Örnek
Şöyle yapmaka daha iyi.

var undefined = 'hello';

Şöyle yapmaka daha iyi.

(()=>{
  var undefined = 'hello';
  ...
})()

Strict Equality Comparison - 3 tane Eşittir

=== (Strict Equality Comparison) Ne Anlama Gelir

Açıklaması şöyle. 3 tane eşittir ile yapılır. İki değişkenin eşit olup olmadığını belirtir.

In weakly typed languages such as JavaScript you can use the strict comparison operator (===) because the language allows comparison between variables which have different types.
And it is useful, when you want to compare variables which may hold values that are "equals" but may be of different types.

Açıklaması şöyle.

One of the many reasons why it is a very useful habit for JS developers to always type === (strict equality) by default, and only use == when you know you are going to need to compare values with different type representations.

Örnek

Şöyle yaparız. Böylece integer ve string'in denkliğini kontrol edebiliriz.

var x = 10;
var y = '10';
console.log(x == y)  // true
console.log(x === y) // false

Örnek
Şöyle yaparız. Burada answer ve string literal'in denkliği kontrol ediliyor.

var answer = prompt ("What body system contains the heart?") .toLowerCase();
if (answer==="circulatory") {
  alert ("Correct!");
  score += 100;
  alert ("Your total score is now " +score);
}
else {
  alert ("Sorry, incorrect.");
   score -= 100;
   alert ("Your total score is now " +score);
}

Örnek
Şöyle yaparız.

componentDidMount() {
  this.fetchData()
    .then(data => {
       const filteredData = data.filter(element => 
         element.someProperty === propertyValue
       );
     this.setState({ data: filteredData });
    })
}

Object Sınıfı

Giriş
Açıklaması şöyle. Yani object ve Object farklı şeyler.

An object is a concept in JavaScript that is a generic container for some data. An object contains properties with keys and associated values.

In JavaScript, everything that is not a primitive is an object. This includes functions, which are basically a special type of object that can be "called" with the () syntax.

JavaScript provides a number of built-in functions that have various purposes. Two such functions happen to be called Object and Function. So in other words Object is a function and thus also an "object" (data structure).

Örnek
Şöyle yaparız.

function Foo() {
  var a = "3"; // a is local to this scope, you cannot get to it from outside
  console.log(a); // prints 3 - local variable a is accessible inside the scope
  console.log(Foo.a); // prints 5 - a is a property on object Foo, and is accessible here
}
// var a inside Foo cannot be accessed here
Foo.a = 5;
Foo();

defineProperty metodu
Açıklaması şöyle

Object.defineProperty should usually only be used when defining a new property

defineProperty metodu + enumerable
Açıklaması şöyle.

enumerable

true if and only if this property shows up during enumeration of the properties on the corresponding object.

Defaults to false.

Açıklaması şöyle.

Non-enumerable means that property will not be shown in Object.keys() or for..in loop neither in console

Örnek
Şöyle yaparız.. defineProperty() metoduna true geçmediğimiz için eklenen alan console.log() çıktısında görünmez.

//Code Snippet 
let profile = {
  name: 'Barry Allen',
}

// I added a new property in the profile object.
Object.defineProperty(profile, 'age', {
  value: 23,
  writable: true
})

console.log(profile)
console.log(profile.age)

Çıktı olarak şunu alırız.

{name: "Barry Allen"}
23 

defineProperty metodu + writable
Örnek
Şöyle yaparız

var x = {};

Object.defineProperty(x, 'name', {
   writable: true
};

Örnek
Elimizde şöyle bir kod olsun

var x = {};

Object.defineProperty(x, 'name', {
   value: 'foo'
});

x.name = 'bar';
console.log(x.name);

Çıktı olarak "foo" alırız çümkü defineProperty writable alanını varsayılan değer olarak false ile ilklendirir.

hasOwnProperty metodu
true veya false döner.
Örnek
Şöyle yaparız.

const myArrOfObjects = [{
  cheesePuffs: "yes"
},
{
  time: "212"
}];

let findByName = (name) => {
  return myArrOfObjects.some(obj=> {
    return obj.hasOwnProperty(name)
  })
}

console.log(findByName("cheesePuffs")) //true
console.log(findByName("time")) //true
console.log(findByName("123")) //false

Örnek
Belirtilen dizideki nesnenin bir alanının değeri, parametre değeri ile aynıysa siler. Şöyle yaparız.

var removeByAttr = function(arr, attr, value){
  var i = arr.length;
  while(i--){
    if( arr[i] 
      && arr[i].hasOwnProperty(attr) 
      && (arguments.length > 2 && arr[i][attr] === value ) ){ 
        arr.splice(i,1);

      }
   }
   return arr;
}

Çağırmak için şöyle yaparız.

var arr = [{id:1,name:'serdar'}, {id:2,name:'alfalfa'},{id:3,name:'joe'}];
removeByAttr(arr, 'id', 1);   
// [{id:2,name:'alfalfa'}, {id:3,name:'joe'}]

removeByAttr(arr, 'name', 'joe');
// [{id:2,name:'alfalfa'}]

keys metodu
Örnek
Elimizde şöyle bir kod olsun.

{r1: "Room 1", r2: "Room 2", r3: "Room 3"}

Şu hale çevirmek isteyelim.

rooms = [
    { id: 'r1', name: 'Room 1'},
    { id: 'r2', name: 'Room 2'},
    { id: 'r3', name: 'Room 3'},
];

Şöyle yaparız.

const array = [];

Object.keys(yourObject).forEach((key) => {
  array.push({[key]: object1[key]});
});

Örnek
İki tane aynı tipten nesneyi karşılaştırmak için şöyle yaparız.

for(const key of Object.keys(object1)) {
  if(key in object2) {
    process(object1[key], object2[key]);
  }
}

toString metodu
Örnek
Eğer toString() override edilmemişse [object Object] döner. Şöyle yaparız.

var tags = [{"value":"tag1"},{"value":"tag2"}];
console.log("tags: " + tags);

Çıktı olarak şunu alırız.

tags: [object Object],[object Object]

values metodu
Object.values() metodu yazısına  taşıdım.