info/Web-Dev-For-Beginners
1
0
Fork 0
mirror of https://github.com/microsoft/Web-Dev-For-Beginners.git synced 2025-08-30 01:50:19 +02:00
Code Issues Projects Releases Wiki Activity

folder names

Browse Source
This commit is contained in:
Jen Looper
2020-11-09 22:51:04 -05:00
parent 33e5d5f777
commit 1d81829ac1
367 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
2-js-basics/3-making-decisions/.github/post-lecture-quiz.md vendored Normal file
View File

@@ -0,0 +1,12 @@
*Complete this quiz by checking one answer per question.*
1. What would the following code return: `'1' == 1`
- [ ] true
- [ ] false
2. Choose the correct operator to express _or_ logic
- [ ] `a | b`
- [ ] `a || b`
- [ ] `a or b`

13
2-js-basics/3-making-decisions/.github/pre-lecture-quiz.md vendored Normal file
View File

@@ -0,0 +1,13 @@
*Complete this quiz in class*
1. The following operator `==` is called
- [ ] Equality
- [ ] Strict equality
- [ ] Assignment
2. A comparison in JavaScript returns what type?
- [ ] boolean
- [ ] null
- [ ] string

166
2-js-basics/3-making-decisions/README.md Normal file
View File

@@ -0,0 +1,166 @@
# JavaScript Basics: Making Decisions
[![Making Decisions](https://img.youtube.com/vi/SxTp8j-fMMY/0.jpg)](https://youtube.com/watch?v=SxTp8j-fMMY "Making Decisions")
## [Pre-lecture quiz](.github/pre-lecture-quiz.md)
Making decisions and controlling the order in which your code runs makes your code reusable and robust. This section covers the syntax for controlling data flow in JavaScript and its significance when used with Boolean data types
## A Brief Recap on Booleans
Booleans can be only two values: `true` or `false`. Booleans help make decisions on which lines of code should run when certain conditions are met.
Set your boolean to be true or false like this:
`let myTrueBool = true`
`let myFalseBool = false`
✅ Booleans are named after the English mathematician, philosopher and logician George Boole (1815–1864).
## Comparison Operators and Booleans
Operators are used to evaluate conditions by making comparisons that will create a Boolean value. The following is a list of operators that are frequently used.
| Symbol | Description | Example |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
| `<` | **Greater than**: Compares two values and returns the `true` Boolean data type if the value on the right side is larger than the left | `5 < 6 // true` |
| `<=` | **Greater than or equal to**: Compares two values and returns the `true` Boolean data type if the value on the right side is larger than or equal to the left | `5 <= 6 // true` |
| `>` | **Less than**: Compares two values and returns the `true` Boolean data type if the value on the left side is larger than the right | `5 > 6 // false` |
| `=>` | **Less than or equal to**: Compares two values and returns the `true` Boolean data type if the value on the left side is larger than or equal to the right | `5 => 6 // false` |
| `===` | **Strict equality**: Compares two values and returns the `true` Boolean data type if values on the right and left are equal AND are the same data type. | `5 === 6 // false` |
| `!==` | **Inequality**: Compares two values and returns the opposite Boolean value of what a strict equality operator would return | `5 !== 6 // true` |
✅ Check your knowledge by writing some comparisons in your browser's console. Does any returned data surprise you?
## If Statement
The if statement will run code in between its blocks if the condition is true.
```javascript
if (condition){
//Condition was true. Code in this block will run.
}
```
Logical operators are often used to form the condition.
```javascript
let currentMoney;
let laptopPrice;
if (currentMoney >= laptopPrice){
//Condition was true. Code in this block will run.
console.log("Getting a new laptop!");
}
```
## IF..Else Statement
The `else` statement will run the code in between its blocks when the condition is false. It's optional with an `if` statement.
```javascript
let currentMoney;
let laptopPrice;
if (currentMoney >= laptopPrice){
//Condition was true. Code in this block will run.
console.log("Getting a new laptop!");
}
else{
//Condition was true. Code in this block will run.
console.log("Can't afford a new laptop, yet!");
}
```
✅ Test your understanding of this code and the following code by running it in a browser console. Change the values of the currentMoney and laptopPrice variables to change the returned `console.log()`.
## Logical Operators and Booleans
Decisions might require more than one comparison, and can be strung together with logical operators to produce a Boolean value.
| Symbol | Description | Example |
| ------ | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| `&&` | **Logical AND**: Compares two Boolean expressions. Returns true **only** if both sides are true | `(5 > 6) && (5 < 6 ) //One side is false, other is true. Returns false` |
| `||` | **Logical OR**: Compares two Boolean expressions. Returns true if at least one side is true | `(5 > 6) || (5 < 6) //One side is false, other is true. Returns true` |
| `!` | **Logical NOT**: Returns the opposite value of a Boolean expression | `!(5 > 6) // 5 is not greater than 6, but "!" will return true` |
## Conditions and Decisions with Logical Operators
Logical operators can be used to form conditions in if..else statements.
```javascript
let currentMoney;
let laptopPrice;
let laptopDiscountPrice = laptopPrice - (laptopPrice * .20) //Laptop price at 20 percent off
if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice){
//Condition was true. Code in this block will run.
console.log("Getting a new laptop!");
}
else {
//Condition was true. Code in this block will run.
console.log("Can't afford a new laptop, yet!");
}
```
### Negation operator
You've seen so far how if you can use an `if...else` statement to create conditional logic. Anything that goes into an `if` needs to evaluate to true/false. By using the `!` operator you can _negate_ the expression. It would look like so:
```javascript
if (!condition) {
// runs if condition is false
} else {
// runs if condition is true
}
```
### Ternary expressions
`if...else` isn't the only way to express decision logic. You can also use something called a ternary operator. The syntax for it looks like this:
```javascript
let variable = condition ? <return this if true> : <return this if false>`
```
Below is a more tangible example:
```javascript
let firstNumber = 20;
let secondNumber = 10
let biggestNumber = firstNumber > secondNumber ? firstNumber: secondNumber;
```
✅ Take a minute to read this code a few times. Do you understand how these operators are working?
The above states that
- if `firstNumber` is larger than `secondNumber`
- then assign `firstNumber` to `biggestNumber`
- else assign `secondNumber`.
The ternary expression is just a compact way of writing the code below:
```javascript
let biggestNumber;
if (firstNumber > secondNumber) {
biggestNumber = firstNumber;
} else {
biggestNumber = secondNumber;
}
```
---
## 🚀 Challenge
Create a program that is written first with logical operators, and then rewrite it using a ternary expression. What's your preferred syntax?
## [Post-lecture quiz](.github/post-lecture-quiz.md)
## Review & Self Study
Read more about the many operators available to the user [on MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators).
## Assignment
[Operators](assignment.md)

40
2-js-basics/3-making-decisions/assignment.md Normal file
View File

@@ -0,0 +1,40 @@
# Operators
## Instructions
Play around with operators. Here's a suggestion for a program you can implement:
You have a set of students from two different grading systems.
### First grading system
One grading system is defined as grades being from 1-5 where 3 and above means you pass the course.
### Second grading system
The other grade system has the following grades `A, A-, B, B-, C, C-` where `A` is the top grade and `C` is the lowest passing grade.
### The task
Given the following array `allStudents` representing all students and their grades, construct a new array `studentsWhoPass` containing all students who pass.
> TIP, use a for-loop and if...else and comparison operators:
```javascript
let allStudents = [
'A',
'B-'
1,
4
5,
2
]
let studentsWhoPass = [];
```
## Rubric
| Criteria | Exemplary | Adequate | Needs Improvement |
| -------- | ------------------------------ | ----------------------------- | ------------------------------- |
| | Complete solution is presented | Partial solution is presented | Solution with bugs is presented |

169
2-js-basics/3-making-decisions/translations/README.de.md Normal file
View File

@@ -0,0 +1,169 @@
# JavaScript-Grundlagen: Entscheidungen treffen
[![Entscheidungen treffen](https://img.youtube.com/vi/SxTp8j-fMMY/0.jpg)](https://youtube.com/watch?v=SxTp8j-fMMY "Entscheidungen treffen")
## [Pre-Lecture Quiz](.github/pre-lecture-quiz.md)
Wenn Sie Entscheidungen treffen und die Reihenfolge steuern, in der Ihr Code ausgeführt wird, ist Ihr Code wiederverwendbar und robust. Dieser Abschnitt behandelt die Syntax zur Steuerung des Datenflusses in JavaScript und ihre Bedeutung bei Verwendung mit booleschen Datentypen.
## Eine kurze Zusammenfassung der Booleschen Werte
Boolesche Werte können nur zwei Werte sein: `true` oder `false`. Boolesche Werte helfen bei der Entscheidung, welche Codezeilen ausgeführt werden sollen, wenn bestimmte Bedingungen erfüllt sind.
Stellen Sie Ihren Booleschen Wert wie folgt auf wahr oder falsch ein:
`let myTrueBool = true`
`let myFalseBool = false`
✅ Boolesche sind nach dem englischen Mathematiker, Philosophen und Logiker George Boole (1815–1864) benannt.
## Vergleichsoperatoren und Boolesche Werte
Operatoren werden verwendet, um Bedingungen durch Vergleiche zu bewerten, die einen Booleschen Wert erzeugen. Das Folgende ist eine Liste von Operatoren, die häufig verwendet werden.
| Symbol | Beschreibung | Beispiel |
| ------ | -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------- | ------------------ |
| `<` | **Größer als**: Vergleicht zwei Werte und gibt den booleschen Datentyp "true" zurück, wenn der Wert auf der rechten Seite größer als der linke ist `5 < 6 // true` |
| `<=` | **Größer oder gleich**: Vergleicht zwei Werte und gibt den booleschen Datentyp `true` zurück, wenn der Wert auf der rechten Seite größer oder gleich dem linken | ist `5 <= 6 // true` |
| `>` | **Kleiner als**: Vergleicht zwei Werte und gibt den booleschen Datentyp `true` zurück, wenn der Wert auf der linken Seite größer als der rechte ist `5 > 6 // false` |
| `=>` | **Kleiner oder gleich**: Vergleicht zwei Werte und gibt den booleschen Datentyp `true` zurück, wenn der Wert auf der linken Seite größer oder gleich dem rechten | ist `5 => 6 // false` |
| `===` | **Strikte Gleichheit**: Vergleicht zwei Werte und gibt den booleschen Datentyp `true` zurück, wenn die Werte rechts und links gleich sind UND denselben Datentyp haben. | `5 === 6 // false` |
| `!==` | **Ungleichung**: Vergleicht zwei Werte und gibt den entgegengesetzten Booleschen Wert zurück, den ein strikter Gleichheitsoperator | zurückgeben würde `5 !== 6 // true` |
✅ Überprüfen Sie Ihr Wissen, indem Sie einige Vergleiche in die Konsole Ihres Browsers schreiben. Überraschen Sie zurückgegebene Daten?
## If-Anweisung
Die if-Anweisung führt Code zwischen ihren Blöcken aus, wenn die Bedingung erfüllt ist.
```javascript
if (condition){
//Bedingung war wahr. Der Code in diesem Block wird ausgeführt.
}
```
Logische Operatoren werden häufig verwendet, um die Bedingung zu bilden.
```javascript
let currentMoney;
let laptopPrice;
if (currentMoney >= laptopPrice){
//Bedingung war wahr. Der Code in diesem Block wird ausgeführt.
console.log("Getting a new laptop!");
}
```
## IF..Else Anweisung
Die `else`-Anweisung führt den Code zwischen ihren Blöcken aus, wenn die Bedingung falsch ist. Es ist optional mit einer `if`-Anweisung.
```javascript
let currentMoney;
let laptopPrice;
if (currentMoney >= laptopPrice){
//Bedingung war wahr. Der Code in diesem Block wird ausgeführt.
console.log("Getting a new laptop!");
}
else{
//Bedingung war wahr. Der Code in diesem Block wird ausgeführt.
console.log("Can't afford a new laptop, yet!");
}
```
✅ Testen Sie Ihr Verständnis dieses Codes und des folgenden Codes, indem Sie ihn in einer Browserkonsole ausführen. Ändern Sie die Werte der Variablen currentMoney und LaptopPrice, um das zurückgegebene `console.log()` zu ändern.
## Logische Operatoren und Boolesche Werte
Entscheidungen erfordern möglicherweise mehr als einen Vergleich und können mit logischen Operatoren verknüpft werden, um einen Booleschen Wert zu erzeugen.
| Symbol | Beschreibung | Beispiel |
| ------ | -------------------------------------------------- ----------------------------------------- | -------------------------------------------------- --------------------- |
| `&&` | **Logisches UND**: Vergleicht zwei Boolesche Ausdrücke. Gibt true **nur** zurück, wenn beide Seiten true | sind `(5 > 6) && (5 < 6) // Eine Seite ist falsch, die andere ist wahr. Gibt false` | zurück
| `||` | **Logisches ODER**: Vergleicht zwei Boolesche Ausdrücke. Gibt true zurück, wenn mindestens eine Seite true ist `(5 > 6) || (5 < 6) // Eine Seite ist falsch, die andere ist wahr. Gibt true` | zurück
| `!` | **Logisch NICHT**: Gibt den entgegengesetzten Wert eines Booleschen Ausdrucks | zurück `! (5 > 6) // 5 ist nicht größer als 6, aber "!" wird true zurückgeben` |
## Bedingungen und Entscheidungen mit logischen Operatoren
Logische Operatoren können verwendet werden, um Bedingungen in if..else-Anweisungen zu bilden.
```javascript
let currentMoney;
let laptopPrice;
let laptopDiscountPrice = laptopPrice - (laptopPrice * .20) //Laptop-Preis bei 20 Prozent Rabatt
if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice){
//Bedingung war wahr. Der Code in diesem Block wird ausgeführt.
console.log("Getting a new laptop!");
}
else {
//Bedingung war wahr. Der Code in diesem Block wird ausgeführt.
console.log("Can't afford a new laptop, yet!");
}
```
### Negationsoperator
Sie haben bisher gesehen, wie Sie mit einer `if...else`-Anweisung eine bedingte Logik erstellen können. Alles, was in ein `if` geht, muss als wahr / falsch bewertet werden. Mit dem Operator `!` Können Sie den Ausdruck _negieren_. Es würde so aussehen:
```javascript
if (!condition) {
// wird ausgeführt, wenn die Bedingung falsch ist
} else {
// wird ausgeführt, wenn die Bedingung erfüllt ist
}
```
### Ternäre Ausdrücke
`if...else` ist nicht die einzige Möglichkeit, Entscheidungslogik auszudrücken. Sie können auch einen so genannten ternären Operator verwenden. Die Syntax dafür sieht folgendermaßen aus:
```javascript
let variable = condition ? <return this if true> : <return this if false>`
```
Below is a more tangible example:
```javascript
let firstNumber = 20;
let secondNumber = 10
let biggestNumber = firstNumber > secondNumber ? firstNumber: secondNumber;
```
✅ Nehmen Sie sich eine Minute Zeit, um diesen Code einige Male zu lesen. Verstehen Sie, wie diese Operatoren arbeiten?
Das Obige besagt das
- wenn `firstNumber` größer als `secondNumber` ist
- dann `firstNumber` zu `biggestNumber` zuweisen
- sonst `secondNumber` zuweisen.
Der ternäre Ausdruck ist nur eine kompakte Art, den folgenden Code zu schreiben:
```javascript
let biggestNumber;
if (firstNumber > secondNumber) {
biggestNumber = firstNumber;
} else {
biggestNumber = secondNumber;
}
```
---
## 🚀 Herausforderung
Erstellen Sie ein Programm, das zuerst mit logischen Operatoren geschrieben wird, und schreiben Sie es dann mit einem ternären Ausdruck neu. Was ist Ihre bevorzugte Syntax?
## [Quiz nach der Vorlesung] (.github/post-lecture-quiz.md)
## Review & Selbststudium
Lesen Sie mehr über die vielen Operatoren, die dem Benutzer [auf MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators) zur Verfügung stehen.
## Zuordnung
[Operators](assignment.md)

164
2-js-basics/3-making-decisions/translations/README.es.md Normal file
View File

@@ -0,0 +1,164 @@
# Conceptos básicos de JavaScript: tomar decisiones
![video](video-url)
## [Pre-lecture prueba](.github/pre-lecture-quiz.md)
Tomar decisiones y controlar el orden en que se ejecuta su código hace que su código sea reutilizable y robusto. Esta sección cubre la sintaxis para controlar el flujo de datos en JavaScript y su importancia cuando se usa con tipos de datos booleanos.
## Un breve resumen sobre los valores booleanos
Los booleanos pueden tener solo dos valores: `true` o` false`. Los booleanos ayudan a tomar decisiones sobre qué líneas de código deben ejecutarse cuando se cumplen ciertas condiciones.
Establezca su booleano en verdadero o falso de esta manera:
`let myTrueBool = true`
`let myFalseBool = false`
✅ Los booleanos llevan el nombre del matemático, filósofo y lógico inglés George Boole. (1815–1864).
## Operadores de comparación y valores booleanos
Los operadores se utilizan para evaluar las condiciones haciendo comparaciones que crearán un valor booleano. La siguiente es una lista de operadores que se utilizan con frecuencia.
| Símbolo | Descripción | Ejemplo |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
| `<` | **Mayor que**: compara dos valores y devuelve el tipo de datos booleano `true` si el valor del lado derecho es mayor que el del izquierdo | `5 < 6 // true` |
| `<=` | **Mayor o igual que**: compara dos valores y devuelve el tipo de datos booleano `true` si el valor del lado derecho es mayor o igual que el del lado izquierdo | `5 <= 6 // true` |
| `>` | **Menor que**: compara dos valores y devuelve el tipo de datos booleano `true` si el valor del lado izquierdo es mayor que el del derecho | `5 > 6 // false` |
| `=>` | **Menor o igual que**: compara dos valores y devuelve el tipo de datos booleano `true` si el valor del lado izquierdo es mayor o igual que el del lado derecho | `5 => 6 // false` |
| `===` | **Igualdad estricta**: compara dos valores y devuelve el tipo de datos booleano `true` si los valores de la derecha y la izquierda son iguales Y son del mismo tipo de datos | `5 === 6 // false` |
| `!==` | **Desigualdad**: compara dos valores y devuelve el valor booleano opuesto de lo que devolvería un operador de igualdad estricta | `5 !== 6 // true` |
✅ Compruebe sus conocimientos escribiendo algunas comparaciones en la consola de su navegador. ¿Te sorprende algún dato devuelto?
## Declaración If
La sentencia if ejecutará código entre sus bloques si la condición es verdadera.
```javascript
if (condition){
//La condición era verdadera. Se ejecutará el código de este bloque.
}
```
Los operadores lógicos se utilizan a menudo para formar la condición.
```javascript
let currentMoney;
let laptopPrice;
if (currentMoney >= laptopPrice){
//La condición era verdadera. Se ejecutará el código de este bloque.
console.log("Getting a new laptop!");
}
```
## IF..Else Declaración
La declaración `else` ejecutará el código entre sus bloques cuando la condición sea falsa. Es opcional con una declaración `if`.
```javascript
let currentMoney;
let laptopPrice;
if (currentMoney >= laptopPrice){
//La condición era verdadera. Se ejecutará el código de este bloque.
console.log("Getting a new laptop!");
}
else{
//La condición era verdadera. Se ejecutará el código de este bloque.
console.log("Can't afford a new laptop, yet!");
}
```
✅ Pruebe su comprensión de este código y del siguiente código ejecutándolo en una consola de navegador. Cambie los valores de las variables currentMoney y laptopPrice para cambiar el `console.log()` devuelto.
## Operadores lógicos y booleanos
Las decisiones pueden requerir más de una comparación y se pueden unir con operadores lógicos para producir un valor booleano.
| Símbolo | Descripción | Ejemplo |
| ------ | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| `&&` | **AND lógico**: compara dos expresiones booleanas. Devuelve verdadero **solo** si ambos lados son verdaderos | `(5 > 6) && (5 < 6 ) //Un lado es falso, el otro es verdadero. Devuelve falso` |
| `||` | **OR lógico**: compara dos expresiones booleanas. Devuelve verdadero si al menos un lado es verdadero | `(5 > 6) || (5 < 6) //Un lado es falso, el otro es verdadero. Devuelve verdadero` |
| `!` | **NOT lógico**: Devuelve el valor opuesto de una expresión booleana | `!(5 > 6) // 5 no es mayor que 6, pero "!" devolverá verdadero` |
## Condiciones y decisiones con operadores lógicos
Los operadores lógicos se pueden utilizar para formar condiciones en sentencias if..else.
```javascript
let currentMoney;
let laptopPrice;
let laptopDiscountPrice = laptopPrice - (laptopPrice * .20) //Precio del portátil al 20% de descuento
if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice){
//La condición era verdadera. Se ejecutará el código de este bloque.
console.log("Getting a new laptop!");
}
else {
//La condición era verdadera. Se ejecutará el código de este bloque.
console.log("Can't afford a new laptop, yet!");
}
```
### Operador de negación
Hasta ahora has visto cómo si puedes usar una instrucción `if...else` para crear lógica condicional. Cualquier cosa que entre en un `if` debe evaluarse como verdadero / falso. Utilizando el operador `!` Puede _negar_ la expresión. Se vería así:
```javascript
if (!condition) {
// se ejecuta si la condición es falsa
} else {
// se ejecuta si la condición es verdadera
}
```
### Expresiones ternarias
`If...else` no es la única forma de expresar la lógica de decisión. También puede usar algo llamado operador ternario. La sintaxis tiene el siguiente aspecto:
```javascript
let variable = condition ? <return this if true> : <return this if false>`
```
A continuación se muestra un ejemplo más tangible:
```javascript
let firstNumber = 20;
let secondNumber = 10
let biggestNumber = firstNumber > secondNumber ? firstNumber: secondNumber;
```
✅ Tómese un minuto para leer este código varias veces. ¿Entiende cómo trabajan estos operadores?
Lo anterior establece que
- si `firstNumber` es mayor que `secondNumber`
- luego asigne `firstNumber` a `biggestNumber`
- de lo contrario, asigne `secondNumber`.
La expresión ternaria es solo una forma compacta de escribir el siguiente código:
```javascript
let biggestNumber;
if (firstNumber > secondNumber) {
biggestNumber = firstNumber;
} else {
biggestNumber = secondNumber;
}
```
🚀 Desafío: cree un programa que se escriba primero con operadores lógicos y luego vuelva a escribirlo utilizando una expresión ternaria. ¿Cuál es tu sintaxis preferida?
## [Post-lecture prueba](.github/post-lecture-quiz.md)
## Revisión y autoestudio
Más información sobre los muchos operadores disponibles para el usuario [en MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators).
**Asignación**: [Operadores](assignment.md)

40
2-js-basics/3-making-decisions/translations/assignment.de.md Normal file
View File

@@ -0,0 +1,40 @@
# Operatoren
## Anleitung
Spielen Sie mit den Betreibern herum. Hier ist ein Vorschlag für ein Programm, das Sie implementieren können:
Sie haben eine Gruppe von Studenten aus zwei verschiedenen Bewertungssystemen.
### Erstbewertungssystem
Ein Bewertungssystem ist definiert als Noten von 1 bis 5, wobei 3 und höher bedeutet, dass Sie den Kurs bestehen.
### Zweites Bewertungssystem
Das andere Notensystem hat die folgenden Noten `A, A-, B, B-, C, C-` wobei `A` die Bestnote und `C` die niedrigste bestandene Note ist.
### Die Aufgabe
Erstellen Sie unter Berücksichtigung des folgenden Arrays `allStudents`, das alle Schüler und ihre Noten darstellt, ein neues Array `studentsWhoPass`, das alle bestandenen Schüler enthält.
> TIPP, verwenden Sie eine for-Schleife und if...else und Vergleichsoperatoren:
```javascript
let allStudents = [
'A',
'B-'
1,
4
5,
2
]
let studentsWhoPass = [];
```
## Rubrik
| Kriterien | Vorbildlich | Angemessen | Verbesserungsbedarf |
| -------- | ------------------------------ | ----------------------------- | ------------------------------- |
| | Komplettlösung wird vorgestellt | Teillösung wird vorgestellt Lösung mit Fehlern wird vorgestellt |

41
2-js-basics/3-making-decisions/translations/assignment.es.md Normal file
View File

@@ -0,0 +1,41 @@
# Operadores
## Instrucciones
Juega con los operadores. Aquí hay una sugerencia de un programa que puede implementar.
Tiene un conjunto de estudiantes de dos sistemas de calificación diferentes.
### Primer sistema de calificación
Un sistema de calificación se define como calificaciones del 1 al 5, donde 3 y más significa que aprueba el curso.
### Segundo sistema de calificación
El otro sistema de calificaciones tiene las siguientes calificaciones `A, A-, B, B-, C, C-` donde `A` es la calificación más alta y `C` es la calificación más baja para aprobar.
### La tarea
Dada la siguiente matriz `allStudents` que representa a todos los estudiantes y sus calificaciones, construya una nueva matriz `StudentsWhoPass` que contenga a todos los estudiantes que aprobaron.
> SUGERENCIA, use un bucle for y if ... else y operadores de comparación:
```javascript
let allStudents = [
'A',
'B-'
1,
4
5,
2
]
let studentsWhoPass = [];
```
## Rúbrica
| Criterios | Ejemplar | Adecuado | Necesita mejorar |
| -------- | ------------------------------ | ----------------------------- | ------------------------------- |
| | Se presenta la solución completa | Se presenta solución parcial | Se presenta solución con errores |