1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Base {
    private var secret = 1                 // 仅本类型（及本文件中该类型的扩展）
    fileprivate var fileSecret = 2         // 本文件
    internal var moduleSecret = 3          // 本模块（默认）
    public var api = 4                     // 模块外可读，但不可被 override
    open var overridable = 5               // 模块外可继承/覆写（仅 class 成员）
    private(set) var counter = 0           // 读公开、写私有
    func bump() { counter += 1; secret += 1 }
}
extension Base {
    func peek() -> Int { secret }          // ✅ 同文件的扩展能看到 private
}
let b = Base()
b.bump()
print(b.counter, b.peek())                 // 1 2
// print(b.secret)                         // 🛑 'secret' is inaccessible due to 'private' protection level

1
2
3
4

// 用 `swiftc vis2.swift` 编译会失败，必须加 -package-name
package func pkgAPI() -> Int { 7 }
// 🛑 error: the package access level used on 'pkgAPI()' requires a package name;
//    set it with the compiler flag -package-name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

type account struct {        // 小写类型名：仅包内可见
	Owner   string           // 大写字段：导出
	balance int              // 小写字段：包内可见，包外彻底看不见
}

func (a *account) Balance() int  { return a.balance }  // 导出方法读私有字段
func (a *account) deposit(n int) { a.balance += n }    // 小写方法：包内

func main() {
	a := account{Owner: "ada", balance: 10}
	a.deposit(5)
	fmt.Println(a.Owner, a.Balance())   // ada 15
}

1
2
3
4
5

v := reflect.ValueOf(&a).Elem()
f := v.FieldByName("balance")
fmt.Println(f.CanInterface(), f.CanSet())   // false false
// f.Int()                                   // 🛑 panic: reflect.Value.Int using value obtained using unexported field
v.FieldByName("Owner").SetString("grace")    // ✅ 导出字段可写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Account:
    def __init__(self, owner: str, balance: int) -> None:
        self.owner = owner          # 公开：纯约定
        self._balance = balance     # 单下划线：约定「内部」，不强制
        self.__pin = 1234           # 双下划线：触发名称改写

class Account2:
    _internal = 1
    __mangled = 2   # 变成 _Account2__mangled

a = Account("ada", 10)
print(a.owner)                 # ada
print(a._balance)              # 10   ⚠️ 能访问，只是约定
# print(a.__pin)               # 🛑 AttributeError
print(a._Account__pin)         # 1234  名称改写后照样能访问
print(hasattr(a, "__pin"), hasattr(a, "_Account__pin"))   # False True
print([n for n in vars(Account2) if "mangled" in n])       # ['_Account2__mangled']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from typing import Final

class Config:
    __slots__ = ("_url",)
    MAX: Final = 10                # typing.Final 只是给类型检查器看的
    def __init__(self, url: str) -> None:
        object.__setattr__(self, "_url", url)
    @property
    def url(self) -> str:
        return self._url

c = Config("https://x.example")
try:
    c.extra = 1                    # 🛑 AttributeError（消息随版本变化）
except AttributeError as e:
    print("AttributeError:", str(e)[:30])   # AttributeError: 'Config' object has no attribu
object.__setattr__(c, "_url", "https://y.example")   # ⚠️ 强制改私有字段
print(c.url, c.MAX, Config.__annotations__)   # https://y.example 10 {'MAX': typing.Final}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 顶层声明
public val all = 1              // 默认就是 public，写出来只是显式
internal val inModule = 2       // 同一个编译模块内可见
private val inFile = 3          // 本文件内可见（顶层 private 的最广范围就是文件）

class Account(private val owner: String) {   // 构造函数私有参数自动变成私有属性
    internal var balance = 0                 // 模块内可见
    protected open fun hook() {}             // 只有子类可见（不能用在顶层）
    private fun audit() {}                   // 类内可见
    fun deposit(n: Int) { balance += n; audit() }
}

class Sub : Account("x") {
    override fun hook() { balance + 1 }      // ✅ 子类能访问 internal 与 protected
}

1
2
3
4
5
6

