Bu örnek, ContextActionService'i bağlam eylemine kullanıcı girdiğini atamak için
nasıl kullanacağınızı düzgün bir şekilde gösterir. Bağlam, ekipman olarak kullanılan aracı;
eylem ise bazı silahları yeniden yüklemektir. Bu kod örneğini bir
Araç'a bağlı bir LocalScript içinde yerleştirerek test edin. Araç ekipman haline geldiğinde, "Yenile" eylemi
bağlanır ve Araç çıkarıldığında "Yenile" eylemi kaldırılır. Oyuncu Araç ekipman halindeyken R tuşuna bastığında, "Yenileniyor!" mesajı
görünecektir.

Bir deneyimin kullanıcı girdisini bağlamasına olanak tanır. Kullanıcı girdisi, bazı durumların veya zaman dönemlerinin yalnızca etkin olduğu bağlamsal eylemlerle ilişkilidir. Örneğin, bir oyuncunun yakında olduğu sürece bir kapıyı açmasına izin vermek. Kod içinde, bir eylem, hizmetin benzersiz eylemleri ayırt etmek için kullandığı bir dizedir (eylemin adı). Eylem dizesi, `Class.ContextActionService:BindAction()|BindAction` ve `Class.ContextActionService:UnbindAction()|UnbindAction` gibi diğer üye işlevlerinin yanı sıra sağlanır. İki eylem aynı girdi ile bağlandığında, en son bağlanan önceliğe sahiptir. En son eylem bağdan çıkarıldığında, bir önceki eylem tekrar kontrolü ele alır. Bu hizmet kullanıcı girdisi ile ilgilendiği için, sadece istemci tarafında `Class.LocalScript|LocalScripts` içinde kullanılabilir.

#### Bağlam ve Eylem

Bir **bağlam**, oyuncunun bir eylemi gerçekleştirebileceği bir koşuldur. Bazı örnekler, bir `Class.Tool` tutmak, bir arabada `Class.Seat|oturmuş` olmak veya bir kapının yanında durmak gibi durumları içerir. Her ne olursa olsun, bağlamın girildiğinde `Class.ContextActionService:BindAction()|BindAction` çağrılması ve bağlamdan çıkıldığında `Class.ContextActionService:UnbindAction()|UnbindAction` çağrılmasını `Class.LocalScript|LocalScripts`'in kendisi belirler.

Bir **eylem**, oyuncunun o bağlamda gerçekleştirebileceği bir girdidir. Böyle bir eylem, bazı menüleri açmak/kapatmak, ikincil bir araç eylemini tetiklemek veya `Class.RemoteFunction:InvokeServer()` aracılığıyla sunucuya bir istekte bulunmak olabilir. Bir eylem, eylem adı olarak `Class.ContextActionService:BindAction()|BindAction` ve `Class.ContextActionService:UnbindAction()|UnbindAction`'ın ilk parametresi olarak benzersiz bir dize ile tanımlanır. Dize, herhangi bir şey olabilir, ancak **gerçekleştirilen eylemi, kullanılan girdi değil, yansıtmalıdır**. Örneğin, "KeyH"'yi bir eylem adı olarak kullanmayın - bunun yerine "CarHorn"'u kullanın. Eylemlerinizi scriptinizin üstünde bir sabit olarak tanımlamak en iyisidir, çünkü onu kodunuzda en az üç farklı yerde kullanacaksınız.

#### Eylemleri Bağlamaya Göre Bağlamak

Çoğu durumda, `Class.ContextActionService:BindAction()|BindAction` kullanmak, `Class.UserInputService.InputBegan`'den daha iyidir. `Class.UserInputService.InputBegan` için, bağlı fonksiyonunuzun oyuncunun gerçekleştirilen eylemin bağlamında olup olmadığını kontrol etmesi gerekir. Çoğu durumda, bu, bağlama girildiğinde/çıkıldığında bir işlev çağırmaktan daha zorlayıcıdır. Örneğin, oyuncunun araçta otururken `H` tuşunun bir korna sesi tetiklemesini isterseniz, oyuncu sohbette "merhaba" yazabilir veya `H` tuşunu başka bir şey için kullanabilir. Başka bir şeyin H tuşunu kullanıp kullanmadığını belirlemek daha zordur (sohbet gibi) - araba, oyuncunun istemediği zaman kornaya basabilir. Bunun yerine, oyuncu arabaya girdiğinde/çıktığında `Class.ContextActionService:BindAction()|BindAction` ve `Class.ContextActionService:UnbindAction()|UnbindAction` kullandığınızda, `Class.ContextActionService`, `H` tuşu basımlarının yalnızca en son bağlanan eylemi tetiklemesini sağlar. Başka bir şey (sohbet gibi) kontrolü alırsa, bunu kontrol etme konusunda endişelenmenize gerek olmaz.

#### Bağlı Eylemleri İnceleme

Bağlı eylemlerin ve girdilerinin bir listesini görmek için, Developer Console (oyun sırasında F9) içindeki "Eylem Bağlantıları" sekmesine bakabilirsiniz. Bu, Roblox çekirdek scriptleri ve varsayılan kamera/kontrol scriptleri tarafından bağlanan tüm bağlantıları gösterir. Eylemlerinizin doğru zamanlarda bağlı/bağlanmadığını kontrol etmek veya başka bir eylemin girdilerinizi çaldığını belirlemek için bu yararlıdır. Örneğin, <kbd>W</kbd><kbd>A</kbd><kbd>S</kbd><kbd>D</kbd> tuşlarını bağlamaya çalışıyorsanız, varsayılan karakter hareketi scriptlerinin aynı tuşlara bağlanıyor olması mümkün olabilir. Benzer şekilde, kamera kontrol scripti sağ tıklama girişini çalabilir, eğer scriptinizden sonra çalışıyorsa.

#### Klavyeden Bağımsız Girdi

Bu hizmet, oyun kolu ve dokunmatik girdi desteği sağlamak için özellikle kullanışlıdır. Oyun kolu girişi için, B tuşunu kullanıcıyı başka bir menüye girdiğinde önceki menüye döndüren bir eyleme bağlamayı tercih edebilirsiniz. Dokunmatik ekranlar için, ekrandaki dokunmatik düğmeler, tuş basımlarının yerini alabilir: bu düğmeler yalnızca eylem bağlandığında görüntülenir ve bu düğmelerin konumu, metni ve/veya resimleri bu hizmet aracılığıyla yapılandırılabilir. Bu hizmetin sağladığı özelleştirme miktarında bazı sınırlamalar vardır; genellikle `Class.ImageButton` veya `Class.TextButton` kullanarak kendi ekran düğmelerinizi yapmanız daha iyi bir fikirdir.


Mevcut oyuncu bir `Class.Tool` donatıldığında tetiklenir.


ContextActionService.LocalToolEquipped

toolEquipped

Mevcut oyuncu bir `Class.Tool` donatmadığında tetiklenir.


ContextActionService.LocalToolUnequipped

toolUnequipped

Bu kod örneği, `F` tuşuna genel bir eylem işleyici fonksiyonuna
"BoundAction" adlı bir eylemi bağlamak için ContextActionService'i kullanır. Bunu
StarterPlayerScripts içindeki bir LocalScript'in içine yerleştirin ve mesajı görmek için
`F`'ye basın: "Handling action: BoundAction".

Bu kod örneği, BindAction'ın nasıl bir yığın gibi davrandığını gösterir. İki
eylemi, FirstAction (`Z`, `X` ve `C` tuşları) ve SecondAction (`Z` ve `X`
tuğları) iki eylem işleme fonksiyonuna bağlar. İkincisi, belirli bir
veriyi ( `X` tuşu) aktaracaktır.

Her iki eylem de `Z` ve `X` tuşlarını kullanmaktadır, ancak ikinci işleyici yalnızca
`X` tuşuna basıldığında veri aktaracaktır. Yani `X` tuşuna basıldığında, ikinci işleyici
 çağrılır ve ardından birincisi çağrılır. İlk eylem ayrıca `C` tuşuna da bağlanmıştır ve
 diğer iki girdi ikinci eylem tarafından "kaplansa" bile tetiklenebilir.

