Preguntas para Entrevistas de Desarrollador Junior de React Native: Guía Completa

Introducción

React Native permite a los desarrolladores crear aplicaciones móviles nativas utilizando JavaScript y React. Con una única base de código, puedes crear aplicaciones tanto para iOS como para Android, lo que la convierte en una opción poderosa para el desarrollo móvil multiplataforma.

Esta guía cubre las preguntas esenciales de la entrevista para desarrolladores Junior de React Native. Exploramos los fundamentos de React, los componentes, los hooks, la navegación, la gestión del estado y los conceptos específicos para móviles para ayudarte a prepararte para tu primer puesto de desarrollador de React Native.

Fundamentos de React (6 preguntas)

1. ¿Qué es React Native y en qué se diferencia de React?

Respuesta:

React: Biblioteca de JavaScript para construir interfaces de usuario web
React Native: Framework para construir aplicaciones móviles nativas utilizando React
Diferencias clave:
- React Native renderiza a componentes nativos (no al DOM)
- Utiliza APIs nativas en lugar de APIs web
- Diferente enfoque de estilo (sin CSS, utiliza StyleSheet)
- Código específico de la plataforma para iOS y Android

// React (Web)
import React from 'react';

function App() {
  return <div className="container">Hola Web</div>;
}

// React Native (Mobile)
import React from 'react';
import { View, Text, StyleSheet } from 'react-native';

function App() {
  return (
    <View style={styles.container}>
      <Text>Hola Mobile</Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
});

Frecuencia: Muy común Dificultad: Fácil

2. ¿Cuáles son los componentes principales en React Native?

Respuesta: React Native proporciona componentes incorporados que se asignan a los elementos de la interfaz de usuario nativa:

View: Componente contenedor (como div en web)
Text: Muestra texto (todo el texto debe estar en el componente Text)
Image: Muestra imágenes
ScrollView: Contenedor desplazable
TextInput: Campo de entrada de texto
TouchableOpacity/Pressable: Elementos táctiles
FlatList: Renderizado eficiente de listas
Button: Componente de botón básico

import {
  View,
  Text,
  Image,
  TextInput,
  TouchableOpacity,
  StyleSheet,
} from 'react-native';

function MyComponent() {
  return (
    <View style={styles.container}>
      <Text style={styles.title}>Bienvenido</Text>
      <Image source={{ uri: 'https://example.com/image.jpg' }} style={styles.image} />
      <TextInput placeholder="Introduce el nombre" style={styles.input} />
      <TouchableOpacity style={styles.button} onPress={() => console.log('Pulsado')}>
        <Text style={styles.buttonText}>Haz clic</Text>
      </TouchableOpacity>
    </View>
  );
}

Frecuencia: Muy común Dificultad: Fácil

3. Explica la diferencia entre `View` y `ScrollView`.

Respuesta:

View: Contenedor estático. El contenido que excede los límites de la pantalla no es desplazable.
ScrollView: Contenedor desplazable. Renderiza todos los hijos a la vez (puede consumir mucha memoria para listas grandes).
Cuándo usar:
- View: Para layouts que caben en la pantalla
- ScrollView: Para pequeñas cantidades de contenido desplazable
- FlatList: Para listas grandes (renderiza solo los elementos visibles)

// View - no desplazable
<View style={{ height: 200 }}>
  <Text>Contenido 1</Text>
  <Text>Contenido 2</Text>
  {/* Si el contenido excede los 200px, se corta */}
</View>

// ScrollView - desplazable
<ScrollView style={{ height: 200 }}>
  <Text>Contenido 1</Text>
  <Text>Contenido 2</Text>
  <Text>Contenido 3</Text>
  {/* Se puede desplazar para ver todo el contenido */}
</ScrollView>

// FlatList - eficiente para listas grandes
<FlatList
  data={items}
  renderItem={({ item }) => <Text>{item.name}</Text>}
  keyExtractor={item => item.id}
/>

Frecuencia: Muy común Dificultad: Fácil

4. ¿Qué son los React Hooks y cuáles son los más utilizados?

Respuesta: Los Hooks son funciones que te permiten usar el estado y las características del ciclo de vida en componentes funcionales.

Hooks comunes:
- useState: Gestiona el estado del componente
- useEffect: Maneja los efectos secundarios (obtención de datos, suscripciones)
- useContext: Accede a los valores del contexto
- useCallback: Memoriza funciones
- useMemo: Memoriza cálculos costosos
- useRef: Referencia elementos DOM o persiste valores

