ClickHouse/docs/tr/sql-reference/functions/higher-order-functions.md
Ivan Blinkov d91c97d15d
[docs] replace underscores with hyphens ()
* Replace underscores with hyphens

* remove temporary code

* fix style check

* fix collapse
2020-04-30 21:19:18 +03:00

265 lines
9.8 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
machine_translated: true
machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818
toc_priority: 57
toc_title: "Y\xFCksek Sipari\u015F"
---
# Yüksek Mertebeden Fonksiyonlar {#higher-order-functions}
## `->` operatör, lambda (params, expr) fonksiyonu {#operator-lambdaparams-expr-function}
Allows describing a lambda function for passing to a higher-order function. The left side of the arrow has a formal parameter, which is any ID, or multiple formal parameters any IDs in a tuple. The right side of the arrow has an expression that can use these formal parameters, as well as any table columns.
Örnekler: `x -> 2 * x, str -> str != Referer.`
Daha yüksek mertebeden işlevler yalnızca Lambda işlevlerini işlevsel argümanları olarak kabul edebilir.
Birden çok bağımsız değişkeni kabul eden bir lambda işlevi, daha yüksek mertebeden bir işleve geçirilebilir. Bu durumda, yüksek mertebeden işlev, bu bağımsız değişkenlerin karşılık geleceği aynı uzunlukta birkaç diziden geçirilir.
Gibi bazı işlevler için [arrayCount](#higher_order_functions-array-count) veya [arraySum](#higher_order_functions-array-count), ilk argüman (lambda işlevi) ihmal edilebilir. Bu durumda, aynı eşleme varsayılır.
Aşağıdaki işlevler için bir lambda işlevi ihmal edilemez:
- [arrayMap](#higher_order_functions-array-map)
- [arrayFilter](#higher_order_functions-array-filter)
- [arrayFill](#higher_order_functions-array-fill)
- [arrayReverseFill](#higher_order_functions-array-reverse-fill)
- [arraySplit](#higher_order_functions-array-split)
- [arrayReverseSplit](#higher_order_functions-array-reverse-split)
- [arrayFirst](#higher_order_functions-array-first)
- [arrayFirstİndex](#higher_order_functions-array-first-index)
### arrayMap(func, arr1, …) {#higher_order_functions-array-map}
Özgün uygulamadan elde edilen bir dizi döndürür `func` fonksiyon inunda her ele elementmana `arr` dizi.
Örnekler:
``` sql
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
``` text
┌─res─────┐
│ [3,4,5] │
└─────────┘
```
Aşağıdaki örnek, farklı dizilerden bir öğe kümesinin nasıl oluşturulacağını gösterir:
``` sql
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
``` text
┌─res─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘
```
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayMap` işlev.
### arrayFilter(func, arr1, …) {#higher_order_functions-array-filter}
Yalnızca öğeleri içeren bir dizi döndürür `arr1` hangi için `func` 0dan başka bir şey döndürür.
Örnekler:
``` sql
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
``` text
┌─res───────────┐
│ ['abc World'] │
└───────────────┘
```
``` sql
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
``` text
┌─res─┐
│ [2] │
└─────┘
```
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFilter` işlev.
### arrayFill(func, arr1, …) {#higher_order_functions-array-fill}
Tarama yoluyla `arr1` ilk öğeden son öğeye ve değiştir `arr1[i]` tarafından `arr1[i - 1]` eğer `func` 0 döndürür. İlk eleman `arr1` değiştir notilm .eyecektir.
Örnekler:
``` sql
SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
```
``` text
┌─res──────────────────────────────┐
│ [1,1,3,11,12,12,12,5,6,14,14,14] │
└──────────────────────────────────┘
```
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFill` işlev.
### arrayReverseFill(func, arr1, …) {#higher_order_functions-array-reverse-fill}
Tarama yoluyla `arr1` son öğeden ilk öğeye ve değiştir `arr1[i]` tarafından `arr1[i + 1]` eğer `func` 0 döndürür. The La lastst element of `arr1` değiştir notilm .eyecektir.
Örnekler:
``` sql
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
```
``` text
┌─res────────────────────────────────┐
│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
└────────────────────────────────────┘
```
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayReverseFill` işlev.
### arraySplit(func, arr1, …) {#higher_order_functions-array-split}
Bölme `arr1` birden fazla diziye. Ne zaman `func` 0dan başka bir şey döndürür, dizi öğenin sol tarafında bölünecektir. Dizi ilk öğeden önce bölünmez.
Örnekler:
``` sql
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
``` text
┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘
```
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arraySplit` işlev.
### arrayReverseSplit(func, arr1, …) {#higher_order_functions-array-reverse-split}
Bölme `arr1` birden fazla diziye. Ne zaman `func` 0dan başka bir şey döndürür, dizi öğenin sağ tarafında bölünecektir. Dizi son öğeden sonra bölünmez.
Örnekler:
``` sql
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
``` text
┌─res───────────────┐
│ [[1],[2,3,4],[5]] │
└───────────────────┘
```
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arraySplit` işlev.
### arrayCount(\[func,\] arr1, …) {#higher_order_functions-array-count}
Func 0dan başka bir şey döndüren arr dizisindeki öğelerin sayısını döndürür. Eğer func belirtilmemişse, dizideki sıfır olmayan öğelerin sayısını döndürür.
### arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
İçinde en az bir öğe varsa 1 değerini döndürür arr hangi için func 0dan başka bir şey döndürür. Aksi takdirde, 0 döndürür.
### arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
Döner 1 Eğer func içindeki tüm öğeler için 0dan başka bir şey döndürür arr. Aksi takdirde, 0 döndürür.
### arraySum(\[func,\] arr1, …) {#higher-order-functions-array-sum}
Toplamını döndürür func değerler. İşlev atlanırsa, sadece dizi öğelerinin toplamını döndürür.
### arrayFirst(func, arr1, …) {#higher_order_functions-array-first}
İlk öğeyi döndürür arr1 dizi hangi func 0dan başka bir şey döndürür.
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFirst` işlev.
### arrayFirstIndex(func, arr1, …) {#higher_order_functions-array-first-index}
İlk öğenin dizinini döndürür arr1 dizi hangi func 0dan başka bir şey döndürür.
İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFirstIndex` işlev.
### arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
Kaynak dizideki öğelerin kısmi toplamlarının bir dizisini döndürür (çalışan bir toplam). Eğer… `func` işlev belirtilir, daha sonra dizi öğelerinin değerleri toplanmadan önce bu işlev tarafından dönüştürülür.
Örnek:
``` sql
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
``` text
┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘
```
### arrayCumSumNonNegative(arr) {#arraycumsumnonnegativearr}
Aynı olarak `arrayCumSum`, kaynak dizideki öğelerin kısmi toplamlarının bir dizisini döndürür (çalışan bir toplam). Farklı `arrayCumSum`, daha sonra döndürülen değer sıfırdan küçük bir değer içerdiğinde, değer sıfır ile değiştirilir ve sonraki hesaplama sıfır parametrelerle gerçekleştirilir. Mesela:
``` sql
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
``` text
┌─res───────┐
│ [1,2,0,1] │
└───────────┘
```
### arraySort(\[func,\] arr1, …) {#arraysortfunc-arr1}
Öğeleri sıralama sonucu bir dizi döndürür `arr1` artan düzende. Eğer… `func` fonksiyon belirtilir, sıralama sırası fonksiyonun sonucu ile belirlenir `func` dizi elemanlarına uygulanır (diziler)
Bu [Schwartzian dönüşümü](https://en.wikipedia.org/wiki/Schwartzian_transform) sıralama verimliliğini artırmak için kullanılır.
Örnek:
``` sql
SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]);
```
``` text
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘
```
Hakkında daha fazla bilgi için `arraySort` yöntem, görmek [Dizilerle çalışmak için işlevler](array-functions.md#array_functions-sort) bölme.
### arrayReverseSort(\[func,\] arr1, …) {#arrayreversesortfunc-arr1}
Öğeleri sıralama sonucu bir dizi döndürür `arr1` azalan sırada. Eğer… `func` fonksiyon belirtilir, sıralama sırası fonksiyonun sonucu ile belirlenir `func` dizi (diziler) elemanlarına uygulanır.
Örnek:
``` sql
SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
```
``` text
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘
```
Hakkında daha fazla bilgi için `arrayReverseSort` yöntem, görmek [Dizilerle çalışmak için işlevler](array-functions.md#array_functions-reverse-sort) bölme.
[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/higher_order_functions/) <!--hide-->