Что такое область определения функции это: § Область определения функции

alexxlab / / Разное

Объяснение функций Kotlin Scope [Пример]

По определению, функции Scoped — это функции, которые выполняют блок кода в контексте объекта.

Kotlin «функции области видимости» — это функции, которые позволяют изменять область или диапазон переменной. В стандартную библиотеку Kotlin включено пять таких функций: apply , run , with , let и также .

Прежде чем приступить к функциям области видимости, я подробно объяснил основы kotlin.

Начальная разработка Android с Kotlin

Kotlin High Order Functions и Lambdas объяснили

Cotlin Coroutines для Android Development

Koin — Kotlin Inception For in Android

KOIN — Netuling For For For in Android

KOIN — Netwin in in Android

KOON -NetWoring.

MVVM с Kotlin Coroutines и Retrofit [Пример]

Scope Functions

Ссылки на объекты

Чтобы использовать эти функции, мы должны понять пару вещей.

Внутри лямбда-функции области видимости этот (лямбда-приемник) используется для доступа к объекту контекста. К тому же объекту можно получить доступ, используя и (лямбда-аргумент). В общем, оба могут выполнять аналогичные действия.

This

Внутри функции области вы сможете ссылаться на объект контекста коротким словом ( this ) вместо самого имени.

выполнить , применить , с используйте ‘ this ’ для доступа к объекту контекста.

