restate / v1.0.0

ಬೇಕಾದುದಕ್ಕೆ ಮಾತ್ರ ಸಬ್‌ಸ್ಕ್ರೈಬ್ ಮಾಡಿ

ಪ್ರತಿ ಕಾಂಪೊನೆಂಟ್ ಸ್ಟೋರ್‌ನ ಯಾವ ಭಾಗವನ್ನು ಅವಲಂಬಿಸಿದೆ ಎಂದು ಆಯ್ಕೆಮಾಡಿ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು shallow ನಿಂದ ಹೋಲಿಸಿ, ಬದಲಾವಣೆಗಳನ್ನು batch ನಿಂದ ಗುಂಪು ಮಾಡಿ, ಮತ್ತು ಬಾಹ್ಯ ಈವೆಂಟ್‌ಗಳನ್ನು ಜೋಡಿಸಿ.

ಈ ಪುಟದಲ್ಲಿselector ಕೊಡಿಪ್ರಯತ್ನಿಸಿshallow ನಿಂದ ಅನೇಕ ಫೀಲ್ಡ್‌ಗಳ ಆಯ್ಕೆಕಸ್ಟಮ್ ಹೋಲಿಕೆbatch ನಿಂದ ಬದಲಾವಣೆಗಳ ಗುಂಪುReact ಹೊರಗೆ ಸಬ್‌ಸ್ಕ್ರಿಪ್ಷನ್ಬಾಹ್ಯ ಈವೆಂಟ್‌ಗಳ ಜೋಡಣೆ

selector ಕೊಡಿ

ಕಾಂಪೊನೆಂಟ್‌ಗೆ ಬೇಕಾದುದನ್ನು ಆಯ್ಕೆಮಾಡುವ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಹುಕ್ ಕಾಲ್ ಮಾಡಿ. ಪ್ರತಿ ಬದಲಾವಣೆಯ ನಂತರ restate selector ಅನ್ನು ರನ್ ಮಾಡಿ, ಫಲಿತಾಂಶವನ್ನು ಹಿಂದಿನದರೊಂದಿಗೆ Object.is ಮೂಲಕ ಹೋಲಿಸುತ್ತದೆ. ಎರಡೂ ಸಮನಾಗಿದ್ದರೆ ಕಾಂಪೊನೆಂಟ್ ರೆಂಡರ್ ಆಗುವುದಿಲ್ಲ.

ಕಾರ್ಡ್ ಬದಲಾಗುತ್ತದೆ. ItemCount ರೆಂಡರ್ ಆಗುತ್ತದೆಯೇ?

ಇಲ್ಲ. ಅದರ selector ಇನ್ನೂ ಅದೇ ವಸ್ತು ಸಂಖ್ಯೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಆಯ್ಕೆ ಸಮನಾಗಿರುವುದರಿಂದ React ಗೆ ರೆಂಡರ್ ಮಾಡಲು ಕೇಳಲಾಗುವುದಿಲ್ಲ.

JavaScript / JSX
const useCart = restate({ items: ['Book'], coupon: '', note: '' });

function ItemCount() {
  // Re-renders only when the number of items changes.
  const count = useCart((cart) => cart.items.length);
  return <p>{count} items</p>;
}

ಪ್ರಯತ್ನಿಸಿ

ಫೀಲ್ಡ್‌ಗಳನ್ನು ಬದಲಿಸಿ ರೆಂಡರ್ ಕೌಂಟರ್‌ಗಳನ್ನು ಗಮನಿಸಿ. ಪ್ರತಿ ಬಾರಿ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಹಿಂತಿರುಗಿಸುವ selector ನೋಡಲು shallow ಆಫ್ ಮಾಡಿ.

ಉದಾಹರಣೆ ಸಿದ್ಧವಾಗುತ್ತಿದೆ…

shallow ನಿಂದ ಅನೇಕ ಫೀಲ್ಡ್‌ಗಳ ಆಯ್ಕೆ

selector ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸಿದಾಗ ಪ್ರತಿ ಬಾರಿ ಹೊಸದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಹೀಗಾಗಿ Object.is ಯಾವಾಗಲೂ ಬದಲಾವಣೆ ಕಾಣುತ್ತದೆ. ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ shallow ಕೊಡಿ: ಅದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ವಂತ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಒಂದು ಹಂತದ ಆಳದವರೆಗೆ ಹೋಲಿಸುತ್ತದೆ.

shallow ಅರೇ, Map ಮತ್ತು Set ಅಂಶಗಳನ್ನೂ ಒಂದು ಹಂತದ ಆಳದವರೆಗೆ ಹೋಲಿಸುತ್ತದೆ.

JavaScript / JSX
import { restate, shallow } from '@kkwaenggwari/restate';

