ToCode

Kanalga Telegram’da o‘tish

טיפים קצרים למתכנתים מאת ינון פרק

Ko'proq ko'rsatish

Hindiston116 355 Texnologiyalar & Aralashmalar36 112

1 420

Obunachilar

+124 soatlar

+17 kunlar

-430 kunlar

182

Post ko'rishlar

~ 7824 soatlar

~ 9748 soatlar

12.82%

Muloqot nisbati

~ 2

Kuniga postlar

Ads index

beta

Postlar arxiv

1 420

מדריך Next.JS - פרק 1 התקנה ופרויקט ראשון השבוע הבלוג יצא לפגרה אבל כדי לא להשאיר את תיבת המייל שלכם ריקה מדי אשלח במהלך התקופה מדריך next.js שכתבתי מראש. מקווה שתמצאו אותו מועיל ונחזור אחרי חנוכה בכוחות מחודשים. מהו Next.JS נקסט ג'יי אס הוא סביבה לפיתוח יישומי Full Stack מבוססת ריאקט, המאפשרת לנו בפרויקט אחד לכתוב גם את קוד צד השרת וגם את קוד צד הלקוח. הדגש של הפריימוורק הוא על קלות בניית פרויקט ואינטגרציה חזקה בין קוד צד שרת לקוד צד לקוח, מה שהופך אותו לבחירה מאוד קלה לפרויקטי ריאקט חדשים. יותר מזה, next.js נוצר על ידי חברת vercel ויש לו כלי אוטומטי ל deployment על הענן שלהם, כך שאפשר להביא את הפרויקט ממכונת הפיתוח לאינטרנט בכמה דקות. פרויקט ראשון בשביל ליצור פרויקט next.js ראשון אני צריך רק להתקין את node.js ואז להפעיל את הפקודה:

npx create-next-app@latest 01-intro

ולענות על מספר שאלות (אני בחרתי בכולן את ברירות המחדל). זה משמעותית יותר מהיר וקל מלהקים קונפיגורציית וובפאק בעצמנו וזה אפילו יותר קל מיצירת פרויקט עם vite. אחרי יצירת הפרויקט אפשר לפתוח שרת לפיתוח מקומי על ידי:

cd 01-intro
npm run dev

פתיחת הפרויקט שנוצר בסביבת פיתוח תראה לנו שיש בסך הכל שני קבצים מעניינים בינתיים בתיקיית app, הראשון נקרא layout.tsx והשני נקרא page.tsx. ב layout אני מוצא את הקוד הבא:

import type { Metadata } from 'next'
import { Inter } from 'next/font/google'
import './globals.css'

const inter = Inter({ subsets: ['latin'] })

export const metadata: Metadata = {
  title: 'Create Next App',
  description: 'Generated by create next app',
}

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="en">
      <body className={inter.className}>{children}</body>
    </html>
  )
}

וב page.tsx את הקוד הבא:

import Image from 'next/image'

