RecommendationService:GenerateItemListAsync

generateRecommendationItemListRequest

RecommendationService:LogActionEvent

actionType

itemId

tracingId

actionEventDetails

RecommendationService:LogImpressionEvent

impressionType

impressionEventDetails

RecommendationService:RegisterItemAsync

player

registerRecommendationItemsRequest

RecommendationService:RemoveItemAsync

RecommendationService:UpdateItemAsync

updateRecommendationItemRequest

RecommendationService

`Instance` Roblox sınıf hiyerarşisindeki tüm sınıfların temel sınıfıdır
`Class.DataModel` ağacının bir parçası olabilir.

Kök `Instance` nesnelerini doğrudan oluşturmak mümkün değildir, ancak özel
`Datatype.Instance.new()` yapıcı, kod aracılığıyla nesneler oluşturur ve
sınıfın adına bir parametre olarak alır ve oluşturulan nesneyi döndürür.


Bir örneğin soy ağacındaki değişiklikleri tespit etmeyi gösterir ve `Class.Instance.AncestryChanged` olayına bağlanarak bunu yapar.

ChangingPart'in Üstü zamanla farklı değerlere ayarlanır. Parçanın üstü, parçanın atasını temsil eder, bu nedenle `Class.Instance.AncestryChanged` olayı ne zaman değişirse tetiklenir.

`Class.Instance.Parent` özelliği nesnenin veya bir atalarının değiştiğinde tetiklenir.

Bu olay iki parametre içerir: `child`, aslında değiştirilen `Class.Instance`
işlevini, `parent` ise bu örneğin yeni `Class.Instance.Parent`'ını temsil eder.

Bu olayı, bir nesnenin Studio'da silinmesini izlemek için kullanabilirsiniz,
örneğin Explorer'da manuel silme veya bir eklenti aracılığıyla. Eğer
`Class.Instance:Destroy()` ile bir nesnenin yok olduğunu tespit etmeniz
gerekirse, bunun yerine `Class.Instance.Destroying` olayını kullanın.


Instance.AncestryChanged

child

`Class.Instance.Parent`'ı değiştirilen `Class.Instance`.


parent

Değiştirilen `Class.Instance`'ın yeni `Class.Instance.Parent`'ı.


`Class.Instance.Parent` özelliği nesnenin veya bir atalarının değiştiğinde tetiklenir.


Bu olay, nesne üzerinde herhangi bir niteliğin değiştiğinde,
`nil` değerine ayarlandığında, tetiklenir. Değiştirilen niteliğin adı,
bağlı fonksiyona iletilir.

Örneğin, aşağıdaki kod parçası, nesnenin niteliği değiştiğinde
`attributeChanged()` fonksiyonunu bağlamaktadır:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "değişti")
end

part.AttributeChanged:Connect(attributeChanged)
```
Ayrıca `Class.Instance:GetAttributeChangedSignal()`'u
da inceleyin; bu, belirli bir niteliğin değiştiğinde tetiklenen bir olayı
döndürür.


Instance.AttributeChanged

attribute

`Class.Instance` üzerinde herhangi bir niteliğin değiştiğinde tetiklenir.


Bu kod parçası, nesneler Workspace'e eklendikçe isimlerini yazdırır:

Bir nesne, bu `Class.Instance`'a eklendikten sonra tetiklenir.

Not: Sunucu tarafından oluşturulan nesneleri istemcide tespit etmek içi,
`Class.Instance:WaitForChild()` kullanılması gerekmektedir; bu nesne ve onun
alt nesnelerinin sunucudan istemciye eşzamanlı olarak çoğaltılması garanti
edilmemektedir. Örneğin:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Alt nesnelerin henüz çoğaltılmamış olabileceğinden WaitForChild() kullanın
	local head = child:WaitForChild("Head")
end)
```
Not: Bu işlev yalnızca `Class.Instance`'ın doğrudan çocukları için
geçerlidir. Tüm alt nesneleri kapsayan bir işlev için,
`Class.Instance.DescendantAdded` kullanın.

Ayrıca `Class.Instance.ChildRemoved`'u da inceleyin.


Instance.ChildAdded

Bir nesne, bu `Class.Instance`'a eklendikten sonra tetiklenir.


Bu kesit, nesnelerin Workspace'ten kaldırıldıkça isimlerini yazdırır:

Bu `Class.Instance`'dan bir çocuğun çıkarılmasından sonra tetiklenir.

Kaldırma, nesnenin ebeveyninin bu `Class.Instance`'dan farklı bir
şeye değiştirilmesiyle ilgilidir. Not: Bu olay, bir çocuk
`Class.Instance:Destroy()` kullanılarak yok edildiğinde de tetiklenir,
çünkü yok etme işlevi bir nesnenin ebeveynini `nil` olarak ayarlar.

Bu işlev yalnızca `Class.Instance`'ın doğrudan çocukları için
geçerlidir. Tüm alt nesneleri kapsayan bir işlev için,
`Class.Instance.DescendantRemoving` kullanın.

Ayrıca `Class.Instance.ChildAdded`'ı da inceleyin.


Instance.ChildRemoved

Bu `Class.Instance`'dan bir çocuğun çıkarılmasından sonra tetiklenir.


Aşağıdaki örnek, Workspace'e eklenen her nesnenin adını yazdıracaktır:

Bu olay, `Class.Instance`'a bir alt nesne eklendikten sonra
başlatılır.

Her alt nesne için tetiklenebileceğinden, bir nesnenin `Class.Instance`
altında ebeveynlik yapılması, bu olay ve tüm alt nesneleri için bireysel
tetiklenmesine sebep olur.

Eğer yalnızca `Class.Instance`'ın **doğrudan çocukları** ile ilgileniyorsanız,
`Class.Instance.ChildAdded`'ı kullanın.

Ayrıca `Class.Instance.DescendantRemoving`'i de inceleyin.


Instance.DescendantAdded

descendant

`Class.Instance`'a bir alt nesne eklendikten sonra tetiklenir.


Aşağıdaki örnek, herhangi bir bebeğin adı Workspace'ten kaldırılırken yazdırılır:

Bu olay, üstteki `Class.Instance`'ın alt nesne
kaldırılmadan **hemen önce** tetiklenir. `Class.Instance:Destroy()|Destroy()`,
bir nesnenin `Class.Instance.Parent|Parent`'ının `nil` olmasını
değiştirir; dolayısıyla, üstteki nesnenin bir alt nesnesine bu yöntem
çağrıldığında bu olay tetiklenecektir.