import React, { useState, useEffect } from 'react';
import { View, Text, Button } from 'react-native';

function Counter() {
  const [count, setCount] = useState(0);
  
  useEffect(() => {
    console.log(`El conteo cambió a: ${count}`);
    
    // Función de limpieza
    return () => {
      console.log('Limpieza');
    };
  }, [count]); // Se ejecuta cuando el conteo cambia
  
  return (
    <View>
      <Text>Conteo: {count}</Text>
      <Button title="Incrementar" onPress={() => setCount(count + 1)} />
    </View>
  );
}

Frecuencia: Muy común Dificultad: Fácil

5. Explica el hook `useEffect` y su array de dependencias.

Respuesta: useEffect ejecuta efectos secundarios después del renderizado. El array de dependencias controla cuándo se ejecuta:

Sin array: Se ejecuta después de cada renderizado
Array vacío []: Se ejecuta una vez después del renderizado inicial
Con dependencias [dep1, dep2]: Se ejecuta cuando las dependencias cambian

import { useEffect, useState } from 'react';

function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  
  // Se ejecuta una vez al montar
  useEffect(() => {
    console.log('Componente montado');
  }, []);
  
  // Se ejecuta cuando userId cambia
  useEffect(() => {
    fetchUser(userId).then(data => setUser(data));
  }, [userId]);
  
  // Se ejecuta después de cada renderizado (evitar esto)
  useEffect(() => {
    console.log('Renderizado');
  });
  
  // Función de limpieza
  useEffect(() => {
    const subscription = subscribeToUpdates();
    
    return () => {
      subscription.unsubscribe(); // Limpieza al desmontar
    };
  }, []);
  
  return <Text>{user?.name}</Text>;
}

Frecuencia: Muy común Dificultad: Media

6. ¿Qué es el DOM Virtual y cómo lo usa React?

Respuesta: El DOM Virtual es una representación ligera de JavaScript del DOM real.

Proceso:
1. Cuando el estado cambia, React crea un nuevo árbol DOM Virtual
2. Lo compara con el DOM Virtual anterior (diffing)
3. Calcula los cambios mínimos necesarios
4. Actualiza solo las partes modificadas en el DOM real
Beneficios: Actualizaciones eficientes, mejor rendimiento

Frecuencia: Común Dificultad: Fácil

Componentes y Props (4 preguntas)

7. ¿Cuál es la diferencia entre Props y State?

Respuesta:

Props:
- Se pasan de padre a hijo
- De solo lectura (inmutables)
- Se utilizan para la configuración del componente
State:
- Se gestiona dentro del componente
- Mutable (se puede cambiar)
- Se utiliza para datos dinámicos

// Componente padre
function ParentComponent() {
  const [count, setCount] = useState(0);
  
  return (
    <ChildComponent 
      title="Contador"  // Props
      count={count}    // Props
      onIncrement={() => setCount(count + 1)}  // Props
    />
  );
}

// Componente hijo
function ChildComponent({ title, count, onIncrement }) {
  // No se pueden modificar las props
  // title = "Nuevo título"; // ¡Error!
  
  return (
    <View>
      <Text>{title}</Text>
      <Text>Conteo: {count}</Text>
      <Button title="Incrementar" onPress={onIncrement} />
    </View>
  );
}

Frecuencia: Muy común Dificultad: Fácil

8. ¿Qué son los Componentes Funcionales vs los Componentes de Clase?

Respuesta:

Componentes Funcionales:
- Sintaxis más sencilla
- Utilizan hooks para el estado y el ciclo de vida
- Preferidos en React moderno
Componentes de Clase:
- Enfoque más antiguo
- Utilizan this.state y métodos del ciclo de vida
- Todavía soportados pero menos comunes

// Componente Funcional (Moderno)
function Welcome({ name }) {
  const [count, setCount] = useState(0);
  
  useEffect(() => {
    console.log('Montado');
  }, []);
  
  return <Text>Hola, {name}</Text>;
}

// Componente de Clase (Legado)
class Welcome extends React.Component {
  constructor(props) {
    super(props);
    this.state = { count: 0 };
  }
  
  componentDidMount() {
    console.log('Montado');
  }
  
  render() {
    return <Text>Hola, {this.props.name}</Text>;
  }
}

Frecuencia: Común Dificultad: Fácil

9. ¿Cómo se pasan datos del componente hijo al componente padre?

Respuesta: Utiliza funciones de callback pasadas como props.

