DEV Community: Nguyen Hoang

bancon

Nguyen Hoang — Fri, 07 Feb 2025 03:46:37 +0000

$cycle_length = 2 * ($friends - 1);
$effective_time = $time % $cycle_length;

$current = 1;
$direction = 1;

for ($i = 0; $i < $effective_time; $i++) {
    $current += $direction;

    if ($current > $friends) {
        $direction = -1;
        $current = $friends - 1;
    } elseif ($current < 1) {
        $direction = 1;
        $current = 2;
    }
}

return [$current - $direction, $current];

add $effective_time == 0 = $cycle_length *2

baton

Nguyen Hoang — Fri, 07 Feb 2025 03:04:04 +0000

<?php

Complete the 'batonPass' function below. *
The function is expected to return an INTEGER_ARRAY.
The function accepts following parameters:
1. INTEGER friends
2. LONG_INTEGER time */

function batonPass($friends, $time) {
$current = 1;

$direction = 1; // 1, -1
$last_passer = null;
$last_received = null;

for ($i = 0; $i < $time; $i++) {
    $next = $current + $direction;

    if ($next > $friends) {
        $direction = -1;
        $next = $current - 1;
    } elseif ($next < 1) {
        $direction = 1;
        $next = $current + 1;
    }

    $last_passer = $current;
    $last_received = $next;

    $current = $next;
}

return [$last_passer, $last_received];

}

$fptr = fopen(getenv("OUTPUT_PATH"), "w");

$friends = intval(trim(fgets(STDIN)));

$time = intval(trim(fgets(STDIN)));

$result = batonPass($friends, $time);

fwrite($fptr, implode("\n", $result) . "\n");

fclose($fptr);

Khi nào dùng cái nào? ✅ Nếu hệ thống nhỏ, đơn giản dùng Choreography-based SAGA (event-driven) ✅ Nếu hệ thống phức tạp, có nhiều bước dùng Orchestration-based SAGA

Nguyen Hoang — Mon, 03 Feb 2025 02:43:41 +0000

Symbols - JavaScript const KEY1: unique symbol = Symbol('key1'); const KEY2: unique symbol = Symbol('key2'); const obj = { [KEY1]: 'Data for KEY1', [KEY2]: 'Data for KEY2', }; console.log(obj[KEY1]); // 'Data for KEY1'

Nguyen Hoang — Mon, 30 Dec 2024 07:14:48 +0000

set vs array

Nguyen Hoang — Fri, 27 Dec 2024 03:27:01 +0000

Tập hợp (Set) và mảng (Array) đều là iterable objects trong JavaScript và TypeScript, nghĩa là bạn có thể duyệt qua các phần tử của chúng bằng các cấu trúc lặp như for...of. Tuy nhiên, chúng có một số khác biệt quan trọng:

Sự khác biệt giữa Set và Array:
Tính duy nhất của phần tử:

Set: Các phần tử trong Set là duy nhất, tức là không có phần tử nào lặp lại. Nếu bạn thêm một phần tử đã tồn tại vào Set, nó sẽ không thay đổi.
Array: Mảng có thể chứa các phần tử trùng lặp.
Thứ tự các phần tử:

Set: Các phần tử trong Set được lưu trữ theo thứ tự chèn vào, nhưng không có chỉ mục (index) như trong mảng.
Array: Các phần tử trong mảng có thứ tự và được truy cập thông qua chỉ mục.
Hiệu suất:

Set: Các thao tác như tìm kiếm, thêm, và xóa phần tử trong Set thường có hiệu suất tốt hơn so với mảng, đặc biệt là khi Set chứa nhiều phần tử.
Array: Các thao tác tương tự trên mảng có thể chậm hơn, đặc biệt là khi mảng lớn và chứa nhiều phần tử trùng lặp.
Ví dụ minh họa:
Tạo và sử dụng Set:
TypeScript
const mySet = new Set();

// Thêm phần tử vào Set
mySet.add(1);
mySet.add(2);
mySet.add(2); // Không thêm phần tử này vì nó đã tồn tại

console.log(mySet); // Output: Set { 1, 2 }

// Duyệt qua các phần tử của Set
for (let value of mySet) {
console.log(value);
}
// Output:
// 1
// 2

// Kiểm tra sự tồn tại của một phần tử
console.log(mySet.has(1)); // Output: true
console.log(mySet.has(3)); // Output: false

// Xóa một phần tử
mySet.delete(1);
console.log(mySet); // Output: Set { 2 }
Tạo và sử dụng Array:
TypeScript
const myArray = [1, 2, 2];

// Duyệt qua các phần tử của Array
for (let value of myArray) {
console.log(value);
}
// Output:
// 1
// 2
// 2

// Kiểm tra sự tồn tại của một phần tử
console.log(myArray.includes(1)); // Output: true
console.log(myArray.includes(3)); // Output: false

// Xóa một phần tử (sử dụng filter để tạo một mảng mới không chứa phần tử đó)
const newArray = myArray.filter(item => item !== 1);
console.log(newArray); // Output: [2, 2]
2 vulnerabilities detected
Tóm tắt:
Set đảm bảo tính duy nhất của các phần tử và thường có hiệu suất tốt hơn cho các thao tác tìm kiếm, thêm, và xóa.
Array cho phép các phần tử trùng lặp và các phần tử có thứ tự, truy cập thông qua chỉ mục.
Hy vọng điều này giúp bạn hiểu rõ hơn về sự khác biệt giữa Set và Array!

larvel queue not dispath

Nguyen Hoang — Thu, 05 Dec 2024 06:43:54 +0000

queue:listen and queue:work not working on windows

It ok
append "database"

php artisan queue:work database --queue=email-marketing-queue --sleep=3 --tries=3

add item to array

Nguyen Hoang — Mon, 25 Nov 2024 02:07:32 +0000

const [items, setItems] = useState([]);
const [input, setInput] = useState("");

const handleAddItem = () => {
if (input.length > 0) {
setItems([...items, input]);
setInput('');
}
};

react day 1

Nguyen Hoang — Fri, 22 Nov 2024 05:07:48 +0000

Your task is to create a React application called "Code Review Feedback" that tracks and manages feedback on various aspects of code quality. The component should have upvote and downvote functionality for each aspect, and it must meet all specified requirements.

image

Detailed Requirements

The CodeReviewFeedback component displays five aspects: Readability, Performance, Security, Documentation, and Testing.
Each aspect has two buttons labeled "Upvote" and "Downvote" to allow users to vote.
The initial count for upvotes and downvotes for each aspect is set to zero.
Clicking the "Upvote" button should increment the upvote count for that aspect by 1.
Clicking the "Downvote" button should increment the downvote count for that aspect by 1.
Ensure the counts update in the UI immediately upon clicking.
The component should have a subtle animation when the voting count is updated to enhance the user experience.

Sample Interaction
Initial State

Display all five aspects with their respective upvote and downvote buttons.
Each aspect shows an initial count of 0 for upvotes and downvotes.
User Action 1

User clicks "Upvote" for Readability.
The upvote count for Readability displays 1.
User Action 2

User clicks "Downvote" for Performance.
The downvote count for Performance displays 1.
User Action 3 3. User clicks "Upvote" for Security and Documentation multiple times. 4. The upvote count for Security displays 2 and Documentation displays 3.

Hey there! Please enter the full-screen mode for the best experience
Authorishanhackerrank
DifficultyMedium
Max Score60
Submitted By195
Need Help?
View discussions
View top submissions
rate this challenge

MORE DETAILS
Download problem statement
Suggest Edits
Share on Facebook