Bu olay, alt nesnenin kaldırılmasından **önce** tetiklendiğinden,
alt nesnenin ebeveyni bu olay tetiklenirken değiştirilmemiş olacaktır.
Eğer alt nesne bir **doğrudan çocuk** ise, bu olay `Class.Instance.ChildRemoved`
den önce tetiklenir.

Eğer bir alt nesnenin çocukları varsa, bu olay önce alt nesneyle,
sırasıyla da onun alt nesneleriyle tetiklenir.

##### Uyarı

Bu olay, kaldırılacak olan alt nesne ile tetiklenir.
Alt nesnenin `Class.Instance.Parent|Parent`'ını başka bir şeye ayarlamaya
çalışmak başarısız olacaktır. Aşağıda bunu gösteren bir örnek verilmektedir:

```
local Workspace = game:GetService("Workspace")

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Bu işlevde alt nesnenin ebeveynini değiştirmeyin!
	-- Bu olay, ebeveyn değiştiği için tetiklenir ve değişim henüz gerçekleşmemiştir
	-- Bu nedenle, ebeveyni şöyle değiştirmek sorunludur:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Ayrıca `Class.Instance.DescendantAdded|DescendantAdded`'ı da inceleyin.


Instance.DescendantRemoving

`Class.Instance`'ın bir alt nesnesi kaldırılmadan hemen önce tetiklenir.


Bu örnek, Anlık sinyal davranışı kullanıldığında, bir Instance'ın yok edilmesiyle, bağlı işlevin bekleyene kadar yerinde kalmasını nasıl gösterdiğini anlatır.

Bu örnek, Ertelenmiş sinyal davranışı kullanıldığında bir İnsanın sinyal ateşlenmeden önce nasıl yok edildiğini gösterir.

Bağlı bir işlev kullanılıyorken `Class.Instance`, hafızadan asla
silinmeyecektir. Fakat işlev bir noktada bekleme yaparsa,
`Class.Instance` ve onun alt nesneleri `nil`'e ebeveynlik yapılacaktır.

`Class.Workspace.SignalBehavior` özelliği `Enum.SignalBehavior.Immediate`
eğer ayarlandığında, bu olay hemen tetiklenecektir;
`Class.Instance` veya onun atalarından biri `Class.Instance:Destroy()` ile
silindiğinde.

Eğer `Class.Workspace.SignalBehavior` özelliği
`Enum.SignalBehavior.Deferred` olarak ayarlandıysa, bu olay sonraki
kaldırma noktasında tetiklenecek, bu da `Class.Instance` veya
otanın biri `Class.Instance:Destroy()` ile silindikten sonraki zamana denk gelir.

`Enum.SignalBehavior.Deferred|Deferred` davranışında, bir script'in
kendi `Class.Instance.Destroying` olayına bağlanması sorunludur;
çünkü script, callback tetiklenmeden önce yok edilir (bu da,
çalışmayacağı anlamına gelir).

Studio'da bir `Class.Instance` silerken, manuel olarak
[Explorer](/studio/explorer) veya bir eklenti aracılığıyla
silme yapıyorsanız, `Class.Instance` yok edilmez. Bunun yerine,
ebeveyn `nil` olarak ayarlanır ki bunu `Class.Instance.AncestryChanged`
aracılığıyla takip edebilirsiniz.


Instance.Destroying

`Class.Instance:Destroy()` aracılığıyla yok edilmeden hemen önce (veya sonrasında)
tetiklenir.


Bu olay, nesne üzerinde herhangi bir stil özelliği değiştiğinde ve
özelliğin `nil` değerine ayarlandığında tetiklenmektedir.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Stil özellikleri değişti")
end

meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
```


Instance.StyledPropertiesChanged

Herhangi bir stil özelliği `nil` değerine ayarlanması da dahil olmak üzere,
değiştiğinde tetiklenir.


Instance.childAdded

Bu yöntem, nesneye bir etiket uygular, etiket daha önce uygulanmışsa
hiçbir etkisi olmaz. Başarıyla bir etiket eklemek, `Class.CollectionService:GetInstanceAddedSignal()`
yöntemiyle oluşturulan bir sinyali belirtilen etiket ile tetikler.

##### Uyarılar

- Bir nesneye istemci tarafında eklenen etiketler, sunucu daha sonra
  o nesne üzerinde bir etiket ekleyip kaldırdığında kaybolur, çünkü
dolayısıyla sunucu tüm etiketleri bir arada kopyalar ve önceki etiketleri
üzerine yazar.

- Bir nesneye etiket eklerken, bu etikete işlevsellik sağlamak için
bazı kaynakların kullanılması yaygındır, örneğin olay bağlantıları veya
tablolar. Bellek sızıntılarını önlemek için, bunları artık gerektiği
zaman temizlemek iyi bir fikirdir (bağlantıyı kesme, `nil` ayarlama, vb.).
Bunu `Class.Instance:RemoveTag()` çağrısından, `Class.Instance:Destroy()`
çağrısından veya `Class.CollectionService:GetInstanceRemovedSignal()` tarafından döndürülen
bir sinyale bağlı olan bir işlevde yapın.


Instance:AddTag

Bu işlev, bir nesnenin tüm çocuklarını ve soyundan gelenlerini yok eder.

```
local part = Instance.new("Part")

-- Bazı parıltılar ekleyin
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("Çocuklar:", #part:GetChildren())  --> Çocuklar: 3

part:ClearAllChildren()

print("Çocuklar:", #part:GetChildren())  --> Çocuklar: 0
```
Eğer **tüm** çocukları ve soyundan gelenleri yok etmek istemiyorsanız,
`Class.Instance:GetChildren()` veya `Class.Instance:GetDescendants()`
yöntemlerini kullanarak bu çocuklarda/dedelerde döngüler oluşturup
hangi nesneleri yok edeceğinizi seçmelisiniz. Örneğin, aşağıdaki kod örneği
bir `Class.Model`'dan düşen tüm `Class.BasePart|BaseParts`'ları yok edecektir:

```
local Workspace = game:GetService("Workspace")

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```


Instance:ClearAllChildren

Bu işlev, bir nesnenin tüm çocuklarını yok eder.


Modeli `Class.Instance:Clone()` kullanarak klonlamayı gösterir.

