StudyTonight-Web-中文教程-二-

StudyTonight Web 中文教程（二）

原文：StudyTonight

协议：CC BY-NC-SA 4.0

JavaScript 变量

原文：https://www.studytonight.com/javascript/javascript-variables

JavaScript Variable 是一个对象(或一个命名的内存空间)，它是用来存储一个可以在程序执行过程中使用的值。JavaScript 中的一个变量，就像其他编程语言一样，有一个名字，一个值和一个内存地址。

  • 变量的名称唯一标识变量，

  • 值是指存储在变量中的数据，并且

  • 内存地址是指变量的内存位置。

换句话说，我们可以说变量是一个可以用来存储值的容器，在使用它之前你需要声明一个变量。

在 JavaScript 中，var关键字用于声明一个变量。另外，从 ES6 开始，我们也可以使用let关键字来声明变量。

变量名的 JavaScript 规则

以下是声明变量时要记住的一些规则。

  • 变量名不能包含空格。

  • 变量的首字母可以是[a-z，A-Z]，美元符号($)或下划线(_)，名字首字母后任意数字[0-9]都可以。

  • 变量名区分大小写。比如:var a和var A都不一样。

  • 我们可以使用var或let关键字来定义变量。

  • 我们不能在 JavaScript 中使用保留字作为变量的名称。

声明变量的 JavaScript 语法

以下是声明变量并为其赋值的语法。

var variable_name;
// or
let variable_name;

我们也可以不用分号来定义变量。此外，当我们必须定义多个变量时，我们可以这样做:

// declaring 3 variables together
var x, y, z;

正如我们已经了解到的，动态类型化是一个 JavaScript 特性，所以我们不必担心指定我们将存储在变量中的值的数据类型。JavaScript 会自动检测到这一点。

JavaScript 变量示例:

现在让我们举一个简单的例子，我们将声明一个变量，然后给它赋值。

var employeeName;   // Declaring a variable

var employeeName = "Rahul";   // Declaring and assigning at the same time

您可以在声明变量时初始化变量或为变量赋值，也可以只声明变量并在以后初始化它。

JavaScript:变量的类型

JavaScript 支持两种类型的变量，它们是:

  • 局部变量

  • 全局变量

您可以根据应用程序中的要求使用它们。让我们通过例子来了解 JavaScript 局部变量和 JavaScript 全局变量。

1.JavaScript 局部变量

JavaScript 局部变量是在代码块或函数体内部或循环体内部声明的变量，它在代码块或函数内有作用域。简单来说，当在代码块或函数体中声明和定义时，局部变量的范围在左大括号和右大括号{ }之间。

从 ES6 开始，在声明局部变量时建议使用let关键字。

让我们举个例子。

2.JavaScript 全局变量

JavaScript 全局变量是一个在脚本中任何地方声明的变量，并且有完整脚本执行的范围。全局变量不在任何块或函数中声明，但可以在任何函数或代码块中使用。

建议我们使用var关键字来声明全局变量，从 ES6 开始。

举个例子吧。

结论:

在本主题中，我们学习了 JavaScript 变量的概念以及 JavaScript 变量的两种类型，即局部变量和全局变量。我们还介绍了通过使用var关键字和let关键字来声明变量的两种不同语法，以及示例。

JavaScript let关键字

原文：https://www.studytonight.com/javascript/javascript-let-keyword

在 JavaScript 中，let是一个关键字，用于声明一个具有块作用域的局部变量。与 var关键字声明全局范围变量不同的是， ECMAScript2016 (ES6)引入let关键字来定义局部范围变量，因为定义全局范围内的所有变量会导致在编写大型 JavaScript 应用程序时出现很多问题。

它允许您声明有限范围变量，这些变量不能在范围之外访问。

让我们举个例子来理解let关键字在 JavaScript 中已经有var关键字创建变量时的需求。假设您正在编写一个包含多个循环、函数和变量的大型 JavaScript 代码，像往常一样，在所有循环中，您为计数器使用了相同的变量名i，并且您使用了var关键字来定义变量i，现在将发生的是，变量 I 将在整个脚本中携带其更改的值，因为它是一个全局变量，如果您忘记在任何地方将其重新初始化为零，它将导致错误，并且您的代码将会中断。你将不得不付出额外的努力来寻找错误。

然而，如果您使用let关键字定义计数器变量i，其范围将仅限于循环，并且当第一个循环结束时，计数器变量也将结束。这样，使用 let 关键字更有意义，因为我们在一般编程实践中使用很少的全局变量和许多局部变量。

让在全局声明时不创建窗口对象的属性。

JavaScript let关键词:语法

使用let关键字定义变量的语法与var关键字相同。

let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN];

如上面的语法所示，是的，我们可以使用单个let关键字来定义多个变量，但是这并不新鲜，我们也可以使用var关键字来定义。

我们来看几个例子，看看这个let关键词是怎么用的，怎么用的。

在代码块中使用let:

如果我们已经使用let关键字定义了变量，那么在块 { }内部声明的 JavaScript 变量不能从块外部访问。请参见下面的示例:

{
    let x = 2;
}

alert(x)  // not accessible

未捕获的引用错误:x 未定义

在上面的例子中，变量只能在块内部访问。请看下面的例子，可以看到:

{
    let x = 2;
    alert(x)  // accessible
}

Two

在循环中使用let:

它更适合于循环，在循环中，我们声明局部变量用作计数器。因此，变量不会与在循环外编写的代码冲突。请参见下面的示例:

let i = 5;

for(let i = 0; i < 10; i++) {
  	// code
}

alert(i);  // print 5

5

正如您在输出中看到的，它显示了 5 ，即使循环将i变量的值增加到了 10 ，这是因为for循环中的局部变量i的范围以循环本身结束，因此在循环之外是不可访问的。

在函数中使用let:

我们知道，let关键字声明了局部范围变量。所以在函数内部声明的变量将保留在函数范围内。如果我们试图从函数外部访问这样的变量，我们会得到一个错误。请参见下面的示例:

function show() {
    let amount = 2500;   // Function Scope
}
alert(amount) // not accessible

未捕获参考错误:金额未定义

JavaScript let vs var关键词

我们已经在介绍中介绍了两者的区别，但是让我们看一些代码示例来看看两者之间的区别。

let和var，这两个关键词都是用来声明变量的，但主要区别是声明变量的范围。

使用var在块内声明的变量可以在块外访问，因为它具有全局范围，但是使用let关键字声明的变量具有局部范围。让我们看一个例子:

{
    let amount = 2500;   // block Scope
    var withdraw = 2000;    // global scope
}
document.write(withdraw)   // accessible
document.write(amount)   // not accessible

2000
未记录参考错误:金额未定义

JavaScrip let关键词示例:

让我们再举一个例子，在这个例子中，我们将编译上面的所有例子，看看使用let关键字定义的变量是如何工作的。

如您所见，在顶部定义的变量x具有全局范围，并且在脚本结束之前将保持可访问，而在代码块和函数内部定义的变量x具有范围，直到代码块或函数结束。

结论

在本教程中，我们已经介绍了用于在 JavaScript 中定义变量的 let 关键字。它是在 ECMAScript2016 中引入的，建议用于定义变量，而不是使用 var 关键字创建 JavaScript 变量。

JavaScript 字面值和关键字

原文：https://www.studytonight.com/javascript/javascript-literals-and-keywords

JavaScript 字面值是不可更改的固定值，您不需要指定任何类型的关键字来编写字面值。在编程中常使用字面值来初始化变量，变量的名称是字符串字面值。

JavaScript 字面值可以是数字、字符串、浮点值、布尔值甚至是对象。简单来说，任何值都是字面值，如果你写一个字符串“study now”就是字面值，任何像 7007 这样的数字都是字面值，等等。

JavaScript 支持下面列出的各种字面值:

  • 数值字面值

  • 浮点字面值

  • 布尔字面值

  • 字符串字面值

  • 数组字面值

  • 正则表达式字面值

  • 对象字面值

数字字面值

  • 它可以用十进制(以 10 为基数)、十六进制(以 16 为基数)或八进制(以 8 为基数)格式表示。

  • 十进制数值由一系列数字(0-9)组成，没有前导 0(零)。

  • 十六进制数字字面值包括数字(0-9)、字母(a-f)或(A-F)。

  • 八进制数字字面值包括数字(0-7)。数字字面值中的前导 0(零)表示八进制格式。

数值字面值示例

120 // decimal literal

021434 // octal literal

0x4567 // hexadecimal literal

浮点字面值

  • 它包含一个小数点(。)

  • 分数是浮点字面值

  • 它可能包含一个指数。

JavaScript 浮点字面值示例

6.99689 // floating-point literal

-167.39894 // negative floating-point literal

JavaScript 布尔字面值

布尔字面值仅支持两个值，即真或假。

JavaScript 布尔字面值示例

true // Boolean literal

false // Boolean literal

JavaScript 字符串字面值