`import React, { useState } from "react";

const categories = [
{ id: 0, name: "Readability" },
{ id: 1, name: "Performance" },
{ id: 2, name: "Security" },
{ id: 3, name: "Documentation" },
{ id: 4, name: "Testing" },
];

const FeedbackCategory = ({ id, name, upvotes, downvotes, onUpvote, onDownvote }) => (

{name}

{/* Upvote button /}
className="py-10 px-15"
data-testid={`upvote-btn-${id}`}
onClick={() => onUpvote(id)}
>
👍 Upvote

{/ Downvote button /}
className="py-10 px-15 danger"
data-testid={`downvote-btn-${id}`}
onClick={() => onDownvote(id)}
>
👎 Downvote

{/ Display counts */}

Upvotes: {upvotes}

Downvotes: {downvotes}

);

const FeedbackSystem = () => {
const [votes, setVotes] = useState(
categories.reduce(
(acc, category) => ({
...acc,
[category.id]: { upvotes: 0, downvotes: 0 },
}),
{}
)
);

const handleUpvote = (id) => {
setVotes((prevVotes) => ({
...prevVotes,
[id]: { ...prevVotes[id], upvotes: prevVotes[id].upvotes + 1 },
}));
};

const handleDownvote = (id) => {
setVotes((prevVotes) => ({
...prevVotes,
[id]: { ...prevVotes[id], downvotes: prevVotes[id].downvotes + 1 },
}));
};

return (

{categories.map(({ id, name }) => (
key={id}
id={id}
name={name}
upvotes={votes[id].upvotes}
downvotes={votes[id].downvotes}
onUpvote={handleUpvote}
onDownvote={handleDownvote}
/>
))}

);
};

export default FeedbackSystem;`

Data Transfer Object la gi khai niem nay tu dau ma ra

Nguyen Hoang — Tue, 19 Nov 2024 06:25:54 +0000

Data Transfer Object (DTO)
Data Transfer Object (DTO) là một mẫu thiết kế (design pattern) được sử dụng để đóng gói dữ liệu và truyền tải nó giữa các lớp hoặc tầng trong một ứng dụng mà không chứa bất kỳ logic kinh doanh nào. DTO giúp cô lập dữ liệu cần thiết cho một yêu cầu cụ thể, giảm sự phụ thuộc không cần thiết giữa các tầng và tối ưu hóa luồng dữ liệu.

Nguồn gốc
DTO lần đầu tiên được giới thiệu trong cuốn sách "Patterns of Enterprise Application Architecture" (2002) của Martin Fowler. Đây là một phần của các mẫu thiết kế nhằm giải quyết vấn đề giao tiếp giữa các tầng trong kiến trúc phần mềm, đặc biệt là trong các ứng dụng sử dụng mô hình Client-Server hoặc Service-Oriented Architecture (SOA).

Tại sao cần DTO?
Tách biệt logic và dữ liệu:

DTO chỉ dùng để mang dữ liệu, không chứa logic kinh doanh, đảm bảo rằng mỗi tầng chỉ nhận dữ liệu cần thiết.
Giảm thiểu sự rò rỉ của mô hình dữ liệu tầng backend lên tầng giao diện (frontend).
Tối ưu hiệu năng:

DTO có thể chỉ chứa các thuộc tính cần thiết, giúp giảm tải dữ liệu không cần thiết khi truyền qua mạng hoặc giữa các lớp.
Tăng tính bảo mật:

DTO có thể giới hạn thông tin được truyền ra ngoài, tránh việc lộ dữ liệu nhạy cảm từ database.
Dễ dàng bảo trì:

Khi thay đổi cấu trúc database hoặc logic backend, DTO có thể được điều chỉnh mà không làm ảnh hưởng đến các tầng khác.
Ví dụ về DTO

Không sử dụng DTO: Nếu bạn trực tiếp truyền mô hình Eloquent từ Laravel (hoặc ORM khác) ra API, bạn có thể truyền cả dữ liệu nhạy cảm:

php
Copy code
public function show(User $user)
{
return response()->json($user);
}
Kết quả JSON có thể bao gồm các trường không mong muốn như password, api_token, v.v.

Sử dụng DTO: php Copy code namespace App\DTO;

class UserDTO
{
public string $id;
public string $name;
public string $email;

public function __construct(string $id, string $name, string $email)
{
    $this->id = $id;
    $this->name = $name;
    $this->email = $email;
}

}
Trong Controller:

php
Copy code
use App\DTO\UserDTO;

public function show(User $user)
{
$userDTO = new UserDTO(
$user->id,
$user->name,
$user->email
);

return response()->json($userDTO);

}
Kết quả JSON chỉ chứa các trường cần thiết:

json
Copy code
{
"id": "123",
"name": "John Doe",
"email": "john.doe@example.com"
}
Ưu điểm của DTO
Cô lập dữ liệu:

Giúp phân tách dữ liệu từ tầng dữ liệu (Database) với tầng giao tiếp (API).
Tương thích dễ dàng với các thay đổi:

Nếu dữ liệu nguồn (database) thay đổi, DTO có thể được cập nhật mà không ảnh hưởng đến các tầng khác.
Giảm phụ thuộc giữa các tầng:

DTO là một cấu trúc trung gian, giảm sự liên kết chặt chẽ giữa tầng giao diện (UI) và tầng dữ liệu.
Nhược điểm của DTO
Tăng thêm lớp trừu tượng:

Việc triển khai DTO có thể làm tăng độ phức tạp, nhất là trong các ứng dụng nhỏ.
Yêu cầu thêm mã nguồn:

Bạn cần viết thêm các lớp DTO và các logic chuyển đổi (mapping), tăng thời gian phát triển.

Khi nào nên sử dụng DTO?
Ứng dụng lớn: Khi ứng dụng có nhiều tầng (frontend, backend, service) hoặc sử dụng các giao tiếp mạng (API, microservices).
Bảo mật dữ liệu: Khi muốn kiểm soát chặt chẽ dữ liệu nào được phép gửi ra ngoài.
Hiệu năng: Khi cần tối ưu hóa dữ liệu truyền qua mạng, chỉ gửi thông tin cần thiết.

Tại sao cần DTO?
Tách biệt logic và dữ liệu:

DTO có thể chỉ chứa các thuộc tính cần thiết, giúp giảm tải dữ liệu không cần thiết khi truyền qua mạng hoặc giữa các lớp.
Tăng tính bảo mật:

DTO có thể giới hạn thông tin được truyền ra ngoài, tránh việc lộ dữ liệu nhạy cảm từ database.
Dễ dàng bảo trì:

Khi thay đổi cấu trúc database hoặc logic backend, DTO có thể được điều chỉnh mà không làm ảnh hưởng đến các tầng khác.
Ví dụ về DTO

Không sử dụng DTO: Nếu bạn trực tiếp truyền mô hình Eloquent từ Laravel (hoặc ORM khác) ra API, bạn có thể truyền cả dữ liệu nhạy cảm:

php
Copy code
public function show(User $user)
{
return response()->json($user);
}
Kết quả JSON có thể bao gồm các trường không mong muốn như password, api_token, v.v.

Sử dụng DTO: php Copy code namespace App\DTO;

class UserDTO
{
public string $id;
public string $name;
public string $email;

public function __construct(string $id, string $name, string $email)
{
    $this->id = $id;
    $this->name = $name;
    $this->email = $email;
}

}
Trong Controller:

php
Copy code
use App\DTO\UserDTO;

public function show(User $user)
{
$userDTO = new UserDTO(
$user->id,
$user->name,
$user->email
);

return response()->json($userDTO);

}
Kết quả JSON chỉ chứa các trường cần thiết:

json
Copy code
{
"id": "123",
"name": "John Doe",
"email": "john.doe@example.com"
}
Ưu điểm của DTO
Cô lập dữ liệu:

Giúp phân tách dữ liệu từ tầng dữ liệu (Database) với tầng giao tiếp (API).
Tương thích dễ dàng với các thay đổi:

Nếu dữ liệu nguồn (database) thay đổi, DTO có thể được cập nhật mà không ảnh hưởng đến các tầng khác.
Giảm phụ thuộc giữa các tầng:

DTO là một cấu trúc trung gian, giảm sự liên kết chặt chẽ giữa tầng giao diện (UI) và tầng dữ liệu.
Nhược điểm của DTO
Tăng thêm lớp trừu tượng:

Việc triển khai DTO có thể làm tăng độ phức tạp, nhất là trong các ứng dụng nhỏ.
Yêu cầu thêm mã nguồn:

Bạn cần viết thêm các lớp DTO và các logic chuyển đổi (mapping), tăng thời gian phát triển.
Khi nào nên sử dụng DTO?
Ứng dụng lớn: Khi ứng dụng có nhiều tầng (frontend, backend, service) hoặc sử dụng các giao tiếp mạng (API, microservices).
Bảo mật dữ liệu: Khi muốn kiểm soát chặt chẽ dữ liệu nào được phép gửi ra ngoài.
Hiệu năng: Khi cần tối ưu hóa dữ liệu truyền qua mạng, chỉ gửi thông tin cần thiết.
Các công cụ hỗ trợ DTO
Một số framework và thư viện hỗ trợ việc tạo và xử lý DTO dễ dàng hơn:

