- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
public getWay(path: string) {
const arrPath = path.slice(1).split('/');
arrPath.map(item => {
this.crumbs.push(MathcPath[item]);
this.crumbs = this.crumbs.filter(crumb => crumb);
});
}
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+3
public getWay(path: string) {
const arrPath = path.slice(1).split('/');
arrPath.map(item => {
this.crumbs.push(MathcPath[item]);
this.crumbs = this.crumbs.filter(crumb => crumb);
});
}
Используем map в качестве forEach + зачем-то фильтруем полученный массив в каждой итерации.
Причем этот код можно записать в одну строку, которая еще и будет работать быстрее.
0
// @strict: true
// @lib: es2020
// @declaration: true
type BadFlatArray<Arr, Depth extends number> = {
obj: {
"done": Arr,
"recur": Arr extends ReadonlyArray<infer InnerArr>
? BadFlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
: Arr
}[Depth extends -1 ? "done" : "recur"]
}["obj"];
declare function flat<A, D extends number = 1>(
arr: A,
depth?: D
): BadFlatArray<A, D>[]
function foo<T>(arr: T[], depth: number) {
return flat(arr, depth);
}
function main() {
foo<number>([1.0, 2.0], 2);
}
спорим вы нихрена не поняли что это такое?
0
namespace Generics {
function swap<T>(arr: T[], i: number, j: number): void {
let temp: T = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function sortHelper<T>(arr: T[], callbackfn?: (value1: T, value2: T) => number): T[] {
if (arr.length <= 0 || !callbackfn) {
return arr;
}
let len = arr.length;
// simple selection sort.
for (let i = 0; i < len - 1; ++i) {
for (let j = i + 1; j < len; ++j) {
if (callbackfn(arr[i], arr[j]) > 0) {
swap(arr, i, j);
}
}
}
return arr;
}
export function arraySort<T>(arr: T[], callbackfn?: (value1: T, value2: T) => number): T[] {
return sortHelper(arr, callbackfn);
}
}
function main() {
print("testGenerics")
let inArray = [4.0, 3.0, 4593.0, 23.0, 43.0, -1.0]
Generics.arraySort(inArray, (x: number, y: number) => { return x - y })
let expectedArray = [-1.0, 3.0, 4.0, 23.0, 43.0, 4593.0]
for (let i = 0; i < expectedArray.length; i++) {
assert(inArray[i] == expectedArray[i])
}
}
ну вот и все.. можно считать последний говнокод... подходит миссия к концу.... и ... потом заархивить все и положить на полочку
−1
function foo(x = class { static prop: string }): string {
return undefined;
}
function main() {
foo(class { static prop = "hello" }).length;
print("done.");
}
ну что С/C++ скушали? а ты так можешь говнокодить?
−1
class Node<T> {
v: T;
k: string;
next: Node<T>;
}
class Map<T> {
head: Node<T>;
getElt(k: string): T {
return mapGet(this, k)
}
setElt(k: string, v: T) {
mapSet(this, k, v)
}
}
function mapSet<T>(m: Map<T>, k: string, v: T) {
for (let p = m.head; p != null; p = p.next) {
if (p.k == k) {
p.v = v
return
}
}
let n = new Node<T>()
n.next = m.head
n.k = k
n.v = v
m.head = n
}
function mapGet<T>(m: Map<T>, k: string): T {
for (let p = m.head; p != null; p = p.next) {
if (p.k == k) {
return p.v
}
}
return null
}
function search_array<T>(a: T[], item: T): number {
for (let i = 0; i < a.length; i++) {
if (a[i] == item) {
return i
}
}
return -1 // NOT FOUND
}
class MyMap<K, V> {
keys: K[]
values: V[]
constructor() {
this.keys = []
this.values = []
}
push(key: K, value: V) {
this.keys.push(key)
this.values.push(value)
}
value_for(key: K): V {
let i = search_array(this.keys, key)
if (i == -1) {
return null
}
return this.values[i]
}
key_for(value: V): K {
let i = search_array(this.values, value)
if (i == -1) {
return null
}
return this.keys[i]
}
set(key: K, value: V): void {
let i = search_array(this.keys, key)
if (i == -1) {
this.keys.push(key)
this.values.push(value)
} else {
this.values[i] = value
}
}
has_key(key: K): boolean {
return search_array(this.keys, key) != -1
}
has_value(value: V): boolean {
return search_array(this.values, value) != -1
}
}
Срочно нужна помощь... не могу решить что делать с функцией mapGet .. когда T - number я не могу использовать "null" .. должен я хакнуть компилятор или изменить тестовый пример?
−1
function testGenRef<T>(v: T) {
let x = v
// test that clear() also gets generalized
function clear() {
print(x);
x = null
}
clear()
}
function testGenRefOuter() {
print("testGenRefOuter");
testGenRef(12)
testGenRef("fXa" + "baa")
}
function main()
{
testGenRefOuter()
print("done.")
}
ну что дорогие мои С/C++ девелоперы.. не ожидали такой подставы... а нука давай свой код на С - С++...
0
function test<T>(t: T)
{
return t;
}
function main()
{
print(test(10), test("Hello"));
print("done.");
}
ура ура.. новая говно-фича подоспела.. а вы думали я тут бездельничаю.. новый год встречаю?
0
function test<T>(t: T) {
return t;
}
function main() {
print(test<number>(11), test<string>("Hello1"));
print("done.");
}
Продолжаем генерить говно... ну вот подъехали первые генерики для функций... толи еще будет гимороя :)
−3
Астрологи объявили неделю getCurrentLanguageName();
0
class Node<T> {
v: T;
k: string;
next: Node<T>;
}
function main()
{
let n = new Node<number>()
n.next = n
n.k = "Hello";
n.v = 10.0;
print("done.");
}
Вы не поверите как сложно сделать простые вещи в LLVM. встречаем рекурсивные типы :)