LibCode

arr.reduce(callback[, initialValue])

function callback(acc, currentValue, index, arr) {
    // acc — аккумулированное значение
    // currentValue — текущий элемент массива
    // index — индекс текущего элемента
    // arr — оригинальный массив
}

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, val) => acc + val, 0);
console.log(sum); // Output: 15

const nums = [5, 3, 9, 1, 11];
const maxNum = nums.reduce((prevMax, currVal) => Math.max(prevMax, currVal));
console.log(maxNum); // Output: 11

const users = [{ id: 1, name: 'John' }, { id: 2, name: 'Alice' }];
const userMap = users.reduce((map, user) => ({ ...map, [user.id]: user }), {});
console.log(userMap); // Output: {1: {id: 1, name: "John"}, 2: {id: 2, name: "Alice"}}

const fruits = ['apple', 'banana', 'orange'];
const fruitCount = fruits.reduce((count, fruit) => ({
    ...count,
    [fruit]: count[fruit] ? count[fruit] + 1 : 1
}), {});
console.log(fruitCount); // Output: { apple: 1, banana: 1, orange: 1 }

const fruits = ["Apple", "Banana", "Cherry"];
const [firstFruit, secondFruit] = fruits;

console.log(firstFruit); // "Apple"
console.log(secondFruit); // "Banana"

const person = { name: "John", age: 30 };
const { name, age } = person;

console.log(name); // "John"
console.log(age); // 30

const user = { fullName: "Jane Smith", birthYear: 1990 };
const { fullName: name, birthYear: year } = user;

console.log(name); // "Jane Smith"
console.log(year); // 1990

const config = { theme: "dark" };
const { theme = "light", language = "English" } = config;

console.log(theme); // "dark"
console.log(language); // "English"

const nestedObj = { profile: { name: "Bob", age: 25 } };
const { profile: { name, age } } = nestedObj;

console.log(name); // "Bob"
console.log(age); // 25

const name = "John";
const greeting = `Hello, ${name}!`;
console.log(greeting); // "Hello, John!"

const poem = `
  Розовый куст расцветает весной,
  Солнце сияет, прохладный покой.
`;
console.log(poem);

const price = 10;
const taxRate = 0.15;
const totalPrice = `Total Price: \$${price * (1 + taxRate)}`;
console.log(totalPrice); // Total Price: $11.5

function highlight(strings, ...values) {
    return strings.raw[0].trim() + "<b>" + values.join("</b>\n<b>") + "</b>";
}

const list = highlight`Item 1\nItem 2\nItem 3`;
console.log(list); // Item 1<b>Item 2</b>\n<b>Item 3</b>

// Обычная функция
function greet(name) {
    return `Hello, ${name}!`;
}

// Стрелочная функция
const greet = (name) => `Hello, ${name}!`;

// До ES6
var squares = [1, 2, 3].map(function(num) {
    return num * num;
});

// После ES6
const squares = [1, 2, 3].map(num => num * num);

const add = (a, b) => a + b;

const obj = {
    name: "John",
    greet: () => `Hello, ${this.name}`, // this будет undefined в strict mode
};

// Лучше использовать обычную функцию
const obj = {
    name: "John",
    greet() {
        return `Hello, ${this.name}`;
    },
};

const numbers = [1, 2, 3, 4, 5];
const evenNumbers = numbers.filter(num => num % 2 === 0);

const sum = [1, 2, 3, 4].reduce((acc, cur) => acc + cur, 0);

document.addEventListener("click", () => {
    console.log("Clicked!");
});

// До ES6
var square = function(num) {
    return num * num;
};

// После ES6
const square = num => num * num;

const name = "Alice";
const greeting = `Hello, ${name}!`;

const person = {firstName: "John", lastName: "Doe"};
const {firstName, lastName} = person;

// Rest
function sum(...args) {
    return args.reduce((acc, curr) => acc + curr, 0);
}

// Spread
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5];

// module.js
export function sayHello(name) {
    return `Hello, ${name}!`;
}

// main.js
import {sayHello} from "./module.js";
alert(sayHello("World"));

// Promises
fetch("/api/user")
    .then(response => response.json())
    .then(data => console.log(data));

// Async/Await
async function getUser() {
    const response = await fetch("/api/user");
    const data = await response.json();
    console.log(data);
}

class Animal {
    constructor(name) {
        this.name = name;
    }
    
    speak() {
        console.log(`${this.name} makes noise`);
    }
}

class Dog extends Animal {
    speak() {
        super.speak();
        console.log(`${this.name} says woof!`);
    }
}

const uniqueNumbers = new Set([1, 2, 3, 4, 5, 1, 2]);
const map = new Map([[1, "One"], [2, "Two"]]);

preg_match(pattern, subject, matches, flags, offset)

$string = "Телефон: +7 (999) 123-45-67";
$pattern = "/\+\d{1,3}\s*$\d{3}$\s*\d{3}-\d{2}-\d{2}/";
if (preg_match($pattern, $string)) {
    echo "Телефон найден!";
} else {
    echo "Телефона нет.";
}

$string = "Контакт: ivan.petrovski@gmail.com";
$pattern = "/[\w.-]+@[a-z\d.-]+\.[a-z]{2,4}/";
preg_match($pattern, $string, $match);
echo $match[0]; // ivan.petrovski@gmail.com

$string = "PHP — замечательный язык программирования!";
$pattern = "/PHP/i";
if (preg_match($pattern, $string)) {
    echo "PHP найден!";
} else {
    echo "PHP не найден.";
}

array_filter(array, callable_function, flags)

