> ## Documentation Index
> Fetch the complete documentation index at: https://ziva.zeleza.ru/llms.txt
> Use this file to discover all available pages before exploring further.

# API Fonksiyonları

> Ziva kütüphanesinin yapılandırma, optimizasyon ve gelişmiş kullanım için global API fonksiyonlarının tam referansı

# API Fonksiyonları

Ziva, kütüphane davranışını yapılandırmak, performansı optimize etmek ve gelişmiş kullanım için zengin bir global fonksiyon seti sağlar.

<Info>
  Bu fonksiyonlar ana kütüphane bileşenlerini tamamlar ve Ziva davranışını özel uygulama gereksinimlerinize göre ince ayar yapmanıza olanak tanır.
</Info>

## Otomatik Yapılandırma

### AutoConfigure()

Mevcut sistemde optimal performans için Ziva'u otomatik olarak yapılandırır.

```go theme={null}
func main() {
    // Program başlatımında çağrılması önerilir
    ziva.AutoConfigure()

    // Uygulama kodunuz
    queue := ziva.NewQueue("Başlık")
}
```

<Tip>
  Sistem için otomatik optimizasyon sağlamak üzere program başlatımında `AutoConfigure()` çağırın.
</Tip>

**Bu fonksiyonun yaptıkları:**

* Mevcut sistem belleğini analiz eder
* İşlemci mimarisini belirler
* Gömülü sistemler için ayarları optimize eder
* Önbellekleme ve tamponlamayı yapılandırır

### Is64Bit() bool

Optimal algoritmaları seçmek için sistem mimarisini belirler.

```go theme={null}
if ziva.Is64Bit() {
    // 64-bit sistemler için algoritmaları kullan
    fmt.Println("64-bit mimari")
} else {
    // 32-bit sistemler için optimizasyonlar
    fmt.Println("32-bit mimari")
}
```

**Döndürür:** 64-bit sistemler için `true`, 32-bit sistemler için `false`

## Performans Araçları

### RepeatEfficient(s string, count int) string

Temel dizeyi verimli şekilde tekrarlayarak dize oluşturur.

```go theme={null}
// Tekrarlardan verimli dize oluşturma
separator := ziva.RepeatEfficient("-", 50)
fmt.Println(separator) // "------------------------------------------------"
```

**Parametreler:**

* `s` - tekrarlanacak dize
* `count` - tekrar sayısı

**Döndürür:** sonuç dizeyi

### JoinEfficient(parts \[]string, separator string) string

Performans için optimize edilmiş ayırıcı ile dize dizisini birleştirir.

```go theme={null}
parts := []string{"bir", "iki", "üç"}
result := ziva.JoinEfficient(parts, " | ")
fmt.Println(result) // "bir | iki | üç"
```

**Parametreler:**

* `parts` - birleştirilecek dize dizisi
* `separator` - öğeler arası ayırıcı

**Döndürür:** birleştirilmiş dize

### FastConcat(parts ...string) string

Ayırıcı olmadan birden fazla dizenin hızlı birleştirilmesi.

```go theme={null}
result := ziva.FastConcat("Merhaba", " ", "dünya", "!")
fmt.Println(result) // "Merhaba dünya!"
```

**Parametreler:**

* `parts` - birleştirilecek değişken sayıda dize

**Döndürür:** birleştirilmiş dize

### CleanWhitespaceEfficient(s string) string

Fazla boşlukları ve satır başlarını verimli şekilde kaldırır.

```go theme={null}
cleaned := ziva.CleanWhitespaceEfficient("  çok   boşluk  \n\t")
fmt.Println(cleaned) // "çok boşluk"
```

**Parametreler:**

* `s` - temizlenecek dize

**Döndürür:** temizlenmiş dize

## Renk Yönetimi

### SetErrorColor(errorsColor, statusColor lipgloss.TerminalColor)

Arayüzde hataları ve durumları görüntülemek için renkleri yapılandırır.

```go theme={null}
import "github.com/charmbracelet/lipgloss"

// Hatalar için kırmızı, durum için sarı renk ayarla
ziva.SetErrorColor(lipgloss.Color("#FF0000"), lipgloss.Color("#FFFF00"))
```

