Du traducteur: a publié un article pour vous , le plus souvent proposé aux candidats-développeurs lors d'entretiens. L'article sera utile avant tout aux programmeurs débutants.
Les entretiens dans les entreprises technologiques ont longtemps fait parler d’eux. Ce n'est pas surprenant : la réussite de l'entretien permet d'obtenir un bon emploi. Mais ce n’est pas si simple, car il faut souvent résoudre des problèmes complexes.
De plus, le plus souvent, la plupart de ces tâches ne sont pas liées au travail que le candidat effectuera, mais elles doivent néanmoins être résolues. Parfois, vous devez le faire sur le tableau, sans vérifier auprès de Google ou de toute autre source. Oui, la situation évolue progressivement et dans certaines entreprises, de tels entretiens sont refusés, mais de nombreux employeurs adhèrent encore à cette tradition. Cet article est consacré à l'analyse de tâches JavaScript typiques qui sont souvent utilisées comme tâches par les candidats.
Nous rappelons: pour tous les lecteurs de "Habr" - une remise de 10 000 roubles lors de l'inscription à n'importe quel cours Skillbox en utilisant le code promotionnel "Habr".
Skillbox vous recommande : Cours pratique .
L'essentiel est de préparer soigneusement votre entretien.
Oui, avant de commencer à décomposer les tâches, examinons quelques conseils généraux pour préparer un entretien.
L'essentiel est de se préparer à l'avance. Vérifiez dans quelle mesure vous vous souvenez des algorithmes et des structures de données et améliorez vos connaissances dans des domaines que vous ne connaissez pas très bien. Il existe de nombreuses plateformes en ligne pour vous aider à préparer les entretiens. Nous conseillons , , и .
Cela vaut la peine d'apprendre à prononcer la décision à voix haute. Il est conseillé d'informer les candidats de ce que vous faites, et de ne pas simplement écrire au tableau (ou de taper du code sur l'ordinateur, également en silence). Ainsi, si vous faites une erreur dans le code, mais que la solution est généralement correcte, vous pouvez augmenter vos chances de succès.
Le problème doit être compris avant de pouvoir commencer à le résoudre. Dans certains cas, vous pouvez comprendre superficiellement la tâche et ensuite vous engager sur la mauvaise voie. Il peut être utile de poser quelques questions de clarification à l'intervieweur.
Vous devez vous entraîner à écrire du code à la main, pas sur un PC. Il arrive que lors des entretiens, le candidat reçoive un marqueur et un tableau sans invites ni formatage automatique. Lorsque vous cherchez une solution, notez votre code sur une feuille de papier ou directement au tableau. Si vous gardez tout en tête, vous pouvez oublier quelque chose d’important.
Tâches de modèle en JavaScript
Vous connaissez probablement déjà certaines de ces tâches. Soit vous avez passé des entretiens au cours desquels vous deviez résoudre quelque chose de similaire, soit vous vous êtes entraînés tout en apprenant JavaScript. Eh bien, il est maintenant temps de les résoudre à nouveau, et avec une explication détaillée du processus.
Palindrome
Un palindrome est un mot, une phrase ou une séquence de caractères qui se lit exactement de la même manière, à la fois dans le sens habituel et dans le sens opposé. Par exemple, « Anna » est un palindrome, mais « table » et « John » ne le sont pas.
Mise en scène
Étant donné une chaîne ; vous devez écrire une fonction qui vous permet de renvoyer true si la chaîne est un palindrome, et false sinon. Dans ce cas, les espaces et les signes de ponctuation doivent être pris en compte.
palindrome('voiture de course') === vrai
palindrome('table') === faux
Analyser la tâche
L'idée principale ici est de retourner la chaîne à l'envers. Si la chaîne "inverse" est complètement identique à celle d'origine, alors nous obtenons un palindrome et la fonction devrait renvoyer vrai. Sinon, faux.
décision
Voici le code qui permet de résoudre le palindrome.
const palindrome = str => {
// turn the string to lowercase
str = str.toLowerCase()
// reverse input string and return the result of the
// comparisong
return str === str.split('').reverse().join('')
}La première étape consiste à convertir les caractères de la chaîne d’entrée en minuscules. C'est une garantie que le programme comparera exactement les caractères eux-mêmes, et non la casse ou autre chose.
La deuxième étape est l’inverse de la ligne. C'est simple à faire : vous devez le convertir en tableau en utilisant la méthode .split() (bibliothèque String). Ensuite, nous inversons le tableau en utilisant .reverse() (bibliothèque Array). La dernière étape consiste à convertir le tableau inversé en chaîne à l'aide de .join() (bibliothèque Array).
Il ne reste plus qu'à comparer la chaîne « inverse » avec la chaîne d'origine, en renvoyant le résultat vrai ou faux.
pétillant
L'un des entretiens d'embauche les plus populaires.
Mise en scène
Il est nécessaire d'écrire une fonction qui affiche sur la console les nombres de 1 à n, où n est un entier que la fonction prend en paramètre, avec les conditions suivantes :
- sortie fizz au lieu de multiples de 3 ;
- sortie buzz au lieu de multiples de 5 ;
- sortie fizzbuzz au lieu de multiples de 3 et 5.
Exemple
Fizzbuzz(5)
Résultat
// 1
// 2
// pétiller
// 4
// bourdonnement
Analyser la tâche
L'essentiel ici est la manière de trouver des multiples à l'aide de JavaScript. Il peut être implémenté à l'aide de l'opérateur module ou du reste -%, qui permet d'afficher le reste lors de la division de deux nombres. Si le reste est 0, cela signifie que le premier nombre est un multiple du second.
12% 5 // 2 -> 12 n'est pas un multiple de 5
12% 3 // 0 -> 12 est un multiple de 3
Ainsi, si on divise 12 par 5, on obtient 2 avec un reste de 2. Si on divise 12 par 3, alors on obtient 4 avec un reste de 0. Dans le premier cas, 12 n'est pas un multiple de 5, dans le Deuxièmement, 12 est un multiple de 3.
décision
La meilleure solution serait le code suivant :
const fizzBuzz = num => {
for(let i = 1; i <= num; i++) {
// check if the number is a multiple of 3 and 5
if(i % 3 === 0 && i % 5 === 0) {
console.log('fizzbuzz')
} // check if the number is a multiple of 3
else if(i % 3 === 0) {
console.log('fizz')
} // check if the number is a multiple of 5
else if(i % 5 === 0) {
console.log('buzz')
} else {
console.log(i)
}
}
}La fonction effectue les vérifications nécessaires à l'aide d'instructions conditionnelles et produit le résultat requis par l'utilisateur. Dans la tâche, il convient de prêter attention à l'ordre des instructions if...else : en commençant par une double condition (&&) et en terminant par le cas où plusieurs nombres n'ont pas pu être trouvés. En conséquence, nous couvrons toutes les options.
Anagramme
C'est le nom d'un mot qui contient toutes les lettres d'un autre mot dans le même numéro, mais dans un ordre différent.
Mise en scène
Nous devons écrire une fonction qui vérifie si deux chaînes sont des anagrammes, et la casse des lettres n'a pas d'importance. Seuls les caractères comptent ; les espaces ou les signes de ponctuation ne sont pas pris en compte.
anagramme('finder', 'Friend') --> vrai
anagramme('bonjour', 'bye') --> faux
Analyser la tâche
Ici, il est important de considérer qu'il est nécessaire de vérifier chaque lettre sur deux lignes de saisie et leur numéro dans chaque ligne.
chercheur -> f : 1 ami -> f : 1
je : 1 r : 1
n : 1 je : 1
d : 1 e : 1
e : 1 n : 1
r:1 ré:1
Pour stocker des données d'anagramme, vous devez choisir une structure telle qu'un littéral d'objet JavaScript. La clé dans ce cas est le caractère de la lettre, la valeur est le nombre de répétitions de celle-ci dans la ligne en cours.
Il existe également d'autres conditions :
- Vous devez vous assurer que la casse des lettres n'est pas prise en compte lors de la comparaison. Convertissez simplement les deux chaînes en minuscules ou en majuscules.
- Nous excluons tous les non-personnages de la comparaison. Il est préférable de travailler avec .
décision
// helper function that builds the
// object to store the data
const buildCharObject = str => {
const charObj = {}
for(let char of str.replace(/[^w]/g).toLowerCase()) {
// if the object has already a key value pair
// equal to the value being looped over,
// increase the value by 1, otherwise add
// the letter being looped over as key and 1 as its value
charObj[char] = charObj[char] + 1 || 1
}
return charObj
}
// main function
const anagram = (strA, strB) => {
// build the object that holds strA data
const aCharObject = buildCharObject(strA)
// build the object that holds strB data
const bCharObject = buildCharObject(strB)
// compare number of keys in the two objects
// (anagrams must have the same number of letters)
if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
return false
}
// if both objects have the same number of keys
// we can be sure that at least both strings
// have the same number of characters
// now we can compare the two objects to see if both
// have the same letters in the same amount
for(let char in aCharObject) {
if(aCharObject[char] !== bCharObject[char]) {
return false
}
}
// if both the above checks succeed,
// you have an anagram: return true
return true
}Attention à l'utilisation dans l'extrait ci-dessus. Cette méthode renvoie un tableau contenant les noms ou les clés dans le même ordre qu'ils apparaissent dans l'objet. Dans ce cas, le tableau ressemblera à ceci :
['f', 'i', 'n', 'd', 'e', 'r']
De cette façon, nous obtenons les propriétés de l'objet sans avoir à faire une grande boucle. Dans une tâche, vous pouvez utiliser cette méthode avec la propriété .length - pour vérifier si les deux chaînes ont le même nombre de caractères - c'est une caractéristique importante des anagrammes.
Recherche de voyelle
Une tâche assez simple qui revient souvent lors des entretiens.
Mise en scène
Vous devez écrire une fonction qui prend une chaîne comme argument et renvoie le nombre de voyelles que contient la chaîne.
Les voyelles sont "a", "e", "i", "o", "u".
Exemple:
findVowels('bonjour') // --> 2
findVowels('pourquoi') // --> 0
décision
Voici l'option la plus simple :
const findVowels = str => {
let count = 0
const vowels = ['a', 'e', 'i', 'o', 'u']
for(let char of str.toLowerCase()) {
if(vowels.includes(char)) {
count++
}
}
return count
}Il est important de faire attention à l’utilisation de la méthode .includes(). Il est disponible pour les chaînes et les tableaux. Il doit être utilisé pour savoir si un tableau contient une certaine valeur. Cette méthode renvoie true si le tableau contient la valeur spécifiée et false sinon.
Il existe également une solution plus courte au problème :
const findVowels = str => {
const matched = str.match(/[aeiou]/gi)
return matched ? matches.length : 0
}La méthode .match() est utilisée ici, ce qui permet de mettre en œuvre une recherche efficace. Si une expression régulière comme argument de méthode est trouvée dans la chaîne spécifiée, alors la valeur de retour est un tableau de caractères correspondants. Eh bien, s'il n'y a pas de correspondance, alors .match() renvoie null.
Fibonacci
Une tâche classique qui peut être accomplie lors d'entretiens à différents niveaux. Il convient de rappeler que la suite de Fibonacci est une série de nombres, où chacun des nombres suivants est la somme des deux précédents. Ainsi, les dix premiers nombres ressemblent à ceci : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
Mise en scène
Vous devez écrire une fonction qui renvoie le nième enregistrement dans une certaine séquence, et n est un nombre transmis comme argument à la fonction.
fibonacci(3) // --> 2
Cette tâche implique de parcourir le nombre de fois spécifié dans l'argument, en renvoyant la valeur à la position appropriée. Cette façon de poser le problème nécessite l’utilisation de boucles. Si vous utilisez plutôt la récursivité, l'intervieweur pourrait l'apprécier et vous donner quelques points supplémentaires.
décision
const fibonacci = num => {
// store the Fibonacci sequence you're going
// to generate inside an array and
// initialize the array with the first two
// numbers of the sequence
const result = [0, 1]
for(let i = 2; i <= num; i++) {
// push the sum of the two numbers
// preceding the position of i in the result array
// at the end of the result array
const prevNum1 = result[i - 1]
const prevNum2 = result[i - 2]
result.push(prevNum1 + prevNum2)
}
// return the last value in the result array
return result[num]
}Dans le tableau de résultats, les deux premiers nombres sont contenus dans une ligne car chaque entrée de la séquence est constituée de la somme des deux nombres précédents. Il n'y a pas deux nombres au tout début qui peuvent être pris pour obtenir le nombre suivant, donc la boucle ne peut pas les générer automatiquement. Mais comme nous le savons, les deux premiers nombres sont toujours 0 et 1. Par conséquent, vous pouvez initialiser le tableau de résultats manuellement.
Quant à la récursivité, tout est plus simple et plus compliqué à la fois :
const fibonacci = num => {
// if num is either 0 or 1 return num
if(num < 2) {
return num
}
// recursion here
return fibonacci(num - 1) + fibonacci(num - 2)
}Nous continuons d'appeler fibonacci(), en passant des nombres de plus en plus petits comme arguments. On s'arrête lorsque l'argument passé est 0 ou 1.
conclusion
Très probablement, vous avez déjà été confronté à l'une de ces tâches si vous passiez un entretien pour un emploi de développeur frontend ou JavaScript (surtout s'il s'agit d'un niveau junior). Mais si vous ne les avez pas rencontrés, ils pourraient s'avérer utiles à l'avenir - du moins pour le développement général.
Skillbox vous recommande :
- Cours appliqué en ligne .
- Cours en ligne .
- Cours pratique de l'année .
Source: habr.com