`Clone()` bir nesnenin ve tüm soyundan gelenlerinin kopyasını oluşturur,
görmezden geldiği `Class.Instance.Archivable|Archivable` olmayan tüm nesneleri. Kök nesnenin
kopyası bu yöntem tarafından döndürülür ve onun `Class.Instance.Parent|Parent`
özelliği `nil` olarak ayarlanır. Dikkat edilmesi gereken, eğer nesne
kendi `Class.Instance.Archivable|Archivable` özelliği `false`
şeklinde ayarlanmışsa, bu işlev `nil` döndürecektir.

Eğer kopyalanmış bir nesneyle `Class.ObjectValue.Value` gibi bir referans
özelliği ayarlanırsa, kopyanın özelliğinin değeri orijinalin
değerine bağlıdır:

- Eğer bir referans özelliği **aynı** zamanda kopyalanmış bir nesneye
  işaret ediyorsa, kopya, kopyayı gösterir.
- Eğer bir referans özelliği kopyalanmamış bir nesneyi gösteriyorsa,
kopyada aynı değer korunur.


Instance:Clone

Bir nesnenin ve tüm soyundan gelenlerin bir kopyasını oluşturur,
görmezden geldiği `Class.Instance.Archivable|Archivable` olmayan nesneleri.


Bir Part'ı `Class.Instance:Destroy()` fonksiyonunu kullanarak yok etmeyi gösterir.

Bu fonksiyon, artık gerekmeyen nesneleri imha etmek için doğru yoldur.

`Class.Instance.Parent` özelliğini `nil` olarak ayarlar, `Class.Instance.Parent`
özelliğini kilitler, tüm bağlantıları koparır ve tüm çocuklara
`Destroy()` çağrısı yapar. Bu işlev, artık gerekli olmayan nesneleri
ortadan kaldırmanın doğru yoludur.

Gereksiz nesneleri yok etmek önemlidir, çünkü yerinde gereksiz nesneler ve
bağlantılar bellek kullanır bu da zamanla ciddi performans sorunlarına yol
açabilir.

`Destroy()` çağrıldıktan sonra bir nesneye atıfta bulunan herhangi bir
değişkeni `nil` olarak ayarlamak en iyi yöntemdir. Bu, kodunuzun nesneyle
yakın olan hiç bir şeye erişmesini önler.

```lua
local part = Instance.new("Part")
part.Name = "Merhaba, dünya"
part:Destroy()
-- Bunu yapmayın:
print(part.Name)  --> "Merhaba, dünya"
-- Yukarıdaki satırın çalışmasını önlemek için bunu yapın:
part = nil
```
Bir `Class.Instance` bu yöntemle yok edildikten sonra tekrar kullanılamaz,
because `Class.Instance.Parent` özelliği kilitlidir. Bir nesneyi yok etmek
yerine **geçici** olarak kaldırmak için, `Class.Instance.Parent|Parent`
özelliğini `nil` yapın. Örneğin:

```
local Workspace = game:GetService("Workspace")

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Belirli bir zaman sonra bir nesneyi yok etmek için, `Class.Debris:AddItem()`
uygulayın.


Instance:Destroy

`Class.Instance.Parent` özelliğini `nil` olarak ayarlar, `Class.Instance.Parent`
özelliğini kilitler, tüm bağlantıları koparır ve tüm çocuklara
`Destroy()` çağrısı yapar.


`Class.Instance.Name`'inin, verilen isimle eşit olan ilk atayı geri döndürür.

Bu işlev yukarı doğru çalışır, yani `Class.Instance.Parent`
özelliğinin bulunduğu yerden başlayıp `Class.DataModel`'a kadar
çalışır. Eğer eşleşen bir atay bulunmazsa, `nil` döndürür.

Aşağıdaki kod örneği, `Car` adlı nesnenin ilk atasını bulur.

```
local car = object:FindFirstAncestor("Car")
```
Belirli bir sınıfın atalarını bulan bu işlevin varyantları için,
`Class.Instance:FindFirstAncestorOfClass()` ve `Class.Instance:FindFirstAncestorWhichIsA()`
bakabilirsiniz.


Instance:FindFirstAncestor

name

`Class.Instance.Name`'i verilen adla eşit olan ilk atayı geri döndürür.


`Class.Instance`'nin ilk atasını, `Class.Object.ClassName`'inin
verilen `className` ile eşit olanı döndürür.

Bu işlev yukarı doğru çalışır, yani `Class.Instance.Parent`
özelliğinin bulunduğu yerden başlayıp `Class.DataModel`'a kadar
gider. Eğer eşleşen bir atay bulunmazsa, `nil` döndürür.

Bu işlevin yaygın kullanımı, bir `Class.BasePart`'ın ait olduğu
`Class.Model`'ı bulmaktır. Örneğin:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Bu işlev, `Class.Instance:FindFirstAncestor()` işlevinin bir varyantıdır
yani `Class.Object.ClassName` özelliğini kontrol eder, `Class.Instance.Name`
özelliği dışında. `Class.Instance:FindFirstAncestorWhichIsA()` yöntemi de bulunmaktadır,
bu sınıf mirasını dikkate almak için `Class.Object:IsA()` yöntemini kullanır.


Instance:FindFirstAncestorOfClass

className

`Class.Instance`'nin ilk atasını verir.


Belirli bir className için `Class.Object:IsA()` ifadesinin true
dönmesi durumunda `Class.Instance`'nin ilk atasını döndürür.

Bu işlev yukarı doğru çalışır, yani `Class.Instance.Parent`
özelliğinin bulunduğu yerden başlayıp `Class.DataModel`'a kadar
gider. Eğer eşleşen bir atay bulunmazsa, `nil` döndürür.

`Class.Instance:FindFirstAncestorOfClass()` işlevinden farklı olarak,
bu işlev `Class.Object:IsA()` kullanır ve sınıf mirasını dikkate alır. Örneğin:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Bu nedenle, aşağıdaki kod örneği,
`Class.BasePart` olan ilk nesneyi döndürür, bu nesne ister `Class.WedgePart`,
`Class.MeshPart` ya da `Class.Part` olsun.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Ayrıca `Class.Instance:FindFirstAncestor()`'ı göz önünde bulundurabilirsiniz.


Instance:FindFirstAncestorWhichIsA

Verilen className için `Class.Object:IsA()`'nın true dönmesi durumunda,
`Class.Instance`'nin ilk atasını döndürür.


Aşağıdakiler, Workspace içinde "Brick" adlı bir nesne arayacaktır. Eğer bulunursa, bu
nesnenin adını "Foo" olarak değiştirecektir.

Verilen isimle bulunan `Class.Instance`'nin ilk çocuğunu döndürür, ya da
hiçbir çocuk yoksa `nil` döner. İsteğe bağlı `recursive` argümanı
`true` ise, bu işlev, `Class.Instance`'nin sadece doğrudan çocukları
yerine tüm soylarını tarar.

##### Bir Nesnenin Varlığını Kontrol Etme

Nesnenin var olup olmadığını kontrol etmek için `FindFirstChild()`
kullanmak gereklidir. Bir çocuğu nokta operatörüyle isimle indekslemeye çalışmak,
eğer çocuk mevcut değilse bir hata fırlatır.

```lua
local Workspace = game:GetService("Workspace")