function CartSummary() {
  const { count, coupon } = useCart(
    (cart) => ({ count: cart.items.length, coupon: cart.coupon }),
    shallow,
  );
  return (
    <p>
      {count} items · {coupon || 'no coupon'}
    </p>
  );
}

ಕಸ್ಟಮ್ ಹೋಲಿಕೆ

ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಯಾವುದೇ (left, right) => boolean ಫಂಕ್ಷನ್ ಸರಿಹೊಂದುತ್ತದೆ. shallow ಸಾಕಾಗದಿದ್ದಾಗ ಬಳಸಿ, ಉದಾಹರಣೆಗೆ id ಮೂಲಕ ಪಟ್ಟಿ ಹೋಲಿಸಲು.

JavaScript / JSX
const ids = useCart(
  (cart) => cart.items.map((item) => item.id),
  (left, right) => left.length === right.length && left.every((id, index) => id === right[index]),
);

batch ನಿಂದ ಬದಲಾವಣೆಗಳ ಗುಂಪು

ಪ್ರತಿ set ಸಬ್‌ಸ್ಕ್ರೈಬರ್‌ಗಳಿಗೆ ತಕ್ಷಣ ಸೂಚಿಸುತ್ತದೆ. ಒಂದು ಕ್ರಿಯೆ ಅನೇಕ ಸ್ಟೋರ್‌ಗಳನ್ನು ಬದಲಿಸಿದಾಗ ಅದನ್ನು batch ನಲ್ಲಿ ಸುತ್ತಿ: ಮೆಮೊರಿ ತಕ್ಷಣ ನವೀಕರಣಗೊಳ್ಳುತ್ತದೆ, ಸಬ್‌ಸ್ಕ್ರೈಬರ್‌ಗಳು callback ನಂತರ ಒಮ್ಮೆ ನಡೆಯುತ್ತಾರೆ.

JavaScript / JSX
import { batch } from '@kkwaenggwari/restate';

function checkout() {
  batch(() => {
    useCart.set((cart) => ({ ...cart, items: [] }));
    useOrder.set((order) => ({ ...order, status: 'paid' }));
  });
  // Subscribers run once, after both stores changed.
}

React ಹೊರಗೆ ಸಬ್‌ಸ್ಕ್ರಿಪ್ಷನ್

subscribeSelector ಆಯ್ಕೆಮಾಡಿದ ಮೌಲ್ಯ ಬದಲಾದಾಗ ಮಾತ್ರ, ಅದೇ ಐಚ್ಛಿಕ ಹೋಲಿಕೆ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ, ನಿಮ್ಮನ್ನು ಕಾಲ್ ಮಾಡುತ್ತದೆ.

JavaScript / JSX
const stop = useCart.subscribeSelector(
  (cart) => cart.items.length,
  (count, previous) => analytics.track('cart-size', { count, previous }),
);

ಬಾಹ್ಯ ಈವೆಂಟ್‌ಗಳ ಜೋಡಣೆ

restate ನ ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ updater ಆಗಿರಬಹುದು. ಮೊದಲ ಕಾಂಪೊನೆಂಟ್ ಅಥವಾ ಸಬ್‌ಸ್ಕ್ರೈಬರ್ ಕೇಳಲು ಆರಂಭಿಸಿದಾಗ ಅದು ನಡೆಯುತ್ತದೆ, ಮತ್ತು ಕೊನೆಯದು ನಿಂತಾಗ ಅದರ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆ ನಡೆಯುತ್ತದೆ. ಹೀಗಾಗಿ ಬ್ರೌಸರ್ ಈವೆಂಟ್‌ಗಳು, ಸಾಕೆಟ್‌ಗಳು ಮತ್ತು ಸೆನ್ಸರ್‌ಗಳು ಬೇಕಾದಷ್ಟು ಸಮಯ ಮಾತ್ರ ಜೋಡಣೆಯಲ್ಲಿರುತ್ತವೆ.

ಕೈಯಾರೆ ನಿಯಂತ್ರಣಕ್ಕೆ start() ಮತ್ತು stop() ಬಳಸಿ.

JavaScript / JSX
import { restate } from '@kkwaenggwari/restate';

// Listens while at least one component or subscriber uses the store.
export const useOnline = restate(true, ({ setState }) => {
  const update = () => setState(navigator.onLine);
  window.addEventListener('online', update);
  window.addEventListener('offline', update);
  update();
  return () => {
    window.removeEventListener('online', update);
    window.removeEventListener('offline', update);
  };
});

ದಸ್ತಾವೇಜಿನಲ್ಲಿ ಹುಡುಕಿ

ಎಲ್ಲ ಮಾರ್ಗದರ್ಶಿಗಳ ಶೀರ್ಷಿಕೆ, ವಿವರಣೆ ಮತ್ತು ವಿಷಯದಲ್ಲಿ ಹುಡುಕಿ.