Résumé des points de connaissances JavaScript courants pour le développement d'entretiens

No1. Syntaxe et type

1. Déclaration et définition

Type de variable : var, définit les variables let, définit les variables locales du domaine de bloc (portée) ; const , définit des 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. Une exception sera levée si une variable non déclarée est utilisée directement.
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 (cas js) Sensible, qui est différent de Null et NULL), non défini, Nombre, Chaîne, Symbole (marqué comme unique et immuable)
Un type d'objet : objet.
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.
Situation de virgule supplémentaire dans Array : ["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 : les entiers peuvent être exprimés en décimal, octal, hexadécimal et 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'acquisition 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 nouvelle ligne de chaîne : 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. Bloquer l'expression

rôle : Bloquer les expressions. sont généralement utilisés pour le flux de contrôle, comme if, for, while Dans le code suivant, {x;} est une déclaration de bloc

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

Il n'y a pas de portée de bloc avant ES6. le bloc est en fait inclus dans la méthode ou global, et l'influence de la variable dépasse 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 la 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

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

Jugement logique

<🎜. >Valeurs spéciales jugées fausses : false, undefined, null, 0, NaN, ""

Types booléens simples et booléens objet : Il y a une différence entre faux et vrai de type booléen simple et faux et vrai d'objet booléen type. Les deux ne sont pas égaux. Comme dans l'exemple suivant :

No4. Gestion des exceptions

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

1. Type d'exception

Syntaxe de lancement d'exception : Le lancement d'une exception peut être effectué. être N'importe quel type. Comme indiqué ci-dessous

Exception personnalisée :

throw "Error2"; // 字符串类型
throw 42; // 数字类型
throw true; // 布尔类型
throw {toString: function() { return "I'm an object!"; } }; //对象类型

2 Syntaxe

// 创建一个对象类型UserException
function UserException(message) {
this.message = message;
this.name = "UserException";
}

//重写toString方法，在抛出异常时能直接获取有用信息
UserException.prototype.toString = function() {
return this.name + ': "' + this.message + '"';
}

// 创建一个对象实体并抛出它
throw new UserException("Value too high");

mot-clé : utilisez try{}catch(e){ }. La syntaxe enfin{} est similaire à la syntaxe C#.

finally return value : Si final ajoute une instruction return, peu importe ce que renvoie l'intégralité de try.catch, la valeur de retour est finalement la suivante :

Exception finalement engloutissante : si final a un retour et qu'il y a une exception de lancement dans le catch, l'exception de lancement ne sera pas interceptée car elle a été couverte par le retour final :

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

Système Objet Error : nous pouvons utiliser directement l'objet Error{name, message}, par exemple : throw (new Error('The message'));

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"

Ce qui précède sont des points de connaissances JavaScript courants sur le développement d'entretiens. Résumé du contenu , veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe

!