-- Aşağıdaki satır, eğer parça yoksa hata verecektir
Workspace.Part.Transparency = 0.5
```
Daha iyi bir yaklaşım, önce `Part` için kontrol etmek ve ardından
bir `if` ifadesi ile buna ihtiyaç duyan kodu çalıştırmaktır.

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace:FindFirstChild("Part")
if part then
	part.Transparency = 0.5
end
```

##### Bir Çocuğu Özelliğiyle Eşleşen Bir İsim Arama

Bazen bir nesnenin `Class.Instance.Name|Name` özelliği,
`Class.Instance.Parent|Parent`'ının bir özelliğiyle aynı olabilir. Nokta operatörünü
kullanırken, özellikler aynı isime sahip olduklarında çocuklardan
önce gelir.

Aşağıdaki örnekte, `Color` adında bir `Class.Folder` bir `Class.Part`'a eklenmiştir,
aynı zamanda `Class.Part.Color` özelliği de bulunmaktadır. `part.Color`'ın
`Datatype.Color3` özelliği değerine, çocuğa (`Class.Folder`) değil,
dikkat edin. `Class.Instance:FindFirstChild()|FindFirstChild()` kullanımının bir
avantajı, yeni özelliklerin kodunuz üzerinde herhangi bir risk yaratmamasıdır.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- Özellik
local c2 = part:FindFirstChild("Color")  -- Çocuk klasör
```

##### Performans Notları

`Class.Instance:FindFirstChild()|FindFirstChild()` kullanımı, nokta operatörü kullanmaktan
yaklaşık %20 daha uzun sürer ve bir nesneyi doğrudan referans almanın
yaklaşık 8 kat daha uzun sürer. Bu nedenle, onu performansa bağlı
kodlarda, örneğin sıkı döngülerde veya `Class.RunService.Heartbeat`
ve `Class.RunService.PreRender` ile bu yöntemi çağırmak yerine, sonucu
bir değişkene kaydedin ya da `Class.Instance.ChildAdded|ChildAdded`
veya `Class.Instance:WaitForChild()|WaitForChild()` ile arama yaparak belirli bir
ismin çocuğunun mevcut olduğunda tespit edilmesini düşünün.


Instance:FindFirstChild

recursive

Aramanın yinelemeli olarak yapılıp yapılmayacağı.


Verilen isimle bulunan `Class.Instance`'nin ilk çocuğunu döndürür.


Belirli bir `className` ile eşleşen `Class.Instance`'nin ilk çocuğunu döndürür.
`Class.Instance:FindFirstChildWhichIsA()` işlevinden farkı, bu
şekilde sadece `className` ile eşleşen nesneleri döndürmesi,
sınıf mirasını yok saymasıdır. Eğer hiçbir eşleşen çocuk bulunmazsa,
bu işlev `nil` döndürür.


Instance:FindFirstChildOfClass

Belirli bir `className` ile eşleşen `Class.Instance`'nin ilk çocuğunu döndürür.


Verilen className için `Class.Object:IsA()` ifadesinin true
dönmesi durumunda `Class.Instance`'nin ilk çocuğunu döndürür.

Eğer eşleşen bir çocuk bulunmazsa, bu işlev `nil` döndürür. İsteğe bağlı
olarak `recursive` argümanı `true` ise, bu işlev, `Class.Instance`'nin
sadece doğrudan çocukları yerine tüm soylarını tarar.

`Class.Instance:FindFirstChildOfClass()` işlevinden farklı olarak,
bu işlev `Class.Object:IsA()` kullanır ve sınıf mirasını dikkate alır. Örneğin:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Bu nedenle, aşağıdaki kod örneği,
`Class.BasePart` olan ilk çocuğu döndürür, bu çocuk ister `Class.WedgePart`,
`Class.MeshPart` veya `Class.Part` olsun.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Bir isme göre çocuğu arayan geliştiricilerin,
`Class.Instance:FindFirstChild()` kullanmalarını öneririz.


Instance:FindFirstChildWhichIsA

Verilen className için `Class.Object:IsA()` ifadesinin true dönmesi durumunda,
`Class.Instance`'nin ilk çocuğunu döndürür.


Belirli bir `Class.Instance.Name` ile bulunan ilk soyunu geri döndürür.

Bu yöntem devre dışıdır ve kullanılamaz. Bir nesnenin ilk soyunu bulmak
istiyorsanız, bunun yerine `Class.Instance:FindFirstChild()`'ta `recursive`
parametresini kullanmayı düşünün.


Instance:FindFirstDescendant

Belirli bir `Class.Instance.Name` ile bulunan ilk soyunu geri döndürür.


Eğer `Class.Instance`, bir `Class.Actor` ise, `Class.Actor` kendisi
geri döndürülür. Aksi takdirde, en yakın atası `Class.Actor`
geri döner. Eğer hiçbir atası `Class.Actor` değilse, sonuç `nil`
dönmektedir.


Instance:GetActor

`Class.Actor` ile ilişkili `Class.Instance`'yi, varsa,
geri döndürür.


Bu yöntem, verilen nitelik adında atanan değeri geri döndürür. Eğer hiçbir
nitelik atanmadıysa, `nil` döner.

Örneğin, aşağıdaki kod parçası nesnenin `InitialPosition` niteliğinin
değerini ayarlar ve ardından alır:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local initialPosition = instance:GetAttribute("InitialPosition")
print(initialPosition)
```

##### Ayrıca Bakınız

- `Class.Instance:SetAttribute()` özelliği, belirtilen adına
  ait niteliği, belirtilen değere ayarlar.
