This package implements support for executing PHP scripts, exporting Go variables for use in PHP contexts, attaching Go method receivers as PHP classes and returning PHP variables for use in Go contexts.
Both PHP 5.x and PHP 7.x series are supported.
Building this package requires that you have PHP installed as a library. For most Linux systems, this can usually be found in the php-embed
package, or variations thereof.
Once the PHP library is available, the bindings can be compiled with go build
and are go get
-able.
Note: Building against PHP 7 currently requires that the php7
tag is provided, i.e.:
go get -tags php7 github.com/deuill/go-php
This restriction might change in the future, in which case building against PHP 7 will be made the default and building against PHP 5 will require a php5
tag.
Executing PHP script files as well as inline strings is supported and stable.
Binding Go values as PHP variables is allowed for most base types, and PHP values returned from eval'd strings can be converted and used in Go contexts as interface{}
values.
It is possible to attach Go method receivers as PHP classes, with full support for calling expored methods, as well as getting and setting embedded fields (for struct
-type method receivers).
Be aware that, by default, PHP is not designed to be used in multithreaded environments (which severely restricts the use of these bindings with Goroutines) if not built with ZTS support. However, ZTS support has been removed from PHP 7, and as such is unsupported by this package (even for PHP 5 targets).
Currently, it is recommended to either sync use of seperate Contexts between Goroutines, or share a single Context among all running Goroutines.
Executing a script is very simple:
package main
import (
php "github.com/deuill/go-php"
"os"
)
func main() {
engine, _ := php.New()
context, _ := engine.NewContext()
context.Output = os.Stdout
context.Exec("index.php")
engine.Destroy()
}
The above will execute script file index.php
located in the current folder and will write any output to the io.Writer
assigned to Context.Output
(in this case, the standard output).
The following example demonstrates binding a Go variable to the running PHP context, and returning a PHP variable for use in Go:
package main
import (
"fmt"
php "github.com/deuill/go-php"
)
func main() {
engine, _ := php.New()
context, _ := engine.NewContext()
var str string = "Hello"
context.Bind("var", str)
val, _ := context.Eval("return $var.' World';")
fmt.Printf("%s", val.Interface())
// Prints 'Hello World' back to the user.
engine.Destroy()
}
A string value "Hello" is attached using Context.Bind
under a name var
(available in PHP as $var
). A script is executed inline using Context.Eval
, combinding the attached value with a PHP string and returning it to the user.
Finally, the value is returned as an interface{}
using Value.Interface()
(one could also use Value.String()
, though the both are equivalent in this case).
All code in this repository is covered by the terms of the MIT License, the full text of which can be found in the LICENSE file.