Bir `Class.Actor`, kendi içinde güvenli bir şekilde `Library.task.desynchronize()` kullanarak parçalanabilen kodlar için bir kapsayıcıdır. Ayrıca, betikleri tarafından kullanılan örnekleri de içermelidir.

Birden fazla Actor kullanarak betik performansını optimize etme hakkında daha fazla bilgi için
[Paralel Luau](/scripting/multithreading) sayfasına bakın.

#### Notlar

- Her `Actor`, kendi Luau VM'sinde çalışır. Bir `Actor` tarafından gereken `Class.ModuleScript|ModuleScripts`
  **paylaşılmaz** veya `Actors` arasında veya ana iş parçacığı ile önbelleğe alınmaz. Her VM, modülün kendi kopyasını çalıştırır, bu nedenle
  modül düzeyindeki durum her `Actor` için izole edilmiştir. Modülleriniz durum tutuyorsa ve paylaşmayı düşünüyorsanız, buna göre tasarlayın.
- `script:GetActor()` metodu, `Class.ModuleScript` içinden çağrıldığında `nil` döner,
  eğer `ModuleScript`, `Actor`'ın bir alt öğesi değilse. Başka bir yerde saklanan `ModuleScripts`
  (örneğin, `Class.ReplicatedStorage`) ve bir `Actor` tarafından gerekenler, `Actor`'ın alt öğesi olarak kabul edilmez.


Bu yöntem, belirtilen konuyla ilgili bir mesaja Luau geri çağrısı bağlamak için kullanılır. Belirtilen konuya gönderilen bir mesaj (kullanarak
`Class.Actor:SendMessage()|SendMessage()`) gönderildiğinde, sağlanan geri çağrı _serial_ çalışma bağlamında çağrılacaktır.

Birden fazla Luau geri çağrısı tek bir aktöre ve hatta tek bir mesaj konusuna bağlanabilir.

Not: Yalnızca bir Aktörün alt öğeleri olan betikler, mesajlarına bağlanabilir.

```lua
local actor = script:GetActor()

-- Bu betik bir Aktörün alt öğesi olduğunda, bir selamlaşma mesajı gönderildiğinde bir mesaj yazdırır.
local connection = actor:BindToMessage("Greeting", function(message)
  print("Alınan Selamlaşma Mesajı:", message)
end)
```

Actor:BindToMessage

topic

Mesaj türünü belirlemek için kullanılan konu.

function

Bu bağlantı nesnesi, Luau geri çağrısını mesajları almaktan ayırmak için kullanılabilir.

Belirtilen konuyla ilgili bir mesaja Luau geri çağrısı bağlar.

Bu yöntem, belirtilen konuyla ilgili bir mesaja Luau geri çağrısı bağlamak için kullanılır. Belirtilen konuya gönderilen bir mesaj (kullanarak
`Class.Actor:SendMessage()|SendMessage()`) gönderildiğinde, sağlanan geri çağrı _parallel_ çalışma bağlamında çağrılacaktır.

Birden fazla Luau geri çağrısı tek bir aktöre ve hatta tek bir mesaj konusuna bağlanabilir.

Not: Yalnızca bir Aktörün alt öğeleri olan betikler, mesajlarına bağlanabilir.

```lua
local actor = script:GetActor()

-- Bu betik bir Aktörün alt öğesi olduğunda, bir selamlaşma mesajı gönderildiğinde bir mesaj yazdırır.
local connection = actor:BindToMessageParallel("Greeting", function(message)
  print("Alınan Selamlaşma Mesajı:", message)
end)
```

Actor:BindToMessageParallel

Bir Aktöre mesaj gönderir. Mesajlar asenkron olarak gönderildiğinden,
Gönderen, `Class.Actor:SendMessage()|SendMessage()` metodunu çağırırken bloklanmaz veya beklemez.

Tek bir Actor farklı türde mesajlar alabileceğinden, farklı türde mesajları ayırt etmek için bir `topic`
parametresi kullanılır.

`Class.Actor:BindToMessage()|BindToMessage()` metodunu kullanarak gönderilen bir mesajı almak için daha fazla bilgiye bakın.

Mesaj argümanlarının **kopya ile** Luau VM sınırları arasında geçildiğini, referans ile değil olduğunu unutmayın. Büyük tabloların gönderilmesi, her çağrıda tam bir kopya oluşturur. Fonksiyonlar belirli bir VM'ye bağlıdır ve mesajlarda geçirilemez.

```lua
-- 'actor'ın bir Actor örneğine atıfta bulunan yerel bir değişken olduğunu varsayalım
actor:SendMessage("Greeting", "Merhaba Dünya")
```


Actor:SendMessage

Gönderilen mesajı tanımlamak için kullanılan konu.

message

Aktöre gönderilecek mesajın içeriği.

Actor

Bir `Class.Actor`, kendi içinde güvenli bir şekilde ayrılabilen kod için bir kapsayıcıdır.

Aşağıdaki örnek, bir nesne tablosunu alan ve onları yeni bir Model içine ebeveyn olarak atayan temel bir işlev içermektedir, bu Model'i döndürmektedir.

Modeller, nesneleri bir araya getiren konteyner nesneleridir. En iyi
`Class.BasePart|BaseParts` koleksiyonlarını tutmak için kullanılırlar
ve işlevselliğini genişleten bir dizi fonksiyona sahiptirler.

Modeller, **geometrik** gruplamaları temsil etmek için tasarlanmıştır. Eğer
gruplamanızın geometrik bir yorumu yoksa, örneğin bir
`Class.Script|Scripts` koleksiyonu varsa, bunun yerine bir
`Class.Folder` kullanın.

Bileşen parçaları eklemlerle birleştirilen modeller (bu nedenle hareket edebilir
veya fiziksel simülasyonla yok edilebilir) genellikle bir
`Class.Model.PrimaryPart|PrimaryPart` ayarına sahiptir, çünkü bu, model
hareket ederken pivot ve sınır kutusunun hangi parçayı "takip edeceğini"
belirler. Tek yere sabit kalan statik modeller, bir birincil parça setinin
olmasından fayda sağlamaz.

Modellerin geniş bir uygulama yelpazesi vardır, bunlar arasında Roblox oyun
karakterleri de bulunmaktadır. Ayrıca, akılda tutulması gereken birçok benzersiz
davranışa sahiptirler:

- Eğer bir `Class.Humanoid` ve **Baş** adında bir `Class.Part` modelin
  altına yerleştirilirse, modelin üzerinde bir isim/sağlık GUI'si
  belirecektir; ayrıntılar için
  [Karakter İsim/Sağlık Gösterimi](/characters/name-health-display)
  kısmına bakın.
- Eğer bir parçanın **Y** eksenindeki konumu
  `Class.Workspace.FallenPartsDestroyHeight` değerine ulaşıyorsa ve
  bu bir `Class.Model` içindeki son nesne ise, model de yok edilecektir.
- `Class.Workspace.StreamingEnabled` true olarak ayarlandığında,
  `Class.Model.ModelStreamingMode|ModelStreamingMode` değeri, model ve
  herhangi bir alt nesnelerin nasıl çoğaltıldığı ve/veya istemcilerden
  nasıl çıkarıldığı ile ilgili çeşitli davranışları kontrol eder.
  Ayrıca, `Class.Model.LevelOfDetail|LevelOfDetail` değeri modelin
  renderlamasını etkiler.

