Résumé des points de connaissances de base de JavaScript

Les variables définies en dehors de la fonction doivent être des variables globales ; pour les variables définies dans la fonction, si var est déclarée, alors la variable est une variable locale. Si var n'est pas déclarée, alors la variable est une variable globale.

1. Variables globales et variables locales

JavaScript

var global = "Global";
test();
function test(){
  var local = "Local";
  document.writeln(global);
  document.writeln(local);
}
document.writeln(global);
document.writeln(local);

2. i) Cookies persistants, qui seront stockés sur le disque dur du client.

ii) Cookie de session : Il ne sera pas stocké sur le disque dur du client, mais sera placé dans la mémoire du processus du navigateur. À la fermeture du navigateur, le cookie de session sera détruit.

3. En JavaScript, une fonction est un objet

4. En JavaScript, il n'y a pas de notion de surcharge de méthode (fonction)

Objet fonction

Il existe un objet Function en JavaScript, et toutes les fonctions personnalisées sont de type objet Function. Tous les paramètres acceptés par l'objet Function sont de type chaîne, le dernier paramètre est le corps de la fonction à exécuter et les paramètres précédents sont les paramètres que la fonction doit réellement accepter.

6. Arguments d'objet implicites

En JavaScript, chaque fonction a des arguments d'objet implicites, qui représentent les paramètres réellement transmis à la fonction. arguments.length représente le nombre de paramètres réellement passés.

7. Nom de la fonction.longueur

Chaque objet fonction a un attribut de longueur, indiquant le nombre de paramètres que la fonction s'attend à accepter. C’est différent des arguments d’une fonction. arguments.length indique le nombre de paramètres réellement acceptés par la fonction.

8. Il existe cinq types de données primitifs en JavaScript

Indéfini, Null, Booléen, Nombre et Chaîne. (Remarque : en JavaScript, il n'y a pas de type de données char)

Le type de données Non défini n'a qu'une seule valeur : undéfini

Le type de données Null n'a qu'une seule valeur :

;

Il existe deux valeurs de type de données booléen : true et false

9. opérateur typeof

typeof est un opérateur unaire, suivi du nom de la variable, utilisé pour obtenir le type de données de la variable. Il y a 5 valeurs de retour : non défini, booléen, nombre, chaîne et objet.

10. En JavaScript, si une fonction ne déclare pas de valeur de retour, elle renverra undéfini11. La relation entre null et undéfini

undéfini est en fait dérivée de null. Par exemple :

La relation entre null et non défini

JavaScript

alert(undefined == null);
//浏览器返回true

Conversion de type forcée

en JavaScript. 3 types de transtypages : Boolean(value), Number(value), String(value).

12. Objet Object

En JavaScript, tous les objets sont hérités de l'objet Object.

Objet Object

JavaScript

var object = new Object();
for(var v in object){
  alert(v);
}

Dans le code ci-dessus, le navigateur n'imprime rien, ce qui ne veut pas dire que l'objet Object n'a aucune propriété. Le code suivant teste si les propriétés de l'objet Object peuvent être énumérées. Si false est renvoyé, cela signifie que les propriétés de l'objet Object ne peuvent pas être énumérées.

Les propriétés de l'objet Object ne peuvent pas être énumérées

JavaScript

alert(object.propertyIsEnumerable("prototype"));

Si le navigateur affiche une fausse boîte de dialogue, cela signifie que dans l'objet Object Les propriétés de ne sont pas énumérables.

Voyons ensuite si les propriétés de l'objet fenêtre peuvent être énumérées

Les propriétés de l'objet fenêtre peuvent être énumérées

JavaScript

for (var v in window) {
  console.log(v);
}

Dans le navigateur Chrome, nous verrons de nombreuses propriétés imprimées dans la console de débogage du navigateur, indiquant que les propriétés de l'objet fenêtre peuvent être énumérées.

13. En JavaScript, vous pouvez ajouter ou supprimer dynamiquement des attributs d'objet

Ajouter/supprimer dynamiquement des attributs d'objet

JavaScript

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);

14. La manière la plus courante de définir des objets en JavaScript

La manière la plus courante de définir des objets

JavaScript

var object = {
  username:"zhangsan",
  password:12345
};
alert(object.username);
alert(object.password);

15. Array

Définition du tableau

JavaScript

//方法一
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);

Appeler la méthode array sort(), le navigateur imprime 1, 25, 4, ce qui n'est pas le résultat attendu.

Pour la méthode de tri du tableau JavaScript, elle convertira d'abord le contenu à trier en chaîne (appelez la méthode toString()), et triera selon l'ordre de la chaîne.

La manière suivante peut obtenir les résultats attendus (triés par taille de tableau) :

Tri de tableau

JavaScript

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);

Nous utilisons ensuite des fonctions anonymes pour mettre en œuvre :

Tri de fonctions anonymes

JavaScript

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);

16. 5 de définition d'objets en JavaScript A manière (il n'y a pas de concept de classe en JavaScript, seulement des objets) i) Développer ses propriétés et méthodes en fonction des objets existants

Développer ses propriétés et méthodes en fonction des objets existants

JavaScript

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

Le moyen le plus simple, peu pratique à utiliser et adapté au besoin temporaire d'un objet.

ii) Créer des objets en mode usine

Méthode Factory sans paramètres :

JavaScript

//工厂方法
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方法

Avec paramètres Méthode Factory :

JavaScript

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();

Inconvénients des deux méthodes d'usine ci-dessus sans paramètres et avec paramètres :

Chaque fois qu'un objet est créé, Création une méthode get dans la mémoire gaspille de la mémoire et affecte les performances. Notre attente est de créer deux objets différents, leurs propriétés sont différentes, mais les méthodes sont partagées. Nous devons donc ensuite améliorer la méthode de fabrique createObject.

Méthode d'usine améliorée :

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中文网！