// Componente padre
function ParentComponent() {
  const [message, setMessage] = useState('');
  
  const handleMessageFromChild = (msg) => {
    setMessage(msg);
  };
  
  return (
    <View>
      <Text>Mensaje del hijo: {message}</Text>
      <ChildComponent onSendMessage={handleMessageFromChild} />
    </View>
  );
}

// Componente hijo
function ChildComponent({ onSendMessage }) {
  const [input, setInput] = useState('');
  
  const sendMessage = () => {
    onSendMessage(input); // Llama a la función del padre
  };
  
  return (
    <View>
      <TextInput value={input} onChangeText={setInput} />
      <Button title="Enviar al padre" onPress={sendMessage} />
    </View>
  );
}

Frecuencia: Muy común Dificultad: Fácil

10. ¿Qué es la prop `key` y por qué es importante?

Respuesta: La prop key ayuda a React a identificar qué elementos han cambiado, se han añadido o se han eliminado en las listas.

Propósito: Optimizar el rendimiento del renderizado
Requisitos: Debe ser único entre los hermanos, estable (no usar el índice si la lista puede cambiar)

// Bien - usando ID único
function UserList({ users }) {
  return (
    <FlatList
      data={users}
      keyExtractor={item => item.id} // Clave única
      renderItem={({ item }) => <Text>{item.name}</Text>}
    />
  );
}

// Mal - usando el índice (evitar si la lista puede cambiar)
function BadList({ items }) {
  return (
    <View>
      {items.map((item, index) => (
        <Text key={index}>{item}</Text> // No usar el índice
      ))}
    </View>
  );
}

// Bien - usando una propiedad única
function GoodList({ items }) {
  return (
    <View>
      {items.map(item => (
        <Text key={item.id}>{item.name}</Text>
      ))}
    </View>
  );
}

Frecuencia: Muy común Dificultad: Fácil

Estilos y Diseño (3 preguntas)

11. ¿Cómo se aplican estilos a los componentes en React Native?

Respuesta: React Native utiliza objetos de JavaScript para los estilos, no CSS.

API StyleSheet: Crea estilos optimizados
Estilos en línea: Objetos de estilo directos (menos rendimiento)
Flexbox: Sistema de diseño predeterminado

import { View, Text, StyleSheet } from 'react-native';

function StyledComponent() {
  return (
    <View style={styles.container}>
      <Text style={styles.title}>Título</Text>
      <Text style={[styles.text, styles.bold]}>Múltiples estilos</Text>
      <Text style={{ color: 'red' }}>Estilo en línea</Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    backgroundColor: '#fff',
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    color: '#333',
  },
  text: {
    fontSize: 16,
    color: '#666',
  },
  bold: {
    fontWeight: 'bold',
  },
});

Frecuencia: Muy común Dificultad: Fácil

12. Explica Flexbox en React Native.

Respuesta: Flexbox es el sistema de diseño principal en React Native.

Propiedades principales:
- flexDirection: row o column (predeterminado: column)
- justifyContent: Alinea a lo largo del eje principal
- alignItems: Alinea a lo largo del eje transversal
- flex: Tamaño proporcional

const styles = StyleSheet.create({
  container: {
    flex: 1,
    flexDirection: 'row', // Diseño horizontal
    justifyContent: 'space-between', // Espacia los elementos uniformemente
    alignItems: 'center', // Centra verticalmente
  },
  box1: {
    flex: 1, // Ocupa 1/3 del espacio
    backgroundColor: 'red',
  },
  box2: {
    flex: 2, // Ocupa 2/3 del espacio
    backgroundColor: 'blue',
  },
});

function FlexExample() {
  return (
    <View style={styles.container}>
      <View style={styles.box1} />
      <View style={styles.box2} />
    </View>
  );
}

Frecuencia: Muy común Dificultad: Media

13. ¿Cuál es la diferencia entre `margin` y `padding`?

Respuesta:

Padding: Espacio dentro del componente (entre el contenido y el borde)
Margin: Espacio fuera del componente (entre el componente y sus vecinos)

const styles = StyleSheet.create({
  box: {
    margin: 20,        // Espacio exterior
    padding: 10,       // Espacio interior
    backgroundColor: 'lightblue',
  },
  // Lados específicos
  specificBox: {
    marginTop: 10,
    marginBottom: 20,
    paddingLeft: 15,
    paddingRight: 15,
  },
  // Horizontal y vertical
  shorthand: {
    marginHorizontal: 20,  // izquierda y derecha
    marginVertical: 10,    // arriba y abajo
    paddingHorizontal: 15,
    paddingVertical: 5,
  },
});