Tüm `Class.Instance` türlerinde olduğu gibi, bir ana `Class.Model`
istemcide çoğaltıldığında, tüm çocuklarının
geliştirilmiş olacağı garantisi yoktur. Bu, istemci üzerinde çalışan kodlar
şu durumlarda erişiliyorsa özellikle önemlidir, örneğin bir
`Class.LocalScript` içinde.
`Class.Model.ModelStreamingMode|ModelStreamingMode` değerinin
`Enum.ModelStreamingMode|Atomic` gibi değerlerle kullanılması,
eğer ana model istemcide mevcutsa tüm modelin ve tüm alt nesnelerin
mevcut olduğunu garantileyebilir; ya da atomiklik istenmiyorsa,
`Class.Instance:WaitForChild()|WaitForChild()` kullanılabilir.

Bu modeli belirli bir oyuncu için kalıcı hale getirir. Kalıcı
modeller, akış ayarları veya koşulları ne olursa olsun, oyuncu için
mevcuttur.

`Class.Model.ModelStreamingMode|ModelStreamingMode`, ekleme sonucu
davranışın değişmesi için `Enum.ModelStreamingMode|PersistentPerPlayer`
olarak ayarlanmalıdır.

Model:AddPersistentPlayer

playerInstance

Bu modeli kalıcı hale getireceğiniz `Class.Player`.

Bu modeli belirli bir oyuncu için kalıcı hale getirir.
`Class.Model.ModelStreamingMode|ModelStreamingMode`, ekleme sonucu
davranışın değişmesi için `Enum.ModelStreamingMode|PersistentPerPlayer`
olarak ayarlanmalıdır.

Bu örnekte her oyuncu karakter modeline eklenen eklemler, ortaya çıktıktan 3 saniye sonra kırılacaktır. Bu eklemelerin kırılması, Humanoid'in ölmesine neden olacaktır.

Bu kod örneği, iki parçanın (PartA ve PartB) manuel eklemlerini oluşturmayı
gösterir, bu parçalar script'in kardeşleridir. Uygun yüzey türlerine sahip iki
parçanın birbirine dokunan eklemlerini oluşturur (Studs ve Inlet).

Parçalar arasındaki bağlantıları, yüzey bağlantıları dahil,
herhangi bir bitişik parça, `Class.WeldConstraint|WeldConstraints` ve tüm
`Class.Weld|Welds` ve diğer `Class.JointInstance|JointInstances`
arasında koparır.

`BreakJoints` Player karakterine kullanıldığında, karakterin
`Class.Humanoid`'u neck bağlantısına bağlı olduğu için ölecektir.

Yüzey bağlantıları ile bitişik parçalar tarafından üretilen eklemler,
`Class.Model:MakeJoints()` kullanılarak teknik olarak yeniden yaratılabilir,
ancak bu sadece yüzeylerden üretilen eklemleri tekrar yaratır. Geliştiricilerin,
eklemelere göre koparılan parçaların artık birbiriyle temas etmeyeceğine dair
bu duruma güvenmemeleri önerilir.

Model:BreakJoints

Parçalar arasındaki bağlantıları, yüzey bağlantıları dahil,
herhangi bir bitişik parça, `Class.WeldConstraint|WeldConstraints`
ve tüm `Class.Weld|Welds` ve diğer `Class.JointInstance|JointInstances`
arasında koparır.

Model:breakJoints

Bu işlev, bir `Class.Model` içindeki tüm `Class.BasePart` çocuklarını
kapsayan bir hacmin tanımını döndürür. Hacmin yönelimi,
`Class.Model.PrimaryPart|PrimaryPart` yönelimine göre belirlenir ve
model seçildiğinde Stüdyoda oluşturulan seçim kutusuyla eşleşir.
`Class.Terrain:FillBlock()` davranışına benzer şekilde,
hacmin merkezini temsil eden bir `Datatype.CFrame` ve boyutunu temsil eden bir
`Datatype.Vector3` döner. Hacmin boyutu
`Class.Model` içerisindeki parçalara fiziksel kısıtlamaların etki etmesi durumunda
çalışma zamanında hatalı olabilir.

Sınır kutusunun yönelimi, ya `Class.Model.PrimaryPart|PrimaryPart`'ın pivotu
(varsa) ya da modelin `Class.Model.WorldPivot|WorldPivot` ile eşleşmektedir.

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

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- Modelin sınır kutusuna eşit olarak parçayı yeniden boyutlandır ve
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Bir hacmin yönelimini temsil eden bir `Datatype.CFrame` ardından da hacmin
boyutunu temsil eden bir `Datatype.Vector3` döndürür.

Bir Modeldeki tüm parçaları içeren bir hacmin tanımını döndürür.

Aşağıdaki kod örneği, Model.GetExtentsSize'in parçaları içeren sınır kutusunun boyutunu almak için nasıl kullanılabileceğini gösterir.

Modelin içindeki tüm `Class.BasePart|BaseParts`'ı kapsayan en küçük
sınır kutusunun boyutunu döndürür. Yönelimi,
`Class.PVInstance.GetPivot|Pivot`'ın yönelimi ile eşleşmektedir. Bu, ya
`Class.Model.PrimaryPart|PrimaryPart`'ın (varsa) pivotu ya da modelin
`Class.Model.WorldPivot|WorldPivot`'udur.

Bu fonksiyon yalnızca en küçük sınır kutusunun boyutunu döndürür ve
geliştiricinin sınırlı kutunun konumunu elde etmek için kendi yöntemini
kullanması gerekir.

Model:GetExtentsSize

`Class.Model`'in boyutunu temsil eden `Datatype.Vector3`.

Modelin içindeki tüm `Class.BasePart|BaseParts`'ı kapsayan en küçük sınır
kutusunun boyutunu döndürür, eğer ayarlanmışsa `Class.Model.PrimaryPart`
ile hizalanır.

Bu değer, modelin merkezi konumunun CFrame'ini geçmişte döndürmüştür.

Model:GetModelCFrame

Bu kod bir model oluşturur, içine bazı parçalar koyar, bunları rastgele konumlandırır,
yetkinin boyutunu yazdırır:

GetModelSize fonksiyonu, `Class.Model`'in `Datatype.Vector3`
boyutunu döndürür.

Model:GetModelSize

Bu metot `Class.Script` tarafından çağrıldığında, bu modelin kalıcı olduğu
`tüm` `Class.Player` nesnelerini döndürür. `Class.LocalScript`'ten çağrıldığında,
bu metot yalnızca bu modelin `Class.Players.LocalPlayer|LocalPlayer`
üzerinde kalıcı olup olmadığını kontrol eder.

Model:GetPersistentPlayers

Bu model nesnesinin kalıcı olduğu tüm `Class.Player` nesnelerini içeren
diziyi döndürür.

Bu model nesnesinin kalıcı olduğu tüm `Class.Player` nesnelerini
döndürür. Davranış, bu metodun `Class.Script` veya `Class.LocalScript`
darından çağrılıp çağrılmadığına bağlıdır.

Aşağıdaki kod, GetPrimaryPartCFrame ve
SetPrimaryPartCFrame'in bir modeli döndürmek için nasıl kullanılacağını göstermektedir.