export default function Home() {
  return (
    <main className="flex min-h-screen flex-col items-center justify-between p-24">
      <div className="z-10 max-w-5xl w-full items-center justify-between font-mono text-sm lg:flex">
        <p className="fixed left-0 top-0 flex w-full justify-center border-b border-gray-300 bg-gradient-to-b from-zinc-200 pb-6 pt-8 backdrop-blur-2xl dark:border-neutral-800 dark:bg-zinc-800/30 dark:from-inherit lg:static lg:w-auto  lg:rounded-xl lg:border lg:bg-gray-200 lg:p-4 lg:dark:bg-zinc-800/30">
          Get started by editing&nbsp;
          <code className="font-mono font-bold">src/app/page.tsx</code>
        </p>
        <div className="fixed bottom-0 left-0 flex h-48 w-full items-end justify-center bg-gradient-to-t from-white via-white dark:from-black dark:via-black lg:static lg:h-auto lg:w-auto lg:bg-none">
          <a
            className="pointer-events-none flex place-items-center gap-2 p-8 lg:pointer-events-auto lg:p-0"
            href="https://vercel.com?utm_source=create-next-app&utm_medium=appdir-template&utm_campaign=create-next-app"
            target="_blank"
            rel="noopener noreferrer"
          >
            By{' '}
            <Image
              src="/vercel.svg"
              alt="Vercel Logo"
              className="dark:invert"
              width={100}
              height={24}
              priority
            />
          </a>
        </div>
      </div>

      <div className="relative flex place-items-center before:absolute before:h-[300px] before:w-[480px] before:-translate-x-1/2 before:rounded-full before:bg-gradient-radial before:from-white before:to-transparent before:blur-2xl before:content-[''] after:absolute after:-z-20 after:h-[180px] after:w-[240px] after:translate-x-1/3 after:bg-gradient-conic after:from-sky-200 after:via-blue-200 after:blur-2xl after:content-[''] before:dark:bg-gradient-to-br before:dark:from-transparent before:dark:to-blue-700 before:dark:opacity-10 after:dark:from-sky-900 after:dark:via-[#0141ff] after:dark:opacity-40 before:lg:h-[360px] z-[-1]">
        <Image
          className="relative dark:drop-shadow-[0_0_0.3rem_#ffffff70] dark:invert"

1 420

https://www.tocode.co.il/blog/2023-12-nextjs-01-intro

1 420

חידת גרמלין - Coalesce הקוד הבא היה אמור לבדוק אם קיים ורקטקס עם הערך bob במאפיין name, ואם לא קיים ליצור חדש, אבל הוא לא עושה בדיוק את מה שרצינו. מה עושה הקוד, מה הבעיה ואיך נתקן אותו?

g
  .V()
  .coalesce(
    __.has('person', 'name', 'bob'),
    __.addV('person').property('name', 'bob')
  )
  .iterate()

הבעיה בקוד הפקודה coalesce של גרמלין מקבלת מספר אפשרויות להתקדמות בגרף ומבצעת אותן לפי הסדר עד שמגיעה לאפשרות שמחזירה צומת תקין. לכן לכאורה הקוד היה אמור להתחיל מכל הצמתים בגרף, למצוא צומת שיש לו את המאפיין name עם הערך bob, אם קיים להחזיר אותו ואם לא קיים להגיע ל addV. אבל לא ככה זה עובד. הבעיה בקוד היא ש coalesce מופיע אחרי V() ולכן הוא יופעל על כל הצמתים בגרף, כלומר לכל צומת נבדוק בנפרד אם הוא מתאים ל has ואם לא ננסה להוסיף צומת כזה עם addV, מה שיגרום להוספה של המון צמתים. דוגמת הרצה בסקאלה עם הקוד הזה:

@main def main() =
  val graph = TinkerGraph.open
  val g = traversal.withEmbedded(graph)

  println(g.addV("person").property("name", "a").next())
  println(g.addV("person").property("name", "b").next())

  println("--- 1")
  println(g.V().elementMap().toList)

  g.V()
    .coalesce(
      has("person", "name", "bob"),
      addV("person").property("name", "bob"))
    .iterate()

  println("--- 2")
  println(g.V().elementMap().toList)

מדפיסה את הפלט:

--- 1
[{id=0, label=person, name=a}, {id=2, label=person, name=b}]
--- 2
[{id=0, label=person, name=a}, {id=2, label=person, name=b}, {id=4, label=person, name=bob}, {id=6, label=person, name=bob}]

כלומר נוצרו שני צמתים חדשים עם השם bob. פיתרון בעזרת fold איך מתקנים? הכי פשוט זה קודם לחפש את הצומת ואז עליו להפעיל את coalesce. הבעיה היא שניסיון כזה עלול להיכשל אם הצומת לא קיים ולעצור את כל השאילתה. לכן יש להוסיף צעד fold שאוסף את כל הצמתים המתאימים לרשימה ולפתוח את אותה רשימה בתוך ה coalesce. או בקיצור בקוד:

@main def main() =
  val graph = TinkerGraph.open
  val g = traversal.withEmbedded(graph)

  println(g.addV("person").property("name", "a").next())
  println(g.addV("person").property("name", "b").next())

  println("--- 1")
  println(g.V().elementMap().toList)

  g.V()
    .has("person", "name", "bob")
    .fold()
    .coalesce(
      unfold(),
      addV("person").property("name", "bob"))
    .iterate()

  println("--- 2")
  println(g.V().elementMap().toList)

מה שיוצר רק צומת אחד עם השם bob. פיתרון בעזרת merge בגירסאות מספיק חדשות של טינקרפופ אפשר להשתמש ב merge כדי לחסוך את כל הבלאגן הזה כשאנחנו מנסים למזג צומת לפי מאפיין כמו name. הקוד נראה ככה:

  g.mergeV(Map[Object, Object](
    T.label -> "person",
    "name" -> "bob"
  ).asJava)
  .iterate()

כל עוד המיזוג הוא לפי מאפיינים שאנחנו מכירים זה יהיה הפיתרון הכי טוב. כשצריך למזג לפי יחסים לצמתים אחרים (לדוגמה אם קיים צומת person שהוא friend של bob) אז נצטרך לחזור לטריק של ה coalesce וה fold.

1 420

https://www.tocode.co.il/blog/2023-12-gremlin-coalesce

1 420

תיקונים קלים, תיקונים קשים ובדיקות בפרויקט Node.JS שעבדתי עליו מצאתי את השורה הזאת:

const [host, port] = address.split(':');

והמשימה היתה להוסיף פורט ברירת מחדל, כך שאם הכתובת לא מסתיימת בנקודותיים ומספר נשתמש בברירת המחדל 8080. התיקון הקל הוא בסך הכל:

const [host, port = '8080'] = address.split(':');

התיקון הקשה היה להתמודד עם כל שאר הדברים שמשתמשים יכלו להכניס בתוך address, למשל להבין שמשתמשים יכולים לכתוב http בהתחלה, להוסיף נתיב, לטעות בשם של ה host, לכתוב כתובת IP לא תקינה או מיליון טעויות אחרות בסגנון. קוד טוב צריך להפריד בין המנגנון שמפענח את הקלט למנגנון שעושה משהו עם הקלט המפוענח, ולאפשר לכל אחד משני המנגנונים לדווח שגיאות בצורה שתתאים הכי טוב למשתמש. שינוי כזה הוא קשה כי השורה היתה קבורה בפונקציה של עשרות שורות והמנגנונים היו מעורבבים יחד. כשיש סט בדיקות טוב אנחנו מרגישים בנוח לבצע גם תיקונים קשים, אפילו כאלה שדורשים ריפקטורינג משמעותי. לצערנו ברוב המערכות כשהמנגנונים השונים בקוד מעורבבים יחד, זה בא יחד עם זה שלמערכת אין בדיקות ויש המון מקרי קצה לא מתועדים, כך שהתיקון הקשה נראה כמעט בלתי אפשרי. כן שווה לזכור שהתיקון הקשה לא יהיה התיקון הקשה האחרון בקוד. אם בכל זאת אנחנו מקבלים הזדמנות לבצע אותו, כדאי לנצל אותה כדי לכתוב סט בדיקות עבור התיקון הקשה הבא.

1 420

https://www.tocode.co.il/blog/2023-12-easy-hard-tests

1 420

טיפ סקאלה: החזרת תוצאה עתידית המנגנון המובנה של Future בסקאלה הוא אומנם פחות מתוחכם מספריות כמו cats effect אבל בהחלט יכול להיות שימושי בבעיות פשוטות, ולא דורש ארגון מחדש של קוד התוכנית. נראה איך זה עובד דרך דוגמה פשוטה. הפונקציה הבאה מייצרת ומחזירה רשימה של מספרים:

  def createNumbers(): List[Int] =
    (1 to 10).map(_ =>
      Thread.sleep(Random.nextInt(500))
      Random.nextInt(100)).toList

וכמובן יש טוויסט - בשביל לייצר מספר אנחנו מחכים עד חצי שניה עם Thread.sleep. אם ניקח את הרשימה מבחוץ וננסה להדפיס אותה עם קוד כזה:

createNumbers().foreach(println(_))

הקוד יחכה עד שהרשימה כולה מוכנה ורק אז ידפיס במכה אחת את כל ה-10 מספרים. זה עלול להיות בעייתי כי אם מאיזושהי סיבה התוכנית תסתיים עם שגיאה לפני שהצליחה לייצר את כל הרשימה אף מספר לא יודפס. בעזרת מנגנון Future אני יכול לייצר רשימה שתהיה זמינה לקוד החיצוני גם לפני שכל הפריטים חושבו במלואם. הרעיון בגדול הוא שבמקום להחזיר רשימה של מספרים אני מחזיר רשימה של תוצאות עתידיות (כן Future מייצג תוצאה עתידית של חישוב). זה הקוד:

  def createFutureNumbers(): List[Future[Int]] =
    (1 to 10).map(_ => Future[Int] {
      Thread.sleep(Random.nextInt(500))
      Random.nextInt(100)
    }).toList

בקוד החיצוני אני לוקח כל Future ו"מדביק" לו קוד שיבוצע אחרי שאותו חישוב עתידי יהיה מוכן. בדוגמת ההדפסה זה יהיה:

val futures = createFutureNumbers()
futures.foreach(f => f.onComplete(i => println(i.get)))

לאחר מכן אני רוצה לחכות עד שכל החישובים העתידיים יסתיימו, לכן אני הופך את רשימת החישובים העתידיים ל Future אחד שיהיה מוכן כשכל הפריטים ברשימה חושבו בעזרת הפונקציה sequence. פונקציה נוספת בשם Await.ready תחכה עד ש Future מסתיים וכך תאפשר לתוכנית לרוץ עד לסיום כל ההדפסות. סך הכל הקוד החיצוני יהיה:

  @main
  def f(): Unit =
      val futures = createFutureNumbers()
      futures.foreach(f => f.onComplete(i => println(i.get)))
      Await.ready(Future.sequence(futures), Duration.Inf)

יותר מזה, ה Future בסקאלה כולל פונקציה בשם flatMap שמאפשרת להוסיף לו המשך חישוב. בחזרה לדוגמה נניח שאחרי שהמספר מוכן התוכנית תחכה עוד מספר מילי שניות לפי המספר שחושב ואז תעלה אותו בריבוע, ובסוף תדפיס את ריבועי כל המספרים. הקוד המעודכן לזה יהיה בסך הכל:

  def f(): Unit =
      val futures = createFutureNumbers().map {f =>
        f.flatMap(i => Future({
          Thread.sleep(i)
          i * i
        }))
      }

      futures.foreach(f => f.onComplete(i => println(i.get)))
      Await.ready(Future.sequence(futures), Duration.Inf)

1 420

https://www.tocode.co.il/blog/2023-12-scala-futures

1 420

לא יכול ללמד את זה שני המימושים הבאים בפייתון לזיהוי האם מספר הוא ראשוני שקולים לגמרי:

* v1 - *
def is_prime_v1(n):
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True
    
* v2 - *
from math import sqrt
def is_prime_v2(n):
    return not any(n % i == 0 for i in range(2, int(sqrt(n)) + 1))

ההבדל היחיד הוא כמה מושגים צריך להכיר כדי להבין את הקוד. במימוש הראשון מספיק להבין מה זה פונקציה ולהתמודד עם לולאות for ו range. המימוש השני כבר דורש היכרות עם Generator Comprehension, עם הפונקציה any ועם פקודת import. מי מהשניים קריא יותר? קשה להגיד. מה שבטוח הוא שחשוב להתאים את הרמה המושגית של הקוד למערכת ולסביבה בה הוא נכתב. ב Code Review הערות כמו "הקוד מסורבל מדי" או "הקוד לא קריא" אומרות הרבה פעמים "הקוד משתמש בפחות מדי מושגים", ולצד השני, הערות כמו "הקוד מתוחכם מדי" או "הקוד קשה לתחזוקה" בסך הכל אומרות "הקוד משתמש ביותר מדי מושגים מהשפה". משחקים עם המדד בקוד שאנחנו כותבים יכולים ללמד אותנו הרבה על השפה והקוד עצמו.

1 420

https://www.tocode.co.il/blog/2023-12-unteachable

1 420

לא יכול ללמד את זה שני המימושים הבאים בפייתון לזיהוי האם מספר הוא ראשוני שקולים לגמרי:

* v1 - *
def is_prime_v1(n):
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True
    
* v2 - *
from math import sqrt
def is_prime_v2(n):
    return not any(n % i == 0 for i in range(2, int(sqrt(n)) + 1))

1 420

https://www.tocode.co.il/blog/2023-12-unteachable

1 420

מכתב פתוח לתלמיד שנרדם (או: ואם אני צריך עוד זמן) יש שני סוגים של שיעורים משעממים - לפעמים זה משעמם כי אנחנו מכירים את כל החומר, ולפעמים כי הקצב לא מתאים ואנחנו פשוט לא מבינים כלום. השיעמום מהסוג הראשון יותר קל. כשאני יודע מה קורה אני יכול לנווט בשלווה לחדשות, לפייסבוק, לטוויטר או לכל גנב זמן אחר. פעם בכמה דקות אפשר להוציא את השנורקל כדי לראות שהחומר עדיין מוכר. השיעמום היותר קשה הוא זה מהסוג השני. שיעמום של חוסר הבנה הוא מתיש, כי אנחנו משקיעים המון אנרגיה בלנסות להבין, בלנסות להדביק את הקצב. במבנה של הרצאה גם מאוד קשה לראות את הפער. זה השיעמום המרדים. כשנתקלים בשיעמום כזה האינסטינקט שלנו מטעה. באותו רגע אנחנו רק מחפשים "לסגור את הפער", לנסות "להבין כמה שאפשר", להמשיך להקשיב אפילו שזה משעמם כי למדנו בבית ספר שיש פה משהו חשוב ושההזדמנות הזאת לא תחזור. עכשיו מקשיבים, אחרי זה מבינים. ומרוב רצון להבין העיניים נעצמות והפה מפהק, כי הגוף כבר יודע מה שהמוח לא רוצה לשמוע. והאמת הכואבת היא שהפער יותר גדול ממה שהמוח היה רוצה לדמיין. זה לא איזה "רעיון" קטן שצריך לשמוע והכל יסתדר, אלא עבודת השלמה משמעותית כדי לסגור את אותו פער. גם אם בקורס נתנו לנושא חצי שעה, אולי אני צריך ארבע שעות כדי להבין את הנושא הזה. הקצב שלי יכול להיות שונה מהקצב של אחרים והניסיון ללמוד בקצב שלא מתאים לי הוא פשוט מתיש. במצב כזה הפיתרון הכי טוב והיחיד שעובד הוא להיצמד לקצב שלך, גם אם זה לא הקצב של הכיתה או הוידאו. זה בסדר לראות את אותו שיעור כמה פעמים. זה בסדר להשקיע שבועיים בדף תרגילים, גם אם מישהו אחר פתר אותו ביום. לימוד זה לא תחרות והקבוצה לא חכמה יותר מכל אחד מהאנשים בה. הקצב היחיד שעובד הוא הקצב שעובד עבורך.

1 420

https://www.tocode.co.il/blog/2023-12-wrong-pace

1 420

טיפ סקאלה: הדפסת דיבג באמצע Pipeline בשפות פונקציונאליות דינמיות כמו קלוז'ר או אליקסיר, יש אופרטור Pipeline ששולח את התוצאה של פונקציה אחת בתור קלט לפונקציה הבאה בתור. לדוגמה הקוד הבא בקלוז'ר:

(->> 10
  (range)
  (map #(* %1 %1))
  (reduce +)
  (println))

לוקח את המספר 10, שולח אותו בתור הפרמטר לפונקציה range, אחרי זה לוקח את התוצאה של range בתור קלט לפונקציית ה map, את התוצאה של map הוא שולח ל reduce ואת זה ישלח ל println כדי להדפיס. סך הכל נקבל על המסך את סכום ריבועי המספרים מאפס עד תשע. אם יש בעיה בחישוב אפשר להגדיר בקלות פונקציה שמדפיסה את הפרמטרים שקיבלה ומחזירה אותם, ואז להוסיף אותה באמצע ה Pipeline כדי לראות סטטוס ביניים:

(defn debug [n]
  (println n)
  n)

(->> 10
  (debug)
  (range)
  (debug)
  (map #(* %1 %1))
  (debug)
  (reduce +)
  (println))

הדפסות הביניים עוזרות להבין מה קורה שם ולתקן בעיות כשצריך. במעבר לסקאלה מאוד התגעגעתי למנגנון הזה, כיוון שבסקאלה קריאה בשרשרת לפונקציות משתמשת בתחביר המתודות של תכנות מונחה עצמים. ככה נראה קוד סקאלה מקביל לקלוז'ר מתחילת הפוסט:

  println(
    (0 to 9)
      .map(_.pow(2))
      .sum
  )

אז זה היה פשוט בסקאלה אני לא יכול להשתמש פעמיים בפרמטר של פונקציה אנונימית אבל במקום זה יש לי פונקציה להעלות בריבוע, טווח כולל את המספר האחרון לכן מסיימים בתשע ויש פונקציית sum אז לא צריכים את reduce. ובכל זאת שני דברים פוגעים פה בחוויה - הראשון הוא ש println צריך להיכתב בהתחלה בתור פונקציה, והשני שגם אם אכתוב פונקציית debug כמו שהיתה לי בקלוז'ר היא לא חלק מהפייפליין. לשמחתנו מנגנון ה Extensions של סקאלה מאפשר לפתור את שתי הבעיות יחסית בקלות. אני מגדיר Extension גנרי שיוסיף את הפונקציה debug לכל ערך בשפה. זה נראה ככה:

extension [A](value: A)
  def debug(): A =
    println(value)
    value
}

@main
def main(): Unit =
  println(
    (0 to 9)
      .debug()
      .map(_.pow(2))
      .debug()
      .sum
  )

והפלט:

NumericRange 0 to 9
Vector(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
285

יותר מזה, בגלל שחלק מהאוביקטים בשפה מחושבים בצורה עצלה (למשל Range), אפשר להוסיף עוד פונקציה שתהפוך איטרטורים לרשימות ואז תדפיס אותם, רק שימו לב לא להפעיל אותה על דברים אינסופיים:


extension [A](value: A)
  def debug(): A =
    println(value)
    value

  def eagerDebug(): A = value match {
    case it: Iterable[_] =>
      println(it.toList)
      value
    case it: Iterator[_] =>
      println(it.toList)
      value
    case _ =>
      println(value.getClass)
      value
  }

@main
def main(): Unit =
  println(
    (0 to 9)
      .eagerDebug()
      .map(_.pow(2))
      .debug()
      .sum
  )

ואם כבר הוספנו את debug נוכל להשתמש בה גם בסוף הפייפליין כדי להדפיס בסגנון קלוז'ר:

@main
def main(): Unit =
  (0 to 9)
    .eagerDebug()
    .map(_.pow(2))
    .debug()
    .sum
    .debug()

1 420

https://www.tocode.co.il/blog/2023-12-scala-debug-pipeline

1 420

סקריפטים ב JavaScript? תנו צ'אנס לדינוזאור אחת הבעיות בשימוש ב node.js לכתיבת סקריפטים היא הקובץ package.json, או יותר נכון הצורך לצרף אותו לסקריפט כדי להתקין את התלויות. התוכנית הבאה ב node.js מתוך קוד הדוגמה של המודול wikipedia על npm לא יכולה לרוץ לבד:

const wiki = require('wikipedia');

(async () => {
 try {
  const page = await wiki.page('Batman');
  console.log(page);
  //Response of type @Page object
  const summary = await page.summary();
  console.log(summary);
  //Response of type @wikiSummary - contains the intro and the main image
 } catch (error) {
  console.log(error);
  //=> Typeof wikiError
 }
})();

בשביל שהיא תעבוד אני צריך ליצור איתה בתיקיה קובץ package.json ולהפעיל npm install או להפעיל

npm install wikipedia

משורת הפקודה לפני הרצה. עכשיו בואו נראה איך אותו טריק יעבוד עם דינו. דבר ראשון צריך לשנות את שורת ה require ל import, ולציין שאני טוען את המודול מ npm כך שקוד התוכנית יהיה:

import wiki from 'npm:wikipedia';


(async () => {
 try {
  const page = await wiki.page('Batman');
  console.log(page);
  //Response of type @Page object
  const summary = await page.summary();
  console.log(summary);
  //Response of type @wikiSummary - contains the intro and the main image
 } catch (error) {
  console.log(error);
  //=> Typeof wikiError
 }
})();

ומכאן זה רק משתפר. אני מריץ את הקוד ודינו מתחיל להזהיר אותי:

$ deno run demo.js

⚠️  ┌ Deno requests env access to "npm_config_no_proxy".
   ├ Run again with --allow-env to bypass this prompt.
   └ Allow? [y/n] (y = yes, allow; n = no, deny) >

שים לב, הוא אומר, הסקריפט מעוניין לקרוא מידע ממשתנה סביבה ואפילו כותב את השם של משתנה הסביבה. אני יכול לאשר עם y או להריץ מחדש עם --allow-end כדי שלא ישאל יותר על גישה למשתני סביבה. אני מאשר וממשיכים לשאלות הבאות. כך זה נראה בסוף:

$ deno run demo.js

✅ Granted env access to "npm_config_no_proxy".
✅ Granted env access to "NPM_CONFIG_NO_PROXY".
✅ Granted env access to "no_proxy".
✅ Granted env access to "NO_PROXY".
✅ Granted env access to "npm_config_https_proxy".
✅ Granted env access to "NPM_CONFIG_HTTPS_PROXY".
✅ Granted env access to "https_proxy".
✅ Granted env access to "HTTPS_PROXY".
✅ Granted env access to "npm_config_proxy".
✅ Granted env access to "NPM_CONFIG_PROXY".
✅ Granted env access to "all_proxy".
✅ Granted env access to "ALL_PROXY".
✅ Granted read access to "/Users/ynonp/Library/Caches/deno/npm/node_modules".
✅ Granted read access to "/Users/ynonp/Library/Caches/deno/node_modules".
✅ Granted read access to "/Users/ynonp/Library/Caches/node_modules".
✅ Granted read access to "/Users/ynonp/Library/node_modules".
✅ Granted read access to "/Users/ynonp/node_modules".
✅ Granted read access to "/Users/node_modules".
✅ Granted read access to "/node_modules".
✅ Granted net access to "en.wikipedia.org".

ואחרי זה מגיע הפלט הרגיל של הסקריפט. אם אני סומך על הסקריפט אני יכול פעם הבאה להריץ אותו עם המתגים:

$ deno run --allow-net --allow-read --allow-env demo.js

כדי לדלג על השאלות. סך הכל כתיבה והרצת סקריפט עם דינו נתנה לי שני יתרונות משמעותיים על פני node: 1. אין צורך בקובץ package.json, כל התלויות רשומות בתוך קובץ הסקריפט וההתקנה קורית אוטומטית בהרצה הראשונה. 2. אני חושש הרבה פחות מקוד זדוני, כי בברירת המחדל הסקריפט רץ עם מעט מאוד הרשאות.

1 420

https://www.tocode.co.il/blog/2023-12-deno-javascript-scripts

1 420

היום למדתי - לא כזה פשוט לחפש מהסוף בביטוי רגולארי התחיל היום Advent Of Code ואומנם אני כנראה לא אצליח לפתור את כל החידות שלו השנה על היום הראשון אי אפשר לוותר. בחידה היומית היה צריך למצוא דברים בתוך טקסטים. לא כזה מסובך עד שנתקלים בטריק הקטן שמקלקל הכל. התרגיל והטריק הסיפור בגדול היה למצוא ספרות בתוך שורת טקסט, כשהספרות יכולות להופיע בתור ספרות ממש כמו 4, 9 או 2 או בתור שם הספרה כמו four, nine או two. אנחנו צריכים למצוא בהינתן שורת טקסט את הסיפרה הראשונה והסיפרה האחרונה בה. למשל בשורה:

הסיפרה הראשונה היא 2 והאחרונה היא 4. בשורה:

abc7d

הסיפרה 7 היא גם הסיפרה הראשונה וגם האחרונה. ובשורה:

eightwo

הסיפרה 8 היא הראשונה ו 2 היא האחרונה. ניסוי 1 - חיפוש כל המופעים רעיון ראשון שאפשר לנסות כדי למצוא את הסיפרה הראשונה והאחרונה הוא חיפוש גלובאלי, בפייתון זה יהיה:

>>> digits = [str(i) for i in range(10)] + ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]

>>> digits_r = '|'.join(digits)

>>> re.findall(digits_r, "1abc3")
['1', '3']

וזה עובד עד שזה מפסיק לעבוד:

>>> re.findall(digitsr, "eightwo")
['eight']

כי הבעיה שה t משותף גם ל eight וגם ל two ומנוע הביטויים הרגולאריים כבר איבד את ה t כשהוא מצא את eight. פיתרון - חיפוש הפוך בהיעדר דרך טובה לחפש מהסוף בביטוי רגולארי נדרשת יצירתיות - למשל להפוך את כל הטקסטים לפני החיפוש ואז להפוך חזרה אחרי שמוצאים כדי לדעת איזו סיפרה מצאנו. בפייתון זה קל:

>>> digits_re = '|'.join([d[::-1] for d in digits])
>>> [r[::-1] for r in re.findall(digits_re, "eightwo"[::-1])]
['two']

1 420

https://www.tocode.co.il/blog/2023-12-regexp-search-from-the-end