Permalink
Browse files

Update lambdas.md

  • Loading branch information...
Temon137 committed Jun 19, 2017
1 parent 1f5acb8 commit 9d81895b3e05cb2038323d75be70e9c4792e1ea4
Showing with 21 additions and 18 deletions.
  1. +21 −18 lambdas.md
View
@@ -29,7 +29,7 @@ fun <T> lock(lock: Lock, body: () -> T): T{
внутри блока `try`, защищена `lock`, и её результат возвращается функцией `lock()`.
Если мы хотим вызвать метод lock(), мы можем подать другую функцию в качестве входящего аргумента
(более подробно читайте [function references](reflection.html#function-references))
(более подробно читайте [function references](reflection.html#function-references)):
``` kotlin
fun toBeSynchronized() = sharedResource.operation()
@@ -43,9 +43,9 @@ val result = lock(lock, { sharedResource.operation() })
```
Лямбда-выражения более подробно описаны [здесь](lambdas.html#lambda-expressions-and-anonymous-functions), но в целях продолжить этот раздел, давайте произведём краткий обзор:
- Лямбда-выражения всегда заключены в фигурные скобки.
- Параметры этого выражения (если такие есть) объявлены до знака `->` (параметры могут быть опущены)
- Тело выражения идёт после знака `->`
- Лямбда-выражения всегда заключены в фигурные скобки,
- Параметры этого выражения (если такие есть) объявлены до знака `->` (параметры могут быть опущены),
- Тело выражения идёт после знака `->`.
В Kotlin существует конвенция, по которой, если последний параметр функции является функцией, и вы применяете лямбда-
выражение в качестве аргумента, вы можете указать её вне скобок:
@@ -70,7 +70,7 @@ fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
val doubled = ints.map { it -> it * 2 }
```
Обратите внимание, что параметры могут быть проигнорированы при вызове функции в том слуаче, если лямбда является единственным аргументом
Обратите внимание, что параметры могут быть проигнорированы при вызове функции в том случае, если лямбда является единственным аргументом
для её вызова.
<!--it: implicit name of a single parameter-->
@@ -88,8 +88,8 @@ ints.map { it * 2 }
strings.filter { it.lenght == 5 }.sortBy { it }.map { it.toUpperCase() }
```
## Инлайн функции.
Иногда необходимо улучшить производительность высокоуровневых функций, используя [инлайн функции](inline-functions.html)
## Инлайн функции
Иногда необходимо улучшить производительность высокоуровневых функций, используя [инлайн функции](inline-functions.html).
<a name="lambda-expressions-and-anonymous-functions"></a>
@@ -110,8 +110,11 @@ max(strings, { a, b -> a.length < b.length })
fun compare(a: String, b: String): Boolean = a.length < b.length
```
<!--Function Types-->
## Типы функций
<!--For a function to accept another function as a parameter, we have to specify a function type for that parameter. For example the abovementioned function max is defined as follows:-->
Для того, чтобы функция принимала другую функцию в качестве входного параметра, нам необходимо её (входящей функции) тип. К примеру, вышеуказанная функция `max` определена следующим образом:
Для того, чтобы функция принимала другую функцию в качестве входного параметра, нам необходимо указать её (входящей функции) тип. К примеру, вышеуказанная функция `max` определена следующим образом:
``` kotlin
fun <T> max(collection: Collection<T>, less: (T, T) -> Boolean): T? {
var max: T? = null
@@ -123,10 +126,10 @@ fun <T> max(collection: Collection<T>, less: (T, T) -> Boolean): T? {
```
<!--The parameter less is of type (T, T) -> Boolean, i.e. a function that takes two parameters of type T and returns a Boolean: true if the first one is smaller than the second one.-->
Параметр 'less' является `(T, T) -> Boolean` типом, то есть функцией, которая принимает два параметра типа `T` и вовзвращает 'Boolean':'true', если первый параметр меньше, чем второй.
Параметр 'less' является `(T, T) -> Boolean` типом, то есть функцией, которая принимает два параметра типа `T` и возвращает 'Boolean':'true', если первый параметр меньше, чем второй.
<!--In the body, line 4, less is used as a function: it is called by passing two arguments of type T.-->
В теле функции, линия 4, `less` используется в качестве функции: она вызывается путём передачи двух аргументов типа `T`.
В теле функции, строка 4, `less` используется в качестве функции: она вызывается путём передачи двух аргументов типа `T`.
<!--A function type is written as above, or may have named parameters, if you want to document the meaning of each parameter.-->
Тип функции может быть написан так, как указано выше, или же может иметь определённые параметры, если вы хотите обозначить значения каждого из параметров.
@@ -144,7 +147,7 @@ val sum = { x: Int, y: Int -> x + y }
```
<!--A lambda expression is always surrounded by curly braces, parameter declarations in the full syntactic form go inside parentheses and have optional type annotations, the body goes after an -> sign. If the inferred return type of the lambda is not Unit, the last (or possibly single) expression inside the lambda body is treated as the return value.-->
Лямбда-выражение всегда заключено в скобки `{...}`, объявление параметров при таком синтаксисе происходит внутри этих скобок и может включать в себя типов (опционально), тело функции начинается после знака `->`. Если тип возвращаемого значения не `Unit`, то в качестве возвращаемого типа принимается последнее (а возможно и единственное) выражение внутри тела лямбды.
Лямбда-выражение всегда заключено в скобки `{...}`, объявление параметров при таком синтаксисе происходит внутри этих скобок и может включать в себя аннотации типов (опционально), тело функции начинается после знака `->`. Если тип возвращаемого значения не `Unit`, то в качестве возвращаемого типа принимается последнее (а возможно и единственное) выражение внутри тела лямбды.
<!--If we leave all the optional annotations out, what's left looks like this:-->
Если мы вынесем все необязательные объявления, то, что останется, будет выглядеть следующим образом:
@@ -159,7 +162,7 @@ ints.filter { it > 0 } //Эта константа имеет тип '(it: Int)
```
<!--We can explicitly return a value from the lambda using the qualified return syntax. Otherwise, the value of the last expression is implictly returned. Therefore, the two following snippets are equivalent:-->
Мы можем явно вернуть значение из лямбды, используя [qualified return](returns.html#return-at-labels) синтаксис.
Мы можем явно вернуть значение из лямбды, используя [qualified return](returns.html#return-at-labels) синтаксис:
``` kotlin
ints.filter {
val shouldFilter = it > 0
@@ -172,15 +175,15 @@ ints.filter {
}
```
<!--Note that if a function takes another function as the last parameter, the lambda expression argument can be passed outside the parenthesized argument list. See the grammar for callSuffix.-->
Обратите внимение, что функция принимает другую функцию в качестве своего последнего параметра, аргумент лямбда-выражения в таком случае может быть принят вне списка аргументов, заключённого в скобках. См. [callSuffix](grammar.html#call-suffix)
Обратите внимение, что функция принимает другую функцию в качестве своего последнего параметра, аргумент лямбда-выражения в таком случае может быть принят вне списка аргументов, заключённого в скобках. См. [callSuffix](grammar.html#call-suffix).
<a name="anonymous-functions"></a>
<!--##Anonymous Functions-->
## Анонимные функции
<!--One thing missing from the lambda expression syntax presented above is the ability to specify the return type of the function. In most cases, this is unnecessary because the return type can be inferred automatically. However, if you do need to specify it explicitly, you can use an alternative syntax: an anonymous function.-->
Единственной особенностью синтаксиса лямбда-выражений, о которой ещё не было сказано, является способность определять и назначать возвращаемый функцией тип. В большинстве случаев, в этом нет особой необходимости, потому что он может быть вычислен автоматически. Однако, если у вас есть потребность в определении возвращаемого типа, вы можете воспользоваться альтернативным синтаксисом:
Единственной особенностью синтаксиса лямбда-выражений, о которой ещё не было сказано, является способность определять и назначать возвращаемый функцией тип. В большинстве случаев в этом нет особой необходимости, потому что он может быть вычислен автоматически. Однако, если у вас есть потребность в определении возвращаемого типа, вы можете воспользоваться альтернативным синтаксисом:
```kotlin
fun(x: Int, y: Int): Int = x + y
```
@@ -193,7 +196,7 @@ fun(x: Int, y: Int): Int {
```
<!--The parameters and the return type are specified in the same way as for regular functions, except that the parameter types can be omitted if they can be inferred from context:-->
Параметры функции и возвращаемый тип обозначаются таким же образом, как в обычных функциях. Правда, тип параметра может быть опущен, если его значение следует из контекста.
Параметры функции и возвращаемый тип обозначаются таким же образом, как в обычных функциях. Правда, тип параметра может быть опущен, если его значение следует из контекста:
```kotlin
ints.filter(fun(item) = item > 0)
```
@@ -205,13 +208,13 @@ ints.filter(fun(item) = item > 0)
Обратите внимание, что параметры анонимных функций всегда заключены в скобки `{...}`. Приём, позволяющий оставлять параметры вне скобок, работает только с лямбда-выражениями.
<!--One other difference between lambda expressions and anonymous functions is the behavior of non-local returns. A return statement without a label always returns from the function declared with the fun keyword. This means that a return inside a lambda expression will return from the enclosing function, whereas a return inside an anonymous function will return from the anonymous function itself.-->
Одним из отличий лямбда-выражений от анонимных функций является поведение оператора `return` ([non-local returns](inline-functions.html#non-local-returns). Слово `return` , не имеющее метки (`@`), всегда возвращается из функции, объявленной ключевым словом `fun`. Это означает, что `return` внутри лямбда-выражения возвратит выполнение к функции, включающей в себя это лямбда-выражение. Внутри анонимных функций, оператор `return`, в свою очередь, выйдет ,собственно, из анонимной функции.
Одним из отличий лямбда-выражений от анонимных функций является поведение оператора `return` ([non-local returns](inline-functions.html#non-local-returns)). Слово `return` , не имеющее метки (`@`), всегда возвращается из функции, объявленной ключевым словом `fun`. Это означает, что `return` внутри лямбда-выражения возвратит выполнение к функции, включающей в себя это лямбда-выражение. Внутри анонимных функций оператор `return`, в свою очередь, выйдет, собственно, из анонимной функции.
<!--## Closures-->
## Замыкания
<!--A lambda expression or anonymous function (as well as a [local function](http://kotlinlang.org/docs/reference/functions.html#local-functions) and an [object expression](http://kotlinlang.org/docs/reference/object-declarations.html#object-expressions)) can access its closure, i.e. the variables declared in the outer scope. Unlike Java, the variables captured in the closure can be modified:-->
Лямбда-выражение или анонимная функция (также, как и [локальная функция](functions.html#local-functions) или [object expression](object-declarations.html#object-expressions)) имеет доступ к своему замыканию, то есть к переменным, объявленным вне этого выражения или функции. В отличае от Java, переменные, захваченные в замыкании могут быть изменены:
Лямбда-выражение или анонимная функция (так же, как и [локальная функция](functions.html#local-functions) или [object expression](object-declarations.html#object-expressions)) имеет доступ к своему замыканию, то есть к переменным, объявленным вне этого выражения или функции. В отличае от Java, переменные, захваченные в замыкании, могут быть изменены:
``` kotlin
var sum = 0
@@ -229,7 +232,7 @@ print(sum)
Kotlin предоставляет возможность вызывать литерал функции с указаным объектом-приёмником. Внутри тела литерала вы можете вызывать методы объекта-приёмника без дополнительных определителей. Это схоже с принципом работы [расширений](extensions.html), которые позволяют получить доступ к членам объекта-приёмника внутри тела функции. Один из самых важных примеров использования литералов с объектом-приёмником это [Type-safe Groovy-style builders](type-safe-builders.html).
<!--The type of such a function literal is a function type with receiver:-->
Тип такого литерала — это тип функции с приёмником
Тип такого литерала — это тип функции с приёмником:
``` kotlin
sum : Int.(other: Int) -> Int
```

0 comments on commit 9d81895

Please sign in to comment.