Workspace içinde basit bir model oluşturulur ve modeli
her 0.2 saniyede Y ekseni etrafında 10 derece döndürecek bir döngü başlatılır.

Bu fonksiyon, `Class.PVInstance:GetPivot()` ile değiştirilmiştir, bu da
performans açısından daha iyi çalışır ve kodunuzun davranışını değiştirmaz.
Yeni işler için `Class.PVInstance:GetPivot()` kullanın ve mevcut
`Class.Model:GetPrimaryPartCFrame()` çağrılarınızı uygun bir zamanda
aktarın.

Modelin `Class.Model.PrimaryPart`'ının `Datatype.CFrame`'ini döndürür.

Bu fonksiyon aşağıdaki ile eşdeğerdir.

    Model.PrimaryPart.CFrame

Unutmayın, bu fonksiyon model için birincil parça yoksa hata verecektir. Bu
davranış istenmiyorsa, örneğin birincil parça hiç ayarlanmamışsa ya da yoksa,
geliştiriciler aşağıdakini yapabilir: bu, birincil parçanın olmaması durumunda
`nil` eşit olacaktır.

    local cFrame = Model.PrimaryPart and Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Modelin `Class.Model.PrimaryPart`'ının `Datatype.CFrame` değerini döndürür.
Bu fonksiyon, model için birincil parça yoksa hata verecektir.

Bu kod örneği, `Class.Model:PivotTo()` ve `Class.Model:ScaleTo()` kullanarak bir ağaç modelinin tüm kopyaları için bir değiştirici yerleştirmenin nasıl yapılacağını göstermektedir. Modellerin pivot ve ölçekleri, yerleştiricilerin göreceli boyutlarının ve konumlarının orijinallerle eşleşmesini sağlamak için bir referans olarak kullanılıyor.


Modeller, kalıcı bir anaölçek faktörüne sahiptir, bu da yeni oluşturulan modeller için
1 olarak başlar ve ölçeklendikçe değişir.
Bu fonksiyon mevcut ana ölçek faktörünü döndürür.

Mevcut ölçek faktörü alt model nesnelerinin boyutlarını doğrudan
e etkilemez. Bu, içeriği oluşturma ve kodlama amaçları için
modelin orijinal boyutuna göre nasıl ölçeklendirildiğini hatırlamak için
kullanılır.

Belirli bir oturum içinde, modelin yedek durumda olan tüm nesneleri
ilk `Class.Model:ScaleTo()` çağrısından sonra kesin orijinal boyut
bilgilerini önbelleğe alır. Bu, `Class.Model:ScaleTo()|ScaleTo(x)` çağrısının
ardından `Class.Model:ScaleTo()|ScaleTo(1)` çağrısının tam olarak
modelin orijinal konfigürasyonuna geri döndürmesini sağlayacaktır,
herhangi bir kayan nokta kayması olmaksızın. Kayan nokta kaymasının
önlenmesi, bir Scale**To** fonksiyonuna sahip olmanın motivasyonudur,
Scale**By** fonksiyonuna karşı.

Ölçek faktörü, motor davranışını bir şekilde etkiler: Bir modelin
ölçek faktörü, bu model altında bir `Class.Animation|Animasyon`
`Class.AnimationController` üzerinde oynatıldığında gözlemlenir,
böylece animasyonlu ekipmanlar doğru şekilde oynatılır.

Model:GetScale

Modelin geçerli ölçek oranını döndürür, bu da yeni oluşturulan modeller için
varsayılan olarak 1'dir ve `Class.Model:ScaleTo()` ile ölçeklendikçe değişir.

Bu kod örneği, eklemlerin nasıl oluşturulabileceğini gösterir
Model:MakeJoints işlevini kullanarak.

Bir model örneklenir, üst üste iki parça ile. Üst parça
sabittir ve alt parça değildir. Normalde, Workspace'e bağlı olduğunda
alt parça Baseplate'e düşer.

Ancak, alt parçanın TopSurface özelliği Enum.SurfaceType.Weld olarak ayarlandığı için,
bu, Model:MakeJoints çalıştırıldığında aralarında bir bağlantı kurulduğu anlamına gelir.

Bu nedenle, alt parça, modeldeki eklemler kırılana kadar düşmez.
Bu genellikle Model:BreakJoints kullanılarak yapılır, ancak bu örnekte
bağlantı bir patlama ile kırılır.

Bu kod örneği, script'in kardeşleri olan iki parçanın (PartA ve PartB) üzerinde eklemlerin oluşturulmasını gösterir. Uyumlu yüzey türlerine (Studs ve Inlet) sahip iki temas eden parçanın üzerinde MakeJoints kullanır.

Yüzey tipine göre birleştirme geçersiz kılınmıştır. Yeni projeler için
MakeJoints kullanmayın. Bunun yerine `Class.WeldConstraint|WeldConstraints`
ve `Class.HingeConstraint|HingeConstraints` kullanın.

Modeldeki tüm `Class.BasePart|Parts`'ı gözden geçirir ve belirlenen parçalarla
ve herhangi bir yüzeyle birleştirir; bu, parçaların yüzeylerine bağlıdır.

- Düzgün yüzeyler eklem oluşturmaz
- Yapışkan yüzeyler `Class.Glue` eklemi oluşturur
- Kaynak, Unjoinable olmayan her yüzeyle bir `Class.Weld` ekleme oluşturur
- Studs, Inlet veya Universal her biri diğer iki yüzeyle (örneğin
Studlarla Inlet ve Universal) bir `Class.Snap` eklemi oluşturur
- Makaralar ve motor yüzeyleri `Class.Rotate` ve `Class.RotateV` eklem
nesnelerini oluşturur.

Bu fonksiyon, parça `Class.Workspace`'ın bir alt öğesi değilse çalışmaz.
Bu nedenle, MakeJoints kullanmadan önce modelin Workspace'e ebeveyn\olarak eklenip eklenmediğini kontrol etmelisiniz.

Model:MakeJoints

Modeldeki tüm `Class.BasePart|BaseParts`'ı gözden geçirir. Eğer herhangi bir
parçanın yüzey türü bir eklem oluşturuyorsa, bitişik parçalarla bir eklem
oluşturacaktır.

Model:makeJoints

Model:move

location

Bu örnek, `Class.Model:MoveTo()` yönteminin çarpışmaları nasıl önlediğini göstermektedir.

Basit bir iki parçalı `Class.Model` oluşturulur ve `Class.Model.PrimaryPart`
ayarlanır. Yanına büyük bir engel parçası yerleştirilir.

5 saniye sonra `Class.Model:MoveTo()` yöntemi, modeli engel parçasının
içine doğru hareket ettirecek şekilde kullanılır. Ancak, MoveTo bir modeli
bir engelin içine hareket ettirmeyeceğinden, `Class.Model` Y ekseninde yukarı
hareket ettirilir ve engelin üzerine yerleştirilir.


`Class.Model.PrimaryPart|PrimaryPart`'ı belirtilen konuma taşır. Eğer
bir birincil parça ayarlanmamışsa, modelin kök parçası kullanılacaktır ancak
kök parça kesin değildir ve `Class.Model:MoveTo()` kullanırken her zaman
bir birincil parça ayarlamanız önerilir.

