模块系统 #

module MyModule

export greet, add

greet(name) = println("Hello, $name!")
add(a, b) = a + b

_internal(x) = x * 2

end

using .MyModule

greet("Julia")
add(1, 2)

import .MyModule: greet, add

greet("Julia")
add(1, 2)

module Shapes

export Circle, Rectangle, area

struct Circle
    radius::Float64
end

struct Rectangle
    width::Float64
    height::Float64
end

area(c::Circle) = π * c.radius^2
area(r::Rectangle) = r.width * r.height

end

using .Shapes

c = Circle(5.0)
area(c)

import .Shapes: Circle, area

c = Circle(5.0)
area(c)

c = Shapes.Circle(5.0)
Shapes.area(c)

module Outer

export outer_func

outer_func() = println("Outer function")

module Inner

export inner_func

inner_func() = println("Inner function")

end

end

using .Outer
using .Outer.Inner

outer_func()
inner_func()

using LinearAlgebra
using Statistics
using Random
using Printf
using Dates
using DelimitedFiles
using Serialization

using LinearAlgebra

A = [1 2; 3 4]
det(A)
inv(A)
eigvals(A)

using Statistics

data = [1, 2, 3, 4, 5]
mean(data)
std(data)
median(data)

using Random

Random.seed!(42)
rand(5)
randn(5)
shuffle([1, 2, 3, 4, 5])

using Printf

@printf("Integer: %d\n", 42)
@printf("Float: %.2f\n", 3.14159)
@printf("String: %s\n", "Julia")

using Dates

now()
today()
Date(2024, 1, 1)
DateTime("2024-01-01T12:00:00")

module MyPackage

using PackageA
using PackageB

import Base: show

export public_func, PublicType

const CONSTANT = 100

struct PublicType
    field::Int
end

function public_func(x)
    _private_helper(x)
end

function _private_helper(x)
    x * 2
end

end

module MyModule

using StandardLibrary
using ThirdPartyPackage

import Base: show

export public_api

end

module MyModule

import Base: show

show(io::IO, x::MyType) = ...

end

module MathTools

export fibonacci, is_prime, factorial

fibonacci(n::Int) = n <= 1 ? n : fibonacci(n-1) + fibonacci(n-2)

function is_prime(n::Int)
    n < 2 && return false
    for i in 2:isqrt(n)
        n % i == 0 && return false
    end
    return true
end

function factorial(n::Int)
    n < 0 && error("n must be non-negative")
    n <= 1 ? 1 : n * factorial(n - 1)
end

end

using .MathTools

fibonacci(10)
is_prime(17)
factorial(5)

module StringUtils

export reverse_words, word_count, is_palindrome

function reverse_words(s::String)
    join(reverse(split(s)), " ")
end

function word_count(s::String)
    length(split(s))
end

function is_palindrome(s::String)
    cleaned = lowercase(replace(s, r"\W" => ""))
    cleaned == reverse(cleaned)
end

end

using .StringUtils

reverse_words("Hello World")
word_count("Hello World Julia")
is_palindrome("A man, a plan, a canal: Panama")

module Config

export get_config, set_config!, load_config!

const _config = Dict{Symbol, Any}()

function get_config(key::Symbol, default=nothing)
    get(_config, key, default)
end

function set_config!(key::Symbol, value)
    _config[key] = value
end

function load_config!(dict::Dict)
    merge!(_config, dict)
end

function list_config()
    copy(_config)
end

end

using .Config

set_config!(:host, "localhost")
set_config!(:port, 8080)
get_config(:host)
list_config()