Frecuencia: Común Dificultad: Fácil

Navegación (3 preguntas)

Respuesta: React Navigation es la biblioteca de navegación más popular para React Native.

Tipos:
- Stack Navigator: Pila de pantallas (push/pop)
- Tab Navigator: Pestañas inferiores
- Drawer Navigator: Menú lateral

import { NavigationContainer } from '@react-navigation/native';
import { createNativeStackNavigator } from '@react-navigation/native-stack';

const Stack = createNativeStackNavigator();

function App() {
  return (
    <NavigationContainer>
      <Stack.Navigator initialRouteName="Home">
        <Stack.Screen name="Home" component={HomeScreen} />
        <Stack.Screen name="Details" component={DetailsScreen} />
      </Stack.Navigator>
    </NavigationContainer>
  );
}

function HomeScreen({ navigation }) {
  return (
    <View>
      <Text>Pantalla de inicio</Text>
      <Button
        title="Ir a detalles"
        onPress={() => navigation.navigate('Details', { itemId: 42 })}
      />
    </View>
  );
}

function DetailsScreen({ route, navigation }) {
  const { itemId } = route.params;
  
  return (
    <View>
      <Text>Pantalla de detalles</Text>
      <Text>ID del elemento: {itemId}</Text>
      <Button title="Volver" onPress={() => navigation.goBack()} />
    </View>
  );
}

Frecuencia: Muy común Dificultad: Media

15. ¿Cómo se pasan parámetros entre pantallas?

Respuesta: Usa la función navigate con un segundo parámetro para los datos.

// Navegar con parámetros
function HomeScreen({ navigation }) {
  const user = { id: 1, name: 'John', email: '[email protected]' };
  
  return (
    <Button
      title="Ver perfil"
      onPress={() => navigation.navigate('Profile', { user })}
    />
  );
}

// Recibir parámetros
function ProfileScreen({ route }) {
  const { user } = route.params;
  
  return (
    <View>
      <Text>Nombre: {user.name}</Text>
      <Text>Email: {user.email}</Text>
    </View>
  );
}

// Actualizar parámetros
function EditScreen({ navigation }) {
  const updateUser = () => {
    navigation.setParams({ user: updatedUser });
  };
  
  return <Button title="Actualizar" onPress={updateUser} />;
}

Frecuencia: Muy común Dificultad: Fácil

16. ¿Qué son las opciones de navegación y cómo se personalizan los encabezados?

Respuesta: Las opciones de navegación controlan la apariencia y el comportamiento de la pantalla.

function HomeScreen({ navigation }) {
  useEffect(() => {
    navigation.setOptions({
      title: 'Mi inicio',
      headerStyle: {
        backgroundColor: '#f4511e',
      },
      headerTintColor: '#fff',
      headerTitleStyle: {
        fontWeight: 'bold',
      },
      headerRight: () => (
        <Button title="Info" onPress={() => alert('Info')} />
      ),
    });
  }, [navigation]);
  
  return <View><Text>Inicio</Text></View>;
}

// O establecer en el navegador
<Stack.Screen
  name="Home"
  component={HomeScreen}
  options={{
    title: 'Mi inicio',
    headerStyle: { backgroundColor: '#f4511e' },
    headerTintColor: '#fff',
  }}
/>

Frecuencia: Común Dificultad: Fácil

Datos y Almacenamiento (4 preguntas)

17. ¿Cómo se obtienen datos de una API en React Native?

Respuesta: Usa la API fetch o bibliotecas como Axios.

import { useState, useEffect } from 'react';
import { View, Text, ActivityIndicator } from 'react-native';

function UserList() {
  const [users, setUsers] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  
  useEffect(() => {
    fetchUsers();
  }, []);
  
  const fetchUsers = async () => {
    try {
      const response = await fetch('https://api.example.com/users');
      
      if (!response.ok) {
        throw new Error('La respuesta de la red no fue correcta');
      }
      
      const data = await response.json();
      setUsers(data);
    } catch (err) {
      setError(err.message);
    } finally {
      setLoading(false);
    }
  };
  
  if (loading) return <ActivityIndicator />;
  if (error) return <Text>Error: {error}</Text>;
  
  return (
    <FlatList
      data={users}
      renderItem={({ item }) => <Text>{item.name}</Text>}
      keyExtractor={item => item.id.toString()}
    />
  );
}

Frecuencia: Muy común Dificultad: Media