Modelin taşınacağı herhangi bir engel varsa, böyle bir durumda
`Class.Terrain` veya diğer `Class.BasePart|BaseParts`, model dikey
yukarı doğru taşınacaktır. Eğer bu davranış istenmiyorsa,
`Class.PVInstance:PivotTo()` kullanılmalıdır.

Not: `Class.Model:MoveTo()` kullanırken dönüş korunmaz. Mevcut modelin
dönüşümünü korumak gerekiyorsa, `Class.Model:TranslateBy()|TranslateBy()`
veya `Class.PVInstance:PivotTo()` kullanılması önerilir.

Model:MoveTo

position

`Class.Model.PrimaryPart|PrimaryPart`'ı belirtilen konuma taşır. Eğer bir
birincil parça ayarlanmamışsa, modelin kök parçası kullanılacaktır.

Model:moveTo

Bu modeli belirtilen oyuncu için kalıcı olmaktan çıkarır. Bu,
modelin oyuncu için hemen kaldırılacağını garanti etmez; bu yöntemi
çağırdıktan sonra, model o oyuncu için `Enum.ModelStreamingMode|Atomic`
olarak kabul edilir ve hedef akış yarıçapı içinde bulunduğu sürece
mevcut kalacaktır.

`Class.Model.ModelStreamingMode|ModelStreamingMode`, kaldırma sonucu
davranışın değişmesi için `Enum.ModelStreamingMode|PersistentPerPlayer`
olarak ayarlanmalıdır.

Model:RemovePersistentPlayer

Bu modeli artık kalıcı hale getirmeyeceğiniz `Class.Player`.

Bu modeli belirtilen oyuncu için kalıcı olmaktan çıkarır.
`Class.Model.ModelStreamingMode|ModelStreamingMode`, kaldırma sonucu
davranışın değişmesi için `Enum.ModelStreamingMode|PersistentPerPlayer`
olarak ayarlanmalıdır.

Model parçalarının dönüşünü, bunları `Class.Model:SetIdentityOrientation()`
metodu vasıtasıyla ayarlanan daha önceki kimlik dönüşüne geri döndürür.

Model:ResetOrientationToIdentity

Modeller, kalıcı bir anaölçek faktörüne sahiptir, bu da yeni oluşturulan modeller için
1 olarak başlar. Bu fonksiyon modeli, pivot konumu etrafında,
ölçek faktörü 1 olduğu durumdaki görünümüne göre ölçeklendirir. Bunu
başarmak için iki şey yapar:

- Modelin mevcut ölçek faktörünü belirtilen değere ayarlar.
- Tüm alt nesneleri ilgili şekilde yeniden boyutlandırır ve yeniden
yerleştirir.

Yerleştirme, pivot konumu etrafında yapılır.

Alt nesnelerin tüm "geometrik" özellikleri ölçeklendirilecektir.
Bu, elbette parçaların boyutları ile ilgili olsa da, ölçeklendirilen bazı
başka örnek özellikler şunlardır:

- `Class.WeldConstraint|WeldConstraints` ve `Class.RopeConstraint`
un bağlantılarının uzunlukları
- `Class.HingeConstraint` gibi fiziksel hızlar ve kuvvetler
- Parçacık üreteçlerinin boyutları gibi görsel özellikler
- `Class.Sound.RollOffMinDistance` gibi diğer uzunluk özellikleri

Model:ScaleTo

newScaleFactor

Modelin ölçek faktörünü ayarlar; tüm alt nesnelerin boyutları ve
yerleri bu ayarlanan ölçek faktörüne göre ayarlanır ve başlangıçta bu
yerlerdeyken 1'dir.

Verilen modelin kimlik dönüşünü ayarlar; daha sonra `ResetOrientationToIdentity`
metodu ile tüm modelin dönüşünü sıfırlamanıza olanak tanır.

Model:SetIdentityOrientation

Bu fonksiyon, daha performanslı bir değişim olarak `Class.PVInstance:PivotTo()` ile
değiştirilmiştir ve kodunuza olan davranışı etkilemez. Yeni işler için
`Class.PVInstance:PivotTo()` kullanın ve mevcut `Class.Model:SetPrimaryPartCFrame()`
çağrılarınızı uygun bir zamanda aktarın.

Modelin `Class.Model.PrimaryPart`'ının `Class.BasePart.CFrame`'ini ayarlar.
Modeldeki diğer tüm parçalar da hareket ettirilecek ve
`Class.Model.PrimaryPart` ile ilgili dönüşüm ve ofsetlerini koruyacaktır.

Not, bu fonksiyon model için birincil parça yoksa hata verecektir. Bu,
eğer birincil parça hiç ayarlanmamışsa ya da yok edilmişse sorun yaratabilir.

Model:SetPrimaryPartCFrame

cframe

Modelin `Class.Model.PrimaryPart`'ının `Class.BasePart.CFrame`'ini ayarlar.
Modeldeki diğer tüm parçalar da hareket ettirilecek ve
`Class.Model.PrimaryPart` ile ilgili dönüşüm ve ofsetlerini koruyacaktır.

Bu örnek, `Class.Model:TranslateBy()`'ın çarpışmaları nasıl göz ardı ettiğini
ve modelin yönelimine nasıl saygı gösterdiğini gösterir.

Sadece iki parçalı bir `Class.Model` oluşturulur, Y ekseninde 45 derece döndürülür
ve `Class.Model.PrimaryPart` ayarlanır. Yanına büyük bir engel parça konulur.

5 saniye sonra, `Class.Model:TranslateBy()` kullanılarak modelin engel
parçanın içine hareket etmesi sağlanır. Model, engelin içine hareket edecek
ve mevcut yönelimini koruyacaktır.


Modeli belirli bir `Datatype.Vector3` kaydırarak, modelin dönüşümünü
korur. Eğer yeni konumda başka bir `Class.BasePart` veya `Class.Terrain`
varsa, `Class.Model` o nesneyle örtüşecektir.

Taşıma dünyada uygulanır ve nesne alanında değil,
yani modelin parçaları farklı yönelime sahip olsa bile
standart eksen boyunca hareket eder.

Model:TranslateBy

delta

Kaydırılacak `Datatype.Vector3` değeri.

Modeli belirli bir `Datatype.Vector3` kaydırarak, modelin dönüşümünü
korur. Eğer yeni konumda başka bir `Class.BasePart` veya `Class.Terrain`
varsa, `Class.Model` o nesneyle örtüşecektir.

Model

Deneyimlerde örnek [streaming](/workspace/streaming) etkin olduğunda modelin detay seviyesini ayarlar. Kompozit veya imge ağları fizik, çarpışma algılama veya ışın izleme desteklemez.

`Enum.ModelLevelOfDetail|StreamingMesh` olarak ayarlandığında, daha düşük çözünürlüklü "imge" ağı (modelin tüm alt parçalarını saran, renklendirilmiş, kaba ağ) akış alanının dışındaki alanlarda render edilir. Doku desteklemez.

