Scope
Scope is the region of a program in which names are visible and can be resolved according to the language’s lookup rules.
The Well-Grounded Rubyist, Fourth Edition
Scope is the lexical region of a Ruby program in which a variable or other name is visible and can be resolved.
- How it is used
- Uses scope to determine which Ruby variable or constant a name denotes as execution crosses definitions and method calls.
- How deep it goes
- Works through definition boundaries and block-variable behavior, including parameter shadowing; defers closure behavior to a later treatment.
- Examples
- Contrasts separate `a` values in a class and method, then tests whether a block parameter changes an outer `x`.
- What you can do after
- Diagnose/debug with scope boundaries and `rdbg` to distinguish same-named locals and inspect their values at a breakpoint.
Read how The Well-Grounded Rubyist, Fourth Edition explains scope →
100 C++ Mistakes and How to Avoid Them
Scope is the region of a C++ program in which a declared name can be accessed.
- How it is used
- Uses scope to limit variable visibility, prevent shadowing, organize searches, and protect local-object lifetimes.
- How deep it goes
- Explains declaration boundaries, statement and block scope, shadowing, scoped initialization, and local lifetime failures.
- Examples
- Demonstrates scoped searches, point-of-need maximum computation, shadowed Circle radii, and a dangling string reference.
- What you can do after
- Diagnose scope-related bugs and refactor declarations, searches, shadowed names, and local returns toward safer C++ code.
Read how 100 C++ Mistakes and How to Avoid Them explains scope →
Modern C
A scope is the region of a C program in which an identifier is visible and can be referred to.
- How it is used
- Determines where C declarations make identifiers visible and which same-named declaration applies.
- How deep it goes
- Defines block and file boundaries, then works through shadowing and distinguishes name visibility from object access and lifetime.
- Examples
- Traces `for`-local and file-scope names, an `extern` declaration among three names called `i`, and access through a saved pointer.
- What you can do after
- Diagnose/debug with it which declaration a C name denotes without mistaking a hidden name for an inaccessible object.
Python Workout, Second Edition
A scope is the region of Python code in which a name can be resolved according to the language's name-lookup rules.
- How it is used
- Explains name lookup, assignment behavior, built-in shadowing, and state shared through nested functions.
- How deep it goes
- Defines LEGB and works through local, global, built-in, enclosing, closure, and nonlocal behavior with executable examples.
- Examples
- Uses shadowed x and sum names, global reassignment, nested multipliers, call counters, and password-generating closures.
- What you can do after
- Diagnose name-resolution mistakes involving local shadowing, built-in rebinding, global assignment, and retained closure state.
Secrets of the JavaScript Ninja, Second Edition
The region in which an identifier's binding is visible and can be resolved.
- How it is used
- Uses scope to hide module internals and explain how closures preserve variable access for callbacks.
- How deep it goes
- Explains function-created scope through a module example and links closures to execution contexts and lexical environments, without specifying identifier lookup order.
- Examples
- Uses a browser click counter and a module-pattern listing with a hidden count and public method.
- What you can do after
- Build it from scratch: use function scope and closures to expose a module interface while keeping state inaccessible from outside.
Read how Secrets of the JavaScript Ninja, Second Edition explains scope →
Functional Programming in JavaScript
Scope is the region of program text in which a binding name refers to a particular variable or function declaration.
- How it is used
- Explains how JavaScript resolves names and preserves surrounding state for closures, callbacks, and higher-order functions.
- How deep it goes
- Defines lexical, function, global, and block scope, then demonstrates lookup, closures, var leakage, and loop-counter problems.
- Examples
- Uses nested functions, returned adders, private accessors, name lookup, var conditionals, and an ambiguous loop counter.
- What you can do after
- Evaluate JavaScript name lookups and use closures to preserve state or emulate private variables.
Read how Functional Programming in JavaScript explains scope →
Modern C, Third Edition
A scope is a region of a C program within which an identifier is visible and its declaration applies.
- How it is used
- Determines where C identifier declarations apply and whether declarations in the same part of a program conflict.
- How deep it goes
- Defines visibility and traces file, parameter, block, and loop cases, then addresses the less obvious visibility of nested structure tags.
- Examples
- Contrasts nested structure declarations with saved pointers to compound literals created by a while loop or a goto-controlled block.
- What you can do after
- Diagnose/debug with it: identify where a declaration is visible and avoid treating a visible pointer as proof that its object remains alive.
The Quick Python Book, Fourth Edition
A scope is a region of program execution in which name bindings can be resolved and accessed according to Python's lookup rules.
- How it is used
- Resolves which binding a name refers to during function calls and module-level execution.
- How deep it goes
- Explains namespace lookup, per-call locals, and global and nonlocal assignments, while deferring further namespace detail to standard-library documentation.
- Examples
- Contrasts local and global assignments, traces nested-function bindings, and shows a built-in hidden by an assignment.
- What you can do after
- Diagnose/debug missing or unexpected names with locals(), globals(), and dir(), and choose global or nonlocal for intended assignments.
Read how The Quick Python Book, Fourth Edition explains scope →
F# in Action: A Revised Edition of Get Programming with F#
A scope is a region of source code that determines the lifetime and accessibility of names and bindings.
- How it is used
- Uses indentation-based scope to control symbol lifetime and accessibility while improving readability and intent.
- How deep it goes
- Explains indentation and nested bindings, then gives a procedural exercise for extracting a nested scope into a function.
- Examples
- Uses a nested full-name greeting and an age-description calculation separated from console output.
- What you can do after
- Practice/perform it by nesting bindings, diagnosing indentation-related errors, and extracting reusable calculations into functions.
Read how F# in Action: A Revised Edition of Get Programming with F# explains scope →
Get Programming: Learn to code with Python
The set of rules and region of a program that determine where a name can be accessed and which binding it refers to.
- How it is used
- Explains which variables functions can access, how Python resolves repeated names, and why local changes do not alter same-named global values.
- How deep it goes
- Works through function and nested-function scopes with traces and error cases, but does not develop broader function-object behavior.
- Examples
- Uses repeated peter variables, odd-or-even tracing, outer-variable access, modification errors, and nested sing and stop functions.
- What you can do after
- Diagnose variable-access errors and predict which value a repeated name refers to during a function call.
Read how Get Programming: Learn to code with Python explains scope →
Python How-To
A scope is a region of Python code that defines the visibility boundary for names and the namespace associated with them.
- How it is used
- Explains name visibility, variable lookup, cross-scope assignment, and debugging through practical Python examples.
- How deep it goes
- Works through LEGB, namespaces, global, nonlocal, and locals() examples, but does not develop broader scope rules beyond these cases.
- Examples
- Uses database filename assignment, nested text-changing functions, namespace inspection, and debugger variable inspection.
- What you can do after
- Diagnose name-resolution mistakes and update global or enclosing variables with global or nonlocal when required.
Python Workout: 50 ten-minute exercises
A local variable is a variable whose scope is limited to the function in which it is defined.
- How it is used
- Explains name visibility, lookup order, shadowing, and state sharing across functions.
- How deep it goes
- Defines LEGB and demonstrates globals, closures, global, and nonlocal, without descending into interpreter implementation.
- Examples
- Uses shadowed x values, a global sum collision, a closure multiplier, and a nonlocal call counter.
- What you can do after
- Diagnose name-resolution surprises and choose global or nonlocal when deliberately updating outer state.
Read how Python Workout: 50 ten-minute exercises explains scope →
Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond
A scoping rule in which a binding is visible only within the block in which it is declared and nested blocks inside it.
- How it is used
- Uses scope to keep let bindings within blocks and expose where var bindings can remain accessible.
- How deep it goes
- Defines block and function scope, works through block and loop boundaries, and contrasts early access without detailing runtime internals.
- Examples
- Uses an if block, a private-data block, list-item click handlers, and a range-function rewrite.
- What you can do after
- Apply it with let to confine temporary and loop variables and remove unnecessary IIFEs from a range function.
Idiomatic Rust
A scope is a region of program text that determines where bindings are valid and when their associated values are destroyed.
- How it is used
- Frames scope as the boundary for binding visibility and RAII resource cleanup in C, C++, and Rust.
- How deep it goes
- Works through function and block scope, shadowing, resource leaks, and destructor-driven cleanup.
- Examples
- Illustrates block shadowing, a C early-return leak, and a Rust String moved into a Vec.
- What you can do after
- Diagnose/debug with it by spotting skipped C cleanup and tracing when Rust-owned values are destroyed.
Rust in Action: Systems programming concepts and techniques
A scope is a region of program text that determines where names and declarations are visible.
- How it is used
- Defines where Rust bindings, blocks, and imported traits are available during introductory programs.
- How deep it goes
- Explains block syntax, local imports, and ownership effects, while deferring a complete treatment of lifetimes and error handling.
- Examples
- Uses integer bindings, trait imports, and CubeSat function calls to demonstrate scope and ownership behavior.
- What you can do after
- Diagnose why Rust permits or rejects a name, method, or value at a particular point in code.
Read how Rust in Action: Systems programming concepts and techniques explains scope →
Grokking Simplicity
The region of a program in which a binding can be accessed or referenced.
- How it is used
- Explains how JavaScript controls function access and protects shared mutable state.
- How deep it goes
- Defines global, local, and inline function scope through examples, then applies scope to state encapsulation.
- Examples
- Uses greetings, inline callbacks, and a cart-processing queue to demonstrate accessible and hidden bindings.
- What you can do after
- Apply via JavaScript function scope to hide queue state and expose only the operation clients need.
The Well-Grounded Python Developer: How the pros use Python and Flask
Scope is the region of a program in which a name or variable is accessible and has a particular binding.
- How it is used
- Organizes Python names by module and function boundaries while controlling accessibility and lifetime.
- How deep it goes
- Explains module and function scope through progressive examples, stopping short of broader name-resolution internals.
- Examples
- Uses prefix, add(), print_prefix(), my_message(), imported modules, and a nested-scope diagram.
- What you can do after
- Diagnose variable behavior by inspecting names within the current scope at debugger breakpoints.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains scope →
Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
Scope is the region of a script or session in which a variable or other name is accessible.
- How it is used
- Explains why aliases, variables, and functions appear or disappear across PowerShell sessions, scripts, and functions.
- How deep it goes
- Defines global, script, and private function scopes, explains parent lookup and lifetime, and defers detailed scoping rules.
- Examples
- Demonstrates $x across a script and shell session, and $PSDefaultParameterValues at command line versus script scope.
- What you can do after
- Apply scope to keep script-specific defaults from affecting the surrounding shell or other scripts.
100 Go Mistakes and How to Avoid Them
Scope is the region of source code in which a variable name binding is valid and can be referenced.
- How it is used
- Prevents incorrect assignments, misleading benchmarks, and goroutines that observe changing loop variables.
- How deep it goes
- Explains block bindings, shadowing, closure capture, and benchmark observability through concrete Go examples.
- Examples
- Uses HTTP client branches, popcount benchmarks, and goroutines launched inside a loop.
- What you can do after
- Diagnose shadowing and closure-capture bugs, then choose assignments or per-iteration values that preserve the intended binding.
Read how 100 Go Mistakes and How to Avoid Them explains scope →
Refactoring to Rust
A region of source code within which a binding is accessible and whose end can trigger the dropping of owned values.
- How it is used
- Explains when Rust bindings remain usable and when owned values are dropped.
- How deep it goes
- Defines scope through ownership and moves, but does not develop borrowing or detailed lexical-scope mechanics.
- Examples
- Uses artwork values passed to admire_art and a repeated art1 call that triggers a compiler error.
- What you can do after
- Diagnose use-of-moved-value errors by tracking ownership across function calls and scopes.
The Art of Code
Scope is the region of a program in which a name or binding is accessible.
- How it is used
- Keeps variables visible only where they contribute to the method’s current scene.
- How deep it goes
- Explains declaration placement and block-local scope through a refactoring example, without developing language-level scope mechanics.
- Examples
- Uses a promotional-email method with birthday and standard promotion branches as the central scope comparison.
- What you can do after
- Apply smallest-possible scope to reduce temporary state and clarify conditional method logic.
Related concepts
- closureused by · A closure is a function or callable value together with access to bindings from the lexical environment in which it was created.
- global variablecontrasts with · A global variable is a variable whose binding is accessible from broad program or module scope according to the language’s name-resolution rules.
- file scopeincludes · File scope is the C scope of an identifier declared outside any function or block and extending to the end of the source file.
- nonlocal statementconfigured by · A nonlocal statement makes a name assigned in a nested Python function refer to a binding in an enclosing function scope.
- namespaceuses · A namespace is a naming context or identifier space in which names are defined and resolved, distinguishing them from names in other contexts.
- blockconfigured by · A code block is a grouped region of code treated as a unit, with boundaries and scope or execution behavior determined by its language or context.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.