One place for hosting & domains

      Las

      Cómo cambiar el estilo de las barras de desplazamiento con CSS


      Introducción

      En septiembre de 2018, las barras de desplazamiento de CSS de W3C definieron especificaciones para personalizar el aspecto de las barras de desplazamiento con CSS.

      A partir de 2020, 96 % de los usuarios de Internet ejecutan navegadores que admiten el estilo de barra de desplazamiento de CSS. Sin embargo, deberá escribir dos conjuntos de reglas de CSS para abarcar Blink y WebKit y también los navegadores de Firefox.

      En este tutorial, aprenderá a usar CSS para personalizar barras de desplazamiento para admitir navegadores modernos.

      Requisitos previos

      Para seguir este artículo, necesitará lo siguiente:

      Agregar estilo a las barras de desplazamiento en Chrome, Edge y Safari

      Actualmente, agregar estilo a las barras de desplazamiento para Chrome, Edge y Safari está disponible con el seudoelemento del prefijo de proveedor -webkit-scrollbar.

      A continuación, se muestra un ejemplo que utiliza los seudoelementos ::-webkit-scrollbar, ::-webkit-scrollbar-track y ::webkit-scrollbar-thumb:

      body::-webkit-scrollbar {
        width: 12px;               /* width of the entire scrollbar */
      }
      
      body::-webkit-scrollbar-track {
        background: orange;        /* color of the tracking area */
      }
      
      body::-webkit-scrollbar-thumb {
        background-color: blue;    /* color of the scroll thumb */
        border-radius: 20px;       /* roundness of the scroll thumb */
        border: 3px solid orange;  /* creates padding around scroll thumb */
      }
      

      A continuación, se muestra una captura de pantalla de la barra de desplazamiento que se genera con estas reglas de CSS:

      Captura de pantalla de una página web de ejemplo con una barra de desplazamiento personalizada con una barra de desplazamiento azul en un recuadro de desplazamiento anaranjado.

      Este código funciona en las últimas versiones de Chrome, Edge y Safari.

      Desafortunadamente, W3C abandonó formalmente esta especificación y probablemente quedará obsoleta con el paso del tiempo.

      Agregar estilo a las barras de desplazamiento en Firefox

      Actualmente, aplicar estilo a las barras de desplazamiento en Firefox está disponible con las nuevas barras de desplazamiento de CSS.

      A continuación, se muestra un ejemplo que utiliza las propiedades scrollbar-width y scrollbar-color:

      body {
        scrollbar-width: thin;          /* "auto" or "thin" */
        scrollbar-color: blue orange;   /* scroll thumb and track */
      }
      

      A continuación, se muestra una captura de pantalla de la barra de desplazamiento que se genera con estas reglas de CSS:

      Captura de pantalla de una página web de ejemplo con una barra de desplazamiento personalizada con una barra de desplazamiento azul en un recuadro de desplazamiento anaranjado.

      Esta especificación comparte algunos puntos en común con la especificación -webkit-scrollbar para controlar el color de la barra de desplazamiento. Sin embargo, actualmente no se puede modificar el relleno y la redondez del “botón de desplazamiento”.

      Crear estilos de barra de desplazamiento a prueba del futuro

      Puede escribir su CSS de tal manera que sea compatible con las especificaciones -webkit-scrollbar y CSS Scrollbars.

      A continuación, se muestra un ejemplo que utiliza scrollbar-width, scrollbar-color, ::-webkit-scrollbar, ::-webkit-scrollbar-track, ::webkit-scrollbar-thumb:

      /* Works on Firefox */
      * {
        scrollbar-width: thin;
        scrollbar-color: blue orange;
      }
      
      /* Works on Chrome, Edge, and Safari */
      *::-webkit-scrollbar {
        width: 12px;
      }
      
      *::-webkit-scrollbar-track {
        background: orange;
      }
      
      *::-webkit-scrollbar-thumb {
        background-color: blue;
        border-radius: 20px;
        border: 3px solid orange;
      }
      

      Los navegadores Blink y WebKit ignorarán las reglas que no reconocen y aplicarán las reglas -webkit-scrollbar. Los navegadores de Firefox ignorarán las reglas que no reconocen y aplicarán las reglas de CSS Scrollbars. Una vez que los navegadores Blink y WebKit ya no sean compatibles por completo con la especificación -webkit-scrollbar, regresarán fácilmente a la nueva especificación de las barras de CSS Scrollbar.

      Conclusión

      En este artículo, aprendió a usar CSS para agregar estilo a las barras de desplazamiento y garantizar que estos estilos sean reconocidos en la mayoría de los navegadores modernos.

      También es posible simular una barra de desplazamiento ocultando la barra de desplazamiento predeterminada y usando JavaScript para detectar la altura y la posición de desplazamiento. Sin embargo, estos enfoques tienen limitaciones a la hora de reproducir experiencias como el desplazamiento por inercia (por ejemplo, desactivar el movimiento al desplazarse con trackpads).

      Si desea obtener más información sobre CSS, consulte nuestra página del tema CSS para consultar ejercicios y proyectos de programación.



      Source link

      Cómo usar las instrucciones break, continue y pass cuando se trabaja con bucles en Python 3


      Introducción

      Usar bucles for y bucles while en Python le permite automatizar y repetir tareas de manera eficiente.

      Sin embargo, a veces, es posible que un factor externo influya en la forma en que se ejecuta su programa. Cuando esto sucede, es posible que prefiera que su programa cierre un bucle por completo, omita parte de un bucle antes de continuar o ignore ese factor externo. Puede hacer estas acciones con las instrucciones break, continue y pass.

      Instrucción break

      En Python, la instrucción break le proporciona la oportunidad de cerrar un bucle cuando se activa una condición externa. Debe poner la instrucción break dentro del bloque de código bajo la instrucción de su bucle, generalmente después de una instrucción if condicional.

      Veamos un ejemplo en el que se utiliza la instrucción break en un bucle for:

      number = 0
      
      for number in range(10):
          if number == 5:
              break    # break here
      
          print('Number is ' + str(number))
      
      print('Out of loop')
      
      

      En este pequeño programa, la variable number se inicia en 0. Luego, una instrucción for construye el bucle siempre que la variable number sea inferior a 10.

      En el bucle for, existe una instrucción if que presenta la condición de que si la variable number es equivalente al entero 5, entonces el bucle se romperá.

      En el bucle también existe una instrucción print() que se ejecutará con cada iteración del bucle for hasta que se rompa el bucle, ya que está después de la instrucción break.

      Para saber cuándo estamos fuera del bucle, hemos incluido una instrucción print() final fuera del bucle for.

      Cuando ejecutemos este código, el resultado será el siguiente:

      Output

      Number is 0 Number is 1 Number is 2 Number is 3 Number is 4 Out of loop

      Esto muestra que una vez que se evalúa el entero number como equivalente a 5, el bucle se rompe porque se indica al programa que lo haga con la instrucción break.

      La instrucción break hace que un programa interrumpa un bucle.

      Instrucción continue

      La instrucción continue da la opción de omitir la parte de un bucle en la que se activa una condición externa, pero continuar para completar el resto del bucle. Es decir, la iteración actual del bucle se interrumpirá, pero el programa volverá a la parte superior del bucle.

      La instrucción continue se encuentra dentro del bloque de código abajo de la instrucción del bucle, generalmente después de una instrucción if condicional.

      Usando el mismo programa de bucle for que en la sección anterior Instrucción break, emplearemos la instrucción continue en vez de la instrucción break:

      number = 0
      
      for number in range(10):
          if number == 5:
              continue    # continue here
      
          print('Number is ' + str(number))
      
      print('Out of loop')
      
      

      La diferencia al usar la instrucción continue en vez de una instrucción break radica en que nuestro código continuará a pesar de la interrupción cuando la variable number se evalúe como equivalente a 5. Veamos el resultado:

      Output

      Number is 0 Number is 1 Number is 2 Number is 3 Number is 4 Number is 6 Number is 7 Number is 8 Number is 9 Out of loop

      Aquí, Number is 5 nunca aparece en el resultado, pero el bucle continúa después de ese punto para imprimir líneas para los números 6 a 10 antes de cerrarse.

      Puede usar la instrucción continue para evitar código condicional profundamente anidado o para optimizar un bucle eliminando los casos frecuentes que desee rechazar.

      La instrucción continue hace que un programa omita determinados factores que surgen dentro de un bucle, pero luego continuará con resto de este.

      Instrucción Pass

      Cuando se activa una condición externa, la instrucción pass permite manejar la condición sin que el bucle se vea afectado de ninguna manera; todo el código continuará leyéndose a menos que se produzca la instrucción break u otra instrucción.

      Igual que con las demás instrucciones, la instrucción pass se encuentra dentro del bloque de código abajo de la instrucción del bucle, normalmente después de una instrucción if condicional.

      Usando el mismo bloque de código que antes, sustituiremos la instrucción break o continue con una instrucción pass:

      number = 0
      
      for number in range(10):
          if number == 5:
              pass    # pass here
      
          print('Number is ' + str(number))
      
      print('Out of loop')
      
      

      La instrucción pass que se produce después de la instrucción condicional if le indica al programa que continúe ejecutando el bucle e ignore el hecho de que la variable number se evalúa como equivalente a 5 durante una de sus iteraciones.

      Ejecutaremos el programa y consideraremos el resultado:

      Output

      Number is 0 Number is 1 Number is 2 Number is 3 Number is 4 Number is 5 Number is 6 Number is 7 Number is 8 Number is 9 Out of loop

      Al usar la instrucción pass en este programa, observamos que el programa se ejecuta exactamente como lo haría si no hubiera instrucción condicional en el programa. La instrucción pass le indica al programa que ignore esa condición y continúe ejecutando el programa como de costumbre.

      La instrucción pass puede crear clases mínimas o actuar como marcador de posición al trabajar en un nuevo código y pensar en un nivel de algoritmo antes de preparar detalles.

      Conclusión

      Las instrucciones break, continue y pass en Python le permitirán usar los bucles for y los bucles while en su código de manera más eficaz.

      Para trabajar más con las instrucciones break y pass, puede seguir el tutorial de nuestro proyecto “Cómo crear un Twitterbot con Python 3 y la Biblioteca Tweepy”.



      Source link

      Cómo funcionan las acciones asíncronas de Redux con Redux Thunk


      Introducción

      De forma predeterminada, las acciones de Redux se envían de forma síncrona, lo cual es un problema para cualquier aplicación no trivial que necesite comunicarse con una API externa o realizar efectos secundarios. Redux también admite el middleware que se encuentra entre la acción que se envía y la acción que llega a los reductores.

      Hay dos bibliotecas muy populares de middleware que permiten efectos secundarios y acciones asíncronas: Redux Thunk y Redux Saga. En este artículo, aprenderá sobre Redux Thunk.

      Thunk es un concepto de programación donde se utiliza una función para retrasar la evaluación o el cálculo de una operación.

      Redux Thunk es un middleware que le permite invocar creadores de acciones que devuelven una función en vez de un objeto de acción. Esa función recibe el método de envío de la tienda, que luego se utiliza para enviar acciones síncronas regulares dentro del cuerpo de la función una vez que se completaron las operaciones asíncronas.

      En este artículo, aprenderá cómo agregar Redux Thunk y cómo puede integrarse en una aplicación de tareas pendientes hipotética.

      Requisitos previos

      En esta artículo, se asume que tiene algunos conocimientos básicos de React y Redux. Puede consultar este artículo si recién está comenzando a usar Redux.

      Este tutorial se basa en una aplicación de tareas pendientes hipotética que rastrea las tareas que se deben realizar y completar. Podemos suponer que create-react-app se utilizó para generar una nueva aplicación React y que redux, react-redux y axios ya se instalaron.

      Aquí no se explica en detalle cómo crear una aplicación de tareas pendientes desde cero. Se presenta como un contexto conceptual para resaltar Redux Thunk.

      Cómo agregar redux-thunk

      Primero, utilice el terminal para navegar al directorio del proyecto e instalar el paquete redux-thunk en su proyecto:

      • npm install redux-thunk@2.3.0

      Nota: Redux Thunk solo tiene 14 líneas de código. Verifique el origen aquí para saber cómo funciona un middleware de Redux más de cerca.

      Ahora aplique el middleware cuando cree la tienda de su aplicación usando applyMiddleware de Redux. Dada una aplicación React con redux y react-redux, su archivo index.js podría verse así:

      src/index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import { Provider } from 'react-redux';
      import { createStore, applyMiddleware } from 'redux';
      import thunk from 'redux-thunk';
      import './index.css';
      import rootReducer from './reducers';
      import App from './App';
      import * as serviceWorker from './serviceWorker';
      
      // use applyMiddleware to add the thunk middleware to the store
      const store = createStore(rootReducer, applyMiddleware(thunk));
      
      ReactDOM.render(
        <Provider store={store}>
          <App />
        </Provider>,
        document.getElementById('root')
      );
      

      Ahora, importó y aplicó Redux Thunk en su aplicación.

      Cómo usar Redux Thunk en una aplicación de muestra

      Redux Thunk se usa con mayor frecuencia para comunicarse de manera asíncrona con una API externa y, así, recuperar o guardar datos. Redux Thunk facilita el envío de acciones que siguen el ciclo de vida de una solicitud a una API externa.

      Normalmente, crear un nuevo elemento de tarea implica enviar primero una acción para indicar que se inició la creación de un elemento de tarea. Luego, si el elemento de tarea se crea correctamente y el servidor externo lo devuelve, se envía otra acción con el nuevo elemento de tarea. En el caso de que se produzca un error y la tarea no se guarde en el servidor, se puede enviar una acción con el error.

      Veamos cómo se puede hacer esto usando Redux Thunk.

      En el componente de su contenedor, importe la acción y envíela:

      src/containers/AddTodo.js

      import { connect } from 'react-redux';
      import { addTodo } from '../actions';
      import NewTodo from '../components/NewTodo';
      
      const mapDispatchToProps = dispatch => {
        return {
          onAddTodo: todo => {
            dispatch(addTodo(todo));
          }
        };
      };
      
      export default connect(
        null,
        mapDispatchToProps
      )(NewTodo);
      

      La acción usará Axios para enviar una solicitud POST al punto de conexión de JSONPlaceholder (https://jsonplaceholder.typicode.com/todos):

      src/actions/index.js

      import {
        ADD_TODO_SUCCESS,
        ADD_TODO_FAILURE,
        ADD_TODO_STARTED,
        DELETE_TODO
      } from './types';
      
      import axios from 'axios';
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(`https://jsonplaceholder.typicode.com/todos`, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              dispatch(addTodoSuccess(res.data));
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      const addTodoSuccess = todo => ({
        type: ADD_TODO_SUCCESS,
        payload: {
          ...todo
        }
      });
      
      const addTodoStarted = () => ({
        type: ADD_TODO_STARTED
      });
      
      const addTodoFailure = error => ({
        type: ADD_TODO_FAILURE,
        payload: {
          error
        }
      });
      

      Observe cómo el creador de la acción addTodo devuelve una función, en lugar del objeto de la acción regular. Esa función recibe el método de envío de la tienda.

      Dentro del cuerpo de la función, primero envíe una acción síncrona inmediata a la tienda para indicar que empezó a guardar la tarea con la API externa. Luego, realice la solicitud POST real al servidor usando Axios. En caso de una respuesta exitosa del servidor, enviará una acción de éxito síncrona con los datos recibidos de la respuesta, pero, en caso de una respuesta fallida, enviará una acción síncrona diferente con el mensaje de error.

      Cuando se utiliza una API externa, como JSONPlaceholder en este caso, se puede ver el retraso real de la red. Sin embargo, si está trabajando con un servidor de backend local, las respuestas de la red pueden pasar demasiado rápido para experimentar el retraso de la red que experimentaría un usuario real, por lo que puede añadir un retraso artificial al desarrollar:

      src/actions/index.js

      // ...
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(ENDPOINT, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              setTimeout(() => {
                dispatch(addTodoSuccess(res.data));
              }, 2500);
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      // ...
      

      Para probar los escenarios de error, puede lanzar un error manualmente:

      src/actions/index.js

      // ...
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(ENDPOINT, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              throw new Error('addToDo error!');
              // dispatch(addTodoSuccess(res.data));
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      // ...
      

      Para completar, aquí hay un ejemplo de cómo se vería el reductor de tareas para manejar el ciclo de vida completo de la solicitud:

      src/reducers/todosReducer.js

      import {
        ADD_TODO_SUCCESS,
        ADD_TODO_FAILURE,
        ADD_TODO_STARTED,
        DELETE_TODO
      } from '../actions/types';
      
      const initialState = {
        loading: false,
        todos: [],
        error: null
      };
      
      export default function todosReducer(state = initialState, action) {
        switch (action.type) {
          case ADD_TODO_STARTED:
            return {
              ...state,
              loading: true
            };
          case ADD_TODO_SUCCESS:
            return {
              ...state,
              loading: false,
              error: null,
              todos: [...state.todos, action.payload]
            };
          case ADD_TODO_FAILURE:
            return {
              ...state,
              loading: false,
              error: action.payload.error
            };
          default:
            return state;
        }
      }
      

      Para qué sirve getState

      Además de recibir el método de envío del estado, la función devuelta por un creador de acciones asíncronas con Redux Thunk también recibe el método getState de la tienda, por lo que los valores actuales de la tienda se pueden ver así:

      src/actions/index.js

      export const addTodo = ({ title, userId }) => {
        return (dispatch, getState) => {
          dispatch(addTodoStarted());
      
          console.log('current state:', getState());
      
          // ...
        };
      };
      

      Al hacer lo que se menciona arriba, el estado actual simplemente se imprimirá en la consola.

      Por ejemplo:

      {loading: true, todos: Array(1), error: null}
      

      Usar getState puede ser útil para manejar las cosas de manera diferente según el estado actual. Por ejemplo, si desea limitar la aplicación a solo cuatro elementos de tareas a la vez, puede regresar de la función si el estado ya contiene la cantidad máxima de elementos de tareas:

      src/actions/index.js

      export const addTodo = ({ title, userId }) => {
        return (dispatch, getState) => {
          const { todos } = getState();
      
          if (todos.length > 4) return;
      
          dispatch(addTodoStarted());
      
          // ...
        };
      };
      

      Al hacer lo que se menciona arriba, la aplicación se limitará a cuatro elementos de tareas.

      Conclusión

      En este tutorial, aprendió a agregar Redux Thunk a una aplicación React para permitir el envío de acciones de forma asíncrona. Esto es práctico cuando se utiliza una tienda de Redux y API externas.

      Si desea aprender más sobre React, eche un vistazo a nuestra serie Cómo crear código en React.js, o consulte nuestra página del tema React para ver ejercicios y proyectos de programación.



      Source link