字符串字面值是包含在单引号(')或双引号(")中的零个或多个字符的组合。

JavaScript 字符串字面值示例

"Study" // String literal

'tonight' // String literal

字符串字面值也可以有一些特殊的字符，如下表所示。

字符串特殊字符:

字符 描述
\b 它代表退格。
\f 它代表一个表单源。
\n 它代表一条新的线。
\r 它代表回车。
\t 它代表一个标签。
\v 它代表一个垂直标签。
\' 它代表撇号或单引号。
\" 它代表一个双引号。
\\ 它表示反斜杠字符。
\uXXXX 它表示由四位十六进制数指定的 Unicode 字符。

JavaScript 数组字面值

  • 数组字面值是一个由零个或多个表达式组成的列表，这些表达式表示括在方括号([])中的数组元素。

  • 每当您使用数组文本创建数组时，它都会使用方括号中指定的元素进行初始化。

JavaScript 数组字面值示例

var emp = ["aman","anu","charita"];  // Array literal

JavaScript 正则表达式文本

正则表达式是一种模式，用于匹配某些文本中的字符或字符串。它是通过将正则表达式字符串括在正斜杠之间来创建的。

JavaScript 正则表达式示例

var myregexp = /ab+c/; // Regular Expression literal

var myregexp = new RegExp("abc"); // Regular Expression literal

JavaScript 对象字面值

它是用花括号({})括起来的键值对的集合。键值对由逗号分隔。

JavaScript 对象字面值示例

var games = {cricket :11, chess :2, carom: 4}  // Object literal

JavaScript 关键字

每种编程语言都有自己的关键词和保留词。创建每个关键字是为了执行特定的任务，编译器或解释器已经知道内置关键字和保留字。JavaScript 支持下表中列出的一组丰富的关键字。

关键词 描述
为 for 关键字用于创建 for 循环。
做/当 do 和 while 这两个关键字都用于在 JavaScript 中创建循环。
如果/否则 if 和 else 关键字用于创建条件语句。
继续 continue 关键字用于恢复循环。
破裂 它用来打破循环。
功能 function 关键字用于声明函数。
调试器 它用于调用调试器函数
班级 class 关键字用于声明类。
返回 Return 关键字用于从函数中返回函数。
漂浮物 它用于声明浮点类型变量。
（同 Internationalorganizations）国际组织 它用于声明 int 类型变量。
私人的 它是一个访问修饰符。
公众的 Public 是一个访问修饰符，它赋予类公共访问权。
定义变量 Var 用于声明变量。
转换 开关创建各种语句块，并根据条件或情况只在块上执行。
尝试/捕捉 它为语句的错误处理创建一个块。

注意: 在定义任何函数或变量的名称时，不应使用任何关键字或保留字。

在本教程中，我们学习了 JavaScript 字面值、不同类型的字面值以及示例。我们还介绍了 JavaScript 关键字和保留字。

JavaScript 数据类型

原文：https://www.studytonight.com/javascript/javascript-data-types

JavaScript 数据类型用于标识脚本执行期间存储在变量中的数据类型。因为我们已经指定了动态类型 JavaScript 特性，所以我们在声明变量时不必指定它的数据类型。

所以 JavaScript 数据类型基本上是为了识别目的，知道变量中存储了什么，什么时候存储的，而不是之前。

动态类型语言是在运行时推断数据类型的语言。它允许在编程过程中为变量存储不同类型的值。

下面我们有一个基本的例子，我们用一个数值定义了一个变量，然后更新它来存储一个字符串值。所以 JavaScript 允许这样做。

var x = 5;    // x is a number
x = "studytonight";    // x is string here.

JavaScript 广泛支持三种类型的数据类型，它们是:

  • 原语类型

  • 参考类型

  • 特殊数据类型

让我们一个接一个地讨论每一个，同时看看哪个类别有所有的数据类型。

原始数据类型

JavaScript 原语数据类型可以进一步分为以下类型:

  1. 字符串数据类型

  2. 布尔数据类型

  3. 数字数据类型

这些是最常见的数据类型，分别用于存储字符序列、真/假和数值。让我们用例子一个接一个地讲述它们。

1.字符串数据类型

每当我们在单引号或双引号内写一个字符或字符序列时，它就变成了字符串。比如“今晚学习”。

我们可以使用单引号或双引号来创建字符串类型值。

var str = "Ferari F60";  // string using double quotes

var str1 = 'Volvo S60';  // string using single quotes.

要将单引号作为字符串的一部分，我们应该使用双引号将字符串值括起来，反之亦然。如果您想在字符串中包含单引号，而该字符串是通过仅用单引号括起来定义的，在这种情况下，我们必须使用反斜杠来转义单引号，同样，我们也可以在字符串值中转义双引号。

让我们看一个例子:

var str1 = "Ferari's F60";    // Output: Ferari's F60

var str2 = 'Volvo "S60"';   // Output: Volvo "S60"

var str3 = 'Ferari\'s F60';    // Output: Ferari's F60

我们已经详细介绍了 JavaScript 字符串，也介绍了 JavaScript 中的各种字符串方法。

2.布尔数据类型

布尔数据类型用于基于条件的编程。它可以有两个值，或者真或者假。

var isOn = true;  // bulb is on

var isOn = false;  // bulb is off

我们在比较两个数字时会得到布尔值，例如:

doument.write(4 < 2)  // false
doument.write(4 > 2)  // true

我们将在 JavaScript If else 流控制教程中看到这一点。

3.数字数据类型

数字数据类型可以有小数点，也可以没有小数点，可以有负值和正值。

var x = 45; // Number without decimal point

var y = 45.90; // Number with decimal point - floating point

var z = -10; // Number with negative value

JavaScript Number 数据类型还表示一些特殊的值，如Infinity、-Infinity和Nan。当正数被零除时(这是运行时错误的一种常见情况)，在 JavaScript 中它被表示为Infinity。同样，当负数被零除时，我们会得到-Infinity。

var a = 100;
var b = -100;
var c = 0;

alert(a/c);  // Infinity 
alert(b/c);  // -Infinity

而Nan的意思是不是一个数字，如果我们试图在一个数值和一个非数值之间执行任何操作，比如字符串，我们会得到这个作为输出。

var a = "Studytonight";
var b = 7;

alert(a/b);    // Nan

复合数据类型

这些数据类型可以保存值和更复杂实体的集合。它进一步分为对象、数组和函数。

  1. 对象数据类型

  2. 数组数据类型

  3. 函数数据类型

1.对象数据类型

在 JavaScript 中，对象数据类型用于存储数据集合。对象的属性被写成键:值对，用逗号和隔开，用花括号 {}括起来。

键(名称)必须始终是字符串，但是值可以是任何数据类型。这非常类似于许多编程语言中的映射数据结构，它也像这样存储键值对。

var name = { };   // It will create an empty object.

var emp = {firstname="ram", lastname="singh", salary=20000};

我们已经在单独的教程中用例子介绍了 JavaScript 对象。

2.JavaScript 数组类型

JavaScript Array 数据类型写在一对方括号[]内，用于存储相同数据类型的多个值，如字符串、数字等。JavaScript 数组中的项目也是以逗号分隔的方式编写的。

数组中的每个元素都有一个数字位置，称为其索引。数组索引从 0 开始，或者我们可以说数组索引是从零开始的，所以第一个数组元素是arr[0]而不是arr[1]。

让我们举一个 JavaScript 数组的例子:

// Creating an Array
var cars = ["Ferrari", "Volvo", "BMW", "Maseratti"];

我们已经在单独的教程中用例子介绍了 JavaScript 数组。

3.JavaScript 函数类型

你一定在想，函数怎么可能是数据类型。但是在 JavaScript 中函数作为一种数据类型，可以分配给一个变量。JavaScript 函数只不过是代码块中的一组语句，用于执行特定的操作这个数据类型本质上是可调用的。因此，您可以随时在程序中的任何地方调用它。

因为函数是对象，所以可以将它们赋给一个变量。

函数可以存储在变量、对象和数组中。函数也可以作为参数传递给其他函数，也可以从其他函数返回。

var welcome = function() {
                  return "Welcome to StudyTonight!";
              }

我们已经在单独的教程中用例子介绍了 JavaScript 函数。

特殊数据类型

JavaScript 也有一些特殊的数据类型，尽管将被调用的函数视为数据类型对您来说已经很特殊了。但是还有两个。

  1. 未定义的数据类型

  2. 空数据类型

让我们一个接一个地讨论它们。

1.未定义的数据类型

当一个变量刚刚被声明并且没有被赋予任何值时，它的值为未定义。是的，未定义在 JavaScript 中是一个有效的数据类型，它只能有一个值未定义。

我们甚至可以在做一些比较时使用这个值。让我们举个例子:

var a;   // Undefined

alert(a == undefined);   // returns true

2.空数据类型

JavaScript Null 数据类型用于表示无值。它不类似于未定义，也不类似于空值或零值。空数据类型意味着变量已经定义，但它不包含任何值。

Null 数据类型只能有一个值，即 null 。让我们举一个例子:

var a = null;

alert(a);    // Output will be null

JavaScript typeOf运算符

JavaScript 中的typeOf运算符可以用来检查任何变量的数据类型。虽然它是一个运算符，但我们在这里提到它，因为它通常用于检查任何变量的数据类型。

让我们举几个例子来看看这是如何工作的:

// Function datatype
var welcome = function() {
                  return "Welcome to StudyTonight!";
              }

typeOf welcome;    // function

var a = null;

typeOf a;   // null

// Array datatype
var cars = ["Ferrari", "Volvo", "BMW", "Maseratti"];

typeOf cars;    // array

您也可以尝试其他数据类型。

结论:

在本主题中，我们解释了 javascript 中使用的变量的数据类型。所有的主题和副主题都用实例来解释，这样我们可以更好地理解主题。

JavaScript 运算符

原文：https://www.studytonight.com/javascript/javascript-operators

在本教程中，我们将学习 JavaScript 运算符，JavaScript 中各种不同类型的运算符，并将有几个例子来看看它们的工作原理。

什么是操作员？

运算符是为特殊任务或操作保留的符号。运算符用于对操作数执行操作。操作数可以是变量或数值或字符串。一个运算符可以处理一个或多个操作数。

运算符对于通过操作相应的变量来修改或更改数据非常有用。例如，有两个变量a和b，我们希望将这两个变量的值相加，为此，我们可以使用算术运算符+来执行这两个变量的相加。

JavaScript 支持一组丰富的运算符。这些操作符执行特定的任务，每个操作符都有不同的属性。操作员列表如下:

  • 算术运算符

  • 关系运算符

  • 按位运算符

  • 逻辑运算符

  • 赋值运算符

  • 字符串运算符

让我们逐一介绍上述每一种运算符类型，并看看 JavaScript 中支持的不同运算符。

算术运算符

JavaScript 算术运算符用于执行算术运算，如加法、减法、乘法、等。下表列出了所有的算术运算符。

操作员 描述 例
+

  • Add two numbers

  • to connect two strings

|

45+20 // output 65

"My"+"Name" // MyName

(也可用于字符串连接) |
| **-** |

  • minus two numbers

  • means negative number

|

45-20 // output 25

|
| * | 将两个数字相乘 |

20*5 // output 100

|
| / | 将两个数相除 |

45/10 // output 4.5

|
| % | 将两个数相除，然后返回余数 |

45%10 // output 5

|
| ++ | 将该值增加 1 |

a = 10
a++; // output will be 11

|
| -- | 将该值减 1 |

x = 9
x--; // output will be 8

|

关系运算符

这些运算符用于在两个操作数之间进行比较。我们将在介绍JavaScript if else Flow Control时使用这些操作符。

操作员 描述 例
== 如果两个操作数相等，则返回真，否则返回假。 
45==10  // output false

|
| != | 如果两者不相等，则返回真，否则返回假。 |

45!=10  // output true

|
| === | 是一个严格相等的算子。如果类型转换时操作数严格相等(相同的值和相同的数据类型)，则返回真否则返回假。 |

3===3  // output true

|
| !== | 如果该运算符两侧的操作数不相等/不是同一类型，则返回 true 。 |

3!=='3'   // output false

|
| > | 如果左侧操作数大于右侧操作数，则返回真，否则返回假。 |

45>10   // output true

|
| >= | 如果左侧操作数大于或等于右侧操作数，则返回真，否则返回假。 |

45>=10   // output true

|
| < | 如果左侧操作数小于右侧操作数，则返回真，否则返回假。 |

10<45   // output true

|
| <= | 如果左侧操作数小于或等于右侧，则返回真，否则返回假。 |

45<=10   // output false

|

JavaScript 逐位运算符

JavaScript 支持以下对操作数执行按位运算的按位运算符。

操作员 描述 例子
&(与) 如果两位都为 1，则将每个位设置为 1 
5&1  // returns 1

0101&0001   // returns 1

|
| &#124;(或) | 如果两个位中的一个为 1，则将每个位设置为 1 |

5&#124;1   // returns 5

0101 &#124; 0001   // returns 5 in decimal or 65 in octal

|
| ^(异或) | 如果两位中只有一位为 1，则将每个位设置为 1。 |

5^1    // returns 4

0101^0001    // returns 4 in decimal or 64 in octal

|
| ~(否) | 反转所有位 |

~5  // output 6

~0101  // output 66 in octal

|
| <<(零填充左移位) | 通过从右边压入零向左移动，让最左边的位脱落 |

5<<1   // returns 10

0101<<1   // returns 10 in decimal and 130 in octal

|
| >>(带符号填充右移) | 通过从左边推入最左边位的副本来向右移动，并让最右边的位脱落。 |

5>>1  // returns 2

0101>>1  // returns 2

|
| >>>(零填充右移) | 通过从左边压入零向右移动，并让最右边的位脱落 |

5>>>1  // returns 2

0101>>>1  // returns 2

|

逻辑运算符

逻辑门的功能在 JavaScript 中用作逻辑运算符。这些运算符也用于控制流。

操作员 描述 例
&& 只有当两个操作数都为真时，它才返回真，否则返回假 
true&&false   // returns false

|
| &#124;&#124; | 如果任一操作数为真，则返回真。当两个操作数都为假时，它返回假 |

true&#124;&#124;false   // returns true

|
| ! | 否定操作数，如果操作数为假则返回真，反之亦然 |

!true   // returns false

|

JavaScript 赋值运算符

这些是在给变量赋值时使用的运算符。

操作员 描述 例
= 它将值赋给左侧变量。 
x = 90;

|
| += | 它将右侧操作数与左侧操作数相加，然后将结果赋给左侧操作数。 |

x = 45;

x += 20;  // x = 65

|
| -= | 它从左侧操作数中减去右侧操作数，然后将结果分配给左侧操作数。 |

x = 45;

x -= 10;  // x = 35

|
| *= | 它将右侧操作数乘以左侧操作数，然后将结果赋给左侧操作数。 |

x = 45;

x *= 10;  // x = 450

|
| /= | 它将左侧操作数除以右侧操作数，并将结果赋给左侧操作数。 |

x = 45;

x /= 10;   // x = 4.5

|
| %= | 它将左侧操作数除以右侧操作数，然后将余数赋给左侧操作数。 |

x = 45;

x% = 10;   // x = 5

|

JavaScript 运算符优先级和结合性

运算符优先级决定运算符的求值顺序。具有较高优先级的运算符首先被求值。例如，表达式(3+4*5)返回 23 ，因为乘法运算符(*)的优先级高于加法运算符(+)。因此*必须先评估。

运算符关联性决定了处理具有相同优先级的运算符的顺序。比如赋值运算符是右关联，可以写a=b=5，用这个语句，给a和b赋值 5 。

下表显示了运算符的优先级和关联性。在这个表格中，优先级是从下到上的，也就是说，位于底部的项目优先级较低，当我们移动到表格顶部时，优先级会增加。

操作员类型 操作员(符号) 关联性
成员 。[] 从左向右
新的 新的 从右向左
函数调用 () 从左向右
增量 ++
减量 -
逻辑非 ！ 从右向左
按位非 ~ 从右向左
一元+ + 从右向左
一元否定 - 从右向左
类型 类型 从右向左
空的 空的 从右向左
删除 删除 从右向左
增加 * 从左到右
分开 / 从左到右
系数 % 从左到右
添加 + 从左到右
减法 - 从左到右
逐位移位 <<>>>>> 从左到右
有关系的 <<=>>= 从左到右
在 在 从左到右
实例 实例 从左到右
平等 ！！ 从左到右
按位“与” & 从左到右
按位异或 ^ 从左到右
按位或 | 从左到右
逻辑与 && 从左到右
逻辑或 || 从左到右
有条件的 ？： 从右向左
作业 =+=-=*=/=%=<<=>>=>>>=&==|= 从右向左
逗号 , 从左到右

JavaScript 运算符示例:

下面我们有一个真实的例子，其中我们使用了上面指定的一些操作符。

在本主题中，我们解释了 JavaScript 运算符及其在 JavaScript 中的用法。运算符是任何编程语言的一个非常重要的组成部分，因为它们是执行操作所必需的，用于条件、比较等。

JavaScript 事件

原文：https://www.studytonight.com/javascript/javascript-events

JavaScript 事件是交互式网页的构件。在 JavaScript 中，事件是指网络浏览器在浏览器屏幕上检测到任何用户移动时所检测到的动作。因此，从鼠标移动、键盘点击、悬停在任何特定的 HTML 元素上、表单提交、点击任何输入字段、从下拉列表中选择一个值，以及您在网页上所做的其他一切，浏览器都会为其生成一个事件，可以使用 JavaScript 进行处理。

JavaScript 使我们能够编写脚本，在这些事件发生时执行。例如onclick事件被浏览器检测到每当你点击鼠标按钮并且使用 JavaScript 我们可以在鼠标点击上执行任何动作就像我们可以设置一个计数器并且跟踪鼠标点击到看用户使用鼠标点击的次数。

在下面的实时示例中，我们已经实现了一个简单的鼠标点击计数器，点击输出区域查看点击次数更新为我们已经在 HTML 页面的整个主体上捕获了鼠标点击事件。

在上面的代码中，用于在捕获鼠标点击事件时执行动作的函数被称为事件处理程序，它在事件被触发时处理特定的事件。

JavaScript 事件处理语法

以下是为任何 HTML 元素中的任何特定事件添加处理程序的语法。

<ABC_ELEMENT onXYZ="EVENT_HANDLER_CODE"></ABC_ELEMENT>

在上面的代码中，我们添加了一个事件处理程序来捕获网页的 ABC_ELEMENT 上的 XYZ 事件。所以每当 XYZ 事件相对于 ABC_ELEMENT 发生时，我们的事件处理程序代码就会被执行。

JavaScript event handling

对于事件处理，我们既可以提供一个 JavaScript 函数名，并单独定义该函数，也可以直接在 HTML 标记本身中提供我们的 JavaScript 代码。

我们也可以通过在 JavaScript 中指定事件处理部分来做到这一点。

<ABC_ELEMENT is="myTag"></ABC_ELEMENT>

<script>
    function eventHandler() {
        // do something
    } 
    // setup event handler on HTML element
    document.getElementById("myTag").onXYZ = eventHandler;
</script>

在上面的语法中，我们已经完全分离了 HTML 和 JavaScript 代码。这是在 JavaScript 中实现事件处理的更好方式。当在 HTML 元素 ABC_ELEMENT 中遇到事件 XYZ 时，这也会调用eventHandler函数。

让我们举几个例子，涵盖几个不同的事件，这样你就可以理解这是如何工作的。

JavaScript onchange事件示例

当一个 HTML 元素如选择，或单选按钮，或复选框等时，该事件被创建。变化。您可以定义一个事件处理程序，以便在此事件发生时执行某些操作。在下面的代码示例中，我们使用<select>标签创建了一个下拉列表，其中使用了<option>标签向下拉列表添加选项。

现在一旦我们在这个元素上添加了onchange事件处理，无论何时使用选择任何值，我们的事件处理函数都将被执行。

JavaScript onClick事件示例

当用户单击一个按钮或单击我们已经设置了事件处理程序的任何 HTML 元素时，就会发生此事件。在下面的例子中，我们在<button> HTML 标签中设置了一个简单的onClick处理程序。

JavaScript onmouseover事件示例

您可以使用onmouseover事件使您的网页更具互动性。当我们在任何 HTML 元素上设置此事件处理时，只要用户将鼠标光标放在该 HTML 元素上，事件处理程序就会被触发。

我们可以使用该事件来改变颜色、文本大小，或者总的来说创建一个有趣的用户界面，在鼠标悬停时改变。

JavaScript onblur事件示例

当焦点从任何输入域消失时，JavaScript onblur事件被触发。在下面的例子中，我们有一个输入字段，我们已经在其上设置了onblur事件处理程序。您可以运行下面的代码示例来查看正在发生的onblur事件。

与 HTML 表单一起使用的 JavaScript 事件

下面我们列出了所有可以用于 HTML 表单的事件。

事件 描述
昂松宾 提交表单时的触发器
onselect 选择元素时的触发器
oninvalid 当元素为时，触发器无效
推理能力 为元素提供输入时触发
onforminput 在表单上提供输入时触发
onformchange 当表单更改时触发
得到焦点时 当窗口获得焦点时触发
上下文菜单 使用上下文菜单时触发
昂哥 当元素改变时触发
onblur(声音) 当窗口失去焦点时触发。

JavaScript 键盘事件

以下是可用于键盘按键的事件。

事件 描述
叔叔家 按键时触发
按键时 按键时触发
onkeyup 释放钥匙时触发

超文本标记语言中使用的鼠标事件

我们已经介绍了上面onmouseover事件的一个例子，这些是其他可用的鼠标事件。也试试用这些，看看它们能做什么。

事件 描述
单击事件 点击鼠标按钮时触发
ondblclick(点击鼠标) 双击鼠标按钮时触发
忍无可忍 拖动元素时触发
羔羊 删除被拖动元素时触发
滚动时触发 滚动元素滚动条时触发
是 mouseup 释放鼠标按钮时触发
鼠标滚轮 旋转鼠标滚轮时触发
软骨 拖动元素时离开有效目标时触发
鼠标点下时 按下鼠标按钮时触发
鼠标移动 移动鼠标指针时触发

浏览器的 JavaScript 事件

以下是您可以在 JavaScript 代码中使用的浏览器事件。

事件 描述
onblur(声音) 当窗口失去焦点时触发
不良事件 发生错误时触发
得到焦点时 当窗口获得焦点时触发
装载 加载文档时触发
onmessage 当 postMessage()方法向当前文档发送消息时触发
打印后 打印文档后触发
打印前 打印文档前触发
onhaschange 更改文档时触发
头上 在文档中执行重做操作时触发
在线 文档联机时触发

HTML 媒体元素的 JavaScript 事件

以下是可用于管理 HTML 网页中各种媒体类型的事件，如视频暂停、视频播放等。

|

事件

| 描述 |
| --- | --- |
| 等待 | 当媒体文件已停止但预计稍后会恢复时触发 |
| ONP 原因 | 暂停媒体文件时触发 |
| 蒙皮 | 当媒体文件将要播放时触发 |
| 开始 | 搜索过程开始时触发 |
| 奥纳博特 | 中止进程时的触发器 |
| 一个提示 | 当媒体元素因某些错误而变空时触发 |
| 合一的 | 当媒体文件结束时触发 |
| onloadeddata | 加载媒体文件时触发 |
| ontimeupdate | 改变媒体文件播放位置时触发 |
| onvolumechange | 更改音量时触发 |

在网页开发中使用 JavaScript 事件

事件在创建一个动态的、互动的 web 应用程序时非常有用。应用程序开发过程充满了事件，包括:

  • 用于加载应用程序的事件

  • 用于单击按钮的事件

  • 提交用户表单的事件

  • 事件来设置文本框的焦点

  • 用于选择元素等的事件。

如果您正在开发一个网站，您应该尝试使用 JavaScript 事件来使您的网页更具响应性，设置客户端验证，处理用户操作等。

我们还列出了上面所有的事件，这样你就可以使用它们，看看它们是如何工作的。在上面的实例中，您可以尝试几乎所有这些事件。

JavaScript 常量——const关键字

原文：https://www.studytonight.com/javascript/javascript-constant-const-keyword

JavaScript const关键字用于定义一旦设置值就不能改变的常量值。常量的值不能通过重新赋值来改变，也不能重新声明。

常量的范围是块范围的，这意味着它不能从块外部访问。就范围而言，它很像使用 let 语句定义的变量。

常数可以是全局的，也可以是声明它的块的局部的。与 var 变量不同，全局常量不会成为窗口对象的属性。

JavaScript const关键词:语法

下面我们有在 JavaScript 中定义常量值的语法。

const name1 = value1 [, name2 = value2 [, ... [, nameN = valueN]]]

在使用const关键字时，我们不必使用var或let关键字。此外，我们可以将列表或简单值或字符串等定义为常量。

JavaScript const关键词示例

让我们了解一下，如何在 JavaScript 程序中创建常量。请参见下面的示例:

{
	const Pi = 3.14;
	alert(Pi);
}

3.14

让我们尝试另一个例子，我们将尝试改变常量的值，看看我们是否允许重新分配值。

{
	const Pi = 3.14;
	alert(Pi);

	// Reassign value
	Pi = 3.143;
	alert(Pi);
}

3.14
未捕获类型错误:常量变量赋值。

JavaScript const:作用域

使用const关键字定义的变量的范围与使用let关键字声明的变量的范围相同。所以，常量在一个块内声明，在该块外将无法访问。让我们举个例子看看:

{
	const Pi = 3.14;
	alert(Pi);
}

// outside block
alert(Pi);  // error

3.14
未捕获的引用错误:未定义 Pi

JavaScript const关键词用法示例

在下面的实时示例中，我们添加了多个代码语句，在这些语句中，我们声明了常量值，并赋予它不同的范围，还尝试更改常量的值。

要查看错误，您可以打开浏览器开发工具(如果您使用的是 Chrome 或 Firefox 浏览器)，您将在控制台中看到未捕获类型错误:常量变量赋值错误消息。

这就是我们如何在 JavaScript 中定义一个常量的方法，它可以用在你想要定义一些常量值的情况下，比如域名，任何固定的前缀值，或者任何整数值，或者可能是你的 JavaScript 代码中的一个 zipcode。

另请阅读:- 如何用 JavaScript 构建一个动画计数器

JavaScript 控制流和循环

JavaScript if、else和else if语句

原文：https://www.studytonight.com/javascript/javascript-if-else-and-else-if-statements

在 JavaScript 中，为了根据条件控制程序或脚本的流程，我们可以使用if...else条件语句。if 和 else 条件语句的工作原理就像它们在通信时用于现实世界一样。比如看下面这个说法，如果你分数超过 40%你就通过考试，否则你考试不及格，这里的条件是分数超过 40% ，如果是真的那你就通过，如果是假的那你就不及格。

在 JavaScript 中，if是一个条件语句，用于控制程序流程，就像在 C、C++等编程语言中一样。根据条件控制程序的流程是最基本、最简单的方法之一。当我们只希望在特定条件为真时执行代码语句时，可以使用if 语句。

if 语句的条件包含在紧接if 关键字之后的括号中。

JavaScript if:语法和使用

下面是在 JavaScript 代码中使用if语句的基本语法。

if(<EXPRESSION>)
{
    // block of statements
}

与if语句一起传递的条件主要是一个可以比较两个值的表达式，任何返回布尔输出真/假的表达式，或者任何其他表达式。此外，当表达式返回真或任何正数值时，将满足条件，在这种情况下，将执行包含在if语句下方花括号内的代码语句块。

JavaScript if statement working

JavaScript if示例

在这个例子中，我们使用的是if语句，只有当表达式为真时，if块才会被执行。

现在让我们看看if...else块的组合在 JavaScript 中是如何工作的。

JavaScript if...else:语法和使用

JavaScript if语句允许您创建一个带有条件的代码块，如果指定的条件为真，那么在if块中编写的代码语句将被执行。else语句还创建了一个代码块，该代码块仅在if语句中的指定条件为 false 时执行。

if(<EXPRESSION>)
{
    // if block
}
else
{
    // else block
}

else语句总是与if块后面的if语句一起使用。我们不能像使用if语句那样使用else语句提供条件/表达式。

JavaScript if...else statement working

JavaScript if...else示例

在这个例子中，我们将使用一个else块以及和if语句和块。

现在我们已经学会了如何使用if...else语句，我们可以根据不同的条件让我们的脚本执行不同的代码语句。但是等等，如果我们的逻辑中有不止一个条件呢？我们应该使用多个if块吗？这个问题的答案将在下一节中讨论。

JavaScript if…else if:语法和使用

JavaScript else if语句与if语句一起使用，定义多个不同的条件和代码块。当我们必须在脚本中实现多个条件时，我们可以在代码中使用if、else if和else语句。else if语句用在if和else语句之间，其中else不是强制性的。

下面我们有使用else if以及if和else语句的基本语法。

if(EXPRESSION1)
{
    // if block
}
else if(EXPRESSION2)
{
    // else if block
}
else if(EXPRESSION3)
{
    // another else if block
}
else
{
    // else block
}

在if语句之后，我们可以有任意多的else if块。此外，在末端有一个else块是可选的。

JavaScript else if statement working

JavaScript if...else if示例

在这个例子中，我们将使用if和else if语句来测试多个条件。

至此，我们已经完成了 JavaScript 流控制的基础知识，现在我们知道如何在 JavaScript 代码中实现基于条件的代码执行。例如，如果您想编写一个简单的脚本，其中您有一个 HTML 表单，您要求用户提供他们的详细信息，如姓名和性别。然后，根据他们输入的内容，您可以显示不同性别的自定义消息，或者类似地，根据任何其他条件集，您可以使用 JavaScript 在用户界面中执行不同的操作。

JavaScript for循环

原文：https://www.studytonight.com/javascript/javascript-for-loop

循环的 JavaScript 用于多次执行特定的代码块，直到给定的条件成立，或者直到给定的 JavaScript 对象(如数组或列表)的所有元素都被完全遍历。

有些时候，我们会希望执行某项操作一定次数，例如，如果我们有一份员工的工资清单，我们必须计算他们的所得税。现在获得所得税的公式对所有员工都是一样的，所以我们可以有一个循环，用不同的输入执行代码语句。

类似地，对于像这样打印数字的数学表像 2 这样的用例，我们可以简单地在适当的位置有一个循环，继续将数字与 1、2、3、4 等相乘直到 10，每次递增乘法因子。

一组语句的执行次数取决于循环中提供的条件，或者如果我们使用for循环遍历数组、列表等，那么循环会一直执行到遍历完成。

循环语句一直执行到条件变为假。当条件变为假时，循环的执行停止。

在 JavaScript 中，有各种类型的循环。

  • for 循环

  • 强制循环

  • for-of 循环

  • while 循环

  • 边做边循环

在本教程中，我们将介绍前三个循环，并在下一个教程中介绍其他循环。

JavaScript for循环

如果您想要执行特定次数的语句，那么您可以使用 JavaScript for循环，该循环允许您循环执行固定次数的语句。

for循环由三个语句组成:

  • 初始化:这里循环计数器用初始值初始化。

  • 条件:这里提供了条件语句，每次相对于计数器的值进行检查，以继续迭代。

  • 迭代:这个语句让你决定是增加还是减少初始计数器值，也称为递增/递减。

JavaScript for循环:语法

以下是for循环的语法:

for(initialization; condition; iteration)
{
    // statements
}

这里的想法是初始化一个计数器，设置一个条件，直到循环运行，并且继续增加或减少计数器，以便在一定的迭代之后条件失败，并且循环退出。如果条件从未失败，循环将继续无限执行。

JavaScript for循环:示例

让我们举个例子来看看循环是如何工作的，

JavaScript for...in循环

如果你想循环一个 JavaScript 对象的属性，那么你可以使用 JavaScript for…in循环。for/in 循环自动遍历对象的字段，当所有字段都被迭代时，循环停止。

循环中的 JavaScript:语法

让我们看看在 JavaScript 中使用 for/in 循环的语法。

for(key in object)
{
    // code statements
}

当循环运行时，每次键都将获得该键的值，使用该值我们可以在对象中访问该值。在 JavaScript 中，对象的格式为{“key 1”:“value 1”，“key 2”:“value 2”，...} for/in 循环可用于迭代 JavaScript 对象的所有字段。

JavaScript for...in循环:示例

让我们举个例子来看看它是如何运作的，

JavaScript for...of循环

for/of 循环的 JavaScript 允许您循环遍历可迭代对象的值，如数组、字符串等。

JavaScript for...of循环:语法

JavaScript 中 for/of 循环的语法类似于 for/in 循环的语法。

for(variable of iterable)
{
    //code here
}

JavaScript for...of循环:示例

下面是一个使用 for/of 循环遍历数组的例子。

let abc = ['BMW','FERARI','VOLVO'];
let y;
for(y of abc)
{
    document.write(y+,"<br>");
}

在本教程中，我们解释了 JavaScript 中使用的for循环、循环中的循环、循环中的循环。我们已经解释了如何在一个简单的 for 循环中执行语句，然后迭代 JavaScript 对象和迭代数组等。在下一个教程中，我们将学习while和do...while循环。

另请阅读:- 用 JavaScript 构建井字游戏

JavaScript do...while循环

原文：https://www.studytonight.com/javascript/javascript-while-loop-and-dowhile-loop

每当你想一遍又一遍地执行某条语句时，你可以使用 JavaScript while 循环来简化你的工作。JavaScript while循环允许我们迭代代码块，只要指定的条件为真。就像对于 Loop 一样，while和do...while循环也用于基于一个条件多次执行代码语句。

while循环和do...while循环之间的唯一区别是do...while循环将至少执行一次，因为在do...while循环中，条件是在代码块执行后检查的。

JavaScript while循环:语法和使用

以下是while循环的语法:

while(condition)
{
    // code statements
}

让我们举个例子来看看while循环在起作用。

JavaScript while循环:示例

在这个例子中，我们使用的是while循环，只有当指定的条件为真时，循环才会执行。

JavaScript do…while循环:语法和使用

就像while循环一样，do...while循环允许你迭代代码块，只要指定的条件是真。在 do-while 循环中，在执行循环后检查条件。所以，即使条件为真或假，代码块也至少执行一次。

下面我们有do...while循环的语法，

do
{
    // code statements
}
while(condition)

JavaScript do...while循环:示例

让我们举个例子，看看do...while循环在起作用。

在本教程中，我们解释了 JavaScript 中使用的while和do...while循环。

JavaScript switch

原文：https://www.studytonight.com/javascript/javascript-switch-case

JavaScript Switch 用例用于根据一个条件从多个语句块中执行一个语句块。JavaScript switch是一个基于条件的语句，它有多个条件，但一次只执行一个块。

在switch语句中，开关表达式只计算一次，然后将输出与开关块中提到的每种情况进行比较，如果表达式的输出与其中一种情况匹配，则执行写入该情况的块中的语句。如果没有匹配的案例，则执行默认案例。

JavaScript switch案例用于必须实现类似菜单的系统的应用程序，在该系统中，基于用户输入采取某些动作。

JavaScript switch:语法

评估条件的表达式写在 switch(表达式)内部，后面跟一个花括号，创建一个定义不同情况的 switch 块。

switch(expression)
{
case 1:
    //code
    break;
case 2:
    //code
    break;
default:
}

根据表达式输出的值，执行许多情况中的一个，然后调用break语句中断执行，退出开关情况。

注: 如果我们不在 switch case 块中的代码语句之后添加break语句，那么解释器将在匹配的 case 之后执行每个案例。

JavaScript 开关案例:示例

在本例中，我们使用switch案例，每个案例都根据提供的值执行。

在上面的例子中，我们使用了break语句来终止开关情况。

不带break的 JavaScript 切换案例示例

break语句的使用是可选的，如果我们不使用它，那么 switch case 不会终止并执行所有剩余的 case，直到匹配的 case 之后结束。请参见下面的示例:

默认情况下

如果开关表达式输出与任何给定情况都不匹配，则执行默认语句。在下面的例子中，我们展示了这个场景:

至此，我们已经介绍了 JavaScript switch 语句。虽然if else语句在大多数情况下很流行并被使用，但在某些情况下使用switch语句会使代码更具可读性和可伸缩性。所以明智地选择，什么时候用什么。

JavaScript break和continue语句

原文：https://www.studytonight.com/javascript/javascript-break-and-continue-statements

JavaScript break和continue语句被称为循环控制语句，因为它们用于控制循环。这些语句让您可以控制 JavaScript 代码中的每个循环和switch语句，使您能够完全脱离循环或直接跳到下一个迭代，跳过当前正在进行的循环迭代。

无论何时需要，我们都可以通过使用break语句退出任何循环的执行，我们也可以通过使用continue语句跳过当前迭代并开始下一次迭代。

JavaScript break语句

大家可能还记得break语句是在开关盒中引入的，这个语句也可以用在其他循环中，比如循环的和循环 while/do-while 循环。

让我们再次回忆一下break语句，break语句让我们脱离循环执行或任何switch语句，并在循环或切换结束后继续执行代码。

这里有一个简单的例子，

在上面的例子中，当变量count的值被 5 整除时，我们脱离循环，因此循环执行停止。尝试删除break语句，您将看到循环将被执行 10 次。

JavaScript continue语句

continue语句可用于跳过当前循环迭代，如果满足循环条件，则跳转到下一次迭代。这是在这样的情况下使用的，对于循环执行中的某些特定条件，您想要不执行任何操作并直接跳转到下一个迭代，那么可以使用continue语句。

让我们举个例子，

在上面的代码示例中，每当变量count的值被 2 整除时，我们什么都不做，调用continue语句直接跳到循环的下一次迭代。因此，您可以看到document.write代码仅针对那些count变量的值不能被 2 整除的迭代执行，这意味着仅针对奇数。

JavaScript 标签

通过使用 JavaScript 标签，您可以更精确地控制代码的执行流程。其中break和continue语句只能用于中断或跳过循环或切换情况下的代码块迭代，使用带有break和continue语句的标签可以控制任何代码块的执行。

要使用 JavaScript 标签，您必须首先定义一个标签，它只不过是一个后跟冒号(:)的名称，然后是您的代码。

然后 JavaScript 标签可以通过写break或continue后跟标签 _ 名称来使用。

让我们举个例子来理解这一点。

如上例所示，我们指定了一个名为 EXECUTE 的标签，然后将其与break语句一起使用，以指定要脱离哪个代码块。

在本教程中，我们学习了break和continue语句，这两个语句在控制循环内或循环外的代码执行流程时非常重要。

JavaScript 高级

JavaScript 字符串

原文：https://www.studytonight.com/javascript/javascript-strings

在 JavaScript 中，字符串是一系列字符，可以是字母、数字或特殊字符，可以简单地用引号括起来，也可以使用String全局对象创建。字符串的例子有“今晚学习”、“今晚学习”、“ 1234 ”、“ @#@# ”等。

我们将介绍在 JavaScript 中创建字符串的各种不同方式，以及我们可以对 JavaScript 字符串执行的各种操作，同时介绍一些最常见和最有用的String内置函数。

String对象是包装器类，也是全局对象的成员。String是 JavaScript 中用于文本处理的主要全局 obejct。

创建 JavaScript 字符串的方法

在 JavaScript 中，基本的字符串字面值也被视为字符串，我们可以将 string 全局对象的属性和方法用于字符串字面值。因此，我们可以说 JavaScript 为我们提供了创建字符串的不同方式，它们是:

  1. 使用基本字符串或使用String构造器

  2. 使用字符串全局对象-使用new关键字。

JavaScript 将字符串字面值视为原始字符串类型，使用字符串字面值或String构造器创建，而使用new关键字创建的字符串被视为String对象。但是 JavaScript 会自动将原始字符串类型转换为 String 对象，这样我们就可以将 string 全局对象的属性和方法一起使用了。

使用字符串字面值

为了创建一个字符串，我们可以使用一个单引号或者一个双引号来封闭字符序列。请参见下面的示例:

let str = "Studytonight";   // double quote
let newstr = 'JavaScript';   // single quote

我们还可以使用连接，即使用+运算符，或者使用反斜杠字符来定义多行字符串。让我们看看两者的例子。

使用字符串连接:

let longStr = "This is a long string" +
              " which is easy to define" +
              " using string concatenation" +
              " or in simple words - joining strings";

使用反斜杠字符:

let longStr = "This is a long string \
which is easy to define \
using backslash character \
like this";

字符串字面值作为模板字面值:

同样，在 ECMAScript2015 中，字符串字面值被称为模板字面值，这意味着我们可以使用${ }语法嵌入表达式。让我们举个例子来看看这个:

let str = 'world!';

// using backticks not single quotes
document.write(`hello ${str}`);

你好世界！

这些是创建字符串字面值的各种方法。

使用字符串构造器创建字符串

如果我们在 JavaScript 中有一个字符序列或任何其他数据类型(甚至是数组)，并且我们想将其转换为字符串基元类型，我们可以使用字符串构造器。以下是它的语法:

String(anything);

让我们举个例子来理解这一点:

在上面的例子中，我们定义了一个数组，然后使用String构造器将其转换为字符串基元类型。我们还使用了typeof运算符来验证数据类型。

使用字符串对象

要创建一个新的字符串对象，我们使用new关键字。

let obj = new String("studytonight");
document.write(typeof obj);

对象

在上面的代码示例中，我们创建了一个新的字符串对象。

字符串作为字符数组

JavaScript String 被视为一个字符数组，我们可以使用索引值访问它的字符，就像我们访问存储在数组中的数据一样。是的，每个字符串都有一个从 0 开始的索引值。

let str = "StudyTonight"; 

let ch1 = str[0];   // Accessing using index
console.log(ch1);   // Output: S

S

同样，我们也可以遍历存储在字符串中的字符序列。

JavaScript 字符串:迭代

由于字符串是字符序列，每个字符都有一个索引，所以我们可以使用 JavaScript 中的循环来迭代它的字符。

let str = "hello"; 

for(let ch of str)
    document.write("<br>" + ch);

h
e
l
l
o

JavaScript 字符串比较

在 JavaScript 中，我们可以通过使用比较运算符来比较字符串值。是的，不需要函数，我们可以使用小于或大于或等于运算符来比较 JavaScript 中的两个字符串。

let str1 = "abc";
let str2 = "abc1";

let isEqual = (str1==str2);

document.write("Are the given two strings equal: " + isEqual);

给定的两个字符串是否相等:假

特殊字符

JavaScript Strings 支持在字符串内部使用引号，只要它们与字符串周围的引号不匹配，例如:“这是一个字符串‘这是字符串内部的引号’”这个字符串是有效的，因为字符串是使用双引号创建的，内部我们使用了单引号，但是在这种情况下，如果我们想要在字符串内部添加双引号，我们将不得不使用转义字符。

如果在字符串内部和周围使用相同的引号，那么字符串将被切成两半，因为它将把字符串内部使用的引号视为结束引号，为了避免这种情况，反斜杠转义字符(\)被用作转义字符。

JavaScript 中有各种转义符号:

  1. \' -避开单引号

  2. \" -避开双引号

  3. \\ -转义反斜杠本身

还有一些特殊的字符:

  1. \b -退格

  2. \f -表单馈送

  3. \n -纽琳

  4. \r -回车

  5. \t -水平制表器

  6. \v -垂直制表器

字符串字面值和字符串对象之间的区别

虽然我们在开头就已经解释了这一点，但让我们举几个例子来看看两者之间的区别。当我们定义字符串字面值或字符串对象时，如上所述，我们可以使用typeof运算符来查找给定变量存储的是基元类型字符串还是字符串对象。

let str = "This is a string";
let strObj = new String("This is also a string");

console.log(typeof str);
console.log(typeof strObj);

弦
物体

此外，当我们使用 eval()函数时，基元类型被视为源代码，其中一个字符串对象被视为另一个对象。让我们看一个例子:

let str1 = '2 + 2'              // creates a string primitive
let str2 = new String('2 + 2')  // creates a String object
console.log(eval(str1))         
console.log(eval(str2))

4
2 + 2

如您所见，第一个字符串被计算为表达式，而 string 对象只是按原样打印。

至此，我们已经完成了对 JavaScript 字符串的基本介绍，涵盖了基本字符串类型和字符串对象以及一些常见的操作，如迭代等。在下一个教程中，我们将介绍 JavaScript 字符串类型的最常见方法。

JavaScript 字符串方法

原文：https://www.studytonight.com/javascript/javascript-string-methods

JavaScript String 全局对象原型提供了预定义的方法和属性来处理与字符串相关的操作，使开发人员更容易执行文本处理。在本教程中，我们将通过代码示例讨论一些最有用的字符串方法。

JavaScript 字符串concat(str)方法

该方法的语法为str1.concat(str2)，用于连接两个字符串str1和str2，并返回连接后的字符串作为结果。

字符串concat()方法示例:

下面我们有一个简单的代码示例来查看concat()函数的运行情况:

let a = "Welcome to Studytonight";

let b = " to learn JavaScript";

let c = a.concat(b);

console.log(c);   // writes "Welcome to Studytonight to learn JavaScript"

这个函数就像串联运算符+一样，也用于连接两个字符串。

JavaScript 字符串toLowerCase()方法

此方法用于将字符串转换为小写字母。这是一个简单的函数，一次对一个字符串进行操作，并将其所有字母字符转换成小写。让我们举个例子，

let a = "WELCOME";

let b = a.toLowerCase();

console.log(b);   // Logs: welcome

欢迎

JavaScript toUpperCase()方法

此方法将字符串转换为大写字母，并以大写形式返回结果。让我们举一个例子:

let x = "studytonight";

let y = x.toUpperCase();

console.log(y);

今晚学习

JavaScript 字符串search()方法

此方法搜索给定字符串值中的字符串或字符串的一部分(子字符串)，并返回要搜索的子字符串第一次出现的位置。

使用search()函数的语法是str1.search(searchStr);，其中str1是我们要在其中搜索searchStr字符串的字符串。

let str =  "Please locate where locate occurs!";

console.log(str.search("locate"));    // Logs: 7

7

JavaScript 字符串slice()方法

JavaScript String slice()方法用于提取字符串的一部分(一个子字符串)，它将提取的部分作为新字符串返回。该方法采用两个参数，起始指标位置和结束指标位置(其中结束指标不包含在输出中)。

如果参数为负，则从字符串末尾开始计算位置。

让我们举个例子来理解:

let a = "Orange Banana Mango";

let subA = a.slice(7,14);   //result of subA will be Banana 

console.log(subA)

香蕉

在上面的例子中，我们使用了slice()方法来提取字符串的一部分，从第 7 个索引开始，也就是 B 字符，直到第 14 个索引，也就是直到香蕉之后的空格。

现在让我们尝试负指数:

let a = "Orange Banana Mango";

let subA = a.slice(-7,19);   //result of subA will be "a Mango"

console.log(subA)

芒果

在上面的代码示例中，我们将第一个索引指定为-7，因此它将从末尾开始计数，将第二个索引指定为正数，因此它将从前面开始计数。您也可以同时使用两个负值。

JavaScript 字符串split()方法

它用于根据给定的分隔符(如空格、连字符等)拆分字符串，并返回一个包含字符串断开部分的数组。让我们举个例子来理解它是如何工作的:

let str = "x,y,z,u,v";   // this is a string

let arr = str.split(",");   //split based on commas

console.log(arr[0]);   // Logs: x
console.log(arr[1]);   // Logs: y

x
y

JavaScript 字符串charAt()方法

此方法返回字符串中指定索引(位置)处的字符。它以索引值为自变量。

让我们举个例子看看:

let str = "Hello Studytonight";

let s = str.charAt(0);   //returns H
console.log(s);

H

JavaScript 字符串trim()方法

trim()方法从字符串的开头和结尾移除多余的空格。让我们举个例子来理解它是如何工作的。

let str = "          Hello StudyTonight JavaScript!                         ";

console.log(str.trim());

你好今晚学习 JavaScript！

在上面的例子中，我们有一个字符串，在前面和末尾有额外的空格。所以我们用trim()的方法去除它们。这个方法应该是用来验证和修改用户在表单中的输入来删除用户在任何表单值中添加的不必要的空格。

JavaScript 字符串replace()方法

JavaScript 字符串replace()方法用给定字符串中的另一个值替换字符串的指定部分(子字符串或字符)。默认情况下，该方法仅替换子串的第一次出现，这意味着如果要替换的子串在主串中出现两次，则仅替换第一次出现的子串，并且该方法区分大小写。

让我们举个例子来理解它是如何工作的:

let txt = "please visit google";

console.log(txt.replace("google", "StudyTonight"));

let newTxt = "Try to Google 'Google'";

console.log(newTxt.replace("Google", "Bing"));

请访问今晚的学习
尝试搜索“谷歌”

如上例所示，只有第一个出现的子串“Google”被替换，而第二个保持不变。

JavaScript 字符串substring()方法

这个方法类似于slice()方法。唯一不同的是substring()方法不接受负指数。在这个方法中，我们可以通过提供开始和结束索引来提取出主字符串的一部分。让我们举个例子:

let str = "C,JAVA,PYTHON";

let res = str.substring(2,6);  

console.log(res)   // Logs: JAVA

JAVA

JavaScript 字符串substr()方法

substr()方法与slice()方法相似，因为它也采用负值作为索引，但有一点不同。substr()方法将要提取的字符串长度作为第二个参数。例如，您可以指定从索引 2 开始，选择长度为 7 的字符串，这意味着直到索引 9。

让我们举个例子来理解这一点:

let fruits = "Apple, Banana, Kiwi, Orange";

let substr = fruits.substr(6,6);
console.log(substr);

香蕉

JavaScript 字符串内置方法:

下面是内置的字符串全局对象方法，我们可以使用 JavaScript 字符串。

方法 描述
夏拉特()

| 返回指定索引(位置) |

处的字符 |
| charCodeAt() |

| 返回指定索引处字符的 Unicode |

|
| 代码点 At() | codePointAt()方法返回一个非负整数，即 Unicode 代码点值。 |
| concat() |

| 它加入两个或多个字符串，并返回一个新加入的字符串 |

|
| endsWith（） |

| 检查字符串是否以指定的字符串/字符结束 |

|
| 包括() |

| 它检查一个字符串是否包含指定的字符串/字符 |

|
| 索引（） |

| 它返回字符串中第一个发现的指定值出现的位置 |

|
| lastIndexOf() |

| 它返回字符串中指定值最后一次出现的位置 |

|
| localeCompare() |

| 它比较当前地区的两个字符串 |

|
| 匹配() |

| 在字符串中搜索正则表达式匹配项，返回匹配项 |

|
| 重复() |

| 它返回一个新字符串，该字符串具有一个现有字符串的指定数量的副本 |

|
| 替换() | 它在字符串中搜索指定的值或正则表达式，并返回替换指定值的新字符串 |
| 搜索() | 它在字符串中搜索指定的值或正则表达式，并返回匹配的位置 |
| 切片() |

| 它提取一个字符串的一部分并返回一个新的字符串 |

|
| 拆分() |

| 它将一个字符串拆分成一个子字符串数组 |

|
| 开始开关() |

| 它检查字符串是否以指定字符开始 |

|
| 子字符串() | 它从字符串中提取字符，从指定的开始位置开始，通过指定数量的字符 |
| toLocaleLowerCase（） |

| 它把一个字符串转换成小写字母，根据宿主的语言环境 |

|
| toLocaleUpperCase() |

| 它把一个字符串转换成大写字母，根据宿主的语言环境 |

|
| toLowerCase() |

| 它把一个字符串转换成小写字母 |

|
| toString() |

| 它返回一个 String 对象的值 |

|
| toUpperCase() |

| 它把一个字符串转换成大写字母 |

|
| 修剪() |

| 它删除字符串两端的空白 |

|
| valueOf() |

| 它返回一个 String 对象的原始值 |

|

在本教程中，我们介绍了开发中最常用的重要字符串方法。

JavaScript 数组

原文：https://www.studytonight.com/javascript/javascript-array

JavaScript Array 也类似于数据类型，用于将一个或多个相似类型或不同类型的值存储在一起。它就像一个容器，用于在单个变量中存储值。我们可以使用数组来存储字符串类型、整数类型、对象或 JavaScript 中的任何其他有效数据类型的值，或者所有这些值。

JavaScript 中的数组是“非”提供的连续内存位置来存储其值。在 JavaScript 中，我们在声明数组时不必提供数组的长度，是的，我们可以简单地声明一个空数组，然后在其中添加任意多的元素。数组是类似列表的对象，在其原型中定义了许多内置函数，用于访问元素、添加元素、数组遍历等。

JavaScript 没有定义数组的特定数组数据类型。但是，有一个预定义的Array对象及其处理数组的方法。数组在 JavaScript 中也有类似length的属性，它不是函数而是属性。

我们可以通过使用new关键字或者使用数组字面值符号即[](方括号)来创建 JavaScript 数组。

使用字面值符号的 JavaScript 数组

我们也可以使用数组字面值符号创建一个数组。数组字面值符号是括在方括号内的逗号分隔的项目列表。

使用数组字面值符号创建数组的语法:

使用数组字面值符号创建数组比使用new关键字创建数组简单。

var arr = [ ];  // empty array

var fruits = ["mango","apple","orange","guava"];  // Array having elements

让我们举个例子，看看如何使用数组字面值符号创建一个简单的数组。

<script>
    var arr = ["Yamaha","Honda","KTM"];
    console.log(arr.length)
</script>

3

正如您在上面的代码示例中看到的，我们使用了数组的length属性来打印其中存在的元素的计数。数组的length属性在遍历数组时使用非常频繁。

使用new的 JavaScript 数组

  • 每当我们不知道要插入数组中的元素的确切数量时，我们就创建一个空数组。

  • 可以使用new关键字创建一个空数组。

  • 然后我们可以使用push()方法在数组的末尾添加元素，或者使用unshift()方法添加到数组的前面。在 JavaScript 中，有许多不同的方法可以将数据添加到数组中。

创建数组的语法:

以下是使用new关键字创建数组的语法。

let arr = new Array(); // empty array

let arr = new Array(10); // array of 10 elements size

let arr = new Array("Java","C","C++"); // array with 3 values

现在，让我们举一个简单的例子来看看这是如何实现的。

<script>
    let fruits = new Array("mango","apple","banana","guava");
    console.log(fruits);
</script>

[“芒果”、“苹果”、“香蕉”、“番石榴”]

JavaScript 数组:访问元素

我们可以通过使用存储数据元素的索引值来访问数组元素。存储在数组中的任何数据元素都存储在索引处。数组索引从 0 开始，一直到值(Array.length - 1)。因此，第一个元素将存储在索引值 0 处，最后一个元素存储在索引值(Array.length - 1)处

let fruits = ["mango","apple","orange","guava"];   // Array having elements

console.log(fruits[0]);   // Accessing element
console.log(fruits[1]);   // Accessing element
console.log(fruits[fruits.length-1]);   // Accessing element

芒果
苹果
番石榴

JavaScript 数组:遍历还是迭代

由于数组是一个对象，我们可以使用for循环迭代它的元素。在我们之前的教程中，我们已经介绍了循环 T2 的 JavaScript。我们在下面的例子中使用了 for-of 循环，但是您也可以使用简单的 for 循环。

let fruits = ["mango", "apple", "orange", "guava"];  // Array having elements
for(f of fruits)    // Traversing array 
	document.wrtie(f + " ");

芒果苹果橘子番石榴

对于初学者，让我们看看一个使用基本的进行循环的数组遍历的例子，

let fruits = ["mango", "apple", "orange", "guava"];  // Array having elements
// Traversing array 
for(let i=0; i < fruits.length; i++)    
{
	document.write(fruits[i] + " ");
}

阵列forEach功能:

要在数组上循环，我们也可以使用数组函数forEach，它是在其原型定义中定义的。让我们看一个例子，

let bikes = ["Honda", "KTM", "Yamaha"];
// using forEach function
bikes.forEach(function(item, index, array) {
    document.write(item, index);
})

本田 0
【ktm 1】
雅马哈 2

JavaScript 数组对象方法

下面我们已经指定了一些流行的方法，用于在 JavaScript 中对数组执行各种操作，比如添加新元素、移除元素、搜索元素的索引等。

1.concat():连接两个或多个数组，并返回连接的数组。

2.join():将数组的所有元素连接成一个字符串。

3.pop():移除数组的最后一个元素并返回该元素。

4.reverse():反转数组中元素列表的顺序。

5.shift():移除数组的第一个元素并返回该元素。

6.slice():选择数组的一部分，并将该部分作为新数组返回。

7.sort():对数组的元素进行排序。

8.push():添加新元素作为最后一个元素，返回新数组的长度。

9.unshift():向数组中添加新元素并返回新长度。

10.splice():添加或移除数组的元素。

11.fill():用静态值将元素填充到数组中。

12.every():判断一个数组的所有元素是否满足提供的函数条件。

13.isArray():检查值是否为数组。

14.indexOf():求数组中某个元素的索引。

15.forEach():循环数组值。

除此之外，还有更多可用的阵列原型功能。让我们来看看其中的一些功能:

1.添加一个元素作为数组的最后一个元素

let bikes = ["Honda", "KTM", "Yamaha"];
bikes.push("Triumph");
console.log(bikes);

【本田" " KTM " "雅马哈" "凯旋】

2.添加一个元素作为数组的第一个元素

let bikes = ["Honda", "KTM", "Yamaha"];
bikes.unshift("Triumph");
console.log(bikes);

【凯旋】【本田】【KTM】【雅马哈】

3.查找数组元素的索引

let bikes = ["Honda", "KTM", "Yamaha"];
// use console.log or document.write for output
console.log(bikes.indexOf("KTM");

1

4.反转数组

let bikes = ["Honda", "KTM", "Yamaha"];
console.log(bikes.reverse());

【山河】、【KTM】、【本田】

同样，你可以在下面给出的直播终端中尝试各种功能。

JavaScript 数组实时示例:

现在让我们来看看一些 JavaScript Array 代码的实际应用。在下面的终端中，我们已经声明了一个数组，并实现了一个遍历数组的循环。现在，请尝试使用上述功能，看看它们是如何工作的。练习代码将帮助您更快地掌握概念。

在本主题中，我们解释了 JavaScript Array 及其功能，以及通常在 Array 上执行的各种操作。我们已经介绍了多个代码示例来帮助您理解这个概念。

JavaScript 正则表达式

原文：https://www.studytonight.com/javascript/javascript-regular-expression

在 JavaScript 中，正则表达式也称为正则表达式，是用于匹配、替换、比较字符串中的字符组合的模式。

当我们在文本中搜索一些特定的数据时，我们可以使用正则表达式作为搜索模式来描述您正在搜索的内容。

正则表达式可以是单个字符，也可以是更复杂的模式。

我们可以使用正则表达式执行任何类型的文本搜索和文本替换操作。

在 JavaScript 中使用正则表达式有两种不同的方式，它们是:

  1. 使用正则表达式对象的构造器

  2. 使用正则表达式字面值

在本教程中，我们将涵盖正则表达式字面值，并在涵盖 JavaScript 对象时详细涵盖 RegExp对象。

JavaScript 正则表达式文本:语法

我们可以使用正则表达式字面值，它由括在斜线之间的模式组成，如下所示:

/*pattern*/*modifiers*;

正则表达式文本在脚本加载时编译。

在上面的语法中，模式可以是任何文本或字符串组合，其中修饰符/标志由 Javascript 提供。下面给出了一些标志。

|

【标志】t1㎡

|

描述

|
| --- | --- |
| i | 它用于执行不区分大小写的搜索。 |
| g | 它用于搜索所有匹配项，如果没有它，则只返回第一个匹配项。 |
| m | 搜索多行模式。 |
| s | 启用允许点的“点全”模式。匹配换行符\n。 |
| u | 启用完全 unicode 支持。 |
| y | 在文本中的准确位置搜索。 |

通常，正则表达式用于根据模式验证字符串，或者从字符串中提取特定的子字符串，或者检查字符串是否包含特定的子字符串，为了检查这一点，我们使用RegExp.test()函数。

JavaScript 字符串test()、replace()和match()功能:

test()函数与提供字符串作为参数的正则表达式模式一起使用。使用test()函数的语法是:

let re = "/SOME-EXPRESSION/";
let str = "some string";
// using test() function
let result = re.test(str);    // returns true on match else false

就像我们在上面的例子中使用test()函数来检查特定的字符串模式是否存在于给定的字符串中一样，当我们必须用其他字符串值替换字符串模式时，我们使用replace()函数和match()函数来匹配并返回匹配字符串。

让我们看几个例子来理解如何在 JavaScript 中使用正则表达式。

使用正则表达式字面值搜索

让我们在任何给定的字符串中使用正则表达式来搜索字符串“hello”。请参见下面的代码示例:

<script>
	let re = /hello/;
	let str = "Hello Studytonight";
    // test() function is used with regular expression
	let result = re.test(str);
	document.write(result)
</script>

假

在上面的例子中，我们执行了一个搜索，在给定的字符串中寻找一个子字符串模式。在这里，我们没有使用任何标志，所以默认情况下执行区分大小写的搜索，这就是为什么我们得到的结果是 f 也是。

使用正则表达式字面值搜索-忽略大小写

我们可以在忽略字符串大小写的情况下执行搜索，如果我们想搜索一个可能的模式，但我们并不是在寻找一个完全匹配的模式。对于使用正则表达式在字符串中执行不区分大小写的搜索，我们将使用 i 标志来启用忽略大小写的搜索。请参见下面的示例:

<script>
	let re = "/hello/i";
	let str = "Hello Studytonight";
	let result = re.test(str);
    // use console.log or document.write
	document.write(result);
</script>

真

使用正则表达式替换字符串

在本例中，我们将用另一个字符串替换一个字符串模式。要替换字符串，我们将使用字符串对象的replace()方法，而不是test()方法。

<script>
		// Creating regex literal
	    let re = "/(\w+)\s(\w+)/"
        let str = 'Delhi Noida';
        // Replacing string
        let newstr = str.replace(re, '$2, $1');
        document.write(newstr);
</script>

订婚，德里

在字符串中搜索模式

这里，我们使用match()方法进行搜索。如果匹配，此方法返回匹配的字符串。请参见下面的示例:

<script>
		// Creating regex literal
		var regex = "/India/g";
        var str = "We live in India.";
        // search for india
        var matches = str.match(regex);
        document.write(matches)
</script>

印度

JavaScript 正则表达式文本:验证电子邮件

JavaScript 中的正则表达式用于验证输入表单值，如电子邮件地址、密码、zipcode 或任何其他值。

让我们创建一个正则表达式来验证电子邮件地址，并使用它来检查给定的电子邮件地址是否有效。您可以很容易地在互联网上找到正则表达式来验证各种类型的输入。

let str = "abc@gmail.com";
// regex pattern to match valid email
let re = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/
// test the 
let result = re.test(str);
if(result)
    document.write("Email is valid")
else
    document.write("Email is not valid")

邮件有效

在本教程中，我们学习了正则表达式，以及如何在 JavaScript 中使用它们来匹配字符串模式、替换字符串、验证用户输入等。我们在这里学到的是创建正则表达式的字面方法(就像在 array 中有两种方法一样)，我们也可以使用 JavaScript 中的正则表达式原型创建正则表达式对象。我们将在讨论 JavaScript 对象时了解它。

JavaScript 弹出框

原文：https://www.studytonight.com/javascript/javascript-popup-boxes

JavaScript 提供了各种弹出框来通知、警告或获取用户的输入。弹出框阻止用户访问程序的其他方面，直到弹出框关闭，因此不应过度使用。

JavaScript 中使用了三种不同的弹出方法。

  • 警告框

  • 确认框

  • 提示席

JavaScript 警告框

警报对话框主要用于通过在一个小对话框中显示一些消息来通知或提醒用户。以下是它的语法:

alert("YOUR MESSAGE COMES HERE");

让我们举个例子来看看它是如何运作的。

`## JavaScript 确认框

一个确认框用于让用户进行选择。当 Javascript 弹出确认框时，用户需要点击【确定】或【取消】才能进入下一步。

此外，根据用户点击的内容，我们可以执行不同的操作。我们可以用条件逻辑来说明这一行动过程。

let result = window.confirm("SOME TEXT MESSAGE");

当用户点击确定按钮时，结果变量将获得值真，如果用户点击取消按钮，结果变量将获得值假。

让我们举个例子，看看这是怎么回事:

`## JavaScript 提示框

当我们想要获得一些用户输入时，可以使用 Javascript 提示框。当 Javascript 显示一个提示框时，用户会看到一个弹出框，其中有一个输入字段和按钮【确定】或【取消】在输入一个输入值后继续。

以下是 JavaScript 提示框的语法:

let result = prompt("SOME MESSAGE", "DEFAULT_VALUE");

这里部分消息是弹出框中显示的消息，默认值是输入字段中的默认值。默认值是一个可选字段。

提示返回的值取决于用户对对话框的具体操作。

JavaScript 弹出框使用:

现在我们已经知道了可以在 JavaScript 中创建和使用的三个弹出框，让我们来介绍几个可以使用它们的用例。

JavaScript Alert 框可用于显示任何错误消息或任何帮助消息。例如，如果您执行表单字段验证，并且您发现某些字段值不正确，您可以显示带有消息的警告框，通知用户输入不正确。

JavaScript Confirm box 是确认任何重要用户动作的好方法，比如如果我们的 web 应用程序中有一个功能，当点击一个按钮时，我们会向服务器发出一个 AJAX 调用，从数据库中删除一些数据，在这种情况下，最好在点击按钮时确认一次，以便在误操作时给用户第二次机会来确认或取消请求。因此，对于重要的操作，我们应该使用确认弹出框。

JavaScript 提示框可用于创建类似系统的菜单，其中基于用户输入，使用 JavaScript switch 语句执行不同的动作。让我们用一个简单的代码示例来演示这一点:

在本教程中，我们介绍了 JavaScript 弹出框，如警告框、确认框和提示框。您可以使用它们来提高应用程序的响应速度。

    • *``

JavaScript 函数

原文：https://www.studytonight.com/javascript/javascript-functions

JavaScript Functions，就像任何其他语言一样，是一组用于执行特定任务的语句，例如添加两个数字、查找数字的平方或任何用户定义的任务。

让我们举个例子来理解函数的概念。如果您正在构建一个学生管理应用程序，其中您在注册过程中从学生那里获取数据，然后在身份证打印、标记页打印、任何通知打印或其他任何地方使用这些数据，那么一种方法是，无论您在哪里想要学生数据，您都可以使用学生 id，查询数据库并找到关于学生的所有信息。你将不得不在任何你想要学生信息的地方写同样的代码。但是这将导致代码重复，如果你不得不改变获取学生数据的逻辑，你将不得不到处进行改变。

JavaScript Function concept

这个问题的更好的解决方法是定义一个函数，该函数以学号作为输入，查询数据库并返回学生数据作为输出，然后只需调用就可以在任何我们想要的地方使用这个函数。现在，如果你必须改变逻辑中的一些东西，你可以很容易地做到。

函数:定义

现在你有了一个想法，什么是函数，让我们看看它的定义，以及我们如何定义函数，基本的函数结构，以及在 JavaScript 中使用函数。

JavaScript 函数是一组用于执行特定任务的语句。它可以接受一个或多个输入，也可以返回输出。获取输入和返回输出都是可选的。

使用函数避免了代码的重复，因为我们只需要编写一次代码，然后就可以使用函数名在任何地方调用代码。在以下情况下，函数可能会有所帮助。

  • 例如，假设您想要添加一些数字并在网页上显示结果。在这种情况下，您可以定义在函数中添加数字的代码，并在需要时调用该函数。

  • 对于重复的任务，比如每当网页被加载到浏览器中时显示一条消息，我们可以使用函数。

下图显示了一个 JavaScript 函数的结构:

JavaScript function structure

如前所述，函数可以是参数化的和非参数化的，这意味着它们可以接受也可以不接受任何输入。不接受任何参数/输入的函数称为非参数化函数。

接受参数/输入的函数必须在括号内用函数名定义(在函数定义之前)，称为参数化函数。当我们调用一个函数时，我们可以为这些参数提供自定义值，然后在函数定义中使用。

要从函数返回输出，我们使用return语句。

大体上，我们可以将函数分为两类:

  1. 用户定义的函数

  2. 内置函数

本教程将主要关注用户定义的函数，因为内置函数是 JavaScript 库函数，我们可以在脚本中随时调用它们来使用它们。

用户定义函数

如上所述，JavaScript 允许我们根据自己的需求定义自己的函数。让我们了解如何创建自己的函数，并在脚本中调用它们来使用它们。

创建用户定义的函数:

在 JavaScript 中，函数是通过使用function关键字后跟函数名和括号( )来定义的，以保存参数(输入)。一个函数可以有零个或多个参数，用逗号隔开。

函数体被括在花括号中，就在函数声明部分(函数名和参数)之后，在函数体的末尾，如果我们愿意，我们可以有一个return语句来返回一些输出。

以下是 JavaScript 用户定义函数的语法:

function function_name(parameter-1, parameter-2,...parameter-n)
{
    // function body
}

其中，函数名代表函数名，参数-1，...，参数-n 代表参数列表。

调用用户定义的函数:

创建函数后，我们可以在脚本中的任何地方调用它。调用函数的语法如下:

function_name(val-1, val-2, ..., val-n);

这里，参数列表表示在函数调用期间传递给函数的值，函数已经在函数定义中指定了这些值。如果一个函数没有任何参数，那么我们在调用该函数时就不必提供任何值。

用户自定义功能return语句:

一个函数可能有也可能没有return语句，因为不是所有函数都返回输出。return语句用于指定函数返回的值/结果/输出。

在函数定义中有一个return语句是完全可选的。执行return语句是函数的最后一个动作，在执行return语句之后，执行控制传递回调用语句，这意味着执行控制退出函数。

以下是使用 return 语句的语法:

return value;

return关键字返回调用语句的值。

用户定义函数示例:

理论讲够了，现在我们来看一些例子。

<html>
    <head>
        <script>
            function mySumFunction(a, b)
            {
                // return the result
                return a+b;
            }

            let x = myFunction(8, 7);
            alert(x);
        </script>
    </head>
</html>

上面我们定义了一个简单的函数来求两个数的和并返回结果。让我们再举一些例子来看看 JavaScript 用户定义函数的作用。

在下面的用户定义函数中，我们只是使用innerHTML属性向一个 HTML 元素添加了一些文本。

带参数的函数示例:在下面的示例中，我们定义了一个简单的乘法函数，该函数将两个数值作为输入，并将它们相乘并返回结果。

另一个函数示例:在下面的示例中，我们有一个名为sum()的函数，它接受三个参数。在调用函数时，当我们为函数参数提供值时，我们将其称为参数。

JavaScript 内置函数

JavaScript 本身作为脚本语言的一部分提供的函数被称为内置函数。JavaScript 提供了一套丰富的库，其中有许多内置函数。内置功能的例子有:alert()、prompt()、parseInt()、eval()等。

作为对象的函数

是的，你读对了。JavaScript 中的函数也被视为对象，可以赋给变量。一旦我们给一个变量分配了一个函数，我们就可以使用变量名来调用这个函数。

让我们举个例子。

let x = function someFunction(y) {
            document.write("Function called with value: " + y);
        }

// we can call the function using the variable now
x(10);

用值调用的函数:10

结论:

在本教程中，我们详细介绍了 JavaScript 函数的概念，包括函数的基础知识、我们为什么需要它们、函数的结构、如何定义它们、如何调用它们，以及示例。

JavaScript 默认参数

原文：https://www.studytonight.com/javascript/javascript-default-parameters

在 JavaScript 中，默认的函数参数是参数，在声明 JavaScript 函数时提供一个默认值。这很有用，因为我们可以为参数提供默认值，如果在调用函数时没有提供值，则可以使用默认值。

因此，如果在函数调用期间没有值或传递了undefined，则默认函数参数用于用默认值初始化命名参数。****

**例如，如果您定义了一个函数，其中如果您提供了两个变量，它将第一个参数与第二个参数相除，并返回除法运算符的结果。现在，如果用户只提供一个参数，那么函数调用将失败。为了避免这种情况，您可以为第二个参数提供一个 defualt 值作为 1，这将把函数调用期间传递的单个参数除以默认值 1，而不是给出一个错误。

默认情况下，如果函数参数在函数调用期间没有被提供值，则在其中设置undefined。

JavaScript 默认参数语法:

以下是默认函数参数的语法:

function function_name([param1[ = defaultValue1][, ..., paramN[ = defaultValueN ]]]) 
{
    statements
}

这里需要注意的一点是，如果一个函数中有多个参数，比如说 2，你为第一个参数提供了默认值，而第二个参数没有默认值，那么在调用过程中，如果用单个参数调用该函数，它将被分配给第一个参数(有默认参数值的参数)，第二个参数将获得未定义的值，这是因为，参数分配是从左到右进行的。所以在默认参数之后不应该有没有默认值的参数。

例如，

function printValue(a=1, b) {
    console.log("a = " + a + " and b = " + b);
}

printValue();    // Logs: a = 1 and b = undefined
printValue(7);    // Logs: a = 7 and b = undefined
printValue(7, 3);    // Logs: a = 7 and b = 3

在上面的代码中，当我们在调用函数时没有提供参数时，a使用了它的默认值，而b没有定义。然后，我们在调用函数的时候提供了一个参数，这个参数被赋值给了第一个参数a，因为参数的参数赋值是按顺序进行的，所以b又一次被欠训练了。

因此，一般来说，如果您不想为其他参数提供默认值，我们建议不要为第一个参数提供默认值，因为这会使您的代码变得混乱。

JavaScript 默认参数示例

在这个例子中，我们正在为参数设置默认值，并在没有参数的情况下调用它。

// default function parameters

function add(a=10, b=20)
{
	return a+b;
}

console.log(" Sum is : " + add());   // No argument
console.log(" Sum is : " + add(1));   // with one argument
console.log(" Sum is : " + add(5,6));   // with both argument

总和为:30
总和为:21
总和为:11

带有null或空参数的 JavaScript 默认参数

如果我们没有为函数参数提供任何值，那么就使用默认值，但是如果有人提供 null 或空字符串作为值呢。在这种情况下null和空值被认为是有效的，并且不使用默认参数值。

让我们举个例子来看看这个:

function test(a = 1)
{
    console.log(typeof a);
    console.log("Value of a: " + a);
}

test();    // Logs: number Value of a: 1
test(undefined);    // Logs: number Value of a: 1

test('');    // Logs: string Value of a: 
test(null);    // Logs: object Value of a: null

正如我们在上面的例子中所看到的，不为参数提供任何值并且提供undefined作为值，两者都将导致函数使用默认参数值，但是当我们提供一个空字符串作为参数时，或者如果我们提供null作为参数，那么两者都被认为是有效值，并且被用作参数值而不是使用默认值。

默认参数在调用时计算

这是要考虑的默认参数的另一个重要特性。每次调用函数时都会创建 JavaScript 默认参数，这些参数不会被重用。让我们举个例子来理解这一点:

function append(value, array = []) {
    array.push(value)
    return array
}

append(1)  // [1]
append(2)  // [2], not [1, 2]

JavaScript 默认参数实时示例

让我们再举一个例子来看看缺省参数在 JavaScript 函数中的用法:

因此，在本教程中，我们学习了默认参数的概念。这是一个有用的概念，可以帮助您更好地发挥功能。在下一个教程中，我们将学习什么是休息参数，这是另一个重要的概念。

JavaScript 剩余参数

原文：https://www.studytonight.com/javascript/javascript-rest-parameters

JavaScript Rest Parameters 为我们提供了一种声明函数的方法，该函数可以接受无限数量的参数，这些参数可以作为数组使用。用简单的语言，我们可以用 Rest Parameters 定义一个 JavaScript 函数，这个函数没有固定数量的参数，在被调用时可以接受任意数量的参数。

比如我想写一个泛型的 sum 函数，可以用来加任意数量的值，这意味着它应该适用于sum(1, 2)函数调用、sum(1,2,3)函数调用、sum(1,2,3,4)函数调用等。

JavaScript 剩余参数语法

要使用 Rest 参数语法，我们需要在定义函数时将...作为前缀添加到最后一个参数的名称中。

function func_name(a, b, ...restArgs) {
    // statements
}

当我们这样做的时候，所有额外的参数都作为一个数组提供给函数，然后可以在函数定义中访问它。

注意: 只有最后一个参数可以是 Rest 参数。

让我们举几个例子，看看剩下的参数是如何起作用的。

JavaScript 剩余参数示例:

在第一个例子中，我们将有一个函数，它将采用一个简单的参数和一个 rest 参数。请参见下面的示例:

当调用test()函数时，尝试提供不同的值作为参数。此外，我们可以为 rest 参数提供单个参数值或不提供参数值，在这种情况下，数组将只有一个值，我们将在函数内部得到一个空数组。

我们再举一个例子，我们将有一个只有 rest 参数的函数。

function sortValues(...theArgs) {
    // using Array method on rest params
    let sortedArgs = theArgs.sort();
    return sortedArgs;
}

console.log(sortValues(11,2,5,13,1,9));

【1，2，5，9，11，13】

在上面的例子中，我们有一个接受单个 rest 参数的函数。还有，由于 rest 参数只是一个数组，所以所有的数组方法都可以在上面使用。

JavaScript 箭头函数

原文：https://www.studytonight.com/javascript/javascript-arrow-function

JavaScript Arrow 函数或 Arrow 函数表达式是常规 JavaScript 函数定义语法的一个更短的替代。它是在 ECMAScript2016 中引入的，它使得定义函数就像编写简单的表达式一样。

箭头函数可以有可选参数和一个返回语句，以及包含在大括号{ }中的函数定义。箭头函数表达式提供了紧凑的语法，但是这会使代码可读性降低。同样，由于它们不太像是函数，而更像是表达式，它们不太适合用于定义方法。它们不能用作构造器。

JavaScript 箭头函数:语法

arrow 函数表达式支持多种不同的语法，我们将看到其中的一些。

(param1, param2, …, paramN) => { statements } 

/* or for a single parameter */

(param1) => { statements } 

/* in case of no parameter */

() => { statements }

在我们有单个参数的情况下，使用参数()是可选的，我们也可以这样定义箭头函数表达式:

param1 => { statements }

而如果我们有一个单独的表达式来返回一些输出，我们甚至可以跳过大括号{}如下:

param1 => { return expression; }
/* can be written as*/
param1 => expression

上述语法也适用于多个参数。

换行符:

箭头函数的参数和箭头之间不能有换行符，但是我们可以在箭头之后有换行符。例如:

var someFunc = (a, b, c)
  => 1;
// SyntaxError: expected expression, got '=>'

var someFunc = (a, b, c) => 
  1;
// No Sytax Error

var someFunc = (a, b, c) => (
  1
);
// No Sytax Error

让我们看一些代码示例。

JavaScript 箭头函数示例:

查看普通 JavaScript 函数和箭头函数表达式之间的区别。让我们从创建一个常规函数开始，然后我们将定义它的箭头函数。

// Example of a regular function
let add = function(a,b) {
    return a+b;
}

let sum = add(10,20);
console.log(sum);

30

现在让我们将上面的函数改为箭头函数表达式:

// Arrow function
let add = (a,b) => { return a+b; }

let sum = add(10,20);

console.log(sum);

30

正如我们在上面的语法中所讨论的，我们可以进一步分解上面的箭头函数表达式，去掉大括号，因为这个表达式只有一个语句代码。

// Arrow function
let add = (a,b) => a+b;

let sum = add(10,20);

console.log(sum);

现在，让我们再举几个涵盖不同场景的例子。

不带参数的 JavaScript 箭头函数:

就像常规函数一样，箭头函数也可以是非参数化的。让我们举个例子来看看如何实现它。

// Arrow function - without parameter
show = () => { return "Hello from arrow function"; }

// Calling function
let msg = show();

console.log(msg);

箭头功能您好

同样，在这个例子中，我们甚至可以删除花括号{}和return关键字，就像我们在上面这个例子中所做的那样。

带默认参数的 JavaScript 箭头函数:

在 JavaScript 箭头函数中，我们还可以在定义箭头函数表达式时指定参数的默认值。让我们举个例子来理解这个概念。

// Arrow function - with default parameters

let sum = (a,b=1) => a+b;

// Calling function
let result = sum(10);
console.log(result);

11

请记住，您不能只为第一个参数提供默认值，也不能为第二个参数提供默认值。要么为两者都提供默认值，要么只为第二个提供默认值。

不带括号的 JavaScript 箭头函数:

在这种情况下，如果函数中只有一个参数，那么可以省略参数周围的括号。让我们举个例子:

// Arrow function without parenthesis
let show = a => "You entered: " + a

console.log(show(10));

你进入:10

JavaScript 箭头函数:实时示例

现在让我们来看一个理解箭头函数的实例。请随意修改代码并更改下面定义的箭头函数以进行实践。

因此，在本教程中，我们学习了如何在 JavaScript 中使用 arrow 函数表达式以简写格式编写函数，这种简写格式易于定义和使用，但有时会导致您的代码变得难以理解。

JavaScript 错误

原文：https://www.studytonight.com/javascript/javascript-errors

JavaScript Errors 被 JavaScript 用来通知开发人员正在执行的脚本中的各种问题。这些问题可能是语法错误，开发人员/程序员使用了错误的语法，也可能是由于一些错误的用户输入或其他问题。

JavaScript 以错误的形式报告这些问题，当您运行 JavaScript 代码时，可以在浏览器控制台中看到这些错误。

例如，如果我运行下面的 JavaScript 代码，

/* 
    try to use variables a and b,
    without defining them
*/
let result = a + b;

未捕获的引用错误:未定义

在输出中可以看到， JavaScript 抛出了一个 ReferenceError ，这意味着没有找到变量a的引用。因为，要使用任何 JavaScript 变量，我们应该首先声明和定义它。

JavaScript 错误类型

现在我们知道了什么是错误，它们可能由于许多不同的原因而发生。让我们看看 JavaScript 中有哪些不同类型的错误，以及几个例子。

每当发生运行时错误时，JavaScript 都会创建一个Error对象并抛出它。Error对象是其他特定错误类型所基于的基础对象。我们还可以在 JavaScript 中定义自定义用户定义的错误类型。

JavaScript Error对象有两个字段:

财产 描述
name 用于设置或获取错误的名称
message 用于设置或获取错误信息

以下是 JavaScript 根据错误类型可以抛出的 6 类Error对象:

错误对象 描述
EvalError 当eval()函数出现任何错误时，JavaScript 都会抛出这个错误。
RangeError 当一个数字或任何其他参数出现超出范围时，JavaScript 会抛出这个错误。
ReferenceError 当您试图使用一些没有声明或定义的变量或对象时，JavaScript 会抛出这个错误。
SyntaxError 当 JavaScript 代码的语法有问题时，JavaScript 会抛出这个错误。
TypeError 当代码中存在类型不匹配时，JavaScript 会抛出此错误。如果 JavaScript 需要某个其他类型的值，并且在代码中得到不同的类型。
URIError 当encodeURI()或decodeURI()函数出现任何错误时，JavaScript 都会抛出这个错误。

JavaScript 抛出错误

每当在 JavaScript 代码执行过程中出现错误，代码执行就会停止，JavaScript 会在控制台中打印一个错误。这也叫抛出错误。这是所有编程语言中使用的标准术语。

JavaScript 在内部捕获错误，然后抛出它，这中断了代码的执行。

如果您想自己在代码中做同样的事情，您想中断代码执行并抛出错误，您可以使用throw语句来完成。

JavaScript throw语句

我们可以在 JavaScript 代码中使用 throw 语句来抛出一个自定义的错误/异常，我们可以在抛出错误时提供一条消息。该消息可以是字符串消息、数字或任何布尔类型(真或假)。让我们举个例子来看看这个:

throw "Some error message";
throw 404;
throw false;

未发现某些错误消息

当遇到throw语句时，代码执行中断，因此只有第一个throw语句被执行。为了处理由 JavaScript 或使用 throw 语句引发的错误，我们有try和catch块，我们将在下一个教程中介绍它们。

JavaScript 自定义错误(用户定义的错误):

在 JavaScript 中，我们也可以定义我们的自定义Error对象。这里我们讨论了 ECMAScript2015 的方式，这是定义用户定义的错误类型的原型方式。

当您运行上述代码示例时，您将在浏览器的控制台中收到一条错误消息。要打开浏览器的开发者工具，请在窗口中按 F12 ，在 Mac OSX 中按命令+选项+ I 。以下是输出:

MyError { name:“MyError”，消息:“这是自定义错误”，堆栈:“新 MyError 处的错误(<匿名> :6:31)

在 ECMAScript2016 中，我们可以定义自定义错误类，这将在后面的教程中介绍。

因此，在本教程中，我们获得了 JavaScript errors 的基本介绍，它的各种不同类型，如何使用 throw 语句抛出错误，以及如何编写自定义的 Error 类型。在下一个教程中，我们将学习如何在 JavaScript 中处理错误和异常。

JavaScript 错误处理-try、catch、finally和onerror事件

原文：https://www.studytonight.com/javascript/javascript-error-handling-try-catch-finally-and-onerror-event

异常是当程序在语法上是正确的时，由于非法操作而在执行时(运行时)发生的错误。例如，每当您试图引用未定义的变量或调用不存在的方法时；将出现异常。

**我们已经介绍了 JavaScript 错误，在本教程中，我们将介绍如何处理 JavaScript 代码中的错误和运行时异常，以避免代码执行突然结束。

因此，异常或错误处理从识别代码开始，我们认为当我们运行它时，代码可能会给出一些错误/异常。这样的代码块可以包含在一个特殊的try块中，这是一个特殊的代码块，如果出现任何运行时异常，那么我们可以在catch块中处理该异常。

要监控异常的语句包含在try块中。如果在try块内发生异常，那么它将被抛出。

您可以通过使用处理异常的catch块来捕获这个抛出的异常。

JavaScript 中处理错误/异常的方法:

在 JavaScript 中处理异常主要有两种方式:

1.使用try、catch和finally语句

2.使用onerror事件

让我们逐一讨论上面给出的处理异常的方法。

JavaScript try和catch语句

在 JavaScript 中，您必须编写这样的代码，如果在运行时生成错误/异常，则该代码位于try块内部，以便可以优雅地处理异常/错误。紧接着，在try块之后，应该有一个catch块，指定您想要捕捉的异常类型。

简单地说，我们要执行的代码语句被保存在 try 块中，后面是 catch 块。这就通知 JavaScript 去尝试执行给定的代码语句，如果有异常发生，抛出，catch 块将捕获异常，然后 catch 块内部的代码被执行。

JavaScript try和catch语法:

让我们看看 try 和 catch 块的语法:

try
{
    // code that can cause an error
}
catch(err)
{
    // what to do when an error occurs
}

在上面的语法中，有两个块try和catch。其中try块包含可能产生错误的可疑代码。如果发生错误，那么try块抛出由catch块捕获的异常，在该异常中我们可以按照自己的意愿处理它。我们可以显示用户可读的信息，也可以在警告框中显示错误信息。

JavaScript try和catch示例:

让我们举个例子来看看 JavaScript try和catch块的作用:

在上面的代码中，我们创建了一个网页，展示了如何使用 try-catch 语句处理异常。它包含两个代码块- try和catch。

在try块中，我们试图打印未定义变量n的值，因此，try块抛出一个被catch块捕获的异常。然后catch块使用err参考显示存储在错误对象中的信息。

注意在try块中，还有一个包含 Hello World 的document.write()函数调用！字符串，该字符串从不执行，因为一旦抛出异常，程序会将控制从try块转移到catch块。

JavaScript finally语句

我们还有一个称为finally语句的可选语句，它与try和catch语句相关联。它用于在执行 try 和 catch 代码块后执行一些代码。JavaScript finally语句确保finally块中的代码语句被执行，无论是什么。

JavaScript finally语句:语法

finally语句用在try和catch语句之后，

try
{
    // code that can cause an error
}
catch(err)
{
    // what to do when an error occurs
}
finally
{
    //code that execute in all the cases
}

不管是否抛出异常，try-catch 语句的可选finally块总是运行其代码。可能有两种情况:

  • 如果try块中的代码运行成功，没有任何异常，那么catch块将不会被执行，但是finally块将被执行。

  • 如果try块有错误，则执行catch块，之后执行finally块

每当控件通过显式的return语句从try或catch块返回调用方方法时，finally块就在控件返回之前执行。

简而言之，无论发生什么，如果你定义了一个finally块，它都会被执行。

JavaScript try、catch和finally示例:

这里我们有另一个在 JavaScript 代码中处理运行时异常并使用finally语句的例子。

在上面的代码中，我们创建了一个显示 finally 块如何工作的网页。上面的代码包含三个块:try、catch 和 finally。try 块生成一个未定义的变量异常，该异常被 catch 块捕获。然后finally块执行并显示 Hello 世界字符串，即使异常已经发生。

处理异常的 JavaScript onerror事件

try-catch 语句未处理的任何错误都会导致在窗口对象上触发onerror事件。onerror事件不创建事件对象，由有错误的窗口调用。

它接受三个论点:

  1. 错误消息

  2. 发生错误的页面的统一资源定位符

  3. 包含错误的行号。

当onerror事件触发时，显示错误信息。网页的 URL，发生错误的行号。

JavaScript onerror事件语法:

以下是使用onerror事件的语法:

window.onerror = function(errmessage, url, line)
{
    alert(errmessage);
}

在上面的代码中，我们使用了 window 对象来调用onerror事件，我们可以为其指定一个事件处理函数。

JavaScript onerror事件示例:

在本例中，我们使用onerror事件处理错误:

至此，我们已经完成了 JavaScript 异常处理教程。在本教程中，我们学习了用于在 JavaScript 代码中处理运行时异常的try、catch和finally语句，并介绍了使用onerror事件处理异常的另一种方式。

JavaScript Cookies

原文：https://www.studytonight.com/javascript/javascript-cookies

JavaScript Cookie 用于在客户端浏览器上存储一些有用的信息，这些信息可以在连续的 HTTP 请求中访问。

cookie 是一个包含信息的小文件，存储在客户端的计算机上，或者更具体地说，存储在客户端的浏览器中。每次当客户端请求网页时，服务器在显示所请求的网页之前参考所创建的 cookie 以获取信息。

让我们举一个简单的例子来理解 cookies 的概念，为什么需要它，以及我们如何使用它。嗯，如果你有一个网站，它没有用户登录系统，在你的网站上你有很多文章。您想在您的网站上添加一个新功能，其中用户已经阅读的文章将在网站上标记为已读。但是由于您没有用户登录系统，因此您无法在服务器(数据库)上保存此用户相关数据。在这种情况下，可以使用 cookies。我们可以创建一个 cookie，并存储在客户端的浏览器中，我们可以在 cookie 中添加用户已经阅读过的文章的网址(或其他标识)。当用户再次访问任何文章时，我们可以首先检查 cookie，如果我们在 cookie 中找到当前文章的网址，我们可以通知用户您已经阅读了它。

嗯，这就是我们如何使用饼干。存储有用的信息，我们可以在进一步的请求中检索这些信息来了解用户。

cookie 的大小取决于浏览器，但一般不应超过 1K (1，024 字节)。所以我们应该小心我们储存在饼干里的东西。

cookie 通常用于在计算机上存储用户信息，以便每当用户再次访问网站时，您可以知道该用户是您的旧用户。

一个 cookie 有几个属性，这些属性包含关于 cookie 的重要信息，例如它的名称、它所属的域名以及域内有效路径的地址。

下面给出了一些常用属性:

1.Cookie 名称属性

它表示要存储在 cookie 中的变量名和相应的值。

2.Cookie 过期属性

它指定 cookie 将被删除的时间。它被表示为一个 Unix 时间戳。一般来说，cookie 不会从浏览器中删除，它会过期。

3.Cookie 域属性

它表示 cookie 所属的域名(部分或完整)。

例如，如果有效域属性的值为www.studytonight.com，则每次用户访问www.studytonight.com网站时，客户端(浏览器)都会将 cookie 信息作为 HTTP 请求的一部分发送给网络服务器。

注意: 浏览器只会提供与 HTTP 请求中当前 URL 域属性值相同的 cookie。

4.Cookie 路径属性

此属性用于为同一域名创建路径特定的 cookies。例如，如果我们想为studytonight.com 根路径(/)创建一个 cookie，为studytonight.com/code/playground创建另一个 cookie，用于实时编码部分，那么我们可以使用 cookie 路径属性来区分这些 cookie。

它根据同一个域中的不同路径来识别网站。将该属性设置为服务器根(/)允许整个域访问存储在 cookie 中的信息。

5.Cookie 安全属性

它限制浏览器通过不安全的连接发送 cookie 信息。如果没有设置，它允许通过任何类型的超文本传输协议(HTTP)连接发送 cookie。

安全标志属性的默认值为 0 。将该值设置为 1 仅允许通过安全 HTTP 连接发送 cookie。

创建和存储 Cookies

在 JavaScript 中，您可以创建自己的 cookies 来存储用户信息或任何您想要的信息。

要创建 cookie，请使用document.cookie属性。设置 cookie 值、路径指定存储 cookie 的位置，过期日期设置 cookie 的有效期。

以下是创建 cookie 的语法:

document.cookie = cookieString;

其中，cookieString是一串形式键=值，将保存在 cookie 中。除了这些信息，我们还可以提供诸如 cookie 的最大年龄、cookie 的到期时间、cookie 的路径属性(它是自动提取的)等信息。用分号(;)分隔每个键=值对。

以下是每个附加可选属性的语法，您可以将其附加到 cookie 字符串中，以便在创建 cookie 时提供更多信息。

Cookie 属性 描述
；路径= 某个路径 默认情况下，cookie 是为当前网址创建的，但是我们可以在创建 cookie 时通过为此属性提供值来更改它。例如: 
document.write = "username=John Wick;path=/profile";

该 cookie 将为当前域名的路径/配置文件创建。 |
| ；域名= 域名 | 默认情况下，这将再次作为当前域名。此外，如果您试图提供一个不同于当前加载 JavaScript 代码的域名，浏览器将忽略您的请求。 |
| ；最大年龄= 最大年龄(秒) | 指定 cookie 应该存在或不应该过期的时间。它的价值可以是60*60*24*365或 31536000 一年，或 3600 一天。 |
| ；过期=GMTString 格式的日期 | 此属性用于指定 cookie 过期的确切时间。如果我们不提供该属性或max-age属性，那么 cookie 将在为其创建 cookie 的当前会话结束时过期。 |
| ；安全的 | 指定只能通过安全的 HTTP 连接提供 cookie。例如:

document.write = "username=John Wick;secure";

|
| ；同一地点 | 此属性用于防止浏览器发送跨站点请求的 cookie 数据。 |

示例创建 Cookies

在下面的代码示例中，我们创建了一个带有一些附加信息的 cookie，

document.cookie = "username=johnwick; expires=Thu, 17 May 2020 10:30:00 IST; path=/";

在上面的代码中，我们创建了一个 cookie 来存储网站访问者的名称。正如您在上面的代码示例中看到的，cookie 只不过是一个附加了所有信息的字符串，用分号(;)隔开。

JavaScript 读取 Cookies

要读取 cookie，我们可以使用document.cookie属性。它将返回当前位置路径中存储的所有 cookie。

var x = document.cookie;

让我们举一个简单的例子来理解这一点:

<html>
    <head>
        <title>
            Using onerror Event
        </title>
        <script type="text/javascript">
        document.cookie = "name=johnwick";
        document.cookie = "favorite_car=1969FordMustang";
        function alertCookie() {
            alert(document.cookie);
        }
        </script>
    </head>
    <body>
        <!-- HTML body -->
        <button onclick="alertCookie()">Show cookies</button>
    </body>
</html>

名称= johnwick 最喜欢的 _ 汽车= 1969 福特野马

当您点击按钮时，您将在警报框中获得上述输出。所以，储存饼干然后读回来非常容易。

要更新 cookie，只需为它设置一个新值，并确保路径应该相同，这样它将更新 cookie，而不是创建一个新的 cookie。

document.cookie = "username=BruceWayne; expires=Sat, 15 Aug 2020 12:00:00 UTC; path=/";

它将覆盖旧的 cookie 值。

要删除一个 cookie，我们需要为该 cookie 设置一个过去的过期日期来立即删除它，或者我们可以在创建 cookie 时设置一个过期日期来指定该 cookie 应该被删除的时间。

document.cookie = "username=BruceWayne; expires=Thu, 10 Jan 2020 00:00:00 UTC; path=/;";

您应该定义 cookie 路径，以确保删除正确的 cookie。

JavaScript 对象

JavaScript 对象

原文：https://www.studytonight.com/javascript/javascript-objects

在 JavaScript 中，我们可以将一个对象定义为属性的集合，这些属性被定义为键值对，其中键是可以赋值的对象特征的通用名。不要把这个对象和类对象混淆，在类对象中，我们定义一个类，然后为它创建一个对象。

在 JavaScript 中，对象是一个独立的实体，对象的属性定义了对象的特征。

例如，如果我们将一部手机视为一个对象，那么它的属性就是它的颜色、屏幕大小、品牌名称、操作系统、内存、内存等。所有这些属性定义了手机的特性。

对象的属性是一个键:值对，其中键指的是一个变量，值指的是与该键关联的任何类型的值。该值可以是任何类型，如数字、字符串，甚至是数组或其他对象。

我们可以使用构造器或者对象字面值在 JavaScript 中创建一个对象。

创建一个 JavaScript 对象

我们可以通过使用Object构造器或者使用对象字面值语法来创建一个 JavaScript 对象。下面我们有一个创建对象的基本语法，它是使用两种方式的 JavaScript:

/* Using Object constructor */
let obj1 = new Object();
/* Using the object literal syntax - empty object */
let obj2 = {};
/* Using the object literal syntax - with properties */
let obj3 = { key1:value1, key2:value2, ...};

当我们使用对象构造器创建一个对象时，我们首先创建一个空对象，然后为其分配属性，而在对象字面值语法的情况下，我们可以创建一个空对象或者在创建对象时在大括号内指定属性。

不需要混淆，JavaScript 为创建对象提供了多种不同的方法。让我们举几个例子来介绍用 JavaScript 创建对象的不同方法。

使用对象构造器的 JavaScript 对象

我们可以使用new关键字创建一个对象的直接实例:

let mobile = new Object();

然后可以使用点运算符(.)为其分配属性，如下所示:

mobile.name = 'Blackberry';
mobile.color = 'Black';
mobile.price = 40000;

我们还可以像这样一次创建对象并为其分配属性，

let mobile = new Object(),
             color = 'Black',
             price = 40000,
             specifications = new Object();

正如您在上面的代码示例中看到的，我们的对象有一个属性，它也是一个对象。

使用对象字面值语法的 JavaScript 对象

使用对象字面值语法创建对象，我们使用花括号{ }。这也是首选的方式，也是比较简单的方式，但是和Object构造器一样。我们可以在花括号内定义这个对象的属性。

让我们创建一个对象，手机，其属性为颜色、名称、价格。

let mobile = {         
    name: "Apple iPhone",
    color: "Black",
    price: 100000      
};

在移动对象中，有三个属性:

  1. 第一个属性有键名称和值“苹果 iPhone ”。

  2. 第二个有键色，值“B 缺”。

  3. 第三套房产有钥匙价格和价值 10 万。

访问 JavaScript 对象属性

要获取对象的属性，我们可以使用点(.)运算符，后跟属性名称或键。见下面的例子，

无论如何创建对象，访问属性的方式都将保持不变。

使用方括号符号:

我们还可以使用方括号符号来访问使用属性名称或键的任何属性。JavaScript 对象类似于关联数组，因为关联数组也有命名索引值，不同于简单数组中的数值索引值。

让我们举个例子来看看如何使用方括号符号来访问对象属性:

/* JS comes here */
let mobile = {         
    name: "Samsung",
    color: "black",
    price: 40000      
};

// Accessing property using square brackets
document.write(mobile['name']);
document.write("<br>"+mobile['color']);

就像我们访问属性值一样，我们也可以向对象添加新属性。

向 JavaScript 对象添加新属性

JavaScript 允许我们向现有对象添加新属性。请参见下面的示例:

let mobile = {         // an object
  name: "BlackBerry",  // property
  color: "black",
  price: 40000      
};

// Adding New Property
mobile.weight = "100gm"

// Accessing newly added property
document.write(mobile.weight)

100 克

使用方括号符号:

我们还可以使用方括号符号来设置使用属性名称或键的任何属性。

让我们举个例子来看看如何使用方括号符号来访问对象属性:

/* JS comes here */
let mobile = {         
    name: "Samsung",
    color: "black",
    price: 40000      
};

// setting property using square brackets
mobile['screen'] = "5 in";

移除 JavaScript 对象的属性

如果我们想从对象中移除任何属性，那么我们可以通过使用delete 运算符轻松完成。请参见下面的示例:

let mobile = {         // an object
  name: "BlackBerry",  // property
  color: "black",
  price: 40000      
};

// Deleting Property
delete mobile.price;

// Trying to access deleted property
document.write(mobile.price);   // Undefined

未定义

更新 JavaScript 对象的属性

允许用新的 JavaScript 对象属性值更新该对象属性值。要更新任何属性，只需为其分配一个新值。请参见下面的示例:

let mobile = {         // an object
  name: "BlackBerry",  // property
  color: "black",
  price: 40000 
};

// Updating property 
mobile.color = "Pearl White";

// Accessing Property
document.write(mobile.color);

珍珠白

对象:处理多字属性

JavaScript 允许我们创建多字属性，但是很少注意，因为使用点(.)操作符访问多字属性会产生语法错误。所以，为了避免这个错误，我们应该使用方括号( [] ) 。

让我们举个例子来看看这个:

let mobile = {         // an object
  name: "BlackBerry",  // property
  color: "black",
  "latest price": 40000      // multiword should enclose with double quotes
};

// setting multiword property key-value with square brackets
mobile["screen size"] = "5 in";

// Accessing Property using square brackets
document.write(mobile["latest price"]);

4 万

如果我们试图使用点运算符(.)来访问多字键属性，我们将会得到一个语法错误。

遍历 JavaScript 对象

我们可以使用 在循环中遍历对象的属性。它返回与对象相关联的键，这些键还可以用来获取值。请参见下面的示例:

let mobile = {         // an object
  name: "BlackBerry",  // property
  color: "black",
  price: 40000
};

// Traversing object
for (key in mobile) {
	document.write(mobile[key]+"<br>")
}

黑莓
黑色
4 万

JavaScript 对象中的创建方法

我们也可以在对象中定义方法。一个方法是一个与对象相关联的函数。方法被定义为正常的 JavaScript 函数被定义，除了它们必须作为属性被分配给一个对象。

定义 JavaScript 对象方法:

这里，我们定义了一个方法showInfo ，它将显示关于对象的信息，即所有对象属性。

let mobile = {         // an object
    name: "BlackBerry",  // property
    color: "black",
    price: 40000

    // defining method
    showInfo: function() {
        document.write(this.name+" "this.color+" "+this.price);
    }
};

访问 JavaScript 对象方法:

访问或调用一个方法非常容易，只需在对象名中使用点(.)运算符:

var mobile = {         // an object
    name: "BlackBerry",  // property
    color: "black",
    price: 40000,

    // method
    showInfo: function() {
        document.write(this.name+" "+this.color+" "+this.price)
    },
};

// Calling method
mobile.showInfo();

黑莓黑 4 万

JavaScript 内置对象

JavaScript 有丰富的内置对象集，可以用来处理各种类型的集合。下面列出了一些常用的内置类型。

  1. 线

  2. 正则表达式

  3. 布尔代数学体系的

  4. 数字

  5. 排列

  6. 数学

  7. 日期

在接下来的几个教程中，我们将介绍内置的 JavaScript 对象，还将学习如何在 JaavaScript 中创建自定义的用户定义对象。

JavaScript 用户定义的对象类型

原文：https://www.studytonight.com/javascript/javascript-userdefined-object-type

本教程涵盖了 JavaScript 中用户定义对象类型的概念。我们已经介绍了 JavaScript 对象，它是使用对象初始化器语法或对象构造器语法创建的，并且创建了一个Object类型的实例。

就像默认的对象类型一样，使用它我们可以在 JavaScript 中创建对象，我们可以定义自定义类型，使用它我们可以在 JavaScript 中创建自定义对象。

创建用户定义的 JavaScript 对象类型

我们可以通过编写构造器来定义自定义对象类型，其中函数的名称应该以大写字母开头，例如 Car 、 Cup 、 Human 等。

构造器的定义就像我们定义任何其他用户定义的 JavaScript 函数一样。

以下是定义构造器的语法:

function Xyz(param1, param2, ... , paramN)
{
    this.param1 = param1;
    this.param2 = param2;
    ...
    this.paramN = paramN;    
}

一旦我们定义了构造器，我们就可以用它来创建一个使用new关键字的对象，如下所示:

let customObj = new Xyz(paramValue1, paramValue2, paramValue3, ... , paramValueN);

使用this关键词

在 JavaScript 中，我们使用this关键字来引用当前对象，因此在构造器中，我们创建新的属性(参数 1 、参数 2 ，...)为对象类型，我们使用new关键字设置对象创建时提供的参数值。

需要记住的几点:

  1. 我们可以根据需要多次更新构造器，添加更多属性或从中移除属性。

  2. 我们也可以在使用new关键字创建对象时，在对象的属性中存储另一个对象。

  3. 在定义用户定义的对象类型的构造器时，我们可以使用默认参数来指定默认值和剩余参数。

现在让我们举几个例子来看看如何定义一个自定义的对象类型，并使用new关键字创建一个对象。

用户定义的 JavaScript 对象类型示例

在下面的代码示例中，我们为对象类型自行车创建了一个新的构造器，然后使用new关键字创建了一个对象。

一旦我们为自行车定义了构造器，我们就可以创建任意多的自行车类型的对象。我们可以在创建对象时设置不同的属性值。例如，

let myBike = new Bike("KTM", "Duke", 2020);
let yourBike = new Bike("Royal Enfield", "Classis", 2020);

我们可以使用 JavaScript 操作符比较这些对象，也可以执行许多其他操作。

使用用户定义的对象作为另一个对象的属性

让我们再定义一个对象类型，然后将其用作我们的自行车对象类型中的一个值。

我们在下面定义了一个新的对象类型人，并且在自行车对象类型中增加了一个新的属性车主，我们将在其中存储人对象。

我们可以用 JavaScript 中用户定义的对象类型做任何事情。

使用Object.create方法

如果您不想麻烦定义一个构造器方法来定义一个用户定义的对象类型，您可以使用 Object.create()方法来创建任何已经定义的原型对象的对象。

让我们举个例子来理解这一点。

let Bike = {
    company: 'KTM',  // Default value of properties
    model: 'Duke 390',
    show: function() {  // Method to display property type of Bike
        document.write(this.company+" "+this.model);
    }
};

// using Object.create to create a new object
let newBike = Object.create(Bike);
newBike.company = 'Yamaha';
newBike.model = 'R15';
newBike.show();

雅马哈 R15

正如您在上面的代码中看到的，我们可以使用Object.create方法使用已经定义的对象创建一个新的对象，然后如果需要，我们可以更改属性值并使用对象函数。

本教程到此结束。在下一个教程中，我们将逐一介绍各种内置的 JavaScript 对象。

JavaScript 布尔对象

原文：https://www.studytonight.com/javascript/javascript-boolean-object

JavaScript 布尔对象是全局对象和包装类的成员。它用于创建一个布尔对象，根据创建布尔对象时使用的值，该对象保存真或假值。

布尔对象的真和假值不同于原始布尔类型的真值和假值。

如前所述，它有两个值，真和假。在创建布尔对象时，当传递诸如 0、-0、空字符串("")、false、null、undefined或 Not Number(NaN)等值时，布尔对象返回 false 。除了将布尔对象的初始值设置为假的所有这些值之外，所有其他值，甚至空数组([])、空对象({})或字符串“假”，都将布尔对象的初始值设置为真。

创建 JavaScript 布尔对象

为了创建布尔对象的实例，我们在布尔对象构造器中使用new关键字，在创建时提供一个值。

以下是它的语法:

let bool = new Boolean(SOME_VALUE);

根据传递的值，初始值被设置为真或假。

让我们举个例子，

// Creating Boolean Object
let boolObj = new Boolean(true);  
document.write(boolObj);

boolObj = new Boolean(false);  
document.write("<br>"+boolObj);

真
假

JavaScript 布尔对象假

如果对象创建时提供的值为 0 、 -0 、NaN、null、undefined，则 JavaScript Boolean Object 的初始值为 false，为 false，为空字符串，或者即使没有提供值，因为默认值也为 false。

let obj1 = new Boolean();
let obj2 = new Boolean(0);
let obj3 = new Boolean(null);
let obj4 = new Boolean('');
let obj5 = new Boolean(false);

document.write(obj1+" "+obj2+" "+obj3+" "+obj4+" "+obj5)

假假假假假

JavaScript 布尔对象真

除了上面指定的布尔对象初始值为假的值之外，所有其他值都将该值设置为真。让我们举几个例子，

let obj1 = new Boolean(true);
let obj2 = new Boolean('true');
let obj3 = new Boolean('false');
let obj4 = new Boolean('hello');
let obj5 = new Boolean([]);
let obj6 = new Boolean({});

document.write(obj1+" "+obj2+" "+obj3+" "+obj4+" "+obj5+" "+obj6)

真真真真真真真

JavaScript 布尔对象与基本布尔类型

正如我们已经提到的，布尔对象和基本布尔类型是不同的。布尔对象是一个 JavaScript 对象，不是一个原语类型，而是一个对象类型，其值可以是真或假。

让我们举个例子，在这里我们将看到布尔对象和原始布尔类型在 JavaScript 条件语句表达式中使用时的行为。

// Boolean object
let obj = new Boolean(false);

// using in if condition 
if(obj)
{
	document.write("It is boolean object"); // executes
}

// Primitive value
let bool = false;
if(bool)
{
	document.write("It is primitive boolean"); // does not execute
}

是布尔对象

不管布尔对象的假值如何，都会执行第一个if语句，这是因为当我们在if条件中提供一个对象时，它总是被评估为真。

我们可以通过使用布尔对象的valueOf()方法来获得布尔对象的值，然后它将被视为正常的原始类型真或假值。

将布尔对象转换为基元

我们可以使用布尔对象的valueOf()方法来访问它的值，

// Boolean object
let obj = new Boolean(false);

// using the value of Boolean object in condition 
if(obj.valueOf()){
	document.write("It is boolean object");   // does not execute
}
else{ 
	document.write("boolean value is false");   // executes
}

布尔值为假

布尔对象的方法

以下是布尔对象的一些常用方法。

  1. toString():将布尔值转换为字符串并返回该字符串。

  2. valueOf():返回布尔对象的基元值。

JavaScript 布尔对象示例

让我们看看布尔对象的另一个代码示例:

在本教程中，我们已经介绍了布尔对象、它的方法、它与基本布尔类型的区别以及多个代码示例。

JavaScript 数字对象

原文：https://www.studytonight.com/javascript/javascript-number-object

JavaScript Number 是一个内置的包装对象，用于处理数值。可以使用Number()构造器创建一个数字对象。

所有数字都是 64 位(8 字节)浮点数。不像 C 或 C++，没有像整数、浮点数、等数据类型可以在 JavaScript 中定义数字(最近有了 ECMAScript2016，JavaScript 已经开始支持整数的BigInt类型)。

创建 JavaScript 数字对象

如果我们使用带有new关键字的Number()构造器，我们可以创建 Number 对象。

let num = new Number(SOME_NUMERIC_VALUE);

如果我们使用Number()函数(在非构造器上下文中)而不使用new关键字，它将创建一个原始数字类型，该类型也可用于类型转换。

让我们举个例子，

let x = new Number(290.78);
document.write(x + "<br/>");
document.write(typeof x + "<br/>");

290.78
物体

因为 Number 是一个内置对象，所以它有一些属性和方法可以处理数字类型。

数字对象属性

以下是数字对象的属性:

财产 描述
Number.EPSILON 两个可表示数字之间的最小间隔。
Number.MAX_SAFE_INTEGER 返回 JavaScript 中最大可能的安全整数值，即 253 - 1
Number.MAX_VALUE 返回可表示的最大正数
Number.MIN_SAFE_INTEGER 返回 JavaScript 中可能的最小安全整数值，即-(253 - 1)
Number.MIN_VALUE 返回在 JavaScript 中可能表示的最小数值。
Number.NaN 它代表特殊的“非数字”值
Number.NEGATIVE_INFINITY 它代表负无穷大的值。
Number.POSITIVE_INFINITY 它代表负无穷大的值。
Number.prototype 这可用于向 Number 对象添加更多属性

注意: 任何大于MAX_SAFE_INTEGER值的值在用 JavaScript 处理时都会被破坏。

让我们举一个例子来看看这些属性的作用。

// Range of Number
document.write(Number.MIN_VALUE+"<br>")
document.write(Number.MAX_VALUE+"<br>")
document.write(Number.NEGATIVE_INFINITY+"<br>")
document.write(Number.POSITIVE_INFINITY+"<br>")
document.write(Number.prototype+"<br>")
document.write(Number.MIN_SAFE_INTEGER+"<br>")
document.write(Number.MAX_SAFE_INTEGER+"<br>")

5e-324
1.7976931348623157 e+308
-Infinity
Infinity
0
-9007199254740991
9007199254740991

数字对象方法

JavaScript Number 对象既有静态方法(在没有创建任何 Number 对象的情况下使用)也有实例方法(在对象上使用)。以下是 Number 对象最常用的方法:

方法名 描述
Number.isNaN() 静态方法；用于检查给定值是否为 NaN。
Number.isFinite() 静态方法；用于检查给定值是否为有限数。
Number.isInteger() 静态方法；用于检查给定值是否为整数。
Number.isSafeInteger() 静态方法；用于检查给定值是否为安全值，即在 253 - 1 到-(253 - 1)之间
Number.parseFloat(string) 静态方法；用于将字符串转换为浮点数。
Number.parseInt(string, [radix]) 静态方法；用于将字符串转换为整数。这里基数代表数学数字系统的基数。
valueOf() 返回数字对象的原始值。
toString() 返回数字对象的字符串值。
toFixed(x) 将数字四舍五入到小数点后的 x 位。
toPrecision(x) 将数字向上舍入到 x 位数的长度。
toExponential(x) 将数字转换为指数记数法。

让我们举几个例子来看看其中的一些功能。

将数字对象转换为基本对象

Number 对象提供了一种方法valueOf()，可用于将 Number 对象转换为基本类型。

let x = new Number(290.78);
document.write(typeof x + "<br/>");

// Conversion from object to number
let num = x.valueOf()
document.write(typeof num + "<br/>");

对象
号

在非构造器上下文中使用数字

正如我们在开头提到的，如果我们使用 Number 函数而没有这个new关键字，我们可以用它来进行类型转换。让我们看几个例子:

// using the Date object
let d = new Date('December 17, 1995 03:24:00');
console.log(Number(d));    // Logs: 819199440000

上面的代码将给出输出 819199440000，它是指定日期的 UNIX 时间戳等价物。这样日期就成功转换成了数字。

此外，我们可以使用数字功能进行如下更简单的转换:

Number('77');        // 77
Number('70.7');      // 70.7
Number('');          // 0
Number('foo');       // NaN
Number('-Infinity'); // -Infinity
Number(null);        // 0

JavaScript 数字对象示例

在这个例子中，我们使用内置方法来理解它们的用途。

您可以使用 Number 对象来检查任何值的类型，例如，如果您必须验证给定的值是否是数字，则可以使用Number.isNaN方法。同样，您也可以使用 Number 对象属性在脚本中分配允许的最大值和最小值。

JavaScript 数学对象

原文：https://www.studytonight.com/javascript/javascript-math-object

在 JavaScript 中，数学是一个内置对象，它包括数学运算的属性和方法。我们可以使用数学对象来执行简单和复杂的算术运算。

注: 数学仅适用于 JavaScript Number 类型。

在数学对象中，所有的属性和方法都是静态的。因此，我们不需要创建它的对象来使用它的属性或方法。同样，即使我们想要，我们也不能创建一个对象，因为数学不是构造器函数。

使用 JavaScript 数学

假设，我们想在程序中得到用于几何计算的π的值或一个数的平方根，那么我们可以使用数学对象。让我们看看如何:

let pi = Math.PI;
document.write(pi + "<br/>");

let sqrt = Math.sqrt(9);
document.write(sqrt);

3.141592653589793
3

JavaScript 提供了一组丰富的数学属性，可以用来获取预定义的常量值。

数学属性

以下是 JavaScript 数学对象提供的属性:

属性 描述
E 保存欧拉数，其值为 2.718(近似值)
LN2 保存值为 0.693(近似值)的自然对数 2。
LN10 保存 10 的自然对数，其值为 2.302(近似值)。
LOG2E 保存 E 的以 2 为底的对数，取值为 1.442(近似值)
LOG10E 保存 E 的以 10 为底的对数，其值为 0.434(近似值)
PI 保存圆周率的数值，其近似值为 3.142
SQRT1_2 保持 1/2 的平方根，其近似值为 0.707
SQRT2 保持 2 的平方根，大约值为 1.414

让我们举个例子来看看如何使用这些属性。

var e  = Math.E
document.write(e +"<br>")

var ln2  = Math.LN2
document.write(ln2 +"<br>")

var ln10  = Math.LN10
document.write(ln10 +"<br>")

var sq = Math.SQRT1_2
document.write(sq +"<br>")

2.718281828459045
0.6931471805599453
2.71828929946

查找最小和最大数量

假设，我们想从随机数列表中找到最小值和最大值，那么使用数学对象就很容易了。见下面的例子。

// Find minimum number
var min = Math.min(10,25,47,23,18,8,21,30)
document.write(min +"<br>")

// Find maximum number
var max = Math.max(10,25,47,23,18,8,21,30)
document.write(max +"<br>")

8
47

数学方法

JavaScript 数学对象提供了一组丰富的方法，用于简化数学计算，并有助于减少面向数学的编程的工作量和时间。这里我们列出了最常用的数学对象方法:

方法 描述
abs(x) 返回 x 的绝对值
ceil(x) 将 x 向上舍入到最接近的最大整数
cos(x) 返回 x 的余弦值
exp(x) 返回指数的值。
random() 返回一个介于 0 和 1 之间的随机数
tan(x) 返回 x 的正切值
sqrt(x) 返回 x 的平方根
sin(x) 返回 x 的正弦值。
floor(x) 将 x 向上舍入到最近的最小整数。
max(x,y,z,......n) 返回 lsit 中最高的数字。
min(x,y,z,.......n) 返回列表中最低的数字。
pow(x,y) 返回 x 的 y 次方
cos(x) 返回 x 的余弦值
log(x) 返回 x 的对数值

让我们看一个例子，其中我们使用数学方法来理解这些方法的返回值:

所以要使用 Math 对象属性或方法，我们不需要使用new关键字创建对象，我们可以直接使用代码中的属性和方法。

JavaScript 日期对象

原文：https://www.studytonight.com/javascript/javascript-date-object

日期对象是一个内置的对象，用于处理日期和时间。它存储一个数字，代表 Unix 时间戳的毫秒数(它只不过是自 1970 年 1 月 1 日世界协调时以来经过的毫秒数)。我们可以用它来创建一个新的日期，格式化一个日期，获得两个不同时间值之间经过的时间，等等。

它还有助于使用毫秒数获得日期值，我们还可以根据不同的时区获得日期。

日期对象默认使用浏览器的日期时区，并以文本格式显示日期。

可以使用日期构造器创建日期对象。

创建 JavaScript 日期对象

让我们看看如何用 JavaScript 创建日期对象。虽然有多种方式，但默认方式是将new关键字与日期构造器一起使用。

let newdate = new Date();

上面将创建一个新的日期对象，其中存储了当前日期和时间。存储在该对象中的日期格式将是:

2020 年 05 月 05 日星期二格林尼治时间+0530 时 21:16:17(印度标准时间)

是的，它将是完整的日期和时间以及时区信息。

要获得标准的 UNIX 时间戳值，我们可以使用以下代码:

let newdate = Date.now();

1588693792007

在上面的代码中，我们对日期对象使用了静态函数now()。这将为我们提供当前日期和时间的 Unix 时间戳，它只不过是自 1970 年 1 月 1 日以来经过的毫秒数。

创建 JavaScript 日期的其他方法

除了以上两种语法之外，还有多种其他方法可以在 JavaScript 中创建日期。这里，我们使用不同的语法来创建日期对象。

正如您在上面的示例中看到的，我们可以为自定义日期创建一个日期，该日期可以是过去的日期，也可以是未来的日期。我们甚至可以提供时间值。

使用 JavaScript 日期

JavaScript Date 构造器处理不同的格式来创建日期，我们可以传递一个字符串格式的日期或者一个带有毫秒的数字字面值来创建一个 JavaScript 中的日期对象。

使用字符串创建 JavaScript 日期

JavaScript 允许以下字符串格式创建日期对象。

let date1 = new Date('February 13, 1991 06:44:00')
document.write(date1 +"<br>");

let date2 = new Date('1991-02-13T06:44:00');
document.write(date2);

1991 年 2 月 13 日星期三 06:44:00 GMT+0530(印度标准时间)
1991 年 2 月 13 日星期三 06:44:00 GMT+0530(印度标准时间)

使用数字字面值创建 JavaScript 日期

我们可以使用 Date()构造器可以取 7 个参数来创建日期，分别是:年、月、日、小时、分钟、秒、毫秒。

我们也可以通过经过毫秒来得到日期。参见以下示例:

let date1 = new Date(2018,11,25,12,25,12,0);
document.write(date1 +"<br/>");

// Passing miliseconds
let date2 = new Date(1825356800000);
document.write(date2);

2018 年 12 月 25 日星期二 12:25:12 GMT+0530(印度标准时间)
Fri 2027 年 11 月 05 日 01:03:20 GMT+0530(印度标准时间)

从 JavaScript 日期中获取年、月和日

要从日期中获取年、月或日的值，我们可以使用 JavaScript 内置方法。这些方法易于使用，减少了编码的工作量和时间。

// Creating a date
let date1 = new Date(2018,11,25,12,25,12,0);

// Getting year
let year = date1.getFullYear();
document.write("<br> Year: "+  year);

// Getting Month
let month = date1.getMonth();
document.write("<br> Month: "+  month);

// Getting day
let day = date1.getDate();
document.write("<br> Day: "+  day);

年:2018
月:11
日:25

日期对象方法

JavaScript 提供了一组丰富的内置方法，它们既是静态方法，也是实例方法，可以用来从 JavaScript Date 对象中获取不同的信息。

方法 描述
Date.now() 返回当前日期和时间的毫秒数(Unix 时间戳)。
Date.parse() 分析日期的字符串值，并返回自 1970 年 1 月 1 日 00:00:00 世界协调时以来的毫秒数，忽略闰秒。
Date.UTC() 此函数采用 7 个带数值的参数，但以世界协调时时区创建日期。
setDate() 设置从 1 到 31 的月份日期。
setHours() 设置从 0 到 23 的小时数
getSeconds() 返回 0 到 59 之间的秒数
toDateString() 将日期值转换为字符串
valueOf() 返回日期对象的原始值。
setMinutes() 设置 0 到 59 之间的分钟数。
setMonth() 设置从 0 到 11 月的数值等值范围
setMilliseconds() 设置 0 到 999 之间的毫秒数
toTimeString() 将时间转换成字符串。
getDate() 返回 1 - 31 之间的日期
getDay() 从 0 - 6 返回星期几
getFullYear() 返回指定日期的年份(4 位数年份为 4 位数)
getMinutes() 返回指定日期的分钟数(0–59)
getMonth() 返回指定日期的月份(0–11)
getHours() 返回 0 到 23 之间的小时数。

现在我们将向您展示如何使用一些日期对象方法:

寻找 JavaScript 日期和运行时间之间的差异

我们可以简单地减去两个日期，找出任意两个日期之间的差异。让我们举个例子来看看这个:

// Using Date objects
let start = Date.now();

// Do something for some time

// get the end time
let end = Date.now();
// time elapsed
let elapsed = end - start;   // elapsed time in milliseconds

但这并不像 Date 对象有日、月、年、小时、分钟和秒的值那么简单，因此我们在查找经过的时间时应该小心。

在本教程中，我们介绍了在许多网络应用程序中使用的 JavaScript 中的日期对象。

JavaScript 正则表达式对象

原文：https://www.studytonight.com/javascript/javascript-regexp-object

正则表达式或 JavaScript RegExp 是一个帮助您验证字符串中的字符模式或匹配字符串等的对象。您可以使用 JavaScript RegExp 对象来验证表单中输入的电子邮件，或者检查密码是否全是数字，或者密码是否包含字母数字和特殊字符等。

在 JavaScript 中定义正则表达式有两种方式。

1.使用 JavaScript 正则表达式对象的构造器

2.使用字面语法

创建 JavaScript 正则表达式对象

让我们看看如何用 JavaScript 创建一个正则表达式对象:

// Object Syntax
let regExp = new RegExp("pattern", "flag");

// Literal Syntax
let regExp = /pattern/flag;

其中模式是正则表达式的文本，标志使正则表达式搜索特定的模式。

注: 在本教程中，我们将讨论 RegExp 对象、其属性和方法。所有的例子都将基于正则表达式对象，而不是字面上的正则表达式。我们已经在前面介绍了正则表达式字面语法。

我们将使用以下字符串方法来使用正则表达式对象来测试、匹配和验证 JavaScript 中的各种字符串值:

  • test()

  • match()

  • replace()

  • exec()

让我们举几个例子来理解 JavaScript RegExp 对象的使用。

创建一个正则表达式来匹配 IP 地址

为了匹配所有看起来像 IP 地址的字符串: xxx.xxx.xxx.xxx ，我们可以使用以下正则表达式模式:

let regularexp = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g;

现在让我们创建一个验证 IP 地址的示例。如果给定的 IP 地址有效，下面的代码返回 true :

let str = "102.235.251.251";
// regex pattern to match valid ip
let re = new RegExp(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/);
// test the regex
let result = re.test(str);
if(result)
	document.write("Ip address is valid");
else
	document.write("Ip address is not valid");

Ip 地址有效

如何使用 Regex 替换字符串？

让我们看一个例子，用其他字符串替换字符串的一部分或整个字符串，或者用正则表达式替换字符串的顺序。

// Creating regex object
let re = new RegExp(/(\w+)\s(\w+)/);
let str = 'Mohan Shyam';
// Replacing string
let newstr = str.replace(re, '$2, $1');
document.write(newstr);

山药、墨山

从域名获取子域值

我们可以使用正则表达式从一个网址中获取子域。RegExp exec()方法用于执行正则表达式模式匹配，并返回一个字符串数组。请参见下面的示例:

let url = 'http://linux.studytonight.com';
// Creating regex object
let re = new RegExp(/[^.]+/);
let result = re.exec(url)[0].substr(7);
document.write(result);

linux

在字符串中查找模式

要在字符串中找到模式，我们可以使用字符串match()方法。它返回可以是子串的匹配模式。请参见下面的示例:

// Creating regex object
var regex = new RegExp(/India/g);
var str = "We live in India.";
// search for India
var matches = str.match(regex);
document.write(matches);

印度

JavaScript 正则表达式对象的属性

  • 全局:指设置了 g 修改器。

  • 忽略:表示设置了 i 修改器

  • lastIndex :指开始下一场比赛的索引。

  • 多行:表示设置了 m 修改器。

  • 来源:指 RegExp 模式的文本。

JavaScript 正则表达式ignoreCase属性:

ignoreCase属性表示i标志是否与正则表达式一起使用。ignoreCase是正则表达式对象的只读属性。

var re = new RegExp("/hello/","i");
// ignorecase property
var result = re.ignoreCase;
document.write(result);

真

## 对象方法

Regex 对象提供了使用正则表达式的各种方法。下表包含其方法:
|

方法

|

描述

|
| --- | --- |
| exec() | 在字符串中执行匹配搜索。如果不匹配，它将返回一个信息数组或 null。 |
| test() | 测试字符串中的匹配。它返回真或假。 |
| match() | 返回包含所有匹配项(包括捕获组)的数组，如果找不到匹配项，则返回 null。 |
| matchAll() | 返回包含所有匹配项的迭代器，包括捕获组。 |
| search() | 测试字符串中的匹配。它返回匹配的索引，如果搜索失败，则返回-1。 |
| replace() | 在字符串中执行匹配搜索，并用替换子字符串替换匹配的子字符串。 |
| split() | 使用正则表达式或固定字符串将字符串分解为子字符串数组。 |

正则表达式test()方法示例

RegExp test()方法用于测试正则表达式，如果表达式匹配，则返回 true。

<script>
	var str = "Hello";
	var re = new RegExp("/hello/","i");
	var result = re.test(str);
	document.write(result)

</script>

真

使用正则表达式验证电子邮件

让我们使用正则表达式来验证电子邮件地址。在下面的示例中，我们正在为用户验证电子邮件，以确保用户只输入有效的电子邮件。

let str = "abc@gmail.com";
// regex pattern to match valid email
let re = new RegExp(/^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/);
// test the 
let result = re.test(str);
if(result)
    document.write("Email is valid")
else
    document.write("Email is not valid")

邮件有效

JavaScript WebAPI 和接口

JavaScript 浏览器对象模型

原文：https://www.studytonight.com/javascript/javascript-browser-object-model

JavaScript 提供了我们在开发 web 应用程序或网站时可以使用的 WebAPIs 和接口(对象类型)。这些 API 和对象帮助我们控制网页的生命周期，并执行各种操作，如获取浏览器信息、管理屏幕大小、打开和关闭新的浏览器窗口、获取 URL 信息或更新 URL、获取 cookies 和本地存储等。

使用这些 WebAPI 和接口可以做很多事情。所有支持的网页 API 和 JavaScript 接口都在 Mozilla 开发者网站上列出。

帮助我们与浏览器窗口交互的界面(对象类型)被称为浏览器对象。浏览器对象不是一个官方术语，而是属于不同 WebAPI 的一组对象，用于管理各种与浏览器相关的信息和操作。

例如，当在浏览器窗口中打开一个 HTML 文档时，浏览器将该文档解释为分层对象(HTML 标记)的集合，并相应地显示这些对象中包含的数据(HTML 页面呈现)。浏览器解析文档并创建一个对象集合，该集合定义了文档及其详细信息。我们在下图中展示了可用于访问浏览器窗口各种组件的各种对象:

JavaScript Browser object Model Example

浏览器对象有各种类型，用于与浏览器交互，属于不同的 API。这些浏览器对象的集合也被称为浏览器对象模型 (BOM)。

浏览器的默认对象是窗口，这意味着你可以直接调用它的函数。

浏览器对象:

下面列出的对象称为浏览器对象。

  • 窗口 DOM API 的一部分

  • 航海家

  • 文档 DOM API 的一部分

  • 窗口对象的屏幕属性

  • 窗口对象的历史属性

  • 窗口和文档对象的位置属性

窗口对象

它用于与显示网页的浏览器窗口进行交互。一般代表浏览器中的一个选项卡，但是窗口宽度、高度等一些动作会影响整个浏览器窗口。

我们已经分别详细介绍了 JavaScript 窗口对象。

导航对象

它作为所有数据的仓库和关于用于访问网页的浏览器软件的信息，该对象用于获取与浏览器相关的信息，例如，用户是使用 Chrome 浏览器还是 Safari 浏览器，正在使用哪个版本的浏览器等。

我们已经分别详细介绍了 JavaScript 导航器对象。

文档对象

该对象表示加载到浏览器中的 HTML 文档。文档对象是提供对文档(网页)的所有 HTML 元素的访问的对象。我们可以用这个对象给网页添加一个新的 HTML 标签，修改任何存在的 HTML 标签，等等。

我们已经分别详细介绍了 JavaScript 文档对象。

历史对象

它在浏览器中存储用户访问的统一资源定位符。它是一个内置对象，用于获取浏览器历史记录。该对象是 JavaScript 窗口对象的一个属性。

我们已经分别详细介绍了 JavaScript 历史对象。

屏幕对象

它是一个内置对象，用于获取与浏览器屏幕相关的信息，如屏幕大小等。它也是从窗口对象获得的。

我们已经分别详细介绍了 JavaScript 屏幕对象。

位置对象

位置是一个内置对象，代表它所链接的对象的位置，可以是窗口或文档。“文档”和“窗口”界面都有链接位置属性。

我们已经分别详细介绍了 JavaScript 位置对象。

在下一个教程中，我们将一个接一个地详细介绍所有这些对象，并举例说明我们如何使用它们与浏览器交互并执行各种不同的操作。

JavaScript 窗口对象

原文：https://www.studytonight.com/javascript/javascript-window-object

JavaScript Window 是全局接口(对象类型)，用于控制浏览器窗口生命周期并对其进行各种操作。

在我们的 JavaScript 代码中有一个全局变量窗口，代表当前运行代码的浏览器窗口，可以使用window字面值直接访问。

它表示一个包含网页的窗口，而网页又由文档对象表示。窗口可以是新窗口、新选项卡、框架集或用 JavaScript 创建的单个框架。

在多标签浏览器的情况下，一个窗口对象代表一个标签，但是它的一些属性如innerHeight、innerWidth和方法如resizeTo()会影响整个浏览器窗口。

每当您打开一个新窗口或选项卡时，就会自动创建一个代表该窗口/选项卡的窗口对象。

窗口对象的属性用于检索关于当前打开的窗口的信息，而它的方法用于执行特定的任务，如打开、最大化、最小化窗口等。

为了理解窗口对象，让我们使用它来执行一些操作，并看看它是如何工作的。

使用 JavaScript 窗口对象

让我们使用 JavaScript 窗口对象创建一个新窗口，使用open()方法。此方法创建一个新窗口，并返回一个对象，该对象可进一步用于管理该窗口。

在上面的代码中，我们已经使用了现有窗口的窗口对象，使用open()方法创建了一个新窗口。在open()方法中，我们可以提供要在新窗口中打开的网址(我们也可以将其留空)窗口名称、要创建的窗口的宽度和高度。

以下是 window 对象 open()方法的语法:

let newWindow = window.open(url, windowName, [windowFeatures]);

在创建新窗口时，我们可以提供任意多的属性。

当执行open()方法时，它返回所创建的新窗口的窗口对象的引用，您可以将其分配给一个变量，就像我们在上面的代码中所做的那样。我们已经将window.open()方法返回的值赋给了win变量。

我们使用了win变量来访问新窗口，比如获取窗口的名称，获取打开新窗口的窗口的位置等等。

窗口对象有许多属性和方法，我们在下面列出了它们。

查找窗口的尺寸

我们可以通过使用窗口对象的内置属性来获得窗口的高度和宽度。

我们还可以使用一个窗口对象(window.document)来访问文档对象，该对象为我们提供了对 HTML 文档的访问，因此我们可以添加新的 HTML 元素，或者向文档中写入任何内容，就像我们在上面的示例中所做的那样。

JavaScript 窗口对象属性

wondow 对象属性是指在 windows 对象内部创建的变量。

在 JavaScript 中，所有可用的数据都作为属性附加到窗口对象。

我们可以访问窗口对象的属性，如:window.propertyname ，其中属性名称是属性的名称。

最流行的窗口对象属性表如下所示:

属性 描述
关闭的 返回一个布尔值，该值指定窗口是否已关闭
文件 指定窗口中的文档对象。
历史 指定窗口的历史对象。
框架 指定当前窗口中所有帧的数组
默认状态 指定必须出现在窗口状态栏中的默认消息。
内部高度 指定窗口内容区域的内部高度。
内宽 指定窗口内容区域的内部宽度。
长度 指定窗口中包含的帧数。
位置 指定了窗口的位置对象
名字 指定窗口的名称
顶端 指定最顶层浏览器窗口的引用。
自己 返回当前活动框架或窗口的引用。
父母 返回当前窗口的父框架或窗口。
状态 指定在窗口上执行活动时，窗口状态栏中显示的消息。
屏幕左 指定窗口相对于用户监视器屏幕的 x 坐标
screenTop(屏幕顶部) 指定窗口相对于用户监视器屏幕的 y 坐标
screenX(屏幕 x) 指定窗口相对于用户监视器屏幕的 x 坐标
风景 指定窗口相对于用户监视器屏幕的 y 坐标

让我们举个例子来看看其中的一些属性:

在上面的例子中，我们创建了一个新窗口，只是为了让您熟悉新窗口的创建，也是为了让您理解当我们创建一个新窗口时，当前窗口有一个不同的窗口对象，而新窗口将有一个单独的窗口对象。

然后，我们尝试访问创建的新窗口的一些属性。

TASK: 在上面的代码游乐场中多尝试一些 windows 属性，练习并理解 windows 属性是如何工作的。

JavaScript 窗口对象方法

窗口对象方法指的是在窗口对象内部创建的函数，这些函数可用于在浏览器窗口上执行各种操作，例如它如何显示消息或从用户那里获取输入。

下面我们列出了一些最常用的窗口对象方法:

方法 描述
alert() 指定一种方法，该方法显示带有消息“确定”按钮的警告框。
blur() 指定从当前窗口中移除焦点的方法。
clearInterval() 指定清除计时器的方法，该方法是通过使用 setInterval()方法设置的。
close() 指定关闭当前窗口的方法。
confirm() 指定显示对话框的方法，该对话框包含一条消息和两个按钮“确定”和“取消”
focus() 指定在当前窗口上设置焦点的方法。
open() 指定了打开新浏览器窗口的方法
moveTo() 指定将窗口移动到指定位置的方法
moveBy() 指定相对于当前位置移动窗口的方法。
prompt() 指定提示输入的方法。
print() 指定发送打印命令以打印当前窗口内容的方法。
setTimeout() 指定在指定的毫秒数后计算表达式的方法。
setInterval() 指定以指定的时间间隔(毫秒)计算表达式的方法
resizeBy() 指定窗口大小调整的量
resizeTo() 用于动态调整窗口大小
scroll() 将窗口滚动到文档中的特定位置
scrollBy() 按给定值滚动窗口
stop() 此方法停止加载窗口

让我们举个例子，看看上面的一些方法是如何起作用的:

在上面的例子中，我们已经使用了一些窗口方法，您可以尝试更多的方法。在下一个教程中，我们将学习历史对象，它是窗口对象的一个属性。

JavaScript 历史对象

原文：https://www.studytonight.com/javascript/javascript-history-object

JavaScript 历史是一个内置接口(对象类型)，用于访问浏览器窗口会话历史。它包含用户在特定浏览器窗口、选项卡或框架中浏览的网址列表，由窗口对象表示。

历史对象是 JavaScript 窗口对象的属性，可以通过window.history属性进行访问，用于访问该窗口对象的会话历史。

它提供了有用的方法和属性，让我们可以在窗口的会话历史中来回导航。

让我们举个例子来看看这是如何工作的，以便更好地理解它。

JavaScript 历史对象示例

历史对象的back()方法用于返回到历史列表中浏览器窗口中访问的上一个网址。

这和在浏览器中点击“后退”按钮是一样的。

<button onclick="goBack()">Go Back</button>

<script>
	function goback(){
	    window.history.back();
	}
</script>

同样，我们可以使用历史对象的forward()方法来加载历史列表中的下一个 URL。如果下一个网址不存在，它什么也不做。

和在浏览器中点击“前进”按钮一样。

<button onclick="goforward()">Go Forward</button>

<script>
	function goforward(){
	    window.history.forward();
	}
</script>

除了back()和forward()之外，JavaScript 历史对象提供了更多类似go() 的方法，可以用来跳转到历史对象中存在的任何特定 URL 。

要将移动到任何特定页面，我们可以使用go()方法，它采用一个整数参数作为历史网址列表的索引值。请参见下面的示例:

<script>
    // move to one page backward
	window.history.go(-1);

    // move to two page backward
    window.history.go(-2);

    // move to one page forward
    window.history.go(1);

    // move to two page forward
    window.history.go(2);
</script>

我们也可以使用历史对象的go()方法刷新当前页面。在下面的例子中，我们已经调用了go()方法两次，它在两个场景中的工作原理是一样的。当我们想要刷新/重新加载当前页面时，我们可以随时调用它。

<script>
// Refresh the page
        window.history.go(0);

        window.history.go();

</script>

JavaScript 历史对象属性

以下是历史对象的属性。length属性使用最多。

属性 描述
长度 指定对象中包含的元素数量
滚动恢复 允许 web 应用程序在历史导航中显式设置默认滚动恢复行为
状态 表示历史堆栈顶部的状态

让我们举一个例子来获取用户在浏览器窗口中访问的页面数量。我们将使用包含被访问页面信息的length属性。请参见下面的示例:

历史对象方法

JavaScript 历史对象方法是指在历史对象内部创建的函数。这些方法指定与浏览器窗口当前会话中访问的网址相关的操作。

方法 描述
back() 指定从历史列表中加载上一个网址的方法。
forward() 指定从历史列表中加载下一个网址的方法。
go() 指定从历史列表中加载特定 URL 的方法。
pushState() 用于将给定数据推送到具有指定标题的会话历史堆栈上
replaceState() 用于将历史堆栈上的最新条目更新为指定的数据、标题和 URL(如果提供)

我们已经在本教程的开头用例子解释了每种方法。

在下一个教程中，我们将了解导航浏览器对象。

JavaScript 导航器对象

原文：https://www.studytonight.com/javascript/javascript-navigator-object

JavaScript Navigator Object 用于获取与浏览器(useragent)相关的信息，如浏览器名称、浏览器版本、操作系统信息等。

JavaScript Navigator 对象也是 JavaScript Window 对象的属性，可以使用当前浏览器窗口的只读属性window.navigator进行访问。

在 JavaScript 中，导航对象包括一些属性和方法，帮助我们从一个元素导航到另一个元素。

导航器对象属性

导航对象的属性是在导航对象内部创建的变量。

我们可以通过如下方式访问导航器对象属性:导航器.属性名称，其中属性名称是属性的名称。

属性 描述
appcodename 指定浏览器的代码名(实验属性-可能返回不正确的值)
应用名称 指定浏览器的名称(实验属性-可能返回不正确的值)
应用版本 指定正在使用的浏览器版本(实验属性-可能返回不正确的值)
烹饪启用 指定浏览器中是否启用 cookies
平台 包含一个字符串，该字符串指示为其编译浏览器的计算机类型。
用户代理 包含一个字符串，代表客户端以 HTTP 协议发送给服务器的用户代理头的值
地理定位 返回地理位置对象，该对象可用于获取设备的位置信息。
在线的 指定浏览器是否在线。
语言 返回具有首选浏览器语言的字符串，例如，英语为 en-US 。
语言 按照用户首选项的顺序返回包含浏览器支持的所有语言的字符串。

在 Navigator 对象中有更多的实验属性，但是上面提到的是最常用的属性。

让我们看一个代码示例，其中一些属性正在运行。

导航器对象方法

Navigator 对象没有很多标准化的方法，大多数可用的方法都是实验性的。

方法名 描述
registerProtocolHandler() 允许网站将自己注册为协议处理程序，以便允许它们打开一些标准的 URL 方案，如 mailto: 、 tel: 、 sms: 等，
share() 用于利用浏览器中提供的本地共享支持。
sendBeacon() 用于从客户端向服务器发送小数据包
vibrate() 如果支持，这可以用来使设备振动，如果不支持，什么都不会发生。这在移动浏览器中很有用。

导航器对象的使用:

navigator 对象可用于多个特定的用例，这些用例可以帮助您改善网站，例如:

  1. 通过为不同的浏览器编写特定的代码来解决兼容性问题，从而使您的 web 应用程序或网站更加兼容不同的浏览器。

  2. 您可以检查浏览器是否在线，如果浏览器与互联网断开连接，则显示一些消息。

  3. 可以使用用户的位置信息显示位置特定内容。

  4. 如果您的网站支持多种语言，您可以将首选语言设置为网站语言。

以上所提到的这些都可以从多方面改善你网站的用户体验。

JavaScript 位置对象

原文：https://www.studytonight.com/javascript/javascript-location-object

JavaScript Location 是一个内置的接口(对象类型)，表示它所连接的对象的位置(URL)。窗口对象和文档对象都具有该属性。窗口对象位置属性让我们可以访问浏览器窗口的位置，而文档位置属性让我们可以访问特定文档的位置对象。

用于获取当前网址的信息。位置对象还允许您导航到另一个网页。

假设我们想要获取当前网站的主机名，那么我们可以使用位置对象的hostname属性。请参见下面的示例:

定位对象有许多不同的属性，也有许多方法。

JavaScript 位置对象属性

JavaScript Location Object 有许多属性，我们可以使用这些属性来访问网页 URL 的各种组件，甚至更改它。

以下是位置对象的一些常用属性:

属性 描述
超链接 表示指定整个网址的字符串，例如 http://www.javascriptstudytonight.com:80/order.cgi?批次= 1 #简介
草案 表示 URL 开头到第一个冒号(:)的字符串，它指定访问 URL 的方法，例如 http:或 https:
宿主 表示由主机名和端口字符串组成的字符串，例如:-www.javascriptstudytonight.com:80
主机名 表示 URL 的服务器名、子域和域名(或 IP 地址)，例如 www.javascriptstudytonight.com
港口 表示指定服务器使用的通信端口的字符串，例如 80
路径名 表示 URL 的字符串部分，指定如何访问特定资源，例如
搜索 表示以问号开头的字符串，用于指定 HTTP URL 中的任何查询信息，例如 batch=1
混杂 表示以哈希(#)开头的字符串，该字符串指定 HTTP URL 中的锚名称，例如#intro

让我们举个例子，了解一下 Location 对象的属性。

现在让我们看看位置对象的方法。

JavaScript 定位对象方法

位置对象方法是指在位置接口内部创建的函数，可用于对网址执行各种操作，如重新加载、更改等。

方法 描述
assign() 在浏览器中加载新文档
reload() 重新加载 location.href 属性中包含的当前文档。
replace() 用指定的新文档替换当前文档。此外，您不能使用浏览器的后退按钮导航回上一个文档。

要加载新文档，我们可以使用定位对象的assign()方法。但是在这个例子中，我们也使用了href属性和replace()方法。它们都可以用来加载文档。请参见下面的示例:

JavaScript 屏幕对象

原文：https://www.studytonight.com/javascript/javascript-screen-object

JavaScript Screen 是一个内置的接口(对象类型)，用于获取与当前窗口在其上呈现的浏览器屏幕相关的信息。

它提供有关显示屏尺寸的信息，如高度、宽度、颜色位等。

由于窗口对象位于作用域链的顶部，属性window.screen给出了 screen 对象，但是也可以在不指定窗口的情况下访问 Screen 对象，在这种情况下，JavaScript 会自动检测浏览器窗口，该窗口是由 JavaScript Runtime Engine 创建的。

让我们举一个简单的例子来看看屏幕对象的工作。

查找屏幕的高度和宽度:

在下面的例子中，我们使用屏幕对象来获得屏幕的宽度和高度:

JavaScript 屏幕对象属性

JavaScript Screen 对象包括一些用于获取浏览器屏幕信息的属性。下面给出了这些属性的表格。

属性 描述
可用高度 指定屏幕高度，不包括 windows 任务栏
可用宽度 指定屏幕宽度，不包括 Windows 任务栏
颜色深度 指定显示图像的调色板深度(以位为单位)
高度 指定屏幕的总高度
像素深度 指定屏幕的颜色分辨率，以每像素位数为单位
宽度 指定屏幕的总宽度

现在，我们将举一个例子来澄清屏幕对象属性的概念:

屏幕对象颜色深度属性是用于表示单个像素颜色的位数。它返回用于显示图像的调色板的位深度。

JavaScript 屏幕对象方法

Screen 方法对象中没有直接方法。

屏幕对象的用途

JavaScript Screen 对象可用于通过基于屏幕大小控制网络应用或网站的用户界面来改善用户体验。

JavaScript 文档对象

原文：https://www.studytonight.com/javascript/javascript-document-object

JavaScript Document 对象是一个提供对文档中所有 HTML 元素的访问的对象。当一个 HTML 文档被加载到浏览器窗口中时，它就变成了一个文档对象。

文档对象将 HTML 文档的元素(如 HTML、HEAD、BODY 和其他 HTML 标记)存储为对象。

文档对象是窗口对象的子对象，指的是浏览器。

您可以使用window.document属性或直接使用对象来访问文档对象。

看，我们能用文档对象做什么:

  • 假设您已经在 HTML 文档中使用 FORM 元素创建了一个表单，并在表单上添加了一些文本字段和按钮。提交表单时，您希望验证输入或在另一页上显示输入。在这种情况下，您可以使用作为窗口对象的子对象的文档对象。使用文档对象，您可以访问表单的元素并验证输入。

  • 文档对象提供不同的集合元素，如锚点和链接，这有助于您计算表单上特定元素的数量。

  • 文档对象还提供了URL、bgcolor等多种属性。这将允许您检索文档的详细信息和各种方法，如open()、close()、write()、etElementById()、getElementByName()等。它允许您执行各种任务，如打开一个 HTML 文档来显示输出和在网页上书写文本。

  • 文档对象还允许您通过提供名为 cookie 的属性来为网页创建 cookie。cookie 存储关于用户计算机的信息，这有助于访问访问过的网站。

现在让我们探索文档对象方法和属性。

JavaScript 文档对象属性

我们知道，一个对象的属性是与该对象相关联的值。使用以下符号访问属性:

objectName.propertyName

其中 objectName 是对象的名称， propertyName 是其属性的名称。

现在，我们将在下表中显示文档对象的属性:

属性 描述
甜饼干 返回包含与文档相关联的所有可见和未过期 cookies 的报告
领域 返回文档来源服务器的域名
上次修改时间 返回文档上次修改的日期
文档模式 返回浏览器处理文档时使用的模式
就绪状态 返回文档的加载状态。
推荐人 返回 HTML 文档中引用的文档的 URL
标题 返回在 TITLE 元素的开始和结束标记之间定义的 HTML 文档的名称
统一资源定位器 返回 HTML 文档的完整 URL。

让我们举个例子，看看文档对象属性的作用:

JavaScript 文档对象方法

JavaScript Document 对象还提供了各种访问 HTML 元素的方法。

现在，我们将向您展示文档对象的一些常用方法:

方法 描述 语法
open() 打开一个 HTML 文档来显示输出 
document.open(mimetype, replace)

|
| close() | 关闭一个 HTML 文档 |

document.close()

|
| write() | 将 HTML 表达式或 JavaScript 代码写入 HTML 文档 |

document.write(exp1, exp2, ...)

|
| writeln() | 在每个 HTML 表达式或 JavaScript 代码后写一个新的行字符 |

document.writeln(exp1, exp2, ...)

|
| getElementById() | 返回具有指定 id 的 HTML 文档的第一个元素的引用。 |

document.getElementById(id)

|
| getElementByName() | 返回具有指定名称的元素的引用 |

document.getElementsByName(name)

|
| getElementsByTagName() | 返回具有指定标记名的所有元素 |

document.getElementsByTagName(tagname)

|

现在我们举个例子，看看像open()、write()、getElementById()这样的文档对象方法，解释它们的用法。请参见下面的示例:

另请阅读:- 如何使用 JavaScript 构建不和机器人

ECMAScript 2020

ECMAScript 2020 或 ES11 中的新功能

原文：https://www.studytonight.com/javascript/ecmascript-2020-or-es11

在本文中，我们将介绍 ECMAScript 2020 新增的功能。

ECMAScript 是由 ECMA 国际根据 ECMA 262 文件标准化的通用脚本语言。这是一个 JavaScript 标准，用于跨多个浏览器为网页提供互操作性。

ECMAScript 一般用于万维网(WWW) 上的客户端脚本，也用于使用 Node.js 编写服务器应用程序和服务。

除了 JavaScript，多种语言都遵循 ECMAScript 规范，如 ActionScript、JScript 等。

ECMAScript 每年都会进化并发布更新，在新版本中增加新功能。此外，流行的浏览器很快增加了对新功能的支持，发布间隔时间很短。

ECMAScript 2020 是 ECMAScript 语言的第 11 版(也称为 ES11)，发布于2020 年 6 月。这是最新版本的 ECMAScript。

JS ECMA 脚本 2020 的特点

2020 年 ECMA 脚本新增功能如下:

  • string . prototype . matchell()

  • 动态导入

  • 比吉斯本

  • Promise.allSettled()

  • 全局此

  • 可选链接

  • 看涨合并

让我们了解一下所有这些特性。

string . prototype . matchell()方法

matchAll()是 ECMAScript 2020 中提供的串的新方法，配合正则表达式使用。这个方法返回所有与正则表达式匹配的迭代器。每个匹配项都是一个带有一些附加属性的数组，即索引和输入。

正则表达式必须有/g标志。否则，它将通过一个类型错误。

martchAll()的语法

matchAll()方法的语法如下:

string.prototype.matchAll(regexp)

因素

  • 字符串 -是要找到匹配的参考字符串。

  • 正则表达式 -是一个正则表达式对象。

  • 返回值 -返回值将是一个迭代器

动态导入

动态导入允许我们将 JavaScript 文件作为模块动态导入。当我们在 Javascript 代码中需要时，这个特性使我们能够在代码的任何地方导入任何代码。我们甚至可以在运行时从其他脚本中导入特定的函数。

动态导入的语法

动态导入的语法很简单，使用import()表达式:

import(moduleSpecifier)

比吉斯本

正如我们所知，JavaScript 只有一个用于数字的数据类型，这是一个数字类型。这种数据类型代表 64 位浮点数。它还表示小于 2^53 的整数。为了表示大于的数字，引入了 2^53-1** 、 BigInt 。**

BigInt 是一个内置 对象代表整数比 2^53-1 更有意义，后者是最大值****JavaScript可以在 BigInt 之前表示。对于 BigInt 数可以有多长，没有指定限制。

BigInt 值与数值相当类似，但两者略有不同。我们不能使用内置数学函数的 BigInt 值。

如何创建 BigInt 值？

我们可以通过在普通数值后添加n或者使用BigInt()函数来创建一个 BigInt 值。

let bigNum = 123432n;

// or use BigInt() function

Promise.allSettled()

ECMAScript 2020 介绍了Promise.allSettled()方法。该方法接受一个承诺列表并返回一个新的承诺，该承诺在所有输入的承诺已经履行或被拒绝后解决。

返回的承诺是用描述每个输入承诺结果的对象数组解析的。

当我们有多个不依赖对方成功完成的异步任务时，或者当我们想知道每个承诺的结果时，使用这种方法。

Promise.allSettled()方法的语法

Promise.allSettled(iterable);

参数

  • 可迭代 -可迭代参数是所有输入承诺的列表。

  • 返回值 -它返回一个待定承诺，当每个输入承诺都已结算时，该承诺将异步履行。

全局此

globalThis对象由 ECMAScript 2020 或 ES11 引入。

如今，JavaScript 被用于各种各样的环境中。除了 web 浏览器是 JavaScript 最常见的主机环境类型之外，我们还可以在服务器、手机、机器人硬件等上运行 JS 程序。使用像 NodeJS 这样的运行时。每个环境由它的对象模型组成，并且具有不同的语法到来访问全局对象。可以通过网页浏览器中的window、self或frame关键词访问全局对象。在 Node.js 中，global关键字用于访问****全局对象。在 Web Workers 中，只有self关键字存在。

访问全局对象的多种方式使得开发人员很难编写出能够在各种平台上运行的 JavaScript 代码。为了克服所有这些问题，引入了globalThis。

该对象为多个环境提供了一种标准方式访问全局对象。通过使用globalThis对象，我们可以创建一个代码，该代码将在窗口(如window引用可用的浏览器)和非窗口环境(后端运行 NodeJS)上工作，而无需添加任何额外的检查或测试。

通常，当我们不知道我们的代码将在哪个环境中运行时，或者当我们想要使我们的代码在不同的环境中可执行时，使用globalThis。为了在不支持这些功能的旧浏览器中实现这些功能，我们必须使用 polyfill。

可选链接(？。)

可选链接操作符在 ECMAScript 2020 中引入。(?.)符号代表可选链接操作符。它改变了从深嵌套对象访问属性的方式。它还解决了在 JavaScript 中访问一长串对象属性时必须进行多次空值检查的问题。

可选链接的用例

  • 它访问一个对象的可能为空或未定义的属性。

  • 它有助于从可能尚不可用的变量中获取结果。

  • 它有助于获取默认值。

  • 它有助于访问长长的属性链。

可选链接的语法

可选链接的语法如下:

obj.val?.prop

obj.val?.[expr]

obj.arr?.[index]

obj.func?.(args)

看涨合并

无效合并是 ECMAScript 2020 的新功能。是一个逻辑运算符，是两个问号 ( ??)所代表的。该运算符接受两个操作数来执行任何任务:

leftExpression ?? rightExpression

如果左表达式为空或未定义，则该运算符返回右表达式。

这个运算符与逻辑的 OR 运算符非常相似，如果左侧操作数是假的值，该运算符也返回右侧操作数值，而不仅仅是空值或未定义的值。****

****无效合并运算符的运算符优先级第五低**，直接低于||，现在高于条件(三元)运算符。

看涨组合的语法

leftExpression ?? rightExpression

结论

在本文中，我们已经了解了 ECMAScript 2020。此外，我们还了解到了 ECMAScript 2020 中增加的新功能，如下所示:

  • string . prototype . matchell()

  • 动态导入

  • 比吉斯本

  • Promise.allSettled()

  • 全局此

  • 可选链接

  • 看涨合并

在接下来的教程页面中，我们已经用代码示例详细介绍了所有这些新特性。单击“下一步”按钮逐一查看所有内容。

JavaScript BigInt

原文：https://www.studytonight.com/javascript/javascript-bigint

我们知道，JavaScript 只有一个数字的数据类型****，这是一个数字类型。这种数据类型代表 64 位浮点数。它还表示小于 2^53 的整数。为了表示比更大的数字，引入了 2^53-1** 、 BigInt 。**

BigInt 是一个内置对象，表示比 2^53-1 大的整数，是 JavaScript 能够表示的最大值。对于一个 BigInt 数值可以有多长没有具体的限制，在行为上， BigInt 数值与数值非常相似，但它们之间略有不同。我们不能使用内置数学对象的 BigInt 值。

如何创建 BigInt？

嗯，我们可以用BigInt()方法创建一个 BigInt 类型的对象，BigInt()的语法如下:

BigInt()

示例:

<!DOCTYPE html>
<html>
<head>
	<title>BigInt</title>
</head>
<body>
<script>
	const bigNum = BigInt(9007199254740991)
	console.log(bigNum);
	const hugeStr = BigInt("9007199254740991")
	console.log(hugeStr);
	const hexNum = BigInt("0x1fffffffffffff")
	console.log(hugehex);
	const octalNum = BigInt("0o377777777777777777")
	console.log(octalNum);
	const binaryNum = BigInt("0b11111111111111111111111111111111111111111111111111111")
	console.log(binaryNum);
</script>
</body>
</html>

输出:

BigInt Javascript example

将运算符与 BigInt 一起使用

BigInt 类型支持所有 JS 操作符，尤其是这些+、*、-、%、**。除了>>>和一元+运算符外，BigInt 还支持按位运算符。除运算符 ( /)也将使用整数s，但结果不会是任何小数位数。

示例:

在本例中，我们使用除法运算符(/)对两个整数进行了除法运算，该运算符返回舍入值 2 而不是 2.5 。这是因为在 BigInt 上执行的所有操作都会返回 BigInt 。

<!DOCTYPE html>
<html>
<head>
	<title>BigInt</title>
</head>
<body>
<script>
	const wholeNum = 5n / 2n
	console.log(wholeNum);
</script>
</body>
</html>

输出:

Using Operators with BigInt

BigInt 的比较

一个大整数不是严格等于一个数，但可以是宽松等于。这意味着当我们使用严格相等的将两个 BigInt 值与(===)进行比较时，结果为假，但是当我们使用宽松相等的将相同的值与()进行比较时，结果将显示为真。

让我们用例子来更好地理解它。

示例:

<!DOCTYPE html>
<html>
<head>
	<title>BigInt</title>
</head>
<body>
<script>
	console.log(2n === 2);
	console.log(2n == 2);  
</script>
</body>
</html>

输出:

我们可以看到，第一个表达式的输出是假，而第二个表达式是真。

BigInt and Numbers

BigInt 中的条件句

在以下情况下，一个大数值的行为类似于一个数值:

  • 使用boolean()功能将 BigInt 值转换为布尔值时

  • 与逻辑运算符如||、&&和!一起使用时。

  • 在条件测试中，如if()语句。

例子

<!DOCTYPE html>
<html>
<head>
	<title>BigInt</title>
</head>
<body>
	<script>
		let count = 0n;

		if(count) {
			console.log("Hello");
		} 
		else {
			console.log("Bye");
		} 
	</script>
</body>
</html>

输出:

在上面的例子中，BigInt 值作为一个数字，它的值被视为 0，因此，else 块被执行，因为在 if-else 语句中 0 值转换为 false 。

Using BigInt with conditionals

带typeof运算符的 BigInt

BigInt 的类型是 BigInt。所以当我们用带 BigInt 的typeof运算符知道 BigInt 的数据类型时，它会返回 BigInt 类型。

示例:

下面是一个简单的代码示例，

<!DOCTYPE html>
<html>
<head>
	<title>BigInt</title>
</head>
<body>
	<script>
		console.log(typeof BigInt(100) === 'bigint'); 
		console.log(typeof 1n === 'bigint')
	</script>
</body>
</html>

输出:

Using typeof with BigInt

结论

BigInt()方法在 ECMAScript 2020 或 ES11 中介绍。该方法用于表示大于 2^53 - 1 的整数。此方法用于创建用于执行复杂数学计算的值。

JavaScript Promise.allSettled()方法

原文：https://www.studytonight.com/javascript/javascript-promise-all-settled-method

承诺是异步操作的实现，用于管理异步操作。在 JavaScript 中，每个 Promise 由以下状态组成:

  • 完成或解决(成功操作)

  • 拒绝(失败操作)

  • 既不满足也不拒绝

在继续之前，你应该先介绍一下 Javascript Promise 和处理 Promise 状态的方法。

ES6 或 ES2015 中承诺类执行的方法有all()、reject、resolve等。而allSettled()方法在 ECMAScript 2020 中介绍。

Promise.allSettled()方法接受一系列承诺****返回一个新承诺****解决在所有输入承诺都解决之后，要么解决要么拒绝。

简单来说，我们可以说这个函数可以用来监控和报告承诺列表的状态。

当我们有多个异步任务时，使用这个方法。这些异步任务并不相互依赖才能成功完成。当我们想知道每个诺言的结果时，也可以使用这种方法。

相比之下，Promise.all()返回的承诺在任务相互依赖时使用。

allSettled()的语法:

下面是我们如何使用这个函数，

Promise.allSettled(iterable);

参数:

  • 一个可迭代是一个对象，比如一个数组，其中每个成员都是一个承诺。

返回值:

当我们将一个空可迭代的作为参数传递给时，Promise.allSettled()方法返回一个已经被解析为空数组的 Promise 对象。

对于每个返回的对象，都有一个状态字符串。如果状态属性的值为满足，则存在值属性，如果状态属性的值为拒绝，则存在原因属性。

值(或原因 ) 属性决定了每个承诺是否被履行(或拒绝)。

示例:

在给定的示例中，我们使用了Promise.allSettled()方法来等待所有的输入承诺解决。

<!DOCTYPE html>
<html>
<head>
	<title>Promise.allSettled() method</title>
</head>
<body>
	<script type="text/javascript">
		const p1 = new Promise((resolve, reject) => {
		setTimeout(() => {
		    console.log('The first promise has resolved');
		    resolve(10);
		}, 1 * 1000);

		});

		const p2 = new Promise((resolve, reject) => {
		setTimeout(() => {
		    console.log('The second promise has rejected');
		    reject(20);
		}, 2 * 1000);
		});

		Promise.allSettled([p1, p2])
		.then((result) => {
		    console.log(result);
		});
	</script>
</body>
</html>

输出:

正如我们在输出图像中看到的那样，第一个承诺 p1 在 1 秒后履行了的值 10，而承诺 p2 在 2 秒后被以原因 20 拒绝。

Using Promise.allSettled method

结论:

我们已经了解了 ECMAScript 2020 中介绍的Promise.allSettled()方法。该方法接受一个承诺列表，并返回一个新的承诺，一旦每个输入的承诺都得到解决，无论是被拒绝还是被履行，该承诺都会得到解决。

JavaScript matchAll()函数

原文：https://www.studytonight.com/javascript/javascript-es11-matchall-function

matchAll()是 ECMAScript 2020 提供的字符串类的新方法，可用于正则表达式。此方法返回存在于特定字符串中的正则表达式的所有匹配项。匹配作为迭代器返回以一次一个的方法访问它们，或者我们可以使用for...of循环将它们转换成数组然后访问它。

matchAll()的语法:

string.prototype.matchAll()方法的语法如下:

string.prototype.matchAll(reg_exp)

参数:

  • 字符串 -这是要找到匹配的参考字符串。

  • Regexp -是包含 /g 标志的正则表达式对象；否则，它将通过类型错误。

  • 返回值 -返回值将是一个包含匹配项的迭代器，包括捕获组。

返回值的每一项都将具有以下属性:

  • 组 -它由正则表达式中指定的命名捕获组的结果组成

  • 索引 -找到结果的搜索索引。

  • 输入 -搜索字符串的副本。

让我们借助一个例子来更好地理解它。

示例:应用String.prototype.matchAll()方法

在这个例子中，我们已经演示了如何使用正则表达式找到匹配，并且借助matchAll()方法捕获了内部组。

<!DOCTYPE html>
<html>
<head>
	<title>ECMA Script</title>
</head>
<body>
<script>
	const regexp = /t(e)(st(\d?))/g;
	const str = 'test1test2';
	const array = [...str.matchAll(regexp)];
	console.log(array[0]);
	console.log(array[1]);
</script>
</body>
</html>

输出:

Javascript String matchAll() method

结论

在本文中，我们解释了matchAll()方法，并介绍了该方法的用法。此外，我们还学到了以下几点:

  • String.prototype.matchAll()方法返回一个迭代器，该迭代器代表匹配项，允许我们在需要时迭代、破坏或转换为数组。

  • 如果没有找到匹配的，那么String.prototype.matchAll()方法返回一个空值。

  • 该方法考虑所有匹配，包括简单使用的捕获组。

  • 该方法在使用非全局正则表达式时抛出类型错误。

  • 在用完迭代器之后，我们需要重新调用String.prototype.matchAll来再次迭代。

JavaScript 空合并运算符

原文：https://www.studytonight.com/javascript/javascript-nullish-coalescing-operator

无效合并在 ECMAScript 2020 中推出。用??双问号表示。

该运算符是逻辑 or 运算符 ( ||)的改进版本。无效合并运算符的工作方式与逻辑或运算符非常相似。唯一不同的是它检查值是否为null而不是 falsy 。这意味着如果左侧的值为空值和未定义，操作符将返回其右侧操作数操作数。

这里有一个表格，列出了什么被认为是虚假值，什么是无效值。

虚假价值观 看涨价值
不明确的 不明确的
空 空
Zero -
错误的 -
圆盘烤饼 -

如果用于如果...否则声明，虚假值视为虚假。

无效合并运算符的第五低运算符优先级，它比逻辑的或运算符直接低，比条件的运算符高。****

******### 无效合并的语法:

以下是使用 nullish 合并运算符的语法:

left_expression ?? right_expression

让我们借助一个例子来理解它

使用无效合并运算符:

如上所述，无效合并操作符仅为无效值设置回退值(未定义且为空)。因此，当我们在未定义或为空的情况下使用该运算符时，它将返回回退值(右侧值)，如图所示。

using nullish coalescing operator in javascript

当我们将此运算符与其他虚假值一起使用时，如零、假、楠等。，则将返回****左侧值，如图所示。

using nullish coalescing operator in javascript

示例:

在给定的示例中，有一个对象名person具有两个属性name和age。首先，我们使用逻辑 OR 运算符将这两个属性的值与回退值进行了比较。然后我们使用无效合并操作符比较了相同的属性。

<!DOCTYPE html>
<html>
<head>
	<title>Nullish Coalescing</title>
</head>
<body>
	<script type="text/javascript">
		let person = {
		profile: {
		name: "",
		age: 0
		}
		};

		console.log(person.profile.name || "Anonymous"); 
		console.log(person.profile.age || 18); 

		console.log(person.profile.name ?? "Anonymous"); 
		console.log(person.profile.age ?? 18); 
	</script>
</body>
</html>

输出:

正如我们在输出图像中看到的，前两个输出是右侧值。之所以会出现这种情况，是因为如果的左操作数不是的空值，则逻辑 OR 运算符||返回的右操作数，而如果的左操作数既不是的空值，也不是的未定义值，则逻辑 OR运算符??返回的空值。

using nullish coalescing operator in javascript

结论

无效合并运算符是逻辑或运算符的扩展。此运算符仅检查左操作数是空还是未定义。

JavaScript 可选链接运算符

原文：https://www.studytonight.com/javascript/javascript-optional-chaining-operator

新的 Javascript 可选链接运算符在 ECMAScript 2020 中引入，也称为 ES11 或 ES 2020 。用?.(问号、点)表示。

可选链接只不过是一个语法，借助它我们可以访问 Javascript 对象中的深度嵌套属性，而无需检查该属性是否存在。不是返回一个对象，而是返回 null 或 undefined 。

可选链接运算符的语法:

以下是使用可选链接运算符的语法，

obj.val?.prop
obj.val?.[expr]
obj.arr?.[index]
obj.func?.(args)

让我们借助一些例子来理解它。

使用可选链接运算符:

在给定的代码中，有一个嵌套对象(对象内部的对象)。有一个对象obj的值是一个人，其中person是另一个对象，有一个属性name值今晚学习。

let obj = {
	person: {
		name: 'studytonight'
	}
};
console.log(obj.person.name);

当我们试图访问嵌套对象的name属性时，我们将得到“今晚学习”如输出图像所示。

javascript optional chaining example

理解没有可选链接的问题:

现在假设person对象没有name属性。现在，当我们试图访问obj.person.name时，我们将得到未定义的。

let obj = {
	person: {

	}
};
console.log(obj.person.name);

以下是输出:

javascript optional chaining example

上面的代码运行良好，因为person对象存在，但其属性未定义。但是如果物体person也不存在呢？然后，Javascript 会抛出一个错误，因为我们试图访问一个不存在的属性。

让我们进一步修改上面的代码，删除person对象。现在，当我们试图访问相同的属性时，我们会得到一个错误。

let obj = {

};
console.log(obj.person.name);

出现错误是因为obj.person已经未定义，我们试图访问未定义实体obj.person的属性name。

javascript optional chaining example

在早期的 Javascript 中，我们曾经有检查来处理这种类型的错误或者避免意外的 Javascript 错误。但现在不是了！

可选链接在这里！

当我们试图访问深度嵌套对象时，处理意外 JavaScript 错误的更简单方法是使用可选链接运算符。

现在我们将使用可选链接运算符访问上面给出的相同代码。

let obj = {

};
console.log(obj?.person?.name);

如我们所见，我们将得到未定义的，而不是错误。发生这种情况是因为可选链接操作符。

javascript optional chaining example

因此，我们不必应用特殊的检查来查看嵌套属性是否存在，我们可以简单地使用可选的链式运算符。

可选链接运算符的优势:

  • 更容易使用，代码更少。

  • 增加了人的可读性，减少了检查空值的假设条件。

  • 有助于避免错误。

  • 当我们试图访问深度对象属性时，这将非常有用。

结论:

可选链接操作符对于深度检查****嵌套对象非常有用。它允许我们避免为检查****属性的存在而写几个检查和语句。

JavaScript globalThis对象

原文：https://www.studytonight.com/javascript/javascript-globalthis-object

现在 JavaScript 在不同的环境下使用。除了 web 浏览器(这是 JavaScript 最常见的主机环境类型)之外，我们还可以在服务器、智能手机、机器人硬件等中运行我们的 JavaScript 程序。

每个环境由它的对象模型组成，并且有一个不同的语法用于访问全局对象。众所周知，网络浏览器中的全局是一个窗口。

同样，每个环境都有自己的全局对象，比如在 node.js 中，全局关键字用于访问全局对象， web workers 使用 self 作为全局对象。

在不同环境中引用全局对象的不同方式使得开发人员很难编写一个可以在多个平台上执行的 JavaScript 代码。

为了克服所有这些问题，globalThis对象是在它的帮助下引入的，我们可以在多个环境上执行 JavaScript 代码。

在 globalThis 对象的帮助下，我们可以在窗口甚至非窗口上下文上执行我们的代码，而无需像以前那样编写额外的检查和测试。

在大多数环境中，globalThis直接指的是那个环境的全局对象。

一般来说，这个对象在我们不知道我们的代码将在哪个环境中执行或者当我们想要使我们的代码在不同的环境中可执行时非常有用。

如果我们想在不支持 globalThis object 的旧浏览器中使用这个特性，那么我们必须使用 polyfill 。

句法

globalThis.[variable]= data

示例:全局此关键字

在这个例子中，我们已经全局保存了我们的数据，并且用globalThis对象检索。

<!DOCTYPE html>
<html>
<head>
	<title>globalThis object</title>
</head>
<body>
	<script>
		function setGlobalData() {
		globalThis.mydata ='Hello World';
		}
		setGlobalData();
		console.log(globalThis.mydata ); 
	</script>
</body>
</html>

输出

output

支持的浏览器

  • 铬
  • 边缘
  • 火狐浏览器
  • 歌剧
  • 旅行队

结论

在本模块中，我们了解了 globalThis object ，该对象在 ECMA 脚本 2020 中介绍，也称为 ES11 或 ES2020 。globalThis对象在创建跨平台代码时使用，这意味着代码将在不同的 JavaScript 环境下执行。

ECMAScript 2019

ECMAScript 2019 或 ES10 简介

原文：https://www.studytonight.com/javascript/introduction-to-ecmascript-2019-or-es10

ECMAScript (ES)是由 ECMA 国际在 ECMA-262 中标准化的脚本语言。ECMAScript 的创建是为了标准化 JavaScript，以提供跨多个浏览器的网页互操作性。ECMA 剧本的新版本每年都会发布，有一些令人兴奋的新功能。

ECMAScript 2019 是 ECMAScript 的第十版，也称为 ES10 或 ES2019 。这个版本引入了一些方法和功能，允许开发人员编写更少的代码和做更多的工作。

ECMAScript 中引入的特性如下:

  • Array.flat()
  • Array.flatMap()
  • Object.fromEntries()
  • String.trimStart()和 String.trimEnd()
  • 可选捕获绑定
  • 符号.描述

我们将在本模块的后面讨论它们。让我们开始吧。

Array.flat()

Array.flat() 是用来压平一个阵的方法。但是，在某些情况下，数组的元素也是数组。这些类型的数组也被称为嵌套数组。以前，我们必须使用递归对这些类型的数组进行排序。但是现在，我们可以使用 flat() 方法对嵌套数组进行排序。

句法

arr.flat(|depth|);

Array.flatMap()

array.flapMap()方法由两种方式的功能组成平铺和映射。它的功能就像一个地图，但它也平坦的阵列。

该方法首先使用映射函数映射每个元素，然后展平嵌套数组得到一个新数组。这个函数可以在数组上实现，并以回调作为参数。回调决定如何展平(排序)数组。

这个方法可以将深度** 一的数组**展平，只是因为在内部，一个贴图函数被深度为 1 的展平函数调用。

句法

arr.flatMap(callback);

Object.fromEntries()

Object.fromEntries() 方法由 ECMAScript 2019 推出。在 ES7 中，有一种object.entries()方法，将对象键值对转换成数组。Object.fromEntries()法是Object.entries()法的逆。

Object.fromEntries()方法用于从给定的键值对形成对象。该方法将键值对的列表转换为对象，该对象的属性由条目决定。

句法

Object.fromEntries(Iterable);

String.trimStart()和 String.trimEnd()

ES10 为字符串类引入了两种新方法。这两种方法用于从给定的字符串中删除多余的空格。下面给出了这两种方法:

  • string . trimstart()
  • String.trimEnd()

String.trimStart() 方法从字符串的开头移除多余的空白。

句法

String.trimStart();

Strim.trimEnd()方法用于去除字符串末尾多余的空白。

句法

String.trimEnd();

可选捕获绑定

以前，不管有没有必要，我们都必须将异常变量绑定到 catch 子句。所以很多时候观察到抓挡只是多余的。但是 ECMAScript 10 引入了可选的 catch binding ，允许我们使用尝试和 catch block 而无需错误变量绑定。

注意:捕捉误差变量在 ES10 中是可选的。

符号.描述

在 JS 中创建符号的同时，我们可以添加一个描述，用于调试目的。但是访问这个描述是相当棘手的。要通过访问指定的描述，我们必须使用 toString() 方法再次构建符号。

ECMAScript 2019 引入了一个新的只读属性，称为描述。此属性用于返回符号的描述。

结论

在本课中，我们学习了 ECMA 脚本 2019 (ES10)中引入的新功能。我们将在接下来的文章中详细解释每一个。

JavaScript Array.flat()方法

原文：https://www.studytonight.com/javascript/javascript-arrayflat-method

在几种情况下，数组的元素也是数组。这些类型的数组被称为嵌套数组。

以前，我们必须使用递归来对这些类型的数组(嵌套数组)进行排序，这是相当繁琐的。所以，为了让这个过程更容易，ECMA 脚本 2019 (ES10)引入了一个新的方法，称为Array.flat()。

Array.flat() 法用于压平一个阵。借助这个方法，我们可以将的解嵌套(展平)嵌套数组在一条直线内。

展平数组是深度为 0 的数组。flat 方法接受一个参数，一个代表数组深度的数字。深度是数组中嵌套数组的数量。

句法

Array.flat(depth);

返回类型

  • 它返回一个扁平数组。

因素

  • 参数深度是可选的。
  • 深度级别指定嵌套数组结构应该取消嵌套(展平)的深度。
  • 深度参数的默认值为 1 。

例 1

在 JavaScript 中，数组的深度可以是无限的。给定阵列的深度为3。我们已经把这个阵压平了直到深度 2 。所以主数组里面还是有一个嵌套数组。

var num = [1, [2, [3, [4, ]]]];

console.log(num.flat(2));  // output [1,2,3, Array(1)]

例 2

在给定的示例中，我们使用深度 4 的 var 关键字创建了一个嵌套数组 arr。该数组由字母作为其元素组成，但采用嵌套数组的形式。所以，我们要用flat() 的方法去解嵌套这个数组。

<!DOCTYPE html>
<html>
<head>
	<title>Array.flat()</title>
</head>
<body>
	<script type="text/javascript">
		var arr = ["S", "T", ["U", "D", "Y", ["T", "O", "N", ["I","G", ["H", "T"]]]]];
		/* Flatten till depth 2*/
		console.log(arr.flat(2));

		/* Flatten till depth 3*/
		console.log(arr.flat(3));

		/* Flatten till depth 4*/
		console.log(arr.flat(4));
	</script>
</body>
</html>

输出

在给定的输出中，有三个数组。当我们让将阵列展平至 2 的深度时，会出现第一个阵列。

第二阵出现在我们将阵压平到深度 3 的时候，而第三阵出现在我们将阵压平到深度 4 的时候。

output

结论

这节课，我们学习了 ECMA 剧本 2019 或 ES 10 中介绍的array.flat()。此方法用于将平铺****嵌套数组在一条直线上。

JavaScript Array.flaMap()方法

原文：https://www.studytonight.com/javascript/javascript-arrayflatmap-method

Array.flatMap()法引入于 ECMA 剧本 2019 或 ES10 。此方法用于展平嵌套数组。

之前学过flat()法，也是用来压平的嵌套阵，但是两种方法略有不同。

Array.flaMap()法是map() 法和flat()法的结合。此方法首先使用映射函数映射数组中的每个元素，然后将数组和结果展平为一个新数组。

这个方法可以用来展平深度 1** 的数组只是因为它调用了一个 map()函数后跟一个深度为 1 的 flat()函数。**

句法

// Arrow function
flatMap((currentValue) => { ... } )
flatMap((currentValue, index) => { ... } )
flatMap((currentValue, index, array) => { ... } )

// Callback function
flatMap(callbackFn)
flatMap(callbackFn, thisArg)

// Inline callback function
flatMap(function callbackFn(currentValue) { ... })
flatMap(function callbackFn(currentValue, index) { ... })
flatMap(function callbackFn(currentValue, index, array){ ... })
flatMap(function callbackFn(currentValue, index, array) { ... }, thisArg)

因素

  • 回调- 它是一个产生新数组元素的函数，采用三个参数:
    • 当前值- 数组中正在处理的当前元素。
    • 索引(可选)- 数组中正在处理的当前元素的索引。
    • 数组(可选)- 调用数组映射。
  • 该参数(可选) -执行回调时用作该参数的值。

返回值

返回一个新数组，其中每个元素都是回调函数的结果，并被展平到 1 的深度。

例 1

在给定的例子中，我们使用flatMap()方法将映射到数组的元素。

<!DOCTYPE html>
<html>
<head>
	<title>flatMap()</title>
</head>
<body>
	<script type="text/javascript">
		const names = ['Study', 'Tonight'];
		const result = names.flatMap((name, index) => [name, index]);
		console.log(result);
	</script>
</body>
</html>

输出

output

示例:使用 flatMap()方法过滤数组元素

在给定的例子中，我们创建了一个名为数字的嵌套数组。

首先，我们使用flat()方法将展平阵列，然后我们使用flatMap().方法将从阵列中移除负数。

<!DOCTYPE html>
<html>
<head>
	<title>flatMap()</title>
</head>
<body>
	<script type="text/javascript">
		const numbers = [1, [3, 6,], [2, -3, 7, ], [-4,], 5, 8, 9];

		console.log(numbers.flat(3));

		const result = numbers.flatMap(number => {
		return number < 0 ? [] : [number];
		});

		console.log(result);
	</script>
</body>
</html>

输出

正如我们在输出中看到的，有两个数组。第一个数组是我们使用flat()得到的平坦数组。

第二个数组是过滤数组，其中我们已经使用flatMap()方法过滤了负数。

output

结论

flatMap() 方法由 ECMAScript 2019 推出，也称为 ES 10。该方法由属性map()方法和flat()方法组成。这个方法首先映射数组中的每个元素，然后将其展平，得到一个新的数组。

JavaScript trimStart()和trimEnd()方法

原文：https://www.studytonight.com/javascript/javascript-trimstart-and-trimend-method

之前，我们不得不使用String.trim()方法(在 ES5 中引入)来从字符串中移除****空格。它删除了两边(开始和结束)多余的空白。但是，如果我们只想从某个特定的方面删除空白呢？

所以，为了解决这个问题， ECMAScript 2019 或 ES10 引入了两个新功能，如下所示:

  • string . trimstart()
  • String.trimEnd()

让我们详细讨论每一个。

弦trimStart()法

顾名思义，String.trimStart()方法从字符串的开始处修剪****空白。空白字符可以是空格、制表符等。

句法

trimStart()

返回值

  • 返回的新字符串开头没有空格。
  • 如果字符串的开头没有空格，则仍会返回一个新字符串，而不会引发错误。

例 1

在本例中，我们将使用trimStart()方法修剪****空格，该空格出现在字符串的开头。

<!DOCTYPE html>
<html>
<head>
	<title>String.trimStart()</title>
</head>
<body>
	<script type="text/javascript">
		const message = '        Welcome to Studytonight.';
		console.log(message);
		console.log(message.trimStart()); 
	</script>
</body>
</html>

输出

我们首先在不使用 trimStart() 方法的情况下打印字符串，然后使用 trimStart() 方法打印字符串。

output

弦trimEnd()法

String.trimEnd()方法从字符串的末端移除空白。trimRight()方法是此方法的别名。

句法

trimEnd()

返回值

  • 返回一个新字符串，其末尾没有空格。
  • 如果字符串末尾没有空格，则仍会返回一个新字符串，而不会引发错误。

例 2

在给定的示例中，我们创建了一个字符串，并在它的末尾指定了额外的空白。我们使用trimEnd()方法移除多余的空格，该空格出现在字符串的末端。

<!DOCTYPE html>
<html>
<head>
	<title>String.trimEnd()</title>
</head>
<body>
	<script type="text/javascript">
		const message = 'Welcome to Studytonight.          ';
		console.log(message);
		console.log(message.trimEnd()); 
	</script>
</body>
</html>

输出

output

结论

在这一课中，我们学习了两种新的弦乐方法:trimStart()和trimEnd()。trimStart()方法用于修剪字符串开头的空白，而trimEnd() 方法用于移除字符串结尾的空白。

JavaScript 可选的捕获绑定

原文：https://www.studytonight.com/javascript/javascript-optional-catch-binding

在早期版本的 JavaScript 中，无论是否需要，都需要将异常变量传递给 catch 语句。为了避免这种情况，引入了可选锁扣绑定。

可选捕捉绑定是由 ECMAScript 2019 (ES10)推出的 JavaScript 新功能。

可选的捕捉绑定允许我们使用尝试/捕捉语句而不通过****错误参数在捕捉块内。您可以选择是否传递错误变量。

让我们借助一个例子来理解它。

示例:没有可选的捕获绑定

这里，我们必须在 catch 块中传递一个变量。

//Without optional catch binding

try {
// do something
} catch (error) {
// we have error parameter to handle it
}

示例:带有可选的捕捉绑定(ES10)

在这里，我们可以跳过在 catch 块中传递变量。

//With optional catch binding

try {
// do something
} catch {
// no binding or parameter to handle it
}

正如我们在第一个例子中看到的，一个异常参数错误被传递给 catch 语句。

该参数用于识别在试块内出现哪种类型的错误。而在第二个例子中，正如我们已经注意到的，没有参数传递给 catch 语句，因为它在 ES10 中是可选的。****

如果在处理异常的代码中不需要异常对象，这将很有帮助。

示例:可选捕获绑定

在这个例子中，我们已经演示了使用尝试和捕捉块 与和无例外变量。

<!DOCTYPE html>
<html>
<head>
<title>Optional catch binding</title>
</head>
<body>
	<script type="text/javascript">
	//Wihout optional catch binding
	try {
		throw new Error("Some random error");
	} catch (error) {
		console.log(error)
	}

	//With optional catch binding
	try {
		throw new Error("Hey");
	} catch {
		console.log("No parameter for catch");
	}
	</script>
</body>
</html>

输出

output

结论

在本文中，我们学习了 ECMAScript 2019 或 ES10 中引入的可选捕捉绑定。它允许我们在向 catch 语句传递或不传递异常变量的情况下使用 catch 块。

PHP

入门

PHP 简介

原文：https://www.studytonight.com/php/introduction-to-php

PHP 是 web 开发中最广泛使用的服务器端脚本语言之一。像脸书、雅虎、维基百科等热门网站以及我们自己的《今夜研究》都是使用 PHP 开发的。

PHP 之所以如此受欢迎，是因为它在服务器上学习、编码和部署非常简单，因此几十年来一直是初学者的首选。

在本教程系列中，我们将涵盖 Php 语言从基础到高级的所有重要概念，还将为初学者分享一些现成的、有用的代码片段，以启动他们的 web 开发项目。

PHP 是什么？

PHP 代表超文本预处理器。PHP 是一种脚本语言，用于开发静态和动态网页和网络应用程序。下面是一些关于 PHP 的重要知识:

  1. PHP 是一种解释语言，因此它不需要编译器。
  2. 为了运行和执行 PHP 代码，我们需要一个必须安装 PHP 的网络服务器。
  3. PHP 是一种服务器端脚本语言，这意味着 PHP 在服务器上执行，结果以纯 HTML 格式发送到浏览器。
  4. PHP 是开源和免费的。

从 PHP 开始的先决条件

虽然我们将在本教程系列中涵盖所有与 PHP 相关的概念，但是在开始本教程之前，您必须对 HTML 有一个基本的了解。

您可以使用我们的 HTML 互动课程学习 HTML，该课程也有印地语版本。

PHP 是正确的语言吗？

如果您仍然不知道是否应该学习 PHP，或者 PHP 是否是适合您的网络项目的语言，那么这里我们列出了 PHP 语言的一些特性和用例，这将帮助您了解 PHP 脚本语言是多么简单而强大，以及您为什么应该学习它。

  1. PHP 是开源的和免费的，因此你可以免费下载、安装并开始使用它进行开发。
  2. PHP 有一个非常简单易懂的语法，因此与其他脚本语言如 JSP 、ASP 等相比，学习曲线更小。
  3. PHP 是跨平台，因此您可以轻松地开发和移动/部署您的 PHP 代码/项目到几乎所有的主要操作系统，如视窗、Linux、苹果 OSX 等。
  4. 所有流行的网络托管服务都支持 PHP 。此外，PHP 的网络托管计划通常是最便宜的计划之一，因为它很受欢迎。
  5. 像 Joomla 、 Drupal 等流行的内容管理系统都是用 PHP 开发的，如果你想创建自己的网站，比如《今夜研究》，你可以用 PHP 轻松实现。
  6. 使用 PHP，您可以创建静态和动态网页，执行文件处理操作，发送电子邮件，访问和修改浏览器 cookies，以及您可能希望在 web 项目中实现的几乎所有其他功能。
  7. 与 JSP 和 ASP 等其他脚本语言相比，PHP 的速度更快。
  8. PHP 内置了对 的支持，MySQL ，是应用最广泛的数据库管理系统之一。

这些是 PHP 的一些主要特性，当你学习这门语言时，你会意识到除了这些特性之外，

PHP 的使用

为了进一步巩固您对 PHP 的信任，下面是这种惊人的脚本语言的一些应用:

  1. 可以用来创建网络应用像社交网络(脸书，Digg)，博客(Wordpress，Joomla)，电商网站(OpenCart，Magento 等)。)等。
  2. 命令行脚本。您可以编写 PHP 脚本在任何机器上执行不同的操作，您需要的只是一个 PHP 解析器。
  3. 使用脸书的 PHP SDK，创建脸书应用程序并在您的网站中轻松集成脸书插件。更多信息请查看链接。
  4. 发送电子邮件或构建电子邮件应用程序，因为 PHP 提供了强大的电子邮件发送功能。
  5. Wordpress 是世界上使用最多的博客(CMS)平台之一，如果你懂 PHP，可以试一试 Wordpress 插件开发。

在你的本地机器上安装 PHP

原文：https://www.studytonight.com/php/install-php

要在任何机器(服务器、计算机等)上运行 PHP 脚本，我们需要在其上安装 PHP。在本教程中，我们将学习如何在我们的计算机/笔记本电脑上安装 PHP 并设置开发环境。

对 PHP 的要求

要运行 PHP 脚本，我们需要以下服务:

  1. PHP 解析器:要执行 PHP 脚本，需要安装 PHP。
  2. 网络服务器:由于 PHP 主要用于开发网站，因此其大部分实现都与 Apache 网络服务器捆绑在一起，Apache 网络服务器是托管通过 HTTP 用 PHP 开发的应用程序所必需的。
  3. 数据库:任何一个数据库管理系统，一般都是 MySQL，因为 PHP 自带对 MySQL 的原生支持

现在，您可以自己单独安装所有 3 个服务，或者您可以简单地下载并安装自动安装上述所有服务的软件。

最受欢迎的此类软件包是 XAMPP 。

什么是 XAMPP？

XAMPP 代表:

X :跨平台，因为它支持 Windows、Mac OSX、Linux 等所有现代操作系统。

A :阿帕奇网络服务器

M : MySQL 数据库管理系统。

P : PHP 安装

P : Perl 脚本语言

XAMPP logo

你可以从这个链接轻松下载安装 XAMPP。安装过程很简单，一旦安装，您将看到一个像这样的小窗口，显示正在运行的各种服务的状态。

XAMPP Window Snapshot

您可以使用 XAMPP 控制面板轻松控制、停止和重启各种服务。

安装成功后，将在 c 盘创建一个名为 xampp 的文件夹(默认)。在 xampp 文件夹中有很多子文件夹，如 apache、cgi-bin、FileZillaFTP 等，但最重要的子文件夹是:

  1. htdocs :这是我们将保存所有 PHP 文件的文件夹。
  2. mysql :这个文件夹包含了 mysql 数据库的所有文件。默认情况下，MySQL 数据库运行在端口号 3306 上。
  3. php :这个文件夹保存了 php 的所有安装文件。当前 PHP 安装的所有配置都保存在 php.ini 文件中，该文件存储在该文件夹中。

如果一切正常，并且 apache 服务器正在运行(检查 XAMPP 控制面板)，打开您的网络浏览器，在地址栏中输入localhost，然后按回车键。您将看到 Apache 网络服务器的默认页面。

Apache Webserver It Works

其他软件包

XAMPP 不是唯一可用的软件包，尽管它是使用最广泛的软件包。以下是您可以下载和安装的其他一些特定于操作系统的选项:

  • 【WAMP】:是给 Windows 用的(Window、Apache、MySQL、PHP)
  • 【MAMP】:是给 Mac OSX 的(Macintosh、Apache、MySQL、PHP)
  • 【LAMP】:是给 Linux 用的(Linux、Apache、MySQL、PHP)

编写 PHP 代码的集成开发环境或编辑器

由于 PHP 代码没有编译，您甚至可以使用记事本这样的简单编辑器来创建 PHP 代码文件。但是有一个外观漂亮的编辑器总是好的，它可以突出显示代码，在编码时为您提供建议，甚至在编写代码时分析代码的语法错误。

在我们检查 ide 和编辑器的列表之前，我们必须知道两者之间的区别。一个编辑器是一个简单的文本编辑器，具有增强的功能，如语法高亮等，许多现代编辑器也允许特定语言的插件下载，以支持更多的功能。

而 IDE 是一个集成开发环境，它是一个独立的包，允许您在同一个地方编写、编译、执行和调试代码。

因此，如果你想要一个轻量级的软件，去任何编辑器，如果你想要一个轻量级的 IDE，你可以从下面的列表中选择任何一个。

这里有几个好的 ide 和编辑器:

  1. netbeans ide
  2. Eclipse IDE
  3. 暴风雨在这里
  4. 原子编辑器
  5. 括号编辑器
  6. 记事本++
  7. 升华文字

下载并安装任何你想要的。我个人使用的是 Atom 编辑器，因为它的闪电速度很快，附带了一些惊人的主题选项和插件。

第一个 PHP 示例

原文：https://www.studytonight.com/php/first-php-example

在本教程中，我们将学习编写基本 PHP 代码的语法，如何将 PHP 代码集成到一个 HTML 文件中，以及如何运行 PHP 脚本并在浏览器中检查输出。

您必须安装并运行 XAMPP，PHP 脚本才能工作。如果你没有安装 XAMPP，去最后一个教程安装 XAMPP。

PHP 中的 Hello World 脚本

所有的 php 代码都写在 php <code>标签里面，也就是<?php和?>。带有 php 代码的文件以扩展名.php保存。这里有一个简单的例子:

<?php
// code statements
?>

于是一句简单的你好，世界！用 PHP 编写的程序将是:

<?php
echo "Hello, World!";
?>

你好，世界！

echo是 PHP 中用来在屏幕上显示任何内容的命令。

如果我们想在一个 HTML 文档中包含这个 php 代码，我们可以这样做:

<!DOCTYPE>  
<html>  
    <body>  
    <?php  
        echo "<h1>Hello, World!</h1>";  
    ?>  
    </body>  
</html>

现在复制上面的代码，粘贴到你的代码编辑器或者 IDE 中，保存名为 hello_world.php 的文件

现在进入你安装 XAMPP 的 C 目录，打开 xampp → htdocs ，新建一个名为study night的文件夹，将你的 php 代码文件 hello_world.php 放入study night文件夹。

现在访问浏览器中的以下链接:本地主机/今晚学习/hello_world.php 您将看到 Hello，world！写在屏幕上。注意你好，世界！被写成一个标题，因为在 HTML 代码中我们指定了你好，世界！应打印为标题，将其放在标题标签<h1>内

How php script is executed by web server

PHP 语法规则

下面我们列出了编写 php 代码时必须遵循的主要语法规则。

  1. All the php code in a php script should be enclosed within <?php and ?>, else it will not be considered as php code. Adding php code inside the PHP tags is known as Escaping to php.

    <?php  ...   ?>

    除了标准的<?php和?>外，还可以使用短开标签:

    <?  ...   ?>

    或者使用 HTML <script> 标签，就像我们在 HTML 文档中添加 javascript 代码一样:

    <script language="PHP">  ...   </script>

  2. PHP 中的每个表达式都以分号结束

  3. Commenting PHP code: Both single line and multi-line comments are supported in PHP. For single line comment, we can either use # or // before the comment line. For example,

    <?php
    # This is also a single line comment
    # another line of comment

    // This is a single line comment
    echo "Example for Single line Comments";
?>

    而对于多行评论，我们用/* ... */。例如，

    <?php
    /*
        This is also a single line comment
        another line of comment
    */
    echo "Example for Multi-line Comments";
?>

  4. PHP is case sensitive, which means that a variable $tiger is not same as $Tiger. Both of these, represent two different variables here.

    但是所有预定义的关键字和函数如if、else、echo等都不区分大小写。

    <?php
    echo "Hello, World!";
    ECHO "Hello, World!";
?>

    你好，世界！你好，世界！

  5. PHP uses curly braces to define a code block.

    <?php
    if($zero == 0)
    {
        echo "If condition satisfied";
        echo "This is a code block";
    }
?>

    不用担心我们会详细了解 if...else 的情况，这只是为了演示花括号的用法。

PHP 中的变量

原文：https://www.studytonight.com/php/variables-in-php

当我们想在电脑/笔记本电脑上存储任何信息(数据)时，我们会将其存储在电脑的内存空间中。我们的操作系统没有记住存储数据的内存空间的复杂地址，而是为我们提供了一个创建文件夹、命名文件夹的选项，这样我们就更容易找到并访问它。

同样，在任何编程/脚本语言中，当我们想要在程序/脚本中使用一些数据值时，我们可以将其存储在内存空间中，并命名内存空间，以便更容易访问它。内存空间的名字叫做变量。

在 PHP 中，变量是用$符号声明的，后跟变量名。

语法:

<?php
    $variableName = value;
?>

创建变量

在下面的例子中，我们已经创建了不同类型的变量:

<?php
    $str = "I am a string";
    $int = 4;
    $float = 3.14;
    // You can name your variable anything
    $wow = "Wow!";
?>

在 PHP 中，您不必先声明变量，然后使用它，就像在 Java 、 C++ 等中一样，但是在 PHP 中，变量是在您为其赋值时创建的，就像 Python 一样。

此外，在 PHP 中，我们不必指定将存储在变量中的数据类型。您可以创建一个变量并在其中保存任何类型的数据。因此，PHP 是一种非常松散类型的语言。

在 PHP 中创建变量的规则

在这里，我们有几个基本规则，在 PHP 中创建变量时，您必须记住这些规则。所有的规则都用简单的例子来解释。

  1. 变量名总是以$符号开头，后面跟着变量名。

  2. 变量名不应以数值开头。它可以以字母或下划线符号_开头。

    <?php
    $var = "I am a variable";
    $_var = 5;
    // Invalid variable name
    $7var = "I am a variable too";
?>

  3. 变量名只能包含字母、数字和下划线符号_。

  4. Variable names in PHP are case-sensitive, which means $love is not same as $Love.

    <?php
    $car = "Jaguar E-Pace";
    echo "My favorite car is $car";
    // below statement will give error
    echo "I love $Car";
?>

    我最喜欢的车是捷豹 E-Pace 注意:未定义变量:汽车

PHP echo和print函数

原文：https://www.studytonight.com/php/php-echo-and-print

在本教程中，我们将学习 PHP 最重要的两种方法，它们不是 PHP 语言的内置函数，而是语言构造。

<?php
    echo "Hello, I am a language construct";
?>

你一定在想，什么是语言构造？一个语言构造按原样被 PHP 解析器接受/执行，换句话说，PHP 解析器不必解析和修改一个语言构造来执行它，因为默认情况下它已经准备好执行了。因此，语言构造比任何内置函数都要快。

PHP Echo

echo()功能用于打印或输出一个或多个字符串。我们在这里特别提到了string，因为echo函数的语法是:

echo(string)

虽然可以使用echo()函数输出任何东西，因为 PHP 解析器会自动将其转换为string类型。

echo不需要括号，虽然如果愿意可以用括号。

<?php
    echo "I am open";
    echo ("I am enclosed in parenthesis");
?>

我是开放的，我被括在括号里

时间为例

我们来看几个常用echo的用例。

打印基本句子

我们已经讨论过多次了，仍然:

<?php
    echo "I am a sentence";
?>

我是一个句子

使用逗号,打印多个字符串

以下是如何使用多个字符串作为echo的参数。

<?php
    echo 'This','is','a','broken','sentence';
?>

这是一个断句

打印多行文本(字符串)

<?php
    echo "This is a
     multiline sentence
     example";
?>

这是一个多行句子的例子

打印字符串变量

<?php
    $str = "I am a string variable";
    echo $str;
?>

我是一个字符串变量

打印包含一些文本的字符串变量

下面我们已经解释了当我们在echo中使用带有一些纯文本的string变量时，如何使用双引号和单引号导致不同的输出。

<?php
    $weird = "Stupid";
    echo "I am $weird";
    echo 'I am $weird';
?>

我很蠢，我很奇怪

如您所见，当我们使用双引号时，字符串变量的值会被打印出来，而如果我们使用单引号，变量会按原样打印出来。

转义特殊字符

如前例所示，echo需要一个双引号来确认要打印的内容。但是如果你也想打印双引号呢？在这种情况下，我们使用转义序列来转义特殊字符的特殊含义。在 PHP 中，反斜杠\用于转义特殊字符。

下面我们有一个简单的例子:

<?php
    echo "Hello, this is a \"beautiful\" picture";
?>

你好，这是一张“美丽”的照片

可以看到，输出中打印了双引号。

PHP 打印

PHP print和echo一模一样，语法相同，用法相同。在以上所有示例中，只需将echo替换为print，它们就会正常工作。

PHP 5 中的数据类型

原文：https://www.studytonight.com/php/datatypes-in-php

PHP 数据类型指定了 PHP 语言支持的不同数据类型。PHP 总共支持 8 种数据类型，分为 3 种主要类型。它们是:

  1. 标量类型 : boolean、integer、float和string。
  2. 化合物类型 : array和object。
  3. 特殊类型 : resource和NULL。

让我们逐一介绍 PHP 中所有不同类型的数据类型。

PHP 布尔值

一个布尔数据类型可以有两个可能的值，或者真或者假。

$a = true;
$b = false;

注:这里的值true和false没有括在引号内，因为它们不是字符串。

PHP 整数

整数数据类型用于存储 2，147，483，648 到 2，147，483，647 范围内的任何非十进制数值。

整数值可以是负数或正数，但不能有小数。

$x = -2671;
$y = 7007;

PHP 浮点

浮点数据类型用于存储任何十进制数值。

浮点值也可以是负值或正值。

$a = -2671.01;
$b = 7007.70;

PHP 字符串

PHP 中的字符串数据类型，通常是包含在引号中的一系列字符(或者任何字符，也可以是数字和特殊字符)。您可以使用单引号或双引号。

$str1 = "Hello";
$str2 = "What is your Roll No?";
$str3 = "4";

echo $str1;
echo "<br/>";
echo $str2;
echo "<br/>";
echo "Me: My Roll number is $str3";

你好，你的号码是多少？我:我的号码是 4

PHP NULL

空数据类型是一种特殊的数据类型，表示无。它只能有一个值，那就是NULL。

如果你创建了任何变量，但没有给它赋值，它会自动存储NULL。

同样，我们可以使用NULL值来清空任何变量。

// holds a null value
$a;
$b = 7007.70;
// we can also assign null value
$b = null;

数组、对象和资源数据类型

我们将在后面研究这些数据类型，因为它们是高级数据类型，需要更好地理解 PHP 基础知识。

PHP 常量

原文：https://www.studytonight.com/php/php-constants

常量是变量，其值不能改变。换句话说，一旦为常数设置了值，就不能更改它。

在 PHP 中，有两种方法来定义常数:

  1. 使用define()方法。
  2. 使用const关键字。

另一个需要记住的非常重要的一点是，在给一个常数命名时，我们不必用 $符号来命名这个常数。

使用define()

下面是使用define()函数创建常数的语法。

define(name, value, case-insensitive)

参数:

  1. name:常量的名称
  2. value:常量的值
  3. case-insensitive:指定常量名称是否区分大小写。它的默认值是false，这意味着默认情况下，常量名称区分大小写。

举个例子

下面我们有一个简单的例子，其中我们没有提到参数不区分大小写，因此它将自动采用默认值。

<?php
    define(OMG, "Oh! my God.");
    echo OMG;
?>

哦！我的上帝。

对于上面的常量定义，如果我们尝试使用下面的语句，我们会得到一个错误，因为常量OMG是区分大小写的。

<?php
    define(OMG, "Oh! my God.");
    echo omg;
?>

天啊

echo会将其视为一个字符串，并按原样打印出来，其中有一个微妙的 NOTICE 表示字符串变量没有定义。

现在让我们看另一个例子，我们将指定不区分大小写的参数。

<?php
    define(OMG, "Oh! my God.", true);
    echo omg;
?>

哦！我的上帝。

使用const关键字

我们也可以使用const关键字在 PHP 中定义常量。但是我们只能使用const关键字来定义标量常量，即只能定义整数、浮点数、布尔值和字符串，而define()也可以用来定义数组和资源常量，尽管它们并不经常使用。

举个例子

<?php
    const OMG = "Oh! my God.";  
    echo OMG;
?>

哦！我的上帝。

当我们使用const关键字定义常数时，常数名称总是区分大小写的。

PHP 运算符

原文：https://www.studytonight.com/php/php-operators

运算符用于对 PHP 变量和简单值进行运算。

在 PHP 中，总共有 7 种类型的运算符，它们是:

  1. 算术运算符
  2. 赋值运算符
  3. 比较运算符
  4. 递增/递减运算符
  5. 逻辑运算符
  6. 字符串运算符
  7. 数组运算符

还有一些额外的操作符，如类型操作符、位操作符、执行操作符等。

根据这些操作符的使用方式，它们分为三类:

  1. 一元运算符:处理单个操作数(变量或值)。
  2. 二进制运算符:处理两个操作数(变量或值)。
  3. 三元运算符:对三个操作数起作用。

PHP 算术运算符

这些运算符用于执行基本的算术运算，如加法、乘法、除法等。

| 名字 | 操作员 | 它是做什么的？ | 例子 |
| 添加 | + | 用于执行正常加法。 | $a + $b |
| 减法 | - | 它用于执行正常减法。 | $a - $b |
| 增加 | * | 它用于执行乘法。 | $a * $b |
| 分开 | / | 它用于执行除法。 | $a / \(b | | 指数 | `**` | 它返回第一个操作数与第二个操作数的幂。`\)a ** $b = \(a<sup>\)b| $a ** $b | | 模数(或余数) |%` | 它返回第一个操作数除以第二个操作数的余数 | $a % $b |

PHP 赋值运算符

赋值操作符用于给变量赋值，可以是按原样赋值，也可以是在对变量执行某种算术运算之后赋值。最基本的赋值运算符是等于 =。

| 操作员 | 使用 |
| = | $a = $b，将变量$b的值保存到变量$a |
| +- | $a += $b同$a + $b |
| -= | $a -= $b同$a - $b |
| *= | $a *= $b同$a * $b |
| /= | $a /= $b同$a / $b |
| %= | $a %= $b同$a % $b |

所以基本上，赋值运算符为我们提供了执行算术运算的速记技术。

PHP 比较运算符

顾名思义，这些用于比较两个值。

| 名字 | 操作员 | 它是做什么的？ | 例子 |
| 平等的 | == | 如果左操作数等于右操作数，则返回true。 | $a == $b |
| 同一的 | === | 如果左操作数等于右操作数，并且它们属于同一类型，则返回true。 | $a === $b |
| 不平等 | != | 如果左操作数不等于右操作数，则返回true。 | 一美元！= $b |
| 不相同 | !== | 如果左操作数不等于右操作数，并且它们的类型不同，则返回true。 | 一美元！== $b |
| 大于 | > | 如果左操作数大于右操作数，则返回true。 | $a > $b |
| 不到 | < | 如果左操作数小于右操作数，则返回true。 | $a < $b |
| 大于或等于 | >= | 如果左操作数大于或等于右操作数，则返回true。 | $a >= $b |
| 小于或等于 | <= | 如果左操作数小于或等于右操作数，则返回true。 | $a <= $b |

PHP 递增/递减运算符

这些运算符是一元运算符，即它们只需要一个操作数。

| 操作员 | 使用 |
| ++$a | 预增量，首先将操作数增加1(加一)，然后使用或返回。 |
| $a++ | 后置递增，首先返回操作数，然后将操作数递增1。 |
| --$b | 预减，首先将操作数减1(减一)，然后使用或返回。 |
| $b-- | 后递减，首先返回操作数，然后将操作数递减1。 |

当使用循环或者当我们在程序/脚本中简单地将任何值递增 1 时，这些操作符非常有用和方便。

逻辑运算符

当任何操作依赖于两个或多个条件时，通常使用逻辑运算符。

| 名字 | 操作员 | 它是做什么的？ | 例子 |
| 和 | and或&& | 如果两个操作数(或表达式)都返回真，则返回真。 | $ a & $ b |
| 或者 | or或&#124;&#124; | 如果两个操作数(或表达式)中的任何一个返回真，或者两个都返回真，则返回真。 | $a || $b |
| Xor | xor | 如果两个操作数(或表达式)中的任何一个返回真，则返回真，但当两个都返回真时，则不返回真。 | $a xor $b |
| 不 | ! | 这是一个一元运算符。如果操作数(或表达式)返回 false，则返回 true。 | ！一美元 |

字符串运算符

串操作符用于对串进行操作。字符串操作符只有两种，一般是用 PHP 内置函数对字符串进行各种操作，我们会在后面的教程中了解到。

| 名字 | 操作员 | 它是做什么的？ | 例子 |
| 串联 | .(一个点) | 它用于连接两个字符串。 | \(a.\)b |
| 串联赋值 | .= | 它用于将一个字符串附加到另一个字符串。 | $a .= $b |

这里我们有一个简单的例子来演示这两个字符串操作符的用法。

<?php
    $a = "study";
    $b = "tonight";
    // concatenating $a and $b
    echo $a.$b;

    // appending $b to $a
    $a .= $b
    echo $a;
?>

今晚学习今晚学习

PHP 数组运算符

这些运算符用于比较数组。

| 名字 | 操作员 | 它是做什么的？ | 例子 |
| 平等的 | == | 如果两个数组具有相同的键/值对，则返回true。 | $a == $b |
| 同一的 | === | 如果两个数组具有相同的键/值对，顺序相同，类型相同，则返回true。 | $a === $b |
| 不平等 | != | 如果两个数组不相同，则返回true。 | 一美元！= $b |
| 不相同 | !== | 如果两个数组不相同，则根据值类型等返回true。 | 一美元！== $b |
| 工会(加入) | + | 它将数组连接在一起 | $a + $b |

PHP if，else和else if条件语句

原文：https://www.studytonight.com/php/php-if-else-elseif

在编写程序/脚本时，会有这样的场景:如果满足某个条件，您只想执行特定的语句。在这种情况下，我们使用条件语句。

在 PHP 中，有 4 种不同类型的条件语句。

  1. if陈述
  2. if...else陈述
  3. if...elseif...else陈述
  4. switch 语句

我们将在下一个教程中介绍switch语句。

if声明

当我们想要在条件为真时执行一些代码时，我们使用if语句。

语法:

if(condition)
{
    // code to be executed if 'condition' is true
}

这里有一个简单的例子，

<?php

$age = 20;

if($age <= 25)
{
    echo "You are not allowed to consume alchohol";
}
?>

if...else声明

当我们想要在条件为真时执行一些代码，当条件为假时执行一些其他代码时，我们使用if...else对。

语法:

if(condition)
{
    // code to be executed if 'condition' is true
}
else 
{
    // code to be executed if 'condition' is false
}

这里有一个简单的例子，

<?php

$age = 26;

if($age <= 25)
{
    echo "You are not allowed to consume alchohol";
}
else 
{
    echo "Enjoy the drinks";
}
?>

享受饮料

if...else...elseif声明

当我们想要对不同的条件集执行不同的代码，并且我们有 2 个以上的可能条件时，那么我们使用if...elseif...else对。

语法:

if(condition1)
{
    // code to be executed if 'condition1' is true
}
elseif(condition2)
{
    // code to be executed if 'condition2' is true
}
else
{
    /* code to be executed if both 'condition1'
     and 'condition2' are false */
}

这里有一个简单的例子，

<?php
// speed in kmph
$speed = 110;

if($speed < 60)
{
    echo "Safe driving speed";
}
elseif($speed > 60 && $speed < 100)
{
    echo "You are burning extra fuel";
}
else 
{
    // when speed is greater than 100
    echo "Its dangerous";
}
?>

这很危险

在上面的例子中，我们也使用了逻辑运算符&&。将多个条件写在一起时，逻辑运算符非常有用。

PHP switch语句

原文：https://www.studytonight.com/php/php-switch-statement

你一定使用过电梯，电梯是用来在建筑物上上下下的，你所要做的就是按下带有你想去的楼层号的按钮，或者使用电视遥控器，你可以通过选择电视遥控器上的频道号来改变电视上的频道。

switch声明

一个switch语句用于根据不同的条件执行不同的动作。

使用switch语句，我们可以指定多个条件以及当该条件为真时要执行的代码，从而实现菜单风格的程序。

语法:

switch(X)
{
    case value1:
        // execute this code when X=value1
        break;
    case value2:
        // execute this code when X=value2
        break;
    case value3:
        // execute this code when X=value3
        break;
    ...
    default:
        /* execute this when X matches none of
           of the specified options */
}

您可以使用单个switch代码块指定任意多个选项。

X可以是变量，也可以是表达式。

在switch语句中，我们为 switch 语句提供了一个可以是变量或表达式的决定因素，然后我们指定了不同的情况，每个情况都有一个值，一段代码和一个 break 语句。

break语句被指定为一旦执行了与指定值相关的操作，就中断 switch 语句的执行。

如果我们没有指定一个break语句，那么所有的开关情况，在匹配的情况之后，将被执行，直到下一个break语句。

如果没有匹配的案例，则执行默认的语句。

<?php
$car = "Jaguar";

switch($car)
{
    case "Audi":
        echo "Audi is amazing";
        break;
    case "Mercedes":
        echo "Mercedes is mindblowing";
        break;
    case "Jaguar":
        echo "Jaguar is the best";
        break;
    default:
        echo "$car is Ok";
}
?>

捷豹是最好的

PHP while和do-...while循环

原文：https://www.studytonight.com/php/php-while-and-dowhile-loop

顾名思义，一个循环用来一遍又一遍地执行某件事情。

例如，如果您想显示从 1 到 1000 的所有数字，而不是使用echo语句 1000 次，或者在一个带有换行符\n的echo语句中指定所有数字，我们可以只使用一个循环，它将运行 1000 次，每次都会显示一个数字，从 1 开始，在每次迭代或循环后递增该数字。

在循环中，我们通常会指定一个条件或一个极限，直到循环执行为止，因为如果我们不指定这样的条件，我们将如何指定循环应该何时结束，而不是无限长的时间。

How loops work in pogramming languages

PHP while循环

PHP 中的while循环有两个组成部分，一个是条件，另一个是要执行的代码。它执行给定的代码，直到指定的条件为真。

语法:

<?php
while(condition)
{
    /* 
        execute this code till the  
        condition is true
    */
}
?>

例如，让我们以本教程开头提到的问题为例。让我们打印从 1 到 10 的数字。

<?php

$a = 1;

while($a <= 10)
{
    echo "$a | ";
    $a++;   // incrementing value of a by 1
}
?>

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |

注:我们增加了一个符号|只是为了分隔数字，它在上面的代码中没有功能用途。

PHP do...while循环

do...while循环和 PHP 中所有的循环都有点不一样，因为它至少会执行一次，即使条件是假的，你能猜到怎么执行吗？因为条件是在循环执行后检查的，所以第一次检查条件时，循环已经执行了一次。

语法:

<?php
do {
    /* 
        execute this code till the  
        condition is true
    */
} while(condition)
?>

让我们使用do...while循环实现上面的例子，

<?php

$a = 1;

do {
    echo "$a | ";
    $a++;   // incrementing value of a by 1
} while($a <= 10)
?>

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |

我们再举一个例子，即使条件是假，循环还是会执行一次。

<?php

$a = 11;

do {
    echo $a;
    $a++;   // incrementing value of a by 1
} while($a <= 10)
?>

Eleven

我们可以清楚地看到，上述do...while循环中的条件将返回假，因为变量$a的值为 11 ，根据该条件，只有当$a的值小于或等于 10 时，循环才应执行。

PHP for和foreach循环

原文：https://www.studytonight.com/php/php-for-and-foreach-loop

在本教程中，我们将学习for和foreach循环，它们也用于在 PHP 中实现循环。

为了理解什么是循环以及它们是如何工作的，我们建议您阅读。

PHP for循环

PHP 中的for循环不像while或do...while循环那样工作，在for循环的情况下，我们必须事先声明我们希望循环运行多少次。

语法:

<?php
for(initialization; condition; increment/decrement)
{
    /* 
        execute this code till the  
        condition is true
    */
}
?>

使用的参数具有以下含义:

  1. 初始化:这里我们用某个值初始化一个变量。这个变量充当循环计数器。
  2. 条件:这里我们定义了循环每次迭代/循环后检查的条件。如果条件返回真，则只执行循环。
  3. 递增/递减:这里我们根据需要递增或递减循环计数器。

How for loop works in Php

举个例子

同样，让我们尝试打印从 1 到 10 的数字，这次我们将使用for循环。

<?php

for($a = 1; $a <= 10; $a++)
{
    echo "$a <br/>";
}
?>

1 2 3 4 5 6 7 8 9 10

嵌套for循环

我们也可以在另一个for循环中使用一个for循环。这里有一个嵌套for循环的简单例子。

<?php

for($a = 0; $a <= 2; $a++)
{
    for($b = 0; $b <= 2; $b++)
    {
        echo "$b $a 
";
    }
}

?>

0 0 1 0 2 0 0 1 1 1 2 1 0 2 1 2 2 2

PHP foreach循环

PHP 中的foreach循环用于访问一个数组的键值对。这个循环只对数组起作用，你不需要初始化任何循环计数器或者设置任何退出循环的条件，一切都是由循环隐式(内部)完成的。

语法:

<?php
foreach($array as $var)
{
    /* 
        execute this code for all the
        array elements

        $var will represent all the array
        elements starting from first element, 
        one by one
    */
}
?>

这里有一个简单的例子。

<?php

$array = array("Jaguar", "Audi", "Mercedes", "BMW");

foreach($array as $var)
{
    echo "$var <br/>";
}

?>

捷豹奥迪奔驰宝马

我们将在接下来的教程中详细了解数组。

PHP break语句

原文：https://www.studytonight.com/php/php-break

我们已经在开关switch 条件语句中看到并使用了break语句。

回想一下，在switch代码块中，当有效的案例块被执行时，我们使用break语句来脱离switch块。

让我们看一个简单switch代码的例子:

<?php

$a = 1;

switch($a)
{
    case 1:
        echo "This is case 1";
        break;
    case 2:
        echo "This is case 2";
        break;
    default:
        echo "This is default case";
}

?>

这是案例 1

但是如果我们忘记在switch语句中的每个案例块的末尾添加break语句呢？在这种情况下，执行仍将从匹配的情况开始，但不会退出switch语句，并将继续执行其下的每个代码语句，直到下一个break语句。

<?php

$a = 2;

switch($a)
{
    case 1:
        echo "This is case 1";
    case 2:
        echo "This is case 2";
    default:
        echo "This is default case";
}

?>

这是案例 2 这是默认案例

在循环中使用break

在循环中，break语句对于想要退出循环(停止循环)的情况非常有用，如果满足某些条件的话。

让我们举一个简单的 for循环的例子来理解我们如何在循环中使用break语句。

在下面的例子中，我们想找到第一个能被 13 整除的数，它在 1762 和 1800 之间，从 1762 开始。

<?php

$x = 13;

for($i = 1762; $i < 1800; $i++)
{
    if($i % $x == 0) 
    {
        echo "The number is $i";
        break;
    }
}

?>

号码是 1768

在上面的脚本中，我们从 1762 年开始我们的for循环，一直运行到 1800 年。在每次迭代/循环中，我们检查递增的数是否能被 13 整除。当我们找到第一个余数为 0 的数字时，我们使用break语句退出循环。

break语句的用法对于所有不同类型的循环都是一样的。

进阶

PHP 函数

原文：https://www.studytonight.com/php/php-user-defined-functions

一个函数只不过是一个“语句块”，它通常执行一个特定的任务，并且可以在我们的程序中重复使用。这个“语句块”也被赋予了一个的名字，所以无论何时我们想在我们的程序/脚本中使用它，我们都可以用它的名字来称呼它。

在 PHP 中，有成千上万个内置函数，我们可以直接在程序/脚本中使用。

PHP 还支持用户自定义函数，我们可以在这里定义自己的函数。

函数在被定义时不执行，在被调用时执行。

用户定义函数

让我们理解如何在程序中定义自己的函数并使用这些函数。

语法:

<?php

function function_name()
{
    // function code statements
}

?>

命名函数的几个规则

  1. 一个函数名只能包含字母、数字和下划线。不允许使用其他特殊字符。
  2. 名称应该以字母或下划线开头。它不应该以数字开头。
  3. 最后但同样重要的是，函数名不区分大小写。
  4. 函数名后的左花括号{标志着函数代码的开始，右花括号}标志着函数代码的结束。

举个例子

让我们写一个非常简单的函数，它将显示一个简单的“圣诞快乐和新年快乐”的信息。这个脚本实际上非常有用，当你必须给你的每个朋友发送节日邮件，并且你必须在所有的邮件中写同样的信息。

<?php
// defining the function
function greetings()
{
    echo "Merry Christmas and a Very Happy New Year";
}

echo "Hey Martha <br/>";
// calling the function
greetings();

// next line
echo "<br/>";

echo "Hey Jon <br/>";
// calling the function again
greetings();

?>

嗨，玛莎，圣诞快乐，新年快乐嗨，乔恩，圣诞快乐，新年快乐

用户定义函数的优势

由于我们已经看到了上面使用函数的一个简单例子，您一定已经理解了它对于大型程序来说是多么节省时间。以下是为您使用函数的一些优点:

  1. 可重用代码:从上面的例子可以清楚的看到，一个函数你写一次就可以在程序中使用一千次。
  2. 少代码重复:在上面的例子中，我们在函数中只有一行代码，但是如果我们有 10 行代码呢。因此，我们可以为它们创建一个函数，并简单地调用该函数，而不是一遍又一遍地重复所有这些代码行。
  3. 易懂:在你的程序中使用函数，让代码更易读易懂。

PHP 函数参数

我们甚至可以将数据传递给一个函数，这个函数可以在函数块中使用。这是使用参数完成的。一个参数只不过是一个变量。

参数在函数名后面的括号中指定，用逗号分隔。当我们定义一个函数时，我们必须定义它将接受的参数数量，并且在调用该函数时只能传递这么多参数。

语法:

<?php
/* 
    we can have as many arguments as we
    want to have in a function
*/
function function_name(argument1, argument2)
{
    // function code statements
}

?>

让我们举一个简单的例子:

<?php
// defining the function with argument
function greetings($festival)
{
    echo "Wish you a very Happy $festival";
}

echo "Hey Jai <br/>";
// calling the function
greetings("Diwali");

// next line
echo "<br/>";

echo "Hey Jon <br/>";
// calling the function again
greetings("New Year");

?>

嘿杰祝你排灯节快乐嘿乔恩祝你新年快乐

从上面的例子中可以看到，我们是如何改变我们的greetings()函数开始接受参数的，现在它可以用于发送不同节日的问候。

PHP 默认函数参数

有时函数参数在函数代码执行中起着重要的作用。在这种情况下，如果用户在调用函数时忘记提供参数，可能会导致一些错误。

为了避免这样的错误，我们可以为参数提供一个默认值，当调用函数时没有为参数提供任何值时，就使用这个默认值。

举个例子吧。

<?php

// defining the function with default argument
function greetings($festival = "Life")
{
    echo "Wish you a very Happy $festival";
}

echo "Hey Jai <br/>";
// calling the function with an argument
greetings("Diwali");

// next line
echo "<br/>";

echo "Hey Jon <br/>";
// and without an argument
greetings();

?>

嘿杰祝你排灯节快乐嘿乔恩祝你生活愉快

因此，当您在调用函数时忘记提供参数时，为了掩饰，您可以为函数的参数设置默认值。

返回值的函数

是的，函数甚至可以返回结果。当我们有函数被定义来执行一些数学运算时，我们想要输出运算的结果，所以我们返回结果。

return语句用于从 PHP 中的函数返回任何变量或值。

我们来看一个例子。

<?php

function add($a, $b)
{
    $sum = $a + $b;
    // returning the result
    return $sum;
}

echo "5 + 10 = " . add(5, 10) . "
";

?>

5 + 10 = 15

函数重载

函数重载允许您拥有一个函数的多个不同变体，根据它们所采用的参数的数量和类型来区分。

例如，我们定义了函数add()，它接受两个参数，并返回这两个参数的和。如果我们希望为添加 3 个数字提供支持，该怎么办？

为了解决这种情况，我们可以做的是，我们可以定义函数add()的两个不同变体，一个接受 2 个参数，另一个接受 3 个参数。这叫做功能过载。

让我们举个例子，

<?php
// add function with 2 arguments
function add($a, $b)
{
    $sum = $a + $b;
    // returning the result
    return $sum;
}

// overloaded add function with 3 arguments
function add($a, $b, $c) 
{
    $sum = $a + $b + $c;
    // returning the result
    return $sum;
}

// calling add with 2 arguments
echo "5 + 10 = " . add(5, 10) . "<br/>";

// calling add with 3 arguments
echo "5 + 10 + 15 = " .add(5, 10, 15) . "<br/>";

?>

5 + 10 = 15 5 + 10 + 15 = 30

遗憾的是，PHP 不支持函数重载。

这只是为了让你了解什么是函数重载。在 PHP 中，函数签名只基于它们的名称，不包括参数列表，因此我们不能有两个同名的函数。

PHP 数组

原文：https://www.studytonight.com/php/php-arrays

一个数组用于在一个变量中存储多个值，通常是相同类型的。

例如，如果您有一个想要存储在一起的节日列表，或者可能是一个固定项目列表，或者是一个颜色列表，那么您可以将它们保存在单独的变量中，但是您将不得不创建许多变量，并且它们不会相互关联。

在这种情况下，使用 PHP 数组。数组可以将多个值一起存储在一个变量中，我们可以使用 foreach循环遍历数组中存储的所有值。

创建数组

我们可以使用array()函数在 PHP 中创建一个数组。

语法:

<?php
/* 
    this function takes multiple values
    separated by comma as input to create
    an aray
*/
array();

?>

在 PHP 中有 3 种类型的数组:

  1. 索引数组:这些是带数值索引的数组。
  2. 关联数组:这些是以命名键为索引的数组，键可以是数字或文本。
  3. 多维数组:这些是包含一个或多个数组的数组。

举个例子

让我们举一个简单的数组例子来帮助您理解数组是如何创建的。

<?php
/* 
    a simple array with car names
*/
$lamborghinis = array("Urus", "Huracan", "Aventador");

?>

要访问存储在数组中的数据，我们可以使用索引号，也可以使用foreach循环遍历数组元素。

数组元素的索引号从0开始，即第一个元素在0位置，第二个元素在1位置，以此类推...

<?php
/* 
    a simple array with Lamborghini car names
*/
$lamborghinis = array("Urus", "Huracan", "Aventador");
// print the first car name
echo $lamborghinis[0];
echo "Urus is the latest Super SUV by Lamborghini";

?>

Urus Urus 是兰博基尼最新的超级 SUV

阵列的优势

以下是在我们的程序/脚本中使用数组的一些优点:

  1. 定义相关数据的简单列表非常容易，而不是创建多个变量。
  2. 使用foreach循环使用和遍历非常简单。
  3. PHP 提供了对数组进行排序的内置函数，因此它也可以用于对信息进行排序。

PHP 索引数组

原文：https://www.studytonight.com/php/indexed-array

一个索引数组是一个简单数组，其中数据元素是根据数字索引存储的。所有数组元素都由一个索引表示，该索引是从第一个数组元素的0开始的数值。

创建索引数组

在 PHP 中创建索引数组有两种不同的方法，它们是:

创建索引数组的第一种方法的语法:

<?php
/* 
    1st - direct array initialization
*/
$lamborghinis = array("Urus", "Huracan", "Aventador");

?>

第二种创建索引数组的方式的语法是:

<?php
/* 
    2nd - distributed array initialization
*/
$suzuki[0] = "Swift";
$suzuki[1] = "Baleno";
$suzuki[2] = "Ertiga";
$suzuki[3] = "Brezza";
$suzuki[4] = "Vitara";

?>

无论我们如何初始化数组，我们都可以按如下方式访问数组，

<?php
/* 
    Accessing array
*/
echo "Accessing the 2nd array...";
echo $suzuki[0], "\n";
echo $suzuki[3], "\n";
echo $suzuki[2], "\n";

echo "Accessing the 1st array...";
echo $lamborghinis[1], "\n";
echo $lamborghinis[0], "\n";
echo $lamborghinis[2], "\n";

?>

访问第二个阵列...Swift Brezza Ertiga 访问第一个阵列...Huracan Urus Aventador

因此，要访问索引数组，我们必须使用数组名以及方括号中元素的索引。

遍历 PHP 索引数组

遍历数组意味着从数组的第一个索引开始迭代，直到最后一个元素。

我们可以使用for循环或foreach遍历索引数组。要了解for和foreach循环的语法和基本用法，可以参考 PHP for 和 foreach 循环教程。

使用for循环

使用for循环遍历索引数组时，我们必须知道数组的大小/长度，这可以使用count()函数找到。

以下是使用for循环遍历数组的语法。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");
// find size of the array
$size = count($lamborghinis);

// using the for loop
for($i = 0; $i < $size; $i++)
{
    echo $lamborghinis[$i], "\n";
}

?>

使用foreach循环

如果必须遍历整个数组，使用foreach遍历索引数组是一种更好的方法，因为我们不必费心计算数组的大小来循环数组。

下面我们用foreach遍历$lamborghinis数组。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// using the foreach loop
foreach($lamborghinis as $lambo)
{
    echo $lambo. "\n";
}

?>

索引数组的优点

以下是在我们的程序/脚本中使用索引数组的一些优点:

  1. 数字索引值使它更容易使用，并且几乎所有编程语言都有数字索引，因此它也使代码对于阅读您的代码的其他人来说更易读。

PHP 关联数组

原文：https://www.studytonight.com/php/associative-arrays

关联数组类似于索引数组，但不是用数字索引顺序存储数据，而是可以用用户设计的string类型的键分配每个值。

创建关联数组

就像索引数组一样，在 PHP 中有两种不同的方法来创建关联数组，

语法第一种创建关联数组的方法:

<?php
/* 
    1st - direct array initialization
*/
$lamborghinis = array("suv"=>"Urus", "sports"=>"Huracan", "coupe"=>"Aventador");

?>

第二种创建关联数组的方式的语法是:

<?php
/* 
    2nd - distributed array initialization
*/
$suzuki["hatch"] = "Swift";
$suzuki["utility"] = "Ertiga";
$suzuki["suv"] = "Vitara";

?>

无论我们如何初始化数组，我们都可以按如下方式访问数组，

<?php
/* 
    Accessing array
*/
echo "Accessing the 2nd array...";
echo $suzuki["hatch"], "\n";
echo $suzuki["utility"], "\n";
echo $suzuki["suv"], "\n";

echo "Accessing the 1st array...";
echo $lamborghinis["suv"], "\n";
echo $lamborghinis["sports"], "\n";
echo $lamborghinis["coupe"], "\n";

?>

访问第二个阵列...Swift Ertiga Vitara 访问第一个阵列...Urus Huracan Aventador

因此，要访问关联数组，我们必须使用数组名和方括号中元素的索引，唯一的区别是索引将是一个字符串，而不是像索引数组那样的数值。

遍历 PHP 关联数组

遍历数组意味着从数组的第一个索引开始迭代，直到最后一个元素。

我们可以使用for循环或foreach遍历关联数组。要了解for和foreach循环的语法和基本用法，可以参考 PHP for 和 foreach 循环教程。

使用for循环

使用for循环遍历关联数组时，我们必须知道数组的大小/长度，这可以使用count()函数找到。

此外，由于关联数组中的索引不是数字，也不是顺序的，因此要查找索引值或键(因为保存在关联数组中的数据是键值形式)，我们可以使用函数array_keys()来获取关联数组中使用的键的数组。

以下是使用for循环遍历数组的语法。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// find size of the array
$size = count($lamborghinis);

// getting the array of keys/index strings
$keys = array_keys($lamborghinis);

// using the for loop
for($i = 0; $i < $size; $i++)
{
    echo $lamborghinis[$keys[$i]] ." is a/an ". $keys[$i] ." car \n";
}

?>

Urus 是一辆 suv 汽车 Huracan 是一辆跑车 Aventador 是一辆轿跑车

使用foreach循环

如果必须遍历整个数组，使用foreach遍历关联数组是一种更好的方法，因为我们不必费心计算数组的大小来循环数组。

下面我们用foreach遍历$lamborghinis数组。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// using the foreach loop
foreach($lamborghinis as $key => $value)
{
    echo $value ."is a/an ". $key ." car \n";
}

?>

Urus 是一辆 suv 汽车 Huracan 是一辆跑车 Aventador 是一辆轿跑车

不要被语法as $key=>$value所迷惑，这意味着在foreach的每次迭代中，我们都将数组表示为键值对。

关联数组的优点

以下是在我们的程序/脚本中使用关联数组的一些优点:

  1. 我们可以为数组元素提供更有意义的键值或索引值。
  2. 我们可以保存更多的数据，因为我们可以有一个字符串作为数组元素的键，我们可以将数据与要存储的值相关联，就像在我们的示例中，我们将汽车的类型存储为键，将汽车的名称存储为值。因此在一个数组元素中存储两种不同的信息。

PHP 多维数组

原文：https://www.studytonight.com/php/multidimensional-arrays

多维数组是在每个索引处存储另一个数组而不是存储单个值的数组。简单来说，多维数组就是数组的数组。

通常情况下，关联数组存储在多维数组中。

创建多维数组

正如我们已经看到的，如何创建一个关联数组，多维数组是数组的数组，将在其中保存关联数组。

创建多维数组的语法:

<?php
/* 
    multidimensional array initialization
*/
$cars = array(
    array(
        "name"=>"Urus", 
        "type"=>"SUV", 
        "brand"=>"Lamborghini"
    ),
    array(
        "name"=>"Cayenne", 
        "type"=>"SUV", 
        "brand"=>"Porsche"
    ),
    array(
        "name"=>"Bentayga", 
        "type"=>"SUV", 
        "brand"=>"Bentley"
    ),
);
?>

由于我们在这里处理数组内部的数组，因此要访问任何信息，我们首先需要到达该数组，然后从存储在多维数组中的特定数组中获取数据。

例如，如果我们想要显示 Urus 汽车的数据，那么，首先我们必须获得我们的多维数组中的第一个数组，可以使用索引 0 访问该数组，然后在该数组中，我们可以显示所有数据，就像我们在关联数组中所做的那样。

<?php
/* 
    Accessing multidimensional array
*/
echo "Accessing multidimensional array...";
echo "Urus is an ".$cars[0]["type"]." manufactured by ".$cars[0]["brand"]."\n";
echo "Bentayga is an ".$cars[2]["type"]." manufactured by ".$cars[2]["brand"]."\n";

?>

访问多维数组...Urus 是一款由兰博基尼制造的 SUV，Bentayga 是一款由宾利制造的 SUV

遍历 PHP 多维数组

遍历数组意味着从数组的第一个索引开始迭代，直到最后一个元素。

我们可以使用两个for循环或两个foreach循环或一个for循环和一个foreach循环遍历多维数组。要了解for和foreach循环的语法和基本用法，可以参考 PHP for 和 foreach 循环教程。

使用一个for循环和一个foreach

在多维数组的情况下，我们必须遍历主数组，然后遍历存储在主数组中的数组，因此我们需要两个循环。

当使用for循环遍历多维数组时，我们必须知道数组的大小/长度，这可以使用count()函数找到。

让我们以上面定义的数组作为遍历多维数组的第一个例子。

<?php
/* 
    multidimensional array initialization
*/
$cars = array(
    array(
        "name"=>"Urus", 
        "type"=>"SUV", 
        "brand"=>"Lamborghini"
    ),
    array(
        "name"=>"Cayenne", 
        "type"=>"SUV", 
        "brand"=>"Porsche"
    ),
    array(
        "name"=>"Bentayga", 
        "type"=>"SUV", 
        "brand"=>"Bentley"
    ),
);

// array traversal
// find size of the array
$size = count($lamborghinis);

// using the for loop
for($i = 0; $i < $size; $i++)
{
    foreach($cars[$i] as $key => $value) {
        echo $key . " : " . $value . "\n";
    }
    echo "\n";
}

?>

名称:Urus 类型:SUV 品牌:兰博基尼名称:卡宴类型:SUV 品牌:Prosche 名称:Bentayga 类型:SUV 品牌:宾利

在上面的多维数组中，我们将主数组作为索引数组，并且存储为元素的数组是关联的。

但是主数组也可以是关联的，让我们举个例子。

此外，由于关联数组中的索引不是数字，也不是顺序的，因此要查找索引值或键(因为保存在关联数组中的数据是键值形式)，我们可以使用函数array_keys()来获取关联数组中使用的键的数组。

<?php
/* 
    multidimensional array initialization
*/
$cars = array(
    "Urus" => array(
            "type"=>"SUV", 
            "brand"=>"Lamborghini"
        ),
    "Cayenne" => array(
            "type"=>"SUV", 
            "brand"=>"Porsche"
        ),
    "Bentayga" => array(
            "type"=>"SUV", 
            "brand"=>"Bentley"
        ),
);

/* 
    array traversal
*/
// find size of the array
$size = count($lamborghinis);

// array keys
$keys = arra_keys($cars);

// using the for loop
for($i = 0; $i < $size; $i++)
{
    echo $keys[$i]. "\n";
    foreach($cars[$keys[$i]] as $key => $value) {
        echo $key . " : " . $value . "\n";
    }
    echo "\n";
}

?>

Urus 类型:SUV 品牌:兰博基尼卡宴类型:SUV 品牌:Prosche Bentayga 类型:SUV 品牌:宾利

多维数组的优势

以下是在我们的程序/脚本中使用多维数组的一些优点:

  1. 详细信息可以存储在多维数组中。
  2. 最重要的是，它可以保持索引或关联，这使得它更加用户友好，因为他们可以根据自己的需求使用它。

PHP 数组函数

原文：https://www.studytonight.com/php/php-array-functions

我们已经介绍了数组、索引数组、关联数组和多维数组的基础知识。现在让我们深入研究数组，了解 PHP 中用于数组处理的内置函数。

一般来说，使用正确的数组函数会节省你很多时间，因为它们是在 PHP 库中预定义的，你所要做的就是调用它们来使用它们。

常用的 PHP5 数组函数

下面我们列出了 PHP 中一些常用的数组函数:

sizeof($arr)

此函数返回数组的大小或数组中存储的数据元素的数量。

它就像count($arr)方法一样，我们在前面的教程中遍历数组时使用的。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");
echo "Size of the array is: ". sizeof($lamborghinis);

?>

数组的大小为:3

is_array($arr)

要检查提供的数据是否为数组形式，我们可以使用is_array()函数。如果变量是数组，则返回True，否则返回False。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// using ternary operator
echo is_array($lamborghinis) ? 'Array' : 'not an Array';

$mycar = "Urus";

// using ternary operator
echo is_array($mycar) ? 'Array' : 'not an Array';

?>

数组不是数组

in_array($var, $arr)

使用数组时，我们可能经常想要检查数组中是否存在某个值。例如，如果获得某辆车的列表，就像我们在几乎所有示例中所做的那样，要检查某辆车是否被添加到数组中，我们可以使用in_array功能。

让我们举个例子看看，

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// new concept car by lamborghini
$concept = "estoque";

echo in_array($concept, $lamborghinis) ? 'Added to the Lineup' : 'Not yet!'

?>

还没有！

我们可以看到，与上面的其他函数不同，这个函数采用两个参数，一个是数组中要搜索的值，第二个是数组本身。

虽然这不是一个数组函数，但这里值得特别一提，因为我们可以使用这个函数以最具描述性的方式打印数组。该函数打印数组的完整表示，以及所有键和值。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");
print_r($lamborghinis);

?>

S7-1200 可编程控制器

array_merge($arr1, $arr2)

如果您想将两个不同的数组组合成一个数组，可以使用这个函数。要组合的数组是相同类型(索引的、关联的等)还是不同类型并不重要，使用这个函数我们可以将它们组合成一个数组。

让我们举一个例子，我们将合并一个索引数组和一个关联数组。

<?php

$hatchbacks = array(
        "Suzuki" => "Baleno",
        "Skoda" => "Fabia",
        "Hyundai" => "i20",
        "Tata" => "Tigor"
    );

// friends who own the above cars
$friends = array("Vinod", "Javed", "Navjot", "Samuel");

// let's merge the two arrays into one
$merged = array_merge($hatchbacks, $friends);

print_r($merged);

?>

array([铃木] = > Baleno[斯柯达]= >法比亚[现代]= > i20[塔塔]= > Tigor[0]= > Vinod[1]= > Javed[2]= > Navjot[3]= > Samuel)

array_values($arr)

在数组中，数据以键值对的形式存储，其中键可以是数字(在索引数组的情况下)或用户定义的字符串(在关联数组的情况下)和值。

如果我们想从数组中获取所有的值，而不需要键，并将它们存储在一个单独的数组中，那么我们可以使用array_values()函数。

我们以上例中形成的数组$merged为例，

<?php

$hatchbacks = array(
        "Suzuki" => "Baleno",
        "Skoda" => "Fabia",
        "Hyundai" => "i20",
        "Tata" => "Tigor"
    );

// friends who own the above cars
$friends = array("Vinod", "Javed", "Navjot", "Samuel");

// let's merge the two arrays into one
$merged = array_merge($hatchbacks, $friends);

//getting only the values
$merged = array_values($merged);

print_r($merged);

?>

Array ( [0] => Baleno [1] = >法比亚[2]= > i20[3]= > Tigor[4]= > Vinod[5]= > Javed[6]= > Navjot[7]= > Samuel)

array_keys($arr)

就像值一样，我们也可以只从数组中提取键。让我们用这个函数从数组$merged中提取按键。

<?php

//getting only the keys
$keys = array_values($merged);

print_r($keys);

?>

Array ( [0] = >铃木[1] = >斯柯达[2] = >现代[3] = >塔塔[4] => 0 [5] => 1 [6] => 2 [7] => 3)

array_pop($arr)

此函数移除数组的最后一个元素。因此，它可以用来从末端移除一个元素。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// removing the last element
array_pop($lamborghinis);

print_r($lamborghinis);

?>

数组([0] => Urus [1] = >飓风)

array_push($arr, $val)

该功能与array_pop()功能相反。这可用于在数组末尾添加新元素。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// adding a new element at the end
array_push($lamborghinis, "Estoque");

print_r($lamborghinis);

?>

数组([0] => Urus [1] = >飓风[2] = >复仇者[3] = >库存)

array_shift($arr)

此函数可用于移除/移动数组中的第一个元素。所以，它就像array_pop()功能一样，只是被移除元素的位置不同。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador");

// removing the first element
array_shift($lamborghinis);

print_r($lamborghinis);

?>

阵列([0] = >飓风[1] = >袭击者)

与此类似，我们有另一个函数array_unshift($arr, $val)在数组的开始处添加一个新值($val)(作为第一个元素)。

sort($arr)

该函数按升序对数组元素进行排序。在字符串值数组的情况下，值按字母升序排序。

其他一些排序功能有:asort()、arsort()、ksort()、krsort()和rsort()。

<?php

$lamborghinis = array("Urus", "Huracan", "Aventador", "Estoque");

// sort the array
sort($lamborghinis);

print_r($lamborghinis);

?>

数组([0] = >修正者[1] = >库存[2] = >飓风[3] => Urus)

array_map('function_name', $arr)

如果要对存储在数组中的所有值执行某种操作，可以使用 for循环或foreach 对数组进行迭代，并对数组的所有值执行所需的操作。

或者，可以使用array_map()功能。我们所要做的就是定义一个单独的函数，我们将一个接一个(一次一个)向它提供存储在数组中的值，它将对这些值执行操作。举个例子，

<?php

function addOne($val) {
    // adding 1 to input value
    return ($val + 1);
}

$numbers = array(10, 20, 30, 40, 50);

// using array_map to operate on all the values stored in array
$numbers = array_map('addOne', $numbers);

print_r($numbers)

?>

数组([0]= > 11[1]= > 21[2]= > 31[3]= > 41[4]= > 51)

功能array_walk($arr, 'function_name')的工作原理与array_map()功能一样。

array_flip($arr)

这个函数交换 PHP 关联数组的键和值。

<?php

$hatchbacks = array(
        "Suzuki" => "Baleno",
        "Skoda" => "Fabia",
        "Hyundai" => "i20",
        "Tata" => "Tigor"
    );

// we can directly print the result of array flipping
print_r(array_flip($hatchbacks));

?>

Array ( [Baleno] = >铃木[法比亚] = >斯柯达[i20] = >现代[Tigor] = >塔塔)

array_reverse($arr)

此函数用于颠倒元素的顺序，使第一个元素成为最后一个元素，最后一个元素成为第一个元素，并类似地重新排列其他数组元素。

<?php

$num = array(10, 20, 30, 40, 50);
// printing the array after reversing it
print_r(array_reverse($num));

?>

数组([0]= > 50[1]= > 40[2]= > 30[3]= > 20[4]= > 10)

array_rand($arr)

如果你想从一个数组中选择随机的数据元素，你可以使用array_rand()函数。这个函数从给定的数组中随机选择一个元素并返回它。

如果是索引数组，它将返回元素的索引，如果是关联数组，它将返回所选随机元素的键。

<?php

$colors = array("red", "black", "blue", "green", "white", "yellow");

echo "Color of the day: ". $colors[array_rand($colors)];

?>

当天颜色:绿色

每次运行上面的脚本，它都会从数组中返回一个随机的颜色值。

array_slice($arr, $offset, $length)

此函数用于创建任何数组的子集。使用这个函数，我们定义了起始点($offset，这是子集开始的数组索引)和长度(或者，子集所需的元素数量，从偏移量开始)。

让我们举个例子，

<?php

$colors = array("red", "black", "blue", "green", "white", "yellow");

print_r(array_slice($colors, 2, 3));

?>

数组([0] = >蓝色[1] = >绿色[2] = >白色)

PHP 字符串

原文：https://www.studytonight.com/php/php-strings

就像任何其他编程语言一样，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 字符串函数

原文：https://www.studytonight.com/php/php-string-functions

在上一个教程中，我们已经介绍了什么是字符串以及如何创建它们，现在让我们深入研究字符串，了解 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 表单处理

原文：https://www.studytonight.com/php/php-form-handling

当我们开发一个网站或者一个网络应用程序时，我们经常需要创建一些表格来接受用户的输入，比如登录表格或者注册表格。

在网页上创建表单是使用 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，你知道它们是干什么的吗？

  1. action:使用这个属性，我们可以指定将要收集和处理表单数据的文件名。在上面的例子中，我们提供了一个 Php 文件的名称。
  2. 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>";

?>

嗨，今晚学习你的电子邮件地址:we@studytonight.com

如果您提供的姓名为“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>";

?>

嗨，今晚学习你的电子邮件地址:we@studytonight.com

同样，输出保持不变。

处理表单数据的第一步是使用 POST 或 GET superglobals 获取数据，一旦你有了数据，你可以对它做任何事情，在你的网页上显示它，将数据保存到数据库，执行验证等。

PHP form data handling

获取与发布:何时使用什么！

现在，你一定想知道，我们应该用哪一个。好吧，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 form handling example

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 中的状态管理

原文：https://www.studytonight.com/php/php-state-management

HTTP 是无状态协议，这意味着每个用户请求都是独立处理的，与之前处理的请求无关。因此，无法使用 HTTP 协议存储或发送任何用户特定的详细信息。

但是在现代应用程序中，会创建用户帐户，并将用户特定信息显示给不同的用户，为此，我们需要了解每个网页上的用户是谁(或他/她希望看到什么等)。

PHP 为 web 应用程序的状态管理提供了两种不同的技术，它们是:

  1. 服务器端状态管理
  2. 客户端服务器管理

服务器端状态管理

在服务器端状态管理中，我们存储在服务器上识别用户所需的用户特定信息。每个网页上都有这些信息。

在 PHP 中我们有 【会话】 用于服务器端状态管理。PHP 会话变量用于存储用户名、用户 id 等用户会话信息，并且可以通过访问 web 应用程序的任何网页上的会话变量来检索这些信息，直到会话变量被销毁。

客户端状态管理

在客户端状态管理中，用户特定信息存储在客户端，即存储在服务器中。同样，该信息在 web 应用程序的所有网页上都可用。

在 PHP 中我们有 Cookies 用于客户端状态管理。cookie 保存在浏览器中，带有一些数据和到期日期(直到 cookie 有效)。

使用 cookie 进行状态管理的一个缺点是，用户可以轻松访问存储在浏览器中的 cookie，甚至可以将其删除。

PHP Cookies

原文：https://www.studytonight.com/php/php-cookies

Cookie 是网络服务器以文件形式存储在用户浏览器中的一小段信息。一旦创建，cookie 将作为每个 HTTP 请求的头信息发送到 web 服务器。

您可以使用 cookie 保存任何数据，但大小不应超过 1K(1024 字节)。

在我们继续讨论如何创建、更新和删除 cookie 之前，让我们学习一些 cookie 在现实世界中的用法。

饼干的真实使用

  1. 存储用户信息，如他/她何时访问过，网站上访问过哪些页面等，以便下次用户访问您的网站时，您可以提供更好的用户体验。
  2. 要存储基本的网站具体信息要知道这不是用户的第一次访问。
  3. 您可以使用 cookies 来存储访问次数或查看计数器。

我希望这能让你对如何在你的 web 应用程序中利用 cookies 有一个概念。

饼干的种类

有两种类型的 cookies，它们是:

  1. 会话 Cookie :这种类型的 Cookie 是临时的，一旦会话结束或浏览器关闭，就会过期。
  2. 持久 Cookie :要使 Cookie 持久，我们必须为其提供过期时间。那么该 cookie 将仅在给定的过期时间后过期，在此之前它将是有效的 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>)之前。

要更新/修改 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。

要删除/移除 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 会话

原文：https://www.studytonight.com/php/php-session-management

为了存储网页上可访问的信息，我们使用会话。会话不像cookie那样存储在用户浏览器上，因此它是一个更安全的选项。

我们知道 HTTP 是一个无状态协议，如果用户访问一个网页并执行一些动作，那么当用户导航到下一个网页时，就没有办法记住他做了什么。

让我们举一个实际的例子，当你登录你的 facebook 帐户时，通过提供你的电子邮件地址和密码，直到并且除非你注销，网络应用程序会记住你是谁，并在你的新闻提要上显示你的朋友正在发布和喜欢什么，你可以更新你的个人资料，给某人发消息，加入一个群组等，这是通过 Session 完成的。

当用户在任何网络应用程序上登录他们的帐户时，会为他们创建一个会话，并且在该会话中会存储他们的用户名或用户标识或其他一些唯一的标识符，然后在连续的网页上使用这些标识符来显示该用户的特定信息。注销时，会话将被销毁。

会话不受任何大小限制，您可以在会话中存储任何信息，无论其大小如何。

在我们继续讨论如何在 PHP 中开始、更新和结束一个会话之前，让我们学习会话的一些实际用法。

会话的真实使用

  1. 需要用户登录的 Web 应用程序使用会话来存储用户信息，以便在每个网页上向用户显示相关信息。
  2. 在电子商务网站中，购物车通常作为会话的一部分保存。

我希望这能让你了解如何在你的 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 中的文件处理

原文：https://www.studytonight.com/php/php-file-handling

当我们使用 PHP 开发一个 web 应用程序时，我们经常需要处理外部文件，比如从文件中读取数据，或者将用户数据写入文件等。因此，在使用任何 web 应用程序时，了解文件是如何处理的非常重要。

文件处理操作

文件处理从创建文件、读取其内容、写入文件以将数据附加到现有文件中，最后关闭文件开始。Php 为所有这些操作提供了预定义的函数，所以让我们从了解这些函数开始。

  1. 创建文件 : fopen()
  2. 打开文件 : fopen()
  3. 读取文件 : fread()
  4. 写入文件 : fwrite()
  5. 追加到文件 : fwrite()
  6. 关闭文件 : fclose()
  7. 删除文件 : unlink()

你一定想知道为什么我们为多个文件操作指定了相同的函数，那是因为仅仅通过改变一个或多个参数，相同的函数就可以用来对文件执行多个操作。

Introduction to File Handling PHP

在接下来的教程中，我们将学习如何使用这些函数以及代码示例。

文件在应用程序中的使用

以下是我们在 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 文件中使用它。

File open and create example 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 读取文件

原文：https://www.studytonight.com/php/php-read-file

用 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()函数有两个参数:

  1. 首先是文件名
  2. 第二个参数指定要读取的内容的字节大小。

举个例子，如果我们有一个文件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 等)、一把椅子(由大小、材料、成本等描述)、一所学校(由地点、学生实力、结果等描述)等。

面向对象编程使编程接近现实生活，因为我们总是在处理一个对象，对它执行操作，使用它的方法和变量等。

面向对象的概念

Basic OOPS concepts

在下面的视频中，我们借助一个非常容易理解的例子解释了面向对象编程的基本概念。如果你想跳过视频，所有内容都在下面讨论。

让我们试着通过一个简单的例子来了解一下这些。人类是有生命的形式，大致分为两种，男性和女性。正确是真的。每个人(男性或女性)都有两条腿、两只手、两只眼睛、一个鼻子、一颗心等。男性和女性都有一些常见的身体部位，但男性有一些女性没有的特定身体部位，女性有一些身体部位，但男性没有。

所有的人都走路、吃饭、看、说话、听等等。现在，男性和女性都执行一些共同的功能，但是两者都有一些细节，这对另一个是无效的。比如:女的可以生，男的不可以生，所以这只针对女的。

人体解剖学很有趣，不是吗？但是让我们看看这一切是如何与 PHP 和 OOPS 相关联的。在这里，我们将尝试通过这个例子来解释所有的 OOPS 概念，在下一个教程中，我们将有所有这些的技术定义。

班级

这里我们可以把人类作为一个类。类是定义其属性和功能的任何功能实体的蓝图。像人一样，有身体的一部分，做各种动作。

遗产

考虑HumanBeing一个类，有手、腿、眼等属性，有走、说、吃、看等功能。Male和Female也是类，但是大部分属性和函数都包含在HumanBeing中，因此它们可以使用继承的概念从类HumanBeing继承一切。

目标

我的名字是阿布舍克，我是类Male的实例/对象。当我们说，人类，男性或女性，我们只是指一种，你，你的朋友，我，我们是这些类的形式。我们有一个物理存在，而一个类只是一个逻辑定义。我们是目标。

抽象

抽象意味着，只向外界展示需要的东西，而隐藏细节。继续我们的例子，人类的会说话，会走路，会听，会吃，但是细节对外界是隐藏的。在我们的案例中，我们可以将皮肤作为抽象因素，隐藏内部机制。

包装

这个概念用我们的例子来解释有点棘手。我们的腿被绑在一起帮助我们走路。我们的手，帮我们拿东西。属性与函数的这种绑定称为封装。

多态性

多态性是一个概念，它允许我们重新定义某件事的工作方式，要么通过改变它是如何完成的，要么通过改变它所使用的部分。这两种方式都有不同的术语。

PHP 中的类

原文：https://www.studytonight.com/php/php-class

作为一种面向对象的编程语言，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 类对象

原文：https://www.studytonight.com/php/php-class-objects

正如在上一个教程中所讨论的，类只不过是一个蓝图或者用户定义的数据类型，可以通过创建它的对象来使用。

类是一个逻辑实体，而它的对象是真实的。

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 访问修饰符

原文：https://www.studytonight.com/php/php-access-modifiers

为了设置类方法和变量的访问权限，我们使用的访问修饰符只是 PHP 关键字。我们甚至可以将其中的一些访问修饰符分配给类本身，以使类以一种特殊的方式运行。

下面是 PHP 关键字，它们被用作访问修饰符，并带有它们的含义:

  1. public:当我们将类成员定义为公共的时候，那么它们可以从任何地方访问，甚至可以从类范围之外访问。
  2. private:当我们将类成员定义为私有时，只能从类本身内部访问。
  3. protected:这个和 private 一样，除了一个例外，定义为 protected 的类成员仍然可以从它的子类访问(我们在了解继承的时候会了解子类)。
  4. abstract :此关键字仅用于 PHP 类及其成员函数。
  5. 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关键字

原文：https://www.studytonight.com/php/php-this-keyword

如果您从头开始学习本教程，或者从 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();

?>

PHP 继承

原文：https://www.studytonight.com/php/php-inheritance

在面向对象编程中，继承使类能够使用现有类的属性和方法。在编码的时候，我们经常会遇到这样的情况:我们必须创建一个新的类，它具有现有类的所有功能和一些附加方法，更像是对现有类的扩展，在这种情况下，我们可以将现有类的所有属性和方法复制到新类中，使它们在新类中可用，或者我们可以简单地继承新类中的旧类。

迷茫？让我们举一个简单的例子来理解它。考虑一个有基本方法的类Human，比如walk()、eat()、hear()、see()等。现在如果我们要为男性和女性再创建两个名为Male和Female的类，拥有类Human的所有属性和方法，以及一些仅适用于Male和Female的特定特性，我们可以通过继承Male和Female类中的Human类来实现。

继承的类称为父类(或超类或基类)，而继承其他类的类称为子类(或子类或派生类)。

在上例中，Human为父类，Male和Female为子类。

一个类可以被多个类继承。

继承如果我们想创建几个类似的类，非常有用。我们可以将公共属性和方法放在一个父类中，然后在子类中继承它。

而对于破坏对象使用析构器方法。

继承类的语法

在 PHP 中，extends关键字用于指定父类的名称，同时定义子类。例如，

<?php
    class Human {
        // parent class code
    }

    class Male extends Human {
        // child class code
    }

    class Female extends Human {
        // child class code
    }
?>

使用继承时需要记住的一些要点是:

  1. 子类只能访问和使用父类上的非私有属性和方法。
  2. 子类也可以有自己的方法，但父类没有。
  3. 子类也可以重写父类中定义的方法，并为其提供自己的实现。

让我们在Human类中添加一些方法，看看如何在子类Male和Female中使用它们。

<?php
    // parent class
    class Human {
        // public property name
        public $name;

        // public function walk
        public function walk() {
            echo $this->name. " is walking...<br/>";
        }

        // public function see
        public function see() {
            echo $this->name. " is seeing...<br/>";
        }
    }

    // child class
    class Male extends Human {
        // No code in child
    }

    // child class
    class Female extends Human {
        // No code in child
    }

    $male = new Male();
    $male->name = "Adam";

    $female = new Female();
    $female->name = "Eve";

    // calling Human class methods
    // check the output (hehe, pun intended)
    $female->walk();
    $male->see();

?>

夏娃正在走路...亚当看见了...

从上面的代码中可以看到，两个子类都是空的，我们只继承了两个子类中的类Human，这允许它们访问和使用父类上的成员属性和方法。

有自己的方法和属性的子类

当子类继承父类时，它可以访问和使用父类的所有非私有成员。我们知道这一点，但是一个子类可以有自己的成员属性和方法吗？是的，它可以有。让我们举另一个例子来看看我们如何做到这一点:

<?php
    // parent class
    class Vehicle {
        // public property name
        public $name;

        // public function start
        public function start() {
            echo $this->name. " - Engine start...<br/>";
        }

        // public function stop
        public function stop() {
            echo $this->name. " - Engine stop...<br/>";
        }
    }

    // child class
    class Car extends Vehicle {

        public function drive() {
            echo "I am " . $this->name . "<br/>";
            echo "Lets go on a drive...";
        }

    }

    // child class
    class Motorcycle extends Vehicle {

        // motorcycle specific properties
        // and methods

    }

    $car = new Car();
    $car->name = "Mercedes benz";

    // calling parent class method
    $car->start();

    // calling child class method
    $car->drive();

?>

奔驰-发动机启动...我是奔驰，我们去兜风吧...

当一个类继承另一个类时，它的优势是能够使用父类中定义的属性和方法，而无需再次定义它们。也可以像其他普通类一样有自己的属性和方法。

protected访问修饰符

我们了解了各种访问修饰符，以及如何使用它们来控制类的各种属性和方法的访问。

当子类继承父类时，它只能访问和重用非私有属性和方法。但是我们不应该对属性使用public访问修饰符，因为这样属性也可以从类外访问。

为了只允许子类访问父类的属性和方法，我们可以使用protected访问修饰符。

当我们将类的任何属性或方法定义为protected时，这些属性和方法只能在继承该类的子类中访问。

让我们举个例子:

<?php
    // parent class
    class Vehicle {
        // protected property name
        protected $name;

        // public function start
        public function start() {
            echo $this->name. " - Engine start...<br/>";
        }

        // public function stop
        public function stop() {
            echo $this->name. " - Engine stop...<br/>";
        }
    }

    // child class
    class Car extends Vehicle {

        public function drive() {
            // accessing name variable of Car class
            echo "I am " . $this->name . "<br/>";
            echo "Lets go on a drive...";
        }

    }

    $car = new Car();
    $car->name = "Mercedes benz";

    // calling parent class method
    $car->start();

    // calling child class method
    $car->drive();

?>

奔驰-发动机启动...我是奔驰，我们去兜风吧...

在上面的例子中，我们已经将name变量设为protected，尝试运行与private同名的代码，您将得到以下错误:

注意:未定义的属性...

重写父类方法

如果一个子类想使用父类方法，但又略有不同，该怎么办？它可以通过重写父类中定义的方法的定义并提供自己的定义来做到这一点。这被称为方法覆盖。

让我们举个例子来理解这个概念:

<?php
    // parent class
    class Vehicle {
        // public property name
        public $name;

        // public method
        public function drive() {
            echo "Vehicle class drive method...<br/>";
        }
    }

    // child class
    class Car extends Vehicle {

        public function drive() {
            echo "Car class drive method...<br/>";
        }

    }

    // child class
    class Motorcycle extends Vehicle {

        public function drive() {
            echo "Motorcycle class drive method...<br/>";
        }

    }

    $car = new Car();
    $car->name = "Mercedes benz";

    // calling child class method
    $car->drive();

    $bike = new Motorcycle();
    $bike->name = "Triumph Tiger";

    // calling child class method
    $bike->drive();

?>

汽车级驱动方法...摩托车级驱动方法...

在上面的代码中，我们有一个名为Vehicle的父类和两个扩展父类的子类，即Car和Motorcycle。在父类中，我们有一个方法drive()，我们已经在子类中覆盖了这个方法，并为它提供了不同的定义。

如果不希望任何子类重写父类方法，该怎么办？

如果我们愿意，我们可以将父类中的方法定义为final。

让我们看看如果我们试图覆盖一个final方法会发生什么。

<?php
    // parent class
    class Vehicle {
        // public property name
        public $name;

        // public method
        final public function drive() {
            echo "Vehicle class drive method...<br/>";
        }
    }

    // child class
    class Car extends Vehicle {

        public function drive() {
            echo "Car class drive method...<br/>";
        }

    }

    $car = new Car();
    $car->name = "Mercedes benz";

    // calling child class method
    $car->drive();

?>

致命错误:无法覆盖最终方法车辆::驱动器()

PHP 抽象类和方法

原文：https://www.studytonight.com/php/php-abstract-class-and-methods

当可以使用abstract关键字定义一个类抽象时。定义为抽象的类不能被实例化。

下面是一些关于抽象类和方法的要点:

  1. 抽象类可以像任何其他普通类一样拥有方法和属性。
  2. 抽象类不能被实例化，因此我们需要创建一个扩展它的子类，然后我们可以创建子类的对象。
  3. 如果一个类只有一个抽象方法，那么这个类也应该是抽象的。
  4. 抽象方法只是声明，其中我们提供了方法和参数的名称，而主体部分是空的。

如果你无法理解，不要担心。我们将通过例子一步一步地介绍所有的要点，让我们从理解如何创建一个抽象类开始。

创建abstract类

要声明一个类抽象，我们需要在类名前使用abstract关键字。

让我们举个例子:

<?php
    // abstract class
    abstract class Vehicle {

        // abstract function mileage
        abstract public function mileage() {

        }
    }

?>

在上例中，我们的类Vehicle是一个抽象类，它有一个抽象方法。

创建抽象类背后的思想是约束开发人员遵循一套准则，例如，如果您想创建一个扩展我们的类的新类Vehicle，那么您必须为抽象方法mileage()提供定义，否则子类也应该是抽象的。因此，所有子类都必须为方法mileage()提供定义。

抽象类中的非抽象方法

任何甚至只有一个抽象方法的类都必须声明为抽象的。但是抽象类也可以有非抽象方法，子类可以直接访问和使用这些方法，而无需重写它们。

让我们扩展上面的例子，在我们的类Vehicle中包含一个非抽象方法:

<?php
    // abstract class
    abstract class Vehicle {

        // protected variable
        protected $name;

        // non-abstract public function start
        public function start() {
            echo $this->name. " - Engine start...<br/>";
        }

        // non-abstract public function stop
        public function stop() {
            echo $this->name. " - Engine stop...<br/>";
        }

        // non-abstract public function setName
        public function setName($name) {
            $this->name = $name;
        }

        // abstract function mileage
        abstract public function mileage() {

        }
    }

?>

在上面的代码中，我们在抽象的Vehicle类中添加了三个非抽象的方法，即start()、stop()和setName()。

继承抽象类

就像任何其他类一样，我们也可以创建扩展抽象类的类。

这里唯一的区别是子类必须为抽象父类中声明的抽象方法提供定义。

如果子类没有为抽象方法提供定义，那么它也应该被定义为抽象类。

让我们创建两个继承类Vehicle的子类，它们将有抽象方法mileage()的定义:

<?php
    // child class
    class Car extends Vehicle {

        public function mileage() {
            echo "I am " . $this->name . "<br/>";
            echo "My mileage range is - 15 to 22 Km/L";
        }

    }

?>

我们可以有任意多的子类，让我们有另一个类:

<?php

    // child class
    class Motorcycle extends Vehicle {

        public function mileage() {
            echo "I am " . $this->name . "<br/>";
            echo "My mileage range is - 35 to 47 Km/L";
        }

    }

?>

如上所述，抽象类不能有任何对象，一旦我们定义了合适的子类，我们就可以为它们创建对象。

<?php

    $car = new Car();
    $car->setName("BMW X1");
    $car->mileage();

?>

我是宝马 X1 我的里程范围是- 15 到 22 公里/升

如果你想尝试，继续尝试创建类Vehicle的对象，你会得到一个错误。

PHP 接口

原文：https://www.studytonight.com/php/php-interfaces

就像抽象类、接口也是为了定义继承接口的类的蓝图而创建的。接口没有抽象的方法，只有public没有定义的方法，继承接口的类必须为接口内部声明的方法提供定义。

定义 PHP 接口的语法

就像使用关键字class定义类一样，使用关键字interface后跟接口名称来定义接口。

<?php
    // interface declaration
    interface NameOfInterface {

    }

?>

一个类使用implements关键字从接口继承并实现接口中声明的方法。

<?php
    // class declaration
    class SomeClass implements NameOfInterface {

    }

?>

举个例子

让我们举一个简单的例子，我们将创建一个接口，其中声明了一些方法，实现它的类将被绑定来为这些方法提供定义。

下面是我们的界面:

<?php
    // interface declaration
    interface WebApp {

        // methods declaration
        public function login($email, $password);

        public function register($email, $password, $username);

        public function logout();

    }

?>

我们定义了一个名为WebApp的接口，其中声明了三个抽象方法，分别是login()、register()和logout()。正如您在上面的代码中看到的，我们还提供了方法将接受的参数。

现在让我们创建一个实现上述接口的类:

<?php
    // class declaration
    class Studytonight implements WebApp {

        // methods definition
        public function login($email, $password) {
            echo "Login the user with email: " . $email;
        }

        public function register($email, $password, $username) {
            echo "User registered: Email=".$email." and Username=".$username;
        }

        public function logout() {
            echo "User logged out!";
        }

    }

?>

在上面的类中，我们已经实现了接口WebApp，并为接口中声明的所有方法提供了定义。

实现多接口

一个类也可以实现多个接口。在这种情况下，类必须为类实现的所有接口中声明的方法提供定义。

让我们创建另一个界面:

<?php
    // interface declaration
    interface CMS {

        // methods declaration
        public function publishPost($post);

    }

?>

现在我们也把上面的界面添加到我们的类Studytonight中:

<?php
    // class declaration
    class Studytonight implements WebApp, CMS {

        // methods definition
        public function login($email, $password) {
            echo "Login the user with email: " . $email;
        }

        public function register($email, $password, $username) {
            echo "User registered: Email=".$email." and Username=".$username;
        }

        public function logout() {
            echo "User logged out!";
        }

        public function publishPost($post) {
            echo $post." published!";
        }

    }

?>

现在我们的类Studytonight实现了两个接口。

需要注意的一些要点:

  • 接口中声明的所有方法都是public，不以abstract关键字开头。
  • 如果我们甚至没有实现接口中声明的单个方法，那么在实现接口的类中，我们将会得到一个错误。
  • 接口没有变量。

如果你无法理解，不要担心。我们将通过例子一步一步地介绍所有的要点，让我们从理解如何创建一个抽象类开始。

abstract类与接口的区别

下面是抽象类和接口之间的一些重要区别:

| 连接 | 抽象类 |
| 接口中不能有具体的方法，即有定义的方法。 | 抽象类中既可以有abstract方法，也可以有具体方法。 |
| 界面中声明的所有方法都应该是public | 抽象类可以有public、private和protected等方法。 |
| 一个类可以实现多个接口。 | 一个类只能扩展一个抽象类。 |

PHP 错误处理

原文：https://www.studytonight.com/php/php-error-handling

在学习如何处理 PHP 中的错误之前，我们应该先知道什么是错误。

当一段代码返回意外结果或由于某些不正确的代码而突然停止时，例如除以零或无限循环等，则称发生了错误。

在 PHP 中，我们可以设置 PHP 配置，在浏览器中显示或隐藏错误消息。

PHP 提供了多种处理错误的方法，

  1. 使用条件语句或die()函数处理代码错误
  2. 使用自定义错误处理程序
  3. PHP 错误报告

让我们用例子来说明每一个。

使用die()功能

PHP 中的die()功能用于显示任何消息，同时退出当前脚本的。因此，一旦检测到错误情况，就可以使用die()函数退出代码执行。

当我们试图用零除一个数时，或者试图打开一个不存在的文件时，可能会发生错误，让我们举个例子，看看如何使用die()函数或条件语句来处理错误情况。

<?php

    $fileName = "noerror.txt";
    // opening the file
    fopen($fileName, "r")
    or die("Unable to open file $fileName");

?>

在上面的代码片段中，如果给定位置没有名为的文件，我们将在屏幕上获得消息无法打开文件 noerror.txt 。

die()函数是exit()函数的别名，也用于退出代码执行。

现在让我们看看如何使用条件语句来处理错误情况。当我们事先知道可能导致错误的情况时，这种类型的错误处理是有用的。

例如，下面的代码将导致错误:

<?php

    function division($numerator, $denominator) {
        // perform division operation
        echo $numerator / $denominator;
    }

    // calling the function
    division(7, 0);

?>

警告:除以零...

在这种情况下，当我们知道某个条件会导致错误时，我们可以使用条件语句来处理会导致错误的角情况。让我们修复上面的代码:

<?php

    function division($numerator, $denominator) {
        // use if statement to check for zero
        if($denominator != 0) {
            echo $numerator / $denominator;
        }
        else {
            echo "Division by zero(0) no allowed!";
        }
    }

    // calling the function
    division(7, 0);

?>

不允许除以零(0)！

正如您在上面的代码中所看到的，错误情况得到了处理。现在我们的代码不会在 scree 上显示任何错误，而是会显示一条消息并优雅地退出。

使用自定义错误处理程序

在 PHP 中，我们可以使用我们的自定义方法来显示任何消息，或者在发生错误时执行任何代码。我们所要做的就是使用函数set_error_handler()将我们的方法设置为 PHP 的默认错误处理程序

让我们举个例子:

<?php

    // custom function to handle error
    function studytonight_error_handler($error_no, $error_msg) {
        echo "Oops! Something unexpected happen...";
        echo "Possible reason: " . $error_msg;
        echo "We are working on it.";
    }

    // set the above function s default error handler
    set_error_handler("studytonight_error_handler");

    $result = 7 / 0;

?>

哎呀！意想不到的事情发生了...可能的原因:除以零我们正在努力。

我们可以用参数$error_no和$error_msg定义我们自己的函数，并且可以按照我们想要的方式处理它们。我们可以显示自定义消息，记录数据库中的错误，发送电子邮件给开发者报告错误等。

PHP 错误报告

PHP 提供了默认的错误报告机制，当错误发生时，可以用来在屏幕上显示消息。

错误处理是为了优雅地处理代码中的错误，并为最终用户提供更好的用户体验。

我们可以使用 PHP 函数error_reporting()设置显示哪些错误，隐藏哪些错误。

以下是该函数的语法:

<?php
    // error reporting function
    error_reporting($reporting_level);

?>

变量$reporting_level的值定义了显示哪个错误和隐藏哪个错误，如果我们没有为其提供任何值，错误报告将被设置为默认值。

以下是我们可以为设置各种错误级别提供的值:

| 报告级别 | 描述 |
| 电子警告 | 仅显示警告消息，不停止脚本的执行。 |
| E _ NOTICE | 显示正常代码执行过程中出现的注意事项。 |
| E_USER_ERROR | 显示用户生成的错误，即自定义错误处理程序。 |
| 电子用户警告 | 显示用户生成的警告消息。 |
| 电子用户通知 | 显示用户生成的通知。 |
| E _ RECOVERABLE _ ERROR | 显示非致命错误。 |
| E_ALL | 显示所有错误和警告。 |

这就引出了 PHP 中错误处理的结论。在下一个教程中，我们将学习 【异常处理】 。

PHP 异常处理

原文：https://www.studytonight.com/php/php-exception-try-catch

在之前的教程中，我们介绍了错误处理。现在问题来了，异常和一个错误有什么区别。

PHP 5 引入了一种新的面向对象的错误处理方式，称为异常。

异常处理用于处理错误，并在发生错误时重定向代码执行过程，这与错误不同，在错误中，代码执行停止，屏幕上显示错误消息。

使用try和catch块

可导致异常或错误的代码包含在try块中，如果没有异常发生，则代码正常执行，而在异常情况下，代码执行退出try块并进入catch块。

以下是使用try和catch进行异常处理的语法，

<?php

try {
    //code goes here that could lead to an exception
}
catch (Exception $e) {
    //exception handling code goes here
}

?>

throw异常

如果需要，我们可以使用throw关键字手动触发异常。Exception是一个 PHP 类，是 PHP 中所有异常类的父类。

要抛出异常，我们必须创建一个异常类的对象，然后使用throw关键字来触发该异常。

让我们举个例子:

<?php
    // funciton declaration
    function triggerException() {
        // using throw keyword
        throw new Exception("Manually triggering exception...");
    }

?>

如果我们调用上面的函数triggerException()，那么它将抛出异常。

现在我们可以在try块内调用这个函数，并处理catch()块中的异常，如下所示:

<?php

try {
    // calling the function
    triggerException();
}
catch (Exception $e) {
    echo "Oops! Some unexpected error occured...";
}

?>

哎呀！出现了一些意外错误...

在catch块内部，我们也可以使用getMessage()方法从异常对象获取消息。

自定义异常类

我们可以通过扩展 PHP 提供的Exception类来创建自定义异常类。

下面我们有一个自定义异常类的例子:

<?php
    // custom exception class
    class StudytonightException extends Exception {

        // define constructor
        function __construct() {
            // we can even take arguments if we want
        }

        // we can define class methods if required

    }

?>

当您需要自定义错误处理时，自定义异常类非常有用，例如记录数据库中的错误等。

处理多个异常

如果一段代码可以抛出不同类型的异常，并且根据异常的类型我们必须执行一些动作，在这种情况下我们可以有多个catch块:

<?php

try {
    // calling the function
    triggerException();
}
catch (StudytonightException $e) {
    // do something here...
}
catch (Exception $e) {
    echo "Oops! Some unexpected error occured...";
}

?>

使用多个catch块处理多个异常时需要记住的几个要点:

  1. Exception班的catch块搬运子班必须放在catch块搬运Exception班的上方。或者换句话说，Exception类搬运catch块应该最后保留。
  2. catch块处理Exception类也可以处理其他异常，因为所有异常类都是Exception类的子类。

PHP 与 MySQL

原文：https://www.studytonight.com/php/php-with-mysql

PHP 是一种脚本语言，主要用于开发 web 应用程序，我们必须在数据库中搅拌用户数据。最受欢迎的开源数据库是 MySQL ，这是使用 PHP 最广泛的数据库之一。

在本教程中，我们将学习远程连接数据库，然后对表执行 SQL 查询。

如果你不知道如何编写 SQL 查询，你可以学习查看我们的 SQL 教程。

我们可以使用MySQL或者 PDO 来使用 PHP 和 MySQL。在本教程中，我们将涵盖 PDO 因为它支持 12 种语言，并且还支持准备好的语句，防止 SQL 注入。

PDO 装置

遵循以下说明:http://php.net/manual/en/pdo.installation.php

连接到 MySQL 服务器

在执行任何查询之前，我们首先需要连接到 MySQL 服务器。下面是使用 PDO 连接到 MySQL 服务器的代码:

<?php
// server details
$servername = "localhost";
$username = "username";
$password = "password";

try 
{
    $conn = new PDO("mysql:host=$servername; dbname=myDB", $username, $password);
    // set the PDO error mode to exception
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Connected successfully"; 
}
catch(PDOException $e)
{
    echo "Connection failed: " . $e->getMessage();
}

?>

在上面的代码中，您需要根据您的服务器详细信息更改用户名和密码。

关闭连接

完成后，关闭与 MySQL 服务器的连接是一个很好的做法。

很简单，我们只需将连接对象设置为 null，如下所示:

<?php

// disconnect MySQL server connection
$conn = null;

?>

创建数据库

数据库包含一个或多个存储数据的表。

我们可以使用 PHP 在 MySQL 中创建数据库，使用 PDO 语句执行CREATE SQL 查询。

下面是代码:

<?php

// connect to MySQL server
$servername = "localhost";
$username = "username";
$password = "password";

try 
{
    $conn = new PDO("mysql:host=$servername", $username, $password);
    // set the PDO error mode to exception
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    // sql query to create database
    $sql = "CREATE DATABASE myDBPDO";
    // use exec() because no results are returned
    $conn->exec($sql);
    echo "Database created successfully <br/>";
}
catch(PDOException $e)
{
    echo $sql . "<br/>" . $e->getMessage();
}

// disconnecting from MySQL server
$conn = null;

?>

PDO 提供异常处理，因此它比 mysqli 更好，因为在数据库上执行 SQL 查询时很有可能发生异常。

就像上面的代码一样，我们可以在变量$sql中提供任何 SQL 查询，并使用exec()函数来执行查询。

创建表格

就像创建数据库一样，我们也可以创建一个表，我们所要做的就是将代码中变量$sql中的 SQL 查询改为创建表的查询。

这里有一个示例查询来创建一个表用户，列有用户标识、电子邮件、密码和全名。

// sql query to create table
$sql = "CREATE TABLE User (
        userid INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
        email VARCHAR(50) NOT NULL,
        password VARCHAR(50) NOT NULL,
        fullname VARCHAR(50)
        )";

这是完整的代码供您参考，

<?php

// connect to MySQL server
$servername = "localhost";
$username = "username";
$password = "password";

try 
{
    $conn = new PDO("mysql:host=$servername", $username, $password);
    // set the PDO error mode to exception
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    // sql query to create table
    $sql = "CREATE TABLE User (
            userid INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
            email VARCHAR(50) NOT NULL,
            password VARCHAR(50) NOT NULL,
            fullname VARCHAR(50)
        )";
    // use exec() because no results are returned
    $conn->exec($sql);
    echo "Table created successfully <br/>";
}
catch(PDOException $e)
{
    echo $sql . "<br/>" . $e->getMessage();
}

// disconnecting from MySQL server
$conn = null;

?>

将数据插入表格

一旦创建了表，下一步就是将数据输入表中。要将数据输入表中，我们必须遵循某些规则:

  • 如果要插入的值是字符串，我们必须用引号引起来。
  • 数值不能用引号括起来。
  • NULL不得用引号括起来。
  • 如果表格中的某一列是AUTO_INCREMENT，那么我们不需要在该列中插入数据，它会自动插入到表格中。

SQL 查询将是，

// sql query to insert data into table
$sql = "INSERT INTO User (email, password, fullname)
        VALUES ('john@studytonight.com', 'IKilledBoogieMan', 'John Wick')";

我们所要做的就是将变量$sql的值更改为上面的查询，剩下的代码将保持不变，就像创建表和创建数据库一样。

从表中删除数据

就像我们执行 insert SQL 语句一样，我们可以执行 delete SQL 语句从表中删除数据。

// sql query to delete data into table
$sql = "DELETE FROM User WHERE userid=1";

剩余的完整代码将保持不变。

从表中选择数据

从表中选择数据与其他操作有点不同。如果我们必须从表中选择多行数据，那么我们必须循环执行fetch()方法。

让我们看一个例子，我们必须从表用户返回所有数据。下面是 SQL 执行部分，考虑到我们已经设置了 MySQL 连接，在$conn连接对象中也有同样的连接。

// sql query to select data from User table
$stmt = $conn->prepare("SELECT userid, email, fullname FROM User"); 
// declaring an array to store the data
$data = array();
// execute the sql statement
$stmt->execute();
// loop to fetch all the rows
while($row = $stmt->fetch(PDO::FETCH_OBJ)) 
{
    $data[] = $row;
}

// close the connection
$conn = null;
// return the data
return $data;

结论

这不是 PHP 教程的结尾，而是开始，我们将不断添加更多的概念、示例、代码片段和教程，帮助您学习这种令人惊叹的脚本语言，敬请关注！

如有任何疑问或疑问，请在我们的 Q & A 论坛发布您的问题。

posted @ 2024-10-24 18:15  绝不原创的飞龙  阅读(3)  评论(0)  编辑  收藏  举报