repo_name string | dataset string | owner string | lang string | func_name string | code string | docstring string | url string | sha string |
|---|---|---|---|---|---|---|---|---|
ZetaForge | github_2023 | zetane | typescript | domReady | function domReady(condition: DocumentReadyState[] = ['complete', 'interactive']) {
return new Promise(resolve => {
if (condition.includes(document.readyState)) {
resolve(true)
} else {
document.addEventListener('readystatechange', () => {
if (condition.includes(document.readyState)) {
resolve(true)
}
})
}
})
} | // --------- Preload scripts loading --------- | https://github.com/zetane/ZetaForge/blob/6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298/frontend/electron/preload/index.ts#L14-L26 | 6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298 |
ZetaForge | github_2023 | zetane | typescript | useLoading | function useLoading() {
const className = `loaders-css__square-spin`
const styleContent = `
@keyframes square-spin {
25% { transform: perspective(100px) rotateX(180deg) rotateY(0); }
50% { transform: perspective(100px) rotateX(180deg) rotateY(180deg); }
75% { transform: perspective(100px) rotateX(0) rotateY(180deg); }
100% { transform: perspective(100px) rotateX(0) rotateY(0); }
}
.${className} > div {
animation-fill-mode: both;
width: 50px;
height: 50px;
background: #fff;
animation: square-spin 3s 0s cubic-bezier(0.09, 0.57, 0.49, 0.9) infinite;
}
.app-loading-wrap {
position: fixed;
top: 0;
left: 0;
width: 100vw;
height: 100vh;
display: flex;
align-items: center;
justify-content: center;
background: #282c34;
z-index: 9;
}
`
const oStyle = document.createElement('style')
const oDiv = document.createElement('div')
oStyle.id = 'app-loading-style'
oStyle.innerHTML = styleContent
oDiv.className = 'app-loading-wrap'
oDiv.innerHTML = `<div class="${className}"><div></div></div>`
return {
appendLoading() {
safeDOM.append(document.head, oStyle)
safeDOM.append(document.body, oDiv)
},
removeLoading() {
safeDOM.remove(document.head, oStyle)
safeDOM.remove(document.body, oDiv)
},
}
} | /**
* https://tobiasahlin.com/spinkit
* https://connoratherton.com/loaders
* https://projects.lukehaas.me/css-loaders
* https://matejkustec.github.io/SpinThatShit
*/ | https://github.com/zetane/ZetaForge/blob/6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298/frontend/electron/preload/index.ts#L47-L94 | 6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298 |
ZetaForge | github_2023 | zetane | typescript | readJsonFile | function readJsonFile<T>(filename: string): T {
try {
const rawData = fs.readFileSync(filename, "utf-8");
return JSON.parse(rawData) as T;
} catch (error) {
console.error("Error reading or parsing the file:", error);
throw error;
}
} | // Function to read a JSON file | https://github.com/zetane/ZetaForge/blob/6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298/frontend/utils/schema/specConverter.ts#L49-L57 | 6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298 |
ZetaForge | github_2023 | zetane | typescript | saveJsonFile | function saveJsonFile(filename: string, data: any): void {
try {
const jsonData = JSON.stringify(data, null, 2);
fs.writeFileSync(filename, jsonData, "utf-8");
console.log(`File saved: ${filename}`);
} catch (error) {
console.error("Error writing the file:", error);
throw error;
}
} | // Function to save a JSON file | https://github.com/zetane/ZetaForge/blob/6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298/frontend/utils/schema/specConverter.ts#L60-L69 | 6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298 |
ZetaForge | github_2023 | zetane | typescript | convertBlockV1 | function convertBlockV1(input_block: any): Block {
// Map the source JSON structure to the Block structure
const blockInformation: Information = {
id: input_block.information.id,
name: input_block.information.name,
description: input_block.information.description,
system_versions: ["0.1"],
block_version: input_block.information.block_version,
block_source: input_block.information.block_source,
block_type: "", // Assuming this needs to be mapped from somewhere else in `sourceData`
};
const inputs: { [key: string]: Put } = {};
for (const key in input_block.inputs) {
let connections: Connection[] = [];
connections = input_block.inputs[key]?.connections.map(
(conn: any): Connection => {
const newConn: Connection = {
block: conn.node,
variable: conn.output,
};
return newConn;
},
);
inputs[key] = {
type: input_block.inputs[key].type,
connections: connections,
relays: input_block.inputs[key].relay_connections, // Assuming relays map to relay_connections
};
}
const outputs: { [key: string]: Put } = {};
for (const key in input_block.outputs) {
let connections: Connection[] = [];
connections = input_block.outputs[key]?.connections.map(
(conn: any): Connection => {
const newConn: Connection = {
block: conn.node,
variable: conn.input,
};
return newConn;
},
);
outputs[key] = {
type: input_block.outputs[key].type,
connections: connections,
relays: input_block.outputs[key].relay_connections, // Assuming relays map to relay_connections
};
}
let action: Action = {};
if (Object.keys(input_block.parameters).length > 0) {
const parameters: { [key: string]: Parameter } = {};
for (const key in input_block.parameters) {
parameters[key] = {
type: input_block.parameters[key].type,
value: input_block.parameters[key].value,
};
}
action = {
parameters: parameters,
};
} else {
console.log("ACTION: ", input_block.action);
console.log("VERSION: ", input_block.action["version"]);
action = {
container: {
// Assuming the container fields need to be mapped from action section
image: input_block.action.container_image_uuid,
version: input_block.action.version,
command_line: ["python", "entrypoint.py"], // Assuming this needs to be filled based on your JSON structure
},
};
}
const bgColor = input_block.views.node?.title_bar?.background_color;
const preview = input_block.views.node?.preview?.active;
const behavior = input_block.views.mode;
const views: Views = {
node: {
behavior: behavior ? behavior : "",
active: "true",
title_bar: {
background_color: bgColor ? bgColor : "#D55908",
},
preview: {
active: preview ? "true" : "false",
},
html: input_block.views.node.html,
pos_x: input_block.views.node.pos_x.toString(),
pos_y: input_block.views.node.pos_y.toString(),
pos_z: input_block.views.node.pos_z.toString(),
},
};
const events: Event = {};
const block: Block = {
information: blockInformation,
inputs: inputs,
outputs: outputs,
action: action,
views: views,
events: events,
};
console.log(block);
return block;
} | // Function to convert from specs to Block | https://github.com/zetane/ZetaForge/blob/6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298/frontend/utils/schema/specConverter.ts#L72-L185 | 6ffa0f9d9005c5d5709e5d7dd46fa83a38e01298 |
differential | github_2023 | differentialhq | typescript | evaluateProject | const evaluateProject = (
filePath: string,
walkPath: string,
paths: string[],
serviceRegistrations = new Map<string, string>(),
): ProjectDetails => {
// Find all `requires` in a file
const listFileRequires = (filePath: string): string[] =>
detective
.find(fs.readFileSync(filePath, "utf-8"), {
nodes: "true",
})
.nodes?.map((node: any) => node.arguments[0].value as string) ?? [];
let fullPath = [walkPath, filePath].join("/");
fullPath = fullPath.endsWith(".js") ? fullPath : fullPath.concat(".js");
log("Evaluating path", { walkPath, filePath, fullPath });
// Check if file exists and if so walk it's dependencies recursively
if (fs.existsSync(fullPath)) {
const registration = findServiceRegistration(fullPath);
if (registration) {
serviceRegistrations.set(registration, fullPath);
}
const dependencies = listFileRequires(fullPath);
for (const require of dependencies) {
const subEval = evaluateProject(
require,
path.dirname(fullPath),
paths,
serviceRegistrations,
);
paths.push(
// Call recursively with new entrypoint
...subEval.dependencies,
);
serviceRegistrations = new Map([
...serviceRegistrations,
...subEval.serviceRegistrations,
]);
}
} else {
// If not, assume it's a module and add it to the list.
// This will be filtered further against the origin package.json
paths.push(filePath);
}
return {
dependencies: paths,
serviceRegistrations,
};
}; | // Recursively traverse the file tree and find all dependencies and service registrations | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/cli/src/lib/package.ts#L130-L184 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | listFileRequires | const listFileRequires = (filePath: string): string[] =>
detective
.find(fs.readFileSync(filePath, "utf-8"), {
nodes: "true",
})
.nodes?.map((node: any) => node.arguments[0].value as string) ?? []; | // Find all `requires` in a file | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/cli/src/lib/package.ts#L137-L142 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | LambdaCfnProvider.schema | public schema(): ZodSchema<void> {
return z.void();
} | // provider configuration. | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/control-plane/src/modules/deployment/lambda-cfn-provider.ts#L36-L38 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | Differential.constructor | constructor(
apiSecret?: string,
options?: {
endpoint?: string;
encryptionKeys?: Buffer[];
jobPollWaitTime?: number;
validateBeforeSerialization?: boolean;
},
) {
if (apiSecret && process.env.DIFFERENTIAL_API_SECRET) {
log(
"API Secret was provided as an argument and environment variable. Constructor argument will be used.",
);
}
apiSecret = apiSecret || process.env.DIFFERENTIAL_API_SECRET;
if (!apiSecret) {
throw new DifferentialError("No API Secret provided.");
}
this.apiSecret = apiSecret;
this.authHeader = `Basic ${this.apiSecret}`;
this.endpoint = options?.endpoint || "https://api.differential.dev";
this.machineId = Math.random().toString(36).substring(7);
this.deploymentId = process.env.DIFFERENTIAL_DEPLOYMENT_ID;
if (process.env.DIFFERENTIAL_DEPLOYMENT_PROVIDER === "lambda") {
this.maxIdleCycles = 2;
}
options?.encryptionKeys?.forEach((key, i) => {
if (key.length !== 32) {
throw new DifferentialError(
`Encryption keys must be 32 bytes long. Received key of length ${key.length} at index ${i}`,
);
}
});
const jobPollWaitTime = options?.jobPollWaitTime || 20000;
if (jobPollWaitTime < 5000) {
throw new DifferentialError("jobPollWaitTime must be at least 5000ms");
}
this.jobPollWaitTime = options?.jobPollWaitTime;
log("Initializing control plane client", {
endpoint: this.endpoint,
machineId: this.machineId,
});
this.controlPlaneClient = createClient({
baseUrl: this.endpoint,
machineId: this.machineId,
deploymentId: this.deploymentId,
});
this.events = new Events(async (events) => {
const result = await this.controlPlaneClient.ingestClientEvents({
body: { events: events },
headers: {
authorization: this.authHeader,
},
});
log("Sent metrics to control plane", {
result: result,
});
});
this.resultsPoller = new ResultsPoller(
this.controlPlaneClient,
this.authHeader,
);
this.resultsPoller.start();
} | /**
* Initializes a new Differential instance.
* @param apiSecret The API Secret for your Differential cluster. If not provided, it will be read from the `DIFFERENTIAL_API_SECRET` environment variable. You can obtain one from https://api.differential.dev/demo/token.
* @param options Additional options for the Differential client.
* @param options.endpoint The endpoint for the Differential cluster. Defaults to https://api.differential.dev.
* @param options.encryptionKeys An array of encryption keys to use for encrypting and decrypting data. These keys are never sent to the control-plane and allows you to encrypt function arguments and return values. If you do not provide any keys, Differential will not encrypt any data. Encryption has a performance impact on your functions. When you want to rotate keys, you can add new keys to the start of the array. Differential will try to decrypt data with each key in the array until it finds a key that works. Differential will encrypt data with the first key in the array. Each key must be 32 bytes long.
* @param options.jobPollWaitTime The amount of time in milliseconds that the client will maintain a connection to the control-plane when polling for jobs. Defaults to 20000ms. If a job is not received within this time, the client will close the connection and try again.
* @param options.validateBeforeSerialization If set to false, Differential will not validate the data before serializing it. This can be useful for performance reasons, but can lead to unexpected results if the data is not serializable. Defaults to true.
*
* @example
* ```ts
* // Basic usage
* const d = new Differential("API_SECRET");
*
* // With encryption
* const d = new Differential("API_SECRET", {
* encryptionKeys: [
* Buffer.from("abcdefghijklmnopqrstuvwxzy123456"), // current key
* Buffer.from("abcdefghijklmnopqrstuvwxzy123old"), // previous key
* ],
* });
* ```
*/ | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/sdk/src/Differential.ts#L458-L536 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | Differential.service | service<T extends ServiceDefinition<N>, N extends string>(
service: T,
): RegisteredService<T> {
for (const [key, value] of Object.entries(service.functions)) {
if (functionRegistry[key]) {
throw new DifferentialError(
`Function name '${key}' is already registered by another service.`,
);
} else {
this.register({
fn: value,
name: key,
serviceName: service.name,
});
}
}
return {
definition: service,
start: () => this.listen(service),
stop: () => this.stop(),
};
} | /**
* Registers a service with Differential. This will register all functions on the service.
* @param service The service definition.
* @returns A registered service instance.
* @example
* ```ts
* const d = new Differential("API_SECRET");
*
* const service = d.service({
* name: "my-service",
* functions: {
* hello: async (name: string) => {
* return `Hello ${name}`;
* }
* });
*
* // start the service
* await service.start();
*
* // stop the service on shutdown
* process.on("beforeExit", async () => {
* await service.stop();
* });
* ```
*/ | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/sdk/src/Differential.ts#L643-L665 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | Differential.client | client<T extends RegisteredService<any>>(
service: T["definition"]["name"],
options?: {
background?: boolean;
},
): ServiceClient<T> | BackgroundServiceClient<T> {
const d = this;
if (options?.background === true) {
return new Proxy({} as BackgroundServiceClient<T>, {
get(_target, property, _receiver) {
return (...args: any[]) =>
d.background(service, property, ...(args as any));
},
});
} else {
return new Proxy({} as ServiceClient<T>, {
get(_target, property, _receiver) {
return (...args: any[]) =>
d.call(service, property, ...(args as any));
},
});
}
} | /**
* Provides a type safe client for performing calls to a registered service.
* Waits for the function to complete before returning, and returns the result of the function call.
* @returns ServiceClient<T>
* @example
* ```ts
* import { d } from "./differential";
* import type { helloService } from "./hello-service";
*
* const client = d.client<helloService>("hello");
*
* // Client usage
* const result = client.hello("world");
* console.log(result); // "Hello world"
* ```
*/ | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/sdk/src/Differential.ts#L692-L715 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | Differential.call | async call<
T extends RegisteredService<any>,
U extends keyof T["definition"]["functions"],
>(
service: T["definition"]["name"],
fn: U,
...args: Parameters<T["definition"]["functions"][U]>
): Promise<ReturnType<T["definition"]["functions"][U]>> {
const start = Date.now();
// create a job
const { id, callConfig } = await this.createJob<T, U>(service, fn, args);
log("Waiting for job to complete", { id });
return new Promise((resolve, reject) => {
this.resultsPoller.getResult(id, callConfig, (result) => {
log("Got result", { fn, id, result });
const end = Date.now();
this.events.push({
timestamp: new Date(),
type: "functionInvocation",
tags: {
function: fn as string,
service: service,
},
intFields: {
roundTripTime: end - start,
},
});
log("Result received", { id, result });
if (result.type === "resolution") {
// return the result
return resolve(
result.content as ReturnType<T["definition"]["functions"][U]>,
);
} else if (result.type === "rejection") {
const error = deserializeError(result.content);
return reject(error);
} else {
return reject(new DifferentialError("Unexpected result type"));
}
});
});
} | /**
* @ignore
* @deprecated Use `d.client` instead.
*/ | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/sdk/src/Differential.ts#L721-L768 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
differential | github_2023 | differentialhq | typescript | Differential.background | async background<
T extends RegisteredService<any>,
U extends keyof T["definition"]["functions"],
>(
service: T["definition"]["name"],
fn: U,
...args: Parameters<T["definition"]["functions"][U]>
): Promise<{ id: string }> {
// create a job
const { id } = await this.createJob<T, U>(service, fn, args);
return { id };
} | /**
* @ignore
* @deprecated Use `d.client` instead.
*/ | https://github.com/differentialhq/differential/blob/f521a42b65d2bef33dbf69d8537238ab6465f7e4/sdk/src/Differential.ts#L774-L786 | f521a42b65d2bef33dbf69d8537238ab6465f7e4 |
roadmap-retos-programacion | github_2023 | mouredev | typescript | Statistics.getAverage | public static getAverage(x: number, y: number): number {
return (x + y) / 2.0;
} | /**
* Returns the average of two numbers.
*
* @remarks
* This method is part of the {@link core-library#Statistics | Statistics subsystem}.
*
* @param x - The first input number
* @param y - The second input number
* @returns The arithmetic mean of `x` and `y`
*|
* @beta
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/RobertoAmaroHub.ts#L19-L21 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | add | function add(a: number, b: number): number {
return a + b;
} | // Function with type annotations | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/duendeintemporal.ts#L154-L156 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | fetchData | const fetchData = (): Promise<string> => {
return new Promise((resolve) => {
setTimeout(() => {
resolve("Data fetched!");
}, 2000);
});
}; | // String length: 24 | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/duendeintemporal.ts#L177-L183 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sinRetorno | function sinRetorno(): void {
console.log("Esta función no retorna nada");
} | // Void (vacío, típicamente para funciones sin retorno) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/eulogioep.ts#L57-L59 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | error | function error(mensaje: string): never {
throw new Error(mensaje);
} | // Never (nunca, para funciones que nunca retornan) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/eulogioep.ts#L62-L64 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sum | function sum(a, b) {
return a + b;
} | /**
* Suma dos números
* @param {number} a - El primer número
* @param {number} b - El segundo número
* @returns {number} - La suma de a y b
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mikelroset.ts#L23-L25 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | logMessage | function logMessage(message: string): void {
console.log(message);
} | // OK | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mikelroset.ts#L124-L126 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | throwError | function throwError(message: string): never {
throw new Error(message);
} | // Never (Representa el tipo de valores que nunca ocurren) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mikelroset.ts#L130-L132 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | add | function add(a: number, b: number): number {
return a + b;
} | // Functions (Se pueden tipar tanto los parámetros como el valor de retorno) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mikelroset.ts#L146-L148 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | saludar | function saludar(): void {
console.log("Hola, mundo!");
} | // Void (usualmente para funciones que no retornan valor) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/tolomero.ts#L45-L47 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | miFuncion | function miFuncion() {
console.log('¡Hola Mundo!');
} | //Operador llamada de función | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/CT-Zodiako.ts#L91-L93 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | h | function h() {
console.log('Hola');
} | // Funciones | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/CT-Zodiako.ts#L145-L147 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | numeros_comprendidos | function numeros_comprendidos(min: number, max: number): void {
for (let num = min; num <= max; num++) {
if (num % 2 == 0 && num != 16 && num % 3 != 0) {
console.log(num);
}
}
} | //****************************************************** */ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/Guillemduno.ts#L220-L226 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | checkEvenNum | let checkEvenNum = (num: number) => {
if (num % 2 === 0) {
console.log(`${num} es par`);
} else {
console.log(`${num} no es par`);
}
}; | //if else | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/RicJDev.ts#L93-L99 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | ejemplo1 | function ejemplo1(valor: string){
throw new Error(valor)
} | //Try Catch errors | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/RobertoAmaroHub.ts#L137-L139 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | obtenerDatos | async function obtenerDatos() {
try {
let respuesta = await fetch('https://api.example.com/datos');
let datos = await respuesta.json();
console.log(datos);
} catch (error) {
console.log("Error al obtener los datos: " + error.message);
}
} | // Estructura de Control asincrónica | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/david-git-dev.ts#L203-L211 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | numbersTentoFifhtty | function numbersTentoFifhtty(){
const final = 55;
let start = 10;
while(start<=55){
start++;
console.log(start%2===0&&start!==16&&start%3!==0?start:'');
}
} | //reto extra | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/david-git-dev.ts#L218-L225 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | isNumberObject | function isNumberObject(value: any): value is Number {
return value instanceof Number;
} | // true | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/duendeintemporal.ts#L450-L452 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | showUser | function showUser({ name, age, email }: { name: string; age: number; email: string }) {
log(`User name: ${name}, age: ${age}, email: ${email}`);
} | // Logs both objects niko_zen instance and niko_zen_settings | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/duendeintemporal.ts#L495-L497 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | calculateAverage | const calculateAverage = (...numbers: number[]) => {
const total = numbers.reduce((sum, num) => sum + num, 0);
return total / numbers.length;
}; | // logs: 6 | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/duendeintemporal.ts#L540-L543 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | isNumbers | const isNumbers = ():void => {
const list: number[] = [];
for (let i=10; i<=55; i++){
if(i % 3 == 0 || i == 16){
continue;
}
list.push(i);
}
console.log(list);
} | /*
* DIFICULTAD EXTRA (opcional):
* Crea un programa que imprima por consola todos los números comprendidos
* entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
*
* Seguro que al revisar detenidamente las posibilidades has descubierto algo nuevo.
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/juanRCoder.ts#L84-L93 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadoresAritmeticos | function operadoresAritmeticos() {
console.log("1. Operadores Aritméticos");
let suma = 5 + 5; // Operador de suma (+)
console.log("Suma: " + suma); // 10
let resta = suma - 5; // Operador de resta (-)
console.log("Resta:" + resta); // 5
let multiplicacion = suma * 5; // Operador de multiplicación (*)
console.log("Multiplicación: " + multiplicacion); // 50
let division = suma / 5 // Operador de división (/)
console.log("División: " + division); // 2
let modulo = suma % 3; // Operador de módulo (%) - Módulo (resto o sobrante de la división) 10 % 3 = 1 se puede considerar como 10/3 = 3 y sobra 1
console.log("Modulo: " + modulo); // 1
suma++; // Operador de incremento (++)
console.log("Incremento: " + suma); // 6
suma--; // Operador de decremento (--)
console.log("Decremento: " + suma); // 5
let exponenciacion = 2 ** 3; // Operador de exponenciación (**)
console.log("Exponenciación" + exponenciacion); // 8
// Ejemplo de uso de operadores aritméticos
let numero1 = 5;
let numero2 = 3;
let resultado = (((numero1 + numero2) * (numero1 - numero2)) / numero2) % numero2 + numero1++ - --numero2 + numero1 ** numero2
console.log("Uso de todos los operadores aritmeticos: " + resultado); // 41.333....
} | /*
* EJERCICIO:
* - Crea ejemplos utilizando todos los tipos de operadores de tu lenguaje:
* Aritméticos, lógicos, de comparación, asignación, identidad, pertenencia, bits...
* (Ten en cuenta que cada lenguaje puede poseer unos diferentes)
* - Utilizando las operaciones con operadores que tú quieras, crea ejemplos
* que representen todos los tipos de estructuras de control que existan
* en tu lenguaje:
* Condicionales, iterativas, excepciones...
* - Debes hacer print por consola del resultado de todos los ejemplos.
*
* DIFICULTAD EXTRA (opcional):
* Crea un programa que imprima por consola todos los números comprendidos
* entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
*
* Seguro que al revisar detenidamente las posibilidades has descubierto algo nuevo.
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L22-L54 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadoresBitBit | function operadoresBitBit() {
console.log("2. Operadores Bit a Bit");
let operadorA = 60; // 60 = 0011 1100
let operadorB = 13; // 13 = 0000 1101
let operadorC = -10; // -10 = 1111 1111 1111 1111 1111 1111 1111 0110
let operadorAnd = operadorA & operadorB; // Operador de AND bit a bit (&)
console.log("AND: " + operadorAnd); // 12
// Explicación con binarios:
// 0011 1100 -> 60
// 0000 1101 -> 13
// ------------ & (AND)
// 0000 1100 -> 12
let operadorOr = operadorA | operadorB; // Operador de OR bit a bit (|)
console.log("OR: " + operadorOr); // 61
// Explicación con binarios:
// 0011 1100 -> 60
// 0000 1101 -> 13
// ------------ | (OR)
// 0011 1101 -> 61
let operadorXor = operadorA ^ operadorB; // Operador de XOR bit a bit (^)
console.log("XOR: " + operadorXor); // 49
// Explicación con binarios:
// 0011 1100 -> 60
// 0000 1101 -> 13
// ------------ ^ (XOR)
// 0011 0001 -> 49
let operadorNot = ~operadorA; // Operador de NOT bit a bit (~)
console.log("NOT: " + operadorNot); // -61
// Explicación con binarios:
// 0011 1100 -> 60
// ------------ ~ (NOT)
// 1100 0011 -> -61
let operadorDesplazamientoIzquierda = operadorA << 2; // Operador de desplazamiento a la izquierda (<<)
console.log("Desplazamiento a la izquierda: " + operadorDesplazamientoIzquierda); // 240
// Explicación con binarios:
// 0011 1100 -> 60
// --------- << (Desplazamiento a la izquierda de 2 bits)
// 1111 0000 -> 240
let operadorDesplazamientoDerecha = operadorA >> 2; // Operador de desplazamiento a la derecha (>>)
console.log("Desplazamiento a la derecha: " + operadorDesplazamientoDerecha); // 15
// Explicación con binarios:
// 0011 1100 -> 60
// --------- >> (Desplazamiento a la derecha de 2 bits)
// 0000 1111 -> 15
let operadorDesplazamientoDerechaSinSigno = operadorC >>> 2; // Operador de desplazamiento a la derecha sin signo (>>>)
console.log("Desplazamiento a la derecha sin signo: " + operadorDesplazamientoDerechaSinSigno); // 1073741821
// Explicación con binarios:
// 1111 1111 1111 1111 1111 1111 1111 0110 -> -10
// --------- >>> (Desplazamiento a la derecha sin signo de 2 bits)
// 0011 1111 1111 1111 1111 1111 1111 1101 -> 1073741821
} | // 2. Operadores Bit a Bit | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L61-L119 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadoresAsignacion | function operadoresAsignacion() {
console.log("3. Operadores de Asignación");
let asignacion = 5; // Operador de asignación (=)
console.log("Asignación: " + asignacion); // 5
asignacion += 5; // Operador de suma y asignación (+=)
console.log("Suma y asignación: " + asignacion); // 10
asignacion -= 5; // Operador de resta y asignación (-=)
console.log("Resta y asignación: " + asignacion); // 5
asignacion *= 5; // Operador de multiplicación y asignación (*=)
console.log("Multiplicación y asignación: " + asignacion); // 25
asignacion /= 5; // Operador de división y asignación (/=)
console.log("División y asignación" + asignacion); // 5
asignacion %= 3; // Operador de módulo y asignación (%=)
console.log("Modulo y asignación: " + asignacion); // 2
asignacion **= 3; // Operador de exponenciación y asignación (**=)
console.log("Exponenciación y asignación: " + asignacion); // 8
asignacion <<= 5; // Operador de desplazamiento a la izquierda y asignación (<<=)
console.log("Desplazamiento a izquierda: " + asignacion); // 256
// Explicación con binarios:
// 0000 0000 1000 -> 8
// --------- <<= (Desplazamiento a la izquierda de 5 bits)
// 0001 0000 0000 -> 256
// let desplazamient = suma >> resta;
asignacion >>= 2; // Operador de desplazamiento a la derecha y asignación (>>=)
console.log("Desplazamiento a derecha: " + asignacion); // 64
// Explicación con binarios:
// 0001 0000 0000 -> 256
// --------- >>= (Desplazamiento a la derecha de 2 bits)
// 0000 0100 0000 -> 64
// Operador de desplazamiento a la derecha sin signo y asignación (>>>=) desplaza los bits a la derecha
// sin importar si el numero es positivo o negativo para lo cual agrerga 0 a la izquierda
let a = -10;
a >>>= 2; // Operador de desplazamiento a la derecha sin signo y asignación (>>>=)
console.log("Despolazamient a derecha sin signo: " + a); // 1073741821
// Explicación con binarios:
// 1111 1111 1111 1111 1111 1111 1111 0110 -> -10
// --------- >>>= (Desplazamiento a la derecha sin signo de 2 bits)
// 0011 1111 1111 1111 1111 1111 1111 1101 -> 1073741821
let num1 = 60;
num1 &= 13; // Operador de AND bit a bit y asignación (&=)
console.log("Operador de AND bit a bit y asignación: " + num1); // 12
// Explicación con binarios:
// 0011 1100 -> 60
// 0000 1101 -> 13
// ------------ & (AND)
// 0000 1100 -> 12
num1 = 60;
num1 |= 13; // Operador de OR bit a bit y asignación (|=)
console.log("Operador de OR bit a bit y asignación: " + num1); // 61
// Explicación con binarios:
// 0011 1100 -> 60
// 0000 1101 -> 13
// ------------ | (OR)
// 0011 1101 -> 61
num1 = 60;
num1 ^= 13; // Operador de XOR bit a bit y asignación (^=)
console.log("Operador de XOR bit a bit y asignación" + num1); // 49
// Explicación con binarios:
// 0011 1100 -> 60
// 0000 1101 -> 13
// ------------ ^ (XOR)
// // 0011 0001 -> 49
} | // 3. Operadores de Asignación. | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L126-L202 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadoresComparacion | function operadoresComparacion() {
console.log("4. Operadores de Comparación");
let comparacionIgual = 5 == 5; // Operador de igualdad (==)
console.log("Igualdad: " + comparacionIgual); // true
let comparacionEstrictamenteIgual = 5 === 5; // Operador de igualdad estricta (===), no solo compara el valor sino también el tipo de dato
console.log("Igualdad estricta: " + comparacionEstrictamenteIgual); // true
let comparacionDistinto = 5 != 5; // Operador de distinto (!=)
console.log("Distinto: " + comparacionDistinto); // false
let comparacionEstrictamenteDistinto = 5 !== 5; // Operador de distinto estricto (!==), no solo compara el valor sino también el tipo de dato
console.log("Distinto estricto: " + comparacionEstrictamenteDistinto); // false
let comparacionMayorQue = 5 > 3; // Operador de mayor que (>)
console.log("Mayor que: " + comparacionMayorQue); // true
let comparacionMenorQue = 5 < 3; // Operador de menor que (<)
console.log("Menor que: " + comparacionMenorQue); // false
let comparacionMayorIgualQue = 5 >= 5; // Operador de mayor o igual que (>=)
console.log("Mayor o igual que: " + comparacionMayorIgualQue); // true
let comparacionMenorIgualQue = 5 <= 3; // Operador de menor o igual que (<=)
console.log("Menor o igual que: " + comparacionMenorIgualQue); // false
} | // 4. Operadores de Comparación | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L209-L235 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadoresLogicos | function operadoresLogicos() {
console.log("5. Operadores Lógicos");
let logicoAnd = true && false; // Operador AND lógico (&&) - Devuelve true si ambos operandos son true
console.log("AND lógico: " + logicoAnd); // false
let logicoOr = true || false; // Operador OR lógico (||) - Devuelve true si al menos uno de los operandos es true
console.log("OR lógico: " + logicoOr); // true
let logicoNot = !true; // Operador NOT lógico (!) - Devuelve true si el operando es false y viceversa
console.log("NOT lógico: " + logicoNot); // false
// Ejemplo de uso de operadores lógicos
let edad = 16;
let estaAcompanado = false;
let puedeVerPelicula = edad >= 18 || (edad >= 16 && estaAcompanado);
console.log(puedeVerPelicula);
// Cambiamos el valor de la variable estaAcompanado a valor contrario por diversión.
if (!puedeVerPelicula) {
console.log("Puedes ver la película");
} else {
console.log("No puedes ver la película");
}
} | // 5. Operadores Lógicos | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L242-L267 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadoresCadena | function operadoresCadena() {
console.log("6. Operadores de Cadena");
const num1 = 5;
const num2 = 27;
let cadena1 = "Hola, la suma de: " + num1 + " y " + num2 + " es " + (num1 + num2); // Concatenación (+)
console.log(cadena1); // Hola, la suma de: 5 y 5 es 10
} | // 6. Operadores de Cadena | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L274-L281 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operadorCondicional | function operadorCondicional() {
console.log("7. Operador Condicional (Ternario)");
let edad = 16;
let puedeVerPelicula2 = edad >= 18 ? "Puede ver la película" : "No puede ver la película"; // Operador condicional (Ternario)
console.log(puedeVerPelicula2); // No puede ver la película
} | // 7. Operador Condicional (Ternario) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L288-L295 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | dificultadExtra | function dificultadExtra() {
console.log("DIFICULTAD EXTRA");
for (let i = 10; i < 56; i++) {
if (i % 2 === 0 && i !== 16 && i % 3 !== 0) {
console.log(i);
}
}
} | // DIFICULTAD EXTRA - Crea un programa que imprima por consola todos los números comprendidos entre 10 y 55 (incluidos) | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/llonardo798.ts#L338-L346 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | ejercicioExtra | function ejercicioExtra(): any {
for (let i = 10; i <= 55; i++) {
if (i % 2 === 0 && i !== 16 && i % 3 !== 0) {
console.log(i);
}
}
} | // Ejercicio extra | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/miguelex.ts#L120-L126 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | someFunction | function someFunction(): void {
console.log("Hello World");
} | // "John" | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L253-L255 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | add | function add(a: number, b: number): number {
return a + b;
} | // return | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L385-L387 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | throwError | function throwError(): never {
throw new Error("Something went wrong");
} | // throw | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L404-L406 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | fetchData | async function fetchData() {
try {
const response = await fetch("https://api.example.com/data");
const data = await response.json();
console.log(data);
} catch (error) {
console.error("Error al obtener los datos:", error);
}
} | // ---------------------- ESTRUCTURAS DE CONTROL DE ASYNC ------------------- // | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L412-L420 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | isEven | function isEven(num: number): boolean {
return num % 2 === 0;
} | /**
* Verifica si un número es par
* @param num - Número a verificar
* @returns true si el número es par
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L450-L452 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | isNotExcludedNumber | function isNotExcludedNumber(num: number): boolean {
return num !== conf.EXCLUDED_NUMBER;
} | /**
* Verifica si un número no es el número excluido (conf.EXCLUDED_NUMBER)
* @param num - Número a verificar
* @returns true si el número no es conf.EXCLUDED_NUMBER
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L459-L461 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | isNotMultipleOf | function isNotMultipleOf(num: number, divisor: number): boolean {
return num % divisor !== 0;
} | /**
* Verifica si un número no es múltiplo de un valor dado
* @param num - Número a verificar
* @param divisor - Valor divisor
* @returns true si el número no es múltiplo del divisor
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L469-L471 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | isEvenAndValid | function isEvenAndValid(num: number): boolean {
return isEven(num)
&& isNotExcludedNumber(num)
&& isNotMultipleOf(num, conf.MULTIPLE_OF_X);
} | /**
* Verifica si un número es par, no es conf.EXCLUDED_NUMBER y no es múltiplo de
* conf.MULTIPLE_OF_X
* @param num - Número a verificar
* @returns true si el número cumple todas las condiciones
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mikelroset.ts#L479-L483 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | saludar | function saludar(): void{
return console.log('Hello World!')
} | //Funcion por Declaracion | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/AChapeton.ts#L9-L11 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | arrow | const arrow: () => void = () => {
return console.log('Arrow function')
} | //Arrow Function | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/AChapeton.ts#L30-L32 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sinParametros | const sinParametros: () => void = () => {
return console.log('Sin parametros')
} | // *** FORMAS DE USO DE FUNCIONES *** | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/AChapeton.ts#L50-L52 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | saludarAlMundo | function saludarAlMundo(): void {
console.log("¡Hola mundo!")
} | // Ejemplo de función sin parámetros ni retorno | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Andeveling.ts#L2-L4 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | duplicar | function duplicar(numero: number): number {
return numero * 2
} | // Ejemplo de función con un parámetro y retorno | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Andeveling.ts#L7-L9 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sumar | function sumar(a: number, b: number): number {
return a + b
} | // Ejemplo de función con varios parámetros y retorno | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Andeveling.ts#L12-L14 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | operacionesMatematicas | function operacionesMatematicas(): void {
function resta(a: number, b: number): number {
return a - b
}
const resultadoResta = resta(10, 5)
console.log("Resultado de la resta:", resultadoResta)
} | // Ejemplo de función dentro de función | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Andeveling.ts#L17-L24 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | cadenasRetornoNumero | function cadenasRetornoNumero(fizz: string = "fizz", buzz: string = "buzz"): number {
if (typeof fizz !== "string" || typeof buzz !== "string") {
throw new Error("Los argumentos deben ser cadenas de texto")
}
let contador = 0
for (let i = 1; i <= 100; i++) {
if (i % 3 === 0 && i % 5 === 0) {
console.log(fizz + buzz)
contador++
} else if (i % 3 === 0) {
console.log(fizz)
contador++
} else if (i % 5 === 0) {
console.log(buzz)
contador++
} else {
console.log(i)
}
}
return contador
} | // Funcion que recibe dos paremetros | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Andeveling.ts#L55-L75 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | saludar | function saludar(): void {
console.log("Hola mundo");
} | // FUNCIONES BASICAS DE TYPESCRIPT | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Danilo0203.ts#L8-L10 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | suma | function suma(a: number, b: number): number {
return a + b;
} | // 📌 Funcion Basica con parametros y retorno | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Danilo0203.ts#L14-L16 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | telefono | function telefono(llamadas: Function): string {
llamadas();
return `Telefono ocupado`;
} | // 📌 Funciones dentro de funciones 'CallBacks' | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Danilo0203.ts#L21-L24 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | scopeLocal | function scopeLocal() {
let variableLocal = "Variable Local"; // Solamente esta disponible en este bloque de codigo {}
variableGloblal = "Actualizacion de la Variable Global";
console.log(variableGloblal);
console.log(variableLocal);
} | // Esta disponible en todo el codigo | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Danilo0203.ts#L57-L62 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | imprimeMensaje | function imprimeMensaje(): void {
console.log("Mensaje");
} | /*
* EJERCICIO:
* - Crea ejemplos de funciones básicas que representen las diferentes
* posibilidades del lenguaje:
* Sin parámetros ni retorno, con uno o varios parámetros, con retorno...
* - Comprueba si puedes crear funciones dentro de funciones.
* - Utiliza algún ejemplo de funciones ya creadas en el lenguaje.
* - Pon a prueba el concepto de variable LOCAL y GLOBAL.
* - Debes hacer print por consola del resultado de todos los ejemplos.
* (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades)
*
* DIFICULTAD EXTRA (opcional):
* Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número.
* - La función imprime todos los números del 1 al 100. Teniendo en cuenta que:
* - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro.
* - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro.
* - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas.
* - La función retorna el número de veces que se ha impreso el número en lugar de los textos.
*
* Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos.
* Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda.
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L25-L27 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | imprimeEsteMensaje | function imprimeEsteMensaje(mensaje: string): void {
console.log(mensaje);
} | // Función con um parámetro que no retorna nada. | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L32-L34 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sumaDosNumeros | function sumaDosNumeros(num1: number, num2: number): number {
return num1 + num2;
} | //Función con más de un parámetro de entrada. Devuelve un número como resultatdo. | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L39-L41 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | imprimeMensajeConFuncion | function imprimeMensajeConFuncion(): void {
imprimeEsteMensaje("Función dentro de otra función.");
} | // Función dentro de otra función | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L46-L48 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | muestraNumero | function muestraNumero() {
console.log("dentro muestra número: " + num);
} | //variable global | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L94-L96 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | muestraOtroNumero | function muestraOtroNumero() {
let otroNum = 10;
console.log("desde muestra otro número: " + otroNum);
} | // Si se declar la variable dentro de la función, solo sera accesible dentro de | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L101-L104 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | imprimeMultiplos | function imprimeMultiplos(str1: string, str2: string) {
let count: number = 0;
for (let index = 1; index <= 100; index++) {
let esMultiplo3 = index % 3 === 0;
let esMultiplo5 = index % 5 === 0;
if (esMultiplo3 && esMultiplo5) {
console.log(index + " " + str1 + " y " + str2);
} else if (esMultiplo3) {
console.log(index + " " + str1);
} else if (esMultiplo5) {
console.log(index + " " + str2);
} else {
console.log(index);
count++;
}
}
console.log("veces que se ha impreso el número: " + count);
} | /**
* EJERCICIO EXTRA
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Guillemduno.ts#L116-L134 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | minumero | function minumero() : number{
return 5;
} | // 1º Tipo de Funciones | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L3-L5 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | minombre | const minombre : () => string = () => {
return 'IgleDev';
} | // Tambien podemos hacerlas como una función flecha | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L16-L18 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sinretorno | function sinretorno() : void{
console.log('No retorno nada');
} | //Funciones sin retorno | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L23-L25 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | getNumero | function getNumero(num : number) : number{
return num;
} | //Funciones con un parámetro | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L29-L31 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sumar | function sumar(a : number, b : number) : number{
return a + b;
} | //Funciones con varios parametros | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L36-L38 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | concatenar | function concatenar(...args : string[]) : string{
return args.join(' ');
} | //Funciones con parámetros pero que no sabemos cuantos | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L43-L45 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | dametuNumero | function dametuNumero(num : number) : string{
return 'Mi número es el: ' + num;
} | // Funciones donde la pasamos un dato y devolvemos otro distinto | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L50-L52 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | error | function error() : never{
throw new Error('Error');
} | //Funciones que se utilizan para lanzar expeciones o errores | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L57-L59 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | factorialFunction | function factorialFunction(): (num: number) => number {
function calculateFactorial(num: number): number {
if (num <= 1) {
return 1;
} else {
return num * calculateFactorial(num - 1);
}
}
return calculateFactorial;
} | // 2º Función dentro de función | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L62-L72 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | identidad | function identidad<T>(dni: T): T {
return dni;
} | // 3º Funciones del propio lenguaje | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L79-L81 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | altaOrden | function altaOrden(callback: (x: number) => number): number {
return callback(10);
} | //Funciones de alta orden: Toman una o más funciones como argumentos o devuelven una función. | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L84-L86 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | ejercicio | function ejercicio(cadena1 : string, cadena2 : string) : number{
let cadenaxnumero = 0;
for(let i = 1; i <= 100; i++){
console.log(i);
if(i % 3 == 0 && i % 5 == 0){
cadenaxnumero++;
console.log(cadena1 + cadena2);
continue;
}else if(i % 5 == 0){
cadenaxnumero++;
console.log(cadena2);
continue;
}else if(i % 3 == 0){
cadenaxnumero++;
console.log(cadena1)
continue;
}
}
return cadenaxnumero;
} | // 5º Ejercicio Extra | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/IgleDev.ts#L102-L121 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | holaMundo | function holaMundo() : void {
console.log(`Hola mundo`);
} | /*
* EJERCICIO:
* - Crea ejemplos de funciones básicas que representen las diferentes
* posibilidades del lenguaje:
* Sin parámetros ni retorno, con uno o varios parámetros, con retorno...
* - Comprueba si puedes crear funciones dentro de funciones.
* - Utiliza algún ejemplo de funciones ya creadas en el lenguaje.
* - Pon a prueba el concepto de variable LOCAL y GLOBAL.
* - Debes hacer print por consola del resultado de todos los ejemplos.
* (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades)
*
* DIFICULTAD EXTRA (opcional):
* Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número.
* - La función imprime todos los números del 1 al 100. Teniendo en cuenta que:
* - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro.
* - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro.
* - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas.
* - La función retorna el número de veces que se ha impreso el número en lugar de los textos.
*
* Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos.
* Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda.
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Jaimerocel96.ts#L25-L27 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sumar | function sumar(a: number, b: number): number {
return a + b;
} | // Función con varios parámetros y retorno | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Jaimerocel96.ts#L32-L34 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | localGlobal | function localGlobal(): void {
let local : string = "Local";
console.log(global);
console.log(local);
let funcion = () => {
console.log('Función dentro de otra');
}
funcion();
} | // Función flecha dentro de otra función y variable local | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Jaimerocel96.ts | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | imprimeCadena | function imprimeCadena(str1: string, str2: string){
let k: number = 0;
for(let i = 0; i < 100; i++){
if(i % 3 === 0 && i % 5 === 0){
console.log(`${str1+str2}`)
}else if(i % 3 === 0){
console.log(`${str1}`)
}else if(i % 3 === 0){
console.log(`${str2}`)
}else{
console.log(i)
k++;
}
}
console.log(`El número se ha impreso ${k} veces.`);
} | // Ejercicio extra | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Jaimerocel96.ts#L59-L74 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | doSomething | function doSomething() {
console.log('Hola, soy una función sin retorno ni parámetros');
} | //EJERCICIO | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RicJDev.ts#L2-L4 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | fizzBuzz | function fizzBuzz(a: string = 'Fizz', b: string = 'Buzz') {
for (let i = 1; i <= 100; i++) {
if (i % 3 === 0 && i % 5 === 0) {
console.log(a + ' ' + b);
} else if (i % 3 === 0) {
console.log(a);
} else if (i % 5 == 0) {
console.log(b);
} else {
console.log(i);
}
}
} | //EXTRA | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RicJDev.ts#L101-L113 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sinParametros | function sinParametros(){
console.log("prueba de función sin parametros");
} | /*
* EJERCICIO:
* - Crea ejemplos de funciones básicas que representen las diferentes
* posibilidades del lenguaje:
* Sin parámetros ni retorno, con uno o varios parámetros, con retorno...*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RobertoAmaroHub.ts#L6-L8 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | conParametroRest | function conParametroRest(...valores:number[]){
let suma:number=0;
for(let i of valores){
suma+=i;
}
console.log(`la suma de todos los parametros es: ${suma}`)
} | //Otra característica de TypeScript es la posibilidad de pasar una lista indefinida de valores y que los reciba un vector. | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RobertoAmaroHub.ts#L40-L46 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | sumar | function sumar(valor1:number, valor2:number, valor3:number):number {
return valor1+valor2+valor3;
} | /**El operador Spread permite descomponer una estructura de datos en elementos individuales.
Es la operación inversa de los parámetros Rest. La sintaxis se aplica anteponiendo al nombre de la variable tres puntos:*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RobertoAmaroHub.ts#L58-L60 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | funcionPrincipal | function funcionPrincipal(){
console.log("llamado de la primera función")
function funcionAnidada(){
console.log("llamado a la función anidada")
}
funcionAnidada();
} | /*
* - Comprueba si puedes crear funciones dentro de funciones.*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RobertoAmaroHub.ts#L67-L73 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | contarLetrasEnFrase | function contarLetrasEnFrase(frase: string){
console.log(`la frase "${frase}" contiene ${frase.length} caracteres incluyendo espacios`);
} | /*
* - Utiliza algún ejemplo de funciones ya creadas en el lenguaje.*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RobertoAmaroHub.ts#L79-L81 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | returnNumber | function returnNumber(texto1: string, texto2: string):number{
let count:number=0;
for(let i=0; i<100; i++){
if(i%3==0 && i%5==0){
console.log(`los dos parámetros son ${texto1} y ${texto2}`);
} else if(i%3==0){
console.log(`primer parámetro: ${texto1}`);
} else if (i%5==0){
console.log(`segundo parámetro: ${texto2}`);
} else {
console.log(i);
count++;
}
}
return count;
} | /*
* DIFICULTAD EXTRA (opcional):
* Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número.
* - La función imprime todos los números del 1 al 100. Teniendo en cuenta que:
* - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro.
* - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro.
* - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas.
* - La función retorna el número de veces que se ha impreso el número en lugar de los textos.
*
* Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos.
* Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda.
*/ | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/RobertoAmaroHub.ts#L108-L123 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | greet | function greet(): void {
console.log("Hello, welcome to TypeScript!");
} | // Function with no parameters and no return | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Sac-Corts.ts#L2-L4 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | greetUser | function greetUser(name: string): void {
console.log(`Hello, ${name}!`);
} | // Function with one parameter and no return | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Sac-Corts.ts#L7-L9 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | addNumbers | function addNumbers(a: number, b: number): void {
console.log(`The sum of ${a} and ${b} is ${a + b}`);
} | // Function with multiple parameters and no return | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Sac-Corts.ts#L12-L14 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | square | function square(num: number): number {
return num * num;
} | // Function with one parameter and a return value | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Sac-Corts.ts#L17-L19 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | multiplyNumbers | function multiplyNumbers(a: number, b: number): number {
return a * b;
} | // Function with multiple parameters and a return value | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Sac-Corts.ts#L22-L24 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
roadmap-retos-programacion | github_2023 | mouredev | typescript | outerFunction | function outerFunction(): void {
console.log("This is the outer function");
// Inner function
function innerFunction(): void {
console.log("This is the inner function");
}
innerFunction();
} | // Nested Functions | https://github.com/mouredev/roadmap-retos-programacion/blob/70396a5dd6ec0b632acf1d316297e2acb778ff2d/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/Sac-Corts.ts#L27-L36 | 70396a5dd6ec0b632acf1d316297e2acb778ff2d |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.