TypeScript'teki Veri Türleri

Articles

Bu makale, TypeScript'teki veri türlerini açıklar.

YouTube Video

TypeScript'teki Veri Türleri

TypeScript çeşitli veri türleri sunar. Bu, değişkenler, fonksiyon argümanları ve dönüş değerleri için kesin türler tanımlamanıza olanak tanır. Aşağıda temel veri türleri ve onların kullanımları yer almaktadır.

Primitif Türler

number Türü

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

number, tam sayı ve ondalık sayılar (yüzer noktalı sayılar) dahil olmak üzere sayısal değerleri işlemek için kullanılan bir türdür. Belirli sınırları aşan değerleri işlemek Infinity veya NaN (Not-a-Number) ile sonuçlanır.

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

TypeScript'te sayılar yüzer noktalı sayılar olarak temsil edilir. Bu, hesaplama sonuçlarında hafif yanlışlıklara neden olabilir.
Finansal miktarlar gibi hassas hesaplamaların gerektiği durumlarda bu tür yuvarlama hatalarından kaçınılması gereklidir. Örneğin, BigInt veya toFixed() kullanabilir ya da decimal.js gibi kütüphanelerle ondalık basamakları ayarlayabilirsiniz.

string Türü

string türü, metinsel verileri işler.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

boolean (Mantıksal Tür)

boolean türü, true veya false olmak üzere iki değere sahiptir.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null ve undefined

null, 'var olmayan bir değer'i ve undefined, 'tanımsız bir değer'i temsil eder.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

TypeScript'te, dizi elemanlarının türünü belirtebilirsiniz. number[] bir sayı dizisini, string[] ise bir metin dizisini ifade eder.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Tuple

Bir tuple, farklı türlerde elemanlara sahip bir dizidir.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Enum

enum, isimlendirilmiş sabitler kümesini tanımlar.

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

any türü herhangi bir türde değeri tutabilir ve tür kontrolünü devre dışı bırakmak istediğinizde kullanılır.

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Bileşik Tür

Bileşik türleri kullanarak, birden fazla türe sahip olabilen değişkenler tanımlayabilirsiniz.

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Özet

number, string, boolean: İlkel türler.
null, undefined: Özel değerler.
Array: Tür açıklamaları içeren bir dizi.
Tuple: Farklı türlerden öğeler içeren bir dizi.
enum: Numaralandırılmış bir tür.
any: Herhangi bir tür.
Union: Birden fazla türden birini alabilen bir değişken.

Bu veri türlerini kullanarak TypeScript, tür güvenliğini artırır ve geliştirme sırasında hataların önlenmesini kolaylaştırır.

Sarmalayıcı Nesneler

TypeScript'te Sarmalayıcı Nesneler (Wrapper Objects), ilkel veri türlerini nesne olarak ele almak için otomatik olarak oluşturulan nesnelerdir. İlkel türler hafif ve hızlı işlemler sağlar, nesne türleri ise daha zengin işlemleri mümkün kılan yöntemlere ve özelliklere sahiptir.

JavaScript (ve TypeScript)'te, string, number ve boolean gibi ilkel türlere karşılık gelen sarmalayıcı nesneler vardır. Bunlar sırasıyla String, Number ve Boolean adlı yapıcı fonksiyonlar kullanılarak oluşturulur.

Aşağıda sarmalayıcı nesne örnekleri bulunmaktadır.

String Nesnesi

String nesnesi, dizeler için özellikler ve yöntemler sağlar.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Özellikler:

İlkel string türünden farklı olarak, bir String nesnesi typeof tarafından object olarak kabul edilir.
Sarmalayıcı nesneler, dizeleri işlemek veya üzerlerinde yöntem çağırmak için kullanışlıdır.

Number Nesnesi

Number nesnesi, sayılar için özellikler ve yöntemler sağlar.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Özellikler:

Number nesnesi, sayılar için bir sarmalayıcı olarak, sayısal işlemler için yöntemleri içerir (örneğin, toFixed).

Boolean Nesnesi

Boolean nesnesi, boolean değerler için özellikler ve yöntemler sağlar.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Özellikler:

Boolean nesnesi, ilkel boolean türü için bir sarmalayıcıdır ve object olarak kabul edilir.

Sarmalayıcı Nesneler ve İlkel Türler Arasındaki Farklar

Sarmalayıcı nesneler nesne olarak kabul edildiğinden, küçük bir performans düşüşü olur; ancak eklenmiş özellikler ve yöntemler sayesinde daha işlevsel işlemler mümkündür. Ayrıca, == ve === kullanılarak yapılan karşılaştırmalarda farklar vardır.

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Özellikler:

==, yalnızca değerleri karşılaştırırken ===, türleri de içeren kesin bir karşılaştırma yapar. ===, sarmal nesneler ile ilkel türleri karşılaştırırken false döner.

Tür Dönüştürme

TypeScript'te örtük ve açık tür dönüştürmeleri düzgün bir şekilde yönetilmesi önemlidir.

Örtük Tür Dönüştürme

TypeScript'te tür güvenliğini sağlamak için örtük tür dönüştürmelerinden mümkün olduğunca kaçınılmalıdır.

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

Bu örnekte, 5 sayısı örtük olarak bir dizeye dönüştürülmüş ve sonuç olarak "55" dizisi elde edilmiştir.

Açık Tür Dönüştürme

TypeScript'te tür dönüştürmelerini güvenli bir şekilde gerçekleştirmek için tür açıklamalarını veya tür dönüştürme fonksiyonlarını kullanın.

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

Bu örnekte, "123" dizisini açıkça 123 sayısına dönüştürmek için Number() fonksiyonu kullanılmıştır.

Tür Kontrolü

TypeScript'te bir değişkenin veri türünü kontrol etmek için typeof operatörünü kullanabilirsiniz.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

TypeScript'te türleri kontrol etmek için typeof kullanılabilir, ancak daha hassas tür kontrolleri için instanceof veya is operatörlerini kullanmanız önerilir.

Özet

Sarmal Nesneler, ilkel türler için ek yöntemler ve özellikler sağladıkları için nesne olarak işlenir.
String, Number ve Boolean, sarmal nesnelere temsilci örneklerdir.
İlkel türlerin aksine, sarmal nesneler typeof tarafından object olarak tanımlanır.

Yukarıdaki makaleyi, YouTube kanalımızda Visual Studio Code'u kullanarak takip edebilirsiniz. Lütfen YouTube kanalını da kontrol edin.

YouTube Video

TypeScript'in Temelleri TypeScript'te Operatörler