`Enum.ModelLevelOfDetail|SLIM` olarak ayarlandığında, **SLIM** modeli (Ölçeklenebilir Hafif Etkileşimli Model) akış alanına dayalı olarak uzaklıkta tüm alt parçaların bir bileşimini giderek daha düşük çözünürlüklerde render eder. Bu, `Enum.ModelLevelOfDetail|StreamingMesh` üzerinde görsel kalitede büyük bir iyileşme sağlar.

`Enum.ModelLevelOfDetail|Disabled` veya `Enum.ModelLevelOfDetail|Automatic` olarak ayarlandığında, daha düşük çözünürlüklü ağlar görüntülenmeyecektir.


Model.LevelOfDetail

Kullanıcıya uygun olmayan akışa açık deneyimler için modelde detay
seviyesini ayarlar.

Kullanıcıya uygun olmayan akış açıkken `Class.Model|Modeller`
[akış](/workspace/streaming) içeri ve dışarı nasıl akıtıldığını
kontrol eder. Davranış, seçilen enum'a bağlıdır. Akış açık değilse,
hiçbir etkisi yoktur.

Bu özellik, akış açıkken Stüdyo'da
[Özellikler](/studio/properties) penceresi aracılığıyla ya da
`Class.Script|Scripts` içinde değiştirilmelidir, fakat asla
`Class.LocalScript|LocalScripts` içinde değiştirilmemelidir (bu, tanımsız bir
davranışa yol açabilir).

Model.ModelStreamingMode

Kullanıcıya uygun olmayan akış açıkken `Class.Model|Modeller` üzerindeki
akış davranışını kontrol eder.

Bu kod örneği bir zar modeli oluşturur ve atar, ardından mavi tarafının yukarı bakıp bakmadığını çıktılar. `Class.Model.PrimaryPart` ayarlanmadıysa, zarın pivotu / sınırlayıcı kutusu dönecektir, çünkü içindeki parçalar atış sırasında fiziksel olarak simüle edilir.

`Class.Model`'in birincil parçasını gösterir. Birincil parça,
modelin pivot referansı için fiziksel olarak işlev gören `Class.BasePart`'dır.
Yani, model içindeki parçalar fiziksel simülasyon veya başka nedenlerle
hareket ettiğinde, pivot birincil parça ile senkronize olarak hareket eder.

`Class.Model|Modeller` varsayılan olarak `PrimaryPart` ayarına sahip
değildir. Eğer fiziğin etkisi altında olması gereken bir model oluşturuyorsanız,
bu özelliği Stüdyoda veya bir script içinde manuel olarak ayarlamalısınız.
Eğer birincil parça **ayarlanmazsa**, pivot dünya alanındaki aynı konumda
kalacaktır, model içindeki parçalar hareket etse bile.

Ayrıca bu özelliği ayarlarken, modelin bir parçası olan bir `Class.BasePart`
olarak ayarlandığından emin olmalısınız. Eğer `Class.Model.PrimaryPart`
`Model`'in bir parçası olmayan bir `Class.BasePart`'a ayarlamaya çalışırsanız,
bu parça olarak ayarlanda ama sonraki simülasyon adımında `nil`
olarak sıfırlanacaktır - bu, bir scriptin varsayılan bir parça olan bir
`Class.BasePart`'ı geçici olarak ayarlayabileceğine olan inancı desteklemek için
eski bir davranıştır.

Modeller için genel kural şudur:

- Fiziksel bağlantılarla birleştirilen parçaları olan modeller,
  `Class.WeldConstraint|WeldConstraints` veya `Class.Motor6D|Motor6Ds`
  gibi birincil bir parça ayarlanmış olmalıdır. Örneğin, Roblox karakter
  modellerinin `Class.Model.PrimaryPart`'ı varsayılan olarak
  **HumanoidRootPart** ayarlanmıştır.
- Statik (genellikle `Class.BasePart.Anchored|Anchored`) modeller,
  bir yerinde kalır ve yalnızca bir script açıkça taşımadığında,
  `Class.Model.PrimaryPart`'a ihtiyaç duymaz ve ayarlanması-
  fayda sağlamazlar.

Model.PrimaryPart

`Class.Model`'in birincil parçasını veya açıkça ayarlanmamışsa
`nil` döndürür.

Bu özelliği Özellikler penceresinde ayarlamak, sanki `Class.Model:ScaleTo()`
çağrılmış gibi modeli ölçeklendirir, modeldeki tüm alt nesneleri,
materyalleri, görselleri ve parçaların 3B geometrisini, modelin orijinal
boyutuna göre belirtilen ölçek faktörü ile birlikte ölçeklendirir.

Bu özellik sadece Stüdyo'da mevcuttur ve bir `Class.Script` veya
`Class.LocalScript` içinde kullanıldığında hata verecektir.
`Class.Model:ScaleTo()` ve `Class.Model:GetScale()` scriptlerden
kullanılmalıdır.

Model.Scale

Modeli pivotu etrafında ölçeklendirmek için kullanılan sadece editör
özelliği. Bu özellik ayarlandığında, sanki `Class.Model:ScaleTo()`
çağrılmış gibi ölçek hareket eder.

Bu kod örneği, bir modelin dönüş noktasını
modelin sınır kutusunun merkezine sıfırlamak için özel bir işlevi göstermektedir.

`Class.Model`'in ayarlanmamış bir `Class.Model.PrimaryPart`'a sahip olduğu
durumlarda nerede olduğunu belirler. Eğer `Class.Model`'in bir
`Class.Model.PrimaryPart|PrimaryPart`'ı varsa, `Class.Model`'in pivotu
o öncelikli parçanın pivotu ile eşit olur ve bu `Class.Model.WorldPivot|WorldPivot`
özelliği göz ardı edilir.

Yeni oluşturulan bir `Class.Model` için, pivotu içeriğinin sınır kutusunun
merkezi olarak davranır ve `Class.Model.WorldPivot` özelliği ilk kez ayarlanana
kadar aynı kritik konumda kalır. Dünya pivotu ilk kez ayarlandığında,
bu başlangıç davranışını geri yüklemek mümkün değildir.

En yaygın olarak, modelin Stüdyo araçlarıyla veya `Class.PVInstance:PivotTo()` ve
`Class.Model:MoveTo()` gibi model hareket fonksiyonlarıyla taşınması,
dünya pivotunu ayarlayacak ve bu yeni model davranışını sonlandıracaktır.

Bu davranışın amacı, yeni bir model oluşturup ona nesneler ekleyerek,
Luau kodunun mantıklı bir pivot elde etmesine olanak sağlamaktır; böylece
er zaman `Class.Model.WorldPivot`'ı açıkça ayarlama gereği kalmaz.

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

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- Şu anda "BluePart" ve "RedPart"'ı içeren
                               sınır kutusunun merkezi ile eşit

model:PivotTo(CFrame.new(0, 10, 0))  -- "model.WorldPivot"'ı
                                     açıkça ayarlamaya gerek olmadan
