Résumé des points de connaissances JavaScript couramment utilisés dans le développement d'entretiens

No1. Syntaxe et type

1. Déclaration et définition

Type de variable : var, définir la variable let ; définir les variables locales de la portée du bloc (portée) const, définit les constantes en lecture seule.

Format variable : commence par une lettre, un trait de soulignement "_" ou un symbole $, sensible à la casse.

Affectation de variable : une variable déclarée mais non affectée a une valeur indéfinie lorsqu'elle est utilisée. Si une variable non déclarée est utilisée directement, une exception sera levée.

Variable non affectée pour le calcul : le résultat est NaN. Par exemple :

var x, y = 1;
console.log(x + y); //结果为NaN，因为x没有赋值。

　2. Portée

　 Portée des variables : avant ES6, il n'y avait pas de portée de déclaration de bloc et les variables agissaient dans des blocs fonctionnels ou globalement. Comme le montre le code suivant, l'entrée x est 5.

if (true) {
var x = 5;
}
console.log(x); // 5

Portée des variables ES6 : ES6 prend en charge la portée des blocs, mais vous devez utiliser let pour déclarer les variables. La sortie de code suivante entraîne la levée d’une exception.

f (true) {
let y = 5;
}
console.log(y); // ReferenceError: y is not defined1234

Variable flottante : Dans une méthode ou un code global, lorsque nous utilisons la variable avant que la variable ne soit déclarée, une exception n'est pas levée, mais undéfini est renvoyé. En effet, JavaScript fait automatiquement flotter la déclaration de variable au début de la fonction ou du global. Par exemple, le code suivant :

/**
* 全局变量上浮
*/
console.log(x === undefined); // logs "true"
var x = 3;

/**
* 方法变量上浮
*/
var myvar = "my value";
// 打印变量myvar结果为：undefined
(function() {
console.log(myvar); // undefined
var myvar = "local value";
})();

Le code ci-dessus est équivalent au code suivant :

/**
* 全局变量上浮
*/
var x;
console.log(x === undefined); // logs "true"
x = 3;

/**
* 方法变量上浮
*/
var myvar = "my value";
(function() {
var myvar;
console.log(myvar); // undefined
myvar = "local value";
})();

Variables globales : Dans la page, l'objet global est window, donc on accéder aux variables globales Disponible via window.variable. Par exemple :

version = "1.0.0";
console.log(window.version); //输出1.0.0

No2. Structure et type des données

1. Type de données

6 types de base : Booléen (vrai ou faux) , null (js est sensible à la casse, différent de Null et NULL), undefined, Number, String, Symbol (marqué comme unique et immuable)

Un type d'objet : object.

Objet et fonction : les objets servent de conteneurs de valeurs et les fonctions servent de procédures d'application.

　2. Conversion de données

　 Fonction : Les méthodes parseInt et parseFloat peuvent être utilisées pour convertir des chaînes en nombres.

parseInt : La signature de la fonction est parseInt(string, radix), radix est un nombre de 2 à 36 représentant la base numérique, comme décimale ou hexadécimale. Le résultat renvoyé est un entier ou NaN. Par exemple, les résultats de sortie ci-dessous sont tous 15.

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10);
parseInt(15.99, 10);
arseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);

ParseFloat : La signature de la fonction est parseFloat(string) et le résultat renvoyé est un nombre ou NaN. Par exemple :

parseFloat("3.14"); //返回数字
parseFloat("314e-2"); //返回数字
parseFloat("more non-digit characters"); //返回NaN

3. Textualisation du type de données

Type de textualisation : Tableau, Booléen, Virgule flottante, entiers, Objet, RegExp, Chaîne.

Virgules supplémentaires dans le tableau : ["Lion", , "Angel"], la longueur est de 3 et la valeur de [1] est indéfendable. ['home', , 'school', ], la dernière virgule est omise donc la longueur est 3. [ , 'maison', , 'école'], la longueur est 4. ['maison', , 'école', , ], la longueur est 4.

entier entier : l'entier peut être exprimé sous forme décimale, octale, hexadécimale, binaire. Par exemple :

0, 117 and -345 //十进制
015, 0001 and -0o77 //八进制
0x1123, 0x00111 and -0xF1A7 //十六进制
0b11, 0b0011 and -0b11 1234 //二进制