$numbers = [1, 2, 3, 4, 5];
$oddNumbers = array_filter($numbers, fn($num) => $num % 2 !== 0);
print_r($oddNumbers);

$data = ["apple" => 1, "banana" => 0, "cherry" => 3];
$filteredData = array_filter($data);
print_r($filteredData);

$data = ["apple" => 1, "banana" => 2, "avocado" => 3];
$filteredData = array_filter($data, fn($k) => strpos($k, 'a') === 0, ARRAY_FILTER_USE_KEY);
print_r($filteredData);

explode(separator, string, limit)

$str = "Привет, мир!";
$arr = explode(" ", $str);
print_r($arr);

$str = "один,два,три,четыре";
$arr = explode(",", $str, 2);
print_r($arr);

$str = "один,два,три,четыре";
$arr = explode(",", $str, -1);
print_r($arr);

const int num = 10;

#include <chrono>

auto start = std::chrono::high_resolution_clock::now();
// Ваш код
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
std::cout << "Время выполнения: " << elapsed.count() << " секунд" << std::endl;

valgrind --leak-check=full ./your_program

#include <chrono>

auto start = std::chrono::high_resolution_clock::now();
// Ваш код
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
std::cout << "Время выполнения: " << elapsed.count() << " секунд" << std::endl;

valgrind --leak-check=full ./your_program

#include <GL/glew.h>
#include <GLFW/glfw3.h>

int main() {
    glfwInit();
    GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    while (!glfwWindowShouldClose(window)) {
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

#include <GL/glew.h>
#include <GLFW/glfw3.h>

int main() {
    glfwInit();
    GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    float vertices[] = {
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         0.0f,  0.5f, 0.0f
    };

    GLuint VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

    while (!glfwWindowShouldClose(window)) {
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glDrawArrays(GL_TRIANGLES, 0, 3);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

float vertices[] = {
    -0.5f, -0.5f, 0.0f,
     0.5f, -0.5f, 0.0f,
     0.5f,  0.5f, 0.0f,
    -0.5f,  0.5f, 0.0f
};

GLuint indices[] = { 
   0, 1, 2,
    2, 3, 0
};

#include <GL/glew.h>
#include <GLFW/glfw3.h>

int main() {
    glfwInit();
    GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    float vertices[] = {
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         0.0f,  0.5f, 0.0f
    };

    GLuint VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

    while (!glfwWindowShouldClose(window)) {
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glDrawArrays(GL_TRIANGLES, 0, 3);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

float vertices[] = {
    -0.5f, -0.5f, 0.0f,
     0.5f, -0.5f, 0.0f,
     0.5f,  0.5f, 0.0f,
    -0.5f,  0.5f, 0.0f
};

GLuint indices[] = {
    0, 1, 2,
    2, 3, 0
};

class User {}

$user = new User();
$user->name = "Иван"; // Динамическое создание свойства
echo $user->name; // выведет "Иван"

class User {
    public string $name; // Явное объявление свойства
}

$user = new User();
$user->name = "Иван"; // Нормально, так как свойство объявлено

class User {
    public string $name = ''; // Свойство с типом и дефолтным значением
}

#include <sys/socket.h>
#include <netinet/in.h>

int sock = socket(AF_INET, SOCK_STREAM, 0);

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    bind(sock, (sockaddr*)&server_addr, sizeof(server_addr));
    listen(sock, 5);
    int client_sock = accept(sock, NULL, NULL);
    char buffer[1024];
    recv(client_sock, buffer, sizeof(buffer), 0);
    std::cout << buffer << std::endl;
    close(client_sock);
    close(sock);
    return 0;
}

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    connect(sock, (sockaddr*)&server_addr, sizeof(server_addr));
    send(sock, "Привет, сервер!", 14, 0);
    close(sock);
    return 0;
}

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    bind(sock, (sockaddr*)&server_addr, sizeof(server_addr));
    listen(sock, 5);

    int client_sock = accept(sock, NULL, NULL);
    char buffer[1024];
    recv(client_sock, buffer, sizeof(buffer), 0);
    std::cout << buffer << std::endl;

    close(client_sock);
    close(sock);
    return 0;
}

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    connect(sock, (sockaddr*)&server_addr, sizeof(server_addr));
    send(sock, "Привет, сервер!", 14, 0);

    close(sock);
    return 0;
}

#include <thread>

void printHello() {
    std::cout << "Привет из потока!" << std::endl;
}

int main() {
    std::thread t(printHello);
    t.join();
    return 0;
}

#include <thread>

void printHello() {
    std::cout << "Привет из потока!" << std::endl;
}

int main() {
    std::thread t(printHello);
    t.join();
    return 0;
}

#include <thread>
#include <mutex>

std::mutex mtx;

void printHello() {
    mtx.lock();
    std::cout << "Привет из потока!" << std::endl;
    mtx.unlock();
}

int main() {
    std::thread t1(printHello);
    std::thread t2(printHello);
    t1.join();
    t2.join();
    return 0;
}

#include <thread>

void printHello() {
    std::cout << "Привет из потока!" << std::endl;
}

int main() {
    std::thread t1(printHello);
    std::thread t2(printHello);
    t1.join();
    t2.join();
    return 0;
}

#include <thread>
#include <mutex>

std::mutex mtx;

void printHello() {
    mtx.lock();
    std::cout << "Привет из потока!" << std::endl;
    mtx.unlock();
}

int main() {
    std::thread t1(printHello);
    std::thread t2(printHello);
    t1.join();
    t2.join();
    return 0;
}