18. ¿Qué es AsyncStorage y cómo se usa?

Respuesta: AsyncStorage es un sistema de almacenamiento asíncrono de clave-valor simple para React Native.

Casos de uso: Preferencias del usuario, tokens, datos pequeños
No para: Grandes conjuntos de datos, consultas complejas (usar SQLite en su lugar)

import AsyncStorage from '@react-native-async-storage/async-storage';

// Guardar datos
const saveData = async (key, value) => {
  try {
    await AsyncStorage.setItem(key, value);
  } catch (error) {
    console.error('Error al guardar los datos:', error);
  }
};

// Guardar objeto
const saveUser = async (user) => {
  try {
    const jsonValue = JSON.stringify(user);
    await AsyncStorage.setItem('user', jsonValue);
  } catch (error) {
    console.error('Error al guardar el usuario:', error);
  }
};

// Leer datos
const getData = async (key) => {
  try {
    const value = await AsyncStorage.getItem(key);
    return value !== null ? value : null;
  } catch (error) {
    console.error('Error al leer los datos:', error);
  }
};

// Leer objeto
const getUser = async () => {
  try {
    const jsonValue = await AsyncStorage.getItem('user');
    return jsonValue != null ? JSON.parse(jsonValue) : null;
  } catch (error) {
    console.error('Error al leer el usuario:', error);
  }
};

// Eliminar datos
const removeData = async (key) => {
  try {
    await AsyncStorage.removeItem(key);
  } catch (error) {
    console.error('Error al eliminar los datos:', error);
  }
};

// Borrar todo
const clearAll = async () => {
  try {
    await AsyncStorage.clear();
  } catch (error) {
    console.error('Error al borrar el almacenamiento:', error);
  }
};

Frecuencia: Muy común Dificultad: Fácil

19. ¿Cuál es la diferencia entre `FlatList` y `ScrollView`?

Respuesta:

ScrollView:
- Renderiza todos los hijos a la vez
- Bueno para listas pequeñas
- Uso intensivo de memoria para listas grandes
FlatList:
- Renderiza solo los elementos visibles (carga perezosa)
- Eficiente para listas grandes
- Optimizaciones incorporadas

// ScrollView - renderiza todo
<ScrollView>
  {items.map(item => (
    <View key={item.id}>
      <Text>{item.name}</Text>
    </View>
  ))}
</ScrollView>

// FlatList - renderiza solo los elementos visibles
<FlatList
  data={items}
  renderItem={({ item }) => (
    <View>
      <Text>{item.name}</Text>
    </View>
  )}
  keyExtractor={item => item.id}
  // Optimizaciones de rendimiento
  initialNumToRender={10}
  maxToRenderPerBatch={10}
  windowSize={5}
/>

Frecuencia: Muy común Dificultad: Fácil

20. ¿Cómo se manejan los formularios y la entrada del usuario?

Respuesta: Usa componentes controlados con estado.

import { useState } from 'react';
import { View, TextInput, Button, Text } from 'react-native';

function LoginForm() {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const [errors, setErrors] = useState({});
  
  const validate = () => {
    const newErrors = {};
    
    if (!email) {
      newErrors.email = 'El email es obligatorio';
    } else if (!/\S+@\S+\.\S+/.test(email)) {
      newErrors.email = 'El email no es válido';
    }
    
    if (!password) {
      newErrors.password = 'La contraseña es obligatoria';
    } else if (password.length < 6) {
      newErrors.password = 'La contraseña debe tener al menos 6 caracteres';
    }
    
    setErrors(newErrors);
    return Object.keys(newErrors).length === 0;
  };
  
  const handleSubmit = () => {
    if (validate()) {
      console.log('Formulario enviado:', { email, password });
      // Enviar a la API
    }
  };
  
  return (
    <View>
      <TextInput
        placeholder="Email"
        value={email}
        onChangeText={setEmail}
        keyboardType="email-address"
        autoCapitalize="none"
      />
      {errors.email && <Text style={{ color: 'red' }}>{errors.email}</Text>}
      
      <TextInput
        placeholder="Contraseña"
        value={password}
        onChangeText={setPassword}
        secureTextEntry
      />
      {errors.password && <Text style={{ color: 'red' }}>{errors.password}</Text>}
      
      <Button title="Iniciar sesión" onPress={handleSubmit} />
    </View>
  );
}

Frecuencia: Muy común Dificultad: Media

Consejos de carrera recientes

Preguntas para Entrevistas de Desarrollador Junior de React Native: Guía Completa

Introducción

