Что такое лексический охват?
Это может помочь вам как-то.
String st="I am am not the one who is thinking I one thing at time";
String []ar = st.split("\\s");
Map<String, Integer> mp= new HashMap<String, Integer>();
int count=0;
for(int i=0;i<ar.length;i++){
count=0;
for(int j=0;j<ar.length;j++){
if(ar[i].equals(ar[j])){
count++;
}
}
mp.put(ar[i], count);
}
System.out.println(mp);
5 ответов
I understand them through examples. :)
First, Lexical Scope (also called Static Scope), in C-like syntax:
void fun()
{
int x = 5;
void fun2()
{
printf("%d", x);
}
}
Every inner level can access its outer levels.
There is another way, called Dynamic Scope used by first implementation of Lisp, снова в C-подобном синтаксисе:
void fun()
{
printf("%d", x);
}
void dummy1()
{
int x = 5;
fun();
}
void dummy2()
{
int x = 10;
fun();
}
Здесь fun может либо получить доступ к x в dummy1 , либо dummy2 , либо к любому x в любой функции, которая вызывает fun с объявленным в ней x .
dummy1();
выводит 5,
dummy2();
выводит 10.
Вызывается первая. static, потому что он может быть выведен во время компиляции, второй называется динамическим, потому что внешняя область видимости является динамической и зависит от цепного вызова функций.
Я считаю, что статическая область видимости проще для глаза. В конечном итоге большинство языков пошло по этому пути, даже Лисп (может и то, и другое, верно?). Динамическое определение области похоже на передачу ссылок на все переменные в вызываемую функцию.
Пример того, почему компилятор не может вывести внешнюю динамическую область видимости функции, рассмотрим наш последний пример, если мы напишем что-то вроде этого:
if(/* some condition */)
dummy1();
else
dummy2();
Цепочка вызовов зависит от условия выполнения. Если это правда, то цепочка вызовов выглядит так:
dummy1 --> fun()
Если условие ложно:
dummy2 --> fun()
Внешняя область действия fun в обоих случаях - это вызывающий плюс вызывающий вызывающий. и т. д. .
Просто упомяну, что язык C не допускает вложенных функций или динамической области видимости.
Лексический контекст относится к стопке контекстов выполнения и его набора (словарь) идентификаторов, видимых к текущему контексту выполнения во время его выполнения.
- global execution context
- foo
- bar
- function1 execution context
- foo2
- bar2
- function2 execution context
- foo3
- bar3
foo и bar всегда в словаре доступных идентификаторов, потому что они глобальны.
, Когда function1 выполняется, это имеет доступ к словарю foo2, bar2, foo, и bar.
, Когда function2 выполняется, это имеет доступ к словарю foo3, bar3, foo2, bar2, foo, и bar.
причина глобальные и/или внешние функции не имеют доступа к, внутренние идентификаторы функций - то, потому что выполнение той функции еще не произошло и поэтому, ни один из ее идентификаторов не был выделен памяти. What’s больше, как только тот внутренний контекст выполняется, он удален из стека выполнения, означая, что все it’s идентификаторы были собраны "мусор" и больше не доступны.
Наконец, это - то, почему вложенный контекст выполнения может ВСЕГДА получать доступ к it’s контексту выполнения предков и таким образом почему он имеет доступ к большему словарю идентификаторов.
См.:
Лексическая (статическая) область видимости относится к определению области действия переменной основанный исключительно на его положении в текстовом корпусе кода. Переменная всегда относится к своей среде верхнего уровня. Хорошо понимать это в связи с динамической областью.
Область действия определяет область, в которой доступны функции, переменные и т. Д. Доступность переменной, например, определяется в ее контексте, скажем, функции, файла или объекта, в котором они определены. Обычно мы называем эти локальные переменные.
Лексическая часть означает, что вы можете получить область видимости из чтение исходного кода.
Лексическая область видимости также известна как статическая область видимости.
Динамическая область видимости определяет глобальные переменные, на которые можно вызывать или ссылаться из любого места после определения. Иногда их называют глобальными переменными, хотя глобальные переменные в большинстве языков программирования имеют лексическую область видимости. Это означает, что на основании чтения кода можно понять, что переменная доступна в этом контексте. Может быть, нужно следовать предложению uses или includes, чтобы найти установку или определение, но код / компилятор знает о переменной в этом месте.
В динамической области, напротив, вы сначала выполняете поиск в локальной функции, а затем вы выполните поиск в функции, которая вызвала локальную функцию, затем выполните поиск в функции, которая вызвала эту функцию, и т. д. вверх по стеку вызовов. «Динамический» относится к изменению в том смысле, что стек вызовов может отличаться каждый раз при вызове данной функции, и поэтому функция может воздействовать на разные переменные в зависимости от того, откуда она вызывается. (см. здесь )
Чтобы увидеть интересный пример для динамической области, см. здесь .
Некоторые примеры в Delphi / Object Pascal
Delphi имеет лексическую область видимости.
unit Main;
uses aUnit; // makes available all variables in interface section of aUnit
interface
var aGlobal: string; // global in the scope of all units that use Main;
type
TmyClass = class
strict private aPrivateVar: Integer; // only known by objects of this class type
// lexical: within class definition,
// reserved word private
public aPublicVar: double; // known to everyboday that has access to a
// object of this class type
end;
implementation
var aLocalGlobal: string; // known to all functions following
// the definition in this unit
end.
Наиболее близкой к динамической области видимости Delphi является пара функций RegisterClass () / GetClass (). Для его использования см. здесь .
Предположим, что время, когда RegisterClass ([TmyClass]) вызывается для регистрации определенного класса, не может быть предсказано путем чтения кода (он вызывается в методе нажатия кнопки, называемом пользователем), код вызова GetClass ('TmyClass') получит результат или нет. Вызов RegisterClass () не обязательно должен находиться в лексической области модуля, использующего GetClass ();
Другой возможностью для динамической области видимости являются анонимные методы (замыкания) в Delphi 2009, поскольку они знают переменные своей вызывающей функции. Он не следует оттуда рекурсивно по пути вызова и поэтому не является полностью динамическим.
Давайте попробуем кратчайшее возможное определение:
Lexical Scoping определяет, как имена переменных разрешаются во вложенных функциях: внутренние функции содержат объем родительских функций, даже если родительский функция вернула .
Вот и все!