Nombre à virgule flottante : [( |-)][digits][.digits][(E|e)[( |-)]digits]. Par exemple :

3.1415926，-.123456789，-3.1E+12（3100000000000），.1e-23（1e-24）

Objet : La valeur d'attribut de l'objet peut être obtenue via ".property" ou "[property name]". Par exemple :

var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

Attributs d'objet : le nom de l'attribut peut être n'importe quelle chaîne ou une chaîne vide. Les noms non valides peuvent être placés entre guillemets. Les noms complexes ne peuvent pas être obtenus via ., mais peuvent être obtenus via []. Par exemple :

var unusualPropertyNames = {
"": "An empty string",
"!": "Bang!"
}
console.log(unusualPropertyNames.""); // SyntaxError: Unexpected string
console.log(unusualPropertyNames[""]); // An empty string
console.log(unusualPropertyNames.!); // SyntaxError: Unexpected token !
console.log(unusualPropertyNames["!"]); // Bang!

Caractères d'échappement : la chaîne de sortie suivante contient des guillemets doubles car le symbole d'échappement """ est utilisé.

var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
console.log(quote);
//输出：He read "The Cremation of Sam McGee" by R.W. Service.1。

Méthode de retour à la ligne : ajoutez "" directement à la fin de la ligne de chaîne, comme indiqué dans le code suivant :

var str = "this string \
is broken \
across multiple\
lines."
console.log(str); // this string is broken across multiplelines.

No3. Flux de contrôle et gestion des erreurs

　1. 🎜> Fonction : les expressions de bloc sont généralement utilisées pour le flux de contrôle, comme if, for, while. Dans le code suivant, {x;} est une déclaration de bloc avant ES6. Portée : Avant ES6, les variables étaient définies. dans le bloc étaient en fait inclus dans la méthode ou globale, et l'influence des variables dépassait la portée du bloc. Par exemple, le résultat final de l'exécution du code suivant est 2, car les variables déclarées dans le bloc agissent sur lui. Méthode.

Il y a une portée de bloc après ES6 : Dans ES6, nous pouvons modifier la déclaration de portée de bloc var en let, de sorte que la variable ne couvre que la portée du bloc 2. Jugement logique

while (x < 10) {
x++;
}

Valeurs spéciales jugées fausses : false, undefined, null, 0, NaN, ""

var x = 1;
{
var x = 2;
}
console.log(x); // outputs 2

N°4. Gestion des exceptions

Syntaxe d'exception de lancement : l'exception de lancement peut être de n'importe quel type, comme indiqué ci-dessous :

var b = new Boolean(false);
if (b) // 返回true
if (b == true) // 返回false

Mot clé : Utiliser. Syntaxe try{}catch(e){}finally{}, similaire à la syntaxe C#

enfin valeur de retour : if finaly Après avoir ajouté l'instruction return, peu importe ce que renvoie l'intégralité de try.catch, la valeur de retour. est le retour final, comme indiqué ci-dessous :

function f() {
    try {
        console.log(0);
        throw "bogus";
    } catch(e) {
        console.log(1);
        return true; // 返回语句被暂停，直到finally执行完成
        console.log(2); // 不会执行的代码
    } finally {
        console.log(3);
        return false; //覆盖try.catch的返回
        console.log(4); //不会执行的代码
    }
    // "return false" is executed now 
    console.log(5); // not reachable
}
f(); // 输出 0, 1, 3; 返回 false

　　finally吞并异常：如果finally有return并且catch中有throw异常。throw的异常不会被捕获，因为已经被finally的return覆盖了。如下代码所示：

function f() {
    try {
        throw "bogus";
    } catch(e) {
        console.log('caught inner "bogus"');
        throw e; // throw语句被暂停，直到finally执行完成
    } finally {
        return false; // 覆盖try.catch中的throw语句
    }
    // 已经执行了"return false"
}

try {
    f();
} catch(e) {
    //这里不会被执行，因为catch中的throw已经被finally中的return语句覆盖了
    console.log('caught outer "bogus"');
}
// 输出
// caught inner "bogus"

　　系统Error对象：我们可以直接使用Error{name, message}对象，例如：throw (new Error('The message'));

 以上就是面试开发常用的 JavaScript 知识点总结的内容，更多相关内容请关注PHP中文网（m.sbmmt.com）！