Примечание : Мы можем исключить это ключевое слово, чтобы ссылаться на членов класса.

 
  забава главная () {
    var user = Пользователь ("Джо", "Лондон")
    val имя пользователя = с (пользователь) {
        имя = "Палани"
        адрес = "Индия"
        println("Имя = $имя, адрес = $адрес")
        имя
    }
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Это 9Функции 0059

‘ let ’ и ‘ also ’ обращаются к контексту объекта как к лямбда-аргументу.

 
  забава главная () {
    var user = Пользователь ("Джо", "Лондон")
    user.let {
        println("Имя: ${it.name}")
        println("Адрес: ${it.address}")
    }
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Возвращаемые значения

Существует два типа возвращаемых значений, которые может возвращать функция области видимости:

Лямбда-результат

Если мы напишем любое выражение в конце блока кода, оно станет возвращаемым значением для функции области видимости. Возвращаемое значение для функций ‘ let ’, ‘ run ’ и ‘ with ’ является лямбда-результатом.

 
  забава главная () {
    var user = Пользователь ("Джо", "Лондон")
    val updatedUsername = user.let {
        it.name = "Джон"
        это.имя
    }
    println("Обновленное имя пользователя: $updatedUsername")
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Объект контекста

Функции ‘ применить ’ и ‘ также’ возвращают сам объект контекста. В этом случае нам не нужно указывать возвращаемое значение. Объект контекста возвращается автоматически.

 
  забава главная () {
    var user = Пользователь ("Джо", "Лондон")
    val updatedUser = user.apply {
        имя = "Джон"
    }
    println("Обновленное имя пользователя: ${updatedUser.name}")
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

См. таблицу ниже для сравнения.

It This
Return Result let run, with
Return object also apply

let’s see the kotlin scope functions in деталь.

Let

В основном используется для нулевых проверок, применяя ?.let к объекту, мы можем быть уверены, что каждый раз, когда мы обращаемся к этому объекту внутри функции области, объект будет не нуль . Чтобы сослаться на объект внутри функции области видимости, мы используем ключевое слово it .

  • Объект контекста – это
  • Возвращает — последний оператор
  • Вариант использования  – функция let часто используется для обеспечения нулевых вызовов безопасности. Используйте оператор безопасного вызова (?.) с оператором let для нулевой безопасности. Он выполняет блок только с ненулевым значением.
 
  забава главная () {
    
    переменная пользователя:Пользователь? = ноль
    пользователь?.let {
        println("Первый раз: пользователь $user")
    }
    пользователь = Пользователь ("Джон", "Индия")
    пользователь?.let {
        println("Второй раз: пользователь $user")
    }
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Выполнить

Функцию «Выполнить» можно назвать комбинацией функций « пусть » и « с ».

  • Объект контекста – этот
  • Возвращает — последний оператор
  • Вариант использования — используется, когда лямбда-выражение объекта содержит как инициализацию, так и вычисление возвращаемого значения. Используя run, мы можем выполнять нулевые вызовы безопасности, а также другие вычисления.

Это единственная функция области действия, имеющая два варианта.

запускать как расширение

, используемое для создания области для выполнения операции над объектом и получения результата.

 
  забава главная () {
    val пользователь = пользователь ("мани", "Индия")
    val имя_пользователя = пользователь?.run {
        имя = генерироватьПолноеИмя(имя)
        имя
    }
    println(имя пользователя)
}
fun generateFullName (имя: строка): строка {
    вернуть имя + "кандам"
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Примечание: run возвращает последний оператор функции.

запустить как функцию

уменьшить область действия определенных переменных, чтобы избежать ненужного доступа.

 
  забава главная () {
    val пользователь = пользователь ("мани", "Индия")
    
    val имя пользователя = запустить {
        generateFullName (имя пользователя)
    }
    println(имя пользователя)
}
fun generateFullName (имя: строка): строка {
    вернуть имя + "кандам"
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

С

Аналогично применяется функция , с также используется для изменения свойств экземпляра, т.е. конфигурации объекта. Разница только в с не является функцией расширения. Последнее выражение функции with возвращает результат.

  • Объект контекста – этот
  • Возвращает — последний оператор
  • Вариант использования — выполнение нескольких операций над объектом
 
  забава главная () {
    val пользователь = пользователь ("мани", "Индия")
    
    val имя пользователя = с (пользователь) {
    имя = "Сатиш"
        адрес = "США"
        имя
    }
    
    println(имя пользователя)
    
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Apply

По сути, если вы инициализируете объект и устанавливаете набор свойств, как в этом случае, у вас есть довольно надежный кандидат на применение этой функции области видимости.

  • Объект контекста – это
  • Возвраты – тот же объект
  • Вариант использования — Инициализация и настройка объекта
 
  забава главная () {
    val пользователь = пользователь ("мани", "Индия")
    
    val updatedUser = user.apply {
        имя = "Шива"
        адрес = "Лондон"
    }
    
    println (обновленный пользователь)
    
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Также

Обычно используется для побочных эффектов без изменения объекта. Мы можем использовать его для выполнения некоторых операций над промежуточными результатами. также не трансформирует объект. Он возвращает тот же объект.

  • Объект контекста – это
  • Возвращает — тот же объект
  • Вариант использования — используется там, где нам необходимо выполнить дополнительные операции после инициализации членов объекта.
 
  весело main() {
    val пользователь = пользователь ("мани", "Индия")
    
    val updatedUser = user.apply {
        имя = "Шива"
        адрес = "Лондон"
    }.также {
        распечатать(это)
    }
   
}
класс данных Пользователь (имя переменной: строка, адрес переменной: строка)

Вот и все. Спасибо за прочтение.

R Environment and Scope (с примерами)

В этой статье вы узнаете о среде (глобальная среда, каскадирование сред и т. д.) в программировании на R. Вы также узнаете о области действия переменных с помощью примеров.

Чтобы правильно писать функции и избегать необычных ошибок, нам необходимо знать концепцию окружения и области видимости в R.

R Среда программирования

Среду можно рассматривать как набор объектов (функций, переменных и т. д.). Окружение создается при первом запуске интерпретатора R. Любая переменная, которую мы определяем, теперь находится в этой среде.

Среда верхнего уровня, доступная нам в командной строке R, — это глобальная среда с именем 9.0084 R_GlobalEnv . Глобальная среда

также может обозначаться как .GlobalEnv в кодах R.

Мы можем использовать функцию ls() , чтобы показать, какие переменные и функции определены в текущей среде. Более того, мы можем использовать функцию environment() для получения текущей среды.

 > а <- 2
> б <- 5
> f <- функция (x) x<-0
> лс()
[1] «а» «б» «ф»
> среда ()
<среда: R_GlobalEnv>
> .GlobalEnv
<среда: R_GlobalEnv>

В приведенном выше примере мы видим, что a , b и f находятся в среде R_GlobalEnv .

Обратите внимание, что x (в аргументе функции) не находится в этой глобальной среде. Когда мы определяем функцию, создается новая среда.

В приведенном выше примере функция f создает новую среду внутри глобальной среды.

На самом деле среда имеет фрейм, в котором определены все объекты, и указатель на окружающую (родительскую) среду.

Следовательно, x находится в рамках нового окружения, созданного функцией f . Эта среда также будет иметь указатель на R_GlobalEnv .

Пример: каскадирование сред 

 f <- функция (f_x) {
г <- функция (g_x) {
print("Внутри g")
печать (окружающая среда ())
печать (лс ())
}
г(5)
print("Внутри f")
печать (окружающая среда ())
печать (лс ())
}

Теперь, когда мы запускаем его из командной строки, мы получаем.

 > ф(6)
[1] «Внутри г»
<среда: 0x0000000010c2bdc8>
[1] "г_х"
[1] «Внутри ф»
<среда: 0x0000000010c2a870>
[1] "f_x" "г"
> среда ()
<среда: R_GlobalEnv>
> лс()
[1] «ф»

Здесь мы определили функцию g внутри f , и ясно, что они оба имеют разные среды с разными объектами в своих соответствующих кадрах.

R Объем программирования

Рассмотрим следующий пример.

 external_func <- function(){
б <- 20
inner_func <- функция(){
с <- 30
}
}
а <- 10

Глобальные переменные

Глобальные переменные — это те переменные, которые существуют во время выполнения программы. Его можно изменить и получить к нему доступ из любой части программы.

Однако глобальные переменные также зависят от перспективы функции.

Например, в приведенном выше примере с точки зрения inner_func() обе a и b являются глобальными переменными.

Однако с точки зрения external_func() , b является локальной переменной, и только и являются глобальной переменной. Переменная c полностью невидима для external_func() .

Локальные переменные

С другой стороны, локальные переменные — это те переменные, которые существуют только в определенной части программы, такой как функция, и освобождаются при завершении вызова функции.

В приведенной выше программе переменная c называется локальной переменной.

Если мы присвоим значение переменной с помощью функции inner_func() , изменение будет только локальным и недоступно вне функции.

То же самое, даже если имена глобальной и локальной переменных совпадают.

Например, если у нас есть функция, как показано ниже.

 external_func <- function(){
а <- 20
inner_func <- функция(){
а <- 30
печать (а)
}
внутренняя_функция()
печать (а)
}

Когда мы называем это

 > а <- 10
> внешняя_функция()
[1] 30
[1] 20
> печатать(а)
[1] 10

Мы видим, что переменная a создается локально в фрейме окружения обеих функций и отличается от глобального фрейма окружения.

Доступ к глобальным переменным

Глобальные переменные можно читать, но когда мы пытаемся присвоить им значение, вместо них создается новая локальная переменная.

Для присваивания значения глобальным переменным используется оператор суперприсваивания <<-.

No related posts.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *