це питання важко підсумувати у назві запитання

ОНОВЛЕННЯ Я створив JSFiddle, який будує невмілий рядок із вашого введення на основі букв, витягнутих із цього питання: Ви можете отримати доступ до нього тут , чи суть буде простішою?

Нещодавно у цьому профілі я натрапив на прикольний затуманений JavaScript, який виглядає приблизно так:

javascript:[[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+([]+!!-
[])[1<<1]+[/~/+{}][+!1][-~1<<1]+([]+/-/[(!!1+[])[1>>1]+(!!1
+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]+([,][
~1]+[])[1-~1]+[[]+{}][!1.1%1][11111.1%11.1*111e11|!1]+(/1/+
1/[1<1][1%1])[1^11]+[[],[]+{}][1][+1]+(/<</[1]+[])[1/1.1&1]

Вибачте, що зіпсував сюрприз, але коли це оцінюється, він повертає це:

"I love you" in Chrome
"I lone you" In Firefox
"I lo[e you" in IE10

Як це працює при розбитті, - це генерувати ряд повідомлень і витягувати з них букви так (використовуючи "Я" як приклад):

[]+1/!1
returns
"Infinity"
then
[[]+1/!1]
creates this array:
["Infinity"]
then
[[]+1/!1][1^1]
Takes the first (1^1 == 0) element of that array
"Infinity"
finally
[[]+1/!1][1^1][1>>1]
Takes the first (1>>1 == 0) char of that string
"I"

Інші рядки, що створюються, включають:

({}+[])       -> "[object Object]" (where the space comes from)
([]+!!-[])    -> "false" (used for it's "l")
[/~/+{}][+!1] -> "/~/[object Object]" (this is used for an "o")
(/<</[1]+[])  -> "undefined"

Мені було цікаво знайти заміну для "n" і "[" і придумав таке:

String.fromCharCode(('1'.charCodeAt(0)<<1)+(10<<1))

Я відчуваю себе в дусі використання значень "1" і "0", але порушує один з найелегантніших аспектів оригінального коду - зовнішній вигляд, що він взагалі не має нічого спільного з рядками. Хтось ще має уявлення про те, як генерувати "v", що відповідає оригінальному прихованому коду?

Ось додаткова інформація, яка була знайдена після того, як багато талановитих програмістів JavaScript більш глибоко розібралися в цьому

Firefox повертає "Я тебе закохав" Через цей рядок:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]+

[1^11<<1] викреслює конкретного символу з цього:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])

Хто оцінює це:

"function test() {
    [native code]
}"

Як виглядає, ми можемо мати своє "V" !!!

Chrome повертає "Я тебе люблю", оскільки той самий код повертає це:

"function test() { [native code] }"

Перш ніж питання закрити для сумнівного зв’язку з "реальною проблемою програмування", я подумав би додати узагальнене рішення, яке ґрунтується на @ Supr's , @ Cory's і @ alpha123 , ось:

alert([[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+(
[]+!!-[])[1<<1]+[/~/+{}][+!1][-~1<<1]+[([]+/-/[(
!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(
!!1+[])[1^1]])[1+(1^(11+1+1)<<1)],([]+/-/[(!!1+[
])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[
])[1^1]])[1^11<<1],([]+/-/[(!!1+[])[1>>1]+(!!1+[
])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11
+1+1)<<1]][((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<
1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1<<1<<1<<1
)+1<<1]==({}+[])[1^1])*1)+((([]+/-/[(!!1+[])[1>>
1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1
]])[(1^11<<1)-1]==({}+[])[1^1])<<1)]+([,][~1]+[]
)[1-~1]+[[]+{}][!1.1%1][11111.1%11.1*111e11|!1]+
(/1/+1/[1<1][1%1])[1^11]+[[],[]+{}][1][+1]+(/<</
[1]+[])[1/1.1&1])

Зважаючи на складність коду та повідомлення, яке він створює, це майже так, як двигун JavaScript говорить про те, як ви особливо відчуваєте :)

Перш за все, я хотів би подякувати Джейсону та всім учасникам, які грали з цим кумедним фрагментом. Я написав цей фрагмент коду просто для розваги , щоб надіслати його дружині 14 лютого :) Після встановлення лише Chrome на ноутбуці у мене не було можливості перевірити, як він працює в Firefox та IE. Більше того, я не дуже сподівався, що toString()представлення вбудованих методів може виглядати інакше в інших браузерах.