**Parametreler:**

* `errorsColor` - hataları görüntülemek için renk
* `statusColor` - durum bilgisini görüntülemek için renk

### ResetErrorColors()

Hata ve durum renklerini varsayılan değerlere sıfırlar.

```go theme={null}
// Varsayılan renkleri geri yükle
ziva.ResetErrorColors()
```

### EnableEmbeddedMode()

Optimize edilmiş renk şeması ile gömülü sistem modunu etkinleştirir.

```go theme={null}
// Yönlendiriciler, IoT cihazları için
ziva.EnableEmbeddedMode()
```

<Note>
  Bu mod, sınırlı sistem kaynakları tespit edildiğinde otomatik olarak etkinleştirilir.
</Note>

### EnableASCIIMode()

Sınırlı karakter desteği olan terminaller için ASCII modunu etkinleştirir.

```go theme={null}
// Eski terminaller veya sınırlı ortamlar için
ziva.EnableASCIIMode()
```

### IsEmbeddedColorMode() bool

Gömülü sistem modunun etkin olup olmadığını kontrol eder.

```go theme={null}
if ziva.IsEmbeddedColorMode() {
    fmt.Println("Gömülü sistem modunda çalışıyor")
}
```

**Döndürür:** gömülü sistem modu etkinse `true`

## Doğrulayıcılar

<Info>
  Ziva, çeşitli veri türlerini kontrol etmek için hazır doğrulayıcılar sağlar. Tüm doğrulayıcılar `InputTask` ile kullanılabilir.
</Info>

### NewPasswordValidator(minLength int) Validator

Minimum uzunlukta şifreleri kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
validator := ziva.NewPasswordValidator(8)
task := ziva.NewInputTask("Şifre", "Şifre girin:")
task.WithValidator(validator)
```

**Parametreler:**

* `minLength` - minimum şifre uzunluğu

**Döndürür:** şifre doğrulayıcısı

### NewEmailValidator() Validator

E-posta adreslerini kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
validator := ziva.NewEmailValidator()
task := ziva.NewInputTask("E-posta", "E-posta girin:")
task.WithValidator(validator)
```

**Döndürür:** e-posta adresi doğrulayıcısı

### NewIPValidator(allowIPv4, allowIPv6 bool) Validator

IPv4 ve/veya IPv6 desteği ile IP adreslerini kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
// Sadece IPv4'e izin ver
validator := ziva.NewIPValidator(true, false)

// Hem IPv4 hem IPv6'ya izin ver
validatorBoth := ziva.NewIPValidator(true, true)
```

**Parametreler:**

* `allowIPv4` - IPv4 adreslerine izin ver
* `allowIPv6` - IPv6 adreslerine izin ver

**Döndürür:** IP adresi doğrulayıcısı

### NewIPv4Validator() Validator

IPv4 adreslerini kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
validator := ziva.NewIPv4Validator()
task := ziva.NewInputTask("IP", "IPv4 adresi girin:")
task.WithValidator(validator)
```

**Döndürür:** IPv4 adresi doğrulayıcısı

### NewIPv6Validator() Validator

IPv6 adreslerini kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
validator := ziva.NewIPv6Validator()
task := ziva.NewInputTask("IPv6", "IPv6 adresi girin:")
task.WithValidator(validator)
```

**Döndürür:** IPv6 adresi doğrulayıcısı

### NewDomainValidator() Validator

Alan adlarını kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
validator := ziva.NewDomainValidator()
task := ziva.NewInputTask("Alan Adı", "Alan adı girin:")
task.WithValidator(validator)
```

**Döndürür:** alan adı doğrulayıcısı

### NewTextValidator(minLen, maxLen int) Validator

Metin uzunluğunu kontrol etmek için doğrulayıcı oluşturur.

```go theme={null}
// 5 ila 100 karakter arası metin
validator := ziva.NewTextValidator(5, 100)
task := ziva.NewInputTask("Metin", "Açıklama girin:")
task.WithValidator(validator)
```

**Parametreler:**

* `minLen` - minimum metin uzunluğu
* `maxLen` - maksimum metin uzunluğu