Fundamentos de React (6 preguntas)

1. ¿Qué es React Native y en qué se diferencia de React?

2. ¿Cuáles son los componentes principales en React Native?

3. Explica la diferencia entre `View` y `ScrollView`.

4. ¿Qué son los React Hooks y cuáles son los más utilizados?

5. Explica el hook `useEffect` y su array de dependencias.

6. ¿Qué es el DOM Virtual y cómo lo usa React?

Componentes y Props (4 preguntas)

7. ¿Cuál es la diferencia entre Props y State?

8. ¿Qué son los Componentes Funcionales vs los Componentes de Clase?

9. ¿Cómo se pasan datos del componente hijo al componente padre?

10. ¿Qué es la prop `key` y por qué es importante?

Estilos y Diseño (3 preguntas)

11. ¿Cómo se aplican estilos a los componentes en React Native?

12. Explica Flexbox en React Native.

13. ¿Cuál es la diferencia entre `margin` y `padding`?

Navegación (3 preguntas)

14. ¿Qué es React Navigation y cómo se usa?

15. ¿Cómo se pasan parámetros entre pantallas?

16. ¿Qué son las opciones de navegación y cómo se personalizan los encabezados?

Datos y Almacenamiento (4 preguntas)

17. ¿Cómo se obtienen datos de una API en React Native?

18. ¿Qué es AsyncStorage y cómo se usa?

19. ¿Cuál es la diferencia entre `FlatList` y `ScrollView`?

20. ¿Cómo se manejan los formularios y la entrada del usuario?

Consejos de carrera semanales que realmente funcionan

Consejos de carrera semanales que realmente funcionan

Publicaciones Relacionadas

Preguntas para Entrevistas de Desarrollador Mobile Junior (iOS): Guía Completa

Preguntas para Entrevistas de Desarrollador Mobile Junior (Android): Guía Completa

Preguntas para Entrevistas de Desarrollador Backend Junior (Python): Guía Completa

Crea un Currículum que Te Contrate 60% Más Rápido

Compartir esta publicación

Duplica tus Llamadas para Entrevistas

Consejos de carrera recientes

Introducción

Fundamentos de React (6 preguntas)

1. ¿Qué es React Native y en qué se diferencia de React?

2. ¿Cuáles son los componentes principales en React Native?

3. Explica la diferencia entre View y ScrollView.

4. ¿Qué son los React Hooks y cuáles son los más utilizados?

5. Explica el hook useEffect y su array de dependencias.

6. ¿Qué es el DOM Virtual y cómo lo usa React?

Componentes y Props (4 preguntas)

7. ¿Cuál es la diferencia entre Props y State?

8. ¿Qué son los Componentes Funcionales vs los Componentes de Clase?

9. ¿Cómo se pasan datos del componente hijo al componente padre?

10. ¿Qué es la prop key y por qué es importante?

Estilos y Diseño (3 preguntas)

11. ¿Cómo se aplican estilos a los componentes en React Native?

12. Explica Flexbox en React Native.

13. ¿Cuál es la diferencia entre margin y padding?

Navegación (3 preguntas)

14. ¿Qué es React Navigation y cómo se usa?

15. ¿Cómo se pasan parámetros entre pantallas?

16. ¿Qué son las opciones de navegación y cómo se personalizan los encabezados?

Datos y Almacenamiento (4 preguntas)

17. ¿Cómo se obtienen datos de una API en React Native?

18. ¿Qué es AsyncStorage y cómo se usa?

19. ¿Cuál es la diferencia entre FlatList y ScrollView?

20. ¿Cómo se manejan los formularios y la entrada del usuario?

Consejos de carrera semanales que realmente funcionan

Consejos de carrera semanales que realmente funcionan

Publicaciones Relacionadas

Preguntas para Entrevistas de Desarrollador Mobile Junior (iOS): Guía Completa

Preguntas para Entrevistas de Desarrollador Mobile Junior (Android): Guía Completa

Preguntas para Entrevistas de Desarrollador Backend Junior (Python): Guía Completa

Crea un Currículum que Te Contrate 60% Más Rápido

Compartir esta publicación

Duplica tus Llamadas para Entrevistas

3. Explica la diferencia entre `View` y `ScrollView`.

5. Explica el hook `useEffect` y su array de dependencias.

10. ¿Qué es la prop `key` y por qué es importante?

13. ¿Cuál es la diferencia entre `margin` y `padding`?

19. ¿Cuál es la diferencia entre `FlatList` y `ScrollView`?