```

Model.WorldPivot

`Class.Model`'in ayarlanmamış bir `Class.Model.PrimaryPart`'a
sahip olduğu durumlarda nerede olduğunu belirler.

Modeller, nesneleri bir araya getiren konteyner nesneleridir. En iyi
`Class.BasePart|BaseParts` koleksiyonlarını tutmak için kullanılırlar
ve işlevselliğini genişleten bir dizi fonksiyona sahiptirler.

Bir `Class.PVInstance`, oluşturulamayan bir soyut sınıftır. Bu, dünyada fiziksel bir konumu olan tüm nesnelerin temelidir.


Bu kod örneği, karakterinizi
10&nbsp;stud ileriye, şu anda baktığınız yönde hareket ettiren basit bir teleport scriptidir. Bunu,
`Class.PVInstance:GetPivot()` ile mevcut pivotu alarak ve `PVInstance|PivotTo` fonksiyonunu çağırarak yapar.
Karakteri ileriye hareket ettirmek için.

Bu fonksiyon, bir `Class.PVInstance`'in pivotunu alır. Bu genellikle
`Class.PVInstance:PivotTo()` ile birlikte bir modeli hareket ettirmek için kullanılır.

`Class.Model|Models` ve `Class.BasePart|BaseParts` her ikisi de
`Class.PVInstance|PVInstances` ("Pozisyon Hız Nesneleri") olduğundan,
bu işlevi taşırlar.


PVInstance:GetPivot

`Class.PVInstance`'i ve onun tüm alt `Class.PVInstance|PVInstances` nesnelerini,
pivotun belirtilen `Datatype.CFrame`'de bulunacak şekilde dönüştürür. Bu, `Class.Model|Models`
in script ile taşınması için kullanılacak birincil fonksiyondur.

`Class.BasePart|BaseParts`, gerekli ofset tarafından `Datatype.CFrame`
dönüştürülerek bu şekilde taşınır.
`Class.Model|Models`, gerekli ofset tarafından `Class.Model.WorldPivot`
dönüştürülerek bu şekilde taşınır.

Verimlilik açısından, bu şekilde taşınan `Class.BasePart|BaseParts`
`Class.BasePart.Position|Position` ve `Class.BasePart.Orientation|Orientation`
 için `Class.Object.Changed` olayları tetiklenmez; sadece `Datatype.CFrame`
 için tetiklenir.

`Class.Model|Models` üzerinde `Class.PVInstance:PivotTo()|PivotTo` metodunu
çağırırken, alt parçaların ve modellerin ofsetleri önbelleğe alınır,
böylece aynı model üzerindeki ardışık `Class.PVInstance:PivotTo()|PivotTo`
çağrıları arasında yüzer nokta kayması birikmez.

`Class.Model|Models` ve `Class.BasePart|BaseParts` her ikisi de
`Class.PVInstance|PVInstances` ("Pozisyon Hız Nesneleri") olduğundan,
bu işlevi taşırlar.


PVInstance:PivotTo

targetCFrame

`Class.PVInstance` pivotunun taşındıktan sonra eşit olması gereken
`Datatype.CFrame`.


`Class.PVInstance`'i ve onun tüm alt `Class.PVInstance|PVInstances` nesnelerini,
pivotun belirtilen `Datatype.CFrame`'de bulunacak şekilde dönüştürür.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Dünyada fiziksel bir konumu olan tüm nesneler için soyut sınıf.


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

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

Bir nesnenin soy ağacındaki değişiklikleri algılamayı, `Class.Instance.AncestryChanged` olayıyla bağlanarak gösterir.

ChangingPart'in Parent'ı zamanla farklı değerlere ayarlanır. Parçanın ebeveyni, parçanın atasıdır, bu yüzden `Class.Instance.AncestryChanged` olayı değiştiğinde tetiklenecektir.


Bu örneğin yeniden ebeveynlenmesi veya herhangi bir atanın yeniden ebeveynlenmesi durumunda tetiklenir.

Bu olayı, Stüdyo'da bir nesnenin silinmesini takip etmek için kullanabilirsiniz, örneğin Explorer'da manuel silme veya bir eklenti aracılığıyla. Eğer bir örneğin `Class.Instance:Destroy()` ile yok olduğunda tespit etmeniz gerekiyorsa, `Class.Instance.Destroying` olayını kullanın.

Instance.AncestryChanged

child

`Class.Instance.Parent|Parent` özelliği değişen örnek,
bu örnek veya daha uzak bir atası, **değil**
biriken işleyiciye bağlıdır.

parent

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

Bu olay, örnekte herhangi bir özelliğin değiştiği her durumda tetiklenir,
özellikle bir özelliğin `nil` olarak ayarlandığı durumlarda. Değişen özelliğin adı,
bu bağlı fonksiyona iletilir.

Örneğin, aşağıdaki kod parçası, bir parçanın özellikleri her değiştiğinde `attributeChanged()`
fonksiyonunu tetikler:

```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, belirli bir özelliğin değiştiğinde tetiklenen olayı döndüren `Class.Instance:GetAttributeChangedSignal()`'ı kontrol edin.

Instance.AttributeChanged

attribute

`Class.Instance` üzerinde bir özellik değiştiğinde tetiklenir.

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

Bir nesne bu `Class.Instance`'ye ebeveynlendikten sonra tetiklenir.

Not, bu yöntemi istemci üzerinde sunucu tarafından oluşturulan nesneleri tespit etmek için kullanırken, bu nesnelerin alt nesnelerine indeksleme yaparken `Class.Instance:WaitForChild()`'i kullanmak gereklidir. Çünkü nesne ve alt nesneler sunucudan istemciye aynı anda kopyalanacağı garanti edilmemektedir. Örneğin:

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

Workspace.ChildAdded:Connect(function(child)
	-- Alt nesnelerin henüz kopyalanmamış olabileceğinden WaitForChild() kullanın
	local head = child:WaitForChild("Head")
end)
```
Not, bu olay yalnızca `Class.Instance`'nin hemen altındaki çocuklar için işler. Tüm alt nesneleri yakalayan bir olay için `Class.Instance.DescendantAdded`'i kullanın.

Ayrıca, `Class.Instance.ChildRemoved`'ı kontrol edin.

Instance.ChildAdded

Bir nesne bu `Class.Instance`'ye ebeveynlendikten sonra tetiklenir.

Instance.childAdded

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

Bu `Class.Instance`'den bir çocuk kaldırıldıktan sonra tetiklenir.

Kaldırılan, bir nesnenin ebeveyninin bu `Class.Instance`'den başka bir şeye değişmesini ifade eder. Not, bu olay, bir çocuğun yok olduğu (kullanarak `Class.Instance:Destroy()`) durumunda da tetiklenir çünkü yok etme fonksiyonu bir nesnenin ebeveynini `nil` olarak ayarlar.

Bu olay yalnızca `Class.Instance`'nin hemen altındaki çocuklar için işler. Tüm alt nesneleri yakalayan bir olay için `Class.Instance.DescendantRemoving`'i kullanın.

Ayrıca, `Class.Instance.ChildAdded`'ı kontrol edin.

Instance.ChildRemoved

Bu `Class.Instance`'den bir çocuk kaldırıldıktan sonra tetiklenir.

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

Bu olay, bir alt nesne `Class.Instance`'ye eklendikten sonra tetiklenir.

Her alt nesne için tetiklendiğinden, bir nesneyi `Class.Instance`'ye ebeveynlendiğinizde bu nesne ve tüm alt nesneleri için olay tetiklenecektir.

Eğer yalnızca `Class.Instance`'nin **doğrudan çocuklarıyla** ilgileniyorsanız, bunun yerine `Class.Instance.ChildAdded`'i kullanın.

Ayrıca, `Class.Instance.DescendantRemoving`'i kontrol edin.

Instance.DescendantAdded

descendant

Bir alt nesne `Class.Instance`'ye eklendikten sonra tetiklenir.

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

Bu olay, bir ebeveyn `Class.Instance`'nin değişmesi üzere **hemen önce** tetiklenir, böylelikle bir **alt nesne** artık bir alt nesne olmayacaktır. `Class.Instance:Destroy()|Destroy()` bir örneğin `Class.Instance.Parent|Parent`'ini `nil` olarak değiştirir, bu nedenle ebeveynlerinden birinin alt nesnesinde bu yöntemi çağırmak bu olayı tetikleyecektir.

Bu olay, alt nesnenin kaldırılmadan önce tetiklendiğinden, bu olayın tetiklendiği sırada alt nesnenin ebeveyni değişmemiş olacaktır. Eğer alt nesne ayrıca ebeveynin **doğrudan çocuğu** ise, bu olay `Class.Instance.ChildRemoved`'den önce tetiklenecektir.

Bir alt nesnenin çocukları varsa, bu olay önce alt nesne ile, ardından onun alt nesneleri ile tetiklenir.

#### Uyarı

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

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Bu fonksiyonda alt nesnenin ebeveynini değiştirmeyin!
	-- Bu olay, ebeveyn manipüle edildiği için tetiklenir ve değişiklik henüz gerçekleşmemiştir
	-- Bu nedenle ebeveyni şu şekilde 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`'ı kontrol edin.