Bu kodu, StarterPlayerScripts içindeki bir LocalScript'e yapıştırarak deneyin,
 ardından `Z`, `X` ve `C` tuşlarına basın. Hangi eylem işleyicilerinin hangi eylemlerle çağrıldığını gözlemleyin.

Kullanıcı girdisine bir eylem bağlamak için bir eylem işleme fonksiyonu verin. Eşleşen bir girdi gerçekleştirildiğinde, aşağıda listelenen argümanlarla eylem işleyici fonksiyonu çağrılacaktır. Geçerli girdi enum öğeleri şunlardır: `Enum.KeyCode`, `Enum.UserInputType` veya `Enum.PlayerActions`. Bir oyuncu, bir eylemin gerçekleştirilebileceği **bağlama girdiğinde** bu fonksiyonu çağırın. Oyuncu bağlamdan ayrıldığında, aynı `actionName` ile `Class.ContextActionService:UnbindAction()|UnbindAction()`'ı çağırın.

Aşağıdaki kod örneği, bir tuş (<kbd>H</kbd>), oyun kolu düğmesi veya dokunmatik ekran düğmesi basıldığında bir `Class.Sound`'ın `Class.Sound:Play()|çaldığını` göstermektedir.

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

-- Bir araba korna sesi
local honkSound = Instance.new("Sound", workspace)
honkSound.Looped = true
honkSound.SoundId = "rbxassetid://9120386436"

local function handleAction(actionName, inputState, inputObject)
	if actionName == "HonkHorn" then
		if inputState == Enum.UserInputState.Begin then
			honkSound:Play()
		else
			honkSound:Pause()
		end
	end
end

-- Oyuncu araca bindiğinde:
ContextActionService:BindAction("HonkHorn", handleAction, true, Enum.KeyCode.H, Enum.KeyCode.ButtonY)