Laravel: Dễ dàng tự định nghĩa DTO trong các lớp PHP đơn giản.
MapStruct (Java): Thư viện tự động tạo các lớp mapping giữa DTO và entity.
AutoMapper (.NET): Tự động ánh xạ entity sang DTO và ngược lại.

trong mo hinh ddd cac domain lien ket voi anhu the nao

Nguyen Hoang — Tue, 19 Nov 2024 04:31:38 +0000

Trong mô hình DDD (Domain-Driven Design), các domain được thiết kế để phản ánh logic nghiệp vụ của hệ thống một cách rõ ràng và được phân tách dựa trên ngữ cảnh (Bounded Context). Việc liên kết giữa các domain (Bounded Contexts) được thực hiện thông qua các phương pháp sau:

Phân cách domain qua Bounded Context Bounded Context đại diện cho một vùng trong hệ thống nơi một domain có các quy tắc và mô hình riêng. Các Bounded Contexts không nên phụ thuộc chặt chẽ vào nhau và chỉ tương tác khi cần thiết, thông qua các mối quan hệ rõ ràng.
Các phương pháp liên kết domain a. Context Mapping Là kỹ thuật mô tả và định nghĩa cách các Bounded Contexts giao tiếp với nhau. Một số kiểu liên kết phổ biến: Shared Kernel: Chia sẻ một phần nhỏ của mô hình (ví dụ: một số lớp hoặc module chung). Customer-Supplier: Một context đóng vai trò cung cấp dữ liệu, context khác tiêu thụ dữ liệu đó. Published Language: Giao tiếp thông qua các định dạng tiêu chuẩn (VD: JSON, XML) hoặc ngôn ngữ chung. Anti-Corruption Layer (ACL): Lớp chống nhiễu, giúp dịch dữ liệu từ context này sang context khác để tránh làm hỏng logic của domain. b. Domain Events Domain Events được sử dụng để giao tiếp giữa các domain một cách lỏng lẻo. Ví dụ: Khi Domain A thực hiện một hành động, nó tạo ra một event như "OrderPlaced". Domain B lắng nghe sự kiện này và xử lý (ví dụ: cập nhật trạng thái kho). Ưu điểm: Tách biệt rõ ràng giữa domain phát sự kiện và domain xử lý sự kiện. Hỗ trợ hệ thống phân tán hoặc kiến trúc microservices. c. Application Services Application Services (dịch vụ ứng dụng) nằm ngoài domain và chịu trách nhiệm phối hợp các domain. Application Services thường: Gửi lệnh tới domain khác. Lấy kết quả từ domain và trả lại cho người dùng hoặc hệ thống khác. d. Repositories Các domain có thể giao tiếp gián tiếp thông qua repositories. Repository cho phép truy xuất và lưu trữ dữ liệu mà không cần phụ thuộc vào chi tiết cụ thể của database. e. Shared Database (hạn chế sử dụng) Các domain sử dụng chung cơ sở dữ liệu. Hạn chế: Có thể gây xung đột giữa các domain. Khó khăn trong việc bảo trì và mở rộng.
Ví dụ thực tế Bối cảnh Giả sử bạn có một hệ thống thương mại điện tử với các domain sau:

Order Management: Quản lý đơn hàng.
Inventory Management: Quản lý kho.
Customer Management: Quản lý khách hàng.
Liên kết giữa các domain
Khi một đơn hàng được đặt:

Order Management tạo một Domain Event: OrderPlaced.
Inventory Management nhận sự kiện này, kiểm tra kho, và giảm số lượng tồn kho.
Customer Management:

Khi khách hàng tạo đơn hàng, Order Management có thể gọi một Application Service để:
Lấy thông tin khách hàng từ Customer Management.
Kiểm tra điều kiện hợp lệ của khách hàng trước khi xử lý đơn hàng.
Sử dụng ACL:

Nếu Inventory Management sử dụng hệ thống bên ngoài (ERP), lớp Anti-Corruption Layer chuyển đổi dữ liệu từ hệ thống ERP sang định dạng mà Inventory Management hiểu được.

