Function to call php script

PHP Functions

In this tutorial you will learn how to create your own custom functions in PHP.

PHP Built-in Functions

A function is a self-contained block of code that performs a specific task.

PHP has a huge collection of internal or built-in functions that you can call directly within your PHP scripts to perform a specific task, like gettype() , print_r() , var_dump , etc.

Please check out PHP reference section for a complete list of useful PHP built-in functions.

PHP User-Defined Functions

In addition to the built-in functions, PHP also allows you to define your own functions. It is a way to create reusable code packages that perform specific tasks and can be kept and maintained separately form main program. Here are some advantages of using functions:

• Functions reduces the repetition of code within a program — Function allows you to extract commonly used block of code into a single component. Now you can perform the same task by calling this function wherever you want within your script without having to copy and paste the same block of code again and again.
• Functions makes the code much easier to maintain — Since a function created once can be used many times, so any changes made inside a function automatically implemented at all the places without touching the several files.
• Functions makes it easier to eliminate the errors — When the program is subdivided into functions, if any error occur you know exactly what function causing the error and where to find it. Therefore, fixing errors becomes much easier.
• Functions can be reused in other application — Because a function is separated from the rest of the script, it’s easy to reuse the same function in other applications just by including the php file containing those functions.

The following section will show you how easily you can define your own function in PHP.

Creating and Invoking Functions

The basic syntax of creating a custom function can be give with:

The declaration of a user-defined function start with the word function , followed by the name of the function you want to create followed by parentheses i.e. () and finally place your function’s code between curly brackets <> .

This is a simple example of an user-defined function, that display today’s date:

Example

 // Calling function whatIsToday(); ?>

Note: A function name must start with a letter or underscore character not with a number, optionally followed by the more letters, numbers, or underscore characters. Function names are case-insensitive.

Functions with Parameters

You can specify parameters when you define your function to accept input values at run time. The parameters work like placeholder variables within a function; they’re replaced at run time by the values (known as argument) provided to the function at the time of invocation.

You can define as many parameters as you like. However for each parameter you specify, a corresponding argument needs to be passed to the function when it is called.

The getSum() function in following example takes two integer values as arguments, simply add them together and then display the result in the browser.

Example

 // Calling function getSum(10, 20); ?>

The output of the above code will be:

Tip: An argument is a value that you pass to a function, and a parameter is the variable within the function that receives the argument. However, in common usage these terms are interchangeable i.e. an argument is a parameter is an argument.

Functions with Optional Parameters and Default Values

You can also create functions with optional parameters — just insert the parameter name, followed by an equals ( = ) sign, followed by a default value, like this.

Example

em;\">Hello, world!
"; > // Calling function customFont("Arial", 2); customFont("Times", 3); customFont("Courier"); ?>

As you can see the third call to customFont() doesn’t include the second argument. This causes PHP engine to use the default value for the $size parameter which is 1.5.

Returning Values from a Function

A function can return a value back to the script that called the function using the return statement. The value may be of any type, including arrays and objects.

Example

 // Printing returned value echo getSum(5, 10); // Outputs: 15 ?>

A function can not return multiple values. However, you can obtain similar results by returning an array, as demonstrated in the following example.

Example

 // Assign variables as if they were an array list($dividend, $divisor, $quotient) = divideNumbers(10, 2); echo $dividend; // Outputs: 10 echo $divisor; // Outputs: 2 echo $quotient; // Outputs: 5 ?>

Passing Arguments to a Function by Reference

In PHP there are two ways you can pass arguments to a function: by value and by reference. By default, function arguments are passed by value so that if the value of the argument within the function is changed, it does not get affected outside of the function. However, to allow a function to modify its arguments, they must be passed by reference.

Passing an argument by reference is done by prepending an ampersand ( & ) to the argument name in the function definition, as shown in the example below:

Example

 $mynum = 5; echo $mynum; // Outputs: 5 selfMultiply($mynum); echo $mynum; // Outputs: 25 ?>

Understanding the Variable Scope

However, you can declare the variables anywhere in a PHP script. But, the location of the declaration determines the extent of a variable’s visibility within the PHP program i.e. where the variable can be used or accessed. This accessibility is known as variable scope.

By default, variables declared within a function are local and they cannot be viewed or manipulated from outside of that function, as demonstrated in the example below:

Example

 test(); // Outputs: Hello World! echo $greet; // Generate undefined variable error ?>

Similarly, if you try to access or import an outside variable inside the function, you’ll get an undefined variable error, as shown in the following example:

Example

 test(); // Generate undefined variable error echo $greet; // Outputs: Hello World! ?>