class Api {
    internal fun internalApi() {}      // 模块内可见
    @JvmSynthetic fun onlyForKotlin() {}   // 对 Java 调用者不可见
    @PublishedApi internal fun usedByInline() {}
    // @PublishedApi 让 internal 声明可以出现在 public inline 函数体里
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package shop;
public class Account {
    public String owner = "ada";        // 全世界可访问
    protected int balance = 10;         // 同包 + 子类
    int pin = 1234;                     // 包私有：同包可访问（默认）
    private String secret = "s3";       // 仅本类（含同类其它实例）

    public int peek(Account other) {
        return other.balance + other.pin;   // ✅ 同类实例之间可以互访 protected/private
    }
}

1
2
3
4
5
6

module shop {
    requires java.base;               // 隐含，写出来只是说明
    exports shop.api;                 // 只有这个包对外可见
    opens shop.model to com.fasterxml.jackson.databind;   // 只对指定模块开放反射
}
// 运行期补救：java --add-opens java.base/java.lang=ALL-UNNAMED

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <cstdio>
class Widget {
public:
    int api() const { return secret_; }
protected:
    int inherited_ = 1;                   // 派生类可见
private:
    int secret_ = 42;                     // 只有本类与 friend 可见
    friend int peek(const Widget &);      // friend 打开一个洞
};
struct Pod { int x = 1; };                 // struct 默认 public
int peek(const Widget &w) { return w.secret_; }
int main() {
    Widget w;
    std::printf("%d %d %d\n", w.api(), peek(w), Pod{}.x);   // 42 42 1
    // std::printf("%d\n", w.secret_);    // 🛑 error: 'secret_' is private
}

1
2
3
4
5

#include <cstdio>
#define private public          // ⚠️ 经典恶作剧：预处理器把 private 换成 public
class Secret { private: int hidden_ = 7; };
#undef private
int main() { Secret s; std::printf("%d\n", s.hidden_); }   // 7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
/* C 没有任何访问修饰符：private 全靠 static（内部链接）与头文件约定 */
struct account {                 /* 定义放进 .c，头文件只放不完整类型才是真封装 */
    const char *owner;            /* 无修饰符：谁拿到指针谁就能改 */
    long balance;
};
static long g_calls = 0;          /* static：内部链接，别的翻译单元看不到这个名字 */
static void bump(void) { g_calls++; }   /* static 函数：本翻译单元私有 */
long account_balance(const struct account *a) { bump(); return a->balance; }
int main(void) {
    struct account a = {"ada", 10};
    struct account *p = (struct account *)&a;
    p->balance = 99;              /* 结构体字段没有访问控制，改得动 */
    printf("%s %ld %ld\n", a.owner, account_balance(&a), g_calls);   /* ada 99 1 */
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

module Shop
export total                      # using Shop 会带入 total
public Account, rate              # 标为公共 API，但不会带入命名空间
struct Account                    # 不在 export 也不在 public：纯内部
    balance::Int
end
total(a::Account) = a.balance
rate() = 0.1
_secret() = 42                    # 下划线约定：内部
end

using .Shop
total(Shop.Account(7))            # 7        ✅ 导出的名字直接可用
# Account                          # 🛑 UndefVarError（public 不产生命名空间效果）
Shop.Account                       # ✅ 限定名永远可访问
Shop._secret()                     # 42      ⚠️ 下划线挡不住任何人
Base.ispublic(Shop, :Account)       # true
Base.ispublic(Shop, :_secret)       # false

1
2
3
4
5
6
7
8

module A
export f
f() = 1
end
module B
import ..A: f            # import 才允许直接扩展
f(::Int) = 2             # ✅ 给 A.f 加方法
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

namespace Shop;

internal class Account            // 顶层类型默认 internal，写出来只是显式
{
    public string Owner = "ada";              // 不限制
    protected int Balance = 10;               // 本类 + 派生类
    internal int Pin = 1234;                  // 本程序集
    protected internal int Limit = 100;       // 本程序集 或 派生类
    private protected int Cap = 50;           // 本程序集 且 派生类
    private string secret = "s3";             // 仅本类型（含同类其它实例）

    public int Peek(Account other) => other.secret.Length + other.Pin;   // ✅ 同类实例互访
}

file class HiddenWidget           // C# 11：只在当前文件可见
{
    public int Work() => 42;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// File1.cs
file interface IWidget { int ProvideAnswer(); }
file class HiddenWidget { public int Work() => 42; }

public class Widget : IWidget {          // ✅ 公开类型隐式实现 file 接口
    public int ProvideAnswer() => new HiddenWidget().Work();
    // private HiddenWidget w;           // 🛑 file 类型不能做非 file 类型的字段
}
// File2.cs
public class HiddenWidget { }            // ✅ 与 File1.cs 的 file 类型不冲突

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// account.dart —— 这个文件本身就是一个 library
class Account {
  final String owner;
  int _balance;              // 私有：只有本库内可见
  Account(this.owner, this._balance);
  int get balance => _balance;
  void _audit() {}           // 私有方法
}

int _helper() => 1;          // 私有顶层函数

void main() {
  final a = Account('ada', 10);
  print(a.owner);            // ada
  print(a.balance);          // 10
  print(a._balance + _helper());   // 11  ✅ 同库内可以访问
}

1
2
3
4

// library.dart
library shop;
part 'account.dart';          // account.dart 里要写 `part of 'library.dart';`
part 'internal.dart';         // 两个 part 共享同一个私有作用域

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 包 mypkg 的 NAMESPACE
export(total)
export(Account)
exportPattern("^[^\\.]")     # 导出所有不以 . 开头的名字（常用的一揽子写法）
S3method(print, Account)     # 注册 S3 方法（不需要用户直接调用）
importFrom(stats, median)

# R/account.R
Account <- function(owner, balance) {
  structure(list(owner = owner, balance = balance), class = "Account")
}
total <- function(a) a$balance          # 导出
.internal_rate <- function() 0.1         # 以 . 开头：约定为内部

1
2
3
4
5

mypkg::total                       # ✅ 导出名可用
mypkg:::.internal_rate             # ✅ 内部名也能拿到（R CMD check 会 NOTE）
env <- asNamespace("mypkg")
get(".internal_rate", envir = env)  # 0.1：直接进命名空间环境取
assignInNamespace(".internal_rate", function() 0.9, ns = "mypkg")   # ⚠️ 直接改包内绑定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// account.zig —— 文件即容器，等价于一个 struct
pub const Account = struct {          // pub：别的文件能看见这个类型
    owner: []const u8,                 // 字段无可见性概念，外部可读写
    balance: i64,
    pub fn init(owner: []const u8) Account {
        return .{ .owner = owner, .balance = 0 };
    }
};

fn helper() i64 { return 1; }          // 未加 pub：仅本文件可见

pub fn tag() []const u8 { return "shop"; }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const std = @import("std");
const account = @import("account.zig");

pub fn main() void {
    const a = account.Account.init("ada");
    std.debug.print("{s}\n", .{account.tag()});   // shop
    // account.helper();                          // 🛑 error: 'helper' is not marked 'pub'
    std.debug.print("{d}\n", .{@field(a, "balance")});   // 0：@field 按名字取字段（必须存在）
    // @field(a, "nope");                         // 🛑 编译期错误：no field named 'nope'
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

-- Lua 没有访问修饰符；真私有靠闭包，约定式私有靠下划线
local Account = {}
Account.__index = Account

function Account.new(owner, balance)
  local self = setmetatable({}, Account)
  self.owner = owner        -- 公开字段
  self._balance = balance   -- 约定式私有：只是名字，谁都改得动
  return self
end

function Account:balance() return self._balance end

local a = Account.new("ada", 10)
print(a.owner, a:balance())      -- ada 10
a._balance = 999                 -- ⚠️ 约定被打破
print(a:balance())               -- 999

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

local function new_private(owner, balance)
  local self = { owner = owner }
  function self:balance() return balance end          -- balance 是 upvalue
  function self:deposit(n) balance = balance + n end  -- 只有闭包能改
  return self
end
local b = new_private("grace", 5)
b:deposit(3)
print(b.owner, b:balance(), b._balance)   -- grace 8 nil
b._balance = 999                          -- 写了个不相干的字段
print(b:balance())                        -- 8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class Account {
  public owner: string;              // 默认就是 public
  protected balance: number;         // 本类 + 子类
  private secret: string;            // 仅本类（编译期）
  readonly id: string;               // 只能构造期赋值
  #pin: number;                      // ES 原生真私有
  constructor(owner: string, id: string) {
    // 赋值顺序与字段声明顺序保持一致，Object.keys 的顺序才可预期
    this.owner = owner; this.balance = 0;
    this.secret = "s3"; this.id = id; this.#pin = 1234;
  }
  peek(other: Account) { return other.secret; }   // ✅ 同类实例互访
  get pin() { return this.#pin; }
}

const a = new Account("ada", "A1");
(a as any).secret;      // "s3"   ⚠️ private 只是编译期，运行时是普通属性
(a as any).balance;     // 0
// (a as any).#pin;     // 🛑 SyntaxError：私有名字在类外无法引用
console.log(Object.keys(a));   // [ 'owner', 'balance', 'secret', 'id' ]

1
2
3

/** @internal */
export function debugOnly() {}    // 配合 tsconfig 的 stripInternal: true，
                                  // 这一项会从生成的 .d.ts 里被删掉

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Counter {
  #count = 0;                          // 真私有字段
  static #instances = 0;               // 私有静态字段
  static { Counter.#instances = 0; }   // 静态块（ES2022）
  #bump() { this.#count += 1; }        // 私有方法
  inc() { this.#bump(); return this.#count; }
  static has(obj) { return #count in obj; }   // 私有字段可用 in 检测
}
const c = new Counter();
console.log(c.inc(), c.inc());       // 1 2
// console.log(c.#count);            // 🛑 SyntaxError
console.log(Object.keys(c));          // []
console.log(Counter.has(c));          // true
console.log(JSON.stringify(c));       // {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 闭包 + WeakMap 也能做到真私有（# 出现之前的做法）
function makeCounter() {
  let n = 0;                          // 闭包变量，外部拿不到
  return { inc: () => ++n, get: () => n };
}
const f = makeCounter();
f.inc();
console.log(f.get(), Object.keys(f));   // 1 [ 'inc', 'get' ]

const priv = new WeakMap();           // WeakMap：外部拿不到 key
class Legacy {
  constructor() { priv.set(this, { n: 0 }); }
  inc() { return ++priv.get(this).n; }
}
const l = new Legacy();
l.inc();
console.log(l.inc(), Reflect.ownKeys(l).length);   // 2 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class Book
{
    public function __construct(
        public private(set) string $title,      // 读：public；写：private
        public protected(set) string $author,   // 读：public；写：protected
        protected private(set) int $pubYear,    // 读：protected；写：private
    ) {}
}

class SpecialBook extends Book
{
    public function update(string $author, int $year): void
    {
        $this->author = $author;   // ✅ 继承类可写 protected(set)
        $this->pubYear = $year;    // 🛑 Fatal Error：private(set) 属性是 final
    }
}

$b = new Book('How to PHP', 'Peter H. Peterson', 2024);
echo $b->title;              // ✅ Works
$b->title = 'How not to PHP';   // 🛑 Fatal Error

1
2
3
4
5
6
7
8
9

class Manager
{
    public private(set) static int $calls = 0;   // PHP 8.5：静态属性也支持非对称可见性
    public function doAThing(): string { self::$calls++; return "some string"; }
}
$m = new Manager();
$m->doAThing();
echo Manager::$calls;    // ✅ 1
Manager::$calls = 5;      // 🛑 Fatal error: Cannot modify private(set) property

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Account
  VERSION = "1.0"
  private_constant :VERSION   # 常量私有：Account::VERSION 会 NameError
  def initialize(owner, balance)
    @owner = owner            # 实例变量天生私有，没有可见性语法
    @balance = balance
  end
  attr_reader :balance        # 公开读方法（生成 def balance）
  def same_as?(other) = self <=> other   # ✅ 类内部调用 protected 方法
  protected
  def <=>(other) = balance <=> other.balance   # 类外显式调用会 NoMethodError
  private
  def secret = "pin"
  public
  def reveal = secret         # ✅ 类内部隐式 receiver 调用私有方法
end

a = Account.new("ada", 10)
b = Account.new("bob", 20)
a.balance                     # 10
a.same_as?(b)                 # -1
a.reveal                      # "pin"
a <=> b                       # 🛑 NoMethodError: protected method '<=>'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Account
  VERSION = "1.0"
  private_constant :VERSION
  def initialize(owner, balance)
    @owner = owner
    @balance = balance
  end
  attr_reader :balance
  private
  def secret = "pin"
end

a = Account.new("ada", 10)
a.secret                              # 🛑 NoMethodError: private method 'secret'
a.send(:secret)                        # "pin"   ⚠️ send 无视 private
a.instance_variable_get(:@balance)     # 10      ⚠️ 实例变量也能反射出来
Account::VERSION                       # 🛑 NameError: private constant
Account.const_get(:VERSION)            # "1.0"   反射照样能拿到

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Engine 模块内
public struct MainEngine {
    public init() {}
    public var stats: String { "ok" }
    package func run() {}          // 同 package 的其它模块可见（SE-0386）
    internal func helper() {}      // 仅 Engine 模块
    fileprivate func local() {}    // 仅本文件
}
// Game 模块（同一 package，构建时传相同的 -package-name）
// import Engine
// MainEngine().run()               // ✅ package
// MainEngine().helper()            // 🛑 internal 跨模块不可见

1
2
3
4

// 两种「内部」的差别
fileprivate struct Cache { }        // 只在本文件可见
private struct Impl { }             // 只在当前声明作用域（含同文件同类型的扩展）可见
package struct Shared { }           // 同 package 的其它模块可见（需 -package-name）

1
2
3
4
5
6
7
8

// 目录布局
// myapp/
//   main.go                  package main，可以 import myapp/internal/store
//   internal/store/store.go  package store，只能被 myapp 目录树内的包导入
//   other/lib/lib.go         package lib，位于 myapp 目录树之外
//
// other/lib 里写 import "myapp/internal/store" 会直接编译失败：
// use of internal package myapp/internal/store not allowed

1
2
3
4
5

// package store（位于 internal/store）
package store
type DB struct{ dsn string }          // 导出类型，但包本身只能是内部包
var defaultDB = &DB{}                 // 未导出变量
func Open(dsn string) *DB { return &DB{dsn: dsn} }   // 导出构造函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# mypkg/__init__.py
from ._impl import Client          # 把实现藏在 _impl 里，对外只暴露 Client
from ._impl import Client as _Client  # ⚠️ 下划线别名能避免 from mypkg import * 带出去

__all__ = ["Client"]               # 只影响 from mypkg import *
__version__ = "1.0"

# mypkg/_impl.py
class Client:
    def __init__(self) -> None:
        self._transport = object()   # 内部字段，约定私有

# 使用方
# from mypkg import Client         # ✅
# from mypkg import _impl          # ⚠️ 能 import，只是约定上不该
# import mypkg; mypkg._impl.Client # ⚠️ 一样能拿到

1
2
3

# mypkg/_impl.pyi（或 mypkg/__init__.pyi）只声明公共面
class Client:
    def __init__(self) -> None: ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// src/main/kotlin/shop/Account.kt
package shop
internal class Ledger {               // 模块内可见：别的 Gradle 模块看不到
    internal fun record() {}
}
private fun fileHelper() {}           // 顶层 private：本文件

// src/main/kotlin/shop/Report.kt（同一个 Gradle 模块）
package shop
fun build() { Ledger().record() }     // ✅ internal 跨文件可用，与 package 无关

1
2
3
4
5
6

class Repo {
    @PublishedApi internal fun raw() = 1     // 允许被 public inline 函数引用
    internal fun secret() = 2
    @JvmSynthetic fun kotlinOnly() = 3       // Java 调用者看不到
}
public inline fun use(r: Repo) = r.raw()     // ✅ 需要 @PublishedApi

1
2
3
4
5
6
7
8
9

// module-info.java
module shop.app {
    requires java.logging;
    exports shop.api;                                   // 编译期与运行期可见
    opens shop.model to com.example.orm;                 // 只对指定模块开放深反射
    uses shop.api.Plugin;
    provides shop.api.Plugin with shop.internal.MyPlugin;
}
// 没有 exports shop.internal; → 其它模块连 import 都不行

1
2
3
4
5
6
7

package shop.api;
public class Service {
    void packagePrivate() {}          // 同包可访问（含同包的测试类）
    protected void forSubclass() {}   // 同包 + 子类
    private void impl() {}
}
// src/test/java/shop/api/ServiceTest.java 里可以直接调 packagePrivate()

1
2
3
4
5
6
7
8

// shop.cppm（模块接口单元）
export module shop;
export int total(int a, int b) { return a + b; }   // 导出：import shop 后可用
int helper() { return 1; }                          // 未导出：模块外不可见，也不进入符号查找

// main.cpp
import shop;
int main() { return total(1, 2) + helper(); }       // 🛑 error: 'helper' was not declared

1
2
3
4
5
6

namespace shop {
    namespace { int private_helper() { return 1; } }   // 内部链接：本翻译单元
    int api() { return private_helper(); }
}
// 另一个 .cpp
// shop::private_helper();    // 🛑 链接错误（内部链接）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/* account.h —— 对外接口：只放不完整类型与函数声明 */
#ifndef ACCOUNT_H
#define ACCOUNT_H
typedef struct account account;        /* 不完整类型：调用方不知道字段 */
account *account_new(const char *owner, long balance);
long account_balance(const account *a);
void account_free(account *a);
#endif

/* account.c —— 实现：完整定义与内部函数都在这里 */
struct account { const char *owner; long balance; };
static long g_calls = 0;               /* 内部链接 */
static void bump(void) { g_calls++; }  /* 内部链接 */
account *account_new(const char *o, long b) { bump(); ... }

1
2

/* 头文件里放 static 变量的经典陷阱 */
static int counter = 0;      /* ⚠️ 每个包含它的 .c 各有一份副本，互不相干 */

1
2
3
4
5
6

module Shop
export Account, total            # using Shop 会把这些名字带进来
public rate                      # 1.11 起：标为公共 API，但不带入命名空间
include("account.jl")            # 在 Shop 的全局作用域里求值
include("report.jl")
end

1
2
3
4
5
6
7
8
9

module A
export f
f() = 1
end
module B
import ..A: f            # 只有 import 形式允许直接扩展
f(::Int) = 2             # ✅ 给 A.f 加方法
# 若写成 using ..A: f，则必须写 A.f(::Int) = 2
end

1
2
3
4
5
6
7
8

// Shop.csproj 里的程序集是一个 boundary
namespace Shop.Api;                     // namespace 本身无访问限制
public class Client { internal void Warm() {} }

// AssemblyInfo.cs —— 把 internal 面开放给测试程序集
[assembly: InternalsVisibleTo("Shop.Tests")]
// 强命名程序集需要写全公钥：
// [assembly: InternalsVisibleTo("Shop.Tests, PublicKey=0024000004800000...")]

1
2
3
4
5
6

// File1.cs
file class HiddenWidget { public int Work() => 42; }
// File2.cs
public class HiddenWidget { }              // ✅ 同名不冲突
// 另一个文件里：
// HiddenWidget w = new();                 // 解析到 File2.cs 的 public 版本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// shop.dart（库入口）
library shop;
part 'src/account.dart';
part 'src/report.dart';
export 'src/account.dart' show Account;    // 只导出 Account
export 'src/report.dart' hide InternalReport;

// src/account.dart
part of '../shop.dart';
class Account {
  int _balance = 0;                  // 在 shop 库的所有 part 里可见
  void _audit() {}
}
// src/report.dart
part of '../shop.dart';
void use(Account a) => a._balance += 1;   // ✅ 跨 part 访问私有

1
2
3
4

// 库的对外 API 面由 export/show/hide 决定
export 'src/impl.dart' show PublicApi, helpers hide InternalApi;
// package 里 src/ 目录的约定：外部不应 import package:foo/src/xxx.dart
// 违反时由 analyzer 的 implementation_imports lint 提示

1
2
3
4
5
6
7
8

# DESCRIPTION 与 NAMESPACE 决定包的接口
# NAMESPACE
export(Account)
export(total)
exportPattern("^[^\\.]")            # 导出全部不以 . 开头的名字
S3method(print, Account)
importFrom(stats, median)
importFrom(utils, head)

1
2
3
4
5
6
7
8

# R/zzz.R
.pkgenv <- new.env(parent = emptyenv())     # 包私有环境：内部状态的标准容器
.onLoad <- function(libname, pkgname) {
  .pkgenv$cache <- list()                   # 初始化
}
.onAttach <- function(libname, pkgname) {
  packageStartupMessage("mypkg loaded")
}

1
2
3
4
5
6

# tests/testthat/test-internal.R
test_that("internal rate is reachable", {
  expect_equal(mypkg:::.internal_rate(), 0.1)     # 直接取内部函数
  env <- asNamespace("mypkg")
  expect_true(is.function(get("total", envir = env)))
})

1
2
3
4
5
6
7
8

// src/shop/store.zig
const std = @import("std");
pub const Store = struct {
    items: std.ArrayList(u32),                 // 字段无可见性，外部可读写
    pub fn init(allocator: std.mem.Allocator) Store { ... }
    fn rehash(self: *Store) void { ... }       // 未加 pub：仅本文件可见
};
pub fn open() Store { ... }

1
2
3
4
5
6

// src/root.zig
pub const store = @import("shop/store.zig");    // 转发：外部可以 mylib.store.open()

// 别的包
const mylib = @import("mylib");
// mylib.store.rehash();                        // 🛑 私有函数

1
2
3
4
5
6
7
8

-- shop.lua
local M = {}                       -- 返回的 table 就是公开 API 面
local rate = 0.1                   -- 真私有：chunk 局部，外部拿不到

function M.total(n) return n * (1 + rate) end
function M.set_rate(r) rate = r end   -- 只能通过这个入口改

return M                           -- 只有 M 被暴露

1
2
3
4
5
6
7
8

-- factory.lua：返回工厂函数，避免模块级单例状态
return function(opts)
  local state = {}                  -- 每次调用一份，外部无法访问
  return {
    get = function(k) return state[k] end,
    set = function(k, v) state[k] = v end,
  }
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// package.json —— 决定外界能 import 到哪些路径（Node 的 exports 字段）
{
  "name": "shop",
  "type": "module",
  "exports": {
    ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
    "./utils": "./dist/utils.js"
  }
}
// 未列入 exports 的子路径一律不可导入：
// import x from "shop/src/internal.js"   // 🛑 ERR_PACKAGE_PATH_NOT_EXPORTED

1
2
3
4
5
6
7
8

// isolatedModules 下必须写清楚哪些是类型
export type { User } from "./types.js";        // ✅ 类型导出用 export type
export { Client } from "./client.js";          // ✅ 值导出
// export { User } from "./types.js";          // 🛑 isolatedModules 报错

// 声明合并 / 全局扩充：不是模块的文件才会影响全局
declare global { interface Window { appVersion: string } }
export {};                                      // 让本文件成为模块，declare global 才合法

1
2
3
4
5
6
7
8

// esm.mjs —— ESM：静态导入，模块作用域
export const API = "v1";              // 命名导出
export default function init() {}     // 默认导出
const internal = 1;                    // 未导出：模块外不可见（真不可见）

// cjs.cjs —— CJS：导出的对象就是对外面
const internal = 1;                    // 模块包装函数内，外部拿不到
module.exports = { api: "v1" };        // 只有这个对象暴露出去

1
2
3

// 全局与模块作用域的差别
var leaked = 1;          // 在 CJS 里是模块包装函数的局部变量，不泄漏到 global
globalThis.shared = 2;    // ✅ 显式挂到全局

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14