- `Class.Instance:GetAttributes()` değer çiftleri için bir sözlük
  döndürür.


Instance:GetAttribute

Verilen niteliğe atanan değer. Eğer hiçbir nitelik atanmadıysa,
`nil` döner.


Verilen nitelik adında atanan değeri geri döndürür.


Bu işlev, tam olarak `Class.Object.Changed|Changed` olayına benzer
bir olayı geri döndürür, yalnızca belirtilen niteliğin değiştiğinde
tetiklenir; sonuç olarak `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()`
özelliğine benzer ancak nitelikler içindir.

Genel olarak, bu yöntemi, belirli bir niteliğin adını kontrol eden bir
görevin bir `Class.Object.Changed|Changed` bağlantısına yerleştirmektense
kullanmanız iyi bir fikirdir. Bu nesne üzerindeki aynı nitelikle aynı olur
ve aynı niteliği kontrol eden işlevle aynı olan başka bir bağlantı
oluşturursanız, yapılan çağrılar, önceden belirlenmiş bir olayla döndürülür.

Aşağıdaki kod örneği, parça'nın `InitialPosition` niteliği değiştiğinde
tetiklenecek `attributeChanged()` işlevini döndürür:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local function attributeChanged()
	print("Niteliği değişti")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Ayrıca, bir nesne üzerindeki herhangi bir niteliğin değiştiğinde ateşleyen
`Class.Instance.AttributeChanged` işlevine bakabilirsiniz.


Instance:GetAttributeChangedSignal

Belirtilen nitelik için değişim sinyalinin geri döndürülen adı.


Belirtilen niteliğin değiştiğinde tetiklenen bir olay.


Belirtilen niteliğin değiştiğinde ateşlenen bir olayı geri döndürür.


Bu yöntem, anahtar-nitelik çiftleri için bir sözlüğü geri döndürür
anahtarın niteliğin adı ve değerinin `nil` olmayan bir değer olduğu
şekilde.

Örneğin, aşağıdaki kod parçası bir nesnenin niteliklerini ve
değerlerini yazdırır:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)
part:SetAttribute("CanUse", true)

for name, value in part:GetAttributes() do
	print(name .. " = " .. value)
end
```
Ayrıca, belirtilen niteliğe atanan değeri geri döndüren
`Class.Instance:GetAttribute()` işlevine de göz atın.


Instance:GetAttributes

Her bir niteliğin adıyla birlikte anahtar-değer çiftlerinden oluşan bir
sözlük.


Nesnenin tüm niteliklerinin bir sözlüğünü geri döndürür.


Aşağıdakiler çalıştırıldığında Workspace'teki tüm nesnelerin adını yazdırır.

Nesnenin doğrudan çocuklarını veya `Class.Instance`'nin `Class.Instance.Parent|Parent`
eşit olduğu her şeyi barındıran bir diziyi geri döndürür. Dizi,
yerine düşürmek/işlevsellik kazandırmak için veya önceki bir dizindeki gibi
sayısal veya genel bir döngü ile yazdırılabilir:

```lua
local Workspace = game:GetService("Workspace")

-- Sayısal döngü örneği
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " çocuk numarasıdır " .. i)
end
```

```lua
local Workspace = game:GetService("Workspace")

-- Genel döngü örneği
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " çocuk numarasıdır " .. i)
end
```
Bu çocuklar, `Class.Instance.Parent|Parent` özelliğinin nesneye ayarlandığı
sıraya göre sıralanmışlardır.

Ayrıca, `Class.Instance:GetDescendants()|GetDescendants` işlevine de bakın.


Instance:GetChildren

Nesnenin çocuklarını içeren bir dizi.


Nesnenin tüm çocuklarının bulunduğu bir dizi döndürür.


Roblox tarafından dahili olarak kullanılan debug ID'nin şifreli bir
dizesini döndürür. Dikkat edin:

- Bu nesne korumalıdır. Bir `Class.Script` veya `Class.LocalScript`'te kullanmaya çalışmak hata verir.
- Debug ID, hata ayıklama süreçlerinde kullanılan bir ID'dir. Debugger'ın,
  bir uygulama işlenmeden önce her talimatı okumasına olanak tanır. Roblox'taki tüm nesneler
  işlemler gibi davranır ve her bir çalıştırım talimatları (veya 'kod') içerebilir,
  gerekiyorsa hata ayıklanabilir.
- Bu, benzer nesneleri ayırt etmesi gereken eklentiler için faydalı olabilir.


Instance:GetDebugId

scopeLength

Roblox tarafından dahili olarak kullanılan debug ID'nin şifreli bir dizesini döndürür.


GetDescendants genellikle belirli bir tür objenin tüm soyundan gelenleri bir
şeyler yapmak için kullanılır. Bu örnekteki kod, GetDescendants ve
`Class.Instance:IsA()` kullanarak çalışma alanındaki tüm parçaları bulur ve
onları yeşil yapar.

Bu nesne yöntemi, nesnenin tüm soylarını içeren bir dizi döndürür.
`Class.Instance:GetChildren()`'dan farklı olarak, yalnızca bir nesnenin
doğrudan çocuklarını geri döndürmez, aynı zamanda nesnenin tüm çocuklarını,
çocuklarının tüm çocuklarını ve devam edenleri bulur.


Instance:GetDescendants

Nesnenin tüm soylarından oluşan bir dizi geri döndürür.


Bu kod örneği, `Class.Instance:GetFullName()` fonksiyonunun davranışını göstermektedir.
Fonksiyonun `DataModel` hiyerarşisinde olmayan bir nesne üzerinde çağrıldığında nasıl davrandığını
ve dönüş değerinin özel karakterleri nasıl kaçırmadığını gösterir.

Bu kod örneği `Class.Instance:GetFullName()` fonksiyonunu Lua'da yeniden uygular.

Bu, nesnenin soyunu açıklayan bir dize döndürür. Dize, nesnenin
tanıtıcı adı ve ataları, noktalarla ayrılır. `Class.DataModel` (`game`)
üzere düşünülmez. Örneğin, `Class.Workspace` içinde bir `Class.Part` şunları geri döndürebilir:
`Class.Workspace.Part`.

`Class.DataModel`'ın bir soy bağı olarak düşünüldüğü bir `Class.Instance`'in çağrılması,
`tahmini en üst ata` olarak görülür. Bu çalışma, bellek kullanımı ve
hata ayıklama amacıyla kullanışlıdır. Döndürülen dizeyi herhangi bir faydalı işlevde ayrıştırmaya
çalışmayın; bu işlev, nesne adlarında noktaları (ya da diğer sembolleri)
düşünmez. Başka bir deyişle, çıktısı genellikle geçerli bir Luau tanıtıcı
şeklinde görünse de, bu garanti edilmez.


Instance:GetFullName

Nesnenin soy kodunu açıklayan bir dize döndürür.


Bu yöntem, belirtilen özelliğin stilize edilmiş veya açıkça
değiştirilmiş değerini geri döndürür, yoksa stilize edilmemiş/değiştirilmemiş varsayılan
özellik değerini geri döndürür. Bu, `[GuiObject].Rotation` gibi,
eğer özelliğin değerine doğrudan erişim sağlarsanız, varsayılan ya da değiştirilmiş
hâlindeki özelliği dönüyor olur.

```lua
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")

