JavaScript Data Types / Veri Türleri
Published: 2024-01-16 09:12:26

Bu eğitimde JavaScript veri türleri ve bunların benzersiz özellikleri hakkında bilgi edineceksiniz.

JavaScript primitive veri türlerine sahiptir:

- null
- undefined
- boolean
- number
- string
- symbol – ES2015 ile mümkün
- bigint – ES2020 ile mümkün

ve karmaşık bir veri türü nesnesi.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s9ycynkeynydd9xwbi9u.png)

JavaScript dinamik olarak yazılan bir dildir; yani bir değişken belirli bir türle ilişkilendirilmez. Başka bir deyişle, bir değişken farklı türde bir değer tutabilir. Örneğin:

```
let counter = 120; // counter is a number
counter = false;   // counter is now a boolean
counter = "foo";   // counter is now a string
```
Bir değişkende saklanan değerin geçerli türünü belirlemek için `typeof` operatörünü kullanırsınız:

```
let counter = 120;
console.log(typeof(counter)); // "number"

counter = false; 
console.log(typeof(counter)); // "boolean"

counter = "Hi";
console.log(typeof(counter)); // "string"
```
Çıktısı:

```
"number"
"boolean"
"string"
```
## Undefined Türü

`Undefined` türü, yalnızca bir değeri tanımlanmamış olan primitive 
 bir türdür. Varsayılan olarak, bir değişken bildirildiğinde ancak başlatılmadığında, varsayılan olarak `undefined` olur.

Aşağıdaki örneği düşünün:

```
let counter;
console.log(counter);        // undefined
console.log(typeof counter); // undefined
```

Bu örnekte `counter` bir değişkendir. `counter` henüz başlatılmadığından `undefined` değere atanmıştır. `counter`'ın türü de `undefined`'tır.

`typeof` operatörünün, onu bildirilmemiş bir değişken üzerinde çağırdığınızda da `unDefinition` değerini döndürdüğünü unutmamak önemlidir:

```
console.log(typeof undeclaredVar); // undefined
```

## null Türü

`null` türü, yalnızca bir `null` değerine sahip olan ikinci primitive veri türüdür. Örneğin:

```
let obj = null;
console.log(typeof obj); // object
```

> `typeof` `null` döndürme nesnesi, JavaScript'te bilinen bir hatadır. Mevcut birçok siteyi bozma potansiyeli nedeniyle düzeltme teklifi reddedildi.

JavaScript, `null`'un `undefined`'a eşit olduğunu şu şekilde tanımlar:

```
console.log(null == undefined); // true
```

## Number Türü

JavaScript, hem tamsayı hem de ondalıklı sayıları temsil etmek için `number` türünü kullanır.

Aşağıdaki ifade bir değişken bildirir ve değerini bir tamsayı ile başlatır:

```
let num = 100;
```

Ondalıklı bir sayıyı temsil etmek için, bir ondalık nokta ve ardından en az bir sayı eklersiniz. Örneğin:

```
let price = 12.5; 
let discount = 0.05;
```
Sayı tam sayı gibi görünüyorsa JavaScript'in ondalıklı sayıyı otomatik olarak tam sayıya dönüştürdüğünü unutmayın.

Bunun nedeni, ondalıklı sayı değeri bir tamsayı değerinden iki kat daha fazla bellek kullandığından Javascript'in her zaman daha az bellek kullanmak istemesidir. Örneğin:

```
let price = 200.00; // interpreted as an integer 200
```
Sayı türünün aralığını elde etmek için `Number.MIN_VALUE` ve `Number.MAX_VALUE`'yu kullanırsınız. Örneğin:

```
console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MIN_VALUE); // 5e-324
```
Ayrıca sonsuz sayıyı temsil etmek için `Infinity` ve `-Infinity`'i kullanabilirsiniz. Örneğin:

```
console.log(Number.MAX_VALUE + Number.MAX_VALUE); // Infinity
console.log(-Number.MAX_VALUE - Number.MAX_VALUE); // -Infinity
```

## NaN

`NaN`, _sayı değil_ anlamına gelir. Geçersiz bir sayıyı belirten özel bir sayısal değerdir. Örneğin, bir dizenin bir sayıya bölünmesi `NaN`: değerini döndürür.

```
console.log('a'/2); // NaN;
```

`NaN`'ın iki özel özelliği vardır:

- `NaN` ile yapılan herhangi bir işlem `NaN` değerini döndürür.
- `NaN` kendisi dahil hiçbir değere eşit değildir.

İşte bazı örnekler:

```
console.log(NaN/2); // NaN
console.log(NaN == NaN); // false
```

## String Türü

JavaScript'te bir string, sıfır veya daha fazla karakterden oluşan bir string'dir. Bir string değişmezi tek tırnakla (`'`) veya çift tırnakla (`"`) başlar ve biter.

Çift tırnakla başlayan bir string çift tırnakla bitmeli, tek tırnakla başlayan bir string de tek tırnakla bitmelidir. Örneğin:

```
let greeting = 'Hi';
let message  = "Bye";
```

Bir değişmez dizede tek tırnak veya çift tırnak kullanmak istiyorsanız, bunlardan kaçmak için ters eğik çizgiyi kullanmanız gerekir. Örneğin:

```
let message = 'I\'m also a valid string'; // use \ to escape the single quote (')
```

JavaScript string değişmezdir, yani oluşturulduktan sonra değiştirilemezler. Ancak mevcut bir string'den yeni bir string oluşturabilirsiniz. Örneğin:

```
let str = 'JavaScript';
str = str + ' String';
```

Bu örnekte:

- Öncelikle `str` değişkenini bildirin ve `'JavaScript'` string'ini oluşturun.
İkinci olarak, `'JavaScript'`'i `'String'` ile birleştirerek değerini `'Javascript String'` yapmak için `+` operatörünü kullanın.
Sahnenin arkasında, JavaScript motoru, yeni `'JavaScript String'` string'ini tutan yeni bir string oluşturur ve orijinal 'JavaScript' ve 'String' türünü yok eder.

Aşağıdaki örnek, JavaScript string'inin ilk karakterini değiştirmeye çalışmaktadır:

```
let s = 'JavaScript';
s[0] = 'j';
console.log(s)
```

Çıktısı:

```
'JavaScript'
```
Ancak istenen:

```
'javaScript'
```
### Boolean Türü

`boolean` türünün iki değişmez değeri vardır: küçük harflerle `true` ve `false`. Aşağıdaki örnek, boolean değerlerini tutan iki değişkeni bildirir.

```
let inProgress = true;
let completed = false;

console.log(typeof completed); // boolean
```
JavaScript, diğer türlerdeki değerlerin `true` veya `false` boolean değerlerine dönüştürülmesine olanak tanır.

Diğer türlerin değerlerini boolean değerlerine dönüştürmek için `Boolean()` function'ını kullanırsınız.

Örnek:

```
console.log(Boolean('Hi'));// true
console.log(Boolean(''));  // false

console.log(Boolean(20));  // true
console.log(Boolean(Infinity));  // true
console.log(Boolean(0));  // false

console.log(Boolean({foo: 100}));  // true on non-empty object
console.log(Boolean(null));// false
```
## Symbol Türü 

JavaScript, ES6'ya yeni bir primitive tür ekledi: `symbol`. Diğer primitive tiplerden farklı olarak `symbol` türünün gerçek bir formu yoktur.

Bir sembol oluşturmak için `Symbol` işlevini şu şekilde çağırırsınız:

```
let s1 = Symbol();
```

`Symbol` işlevi, onu her çağırdığınızda yeni bir benzersiz değer oluşturur.

```
console.log(Symbol() == Symbol()); // false
```
Sembol eğitiminde semboller hakkında daha fazla bilgi edineceğinizi unutmayın.

## bigint Türü

`bigint` türü, 253 – 1'den büyük tam sayıları temsil eder. `bigint` değişmez bir sayı oluşturmak için sayının sonuna `n` harfini eklersiniz:

```
let pageView = 9007199254740991n;
console.log(typeof(pageView)); // 'bigint'
```

## object Türü

JavaScript'te bir nesne, her özelliğin bir anahtar/değer çifti olarak tanımlandığı bir özellikler koleksiyonudur.

Aşağıdaki örnek, nesne değişmez sözdizimini kullanarak boş bir nesneyi tanımlar:

```
let emptyObject = {};
```
Şu örnek, kişi nesnesini iki özellikle tanımlar: `FirstName` ve `lastName`.

```
let person = {
    firstName: 'John',
    lastName: 'Doe'
};
```

Bir nesnenin özellik adı herhangi bir dize olabilir. Geçerli bir tanımlayıcı değilse, özellik adının etrafında tırnak işaretleri kullanabilirsiniz.

Örneğin, `person` nesnesinin bir `ad` özelliği varsa, bunu `"ad"` gibi tırnak işaretleri içine almanız gerekir.

Bir nesnenin özelliği bir nesneyi tutabilir. Örneğin:

```
let contact = {
    firstName: 'John',
    lastName: 'Doe',
    email: 'john.doe@example.com',
    phone: '(408)-555-9999',
    address: {
        building: '4000',
        street: 'North 1st street',
        city: 'San Jose',
        state: 'CA',
        country: 'USA'
    }
}
```

`contact` nesnesi, `FirstName`, `LastName`, `email`, `phone` ve `address` özelliklerine sahiptir.

`address` özelliğinin kendisi `building`, `street`, `city`, `state` ve `country` özelliklerine sahip bir nesneyi içerir.

Bir nesnenin özelliğine erişmek için şunları kullanabilirsiniz:

- Nokta gösterimi (`.`)
- Dizi benzeri gösterim (`[]`).

Aşağıdaki örnek, `contact` nesnesinin `firstName` ve `lastName ` özelliklerine erişmek için nokta gösterimini (`.`) kullanır.

```
console.log(contact.firstName);
console.log(contact.lastName);
```
Mevcut olmayan bir özelliğe başvurursanız `undefined` bir değer elde edersiniz. Örneğin:

```
console.log(contact.age); // undefined
```

Aşağıdaki örnek, `contact` nesnesinin `email` ve `phobe` özelliklerine erişmek için dizi benzeri gösterimi kullanır.

```
console.log(contact['phone']); // '(408)-555-9999'
console.log(contact['email']); // 'john.doe@example.com'
```

## Özet

JavaScript'in primitive türleri vardır: `number`, `string`, `boolean`, `null`, `undefined`, `symbol ` and `bigint` ve karmaşık bir tür: `object`.

[Github JS Eğitimleri](https://github.com/haktantekin/javascript-tutorial/tree/main)

[Linkedin](https://www.linkedin.com/in/haktantekin/)

[Kaynak](https://www.javascripttutorial.net/web-development-tools/)