Тепер, переходячи до реальної проблеми , давайте точно розглянемо код. Так, тут "v"була справжня «проблема». Я не знайшов інших способів отримання цього листа, крім розбору [native code]рядка, який можна взяти з будь-якого вбудованого методу. Оскільки я обмежився тим, що не маю рядків і жодних цифр, крім 1використаних, мені потрібно було скористатися деяким методом, у своєму імені якого є лише доступні символи.

Доступні символи можуть бути отримані з існуючих ключових слів і рядків уявлень, тобто з самого початку ми мали NaN, null, undefined, Infinity, true, false, і "[object Object]". Деякі з них можна легко перетворити на рядки, наприклад, 1/!1+[]Give "Infinity".

Я проаналізував різні вбудовані методи для масивів [], об’єктів {}, регулярних виразів /(?:)/, чисел 1.1, рядків "1"та виявив один прекрасний метод, який RegExpназивається об'єктом test(). Його ім'я може бути зібрана з усіх доступних символів, наприклад , "t"і "e"з true, і "s"з false. Я створив рядок "test"і звернувся до цього методу, використовуючи позначення квадратних дужок для прямокутника регулярного виразів /-/, правильно визначеного в цьому рядку:

/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]]

Як уже обговорювалося, цей фрагмент коду оцінюється в Chrome як:

function test() { [native code] }

в Firefox як:

function test() {
    [native code]
}

а в IE як:

 function test() {     [native code] }  

^{(в останньому зверніть особливу увагу на пробіл перед functionключовим словом)}

Отже, як ви добре бачите, мій код отримував 24-й символ із представленого рядка, який у Chrome був "v"(як було заплановано), але, на жаль, у Firefox та IE - "n"і "["відповідно.

Для того, щоб зробити однаковий результат у всіх браузерах, я використовував інший підхід, ніж проілюстровано в інших відповідях. Тепер модифікована версія виглядає так:

javascript:[[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+([]+!!-
[])[1<<1]+[/~/+{}][+!1][-~1<<1]+/\[[^1]+\]/[([]+![])[1<<1<<
1]+(/|/[(1+{})[1+11>>>1]+[[]+{}][+!1][1]+([]+1/[])[1<<1>>1]
+([1<1]+[])[1+11>>>1+1]+[[!!1]+1][+[]][1-1]+([]+!!/!/)[1|1]
+(/1/[1]+[])[!1%1]+(-{}+{})[-1+1e1-1]+(1+[!!1])[1]+([]+1+{}
)[1<<1]+[!!/!!/+[]][+[]][1&1]]+/=/)[1e1+(1<<1|1)+(([]+/-/[(
!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1
]])[1^1]==+!1)]+(!![]+{})[1|1<<1]+[1+{}+1][!1+!1][(11>>1)+1
]](([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+
(!!1+[])[1^1]]))[1&.1][11>>>1]+([,][~1]+[])[1-~1]+[[]+{}][!
1.1%1][11111.1%11.1*111e11|!1]+(/1/+1/[1<1][1%1])[1^11]+[[]
,[]+{}][1<<1>>>1][1||1]+(/[<+>]/[1&1|1]+[1.1])[1/11.1&1.11]

Однак, щоб заінтригувати читачів, я не надам рішення для цього. Я чесно вірю, що ви легко зрозумієте, як це працює ... і деякі можуть навіть здивувати коханого крос-браузерним способом;)

PS Ще один Obfuscator

Натхненний ідеєю Джейсона створити універсальний запаморочливий інструмент, я написав ще один. Ви можете знайти його на JSBin: http://jsbin.com/amecoq/2 . Він може заплутати будь-який текст, який містить цифри [0-9], маленькі латинські літери [a-z]та пробіли. Довжина рядка обмежена здебільшого вашою оперативною пам’яттю (принаймні частина моєї відповіді була успішно затуманена). Вихід підтримується Chrome, Firefox та IE.

^{Підказка: інструмент використовує інший підхід до обфускування, ніж був представлений вище.}

Чому не використовується native codeшматочок від запитання? Це дає як 'v'у Chrome, так і в Firefox:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]>([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]?([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]:([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]

Редагуйте, щоб підтримати IE і зробити це без потрійного оператора. Цей працює в Chrome, IE та FF. Створює масив і використовує ==для визначення браузера.

[([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1+(1^(11+1+1)<<1)],([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1],([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]][((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1<<1<<1<<1)+1<<1]==({}+[])[1^1])*1)+((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)-1]==({}+[])[1^1])<<1)]

Читає:

[
    //ie
    ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1+(1^(11+1+1)<<1)],
    //ch
    ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1],
    //ff
    ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]
]
[
    //ch?
    ((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1<<1<<1<<1)+1<<1]==({}+[])[1^1])*1)+
    //ff?
    ((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)-1]==({}+[])[1^1])<<1)
]