local coreSheet = ReplicatedStorage:FindFirstChild("CoreSheet")
local rule = coreSheet:FindFirstChildWhichIsA("StyleRule")
rule.Selector = "TextButton"

-- Bir butona referans
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (varsayılan değer)
print(button.Rotation) --> 0 (varsayılan değer)

-- Stil kuralı özelliğiyle uygulanan dönüşüm
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (stilize edilmiş değer)
print(button.Rotation) --> 0 (varsayılan değer)

-- Stilize edilmiş özelliği açıkça değiştirme/baskılama
button.Rotation = 45

print(button:GetStyled("Rotation")) --> 45 (değiştirilmiş değer)
print(button.Rotation) --> 45 (değiştirilmiş değer)
```


Instance:GetStyled

Belirtilen özelliğin stilize edilmiş veya açıkça değiştirilmiş değeri,
yoksa stilize edilmemiş/değiştirilmemiş varsayılan özellik değeri.


Belirtilen özellik değerinin stilize edilmiş veya açıkça değiştirilmiş değerini,
yoksa stilize edilmemiş/ değiştirilmemiş varsayılan özellik değerini geri döndürür.


Bu yöntem, yalnızca belirtilen stil özelliği değiştiğinde ateşlemesi
gereken bir olayla tam olarak `Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`
events'
in bir olayıdır. Genel olarak,bu yöntemi, belirli bir stil özelliğinin
adını kontrol eden bir işlevle `Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`
bir bağlantı kurmak yerine kullanmanız iyi bir fikirdir. Aynı nesne üzerindeki
bu yöntemin aynı özellik adıyla çağrılmasında aynı olay döner.

Dikkat edin, bu olayı bağlanırken, herhangi bir argümanın geçirilmemesi,
dolayısıyla değiştirilen niteliğin doğrudan okunması gerekir.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Stil özelliği değişti!")
end

meterBar:GetStyledPropertyChangedSignal("AnchorPoint"):Connect(stylePropertyChanged)
```


Instance:GetStyledPropertyChangedSignal

property

Değişim sinyali dinlenecek stil özelliğinin adı.


Veritabanı ilişkilendirilmiş olayın tetiklendiği sinyal.


Bu yöntem, verilen nesneye uygulanan etiketler dizisini,
yani dizeleri geri döndürür. Etiketleri hem
[Özellikler](/studio/properties) penceresinde Studio'da ekleyebilir ya da
çalışma zamanında `Class.Instance:AddTag()|AddTag()` ile ekleyebilirsiniz.

Bu yöntem, bir nesne üzerindeki birden fazla etikete aynı anda
bir şey yapmak istediğinizde faydalıdır. Ancak, tek bir etiketin
varlığını kontrol etmek için bu yöntemi kullanmak verimsizdir,
bunun yerine belirli bir etiketi kontrol etmek için
`Class.Instance:HasTag()|HasTag()` özelliğini kullanın.


Instance:GetTags

Nesneye uygulanmış tüm etiketlerin dizisini alır.


Bu yöntem, sağlanan etiketin nesneye eklenip eklenmediğine dair `true`
döndürüyor. Etiketleri hem Studio'da
[Özellikler](/studio/properties) penceresinde ekleyebilir ya da
çalışma zamanında `Class.Instance:AddTag()|AddTag()` ile ekleyebilirsiniz.


Instance:HasTag

Nesnenin belirli bir etikete sahip olup olmadığını kontrol eder.


Bir örneğin başka bir örneğin ata olup olmadığını belirlemeyi gösterir `Class.Instance:IsAncestorOf()`

Workspace ve SpawnLocation, SpawnLocation'ın dekallerinin atalarıdır.
Workspace, SpawnLocation'ın atasıdır.

SpawnLocation ve dekali, Workspace'in soyundan gelir, ataları değildir.
Dekal, SpawnLocation'a bir soy göndericisidir, ata değildir.

Bir `Class.Instance`'in, verilen soydan bir atası olup olmadığını kontrol eden
bir işlevdir.

Bir `Class.Instance`, nesnenin `Class.Instance.Parent`'ının veya
bir ebeveyninin `Class.Instance.Parent`ının `Class.Instance` olarak
ayarlanması durumunda atası olarak kabul edilir.

`Class.Instance:IsDescendantOf()` ile de bakabilirsiniz.


Instance:IsAncestorOf

Verilen soyun `Class.Instance`'nin atası olup olduğu doğru.


Bir `Class.Instance`'in, verilen soydan bir atası olup olmadığını kontrol eder.


Verilen atanın bir `Class.Instance`'in soyu olup olmadığını kontrol eder.

`nil` parametresiyle `IsDescendantOf()` kullanılmamalıdır; böylece bir nesnenin kaldırılıp
kaldırılmadığını kontrol etmemek gerekir.

`Class.Instance:IsAncestorOf()` ile de kontrol edebilirsiniz.


Instance:IsDescendantOf

ancestor

Verilen atanın `Class.Instance`'nin soyu olduğu doğru.


Verilen atanın bir `Class.Instance`'in soyunu kontrol eder.


Belirtilen kaydın değeri, kodla yerinden kaynaklanan varsayılan değeriyle
eşitse `true` döndürür. Örneğin, `Class.TextLabel.TextSize|TextSize` niteliğinin
bir `Class.TextLabel`'ın değerinin `8` olduğu;
dehum yapıldığında `IsPropertyModified("TextSize")` çağrıldığında `false`
gelir, çünkü `8`'in varsayılan değeri `Class.TextLabel.TextSize`
özelliğidir ve bu oluşturulmuş bir `Instance.new("TextLabel")`
şeklinde değil, Studio'nun ekleme iş akışlarıyla değil.