Instance.DescendantRemoving

Bir `Class.Instance`'nin alt nesnesi kaldırılmadan hemen önce tetiklenir.

Bu örnek, Immediate sinyal davranışını kullanırken, bir
örneğin yok edildiğinde bağlı fonksiyonun beklemesine kadar yerinde kaldığını gösterir.


Bu örnek, Ertelenmiş sinyal davranışı kullanıldığında, bir Instance'ın
sinyal ateşlenmeden önce yok edildiğini göstermektedir.


Bağlı bir fonksiyon hala kullanılırken `Class.Instance` asla bellekten silinmeyecektir. Ancak, fonksiyon herhangi bir noktada bekleme yaparsa,
`Class.Instance` ve onun alt nesneleri `nil`'e ebeveynlendirilir.

Eğer `Class.Workspace.SignalBehavior` özelliği  `Enum.SignalBehavior.Immediate` olarak ayarlandıysa,
bu olay, `Class.Instance` veya bir atası `Class.Instance:Destroy()` ile yok edilmeden hemen önce tetiklenecektir.

Eğer `Class.Workspace.SignalBehavior` özelliği `Enum.SignalBehavior.Deferred` olarak ayarlandıysa,
bu olay bir sonraki yeniden başlatma noktasında tetiklenecektir, ki bu da `Class.Instance` veya bir atası `Class.Instance:Destroy()` ile yok edildikten sonraki zamandır.

`Enum.SignalBehavior.Deferred|Deferred` davranışında, bir betiği kendi `Class.Instance.Destroying` olayına bağlamak sorunludur, çünkü betik geri çağrının çağrılabileceği noktadan önce yok olacaktır (yani çalışmayacaktır).

Bir `Class.Instance` i Stüdyoda silerken, örneğin [Explorer](/studio/explorer) üzerinden manuel silme veya bir eklenti aracılığıyla,
`Class.Instance` yok edilmez. Bunun yerine, ebeveyn `nil` olarak ayarlanır ki bunu `Class.Instance.AncestryChanged` ile takip edebilirsiniz.

Instance.Destroying

Örnek, `Class.Instance:Destroy()` aracılığıyla yok edilmeden hemen önce (veya sonrasına ertelenerek) tetiklenir.

Bu olay, her zaman bir stil özelliği değiştirildiğinde tetiklenir,
özellikle bir özelliğin `nil` olarak ayarlandığı durumlarda.

```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 değiştirildiğinde tetiklenir, özellikle bir özellik `nil` olarak ayarlandığında.

Bu yöntem, etiket uygulandığında etkisiz hale gelir, bir etiket uygular.
Bir etiket başarıyla eklenirse, sağlanan etiketle birlikte
`Class.CollectionService:GetInstanceAddedSignal()` tarafından oluşturulan bir sinyal tetiklenir.

#### Uyarılar

- İstemci tarafında eklenen bir nesnenin etiketleri, sunucu daha sonra o nesneye bir etiket ekler veya kaldırırsa
  silinecektir çünkü sunucu tüm etiketleri birlikte kopyalar ve önceki etiketleri geçersiz kılacaktır.

- Bir nesneyi etiketlerken, etiketin işlevselliğini 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, bir etikete artık ihtiyaç kalmadığında bunları temizlemek iyi bir fikirdir (koparıp,
  `nil` olarak ayarlamak vb.). Bunu `Class.Instance:RemoveTag()` çağrılırken, `Class.Instance:Destroy()` çağrıldığında veya `Class.CollectionService:GetInstanceRemovedSignal()` tarafından döndürülen bir sinyale bağlı bir işlevde yapın.

Instance:AddTag

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

Instance:children

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

Bu yöntem, bir nesnenin tüm çocuklarını ve soylarını yok eder.

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

-- Bazı ışıldaklar ekleyelim
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

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

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

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
Eğer **tüm** çocukları ve soyları yok etmek istemiyorsanız, ya
`Class.Instance:GetChildren()` ya da `Class.Instance:GetDescendants()` kullanarak o çocuklar/soylar arasında döngüye girebilir ve hangi nesneleri yok etmeniz gerektiğini seçebilirsiniz. Örneğin, aşağıdaki kod örneği, bir `Class.Model`'dan inen tüm
`Class.BasePart|BaseParts`'ı 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 yöntem, bir nesnenin tüm çocuklarını yok eder.

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

`Clone()` bir nesnenin ve tüm soylarının bir kopyasını oluşturur,
`Class.Instance.Archivable|Archivable` olmayan tüm nesneleri yok sayar. Kök nesnenin kopyası
bu yöntemle döndürülür ve `Class.Instance.Parent|Parent`'ı `nil` olarak ayarlanır. Eğer nesne kendisi `Class.Instance.Archivable|Archivable` değeri `false` ise,
hesap bu yöntem `nil` döndürecektir.

Eğer bir referencia nesne, örneğin `Class.ObjectValue.Value`, kopyalanan bir nesnede ayarlanırsa,
kopyanın özelliklerinin değeri orijinalinin değerine bağlıdır:

- Eğer bir referans özelliği **aynı zamanda** kopyalandıysa,
kopya bu kopyaya işaret edecektir.
- Eğer bir referans özelliği **kopyalanmamış** bir nesneye işaret ediyorsa,
kopyada aynı değer korunacaktır.

Instance:Clone

Bir nesnenin ve tüm soylarının bir kopyasını oluşturur; `Class.Instance.Archivable|Archivable` olmayan nesneleri yok sayar.

Instance:clone

Bir Parçayı `Class.Instance:Destroy()` fonksiyonunu kullanarak yok etmenin gösterimi.

Bu fonksiyon, artık gereksiz olan nesneleri imha etmenin doğru yoludur.


`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 yöntem,
artık gerekli olmayan nesneleri atmanın doğru yoludur.

