原文：StudyTonight
PHP 字符串
就像任何其他编程语言一样，Php 中的字符串也是字母数字字符的集合，对于简单的字符串数据用单引号括起来，对于复杂的字符串数据用双引号括起来。
创建 PHP 5 字符串
有许多不同的方法可以在 Php 中创建字符串。让我们从最简单的方法开始，
<?php
$srt1 = "This is a String";
$str2 = 'This is also a String';
?>
我们可以使用双引号和单引号来定义字符串。
但是，如果字符串中有单引号或双引号，那会怎样？
<?php
$srt1 = "This is "a" String";
$str2 = 'This is also 'a' String';
?>
以上两种字符串定义都会导致错误，因为如果字符串是在双引号内定义的，我们不能在字符串中包含双引号。
但是如果字符串包含双引号，但是它是使用单引号定义的，反之亦然，例如，
<?php
// string inside double quotes, with a single quote
$srt1 = "This is 'a' String";
// string inside single quotes, with a double quote
$str2 = 'This is also "a" String';
?>
还有一个更简单的技巧来处理引号问题，它被称为转义特殊字符，这可以使用反斜杠来完成。
让我们举个例子，
<?php
// escaping double quote using backslash
$srt1 = "I\"ll handle this.";
// escaping single quote using backslash
$str2 = 'I\'ll handle this.';
echo $str1;
echo "\n"; // new line
echo $str2;
?>
我会处理的。我来处理。
从上面的例子可以明显看出，在 PHP 5 中声明和定义一个字符串变量非常简单。只是要小心引号和其他一些特殊字符，如$。我们也举一个$特殊字符的例子。
<?php
// string with $
$srt1 = "pas$word";
echo $str1;
?>
注意:未定义的变量传递
运行上面的代码，将显示只有在$符号之前的字符串部分将被存储在变量中，而$word被视为变量，没有被赋予任何值，因此，PHP 打印了一个NOTICE。现在让我们试着用反斜杠来转义它，
<?php
// string with escaped $
$srt1 = "pas\$word";
echo $str1;
?>
传递$word
使用此文档方法创建字符串
如果我们想定义一个多行字符串，使用这里的doc语法是最好也是最简单的技术。
使用这种方法，我们可以创建多行字符串，而不需要字符串连接。
此外，如果我们使用这里的文档方法来定义字符串，则不需要转义双引号或单引号。
让我们举个例子:
<?php
$str = <<< EOT
Take a right from the T point,
and the go straight to fins the "Shop"
EOT;
echo $str;
?>
从 T 点向右拐，然后一直走到“商店”
这里 EOT 只是文本结尾的同义词，没有任何意义。这 3 个字符只是用来标记多行字符串的开始和结束。
你可以使用 EOF 或者也许 SQL 如果你用这个来定义你的多行 SQL 查询，比如，
<?php
$tablename = "products";
$str = <<< SQL
Select * from $tablename
Where product_name = "widgets"
SQL;
echo $str;
?>
从产品中选择*产品名称=“小部件”
使用 Nowdoc 方法创建字符串
创建字符串的 Nowdoc 方法类似于赫里多克方法，只有一个区别，那就是字符串没有被解析，因此如果我们想使用其他变量`，就像我们在上面的 SQL 查询字符串中所做的那样，给我们的字符串添加一个值，我们不能用 Nowdoc 来做。
让我们举个例子，
<?php
$hername = "Selena";
$str = <<< 'LOV'
This is my declaration of love,
for $hername
LOV;
echo $str;
?>
这是我的爱情宣言，价值 100 美元
字符串中的变量不会被转换为其值。
打印字符串变量
打印字符串变量很简单，我们举两个例子，第一个例子中我们只使用echo方法打印字符串变量，第二个例子中，我们将在echo方法中附加一个字符串变量和一些其他文本，用单引号和双引号括起来。
<?php
$hername = "Selena";
// only the string variable
echo $hername;
// for new line
echo "\n";
// string variable with text and single quote
echo '$hername, I love you!';
echo "\n";
// string variable with text and double quote
echo "$hername, I love you!";
?>
赛琳娜，我爱你！赛琳娜，我爱你！
看到区别了吗，单引号不会解析它里面的文本，因此变量不会被翻译成它的值，而在双引号的情况下，它会。
PHP 字符串函数
在上一个教程中，我们已经介绍了什么是字符串以及如何创建它们，现在让我们深入研究字符串，了解 PHP 中用于字符串处理的内置函数。
一般来说，使用正确的字符串函数会节省很多时间，因为它们是在 PHP 库中预定义的，您所要做的就是调用它们来使用它们。
常用的 PHP 5 字符串函数
下面我们列出了 PHP 中一些常用的字符串函数:
strlen($str)
此函数返回字符串的长度或字符串中的字符数，包括空格。
<?php
$str = "Welcome to Studytonight";
// using strlen in echo method
echo "Length of the string is: ". strlen($str);
?>
字符串的长度为:23
str_word_count($str)
此函数返回字符串中的字数。对于一些简单的验证，这个函数在表单域验证中很容易实现。
<?php
$str = "Welcome to Studytonight";
// using str_word_count in echo method
echo "Number of words in the string are: ". str_word_count($str);
?>
字符串中的字数是:3
strrev($str)
此函数用于反转字符串。
让我们举个例子看看，
<?php
$str = "Welcome to Studytonight";
// using strrev in echo method
echo "Reverse: ". strrev($str);
?>
反向:thginotyduts ot emoclew
strpos($str, $text)
该函数用于查找给定字符串中任何文本/单词的位置。就像数组一样，字符串也从零开始为存储在其中的字符分配索引值。
<?php
$str = "Welcome to Studytonight";
// using strpos in echo method
echo "Position of 'Studytonight' in string: ". strpos($str, 'Studytonight');
?>
“今晚学习”在字符串中的位置:11
str_replace($replacethis, $replacewith, $str)
此函数用于用一些文本替换字符串的一部分。使用此函数时，第一个参数是要替换的字符串部分，第二个参数是要包含的新文本，最后一个参数是字符串变量本身。
让我们举个例子，
<?php
$str = str_replace("Studytonight", "Studytonight.com", "Welcome to Studytonight");
echo $str;
?>
欢迎来到 Studytonight.com
ucwords($str)
该函数用于格式化字符串。该函数将字符串中每个单词的第一个字母/字符转换为大写。
让我们举个例子看看，
<?php
$str = "welcome to studytonight";
echo ucwords($str);
?>
欢迎今晚来学习
strtoupper($str)
要将字符串中每个单词的每个字母/字符转换为大写，可以使用strtoupper()方法。
<?php
$str = "welcome to studytonight";
echo strtoupper($str);
?>
欢迎今晚来学习
strtolower($str)
该函数用于将字符串的每个字母/字符转换为小写。
<?php
$str = "WELCOME TO STUDYTONIGHT";
echo strtolower($str);
?>
欢迎今晚来学习
str_repeat($str, $counter)
该函数用于将字符串重复给定的次数。第一个参数是字符串，第二个参数是字符串应该重复的次数。
<?php
$str = "Studytonight";
echo str_repeat($str, 4);
?>
今晚学习
strcmp($str1, $str2)
该函数用于比较两个字符串。比较是按字母顺序进行的。如果第一个字符串大于第二个字符串，结果将大于0，如果第一个字符串等于第二个字符串，结果将等于0，如果第二个字符串大于第一个字符串，则结果将小于0。
<?php
$str1 = "Studytonight";
$str2 = "Studytonight.com";
// comparing str1 and str2
echo strcmp($str1, $str2);
// comparing str2 and str1
echo strcmp($str2, $str1);
// comparing str1 with str1
echo strcmp($str1, $str1);
?>
-4 4 0
substr($str, $start, $length)
该函数用于从特定位置开始，取出特定长度的字符串(子字符串)的一部分。
第一个参数是字符串本身，第二个参数是要提取的子字符串的起始索引，第三个参数是要提取的子字符串的长度。
<?php
$str = "Welcome to Studytonight";
echo substr($str, 11, 12);
?>
今晚学习
trim($str, charlist)
此函数用于从字符串的开头和结尾移除多余的空格。第二个参数charlist是可选的。我们可以提供一个字符列表，就像字符串一样，作为第二个参数，从主字符串中删除这些字符。
<?php
$str1 = " Hello World ";
echo trim($str1) . "<br/>";
$str2 = "Hello Hello";
echo trim($str2,"Heo");
?>
你好，地狱世界
正如您在输出中看到的，从开始和结束的额外空格被删除，在第二种情况下，指定的字符从字符串的开始和结束被删除。
explode(separator, $str, $limit)
此函数用于断开字符串，创建字符串断开部分的数组并返回数组。第一个参数分隔符定义了从哪里断开字符串。它可以是空格、hiphen(-)或任何其他字符。
这个函数的第二个参数是字符串本身，第三个参数是限制，指定要返回的数组元素个数。第三个参数是可选的。
举个例子，
<?php
$str = "Its a beautiful day";
// we can directly print the result of explode
print_r(explode(" ", $str));
?>
数组([0] = >它的[1] = >一个[2] = >美丽的[3] = >天)
在上面的例子中，我们提供了空间作为分隔符来断开字符串并返回一个数组。
如果我们也提供第三个参数限制，我们可以限制返回的数组元素的数量。例如，如果我们提供2作为第三个参数，那么我们将只得到数组中的 2 个元素，前两个。
implode(separator, $arr)
该函数用于使用提供的数组中的数组元素组成字符串，并使用分隔符连接它们。
让我们举个例子，
<?php
$arr = array("Its", "a", "beautiful", "day");
// <br> is used to jump to next line
echo implode(" ", $arr) . "<br>";
echo implode("-", $arr) . "<br>";
echo implode("/", $arr) . "<br>";
?>
这是美好的一天，这是美好的一天
nl2br($str)
该功能用于将换行符或\n改为换行符的 HTML 标签，即<br>。
这个函数对于格式化字符串数据以在 HTML 页面上显示非常有用，因为当提交多行表单数据时，它的 strnig 中包含了\n用于换行符，但是当您在 HTML 页面上显示它时，换行符不会被渲染，因为 HTML 不理解\n。
<?php
echo nl2br("Its a\nbeautiful day");
?>
天气真好
PHP 表单处理
当我们开发一个网站或者一个网络应用程序时，我们经常需要创建一些表格来接受用户的输入，比如登录表格或者注册表格。
在网页上创建表单是使用 HTML 来完成的，而 PHP 则是将这些值从网页传输到服务器，然后进一步处理这些值。
PHP 提供了两个超级全局 $_GET和$_POST来收集表单数据进行处理。
理解 HTML 表单的工作原理
让我们创建一个简单的 HTML 表单，并尝试理解它是如何工作的，在<form>标签中有哪些不同的可用属性，以及它们用于什么。
<html>
<body>
<form action="form-handler.php" method="POST">
Name: <input type="text" name="name"> <br/>
Email: <input type="text" name="email"> <br/>
<input type="submit">
</form>
</body>
</html>
在上面的代码中，我们使用了<form>标签来创建一个 HTML 表单，在表单数据的提交按钮上有名称和电子邮件的输入字段。
在<form>标签中，我们有两个属性，action和method，你知道它们是干什么的吗？
action:使用这个属性，我们可以指定将要收集和处理表单数据的文件名。在上面的例子中，我们提供了一个 Php 文件的名称。method:该属性指定发送表单数据的方式，是通过 POST 方式还是 GET 方式提交。
下面我们用method和一样的形式得到，
<html>
<body>
<form action="form-handler.php" method="GET">
Name: <input type="text" name="name"> <br/>
Email: <input type="text" name="email"> <br/>
<input type="submit">
</form>
</body>
</html>
用开机自检处理 PHP 表单
如果我们将表单方法指定为 POST ，那么表单数据将使用 HTTP POST 方法发送到服务器。
下面，我们有代码，访问在我们的 HTML 表单的action属性中指定的 Php 文件中的表单数据。
<?php
// getting the value of name field
$name = $_POST["name"];
// getting the value of the email field
$email = $_POST["email"];
echo "Hi, ". $name . "<br>";
echo "Your email address: ". $email ."<br>";
?>
嗨，今晚学习你的电子邮件地址:[email protected]
如果您提供的姓名为“Studytonight”，电子邮件地址为“we @ studytonight.com”，您将获得上述输出。
用 GET 处理 PHP 表单
如果我们将表单方法指定为 GET ，那么表单数据将使用 HTTP GET 方法发送到服务器。
下面，我们有代码，访问在我们的 HTML 表单的action属性中指定的 Php 文件中的表单数据，这次使用 GET superglobal。
<?php
// getting the value of name field
$name = $_GET["name"];
// getting the value of the email field
$email = $_GET["email"];
echo "Hi, ". $name . "<br>";
echo "Your email address: ". $email ."<br>";
?>
嗨，今晚学习你的电子邮件地址:[email protected]
同样，输出保持不变。
处理表单数据的第一步是使用 POST 或 GET superglobals 获取数据，一旦你有了数据，你可以对它做任何事情，在你的网页上显示它，将数据保存到数据库，执行验证等。
获取与发布:何时使用什么！
现在，你一定想知道，我们应该用哪一个。好吧，GET 和 POST 都用于相同的目的，但是它们的工作方式不同。
当用户提交表单时，输入字段中的值存储在一个数组中，如array(key1=>value1, key2=>value2,...)，然后传递到<form>标签的action属性中指定的目标(Php 文件)。
使用 GET 方法
在 GET 方法的情况下，表单数据作为 URL 参数提交，即用户在表单字段中输入的所有值都被发送到动作脚本，并附加在 URL 中。
让我们举一个简单的例子来理解，下面我们有一个简单的 HTML 表单，
<html>
<body>
<form action="form-handler.php" method="GET">
Name: <input type="text" name="name"> <br/>
Age: <input type="text" name="age"> <br/>
<input type="submit">
</form>
</body>
</html>
上表我们有两个输入字段，一个是姓名，另一个是年龄。当我们点击提交时，我们将被重定向到以下网址:form-handler.php？名称=今晚学习&年龄=5 ，表单数据附加到网址。
将表单数据作为网址参数发送有时被证明是有用的，因为您可以很容易地将链接添加到表单数据中，但是在网址中添加参数有 2000 个字符的限制，因此对于具有大量字段的表单，不建议这样做，因为一些数据可能会丢失或者表单提交可能会导致错误。
Php 文件form-handler.php看起来像，
<?php
// name attribute of the input field goes inside the
// square brackets of $_GET superglobal
$name = $_GET["name"];
$age = $_GET["age"];
echo "Your name is ". $name . " and you are ". $age . " years old".
?>
你的名字是今晚学习，你 5 岁了
由于表单数据对每个人都是可见的，因为它是作为网址参数发送的，因此我们不应该对带有敏感数据的表单使用 GET 方法，比如密码等。
使用开机自检方法
当我们使用 POST 方法时，来自 HTML 表单的键值对数组(表单数据)作为 HTTP 请求的一部分被发送，因此它们对用户是不可见的。
此外，正在传输的信息/数据没有字符限制。
POST 方法也支持多部分表单-数据上传，用于文件上传。
我们建议您在处理任何 PHP 网络应用程序/项目时使用 POST 方法。
让我们举一个简单的例子来理解，下面我们有一个简单的 HTML 表单，
<html>
<body>
<form action="form-handler.php" method="POST">
Name: <input type="text" name="name"> <br/>
Age: <input type="text" name="age"> <br/>
<input type="submit">
</form>
</body>
</html>
Php 文件form-handler.php看起来像，
<?php
// name attribute of the input field goes inside the
// square brackets of $_POST superglobal
$name = $_POST["name"];
$age = $_POST["age"];
echo "Your name is ". $name . " and you are ". $age . " years old".
?>
你的名字是今晚学习，你 5 岁了
PHP 表单处理示例
原文：https://www.studytonight.com/php/php-form-handling-example
在本教程中，我们将使用不同类型的输入创建一个简单的 HTML 表单，然后编写 PHP 代码来处理提交时的表单数据。
我们还将学习一些有用的技巧，可以在处理表单数据时使用，如检查空输入值、验证字段等。让我们开始吧。
超文本标记语言表单
我们将创建一个 HTML 表单，其中 2 个文本字段用于姓名和电子邮件，1 个文本区域用于用户提供自我描述(更像是关于我的)和一个询问用户性别的单选按钮集。
下面是表单的 HTML 代码。
<html>
<body>
<form action="form-handler.php" method="POST">
Name: <input type="text" name="name"> <br/>
Email: <input type="text" name="email"> <br/>
About Me:<br/>
<textarea name="aboutme"></textarea> <br/>
Gender:
<input type="radio" name="gender" value="female"> Female
<input type="radio" name="gender" value="male"> Male
<br/>
<input type="submit" name="submit" value="Submit">
</form>
</body>
</html>
PHP 代码
在上面的表单中，我们要求用户提供 4 种不同的输入，让我们看看如何获取 PHP 中字段的提交值。
<?php
// getting the value of name field
$name = $_POST["name"];
// getting the value of the email field
$email = $_POST["email"];
// getting the value of the aboutme field
$aboutme = $_POST["aboutme"];
// getting the value of the radio buttons
$gender = $_POST["gender"];
?>
很简单，对吧？是的，要访问不同类型的 HTML 表单元素的表单数据，您需要的只是$_POST。
但是一个 HTML 表单是一个很好的切入点，黑客可以通过在输入字段中输入脚本或一些恶意代码来在您的 PHP 脚本中造成一些错误/问题。
为了解决这个问题，最好在 PHP 代码中加入一些验证，以验证表单数据中提交的用户输入。
PHP 表单验证
现在，我们将学习一些基本的验证，这些验证可以很容易地应用于提交的表单数据，以便在对其执行任何操作之前对其进行验证。
<?php
// getting the value of name field
$name = $_POST["name"];
// check if name is empty or not
if(empty($name)) {
echo "Name is required";
}
?>
在上面的代码中，我们正在检查用户是否在表单中输入了名称值，类似地，您可以检查所有必需的表单字段。
为了验证电子邮件地址，PHP 中有一个特殊的函数，我们可以用它来验证电子邮件地址。功能是filter_var($email, FILTER_VALIDATE_EMAIL)，让我们看看它是如何工作的。
<?php
// getting the value of the email field
$email = $_POST["email"];
// checking if the email value is valid
if(!filter_var($email, FILTER_VALIDATE_EMAIL)) {
echo "Email value invalid";
}
?>
filter_var()功能返回true为有效的电子邮件地址，返回false为无效的电子邮件地址。
用 PHP 验证表单也取决于您的需求。例如，如果您的表单中没有任何必填字段，那么您就不必担心检查提交的值是否为空。
如果您有电子邮件地址字段，我们建议您验证它。
您甚至可以添加更多的验证，例如使用正则表达式检查输入中的恶意代码，如<script>标签。
什么是$_SERVER["PHP_SELF"]？
有时我们可以避免使用额外的 PHP 文件来处理表单数据，并且可以将 PHP 代码包含在 HTML 表单本身的文件中。
在这种情况下，我们将不得不再次将表单提交到同一个网页，我们可以使用$_SERVER["PHP_SELF"]作为表单动作。
<form action="<?php echo $_SERVER["PHP_SELF"]; ?>" method="POST">
这个 superglobal 的作用是返回当前网页的文件名，然后作为动作脚本。
但是由于这将从 URL 中返回现有的文件名，您必须小心一点，因为用户可能会从 URL 中注入一些不需要的代码，因此为了避免这种情况，我们可以使用htmlspecialchars()函数将字符串(本例中为 URL)中的任何特殊字符转换为 HTML 实体。
所以你应该用，
<form action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]); ?>" method="POST">
PHP 中的状态管理
HTTP 是无状态协议，这意味着每个用户请求都是独立处理的，与之前处理的请求无关。因此，无法使用 HTTP 协议存储或发送任何用户特定的详细信息。
但是在现代应用程序中，会创建用户帐户，并将用户特定信息显示给不同的用户，为此，我们需要了解每个网页上的用户是谁(或他/她希望看到什么等)。
PHP 为 web 应用程序的状态管理提供了两种不同的技术，它们是:
- 服务器端状态管理
- 客户端服务器管理
服务器端状态管理
在服务器端状态管理中，我们存储在服务器上识别用户所需的用户特定信息。每个网页上都有这些信息。
在 PHP 中我们有 【会话】 用于服务器端状态管理。PHP 会话变量用于存储用户名、用户 id 等用户会话信息，并且可以通过访问 web 应用程序的任何网页上的会话变量来检索这些信息，直到会话变量被销毁。
客户端状态管理
在客户端状态管理中，用户特定信息存储在客户端，即存储在服务器中。同样，该信息在 web 应用程序的所有网页上都可用。
在 PHP 中我们有 Cookies 用于客户端状态管理。cookie 保存在浏览器中，带有一些数据和到期日期(直到 cookie 有效)。
使用 cookie 进行状态管理的一个缺点是，用户可以轻松访问存储在浏览器中的 cookie，甚至可以将其删除。
PHP Cookies
Cookie 是网络服务器以文件形式存储在用户浏览器中的一小段信息。一旦创建，cookie 将作为每个 HTTP 请求的头信息发送到 web 服务器。
您可以使用 cookie 保存任何数据，但大小不应超过 1K(1024 字节)。
在我们继续讨论如何创建、更新和删除 cookie 之前，让我们学习一些 cookie 在现实世界中的用法。
饼干的真实使用
- 存储用户信息，如他/她何时访问过，网站上访问过哪些页面等，以便下次用户访问您的网站时，您可以提供更好的用户体验。
- 要存储基本的网站具体信息要知道这不是用户的第一次访问。
- 您可以使用 cookies 来存储访问次数或查看计数器。
我希望这能让你对如何在你的 web 应用程序中利用 cookies 有一个概念。
饼干的种类
有两种类型的 cookies，它们是:
- 会话 Cookie :这种类型的 Cookie 是临时的，一旦会话结束或浏览器关闭，就会过期。
- 持久 Cookie :要使 Cookie 持久，我们必须为其提供过期时间。那么该 cookie 将仅在给定的过期时间后过期，在此之前它将是有效的 cookie。
用 PHP 创建一个 Cookie
在 PHP 中，我们可以使用setcookie()函数创建/设置一个 cookie。
下面是函数的语法，
setcookie(name, value, expire, path, domain, secure)
定义 cookie 的名称的第一个参数是强制的，其余的都是可选参数。让我们了解一下，我们可以向setcookie()函数提供哪些可用的参数来设置 cookie。
| 争吵 | 它是干什么用的？ |
| 名字 | 用于指定 cookie 的名称。这是一个强制性的论点。cookie 的名称必须是字符串。 |
| 价值 | 用于在 cookie 中存储任何值。一般保存为带名称的一对。例如，名称为用户标识，值为 7007 ，任意用户的用户标识。 |
| 期满 | 用于设置 cookie 的过期时间。如果不提供任何值，cookie 将被视为会话 cookie，并在浏览器关闭时过期。 |
| 小路 | 用于在 cookie 中设置网址。如果设置，cookie 将只能从该网址访问。要通过域访问 cookie，请将'/'设置为 cookie 路径。 |
| 领域 | 您的 web 应用程序的域。它可以用来限制子域对 cookie 的访问。例如，如果您将域值设置为wwww.studytonight.com，则该 cookie 将无法从blog.studytonight.com访问 |
| 安全的 | 如果您将此设置为1，则 cookie 将可用，并且仅通过 HTTPS 连接发送。 |
因此，如果我们想创建一个 cookie 来存储访问您网站的用户的姓名，并设置一周的过期时间，那么我们可以这样做，
<?php
setcookie("username", "iamabhishek", time()+60*60*24*7);
?>
要访问存储的 cookie，我们使用$_COOKIE全局变量，并且可以使用isset()方法来检查 cookie 是否被设置。
让我们有一个完整的例子，我们将设置一个 cookie，然后检索它以在 HTML 页面中显示它的值。
<?php
// set the cookie
setcookie("username", "iamabhishek", time()+60*60*24*7);
?>
<html>
<body>
<?php
// check if the cookie exists
if(isset($_COOKIE["username"]))
{
echo "Cookie set with value: ".$_COOKIE["username"];
}
else
{
echo "cookie not set!";
}
?>
</body>
</html>
因此，通过提供带有全局变量$_COOKIE[]的方形数据库中的 cookie 名称，我们可以访问该 cookie。
注意: setcookie()功能应该放在起始 HTML 标记(<html>)之前。
用 PHP 更新 Cookie
要更新/修改 cookie，只需再次设置即可。例如，如果我们想更新上面创建的 cookie 中存储的用户名，我们可以再次使用setcookie()方法来完成，
<?php
// updating the cookie
setcookie("username", "iamNOTabhishek", time()+60*60*24*7);
?>
<html>
<body>
<?php
// check if the cookie exists
if(isset($_COOKIE["username"]))
{
echo "Cookie set with value: ".$_COOKIE["username"];
}
else
{
echo "cookie not set!";
}
?>
</body>
</html>
我们只是将用户名 cookie 的值从iamabishek更新为iamanabishek。
删除 PHP 中的一个 Cookie
要删除/移除 cookie，我们需要使 cookie 过期，这可以通过使用过期日期在过去的setcookie()功能更新 cookie 来完成。
<?php
// updating the cookie
setcookie("username", "iamNOTabhishek", time() - 3600);
?>
<html>
<body>
<?php
echo "cookie username is deleted!";
?>
</body>
</html>
有了这个，我们现在知道如何创建一个 cookie，如何更新它，以及当我们不再需要它时如何删除它。接下来，会话！
用于状态管理的 PHP 会话
为了存储网页上可访问的信息，我们使用会话。会话不像cookie那样存储在用户浏览器上，因此它是一个更安全的选项。
我们知道 HTTP 是一个无状态协议，如果用户访问一个网页并执行一些动作，那么当用户导航到下一个网页时，就没有办法记住他做了什么。
让我们举一个实际的例子，当你登录你的 facebook 帐户时，通过提供你的电子邮件地址和密码，直到并且除非你注销，网络应用程序会记住你是谁，并在你的新闻提要上显示你的朋友正在发布和喜欢什么，你可以更新你的个人资料，给某人发消息，加入一个群组等，这是通过 Session 完成的。
当用户在任何网络应用程序上登录他们的帐户时，会为他们创建一个会话，并且在该会话中会存储他们的用户名或用户标识或其他一些唯一的标识符，然后在连续的网页上使用这些标识符来显示该用户的特定信息。注销时，会话将被销毁。
会话不受任何大小限制，您可以在会话中存储任何信息，无论其大小如何。
在我们继续讨论如何在 PHP 中开始、更新和结束一个会话之前，让我们学习会话的一些实际用法。
会话的真实使用
- 需要用户登录的 Web 应用程序使用会话来存储用户信息，以便在每个网页上向用户显示相关信息。
- 在电子商务网站中，购物车通常作为会话的一部分保存。
我希望这能让你了解如何在你的 web 应用程序中利用会话。
用 PHP 启动一个会话
在 PHP 中，我们可以使用session_start()函数启动一个会话。并且使用会话变量将数据存储在会话中，可以使用全局变量$_SESSION为其分配不同的值
简单来说，使用函数session_start()我们初始化会话，其中我们可以使用会话变量$_SESSION存储信息。
举个例子，下面我们有一个 Php 文件名为 first_page.php 的网页
<?php
// start the session
session_start();
// set the session variable
$_SESSION["username"] = "iamabhishek";
$_SESSION["userid"] = "1";
?>
<html>
<body>
<?php
echo "Session variable is set.";
?>
<a href="second_page.php">Go to Second Page</a>
</body>
</html>
**注意:**函数session_start()应该是页面的第一条语句，在任何 HTML 标签之前。
获取 PHP 会话变量值
在上面的代码中，我们已经启动了一个会话并设置了两个会话变量。上述网页还将有一个链接导航到第二页 second_page.php 。
下面是 second_page.php 的代码，其中我们从 first_page.php 中设置的会话变量中获取值。
<?php
// start the session
session_start();
// get the session variable values
$username = $_SESSION["username"];
$userid = $_SESSION["userid"];
?>
<html>
<body>
<?php
echo "Username is: ".$username."<br/>";
echo "User id is: ".$userid;
?>
</body>
</html>
用户名为:iamabhishek 用户 id 为:1
你一定在想，为什么我们在这里使用session_start()虽然我们没有在会话变量中设置任何新的值。
session_start()函数用于初始化一个新的会话，并获取正在进行的会话(如果已经开始)，然后，使用$_SESSION全局变量，我们可以在会话中设置新的值，或者获取保存的值。
如果会话中存储的值太多，并且不知道要获取哪个值，可以使用下面的代码打印所有当前会话变量数据。
<?php
// start the session
session_start();
?>
<html>
<body>
<?php
print_r($_SESSION);
?>
</body>
</html>
数组([用户名]= > iamabishek，[用户标识] => 1)
用 PHP 更新会话变量
要更新会话变量中存储的任何值，通过调用session_start()函数启动会话，然后简单地覆盖 vakue 来更新会话变量。
<?php
// start the session
session_start();
// update the session variable values
$_SESSION["userid"] = "1111";
?>
<html>
<body>
<?php
echo "Username is: ".$username."<br/>";
echo "User id is: ".$userid;
?>
</body>
</html>
用户名为:iamabhishek 用户 id 为:1111
我们刚刚将会话变量中用户标识的值从 1 更新为 1111 。
用 PHP 销毁一个会话
要清除会话变量或从会话变量中移除所有存储的值，我们可以使用函数session_unset()，要取消会话，我们可以使用session_destroy()函数。
<?php
// start the session
session_start();
?>
<html>
<body>
<?php
// clean the session variable
session_unset();
// destroy the session
session_destroy();
?>
</body>
</html>
在电子商务网站的情况下，我们在类似注销或结账的页面上使用这些功能来清除用户特定数据的会话变量，并最终销毁当前会话。
PHP 中的文件处理
当我们使用 PHP 开发一个 web 应用程序时，我们经常需要处理外部文件，比如从文件中读取数据，或者将用户数据写入文件等。因此，在使用任何 web 应用程序时，了解文件是如何处理的非常重要。
文件处理操作
文件处理从创建文件、读取其内容、写入文件以将数据附加到现有文件中，最后关闭文件开始。Php 为所有这些操作提供了预定义的函数，所以让我们从了解这些函数开始。
- 创建文件 :
fopen() - 打开文件 :
fopen() - 读取文件 :
fread() - 写入文件 :
fwrite() - 追加到文件 :
fwrite() - 关闭文件 :
fclose() - 删除文件 :
unlink()
你一定想知道为什么我们为多个文件操作指定了相同的函数，那是因为仅仅通过改变一个或多个参数，相同的函数就可以用来对文件执行多个操作。
在接下来的教程中，我们将学习如何使用这些函数以及代码示例。
文件在应用程序中的使用
以下是我们在 web 应用程序中需要文件的一些实际用例。
- 数据通常存储在 JSON 文件的 for 中，而 Php 代码必须读取该文件，然后将数据显示在网页上。
- 在一些简单的应用程序中，不使用数据库，而是将数据存储在文件中。
- 在某些 web 应用程序中，您可能必须准备一个文件供用户下载，在这种情况下，Php 代码将创建一个文件，在其中写入数据，然后允许用户下载。
上面的用例只是为了说明通常需要文件处理。
使用 PHP 创建、打开和关闭文件
原文：https://www.studytonight.com/php/php-file-open-create-close
创建一个新文件或者打开一个现有文件，我们使用 PHP 提供的fopen()函数，关闭一个文件资源使用fclose()函数。
用 PHP 创建一个文件
当我们使用函数fopen()打开一个不存在的文件时，这个文件就被创建了。
让我们举个例子，
$myfile = 'file.txt';
//opens the file.txt file or implicitly creates the file
$handle = fopen($myfile, 'w') or die('Cannot open file: '.$myfile);
fopen()函数以文件名作为第一个参数，第二个参数代表文件将在其中打开的模式。
但是，如果一个文件不存在，而你正在使用fopen()创建一个文件，那么你应该保持模式为w，也就是写模式。我们将在下一节中了解各种模式。
用 PHP 打开一个文件
打开一个文件，使用同样的fopen()功能。打开文件背后可能有许多原因，如读取文件内容、向文件中写入新内容或向文件中已经存在的内容追加附加内容。
让我们举一个简单的例子，然后我们将讨论打开文件的不同模式。
$myfile = 'file.txt';
//opens the file.txt file
$handle = fopen($myfile, 'w') or die('Cannot open file: '.$myfile);
同样，fopen()函数接受两个强制参数，一个是文件名，第二个代表模式。
以下是不同的模式以及应该在fopen()函数中作为参数传递的字面值。
| 方式 | 字符串字面值 | 描述 |
| 写入模式 | w | 如果文件存在，则打开它以允许在其中进行写操作，如果不存在，则创建一个新文件。在这种模式下，文件中的所有现有数据都会被擦除。 |
| 读取模式 | r | 文件以读取模式打开，文件指针从文件开头开始。 |
| 附加方式 | a | 文件在写入模式下打开，其中文件的现有内容被注意擦除。在现有内容之后添加的新内容。 |
| 创建只写文件 | x | 创建一个具有只写访问权限的新文件。如果文件已经存在，则返回错误。 |
除了上面指定的模式之外，我们可以将+与字符串一起添加，以允许给定模式的读写(默认)操作。
例如，r+模式打开文件进行读写。w+、a+分别允许对文件进行读操作以及默认的写和追加操作。
从技术上讲，文件是不打开的，fopen()将资源(文件)绑定到一个流，然后可以用这个流从文件中读取数据或将数据写入文件。
此外，如果文件是本地文件，文件名应该是完全限定名以及相对路径。文件名也可以是指定远程域路径的网址。在这种情况下，一旦 PHP 意识到文件路径不是本地的，它将在 php.ini (PHP 的配置文件)中检查allow_url_fopen属性值。如果是假，PHP 会打印警告，fopen()调用会失败。
用 PHP 关闭一个文件
使用文件资源后将其关闭是一个很好的做法。在 PHP 中fclose()函数用于关闭一个文件资源。它以文件名作为参数，或者以保存文件资源指针的变量作为参数。让我们举个例子:
$myfile = 'file.txt';
//opens the file.txt file or implicitly creates the file
$handle = fopen($myfile, 'w') or die('Cannot open file: '.$myfile);
// closing a file
fclose($handle);
举个例子
让我们举一个简单的例子，我们将创建一个 PHP 文件来创建一个文本文件，然后打开同一个文件在其中写入内容。
在下图中，我们描述了目录结构，这将帮助您理解如何提供文件的路径并在 PHP 文件中使用它。
下面是我们将保存在read-file.php文件中打开文件. txt 文本文件在其中写入数据的代码。
$myfile = 'include/file.txt';
//opens the file.txt file
$handle = fopen($myfile, 'w') or die('Cannot open file: '.$myfile);
// close a file
fclose($handle);
我们可以为要读取的文件提供完整的路径，也可以像上面的例子一样提供相对路径。
在接下来的教程中，我们将学习如何读取、写入、将数据追加到文件中。
使用 PHP 读取文件
用 PHP 从文件中读取内容可以通过两种方式完成:
- 使用
readfile()功能 - 使用
fread()从打开的文件中读取内容。
使用readfile()读取文件
readfile()函数读取文件的全部内容，并将其写入输出缓冲区。
如果我们有一个文件study south-info . txt，内容如下:
Following are some of the subjects available on Studytonight:
C Language
C++
Data Structure
Android
Python
我们可以使用readfile()函数读取上述文件的全部内容并写入输出缓冲区。
<?php
echo readfile("studytonight-info.txt");
?>
使用fread()打开并读取文件
我们可以使用fread()功能从已经打开的文件中读取内容。fread()函数有两个参数:
- 首先是文件名
- 第二个参数指定要读取的内容的字节大小。
举个例子，如果我们有一个文件study now . txt，内容如下:
Studytonight is for coding enthusiasts!
如果我们想读取文件的全部内容，我们将在读取模式下打开文件，然后使用fread()功能。
<?php
// Opening a file
$myfile = fopen("studytonight.txt", "r");
// reading the entire file using
// fread() function
echo fread($myfile, filesize("studytonight.txt"));
// closing the file
fclose($myfile);
?>
今晚的学习是为编码爱好者准备的！
正如您在上面的代码片段中看到的，我们使用了filesize()函数来指定等于整个文件大小的字节大小，因此fread()函数读取文件的整个内容。
但是如果想只打印文件中的部分内容，可以直接在第二个参数中指定的大小(以字节为单位) (1 字节= 1 个字符)，如下所示:
<?php
// Opening a file
$myfile = fopen("studytonight.txt", "r");
// reading only 12 bytes using
// fread() function
echo fread($myfile, 12);
// closing the file
fclose($myfile);
?>
今晚学习
使用fgets()逐行读取文件
fgets()函数从任何给定文件中读取一行(直到新的行字符)。
记住study south-info . txt文件，让我们在下面的例子中使用该文件，
<?php
// Opening a file
$myfile = fopen("studytonight-info.txt", "r");
// reading a single line using fgets()
echo fgets($myfile);
// closing the file
fclose($myfile);
?>
以下是《今夜研究》的一些主题:
在调用fgets()函数后，文件指针移动到下一行，所以如果我们调用fgets()函数两次，我们将从文件中得到两行，
<?php
// Opening a file
$myfile = fopen("studytonight-info.txt", "r");
// reading the first line using fgets()
echo fgets($myfile) . "<br>";
// reading the second line
echo fgets($myfile);
// closing the file
fclose($myfile);
?>
以下是今晚学习中的一些科目:C 语言
使用feof()获取文件结尾
如果文件指针在文件末尾，函数feof()返回true，否则返回false。
此功能可用于循环通过大小未知的文件，因为feof()功能可用于检查是否到达文件结尾。
让我们使用feof()和fgets()功能来逐行读取和回显/打印文件的内容。
<?php
// Opening a file
$myfile = fopen("studytonight-info.txt", "r");
// loop around the file to output the content
// line by line
while(!feof($myfile)) {
echo fgets($myfile) . "<br>";
}
// closing the file
fclose($myfile);
?>
以下是《今夜研究》提供的一些主题:C 语言 C++数据结构安卓 Python
逐字符读取文件- fgetc()
我们可以使用函数fgetc()从头开始从任何文件资源中读取单个字符。
我们可以使用fgetc()功能和feof()功能，一个字符一个字符地打印一个文件的全部内容。
如果您必须替换任何字符或在文件内容中查找任何特定字符，此功能会派上用场。
让我们举个例子，
<?php
// Opening a file
$myfile = fopen("studytonight-info.txt", "r");
// loop around the file to output the content
// character by character
while(!feof($myfile)) {
echo fgetc($myfile);
}
// closing the file
fclose($myfile);
?>
以下是今晚学习中的一些主题:C 语言 c++数据结构和 Python
使用 PHP 将数据写入或追加到文件中
原文：https://www.studytonight.com/php/php-file-write-and-append
要将内容写入文件，我们可以使用 PHP 中的fwrite()函数。要使用fwrite()功能将内容写入文件，我们首先需要在写入或追加模式下打开文件资源。
用 PHP 写一个文件
fwrite()功能用于在写入模式下，当文件已经打开时，将内容写入文件。
让我们举个例子，我们将在文件 movies.txt 中写入几个电影名称
$file_name = 'movies.txt';
//opens the file.txt file or implicitly creates the file
$myfile = fopen($file_name, 'w') or die('Cannot open file: '.$file_name);
$movie_name = "The Man from Earth \n";
// write name to the file
fwrite($myfile, $movie_name);
// lets write another movie name to our file
$movie_name = "SouthPaw \n";
fwrite($myfile, $movie_name);
// close the file
fclose($myfile);
在上面的代码中，我们在文件 movies.txt 中写了两个电影名。如果我们打开文件，它将如下所示:
来自地球的左撇子
注意:当在写入模式下打开文件时，文件中的所有现有数据都会被擦除，并且可以使用fwrite()功能将新数据写入文件。
如果我们再次打开上面的文件向其中写入更多的内容，并且我们在写入模式下打开文件，那么所有现有的内容都将被擦除。
用 PHP 将数据追加到文件中
如果我们希望在文件 movies.txt 中添加更多的电影名称，那么我们需要在追加模式中打开该文件。我们举个例子看看。
$file_name = 'movies.txt';
//opens the file.txt file or implicitly creates the file
$myfile = fopen($file_name, 'a') or die('Cannot open file: '.$file_name);
$movie_name = "Avengers \n";
// write name to the file
fwrite($myfile, $movie_name);
// lets write another movie name to our file
$movie_name = "Real Steel \n";
fwrite($myfile, $movie_name);
// close the file
fclose($myfile);
地球人左撇子复仇者联盟真钢
高级
PHP 中的面向对象编程
原文：https://www.studytonight.com/php/php-object-oriented-programming
自从编程语言产生以来，计算机科学家们一直在努力开发几种给计算机编程的方法。最终，随着越来越发达的编程语言的出现，人们过去编写程序的方式也发生了变化。方法论，算法，概念化，这些年来一直在发展。如今，面向对象编程是编程任何应用程序的流行方法。
一种特定的编程语言必须以一种非常具体的方式来设计，这样才能遵循一种特定的方法。就 PHP 而言，它是一种面向对象的编程语言。在本节中，我们将看到 PHP 中有哪些特性支持或支持它成为面向对象的编程语言。首先，让我们试着理解什么是面向对象编程？(或 OOP)和它的概念。
什么是面向对象编程？
面向对象编程是一种与类、对象的概念以及围绕这两个概念的各种其他概念相关联的编程风格，如继承、多态、抽象、封装等。
面向对象程序设计的方式是，人们在编程时应该关注一个对象，而不是过程。物体可以是我们在周围看到的任何东西。它可以是一个人(具有一些属性，如姓名、地址、DOB 等)、一把椅子(由大小、材料、成本等描述)、一所学校(由地点、学生实力、结果等描述)等。
面向对象编程使编程接近现实生活，因为我们总是在处理一个对象，对它执行操作，使用它的方法和变量等。
面向对象的概念
在下面的视频中，我们借助一个非常容易理解的例子解释了面向对象编程的基本概念。如果你想跳过视频，所有内容都在下面讨论。
让我们试着通过一个简单的例子来了解一下这些。人类是有生命的形式，大致分为两种，男性和女性。正确是真的。每个人(男性或女性)都有两条腿、两只手、两只眼睛、一个鼻子、一颗心等。男性和女性都有一些常见的身体部位，但男性有一些女性没有的特定身体部位，女性有一些身体部位，但男性没有。
所有的人都走路、吃饭、看、说话、听等等。现在，男性和女性都执行一些共同的功能，但是两者都有一些细节，这对另一个是无效的。比如:女的可以生，男的不可以生，所以这只针对女的。
人体解剖学很有趣，不是吗？但是让我们看看这一切是如何与 PHP 和 OOPS 相关联的。在这里，我们将尝试通过这个例子来解释所有的 OOPS 概念，在下一个教程中，我们将有所有这些的技术定义。
班级
这里我们可以把人类作为一个类。类是定义其属性和功能的任何功能实体的蓝图。像人一样，有身体的一部分，做各种动作。
遗产
考虑HumanBeing一个类，有手、腿、眼等属性，有走、说、吃、看等功能。Male和Female也是类，但是大部分属性和函数都包含在HumanBeing中，因此它们可以使用继承的概念从类HumanBeing继承一切。
目标
我的名字是阿布舍克，我是类Male的实例/对象。当我们说，人类，男性或女性，我们只是指一种，你，你的朋友，我，我们是这些类的形式。我们有一个物理存在，而一个类只是一个逻辑定义。我们是目标。
抽象
抽象意味着，只向外界展示需要的东西，而隐藏细节。继续我们的例子，人类的会说话，会走路，会听，会吃，但是细节对外界是隐藏的。在我们的案例中，我们可以将皮肤作为抽象因素，隐藏内部机制。
包装
这个概念用我们的例子来解释有点棘手。我们的腿被绑在一起帮助我们走路。我们的手，帮我们拿东西。属性与函数的这种绑定称为封装。
多态性
多态性是一个概念，它允许我们重新定义某件事的工作方式，要么通过改变它是如何完成的，要么通过改变它所使用的部分。这两种方式都有不同的术语。
PHP 中的类
作为一种面向对象的编程语言，PHP 允许在开发任何软件或应用程序时，创建遵循面向对象编程范式的类和对象。
一个类是用户定义的数据类型，包括局部变量和局部方法。
而对象是类的一个实例，它保存了带有赋值的局部变量，我们可以在其上调用类中定义的局部方法。
在本教程中，我们将学习如何在 PHP 中定义一个类，以及如何创建它的对象。
用 PHP 定义一个类
当我们用 PHP 定义一个类时，就像任何变量一样，我们必须给我们的类命名，在用 PHP 命名我们的类时，我们必须遵循一些规则，它们是:
- 类名应该以字母开头。
- 类名不应是保留的 PHP 关键字。
- 类名不应包含任何空格。
现在我们已经知道了 PHP 中与类命名约定相关的规则，让我们创建一个名为 Person 的简单类。
用 PHP 定义类的语法
在 PHP 中定义一个类的语法非常简单，我们使用关键字class后跟类的名称，然后我们将该类的代码放在花括号{ } 中，就像函数/方法一样。
以下是Person类的代码:
<?php
class Person {
// class variables and methods comes here...
}
?>
虽然这不是强制性的，但是使用类名作为 PHP 文件的文件名是一个很好的做法。此外，PHP 允许在一个文件中定义多个类，但同样不建议这样做。
所以我们将上述类Person的代码保存在文件Person.php中。
现在我们给我们的类添加一个变量来存储一个人的名字。当我们在一个类中创建一个变量时，它被称为属性。
<?php
class Person {
// to store name of person
var $name;
}
?>
var是定义类内变量/属性的关键字，$name是变量的名称。
是时候在我们的类中添加方法/函数了。函数在类内定义时称为方法。
在一个类中，方法被定义为要么对类变量(属性)执行一些操作，要么对类执行一些其他操作，比如打印所有变量的值，或者可以将数据存储到数据库等。
当我们定义方法来获取类变量的值和设置类变量的值时，这些方法被称为 Getter 和 Setter 函数。
这些被普遍命名为get_NAME-OF-VARIABLE()和set_NAME-OF-VARIABLE()。
所以，对于变量$name，我们来添加get_name()和set_name()函数。
<?php
class Person {
// to store name of person
var $name;
// print name
function get_name() {
return $this->name;
}
function set_name($new_name) {
$this->name = $new_name;
}
}
?>
当我们将学习如何创建类的对象时，我们将更多地讨论为什么我们需要 getter 和 setter 函数。
我们可以定义一个没有变量的类吗？
是的，一个简单的类不需要任何变量。我们可以简单地有一些方法。这样的类通常是助手类，其中包含一些有用的通用方法。
让我们用两种方法创建一个名为人类的简单类:
<?php
class Human {
// for male
function male() {
echo "This human is a male";
}
function female() {
echo "This human is a female";
}
}
?>
对于上面的类，所有的对象都是相似的，因为没有变量。
当我们在一个类中有变量时，我们可以用类变量的不同值创建该类的多个对象。
所以到目前为止，我们希望你已经理解了什么是类，它只是一个用户定义的数据类型，它有属性/变量和类方法。在下一个教程中，我们将学习如何创建类对象。
PHP 类对象
正如在上一个教程中所讨论的，类只不过是一个蓝图或者用户定义的数据类型，可以通过创建它的对象来使用。
类是一个逻辑实体，而它的对象是真实的。
A 类一般包括局部变量和局部方法。
而对象是类的一个实例，它保存了带有赋值的局部变量，使用这个对象我们可以调用类中定义的局部方法。
在本教程中，我们将学习如何在 PHP 中初始化任何类的对象。
用 PHP 创建一个类的对象
为了创建一个类的对象，我们使用new关键字。
让我们举一个快速的例子，我们将为一个简单的 PHP 类创建对象。
<?php
class Studytonight {
// to store name of person
var $url = "studytonight.com";
// simple class method
function desc() {
echo "Studytonight helps you learn Coding.";
}
}
// creating class object
$obj = new Studytonight();
?>
如您所见，我们在最后一行使用new关键字创建了一个类对象study now，并将其分配给变量$obj。
一旦我们有了任何类的对象，我们就可以使用->运算符使用它来访问类方法和变量。
<?php
class Studytonight {
// variable with a default value
var $url = "studytonight.com";
// simple class method
function desc() {
echo "Studytonight helps you learn Coding.";
}
}
// creating class object
$obj = new Studytonight();
// accessing class variable
echo $obj->url . "<br/>";
// calling class method
$obj->desc();
?>
Studytonight 研究今晚帮助你学习编码。
访问类变量和方法
要使用类的对象访问类变量和方法，我们使用->运算符，后跟变量的名称或方法的名称。
我们已经在上面的例子中展示了这一点，但是让我们有另一个例子，有一个更复杂的类。
<?php
class Person {
// first name of person
var $fname;
// last name of person
var $lname;
function showName() {
echo "My name is: " . $this->fname . " " . $this->lname;
}
}
// creating class object
$john = new Person();
// assigning values to variables
$john->fname = "John";
$john->lname = "Wick";
// calling the method function
$john->showName();
?>
我叫:疾速追杀
在上面的类中，在showName()方法内部，我们使用了$this关键字，用于引用调用对象。我们将在接下来的教程中了解更多信息。
类似地，我们可以用分配给局部类变量的不同值创建一个类的多个对象。我们开始吧，
<?php
class Person {
// first name of person
var $fname;
// last name of person
var $lname;
function showName() {
echo "My name is: " . $this->fname . " " . $this->lname;
}
}
// creating class object
$john = new Person();
// assigning values to variables
$john->fname = "John";
$john->lname = "Wick";
// calling the method function
$john->showName();
echo "<br/>";
// creating class object
$james = new Person();
// assigning values to variables
$james->fname = "James";
$james->lname = "Bond";
// calling the method function
$james->showName();
?>
我的名字是:疾速追杀我的名字是:詹姆斯·邦德
类变量fname和lname都可以在对象$john和$james中作为单独的副本使用，我们可以为它们赋值，然后使用它们。
PHP 访问修饰符
为了设置类方法和变量的访问权限，我们使用的访问修饰符只是 PHP 关键字。我们甚至可以将其中的一些访问修饰符分配给类本身，以使类以一种特殊的方式运行。
下面是 PHP 关键字，它们被用作访问修饰符，并带有它们的含义:
public:当我们将类成员定义为公共的时候，那么它们可以从任何地方访问，甚至可以从类范围之外访问。private:当我们将类成员定义为私有时，只能从类本身内部访问。protected:这个和 private 一样，除了一个例外，定义为 protected 的类成员仍然可以从它的子类访问(我们在了解继承的时候会了解子类)。abstract:此关键字仅用于 PHP 类及其成员函数。final:定义为 final 的类方法不能被任何子类改变或覆盖。
何时使用哪个访问修饰符
我们不能对类、它的变体和方法使用所有可用的访问修饰符。在下表中，我们指定了哪个访问说明符应用于什么:
| 访问修饰符 | 班 | 功能 | 变量 |
| 公共 | 不适用 | 可应用的 | 可应用的 |
| 私人 | 不适用 | 可应用的 | 可应用的 |
| 受保护 | 不适用 | 可应用的 | 可应用的 |
| 摘要 | 可应用的 | 可应用的 | 不适用 |
| 决赛 | 可应用的 | 可应用的 | 不适用 |
现在我们知道了在哪里使用哪个访问修饰符，让我们通过例子详细了解访问修饰符。
public存取修改子
如果我们不指定任何访问修饰符，默认情况下，所有类及其成员都被视为public。
如上表所述，public、private或protected访问修饰符不能用于类。让我们看看如果我们这样做了会发生什么，
<?php
public class Studytonight {
...
}
?>
分析错误:语法错误，中出现意外的“PUBLIC”(T _ PUBLIC)…
我们会得到上面的错误。
但是对于类方法和变量，我们应该指定访问说明符，尽管默认情况下它们被视为公共的。
这是一个简单的 PHP 类的例子:
<?php
class Studytonight {
// to store name of person
var $url = "studytonight.com";
// simple class method
function desc() {
echo "Studytonight helps you learn Coding.";
}
}
?>
在上面的代码中，我们在类变量之前使用了关键字var。如果我们不使用var，我们会得到一个解析错误。
但是除了使用var之外，我们还可以在类变量的脱序之前使用访问修饰符关键字，例如:
<?php
class Studytonight {
// to store name of person
public $url = "studytonight.com";
// simple class method
function desc() {
echo "Studytonight helps you learn Coding.";
}
}
?>
这就是我们应该如何创建一个 PHP 类，指定访问修饰符以及类变量和方法是很好的编程实践。
private存取修改子
我们可以对类变量和方法使用private访问修饰符，但不能对 PHP 类使用。当一个类成员——一个变量或一个函数——被声明为private时，它就不能直接使用该类的对象来访问。例如:
<?php
class Person {
// first name of person
private $fname;
// last name of person
private $lname;
// public function to set value for fname
public function setFName($fname) {
$this->fname = $fname;
}
// public function to set value for lname
public function setLName($lname) {
$this->lname = $lname;
}
// public function to
public function showName() {
echo "My name is: " . $this->fname . " " . $this->lname;
}
}
// creating class object
$john = new Person();
// trying to access private class variables
$john->fname = "John"; // invalid
$john->lname = "Wick"; // invalid
// calling the public function to set fname and lname
$john->setFName("John");
$john->setLName("Wick");
?>
在上面的代码中，$fname和$lname是私有的类变量，因此我们不能使用类对象直接访问它们。
因此，当我们尝试执行以下代码行时:
<?php
$john->setFName("John");
?>
我们将得到一个致命的 PHP 错误:
致命错误:无法访问私有属性个人::$fname in…
但是我们可以通过在类中定义公共函数来轻松访问类的私有变量。我们可以创建单独的函数来设置私有变量的值并获取它们的值。这些函数称为获取器和设置器。
<?php
class Person {
// first name of person
private $name;
// public function to set value for name (setter method)
public function setName($name) {
$this->name = $name;
}
// public function to get value of name (getter method)
public function getName() {
return $this->name;
}
}
// creating class object
$john = new Person();
// calling the public function to set fname
$john->setName("John Wick");
// getting the value of the name variable
echo "My name is " . $john->getName();
?>
我叫疾速追杀
对于类中的所有私有变量，我们应该有 getter 和 setter 方法。
protected存取修改子
就像private访问修饰符一样，protected访问修饰符也限制类外的类变量和方法的访问。但是protected类变量和函数可以在类内部和子类(继承类的类)内部访问。
我们将在接下来的教程中学习如何创建子类以及继承的概念。
让我们举一个简单快速的例子:
<?php
class Human {
// protected variable
protected $genders = array("Male", "Female", "Other");
// protected function for humans features
protected function getFeatures($gender) {
if($gender == "Male") {
echo "Men will be Men";
}
else if($gender == "Female") {
echo "Women's mind is a maze.";
}
else if($gender == "Other") {
echo "All are born equal.";
}
}
}
// subclass of the above class
class Male extends Human {
protected $gender = "Male";
// public function to print Male features
public function getMaleFeatures() {
// calling the protected getFeatures() method of class Human
$this->getFeatures($this->gender);
}
}
// object of Human class
$human = new Human();
// object of Male class
$male = new Male();
/*
accessing protected variables and methods
*/
echo $human->genders; // INVALID
$human->getFeatures("Male"); // INVALID
echo $male->gender; // INVALID
/*
but we can call getMaleFeatures method,
in which we are calling a protected method
of Human class
*/
$male->getMaleFeatures();
?>
在上面的程序中，我们定义了两个类，Human和Male。Male类是Human类的子类。
在Human类中，所有的类变量和方法都是protected，因此它们不能从类外访问，但是它们可以在类的子类Human中访问。
不要担心，如果这看起来由于 【继承】 的概念而令人困惑，我们将再次重新访问这一点，届时我们将了解继承。
abstract存取修改子
abstract访问修饰符用于 PHP 类及其函数。它不能用于类变量。
如果一个类甚至只有一个abstract方法。那么类也必须定义为abstract。
此外，PHP 不允许实例化抽象类，即您不能创建abstract类的对象，尽管这些类可以被继承。
我们将在讨论抽象类和接口时详细了解这个访问修饰符。
final存取修改子
当我们使用这个访问修饰符将一个类声明为final时，那么这个类就不能被继承。
类似地，当我们将一个类函数定义为final时，PHP 会限制该类的子类覆盖声明为final的函数。
同样，当我们学习继承时，我们将通过例子来解释这一点。
PHP $this关键字
如果您从头开始学习本教程，或者从 OOPS 概念开始，您一定注意到了一些代码片段中$this的用法。
this关键字在类内部使用，通常在成员函数内部，用于访问当前对象的类(变量或函数)的非静态成员。
我们举个例子来了解一下$this的用法。
<?php
class Person {
// first name of person
private $name;
// public function to set value for name (setter method)
public function setName($name) {
$this->name = $name;
}
// public function to get value of name (getter method)
public function getName() {
return $this->name;
}
}
// creating class object
$john = new Person();
// calling the public function to set fname
$john->setName("John Wick");
// getting the value of the name variable
echo "My name is " . $john->getName();
?>
我叫疾速追杀
在上面的程序中，我们在类中创建了一个名为$name的private变量，我们有两个public方法setName()和getName()分别给$name变量赋值和获取它的值。
每当我们想从成员函数内部调用类的任何变量时，我们使用$this指向保存该变量的当前对象。
我们也可以使用$this在另一个成员函数内部调用一个类的一个成员函数。
**注:**如果类中有任何static成员函数或变量，我们不能用$this来引用。
将self用于static类成员
代替$this，对于static类成员(变量或函数)，我们使用self，以及范围解析运算符 ::。让我们举个例子，
<?php
class Person {
// first name of person
public static $name;
// public function to get value of name (getter method)
public static function getName() {
return self::$name; // using self here
}
}
?>
PHP self和this的区别
让我们了解一下self和this的几个区别:
| self | this |
| self关键字前面没有任何符号。 | this关键字前面应该有一个$符号。 |
| 要使用self关键字访问类变量和方法，我们使用范围解析运算符 :: | 对于this运算符，我们使用-<符号。 |
| 用来指代班级的static成员。 | 用于访问类的非静态成员。 |
| PHP self指的是类成员，但不是针对任何特定的对象。这是因为static成员(变量或函数)是类的所有对象共享的类成员。 | 而$this将引用特定实例的成员变量和函数。 |
让我们举一个代码示例来更好地理解这一点:
<?php
class Job {
// opening for position
public $name;
// description for the job;
public $desc;
// company name - as the company name stays the same
public static $company;
// public function to get job name
public function getName() {
return $this->name;
}
// public function to get job description
public function getDesc() {
return $this->desc;
}
// static function to get the company name
public static function getCompany() {
return self::$company;
}
// non-static function to get the company name
public function getCompany_nonStatic() {
return self::getCompany();
}
}
$objJob = new Job();
// setting values to non-static variables
$objJob->name = "Data Scientist";
$objJob->desc = "You must know Data Science";
/*
setting value for static variable.
done using the class name
*/
Job::$company = "Studytonight";
// calling the methods
echo "Job Name: " .$objJob->getName()."<br/>";
echo "Job Description: " .$objJob->getDesc()."<br/>";
echo "Company Name: " .Job::getCompany_nonStatic();
?>
职位名称:数据科学家职位描述:你一定知道数据科学公司名称:今晚学习
在上面的代码片段中，我们有几个非静态变量和一个static变量。
因为static成员与类本身相关联，而不是与类的对象相关联，因此我们使用类名来称呼它们。
同样，一个static成员函数可以在里面使用一个static变量，而如果一个非静态方法在里面使用一个static变量，那么它也被称为使用类名，就像一个static方法一样。
PHP 构造器和析构器
原文：https://www.studytonight.com/php/php-constructor-and-destructor
当我们创建任何类的对象时，我们需要在使用它之前设置该对象的属性。我们可以这样做:首先初始化对象，然后设置属性的值，如果变量是public，则使用->操作符，或者对private变量使用公共设置器方法。
为了一步创建并初始化一个类对象，PHP 提供了一种特殊的方法，称为构造器，用于在创建对象时通过分配所需的属性值来构造对象。
而对于破坏对象使用析构器方法。
定义构造器和析构器的语法
在 PHP 中，我们有特殊的函数来定义一个类的构造器和析构器，它们是:__construct()和__destruct()。
<?php
class <CLASS_NAME> {
// constructor
function __construct() {
// initialize the object properties
}
// destructor
function __destruct() {
// clearing the object reference
}
}
?>
构造器可以接受参数，而析构器不会有任何参数，因为析构器的工作是删除当前的对象引用。
PHP 构造器
让我们以一个有两个属性fname和lname的类Person为例，对于这个类，我们将定义一个构造器，用于在创建对象时初始化类属性(变量)。
<?php
class Person {
// first name of person
private $fname;
// last name of person
private $lname;
// Constructor
public function __construct($fname, $lname) {
echo "Initialising the object...<br/>";
$this->fname = $fname;
$this->lname = $lname;
}
// public method to show name
public function showName() {
echo "My name is: " . $this->fname . " " . $this->lname;
}
}
// creating class object
$john = new Person("John", "Wick");
$john->showName();
?>
初始化对象…我叫疾速追杀
之前，我们使用->操作符来设置变量的值，或者使用设置器方法，在构造器方法的情况下，我们可以在对象创建时为变量赋值。
如果一个类有一个构造器，那么无论何时创建该类的对象，都会调用该构造器。
PHP 构造器重载
PHP 不支持函数重载，因此我们不能在一个类中有多个构造器实现。
PHP 破坏程序
PHP 析构器方法在 PHP 即将从内存中释放任何对象之前被调用。通常，你可以在析构器中关闭文件，清理资源等。让我们举个例子，
<?php
class Person {
// first name of person
private $fname;
// last name of person
private $lname;
// Constructor
public function __construct($fname, $lname) {
echo "Initialising the object...<br/>";
$this->fname = $fname;
$this->lname = $lname;
}
// Destructor
public function __destruct(){
// clean up resources or do something else
echo "Destroying Object...";
}
// public method to show name
public function showName() {
echo "My name is: " . $this->fname . " " . $this->lname . "<br/>";
}
}
// creating class object
$john = new Person("John", "Wick");
$john->showName();
?>
初始化对象…我的名字是:疾速追杀摧毁物体…
正如我们在上面的输出中看到的，当 PHP 程序结束时，就在它之前，PHP 启动了所创建对象的释放，因此调用了析构器方法。
析构器方法不能接受任何参数，并且在对象被删除之前被调用，这发生在对象没有引用或者 PHP 脚本完成执行的时候。
**注意:**如果你看到一个 PHP 类的函数与类名同名，那么这个函数将充当构造器。在 PHP 的旧版本中，构造器不是使用__construct()名称定义的，但是它曾经和类名同名，就像核心 Java 一样。
例如:
<?php
class Person {
// first name of person
private $fname;
// last name of person
private $lname;
// Constructor
public function Person($fname, $lname) {
echo "Initialising the object...<br/>";
$this->fname = $fname;
$this->lname = $lname;
}
// public method to show name
public function showName() {
echo "My name is: " . $this->fname . " " . $this->lname . "<br/>";
}
}
// creating class object
$john = new Person("John", "Wick");
$john->showName();
?>