Це приблизно так близько, як я міг підійти, на жаль, це порушує конвенцію про початкове затуманення, закликаючи unescape():

unescape((/%/+[])[1]+(/1/[1]+[])[1%1]+(+!1)+(+!1)+(1e1+(11*(1-~1)<<1)))

Teardown:

(/%/+[])[1]          => "%"
(/1/[1]+[])[1%1]     => "u"
(+!1)                => "0"
(+!1)                => "0"
(1e1+(11*(1-~1)<<1)) => "76"
===========================
unescape("%u0076")   => "v"

Інші ідеї:

1. Якось дістатися unescape("\x76")
2. Якось конвертувати 118без дзвінківString.fromCharCode()
3. Отримайте текст за винятком із написом слова "Недійсне"

Оновлення:

Я почав грати в гольф коду і скорочував його, замінюючи деталі на більше 1s і т.д.

Ось частина, яка генерує n / v:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]

У Firefox ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])оцінює до

"function test() {
    [native code]
}"

а в Chrome це

"function test() { [native code] }"

1^11<<1 дорівнює 23. Отже, через додатковий пробіл Firefox цього недостатньо, щоб дістатися до 'v', а натомість 'n'.

І саме тому вам не слід покладатися на функцію # toString. ;)

EDIT: Нарешті, я знайшов досить заплутану версію веб-переглядача:

[[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+([]+!!-[])[1<<1]+[/~/+{}][+!1][-~1<<1]+([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)+(parseInt("010")<10?(1+1+1+1):0)]+([,][~1]+[])[1-~1]+[[]+{}][!1.1%1][11111.1%11.1*111e11|!1]+(/1/+1/[1<1][1%1])[1^11]+[[],[]+{}][1][+1]+(/<</[1]+[])[1/1.1&1]

Це замінює n / v розділ на:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)+(parseInt("010")<10?(1+1+1+1):0)]

який використовує відмінності в parseInt (мабуть, Firefox розбирає номери, починаючи з 0 у вісімці, а Chrome не), щоб додати 4 у випадку Firefox, таким чином отримуючи 'v' від 'native' в обох випадках (я не можу знайти іншого 'v ': Р).
Аналіз виглядає трохи поза місцем, але це найкраще, що я можу зробити зараз.

У загальному випадку, якщо корпус символів не викликає особливих проблем, я, можливо, схильний трохи обдурити.

Створіть функцію "c", яка перетворює число 0 .. 25 в символ.

c=function(v){for(var i in window){for(var ci in i){if(parseInt(i[ci],(10+11+11)+(1<<1)+(1<<1))==(v+10)){return i[ci]}}}};

З міркувань продуктивності попередньо кешуйте листи, якщо хочете.

l=[];for(var i=0; i<(11+11)+(1<<1)+(1<<1);i++){l[i]=c(i);}

На консолі Chrome отриманий масив виглядає приблизно так:

> l;
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "K", "l", "m", "n", "o", "p", "q", "r", "S", "t", "u", "v", "w", "x", "y", "Z"]

Отже ... ваш v може бути l[10+10+1].

Як варіант, таке загальне рішення:

p=(function(){10%11}+[])[1+11+(1<<1)]; // "%"
u=(function(){club=1}+[])[1+11+(1<<1)]; // "u"
vc=p+u+(0+[])+(0+[])+((111>>1)+11+10+[]); // "%u0076"
unescape(vc);

Або для цієї конкретної проблеми, можливо, просто:

(function(){v=1}+[])[10+(1<<1)]; // "v"

Це дає av у Chrome:

Object.getOwnPropertyNames(Object)[17][3];

І це робиться в Firefox:

Object.getOwnPropertyNames(Object)[9][3]

Вони обидва витягують його з Object.prototype.preventExtensions(), так що, ймовірно, ви можете знайти крос-браузерний спосіб посилання на цей метод. (Це єдине 17-символьне ім'я в Object.Prototype для початківців.)

Не соромтеся створити більш затуманену версію цього і взяти всю кредит на себе, я не маю часу;)

У хромі вираження ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])оцінюється до "function test() { [native code] }", [1^11<<1]оцінюється до 23 (побітові оператори призводять до врізання змінної до 32 біт)