Bu yöntem `true` dönerse, stil, özelliği etkilemez; çünkü açıkça bir özelliği
 değiştirmek, stil ile öncelikli bir durumdadır.


Instance:IsPropertyModified

Özelliğin değiştirilip değiştirilmediği doğru.


Belirtilen kaydın değeri, kodla yerinden kaynaklanan varsayılana eşitse `true`
döndürür.


Aşağıdaki kod, bir parçanın kaldırıldıktan sonra DataModel'e nasıl yeniden eklenebileceğini göstermektedir:


Bu işlev, nesnenin `Class.Instance.Parent`'ını `nil` yapar, ve tüm soylarını da aynı
duruma getirir.

Eğer nesne kaldırılmadan önce referans verilirse, nesne daha sonra
tekrar alınabilir.


Instance:Remove

Nesnenin `Parent`'ını `nil` yapar, ve tüm soylarını da aynı işlemi yapar.


Bu yöntem, bir nesneden bir etiketi kaldırır. Eğer nesne bu etikete sahip değilse hata fırlatmaz.
Başarıyla bir etiketi kaldırmak, `Class.CollectionService:GetInstanceRemovedSignal()`
metodu ile verilen etiketi taşıyan bir sinyal fırlatır.

Dikkat edin ki, bir nesneye etiket eklerken, bu etiketin işlevselliğini sağlamak için kaynakların bulunabileceği
yaygındır, örneğin olay bağlantıları veya tablolar. Bellek sızıntılarını önlemek için,
bunları öncelikle temizlemek iyi bir fikirdir
(bazı bağlantıları koparma, `nil` ayarlama, vb.) bunları gereksinim olmayacak zamanlarda.


Instance:RemoveTag

Bir özelliği varsayılan değerine sıfırlar. Örneğin,
`ResetPropertyToDefault("Rotation")` çağrısı `Class.TextLabel` üzerinde,
`Class.TextLabel.Rotation|Rotation` değerini `0` (özelliğin
varsayılan değeri) olarak ayarlamakla eşdeğerdir. Bu yöntem, stilin
bu özelliğin varsayılan değerini geçmesini sağlamak için kullanılabilir.


Instance:ResetPropertyToDefault

Bir özelliği varsayılan değerine sıfırlar.


Bu yöntem, verilen isimle tanımlı niteliği verilmiş değere ayarlar. Eğer
verilen değer `nil` ise, bu nitelik kaldırılır; çünkü `nil`
varsayılan olarak döner.

Örneğin, aşağıdaki kod parçası nesnenin `InitialPosition`
niteliğini `Datatype.Vector3|Vector3.new(0, 10, 0)` olarak ayarlar:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", Vector3.new(0, 10, 0))
```

##### Sınırlamalar

İsimlendirme gereksinimleri ve kısıtlamaları:

- İsimler yalnızca alfanümerik karakterler içermelidir.
  - Nokta, tire, eğik çizgi ve alt çizgi de eklenebilir.
- Boşluk veya benzersiz semboller (örneğin @, ~, !) kullanılamaz.
- Dizeler 100 karakter veya daha az olmalıdır.
- İsimler **RBX** ile başlayamaz; eğer çağıran bir
  Roblox temel betiği ise (Roblox için ayrılmıştır).

Desteklenmeyen bir türde bir niteliği ayarlamaya çalışırken, bir hata
oluşacaktır.

##### Ayrıca Bakınız

- `Class.Instance:GetAttribute()` verilen nitelik adının atanmış
  değerini döndürür.
- `Class.Instance:GetAttributes()` her bir nesnenin niteliği için
  anahtar-değer çiftleri içeren bir sözlük döndürür.


Instance:SetAttribute

value

Belirtilen niteliği ayarlamak için değer.


Verilen isimle tanımlı niteliği verilmiş değere ayarlar.


Aşağıdaki kod, "Parça" adı verilen bir nesnenin
Workspace'e eklenmesini bekler.

Verilen isimle `Class.Instance`'ın çocuğunu döndürür. Eğer
çocuk mevcut değilse, mevcut iş parçacığını mevcut olana kadar bekletir. Eğer
`timeOut` parametresi belirtilmişse, bu yöntem belirtilen süre
sonunda zaman aşımına uğrayacak ve `nil` döndürecektir.

##### Temel Kullanım

`Class.Instance:WaitForChild()|WaitForChild()` bir `Class.LocalScript`
dışında çalışan kod üzerinde son derece önemlidir. Roblox
motoru, nesnelerin sunucudan istemciye hangi sürede ve sırayla çoğaltılacağına
ilişkin bir garanti vermez. Ayrıca, bir deneyim `Class.Workspace.StreamingEnabled`
in durumunun doğru ayarlanması durumunda, oyuncunun karakterinden uzak
değişiklikler yapıldığında, `Class.BasePart|BaseParts` istemciye aktarılmıyor
ebilir ve bu da istemcide henüz mevcut olmayan nesnelere erişilirken scriptlerin
çalışmasını bozabilir.

##### Notlar

- Eğer çağrı yapıldığında verilen isimde bir çocuk mevcutsa, bu işlev
  bekletmez.
- `Class.Instance:FindFirstChild()` mevcut olduğu varsayılan nesneler için
  `Class.Instance:WaitForChild()|WaitForChild()` yöntemine göre daha verimli
  bir alternatiftir.
- Eğer bu yöntemle çağrı 5 saniyeyi geçerse ve dönüş sağlamazsa, ve
  `timeOut` parametresi belirtilmemişse, iş parçacığının sonsuz bekleyebileceğine
  dair bir uyarı çıktıya yazılır.


Instance:WaitForChild

childName

timeOut

Verilen isimle `Class.Instance`'ın çocuğunu döndürür. Eğer
çocuk mevcut değilse, mevcut iş parçacığını mevcut olana kadar bekletir.


Çocuklar işlevi, nesnenin çocuklarının bir dizisini döndürür.


Instance:children

Çocuk nesnelerinin/örneklerinin dizisi.


Nesnenin çocuklarının bir dizisini döndürür.


Instance:clone

Instance:destroy

Instance:findFirstChild

Instance:getChildren

Instance:isDescendantOf

Instance:remove

Instance

Bu özellik, nesnenin yayınlandığında veya kaydedildiğinde dahil edilip
edilmeyeceğini, ya da `Class.Instance:Clone()|Clone()` çağrıldığında
nesnenin atalarından birinin üzerinde olup olmadığını belirler. `Class.Instance:Clone()|Clone()`
nesnesi üzerinde doğrudan çağrıldığında `nil` döndürür eğer bu
nesne **değilse** `Class.Instance.Archivable|Archivable`.

Studio'da **Yinelenen** veya **Kopyala**/**Yapıştır**
seçenekleriyle bir nesneyi kopyalamak, kendi `Class.Instance.Archivable|Archivable`
özelliğini yok sayacak ve kopya için `Class.Instance.Archivable|Archivable`
özelliğini `true` yapacaktır.

```
local part = Instance.new("Part")
print(part:Clone())  --> Part
part.Archivable = false
print(part:Clone())  --> nil
```


Instance.Archivable

`Class.Instance` ve alt nesnelerinin `Class.Instance:Clone()` ile kopyalanıp
kaydedilebileceğini belirler.


Bu nesne içinde kullanılmasına izin verilen yetenekler seti. Yeteneklerin
etki göstermesi için `Class.Instance.Sandboxed`
özelliğinin etkinleştirilmiş olması gerekir.

Bu özellik deneysel bir özellik tarafından kullanılır. Daha fazla bilgi için
[baskı yetenekleri](/scripting/capabilities) sayfasına bakın.


Instance.Capabilities

Bu kapsayıcıda kullanılmasına izin verilen yetenekler seti.


`Class.Instance` için benzersiz olmayan bir tanıtıcı. İsimler, nesne
hiyerarşisini düzenli tutmak için kullanılır, ayrıca betiklerin belirli
nesnelere erişmesine de olanak tanır. Bir nesnenin adı 100 karakteri
geçemez.

Bir nesnenin adı, verim modeli hiyerarşisi aracılığıyla nesneye erişim
sağlamak için genellikle şu yöntemleri kullanır:

```
local Workspace = game:GetService("Workspace")

