Variablen, die außerhalb der Funktion definiert sind, müssen globale Variablen sein. Wenn var deklariert ist, ist die Variable eine lokale Variable. Wenn var nicht deklariert ist, ist die Variable eine globale Variable.
1. Globale Variablen und lokale Variablen
JavaScript
var global = "Global";
test();
function test(){
var local = "Local";
document.writeln(global);
document.writeln(local);
}
document.writeln(global);
document.writeln(local);2. Arten von Cookies
i) Permanente Cookies, die auf der Festplatte des Kunden gespeichert werden.
ii) Sitzungscookie: Es wird nicht auf der Festplatte des Clients gespeichert, sondern im Speicher des Browserprozesses abgelegt. Beim Schließen des Browsers wird das Sitzungscookie gelöscht.
3. In JavaScript ist eine Funktion ein Objekt
4. In JavaScript gibt es kein Konzept der Methoden-(Funktions-)Überladung
Funktionsobjekt
Es gibt ein Funktionsobjekt in JavaScript und alle benutzerdefinierten Funktionen sind vom Funktionsobjekttyp. Alle vom Funktionsobjekt akzeptierten Parameter sind vom Typ String, der letzte Parameter ist der auszuführende Funktionskörper und die vorherigen Parameter sind die Parameter, die die Funktion wirklich akzeptieren muss.
6. Implizite Objektargumente
In JavaScript verfügt jede Funktion über implizite Objektargumente, die die tatsächlich an die Funktion übergebenen Parameter darstellen. arguments.length stellt die Anzahl der tatsächlich übergebenen Parameter dar.
7. Funktionsname.länge
Jedes Funktionsobjekt verfügt über ein Längenattribut, das die Anzahl der Parameter angibt, die die Funktion voraussichtlich akzeptieren wird. Es unterscheidet sich von den Argumenten einer Funktion. arguments.length gibt die Anzahl der tatsächlich von der Funktion akzeptierten Parameter an.
8. Es gibt fünf primitive Datentypen in JavaScript
Undefiniert, Null, Boolean, Zahl und Zeichenfolge. (Hinweis: In JavaScript gibt es keinen char-Datentyp)
Der Undefinierte Datentyp hat nur einen Wert: undefiniert;
Der Null-Datentyp hat nur einen Wert: null;
Es gibt zwei Werte des booleschen Datentyps: true und false; 9 typeof Operator typeof ist ein unärer Operator, gefolgt vom Namen der Variablen Ermitteln Sie den Datentyp der Variablen. Es gibt 5 Rückgabewerte: undefiniert, boolesch, Zahl, Zeichenfolge und Objekt. 10. Wenn eine Funktion in JavaScript keinen Rückgabewert deklariert, gibt sie undefiniert zurück.11 Die Beziehung zwischen null und undefiniert undefiniert wird tatsächlich von null abgeleitet. Zum Beispiel: Die Beziehung zwischen null und undefiniertJavaScriptalert(undefined == null); //浏览器返回true
var object = new Object();
for(var v in object){
alert(v);
}alert(object.propertyIsEnumerable("prototype"));for (var v in window) {
console.log(v);
}var object = new Object(); alert(object.username);//undefined object.username = "zhangsan"; alert(object.username);//zhangsan object["password"] = "123"; alert(object.password);//123 delete object.username;//此时，username属性已经被删除 alert(object.username);
var object = {
username:"zhangsan",
password:12345
};
alert(object.username);
alert(object.password);//方法一 var array = new Array(); array.push(1); array.push(2); array.push(3); alert(array.length); //方法二（推荐） var array = [1,25,4]; array.sort(); alert(array);
function compare(num1,num2) {
var temp1 = parseInt(num1);
var temp2 = parseInt(num2);
if (temp1 < temp2) {
return -1;
} else if (temp1 == temp2) {
return 0;
} else {
return 1;
}
}
var array = [1,25,3];
array.sort(compare);
alert(array);var array = [1,25,3];
array.sort(function(num1,num2){
var temp1 = parseInt(num1);
var temp2 = parseInt(num2);
if (temp1 < temp2) {
return -1;
} else if(temp1 == temp2) {
return 0;
} else {
return 1;
}
});
alert(array);
var object = new Object();
//添加name属性
object.name = "zhangsan";
//添加sayName方法
object.sayName = function(name) {
this.name = name;
alert(this.name);
};
object.sayName("kyle");//调用sayName方法，name属性被修改为kyle，浏览器将打印kyle//工厂方法
function createObject() {
var object = new Object();//创建一个对象
object.name = "zhangsan";//为该对象添加一个name属性
object.password = "123";//为该对象添加一个password属性
object.get = function() {//为该对象添加一个get方法
alert(this.name+","+this.password);
};
return object;//返回该对象
}
var object1 = createObject();//调用createObject工厂方法创建对象object1
var object2 = createObject();//调用createObject工厂方法创建对象object2
object1.get();//调用对象get方法
object2.get();//调用对象get方法function createObject(name,password) {
var object = new Object();
object.name = name;
object.password = password;
object.get = function() {
alert(this.name+","+this.password);
};
return object;
}
var object1 = createObject("zhangsan","123");
var object2 = createObject("lisi","456");
object1.get();
object2.get();JavaScript
function get(){
alert(this.name+","+this.password);
}
function createObject(name,password) {
var object = new Object();
object.name = name;
object.password = password;
object.get = get;
return object;
}
var object1 = createObject("zhangsan","123");
var object2 = createObject("lisi","456");
object1.get();
object2.get();将get方法定义在createObject函数外面，这样每创建一个对象，get方法都是共用的。让一个函数对象被多个对象所共享，而不是每一个对象都拥有一个函数对象。
iii）构造函数方式创建对象
不带参数的构造函数：
JavaScript
function Person(){
//在执行第一行代码前，js引擎会为我们生成一个对象
this.name = "zhangsan";
this.password = "123";
this.getInfo = function() {
alert(this.name+","+this.password);
};
//此处有一个隐含的return语句，用于将之前生成的对象返回（也是跟工厂方式不一样的地方）
}
var p1 = new Person();
p1.getInfo();带参数的构造函数
JavaScript
function Person(name,password) {
this.name = name;
this.password = password;
this.getInfo = function() {
alert(this.name+","+this.password);
};
}
var p1 = new Person("zhangsan","123");
var p2 = new Person("lisi","456");
p1.getInfo();
p2.getInfo();iv）原型（prototype）方式创建对象
prototype是Object对象里面的一个属性
prototype
JavaScript
function Person(){
}
Person.prototype.name = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function() {
alert(this.name+","+this.password);
};
var p1 = new Person();
var p2 = new Person();
p1.name = "kyle";//对象生成之后再去改变属性
p1.getInfo();
p2.getInfo();单纯地使用原型方式有两个问题：第一，你无法在构造函数中为属性赋初值，只能在对象生成之后再去改变属性值。
prototype
JavaScript
function Person(){
}
Person.prototype.name = new Array();
Person.prototype.password = "123";
Person.prototype.getInfo = function() {
alert(this.name+","+this.password);
};
var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p1.name.push("lisi");
p1.password = "456";
p1.getInfo();
p2.getInfo()浏览器将会打印：zhangsan，lisi，456 和 zhangsan，lisi，123.
如果使用原型方式创建对象，那么生成的所有对象会共享原型中的属性，这样一个对象改变了该属性也会反应到其他对象当中。所以单纯地使用原型方式是不行的，还需要结合其他方式。接下来我们会继续介绍。
使用原型+构造函数方式来定义对象
JavaScript
function Person() {
this.name = new Array();
this.password = "123";
}
Person.prototype.getInfo = function() {
alert(this.name+","+this.password);
};
var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p2.name.push("lisi");
p1.getInfo();
p2.getInfo();使用原型+构造函数方式来定义对象，对象之间的属性互不干扰，各个对象间共享同一个方法，这是一种比较好的方式。
v）动态原型方式
JavaScript
function Person(){
this.name = "zhangsan";
this.password = "123";
if(typeof Person.flag == "undefined"){
alert("invoked");
Person.prototype.getInfo = function(){
alert(this.name + "," + this.password);
}
Person.flag = true;
}
}
var p1 = new Person();
var p2 = new Person();
p1.getInfo();
p2.getInfo();在动态原型方式中，在构造函数中通过标志量让所有对象共享一个方法，而每个对象拥有自己的属性。上面代码在第一次创建对象时，首先通过一个判断语句，看flag属性是否已经定义，若没有定义，则通过原型方式添加getInfo方法，然后将flag设置为true，那么当第二次创建对象时，if语句判断为假，跳过执行。这样就达到了我们所期望的结果，创建的对象属性是互不干扰的，而对象的方法是共享的。
17、JavaScript中对象的继承（5种方式）
第一种方式:对象冒充
冒充对象继承
JavaScript
//父类
function Parent(username) {
this.username = username;
this.sayHello = function() {
alert(this.username);
};
}
//子类
function Child(username,password){
//下面三行代码是最关键的
this.method = Parent;
this.method(username);
delete this.method;
this.password = password;
this.sayWorld = function() {
alert(this.password);
};
}
var p = new Parent("zhangsan");
var c = new Child("lisi","123");
p.sayHello();
c.sayHello();
c.sayWorld()第二种方式:call()
继承的第二种实现方式，call方法方式，call方法是Function对象中定义的方法，因此我们定义的每个函数都拥有该方法。call方法的第一个参数会被传递给函数中的this，从第2个参数开始，逐一赋给函数中的参数。
call 继承父类
JavaScript
function test(str) {
alert(this.name+","+str);
}
var object = new Object();
object.name = "zhangsan";
//test.call相当于调用了test函数
test.call(object,"html5war");//将object赋给了this接下来我们用call方式实现对象的继承
JavaScript
//父类
function Parent(username){
this.username = username;
this.sayHello = function() {
alert(this.username);
};
}
//子类
function Child(username,password) {
Parent.call(this,username);
this.password = password;
this.sayWorld = function() {
alert(this.password);
};
}
var p = new Parent("zhangsan");
var c = new Child("lisi","123");
p.sayHello();
c.sayHello();
c.sayWorld();第三种方式:apply()
apply 继承父类
JavaScript
//父类
function Parent(username){
this.username = username;
this.sayHello = function(){
alert(this.username);
};
}
//子类
function Child(username,password){
Parent.apply(this,new Array(username));
this.password = password;
this.sayWorld = function(){
alert(this.password);
};
}
var p = new Parent("zhangsan");
var c = new Child("lisi","123");
p.sayHello();
c.sayHello();
c.sayWorld();apply方法与call方法很类似，apply方法也是定义在Function对象中的方法，因此我们定义的每个函数都拥有该方法。
apply方法与call方法有一个区别：Parent.apply(this,new Array(username));传递的第二个参数为一个数组，而call方法传递的是一些离散的数据参数。这两个方法并不能说谁好谁坏，要看具体使用场景。
第四种方式:原型链方式（无法给构造函数传递参数）
原型链继承
JavaScript
function Parent() {
}
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function() {
alert(this.hello);
};
function Child() {
}
Child.prototype = new Parent();
Child.prototype.world = "world";
Child.prototype.sayWorld = function() {
alert(this.world);
};
var c = new Child();
c.sayHello();
c.sayWorld();单纯使用原型链方式的缺点：没有办法传递参数，只有等对象创建完之后再去修改。我们接下来结合其它的方式解决这个问题。
第五种方式:混合方式(推荐)
使用混合方式实现对象的继承
JavaScript
function Parent(hello) {
this.hello = hello;
}
Parent.prototype.sayHello = function() {
alert(this.hello);
}
function Child(hello,world) {
Parent.call(this,hello);
this.world = world;
}
Child.prototype = new Parent();
Child.prototype.sayWorld = function() {
alert(this.world);
}
var c = new Child("hello","world");
c.sayHello();
c.sayWorld();以上这篇JavaScript基础知识点归纳(推荐)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持PHP中文网。
更多JavaScript基础知识点归纳相关文章请关注PHP中文网！
Mul-Anweisungsverwendung
Datei im DAT-Format
So passen Sie die Helligkeit des Computerbildschirms an
Wie man die Fans von Douyin schnell und effektiv steigert
So schließen Sie die App-Ressourcenbibliothek
Einführung in die Lightning-Schnittstelle
Vue verweist auf JS-Dateien
Häufig verwendete Permutations- und Kombinationsformeln
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