As you can see in the above examples the variable declared inside the function is not accessible from outside, likewise the variable declared outside of the function is not accessible inside of the function. This separation reduces the chances of variables within a function getting affected by the variables in the main program.

Tip: It is possible to reuse the same name for a variable in different functions, since local variables are only recognized by the function in which they are declared.

The global Keyword

There may be a situation when you need to import a variable from the main program into a function, or vice versa. In such cases, you can use the global keyword before the variables inside a function. This keyword turns the variable into a global variable, making it visible or accessible both inside and outside the function, as show in the example below:

Example

 test(); // Outpus: Hello World! echo $greet; // Outpus: Hello World! // Assign a new value to variable $greet = "Goodbye"; test(); // Outputs: Goodbye echo $greet; // Outputs: Goodbye ?>

You will learn more about visibility and access control in PHP classes and objects chapter.

Creating Recursive Functions

A recursive function is a function that calls itself again and again until a condition is satisfied. Recursive functions are often used to solve complex mathematical calculations, or to process deeply nested structures e.g., printing all the elements of a deeply nested array.

The following example demonstrates how a recursive function works.

Example

 /* Loop through array, if value is itself an array recursively call the function else add the value found to the output items array, and increment counter by 1 for each value found */ foreach($arr as $a) < if(is_array($a))< printValues($a); >else < $items[] = $a; $count++; >> // Return total count and values found in array return array('total' => $count, 'values' => $items); > // Define nested array $species = array( "birds" => array( "Eagle", "Parrot", "Swan" ), "mammals" => array( "Human", "cat" => array( "Lion", "Tiger", "Jaguar" ), "Elephant", "Monkey" ), "reptiles" => array( "snake" => array( "Cobra" => array( "King Cobra", "Egyptian cobra" ), "Viper", "Anaconda" ), "Crocodile", "Dinosaur" => array( "T-rex", "Alamosaurus" ) ) ); // Count and print values in nested array $result = printValues($species); echo $result['total'] . ' value(s) found: '; echo implode(', ', $result['values']); ?>

Note: Be careful while creating recursive functions, because if code is written improperly it may result in an infinite loop of function calling.

Источник

How to call PHP function from JavaScript tutorial

If you’re using PHP files to render your web pages, then you can call the PHP function from JavaScript by calling the PHP echo() function.

Suppose you have an index.php file with the following content:

Then, you write your HTML content right below the function as follows:

 You can include a tag inside the tag that calls on PHP function as follows:

 When you open your index.php file from the browser, you will see the HTML rendered as follows:

Any PHP code that you include inside your HTML page will be processed on the server-side before being served to the browser.

When you call a PHP function inline from JavaScript as shown above, you can’t use dynamic values from user input.

If you want to call PHP function as a response to user action, then you need to send HTTP request from JavaScript to the PHP file. Let’s learn that next.

Call PHP function from JavaScript over HTTP request

• separate your PHP file from your HTML file
• Call the PHP function over an HTTP request using fetch() JavaScript method

First, separate your PHP function in a different file. Let’s call the file add.php and put the following content inside it:

Next, create an index.html file in the same folder where you created the add.php file and put the following content inside it:

The fetch() method will be executed each time the element is clicked. JavaScript will send a POST request to the PHP server and write the response inside the element.

In the code above, I used the full URL of my add.php , which is located at http://localhost:8000/add.php . You need to change the address to your actual PHP file location.

Once your files are ready, open the index.html file from the browser. Please make sure that you’re opening the HTML file from the same server that serve your PHP files to avoid CORS issues.

You can run a local PHP server using php -s localhost:8000 command and open localhost:8000/index.html from the browser to see your HTML page.

When you click on the button, the fetch() method will be executed and JavaScript will put the response inside the element.

The resulting HTML would be as follows:

 Now that your code is working, you can add elements to the HTML page and assign the values that the user puts in those elements to x and y variables. The PHP function should be able to add the dynamic values correctly

And those are the two ways you can call PHP function from JavaScript. More often, you’d want to separate the PHP files from your JavaScript files and call PHP function using HTTP requests.

The same pattern also works when you’re developing web app using modern PHP framework like Laravel and modern JavaScript libraries like React and Vue.

You can use the fetch() method and send a POST request to the right Laravel API route that you created and send the right parameters.

Learn JavaScript for Beginners 🔥

Get the JS Basics Handbook, understand how JavaScript works and be a confident software developer.

A practical and fun way to learn JavaScript and build an application using Node.js.

About

Hello! This website is dedicated to help you learn tech and data science skills with its step-by-step, beginner-friendly tutorials.
Learn statistics, JavaScript and other programming languages using clear examples written for people.

Search

Type the keyword below and hit enter

Tags

Click to see all tutorials tagged with:

Источник