local baseplate = Workspace.Baseplate
local baseplate = Workspace["Baseplate"]
local baseplate = Workspace:FindFirstChild("BasePlate")
```
Bir nesne, nokta operatörü (`.`) kullanılarak erişilebilir olması için
adının bir alt çizgi veya harfle başlaması gerekir, geri kalanı yalnızca
harfler, sayılar veya alt çizgiler içerebilir (başka özel
karakterler yok). Eğer bir nesnenin adı bu sözdizimine uymazsa,
neresi nokta operatörü kullanılarak erişilemez ve Luau adı
bir tanıtıcı olarak yorumlamaz.

Eğer aynı adı taşıyan birden fazla nesne kardeşse, o adı taşıyan
bir nesneye erişim girişimi sadece bir nesneyi döndürecek, `Class.Instance:FindFirstChild()` gibi,
bir zaman her zaman istenen nesne olmayabilir. Eğer belirli bir nesneye
kod aracılığıyla erişim sağlanıyorsa, ona benzersiz bir ad verilmesi veya
kardeşlerinin aynı adı paylaşmadığından emin olunması önerilir.

Ayrıca, bir nesnenin hiyerarşisini içeren tam adını almak için `Class.Instance:GetFullName()`'a
bakın.


Instance.Name

`Class.Instance` için benzersiz olmayan bir tanıtıcı.


`Parent` özelliği, `Class.Instance`'ın hiyerarşik ebeveynini
determin. Bu özellik ayarlandığında yaygın olarak kullanılan aşağıdaki
terimlendirmedir:

- Bir nesne, başka bir nesnenin `Parent`'ı olarak ayarlandığında
  **çocuk** olarak adlandırılır veya o nesneye **ebeveynlik** yapar.

- Bir `Class.Instance`'ın **soyundan gelen** çocuklar, o nesnenin
  çocukları ile birlikte çocukların soylarından gelenlerdir.

- Bir `Class.Instance`'ın **atalar**ı, nesnenin söz konusu olduğu tüm
  nesnelerdir.

`Parent` özelliği sayesinde, `Class.Instance:GetChildren()|GetChildren()` ve
`Class.Instance:FindFirstChild()|FindFirstChild()` gibi diğer API
üyeleri isimlerini alır. Bu özellik ayrıca, bir nesnenin deneyimde
mevcut olup olmadığını veya kaldırılması gerekip gerekmediğini yönetmek
için de kullanılır. Bir nesnenin ebeveyninin `Class.DataModel` içinde
olduğu, bir değişkene depolandığı veya başka bir nesnenin özelliğiyle
tanımlandığı sürece nesne deneyimde kalır; aksi takdirde nesne otomatik olarak
kaldırılacaktır.

`Class.Instance:Destroy()|Destroy()` çağrıldığında, bir `Class.Instance`
ve tüm alt nesnelerinin `Parent`'ı `nil` olarak ayarlanacak ve `Parent`
özelliği de **kilitlenecektir**. Kaldırılmış bir nesnenin `Parent`
özelliğini ayarlamak istendiğinde hata ortaya çıkacaktır.

`Datatype.Instance.new()` kullanılarak oluşturulan yeni nesnelerin ebeveyni
olmayacak ve genellikle bir tanım yapılana kadar görünür veya çalışmaz.

##### Nesne Kopyalama

Sunucu tarafından oluşturulan bir nesne, bazı nesnelere atanmadıkça
istemciye kopyalanmayacaktır. Bir nesne oluştururken ve birçok
özelliği ayarlarken, `Parent` özelliğinin **son** olarak ayarlanması
önerilir. Bu, nesnenin bir kez kopyalanmasını sağlar, birçok özellik
değişikliği yerine.

```lua
local Workspace = game:GetService("Workspace")

-- Yeni nesnenin ebeveynini en son ayarlayın (önerilen)
local part = Instance.new("Part")
part.Position = Vector3.new(0, 10, 0)
part.Parent = Workspace
```
Ancak, ebeveynlik yapılmadan önce kırılma ilgili bir `Class.Model`'ın
kalan parçalarına ebeveynlik yapmak kabul edilebilir, çünkü model henüz
kopyalanmamıştır.


Instance.Parent

`Class.Instance`'ın hiyerarşik ebeveynini belirler.


`Instance` Roblox sınıf hiyerarşisindeki tüm sınıfların temel sınıfıdır
`Class.DataModel` ağacının bir parçası olabilir.


/reference/engine/classes/RecommendationService.yaml