**Döndürür:** metin doğrulayıcısı

## Bellek Optimizasyonu

### InternString(s string) string

Tekrarlanan dizelerle çalışırken bellek tasarrufu için dizeyi intern eder.

```go theme={null}
// Aynı dizelerle çalışırken bellek tasarrufu
title1 := ziva.InternString("Başlık")
title2 := ziva.InternString("Başlık") // Aynı belleği kullanır
```

**Parametreler:**

* `s` - intern edilecek dize

**Döndürür:** intern edilmiş dize

<Warning>
  Dikkatli kullanın - intern edilmiş dizeler önbellek temizlenene kadar bellekte kalır.
</Warning>

### GetCacheStats() (size int, capacity int)

İntern edilmiş dize önbelleğinin kullanım istatistiklerini döndürür.

```go theme={null}
size, capacity := ziva.GetCacheStats()
fmt.Printf("Kullanılan: %d/%d\n", size, capacity)
```

**Döndürür:**

* `size` - mevcut önbellek boyutu
* `capacity` - maksimum önbellek kapasitesi

### ClearInternCache()

Belleği boşaltmak için intern edilmiş dize önbelleğini temizler.

```go theme={null}
// Kapatma sırasında veya bellek düşük olduğunda temizle
ziva.ClearInternCache()
```

## Düzen Araçları

### CalculateLayoutWidth(screenWidth int) int

Arayüz öğesi düzeni için optimal genişliği hesaplar.

```go theme={null}
screenWidth := 120
layoutWidth := ziva.CalculateLayoutWidth(screenWidth)
fmt.Printf("Önerilen genişlik: %d\n", layoutWidth)
```

**Parametreler:**

* `screenWidth` - karakter cinsinden ekran genişliği

**Döndürür:** düzen için optimal genişlik

Seçim listelerinde yardım bilgisini görüntülemek için ayırıcı ayarlar.

```go theme={null}
// Ayırıcıyı " - " den " → " ya değiştir
```

**Parametreler:**

* `delim` - ayırıcı dize

<Tip>
  Seçim listelerindeki yardım ipuçlarının görünümünü özelleştirmek için bu fonksiyonu kullanın.
</Tip>

## Kullanım Örnekleri

### Gömülü Sistemler için Kapsamlı Kurulum

```go theme={null}
func setupEmbeddedEnvironment() {
    // Otomatik yapılandırma
    ziva.AutoConfigure()

    // Gömülü sistem modunu etkinleştir
    ziva.EnableEmbeddedMode()

    // Daha iyi görünürlük için renkleri yapılandır
    ziva.SetErrorColor(lipgloss.Color("#FF6B6B"), lipgloss.Color("#FFE66D"))

    // Mimariyi kontrol et
    if !ziva.Is64Bit() {
        // 32-bit sistemler için ek optimizasyonlar
        ziva.EnableASCIIMode()
    }
}
```

### Dize İşlemleri Optimizasyonu

```go theme={null}
func createFormattedOutput(items []string) string {
    // Verimli ayırıcı oluşturma
    separator := ziva.RepeatEfficient("=", 50)

    // Öğeleri birleştir
    content := ziva.JoinEfficient(items, "\n")

    // Tüm parçaları hızlı birleştirme
    return ziva.FastConcat(
        separator, "\n",
        "RAPOR\n",
        separator, "\n",
        content, "\n",
        separator,
    )
}
```

### Doğrulanmış Giriş Oluşturma

```go theme={null}
func createValidatedInput() {
    // Doğrulamalı e-posta
    emailTask := ziva.NewInputTask("E-posta", "E-postanızı girin:")
    emailTask.WithValidator(ziva.NewEmailValidator())

    // Minimum uzunlukta şifre
    passwordTask := ziva.NewInputTask("Şifre", "Şifre oluşturun:")
    passwordTask.WithValidator(ziva.NewPasswordValidator(8))

    // IPv4 ve IPv6 destekli IP adresi
    ipTask := ziva.NewInputTask("IP", "IP adresi girin:")
    ipTask.WithValidator(ziva.NewIPValidator(true, true))
}
```