require、loadfile、dofile、load、loadstring

1.loadfile Compile only , Not running
loadfile(filename, mode, env) Used to load a specified path filename Code block for , The parameters are as follows ：

Basic and load equivalent , The difference is the code block used to load a file , See below ：

LuaFunc.lua（ To be accessed ） file ：

--LuaFunc.lua
function add(x, y)
    return x + y
end
 
m = "LuaFunc.m"
local n = "n"
 
print("------------------ < LuaFunc.lua > ------------------")
print("m = "..m)
print("n = "..n)
print("------------------ < LuaFunc.lua > ------------------")

The calling code is as follows ：

-- Load and compile code 
f = assert(loadfile("Child/LuaFunc.lua"))
-- function 
f()
print("add : "..add(100, 88))
print(m)

The output is as follows ：

------------------ < LuaFunc.lua > ------------------
m = LuaFunc.m
n = n
------------------ < LuaFunc.lua > ------------------
add : 188
LuaFunc.m

• loadfile： Compile only , Not running , It only loads files , Compile code , Will not run the code in the file ,loadfile Only... Will be loaded (load)lua File but will not execute (run). such as , We have a hellofile.lua file ：

print(“hello”);

function hehe()

print(“hello”);

end

There is a code in this file , And a function . Try it out loadfile Load this file , The following code ：

loadfile("hellofile.lua");

print("end");

The output is as follows ：

end

if loadfile If you can execute the code in the file , that , It should output hello A string of . It turns out that , It will not execute code .

2.dofile perform
dofile(filename) Used to load a specified path filename Code block for , And run . The parameters are as follows ：

Internal call first loadfile, Then it will run automatically , See below ：

dofile("Child/LuaFunc.lua")
print("add : "..add(100, 88))
print(m)

The output is the same as the above example .

• perform dofile Is to execute code ,dofile And require similar , But it didn't caching Files that have been executed once , So it can be repeated many times . Obviously ,dofile Is the guy who can execute code , The following code ：

dofile("D:/vscode lua Code /hello world/foo.lua");


print("end");

The output is as follows ：

hello
end

3.require I only do it once
require(modname) Used to load a specified code block , And run . The parameters are as follows ：

This function will only be loaded once for the same code block （ It will be saved after loading ）, and dofile similar , It will also run automatically after loading and compiling , See below ：

-- Load compile and run 
require("Child/LuaFunc") --  Equate to ：require("Child.LuaFunc")
print("add : "..add(100, 88))
print(m)

The output is the same as the above example .

• require and dofile It's kind of like , But it's very different ,require When loading the file for the first time , Will execute the code inside . however , After the second time , Load the file again , Will not be repeated . let me put it another way , It will save the loaded file , Does not load repeatedly .require The return value of will be stored cache get up , So a file can only be executed once at most , Even if require Many times .

for i = 1, 2, 1 do
   require("foo.lua");
end
   
print("end");

To illustrate this situation , I deliberately called twice require, The output is as follows ：

hello
end

As we said , Called twice , But the code only executes once . If you change here to dofile, Will output twice hello character string .

4.load Used to load string code blocks
Same as loadstring,5.2 After the version loadstring Removed , use load Instead of ,load(chunk, chunkname, mode, env) Used to load string code blocks , The parameters are as follows ：

Pay attention here ：load Used to load string code blocks and compile , But it didn't run . Remember to run it before using , See below ：

a = 100
-- Load string code block 
f = assert(load("a = a + 100"))
print("before a = "..a)
-- Run code block 
f()
print("after a = "..a)

The output is as follows ：

before a = 100
after  a = 200

You can see that after loading the code block , Before running ,a The value of does not change to 100, Executed after running a = a + 100,a = 200.

5. Code block chuck How to understand
lua Code block in chunk, When actually compiling , It is equivalent to being wrapped by a variable parameter anonymous function , And will bind a unique upvalue value _ENV, After running, the code block chunk Global variables in are added to Global environment variable _ENV in . Code block “a = a + 100” Equivalent to the following function ：

-- Code block 
function chuck()
    a = a + 100
end
-- This sentence is a metaphor load The loading and compiling process of code blocks （ Not necessarily appropriate , Just think about it ）
f = chuck()
-- function 
f()

There may be some doubts here ,load Why can this code block in access external variables a？

env： It is an environment variable , You can customize （ It is generally used to simulate a sandbox environment ）, The default value will be lua The global environment variable of _ENV fill .

_ENV yes lua5.2 Version is used to replace _G A global variable of （_ENV Inside, it points to _G Of , You can simply think that they are the same thing ）, But it's a upvalue value .（_G And _ENV Those who are interested can learn by themselves ） Here is a brief description of _ENV, every last lua Code blocks have one by default _ENV Global environment variable , It's a watch , It contains all of lua Standard class libraries and all compiled global variables .

a = 100
-- Load and run the string code block 
assert(load("a = a + 11; b = 'b126'; print('this is chunk')"))()
print("a = "..a)
print("_ENV.a = ".._ENV.a)
print("b = "..b)
print("_ENV.b = ".._ENV.b)

Output is as follows :

this is chunk
a = 111
_ENV.a = 111
b = b126
_ENV.b = b126

You can see :

1. Block of code , You can call print function , This is because the default env What's coming in is _ENV, Equivalent to calling _ENV.print.

2. a and _ENV.a Same output , In fact, when compiling , Global variables are preceded by _ENV. limit .

3. Compile and run code blocks chunk after , Variable b Has been added to _ENV in .

Custom environment variables env Use ： It is generally used to simulate a sandbox environment , See below ：

a = 100
-- Custom environment variables 
local env = {
    
    a = 8,
    print = print
}
-- Load and run the string code block 
assert(load("a = a + 10; print('this is chunk, a = '..a)", "chunkTest", "bt", env))()
print("a = "..a)

Output is as follows :

this is chunk, a = 18
a = 100

1. You can see the code block chunkTest in ,a Take the custom environment variable env Of a value , Print a = 18;

2. Because there is no default global environment variable _ENV fill , So external variables a It hasn't been modified ： a = 100

3. env Medium print = print, Equivalent to ：print = _ENV.print.