Các điểm cần lưu ý Cố gắng giảm phụ thuộc trực tiếp giữa các domain: Sử dụng sự kiện (Domain Events). Giao tiếp qua Application Services hoặc ACL. Phân định rạch ròi giữa các Bounded Contexts: Mỗi context chỉ quan tâm đến nghiệp vụ của mình. Sử dụng Context Mapping để xác định rõ ràng cách các domain liên kết với nhau. Tóm tắt Domain liên kết thông qua: Context Mapping, Domain Events, Application Services, ACL, hoặc Repositories. Cách tiếp cận khuyên dùng: Ưu tiên giao tiếp lỏng lẻo (Domain Events). Hạn chế chia sẻ trực tiếp dữ liệu hoặc phụ thuộc chặt chẽ. Mục tiêu là giữ mỗi domain độc lập và dễ dàng mở rộng khi cần.

System-Design-Preparation

Nguyen Hoang — Wed, 23 Oct 2024 03:30:48 +0000

https://github.com/arkapg211002/System-Design-Preparation

https://www.geeksforgeeks.org/complete-roadmap-to-learn-system-design/

https://coursehunters.online/t/educative-io-design-gurus-grokking-the-system-design-interview-part-5/584

𝐭𝐡𝐞 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞𝐬 between 𝐆𝐢𝐭 𝐌𝐞𝐫𝐠𝐞 and 𝐆𝐢𝐭 𝐑𝐞𝐛𝐚𝐬𝐞.

Nguyen Hoang — Wed, 23 Oct 2024 03:24:54 +0000

Let me tell you 𝐭𝐡𝐞 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞𝐬 between 𝐆𝐢𝐭 𝐌𝐞𝐫𝐠𝐞 and 𝐆𝐢𝐭 𝐑𝐞𝐛𝐚𝐬𝐞.
𝘞𝘩𝘦𝘯 𝘸𝘦 𝐦𝐞𝐫𝐠𝐞 𝐜𝐡𝐚𝐧𝐠𝐞𝐬 𝘧𝘳𝘰𝘮 𝘰𝘯𝘦 𝘎𝘪𝘵 𝘣𝘳𝘢𝘯𝘤𝘩 𝘵𝘰 𝘢𝘯𝘰𝘵𝘩𝘦𝘳, 𝘸𝘦 𝘤𝘢𝘯 𝘶𝘴𝘦 ‘𝘨𝘪𝘵 𝘮𝘦𝘳𝘨𝘦’ 𝘰𝘳 ‘𝘨𝘪𝘵 𝘳𝘦𝘣𝘢𝘴𝘦’.

𝘛𝘩𝘦 𝘥𝘪𝘢𝘨𝘳𝘢𝘮 𝘣𝘦𝘭𝘰𝘸 𝘴𝘩𝘰𝘸𝘴 𝘩𝘰𝘸 𝘵𝘩𝘦 𝘵𝘸𝘰 𝘤𝘰𝘮𝘮𝘢𝘯𝘥𝘴 𝘸𝘰𝘳𝘬.

𝐆𝐢𝐭 𝐌𝐞𝐫𝐠𝐞
This creates a new commit G’ in the main branch. G’ ties the histories of both main and feature branches.

Git merge is 𝐧𝐨𝐧-𝐝𝐞𝐬𝐭𝐫𝐮𝐜𝐭𝐢𝐯𝐞. Neither the main nor the feature branch is changed.

𝐆𝐢𝐭 𝐑𝐞𝐛𝐚𝐬𝐞
Git rebase moves the feature branch histories to the head of the main branch. It creates new commits E’, F’, and G’ for each commit in the feature branch.

The benefit of rebase is that it has 𝐥𝐢𝐧𝐞𝐚𝐫 𝐜𝐨𝐦𝐦𝐢𝐭 𝐡𝐢𝐬𝐭𝐨𝐫𝐲.

Rebase can be dangerous if “the golden rule of git rebase” is not followed.

𝐓𝐡𝐞 𝐆𝐨𝐥𝐝𝐞𝐧 𝐑𝐮𝐥𝐞 𝐨𝐟 𝐆𝐢𝐭 𝐑𝐞𝐛𝐚𝐬𝐞
Never use it on public branches!