-- Oyuncu araçtan çıktığında:
ContextActionService:UnbindAction("HonkHorn")
```

#### Eylem İşleyici Parametreleri

Eylem işleyici fonksiyonları, aşağıdaki parametrelerle çağrılır:

<table>
<tr>
  <th>#</th>
  <th>Tür</th>
  <th>Açıklama</th>
</tr>
<tr>
  <td>1</td>
  <td><code>string</code></td>
  <td><code>Class.ContextActionService:BindAction()|BindAction()</code> ile ilk başta geçirilen aynı dize. Bu, bir fonksiyonun gerekirse birden fazla eylemi aynı anda işlemesini sağlar.</td>
</tr>
<tr>
  <td>2</td>
  <td><code>Enum.UserInputState</code></td>
  <td>Girdi durumu. Eğer bazı bir girdi sürecinde isek ve başka bir eylem o süreçteki girdi üzerine bağlanmışsa ya da mevcut bağlı eylem `Class.ContextActionService:UnbindAction()|UnbindAction()` ile bağdan çıkarılmışsa <code>Enum.UserInputState|Cancel</code> gönderilir.</td>
</tr>
<tr>
  <td>3</td>
  <td><code>InputObject</code></td>
  <td>Girdi hakkında bilgi içeren bir nesne (girdi türüne bağlı olarak değişir). Eylemin bağlandığı girdiler ile `Class.InputObject` bazen eşleşmeyebilir: state <code>Enum.UserInputState|Cancel</code> gönderildiğinde, bu nesne <code>Enum.KeyCode.Unknown</code> ve <code>Enum.UserInputType.None</code> olacaktır.</td>
</tr>
</table>

#### Eylem Bağlantıları Yığını

Eylem bağlantıları bir yığın gibi davranır: eğer iki eylem aynı kullanıcı girdiğine bağlanmışsa, **en son bağlı** eylem işleyici kullanılacaktır. Eğer bir eylem işleyici `Enum.ContextActionResult.Pass` dönerse, en son bağlı sonraki eylem işleyici çağrılır ve bu şekilde devam eder; bir işleyici girişi durduruncaya kadar (return `nil` veya `Enum.ContextActionResult.Sink` döndürüldüğünde). `Class.ContextActionService:UnbindAction()|UnbindAction` çağrıldığında, eylem işleyici yığından çıkarılır. Bu yığın davranışı, `Class.ContextActionService:BindActionAtPriority()|BindActionAtPriority` ile geçersiz kılınabilir; burada ek bir öncelik parametresi `createTouchButton`'dan sonra verildiğinde eylemlerin hangi sıradayken bağlanacağını geçersiz kılabilir (yüksek önce, düşük sonra).

#### Dokunma Düğmeleri

Girdi türlerinin yanı sıra, bu fonksiyonun üçüncü parametresi, `Class.UserInputService.TouchEnabled|TouchEnabled` cihazları için bir düğme oluşturup oluşturmayacağını kontrol eder. İlk dokunmatik düğmenin oluşturulmasıyla birlikte, `Class.PlayerGui`'ya "ContextActionGui" adında bir `Class.ScreenGui` eklenir. ScreenGui içinde "ContextButtonFrame" adında bir `Class.Frame` eklenir. Bu çerçevede, bağlı eylemler için `Class.ImageButton|ImageButtons` yerleştirilir; `Class.ContextActionService:GetButton()|GetButton()` kullanarak bu düğmeleri özelleştirmek için alabilirsiniz. Maksimum 7 dokunma düğmesi, `Class.ContextActionService:BindAction()|BindAction()` aracılığıyla oluşturulabilir.


ContextActionService:BindAction

actionName

Gerçekleştirilen eylemi temsil eden bir dize (ör. "HonkHorn" veya "OpenDoor").


functionToBind

Bağlı girişler tetiklendiğinde çağrılan eylem işleme fonksiyonu, aşağıdaki parametrelerle birlikte: dize (actionName), `Enum.UserInputState` ve bir InputObject.


createTouchButton

Dokunmatik giriş cihazları için eylem için bir GUI düğmesi oluşturulup oluşturulmayacağını belirtir.


inputTypes

Eyleme bağlanacak herhangi bir sayıda `Enum.KeyCode` veya `Enum.UserInputType`.


Bir eylem işleme fonksiyonu verilerek kullanıcı girdisini bir eyleme bağlayın.


Bu kod örneği, `Class.ContextActionService:BindActionAtPriority()`'nın
eylemleri sırayla bağlamak için nasıl kullanılabileceğini gösterir; fakat yine de
aynı öncelik seviyelerine sahip olurlar. Normalde, `Class.ContextActionService:BindAction()`
son bağlı eylemin en yüksek önceliğe sahip olmasıyla sırayla çalışır, ancak öncelik seviyeleri
bunu geçersiz kılar. Bu kodu, `ReplicatedStorage` içinde `RunContext` = `Client`
tanımlı bir `Script` içerisine yapıştırarak test edebilirsiniz.

BindActionAtPriority, `Class.ContextActionService:BindAction()|BindAction` gibi davranır ama ayrıca bağlı eyleme bir öncelik atanmaya izin verir. Eğer birden çok eylem aynı girdiye bağlanmışsa, daha yüksek öncelikli fonksiyon bağlamanın sırasından bağımsız olarak çağrılacaktır. Diğer bir deyişle, bu fonksiyon BindAction'ın normal "yığın" davranışını geçersiz kılar.


ContextActionService:BindActionAtPriority

priorityLevel

Eylemin bağlanması gereken öncelik seviyesi (yüksek, düşükten önce dikkate alınır).


`Class.ContextActionService:BindAction()|BindAction` gibi davranır ama ayrıca bind edilen eyleme çakışan girdi türleri için bir öncelik atanmaya da izin verir (yüksek önce, düşük sonra).


Bu fonksiyon _functionToBind_'ı tuş basımları, fare hareketleri veya denetleyici girişi gibi girdi olaylarına bağlar. Motorun dinlediği belirli girdi türleri BindAction'ın parametreleri olarak listelenmiştir. Oyuncu bu girdi türlerinden birini kullandığında, Roblox Motoru "functionToBind"'ı çağırır. BindAction, `Enum.ContextActionPriority` üzerinden priorityLevel'ı Default.Value (2000) olarak ayarlar. Bağlı etkinliklerin önceliğini kontrol etmek için `Class.ContextActionService:GetButton()`'u kullanın.

Girdi türlerine ek olarak, BindAction bir createTouchButton parametresi içerir. Bu doğru ayarlandığında, dokunmatik ekran içeren herhangi bir cihazda bir `Class.ImageButton` oluşturur. Bir `Class.ScreenGui` de yaratılır ve bağlam düğmeleri "ContextActionGui" adlı bir yere yerleştirilir ve `Class.PlayerGui`'ye atanır. Oluşturulan ImageButton, bu ContextActionGui'ye atanır. GetButton, oluşturulan düğmeyi almak için kullanılabilir.

Bir girdi birden fazla fonksiyon ile bağlandığında, her fonksiyon bir yığında yer alır. Bir yığın, son giren ilk çıkar ilkesine uyar. Yani, yığının en üstünde ilk yerleştirilen nesne üstte olur. Yığına bir sonraki eklenen nesne üstte olur ve önceki nesne bir pozisyon aşağı iner (bir kitap yığını gibi). Girdi tetiklendiğinde, yığının üstündeki fonksiyon çağrılır. Eğer fonksiyon `Enum.ContextActionResult`.Pass dönerse, bu yığının aşağısına devam eder. Bir fonksiyonu, bağlandığı tüm girişlerden kaldırmak için `Class.ContextActionService:UnbindAction()` kullanın.

BindAction, bir bağlanan eylemin yığın üzerindeki diğer eylemler tarafından işlenip işlenmeyeceği üzerinde kontrol sağlar, `Enum.ContextActionResult` aracılığıyla. Eğer geri çağırma fonksiyonunda `Enum.ContextActionResult.Pass` dönerse, yığındaki altında kalan her eylemin (en son çağrılan fonksiyon önce çalışır) bunu işlemeleri için bir şansı olacaktır. Pass dışındaki her şey `Enum.ContextActionResult.Sink` olarak işlenecektir, `nil` de dahil. Geri çağırma yield edildiğinde de durduracaktır.


ContextActionService:BindActionToInputTypes

Girdi olaylarına, tuş basımları, fare hareketleri veya denetleyici girişi gibi _functionToBind_'ı bağlar.


Bir `Enum.KeyCode`'u, `Class.ClickDetector` olaylarını, `Class.Tool|Tools`'ı ve `Class.GuiButton|GuiButtons`'ı etkinleştirmek için kullanılabilir şekilde bağlar. Verilen tuş/düğme basıldığında, `Class.Tool.Equipped`'e gönderilen faredeki `Class.Mouse.Button1Down` olayı tetiklenir. Bu, `Class.Tool.ManualActivationOnly` true olarak ayarlanmamışsa, `Class.Tool.Activated` olayını tetikler. Oyun kolu girişi için, bu fonksiyon varsayılan kontrol scriptleri tarafından bir `Enum.KeyCode` olan ButtonR2'yi bağlamak için çağrılır.

Belirtilen `Enum.UserInputType`'ın geçerli olması için `Keyboard` veya `Gamepad1` ile `Gamepad8` arasında olması gerektiğini unutmayın.


ContextActionService:BindActivate

userInputTypeForActivation

Klavye veya Gamepad1'den Gamepad8'e kadar olmalıdır.


keyCodesForActivation

Bir `Enum.KeyCode` ile belirli bir `Enum.UserInputType`'ı bağlayarak `Class.Tool.Activation` ve `Class.ClickDetector` olaylarını tetikler.


GetAllBoundActionInfo, tüm eylemlerin isimlerini (ilk başta `Class.ContextActionService:BindAction()|BindAction` ile geçirilenler) döndüren bir tablo alır ve bununla birlikte `Class.ContextActionService:GetBoundActionInfo()|GetBoundActionInfo` ile çağrıldığında dönen tablo ile eşleştirir. Bu fonksiyonu kullanarak, mevcut bağlı eylemleri inceleyebilirsiniz. Bu, onların öncelik düzeylerini veya yığın sıralarını hata ayıklarken yararlıdır.


ContextActionService:GetAllBoundActionInfo

Tüm bağlı eylemler hakkında bilgi içeren bir tablo döndürür (anahtar, `Class.ContextActionService:BindAction()|BindAction` ile geçirilen isimdir, değer `Class.ContextActionService:GetBoundActionInfo()|GetBoundActionInfo` ile çağrıldığında dönen bir tablodur).


GetBoundActionInfo, adını vererek bir bağlı eylemi tanımlayan bir tablo döndürür. Tüm eylemler için aynı bilgilere bir seferde erişmek için, `Class.ContextActionService:GetAllBoundActionInfo()|GetAllBoundActionInfo` kullanın.

<table>
<tr>
  <th>İsim</th>
  <th>Tür</th>
  <th>Açıklama</th>
</tr>
<tr>
  <td><code>stackOrder</code></td>
  <td>number</td>
  <td>

Eylemin yığındaki dizinini tanımlar (artarak)

</td>
</tr>
<tr>
  <td><code>priorityLevel</code>*</td>
  <td>number</td>
  <td>

Eylemin 
<code>Class.ContextActionService:BindActionAtPriority()|priority</code>
seviye düzeyini tanımlar

</td>
</tr>
<tr>
  <td><code>createTouchButton</code></td>
  <td>bool</td>
  <td>

Bir dokunmatik düğme yaratılıp yaratılmayacağını tanımlar <code>Class.UserInputService.TouchEnabled|TouchEnabled</code> cihazlarda

</td>
</tr>
<tr>
  <td><code>inputTypes</code></td>
  <td>table</td>
  <td>

Bu eylemin tetikleneceği <code>Class.ContextActionService:BindAction()|BindAction</code>'da belirtilen girdi türleri

</td>
</tr>
<tr>
  <td><code>description</code>†</td>
  <td>string</td>
  <td>

<code>Class.ContextActionService:SetDescription()|SetDescription</code> tarafından ayarlanmış eylemin açıklamasıdır

</td>
</tr>
<tr>
  <td><code>title</code>†</td>
  <td>string</td>
  <td>

<code>Class.ContextActionService:SetTitle()|SetTitle</code> tarafından ayarlanmış eylemin başlığıdır

</td>
</tr>
<tr>
  <td><code>image</code>†</td>
  <td>string</td>
  <td>

<code>Class.ContextActionService:SetImage()|SetImage</code> tarafından ayarlanmış eylemin dokunmatik düğmesinin görüntüsüdür

</td>
</tr>
</table>

\\* Öncelik seviyesi, eğer `Class.ContextActionService:BindActionAtPriority()|BindActionAtPriority`
 kullanılmamışsa bile dahil edilir - varsayılan olarak 2000 olacaktır.

† Bu alan, verilen eylem için ilişkili olan metot çağrılmadıysa `nil` olacaktır.


ContextActionService:GetBoundActionInfo

Bir bağlı eylemin ismini vererek bilgi içeren bir tablo döndürür.


GetButton, `Class.ContextActionService:BindAction()|BindAction`'ın üçüncü parametresi true olduğunda ve cihaz `Class.UserInputService.TouchEnabled|TouchEnabled` ise oluşturulan `Class.ImageButton`'ı döndürür. Bu fonksiyonun tek parametresi, BindAction'a ilk gönderilen eylemin ismi ile tam olarak eşleşmelidir.

Eğer böyle bir eylem bağlı değilse veya bir düğme oluşturulmadıysa, bu fonksiyon `nil` döndürür.


ContextActionService:GetButton

BindAction'a ilk gönderilen eylemin ismi.


BindAction tarafından oluşturulan bir ImageButton.


`Class.ContextActionService:BindAction()|bağlı` bir eylemin dokunmatik girdi düğmesi oluşturulmuşsa, `Class.ImageButton`'ı alır.


GetCurrentLocalToolIcon, `Class.Player` tarafından şu anda `Class.Tool.Equipped|donanmış` olan `Class.Tool`'un `Class.BackpackItem.TextureId`'sini döndürür, ya da böyle bir Araç yoksa veya oyuncu bir `Class.Player.Character|Karakter`e sahip değilse `nil` döndürür.


ContextActionService:GetCurrentLocalToolIcon

Araçların TextureId'sinden bir içerik dizesi, ya da bulunamazsa `nil`.


Şu anda `Class.Player` tarafından `Class.Tool.Equipped|donanmış` olan `Class.Tool`'un `Class.BackpackItem.TextureId`'sini döndürür.


Bu kod örneği, `ContextActionService` tarafından otomatik olarak oluşturulan bir dokunma butonuna bir "İncele" eyleminin bağlanmasını göstermektedir. Buton, `Class.ContextActionService:SetImage()|SetImage()`,
`Class.ContextActionService:SetTitle()|SetTitle()`,
`Class.ContextActionService:SetDescription()|SetDescription()` ve
`Class.ContextActionService:SetPosition()|SetPosition()` kullanılarak özelleştirilmiştir. Buton, ayrıca `Class.ContextActionService:GetButton()|GetButton()` kullanılarak bir referans alınarak ve `Class.ImageButton.ImageColor3` ayarlanarak yeşil renkte tonlanmıştır.

Bu kodu `StarterPlayerScripts` içine yerleştirilmiş bir `LocalScript` içine yapıştırarak test edebilirsiniz. Studio'da, butonun gerçekten oluşturulabilmesi için dokunma cihazı emülatörünün açıldığından emin olun.

SetDescription, `Class.ContextActionService:BindAction()|BindAction` tarafından bağlı bir eylemin açıklamasını ayarlar. Mevcut eylemler listesinde, bu, verilen eylemi tanımlayan bir metin olur.

Adı, bu metodun, kendi oluşturduğu dokunmatik düğmeleri özelleştiren fonksiyonlar dizisine ait olduğunu düşündürse de (`Class.ContextActionService:SetTitle()|SetTitle`, `Class.ContextActionService:SetImage()|SetImage` ve `Class.ContextActionService:SetPosition()|SetPosition`), bu metod böyle bir düğmeyi etkilemez. Bu metod yalnızca bir eylemin metin açıklamasını ayarlamakta ve başka bir işlemde bulunmamaktadır.


ContextActionService:SetDescription

description

Eylemin açıklaması olarak gösterilecek metin, örneğin "Arabanın kornasını çal" veya "Envanteri aç".


Dokunmatik düğmeye sahip bir bağlı eylemin adını vererek, eylemin açıklamasını ayarlar.


Bu metod, `Class.ContextActionService:BindAction()|BindAction()` ile oluşturulmuş bir dokunmatik düğme üzerindeki görüntüyü ayarlar. Özellikle, bu, `Class.ImageButton` içindeki `Class.ImageLabel`'in `Class.ImageLabel.Image` özelliğini ayarlar ve bununla birlikte `Class.ContextActionService:GetButton()|GetButton` ile döndürülmesi beklenir. Eğer böyle bir bağlı eylem yoksa (örneğin, GetButton hiçbir şey döndürmezse), bu fonksiyon hiçbir şey yapmaz ve hata fırlatmaz.

Bu fonksiyon, bir eylemin dokunmatik düğmesini özelleştiren metotlar dizisinin bir parçasıdır. Diğerleri arasında `Class.ContextActionService:SetPosition()|SetPosition` ve `Class.ContextActionService:SetTitle()|SetTitle` bulunur.


ContextActionService:SetImage

image

Görüntü özelliğinin ayarlanacağı değer.


`actionName` anahtarı bağlı bir eylemi içeriyorsa, o zaman `image`, dokunmatik düğmenin görüntüsü olarak ayarlanır.


Bu metod, `Class.ContextActionService:BindAction()|BindAction()` ile oluşturulmuş bir dokunmatik düğmenin konumunu ayarlar. Özellikle, `Class.ImageButton`'in `Class.GuiObject.Position` özelliğini ayarlar; bu daha önce `Class.ContextActionService:GetButton()|GetButton` ile döndürülmesi beklenir. Eğer böyle bir bağlı eylem yoksa (örneğin, GetButton hiçbir şey döndürmezse), bu fonksiyon hiçbir şey yapmaz ve hata fırlatmaz.

Bu fonksiyon, bir eylemin dokunmatik düğmesini özelleştiren metotlar dizisinin bir parçasıdır. Diğerleri arasında `Class.ContextActionService:SetImage()|SetImage` ve `Class.ContextActionService:SetTitle()|SetTitle` bulunur.


ContextActionService:SetPosition

position

Dokunmatik düğmeye sahip bir bağlı eylemin adını vererek, düğmenin ContextButtonFrame içindeki pozisyonunu ayarlar.


SetTitle, `Class.ContextActionService:BindAction()|BindAction` ile oluşturulmuş bir dokunmatik düğmede görüntülenen metni ayarlar. Özellikle, bu, `Class.ImageButton` içindeki `Class.TextLabel.Text` özelliğini ayarlar; bu daha önce `Class.ContextActionService:GetButton()|GetButton` ile döndürülmesi beklenir. Eğer böyle bir bağlı eylem yoksa (örneğin, GetButton hiçbir şey döndürmezse), bu fonksiyon hiçbir şey yapmaz ve hata fırlatmaz.

Bu fonksiyon, bir eylemin dokunmatik düğmesini özelleştiren metotlar dizisinin bir parçasıdır. Diğerleri arasında `Class.ContextActionService:SetImage()|SetImage` ve `Class.ContextActionService:SetPosition()|SetPosition` bulunur.


ContextActionService:SetTitle

title

Dokunmatik düğmeye sahip bir bağlı eylemin adını vererek, düğme üzerinde görüntülenen metni ayarlar.


UnbindAction, bir eylemi girdi ile kullanıcı girdilerinden bağdan çıkarır, böylece eylem işleyici fonksiyonu artık çağrılmaz. Bir eylem için bağlamın artık geçerli olmadığında, bu fonksiyonu çağırın; örneğin kullanıcı arayüzünü kapatma, bir arabadan çıkma veya `Class.Tool.Unequipped|donanmayı çıkarmak`. Bağlı eylemler nasıl çalıştığını daha fazla bilgi için `Class.ContextActionService:BindAction()|BindAction`'a bakın.

Bu fonksiyon, verilen dizgeyle bağlı bir eylem yoksa hata fırlatmaz. Hangi eylemlerin şu anda bağlı olduğunu anlamak için `Class.ContextActionService:GetAllBoundActionInfo()|GetAllBoundActionInfo` veya Geliştirici Konsolu'nun "Eylem Bağlantıları" sekmesini kullanabilirsiniz.


ContextActionService:UnbindAction

Bir eylemi adına göre girdi ile bağlamaktan kaldırın.


UnbindActivate, bağlanan `Class.Tool`'u (veya `Class.HopperBin`) `Class.ContextActionService:BindActivate()|BindActivate` kullanarak etkinleştirmek için kullanılan bir `Enum.KeyCode`'u bağlamaktan çıkarır. Bu fonksiyon, o işlevin gerçekleştirilmesini esasen geri alır.


ContextActionService:UnbindActivate

BindActivate'a ilk gönderilen UserInputType.


keyCodeForActivation

Belirli bir `Enum.UserInputType` ile bir `Enum.KeyCode`'u bağlamaktan çıkararak `Class.Tool.Activation`'ı tetiklemesini engelleyin, `Class.ContextActionService:BindActivate()` ile bağlandığında.


Bağlı tüm fonksiyonları kaldırır. Hiçbir actionName kalmaz. Tüm dokunmatik düğmeler kaldırılacaktır. Eğer bir düğme manuel olarak değiştirildiyse, bunun temizlenip temizlenmeyeceği garanti edilmez.


ContextActionService:UnbindAllActions

Bağlı tüm fonksiyonları kaldırır. Hiçbir actionName kalmaz. Tüm dokunmatik düğmeler kaldırılacaktır.


ContextActionService

Kullanıcı girdisini bağlamak için kullanılan bir hizmettir.


`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

Instance

`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/ContextActionService.yaml

ContextActionService

Kod Örnekleri

Özet

Özellikler

Yöntemler

Olaylar

Özellikler

Yöntemler

Olaylar

Bu sayfadakiler