Artık gerekli olmayan nesneleri atmak önemlidir, çünkü gereksiz nesneler ve
yerlerdeki bağlantılar bellek kullanır ve zamanla ciddi performans sorunlarına yol açabilir.

`Destroy()` çağrıldıktan sonra bir nesneye referans veren değişkenleri `nil`
a ayarlamak en iyi uygulamadır. Bu, kodunuzun nesneyle ilgili herhangi bir şeye erişmesini engeller.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Bunu yapmayın:
print(part.Name)  --> "Hello, world"
-- Yukarıdaki satırın çalışmasını önlemek için bunu yapın:
part = nil
```
Bir `Class.Instance`, bu yöntemle yok edildiğinde,
tekrar kullanılamaz çünkü `Class.Instance.Parent` özelliği kilitlenir. Nesneyi **geçici olarak** kaldırmak, yok etmek yerine,
`Class.Instance.Parent|Parent` değerini `nil` olarak ayarlayarak yapılabilir. Örneğin:

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Belirli bir süre sonra bir nesneyi yok etmek için,
`Class.Debris:AddItem()` kullanı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.

Instance:destroy

Verilen isme eşit olan `Class.Instance`'nin ilk atasını döndürür.

Bu yöntem yukarıya doğru çalışır, yani nesnenin hemen üstündeki `Class.Instance.Parent`
dan başlar ve `Class.DataModel`'e kadar çıkar. Eşleşen bir ata bulunamazsa, `nil` döndürür.

Aşağıdaki kod parçacığı, `Car` adındaki nesnenin ilk atasını bulacaktır.

```
local car = object:FindFirstAncestor("Car")
```
Belirli bir sınıfın atalarını bulan bu yöntemin varyantları için lütfen `Class.Instance:FindFirstAncestorOfClass()` ve `Class.Instance:FindFirstAncestorWhichIsA()`'ya bakın.

Instance:FindFirstAncestor

name

Verilen isme eşit olan `Class.Instance`'nin ilk atasını döndürür.

Verilen className'e eşit olan `Class.Object.ClassName`'in ilk atasını döndürür.

Bu yöntem yukarıya doğru çalışır; yani nesnenin hemen üstündeki `Class.Instance.Parent`
dan başlar ve `Class.DataModel`'e kadar çıkar. Eşleşen bir ata bulunamazsa, `nil` döndürür.

Bu yöntemin yaygın bir kullanım durumu, bir `Class.BasePart`'ın ait olduğu `Class.Model`'ı bulmaktır. Örneğin:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Bu yöntem, `Class.Instance:FindFirstAncestor()`'ın bir varyantıdır ve `Class.Object.ClassName` özelliğini kontrol eder;
`Class.Instance:FindFirstAncestorWhichIsA()` ise sınıf mirasını dikkate almak için `Class.Object:IsA()` metodunu kullanır.

Instance:FindFirstAncestorOfClass

className

Verilen className'e eşit olan `Class.Object.ClassName`'in ilk atasını döndürür.

Verilen className için, `Class.Object:IsA()` değerinin true döndürdüğü `Class.Instance`'nin ilk atalarını döndürür.

Bu yöntem yukarıya doğru çalışır; yani nesnenin hemen üstündeki `Class.Instance.Parent`
dan başlar ve `Class.DataModel`'e kadar çıkar. Eşleşen bir ata bulunamazsa, `nil` döndürür.

`Class.Instance:FindFirstAncestorOfClass()`'dan farklı olarak, bu yöntem `Class.Object:IsA()` metodunu 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 parçacığı, ilk `Class.BasePart` ata ile sonuçlanır; bu, `Class.WedgePart`, `Class.MeshPart` veya `Class.Part` olsun.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```

`Class.Instance:FindFirstAncestor()`'a da bakın.

Instance:FindFirstAncestorWhichIsA

Verilen className için, `Class.Object:IsA()` değerinin true döndürdüğü `Class.Instance`'nin ilk ataları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 isme sahip olan `Class.Instance` çocuklarından ilki döndürülür; eğer böyle bir çocuk yoksa
`nil` döner. İsteğe bağlı `recursive` argümanı `true` ise, bu yöntem yalnızca `Class.Instance`'nin hemen çocuklarına değil, tüm soylarına bakar.

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

`FindFirstChild()` bir nesnenin varlığını doğrulamanız gerektiğinde gereklidir.
Eğer çocuk ismiyle indekslenirse, çocuk mevcut değilse bir hata fırlatır.

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

-- Aşağıdaki satır parça yoksa hata verir.
Workspace.Part.Transparency = 0.5
```
Daha iyi bir yaklaşım, önce `Part`'ı kontrol etmek için `FindFirstChild()` kullanmak ve sonra gerekli olan kodu çalıştırmak için bir `if` ifadesi kullanmaktır.

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

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

#### Bir Özellik ile Eşleşen Bir Çocuğu Bulma

Bazen bir nesnenin `Class.Instance.Name|Name`'i, `Class.Instance.Parent|Parent`'nin bir özelliğiyle aynıdır. Noktalamayı kullanırken, isimleri aynı olan çocuklar üzerinde özellikler önceliklidir.

Aşağıdaki örnekte, `Color` adında bir `Class.Folder` eklenir, ayrıca bu `Class.Part`, `Class.Part.Color` özelliğine sahiptir. `part.Color` öğesi,
`Datatype.Color3` özelliğinin değerine atıfta bulunur, çocuk `Class.Folder` nesnesine değil. `Class.Instance:FindFirstChild()|FindFirstChild()` kullanmanın faydası, yeni özelliklerin tanıtılmasının kodunuza herhangi bir risk yüklememesi gerektiğidir.

```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")  -- Alt klasör
```

#### Performans Notları

`Class.Instance:FindFirstChild()|FindFirstChild()` kullanmak, noktalamayı kullanmaktan yaklaşık %20 daha uzun sürer ve bir nesneye referans tutmaktan neredeyse 8 kat daha uzun sürer. Bu yüzden, performansa bağlı kodda, örneğin sıkı döngülerde veya `Class.RunService.Heartbeat` ve `Class.RunService.PreRender` ile ilişkili işlevlerde kullanılmamalıdır. Bunun yerine, sonucu bir değişkende saklayın veya `Class.Instance.ChildAdded|ChildAdded` veya `Class.Instance:WaitForChild()|WaitForChild()` kullanmayı düşünün ve belirli bir isme sahip çocuğun ne zaman erişilebilir olduğunu tespit edin.

Instance:FindFirstChild

recursive

Aramanın yeniden işleme tabi olup olmayacağı.

Verilen isme sahip olan `Class.Instance` çocuklarından ilki döndürülür.

Instance:findFirstChild

Verilen `className`'e eşit olan `Class.Instance`'nin ilk çocuğunu döndürür.
`Class.Instance:FindFirstChildWhichIsA()`'dan farklı olarak bu yöntem yalnızca `className` ile eşleşen nesneleri döndürür ve sınıf mirasını görmezden gelir. Eğer eşleşen bir çocuk yoksa bu yöntem `nil` döndürür.

Instance:FindFirstChildOfClass

Verilen `className`'e eşit olan `Class.Instance`'nin ilk çocuğunu döndürür.

Instance

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