Werfen wir einen Blick auf die detaillierte Erklärung und Beispiele für Golang-Aufrufe von PHP7

PHP-Datei ausführen

func Test_exec(t *testing.T) {
  engine.Initialize()
  ctx := &engine.Context{
    Output: os.Stdout,
  }
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  err = ctx.Exec("/tmp/index.php")
  if err != nil {
    fmt.Println(err)
  }
}

Der Inhalt von /tmp/index.php ist

<?php
echo("hello\n");

Eval, Rückgabewert

func Test_eval(t *testing.T) {
  engine.Initialize()
  ctx := &engine.Context{}
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  val, err := ctx.Eval("return 'hello';")
  if err != nil {
    fmt.Println(err)
  }
  defer engine.DestroyValue(val)
  if engine.ToString(val) != "hello" {
    t.FailNow()
  }
}

Der Lebenszyklus-Eigentümer des zurückgegebenen Werts ist das Golang-Programm, daher sind wir für DestroyValue verantwortlich

Einrichten globaler Variablen zur Übergabe von Parametern

func Test_argument(t *testing.T) {
  engine.Initialize()
  ctx := &engine.Context{}
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  err = ctx.Bind("greeting", "hello")
  if err != nil {
    fmt.Println(err)
  }
  val, err := ctx.Eval("return $greeting;")
  if err != nil {
    fmt.Println(err)
  }
  defer engine.DestroyValue(val)
  if engine.ToString(val) != "hello" {
    t.FailNow()
  }
}

Der Lebenszyklus der übergebenen Parameter wird von PHP gesteuert und der Speicher wird freigegeben, wenn die Anforderung beendet wird.

PHP-Rückruf Golang

type greetingProvider struct {
  greeting string
}

func (provider *greetingProvider) GetGreeting() string {
  return provider.greeting
}

func newGreetingProvider(args []interface{}) interface{} {
  return &greetingProvider{
    greeting: args[0].(string),
  }
}

func Test_callback(t *testing.T) {
  engine.Initialize()
  ctx := &engine.Context{}
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  err = engine.Define("GreetingProvider", newGreetingProvider)
  if err != nil {
    fmt.Println(err)
  }
  val, err := ctx.Eval(`
  $greetingProvider = new GreetingProvider('hello');
  return $greetingProvider->GetGreeting();`)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.DestroyValue(val)
  if engine.ToString(val) != "hello" {
    t.FailNow()
  }
}

PHP-Fehlerprotokoll

func Test_log(t *testing.T) {
  engine.PHP_INI_PATH_OVERRIDE = "/tmp/php.ini"
  engine.Initialize()
  ctx := &engine.Context{
    Log: os.Stderr,
  }
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  _, err = ctx.Eval("error_log('hello', 4); trigger_error('sent from golang', E_USER_ERROR);")
  if err != nil {
    fmt.Println(err)
  }
}

Der Inhalt von /tmp/php.ini ist

error_reporting = E_ALL
error_log = "/tmp/php-error.log"

Fehler werden nach /tmp/php-error.log ausgegeben. Beim direkten Aufruf von error_log wird auch eine weitere Kopie an stderr ausgegeben

HTTP-Eingabe und -Ausgabe

func Test_http(t *testing.T) {
  engine.Initialize()
  recorder := httptest.NewRecorder()
  ctx := &engine.Context{
    Request: httptest.NewRequest("GET", "/hello", nil),
    ResponseWriter: recorder,
  }
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  _, err = ctx.Eval("echo($_SERVER['REQUEST_URI']);")
  if err != nil {
    fmt.Println(err)
  }
  body, err := ioutil.ReadAll(recorder.Result().Body)
  if err != nil {
    fmt.Println(err)
  }
  if string(body) != "/hello" {
    t.FailNow()
  }
}

Alle superglobalen PHP-Variablen werden mit dem Wert der übergebenen Anforderung initialisiert. Einschließlich des Inhalts von

$_SERVER
$_GET
$_POST
$_FILE
$_COOKIE
$_ENV

echo werden HTTP-Code und http-Header an den eingehenden ResponseWriter zurückgeschrieben

fastcgi_finish_request

PHP- Eine sehr häufig verwendete Funktion von FPM ist fastcgi_finish_request, mit der einige asynchrone Dinge in PHP ausgeführt werden. Diese spezielle globale Funktion muss

func Test_fastcgi_finish_reqeust(t *testing.T) {
  engine.Initialize()
  buffer := &bytes.Buffer{}
  ctx := &engine.Context{
    Output: buffer,
  }
  err := engine.RequestStartup(ctx)
  if err != nil {
    fmt.Println(err)
  }
  defer engine.RequestShutdown(ctx)
  ctx.Eval("ob_start(); echo ('hello');")
  if buffer.String() != "" {
    t.FailNow()
  }
  ctx.Eval("fastcgi_finish_request();")
  if buffer.String() != "hello" {
    t.FailNow()
  }
}

unterstützen. Ihre eigentliche Funktion besteht darin, die Ausgabe im Voraus an ResposneWriter auszugeben, um den Aufrufer über das Ergebnis zu informieren. Es hat eigentlich keinen Einfluss auf die Ausführung des aktuellen Prozesses, sondern nur auf die Ausgabe.

Verwandte Lernempfehlungen: PHP7-Tutorial

Das obige ist der detaillierte Inhalt vonWerfen wir einen Blick auf die detaillierte Erklärung und Beispiele für Golang-Aufrufe von PHP7. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!